1 // SPDX-License-Identifier: BSD-3-Clause-Clear
3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
7 #include <net/mac80211.h>
8 #include <net/cfg80211.h>
9 #include <linux/etherdevice.h>
10 #include <linux/bitfield.h>
11 #include <linux/inetdevice.h>
12 #include <net/if_inet6.h>
24 #include "debugfs_sta.h"
28 #define CHAN2G(_channel, _freq, _flags) { \
29 .band = NL80211_BAND_2GHZ, \
30 .hw_value = (_channel), \
31 .center_freq = (_freq), \
33 .max_antenna_gain = 0, \
37 #define CHAN5G(_channel, _freq, _flags) { \
38 .band = NL80211_BAND_5GHZ, \
39 .hw_value = (_channel), \
40 .center_freq = (_freq), \
42 .max_antenna_gain = 0, \
46 #define CHAN6G(_channel, _freq, _flags) { \
47 .band = NL80211_BAND_6GHZ, \
48 .hw_value = (_channel), \
49 .center_freq = (_freq), \
51 .max_antenna_gain = 0, \
55 static const struct ieee80211_channel ath11k_2ghz_channels[] = {
72 static const struct ieee80211_channel ath11k_5ghz_channels[] = {
100 CHAN5G(177, 5885, 0),
103 static const struct ieee80211_channel ath11k_6ghz_channels[] = {
129 CHAN6G(101, 6455, 0),
130 CHAN6G(105, 6475, 0),
131 CHAN6G(109, 6495, 0),
132 CHAN6G(113, 6515, 0),
133 CHAN6G(117, 6535, 0),
134 CHAN6G(121, 6555, 0),
135 CHAN6G(125, 6575, 0),
136 CHAN6G(129, 6595, 0),
137 CHAN6G(133, 6615, 0),
138 CHAN6G(137, 6635, 0),
139 CHAN6G(141, 6655, 0),
140 CHAN6G(145, 6675, 0),
141 CHAN6G(149, 6695, 0),
142 CHAN6G(153, 6715, 0),
143 CHAN6G(157, 6735, 0),
144 CHAN6G(161, 6755, 0),
145 CHAN6G(165, 6775, 0),
146 CHAN6G(169, 6795, 0),
147 CHAN6G(173, 6815, 0),
148 CHAN6G(177, 6835, 0),
149 CHAN6G(181, 6855, 0),
150 CHAN6G(185, 6875, 0),
151 CHAN6G(189, 6895, 0),
152 CHAN6G(193, 6915, 0),
153 CHAN6G(197, 6935, 0),
154 CHAN6G(201, 6955, 0),
155 CHAN6G(205, 6975, 0),
156 CHAN6G(209, 6995, 0),
157 CHAN6G(213, 7015, 0),
158 CHAN6G(217, 7035, 0),
159 CHAN6G(221, 7055, 0),
160 CHAN6G(225, 7075, 0),
161 CHAN6G(229, 7095, 0),
162 CHAN6G(233, 7115, 0),
164 /* new addition in IEEE Std 802.11ax-2021 */
168 static struct ieee80211_rate ath11k_legacy_rates[] = {
170 .hw_value = ATH11K_HW_RATE_CCK_LP_1M },
172 .hw_value = ATH11K_HW_RATE_CCK_LP_2M,
173 .hw_value_short = ATH11K_HW_RATE_CCK_SP_2M,
174 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
176 .hw_value = ATH11K_HW_RATE_CCK_LP_5_5M,
177 .hw_value_short = ATH11K_HW_RATE_CCK_SP_5_5M,
178 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
180 .hw_value = ATH11K_HW_RATE_CCK_LP_11M,
181 .hw_value_short = ATH11K_HW_RATE_CCK_SP_11M,
182 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
184 { .bitrate = 60, .hw_value = ATH11K_HW_RATE_OFDM_6M },
185 { .bitrate = 90, .hw_value = ATH11K_HW_RATE_OFDM_9M },
186 { .bitrate = 120, .hw_value = ATH11K_HW_RATE_OFDM_12M },
187 { .bitrate = 180, .hw_value = ATH11K_HW_RATE_OFDM_18M },
188 { .bitrate = 240, .hw_value = ATH11K_HW_RATE_OFDM_24M },
189 { .bitrate = 360, .hw_value = ATH11K_HW_RATE_OFDM_36M },
190 { .bitrate = 480, .hw_value = ATH11K_HW_RATE_OFDM_48M },
191 { .bitrate = 540, .hw_value = ATH11K_HW_RATE_OFDM_54M },
195 ath11k_phymodes[NUM_NL80211_BANDS][ATH11K_CHAN_WIDTH_NUM] = {
196 [NL80211_BAND_2GHZ] = {
197 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
198 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
199 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20_2G,
200 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20_2G,
201 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40_2G,
202 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80_2G,
203 [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN,
204 [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN,
206 [NL80211_BAND_5GHZ] = {
207 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
208 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
209 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
210 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
211 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
212 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
213 [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
214 [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
216 [NL80211_BAND_6GHZ] = {
217 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
218 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
219 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
220 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
221 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
222 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
223 [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
224 [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
229 const struct htt_rx_ring_tlv_filter ath11k_mac_mon_status_filter_default = {
230 .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START |
231 HTT_RX_FILTER_TLV_FLAGS_PPDU_END |
232 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE,
233 .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0,
234 .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1,
235 .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2,
236 .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 |
237 HTT_RX_FP_CTRL_FILTER_FLASG3
240 #define ATH11K_MAC_FIRST_OFDM_RATE_IDX 4
241 #define ath11k_g_rates ath11k_legacy_rates
242 #define ath11k_g_rates_size (ARRAY_SIZE(ath11k_legacy_rates))
243 #define ath11k_a_rates (ath11k_legacy_rates + 4)
244 #define ath11k_a_rates_size (ARRAY_SIZE(ath11k_legacy_rates) - 4)
246 #define ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD 200 /* in msecs */
248 /* Overhead due to the processing of channel switch events from FW */
249 #define ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD 10 /* in msecs */
251 static const u32 ath11k_smps_map[] = {
252 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
253 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
254 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
255 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
258 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
259 struct ieee80211_vif *vif);
261 enum nl80211_he_ru_alloc ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc(u16 ru_phy)
263 enum nl80211_he_ru_alloc ret;
267 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
270 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
273 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
276 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
279 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
282 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
285 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
292 enum nl80211_he_ru_alloc ath11k_mac_he_ru_tones_to_nl80211_he_ru_alloc(u16 ru_tones)
294 enum nl80211_he_ru_alloc ret;
298 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
301 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
304 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
307 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
310 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
313 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
316 ret = NL80211_RATE_INFO_HE_RU_ALLOC_2x996;
319 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
326 enum nl80211_he_gi ath11k_mac_he_gi_to_nl80211_he_gi(u8 sgi)
328 enum nl80211_he_gi ret;
331 case RX_MSDU_START_SGI_0_8_US:
332 ret = NL80211_RATE_INFO_HE_GI_0_8;
334 case RX_MSDU_START_SGI_1_6_US:
335 ret = NL80211_RATE_INFO_HE_GI_1_6;
337 case RX_MSDU_START_SGI_3_2_US:
338 ret = NL80211_RATE_INFO_HE_GI_3_2;
341 ret = NL80211_RATE_INFO_HE_GI_0_8;
348 u8 ath11k_mac_bw_to_mac80211_bw(u8 bw)
354 ret = RATE_INFO_BW_20;
357 ret = RATE_INFO_BW_40;
360 ret = RATE_INFO_BW_80;
363 ret = RATE_INFO_BW_160;
370 enum ath11k_supported_bw ath11k_mac_mac80211_bw_to_ath11k_bw(enum rate_info_bw bw)
373 case RATE_INFO_BW_20:
375 case RATE_INFO_BW_40:
377 case RATE_INFO_BW_80:
379 case RATE_INFO_BW_160:
380 return ATH11K_BW_160;
386 int ath11k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
389 /* As default, it is OFDM rates */
390 int i = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
391 int max_rates_idx = ath11k_g_rates_size;
393 if (preamble == WMI_RATE_PREAMBLE_CCK) {
394 hw_rc &= ~ATH11k_HW_RATECODE_CCK_SHORT_PREAM_MASK;
396 max_rates_idx = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
399 while (i < max_rates_idx) {
400 if (hw_rc == ath11k_legacy_rates[i].hw_value) {
402 *rate = ath11k_legacy_rates[i].bitrate;
411 static int get_num_chains(u32 mask)
424 u8 ath11k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
429 for (i = 0; i < sband->n_bitrates; i++)
430 if (sband->bitrates[i].bitrate == bitrate)
437 ath11k_mac_max_ht_nss(const u8 *ht_mcs_mask)
441 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
442 if (ht_mcs_mask[nss])
449 ath11k_mac_max_vht_nss(const u16 *vht_mcs_mask)
453 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
454 if (vht_mcs_mask[nss])
461 ath11k_mac_max_he_nss(const u16 *he_mcs_mask)
465 for (nss = NL80211_HE_NSS_MAX - 1; nss >= 0; nss--)
466 if (he_mcs_mask[nss])
472 static u8 ath11k_parse_mpdudensity(u8 mpdudensity)
474 /* 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
475 * 0 for no restriction
484 switch (mpdudensity) {
490 /* Our lower layer calculations limit our precision to
507 static int ath11k_mac_vif_chan(struct ieee80211_vif *vif,
508 struct cfg80211_chan_def *def)
510 struct ieee80211_chanctx_conf *conf;
513 conf = rcu_dereference(vif->bss_conf.chanctx_conf);
525 static bool ath11k_mac_bitrate_is_cck(int bitrate)
538 u8 ath11k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
539 u8 hw_rate, bool cck)
541 const struct ieee80211_rate *rate;
544 for (i = 0; i < sband->n_bitrates; i++) {
545 rate = &sband->bitrates[i];
547 if (ath11k_mac_bitrate_is_cck(rate->bitrate) != cck)
550 if (rate->hw_value == hw_rate)
552 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
553 rate->hw_value_short == hw_rate)
560 static u8 ath11k_mac_bitrate_to_rate(int bitrate)
562 return DIV_ROUND_UP(bitrate, 5) |
563 (ath11k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
566 static void ath11k_get_arvif_iter(void *data, u8 *mac,
567 struct ieee80211_vif *vif)
569 struct ath11k_vif_iter *arvif_iter = data;
570 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
572 if (arvif->vdev_id == arvif_iter->vdev_id)
573 arvif_iter->arvif = arvif;
576 struct ath11k_vif *ath11k_mac_get_arvif(struct ath11k *ar, u32 vdev_id)
578 struct ath11k_vif_iter arvif_iter;
581 memset(&arvif_iter, 0, sizeof(struct ath11k_vif_iter));
582 arvif_iter.vdev_id = vdev_id;
584 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
585 ieee80211_iterate_active_interfaces_atomic(ar->hw,
587 ath11k_get_arvif_iter,
589 if (!arvif_iter.arvif) {
590 ath11k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id);
594 return arvif_iter.arvif;
597 struct ath11k_vif *ath11k_mac_get_arvif_by_vdev_id(struct ath11k_base *ab,
601 struct ath11k_pdev *pdev;
602 struct ath11k_vif *arvif;
604 for (i = 0; i < ab->num_radios; i++) {
605 pdev = rcu_dereference(ab->pdevs_active[i]);
606 if (pdev && pdev->ar &&
607 (pdev->ar->allocated_vdev_map & (1LL << vdev_id))) {
608 arvif = ath11k_mac_get_arvif(pdev->ar, vdev_id);
617 struct ath11k *ath11k_mac_get_ar_by_vdev_id(struct ath11k_base *ab, u32 vdev_id)
620 struct ath11k_pdev *pdev;
622 for (i = 0; i < ab->num_radios; i++) {
623 pdev = rcu_dereference(ab->pdevs_active[i]);
624 if (pdev && pdev->ar) {
625 if (pdev->ar->allocated_vdev_map & (1LL << vdev_id))
633 struct ath11k *ath11k_mac_get_ar_by_pdev_id(struct ath11k_base *ab, u32 pdev_id)
636 struct ath11k_pdev *pdev;
638 if (ab->hw_params.single_pdev_only) {
639 pdev = rcu_dereference(ab->pdevs_active[0]);
640 return pdev ? pdev->ar : NULL;
643 if (WARN_ON(pdev_id > ab->num_radios))
646 for (i = 0; i < ab->num_radios; i++) {
647 if (ab->fw_mode == ATH11K_FIRMWARE_MODE_FTM)
648 pdev = &ab->pdevs[i];
650 pdev = rcu_dereference(ab->pdevs_active[i]);
652 if (pdev && pdev->pdev_id == pdev_id)
653 return (pdev->ar ? pdev->ar : NULL);
659 struct ath11k_vif *ath11k_mac_get_vif_up(struct ath11k_base *ab)
662 struct ath11k_pdev *pdev;
663 struct ath11k_vif *arvif;
666 for (i = 0; i < ab->num_radios; i++) {
667 pdev = &ab->pdevs[i];
669 list_for_each_entry(arvif, &ar->arvifs, list) {
678 static bool ath11k_mac_band_match(enum nl80211_band band1, enum WMI_HOST_WLAN_BAND band2)
680 return (((band1 == NL80211_BAND_2GHZ) && (band2 & WMI_HOST_WLAN_2G_CAP)) ||
681 (((band1 == NL80211_BAND_5GHZ) || (band1 == NL80211_BAND_6GHZ)) &&
682 (band2 & WMI_HOST_WLAN_5G_CAP)));
685 u8 ath11k_mac_get_target_pdev_id_from_vif(struct ath11k_vif *arvif)
687 struct ath11k *ar = arvif->ar;
688 struct ath11k_base *ab = ar->ab;
689 struct ieee80211_vif *vif = arvif->vif;
690 struct cfg80211_chan_def def;
691 enum nl80211_band band;
692 u8 pdev_id = ab->target_pdev_ids[0].pdev_id;
695 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
698 band = def.chan->band;
700 for (i = 0; i < ab->target_pdev_count; i++) {
701 if (ath11k_mac_band_match(band, ab->target_pdev_ids[i].supported_bands))
702 return ab->target_pdev_ids[i].pdev_id;
708 u8 ath11k_mac_get_target_pdev_id(struct ath11k *ar)
710 struct ath11k_vif *arvif;
712 arvif = ath11k_mac_get_vif_up(ar->ab);
715 return ath11k_mac_get_target_pdev_id_from_vif(arvif);
717 return ar->ab->target_pdev_ids[0].pdev_id;
720 static void ath11k_pdev_caps_update(struct ath11k *ar)
722 struct ath11k_base *ab = ar->ab;
724 ar->max_tx_power = ab->target_caps.hw_max_tx_power;
726 /* FIXME Set min_tx_power to ab->target_caps.hw_min_tx_power.
727 * But since the received value in svcrdy is same as hw_max_tx_power,
728 * we can set ar->min_tx_power to 0 currently until
729 * this is fixed in firmware
731 ar->min_tx_power = 0;
733 ar->txpower_limit_2g = ar->max_tx_power;
734 ar->txpower_limit_5g = ar->max_tx_power;
735 ar->txpower_scale = WMI_HOST_TP_SCALE_MAX;
738 static int ath11k_mac_txpower_recalc(struct ath11k *ar)
740 struct ath11k_pdev *pdev = ar->pdev;
741 struct ath11k_vif *arvif;
742 int ret, txpower = -1;
745 lockdep_assert_held(&ar->conf_mutex);
747 list_for_each_entry(arvif, &ar->arvifs, list) {
748 if (arvif->txpower <= 0)
752 txpower = arvif->txpower;
754 txpower = min(txpower, arvif->txpower);
760 /* txpwr is set as 2 units per dBm in FW*/
761 txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower),
762 ar->max_tx_power) * 2;
764 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower to set in hw %d\n",
767 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) &&
768 ar->txpower_limit_2g != txpower) {
769 param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
770 ret = ath11k_wmi_pdev_set_param(ar, param,
771 txpower, ar->pdev->pdev_id);
774 ar->txpower_limit_2g = txpower;
777 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) &&
778 ar->txpower_limit_5g != txpower) {
779 param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
780 ret = ath11k_wmi_pdev_set_param(ar, param,
781 txpower, ar->pdev->pdev_id);
784 ar->txpower_limit_5g = txpower;
790 ath11k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n",
791 txpower / 2, param, ret);
795 static int ath11k_recalc_rtscts_prot(struct ath11k_vif *arvif)
797 struct ath11k *ar = arvif->ar;
798 u32 vdev_param, rts_cts = 0;
801 lockdep_assert_held(&ar->conf_mutex);
803 vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS;
805 /* Enable RTS/CTS protection for sw retries (when legacy stations
806 * are in BSS) or by default only for second rate series.
807 * TODO: Check if we need to enable CTS 2 Self in any case
809 rts_cts = WMI_USE_RTS_CTS;
811 if (arvif->num_legacy_stations > 0)
812 rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4;
814 rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4;
816 /* Need not send duplicate param value to firmware */
817 if (arvif->rtscts_prot_mode == rts_cts)
820 arvif->rtscts_prot_mode = rts_cts;
822 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d recalc rts/cts prot %d\n",
823 arvif->vdev_id, rts_cts);
825 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
826 vdev_param, rts_cts);
828 ath11k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n",
829 arvif->vdev_id, ret);
834 static int ath11k_mac_set_kickout(struct ath11k_vif *arvif)
836 struct ath11k *ar = arvif->ar;
840 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH,
841 ATH11K_KICKOUT_THRESHOLD,
844 ath11k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n",
845 arvif->vdev_id, ret);
849 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
850 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
851 ATH11K_KEEPALIVE_MIN_IDLE);
853 ath11k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n",
854 arvif->vdev_id, ret);
858 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
859 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
860 ATH11K_KEEPALIVE_MAX_IDLE);
862 ath11k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n",
863 arvif->vdev_id, ret);
867 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
868 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
869 ATH11K_KEEPALIVE_MAX_UNRESPONSIVE);
871 ath11k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
872 arvif->vdev_id, ret);
879 void ath11k_mac_peer_cleanup_all(struct ath11k *ar)
881 struct ath11k_peer *peer, *tmp;
882 struct ath11k_base *ab = ar->ab;
884 lockdep_assert_held(&ar->conf_mutex);
886 mutex_lock(&ab->tbl_mtx_lock);
887 spin_lock_bh(&ab->base_lock);
888 list_for_each_entry_safe(peer, tmp, &ab->peers, list) {
889 ath11k_peer_rx_tid_cleanup(ar, peer);
890 ath11k_peer_rhash_delete(ab, peer);
891 list_del(&peer->list);
894 spin_unlock_bh(&ab->base_lock);
895 mutex_unlock(&ab->tbl_mtx_lock);
898 ar->num_stations = 0;
901 static inline int ath11k_mac_vdev_setup_sync(struct ath11k *ar)
903 lockdep_assert_held(&ar->conf_mutex);
905 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
908 if (!wait_for_completion_timeout(&ar->vdev_setup_done,
909 ATH11K_VDEV_SETUP_TIMEOUT_HZ))
912 return ar->last_wmi_vdev_start_status ? -EINVAL : 0;
916 ath11k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
917 struct ieee80211_chanctx_conf *conf,
920 struct cfg80211_chan_def **def = data;
925 static int ath11k_mac_monitor_vdev_start(struct ath11k *ar, int vdev_id,
926 struct cfg80211_chan_def *chandef)
928 struct ieee80211_channel *channel;
929 struct wmi_vdev_start_req_arg arg = {};
932 lockdep_assert_held(&ar->conf_mutex);
934 channel = chandef->chan;
936 arg.vdev_id = vdev_id;
937 arg.channel.freq = channel->center_freq;
938 arg.channel.band_center_freq1 = chandef->center_freq1;
939 arg.channel.band_center_freq2 = chandef->center_freq2;
941 arg.channel.mode = ath11k_phymodes[chandef->chan->band][chandef->width];
942 arg.channel.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR);
944 arg.channel.min_power = 0;
945 arg.channel.max_power = channel->max_power;
946 arg.channel.max_reg_power = channel->max_reg_power;
947 arg.channel.max_antenna_gain = channel->max_antenna_gain;
949 arg.pref_tx_streams = ar->num_tx_chains;
950 arg.pref_rx_streams = ar->num_rx_chains;
952 arg.channel.passive = !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
954 reinit_completion(&ar->vdev_setup_done);
955 reinit_completion(&ar->vdev_delete_done);
957 ret = ath11k_wmi_vdev_start(ar, &arg, false);
959 ath11k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n",
964 ret = ath11k_mac_vdev_setup_sync(ar);
966 ath11k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n",
971 ret = ath11k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr, NULL, 0, 0);
973 ath11k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
978 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %i started\n",
984 reinit_completion(&ar->vdev_setup_done);
986 ret = ath11k_wmi_vdev_stop(ar, vdev_id);
988 ath11k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n",
993 ret = ath11k_mac_vdev_setup_sync(ar);
995 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i stop: %d\n",
1003 static int ath11k_mac_monitor_vdev_stop(struct ath11k *ar)
1007 lockdep_assert_held(&ar->conf_mutex);
1009 reinit_completion(&ar->vdev_setup_done);
1011 ret = ath11k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1013 ath11k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n",
1014 ar->monitor_vdev_id, ret);
1018 ret = ath11k_mac_vdev_setup_sync(ar);
1020 ath11k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n",
1021 ar->monitor_vdev_id, ret);
1025 ret = ath11k_wmi_vdev_down(ar, ar->monitor_vdev_id);
1027 ath11k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n",
1028 ar->monitor_vdev_id, ret);
1032 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %i stopped\n",
1033 ar->monitor_vdev_id);
1038 static int ath11k_mac_monitor_vdev_create(struct ath11k *ar)
1040 struct ath11k_pdev *pdev = ar->pdev;
1041 struct vdev_create_params param = {};
1043 u8 tmp_addr[6] = {0};
1046 lockdep_assert_held(&ar->conf_mutex);
1048 if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1051 if (ar->ab->free_vdev_map == 0) {
1052 ath11k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n");
1056 bit = __ffs64(ar->ab->free_vdev_map);
1058 ar->monitor_vdev_id = bit;
1060 param.if_id = ar->monitor_vdev_id;
1061 param.type = WMI_VDEV_TYPE_MONITOR;
1062 param.subtype = WMI_VDEV_SUBTYPE_NONE;
1063 param.pdev_id = pdev->pdev_id;
1065 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
1066 param.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
1067 param.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
1069 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
1070 param.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
1071 param.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
1074 ret = ath11k_wmi_vdev_create(ar, tmp_addr, ¶m);
1076 ath11k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n",
1077 ar->monitor_vdev_id, ret);
1078 ar->monitor_vdev_id = -1;
1082 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
1083 ret = ath11k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id,
1084 WMI_VDEV_PARAM_NSS, nss);
1086 ath11k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
1087 ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret);
1091 ret = ath11k_mac_txpower_recalc(ar);
1093 ath11k_warn(ar->ab, "failed to recalc txpower for monitor vdev %d: %d\n",
1094 ar->monitor_vdev_id, ret);
1098 ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id;
1099 ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1100 ar->num_created_vdevs++;
1101 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1103 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %d created\n",
1104 ar->monitor_vdev_id);
1109 ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1110 ar->monitor_vdev_id = -1;
1114 static int ath11k_mac_monitor_vdev_delete(struct ath11k *ar)
1117 unsigned long time_left;
1119 lockdep_assert_held(&ar->conf_mutex);
1121 if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1124 reinit_completion(&ar->vdev_delete_done);
1126 ret = ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1128 ath11k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n",
1129 ar->monitor_vdev_id, ret);
1133 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
1134 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
1135 if (time_left == 0) {
1136 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
1138 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %d deleted\n",
1139 ar->monitor_vdev_id);
1141 ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1142 ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id);
1143 ar->num_created_vdevs--;
1144 ar->monitor_vdev_id = -1;
1145 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1151 static int ath11k_mac_monitor_start(struct ath11k *ar)
1153 struct cfg80211_chan_def *chandef = NULL;
1156 lockdep_assert_held(&ar->conf_mutex);
1158 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1161 ieee80211_iter_chan_contexts_atomic(ar->hw,
1162 ath11k_mac_get_any_chandef_iter,
1167 ret = ath11k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef);
1169 ath11k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret);
1170 ath11k_mac_monitor_vdev_delete(ar);
1174 set_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1176 ar->num_started_vdevs++;
1177 ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, false);
1179 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during start: %d",
1184 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor started\n");
1189 static int ath11k_mac_monitor_stop(struct ath11k *ar)
1193 lockdep_assert_held(&ar->conf_mutex);
1195 if (!test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1198 ret = ath11k_mac_monitor_vdev_stop(ar);
1200 ath11k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret);
1204 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1205 ar->num_started_vdevs--;
1207 ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, true);
1209 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during stop: %d",
1214 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor stopped ret %d\n", ret);
1219 static int ath11k_mac_vif_setup_ps(struct ath11k_vif *arvif)
1221 struct ath11k *ar = arvif->ar;
1222 struct ieee80211_vif *vif = arvif->vif;
1223 struct ieee80211_conf *conf = &ar->hw->conf;
1224 enum wmi_sta_powersave_param param;
1225 enum wmi_sta_ps_mode psmode;
1230 lockdep_assert_held(&arvif->ar->conf_mutex);
1232 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1235 enable_ps = arvif->ps;
1237 if (!arvif->is_started) {
1238 /* mac80211 can update vif powersave state while disconnected.
1239 * Firmware doesn't behave nicely and consumes more power than
1240 * necessary if PS is disabled on a non-started vdev. Hence
1241 * force-enable PS for non-running vdevs.
1243 psmode = WMI_STA_PS_MODE_ENABLED;
1244 } else if (enable_ps) {
1245 psmode = WMI_STA_PS_MODE_ENABLED;
1246 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1248 timeout = conf->dynamic_ps_timeout;
1250 /* firmware doesn't like 0 */
1251 timeout = ieee80211_tu_to_usec(vif->bss_conf.beacon_int) / 1000;
1254 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1257 ath11k_warn(ar->ab, "failed to set inactivity time for vdev %d: %i\n",
1258 arvif->vdev_id, ret);
1262 psmode = WMI_STA_PS_MODE_DISABLED;
1265 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d psmode %s\n",
1266 arvif->vdev_id, psmode ? "enable" : "disable");
1268 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, psmode);
1270 ath11k_warn(ar->ab, "failed to set sta power save mode %d for vdev %d: %d\n",
1271 psmode, arvif->vdev_id, ret);
1278 static int ath11k_mac_config_ps(struct ath11k *ar)
1280 struct ath11k_vif *arvif;
1283 lockdep_assert_held(&ar->conf_mutex);
1285 list_for_each_entry(arvif, &ar->arvifs, list) {
1286 ret = ath11k_mac_vif_setup_ps(arvif);
1288 ath11k_warn(ar->ab, "failed to setup powersave: %d\n", ret);
1296 static int ath11k_mac_op_config(struct ieee80211_hw *hw, u32 changed)
1298 struct ath11k *ar = hw->priv;
1299 struct ieee80211_conf *conf = &hw->conf;
1302 mutex_lock(&ar->conf_mutex);
1304 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1305 if (conf->flags & IEEE80211_CONF_MONITOR) {
1306 set_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1308 if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1309 &ar->monitor_flags))
1312 ret = ath11k_mac_monitor_vdev_create(ar);
1314 ath11k_warn(ar->ab, "failed to create monitor vdev: %d",
1319 ret = ath11k_mac_monitor_start(ar);
1321 ath11k_warn(ar->ab, "failed to start monitor: %d",
1326 clear_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1328 if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1329 &ar->monitor_flags))
1332 ret = ath11k_mac_monitor_stop(ar);
1334 ath11k_warn(ar->ab, "failed to stop monitor: %d",
1339 ret = ath11k_mac_monitor_vdev_delete(ar);
1341 ath11k_warn(ar->ab, "failed to delete monitor vdev: %d",
1349 mutex_unlock(&ar->conf_mutex);
1353 ath11k_mac_monitor_vdev_delete(ar);
1354 mutex_unlock(&ar->conf_mutex);
1358 static void ath11k_mac_setup_nontx_vif_rsnie(struct ath11k_vif *arvif,
1359 bool tx_arvif_rsnie_present,
1360 const u8 *profile, u8 profile_len)
1362 if (cfg80211_find_ie(WLAN_EID_RSN, profile, profile_len)) {
1363 arvif->rsnie_present = true;
1364 } else if (tx_arvif_rsnie_present) {
1367 const u8 *nie = cfg80211_find_ext_ie(WLAN_EID_EXT_NON_INHERITANCE,
1368 profile, profile_len);
1374 for (i = 0; i < nie_len; i++) {
1375 if (nie[i] == WLAN_EID_RSN) {
1376 arvif->rsnie_present = false;
1383 static bool ath11k_mac_set_nontx_vif_params(struct ath11k_vif *tx_arvif,
1384 struct ath11k_vif *arvif,
1385 struct sk_buff *bcn)
1387 struct ieee80211_mgmt *mgmt;
1388 const u8 *ies, *profile, *next_profile;
1391 ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1392 mgmt = (struct ieee80211_mgmt *)bcn->data;
1393 ies += sizeof(mgmt->u.beacon);
1394 ies_len = skb_tail_pointer(bcn) - ies;
1396 ies = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ies, ies_len);
1397 arvif->rsnie_present = tx_arvif->rsnie_present;
1402 ies_len -= (2 + ies[1]);
1403 mbssid_len = ies[1] - 1;
1406 while (mbssid_len) {
1409 profile_len = profile[1];
1410 next_profile = profile + (2 + profile_len);
1411 mbssid_len -= (2 + profile_len);
1414 profile_len -= (2 + profile[1]);
1415 profile += (2 + profile[1]); /* nontx capabilities */
1416 profile_len -= (2 + profile[1]);
1417 profile += (2 + profile[1]); /* SSID */
1418 if (profile[2] == arvif->vif->bss_conf.bssid_index) {
1420 profile = profile + 5;
1421 ath11k_mac_setup_nontx_vif_rsnie(arvif,
1422 tx_arvif->rsnie_present,
1427 profile = next_profile;
1429 ies = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, profile,
1436 static void ath11k_mac_set_vif_params(struct ath11k_vif *arvif,
1437 struct sk_buff *bcn)
1439 struct ieee80211_mgmt *mgmt;
1442 ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1443 mgmt = (struct ieee80211_mgmt *)bcn->data;
1444 ies += sizeof(mgmt->u.beacon);
1446 if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies)))
1447 arvif->rsnie_present = true;
1449 arvif->rsnie_present = false;
1451 if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1452 WLAN_OUI_TYPE_MICROSOFT_WPA,
1453 ies, (skb_tail_pointer(bcn) - ies)))
1454 arvif->wpaie_present = true;
1456 arvif->wpaie_present = false;
1459 static int ath11k_mac_setup_bcn_tmpl_ema(struct ath11k_vif *arvif)
1461 struct ath11k_vif *tx_arvif;
1462 struct ieee80211_ema_beacons *beacons;
1464 bool nontx_vif_params_set = false;
1468 tx_arvif = ath11k_vif_to_arvif(arvif->vif->mbssid_tx_vif);
1470 beacons = ieee80211_beacon_get_template_ema_list(tx_arvif->ar->hw,
1472 if (!beacons || !beacons->cnt) {
1473 ath11k_warn(arvif->ar->ab,
1474 "failed to get ema beacon templates from mac80211\n");
1478 if (tx_arvif == arvif)
1479 ath11k_mac_set_vif_params(tx_arvif, beacons->bcn[0].skb);
1481 arvif->wpaie_present = tx_arvif->wpaie_present;
1483 for (i = 0; i < beacons->cnt; i++) {
1484 if (tx_arvif != arvif && !nontx_vif_params_set)
1485 nontx_vif_params_set =
1486 ath11k_mac_set_nontx_vif_params(tx_arvif, arvif,
1487 beacons->bcn[i].skb);
1489 params = beacons->cnt;
1490 params |= (i << WMI_EMA_TMPL_IDX_SHIFT);
1491 params |= ((!i ? 1 : 0) << WMI_EMA_FIRST_TMPL_SHIFT);
1492 params |= ((i + 1 == beacons->cnt ? 1 : 0) << WMI_EMA_LAST_TMPL_SHIFT);
1494 ret = ath11k_wmi_bcn_tmpl(tx_arvif->ar, tx_arvif->vdev_id,
1495 &beacons->bcn[i].offs,
1496 beacons->bcn[i].skb, params);
1498 ath11k_warn(tx_arvif->ar->ab,
1499 "failed to set ema beacon template id %i error %d\n",
1505 ieee80211_beacon_free_ema_list(beacons);
1507 if (tx_arvif != arvif && !nontx_vif_params_set)
1508 return -EINVAL; /* Profile not found in the beacons */
1513 static int ath11k_mac_setup_bcn_tmpl_mbssid(struct ath11k_vif *arvif)
1515 struct ath11k *ar = arvif->ar;
1516 struct ath11k_base *ab = ar->ab;
1517 struct ath11k_vif *tx_arvif = arvif;
1518 struct ieee80211_hw *hw = ar->hw;
1519 struct ieee80211_vif *vif = arvif->vif;
1520 struct ieee80211_mutable_offsets offs = {};
1521 struct sk_buff *bcn;
1524 if (vif->mbssid_tx_vif) {
1525 tx_arvif = ath11k_vif_to_arvif(vif->mbssid_tx_vif);
1526 if (tx_arvif != arvif) {
1530 vif = tx_arvif->vif;
1534 bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);
1536 ath11k_warn(ab, "failed to get beacon template from mac80211\n");
1540 if (tx_arvif == arvif)
1541 ath11k_mac_set_vif_params(tx_arvif, bcn);
1542 else if (!ath11k_mac_set_nontx_vif_params(tx_arvif, arvif, bcn))
1545 ret = ath11k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn, 0);
1549 ath11k_warn(ab, "failed to submit beacon template command: %d\n",
1555 static int ath11k_mac_setup_bcn_tmpl(struct ath11k_vif *arvif)
1557 struct ieee80211_vif *vif = arvif->vif;
1559 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1562 /* Target does not expect beacon templates for the already up
1563 * non-transmitting interfaces, and results in a crash if sent.
1565 if (vif->mbssid_tx_vif &&
1566 arvif != ath11k_vif_to_arvif(vif->mbssid_tx_vif) && arvif->is_up)
1569 if (vif->bss_conf.ema_ap && vif->mbssid_tx_vif)
1570 return ath11k_mac_setup_bcn_tmpl_ema(arvif);
1572 return ath11k_mac_setup_bcn_tmpl_mbssid(arvif);
1575 void ath11k_mac_bcn_tx_event(struct ath11k_vif *arvif)
1577 struct ieee80211_vif *vif = arvif->vif;
1579 if (!vif->bss_conf.color_change_active && !arvif->bcca_zero_sent)
1582 if (vif->bss_conf.color_change_active &&
1583 ieee80211_beacon_cntdwn_is_complete(vif)) {
1584 arvif->bcca_zero_sent = true;
1585 ieee80211_color_change_finish(vif);
1589 arvif->bcca_zero_sent = false;
1591 if (vif->bss_conf.color_change_active)
1592 ieee80211_beacon_update_cntdwn(vif);
1593 ath11k_mac_setup_bcn_tmpl(arvif);
1596 static void ath11k_control_beaconing(struct ath11k_vif *arvif,
1597 struct ieee80211_bss_conf *info)
1599 struct ath11k *ar = arvif->ar;
1600 struct ath11k_vif *tx_arvif = NULL;
1603 lockdep_assert_held(&arvif->ar->conf_mutex);
1605 if (!info->enable_beacon) {
1606 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
1608 ath11k_warn(ar->ab, "failed to down vdev_id %i: %d\n",
1609 arvif->vdev_id, ret);
1611 arvif->is_up = false;
1615 /* Install the beacon template to the FW */
1616 ret = ath11k_mac_setup_bcn_tmpl(arvif);
1618 ath11k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n",
1623 arvif->tx_seq_no = 0x1000;
1627 ether_addr_copy(arvif->bssid, info->bssid);
1629 if (arvif->vif->mbssid_tx_vif)
1630 tx_arvif = ath11k_vif_to_arvif(arvif->vif->mbssid_tx_vif);
1632 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1634 tx_arvif ? tx_arvif->bssid : NULL,
1636 1 << info->bssid_indicator);
1638 ath11k_warn(ar->ab, "failed to bring up vdev %d: %i\n",
1639 arvif->vdev_id, ret);
1643 arvif->is_up = true;
1645 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d up\n", arvif->vdev_id);
1648 static void ath11k_mac_handle_beacon_iter(void *data, u8 *mac,
1649 struct ieee80211_vif *vif)
1651 struct sk_buff *skb = data;
1652 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1653 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1655 if (vif->type != NL80211_IFTYPE_STATION)
1658 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1661 cancel_delayed_work(&arvif->connection_loss_work);
1664 void ath11k_mac_handle_beacon(struct ath11k *ar, struct sk_buff *skb)
1666 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1667 IEEE80211_IFACE_ITER_NORMAL,
1668 ath11k_mac_handle_beacon_iter,
1672 static void ath11k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1673 struct ieee80211_vif *vif)
1675 u32 *vdev_id = data;
1676 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1677 struct ath11k *ar = arvif->ar;
1678 struct ieee80211_hw *hw = ar->hw;
1680 if (arvif->vdev_id != *vdev_id)
1686 ieee80211_beacon_loss(vif);
1688 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1689 * (done by mac80211) succeeds but beacons do not resume then it
1690 * doesn't make sense to continue operation. Queue connection loss work
1691 * which can be cancelled when beacon is received.
1693 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1694 ATH11K_CONNECTION_LOSS_HZ);
1697 void ath11k_mac_handle_beacon_miss(struct ath11k *ar, u32 vdev_id)
1699 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1700 IEEE80211_IFACE_ITER_NORMAL,
1701 ath11k_mac_handle_beacon_miss_iter,
1705 static void ath11k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1707 struct ath11k_vif *arvif = container_of(work, struct ath11k_vif,
1708 connection_loss_work.work);
1709 struct ieee80211_vif *vif = arvif->vif;
1714 ieee80211_connection_loss(vif);
1717 static void ath11k_peer_assoc_h_basic(struct ath11k *ar,
1718 struct ieee80211_vif *vif,
1719 struct ieee80211_sta *sta,
1720 struct peer_assoc_params *arg)
1722 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1725 lockdep_assert_held(&ar->conf_mutex);
1727 if (vif->type == NL80211_IFTYPE_STATION)
1732 ether_addr_copy(arg->peer_mac, sta->addr);
1733 arg->vdev_id = arvif->vdev_id;
1734 arg->peer_associd = aid;
1735 arg->auth_flag = true;
1736 /* TODO: STA WAR in ath10k for listen interval required? */
1737 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1739 arg->peer_caps = vif->bss_conf.assoc_capability;
1742 static void ath11k_peer_assoc_h_crypto(struct ath11k *ar,
1743 struct ieee80211_vif *vif,
1744 struct ieee80211_sta *sta,
1745 struct peer_assoc_params *arg)
1747 struct ieee80211_bss_conf *info = &vif->bss_conf;
1748 struct cfg80211_chan_def def;
1749 struct cfg80211_bss *bss;
1750 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1751 const u8 *rsnie = NULL;
1752 const u8 *wpaie = NULL;
1754 lockdep_assert_held(&ar->conf_mutex);
1756 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1759 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1760 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1762 if (arvif->rsnie_present || arvif->wpaie_present) {
1763 arg->need_ptk_4_way = true;
1764 if (arvif->wpaie_present)
1765 arg->need_gtk_2_way = true;
1767 const struct cfg80211_bss_ies *ies;
1770 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1772 ies = rcu_dereference(bss->ies);
1774 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1775 WLAN_OUI_TYPE_MICROSOFT_WPA,
1779 cfg80211_put_bss(ar->hw->wiphy, bss);
1782 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1783 if (rsnie || wpaie) {
1784 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1785 "%s: rsn ie found\n", __func__);
1786 arg->need_ptk_4_way = true;
1790 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1791 "%s: wpa ie found\n", __func__);
1792 arg->need_gtk_2_way = true;
1796 /* TODO: Need to check if FW supports PMF? */
1797 arg->is_pmf_enabled = true;
1800 /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */
1803 static void ath11k_peer_assoc_h_rates(struct ath11k *ar,
1804 struct ieee80211_vif *vif,
1805 struct ieee80211_sta *sta,
1806 struct peer_assoc_params *arg)
1808 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1809 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1810 struct cfg80211_chan_def def;
1811 const struct ieee80211_supported_band *sband;
1812 const struct ieee80211_rate *rates;
1813 enum nl80211_band band;
1818 lockdep_assert_held(&ar->conf_mutex);
1820 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1823 band = def.chan->band;
1824 sband = ar->hw->wiphy->bands[band];
1825 ratemask = sta->deflink.supp_rates[band];
1826 ratemask &= arvif->bitrate_mask.control[band].legacy;
1827 rates = sband->bitrates;
1829 rateset->num_rates = 0;
1831 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1832 if (!(ratemask & 1))
1835 rate = ath11k_mac_bitrate_to_rate(rates->bitrate);
1836 rateset->rates[rateset->num_rates] = rate;
1837 rateset->num_rates++;
1842 ath11k_peer_assoc_h_ht_masked(const u8 *ht_mcs_mask)
1846 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
1847 if (ht_mcs_mask[nss])
1854 ath11k_peer_assoc_h_vht_masked(const u16 *vht_mcs_mask)
1858 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
1859 if (vht_mcs_mask[nss])
1865 static void ath11k_peer_assoc_h_ht(struct ath11k *ar,
1866 struct ieee80211_vif *vif,
1867 struct ieee80211_sta *sta,
1868 struct peer_assoc_params *arg)
1870 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
1871 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1872 struct cfg80211_chan_def def;
1873 enum nl80211_band band;
1874 const u8 *ht_mcs_mask;
1879 lockdep_assert_held(&ar->conf_mutex);
1881 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1884 if (!ht_cap->ht_supported)
1887 band = def.chan->band;
1888 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
1890 if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask))
1893 arg->ht_flag = true;
1895 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1896 ht_cap->ampdu_factor)) - 1;
1898 arg->peer_mpdu_density =
1899 ath11k_parse_mpdudensity(ht_cap->ampdu_density);
1901 arg->peer_ht_caps = ht_cap->cap;
1902 arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;
1904 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1905 arg->ldpc_flag = true;
1907 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
1909 arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG;
1912 /* As firmware handles this two flags (IEEE80211_HT_CAP_SGI_20
1913 * and IEEE80211_HT_CAP_SGI_40) for enabling SGI, we reset
1914 * both flags if guard interval is Default GI
1916 if (arvif->bitrate_mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI)
1917 arg->peer_ht_caps &= ~(IEEE80211_HT_CAP_SGI_20 |
1918 IEEE80211_HT_CAP_SGI_40);
1920 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
1921 if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 |
1922 IEEE80211_HT_CAP_SGI_40))
1923 arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG;
1926 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1927 arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG;
1928 arg->stbc_flag = true;
1931 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1932 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1933 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1934 stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S;
1935 arg->peer_rate_caps |= stbc;
1936 arg->stbc_flag = true;
1939 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1940 arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG;
1941 else if (ht_cap->mcs.rx_mask[1])
1942 arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG;
1944 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
1945 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
1946 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
1947 max_nss = (i / 8) + 1;
1948 arg->peer_ht_rates.rates[n++] = i;
1951 /* This is a workaround for HT-enabled STAs which break the spec
1952 * and have no HT capabilities RX mask (no HT RX MCS map).
1954 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1955 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1957 * Firmware asserts if such situation occurs.
1960 arg->peer_ht_rates.num_rates = 8;
1961 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1962 arg->peer_ht_rates.rates[i] = i;
1964 arg->peer_ht_rates.num_rates = n;
1965 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1968 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "ht peer %pM mcs cnt %d nss %d\n",
1970 arg->peer_ht_rates.num_rates,
1974 static int ath11k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
1976 switch ((mcs_map >> (2 * nss)) & 0x3) {
1977 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
1978 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
1979 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
1985 ath11k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
1986 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
1993 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
1994 mcs_map = ath11k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
1998 idx_limit = fls(mcs_map) - 1;
2002 switch (idx_limit) {
2011 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2014 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2017 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2023 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2027 tx_mcs_set &= ~(0x3 << (nss * 2));
2028 tx_mcs_set |= mcs << (nss * 2);
2034 static u8 ath11k_get_nss_160mhz(struct ath11k *ar,
2037 u8 nss_ratio_info = ar->pdev->cap.nss_ratio_info;
2040 switch (nss_ratio_info) {
2041 case WMI_NSS_RATIO_1BY2_NSS:
2042 max_sup_nss = max_nss >> 1;
2044 case WMI_NSS_RATIO_3BY4_NSS:
2045 ath11k_warn(ar->ab, "WMI_NSS_RATIO_3BY4_NSS not supported\n");
2047 case WMI_NSS_RATIO_1_NSS:
2048 max_sup_nss = max_nss;
2050 case WMI_NSS_RATIO_2_NSS:
2051 ath11k_warn(ar->ab, "WMI_NSS_RATIO_2_NSS not supported\n");
2054 ath11k_warn(ar->ab, "invalid nss ratio received from firmware: %d\n",
2062 static void ath11k_peer_assoc_h_vht(struct ath11k *ar,
2063 struct ieee80211_vif *vif,
2064 struct ieee80211_sta *sta,
2065 struct peer_assoc_params *arg)
2067 const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2068 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2069 struct cfg80211_chan_def def;
2070 enum nl80211_band band;
2073 u8 max_nss, vht_mcs;
2074 int i, vht_nss, nss_idx;
2075 bool user_rate_valid = true;
2076 u32 rx_nss, tx_nss, nss_160;
2078 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2081 if (!vht_cap->vht_supported)
2084 band = def.chan->band;
2085 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2087 if (ath11k_peer_assoc_h_vht_masked(vht_mcs_mask))
2090 arg->vht_flag = true;
2092 /* TODO: similar flags required? */
2093 arg->vht_capable = true;
2095 if (def.chan->band == NL80211_BAND_2GHZ)
2096 arg->vht_ng_flag = true;
2098 arg->peer_vht_caps = vht_cap->cap;
2100 ampdu_factor = (vht_cap->cap &
2101 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2102 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2104 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2105 * zero in VHT IE. Using it would result in degraded throughput.
2106 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2107 * it if VHT max_mpdu is smaller.
2109 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2110 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2111 ampdu_factor)) - 1);
2113 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2116 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2119 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
2121 if (vht_nss > sta->deflink.rx_nss) {
2122 user_rate_valid = false;
2123 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2124 if (vht_mcs_mask[nss_idx]) {
2125 user_rate_valid = true;
2131 if (!user_rate_valid) {
2132 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting vht range mcs value to peer supported nss %d for peer %pM\n",
2133 sta->deflink.rx_nss, sta->addr);
2134 vht_mcs_mask[sta->deflink.rx_nss - 1] = vht_mcs_mask[vht_nss - 1];
2137 /* Calculate peer NSS capability from VHT capabilities if STA
2140 for (i = 0, max_nss = 0; i < NL80211_VHT_NSS_MAX; i++) {
2141 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
2144 if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
2148 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2149 arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2150 arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2151 arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2152 arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit(
2153 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2155 /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default.
2156 * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard.
2157 * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
2159 arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
2160 arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;
2162 if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) ==
2163 IEEE80211_VHT_MCS_NOT_SUPPORTED)
2164 arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
2167 arg->tx_max_mcs_nss = 0xFF;
2169 if (arg->peer_phymode == MODE_11AC_VHT160 ||
2170 arg->peer_phymode == MODE_11AC_VHT80_80) {
2171 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2172 rx_nss = min(arg->peer_nss, tx_nss);
2173 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2176 ath11k_warn(ar->ab, "invalid max_nss\n");
2180 if (arg->peer_phymode == MODE_11AC_VHT160)
2181 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2183 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2185 arg->peer_bw_rxnss_override |= nss_160;
2188 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2189 "vht peer %pM max_mpdu %d flags 0x%x nss_override 0x%x\n",
2190 sta->addr, arg->peer_max_mpdu, arg->peer_flags,
2191 arg->peer_bw_rxnss_override);
2194 static int ath11k_mac_get_max_he_mcs_map(u16 mcs_map, int nss)
2196 switch ((mcs_map >> (2 * nss)) & 0x3) {
2197 case IEEE80211_HE_MCS_SUPPORT_0_7: return BIT(8) - 1;
2198 case IEEE80211_HE_MCS_SUPPORT_0_9: return BIT(10) - 1;
2199 case IEEE80211_HE_MCS_SUPPORT_0_11: return BIT(12) - 1;
2204 static u16 ath11k_peer_assoc_h_he_limit(u16 tx_mcs_set,
2205 const u16 he_mcs_limit[NL80211_HE_NSS_MAX])
2212 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
2213 mcs_map = ath11k_mac_get_max_he_mcs_map(tx_mcs_set, nss) &
2217 idx_limit = fls(mcs_map) - 1;
2221 switch (idx_limit) {
2223 mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
2227 mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
2231 mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
2237 mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
2241 tx_mcs_set &= ~(0x3 << (nss * 2));
2242 tx_mcs_set |= mcs << (nss * 2);
2249 ath11k_peer_assoc_h_he_masked(const u16 *he_mcs_mask)
2253 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++)
2254 if (he_mcs_mask[nss])
2260 static void ath11k_peer_assoc_h_he(struct ath11k *ar,
2261 struct ieee80211_vif *vif,
2262 struct ieee80211_sta *sta,
2263 struct peer_assoc_params *arg)
2265 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2266 struct cfg80211_chan_def def;
2267 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2268 enum nl80211_band band;
2269 u16 he_mcs_mask[NL80211_HE_NSS_MAX];
2271 u16 he_tx_mcs = 0, v = 0;
2272 int i, he_nss, nss_idx;
2273 bool user_rate_valid = true;
2274 u32 rx_nss, tx_nss, nss_160;
2275 u8 ampdu_factor, rx_mcs_80, rx_mcs_160;
2276 u16 mcs_160_map, mcs_80_map;
2279 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2282 if (!he_cap->has_he)
2285 band = def.chan->band;
2286 memcpy(he_mcs_mask, arvif->bitrate_mask.control[band].he_mcs,
2287 sizeof(he_mcs_mask));
2289 if (ath11k_peer_assoc_h_he_masked(he_mcs_mask))
2292 arg->he_flag = true;
2293 support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
2294 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);
2296 /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
2297 mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2298 mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2301 for (i = 7; i >= 0; i--) {
2302 u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
2304 if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2311 for (i = 7; i >= 0; i--) {
2312 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
2314 if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2321 max_nss = min(rx_mcs_80, rx_mcs_160);
2323 max_nss = rx_mcs_80;
2325 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2327 memcpy_and_pad(&arg->peer_he_cap_macinfo,
2328 sizeof(arg->peer_he_cap_macinfo),
2329 he_cap->he_cap_elem.mac_cap_info,
2330 sizeof(he_cap->he_cap_elem.mac_cap_info),
2332 memcpy_and_pad(&arg->peer_he_cap_phyinfo,
2333 sizeof(arg->peer_he_cap_phyinfo),
2334 he_cap->he_cap_elem.phy_cap_info,
2335 sizeof(he_cap->he_cap_elem.phy_cap_info),
2337 arg->peer_he_ops = vif->bss_conf.he_oper.params;
2339 /* the top most byte is used to indicate BSS color info */
2340 arg->peer_he_ops &= 0xffffff;
2342 /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
2343 * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
2344 * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
2346 * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
2347 * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
2348 * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
2349 * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
2350 * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
2353 ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
2354 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);
2357 if (sta->deflink.vht_cap.vht_supported)
2358 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2360 else if (sta->deflink.ht_cap.ht_supported)
2361 arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
2365 if (he_cap->he_cap_elem.phy_cap_info[6] &
2366 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
2370 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
2371 IEEE80211_PPE_THRES_NSS_MASK;
2372 arg->peer_ppet.ru_bit_mask =
2373 (he_cap->ppe_thres[0] &
2374 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
2375 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
2377 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
2378 for (ru = 0; ru < 4; ru++) {
2382 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
2384 for (i = 0; i < 6; i++) {
2386 val |= ((he_cap->ppe_thres[bit / 8] >>
2387 (bit % 8)) & 0x1) << 5;
2390 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
2396 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
2397 arg->twt_responder = true;
2398 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
2399 arg->twt_requester = true;
2401 he_nss = ath11k_mac_max_he_nss(he_mcs_mask);
2403 if (he_nss > sta->deflink.rx_nss) {
2404 user_rate_valid = false;
2405 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2406 if (he_mcs_mask[nss_idx]) {
2407 user_rate_valid = true;
2413 if (!user_rate_valid) {
2414 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting he range mcs value to peer supported nss %d for peer %pM\n",
2415 sta->deflink.rx_nss, sta->addr);
2416 he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1];
2419 switch (sta->deflink.bandwidth) {
2420 case IEEE80211_STA_RX_BW_160:
2421 if (he_cap->he_cap_elem.phy_cap_info[0] &
2422 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2423 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
2424 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2425 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2427 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
2428 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2430 arg->peer_he_mcs_count++;
2433 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2434 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2436 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
2437 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2438 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2440 arg->peer_he_mcs_count++;
2446 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2447 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2449 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
2450 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2451 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2453 arg->peer_he_mcs_count++;
2459 /* Calculate peer NSS capability from HE capabilities if STA
2462 for (i = 0, max_nss = 0; i < NL80211_HE_NSS_MAX; i++) {
2463 he_mcs = he_tx_mcs >> (2 * i) & 3;
2465 /* In case of fixed rates, MCS Range in he_tx_mcs might have
2466 * unsupported range, with he_mcs_mask set, so check either of them
2469 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2473 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2475 if (arg->peer_phymode == MODE_11AX_HE160 ||
2476 arg->peer_phymode == MODE_11AX_HE80_80) {
2477 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2478 rx_nss = min(arg->peer_nss, tx_nss);
2479 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2482 ath11k_warn(ar->ab, "invalid max_nss\n");
2486 if (arg->peer_phymode == MODE_11AX_HE160)
2487 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2489 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2491 arg->peer_bw_rxnss_override |= nss_160;
2494 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2495 "he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
2496 sta->addr, arg->peer_nss,
2497 arg->peer_he_mcs_count,
2498 arg->peer_bw_rxnss_override);
2501 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
2502 struct ieee80211_vif *vif,
2503 struct ieee80211_sta *sta,
2504 struct peer_assoc_params *arg)
2506 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2507 struct cfg80211_chan_def def;
2508 enum nl80211_band band;
2511 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2514 band = def.chan->band;
2516 if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa)
2519 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2522 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2525 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2528 arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa);
2529 arg->peer_mpdu_density =
2530 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2531 arg->peer_he_caps_6ghz));
2533 /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2534 * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2535 * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2536 * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2537 * Band Capabilities element in the 6 GHz band.
2539 * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2540 * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2542 ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2543 he_cap->he_cap_elem.mac_cap_info[3]) +
2544 FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2545 arg->peer_he_caps_6ghz);
2547 arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2551 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2552 struct peer_assoc_params *arg)
2554 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2557 if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa)
2560 if (ht_cap->ht_supported) {
2561 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2562 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2564 smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
2565 IEEE80211_HE_6GHZ_CAP_SM_PS);
2569 case WLAN_HT_CAP_SM_PS_STATIC:
2570 arg->static_mimops_flag = true;
2572 case WLAN_HT_CAP_SM_PS_DYNAMIC:
2573 arg->dynamic_mimops_flag = true;
2575 case WLAN_HT_CAP_SM_PS_DISABLED:
2576 arg->spatial_mux_flag = true;
2583 static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
2584 struct ieee80211_vif *vif,
2585 struct ieee80211_sta *sta,
2586 struct peer_assoc_params *arg)
2588 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2590 switch (arvif->vdev_type) {
2591 case WMI_VDEV_TYPE_AP:
2593 /* TODO: Check WME vs QoS */
2594 arg->is_wme_set = true;
2595 arg->qos_flag = true;
2598 if (sta->wme && sta->uapsd_queues) {
2599 /* TODO: Check WME vs QoS */
2600 arg->is_wme_set = true;
2601 arg->apsd_flag = true;
2602 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
2605 case WMI_VDEV_TYPE_STA:
2607 arg->is_wme_set = true;
2608 arg->qos_flag = true;
2615 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM qos %d\n",
2616 sta->addr, arg->qos_flag);
2619 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
2620 struct ath11k_vif *arvif,
2621 struct ieee80211_sta *sta)
2623 struct ap_ps_params params;
2628 lockdep_assert_held(&ar->conf_mutex);
2630 params.vdev_id = arvif->vdev_id;
2632 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "uapsd_queues 0x%x max_sp %d\n",
2633 sta->uapsd_queues, sta->max_sp);
2636 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2637 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2638 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2639 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2640 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2641 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2642 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2643 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2644 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2645 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2646 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2647 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2650 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2651 max_sp = sta->max_sp;
2653 params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
2654 params.value = uapsd;
2655 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2659 params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
2660 params.value = max_sp;
2661 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2665 /* TODO revisit during testing */
2666 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
2667 params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2668 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2672 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
2673 params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2674 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2681 ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
2682 params.param, arvif->vdev_id, ret);
2686 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2688 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2689 ATH11K_MAC_FIRST_OFDM_RATE_IDX;
2692 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
2693 struct ieee80211_sta *sta)
2695 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2696 switch (sta->deflink.vht_cap.cap &
2697 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2698 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2699 return MODE_11AC_VHT160;
2700 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2701 return MODE_11AC_VHT80_80;
2703 /* not sure if this is a valid case? */
2704 return MODE_11AC_VHT160;
2708 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2709 return MODE_11AC_VHT80;
2711 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2712 return MODE_11AC_VHT40;
2714 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2715 return MODE_11AC_VHT20;
2717 return MODE_UNKNOWN;
2720 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
2721 struct ieee80211_sta *sta)
2723 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2724 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2725 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2726 return MODE_11AX_HE160;
2727 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2728 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2729 return MODE_11AX_HE80_80;
2730 /* not sure if this is a valid case? */
2731 return MODE_11AX_HE160;
2734 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2735 return MODE_11AX_HE80;
2737 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2738 return MODE_11AX_HE40;
2740 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2741 return MODE_11AX_HE20;
2743 return MODE_UNKNOWN;
2746 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
2747 struct ieee80211_vif *vif,
2748 struct ieee80211_sta *sta,
2749 struct peer_assoc_params *arg)
2751 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2752 struct cfg80211_chan_def def;
2753 enum nl80211_band band;
2754 const u8 *ht_mcs_mask;
2755 const u16 *vht_mcs_mask;
2756 const u16 *he_mcs_mask;
2757 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2759 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2762 band = def.chan->band;
2763 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2764 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2765 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2768 case NL80211_BAND_2GHZ:
2769 if (sta->deflink.he_cap.has_he &&
2770 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2771 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2772 phymode = MODE_11AX_HE80_2G;
2773 else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2774 phymode = MODE_11AX_HE40_2G;
2776 phymode = MODE_11AX_HE20_2G;
2777 } else if (sta->deflink.vht_cap.vht_supported &&
2778 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2779 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2780 phymode = MODE_11AC_VHT40;
2782 phymode = MODE_11AC_VHT20;
2783 } else if (sta->deflink.ht_cap.ht_supported &&
2784 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2785 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2786 phymode = MODE_11NG_HT40;
2788 phymode = MODE_11NG_HT20;
2789 } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2795 case NL80211_BAND_5GHZ:
2796 case NL80211_BAND_6GHZ:
2797 /* Check HE first */
2798 if (sta->deflink.he_cap.has_he &&
2799 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2800 phymode = ath11k_mac_get_phymode_he(ar, sta);
2801 } else if (sta->deflink.vht_cap.vht_supported &&
2802 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2803 phymode = ath11k_mac_get_phymode_vht(ar, sta);
2804 } else if (sta->deflink.ht_cap.ht_supported &&
2805 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2806 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2807 phymode = MODE_11NA_HT40;
2809 phymode = MODE_11NA_HT20;
2818 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM phymode %s\n",
2819 sta->addr, ath11k_wmi_phymode_str(phymode));
2821 arg->peer_phymode = phymode;
2822 WARN_ON(phymode == MODE_UNKNOWN);
2825 static void ath11k_peer_assoc_prepare(struct ath11k *ar,
2826 struct ieee80211_vif *vif,
2827 struct ieee80211_sta *sta,
2828 struct peer_assoc_params *arg,
2831 struct ath11k_sta *arsta;
2833 lockdep_assert_held(&ar->conf_mutex);
2835 arsta = ath11k_sta_to_arsta(sta);
2837 memset(arg, 0, sizeof(*arg));
2839 reinit_completion(&ar->peer_assoc_done);
2841 arg->peer_new_assoc = !reassoc;
2842 ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
2843 ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
2844 ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
2845 ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
2846 ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
2847 ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
2848 ath11k_peer_assoc_h_he(ar, vif, sta, arg);
2849 ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
2850 ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
2851 ath11k_peer_assoc_h_smps(sta, arg);
2853 arsta->peer_nss = arg->peer_nss;
2855 /* TODO: amsdu_disable req? */
2858 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
2860 const struct ieee80211_sta_ht_cap *ht_cap,
2865 if (!ht_cap->ht_supported && !he_6ghz_capa)
2868 if (ht_cap->ht_supported) {
2869 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2870 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2872 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
2875 if (smps >= ARRAY_SIZE(ath11k_smps_map))
2878 return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2879 WMI_PEER_MIMO_PS_STATE,
2880 ath11k_smps_map[smps]);
2883 static bool ath11k_mac_set_he_txbf_conf(struct ath11k_vif *arvif)
2885 struct ath11k *ar = arvif->ar;
2889 if (!arvif->vif->bss_conf.he_support)
2892 param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2894 if (arvif->vif->bss_conf.he_su_beamformer) {
2895 value |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2896 if (arvif->vif->bss_conf.he_mu_beamformer &&
2897 arvif->vdev_type == WMI_VDEV_TYPE_AP)
2898 value |= FIELD_PREP(HE_MODE_MU_TX_BFER, HE_MU_BFER_ENABLE);
2901 if (arvif->vif->type != NL80211_IFTYPE_MESH_POINT) {
2902 value |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2903 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2905 if (arvif->vif->bss_conf.he_full_ul_mumimo)
2906 value |= FIELD_PREP(HE_MODE_UL_MUMIMO, HE_UL_MUMIMO_ENABLE);
2908 if (arvif->vif->bss_conf.he_su_beamformee)
2909 value |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2912 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, value);
2914 ath11k_warn(ar->ab, "failed to set vdev %d HE MU mode: %d\n",
2915 arvif->vdev_id, ret);
2919 param = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
2920 value = FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
2921 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
2922 HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
2923 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2926 ath11k_warn(ar->ab, "failed to set vdev %d sounding mode: %d\n",
2927 arvif->vdev_id, ret);
2933 static bool ath11k_mac_vif_recalc_sta_he_txbf(struct ath11k *ar,
2934 struct ieee80211_vif *vif,
2935 struct ieee80211_sta_he_cap *he_cap)
2937 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2938 struct ieee80211_he_cap_elem he_cap_elem = {0};
2939 struct ieee80211_sta_he_cap *cap_band = NULL;
2940 struct cfg80211_chan_def def;
2941 u32 param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2945 if (!vif->bss_conf.he_support)
2948 if (vif->type != NL80211_IFTYPE_STATION)
2951 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2954 if (def.chan->band == NL80211_BAND_2GHZ)
2955 cap_band = &ar->mac.iftype[NL80211_BAND_2GHZ][vif->type].he_cap;
2957 cap_band = &ar->mac.iftype[NL80211_BAND_5GHZ][vif->type].he_cap;
2959 memcpy(&he_cap_elem, &cap_band->he_cap_elem, sizeof(he_cap_elem));
2961 if (HECAP_PHY_SUBFME_GET(he_cap_elem.phy_cap_info)) {
2962 if (HECAP_PHY_SUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2963 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2964 if (HECAP_PHY_MUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2965 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
2968 if (vif->type != NL80211_IFTYPE_MESH_POINT) {
2969 hemode |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2970 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2972 if (HECAP_PHY_ULMUMIMO_GET(he_cap_elem.phy_cap_info))
2973 if (HECAP_PHY_ULMUMIMO_GET(he_cap->he_cap_elem.phy_cap_info))
2974 hemode |= FIELD_PREP(HE_MODE_UL_MUMIMO,
2975 HE_UL_MUMIMO_ENABLE);
2977 if (FIELD_GET(HE_MODE_MU_TX_BFEE, hemode))
2978 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2980 if (FIELD_GET(HE_MODE_MU_TX_BFER, hemode))
2981 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2984 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, hemode);
2986 ath11k_warn(ar->ab, "failed to submit vdev param txbf 0x%x: %d\n",
2994 static void ath11k_bss_assoc(struct ieee80211_hw *hw,
2995 struct ieee80211_vif *vif,
2996 struct ieee80211_bss_conf *bss_conf)
2998 struct ath11k *ar = hw->priv;
2999 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3000 struct peer_assoc_params peer_arg;
3001 struct ieee80211_sta *ap_sta;
3002 struct ath11k_peer *peer;
3003 bool is_auth = false;
3004 struct ieee80211_sta_he_cap he_cap;
3007 lockdep_assert_held(&ar->conf_mutex);
3009 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i assoc bssid %pM aid %d\n",
3010 arvif->vdev_id, arvif->bssid, arvif->aid);
3014 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
3016 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
3017 bss_conf->bssid, arvif->vdev_id);
3022 /* he_cap here is updated at assoc success for sta mode only */
3023 he_cap = ap_sta->deflink.he_cap;
3025 ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
3029 peer_arg.is_assoc = true;
3030 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
3032 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
3033 bss_conf->bssid, arvif->vdev_id, ret);
3037 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
3038 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
3039 bss_conf->bssid, arvif->vdev_id);
3043 ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
3044 &ap_sta->deflink.ht_cap,
3045 le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa));
3047 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
3048 arvif->vdev_id, ret);
3052 if (!ath11k_mac_vif_recalc_sta_he_txbf(ar, vif, &he_cap)) {
3053 ath11k_warn(ar->ab, "failed to recalc he txbf for vdev %i on bss %pM\n",
3054 arvif->vdev_id, bss_conf->bssid);
3058 WARN_ON(arvif->is_up);
3060 arvif->aid = vif->cfg.aid;
3061 ether_addr_copy(arvif->bssid, bss_conf->bssid);
3063 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid,
3066 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
3067 arvif->vdev_id, ret);
3071 arvif->is_up = true;
3072 arvif->rekey_data.enable_offload = false;
3074 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3075 "vdev %d up (associated) bssid %pM aid %d\n",
3076 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
3078 spin_lock_bh(&ar->ab->base_lock);
3080 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
3081 if (peer && peer->is_authorized)
3084 spin_unlock_bh(&ar->ab->base_lock);
3087 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
3092 ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
3095 ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
3096 &bss_conf->he_obss_pd);
3098 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
3099 arvif->vdev_id, ret);
3101 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3102 WMI_VDEV_PARAM_DTIM_POLICY,
3103 WMI_DTIM_POLICY_STICK);
3105 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
3106 arvif->vdev_id, ret);
3108 ath11k_mac_11d_scan_stop_all(ar->ab);
3111 static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
3112 struct ieee80211_vif *vif)
3114 struct ath11k *ar = hw->priv;
3115 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3118 lockdep_assert_held(&ar->conf_mutex);
3120 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i disassoc bssid %pM\n",
3121 arvif->vdev_id, arvif->bssid);
3123 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
3125 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
3126 arvif->vdev_id, ret);
3128 arvif->is_up = false;
3130 memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
3132 cancel_delayed_work_sync(&arvif->connection_loss_work);
3135 static u32 ath11k_mac_get_rate_hw_value(int bitrate)
3142 if (ath11k_mac_bitrate_is_cck(bitrate))
3143 preamble = WMI_RATE_PREAMBLE_CCK;
3145 preamble = WMI_RATE_PREAMBLE_OFDM;
3147 for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
3148 if (ath11k_legacy_rates[i].bitrate != bitrate)
3151 hw_value = ath11k_legacy_rates[i].hw_value;
3152 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3160 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
3161 struct ieee80211_vif *vif,
3162 struct cfg80211_chan_def *def)
3164 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3165 const struct ieee80211_supported_band *sband;
3172 lockdep_assert_held(&ar->conf_mutex);
3174 sband = ar->hw->wiphy->bands[def->chan->band];
3175 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
3176 bitrate = sband->bitrates[basic_rate_idx].bitrate;
3178 hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
3179 if (hw_rate_code < 0) {
3180 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
3184 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
3185 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3188 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
3190 /* For WCN6855, firmware will clear this param when vdev starts, hence
3191 * cache it here so that we can reconfigure it once vdev starts.
3193 ar->hw_rate_code = hw_rate_code;
3195 vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
3196 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3199 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
3202 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
3203 struct ieee80211_bss_conf *info)
3205 struct ath11k *ar = arvif->ar;
3206 struct sk_buff *tmpl;
3209 bool unsol_bcast_probe_resp_enabled = false;
3211 if (info->fils_discovery.max_interval) {
3212 interval = info->fils_discovery.max_interval;
3214 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
3216 ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
3218 } else if (info->unsol_bcast_probe_resp_interval) {
3219 unsol_bcast_probe_resp_enabled = 1;
3220 interval = info->unsol_bcast_probe_resp_interval;
3222 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
3225 ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
3227 } else { /* Disable */
3228 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
3233 "mac vdev %i failed to retrieve %s template\n",
3234 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
3235 "unsolicited broadcast probe response" :
3242 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
3243 unsol_bcast_probe_resp_enabled);
3248 static int ath11k_mac_config_obss_pd(struct ath11k *ar,
3249 struct ieee80211_he_obss_pd *he_obss_pd)
3251 u32 bitmap[2], param_id, param_val, pdev_id;
3253 s8 non_srg_th = 0, srg_th = 0;
3255 pdev_id = ar->pdev->pdev_id;
3257 /* Set and enable SRG/non-SRG OBSS PD Threshold */
3258 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
3259 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
3260 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
3263 "failed to set obss_pd_threshold for pdev: %u\n",
3268 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3269 "obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
3270 he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
3271 he_obss_pd->max_offset);
3275 if (he_obss_pd->sr_ctrl &
3276 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
3277 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
3279 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
3280 non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
3281 he_obss_pd->non_srg_max_offset);
3283 non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;
3285 param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
3288 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
3289 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
3290 param_val |= ATH11K_OBSS_PD_SRG_EN;
3293 if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3294 ar->ab->wmi_ab.svc_map)) {
3295 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
3296 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
3298 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
3299 /* SRG not supported and threshold in dB */
3300 param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
3301 ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
3304 param_val |= (non_srg_th & GENMASK(7, 0));
3305 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3308 "failed to set obss_pd_threshold for pdev: %u\n",
3313 /* Enable OBSS PD for all access category */
3314 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
3316 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3319 "failed to set obss_pd_per_ac for pdev: %u\n",
3324 /* Set SR Prohibit */
3325 param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
3326 param_val = !!(he_obss_pd->sr_ctrl &
3327 IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
3328 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3330 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",
3335 if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3336 ar->ab->wmi_ab.svc_map))
3339 /* Set SRG BSS Color Bitmap */
3340 memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
3341 ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);
3344 "failed to set bss_color_bitmap for pdev: %u\n",
3349 /* Set SRG Partial BSSID Bitmap */
3350 memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
3351 ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);
3354 "failed to set partial_bssid_bitmap for pdev: %u\n",
3359 memset(bitmap, 0xff, sizeof(bitmap));
3361 /* Enable all BSS Colors for SRG */
3362 ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);
3365 "failed to set srg_color_en_bitmap pdev: %u\n",
3370 /* Enable all partial BSSID mask for SRG */
3371 ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);
3374 "failed to set srg_bssid_en_bitmap pdev: %u\n",
3379 /* Enable all BSS Colors for non-SRG */
3380 ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);
3383 "failed to set non_srg_color_en_bitmap pdev: %u\n",
3388 /* Enable all partial BSSID mask for non-SRG */
3389 ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);
3392 "failed to set non_srg_bssid_en_bitmap pdev: %u\n",
3400 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
3401 struct ieee80211_vif *vif,
3402 struct ieee80211_bss_conf *info,
3405 struct ath11k *ar = hw->priv;
3406 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3407 struct cfg80211_chan_def def;
3408 u32 param_id, param_value;
3409 enum nl80211_band band;
3420 mutex_lock(&ar->conf_mutex);
3422 if (changed & BSS_CHANGED_BEACON_INT) {
3423 arvif->beacon_interval = info->beacon_int;
3425 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
3426 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3428 arvif->beacon_interval);
3430 ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
3433 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3434 "Beacon interval: %d set for VDEV: %d\n",
3435 arvif->beacon_interval, arvif->vdev_id);
3438 if (changed & BSS_CHANGED_BEACON) {
3439 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
3440 param_value = WMI_BEACON_STAGGERED_MODE;
3441 ret = ath11k_wmi_pdev_set_param(ar, param_id,
3442 param_value, ar->pdev->pdev_id);
3444 ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
3447 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3448 "Set staggered beacon mode for VDEV: %d\n",
3451 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) {
3452 ret = ath11k_mac_setup_bcn_tmpl(arvif);
3454 ath11k_warn(ar->ab, "failed to update bcn template: %d\n",
3458 if (arvif->bcca_zero_sent)
3459 arvif->do_not_send_tmpl = true;
3461 arvif->do_not_send_tmpl = false;
3463 if (vif->bss_conf.he_support) {
3464 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3465 WMI_VDEV_PARAM_BA_MODE,
3466 WMI_BA_MODE_BUFFER_SIZE_256);
3469 "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3472 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3473 "Set BA BUFFER SIZE 256 for VDEV: %d\n",
3478 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3479 arvif->dtim_period = info->dtim_period;
3481 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3482 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3484 arvif->dtim_period);
3487 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3488 arvif->vdev_id, ret);
3490 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3491 "DTIM period: %d set for VDEV: %d\n",
3492 arvif->dtim_period, arvif->vdev_id);
3495 if (changed & BSS_CHANGED_SSID &&
3496 vif->type == NL80211_IFTYPE_AP) {
3497 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
3498 if (vif->cfg.ssid_len)
3499 memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
3501 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3504 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3505 ether_addr_copy(arvif->bssid, info->bssid);
3507 if (changed & BSS_CHANGED_BEACON_ENABLED) {
3508 if (info->enable_beacon)
3509 ath11k_mac_set_he_txbf_conf(arvif);
3510 ath11k_control_beaconing(arvif, info);
3512 if (arvif->is_up && vif->bss_conf.he_support &&
3513 vif->bss_conf.he_oper.params) {
3514 param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3515 param_value = vif->bss_conf.he_oper.params;
3516 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3517 param_id, param_value);
3518 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3519 "he oper param: %x set for VDEV: %d\n",
3520 param_value, arvif->vdev_id);
3523 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3524 param_value, arvif->vdev_id, ret);
3528 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3531 cts_prot = !!(info->use_cts_prot);
3532 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3534 if (arvif->is_started) {
3535 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3536 param_id, cts_prot);
3538 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3541 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3542 cts_prot, arvif->vdev_id);
3544 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3548 if (changed & BSS_CHANGED_ERP_SLOT) {
3551 if (info->use_short_slot)
3552 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3555 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3557 param_id = WMI_VDEV_PARAM_SLOT_TIME;
3558 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3559 param_id, slottime);
3561 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3564 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3565 "Set slottime: %d for VDEV: %d\n",
3566 slottime, arvif->vdev_id);
3569 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3572 if (info->use_short_preamble)
3573 preamble = WMI_VDEV_PREAMBLE_SHORT;
3575 preamble = WMI_VDEV_PREAMBLE_LONG;
3577 param_id = WMI_VDEV_PARAM_PREAMBLE;
3578 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3579 param_id, preamble);
3581 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3584 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3585 "Set preamble: %d for VDEV: %d\n",
3586 preamble, arvif->vdev_id);
3589 if (changed & BSS_CHANGED_ASSOC) {
3591 ath11k_bss_assoc(hw, vif, info);
3593 ath11k_bss_disassoc(hw, vif);
3596 if (changed & BSS_CHANGED_TXPOWER) {
3597 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev_id %i txpower %d\n",
3598 arvif->vdev_id, info->txpower);
3600 arvif->txpower = info->txpower;
3601 ath11k_mac_txpower_recalc(ar);
3604 if (changed & BSS_CHANGED_PS &&
3605 ar->ab->hw_params.supports_sta_ps) {
3606 arvif->ps = vif->cfg.ps;
3608 ret = ath11k_mac_config_ps(ar);
3610 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3611 arvif->vdev_id, ret);
3614 if (changed & BSS_CHANGED_MCAST_RATE &&
3615 !ath11k_mac_vif_chan(arvif->vif, &def)) {
3616 band = def.chan->band;
3617 mcast_rate = vif->bss_conf.mcast_rate[band];
3620 rateidx = mcast_rate - 1;
3622 rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3624 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3625 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3627 bitrate = ath11k_legacy_rates[rateidx].bitrate;
3628 hw_value = ath11k_legacy_rates[rateidx].hw_value;
3630 if (ath11k_mac_bitrate_is_cck(bitrate))
3631 preamble = WMI_RATE_PREAMBLE_CCK;
3633 preamble = WMI_RATE_PREAMBLE_OFDM;
3635 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3637 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3638 "vdev %d mcast_rate %x\n",
3639 arvif->vdev_id, rate);
3641 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3642 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3646 "failed to set mcast rate on vdev %i: %d\n",
3647 arvif->vdev_id, ret);
3649 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3650 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3654 "failed to set bcast rate on vdev %i: %d\n",
3655 arvif->vdev_id, ret);
3658 if (changed & BSS_CHANGED_BASIC_RATES &&
3659 !ath11k_mac_vif_chan(arvif->vif, &def))
3660 ath11k_recalculate_mgmt_rate(ar, vif, &def);
3662 if (changed & BSS_CHANGED_TWT) {
3663 struct wmi_twt_enable_params twt_params = {0};
3665 if (info->twt_requester || info->twt_responder) {
3666 ath11k_wmi_fill_default_twt_params(&twt_params);
3667 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id,
3670 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
3674 if (changed & BSS_CHANGED_HE_OBSS_PD)
3675 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3677 if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3678 if (vif->type == NL80211_IFTYPE_AP) {
3679 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3680 ar, arvif->vdev_id, info->he_bss_color.color,
3681 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
3682 info->he_bss_color.enabled);
3684 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3685 arvif->vdev_id, ret);
3687 param_id = WMI_VDEV_PARAM_BSS_COLOR;
3688 if (info->he_bss_color.enabled)
3689 param_value = info->he_bss_color.color <<
3690 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3692 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3694 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3699 "failed to set bss color param on vdev %i: %d\n",
3700 arvif->vdev_id, ret);
3702 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3703 "bss color param 0x%x set on vdev %i\n",
3704 param_value, arvif->vdev_id);
3705 } else if (vif->type == NL80211_IFTYPE_STATION) {
3706 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3710 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3711 arvif->vdev_id, ret);
3712 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3713 ar, arvif->vdev_id, 0,
3714 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3716 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3717 arvif->vdev_id, ret);
3721 if (changed & BSS_CHANGED_FTM_RESPONDER &&
3722 arvif->ftm_responder != info->ftm_responder &&
3723 test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map) &&
3724 (vif->type == NL80211_IFTYPE_AP ||
3725 vif->type == NL80211_IFTYPE_MESH_POINT)) {
3726 arvif->ftm_responder = info->ftm_responder;
3727 param = WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE;
3728 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
3729 arvif->ftm_responder);
3731 ath11k_warn(ar->ab, "Failed to set ftm responder %i: %d\n",
3732 arvif->vdev_id, ret);
3735 if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3736 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3737 ath11k_mac_fils_discovery(arvif, info);
3739 if (changed & BSS_CHANGED_ARP_FILTER) {
3740 ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3741 memcpy(arvif->arp_ns_offload.ipv4_addr,
3742 vif->cfg.arp_addr_list,
3743 ipv4_cnt * sizeof(u32));
3744 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3745 arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3747 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3748 vif->cfg.arp_addr_cnt,
3749 vif->addr, arvif->arp_ns_offload.ipv4_addr);
3752 mutex_unlock(&ar->conf_mutex);
3755 void __ath11k_mac_scan_finish(struct ath11k *ar)
3757 lockdep_assert_held(&ar->data_lock);
3759 switch (ar->scan.state) {
3760 case ATH11K_SCAN_IDLE:
3762 case ATH11K_SCAN_RUNNING:
3763 case ATH11K_SCAN_ABORTING:
3764 if (ar->scan.is_roc && ar->scan.roc_notify)
3765 ieee80211_remain_on_channel_expired(ar->hw);
3767 case ATH11K_SCAN_STARTING:
3768 if (!ar->scan.is_roc) {
3769 struct cfg80211_scan_info info = {
3770 .aborted = ((ar->scan.state ==
3771 ATH11K_SCAN_ABORTING) ||
3773 ATH11K_SCAN_STARTING)),
3776 ieee80211_scan_completed(ar->hw, &info);
3779 ar->scan.state = ATH11K_SCAN_IDLE;
3780 ar->scan_channel = NULL;
3781 ar->scan.roc_freq = 0;
3782 cancel_delayed_work(&ar->scan.timeout);
3783 complete_all(&ar->scan.completed);
3788 void ath11k_mac_scan_finish(struct ath11k *ar)
3790 spin_lock_bh(&ar->data_lock);
3791 __ath11k_mac_scan_finish(ar);
3792 spin_unlock_bh(&ar->data_lock);
3795 static int ath11k_scan_stop(struct ath11k *ar)
3797 struct scan_cancel_param arg = {
3798 .req_type = WLAN_SCAN_CANCEL_SINGLE,
3799 .scan_id = ATH11K_SCAN_ID,
3803 lockdep_assert_held(&ar->conf_mutex);
3805 /* TODO: Fill other STOP Params */
3806 arg.pdev_id = ar->pdev->pdev_id;
3808 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3810 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3814 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3817 "failed to receive scan abort comple: timed out\n");
3819 } else if (ret > 0) {
3824 /* Scan state should be updated upon scan completion but in case
3825 * firmware fails to deliver the event (for whatever reason) it is
3826 * desired to clean up scan state anyway. Firmware may have just
3827 * dropped the scan completion event delivery due to transport pipe
3828 * being overflown with data and/or it can recover on its own before
3829 * next scan request is submitted.
3831 spin_lock_bh(&ar->data_lock);
3832 if (ar->scan.state != ATH11K_SCAN_IDLE)
3833 __ath11k_mac_scan_finish(ar);
3834 spin_unlock_bh(&ar->data_lock);
3839 static void ath11k_scan_abort(struct ath11k *ar)
3843 lockdep_assert_held(&ar->conf_mutex);
3845 spin_lock_bh(&ar->data_lock);
3847 switch (ar->scan.state) {
3848 case ATH11K_SCAN_IDLE:
3849 /* This can happen if timeout worker kicked in and called
3850 * abortion while scan completion was being processed.
3853 case ATH11K_SCAN_STARTING:
3854 case ATH11K_SCAN_ABORTING:
3855 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3858 case ATH11K_SCAN_RUNNING:
3859 ar->scan.state = ATH11K_SCAN_ABORTING;
3860 spin_unlock_bh(&ar->data_lock);
3862 ret = ath11k_scan_stop(ar);
3864 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3866 spin_lock_bh(&ar->data_lock);
3870 spin_unlock_bh(&ar->data_lock);
3873 static void ath11k_scan_timeout_work(struct work_struct *work)
3875 struct ath11k *ar = container_of(work, struct ath11k,
3878 mutex_lock(&ar->conf_mutex);
3879 ath11k_scan_abort(ar);
3880 mutex_unlock(&ar->conf_mutex);
3883 static int ath11k_start_scan(struct ath11k *ar,
3884 struct scan_req_params *arg)
3887 unsigned long timeout = 1 * HZ;
3889 lockdep_assert_held(&ar->conf_mutex);
3891 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3892 ath11k_spectral_reset_buffer(ar);
3894 ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3898 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3901 if (ar->supports_6ghz)
3905 ret = wait_for_completion_timeout(&ar->scan.started, timeout);
3907 ret = ath11k_scan_stop(ar);
3909 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3914 /* If we failed to start the scan, return error code at
3915 * this point. This is probably due to some issue in the
3916 * firmware, but no need to wedge the driver due to that...
3918 spin_lock_bh(&ar->data_lock);
3919 if (ar->scan.state == ATH11K_SCAN_IDLE) {
3920 spin_unlock_bh(&ar->data_lock);
3923 spin_unlock_bh(&ar->data_lock);
3928 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3929 struct ieee80211_vif *vif,
3930 struct ieee80211_scan_request *hw_req)
3932 struct ath11k *ar = hw->priv;
3933 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3934 struct cfg80211_scan_request *req = &hw_req->req;
3935 struct scan_req_params *arg = NULL;
3940 /* Firmwares advertising the support of triggering 11D algorithm
3941 * on the scan results of a regular scan expects driver to send
3942 * WMI_11D_SCAN_START_CMDID before sending WMI_START_SCAN_CMDID.
3943 * With this feature, separate 11D scan can be avoided since
3944 * regdomain can be determined with the scan results of the
3947 if (ar->state_11d == ATH11K_11D_PREPARING &&
3948 test_bit(WMI_TLV_SERVICE_SUPPORT_11D_FOR_HOST_SCAN,
3949 ar->ab->wmi_ab.svc_map))
3950 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3952 mutex_lock(&ar->conf_mutex);
3954 spin_lock_bh(&ar->data_lock);
3955 switch (ar->scan.state) {
3956 case ATH11K_SCAN_IDLE:
3957 reinit_completion(&ar->scan.started);
3958 reinit_completion(&ar->scan.completed);
3959 ar->scan.state = ATH11K_SCAN_STARTING;
3960 ar->scan.is_roc = false;
3961 ar->scan.vdev_id = arvif->vdev_id;
3964 case ATH11K_SCAN_STARTING:
3965 case ATH11K_SCAN_RUNNING:
3966 case ATH11K_SCAN_ABORTING:
3970 spin_unlock_bh(&ar->data_lock);
3975 arg = kzalloc(sizeof(*arg), GFP_KERNEL);
3982 ath11k_wmi_start_scan_init(ar, arg);
3983 arg->vdev_id = arvif->vdev_id;
3984 arg->scan_id = ATH11K_SCAN_ID;
3987 arg->extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3988 if (!arg->extraie.ptr) {
3992 arg->extraie.len = req->ie_len;
3996 arg->num_ssids = req->n_ssids;
3997 for (i = 0; i < arg->num_ssids; i++) {
3998 arg->ssid[i].length = req->ssids[i].ssid_len;
3999 memcpy(&arg->ssid[i].ssid, req->ssids[i].ssid,
4000 req->ssids[i].ssid_len);
4003 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
4006 if (req->n_channels) {
4007 arg->num_chan = req->n_channels;
4008 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
4011 if (!arg->chan_list) {
4016 for (i = 0; i < arg->num_chan; i++) {
4017 if (test_bit(WMI_TLV_SERVICE_SCAN_CONFIG_PER_CHANNEL,
4018 ar->ab->wmi_ab.svc_map)) {
4020 u32_encode_bits(req->channels[i]->center_freq,
4021 WMI_SCAN_CONFIG_PER_CHANNEL_MASK);
4023 /* If NL80211_SCAN_FLAG_COLOCATED_6GHZ is set in scan
4024 * flags, then scan all PSC channels in 6 GHz band and
4025 * those non-PSC channels where RNR IE is found during
4026 * the legacy 2.4/5 GHz scan.
4027 * If NL80211_SCAN_FLAG_COLOCATED_6GHZ is not set,
4028 * then all channels in 6 GHz will be scanned.
4030 if (req->channels[i]->band == NL80211_BAND_6GHZ &&
4031 req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ &&
4032 !cfg80211_channel_is_psc(req->channels[i]))
4033 arg->chan_list[i] |=
4034 WMI_SCAN_CH_FLAG_SCAN_ONLY_IF_RNR_FOUND;
4036 arg->chan_list[i] = req->channels[i]->center_freq;
4041 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
4042 arg->scan_f_add_spoofed_mac_in_probe = 1;
4043 ether_addr_copy(arg->mac_addr.addr, req->mac_addr);
4044 ether_addr_copy(arg->mac_mask.addr, req->mac_addr_mask);
4047 /* if duration is set, default dwell times will be overwritten */
4048 if (req->duration) {
4049 arg->dwell_time_active = req->duration;
4050 arg->dwell_time_active_2g = req->duration;
4051 arg->dwell_time_active_6g = req->duration;
4052 arg->dwell_time_passive = req->duration;
4053 arg->dwell_time_passive_6g = req->duration;
4054 arg->burst_duration = req->duration;
4056 scan_timeout = min_t(u32, arg->max_rest_time *
4057 (arg->num_chan - 1) + (req->duration +
4058 ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *
4059 arg->num_chan, arg->max_scan_time);
4061 scan_timeout = arg->max_scan_time;
4064 /* Add a margin to account for event/command processing */
4065 scan_timeout += ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD;
4067 ret = ath11k_start_scan(ar, arg);
4069 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
4070 spin_lock_bh(&ar->data_lock);
4071 ar->scan.state = ATH11K_SCAN_IDLE;
4072 spin_unlock_bh(&ar->data_lock);
4075 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4076 msecs_to_jiffies(scan_timeout));
4080 kfree(arg->chan_list);
4081 kfree(arg->extraie.ptr);
4085 mutex_unlock(&ar->conf_mutex);
4087 if (ar->state_11d == ATH11K_11D_PREPARING)
4088 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
4093 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
4094 struct ieee80211_vif *vif)
4096 struct ath11k *ar = hw->priv;
4098 mutex_lock(&ar->conf_mutex);
4099 ath11k_scan_abort(ar);
4100 mutex_unlock(&ar->conf_mutex);
4102 cancel_delayed_work_sync(&ar->scan.timeout);
4105 static int ath11k_install_key(struct ath11k_vif *arvif,
4106 struct ieee80211_key_conf *key,
4107 enum set_key_cmd cmd,
4108 const u8 *macaddr, u32 flags)
4111 struct ath11k *ar = arvif->ar;
4112 struct wmi_vdev_install_key_arg arg = {
4113 .vdev_id = arvif->vdev_id,
4114 .key_idx = key->keyidx,
4115 .key_len = key->keylen,
4116 .key_data = key->key,
4121 lockdep_assert_held(&arvif->ar->conf_mutex);
4123 reinit_completion(&ar->install_key_done);
4125 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4128 if (cmd == DISABLE_KEY) {
4129 arg.key_cipher = WMI_CIPHER_NONE;
4130 arg.key_data = NULL;
4134 switch (key->cipher) {
4135 case WLAN_CIPHER_SUITE_CCMP:
4136 arg.key_cipher = WMI_CIPHER_AES_CCM;
4137 /* TODO: Re-check if flag is valid */
4138 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
4140 case WLAN_CIPHER_SUITE_TKIP:
4141 arg.key_cipher = WMI_CIPHER_TKIP;
4142 arg.key_txmic_len = 8;
4143 arg.key_rxmic_len = 8;
4145 case WLAN_CIPHER_SUITE_CCMP_256:
4146 arg.key_cipher = WMI_CIPHER_AES_CCM;
4148 case WLAN_CIPHER_SUITE_GCMP:
4149 case WLAN_CIPHER_SUITE_GCMP_256:
4150 arg.key_cipher = WMI_CIPHER_AES_GCM;
4153 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
4157 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
4158 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
4159 IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
4162 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
4167 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
4170 return ar->install_key_status ? -EINVAL : 0;
4173 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
4176 struct ath11k *ar = arvif->ar;
4177 struct ath11k_base *ab = ar->ab;
4178 struct ath11k_peer *peer;
4179 int first_errno = 0;
4184 lockdep_assert_held(&ar->conf_mutex);
4186 spin_lock_bh(&ab->base_lock);
4187 peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
4188 spin_unlock_bh(&ab->base_lock);
4193 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
4197 /* key flags are not required to delete the key */
4198 ret = ath11k_install_key(arvif, peer->keys[i],
4199 DISABLE_KEY, addr, flags);
4200 if (ret < 0 && first_errno == 0)
4204 ath11k_warn(ab, "failed to remove peer key %d: %d\n",
4207 spin_lock_bh(&ab->base_lock);
4208 peer->keys[i] = NULL;
4209 spin_unlock_bh(&ab->base_lock);
4215 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4216 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4217 struct ieee80211_key_conf *key)
4219 struct ath11k *ar = hw->priv;
4220 struct ath11k_base *ab = ar->ab;
4221 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4222 struct ath11k_peer *peer;
4223 struct ath11k_sta *arsta;
4224 const u8 *peer_addr;
4228 /* BIP needs to be done in software */
4229 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
4230 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
4231 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
4232 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
4235 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4238 if (key->keyidx > WMI_MAX_KEY_INDEX)
4241 mutex_lock(&ar->conf_mutex);
4244 peer_addr = sta->addr;
4245 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4246 peer_addr = vif->bss_conf.bssid;
4248 peer_addr = vif->addr;
4250 key->hw_key_idx = key->keyidx;
4252 /* the peer should not disappear in mid-way (unless FW goes awry) since
4253 * we already hold conf_mutex. we just make sure its there now.
4255 spin_lock_bh(&ab->base_lock);
4256 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4258 /* flush the fragments cache during key (re)install to
4259 * ensure all frags in the new frag list belong to the same key.
4261 if (peer && sta && cmd == SET_KEY)
4262 ath11k_peer_frags_flush(ar, peer);
4263 spin_unlock_bh(&ab->base_lock);
4266 if (cmd == SET_KEY) {
4267 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
4272 /* if the peer doesn't exist there is no key to disable
4279 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4280 flags |= WMI_KEY_PAIRWISE;
4282 flags |= WMI_KEY_GROUP;
4284 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
4286 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
4290 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
4292 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
4296 spin_lock_bh(&ab->base_lock);
4297 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4298 if (peer && cmd == SET_KEY) {
4299 peer->keys[key->keyidx] = key;
4300 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
4301 peer->ucast_keyidx = key->keyidx;
4302 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
4304 peer->mcast_keyidx = key->keyidx;
4305 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
4307 } else if (peer && cmd == DISABLE_KEY) {
4308 peer->keys[key->keyidx] = NULL;
4309 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4310 peer->ucast_keyidx = 0;
4312 peer->mcast_keyidx = 0;
4314 /* impossible unless FW goes crazy */
4315 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
4318 arsta = ath11k_sta_to_arsta(sta);
4320 switch (key->cipher) {
4321 case WLAN_CIPHER_SUITE_TKIP:
4322 case WLAN_CIPHER_SUITE_CCMP:
4323 case WLAN_CIPHER_SUITE_CCMP_256:
4324 case WLAN_CIPHER_SUITE_GCMP:
4325 case WLAN_CIPHER_SUITE_GCMP_256:
4327 arsta->pn_type = HAL_PN_TYPE_WPA;
4329 arsta->pn_type = HAL_PN_TYPE_NONE;
4332 arsta->pn_type = HAL_PN_TYPE_NONE;
4337 spin_unlock_bh(&ab->base_lock);
4340 mutex_unlock(&ar->conf_mutex);
4345 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
4346 enum nl80211_band band,
4347 const struct cfg80211_bitrate_mask *mask)
4352 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
4353 num_rates += hweight8(mask->control[band].ht_mcs[i]);
4359 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
4360 enum nl80211_band band,
4361 const struct cfg80211_bitrate_mask *mask)
4366 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
4367 num_rates += hweight16(mask->control[band].vht_mcs[i]);
4373 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
4374 enum nl80211_band band,
4375 const struct cfg80211_bitrate_mask *mask)
4380 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
4381 num_rates += hweight16(mask->control[band].he_mcs[i]);
4387 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
4388 struct ieee80211_sta *sta,
4389 const struct cfg80211_bitrate_mask *mask,
4390 enum nl80211_band band)
4392 struct ath11k *ar = arvif->ar;
4397 lockdep_assert_held(&ar->conf_mutex);
4401 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
4402 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
4404 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4409 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
4414 /* Avoid updating invalid nss as fixed rate*/
4415 if (nss > sta->deflink.rx_nss)
4418 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4419 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4422 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4423 WMI_RATE_PREAMBLE_VHT);
4424 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4426 WMI_PEER_PARAM_FIXED_RATE,
4430 "failed to update STA %pM Fixed Rate %d: %d\n",
4431 sta->addr, rate_code, ret);
4437 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4438 struct ieee80211_sta *sta,
4439 const struct cfg80211_bitrate_mask *mask,
4440 enum nl80211_band band)
4442 struct ath11k *ar = arvif->ar;
4447 lockdep_assert_held(&ar->conf_mutex);
4451 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4452 if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4454 he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4459 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4464 /* Avoid updating invalid nss as fixed rate */
4465 if (nss > sta->deflink.rx_nss)
4468 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4469 "setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4472 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4473 WMI_RATE_PREAMBLE_HE);
4475 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4477 WMI_PEER_PARAM_FIXED_RATE,
4481 "failed to update sta %pM fixed rate %d: %d\n",
4482 sta->addr, rate_code, ret);
4488 ath11k_mac_set_peer_ht_fixed_rate(struct ath11k_vif *arvif,
4489 struct ieee80211_sta *sta,
4490 const struct cfg80211_bitrate_mask *mask,
4491 enum nl80211_band band)
4493 struct ath11k *ar = arvif->ar;
4494 u8 ht_rate, nss = 0;
4498 lockdep_assert_held(&ar->conf_mutex);
4500 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
4501 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
4503 ht_rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4508 ath11k_warn(ar->ab, "No single HT Fixed rate found to set for %pM",
4513 /* Avoid updating invalid nss as fixed rate*/
4514 if (nss > sta->deflink.rx_nss)
4517 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4518 "Setting Fixed HT Rate for peer %pM. Device will not switch to any other selected rates",
4521 rate_code = ATH11K_HW_RATE_CODE(ht_rate, nss - 1,
4522 WMI_RATE_PREAMBLE_HT);
4523 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4525 WMI_PEER_PARAM_FIXED_RATE,
4529 "failed to update STA %pM HT Fixed Rate %d: %d\n",
4530 sta->addr, rate_code, ret);
4535 static int ath11k_station_assoc(struct ath11k *ar,
4536 struct ieee80211_vif *vif,
4537 struct ieee80211_sta *sta,
4540 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4541 struct peer_assoc_params peer_arg;
4543 struct cfg80211_chan_def def;
4544 enum nl80211_band band;
4545 struct cfg80211_bitrate_mask *mask;
4546 u8 num_ht_rates, num_vht_rates, num_he_rates;
4548 lockdep_assert_held(&ar->conf_mutex);
4550 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4553 band = def.chan->band;
4554 mask = &arvif->bitrate_mask;
4556 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4558 peer_arg.is_assoc = true;
4559 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4561 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4562 sta->addr, arvif->vdev_id, ret);
4566 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4567 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4568 sta->addr, arvif->vdev_id);
4572 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
4573 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
4574 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask);
4576 /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4577 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
4579 * Note that all other rates and NSS will be disabled for this peer.
4581 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4582 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4586 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4587 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4591 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4592 ret = ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4598 /* Re-assoc is run only to update supported rates for given station. It
4599 * doesn't make much sense to reconfigure the peer completely.
4604 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
4605 &sta->deflink.ht_cap,
4606 le16_to_cpu(sta->deflink.he_6ghz_capa.capa));
4608 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4609 arvif->vdev_id, ret);
4614 arvif->num_legacy_stations++;
4615 ret = ath11k_recalc_rtscts_prot(arvif);
4620 if (sta->wme && sta->uapsd_queues) {
4621 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4623 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4624 sta->addr, arvif->vdev_id, ret);
4632 static int ath11k_station_disassoc(struct ath11k *ar,
4633 struct ieee80211_vif *vif,
4634 struct ieee80211_sta *sta)
4636 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4639 lockdep_assert_held(&ar->conf_mutex);
4642 arvif->num_legacy_stations--;
4643 ret = ath11k_recalc_rtscts_prot(arvif);
4648 ret = ath11k_clear_peer_keys(arvif, sta->addr);
4650 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4651 arvif->vdev_id, ret);
4657 static u32 ath11k_mac_max_nss(const u8 *ht_mcs_mask, const u16 *vht_mcs_mask,
4658 const u16 *he_mcs_mask)
4660 return max3(ath11k_mac_max_ht_nss(ht_mcs_mask),
4661 ath11k_mac_max_vht_nss(vht_mcs_mask),
4662 ath11k_mac_max_he_nss(he_mcs_mask));
4665 static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4668 struct ath11k_vif *arvif;
4669 struct ath11k_sta *arsta;
4670 struct ieee80211_sta *sta;
4671 struct cfg80211_chan_def def;
4672 enum nl80211_band band;
4673 const u8 *ht_mcs_mask;
4674 const u16 *vht_mcs_mask;
4675 const u16 *he_mcs_mask;
4676 u32 changed, bw, nss, smps, bw_prev;
4677 int err, num_ht_rates, num_vht_rates, num_he_rates;
4678 const struct cfg80211_bitrate_mask *mask;
4679 struct peer_assoc_params peer_arg;
4680 enum wmi_phy_mode peer_phymode;
4682 arsta = container_of(wk, struct ath11k_sta, update_wk);
4683 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4684 arvif = arsta->arvif;
4687 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4690 band = def.chan->band;
4691 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4692 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4693 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
4695 spin_lock_bh(&ar->data_lock);
4697 changed = arsta->changed;
4701 bw_prev = arsta->bw_prev;
4705 spin_unlock_bh(&ar->data_lock);
4707 mutex_lock(&ar->conf_mutex);
4709 nss = max_t(u32, 1, nss);
4710 nss = min(nss, ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
4712 if (changed & IEEE80211_RC_BW_CHANGED) {
4713 /* Get the peer phymode */
4714 ath11k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg);
4715 peer_phymode = peer_arg.peer_phymode;
4717 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM peer bw %d phymode %d\n",
4718 sta->addr, bw, peer_phymode);
4721 /* BW is upgraded. In this case we send WMI_PEER_PHYMODE
4722 * followed by WMI_PEER_CHWIDTH
4724 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW upgrade for sta %pM new BW %d, old BW %d\n",
4725 sta->addr, bw, bw_prev);
4727 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4728 WMI_PEER_PHYMODE, peer_phymode);
4731 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4732 sta->addr, peer_phymode, err);
4733 goto err_rc_bw_changed;
4736 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4737 WMI_PEER_CHWIDTH, bw);
4740 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4741 sta->addr, bw, err);
4743 /* BW is downgraded. In this case we send WMI_PEER_CHWIDTH
4744 * followed by WMI_PEER_PHYMODE
4746 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW downgrade for sta %pM new BW %d,old BW %d\n",
4747 sta->addr, bw, bw_prev);
4749 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4750 WMI_PEER_CHWIDTH, bw);
4753 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4754 sta->addr, bw, err);
4755 goto err_rc_bw_changed;
4758 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4759 WMI_PEER_PHYMODE, peer_phymode);
4762 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4763 sta->addr, peer_phymode, err);
4767 if (changed & IEEE80211_RC_NSS_CHANGED) {
4768 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM nss %d\n",
4771 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4774 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4775 sta->addr, nss, err);
4778 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4779 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM smps %d\n",
4782 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4783 WMI_PEER_MIMO_PS_STATE, smps);
4785 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4786 sta->addr, smps, err);
4789 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4790 mask = &arvif->bitrate_mask;
4791 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band,
4793 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4795 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4798 /* Peer_assoc_prepare will reject vht rates in
4799 * bitrate_mask if its not available in range format and
4800 * sets vht tx_rateset as unsupported. So multiple VHT MCS
4801 * setting(eg. MCS 4,5,6) per peer is not supported here.
4802 * But, Single rate in VHT mask can be set as per-peer
4803 * fixed rate. But even if any HT rates are configured in
4804 * the bitrate mask, device will not switch to those rates
4805 * when per-peer Fixed rate is set.
4806 * TODO: Check RATEMASK_CMDID to support auto rates selection
4807 * across HT/VHT and for multiple VHT MCS support.
4809 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4810 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4812 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4813 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4815 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4816 ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4819 /* If the peer is non-VHT/HE or no fixed VHT/HE rate
4820 * is provided in the new bitrate mask we set the
4821 * other rates using peer_assoc command. Also clear
4822 * the peer fixed rate settings as it has higher proprity
4825 err = ath11k_wmi_set_peer_param(ar, sta->addr,
4827 WMI_PEER_PARAM_FIXED_RATE,
4828 WMI_FIXED_RATE_NONE);
4831 "failed to disable peer fixed rate for sta %pM: %d\n",
4834 ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4837 peer_arg.is_assoc = false;
4838 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4840 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4841 sta->addr, arvif->vdev_id, err);
4843 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4844 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4845 sta->addr, arvif->vdev_id);
4850 mutex_unlock(&ar->conf_mutex);
4853 static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4856 struct ath11k_vif *arvif;
4857 struct ath11k_sta *arsta;
4858 struct ieee80211_sta *sta;
4861 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4862 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4863 arvif = arsta->arvif;
4866 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4867 "setting USE_4ADDR for peer %pM\n", sta->addr);
4869 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4871 WMI_PEER_USE_4ADDR, 1);
4874 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4878 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4879 struct ieee80211_sta *sta)
4881 struct ath11k *ar = arvif->ar;
4883 lockdep_assert_held(&ar->conf_mutex);
4885 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4888 if (ar->num_stations >= ar->max_num_stations)
4896 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4897 struct ieee80211_sta *sta)
4899 struct ath11k *ar = arvif->ar;
4901 lockdep_assert_held(&ar->conf_mutex);
4903 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4909 static int ath11k_mac_station_add(struct ath11k *ar,
4910 struct ieee80211_vif *vif,
4911 struct ieee80211_sta *sta)
4913 struct ath11k_base *ab = ar->ab;
4914 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4915 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
4916 struct peer_create_params peer_param;
4919 lockdep_assert_held(&ar->conf_mutex);
4921 ret = ath11k_mac_inc_num_stations(arvif, sta);
4923 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4924 ar->max_num_stations);
4928 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4929 if (!arsta->rx_stats) {
4931 goto dec_num_station;
4934 peer_param.vdev_id = arvif->vdev_id;
4935 peer_param.peer_addr = sta->addr;
4936 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4938 ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4940 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4941 sta->addr, arvif->vdev_id);
4945 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4946 sta->addr, arvif->vdev_id);
4948 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
4949 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4950 if (!arsta->tx_stats) {
4956 if (ieee80211_vif_is_mesh(vif)) {
4957 ath11k_dbg(ab, ATH11K_DBG_MAC,
4958 "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
4959 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4961 WMI_PEER_USE_4ADDR, 1);
4963 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
4969 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4971 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4972 sta->addr, arvif->vdev_id, ret);
4976 if (ab->hw_params.vdev_start_delay &&
4977 !arvif->is_started &&
4978 arvif->vdev_type != WMI_VDEV_TYPE_AP) {
4979 ret = ath11k_start_vdev_delay(ar->hw, vif);
4981 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4986 ewma_avg_rssi_init(&arsta->avg_rssi);
4990 kfree(arsta->tx_stats);
4991 arsta->tx_stats = NULL;
4993 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4995 kfree(arsta->rx_stats);
4996 arsta->rx_stats = NULL;
4998 ath11k_mac_dec_num_stations(arvif, sta);
5003 static u32 ath11k_mac_ieee80211_sta_bw_to_wmi(struct ath11k *ar,
5004 struct ieee80211_sta *sta)
5006 u32 bw = WMI_PEER_CHWIDTH_20MHZ;
5008 switch (sta->deflink.bandwidth) {
5009 case IEEE80211_STA_RX_BW_20:
5010 bw = WMI_PEER_CHWIDTH_20MHZ;
5012 case IEEE80211_STA_RX_BW_40:
5013 bw = WMI_PEER_CHWIDTH_40MHZ;
5015 case IEEE80211_STA_RX_BW_80:
5016 bw = WMI_PEER_CHWIDTH_80MHZ;
5018 case IEEE80211_STA_RX_BW_160:
5019 bw = WMI_PEER_CHWIDTH_160MHZ;
5022 ath11k_warn(ar->ab, "Invalid bandwidth %d for %pM\n",
5023 sta->deflink.bandwidth, sta->addr);
5024 bw = WMI_PEER_CHWIDTH_20MHZ;
5031 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
5032 struct ieee80211_vif *vif,
5033 struct ieee80211_sta *sta,
5034 enum ieee80211_sta_state old_state,
5035 enum ieee80211_sta_state new_state)
5037 struct ath11k *ar = hw->priv;
5038 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5039 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5040 struct ath11k_peer *peer;
5043 /* cancel must be done outside the mutex to avoid deadlock */
5044 if ((old_state == IEEE80211_STA_NONE &&
5045 new_state == IEEE80211_STA_NOTEXIST)) {
5046 cancel_work_sync(&arsta->update_wk);
5047 cancel_work_sync(&arsta->set_4addr_wk);
5050 mutex_lock(&ar->conf_mutex);
5052 if (old_state == IEEE80211_STA_NOTEXIST &&
5053 new_state == IEEE80211_STA_NONE) {
5054 memset(arsta, 0, sizeof(*arsta));
5055 arsta->arvif = arvif;
5056 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
5057 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
5058 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
5060 ret = ath11k_mac_station_add(ar, vif, sta);
5062 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
5063 sta->addr, arvif->vdev_id);
5064 } else if ((old_state == IEEE80211_STA_NONE &&
5065 new_state == IEEE80211_STA_NOTEXIST)) {
5066 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
5067 vif->type == NL80211_IFTYPE_STATION;
5069 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
5071 if (!skip_peer_delete) {
5072 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
5075 "Failed to delete peer: %pM for VDEV: %d\n",
5076 sta->addr, arvif->vdev_id);
5080 "Removed peer: %pM for VDEV: %d\n",
5081 sta->addr, arvif->vdev_id);
5084 ath11k_mac_dec_num_stations(arvif, sta);
5085 mutex_lock(&ar->ab->tbl_mtx_lock);
5086 spin_lock_bh(&ar->ab->base_lock);
5087 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5088 if (skip_peer_delete && peer) {
5090 } else if (peer && peer->sta == sta) {
5091 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
5092 vif->addr, arvif->vdev_id);
5093 ath11k_peer_rhash_delete(ar->ab, peer);
5095 list_del(&peer->list);
5099 spin_unlock_bh(&ar->ab->base_lock);
5100 mutex_unlock(&ar->ab->tbl_mtx_lock);
5102 kfree(arsta->tx_stats);
5103 arsta->tx_stats = NULL;
5105 kfree(arsta->rx_stats);
5106 arsta->rx_stats = NULL;
5107 } else if (old_state == IEEE80211_STA_AUTH &&
5108 new_state == IEEE80211_STA_ASSOC &&
5109 (vif->type == NL80211_IFTYPE_AP ||
5110 vif->type == NL80211_IFTYPE_MESH_POINT ||
5111 vif->type == NL80211_IFTYPE_ADHOC)) {
5112 ret = ath11k_station_assoc(ar, vif, sta, false);
5114 ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
5117 spin_lock_bh(&ar->data_lock);
5118 /* Set arsta bw and prev bw */
5119 arsta->bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5120 arsta->bw_prev = arsta->bw;
5121 spin_unlock_bh(&ar->data_lock);
5122 } else if (old_state == IEEE80211_STA_ASSOC &&
5123 new_state == IEEE80211_STA_AUTHORIZED) {
5124 spin_lock_bh(&ar->ab->base_lock);
5126 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5128 peer->is_authorized = true;
5130 spin_unlock_bh(&ar->ab->base_lock);
5132 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
5133 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
5138 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
5139 sta->addr, arvif->vdev_id, ret);
5141 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
5142 new_state == IEEE80211_STA_ASSOC) {
5143 spin_lock_bh(&ar->ab->base_lock);
5145 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5147 peer->is_authorized = false;
5149 spin_unlock_bh(&ar->ab->base_lock);
5150 } else if (old_state == IEEE80211_STA_ASSOC &&
5151 new_state == IEEE80211_STA_AUTH &&
5152 (vif->type == NL80211_IFTYPE_AP ||
5153 vif->type == NL80211_IFTYPE_MESH_POINT ||
5154 vif->type == NL80211_IFTYPE_ADHOC)) {
5155 ret = ath11k_station_disassoc(ar, vif, sta);
5157 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
5161 mutex_unlock(&ar->conf_mutex);
5165 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
5166 struct ieee80211_vif *vif,
5167 struct ieee80211_sta *sta)
5169 struct ath11k *ar = hw->priv;
5170 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5174 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
5177 txpwr = sta->deflink.txpwr.power;
5182 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
5185 mutex_lock(&ar->conf_mutex);
5187 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
5188 WMI_PEER_USE_FIXED_PWR, txpwr);
5190 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
5196 mutex_unlock(&ar->conf_mutex);
5200 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
5201 struct ieee80211_vif *vif,
5202 struct ieee80211_sta *sta, bool enabled)
5204 struct ath11k *ar = hw->priv;
5205 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5207 if (enabled && !arsta->use_4addr_set) {
5208 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
5209 arsta->use_4addr_set = true;
5213 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
5214 struct ieee80211_vif *vif,
5215 struct ieee80211_sta *sta,
5218 struct ath11k *ar = hw->priv;
5219 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5220 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5221 struct ath11k_peer *peer;
5224 spin_lock_bh(&ar->ab->base_lock);
5226 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5228 spin_unlock_bh(&ar->ab->base_lock);
5229 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
5230 sta->addr, arvif->vdev_id);
5234 spin_unlock_bh(&ar->ab->base_lock);
5236 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5237 "sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
5238 sta->addr, changed, sta->deflink.bandwidth,
5239 sta->deflink.rx_nss,
5240 sta->deflink.smps_mode);
5242 spin_lock_bh(&ar->data_lock);
5244 if (changed & IEEE80211_RC_BW_CHANGED) {
5245 bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5246 arsta->bw_prev = arsta->bw;
5250 if (changed & IEEE80211_RC_NSS_CHANGED)
5251 arsta->nss = sta->deflink.rx_nss;
5253 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5254 smps = WMI_PEER_SMPS_PS_NONE;
5256 switch (sta->deflink.smps_mode) {
5257 case IEEE80211_SMPS_AUTOMATIC:
5258 case IEEE80211_SMPS_OFF:
5259 smps = WMI_PEER_SMPS_PS_NONE;
5261 case IEEE80211_SMPS_STATIC:
5262 smps = WMI_PEER_SMPS_STATIC;
5264 case IEEE80211_SMPS_DYNAMIC:
5265 smps = WMI_PEER_SMPS_DYNAMIC;
5268 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
5269 sta->deflink.smps_mode, sta->addr);
5270 smps = WMI_PEER_SMPS_PS_NONE;
5277 arsta->changed |= changed;
5279 spin_unlock_bh(&ar->data_lock);
5281 ieee80211_queue_work(hw, &arsta->update_wk);
5284 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
5285 u16 ac, bool enable)
5287 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5291 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5295 case IEEE80211_AC_VO:
5296 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5297 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5299 case IEEE80211_AC_VI:
5300 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5301 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5303 case IEEE80211_AC_BE:
5304 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5305 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5307 case IEEE80211_AC_BK:
5308 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5309 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5314 arvif->u.sta.uapsd |= value;
5316 arvif->u.sta.uapsd &= ~value;
5318 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5319 WMI_STA_PS_PARAM_UAPSD,
5320 arvif->u.sta.uapsd);
5322 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
5326 if (arvif->u.sta.uapsd)
5327 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5329 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5331 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5332 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5335 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
5341 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
5342 struct ieee80211_vif *vif,
5343 unsigned int link_id, u16 ac,
5344 const struct ieee80211_tx_queue_params *params)
5346 struct ath11k *ar = hw->priv;
5347 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5348 struct wmi_wmm_params_arg *p = NULL;
5351 mutex_lock(&ar->conf_mutex);
5354 case IEEE80211_AC_VO:
5355 p = &arvif->wmm_params.ac_vo;
5357 case IEEE80211_AC_VI:
5358 p = &arvif->wmm_params.ac_vi;
5360 case IEEE80211_AC_BE:
5361 p = &arvif->wmm_params.ac_be;
5363 case IEEE80211_AC_BK:
5364 p = &arvif->wmm_params.ac_bk;
5373 p->cwmin = params->cw_min;
5374 p->cwmax = params->cw_max;
5375 p->aifs = params->aifs;
5376 p->txop = params->txop;
5378 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
5379 &arvif->wmm_params);
5381 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
5385 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5388 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
5391 mutex_unlock(&ar->conf_mutex);
5395 static struct ieee80211_sta_ht_cap
5396 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
5399 struct ieee80211_sta_ht_cap ht_cap = {0};
5400 u32 ar_vht_cap = ar->pdev->cap.vht_cap;
5402 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
5405 ht_cap.ht_supported = 1;
5406 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5407 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
5408 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5409 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5410 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
5412 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
5413 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5415 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
5416 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5418 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
5421 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
5422 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
5427 if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
5428 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
5430 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
5434 stbc &= WMI_HT_CAP_RX_STBC;
5435 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
5436 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
5437 stbc &= IEEE80211_HT_CAP_RX_STBC;
5442 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
5443 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
5445 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
5446 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
5448 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
5449 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
5451 for (i = 0; i < ar->num_rx_chains; i++) {
5452 if (rate_cap_rx_chainmask & BIT(i))
5453 ht_cap.mcs.rx_mask[i] = 0xFF;
5456 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
5461 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
5464 struct ath11k *ar = arvif->ar;
5467 u32 vht_cap = ar->pdev->cap.vht_cap;
5468 u32 vdev_param = WMI_VDEV_PARAM_TXBF;
5470 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
5471 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5472 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5473 if (nsts > (ar->num_rx_chains - 1))
5474 nsts = ar->num_rx_chains - 1;
5475 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
5478 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
5479 sound_dim = vht_cap &
5480 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5481 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5482 if (sound_dim > (ar->num_tx_chains - 1))
5483 sound_dim = ar->num_tx_chains - 1;
5484 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
5490 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
5491 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
5493 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
5494 arvif->vdev_type == WMI_VDEV_TYPE_AP)
5495 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
5498 /* TODO: SUBFEE not validated in HK, disable here until validated? */
5500 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
5501 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
5503 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
5504 arvif->vdev_type == WMI_VDEV_TYPE_STA)
5505 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
5508 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5512 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
5514 bool subfer, subfee;
5515 int sound_dim = 0, nsts = 0;
5517 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
5518 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5520 if (ar->num_tx_chains < 2) {
5521 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5525 if (ar->num_rx_chains < 2) {
5526 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
5530 /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5532 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5534 /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5536 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5538 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5539 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5540 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5542 nsts = (*vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5543 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5544 *vht_cap &= ~IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5546 /* Enable Sounding Dimension Field only if SU BF is enabled */
5548 if (sound_dim > (ar->num_tx_chains - 1))
5549 sound_dim = ar->num_tx_chains - 1;
5551 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5552 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5553 *vht_cap |= sound_dim;
5556 /* Enable Beamformee STS Field only if SU BF is enabled */
5558 if (nsts > (ar->num_rx_chains - 1))
5559 nsts = ar->num_rx_chains - 1;
5561 nsts <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5562 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5567 static struct ieee80211_sta_vht_cap
5568 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5569 u32 rate_cap_rx_chainmask)
5571 struct ieee80211_sta_vht_cap vht_cap = {0};
5572 u16 txmcs_map, rxmcs_map;
5575 vht_cap.vht_supported = 1;
5576 vht_cap.cap = ar->pdev->cap.vht_cap;
5578 if (ar->pdev->cap.nss_ratio_enabled)
5579 vht_cap.vht_mcs.tx_highest |=
5580 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5582 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5586 for (i = 0; i < 8; i++) {
5587 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5588 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5590 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5592 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5593 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5595 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5598 if (rate_cap_tx_chainmask <= 1)
5599 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5601 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5602 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5607 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5608 struct ath11k_pdev_cap *cap,
5611 struct ieee80211_supported_band *band;
5612 u32 rate_cap_tx_chainmask;
5613 u32 rate_cap_rx_chainmask;
5616 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5617 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5619 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5620 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5621 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5623 *ht_cap_info = ht_cap;
5624 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5625 rate_cap_rx_chainmask);
5628 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5629 (ar->ab->hw_params.single_pdev_only ||
5630 !ar->supports_6ghz)) {
5631 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5632 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5634 *ht_cap_info = ht_cap;
5635 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5636 rate_cap_rx_chainmask);
5637 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5638 rate_cap_rx_chainmask);
5642 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5644 /* TODO: Check the request chainmask against the supported
5645 * chainmask table which is advertised in extented_service_ready event
5651 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5657 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5658 he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5659 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5660 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5661 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5662 for (ru = 0; ru < 4; ru++) {
5666 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5668 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5670 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5671 for (i = 5; i >= 0; i--) {
5673 ((val >> i) & 0x1) << ((bit % 8));
5681 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5685 m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5686 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5687 he_cap_elem->mac_cap_info[0] &= ~m;
5689 m = IEEE80211_HE_MAC_CAP2_TRS |
5690 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5691 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5692 he_cap_elem->mac_cap_info[2] &= ~m;
5694 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5695 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5696 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5697 he_cap_elem->mac_cap_info[3] &= ~m;
5699 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5700 IEEE80211_HE_MAC_CAP4_BQR;
5701 he_cap_elem->mac_cap_info[4] &= ~m;
5703 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5704 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5705 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5706 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5707 he_cap_elem->mac_cap_info[5] &= ~m;
5709 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5710 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5711 he_cap_elem->phy_cap_info[2] &= ~m;
5713 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5714 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5715 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5716 he_cap_elem->phy_cap_info[3] &= ~m;
5718 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5719 he_cap_elem->phy_cap_info[4] &= ~m;
5721 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5722 he_cap_elem->phy_cap_info[5] &= ~m;
5724 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5725 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5726 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5727 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5728 he_cap_elem->phy_cap_info[6] &= ~m;
5730 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5731 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5732 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5733 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5734 he_cap_elem->phy_cap_info[7] &= ~m;
5736 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5737 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5738 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5739 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5740 he_cap_elem->phy_cap_info[8] &= ~m;
5742 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5743 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5744 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5745 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5746 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5747 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5748 he_cap_elem->phy_cap_info[9] &= ~m;
5751 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5752 struct ath11k_band_cap *bcap)
5756 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5757 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5758 bcap->he_6ghz_capa |=
5759 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5760 WLAN_HT_CAP_SM_PS_DYNAMIC);
5762 bcap->he_6ghz_capa |=
5763 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5764 WLAN_HT_CAP_SM_PS_DISABLED);
5765 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5767 bcap->he_6ghz_capa |=
5768 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5769 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5770 bcap->he_6ghz_capa |=
5771 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5772 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5773 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5774 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5775 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5777 return cpu_to_le16(bcap->he_6ghz_capa);
5780 static void ath11k_mac_set_hemcsmap(struct ath11k *ar,
5781 struct ath11k_pdev_cap *cap,
5782 struct ieee80211_sta_he_cap *he_cap,
5785 u16 txmcs_map, rxmcs_map;
5790 for (i = 0; i < 8; i++) {
5791 if (i < ar->num_tx_chains &&
5792 (ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5793 txmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5795 txmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5797 if (i < ar->num_rx_chains &&
5798 (ar->cfg_rx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5799 rxmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5801 rxmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5803 he_cap->he_mcs_nss_supp.rx_mcs_80 =
5804 cpu_to_le16(rxmcs_map & 0xffff);
5805 he_cap->he_mcs_nss_supp.tx_mcs_80 =
5806 cpu_to_le16(txmcs_map & 0xffff);
5807 he_cap->he_mcs_nss_supp.rx_mcs_160 =
5808 cpu_to_le16(rxmcs_map & 0xffff);
5809 he_cap->he_mcs_nss_supp.tx_mcs_160 =
5810 cpu_to_le16(txmcs_map & 0xffff);
5811 he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5812 cpu_to_le16(rxmcs_map & 0xffff);
5813 he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5814 cpu_to_le16(txmcs_map & 0xffff);
5817 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5818 struct ath11k_pdev_cap *cap,
5819 struct ieee80211_sband_iftype_data *data,
5824 for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5825 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5826 struct ath11k_band_cap *band_cap = &cap->band[band];
5827 struct ieee80211_he_cap_elem *he_cap_elem =
5828 &he_cap->he_cap_elem;
5831 case NL80211_IFTYPE_STATION:
5832 case NL80211_IFTYPE_AP:
5833 case NL80211_IFTYPE_MESH_POINT:
5840 data[idx].types_mask = BIT(i);
5841 he_cap->has_he = true;
5842 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5843 sizeof(he_cap_elem->mac_cap_info));
5844 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5845 sizeof(he_cap_elem->phy_cap_info));
5847 he_cap_elem->mac_cap_info[1] &=
5848 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5850 he_cap_elem->phy_cap_info[5] &=
5851 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5852 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5855 case NL80211_IFTYPE_AP:
5856 he_cap_elem->phy_cap_info[3] &=
5857 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5858 he_cap_elem->phy_cap_info[9] |=
5859 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5861 case NL80211_IFTYPE_STATION:
5862 he_cap_elem->mac_cap_info[0] &=
5863 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5864 he_cap_elem->mac_cap_info[0] |=
5865 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5866 he_cap_elem->phy_cap_info[9] |=
5867 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5869 case NL80211_IFTYPE_MESH_POINT:
5870 ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5874 ath11k_mac_set_hemcsmap(ar, cap, he_cap, band);
5876 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5877 if (he_cap_elem->phy_cap_info[6] &
5878 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5879 ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5882 if (band == NL80211_BAND_6GHZ) {
5883 data[idx].he_6ghz_capa.capa =
5884 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5892 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5893 struct ath11k_pdev_cap *cap)
5895 struct ieee80211_supported_band *band;
5898 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5899 count = ath11k_mac_copy_he_cap(ar, cap,
5900 ar->mac.iftype[NL80211_BAND_2GHZ],
5902 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5903 _ieee80211_set_sband_iftype_data(band,
5904 ar->mac.iftype[NL80211_BAND_2GHZ],
5908 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5909 count = ath11k_mac_copy_he_cap(ar, cap,
5910 ar->mac.iftype[NL80211_BAND_5GHZ],
5912 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5913 _ieee80211_set_sband_iftype_data(band,
5914 ar->mac.iftype[NL80211_BAND_5GHZ],
5918 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5919 ar->supports_6ghz) {
5920 count = ath11k_mac_copy_he_cap(ar, cap,
5921 ar->mac.iftype[NL80211_BAND_6GHZ],
5923 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5924 _ieee80211_set_sband_iftype_data(band,
5925 ar->mac.iftype[NL80211_BAND_6GHZ],
5930 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5934 lockdep_assert_held(&ar->conf_mutex);
5936 if (ath11k_check_chain_mask(ar, tx_ant, true))
5939 if (ath11k_check_chain_mask(ar, rx_ant, false))
5942 ar->cfg_tx_chainmask = tx_ant;
5943 ar->cfg_rx_chainmask = rx_ant;
5945 if (ar->state != ATH11K_STATE_ON &&
5946 ar->state != ATH11K_STATE_RESTARTED)
5949 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5950 tx_ant, ar->pdev->pdev_id);
5952 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5957 ar->num_tx_chains = get_num_chains(tx_ant);
5959 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5960 rx_ant, ar->pdev->pdev_id);
5962 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5967 ar->num_rx_chains = get_num_chains(rx_ant);
5969 /* Reload HT/VHT/HE capability */
5970 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5971 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5976 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5980 ieee80211_free_txskb(ar->hw, skb);
5982 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5988 wake_up(&ar->txmgmt_empty_waitq);
5991 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5993 struct sk_buff *msdu;
5994 struct ieee80211_tx_info *info;
5996 spin_lock_bh(&ar->txmgmt_idr_lock);
5997 msdu = idr_remove(&ar->txmgmt_idr, buf_id);
5998 spin_unlock_bh(&ar->txmgmt_idr_lock);
6003 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
6006 info = IEEE80211_SKB_CB(msdu);
6007 memset(&info->status, 0, sizeof(info->status));
6009 ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
6012 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
6014 struct ath11k *ar = ctx;
6016 ath11k_mac_tx_mgmt_free(ar, buf_id);
6021 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
6023 struct ieee80211_vif *vif = ctx;
6024 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6025 struct ath11k *ar = skb_cb->ar;
6027 if (skb_cb->vif == vif)
6028 ath11k_mac_tx_mgmt_free(ar, buf_id);
6033 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
6034 struct sk_buff *skb)
6036 struct ath11k_base *ab = ar->ab;
6037 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6038 struct ieee80211_tx_info *info;
6043 ATH11K_SKB_CB(skb)->ar = ar;
6045 spin_lock_bh(&ar->txmgmt_idr_lock);
6046 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
6047 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
6048 spin_unlock_bh(&ar->txmgmt_idr_lock);
6050 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6051 "tx mgmt frame, buf id %d\n", buf_id);
6056 info = IEEE80211_SKB_CB(skb);
6057 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
6058 if ((ieee80211_is_action(hdr->frame_control) ||
6059 ieee80211_is_deauth(hdr->frame_control) ||
6060 ieee80211_is_disassoc(hdr->frame_control)) &&
6061 ieee80211_has_protected(hdr->frame_control)) {
6062 skb_put(skb, IEEE80211_CCMP_MIC_LEN);
6066 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
6067 if (dma_mapping_error(ab->dev, paddr)) {
6068 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
6073 ATH11K_SKB_CB(skb)->paddr = paddr;
6075 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
6077 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
6084 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
6085 skb->len, DMA_TO_DEVICE);
6087 spin_lock_bh(&ar->txmgmt_idr_lock);
6088 idr_remove(&ar->txmgmt_idr, buf_id);
6089 spin_unlock_bh(&ar->txmgmt_idr_lock);
6094 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
6096 struct sk_buff *skb;
6098 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
6099 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6102 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
6104 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
6105 struct ath11k_skb_cb *skb_cb;
6106 struct ath11k_vif *arvif;
6107 struct sk_buff *skb;
6110 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
6111 skb_cb = ATH11K_SKB_CB(skb);
6113 ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
6114 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6118 arvif = ath11k_vif_to_arvif(skb_cb->vif);
6119 mutex_lock(&ar->conf_mutex);
6120 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
6121 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
6123 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
6124 arvif->vdev_id, ret);
6125 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6127 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6128 "tx mgmt frame, vdev_id %d\n",
6133 "dropping mgmt frame for vdev %d, is_started %d\n",
6136 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6138 mutex_unlock(&ar->conf_mutex);
6142 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
6145 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
6147 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
6150 /* Drop probe response packets when the pending management tx
6151 * count has reached a certain threshold, so as to prioritize
6152 * other mgmt packets like auth and assoc to be sent on time
6153 * for establishing successful connections.
6156 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
6158 "dropping probe response as pending queue is almost full\n");
6162 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
6163 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
6167 skb_queue_tail(q, skb);
6168 atomic_inc(&ar->num_pending_mgmt_tx);
6169 queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
6174 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
6175 struct ieee80211_tx_control *control,
6176 struct sk_buff *skb)
6178 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6179 struct ath11k *ar = hw->priv;
6180 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
6181 struct ieee80211_vif *vif = info->control.vif;
6182 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6183 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6184 struct ieee80211_key_conf *key = info->control.hw_key;
6185 struct ath11k_sta *arsta = NULL;
6186 u32 info_flags = info->flags;
6190 memset(skb_cb, 0, sizeof(*skb_cb));
6194 skb_cb->cipher = key->cipher;
6195 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
6198 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
6199 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
6200 } else if (ieee80211_is_mgmt(hdr->frame_control)) {
6201 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
6202 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
6204 ath11k_warn(ar->ab, "failed to queue management frame %d\n",
6206 ieee80211_free_txskb(ar->hw, skb);
6212 arsta = ath11k_sta_to_arsta(control->sta);
6214 ret = ath11k_dp_tx(ar, arvif, arsta, skb);
6215 if (unlikely(ret)) {
6216 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
6217 ieee80211_free_txskb(ar->hw, skb);
6221 void ath11k_mac_drain_tx(struct ath11k *ar)
6223 /* make sure rcu-protected mac80211 tx path itself is drained */
6226 cancel_work_sync(&ar->wmi_mgmt_tx_work);
6227 ath11k_mgmt_over_wmi_tx_purge(ar);
6230 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
6232 struct htt_rx_ring_tlv_filter tlv_filter = {0};
6233 struct ath11k_base *ab = ar->ab;
6238 tlv_filter = ath11k_mac_mon_status_filter_default;
6239 if (ath11k_debugfs_rx_filter(ar))
6240 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
6243 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
6244 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
6245 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
6247 HAL_RXDMA_MONITOR_STATUS,
6252 if (enable && !ar->ab->hw_params.rxdma1_enable)
6253 mod_timer(&ar->ab->mon_reap_timer, jiffies +
6254 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
6259 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
6261 int recovery_start_count;
6266 recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
6267 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
6269 if (recovery_start_count == ab->num_radios) {
6270 complete(&ab->recovery_start);
6271 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
6274 ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
6276 wait_for_completion_timeout(&ab->reconfigure_complete,
6277 ATH11K_RECONFIGURE_TIMEOUT_HZ);
6280 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
6282 struct ath11k *ar = hw->priv;
6283 struct ath11k_base *ab = ar->ab;
6284 struct ath11k_pdev *pdev = ar->pdev;
6287 if (ath11k_ftm_mode) {
6288 ath11k_warn(ab, "mac operations not supported in factory test mode\n");
6292 ath11k_mac_drain_tx(ar);
6293 mutex_lock(&ar->conf_mutex);
6295 switch (ar->state) {
6296 case ATH11K_STATE_OFF:
6297 ar->state = ATH11K_STATE_ON;
6299 case ATH11K_STATE_RESTARTING:
6300 ar->state = ATH11K_STATE_RESTARTED;
6301 ath11k_mac_wait_reconfigure(ab);
6303 case ATH11K_STATE_RESTARTED:
6304 case ATH11K_STATE_WEDGED:
6305 case ATH11K_STATE_ON:
6306 case ATH11K_STATE_FTM:
6312 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
6316 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
6320 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
6323 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
6327 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
6328 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
6330 ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
6335 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
6338 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
6343 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
6345 ath11k_err(ab, "failed to offload radar detection: %d\n",
6350 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
6351 HTT_PPDU_STATS_TAG_DEFAULT);
6353 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
6357 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
6361 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
6365 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
6367 /* TODO: Do we need to enable ANI? */
6369 ath11k_reg_update_chan_list(ar, false);
6371 ar->num_started_vdevs = 0;
6372 ar->num_created_vdevs = 0;
6374 ar->allocated_vdev_map = 0;
6376 /* Configure monitor status ring with default rx_filter to get rx status
6377 * such as rssi, rx_duration.
6379 ret = ath11k_mac_config_mon_status_default(ar, true);
6381 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
6386 /* Configure the hash seed for hash based reo dest ring selection */
6387 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
6389 /* allow device to enter IMPS */
6390 if (ab->hw_params.idle_ps) {
6391 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
6394 ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
6399 mutex_unlock(&ar->conf_mutex);
6401 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
6402 &ab->pdevs[ar->pdev_idx]);
6407 ar->state = ATH11K_STATE_OFF;
6408 mutex_unlock(&ar->conf_mutex);
6413 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
6415 struct ath11k *ar = hw->priv;
6416 struct htt_ppdu_stats_info *ppdu_stats, *tmp;
6419 ath11k_mac_drain_tx(ar);
6421 mutex_lock(&ar->conf_mutex);
6422 ret = ath11k_mac_config_mon_status_default(ar, false);
6424 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
6427 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6428 ar->state = ATH11K_STATE_OFF;
6429 mutex_unlock(&ar->conf_mutex);
6431 cancel_delayed_work_sync(&ar->scan.timeout);
6432 cancel_work_sync(&ar->regd_update_work);
6433 cancel_work_sync(&ar->ab->update_11d_work);
6435 if (ar->state_11d == ATH11K_11D_PREPARING) {
6436 ar->state_11d = ATH11K_11D_IDLE;
6437 complete(&ar->completed_11d_scan);
6440 spin_lock_bh(&ar->data_lock);
6441 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
6442 list_del(&ppdu_stats->list);
6445 spin_unlock_bh(&ar->data_lock);
6447 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
6451 atomic_set(&ar->num_pending_mgmt_tx, 0);
6454 static int ath11k_mac_setup_vdev_params_mbssid(struct ath11k_vif *arvif,
6455 u32 *flags, u32 *tx_vdev_id)
6457 struct ath11k *ar = arvif->ar;
6458 struct ath11k_vif *tx_arvif;
6459 struct ieee80211_vif *tx_vif;
6462 tx_vif = arvif->vif->mbssid_tx_vif;
6464 *flags = WMI_HOST_VDEV_FLAGS_NON_MBSSID_AP;
6468 tx_arvif = ath11k_vif_to_arvif(tx_vif);
6470 if (arvif->vif->bss_conf.nontransmitted) {
6471 if (ar->hw->wiphy != ieee80211_vif_to_wdev(tx_vif)->wiphy)
6474 *flags = WMI_HOST_VDEV_FLAGS_NON_TRANSMIT_AP;
6475 *tx_vdev_id = ath11k_vif_to_arvif(tx_vif)->vdev_id;
6476 } else if (tx_arvif == arvif) {
6477 *flags = WMI_HOST_VDEV_FLAGS_TRANSMIT_AP;
6482 if (arvif->vif->bss_conf.ema_ap)
6483 *flags |= WMI_HOST_VDEV_FLAGS_EMA_MODE;
6488 static int ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
6489 struct vdev_create_params *params)
6491 struct ath11k *ar = arvif->ar;
6492 struct ath11k_pdev *pdev = ar->pdev;
6495 params->if_id = arvif->vdev_id;
6496 params->type = arvif->vdev_type;
6497 params->subtype = arvif->vdev_subtype;
6498 params->pdev_id = pdev->pdev_id;
6499 params->mbssid_flags = 0;
6500 params->mbssid_tx_vdev_id = 0;
6502 if (!test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
6503 ar->ab->wmi_ab.svc_map)) {
6504 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
6505 ¶ms->mbssid_flags,
6506 ¶ms->mbssid_tx_vdev_id);
6511 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
6512 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
6513 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
6515 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
6516 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
6517 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
6519 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
6520 ar->supports_6ghz) {
6521 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
6522 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
6527 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
6528 struct ieee80211_vif *vif)
6530 struct ath11k *ar = hw->priv;
6531 struct ath11k_base *ab = ar->ab;
6532 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6533 u32 param_id, param_value;
6536 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
6537 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
6538 (vif->type != NL80211_IFTYPE_STATION &&
6539 vif->type != NL80211_IFTYPE_AP))
6540 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
6541 IEEE80211_OFFLOAD_DECAP_ENABLED);
6543 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
6544 param_value = ATH11K_HW_TXRX_ETHERNET;
6545 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6546 param_value = ATH11K_HW_TXRX_RAW;
6548 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6550 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6551 param_id, param_value);
6553 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6554 arvif->vdev_id, ret);
6555 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6558 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6559 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6560 param_value = ATH11K_HW_TXRX_ETHERNET;
6561 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6562 param_value = ATH11K_HW_TXRX_RAW;
6564 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6566 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6567 param_id, param_value);
6569 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6570 arvif->vdev_id, ret);
6571 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6575 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6578 struct ath11k_pdev *pdev;
6579 struct ath11k_vif *arvif;
6582 for (i = 0; i < ab->num_radios; i++) {
6583 pdev = &ab->pdevs[i];
6585 list_for_each_entry(arvif, &ar->arvifs, list) {
6586 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6593 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6595 struct wmi_11d_scan_start_params param;
6598 mutex_lock(&ar->ab->vdev_id_11d_lock);
6600 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev id for 11d scan %d\n",
6601 ar->vdev_id_11d_scan);
6603 if (ar->regdom_set_by_user)
6606 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6609 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6612 if (ath11k_mac_vif_ap_active_any(ar->ab))
6615 param.vdev_id = vdev_id;
6616 param.start_interval_msec = 0;
6617 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6619 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "start 11d scan\n");
6621 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, ¶m);
6623 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6626 ar->vdev_id_11d_scan = vdev_id;
6627 if (ar->state_11d == ATH11K_11D_PREPARING)
6628 ar->state_11d = ATH11K_11D_RUNNING;
6632 if (ar->state_11d == ATH11K_11D_PREPARING) {
6633 ar->state_11d = ATH11K_11D_IDLE;
6634 complete(&ar->completed_11d_scan);
6637 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6640 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6645 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6648 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d scan\n");
6650 mutex_lock(&ar->ab->vdev_id_11d_lock);
6652 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d vdev id %d\n",
6653 ar->vdev_id_11d_scan);
6655 if (ar->state_11d == ATH11K_11D_PREPARING) {
6656 ar->state_11d = ATH11K_11D_IDLE;
6657 complete(&ar->completed_11d_scan);
6660 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6661 vdev_id = ar->vdev_id_11d_scan;
6663 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6666 "failed to stopt 11d scan vdev %d ret: %d\n",
6669 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6670 ar->state_11d = ATH11K_11D_IDLE;
6671 complete(&ar->completed_11d_scan);
6674 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6677 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6680 struct ath11k_pdev *pdev;
6683 ath11k_dbg(ab, ATH11K_DBG_MAC, "stop soc 11d scan\n");
6685 for (i = 0; i < ab->num_radios; i++) {
6686 pdev = &ab->pdevs[i];
6689 ath11k_mac_11d_scan_stop(ar);
6693 static int ath11k_mac_vdev_delete(struct ath11k *ar, struct ath11k_vif *arvif)
6695 unsigned long time_left;
6696 struct ieee80211_vif *vif = arvif->vif;
6699 lockdep_assert_held(&ar->conf_mutex);
6701 reinit_completion(&ar->vdev_delete_done);
6703 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6705 ath11k_warn(ar->ab, "failed to delete WMI vdev %d: %d\n",
6706 arvif->vdev_id, ret);
6710 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6711 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6712 if (time_left == 0) {
6713 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
6717 ar->ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6718 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6719 ar->num_created_vdevs--;
6721 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6722 vif->addr, arvif->vdev_id);
6727 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6728 struct ieee80211_vif *vif)
6730 struct ath11k *ar = hw->priv;
6731 struct ath11k_base *ab = ar->ab;
6732 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6733 struct vdev_create_params vdev_param = {0};
6734 struct peer_create_params peer_param;
6735 u32 param_id, param_value;
6741 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6743 mutex_lock(&ar->conf_mutex);
6745 if (vif->type == NL80211_IFTYPE_AP &&
6746 ar->num_peers > (ar->max_num_peers - 1)) {
6747 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6752 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6753 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6754 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6759 /* In the case of hardware recovery, debugfs files are
6760 * not deleted since ieee80211_ops.remove_interface() is
6761 * not invoked. In such cases, try to delete the files.
6762 * These will be re-created later.
6764 ath11k_debugfs_remove_interface(arvif);
6766 memset(arvif, 0, sizeof(*arvif));
6771 INIT_LIST_HEAD(&arvif->list);
6772 INIT_DELAYED_WORK(&arvif->connection_loss_work,
6773 ath11k_mac_vif_sta_connection_loss_work);
6775 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6776 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6777 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6778 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6779 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6780 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6781 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6782 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6783 sizeof(arvif->bitrate_mask.control[i].he_mcs));
6786 bit = __ffs64(ab->free_vdev_map);
6788 arvif->vdev_id = bit;
6789 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6791 switch (vif->type) {
6792 case NL80211_IFTYPE_UNSPECIFIED:
6793 case NL80211_IFTYPE_STATION:
6794 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6796 case NL80211_IFTYPE_MESH_POINT:
6797 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6799 case NL80211_IFTYPE_AP:
6800 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6802 case NL80211_IFTYPE_MONITOR:
6803 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6804 ar->monitor_vdev_id = bit;
6811 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "add interface id %d type %d subtype %d map %llx\n",
6812 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6815 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6816 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6817 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6819 ret = ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6821 ath11k_warn(ab, "failed to create vdev parameters %d: %d\n",
6822 arvif->vdev_id, ret);
6826 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6828 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6829 arvif->vdev_id, ret);
6833 ar->num_created_vdevs++;
6834 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6835 vif->addr, arvif->vdev_id);
6836 ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6837 ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6839 spin_lock_bh(&ar->data_lock);
6840 list_add(&arvif->list, &ar->arvifs);
6841 spin_unlock_bh(&ar->data_lock);
6843 ath11k_mac_op_update_vif_offload(hw, vif);
6845 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6846 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6847 WMI_VDEV_PARAM_NSS, nss);
6849 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6850 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6854 switch (arvif->vdev_type) {
6855 case WMI_VDEV_TYPE_AP:
6856 peer_param.vdev_id = arvif->vdev_id;
6857 peer_param.peer_addr = vif->addr;
6858 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6859 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6861 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6862 arvif->vdev_id, ret);
6866 ret = ath11k_mac_set_kickout(arvif);
6868 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6869 arvif->vdev_id, ret);
6873 ath11k_mac_11d_scan_stop_all(ar->ab);
6875 case WMI_VDEV_TYPE_STA:
6876 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6877 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6878 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6879 param_id, param_value);
6881 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6882 arvif->vdev_id, ret);
6886 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6887 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6888 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6889 param_id, param_value);
6891 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6892 arvif->vdev_id, ret);
6896 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6897 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6898 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6899 param_id, param_value);
6901 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6902 arvif->vdev_id, ret);
6906 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6907 WMI_STA_PS_MODE_DISABLED);
6909 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6910 arvif->vdev_id, ret);
6914 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6915 reinit_completion(&ar->completed_11d_scan);
6916 ar->state_11d = ATH11K_11D_PREPARING;
6919 case WMI_VDEV_TYPE_MONITOR:
6920 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6926 arvif->txpower = vif->bss_conf.txpower;
6927 ret = ath11k_mac_txpower_recalc(ar);
6931 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6932 param_value = ar->hw->wiphy->rts_threshold;
6933 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6934 param_id, param_value);
6936 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6937 arvif->vdev_id, ret);
6940 ath11k_dp_vdev_tx_attach(ar, arvif);
6942 ath11k_debugfs_add_interface(arvif);
6944 if (vif->type != NL80211_IFTYPE_MONITOR &&
6945 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6946 ret = ath11k_mac_monitor_vdev_create(ar);
6948 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6952 mutex_unlock(&ar->conf_mutex);
6957 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6958 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6960 ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6961 vif->addr, arvif->vdev_id, fbret);
6967 ath11k_mac_vdev_delete(ar, arvif);
6968 spin_lock_bh(&ar->data_lock);
6969 list_del(&arvif->list);
6970 spin_unlock_bh(&ar->data_lock);
6973 mutex_unlock(&ar->conf_mutex);
6978 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6980 struct ieee80211_vif *vif = ctx;
6981 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6983 if (skb_cb->vif == vif)
6989 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6990 struct ieee80211_vif *vif)
6992 struct ath11k *ar = hw->priv;
6993 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6994 struct ath11k_base *ab = ar->ab;
6998 cancel_delayed_work_sync(&arvif->connection_loss_work);
7000 mutex_lock(&ar->conf_mutex);
7002 ath11k_dbg(ab, ATH11K_DBG_MAC, "remove interface (vdev %d)\n",
7005 ret = ath11k_spectral_vif_stop(arvif);
7007 ath11k_warn(ab, "failed to stop spectral for vdev %i: %d\n",
7008 arvif->vdev_id, ret);
7010 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7011 ath11k_mac_11d_scan_stop(ar);
7013 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7014 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
7016 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
7017 arvif->vdev_id, ret);
7020 ret = ath11k_mac_vdev_delete(ar, arvif);
7022 ath11k_warn(ab, "failed to delete vdev %d: %d\n",
7023 arvif->vdev_id, ret);
7027 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7028 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
7029 ar->monitor_vdev_id = -1;
7030 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
7031 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
7032 ret = ath11k_mac_monitor_vdev_delete(ar);
7034 /* continue even if there's an error */
7035 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
7040 spin_lock_bh(&ar->data_lock);
7041 list_del(&arvif->list);
7042 spin_unlock_bh(&ar->data_lock);
7044 ath11k_peer_cleanup(ar, arvif->vdev_id);
7046 idr_for_each(&ar->txmgmt_idr,
7047 ath11k_mac_vif_txmgmt_idr_remove, vif);
7049 for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
7050 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7051 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
7052 ath11k_mac_vif_unref, vif);
7053 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7056 /* Recalc txpower for remaining vdev */
7057 ath11k_mac_txpower_recalc(ar);
7059 ath11k_debugfs_remove_interface(arvif);
7061 /* TODO: recal traffic pause state based on the available vdevs */
7063 mutex_unlock(&ar->conf_mutex);
7066 /* FIXME: Has to be verified. */
7067 #define SUPPORTED_FILTERS \
7072 FIF_BCN_PRBRESP_PROMISC | \
7076 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
7077 unsigned int changed_flags,
7078 unsigned int *total_flags,
7081 struct ath11k *ar = hw->priv;
7083 mutex_lock(&ar->conf_mutex);
7085 *total_flags &= SUPPORTED_FILTERS;
7086 ar->filter_flags = *total_flags;
7088 mutex_unlock(&ar->conf_mutex);
7091 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
7093 struct ath11k *ar = hw->priv;
7095 mutex_lock(&ar->conf_mutex);
7097 *tx_ant = ar->cfg_tx_chainmask;
7098 *rx_ant = ar->cfg_rx_chainmask;
7100 mutex_unlock(&ar->conf_mutex);
7105 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
7107 struct ath11k *ar = hw->priv;
7110 mutex_lock(&ar->conf_mutex);
7111 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
7112 mutex_unlock(&ar->conf_mutex);
7117 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
7118 struct ieee80211_vif *vif,
7119 struct ieee80211_ampdu_params *params)
7121 struct ath11k *ar = hw->priv;
7124 mutex_lock(&ar->conf_mutex);
7126 switch (params->action) {
7127 case IEEE80211_AMPDU_RX_START:
7128 ret = ath11k_dp_rx_ampdu_start(ar, params);
7130 case IEEE80211_AMPDU_RX_STOP:
7131 ret = ath11k_dp_rx_ampdu_stop(ar, params);
7133 case IEEE80211_AMPDU_TX_START:
7134 case IEEE80211_AMPDU_TX_STOP_CONT:
7135 case IEEE80211_AMPDU_TX_STOP_FLUSH:
7136 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
7137 case IEEE80211_AMPDU_TX_OPERATIONAL:
7138 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
7139 * Tx aggregation requests.
7145 mutex_unlock(&ar->conf_mutex);
7150 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
7151 struct ieee80211_chanctx_conf *ctx)
7153 struct ath11k *ar = hw->priv;
7154 struct ath11k_base *ab = ar->ab;
7156 ath11k_dbg(ab, ATH11K_DBG_MAC,
7157 "chanctx add freq %u width %d ptr %p\n",
7158 ctx->def.chan->center_freq, ctx->def.width, ctx);
7160 mutex_lock(&ar->conf_mutex);
7162 spin_lock_bh(&ar->data_lock);
7163 /* TODO: In case of multiple channel context, populate rx_channel from
7164 * Rx PPDU desc information.
7166 ar->rx_channel = ctx->def.chan;
7167 spin_unlock_bh(&ar->data_lock);
7169 mutex_unlock(&ar->conf_mutex);
7174 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
7175 struct ieee80211_chanctx_conf *ctx)
7177 struct ath11k *ar = hw->priv;
7178 struct ath11k_base *ab = ar->ab;
7180 ath11k_dbg(ab, ATH11K_DBG_MAC,
7181 "chanctx remove freq %u width %d ptr %p\n",
7182 ctx->def.chan->center_freq, ctx->def.width, ctx);
7184 mutex_lock(&ar->conf_mutex);
7186 spin_lock_bh(&ar->data_lock);
7187 /* TODO: In case of there is one more channel context left, populate
7188 * rx_channel with the channel of that remaining channel context.
7190 ar->rx_channel = NULL;
7191 spin_unlock_bh(&ar->data_lock);
7193 mutex_unlock(&ar->conf_mutex);
7197 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
7198 struct ieee80211_chanctx_conf *ctx,
7201 struct ath11k *ar = arvif->ar;
7202 struct ath11k_base *ab = ar->ab;
7203 struct wmi_vdev_start_req_arg arg = {};
7204 const struct cfg80211_chan_def *chandef = &ctx->def;
7206 unsigned int dfs_cac_time;
7208 lockdep_assert_held(&ar->conf_mutex);
7210 reinit_completion(&ar->vdev_setup_done);
7212 arg.vdev_id = arvif->vdev_id;
7213 arg.dtim_period = arvif->dtim_period;
7214 arg.bcn_intval = arvif->beacon_interval;
7216 arg.channel.freq = chandef->chan->center_freq;
7217 arg.channel.band_center_freq1 = chandef->center_freq1;
7218 arg.channel.band_center_freq2 = chandef->center_freq2;
7220 ath11k_phymodes[chandef->chan->band][chandef->width];
7222 arg.channel.min_power = 0;
7223 arg.channel.max_power = chandef->chan->max_power;
7224 arg.channel.max_reg_power = chandef->chan->max_reg_power;
7225 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
7227 arg.pref_tx_streams = ar->num_tx_chains;
7228 arg.pref_rx_streams = ar->num_rx_chains;
7230 arg.mbssid_flags = 0;
7231 arg.mbssid_tx_vdev_id = 0;
7232 if (test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
7233 ar->ab->wmi_ab.svc_map)) {
7234 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
7236 &arg.mbssid_tx_vdev_id);
7241 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7242 arg.ssid = arvif->u.ap.ssid;
7243 arg.ssid_len = arvif->u.ap.ssid_len;
7244 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
7246 /* For now allow DFS for AP mode */
7247 arg.channel.chan_radar =
7248 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
7250 arg.channel.freq2_radar = ctx->radar_enabled;
7252 arg.channel.passive = arg.channel.chan_radar;
7254 spin_lock_bh(&ab->base_lock);
7255 arg.regdomain = ar->ab->dfs_region;
7256 spin_unlock_bh(&ab->base_lock);
7259 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
7261 ath11k_dbg(ab, ATH11K_DBG_MAC,
7262 "vdev %d start center_freq %d phymode %s\n",
7263 arg.vdev_id, arg.channel.freq,
7264 ath11k_wmi_phymode_str(arg.channel.mode));
7266 ret = ath11k_wmi_vdev_start(ar, &arg, restart);
7268 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
7269 restart ? "restart" : "start", arg.vdev_id);
7273 ret = ath11k_mac_vdev_setup_sync(ar);
7275 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
7276 arg.vdev_id, restart ? "restart" : "start", ret);
7281 ar->num_started_vdevs++;
7283 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n",
7284 arvif->vif->addr, arvif->vdev_id);
7286 /* Enable CAC Flag in the driver by checking the all sub-channel's DFS
7287 * state as NL80211_DFS_USABLE which indicates CAC needs to be
7288 * done before channel usage. This flags is used to drop rx packets.
7291 /* TODO Set the flag for other interface types as required */
7292 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && ctx->radar_enabled &&
7293 cfg80211_chandef_dfs_usable(ar->hw->wiphy, chandef)) {
7294 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7295 dfs_cac_time = cfg80211_chandef_dfs_cac_time(ar->hw->wiphy,
7297 ath11k_dbg(ab, ATH11K_DBG_MAC,
7298 "cac started dfs_cac_time %u center_freq %d center_freq1 %d for vdev %d\n",
7299 dfs_cac_time, arg.channel.freq, chandef->center_freq1,
7303 ret = ath11k_mac_set_txbf_conf(arvif);
7305 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
7306 arvif->vdev_id, ret);
7311 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
7313 struct ath11k *ar = arvif->ar;
7316 lockdep_assert_held(&ar->conf_mutex);
7318 reinit_completion(&ar->vdev_setup_done);
7320 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
7322 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
7323 arvif->vdev_id, ret);
7327 ret = ath11k_mac_vdev_setup_sync(ar);
7329 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
7330 arvif->vdev_id, ret);
7334 WARN_ON(ar->num_started_vdevs == 0);
7336 ar->num_started_vdevs--;
7337 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
7338 arvif->vif->addr, arvif->vdev_id);
7340 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
7341 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7342 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
7351 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
7352 struct ieee80211_chanctx_conf *ctx)
7354 return ath11k_mac_vdev_start_restart(arvif, ctx, false);
7357 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
7358 struct ieee80211_chanctx_conf *ctx)
7360 return ath11k_mac_vdev_start_restart(arvif, ctx, true);
7363 struct ath11k_mac_change_chanctx_arg {
7364 struct ieee80211_chanctx_conf *ctx;
7365 struct ieee80211_vif_chanctx_switch *vifs;
7371 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
7372 struct ieee80211_vif *vif)
7374 struct ath11k_mac_change_chanctx_arg *arg = data;
7376 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
7383 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
7384 struct ieee80211_vif *vif)
7386 struct ath11k_mac_change_chanctx_arg *arg = data;
7387 struct ieee80211_chanctx_conf *ctx;
7389 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
7390 if (ctx != arg->ctx)
7393 if (WARN_ON(arg->next_vif == arg->n_vifs))
7396 arg->vifs[arg->next_vif].vif = vif;
7397 arg->vifs[arg->next_vif].old_ctx = ctx;
7398 arg->vifs[arg->next_vif].new_ctx = ctx;
7403 ath11k_mac_update_vif_chan(struct ath11k *ar,
7404 struct ieee80211_vif_chanctx_switch *vifs,
7407 struct ath11k_base *ab = ar->ab;
7408 struct ath11k_vif *arvif, *tx_arvif = NULL;
7409 struct ieee80211_vif *mbssid_tx_vif;
7412 bool monitor_vif = false;
7414 lockdep_assert_held(&ar->conf_mutex);
7416 /* Associated channel resources of all relevant vdevs
7417 * should be available for the channel switch now.
7420 /* TODO: Update ar->rx_channel */
7422 for (i = 0; i < n_vifs; i++) {
7423 arvif = ath11k_vif_to_arvif(vifs[i].vif);
7425 if (WARN_ON(!arvif->is_started))
7428 /* change_chanctx can be called even before vdev_up from
7429 * ieee80211_start_ap->ieee80211_vif_use_channel->
7430 * ieee80211_recalc_radar_chanctx.
7432 * Firmware expect vdev_restart only if vdev is up.
7433 * If vdev is down then it expect vdev_stop->vdev_start.
7436 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
7438 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
7439 arvif->vdev_id, ret);
7443 ret = ath11k_mac_vdev_stop(arvif);
7445 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
7446 arvif->vdev_id, ret);
7450 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
7452 ath11k_warn(ab, "failed to start vdev %d: %d\n",
7453 arvif->vdev_id, ret);
7458 ret = ath11k_mac_setup_bcn_tmpl(arvif);
7460 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
7463 mbssid_tx_vif = arvif->vif->mbssid_tx_vif;
7465 tx_arvif = ath11k_vif_to_arvif(mbssid_tx_vif);
7467 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
7469 tx_arvif ? tx_arvif->bssid : NULL,
7470 arvif->vif->bss_conf.bssid_index,
7471 1 << arvif->vif->bss_conf.bssid_indicator);
7473 ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
7474 arvif->vdev_id, ret);
7479 /* Restart the internal monitor vdev on new channel */
7481 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7482 ret = ath11k_mac_monitor_stop(ar);
7484 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
7489 ret = ath11k_mac_monitor_start(ar);
7491 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
7499 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
7500 struct ieee80211_chanctx_conf *ctx)
7502 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
7504 lockdep_assert_held(&ar->conf_mutex);
7506 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7507 IEEE80211_IFACE_ITER_NORMAL,
7508 ath11k_mac_change_chanctx_cnt_iter,
7510 if (arg.n_vifs == 0)
7513 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
7517 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7518 IEEE80211_IFACE_ITER_NORMAL,
7519 ath11k_mac_change_chanctx_fill_iter,
7522 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
7527 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
7528 struct ieee80211_chanctx_conf *ctx,
7531 struct ath11k *ar = hw->priv;
7532 struct ath11k_base *ab = ar->ab;
7534 mutex_lock(&ar->conf_mutex);
7536 ath11k_dbg(ab, ATH11K_DBG_MAC,
7537 "chanctx change freq %u width %d ptr %p changed %x\n",
7538 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
7540 /* This shouldn't really happen because channel switching should use
7541 * switch_vif_chanctx().
7543 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
7546 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
7547 changed & IEEE80211_CHANCTX_CHANGE_RADAR)
7548 ath11k_mac_update_active_vif_chan(ar, ctx);
7550 /* TODO: Recalc radar detection */
7553 mutex_unlock(&ar->conf_mutex);
7556 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
7557 struct ieee80211_vif *vif)
7559 struct ath11k *ar = hw->priv;
7560 struct ath11k_base *ab = ar->ab;
7561 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7564 if (WARN_ON(arvif->is_started))
7567 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
7569 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7570 arvif->vdev_id, vif->addr,
7571 arvif->chanctx.def.chan->center_freq, ret);
7575 /* Reconfigure hardware rate code since it is cleared by firmware.
7577 if (ar->hw_rate_code > 0) {
7578 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
7580 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
7583 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
7588 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7589 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr,
7592 ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7597 arvif->is_started = true;
7599 /* TODO: Setup ps and cts/rts protection */
7604 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7605 struct ieee80211_vif *vif,
7606 struct ieee80211_bss_conf *link_conf,
7607 struct ieee80211_chanctx_conf *ctx)
7609 struct ath11k *ar = hw->priv;
7610 struct ath11k_base *ab = ar->ab;
7611 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7613 struct peer_create_params param;
7615 mutex_lock(&ar->conf_mutex);
7617 ath11k_dbg(ab, ATH11K_DBG_MAC,
7618 "chanctx assign ptr %p vdev_id %i\n",
7619 ctx, arvif->vdev_id);
7621 /* for QCA6390 bss peer must be created before vdev_start */
7622 if (ab->hw_params.vdev_start_delay &&
7623 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7624 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7625 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7626 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7631 if (WARN_ON(arvif->is_started)) {
7636 if (ab->hw_params.vdev_start_delay &&
7637 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7638 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7639 param.vdev_id = arvif->vdev_id;
7640 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7641 param.peer_addr = ar->mac_addr;
7643 ret = ath11k_peer_create(ar, arvif, NULL, ¶m);
7645 ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7651 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7652 ret = ath11k_mac_monitor_start(ar);
7654 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7659 arvif->is_started = true;
7663 ret = ath11k_mac_vdev_start(arvif, ctx);
7665 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7666 arvif->vdev_id, vif->addr,
7667 ctx->def.chan->center_freq, ret);
7671 arvif->is_started = true;
7673 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7674 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7675 ret = ath11k_mac_monitor_start(ar);
7677 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7683 /* TODO: Setup ps and cts/rts protection */
7688 mutex_unlock(&ar->conf_mutex);
7694 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7695 struct ieee80211_vif *vif,
7696 struct ieee80211_bss_conf *link_conf,
7697 struct ieee80211_chanctx_conf *ctx)
7699 struct ath11k *ar = hw->priv;
7700 struct ath11k_base *ab = ar->ab;
7701 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7702 struct ath11k_peer *peer;
7705 mutex_lock(&ar->conf_mutex);
7707 ath11k_dbg(ab, ATH11K_DBG_MAC,
7708 "chanctx unassign ptr %p vdev_id %i\n",
7709 ctx, arvif->vdev_id);
7711 WARN_ON(!arvif->is_started);
7713 if (ab->hw_params.vdev_start_delay &&
7714 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7715 spin_lock_bh(&ab->base_lock);
7716 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7717 spin_unlock_bh(&ab->base_lock);
7719 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7722 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7723 ret = ath11k_mac_monitor_stop(ar);
7725 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7727 mutex_unlock(&ar->conf_mutex);
7731 arvif->is_started = false;
7732 mutex_unlock(&ar->conf_mutex);
7736 ret = ath11k_mac_vdev_stop(arvif);
7738 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7739 arvif->vdev_id, ret);
7741 arvif->is_started = false;
7743 if (ab->hw_params.vdev_start_delay &&
7744 arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7745 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7748 "failed to delete peer %pM for vdev %d: %d\n",
7749 arvif->bssid, arvif->vdev_id, ret);
7751 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7752 "removed peer %pM vdev %d after vdev stop\n",
7753 arvif->bssid, arvif->vdev_id);
7756 if (ab->hw_params.vdev_start_delay &&
7757 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7758 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7760 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7761 ar->num_started_vdevs == 1 &&
7762 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7763 ret = ath11k_mac_monitor_stop(ar);
7765 /* continue even if there's an error */
7766 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7770 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7771 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7773 mutex_unlock(&ar->conf_mutex);
7777 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7778 struct ieee80211_vif_chanctx_switch *vifs,
7780 enum ieee80211_chanctx_switch_mode mode)
7782 struct ath11k *ar = hw->priv;
7784 mutex_lock(&ar->conf_mutex);
7786 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7787 "chanctx switch n_vifs %d mode %d\n",
7789 ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7791 mutex_unlock(&ar->conf_mutex);
7797 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7799 struct ath11k_vif *arvif;
7802 mutex_lock(&ar->conf_mutex);
7803 list_for_each_entry(arvif, &ar->arvifs, list) {
7804 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7805 param, arvif->vdev_id, value);
7807 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7810 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7811 param, arvif->vdev_id, ret);
7815 mutex_unlock(&ar->conf_mutex);
7819 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7820 * this is set interface specific to firmware from ath11k driver
7822 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7824 struct ath11k *ar = hw->priv;
7825 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7827 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7830 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7832 /* Even though there's a WMI vdev param for fragmentation threshold no
7833 * known firmware actually implements it. Moreover it is not possible to
7834 * rely frame fragmentation to mac80211 because firmware clears the
7835 * "more fragments" bit in frame control making it impossible for remote
7836 * devices to reassemble frames.
7838 * Hence implement a dummy callback just to say fragmentation isn't
7839 * supported. This effectively prevents mac80211 from doing frame
7840 * fragmentation in software.
7845 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7850 time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7851 (atomic_read(&ar->dp.num_tx_pending) == 0),
7852 ATH11K_FLUSH_TIMEOUT);
7853 if (time_left == 0) {
7854 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7855 atomic_read(&ar->dp.num_tx_pending));
7859 time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7860 (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7861 ATH11K_FLUSH_TIMEOUT);
7862 if (time_left == 0) {
7863 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7864 atomic_read(&ar->num_pending_mgmt_tx));
7871 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7873 ath11k_mac_drain_tx(ar);
7874 return ath11k_mac_flush_tx_complete(ar);
7877 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7878 u32 queues, bool drop)
7880 struct ath11k *ar = hw->priv;
7885 ath11k_mac_flush_tx_complete(ar);
7889 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7890 enum nl80211_band band,
7891 const struct cfg80211_bitrate_mask *mask)
7895 num_rates = hweight32(mask->control[band].legacy);
7897 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7900 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7903 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7906 return num_rates == 1;
7910 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7912 if (he_cap->he_cap_elem.phy_cap_info[0] &
7913 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7914 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7916 if (he_cap->he_cap_elem.phy_cap_info[0] &
7917 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7918 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7920 return he_cap->he_mcs_nss_supp.tx_mcs_80;
7924 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7925 struct ath11k_vif *arvif,
7926 enum nl80211_band band,
7927 const struct cfg80211_bitrate_mask *mask,
7930 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7931 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7932 const struct ieee80211_sta_he_cap *he_cap;
7935 u8 vht_nss_mask = 0;
7939 /* No need to consider legacy here. Basic rates are always present
7943 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7944 if (mask->control[band].ht_mcs[i] == 0)
7946 else if (mask->control[band].ht_mcs[i] ==
7947 sband->ht_cap.mcs.rx_mask[i])
7948 ht_nss_mask |= BIT(i);
7953 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7954 if (mask->control[band].vht_mcs[i] == 0)
7956 else if (mask->control[band].vht_mcs[i] ==
7957 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7958 vht_nss_mask |= BIT(i);
7963 he_cap = ieee80211_get_he_iftype_cap_vif(sband, arvif->vif);
7967 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(he_cap));
7969 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7970 if (mask->control[band].he_mcs[i] == 0)
7973 if (mask->control[band].he_mcs[i] ==
7974 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7975 he_nss_mask |= BIT(i);
7980 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7983 if (ht_nss_mask == 0)
7986 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7989 *nss = fls(ht_nss_mask);
7995 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7996 enum nl80211_band band,
7997 const struct cfg80211_bitrate_mask *mask,
8005 if (hweight32(mask->control[band].legacy) != 1)
8008 rate_idx = ffs(mask->control[band].legacy) - 1;
8010 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
8011 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
8013 hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
8014 bitrate = ath11k_legacy_rates[rate_idx].bitrate;
8016 if (ath11k_mac_bitrate_is_cck(bitrate))
8017 preamble = WMI_RATE_PREAMBLE_CCK;
8019 preamble = WMI_RATE_PREAMBLE_OFDM;
8022 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
8028 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
8030 struct ath11k *ar = arvif->ar;
8033 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
8034 if (he_gi && he_gi != 0xFF)
8037 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8038 WMI_VDEV_PARAM_SGI, he_gi);
8040 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
8048 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8049 WMI_VDEV_PARAM_HE_LTF, he_ltf);
8051 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
8060 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
8062 struct ath11k *ar = arvif->ar;
8066 if (he_gi != 0xFF) {
8068 case NL80211_RATE_INFO_HE_GI_0_8:
8069 he_gi = WMI_AUTORATE_800NS_GI;
8071 case NL80211_RATE_INFO_HE_GI_1_6:
8072 he_gi = WMI_AUTORATE_1600NS_GI;
8074 case NL80211_RATE_INFO_HE_GI_3_2:
8075 he_gi = WMI_AUTORATE_3200NS_GI;
8078 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
8083 if (he_ltf != 0xFF) {
8085 case NL80211_RATE_INFO_HE_1XLTF:
8086 he_ltf = WMI_HE_AUTORATE_LTF_1X;
8088 case NL80211_RATE_INFO_HE_2XLTF:
8089 he_ltf = WMI_HE_AUTORATE_LTF_2X;
8091 case NL80211_RATE_INFO_HE_4XLTF:
8092 he_ltf = WMI_HE_AUTORATE_LTF_4X;
8095 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
8100 he_ar_gi_ltf = he_gi | he_ltf;
8101 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8102 WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
8106 "failed to set he autorate gi %u ltf %u: %d\n",
8107 he_gi, he_ltf, ret);
8114 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
8115 u32 rate, u8 nss, u8 sgi, u8 ldpc,
8116 u8 he_gi, u8 he_ltf, bool he_fixed_rate)
8118 struct ath11k *ar = arvif->ar;
8122 lockdep_assert_held(&ar->conf_mutex);
8124 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8125 "set rate params vdev %i rate 0x%02x nss 0x%02x sgi 0x%02x ldpc 0x%02x he_gi 0x%02x he_ltf 0x%02x he_fixed_rate %d\n",
8126 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
8127 he_ltf, he_fixed_rate);
8129 if (!arvif->vif->bss_conf.he_support) {
8130 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
8131 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8134 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
8140 vdev_param = WMI_VDEV_PARAM_NSS;
8141 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8144 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
8149 vdev_param = WMI_VDEV_PARAM_LDPC;
8150 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8153 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
8158 if (arvif->vif->bss_conf.he_support) {
8159 if (he_fixed_rate) {
8160 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
8163 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
8168 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
8171 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
8177 vdev_param = WMI_VDEV_PARAM_SGI;
8178 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8181 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
8191 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
8192 enum nl80211_band band,
8193 const struct cfg80211_bitrate_mask *mask)
8198 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8199 vht_mcs = mask->control[band].vht_mcs[i];
8216 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
8217 enum nl80211_band band,
8218 const struct cfg80211_bitrate_mask *mask)
8223 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
8224 he_mcs = mask->control[band].he_mcs[i];
8240 static void ath11k_mac_set_bitrate_mask_iter(void *data,
8241 struct ieee80211_sta *sta)
8243 struct ath11k_vif *arvif = data;
8244 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8245 struct ath11k *ar = arvif->ar;
8247 spin_lock_bh(&ar->data_lock);
8248 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
8249 spin_unlock_bh(&ar->data_lock);
8251 ieee80211_queue_work(ar->hw, &arsta->update_wk);
8254 static void ath11k_mac_disable_peer_fixed_rate(void *data,
8255 struct ieee80211_sta *sta)
8257 struct ath11k_vif *arvif = data;
8258 struct ath11k *ar = arvif->ar;
8261 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
8263 WMI_PEER_PARAM_FIXED_RATE,
8264 WMI_FIXED_RATE_NONE);
8267 "failed to disable peer fixed rate for STA %pM ret %d\n",
8272 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
8273 const struct cfg80211_bitrate_mask *mask)
8275 bool he_fixed_rate = false, vht_fixed_rate = false;
8276 struct ath11k_peer *peer;
8277 const u16 *vht_mcs_mask, *he_mcs_mask;
8278 struct ieee80211_link_sta *deflink;
8282 vht_mcs_mask = mask->control[band].vht_mcs;
8283 he_mcs_mask = mask->control[band].he_mcs;
8285 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
8286 vht_fixed_rate = true;
8288 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
8289 he_fixed_rate = true;
8291 if (!vht_fixed_rate && !he_fixed_rate)
8294 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
8295 he_nss = ath11k_mac_max_he_nss(he_mcs_mask);
8298 spin_lock_bh(&ar->ab->base_lock);
8299 list_for_each_entry(peer, &ar->ab->peers, list) {
8301 deflink = &peer->sta->deflink;
8303 if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
8304 deflink->rx_nss < vht_nss)) {
8309 if (he_fixed_rate && (!deflink->he_cap.has_he ||
8310 deflink->rx_nss < he_nss)) {
8318 spin_unlock_bh(&ar->ab->base_lock);
8324 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
8325 struct ieee80211_vif *vif,
8326 const struct cfg80211_bitrate_mask *mask)
8328 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8329 struct cfg80211_chan_def def;
8330 struct ath11k_pdev_cap *cap;
8331 struct ath11k *ar = arvif->ar;
8332 enum nl80211_band band;
8333 const u8 *ht_mcs_mask;
8334 const u16 *vht_mcs_mask;
8335 const u16 *he_mcs_mask;
8345 bool he_fixed_rate = false;
8347 if (ath11k_mac_vif_chan(vif, &def))
8350 band = def.chan->band;
8351 cap = &ar->pdev->cap;
8352 ht_mcs_mask = mask->control[band].ht_mcs;
8353 vht_mcs_mask = mask->control[band].vht_mcs;
8354 he_mcs_mask = mask->control[band].he_mcs;
8355 ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
8357 sgi = mask->control[band].gi;
8358 if (sgi == NL80211_TXRATE_FORCE_LGI)
8361 he_gi = mask->control[band].he_gi;
8362 he_ltf = mask->control[band].he_ltf;
8364 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
8365 * requires passing at least one of used basic rates along with them.
8366 * Fixed rate setting across different preambles(legacy, HT, VHT) is
8367 * not supported by the FW. Hence use of FIXED_RATE vdev param is not
8368 * suitable for setting single HT/VHT rates.
8369 * But, there could be a single basic rate passed from userspace which
8370 * can be done through the FIXED_RATE param.
8372 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
8373 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
8376 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
8377 arvif->vdev_id, ret);
8380 ieee80211_iterate_stations_atomic(ar->hw,
8381 ath11k_mac_disable_peer_fixed_rate,
8383 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, arvif, band, mask,
8385 rate = WMI_FIXED_RATE_NONE;
8387 mutex_lock(&ar->conf_mutex);
8388 arvif->bitrate_mask = *mask;
8389 ieee80211_iterate_stations_atomic(ar->hw,
8390 ath11k_mac_set_bitrate_mask_iter,
8392 mutex_unlock(&ar->conf_mutex);
8394 rate = WMI_FIXED_RATE_NONE;
8396 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
8398 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
8399 nss = min_t(u32, ar->num_tx_chains,
8400 ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
8402 /* If multiple rates across different preambles are given
8403 * we can reconfigure this info with all peers using PEER_ASSOC
8404 * command with the below exception cases.
8405 * - Single VHT Rate : peer_assoc command accommodates only MCS
8406 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
8407 * mandates passing basic rates along with HT/VHT rates, FW
8408 * doesn't allow switching from VHT to Legacy. Hence instead of
8409 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
8410 * we could set this VHT rate as peer fixed rate param, which
8411 * will override FIXED rate and FW rate control algorithm.
8412 * If single VHT rate is passed along with HT rates, we select
8413 * the VHT rate as fixed rate for vht peers.
8414 * - Multiple VHT Rates : When Multiple VHT rates are given,this
8415 * can be set using RATEMASK CMD which uses FW rate-ctl alg.
8416 * TODO: Setting multiple VHT MCS and replacing peer_assoc with
8417 * RATEMASK_CMDID can cover all use cases of setting rates
8418 * across multiple preambles and rates within same type.
8419 * But requires more validation of the command at this point.
8422 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
8425 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
8427 /* TODO: Handle multiple VHT MCS values setting using
8431 "setting %d mcs values in bitrate mask not supported\n",
8436 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
8439 he_fixed_rate = true;
8441 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
8444 "Setting more than one HE MCS Value in bitrate mask not supported\n");
8448 mutex_lock(&ar->conf_mutex);
8449 ieee80211_iterate_stations_atomic(ar->hw,
8450 ath11k_mac_disable_peer_fixed_rate,
8453 arvif->bitrate_mask = *mask;
8454 ieee80211_iterate_stations_atomic(ar->hw,
8455 ath11k_mac_set_bitrate_mask_iter,
8458 mutex_unlock(&ar->conf_mutex);
8461 mutex_lock(&ar->conf_mutex);
8463 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
8464 he_ltf, he_fixed_rate);
8466 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
8467 arvif->vdev_id, ret);
8470 mutex_unlock(&ar->conf_mutex);
8476 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
8477 enum ieee80211_reconfig_type reconfig_type)
8479 struct ath11k *ar = hw->priv;
8480 struct ath11k_base *ab = ar->ab;
8482 struct ath11k_vif *arvif;
8484 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
8487 mutex_lock(&ar->conf_mutex);
8489 if (ar->state == ATH11K_STATE_RESTARTED) {
8490 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
8492 ar->state = ATH11K_STATE_ON;
8493 ieee80211_wake_queues(ar->hw);
8495 if (ar->ab->hw_params.current_cc_support &&
8496 ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
8497 struct wmi_set_current_country_params set_current_param = {};
8499 memcpy(&set_current_param.alpha2, ar->alpha2, 2);
8500 ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8504 recovery_count = atomic_inc_return(&ab->recovery_count);
8505 ath11k_dbg(ab, ATH11K_DBG_BOOT,
8506 "recovery count %d\n", recovery_count);
8507 /* When there are multiple radios in an SOC,
8508 * the recovery has to be done for each radio
8510 if (recovery_count == ab->num_radios) {
8511 atomic_dec(&ab->reset_count);
8512 complete(&ab->reset_complete);
8513 ab->is_reset = false;
8514 atomic_set(&ab->fail_cont_count, 0);
8515 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
8518 if (ar->ab->hw_params.support_fw_mac_sequence) {
8519 list_for_each_entry(arvif, &ar->arvifs, list) {
8520 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
8521 ieee80211_hw_restart_disconnect(arvif->vif);
8526 mutex_unlock(&ar->conf_mutex);
8530 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
8531 struct ieee80211_channel *channel)
8534 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8536 lockdep_assert_held(&ar->conf_mutex);
8538 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
8539 ar->rx_channel != channel)
8542 if (ar->scan.state != ATH11K_SCAN_IDLE) {
8543 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8544 "ignoring bss chan info req while scanning..\n");
8548 reinit_completion(&ar->bss_survey_done);
8550 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
8552 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
8556 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8558 ath11k_warn(ar->ab, "bss channel survey timed out\n");
8561 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
8562 struct survey_info *survey)
8564 struct ath11k *ar = hw->priv;
8565 struct ieee80211_supported_band *sband;
8566 struct survey_info *ar_survey;
8569 if (idx >= ATH11K_NUM_CHANS)
8572 ar_survey = &ar->survey[idx];
8574 mutex_lock(&ar->conf_mutex);
8576 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8577 if (sband && idx >= sband->n_channels) {
8578 idx -= sband->n_channels;
8583 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8584 if (sband && idx >= sband->n_channels) {
8585 idx -= sband->n_channels;
8590 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8591 if (!sband || idx >= sband->n_channels) {
8596 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8598 spin_lock_bh(&ar->data_lock);
8599 memcpy(survey, ar_survey, sizeof(*survey));
8600 spin_unlock_bh(&ar->data_lock);
8602 survey->channel = &sband->channels[idx];
8604 if (ar->rx_channel == survey->channel)
8605 survey->filled |= SURVEY_INFO_IN_USE;
8608 mutex_unlock(&ar->conf_mutex);
8612 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8613 struct ath11k_sta *arsta,
8617 struct ath11k *ar = arsta->arvif->ar;
8621 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8622 sinfo->chains &= ~BIT(i);
8623 rssi = arsta->chain_signal[i];
8625 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8627 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8628 "sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8630 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8631 rssi != ATH11K_INVALID_RSSI_FULL &&
8632 rssi != ATH11K_INVALID_RSSI_EMPTY &&
8634 sinfo->chain_signal[i] = rssi;
8635 sinfo->chains |= BIT(i);
8636 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8641 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8642 struct ieee80211_vif *vif,
8643 struct ieee80211_sta *sta,
8644 struct station_info *sinfo)
8646 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8647 struct ath11k *ar = arsta->arvif->ar;
8649 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8650 ar->ab->wmi_ab.svc_map);
8652 sinfo->rx_duration = arsta->rx_duration;
8653 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8655 sinfo->tx_duration = arsta->tx_duration;
8656 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8658 if (arsta->txrate.legacy || arsta->txrate.nss) {
8659 if (arsta->txrate.legacy) {
8660 sinfo->txrate.legacy = arsta->txrate.legacy;
8662 sinfo->txrate.mcs = arsta->txrate.mcs;
8663 sinfo->txrate.nss = arsta->txrate.nss;
8664 sinfo->txrate.bw = arsta->txrate.bw;
8665 sinfo->txrate.he_gi = arsta->txrate.he_gi;
8666 sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8667 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8669 sinfo->txrate.flags = arsta->txrate.flags;
8670 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8673 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8675 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8676 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8677 ar->ab->hw_params.supports_rssi_stats &&
8678 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8679 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8680 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8683 signal = arsta->rssi_comb;
8685 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8686 ar->ab->hw_params.supports_rssi_stats &&
8687 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8688 WMI_REQUEST_VDEV_STAT)))
8689 signal = arsta->rssi_beacon;
8691 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8692 "sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8693 db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8696 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8697 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8700 sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8701 ATH11K_DEFAULT_NOISE_FLOOR;
8702 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8705 #if IS_ENABLED(CONFIG_IPV6)
8706 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8707 struct ath11k_arp_ns_offload *offload)
8711 for (i = 0; i < offload->ipv6_count; i++) {
8712 offload->self_ipv6_addr[i][0] = 0xff;
8713 offload->self_ipv6_addr[i][1] = 0x02;
8714 offload->self_ipv6_addr[i][11] = 0x01;
8715 offload->self_ipv6_addr[i][12] = 0xff;
8716 offload->self_ipv6_addr[i][13] =
8717 offload->ipv6_addr[i][13];
8718 offload->self_ipv6_addr[i][14] =
8719 offload->ipv6_addr[i][14];
8720 offload->self_ipv6_addr[i][15] =
8721 offload->ipv6_addr[i][15];
8722 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8723 offload->self_ipv6_addr[i]);
8727 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8728 struct ieee80211_vif *vif,
8729 struct inet6_dev *idev)
8731 struct ath11k *ar = hw->priv;
8732 struct ath11k_arp_ns_offload *offload;
8733 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8734 struct inet6_ifaddr *ifa6;
8735 struct ifacaddr6 *ifaca6;
8736 struct list_head *p;
8739 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "op ipv6 changed\n");
8741 offload = &arvif->arp_ns_offload;
8744 read_lock_bh(&idev->lock);
8746 memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8747 memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8748 memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8750 /* get unicast address */
8751 list_for_each(p, &idev->addr_list) {
8752 if (count >= ATH11K_IPV6_MAX_COUNT)
8755 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8756 if (ifa6->flags & IFA_F_DADFAILED)
8758 scope = ipv6_addr_src_scope(&ifa6->addr);
8759 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8760 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8761 memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8762 sizeof(ifa6->addr.s6_addr));
8763 offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8764 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 uc %pI6 scope %d\n",
8765 count, offload->ipv6_addr[count],
8769 ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8773 /* get anycast address */
8774 for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8775 if (count >= ATH11K_IPV6_MAX_COUNT)
8778 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8779 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8780 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8781 memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8782 sizeof(ifaca6->aca_addr));
8783 offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8784 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 ac %pI6 scope %d\n",
8785 count, offload->ipv6_addr[count],
8789 ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8794 offload->ipv6_count = count;
8795 read_unlock_bh(&idev->lock);
8797 /* generate ns multicast address */
8798 ath11k_generate_ns_mc_addr(ar, offload);
8802 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8803 struct ieee80211_vif *vif,
8804 struct cfg80211_gtk_rekey_data *data)
8806 struct ath11k *ar = hw->priv;
8807 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8808 struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8810 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "set rekey data vdev %d\n",
8813 mutex_lock(&ar->conf_mutex);
8815 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8816 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8818 /* The supplicant works on big-endian, the firmware expects it on
8821 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8823 arvif->rekey_data.enable_offload = true;
8825 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8826 rekey_data->kck, NL80211_KCK_LEN);
8827 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8828 rekey_data->kck, NL80211_KEK_LEN);
8829 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8830 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8832 mutex_unlock(&ar->conf_mutex);
8835 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8836 const struct cfg80211_sar_specs *sar)
8838 struct ath11k *ar = hw->priv;
8839 const struct cfg80211_sar_sub_specs *sspec;
8844 if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8845 sar->num_sub_specs == 0)
8848 mutex_lock(&ar->conf_mutex);
8850 if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8851 !ar->ab->hw_params.bios_sar_capa) {
8856 ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8858 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8862 sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8868 sspec = sar->sub_specs;
8869 for (i = 0; i < sar->num_sub_specs; i++) {
8870 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8871 ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8872 sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8876 /* chain0 and chain1 share same power setting */
8877 sar_tbl[sspec->freq_range_index] = sspec->power;
8878 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8879 sar_tbl[index] = sspec->power;
8880 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8881 sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8885 ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8887 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8891 mutex_unlock(&ar->conf_mutex);
8896 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8897 struct ieee80211_vif *vif)
8899 struct ath11k *ar = hw->priv;
8901 mutex_lock(&ar->conf_mutex);
8903 spin_lock_bh(&ar->data_lock);
8904 ar->scan.roc_notify = false;
8905 spin_unlock_bh(&ar->data_lock);
8907 ath11k_scan_abort(ar);
8909 mutex_unlock(&ar->conf_mutex);
8911 cancel_delayed_work_sync(&ar->scan.timeout);
8916 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8917 struct ieee80211_vif *vif,
8918 struct ieee80211_channel *chan,
8920 enum ieee80211_roc_type type)
8922 struct ath11k *ar = hw->priv;
8923 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8924 struct scan_req_params *arg;
8928 mutex_lock(&ar->conf_mutex);
8930 spin_lock_bh(&ar->data_lock);
8931 switch (ar->scan.state) {
8932 case ATH11K_SCAN_IDLE:
8933 reinit_completion(&ar->scan.started);
8934 reinit_completion(&ar->scan.completed);
8935 reinit_completion(&ar->scan.on_channel);
8936 ar->scan.state = ATH11K_SCAN_STARTING;
8937 ar->scan.is_roc = true;
8938 ar->scan.vdev_id = arvif->vdev_id;
8939 ar->scan.roc_freq = chan->center_freq;
8940 ar->scan.roc_notify = true;
8943 case ATH11K_SCAN_STARTING:
8944 case ATH11K_SCAN_RUNNING:
8945 case ATH11K_SCAN_ABORTING:
8949 spin_unlock_bh(&ar->data_lock);
8954 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8956 arg = kzalloc(sizeof(*arg), GFP_KERNEL);
8961 ath11k_wmi_start_scan_init(ar, arg);
8963 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
8965 if (!arg->chan_list) {
8970 arg->vdev_id = arvif->vdev_id;
8971 arg->scan_id = ATH11K_SCAN_ID;
8972 arg->chan_list[0] = chan->center_freq;
8973 arg->dwell_time_active = scan_time_msec;
8974 arg->dwell_time_passive = scan_time_msec;
8975 arg->max_scan_time = scan_time_msec;
8976 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8977 arg->scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8978 arg->burst_duration = duration;
8980 ret = ath11k_start_scan(ar, arg);
8982 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8984 spin_lock_bh(&ar->data_lock);
8985 ar->scan.state = ATH11K_SCAN_IDLE;
8986 spin_unlock_bh(&ar->data_lock);
8987 goto free_chan_list;
8990 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8992 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8993 ret = ath11k_scan_stop(ar);
8995 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8997 goto free_chan_list;
9000 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
9001 msecs_to_jiffies(duration));
9006 kfree(arg->chan_list);
9010 mutex_unlock(&ar->conf_mutex);
9014 static int ath11k_fw_stats_request(struct ath11k *ar,
9015 struct stats_request_params *req_param)
9017 struct ath11k_base *ab = ar->ab;
9018 unsigned long time_left;
9021 lockdep_assert_held(&ar->conf_mutex);
9023 spin_lock_bh(&ar->data_lock);
9024 ar->fw_stats_done = false;
9025 ath11k_fw_stats_pdevs_free(&ar->fw_stats.pdevs);
9026 spin_unlock_bh(&ar->data_lock);
9028 reinit_completion(&ar->fw_stats_complete);
9030 ret = ath11k_wmi_send_stats_request_cmd(ar, req_param);
9032 ath11k_warn(ab, "could not request fw stats (%d)\n",
9037 time_left = wait_for_completion_timeout(&ar->fw_stats_complete,
9046 static int ath11k_mac_op_get_txpower(struct ieee80211_hw *hw,
9047 struct ieee80211_vif *vif,
9050 struct ath11k *ar = hw->priv;
9051 struct ath11k_base *ab = ar->ab;
9052 struct stats_request_params req_param = {0};
9053 struct ath11k_fw_stats_pdev *pdev;
9056 /* Final Tx power is minimum of Target Power, CTL power, Regulatory
9057 * Power, PSD EIRP Power. We just know the Regulatory power from the
9058 * regulatory rules obtained. FW knows all these power and sets the min
9059 * of these. Hence, we request the FW pdev stats in which FW reports
9060 * the minimum of all vdev's channel Tx power.
9062 mutex_lock(&ar->conf_mutex);
9064 if (ar->state != ATH11K_STATE_ON)
9067 /* Firmware doesn't provide Tx power during CAC hence no need to fetch
9070 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
9071 mutex_unlock(&ar->conf_mutex);
9075 req_param.pdev_id = ar->pdev->pdev_id;
9076 req_param.stats_id = WMI_REQUEST_PDEV_STAT;
9078 ret = ath11k_fw_stats_request(ar, &req_param);
9080 ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret);
9084 spin_lock_bh(&ar->data_lock);
9085 pdev = list_first_entry_or_null(&ar->fw_stats.pdevs,
9086 struct ath11k_fw_stats_pdev, list);
9088 spin_unlock_bh(&ar->data_lock);
9092 /* tx power is set as 2 units per dBm in FW. */
9093 *dbm = pdev->chan_tx_power / 2;
9095 spin_unlock_bh(&ar->data_lock);
9096 mutex_unlock(&ar->conf_mutex);
9098 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware %d, reported %d dBm\n",
9099 pdev->chan_tx_power, *dbm);
9103 mutex_unlock(&ar->conf_mutex);
9104 /* We didn't get txpower from FW. Hence, relying on vif->bss_conf.txpower */
9105 *dbm = vif->bss_conf.txpower;
9106 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware NaN, reported %d dBm\n",
9111 static const struct ieee80211_ops ath11k_ops = {
9112 .tx = ath11k_mac_op_tx,
9113 .wake_tx_queue = ieee80211_handle_wake_tx_queue,
9114 .start = ath11k_mac_op_start,
9115 .stop = ath11k_mac_op_stop,
9116 .reconfig_complete = ath11k_mac_op_reconfig_complete,
9117 .add_interface = ath11k_mac_op_add_interface,
9118 .remove_interface = ath11k_mac_op_remove_interface,
9119 .update_vif_offload = ath11k_mac_op_update_vif_offload,
9120 .config = ath11k_mac_op_config,
9121 .bss_info_changed = ath11k_mac_op_bss_info_changed,
9122 .configure_filter = ath11k_mac_op_configure_filter,
9123 .hw_scan = ath11k_mac_op_hw_scan,
9124 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan,
9125 .set_key = ath11k_mac_op_set_key,
9126 .set_rekey_data = ath11k_mac_op_set_rekey_data,
9127 .sta_state = ath11k_mac_op_sta_state,
9128 .sta_set_4addr = ath11k_mac_op_sta_set_4addr,
9129 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr,
9130 .sta_rc_update = ath11k_mac_op_sta_rc_update,
9131 .conf_tx = ath11k_mac_op_conf_tx,
9132 .set_antenna = ath11k_mac_op_set_antenna,
9133 .get_antenna = ath11k_mac_op_get_antenna,
9134 .ampdu_action = ath11k_mac_op_ampdu_action,
9135 .add_chanctx = ath11k_mac_op_add_chanctx,
9136 .remove_chanctx = ath11k_mac_op_remove_chanctx,
9137 .change_chanctx = ath11k_mac_op_change_chanctx,
9138 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx,
9139 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx,
9140 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx,
9141 .set_rts_threshold = ath11k_mac_op_set_rts_threshold,
9142 .set_frag_threshold = ath11k_mac_op_set_frag_threshold,
9143 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask,
9144 .get_survey = ath11k_mac_op_get_survey,
9145 .flush = ath11k_mac_op_flush,
9146 .sta_statistics = ath11k_mac_op_sta_statistics,
9147 CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
9150 .suspend = ath11k_wow_op_suspend,
9151 .resume = ath11k_wow_op_resume,
9152 .set_wakeup = ath11k_wow_op_set_wakeup,
9155 #ifdef CONFIG_ATH11K_DEBUGFS
9156 .sta_add_debugfs = ath11k_debugfs_sta_op_add,
9159 #if IS_ENABLED(CONFIG_IPV6)
9160 .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
9162 .get_txpower = ath11k_mac_op_get_txpower,
9164 .set_sar_specs = ath11k_mac_op_set_bios_sar_specs,
9165 .remain_on_channel = ath11k_mac_op_remain_on_channel,
9166 .cancel_remain_on_channel = ath11k_mac_op_cancel_remain_on_channel,
9169 static void ath11k_mac_update_ch_list(struct ath11k *ar,
9170 struct ieee80211_supported_band *band,
9171 u32 freq_low, u32 freq_high)
9175 if (!(freq_low && freq_high))
9178 for (i = 0; i < band->n_channels; i++) {
9179 if (band->channels[i].center_freq < freq_low ||
9180 band->channels[i].center_freq > freq_high)
9181 band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
9185 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
9187 struct ath11k_pdev *pdev = ar->pdev;
9188 struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
9190 if (band == WMI_HOST_WLAN_2G_CAP)
9191 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
9193 if (band == WMI_HOST_WLAN_5G_CAP)
9194 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
9196 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
9201 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
9202 u32 supported_bands)
9204 struct ieee80211_supported_band *band;
9205 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
9209 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
9210 ARRAY_SIZE(ath11k_5ghz_channels) +
9211 ARRAY_SIZE(ath11k_6ghz_channels)) !=
9214 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
9215 temp_reg_cap = reg_cap;
9217 if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
9218 channels = kmemdup(ath11k_2ghz_channels,
9219 sizeof(ath11k_2ghz_channels),
9224 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
9225 band->band = NL80211_BAND_2GHZ;
9226 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
9227 band->channels = channels;
9228 band->n_bitrates = ath11k_g_rates_size;
9229 band->bitrates = ath11k_g_rates;
9230 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
9232 if (ar->ab->hw_params.single_pdev_only) {
9233 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
9234 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9236 ath11k_mac_update_ch_list(ar, band,
9237 temp_reg_cap->low_2ghz_chan,
9238 temp_reg_cap->high_2ghz_chan);
9241 if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
9242 if (reg_cap->high_5ghz_chan >= ATH11K_MIN_6G_FREQ) {
9243 channels = kmemdup(ath11k_6ghz_channels,
9244 sizeof(ath11k_6ghz_channels), GFP_KERNEL);
9246 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9250 ar->supports_6ghz = true;
9251 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
9252 band->band = NL80211_BAND_6GHZ;
9253 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
9254 band->channels = channels;
9255 band->n_bitrates = ath11k_a_rates_size;
9256 band->bitrates = ath11k_a_rates;
9257 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
9259 if (ar->ab->hw_params.single_pdev_only) {
9260 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9261 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9264 ath11k_mac_update_ch_list(ar, band,
9265 temp_reg_cap->low_5ghz_chan,
9266 temp_reg_cap->high_5ghz_chan);
9269 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
9270 channels = kmemdup(ath11k_5ghz_channels,
9271 sizeof(ath11k_5ghz_channels),
9274 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9275 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9279 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
9280 band->band = NL80211_BAND_5GHZ;
9281 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
9282 band->channels = channels;
9283 band->n_bitrates = ath11k_a_rates_size;
9284 band->bitrates = ath11k_a_rates;
9285 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
9287 if (ar->ab->hw_params.single_pdev_only) {
9288 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9289 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9292 ath11k_mac_update_ch_list(ar, band,
9293 temp_reg_cap->low_5ghz_chan,
9294 temp_reg_cap->high_5ghz_chan);
9301 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
9303 struct ath11k_base *ab = ar->ab;
9304 struct ieee80211_iface_combination *combinations;
9305 struct ieee80211_iface_limit *limits;
9308 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
9314 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
9316 kfree(combinations);
9321 limits[0].types |= BIT(NL80211_IFTYPE_STATION);
9324 limits[1].types |= BIT(NL80211_IFTYPE_AP);
9326 if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
9327 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
9328 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
9330 combinations[0].limits = limits;
9331 combinations[0].n_limits = n_limits;
9332 combinations[0].max_interfaces = 16;
9333 combinations[0].num_different_channels = 1;
9334 combinations[0].beacon_int_infra_match = true;
9335 combinations[0].beacon_int_min_gcd = 100;
9336 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9337 BIT(NL80211_CHAN_WIDTH_20) |
9338 BIT(NL80211_CHAN_WIDTH_40) |
9339 BIT(NL80211_CHAN_WIDTH_80) |
9340 BIT(NL80211_CHAN_WIDTH_80P80) |
9341 BIT(NL80211_CHAN_WIDTH_160);
9343 ar->hw->wiphy->iface_combinations = combinations;
9344 ar->hw->wiphy->n_iface_combinations = 1;
9349 static const u8 ath11k_if_types_ext_capa[] = {
9350 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9351 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9352 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9355 static const u8 ath11k_if_types_ext_capa_sta[] = {
9356 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9357 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9358 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9359 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
9362 static const u8 ath11k_if_types_ext_capa_ap[] = {
9363 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9364 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9365 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9366 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
9367 [10] = WLAN_EXT_CAPA11_EMA_SUPPORT,
9370 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
9372 .extended_capabilities = ath11k_if_types_ext_capa,
9373 .extended_capabilities_mask = ath11k_if_types_ext_capa,
9374 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
9376 .iftype = NL80211_IFTYPE_STATION,
9377 .extended_capabilities = ath11k_if_types_ext_capa_sta,
9378 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
9379 .extended_capabilities_len =
9380 sizeof(ath11k_if_types_ext_capa_sta),
9382 .iftype = NL80211_IFTYPE_AP,
9383 .extended_capabilities = ath11k_if_types_ext_capa_ap,
9384 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
9385 .extended_capabilities_len =
9386 sizeof(ath11k_if_types_ext_capa_ap),
9390 static void __ath11k_mac_unregister(struct ath11k *ar)
9392 cancel_work_sync(&ar->regd_update_work);
9394 ieee80211_unregister_hw(ar->hw);
9396 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
9397 idr_destroy(&ar->txmgmt_idr);
9399 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9400 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9401 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9403 kfree(ar->hw->wiphy->iface_combinations[0].limits);
9404 kfree(ar->hw->wiphy->iface_combinations);
9406 SET_IEEE80211_DEV(ar->hw, NULL);
9409 void ath11k_mac_unregister(struct ath11k_base *ab)
9412 struct ath11k_pdev *pdev;
9415 for (i = 0; i < ab->num_radios; i++) {
9416 pdev = &ab->pdevs[i];
9421 __ath11k_mac_unregister(ar);
9424 ath11k_peer_rhash_tbl_destroy(ab);
9427 static int __ath11k_mac_register(struct ath11k *ar)
9429 struct ath11k_base *ab = ar->ab;
9430 struct ath11k_pdev_cap *cap = &ar->pdev->cap;
9431 static const u32 cipher_suites[] = {
9432 WLAN_CIPHER_SUITE_TKIP,
9433 WLAN_CIPHER_SUITE_CCMP,
9434 WLAN_CIPHER_SUITE_AES_CMAC,
9435 WLAN_CIPHER_SUITE_BIP_CMAC_256,
9436 WLAN_CIPHER_SUITE_BIP_GMAC_128,
9437 WLAN_CIPHER_SUITE_BIP_GMAC_256,
9438 WLAN_CIPHER_SUITE_GCMP,
9439 WLAN_CIPHER_SUITE_GCMP_256,
9440 WLAN_CIPHER_SUITE_CCMP_256,
9445 ath11k_pdev_caps_update(ar);
9447 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
9449 SET_IEEE80211_DEV(ar->hw, ab->dev);
9451 ret = ath11k_mac_setup_channels_rates(ar,
9452 cap->supported_bands);
9456 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
9457 ath11k_mac_setup_he_cap(ar, cap);
9459 ret = ath11k_mac_setup_iface_combinations(ar);
9461 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
9462 goto err_free_channels;
9465 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
9466 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
9468 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
9470 if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
9471 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
9473 if (ab->hw_params.supports_multi_bssid) {
9474 ieee80211_hw_set(ar->hw, SUPPORTS_MULTI_BSSID);
9475 ieee80211_hw_set(ar->hw, SUPPORTS_ONLY_HE_MULTI_BSSID);
9478 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
9479 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
9480 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
9481 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
9482 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
9483 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
9484 ieee80211_hw_set(ar->hw, AP_LINK_PS);
9485 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
9486 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
9487 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
9488 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
9489 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
9490 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
9491 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
9492 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
9494 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
9495 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
9496 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
9499 if (cap->nss_ratio_enabled)
9500 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
9502 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
9503 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
9504 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
9505 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
9506 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
9507 ieee80211_hw_set(ar->hw, USES_RSS);
9510 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
9511 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
9513 /* TODO: Check if HT capability advertised from firmware is different
9514 * for each band for a dual band capable radio. It will be tricky to
9515 * handle it when the ht capability different for each band.
9517 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
9518 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
9519 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
9521 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
9522 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
9524 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
9526 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
9527 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
9528 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
9530 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
9531 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
9532 NL80211_FEATURE_AP_SCAN;
9534 ar->max_num_stations = TARGET_NUM_STATIONS(ab);
9535 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
9537 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
9539 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
9540 ar->hw->wiphy->features |=
9541 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
9544 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
9545 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
9546 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
9547 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
9548 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
9549 ar->hw->wiphy->max_sched_scan_plan_interval =
9550 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
9551 ar->hw->wiphy->max_sched_scan_plan_iterations =
9552 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
9553 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
9556 ret = ath11k_wow_init(ar);
9558 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
9559 goto err_free_if_combs;
9562 if (test_bit(WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI,
9563 ar->ab->wmi_ab.svc_map))
9564 wiphy_ext_feature_set(ar->hw->wiphy,
9565 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);
9567 ar->hw->queues = ATH11K_HW_MAX_QUEUES;
9568 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
9569 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
9570 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
9572 ar->hw->vif_data_size = sizeof(struct ath11k_vif);
9573 ar->hw->sta_data_size = sizeof(struct ath11k_sta);
9575 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
9576 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
9577 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
9578 ar->ab->wmi_ab.svc_map)) {
9579 wiphy_ext_feature_set(ar->hw->wiphy,
9580 NL80211_EXT_FEATURE_BSS_COLOR);
9581 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
9584 ar->hw->wiphy->cipher_suites = cipher_suites;
9585 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
9587 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
9588 ar->hw->wiphy->num_iftype_ext_capab =
9589 ARRAY_SIZE(ath11k_iftypes_ext_capa);
9591 if (ar->supports_6ghz) {
9592 wiphy_ext_feature_set(ar->hw->wiphy,
9593 NL80211_EXT_FEATURE_FILS_DISCOVERY);
9594 wiphy_ext_feature_set(ar->hw->wiphy,
9595 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
9598 wiphy_ext_feature_set(ar->hw->wiphy,
9599 NL80211_EXT_FEATURE_SET_SCAN_DWELL);
9601 if (test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map))
9602 wiphy_ext_feature_set(ar->hw->wiphy,
9603 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
9605 ar->hw->wiphy->mbssid_max_interfaces = TARGET_NUM_VDEVS(ab);
9606 ar->hw->wiphy->ema_max_profile_periodicity = TARGET_EMA_MAX_PROFILE_PERIOD;
9608 ath11k_reg_init(ar);
9610 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
9611 ar->hw->netdev_features = NETIF_F_HW_CSUM;
9612 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
9613 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
9616 if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
9617 ab->hw_params.bios_sar_capa)
9618 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
9620 ret = ieee80211_register_hw(ar->hw);
9622 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
9623 goto err_free_if_combs;
9626 if (!ab->hw_params.supports_monitor)
9627 /* There's a race between calling ieee80211_register_hw()
9628 * and here where the monitor mode is enabled for a little
9629 * while. But that time is so short and in practise it make
9630 * a difference in real life.
9632 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
9634 /* Apply the regd received during initialization */
9635 ret = ath11k_regd_update(ar);
9637 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
9638 goto err_unregister_hw;
9641 if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
9642 struct wmi_set_current_country_params set_current_param = {};
9644 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
9645 memcpy(&ar->alpha2, ab->new_alpha2, 2);
9646 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
9649 "failed set cc code for mac register: %d\n", ret);
9652 ret = ath11k_debugfs_register(ar);
9654 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
9655 goto err_unregister_hw;
9661 ieee80211_unregister_hw(ar->hw);
9664 kfree(ar->hw->wiphy->iface_combinations[0].limits);
9665 kfree(ar->hw->wiphy->iface_combinations);
9668 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9669 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9670 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9673 SET_IEEE80211_DEV(ar->hw, NULL);
9677 int ath11k_mac_register(struct ath11k_base *ab)
9680 struct ath11k_pdev *pdev;
9683 u8 mac_addr[ETH_ALEN] = {0};
9685 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9688 /* Initialize channel counters frequency value in hertz */
9689 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
9690 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
9692 ret = ath11k_peer_rhash_tbl_init(ab);
9696 device_get_mac_address(ab->dev, mac_addr);
9698 for (i = 0; i < ab->num_radios; i++) {
9699 pdev = &ab->pdevs[i];
9701 if (ab->pdevs_macaddr_valid) {
9702 ether_addr_copy(ar->mac_addr, pdev->mac_addr);
9704 if (is_zero_ether_addr(mac_addr))
9705 ether_addr_copy(ar->mac_addr, ab->mac_addr);
9707 ether_addr_copy(ar->mac_addr, mac_addr);
9708 ar->mac_addr[4] += i;
9711 idr_init(&ar->txmgmt_idr);
9712 spin_lock_init(&ar->txmgmt_idr_lock);
9714 ret = __ath11k_mac_register(ar);
9718 init_waitqueue_head(&ar->txmgmt_empty_waitq);
9724 for (i = i - 1; i >= 0; i--) {
9725 pdev = &ab->pdevs[i];
9727 __ath11k_mac_unregister(ar);
9730 ath11k_peer_rhash_tbl_destroy(ab);
9735 int ath11k_mac_allocate(struct ath11k_base *ab)
9737 struct ieee80211_hw *hw;
9739 struct ath11k_pdev *pdev;
9743 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9746 for (i = 0; i < ab->num_radios; i++) {
9747 pdev = &ab->pdevs[i];
9748 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9750 ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9760 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9762 ar->wmi = &ab->wmi_ab.wmi[i];
9763 /* FIXME wmi[0] is already initialized during attach,
9764 * Should we do this again?
9766 ath11k_wmi_pdev_attach(ab, i);
9768 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9769 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9770 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9771 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9774 spin_lock_init(&ar->data_lock);
9775 INIT_LIST_HEAD(&ar->arvifs);
9776 INIT_LIST_HEAD(&ar->ppdu_stats_info);
9777 mutex_init(&ar->conf_mutex);
9778 init_completion(&ar->vdev_setup_done);
9779 init_completion(&ar->vdev_delete_done);
9780 init_completion(&ar->peer_assoc_done);
9781 init_completion(&ar->peer_delete_done);
9782 init_completion(&ar->install_key_done);
9783 init_completion(&ar->bss_survey_done);
9784 init_completion(&ar->scan.started);
9785 init_completion(&ar->scan.completed);
9786 init_completion(&ar->scan.on_channel);
9787 init_completion(&ar->thermal.wmi_sync);
9789 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9790 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9792 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9793 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9795 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9797 ar->monitor_vdev_id = -1;
9798 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9799 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9800 init_completion(&ar->completed_11d_scan);
9802 ath11k_fw_stats_init(ar);
9808 ath11k_mac_destroy(ab);
9813 void ath11k_mac_destroy(struct ath11k_base *ab)
9816 struct ath11k_pdev *pdev;
9819 for (i = 0; i < ab->num_radios; i++) {
9820 pdev = &ab->pdevs[i];
9825 ath11k_fw_stats_free(&ar->fw_stats);
9826 ieee80211_free_hw(ar->hw);
9831 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9832 enum wmi_sta_keepalive_method method,
9835 struct ath11k *ar = arvif->ar;
9836 struct wmi_sta_keepalive_arg arg = {};
9839 lockdep_assert_held(&ar->conf_mutex);
9841 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9844 if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9847 arg.vdev_id = arvif->vdev_id;
9849 arg.method = method;
9850 arg.interval = interval;
9852 ret = ath11k_wmi_sta_keepalive(ar, &arg);
9854 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9855 arvif->vdev_id, ret);