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);
2300 /* Initialize rx_mcs_160 to 9 which is an invalid value */
2303 for (i = 7; i >= 0; i--) {
2304 u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
2306 if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2313 /* Initialize rx_mcs_80 to 9 which is an invalid value */
2315 for (i = 7; i >= 0; i--) {
2316 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
2318 if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2325 max_nss = min(rx_mcs_80, rx_mcs_160);
2327 max_nss = rx_mcs_80;
2329 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2331 memcpy_and_pad(&arg->peer_he_cap_macinfo,
2332 sizeof(arg->peer_he_cap_macinfo),
2333 he_cap->he_cap_elem.mac_cap_info,
2334 sizeof(he_cap->he_cap_elem.mac_cap_info),
2336 memcpy_and_pad(&arg->peer_he_cap_phyinfo,
2337 sizeof(arg->peer_he_cap_phyinfo),
2338 he_cap->he_cap_elem.phy_cap_info,
2339 sizeof(he_cap->he_cap_elem.phy_cap_info),
2341 arg->peer_he_ops = vif->bss_conf.he_oper.params;
2343 /* the top most byte is used to indicate BSS color info */
2344 arg->peer_he_ops &= 0xffffff;
2346 /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
2347 * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
2348 * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
2350 * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
2351 * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
2352 * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
2353 * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
2354 * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
2357 ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
2358 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);
2361 if (sta->deflink.vht_cap.vht_supported)
2362 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2364 else if (sta->deflink.ht_cap.ht_supported)
2365 arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
2369 if (he_cap->he_cap_elem.phy_cap_info[6] &
2370 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
2374 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
2375 IEEE80211_PPE_THRES_NSS_MASK;
2376 arg->peer_ppet.ru_bit_mask =
2377 (he_cap->ppe_thres[0] &
2378 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
2379 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
2381 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
2382 for (ru = 0; ru < 4; ru++) {
2386 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
2388 for (i = 0; i < 6; i++) {
2390 val |= ((he_cap->ppe_thres[bit / 8] >>
2391 (bit % 8)) & 0x1) << 5;
2394 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
2400 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
2401 arg->twt_responder = true;
2402 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
2403 arg->twt_requester = true;
2405 he_nss = ath11k_mac_max_he_nss(he_mcs_mask);
2407 if (he_nss > sta->deflink.rx_nss) {
2408 user_rate_valid = false;
2409 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2410 if (he_mcs_mask[nss_idx]) {
2411 user_rate_valid = true;
2417 if (!user_rate_valid) {
2418 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting he range mcs value to peer supported nss %d for peer %pM\n",
2419 sta->deflink.rx_nss, sta->addr);
2420 he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1];
2423 switch (sta->deflink.bandwidth) {
2424 case IEEE80211_STA_RX_BW_160:
2425 if (he_cap->he_cap_elem.phy_cap_info[0] &
2426 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2427 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
2428 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2429 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2431 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
2432 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2434 arg->peer_he_mcs_count++;
2437 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2438 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2440 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
2441 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2442 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2444 arg->peer_he_mcs_count++;
2450 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2451 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2453 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
2454 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2455 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2457 arg->peer_he_mcs_count++;
2463 /* Calculate peer NSS capability from HE capabilities if STA
2466 for (i = 0, max_nss = 0; i < NL80211_HE_NSS_MAX; i++) {
2467 he_mcs = he_tx_mcs >> (2 * i) & 3;
2469 /* In case of fixed rates, MCS Range in he_tx_mcs might have
2470 * unsupported range, with he_mcs_mask set, so check either of them
2473 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2477 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2479 if (arg->peer_phymode == MODE_11AX_HE160 ||
2480 arg->peer_phymode == MODE_11AX_HE80_80) {
2481 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2482 rx_nss = min(arg->peer_nss, tx_nss);
2483 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2486 ath11k_warn(ar->ab, "invalid max_nss\n");
2490 if (arg->peer_phymode == MODE_11AX_HE160)
2491 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2493 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2495 arg->peer_bw_rxnss_override |= nss_160;
2498 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2499 "he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
2500 sta->addr, arg->peer_nss,
2501 arg->peer_he_mcs_count,
2502 arg->peer_bw_rxnss_override);
2505 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
2506 struct ieee80211_vif *vif,
2507 struct ieee80211_sta *sta,
2508 struct peer_assoc_params *arg)
2510 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2511 struct cfg80211_chan_def def;
2512 enum nl80211_band band;
2515 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2518 band = def.chan->band;
2520 if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa)
2523 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2526 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2529 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2532 arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa);
2533 arg->peer_mpdu_density =
2534 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2535 arg->peer_he_caps_6ghz));
2537 /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2538 * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2539 * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2540 * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2541 * Band Capabilities element in the 6 GHz band.
2543 * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2544 * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2546 ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2547 he_cap->he_cap_elem.mac_cap_info[3]) +
2548 FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2549 arg->peer_he_caps_6ghz);
2551 arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2555 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2556 struct peer_assoc_params *arg)
2558 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2561 if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa)
2564 if (ht_cap->ht_supported) {
2565 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2566 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2568 smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
2569 IEEE80211_HE_6GHZ_CAP_SM_PS);
2573 case WLAN_HT_CAP_SM_PS_STATIC:
2574 arg->static_mimops_flag = true;
2576 case WLAN_HT_CAP_SM_PS_DYNAMIC:
2577 arg->dynamic_mimops_flag = true;
2579 case WLAN_HT_CAP_SM_PS_DISABLED:
2580 arg->spatial_mux_flag = true;
2587 static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
2588 struct ieee80211_vif *vif,
2589 struct ieee80211_sta *sta,
2590 struct peer_assoc_params *arg)
2592 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2594 switch (arvif->vdev_type) {
2595 case WMI_VDEV_TYPE_AP:
2597 /* TODO: Check WME vs QoS */
2598 arg->is_wme_set = true;
2599 arg->qos_flag = true;
2602 if (sta->wme && sta->uapsd_queues) {
2603 /* TODO: Check WME vs QoS */
2604 arg->is_wme_set = true;
2605 arg->apsd_flag = true;
2606 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
2609 case WMI_VDEV_TYPE_STA:
2611 arg->is_wme_set = true;
2612 arg->qos_flag = true;
2619 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM qos %d\n",
2620 sta->addr, arg->qos_flag);
2623 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
2624 struct ath11k_vif *arvif,
2625 struct ieee80211_sta *sta)
2627 struct ap_ps_params params;
2632 lockdep_assert_held(&ar->conf_mutex);
2634 params.vdev_id = arvif->vdev_id;
2636 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "uapsd_queues 0x%x max_sp %d\n",
2637 sta->uapsd_queues, sta->max_sp);
2640 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2641 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2642 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2643 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2644 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2645 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2646 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2647 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2648 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2649 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2650 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2651 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2654 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2655 max_sp = sta->max_sp;
2657 params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
2658 params.value = uapsd;
2659 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2663 params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
2664 params.value = max_sp;
2665 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2669 /* TODO revisit during testing */
2670 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
2671 params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2672 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2676 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
2677 params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2678 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms);
2685 ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
2686 params.param, arvif->vdev_id, ret);
2690 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2692 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2693 ATH11K_MAC_FIRST_OFDM_RATE_IDX;
2696 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
2697 struct ieee80211_sta *sta)
2699 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2700 switch (sta->deflink.vht_cap.cap &
2701 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2702 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2703 return MODE_11AC_VHT160;
2704 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2705 return MODE_11AC_VHT80_80;
2707 /* not sure if this is a valid case? */
2708 return MODE_11AC_VHT160;
2712 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2713 return MODE_11AC_VHT80;
2715 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2716 return MODE_11AC_VHT40;
2718 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2719 return MODE_11AC_VHT20;
2721 return MODE_UNKNOWN;
2724 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
2725 struct ieee80211_sta *sta)
2727 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2728 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2729 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2730 return MODE_11AX_HE160;
2731 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2732 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2733 return MODE_11AX_HE80_80;
2734 /* not sure if this is a valid case? */
2735 return MODE_11AX_HE160;
2738 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2739 return MODE_11AX_HE80;
2741 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2742 return MODE_11AX_HE40;
2744 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2745 return MODE_11AX_HE20;
2747 return MODE_UNKNOWN;
2750 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
2751 struct ieee80211_vif *vif,
2752 struct ieee80211_sta *sta,
2753 struct peer_assoc_params *arg)
2755 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2756 struct cfg80211_chan_def def;
2757 enum nl80211_band band;
2758 const u8 *ht_mcs_mask;
2759 const u16 *vht_mcs_mask;
2760 const u16 *he_mcs_mask;
2761 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2763 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2766 band = def.chan->band;
2767 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2768 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2769 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2772 case NL80211_BAND_2GHZ:
2773 if (sta->deflink.he_cap.has_he &&
2774 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2775 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2776 phymode = MODE_11AX_HE80_2G;
2777 else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2778 phymode = MODE_11AX_HE40_2G;
2780 phymode = MODE_11AX_HE20_2G;
2781 } else if (sta->deflink.vht_cap.vht_supported &&
2782 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2783 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2784 phymode = MODE_11AC_VHT40;
2786 phymode = MODE_11AC_VHT20;
2787 } else if (sta->deflink.ht_cap.ht_supported &&
2788 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2789 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2790 phymode = MODE_11NG_HT40;
2792 phymode = MODE_11NG_HT20;
2793 } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2799 case NL80211_BAND_5GHZ:
2800 case NL80211_BAND_6GHZ:
2801 /* Check HE first */
2802 if (sta->deflink.he_cap.has_he &&
2803 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2804 phymode = ath11k_mac_get_phymode_he(ar, sta);
2805 } else if (sta->deflink.vht_cap.vht_supported &&
2806 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2807 phymode = ath11k_mac_get_phymode_vht(ar, sta);
2808 } else if (sta->deflink.ht_cap.ht_supported &&
2809 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2810 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2811 phymode = MODE_11NA_HT40;
2813 phymode = MODE_11NA_HT20;
2822 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM phymode %s\n",
2823 sta->addr, ath11k_wmi_phymode_str(phymode));
2825 arg->peer_phymode = phymode;
2826 WARN_ON(phymode == MODE_UNKNOWN);
2829 static void ath11k_peer_assoc_prepare(struct ath11k *ar,
2830 struct ieee80211_vif *vif,
2831 struct ieee80211_sta *sta,
2832 struct peer_assoc_params *arg,
2835 struct ath11k_sta *arsta;
2837 lockdep_assert_held(&ar->conf_mutex);
2839 arsta = ath11k_sta_to_arsta(sta);
2841 memset(arg, 0, sizeof(*arg));
2843 reinit_completion(&ar->peer_assoc_done);
2845 arg->peer_new_assoc = !reassoc;
2846 ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
2847 ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
2848 ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
2849 ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
2850 ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
2851 ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
2852 ath11k_peer_assoc_h_he(ar, vif, sta, arg);
2853 ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
2854 ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
2855 ath11k_peer_assoc_h_smps(sta, arg);
2857 arsta->peer_nss = arg->peer_nss;
2859 /* TODO: amsdu_disable req? */
2862 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
2864 const struct ieee80211_sta_ht_cap *ht_cap,
2869 if (!ht_cap->ht_supported && !he_6ghz_capa)
2872 if (ht_cap->ht_supported) {
2873 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2874 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2876 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
2879 if (smps >= ARRAY_SIZE(ath11k_smps_map))
2882 return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2883 WMI_PEER_MIMO_PS_STATE,
2884 ath11k_smps_map[smps]);
2887 static bool ath11k_mac_set_he_txbf_conf(struct ath11k_vif *arvif)
2889 struct ath11k *ar = arvif->ar;
2893 if (!arvif->vif->bss_conf.he_support)
2896 param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2898 if (arvif->vif->bss_conf.he_su_beamformer) {
2899 value |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2900 if (arvif->vif->bss_conf.he_mu_beamformer &&
2901 arvif->vdev_type == WMI_VDEV_TYPE_AP)
2902 value |= FIELD_PREP(HE_MODE_MU_TX_BFER, HE_MU_BFER_ENABLE);
2905 if (arvif->vif->type != NL80211_IFTYPE_MESH_POINT) {
2906 value |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2907 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2909 if (arvif->vif->bss_conf.he_full_ul_mumimo)
2910 value |= FIELD_PREP(HE_MODE_UL_MUMIMO, HE_UL_MUMIMO_ENABLE);
2912 if (arvif->vif->bss_conf.he_su_beamformee)
2913 value |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2916 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, value);
2918 ath11k_warn(ar->ab, "failed to set vdev %d HE MU mode: %d\n",
2919 arvif->vdev_id, ret);
2923 param = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
2924 value = FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
2925 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
2926 HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
2927 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2930 ath11k_warn(ar->ab, "failed to set vdev %d sounding mode: %d\n",
2931 arvif->vdev_id, ret);
2937 static bool ath11k_mac_vif_recalc_sta_he_txbf(struct ath11k *ar,
2938 struct ieee80211_vif *vif,
2939 struct ieee80211_sta_he_cap *he_cap)
2941 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2942 struct ieee80211_he_cap_elem he_cap_elem = {0};
2943 struct ieee80211_sta_he_cap *cap_band = NULL;
2944 struct cfg80211_chan_def def;
2945 u32 param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2949 if (!vif->bss_conf.he_support)
2952 if (vif->type != NL80211_IFTYPE_STATION)
2955 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2958 if (def.chan->band == NL80211_BAND_2GHZ)
2959 cap_band = &ar->mac.iftype[NL80211_BAND_2GHZ][vif->type].he_cap;
2961 cap_band = &ar->mac.iftype[NL80211_BAND_5GHZ][vif->type].he_cap;
2963 memcpy(&he_cap_elem, &cap_band->he_cap_elem, sizeof(he_cap_elem));
2965 if (HECAP_PHY_SUBFME_GET(he_cap_elem.phy_cap_info)) {
2966 if (HECAP_PHY_SUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2967 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2968 if (HECAP_PHY_MUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2969 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
2972 if (vif->type != NL80211_IFTYPE_MESH_POINT) {
2973 hemode |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2974 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2976 if (HECAP_PHY_ULMUMIMO_GET(he_cap_elem.phy_cap_info))
2977 if (HECAP_PHY_ULMUMIMO_GET(he_cap->he_cap_elem.phy_cap_info))
2978 hemode |= FIELD_PREP(HE_MODE_UL_MUMIMO,
2979 HE_UL_MUMIMO_ENABLE);
2981 if (FIELD_GET(HE_MODE_MU_TX_BFEE, hemode))
2982 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2984 if (FIELD_GET(HE_MODE_MU_TX_BFER, hemode))
2985 hemode |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2988 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, hemode);
2990 ath11k_warn(ar->ab, "failed to submit vdev param txbf 0x%x: %d\n",
2998 static void ath11k_bss_assoc(struct ieee80211_hw *hw,
2999 struct ieee80211_vif *vif,
3000 struct ieee80211_bss_conf *bss_conf)
3002 struct ath11k *ar = hw->priv;
3003 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3004 struct peer_assoc_params peer_arg;
3005 struct ieee80211_sta *ap_sta;
3006 struct ath11k_peer *peer;
3007 bool is_auth = false;
3008 struct ieee80211_sta_he_cap he_cap;
3011 lockdep_assert_held(&ar->conf_mutex);
3013 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i assoc bssid %pM aid %d\n",
3014 arvif->vdev_id, arvif->bssid, arvif->aid);
3018 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
3020 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
3021 bss_conf->bssid, arvif->vdev_id);
3026 /* he_cap here is updated at assoc success for sta mode only */
3027 he_cap = ap_sta->deflink.he_cap;
3029 ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
3033 if (!ath11k_mac_vif_recalc_sta_he_txbf(ar, vif, &he_cap)) {
3034 ath11k_warn(ar->ab, "failed to recalc he txbf for vdev %i on bss %pM\n",
3035 arvif->vdev_id, bss_conf->bssid);
3039 peer_arg.is_assoc = true;
3041 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
3043 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
3044 bss_conf->bssid, arvif->vdev_id, ret);
3048 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
3049 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
3050 bss_conf->bssid, arvif->vdev_id);
3054 ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
3055 &ap_sta->deflink.ht_cap,
3056 le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa));
3058 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
3059 arvif->vdev_id, ret);
3063 WARN_ON(arvif->is_up);
3065 arvif->aid = vif->cfg.aid;
3066 ether_addr_copy(arvif->bssid, bss_conf->bssid);
3068 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid,
3071 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
3072 arvif->vdev_id, ret);
3076 arvif->is_up = true;
3077 arvif->rekey_data.enable_offload = false;
3079 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3080 "vdev %d up (associated) bssid %pM aid %d\n",
3081 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
3083 spin_lock_bh(&ar->ab->base_lock);
3085 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
3086 if (peer && peer->is_authorized)
3089 spin_unlock_bh(&ar->ab->base_lock);
3092 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
3097 ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
3100 ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
3101 &bss_conf->he_obss_pd);
3103 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
3104 arvif->vdev_id, ret);
3106 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3107 WMI_VDEV_PARAM_DTIM_POLICY,
3108 WMI_DTIM_POLICY_STICK);
3110 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
3111 arvif->vdev_id, ret);
3113 ath11k_mac_11d_scan_stop_all(ar->ab);
3116 static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
3117 struct ieee80211_vif *vif)
3119 struct ath11k *ar = hw->priv;
3120 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3123 lockdep_assert_held(&ar->conf_mutex);
3125 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i disassoc bssid %pM\n",
3126 arvif->vdev_id, arvif->bssid);
3128 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
3130 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
3131 arvif->vdev_id, ret);
3133 arvif->is_up = false;
3135 memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
3137 cancel_delayed_work_sync(&arvif->connection_loss_work);
3140 static u32 ath11k_mac_get_rate_hw_value(int bitrate)
3147 if (ath11k_mac_bitrate_is_cck(bitrate))
3148 preamble = WMI_RATE_PREAMBLE_CCK;
3150 preamble = WMI_RATE_PREAMBLE_OFDM;
3152 for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
3153 if (ath11k_legacy_rates[i].bitrate != bitrate)
3156 hw_value = ath11k_legacy_rates[i].hw_value;
3157 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3165 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
3166 struct ieee80211_vif *vif,
3167 struct cfg80211_chan_def *def)
3169 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3170 const struct ieee80211_supported_band *sband;
3177 lockdep_assert_held(&ar->conf_mutex);
3179 sband = ar->hw->wiphy->bands[def->chan->band];
3180 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
3181 bitrate = sband->bitrates[basic_rate_idx].bitrate;
3183 hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
3184 if (hw_rate_code < 0) {
3185 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
3189 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
3190 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3193 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
3195 /* For WCN6855, firmware will clear this param when vdev starts, hence
3196 * cache it here so that we can reconfigure it once vdev starts.
3198 ar->hw_rate_code = hw_rate_code;
3200 vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
3201 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3204 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
3207 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
3208 struct ieee80211_bss_conf *info)
3210 struct ath11k *ar = arvif->ar;
3211 struct sk_buff *tmpl;
3214 bool unsol_bcast_probe_resp_enabled = false;
3216 if (info->fils_discovery.max_interval) {
3217 interval = info->fils_discovery.max_interval;
3219 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
3221 ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
3223 } else if (info->unsol_bcast_probe_resp_interval) {
3224 unsol_bcast_probe_resp_enabled = 1;
3225 interval = info->unsol_bcast_probe_resp_interval;
3227 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
3230 ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
3232 } else { /* Disable */
3233 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
3238 "mac vdev %i failed to retrieve %s template\n",
3239 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
3240 "unsolicited broadcast probe response" :
3247 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
3248 unsol_bcast_probe_resp_enabled);
3253 static int ath11k_mac_config_obss_pd(struct ath11k *ar,
3254 struct ieee80211_he_obss_pd *he_obss_pd)
3256 u32 bitmap[2], param_id, param_val, pdev_id;
3258 s8 non_srg_th = 0, srg_th = 0;
3260 pdev_id = ar->pdev->pdev_id;
3262 /* Set and enable SRG/non-SRG OBSS PD Threshold */
3263 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
3264 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
3265 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
3268 "failed to set obss_pd_threshold for pdev: %u\n",
3273 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3274 "obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
3275 he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
3276 he_obss_pd->max_offset);
3280 if (he_obss_pd->sr_ctrl &
3281 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
3282 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
3284 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
3285 non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
3286 he_obss_pd->non_srg_max_offset);
3288 non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;
3290 param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
3293 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
3294 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
3295 param_val |= ATH11K_OBSS_PD_SRG_EN;
3298 if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3299 ar->ab->wmi_ab.svc_map)) {
3300 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
3301 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
3303 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
3304 /* SRG not supported and threshold in dB */
3305 param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
3306 ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
3309 param_val |= (non_srg_th & GENMASK(7, 0));
3310 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3313 "failed to set obss_pd_threshold for pdev: %u\n",
3318 /* Enable OBSS PD for all access category */
3319 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
3321 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3324 "failed to set obss_pd_per_ac for pdev: %u\n",
3329 /* Set SR Prohibit */
3330 param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
3331 param_val = !!(he_obss_pd->sr_ctrl &
3332 IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
3333 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3335 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",
3340 if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3341 ar->ab->wmi_ab.svc_map))
3344 /* Set SRG BSS Color Bitmap */
3345 memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
3346 ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);
3349 "failed to set bss_color_bitmap for pdev: %u\n",
3354 /* Set SRG Partial BSSID Bitmap */
3355 memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
3356 ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);
3359 "failed to set partial_bssid_bitmap for pdev: %u\n",
3364 memset(bitmap, 0xff, sizeof(bitmap));
3366 /* Enable all BSS Colors for SRG */
3367 ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);
3370 "failed to set srg_color_en_bitmap pdev: %u\n",
3375 /* Enable all partial BSSID mask for SRG */
3376 ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);
3379 "failed to set srg_bssid_en_bitmap pdev: %u\n",
3384 /* Enable all BSS Colors for non-SRG */
3385 ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);
3388 "failed to set non_srg_color_en_bitmap pdev: %u\n",
3393 /* Enable all partial BSSID mask for non-SRG */
3394 ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);
3397 "failed to set non_srg_bssid_en_bitmap pdev: %u\n",
3405 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
3406 struct ieee80211_vif *vif,
3407 struct ieee80211_bss_conf *info,
3410 struct ath11k *ar = hw->priv;
3411 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3412 struct cfg80211_chan_def def;
3413 u32 param_id, param_value;
3414 enum nl80211_band band;
3425 mutex_lock(&ar->conf_mutex);
3427 if (changed & BSS_CHANGED_BEACON_INT) {
3428 arvif->beacon_interval = info->beacon_int;
3430 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
3431 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3433 arvif->beacon_interval);
3435 ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
3438 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3439 "Beacon interval: %d set for VDEV: %d\n",
3440 arvif->beacon_interval, arvif->vdev_id);
3443 if (changed & BSS_CHANGED_BEACON) {
3444 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
3445 param_value = WMI_BEACON_STAGGERED_MODE;
3446 ret = ath11k_wmi_pdev_set_param(ar, param_id,
3447 param_value, ar->pdev->pdev_id);
3449 ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
3452 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3453 "Set staggered beacon mode for VDEV: %d\n",
3456 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) {
3457 ret = ath11k_mac_setup_bcn_tmpl(arvif);
3459 ath11k_warn(ar->ab, "failed to update bcn template: %d\n",
3463 if (arvif->bcca_zero_sent)
3464 arvif->do_not_send_tmpl = true;
3466 arvif->do_not_send_tmpl = false;
3468 if (vif->bss_conf.he_support) {
3469 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3470 WMI_VDEV_PARAM_BA_MODE,
3471 WMI_BA_MODE_BUFFER_SIZE_256);
3474 "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3477 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3478 "Set BA BUFFER SIZE 256 for VDEV: %d\n",
3483 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3484 arvif->dtim_period = info->dtim_period;
3486 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3487 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3489 arvif->dtim_period);
3492 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3493 arvif->vdev_id, ret);
3495 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3496 "DTIM period: %d set for VDEV: %d\n",
3497 arvif->dtim_period, arvif->vdev_id);
3500 if (changed & BSS_CHANGED_SSID &&
3501 vif->type == NL80211_IFTYPE_AP) {
3502 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
3503 if (vif->cfg.ssid_len)
3504 memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
3506 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3509 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3510 ether_addr_copy(arvif->bssid, info->bssid);
3512 if (changed & BSS_CHANGED_BEACON_ENABLED) {
3513 if (info->enable_beacon)
3514 ath11k_mac_set_he_txbf_conf(arvif);
3515 ath11k_control_beaconing(arvif, info);
3517 if (arvif->is_up && vif->bss_conf.he_support &&
3518 vif->bss_conf.he_oper.params) {
3519 param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3520 param_value = vif->bss_conf.he_oper.params;
3521 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3522 param_id, param_value);
3523 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3524 "he oper param: %x set for VDEV: %d\n",
3525 param_value, arvif->vdev_id);
3528 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3529 param_value, arvif->vdev_id, ret);
3533 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3536 cts_prot = !!(info->use_cts_prot);
3537 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3539 if (arvif->is_started) {
3540 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3541 param_id, cts_prot);
3543 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3546 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3547 cts_prot, arvif->vdev_id);
3549 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3553 if (changed & BSS_CHANGED_ERP_SLOT) {
3556 if (info->use_short_slot)
3557 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3560 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3562 param_id = WMI_VDEV_PARAM_SLOT_TIME;
3563 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3564 param_id, slottime);
3566 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3569 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3570 "Set slottime: %d for VDEV: %d\n",
3571 slottime, arvif->vdev_id);
3574 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3577 if (info->use_short_preamble)
3578 preamble = WMI_VDEV_PREAMBLE_SHORT;
3580 preamble = WMI_VDEV_PREAMBLE_LONG;
3582 param_id = WMI_VDEV_PARAM_PREAMBLE;
3583 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3584 param_id, preamble);
3586 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3589 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3590 "Set preamble: %d for VDEV: %d\n",
3591 preamble, arvif->vdev_id);
3594 if (changed & BSS_CHANGED_ASSOC) {
3596 ath11k_bss_assoc(hw, vif, info);
3598 ath11k_bss_disassoc(hw, vif);
3601 if (changed & BSS_CHANGED_TXPOWER) {
3602 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev_id %i txpower %d\n",
3603 arvif->vdev_id, info->txpower);
3605 arvif->txpower = info->txpower;
3606 ath11k_mac_txpower_recalc(ar);
3609 if (changed & BSS_CHANGED_PS &&
3610 ar->ab->hw_params.supports_sta_ps) {
3611 arvif->ps = vif->cfg.ps;
3613 ret = ath11k_mac_config_ps(ar);
3615 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3616 arvif->vdev_id, ret);
3619 if (changed & BSS_CHANGED_MCAST_RATE &&
3620 !ath11k_mac_vif_chan(arvif->vif, &def)) {
3621 band = def.chan->band;
3622 mcast_rate = vif->bss_conf.mcast_rate[band];
3625 rateidx = mcast_rate - 1;
3627 rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3629 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3630 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3632 bitrate = ath11k_legacy_rates[rateidx].bitrate;
3633 hw_value = ath11k_legacy_rates[rateidx].hw_value;
3635 if (ath11k_mac_bitrate_is_cck(bitrate))
3636 preamble = WMI_RATE_PREAMBLE_CCK;
3638 preamble = WMI_RATE_PREAMBLE_OFDM;
3640 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3642 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3643 "vdev %d mcast_rate %x\n",
3644 arvif->vdev_id, rate);
3646 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3647 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3651 "failed to set mcast rate on vdev %i: %d\n",
3652 arvif->vdev_id, ret);
3654 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3655 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3659 "failed to set bcast rate on vdev %i: %d\n",
3660 arvif->vdev_id, ret);
3663 if (changed & BSS_CHANGED_BASIC_RATES &&
3664 !ath11k_mac_vif_chan(arvif->vif, &def))
3665 ath11k_recalculate_mgmt_rate(ar, vif, &def);
3667 if (changed & BSS_CHANGED_TWT) {
3668 struct wmi_twt_enable_params twt_params = {0};
3670 if (info->twt_requester || info->twt_responder) {
3671 ath11k_wmi_fill_default_twt_params(&twt_params);
3672 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id,
3675 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
3679 if (changed & BSS_CHANGED_HE_OBSS_PD)
3680 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3682 if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3683 if (vif->type == NL80211_IFTYPE_AP) {
3684 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3685 ar, arvif->vdev_id, info->he_bss_color.color,
3686 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
3687 info->he_bss_color.enabled);
3689 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3690 arvif->vdev_id, ret);
3692 param_id = WMI_VDEV_PARAM_BSS_COLOR;
3693 if (info->he_bss_color.enabled)
3694 param_value = info->he_bss_color.color <<
3695 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3697 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3699 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3704 "failed to set bss color param on vdev %i: %d\n",
3705 arvif->vdev_id, ret);
3707 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3708 "bss color param 0x%x set on vdev %i\n",
3709 param_value, arvif->vdev_id);
3710 } else if (vif->type == NL80211_IFTYPE_STATION) {
3711 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3715 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3716 arvif->vdev_id, ret);
3717 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3718 ar, arvif->vdev_id, 0,
3719 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3721 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3722 arvif->vdev_id, ret);
3726 if (changed & BSS_CHANGED_FTM_RESPONDER &&
3727 arvif->ftm_responder != info->ftm_responder &&
3728 test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map) &&
3729 (vif->type == NL80211_IFTYPE_AP ||
3730 vif->type == NL80211_IFTYPE_MESH_POINT)) {
3731 arvif->ftm_responder = info->ftm_responder;
3732 param = WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE;
3733 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
3734 arvif->ftm_responder);
3736 ath11k_warn(ar->ab, "Failed to set ftm responder %i: %d\n",
3737 arvif->vdev_id, ret);
3740 if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3741 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3742 ath11k_mac_fils_discovery(arvif, info);
3744 if (changed & BSS_CHANGED_ARP_FILTER) {
3745 ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3746 memcpy(arvif->arp_ns_offload.ipv4_addr,
3747 vif->cfg.arp_addr_list,
3748 ipv4_cnt * sizeof(u32));
3749 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3750 arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3752 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3753 vif->cfg.arp_addr_cnt,
3754 vif->addr, arvif->arp_ns_offload.ipv4_addr);
3757 mutex_unlock(&ar->conf_mutex);
3760 void __ath11k_mac_scan_finish(struct ath11k *ar)
3762 lockdep_assert_held(&ar->data_lock);
3764 switch (ar->scan.state) {
3765 case ATH11K_SCAN_IDLE:
3767 case ATH11K_SCAN_RUNNING:
3768 case ATH11K_SCAN_ABORTING:
3769 if (ar->scan.is_roc && ar->scan.roc_notify)
3770 ieee80211_remain_on_channel_expired(ar->hw);
3772 case ATH11K_SCAN_STARTING:
3773 if (!ar->scan.is_roc) {
3774 struct cfg80211_scan_info info = {
3775 .aborted = ((ar->scan.state ==
3776 ATH11K_SCAN_ABORTING) ||
3778 ATH11K_SCAN_STARTING)),
3781 ieee80211_scan_completed(ar->hw, &info);
3784 ar->scan.state = ATH11K_SCAN_IDLE;
3785 ar->scan_channel = NULL;
3786 ar->scan.roc_freq = 0;
3787 cancel_delayed_work(&ar->scan.timeout);
3788 complete_all(&ar->scan.completed);
3793 void ath11k_mac_scan_finish(struct ath11k *ar)
3795 spin_lock_bh(&ar->data_lock);
3796 __ath11k_mac_scan_finish(ar);
3797 spin_unlock_bh(&ar->data_lock);
3800 static int ath11k_scan_stop(struct ath11k *ar)
3802 struct scan_cancel_param arg = {
3803 .req_type = WLAN_SCAN_CANCEL_SINGLE,
3804 .scan_id = ATH11K_SCAN_ID,
3808 lockdep_assert_held(&ar->conf_mutex);
3810 /* TODO: Fill other STOP Params */
3811 arg.pdev_id = ar->pdev->pdev_id;
3813 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3815 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3819 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3822 "failed to receive scan abort comple: timed out\n");
3824 } else if (ret > 0) {
3829 /* Scan state should be updated upon scan completion but in case
3830 * firmware fails to deliver the event (for whatever reason) it is
3831 * desired to clean up scan state anyway. Firmware may have just
3832 * dropped the scan completion event delivery due to transport pipe
3833 * being overflown with data and/or it can recover on its own before
3834 * next scan request is submitted.
3836 spin_lock_bh(&ar->data_lock);
3837 if (ar->scan.state != ATH11K_SCAN_IDLE)
3838 __ath11k_mac_scan_finish(ar);
3839 spin_unlock_bh(&ar->data_lock);
3844 static void ath11k_scan_abort(struct ath11k *ar)
3848 lockdep_assert_held(&ar->conf_mutex);
3850 spin_lock_bh(&ar->data_lock);
3852 switch (ar->scan.state) {
3853 case ATH11K_SCAN_IDLE:
3854 /* This can happen if timeout worker kicked in and called
3855 * abortion while scan completion was being processed.
3858 case ATH11K_SCAN_STARTING:
3859 case ATH11K_SCAN_ABORTING:
3860 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3863 case ATH11K_SCAN_RUNNING:
3864 ar->scan.state = ATH11K_SCAN_ABORTING;
3865 spin_unlock_bh(&ar->data_lock);
3867 ret = ath11k_scan_stop(ar);
3869 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3871 spin_lock_bh(&ar->data_lock);
3875 spin_unlock_bh(&ar->data_lock);
3878 static void ath11k_scan_timeout_work(struct work_struct *work)
3880 struct ath11k *ar = container_of(work, struct ath11k,
3883 mutex_lock(&ar->conf_mutex);
3884 ath11k_scan_abort(ar);
3885 mutex_unlock(&ar->conf_mutex);
3888 static int ath11k_start_scan(struct ath11k *ar,
3889 struct scan_req_params *arg)
3892 unsigned long timeout = 1 * HZ;
3894 lockdep_assert_held(&ar->conf_mutex);
3896 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3897 ath11k_spectral_reset_buffer(ar);
3899 ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3903 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3906 if (ar->supports_6ghz)
3910 ret = wait_for_completion_timeout(&ar->scan.started, timeout);
3912 ret = ath11k_scan_stop(ar);
3914 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3919 /* If we failed to start the scan, return error code at
3920 * this point. This is probably due to some issue in the
3921 * firmware, but no need to wedge the driver due to that...
3923 spin_lock_bh(&ar->data_lock);
3924 if (ar->scan.state == ATH11K_SCAN_IDLE) {
3925 spin_unlock_bh(&ar->data_lock);
3928 spin_unlock_bh(&ar->data_lock);
3933 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3934 struct ieee80211_vif *vif,
3935 struct ieee80211_scan_request *hw_req)
3937 struct ath11k *ar = hw->priv;
3938 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3939 struct cfg80211_scan_request *req = &hw_req->req;
3940 struct scan_req_params *arg = NULL;
3945 /* Firmwares advertising the support of triggering 11D algorithm
3946 * on the scan results of a regular scan expects driver to send
3947 * WMI_11D_SCAN_START_CMDID before sending WMI_START_SCAN_CMDID.
3948 * With this feature, separate 11D scan can be avoided since
3949 * regdomain can be determined with the scan results of the
3952 if (ar->state_11d == ATH11K_11D_PREPARING &&
3953 test_bit(WMI_TLV_SERVICE_SUPPORT_11D_FOR_HOST_SCAN,
3954 ar->ab->wmi_ab.svc_map))
3955 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3957 mutex_lock(&ar->conf_mutex);
3959 spin_lock_bh(&ar->data_lock);
3960 switch (ar->scan.state) {
3961 case ATH11K_SCAN_IDLE:
3962 reinit_completion(&ar->scan.started);
3963 reinit_completion(&ar->scan.completed);
3964 ar->scan.state = ATH11K_SCAN_STARTING;
3965 ar->scan.is_roc = false;
3966 ar->scan.vdev_id = arvif->vdev_id;
3969 case ATH11K_SCAN_STARTING:
3970 case ATH11K_SCAN_RUNNING:
3971 case ATH11K_SCAN_ABORTING:
3975 spin_unlock_bh(&ar->data_lock);
3980 arg = kzalloc(sizeof(*arg), GFP_KERNEL);
3987 ath11k_wmi_start_scan_init(ar, arg);
3988 arg->vdev_id = arvif->vdev_id;
3989 arg->scan_id = ATH11K_SCAN_ID;
3992 arg->extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3993 if (!arg->extraie.ptr) {
3997 arg->extraie.len = req->ie_len;
4001 arg->num_ssids = req->n_ssids;
4002 for (i = 0; i < arg->num_ssids; i++) {
4003 arg->ssid[i].length = req->ssids[i].ssid_len;
4004 memcpy(&arg->ssid[i].ssid, req->ssids[i].ssid,
4005 req->ssids[i].ssid_len);
4008 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
4011 if (req->n_channels) {
4012 arg->num_chan = req->n_channels;
4013 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
4016 if (!arg->chan_list) {
4021 for (i = 0; i < arg->num_chan; i++) {
4022 if (test_bit(WMI_TLV_SERVICE_SCAN_CONFIG_PER_CHANNEL,
4023 ar->ab->wmi_ab.svc_map)) {
4025 u32_encode_bits(req->channels[i]->center_freq,
4026 WMI_SCAN_CONFIG_PER_CHANNEL_MASK);
4028 /* If NL80211_SCAN_FLAG_COLOCATED_6GHZ is set in scan
4029 * flags, then scan all PSC channels in 6 GHz band and
4030 * those non-PSC channels where RNR IE is found during
4031 * the legacy 2.4/5 GHz scan.
4032 * If NL80211_SCAN_FLAG_COLOCATED_6GHZ is not set,
4033 * then all channels in 6 GHz will be scanned.
4035 if (req->channels[i]->band == NL80211_BAND_6GHZ &&
4036 req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ &&
4037 !cfg80211_channel_is_psc(req->channels[i]))
4038 arg->chan_list[i] |=
4039 WMI_SCAN_CH_FLAG_SCAN_ONLY_IF_RNR_FOUND;
4041 arg->chan_list[i] = req->channels[i]->center_freq;
4046 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
4047 arg->scan_f_add_spoofed_mac_in_probe = 1;
4048 ether_addr_copy(arg->mac_addr.addr, req->mac_addr);
4049 ether_addr_copy(arg->mac_mask.addr, req->mac_addr_mask);
4052 /* if duration is set, default dwell times will be overwritten */
4053 if (req->duration) {
4054 arg->dwell_time_active = req->duration;
4055 arg->dwell_time_active_2g = req->duration;
4056 arg->dwell_time_active_6g = req->duration;
4057 arg->dwell_time_passive = req->duration;
4058 arg->dwell_time_passive_6g = req->duration;
4059 arg->burst_duration = req->duration;
4061 scan_timeout = min_t(u32, arg->max_rest_time *
4062 (arg->num_chan - 1) + (req->duration +
4063 ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *
4064 arg->num_chan, arg->max_scan_time);
4066 scan_timeout = arg->max_scan_time;
4069 /* Add a margin to account for event/command processing */
4070 scan_timeout += ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD;
4072 ret = ath11k_start_scan(ar, arg);
4074 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
4075 spin_lock_bh(&ar->data_lock);
4076 ar->scan.state = ATH11K_SCAN_IDLE;
4077 spin_unlock_bh(&ar->data_lock);
4080 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4081 msecs_to_jiffies(scan_timeout));
4085 kfree(arg->chan_list);
4086 kfree(arg->extraie.ptr);
4090 mutex_unlock(&ar->conf_mutex);
4092 if (ar->state_11d == ATH11K_11D_PREPARING)
4093 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
4098 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
4099 struct ieee80211_vif *vif)
4101 struct ath11k *ar = hw->priv;
4103 mutex_lock(&ar->conf_mutex);
4104 ath11k_scan_abort(ar);
4105 mutex_unlock(&ar->conf_mutex);
4107 cancel_delayed_work_sync(&ar->scan.timeout);
4110 static int ath11k_install_key(struct ath11k_vif *arvif,
4111 struct ieee80211_key_conf *key,
4112 enum set_key_cmd cmd,
4113 const u8 *macaddr, u32 flags)
4116 struct ath11k *ar = arvif->ar;
4117 struct wmi_vdev_install_key_arg arg = {
4118 .vdev_id = arvif->vdev_id,
4119 .key_idx = key->keyidx,
4120 .key_len = key->keylen,
4121 .key_data = key->key,
4126 lockdep_assert_held(&arvif->ar->conf_mutex);
4128 reinit_completion(&ar->install_key_done);
4130 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4133 if (cmd == DISABLE_KEY) {
4134 arg.key_cipher = WMI_CIPHER_NONE;
4135 arg.key_data = NULL;
4139 switch (key->cipher) {
4140 case WLAN_CIPHER_SUITE_CCMP:
4141 arg.key_cipher = WMI_CIPHER_AES_CCM;
4142 /* TODO: Re-check if flag is valid */
4143 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
4145 case WLAN_CIPHER_SUITE_TKIP:
4146 arg.key_cipher = WMI_CIPHER_TKIP;
4147 arg.key_txmic_len = 8;
4148 arg.key_rxmic_len = 8;
4150 case WLAN_CIPHER_SUITE_CCMP_256:
4151 arg.key_cipher = WMI_CIPHER_AES_CCM;
4153 case WLAN_CIPHER_SUITE_GCMP:
4154 case WLAN_CIPHER_SUITE_GCMP_256:
4155 arg.key_cipher = WMI_CIPHER_AES_GCM;
4158 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
4162 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
4163 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
4164 IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
4167 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
4172 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
4175 return ar->install_key_status ? -EINVAL : 0;
4178 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
4181 struct ath11k *ar = arvif->ar;
4182 struct ath11k_base *ab = ar->ab;
4183 struct ath11k_peer *peer;
4184 int first_errno = 0;
4189 lockdep_assert_held(&ar->conf_mutex);
4191 spin_lock_bh(&ab->base_lock);
4192 peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
4193 spin_unlock_bh(&ab->base_lock);
4198 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
4202 /* key flags are not required to delete the key */
4203 ret = ath11k_install_key(arvif, peer->keys[i],
4204 DISABLE_KEY, addr, flags);
4205 if (ret < 0 && first_errno == 0)
4209 ath11k_warn(ab, "failed to remove peer key %d: %d\n",
4212 spin_lock_bh(&ab->base_lock);
4213 peer->keys[i] = NULL;
4214 spin_unlock_bh(&ab->base_lock);
4220 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4221 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4222 struct ieee80211_key_conf *key)
4224 struct ath11k *ar = hw->priv;
4225 struct ath11k_base *ab = ar->ab;
4226 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4227 struct ath11k_peer *peer;
4228 struct ath11k_sta *arsta;
4229 const u8 *peer_addr;
4233 /* BIP needs to be done in software */
4234 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
4235 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
4236 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
4237 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
4240 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4243 if (key->keyidx > WMI_MAX_KEY_INDEX)
4246 mutex_lock(&ar->conf_mutex);
4249 peer_addr = sta->addr;
4250 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4251 peer_addr = vif->bss_conf.bssid;
4253 peer_addr = vif->addr;
4255 key->hw_key_idx = key->keyidx;
4257 /* the peer should not disappear in mid-way (unless FW goes awry) since
4258 * we already hold conf_mutex. we just make sure its there now.
4260 spin_lock_bh(&ab->base_lock);
4261 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4263 /* flush the fragments cache during key (re)install to
4264 * ensure all frags in the new frag list belong to the same key.
4266 if (peer && sta && cmd == SET_KEY)
4267 ath11k_peer_frags_flush(ar, peer);
4268 spin_unlock_bh(&ab->base_lock);
4271 if (cmd == SET_KEY) {
4272 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
4277 /* if the peer doesn't exist there is no key to disable
4284 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4285 flags |= WMI_KEY_PAIRWISE;
4287 flags |= WMI_KEY_GROUP;
4289 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
4291 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
4295 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
4297 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
4301 spin_lock_bh(&ab->base_lock);
4302 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4303 if (peer && cmd == SET_KEY) {
4304 peer->keys[key->keyidx] = key;
4305 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
4306 peer->ucast_keyidx = key->keyidx;
4307 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
4309 peer->mcast_keyidx = key->keyidx;
4310 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
4312 } else if (peer && cmd == DISABLE_KEY) {
4313 peer->keys[key->keyidx] = NULL;
4314 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4315 peer->ucast_keyidx = 0;
4317 peer->mcast_keyidx = 0;
4319 /* impossible unless FW goes crazy */
4320 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
4323 arsta = ath11k_sta_to_arsta(sta);
4325 switch (key->cipher) {
4326 case WLAN_CIPHER_SUITE_TKIP:
4327 case WLAN_CIPHER_SUITE_CCMP:
4328 case WLAN_CIPHER_SUITE_CCMP_256:
4329 case WLAN_CIPHER_SUITE_GCMP:
4330 case WLAN_CIPHER_SUITE_GCMP_256:
4332 arsta->pn_type = HAL_PN_TYPE_WPA;
4334 arsta->pn_type = HAL_PN_TYPE_NONE;
4337 arsta->pn_type = HAL_PN_TYPE_NONE;
4342 spin_unlock_bh(&ab->base_lock);
4345 mutex_unlock(&ar->conf_mutex);
4350 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
4351 enum nl80211_band band,
4352 const struct cfg80211_bitrate_mask *mask)
4357 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
4358 num_rates += hweight8(mask->control[band].ht_mcs[i]);
4364 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
4365 enum nl80211_band band,
4366 const struct cfg80211_bitrate_mask *mask)
4371 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
4372 num_rates += hweight16(mask->control[band].vht_mcs[i]);
4378 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
4379 enum nl80211_band band,
4380 const struct cfg80211_bitrate_mask *mask)
4385 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
4386 num_rates += hweight16(mask->control[band].he_mcs[i]);
4392 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
4393 struct ieee80211_sta *sta,
4394 const struct cfg80211_bitrate_mask *mask,
4395 enum nl80211_band band)
4397 struct ath11k *ar = arvif->ar;
4402 lockdep_assert_held(&ar->conf_mutex);
4406 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
4407 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
4409 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4414 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
4419 /* Avoid updating invalid nss as fixed rate*/
4420 if (nss > sta->deflink.rx_nss)
4423 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4424 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4427 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4428 WMI_RATE_PREAMBLE_VHT);
4429 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4431 WMI_PEER_PARAM_FIXED_RATE,
4435 "failed to update STA %pM Fixed Rate %d: %d\n",
4436 sta->addr, rate_code, ret);
4442 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4443 struct ieee80211_sta *sta,
4444 const struct cfg80211_bitrate_mask *mask,
4445 enum nl80211_band band)
4447 struct ath11k *ar = arvif->ar;
4452 lockdep_assert_held(&ar->conf_mutex);
4456 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4457 if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4459 he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4464 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4469 /* Avoid updating invalid nss as fixed rate */
4470 if (nss > sta->deflink.rx_nss)
4473 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4474 "setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4477 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4478 WMI_RATE_PREAMBLE_HE);
4480 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4482 WMI_PEER_PARAM_FIXED_RATE,
4486 "failed to update sta %pM fixed rate %d: %d\n",
4487 sta->addr, rate_code, ret);
4493 ath11k_mac_set_peer_ht_fixed_rate(struct ath11k_vif *arvif,
4494 struct ieee80211_sta *sta,
4495 const struct cfg80211_bitrate_mask *mask,
4496 enum nl80211_band band)
4498 struct ath11k *ar = arvif->ar;
4499 u8 ht_rate, nss = 0;
4503 lockdep_assert_held(&ar->conf_mutex);
4505 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
4506 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
4508 ht_rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4513 ath11k_warn(ar->ab, "No single HT Fixed rate found to set for %pM",
4518 /* Avoid updating invalid nss as fixed rate*/
4519 if (nss > sta->deflink.rx_nss)
4522 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4523 "Setting Fixed HT Rate for peer %pM. Device will not switch to any other selected rates",
4526 rate_code = ATH11K_HW_RATE_CODE(ht_rate, nss - 1,
4527 WMI_RATE_PREAMBLE_HT);
4528 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4530 WMI_PEER_PARAM_FIXED_RATE,
4534 "failed to update STA %pM HT Fixed Rate %d: %d\n",
4535 sta->addr, rate_code, ret);
4540 static int ath11k_station_assoc(struct ath11k *ar,
4541 struct ieee80211_vif *vif,
4542 struct ieee80211_sta *sta,
4545 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4546 struct peer_assoc_params peer_arg;
4548 struct cfg80211_chan_def def;
4549 enum nl80211_band band;
4550 struct cfg80211_bitrate_mask *mask;
4551 u8 num_ht_rates, num_vht_rates, num_he_rates;
4553 lockdep_assert_held(&ar->conf_mutex);
4555 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4558 band = def.chan->band;
4559 mask = &arvif->bitrate_mask;
4561 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4563 peer_arg.is_assoc = true;
4564 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4566 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4567 sta->addr, arvif->vdev_id, ret);
4571 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4572 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4573 sta->addr, arvif->vdev_id);
4577 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
4578 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
4579 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask);
4581 /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4582 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
4584 * Note that all other rates and NSS will be disabled for this peer.
4586 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4587 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4591 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4592 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4596 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4597 ret = ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4603 /* Re-assoc is run only to update supported rates for given station. It
4604 * doesn't make much sense to reconfigure the peer completely.
4609 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
4610 &sta->deflink.ht_cap,
4611 le16_to_cpu(sta->deflink.he_6ghz_capa.capa));
4613 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4614 arvif->vdev_id, ret);
4619 arvif->num_legacy_stations++;
4620 ret = ath11k_recalc_rtscts_prot(arvif);
4625 if (sta->wme && sta->uapsd_queues) {
4626 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4628 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4629 sta->addr, arvif->vdev_id, ret);
4637 static int ath11k_station_disassoc(struct ath11k *ar,
4638 struct ieee80211_vif *vif,
4639 struct ieee80211_sta *sta)
4641 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4644 lockdep_assert_held(&ar->conf_mutex);
4647 arvif->num_legacy_stations--;
4648 ret = ath11k_recalc_rtscts_prot(arvif);
4653 ret = ath11k_clear_peer_keys(arvif, sta->addr);
4655 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4656 arvif->vdev_id, ret);
4662 static u32 ath11k_mac_max_nss(const u8 *ht_mcs_mask, const u16 *vht_mcs_mask,
4663 const u16 *he_mcs_mask)
4665 return max3(ath11k_mac_max_ht_nss(ht_mcs_mask),
4666 ath11k_mac_max_vht_nss(vht_mcs_mask),
4667 ath11k_mac_max_he_nss(he_mcs_mask));
4670 static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4673 struct ath11k_vif *arvif;
4674 struct ath11k_sta *arsta;
4675 struct ieee80211_sta *sta;
4676 struct cfg80211_chan_def def;
4677 enum nl80211_band band;
4678 const u8 *ht_mcs_mask;
4679 const u16 *vht_mcs_mask;
4680 const u16 *he_mcs_mask;
4681 u32 changed, bw, nss, smps, bw_prev;
4682 int err, num_ht_rates, num_vht_rates, num_he_rates;
4683 const struct cfg80211_bitrate_mask *mask;
4684 struct peer_assoc_params peer_arg;
4685 enum wmi_phy_mode peer_phymode;
4687 arsta = container_of(wk, struct ath11k_sta, update_wk);
4688 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4689 arvif = arsta->arvif;
4692 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4695 band = def.chan->band;
4696 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4697 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4698 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
4700 spin_lock_bh(&ar->data_lock);
4702 changed = arsta->changed;
4706 bw_prev = arsta->bw_prev;
4710 spin_unlock_bh(&ar->data_lock);
4712 mutex_lock(&ar->conf_mutex);
4714 nss = max_t(u32, 1, nss);
4715 nss = min(nss, ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
4717 if (changed & IEEE80211_RC_BW_CHANGED) {
4718 /* Get the peer phymode */
4719 ath11k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg);
4720 peer_phymode = peer_arg.peer_phymode;
4722 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM peer bw %d phymode %d\n",
4723 sta->addr, bw, peer_phymode);
4726 /* BW is upgraded. In this case we send WMI_PEER_PHYMODE
4727 * followed by WMI_PEER_CHWIDTH
4729 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW upgrade for sta %pM new BW %d, old BW %d\n",
4730 sta->addr, bw, bw_prev);
4732 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4733 WMI_PEER_PHYMODE, peer_phymode);
4736 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4737 sta->addr, peer_phymode, err);
4738 goto err_rc_bw_changed;
4741 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4742 WMI_PEER_CHWIDTH, bw);
4745 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4746 sta->addr, bw, err);
4748 /* BW is downgraded. In this case we send WMI_PEER_CHWIDTH
4749 * followed by WMI_PEER_PHYMODE
4751 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW downgrade for sta %pM new BW %d,old BW %d\n",
4752 sta->addr, bw, bw_prev);
4754 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4755 WMI_PEER_CHWIDTH, bw);
4758 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4759 sta->addr, bw, err);
4760 goto err_rc_bw_changed;
4763 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4764 WMI_PEER_PHYMODE, peer_phymode);
4767 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4768 sta->addr, peer_phymode, err);
4772 if (changed & IEEE80211_RC_NSS_CHANGED) {
4773 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM nss %d\n",
4776 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4779 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4780 sta->addr, nss, err);
4783 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4784 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM smps %d\n",
4787 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4788 WMI_PEER_MIMO_PS_STATE, smps);
4790 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4791 sta->addr, smps, err);
4794 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4795 mask = &arvif->bitrate_mask;
4796 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band,
4798 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4800 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4803 /* Peer_assoc_prepare will reject vht rates in
4804 * bitrate_mask if its not available in range format and
4805 * sets vht tx_rateset as unsupported. So multiple VHT MCS
4806 * setting(eg. MCS 4,5,6) per peer is not supported here.
4807 * But, Single rate in VHT mask can be set as per-peer
4808 * fixed rate. But even if any HT rates are configured in
4809 * the bitrate mask, device will not switch to those rates
4810 * when per-peer Fixed rate is set.
4811 * TODO: Check RATEMASK_CMDID to support auto rates selection
4812 * across HT/VHT and for multiple VHT MCS support.
4814 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4815 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4817 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4818 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4820 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4821 ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4824 /* If the peer is non-VHT/HE or no fixed VHT/HE rate
4825 * is provided in the new bitrate mask we set the
4826 * other rates using peer_assoc command. Also clear
4827 * the peer fixed rate settings as it has higher proprity
4830 err = ath11k_wmi_set_peer_param(ar, sta->addr,
4832 WMI_PEER_PARAM_FIXED_RATE,
4833 WMI_FIXED_RATE_NONE);
4836 "failed to disable peer fixed rate for sta %pM: %d\n",
4839 ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4842 peer_arg.is_assoc = false;
4843 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4845 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4846 sta->addr, arvif->vdev_id, err);
4848 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4849 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4850 sta->addr, arvif->vdev_id);
4855 mutex_unlock(&ar->conf_mutex);
4858 static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4861 struct ath11k_vif *arvif;
4862 struct ath11k_sta *arsta;
4863 struct ieee80211_sta *sta;
4866 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4867 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4868 arvif = arsta->arvif;
4871 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4872 "setting USE_4ADDR for peer %pM\n", sta->addr);
4874 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4876 WMI_PEER_USE_4ADDR, 1);
4879 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4883 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4884 struct ieee80211_sta *sta)
4886 struct ath11k *ar = arvif->ar;
4888 lockdep_assert_held(&ar->conf_mutex);
4890 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4893 if (ar->num_stations >= ar->max_num_stations)
4901 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4902 struct ieee80211_sta *sta)
4904 struct ath11k *ar = arvif->ar;
4906 lockdep_assert_held(&ar->conf_mutex);
4908 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4914 static int ath11k_mac_station_add(struct ath11k *ar,
4915 struct ieee80211_vif *vif,
4916 struct ieee80211_sta *sta)
4918 struct ath11k_base *ab = ar->ab;
4919 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4920 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
4921 struct peer_create_params peer_param;
4924 lockdep_assert_held(&ar->conf_mutex);
4926 ret = ath11k_mac_inc_num_stations(arvif, sta);
4928 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4929 ar->max_num_stations);
4933 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4934 if (!arsta->rx_stats) {
4936 goto dec_num_station;
4939 peer_param.vdev_id = arvif->vdev_id;
4940 peer_param.peer_addr = sta->addr;
4941 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4943 ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4945 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4946 sta->addr, arvif->vdev_id);
4950 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4951 sta->addr, arvif->vdev_id);
4953 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
4954 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4955 if (!arsta->tx_stats) {
4961 if (ieee80211_vif_is_mesh(vif)) {
4962 ath11k_dbg(ab, ATH11K_DBG_MAC,
4963 "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
4964 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4966 WMI_PEER_USE_4ADDR, 1);
4968 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
4974 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4976 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4977 sta->addr, arvif->vdev_id, ret);
4981 if (ab->hw_params.vdev_start_delay &&
4982 !arvif->is_started &&
4983 arvif->vdev_type != WMI_VDEV_TYPE_AP) {
4984 ret = ath11k_start_vdev_delay(ar->hw, vif);
4986 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4991 ewma_avg_rssi_init(&arsta->avg_rssi);
4995 kfree(arsta->tx_stats);
4996 arsta->tx_stats = NULL;
4998 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
5000 kfree(arsta->rx_stats);
5001 arsta->rx_stats = NULL;
5003 ath11k_mac_dec_num_stations(arvif, sta);
5008 static u32 ath11k_mac_ieee80211_sta_bw_to_wmi(struct ath11k *ar,
5009 struct ieee80211_sta *sta)
5011 u32 bw = WMI_PEER_CHWIDTH_20MHZ;
5013 switch (sta->deflink.bandwidth) {
5014 case IEEE80211_STA_RX_BW_20:
5015 bw = WMI_PEER_CHWIDTH_20MHZ;
5017 case IEEE80211_STA_RX_BW_40:
5018 bw = WMI_PEER_CHWIDTH_40MHZ;
5020 case IEEE80211_STA_RX_BW_80:
5021 bw = WMI_PEER_CHWIDTH_80MHZ;
5023 case IEEE80211_STA_RX_BW_160:
5024 bw = WMI_PEER_CHWIDTH_160MHZ;
5027 ath11k_warn(ar->ab, "Invalid bandwidth %d for %pM\n",
5028 sta->deflink.bandwidth, sta->addr);
5029 bw = WMI_PEER_CHWIDTH_20MHZ;
5036 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
5037 struct ieee80211_vif *vif,
5038 struct ieee80211_sta *sta,
5039 enum ieee80211_sta_state old_state,
5040 enum ieee80211_sta_state new_state)
5042 struct ath11k *ar = hw->priv;
5043 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5044 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5045 struct ath11k_peer *peer;
5048 /* cancel must be done outside the mutex to avoid deadlock */
5049 if ((old_state == IEEE80211_STA_NONE &&
5050 new_state == IEEE80211_STA_NOTEXIST)) {
5051 cancel_work_sync(&arsta->update_wk);
5052 cancel_work_sync(&arsta->set_4addr_wk);
5055 mutex_lock(&ar->conf_mutex);
5057 if (old_state == IEEE80211_STA_NOTEXIST &&
5058 new_state == IEEE80211_STA_NONE) {
5059 memset(arsta, 0, sizeof(*arsta));
5060 arsta->arvif = arvif;
5061 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
5062 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
5063 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
5065 ret = ath11k_mac_station_add(ar, vif, sta);
5067 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
5068 sta->addr, arvif->vdev_id);
5069 } else if ((old_state == IEEE80211_STA_NONE &&
5070 new_state == IEEE80211_STA_NOTEXIST)) {
5071 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
5072 vif->type == NL80211_IFTYPE_STATION;
5074 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
5076 if (!skip_peer_delete) {
5077 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
5080 "Failed to delete peer: %pM for VDEV: %d\n",
5081 sta->addr, arvif->vdev_id);
5085 "Removed peer: %pM for VDEV: %d\n",
5086 sta->addr, arvif->vdev_id);
5089 ath11k_mac_dec_num_stations(arvif, sta);
5090 mutex_lock(&ar->ab->tbl_mtx_lock);
5091 spin_lock_bh(&ar->ab->base_lock);
5092 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5093 if (skip_peer_delete && peer) {
5095 } else if (peer && peer->sta == sta) {
5096 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
5097 vif->addr, arvif->vdev_id);
5098 ath11k_peer_rhash_delete(ar->ab, peer);
5100 list_del(&peer->list);
5104 spin_unlock_bh(&ar->ab->base_lock);
5105 mutex_unlock(&ar->ab->tbl_mtx_lock);
5107 kfree(arsta->tx_stats);
5108 arsta->tx_stats = NULL;
5110 kfree(arsta->rx_stats);
5111 arsta->rx_stats = NULL;
5112 } else if (old_state == IEEE80211_STA_AUTH &&
5113 new_state == IEEE80211_STA_ASSOC &&
5114 (vif->type == NL80211_IFTYPE_AP ||
5115 vif->type == NL80211_IFTYPE_MESH_POINT ||
5116 vif->type == NL80211_IFTYPE_ADHOC)) {
5117 ret = ath11k_station_assoc(ar, vif, sta, false);
5119 ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
5122 spin_lock_bh(&ar->data_lock);
5123 /* Set arsta bw and prev bw */
5124 arsta->bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5125 arsta->bw_prev = arsta->bw;
5126 spin_unlock_bh(&ar->data_lock);
5127 } else if (old_state == IEEE80211_STA_ASSOC &&
5128 new_state == IEEE80211_STA_AUTHORIZED) {
5129 spin_lock_bh(&ar->ab->base_lock);
5131 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5133 peer->is_authorized = true;
5135 spin_unlock_bh(&ar->ab->base_lock);
5137 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
5138 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
5143 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
5144 sta->addr, arvif->vdev_id, ret);
5146 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
5147 new_state == IEEE80211_STA_ASSOC) {
5148 spin_lock_bh(&ar->ab->base_lock);
5150 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5152 peer->is_authorized = false;
5154 spin_unlock_bh(&ar->ab->base_lock);
5155 } else if (old_state == IEEE80211_STA_ASSOC &&
5156 new_state == IEEE80211_STA_AUTH &&
5157 (vif->type == NL80211_IFTYPE_AP ||
5158 vif->type == NL80211_IFTYPE_MESH_POINT ||
5159 vif->type == NL80211_IFTYPE_ADHOC)) {
5160 ret = ath11k_station_disassoc(ar, vif, sta);
5162 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
5166 mutex_unlock(&ar->conf_mutex);
5170 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
5171 struct ieee80211_vif *vif,
5172 struct ieee80211_sta *sta)
5174 struct ath11k *ar = hw->priv;
5175 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5179 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
5182 txpwr = sta->deflink.txpwr.power;
5187 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
5190 mutex_lock(&ar->conf_mutex);
5192 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
5193 WMI_PEER_USE_FIXED_PWR, txpwr);
5195 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
5201 mutex_unlock(&ar->conf_mutex);
5205 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
5206 struct ieee80211_vif *vif,
5207 struct ieee80211_sta *sta, bool enabled)
5209 struct ath11k *ar = hw->priv;
5210 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5212 if (enabled && !arsta->use_4addr_set) {
5213 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
5214 arsta->use_4addr_set = true;
5218 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
5219 struct ieee80211_vif *vif,
5220 struct ieee80211_sta *sta,
5223 struct ath11k *ar = hw->priv;
5224 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5225 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5226 struct ath11k_peer *peer;
5229 spin_lock_bh(&ar->ab->base_lock);
5231 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5233 spin_unlock_bh(&ar->ab->base_lock);
5234 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
5235 sta->addr, arvif->vdev_id);
5239 spin_unlock_bh(&ar->ab->base_lock);
5241 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5242 "sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
5243 sta->addr, changed, sta->deflink.bandwidth,
5244 sta->deflink.rx_nss,
5245 sta->deflink.smps_mode);
5247 spin_lock_bh(&ar->data_lock);
5249 if (changed & IEEE80211_RC_BW_CHANGED) {
5250 bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5251 arsta->bw_prev = arsta->bw;
5255 if (changed & IEEE80211_RC_NSS_CHANGED)
5256 arsta->nss = sta->deflink.rx_nss;
5258 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5259 smps = WMI_PEER_SMPS_PS_NONE;
5261 switch (sta->deflink.smps_mode) {
5262 case IEEE80211_SMPS_AUTOMATIC:
5263 case IEEE80211_SMPS_OFF:
5264 smps = WMI_PEER_SMPS_PS_NONE;
5266 case IEEE80211_SMPS_STATIC:
5267 smps = WMI_PEER_SMPS_STATIC;
5269 case IEEE80211_SMPS_DYNAMIC:
5270 smps = WMI_PEER_SMPS_DYNAMIC;
5273 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
5274 sta->deflink.smps_mode, sta->addr);
5275 smps = WMI_PEER_SMPS_PS_NONE;
5282 arsta->changed |= changed;
5284 spin_unlock_bh(&ar->data_lock);
5286 ieee80211_queue_work(hw, &arsta->update_wk);
5289 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
5290 u16 ac, bool enable)
5292 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5296 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5300 case IEEE80211_AC_VO:
5301 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5302 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5304 case IEEE80211_AC_VI:
5305 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5306 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5308 case IEEE80211_AC_BE:
5309 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5310 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5312 case IEEE80211_AC_BK:
5313 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5314 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5319 arvif->u.sta.uapsd |= value;
5321 arvif->u.sta.uapsd &= ~value;
5323 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5324 WMI_STA_PS_PARAM_UAPSD,
5325 arvif->u.sta.uapsd);
5327 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
5331 if (arvif->u.sta.uapsd)
5332 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5334 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5336 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5337 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5340 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
5346 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
5347 struct ieee80211_vif *vif,
5348 unsigned int link_id, u16 ac,
5349 const struct ieee80211_tx_queue_params *params)
5351 struct ath11k *ar = hw->priv;
5352 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5353 struct wmi_wmm_params_arg *p = NULL;
5356 mutex_lock(&ar->conf_mutex);
5359 case IEEE80211_AC_VO:
5360 p = &arvif->wmm_params.ac_vo;
5362 case IEEE80211_AC_VI:
5363 p = &arvif->wmm_params.ac_vi;
5365 case IEEE80211_AC_BE:
5366 p = &arvif->wmm_params.ac_be;
5368 case IEEE80211_AC_BK:
5369 p = &arvif->wmm_params.ac_bk;
5378 p->cwmin = params->cw_min;
5379 p->cwmax = params->cw_max;
5380 p->aifs = params->aifs;
5381 p->txop = params->txop;
5383 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
5384 &arvif->wmm_params);
5386 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
5390 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5393 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
5396 mutex_unlock(&ar->conf_mutex);
5400 static struct ieee80211_sta_ht_cap
5401 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
5404 struct ieee80211_sta_ht_cap ht_cap = {0};
5405 u32 ar_vht_cap = ar->pdev->cap.vht_cap;
5407 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
5410 ht_cap.ht_supported = 1;
5411 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5412 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
5413 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5414 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5415 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
5417 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
5418 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5420 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
5421 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5423 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
5426 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
5427 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
5432 if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
5433 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
5435 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
5439 stbc &= WMI_HT_CAP_RX_STBC;
5440 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
5441 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
5442 stbc &= IEEE80211_HT_CAP_RX_STBC;
5447 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
5448 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
5450 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
5451 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
5453 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
5454 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
5456 for (i = 0; i < ar->num_rx_chains; i++) {
5457 if (rate_cap_rx_chainmask & BIT(i))
5458 ht_cap.mcs.rx_mask[i] = 0xFF;
5461 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
5466 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
5469 struct ath11k *ar = arvif->ar;
5472 u32 vht_cap = ar->pdev->cap.vht_cap;
5473 u32 vdev_param = WMI_VDEV_PARAM_TXBF;
5475 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
5476 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5477 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5478 if (nsts > (ar->num_rx_chains - 1))
5479 nsts = ar->num_rx_chains - 1;
5480 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
5483 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
5484 sound_dim = vht_cap &
5485 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5486 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5487 if (sound_dim > (ar->num_tx_chains - 1))
5488 sound_dim = ar->num_tx_chains - 1;
5489 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
5495 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
5496 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
5498 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
5499 arvif->vdev_type == WMI_VDEV_TYPE_AP)
5500 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
5503 /* TODO: SUBFEE not validated in HK, disable here until validated? */
5505 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
5506 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
5508 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
5509 arvif->vdev_type == WMI_VDEV_TYPE_STA)
5510 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
5513 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5517 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
5519 bool subfer, subfee;
5520 int sound_dim = 0, nsts = 0;
5522 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
5523 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5525 if (ar->num_tx_chains < 2) {
5526 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5530 if (ar->num_rx_chains < 2) {
5531 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
5535 /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5537 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5539 /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5541 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5543 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5544 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5545 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5547 nsts = (*vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5548 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5549 *vht_cap &= ~IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5551 /* Enable Sounding Dimension Field only if SU BF is enabled */
5553 if (sound_dim > (ar->num_tx_chains - 1))
5554 sound_dim = ar->num_tx_chains - 1;
5556 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5557 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5558 *vht_cap |= sound_dim;
5561 /* Enable Beamformee STS Field only if SU BF is enabled */
5563 if (nsts > (ar->num_rx_chains - 1))
5564 nsts = ar->num_rx_chains - 1;
5566 nsts <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5567 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5572 static struct ieee80211_sta_vht_cap
5573 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5574 u32 rate_cap_rx_chainmask)
5576 struct ieee80211_sta_vht_cap vht_cap = {0};
5577 u16 txmcs_map, rxmcs_map;
5580 vht_cap.vht_supported = 1;
5581 vht_cap.cap = ar->pdev->cap.vht_cap;
5583 if (ar->pdev->cap.nss_ratio_enabled)
5584 vht_cap.vht_mcs.tx_highest |=
5585 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5587 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5591 for (i = 0; i < 8; i++) {
5592 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5593 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5595 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5597 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5598 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5600 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5603 if (rate_cap_tx_chainmask <= 1)
5604 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5606 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5607 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5612 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5613 struct ath11k_pdev_cap *cap,
5616 struct ieee80211_supported_band *band;
5617 u32 rate_cap_tx_chainmask;
5618 u32 rate_cap_rx_chainmask;
5621 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5622 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5624 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5625 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5626 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5628 *ht_cap_info = ht_cap;
5629 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5630 rate_cap_rx_chainmask);
5633 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5634 (ar->ab->hw_params.single_pdev_only ||
5635 !ar->supports_6ghz)) {
5636 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5637 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5639 *ht_cap_info = ht_cap;
5640 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5641 rate_cap_rx_chainmask);
5642 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5643 rate_cap_rx_chainmask);
5647 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5649 /* TODO: Check the request chainmask against the supported
5650 * chainmask table which is advertised in extented_service_ready event
5656 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5662 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5663 he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5664 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5665 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5666 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5667 for (ru = 0; ru < 4; ru++) {
5671 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5673 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5675 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5676 for (i = 5; i >= 0; i--) {
5678 ((val >> i) & 0x1) << ((bit % 8));
5686 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5690 m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5691 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5692 he_cap_elem->mac_cap_info[0] &= ~m;
5694 m = IEEE80211_HE_MAC_CAP2_TRS |
5695 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5696 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5697 he_cap_elem->mac_cap_info[2] &= ~m;
5699 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5700 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5701 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5702 he_cap_elem->mac_cap_info[3] &= ~m;
5704 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5705 IEEE80211_HE_MAC_CAP4_BQR;
5706 he_cap_elem->mac_cap_info[4] &= ~m;
5708 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5709 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5710 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5711 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5712 he_cap_elem->mac_cap_info[5] &= ~m;
5714 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5715 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5716 he_cap_elem->phy_cap_info[2] &= ~m;
5718 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5719 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5720 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5721 he_cap_elem->phy_cap_info[3] &= ~m;
5723 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5724 he_cap_elem->phy_cap_info[4] &= ~m;
5726 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5727 he_cap_elem->phy_cap_info[5] &= ~m;
5729 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5730 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5731 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5732 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5733 he_cap_elem->phy_cap_info[6] &= ~m;
5735 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5736 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5737 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5738 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5739 he_cap_elem->phy_cap_info[7] &= ~m;
5741 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5742 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5743 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5744 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5745 he_cap_elem->phy_cap_info[8] &= ~m;
5747 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5748 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5749 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5750 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5751 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5752 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5753 he_cap_elem->phy_cap_info[9] &= ~m;
5756 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5757 struct ath11k_band_cap *bcap)
5761 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5762 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5763 bcap->he_6ghz_capa |=
5764 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5765 WLAN_HT_CAP_SM_PS_DYNAMIC);
5767 bcap->he_6ghz_capa |=
5768 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5769 WLAN_HT_CAP_SM_PS_DISABLED);
5770 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5772 bcap->he_6ghz_capa |=
5773 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5774 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5775 bcap->he_6ghz_capa |=
5776 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5777 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5778 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5779 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5780 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5782 return cpu_to_le16(bcap->he_6ghz_capa);
5785 static void ath11k_mac_set_hemcsmap(struct ath11k *ar,
5786 struct ath11k_pdev_cap *cap,
5787 struct ieee80211_sta_he_cap *he_cap,
5790 u16 txmcs_map, rxmcs_map;
5795 for (i = 0; i < 8; i++) {
5796 if (i < ar->num_tx_chains &&
5797 (ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5798 txmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5800 txmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5802 if (i < ar->num_rx_chains &&
5803 (ar->cfg_rx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5804 rxmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5806 rxmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5808 he_cap->he_mcs_nss_supp.rx_mcs_80 =
5809 cpu_to_le16(rxmcs_map & 0xffff);
5810 he_cap->he_mcs_nss_supp.tx_mcs_80 =
5811 cpu_to_le16(txmcs_map & 0xffff);
5812 he_cap->he_mcs_nss_supp.rx_mcs_160 =
5813 cpu_to_le16(rxmcs_map & 0xffff);
5814 he_cap->he_mcs_nss_supp.tx_mcs_160 =
5815 cpu_to_le16(txmcs_map & 0xffff);
5816 he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5817 cpu_to_le16(rxmcs_map & 0xffff);
5818 he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5819 cpu_to_le16(txmcs_map & 0xffff);
5822 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5823 struct ath11k_pdev_cap *cap,
5824 struct ieee80211_sband_iftype_data *data,
5829 for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5830 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5831 struct ath11k_band_cap *band_cap = &cap->band[band];
5832 struct ieee80211_he_cap_elem *he_cap_elem =
5833 &he_cap->he_cap_elem;
5836 case NL80211_IFTYPE_STATION:
5837 case NL80211_IFTYPE_AP:
5838 case NL80211_IFTYPE_MESH_POINT:
5845 data[idx].types_mask = BIT(i);
5846 he_cap->has_he = true;
5847 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5848 sizeof(he_cap_elem->mac_cap_info));
5849 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5850 sizeof(he_cap_elem->phy_cap_info));
5852 he_cap_elem->mac_cap_info[1] &=
5853 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5855 he_cap_elem->phy_cap_info[5] &=
5856 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5857 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5860 case NL80211_IFTYPE_AP:
5861 he_cap_elem->phy_cap_info[3] &=
5862 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5863 he_cap_elem->phy_cap_info[9] |=
5864 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5866 case NL80211_IFTYPE_STATION:
5867 he_cap_elem->mac_cap_info[0] &=
5868 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5869 he_cap_elem->mac_cap_info[0] |=
5870 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5871 he_cap_elem->phy_cap_info[9] |=
5872 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5874 case NL80211_IFTYPE_MESH_POINT:
5875 ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5879 ath11k_mac_set_hemcsmap(ar, cap, he_cap, band);
5881 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5882 if (he_cap_elem->phy_cap_info[6] &
5883 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5884 ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5887 if (band == NL80211_BAND_6GHZ) {
5888 data[idx].he_6ghz_capa.capa =
5889 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5897 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5898 struct ath11k_pdev_cap *cap)
5900 struct ieee80211_supported_band *band;
5903 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5904 count = ath11k_mac_copy_he_cap(ar, cap,
5905 ar->mac.iftype[NL80211_BAND_2GHZ],
5907 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5908 _ieee80211_set_sband_iftype_data(band,
5909 ar->mac.iftype[NL80211_BAND_2GHZ],
5913 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5914 count = ath11k_mac_copy_he_cap(ar, cap,
5915 ar->mac.iftype[NL80211_BAND_5GHZ],
5917 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5918 _ieee80211_set_sband_iftype_data(band,
5919 ar->mac.iftype[NL80211_BAND_5GHZ],
5923 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5924 ar->supports_6ghz) {
5925 count = ath11k_mac_copy_he_cap(ar, cap,
5926 ar->mac.iftype[NL80211_BAND_6GHZ],
5928 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5929 _ieee80211_set_sband_iftype_data(band,
5930 ar->mac.iftype[NL80211_BAND_6GHZ],
5935 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5939 lockdep_assert_held(&ar->conf_mutex);
5941 if (ath11k_check_chain_mask(ar, tx_ant, true))
5944 if (ath11k_check_chain_mask(ar, rx_ant, false))
5947 ar->cfg_tx_chainmask = tx_ant;
5948 ar->cfg_rx_chainmask = rx_ant;
5950 if (ar->state != ATH11K_STATE_ON &&
5951 ar->state != ATH11K_STATE_RESTARTED)
5954 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5955 tx_ant, ar->pdev->pdev_id);
5957 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5962 ar->num_tx_chains = get_num_chains(tx_ant);
5964 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5965 rx_ant, ar->pdev->pdev_id);
5967 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5972 ar->num_rx_chains = get_num_chains(rx_ant);
5974 /* Reload HT/VHT/HE capability */
5975 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5976 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5981 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5985 ieee80211_free_txskb(ar->hw, skb);
5987 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5993 wake_up(&ar->txmgmt_empty_waitq);
5996 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5998 struct sk_buff *msdu;
5999 struct ieee80211_tx_info *info;
6001 spin_lock_bh(&ar->txmgmt_idr_lock);
6002 msdu = idr_remove(&ar->txmgmt_idr, buf_id);
6003 spin_unlock_bh(&ar->txmgmt_idr_lock);
6008 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
6011 info = IEEE80211_SKB_CB(msdu);
6012 memset(&info->status, 0, sizeof(info->status));
6014 ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
6017 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
6019 struct ath11k *ar = ctx;
6021 ath11k_mac_tx_mgmt_free(ar, buf_id);
6026 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
6028 struct ieee80211_vif *vif = ctx;
6029 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6030 struct ath11k *ar = skb_cb->ar;
6032 if (skb_cb->vif == vif)
6033 ath11k_mac_tx_mgmt_free(ar, buf_id);
6038 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
6039 struct sk_buff *skb)
6041 struct ath11k_base *ab = ar->ab;
6042 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6043 struct ieee80211_tx_info *info;
6048 ATH11K_SKB_CB(skb)->ar = ar;
6050 spin_lock_bh(&ar->txmgmt_idr_lock);
6051 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
6052 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
6053 spin_unlock_bh(&ar->txmgmt_idr_lock);
6055 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6056 "tx mgmt frame, buf id %d\n", buf_id);
6061 info = IEEE80211_SKB_CB(skb);
6062 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
6063 if ((ieee80211_is_action(hdr->frame_control) ||
6064 ieee80211_is_deauth(hdr->frame_control) ||
6065 ieee80211_is_disassoc(hdr->frame_control)) &&
6066 ieee80211_has_protected(hdr->frame_control)) {
6067 skb_put(skb, IEEE80211_CCMP_MIC_LEN);
6071 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
6072 if (dma_mapping_error(ab->dev, paddr)) {
6073 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
6078 ATH11K_SKB_CB(skb)->paddr = paddr;
6080 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
6082 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
6089 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
6090 skb->len, DMA_TO_DEVICE);
6092 spin_lock_bh(&ar->txmgmt_idr_lock);
6093 idr_remove(&ar->txmgmt_idr, buf_id);
6094 spin_unlock_bh(&ar->txmgmt_idr_lock);
6099 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
6101 struct sk_buff *skb;
6103 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
6104 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6107 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
6109 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
6110 struct ath11k_skb_cb *skb_cb;
6111 struct ath11k_vif *arvif;
6112 struct sk_buff *skb;
6115 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
6116 skb_cb = ATH11K_SKB_CB(skb);
6118 ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
6119 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6123 arvif = ath11k_vif_to_arvif(skb_cb->vif);
6124 mutex_lock(&ar->conf_mutex);
6125 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
6126 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
6128 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
6129 arvif->vdev_id, ret);
6130 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6132 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6133 "tx mgmt frame, vdev_id %d\n",
6138 "dropping mgmt frame for vdev %d, is_started %d\n",
6141 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6143 mutex_unlock(&ar->conf_mutex);
6147 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
6150 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
6152 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
6155 /* Drop probe response packets when the pending management tx
6156 * count has reached a certain threshold, so as to prioritize
6157 * other mgmt packets like auth and assoc to be sent on time
6158 * for establishing successful connections.
6161 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
6163 "dropping probe response as pending queue is almost full\n");
6167 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
6168 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
6172 skb_queue_tail(q, skb);
6173 atomic_inc(&ar->num_pending_mgmt_tx);
6174 queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
6179 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
6180 struct ieee80211_tx_control *control,
6181 struct sk_buff *skb)
6183 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6184 struct ath11k *ar = hw->priv;
6185 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
6186 struct ieee80211_vif *vif = info->control.vif;
6187 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6188 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6189 struct ieee80211_key_conf *key = info->control.hw_key;
6190 struct ath11k_sta *arsta = NULL;
6191 u32 info_flags = info->flags;
6195 memset(skb_cb, 0, sizeof(*skb_cb));
6199 skb_cb->cipher = key->cipher;
6200 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
6203 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
6204 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
6205 } else if (ieee80211_is_mgmt(hdr->frame_control)) {
6206 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
6207 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
6209 ath11k_warn(ar->ab, "failed to queue management frame %d\n",
6211 ieee80211_free_txskb(ar->hw, skb);
6217 arsta = ath11k_sta_to_arsta(control->sta);
6219 ret = ath11k_dp_tx(ar, arvif, arsta, skb);
6220 if (unlikely(ret)) {
6221 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
6222 ieee80211_free_txskb(ar->hw, skb);
6226 void ath11k_mac_drain_tx(struct ath11k *ar)
6228 /* make sure rcu-protected mac80211 tx path itself is drained */
6231 cancel_work_sync(&ar->wmi_mgmt_tx_work);
6232 ath11k_mgmt_over_wmi_tx_purge(ar);
6235 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
6237 struct htt_rx_ring_tlv_filter tlv_filter = {0};
6238 struct ath11k_base *ab = ar->ab;
6243 tlv_filter = ath11k_mac_mon_status_filter_default;
6244 if (ath11k_debugfs_rx_filter(ar))
6245 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
6248 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
6249 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
6250 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
6252 HAL_RXDMA_MONITOR_STATUS,
6257 if (enable && !ar->ab->hw_params.rxdma1_enable)
6258 mod_timer(&ar->ab->mon_reap_timer, jiffies +
6259 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
6264 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
6266 int recovery_start_count;
6271 recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
6272 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
6274 if (recovery_start_count == ab->num_radios) {
6275 complete(&ab->recovery_start);
6276 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
6279 ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
6281 wait_for_completion_timeout(&ab->reconfigure_complete,
6282 ATH11K_RECONFIGURE_TIMEOUT_HZ);
6285 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
6287 struct ath11k *ar = hw->priv;
6288 struct ath11k_base *ab = ar->ab;
6289 struct ath11k_pdev *pdev = ar->pdev;
6292 if (ath11k_ftm_mode) {
6293 ath11k_warn(ab, "mac operations not supported in factory test mode\n");
6297 ath11k_mac_drain_tx(ar);
6298 mutex_lock(&ar->conf_mutex);
6300 switch (ar->state) {
6301 case ATH11K_STATE_OFF:
6302 ar->state = ATH11K_STATE_ON;
6304 case ATH11K_STATE_RESTARTING:
6305 ar->state = ATH11K_STATE_RESTARTED;
6306 ath11k_mac_wait_reconfigure(ab);
6308 case ATH11K_STATE_RESTARTED:
6309 case ATH11K_STATE_WEDGED:
6310 case ATH11K_STATE_ON:
6311 case ATH11K_STATE_FTM:
6317 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
6321 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
6325 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
6328 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
6332 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
6333 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
6335 ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
6340 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
6343 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
6348 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
6350 ath11k_err(ab, "failed to offload radar detection: %d\n",
6355 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
6356 HTT_PPDU_STATS_TAG_DEFAULT);
6358 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
6362 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
6366 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
6370 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
6372 /* TODO: Do we need to enable ANI? */
6374 ath11k_reg_update_chan_list(ar, false);
6376 ar->num_started_vdevs = 0;
6377 ar->num_created_vdevs = 0;
6379 ar->allocated_vdev_map = 0;
6381 /* Configure monitor status ring with default rx_filter to get rx status
6382 * such as rssi, rx_duration.
6384 ret = ath11k_mac_config_mon_status_default(ar, true);
6386 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
6391 /* Configure the hash seed for hash based reo dest ring selection */
6392 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
6394 /* allow device to enter IMPS */
6395 if (ab->hw_params.idle_ps) {
6396 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
6399 ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
6404 mutex_unlock(&ar->conf_mutex);
6406 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
6407 &ab->pdevs[ar->pdev_idx]);
6412 ar->state = ATH11K_STATE_OFF;
6413 mutex_unlock(&ar->conf_mutex);
6418 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
6420 struct ath11k *ar = hw->priv;
6421 struct htt_ppdu_stats_info *ppdu_stats, *tmp;
6424 ath11k_mac_drain_tx(ar);
6426 mutex_lock(&ar->conf_mutex);
6427 ret = ath11k_mac_config_mon_status_default(ar, false);
6429 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
6432 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6433 ar->state = ATH11K_STATE_OFF;
6434 mutex_unlock(&ar->conf_mutex);
6436 cancel_delayed_work_sync(&ar->scan.timeout);
6437 cancel_work_sync(&ar->regd_update_work);
6438 cancel_work_sync(&ar->ab->update_11d_work);
6440 if (ar->state_11d == ATH11K_11D_PREPARING) {
6441 ar->state_11d = ATH11K_11D_IDLE;
6442 complete(&ar->completed_11d_scan);
6445 spin_lock_bh(&ar->data_lock);
6446 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
6447 list_del(&ppdu_stats->list);
6450 spin_unlock_bh(&ar->data_lock);
6452 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
6456 atomic_set(&ar->num_pending_mgmt_tx, 0);
6459 static int ath11k_mac_setup_vdev_params_mbssid(struct ath11k_vif *arvif,
6460 u32 *flags, u32 *tx_vdev_id)
6462 struct ath11k *ar = arvif->ar;
6463 struct ath11k_vif *tx_arvif;
6464 struct ieee80211_vif *tx_vif;
6467 tx_vif = arvif->vif->mbssid_tx_vif;
6469 *flags = WMI_HOST_VDEV_FLAGS_NON_MBSSID_AP;
6473 tx_arvif = ath11k_vif_to_arvif(tx_vif);
6475 if (arvif->vif->bss_conf.nontransmitted) {
6476 if (ar->hw->wiphy != ieee80211_vif_to_wdev(tx_vif)->wiphy)
6479 *flags = WMI_HOST_VDEV_FLAGS_NON_TRANSMIT_AP;
6480 *tx_vdev_id = ath11k_vif_to_arvif(tx_vif)->vdev_id;
6481 } else if (tx_arvif == arvif) {
6482 *flags = WMI_HOST_VDEV_FLAGS_TRANSMIT_AP;
6487 if (arvif->vif->bss_conf.ema_ap)
6488 *flags |= WMI_HOST_VDEV_FLAGS_EMA_MODE;
6493 static int ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
6494 struct vdev_create_params *params)
6496 struct ath11k *ar = arvif->ar;
6497 struct ath11k_pdev *pdev = ar->pdev;
6500 params->if_id = arvif->vdev_id;
6501 params->type = arvif->vdev_type;
6502 params->subtype = arvif->vdev_subtype;
6503 params->pdev_id = pdev->pdev_id;
6504 params->mbssid_flags = 0;
6505 params->mbssid_tx_vdev_id = 0;
6507 if (!test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
6508 ar->ab->wmi_ab.svc_map)) {
6509 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
6510 ¶ms->mbssid_flags,
6511 ¶ms->mbssid_tx_vdev_id);
6516 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
6517 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
6518 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
6520 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
6521 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
6522 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
6524 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
6525 ar->supports_6ghz) {
6526 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
6527 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
6532 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
6533 struct ieee80211_vif *vif)
6535 struct ath11k *ar = hw->priv;
6536 struct ath11k_base *ab = ar->ab;
6537 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6538 u32 param_id, param_value;
6541 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
6542 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
6543 (vif->type != NL80211_IFTYPE_STATION &&
6544 vif->type != NL80211_IFTYPE_AP))
6545 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
6546 IEEE80211_OFFLOAD_DECAP_ENABLED);
6548 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
6549 param_value = ATH11K_HW_TXRX_ETHERNET;
6550 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6551 param_value = ATH11K_HW_TXRX_RAW;
6553 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6555 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6556 param_id, param_value);
6558 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6559 arvif->vdev_id, ret);
6560 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6563 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6564 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6565 param_value = ATH11K_HW_TXRX_ETHERNET;
6566 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6567 param_value = ATH11K_HW_TXRX_RAW;
6569 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6571 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6572 param_id, param_value);
6574 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6575 arvif->vdev_id, ret);
6576 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6580 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6583 struct ath11k_pdev *pdev;
6584 struct ath11k_vif *arvif;
6587 for (i = 0; i < ab->num_radios; i++) {
6588 pdev = &ab->pdevs[i];
6590 list_for_each_entry(arvif, &ar->arvifs, list) {
6591 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6598 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6600 struct wmi_11d_scan_start_params param;
6603 mutex_lock(&ar->ab->vdev_id_11d_lock);
6605 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev id for 11d scan %d\n",
6606 ar->vdev_id_11d_scan);
6608 if (ar->regdom_set_by_user)
6611 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6614 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6617 if (ath11k_mac_vif_ap_active_any(ar->ab))
6620 param.vdev_id = vdev_id;
6621 param.start_interval_msec = 0;
6622 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6624 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "start 11d scan\n");
6626 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, ¶m);
6628 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6631 ar->vdev_id_11d_scan = vdev_id;
6632 if (ar->state_11d == ATH11K_11D_PREPARING)
6633 ar->state_11d = ATH11K_11D_RUNNING;
6637 if (ar->state_11d == ATH11K_11D_PREPARING) {
6638 ar->state_11d = ATH11K_11D_IDLE;
6639 complete(&ar->completed_11d_scan);
6642 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6645 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6650 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6653 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d scan\n");
6655 mutex_lock(&ar->ab->vdev_id_11d_lock);
6657 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d vdev id %d\n",
6658 ar->vdev_id_11d_scan);
6660 if (ar->state_11d == ATH11K_11D_PREPARING) {
6661 ar->state_11d = ATH11K_11D_IDLE;
6662 complete(&ar->completed_11d_scan);
6665 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6666 vdev_id = ar->vdev_id_11d_scan;
6668 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6671 "failed to stopt 11d scan vdev %d ret: %d\n",
6674 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6675 ar->state_11d = ATH11K_11D_IDLE;
6676 complete(&ar->completed_11d_scan);
6679 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6682 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6685 struct ath11k_pdev *pdev;
6688 ath11k_dbg(ab, ATH11K_DBG_MAC, "stop soc 11d scan\n");
6690 for (i = 0; i < ab->num_radios; i++) {
6691 pdev = &ab->pdevs[i];
6694 ath11k_mac_11d_scan_stop(ar);
6698 static int ath11k_mac_vdev_delete(struct ath11k *ar, struct ath11k_vif *arvif)
6700 unsigned long time_left;
6701 struct ieee80211_vif *vif = arvif->vif;
6704 lockdep_assert_held(&ar->conf_mutex);
6706 reinit_completion(&ar->vdev_delete_done);
6708 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6710 ath11k_warn(ar->ab, "failed to delete WMI vdev %d: %d\n",
6711 arvif->vdev_id, ret);
6715 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6716 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6717 if (time_left == 0) {
6718 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
6722 ar->ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6723 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6724 ar->num_created_vdevs--;
6726 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6727 vif->addr, arvif->vdev_id);
6732 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6733 struct ieee80211_vif *vif)
6735 struct ath11k *ar = hw->priv;
6736 struct ath11k_base *ab = ar->ab;
6737 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6738 struct vdev_create_params vdev_param = {0};
6739 struct peer_create_params peer_param;
6740 u32 param_id, param_value;
6746 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6748 mutex_lock(&ar->conf_mutex);
6750 if (vif->type == NL80211_IFTYPE_AP &&
6751 ar->num_peers > (ar->max_num_peers - 1)) {
6752 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6757 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6758 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6759 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6764 memset(arvif, 0, sizeof(*arvif));
6769 INIT_LIST_HEAD(&arvif->list);
6770 INIT_DELAYED_WORK(&arvif->connection_loss_work,
6771 ath11k_mac_vif_sta_connection_loss_work);
6773 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6774 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6775 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6776 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6777 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6778 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6779 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6780 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6781 sizeof(arvif->bitrate_mask.control[i].he_mcs));
6784 bit = __ffs64(ab->free_vdev_map);
6786 arvif->vdev_id = bit;
6787 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6789 switch (vif->type) {
6790 case NL80211_IFTYPE_UNSPECIFIED:
6791 case NL80211_IFTYPE_STATION:
6792 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6794 case NL80211_IFTYPE_MESH_POINT:
6795 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6797 case NL80211_IFTYPE_AP:
6798 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6800 case NL80211_IFTYPE_MONITOR:
6801 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6802 ar->monitor_vdev_id = bit;
6809 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "add interface id %d type %d subtype %d map %llx\n",
6810 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6813 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6814 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6815 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6817 ret = ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6819 ath11k_warn(ab, "failed to create vdev parameters %d: %d\n",
6820 arvif->vdev_id, ret);
6824 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6826 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6827 arvif->vdev_id, ret);
6831 ar->num_created_vdevs++;
6832 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6833 vif->addr, arvif->vdev_id);
6834 ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6835 ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6837 spin_lock_bh(&ar->data_lock);
6838 list_add(&arvif->list, &ar->arvifs);
6839 spin_unlock_bh(&ar->data_lock);
6841 ath11k_mac_op_update_vif_offload(hw, vif);
6843 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6844 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6845 WMI_VDEV_PARAM_NSS, nss);
6847 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6848 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6852 switch (arvif->vdev_type) {
6853 case WMI_VDEV_TYPE_AP:
6854 peer_param.vdev_id = arvif->vdev_id;
6855 peer_param.peer_addr = vif->addr;
6856 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6857 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6859 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6860 arvif->vdev_id, ret);
6864 ret = ath11k_mac_set_kickout(arvif);
6866 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6867 arvif->vdev_id, ret);
6871 ath11k_mac_11d_scan_stop_all(ar->ab);
6873 case WMI_VDEV_TYPE_STA:
6874 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6875 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6876 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6877 param_id, param_value);
6879 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6880 arvif->vdev_id, ret);
6884 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6885 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6886 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6887 param_id, param_value);
6889 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6890 arvif->vdev_id, ret);
6894 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6895 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6896 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6897 param_id, param_value);
6899 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6900 arvif->vdev_id, ret);
6904 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6905 WMI_STA_PS_MODE_DISABLED);
6907 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6908 arvif->vdev_id, ret);
6912 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6913 reinit_completion(&ar->completed_11d_scan);
6914 ar->state_11d = ATH11K_11D_PREPARING;
6917 case WMI_VDEV_TYPE_MONITOR:
6918 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6924 arvif->txpower = vif->bss_conf.txpower;
6925 ret = ath11k_mac_txpower_recalc(ar);
6929 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6930 param_value = ar->hw->wiphy->rts_threshold;
6931 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6932 param_id, param_value);
6934 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6935 arvif->vdev_id, ret);
6938 ath11k_dp_vdev_tx_attach(ar, arvif);
6940 if (vif->type != NL80211_IFTYPE_MONITOR &&
6941 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6942 ret = ath11k_mac_monitor_vdev_create(ar);
6944 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6948 mutex_unlock(&ar->conf_mutex);
6953 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6954 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6956 ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6957 vif->addr, arvif->vdev_id, fbret);
6963 ath11k_mac_vdev_delete(ar, arvif);
6964 spin_lock_bh(&ar->data_lock);
6965 list_del(&arvif->list);
6966 spin_unlock_bh(&ar->data_lock);
6969 mutex_unlock(&ar->conf_mutex);
6974 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6976 struct ieee80211_vif *vif = ctx;
6977 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6979 if (skb_cb->vif == vif)
6985 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6986 struct ieee80211_vif *vif)
6988 struct ath11k *ar = hw->priv;
6989 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6990 struct ath11k_base *ab = ar->ab;
6994 cancel_delayed_work_sync(&arvif->connection_loss_work);
6996 mutex_lock(&ar->conf_mutex);
6998 ath11k_dbg(ab, ATH11K_DBG_MAC, "remove interface (vdev %d)\n",
7001 ret = ath11k_spectral_vif_stop(arvif);
7003 ath11k_warn(ab, "failed to stop spectral for vdev %i: %d\n",
7004 arvif->vdev_id, ret);
7006 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7007 ath11k_mac_11d_scan_stop(ar);
7009 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7010 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
7012 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
7013 arvif->vdev_id, ret);
7016 ret = ath11k_mac_vdev_delete(ar, arvif);
7018 ath11k_warn(ab, "failed to delete vdev %d: %d\n",
7019 arvif->vdev_id, ret);
7023 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7024 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
7025 ar->monitor_vdev_id = -1;
7026 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
7027 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
7028 ret = ath11k_mac_monitor_vdev_delete(ar);
7030 /* continue even if there's an error */
7031 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
7036 spin_lock_bh(&ar->data_lock);
7037 list_del(&arvif->list);
7038 spin_unlock_bh(&ar->data_lock);
7040 ath11k_peer_cleanup(ar, arvif->vdev_id);
7042 idr_for_each(&ar->txmgmt_idr,
7043 ath11k_mac_vif_txmgmt_idr_remove, vif);
7045 for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
7046 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7047 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
7048 ath11k_mac_vif_unref, vif);
7049 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7052 /* Recalc txpower for remaining vdev */
7053 ath11k_mac_txpower_recalc(ar);
7055 /* TODO: recal traffic pause state based on the available vdevs */
7057 mutex_unlock(&ar->conf_mutex);
7060 /* FIXME: Has to be verified. */
7061 #define SUPPORTED_FILTERS \
7066 FIF_BCN_PRBRESP_PROMISC | \
7070 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
7071 unsigned int changed_flags,
7072 unsigned int *total_flags,
7075 struct ath11k *ar = hw->priv;
7077 mutex_lock(&ar->conf_mutex);
7079 *total_flags &= SUPPORTED_FILTERS;
7080 ar->filter_flags = *total_flags;
7082 mutex_unlock(&ar->conf_mutex);
7085 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
7087 struct ath11k *ar = hw->priv;
7089 mutex_lock(&ar->conf_mutex);
7091 *tx_ant = ar->cfg_tx_chainmask;
7092 *rx_ant = ar->cfg_rx_chainmask;
7094 mutex_unlock(&ar->conf_mutex);
7099 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
7101 struct ath11k *ar = hw->priv;
7104 mutex_lock(&ar->conf_mutex);
7105 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
7106 mutex_unlock(&ar->conf_mutex);
7111 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
7112 struct ieee80211_vif *vif,
7113 struct ieee80211_ampdu_params *params)
7115 struct ath11k *ar = hw->priv;
7118 mutex_lock(&ar->conf_mutex);
7120 switch (params->action) {
7121 case IEEE80211_AMPDU_RX_START:
7122 ret = ath11k_dp_rx_ampdu_start(ar, params);
7124 case IEEE80211_AMPDU_RX_STOP:
7125 ret = ath11k_dp_rx_ampdu_stop(ar, params);
7127 case IEEE80211_AMPDU_TX_START:
7128 case IEEE80211_AMPDU_TX_STOP_CONT:
7129 case IEEE80211_AMPDU_TX_STOP_FLUSH:
7130 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
7131 case IEEE80211_AMPDU_TX_OPERATIONAL:
7132 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
7133 * Tx aggregation requests.
7139 mutex_unlock(&ar->conf_mutex);
7144 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
7145 struct ieee80211_chanctx_conf *ctx)
7147 struct ath11k *ar = hw->priv;
7148 struct ath11k_base *ab = ar->ab;
7150 ath11k_dbg(ab, ATH11K_DBG_MAC,
7151 "chanctx add freq %u width %d ptr %p\n",
7152 ctx->def.chan->center_freq, ctx->def.width, ctx);
7154 mutex_lock(&ar->conf_mutex);
7156 spin_lock_bh(&ar->data_lock);
7157 /* TODO: In case of multiple channel context, populate rx_channel from
7158 * Rx PPDU desc information.
7160 ar->rx_channel = ctx->def.chan;
7161 spin_unlock_bh(&ar->data_lock);
7163 mutex_unlock(&ar->conf_mutex);
7168 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
7169 struct ieee80211_chanctx_conf *ctx)
7171 struct ath11k *ar = hw->priv;
7172 struct ath11k_base *ab = ar->ab;
7174 ath11k_dbg(ab, ATH11K_DBG_MAC,
7175 "chanctx remove freq %u width %d ptr %p\n",
7176 ctx->def.chan->center_freq, ctx->def.width, ctx);
7178 mutex_lock(&ar->conf_mutex);
7180 spin_lock_bh(&ar->data_lock);
7181 /* TODO: In case of there is one more channel context left, populate
7182 * rx_channel with the channel of that remaining channel context.
7184 ar->rx_channel = NULL;
7185 spin_unlock_bh(&ar->data_lock);
7187 mutex_unlock(&ar->conf_mutex);
7191 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
7192 struct ieee80211_chanctx_conf *ctx,
7195 struct ath11k *ar = arvif->ar;
7196 struct ath11k_base *ab = ar->ab;
7197 struct wmi_vdev_start_req_arg arg = {};
7198 const struct cfg80211_chan_def *chandef = &ctx->def;
7200 unsigned int dfs_cac_time;
7202 lockdep_assert_held(&ar->conf_mutex);
7204 reinit_completion(&ar->vdev_setup_done);
7206 arg.vdev_id = arvif->vdev_id;
7207 arg.dtim_period = arvif->dtim_period;
7208 arg.bcn_intval = arvif->beacon_interval;
7210 arg.channel.freq = chandef->chan->center_freq;
7211 arg.channel.band_center_freq1 = chandef->center_freq1;
7212 arg.channel.band_center_freq2 = chandef->center_freq2;
7214 ath11k_phymodes[chandef->chan->band][chandef->width];
7216 arg.channel.min_power = 0;
7217 arg.channel.max_power = chandef->chan->max_power;
7218 arg.channel.max_reg_power = chandef->chan->max_reg_power;
7219 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
7221 arg.pref_tx_streams = ar->num_tx_chains;
7222 arg.pref_rx_streams = ar->num_rx_chains;
7224 arg.mbssid_flags = 0;
7225 arg.mbssid_tx_vdev_id = 0;
7226 if (test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
7227 ar->ab->wmi_ab.svc_map)) {
7228 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
7230 &arg.mbssid_tx_vdev_id);
7235 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7236 arg.ssid = arvif->u.ap.ssid;
7237 arg.ssid_len = arvif->u.ap.ssid_len;
7238 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
7240 /* For now allow DFS for AP mode */
7241 arg.channel.chan_radar =
7242 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
7244 arg.channel.freq2_radar = ctx->radar_enabled;
7246 arg.channel.passive = arg.channel.chan_radar;
7248 spin_lock_bh(&ab->base_lock);
7249 arg.regdomain = ar->ab->dfs_region;
7250 spin_unlock_bh(&ab->base_lock);
7253 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
7255 ath11k_dbg(ab, ATH11K_DBG_MAC,
7256 "vdev %d start center_freq %d phymode %s\n",
7257 arg.vdev_id, arg.channel.freq,
7258 ath11k_wmi_phymode_str(arg.channel.mode));
7260 ret = ath11k_wmi_vdev_start(ar, &arg, restart);
7262 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
7263 restart ? "restart" : "start", arg.vdev_id);
7267 ret = ath11k_mac_vdev_setup_sync(ar);
7269 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
7270 arg.vdev_id, restart ? "restart" : "start", ret);
7275 ar->num_started_vdevs++;
7277 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n",
7278 arvif->vif->addr, arvif->vdev_id);
7280 /* Enable CAC Flag in the driver by checking the all sub-channel's DFS
7281 * state as NL80211_DFS_USABLE which indicates CAC needs to be
7282 * done before channel usage. This flags is used to drop rx packets.
7285 /* TODO Set the flag for other interface types as required */
7286 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && ctx->radar_enabled &&
7287 cfg80211_chandef_dfs_usable(ar->hw->wiphy, chandef)) {
7288 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7289 dfs_cac_time = cfg80211_chandef_dfs_cac_time(ar->hw->wiphy,
7291 ath11k_dbg(ab, ATH11K_DBG_MAC,
7292 "cac started dfs_cac_time %u center_freq %d center_freq1 %d for vdev %d\n",
7293 dfs_cac_time, arg.channel.freq, chandef->center_freq1,
7297 ret = ath11k_mac_set_txbf_conf(arvif);
7299 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
7300 arvif->vdev_id, ret);
7305 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
7307 struct ath11k *ar = arvif->ar;
7310 lockdep_assert_held(&ar->conf_mutex);
7312 reinit_completion(&ar->vdev_setup_done);
7314 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
7316 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
7317 arvif->vdev_id, ret);
7321 ret = ath11k_mac_vdev_setup_sync(ar);
7323 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
7324 arvif->vdev_id, ret);
7328 WARN_ON(ar->num_started_vdevs == 0);
7330 ar->num_started_vdevs--;
7331 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
7332 arvif->vif->addr, arvif->vdev_id);
7334 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
7335 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7336 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
7345 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
7346 struct ieee80211_chanctx_conf *ctx)
7348 return ath11k_mac_vdev_start_restart(arvif, ctx, false);
7351 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
7352 struct ieee80211_chanctx_conf *ctx)
7354 return ath11k_mac_vdev_start_restart(arvif, ctx, true);
7357 struct ath11k_mac_change_chanctx_arg {
7358 struct ieee80211_chanctx_conf *ctx;
7359 struct ieee80211_vif_chanctx_switch *vifs;
7365 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
7366 struct ieee80211_vif *vif)
7368 struct ath11k_mac_change_chanctx_arg *arg = data;
7370 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
7377 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
7378 struct ieee80211_vif *vif)
7380 struct ath11k_mac_change_chanctx_arg *arg = data;
7381 struct ieee80211_chanctx_conf *ctx;
7383 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
7384 if (ctx != arg->ctx)
7387 if (WARN_ON(arg->next_vif == arg->n_vifs))
7390 arg->vifs[arg->next_vif].vif = vif;
7391 arg->vifs[arg->next_vif].old_ctx = ctx;
7392 arg->vifs[arg->next_vif].new_ctx = ctx;
7397 ath11k_mac_update_vif_chan(struct ath11k *ar,
7398 struct ieee80211_vif_chanctx_switch *vifs,
7401 struct ath11k_base *ab = ar->ab;
7402 struct ath11k_vif *arvif, *tx_arvif = NULL;
7403 struct ieee80211_vif *mbssid_tx_vif;
7406 bool monitor_vif = false;
7408 lockdep_assert_held(&ar->conf_mutex);
7410 /* Associated channel resources of all relevant vdevs
7411 * should be available for the channel switch now.
7414 /* TODO: Update ar->rx_channel */
7416 for (i = 0; i < n_vifs; i++) {
7417 arvif = ath11k_vif_to_arvif(vifs[i].vif);
7419 if (WARN_ON(!arvif->is_started))
7422 /* change_chanctx can be called even before vdev_up from
7423 * ieee80211_start_ap->ieee80211_vif_use_channel->
7424 * ieee80211_recalc_radar_chanctx.
7426 * Firmware expect vdev_restart only if vdev is up.
7427 * If vdev is down then it expect vdev_stop->vdev_start.
7430 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
7432 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
7433 arvif->vdev_id, ret);
7437 ret = ath11k_mac_vdev_stop(arvif);
7439 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
7440 arvif->vdev_id, ret);
7444 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
7446 ath11k_warn(ab, "failed to start vdev %d: %d\n",
7447 arvif->vdev_id, ret);
7452 ret = ath11k_mac_setup_bcn_tmpl(arvif);
7454 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
7457 mbssid_tx_vif = arvif->vif->mbssid_tx_vif;
7459 tx_arvif = ath11k_vif_to_arvif(mbssid_tx_vif);
7461 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
7463 tx_arvif ? tx_arvif->bssid : NULL,
7464 arvif->vif->bss_conf.bssid_index,
7465 1 << arvif->vif->bss_conf.bssid_indicator);
7467 ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
7468 arvif->vdev_id, ret);
7473 /* Restart the internal monitor vdev on new channel */
7475 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7476 ret = ath11k_mac_monitor_stop(ar);
7478 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
7483 ret = ath11k_mac_monitor_start(ar);
7485 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
7493 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
7494 struct ieee80211_chanctx_conf *ctx)
7496 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
7498 lockdep_assert_held(&ar->conf_mutex);
7500 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7501 IEEE80211_IFACE_ITER_NORMAL,
7502 ath11k_mac_change_chanctx_cnt_iter,
7504 if (arg.n_vifs == 0)
7507 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
7511 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7512 IEEE80211_IFACE_ITER_NORMAL,
7513 ath11k_mac_change_chanctx_fill_iter,
7516 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
7521 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
7522 struct ieee80211_chanctx_conf *ctx,
7525 struct ath11k *ar = hw->priv;
7526 struct ath11k_base *ab = ar->ab;
7528 mutex_lock(&ar->conf_mutex);
7530 ath11k_dbg(ab, ATH11K_DBG_MAC,
7531 "chanctx change freq %u width %d ptr %p changed %x\n",
7532 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
7534 /* This shouldn't really happen because channel switching should use
7535 * switch_vif_chanctx().
7537 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
7540 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
7541 changed & IEEE80211_CHANCTX_CHANGE_RADAR)
7542 ath11k_mac_update_active_vif_chan(ar, ctx);
7544 /* TODO: Recalc radar detection */
7547 mutex_unlock(&ar->conf_mutex);
7550 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
7551 struct ieee80211_vif *vif)
7553 struct ath11k *ar = hw->priv;
7554 struct ath11k_base *ab = ar->ab;
7555 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7558 if (WARN_ON(arvif->is_started))
7561 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
7563 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7564 arvif->vdev_id, vif->addr,
7565 arvif->chanctx.def.chan->center_freq, ret);
7569 /* Reconfigure hardware rate code since it is cleared by firmware.
7571 if (ar->hw_rate_code > 0) {
7572 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
7574 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
7577 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
7582 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7583 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr,
7586 ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7591 arvif->is_started = true;
7593 /* TODO: Setup ps and cts/rts protection */
7598 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7599 struct ieee80211_vif *vif,
7600 struct ieee80211_bss_conf *link_conf,
7601 struct ieee80211_chanctx_conf *ctx)
7603 struct ath11k *ar = hw->priv;
7604 struct ath11k_base *ab = ar->ab;
7605 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7607 struct peer_create_params param;
7609 mutex_lock(&ar->conf_mutex);
7611 ath11k_dbg(ab, ATH11K_DBG_MAC,
7612 "chanctx assign ptr %p vdev_id %i\n",
7613 ctx, arvif->vdev_id);
7615 /* for QCA6390 bss peer must be created before vdev_start */
7616 if (ab->hw_params.vdev_start_delay &&
7617 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7618 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7619 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7620 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7625 if (WARN_ON(arvif->is_started)) {
7630 if (ab->hw_params.vdev_start_delay &&
7631 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7632 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7633 param.vdev_id = arvif->vdev_id;
7634 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7635 param.peer_addr = ar->mac_addr;
7637 ret = ath11k_peer_create(ar, arvif, NULL, ¶m);
7639 ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7645 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7646 ret = ath11k_mac_monitor_start(ar);
7648 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7653 arvif->is_started = true;
7657 ret = ath11k_mac_vdev_start(arvif, ctx);
7659 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7660 arvif->vdev_id, vif->addr,
7661 ctx->def.chan->center_freq, ret);
7665 arvif->is_started = true;
7667 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7668 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7669 ret = ath11k_mac_monitor_start(ar);
7671 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7677 /* TODO: Setup ps and cts/rts protection */
7682 mutex_unlock(&ar->conf_mutex);
7688 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7689 struct ieee80211_vif *vif,
7690 struct ieee80211_bss_conf *link_conf,
7691 struct ieee80211_chanctx_conf *ctx)
7693 struct ath11k *ar = hw->priv;
7694 struct ath11k_base *ab = ar->ab;
7695 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7696 struct ath11k_peer *peer;
7699 mutex_lock(&ar->conf_mutex);
7701 ath11k_dbg(ab, ATH11K_DBG_MAC,
7702 "chanctx unassign ptr %p vdev_id %i\n",
7703 ctx, arvif->vdev_id);
7705 WARN_ON(!arvif->is_started);
7707 if (ab->hw_params.vdev_start_delay &&
7708 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7709 spin_lock_bh(&ab->base_lock);
7710 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7711 spin_unlock_bh(&ab->base_lock);
7713 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7716 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7717 ret = ath11k_mac_monitor_stop(ar);
7719 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7721 mutex_unlock(&ar->conf_mutex);
7725 arvif->is_started = false;
7726 mutex_unlock(&ar->conf_mutex);
7730 ret = ath11k_mac_vdev_stop(arvif);
7732 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7733 arvif->vdev_id, ret);
7735 arvif->is_started = false;
7737 if (ab->hw_params.vdev_start_delay &&
7738 arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7739 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7742 "failed to delete peer %pM for vdev %d: %d\n",
7743 arvif->bssid, arvif->vdev_id, ret);
7745 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7746 "removed peer %pM vdev %d after vdev stop\n",
7747 arvif->bssid, arvif->vdev_id);
7750 if (ab->hw_params.vdev_start_delay &&
7751 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7752 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7754 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7755 ar->num_started_vdevs == 1 &&
7756 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7757 ret = ath11k_mac_monitor_stop(ar);
7759 /* continue even if there's an error */
7760 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7764 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7765 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7767 mutex_unlock(&ar->conf_mutex);
7771 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7772 struct ieee80211_vif_chanctx_switch *vifs,
7774 enum ieee80211_chanctx_switch_mode mode)
7776 struct ath11k *ar = hw->priv;
7778 mutex_lock(&ar->conf_mutex);
7780 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7781 "chanctx switch n_vifs %d mode %d\n",
7783 ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7785 mutex_unlock(&ar->conf_mutex);
7791 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7793 struct ath11k_vif *arvif;
7796 mutex_lock(&ar->conf_mutex);
7797 list_for_each_entry(arvif, &ar->arvifs, list) {
7798 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7799 param, arvif->vdev_id, value);
7801 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7804 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7805 param, arvif->vdev_id, ret);
7809 mutex_unlock(&ar->conf_mutex);
7813 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7814 * this is set interface specific to firmware from ath11k driver
7816 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7818 struct ath11k *ar = hw->priv;
7819 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7821 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7824 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7826 /* Even though there's a WMI vdev param for fragmentation threshold no
7827 * known firmware actually implements it. Moreover it is not possible to
7828 * rely frame fragmentation to mac80211 because firmware clears the
7829 * "more fragments" bit in frame control making it impossible for remote
7830 * devices to reassemble frames.
7832 * Hence implement a dummy callback just to say fragmentation isn't
7833 * supported. This effectively prevents mac80211 from doing frame
7834 * fragmentation in software.
7839 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7844 time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7845 (atomic_read(&ar->dp.num_tx_pending) == 0),
7846 ATH11K_FLUSH_TIMEOUT);
7847 if (time_left == 0) {
7848 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7849 atomic_read(&ar->dp.num_tx_pending));
7853 time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7854 (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7855 ATH11K_FLUSH_TIMEOUT);
7856 if (time_left == 0) {
7857 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7858 atomic_read(&ar->num_pending_mgmt_tx));
7865 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7867 ath11k_mac_drain_tx(ar);
7868 return ath11k_mac_flush_tx_complete(ar);
7871 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7872 u32 queues, bool drop)
7874 struct ath11k *ar = hw->priv;
7879 ath11k_mac_flush_tx_complete(ar);
7883 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7884 enum nl80211_band band,
7885 const struct cfg80211_bitrate_mask *mask)
7889 num_rates = hweight32(mask->control[band].legacy);
7891 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7894 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7897 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7900 return num_rates == 1;
7904 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7906 if (he_cap->he_cap_elem.phy_cap_info[0] &
7907 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7908 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7910 if (he_cap->he_cap_elem.phy_cap_info[0] &
7911 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7912 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7914 return he_cap->he_mcs_nss_supp.tx_mcs_80;
7918 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7919 struct ath11k_vif *arvif,
7920 enum nl80211_band band,
7921 const struct cfg80211_bitrate_mask *mask,
7924 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7925 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7926 const struct ieee80211_sta_he_cap *he_cap;
7929 u8 vht_nss_mask = 0;
7933 /* No need to consider legacy here. Basic rates are always present
7937 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7938 if (mask->control[band].ht_mcs[i] == 0)
7940 else if (mask->control[band].ht_mcs[i] ==
7941 sband->ht_cap.mcs.rx_mask[i])
7942 ht_nss_mask |= BIT(i);
7947 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7948 if (mask->control[band].vht_mcs[i] == 0)
7950 else if (mask->control[band].vht_mcs[i] ==
7951 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7952 vht_nss_mask |= BIT(i);
7957 he_cap = ieee80211_get_he_iftype_cap_vif(sband, arvif->vif);
7961 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(he_cap));
7963 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7964 if (mask->control[band].he_mcs[i] == 0)
7967 if (mask->control[band].he_mcs[i] ==
7968 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7969 he_nss_mask |= BIT(i);
7974 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7977 if (ht_nss_mask == 0)
7980 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7983 *nss = fls(ht_nss_mask);
7989 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7990 enum nl80211_band band,
7991 const struct cfg80211_bitrate_mask *mask,
7999 if (hweight32(mask->control[band].legacy) != 1)
8002 rate_idx = ffs(mask->control[band].legacy) - 1;
8004 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
8005 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
8007 hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
8008 bitrate = ath11k_legacy_rates[rate_idx].bitrate;
8010 if (ath11k_mac_bitrate_is_cck(bitrate))
8011 preamble = WMI_RATE_PREAMBLE_CCK;
8013 preamble = WMI_RATE_PREAMBLE_OFDM;
8016 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
8022 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
8024 struct ath11k *ar = arvif->ar;
8027 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
8028 if (he_gi && he_gi != 0xFF)
8031 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8032 WMI_VDEV_PARAM_SGI, he_gi);
8034 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
8042 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8043 WMI_VDEV_PARAM_HE_LTF, he_ltf);
8045 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
8054 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
8056 struct ath11k *ar = arvif->ar;
8060 if (he_gi != 0xFF) {
8062 case NL80211_RATE_INFO_HE_GI_0_8:
8063 he_gi = WMI_AUTORATE_800NS_GI;
8065 case NL80211_RATE_INFO_HE_GI_1_6:
8066 he_gi = WMI_AUTORATE_1600NS_GI;
8068 case NL80211_RATE_INFO_HE_GI_3_2:
8069 he_gi = WMI_AUTORATE_3200NS_GI;
8072 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
8077 if (he_ltf != 0xFF) {
8079 case NL80211_RATE_INFO_HE_1XLTF:
8080 he_ltf = WMI_HE_AUTORATE_LTF_1X;
8082 case NL80211_RATE_INFO_HE_2XLTF:
8083 he_ltf = WMI_HE_AUTORATE_LTF_2X;
8085 case NL80211_RATE_INFO_HE_4XLTF:
8086 he_ltf = WMI_HE_AUTORATE_LTF_4X;
8089 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
8094 he_ar_gi_ltf = he_gi | he_ltf;
8095 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8096 WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
8100 "failed to set he autorate gi %u ltf %u: %d\n",
8101 he_gi, he_ltf, ret);
8108 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
8109 u32 rate, u8 nss, u8 sgi, u8 ldpc,
8110 u8 he_gi, u8 he_ltf, bool he_fixed_rate)
8112 struct ath11k *ar = arvif->ar;
8116 lockdep_assert_held(&ar->conf_mutex);
8118 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8119 "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",
8120 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
8121 he_ltf, he_fixed_rate);
8123 if (!arvif->vif->bss_conf.he_support) {
8124 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
8125 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8128 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
8134 vdev_param = WMI_VDEV_PARAM_NSS;
8135 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8138 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
8143 vdev_param = WMI_VDEV_PARAM_LDPC;
8144 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8147 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
8152 if (arvif->vif->bss_conf.he_support) {
8153 if (he_fixed_rate) {
8154 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
8157 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
8162 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
8165 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
8171 vdev_param = WMI_VDEV_PARAM_SGI;
8172 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8175 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
8185 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
8186 enum nl80211_band band,
8187 const struct cfg80211_bitrate_mask *mask)
8192 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8193 vht_mcs = mask->control[band].vht_mcs[i];
8210 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
8211 enum nl80211_band band,
8212 const struct cfg80211_bitrate_mask *mask)
8217 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
8218 he_mcs = mask->control[band].he_mcs[i];
8234 static void ath11k_mac_set_bitrate_mask_iter(void *data,
8235 struct ieee80211_sta *sta)
8237 struct ath11k_vif *arvif = data;
8238 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8239 struct ath11k *ar = arvif->ar;
8241 spin_lock_bh(&ar->data_lock);
8242 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
8243 spin_unlock_bh(&ar->data_lock);
8245 ieee80211_queue_work(ar->hw, &arsta->update_wk);
8248 static void ath11k_mac_disable_peer_fixed_rate(void *data,
8249 struct ieee80211_sta *sta)
8251 struct ath11k_vif *arvif = data;
8252 struct ath11k *ar = arvif->ar;
8255 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
8257 WMI_PEER_PARAM_FIXED_RATE,
8258 WMI_FIXED_RATE_NONE);
8261 "failed to disable peer fixed rate for STA %pM ret %d\n",
8266 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
8267 const struct cfg80211_bitrate_mask *mask)
8269 bool he_fixed_rate = false, vht_fixed_rate = false;
8270 struct ath11k_peer *peer;
8271 const u16 *vht_mcs_mask, *he_mcs_mask;
8272 struct ieee80211_link_sta *deflink;
8276 vht_mcs_mask = mask->control[band].vht_mcs;
8277 he_mcs_mask = mask->control[band].he_mcs;
8279 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
8280 vht_fixed_rate = true;
8282 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
8283 he_fixed_rate = true;
8285 if (!vht_fixed_rate && !he_fixed_rate)
8288 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
8289 he_nss = ath11k_mac_max_he_nss(he_mcs_mask);
8292 spin_lock_bh(&ar->ab->base_lock);
8293 list_for_each_entry(peer, &ar->ab->peers, list) {
8295 deflink = &peer->sta->deflink;
8297 if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
8298 deflink->rx_nss < vht_nss)) {
8303 if (he_fixed_rate && (!deflink->he_cap.has_he ||
8304 deflink->rx_nss < he_nss)) {
8312 spin_unlock_bh(&ar->ab->base_lock);
8318 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
8319 struct ieee80211_vif *vif,
8320 const struct cfg80211_bitrate_mask *mask)
8322 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8323 struct cfg80211_chan_def def;
8324 struct ath11k_pdev_cap *cap;
8325 struct ath11k *ar = arvif->ar;
8326 enum nl80211_band band;
8327 const u8 *ht_mcs_mask;
8328 const u16 *vht_mcs_mask;
8329 const u16 *he_mcs_mask;
8339 bool he_fixed_rate = false;
8341 if (ath11k_mac_vif_chan(vif, &def))
8344 band = def.chan->band;
8345 cap = &ar->pdev->cap;
8346 ht_mcs_mask = mask->control[band].ht_mcs;
8347 vht_mcs_mask = mask->control[band].vht_mcs;
8348 he_mcs_mask = mask->control[band].he_mcs;
8349 ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
8351 sgi = mask->control[band].gi;
8352 if (sgi == NL80211_TXRATE_FORCE_LGI)
8355 he_gi = mask->control[band].he_gi;
8356 he_ltf = mask->control[band].he_ltf;
8358 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
8359 * requires passing at least one of used basic rates along with them.
8360 * Fixed rate setting across different preambles(legacy, HT, VHT) is
8361 * not supported by the FW. Hence use of FIXED_RATE vdev param is not
8362 * suitable for setting single HT/VHT rates.
8363 * But, there could be a single basic rate passed from userspace which
8364 * can be done through the FIXED_RATE param.
8366 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
8367 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
8370 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
8371 arvif->vdev_id, ret);
8374 ieee80211_iterate_stations_atomic(ar->hw,
8375 ath11k_mac_disable_peer_fixed_rate,
8377 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, arvif, band, mask,
8379 rate = WMI_FIXED_RATE_NONE;
8381 mutex_lock(&ar->conf_mutex);
8382 arvif->bitrate_mask = *mask;
8383 ieee80211_iterate_stations_atomic(ar->hw,
8384 ath11k_mac_set_bitrate_mask_iter,
8386 mutex_unlock(&ar->conf_mutex);
8388 rate = WMI_FIXED_RATE_NONE;
8390 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
8392 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
8393 nss = min_t(u32, ar->num_tx_chains,
8394 ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
8396 /* If multiple rates across different preambles are given
8397 * we can reconfigure this info with all peers using PEER_ASSOC
8398 * command with the below exception cases.
8399 * - Single VHT Rate : peer_assoc command accommodates only MCS
8400 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
8401 * mandates passing basic rates along with HT/VHT rates, FW
8402 * doesn't allow switching from VHT to Legacy. Hence instead of
8403 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
8404 * we could set this VHT rate as peer fixed rate param, which
8405 * will override FIXED rate and FW rate control algorithm.
8406 * If single VHT rate is passed along with HT rates, we select
8407 * the VHT rate as fixed rate for vht peers.
8408 * - Multiple VHT Rates : When Multiple VHT rates are given,this
8409 * can be set using RATEMASK CMD which uses FW rate-ctl alg.
8410 * TODO: Setting multiple VHT MCS and replacing peer_assoc with
8411 * RATEMASK_CMDID can cover all use cases of setting rates
8412 * across multiple preambles and rates within same type.
8413 * But requires more validation of the command at this point.
8416 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
8419 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
8421 /* TODO: Handle multiple VHT MCS values setting using
8425 "setting %d mcs values in bitrate mask not supported\n",
8430 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
8433 he_fixed_rate = true;
8435 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
8438 "Setting more than one HE MCS Value in bitrate mask not supported\n");
8442 mutex_lock(&ar->conf_mutex);
8443 ieee80211_iterate_stations_atomic(ar->hw,
8444 ath11k_mac_disable_peer_fixed_rate,
8447 arvif->bitrate_mask = *mask;
8448 ieee80211_iterate_stations_atomic(ar->hw,
8449 ath11k_mac_set_bitrate_mask_iter,
8452 mutex_unlock(&ar->conf_mutex);
8455 mutex_lock(&ar->conf_mutex);
8457 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
8458 he_ltf, he_fixed_rate);
8460 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
8461 arvif->vdev_id, ret);
8464 mutex_unlock(&ar->conf_mutex);
8470 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
8471 enum ieee80211_reconfig_type reconfig_type)
8473 struct ath11k *ar = hw->priv;
8474 struct ath11k_base *ab = ar->ab;
8476 struct ath11k_vif *arvif;
8478 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
8481 mutex_lock(&ar->conf_mutex);
8483 if (ar->state == ATH11K_STATE_RESTARTED) {
8484 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
8486 ar->state = ATH11K_STATE_ON;
8487 ieee80211_wake_queues(ar->hw);
8489 if (ar->ab->hw_params.current_cc_support &&
8490 ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
8491 struct wmi_set_current_country_params set_current_param = {};
8493 memcpy(&set_current_param.alpha2, ar->alpha2, 2);
8494 ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8498 recovery_count = atomic_inc_return(&ab->recovery_count);
8499 ath11k_dbg(ab, ATH11K_DBG_BOOT,
8500 "recovery count %d\n", recovery_count);
8501 /* When there are multiple radios in an SOC,
8502 * the recovery has to be done for each radio
8504 if (recovery_count == ab->num_radios) {
8505 atomic_dec(&ab->reset_count);
8506 complete(&ab->reset_complete);
8507 ab->is_reset = false;
8508 atomic_set(&ab->fail_cont_count, 0);
8509 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
8512 if (ar->ab->hw_params.support_fw_mac_sequence) {
8513 list_for_each_entry(arvif, &ar->arvifs, list) {
8514 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
8515 ieee80211_hw_restart_disconnect(arvif->vif);
8520 mutex_unlock(&ar->conf_mutex);
8524 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
8525 struct ieee80211_channel *channel)
8528 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8530 lockdep_assert_held(&ar->conf_mutex);
8532 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
8533 ar->rx_channel != channel)
8536 if (ar->scan.state != ATH11K_SCAN_IDLE) {
8537 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8538 "ignoring bss chan info req while scanning..\n");
8542 reinit_completion(&ar->bss_survey_done);
8544 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
8546 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
8550 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8552 ath11k_warn(ar->ab, "bss channel survey timed out\n");
8555 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
8556 struct survey_info *survey)
8558 struct ath11k *ar = hw->priv;
8559 struct ieee80211_supported_band *sband;
8560 struct survey_info *ar_survey;
8563 if (idx >= ATH11K_NUM_CHANS)
8566 ar_survey = &ar->survey[idx];
8568 mutex_lock(&ar->conf_mutex);
8570 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8571 if (sband && idx >= sband->n_channels) {
8572 idx -= sband->n_channels;
8577 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8578 if (sband && idx >= sband->n_channels) {
8579 idx -= sband->n_channels;
8584 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8585 if (!sband || idx >= sband->n_channels) {
8590 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8592 spin_lock_bh(&ar->data_lock);
8593 memcpy(survey, ar_survey, sizeof(*survey));
8594 spin_unlock_bh(&ar->data_lock);
8596 survey->channel = &sband->channels[idx];
8598 if (ar->rx_channel == survey->channel)
8599 survey->filled |= SURVEY_INFO_IN_USE;
8602 mutex_unlock(&ar->conf_mutex);
8606 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8607 struct ath11k_sta *arsta,
8611 struct ath11k *ar = arsta->arvif->ar;
8615 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8616 sinfo->chains &= ~BIT(i);
8617 rssi = arsta->chain_signal[i];
8619 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8621 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8622 "sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8624 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8625 rssi != ATH11K_INVALID_RSSI_FULL &&
8626 rssi != ATH11K_INVALID_RSSI_EMPTY &&
8628 sinfo->chain_signal[i] = rssi;
8629 sinfo->chains |= BIT(i);
8630 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8635 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8636 struct ieee80211_vif *vif,
8637 struct ieee80211_sta *sta,
8638 struct station_info *sinfo)
8640 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8641 struct ath11k *ar = arsta->arvif->ar;
8643 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8644 ar->ab->wmi_ab.svc_map);
8646 sinfo->rx_duration = arsta->rx_duration;
8647 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8649 sinfo->tx_duration = arsta->tx_duration;
8650 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8652 if (arsta->txrate.legacy || arsta->txrate.nss) {
8653 if (arsta->txrate.legacy) {
8654 sinfo->txrate.legacy = arsta->txrate.legacy;
8656 sinfo->txrate.mcs = arsta->txrate.mcs;
8657 sinfo->txrate.nss = arsta->txrate.nss;
8658 sinfo->txrate.bw = arsta->txrate.bw;
8659 sinfo->txrate.he_gi = arsta->txrate.he_gi;
8660 sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8661 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8663 sinfo->txrate.flags = arsta->txrate.flags;
8664 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8667 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8669 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8670 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8671 ar->ab->hw_params.supports_rssi_stats &&
8672 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8673 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8674 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8677 signal = arsta->rssi_comb;
8679 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8680 ar->ab->hw_params.supports_rssi_stats &&
8681 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8682 WMI_REQUEST_VDEV_STAT)))
8683 signal = arsta->rssi_beacon;
8685 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8686 "sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8687 db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8690 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8691 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8694 sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8695 ATH11K_DEFAULT_NOISE_FLOOR;
8696 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8699 #if IS_ENABLED(CONFIG_IPV6)
8700 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8701 struct ath11k_arp_ns_offload *offload)
8705 for (i = 0; i < offload->ipv6_count; i++) {
8706 offload->self_ipv6_addr[i][0] = 0xff;
8707 offload->self_ipv6_addr[i][1] = 0x02;
8708 offload->self_ipv6_addr[i][11] = 0x01;
8709 offload->self_ipv6_addr[i][12] = 0xff;
8710 offload->self_ipv6_addr[i][13] =
8711 offload->ipv6_addr[i][13];
8712 offload->self_ipv6_addr[i][14] =
8713 offload->ipv6_addr[i][14];
8714 offload->self_ipv6_addr[i][15] =
8715 offload->ipv6_addr[i][15];
8716 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8717 offload->self_ipv6_addr[i]);
8721 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8722 struct ieee80211_vif *vif,
8723 struct inet6_dev *idev)
8725 struct ath11k *ar = hw->priv;
8726 struct ath11k_arp_ns_offload *offload;
8727 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8728 struct inet6_ifaddr *ifa6;
8729 struct ifacaddr6 *ifaca6;
8730 struct list_head *p;
8733 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "op ipv6 changed\n");
8735 offload = &arvif->arp_ns_offload;
8738 read_lock_bh(&idev->lock);
8740 memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8741 memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8742 memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8744 /* get unicast address */
8745 list_for_each(p, &idev->addr_list) {
8746 if (count >= ATH11K_IPV6_MAX_COUNT)
8749 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8750 if (ifa6->flags & IFA_F_DADFAILED)
8752 scope = ipv6_addr_src_scope(&ifa6->addr);
8753 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8754 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8755 memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8756 sizeof(ifa6->addr.s6_addr));
8757 offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8758 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 uc %pI6 scope %d\n",
8759 count, offload->ipv6_addr[count],
8763 ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8767 /* get anycast address */
8768 for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8769 if (count >= ATH11K_IPV6_MAX_COUNT)
8772 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8773 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8774 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8775 memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8776 sizeof(ifaca6->aca_addr));
8777 offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8778 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 ac %pI6 scope %d\n",
8779 count, offload->ipv6_addr[count],
8783 ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8788 offload->ipv6_count = count;
8789 read_unlock_bh(&idev->lock);
8791 /* generate ns multicast address */
8792 ath11k_generate_ns_mc_addr(ar, offload);
8796 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8797 struct ieee80211_vif *vif,
8798 struct cfg80211_gtk_rekey_data *data)
8800 struct ath11k *ar = hw->priv;
8801 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8802 struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8804 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "set rekey data vdev %d\n",
8807 mutex_lock(&ar->conf_mutex);
8809 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8810 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8812 /* The supplicant works on big-endian, the firmware expects it on
8815 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8817 arvif->rekey_data.enable_offload = true;
8819 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8820 rekey_data->kck, NL80211_KCK_LEN);
8821 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8822 rekey_data->kck, NL80211_KEK_LEN);
8823 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8824 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8826 mutex_unlock(&ar->conf_mutex);
8829 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8830 const struct cfg80211_sar_specs *sar)
8832 struct ath11k *ar = hw->priv;
8833 const struct cfg80211_sar_sub_specs *sspec;
8838 if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8839 sar->num_sub_specs == 0)
8842 mutex_lock(&ar->conf_mutex);
8844 if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8845 !ar->ab->hw_params.bios_sar_capa) {
8850 ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8852 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8856 sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8862 sspec = sar->sub_specs;
8863 for (i = 0; i < sar->num_sub_specs; i++) {
8864 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8865 ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8866 sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8870 /* chain0 and chain1 share same power setting */
8871 sar_tbl[sspec->freq_range_index] = sspec->power;
8872 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8873 sar_tbl[index] = sspec->power;
8874 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8875 sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8879 ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8881 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8885 mutex_unlock(&ar->conf_mutex);
8890 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8891 struct ieee80211_vif *vif)
8893 struct ath11k *ar = hw->priv;
8895 mutex_lock(&ar->conf_mutex);
8897 spin_lock_bh(&ar->data_lock);
8898 ar->scan.roc_notify = false;
8899 spin_unlock_bh(&ar->data_lock);
8901 ath11k_scan_abort(ar);
8903 mutex_unlock(&ar->conf_mutex);
8905 cancel_delayed_work_sync(&ar->scan.timeout);
8910 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8911 struct ieee80211_vif *vif,
8912 struct ieee80211_channel *chan,
8914 enum ieee80211_roc_type type)
8916 struct ath11k *ar = hw->priv;
8917 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8918 struct scan_req_params *arg;
8922 mutex_lock(&ar->conf_mutex);
8924 spin_lock_bh(&ar->data_lock);
8925 switch (ar->scan.state) {
8926 case ATH11K_SCAN_IDLE:
8927 reinit_completion(&ar->scan.started);
8928 reinit_completion(&ar->scan.completed);
8929 reinit_completion(&ar->scan.on_channel);
8930 ar->scan.state = ATH11K_SCAN_STARTING;
8931 ar->scan.is_roc = true;
8932 ar->scan.vdev_id = arvif->vdev_id;
8933 ar->scan.roc_freq = chan->center_freq;
8934 ar->scan.roc_notify = true;
8937 case ATH11K_SCAN_STARTING:
8938 case ATH11K_SCAN_RUNNING:
8939 case ATH11K_SCAN_ABORTING:
8943 spin_unlock_bh(&ar->data_lock);
8948 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8950 arg = kzalloc(sizeof(*arg), GFP_KERNEL);
8955 ath11k_wmi_start_scan_init(ar, arg);
8957 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
8959 if (!arg->chan_list) {
8964 arg->vdev_id = arvif->vdev_id;
8965 arg->scan_id = ATH11K_SCAN_ID;
8966 arg->chan_list[0] = chan->center_freq;
8967 arg->dwell_time_active = scan_time_msec;
8968 arg->dwell_time_passive = scan_time_msec;
8969 arg->max_scan_time = scan_time_msec;
8970 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8971 arg->scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8972 arg->burst_duration = duration;
8974 ret = ath11k_start_scan(ar, arg);
8976 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8978 spin_lock_bh(&ar->data_lock);
8979 ar->scan.state = ATH11K_SCAN_IDLE;
8980 spin_unlock_bh(&ar->data_lock);
8981 goto free_chan_list;
8984 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8986 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8987 ret = ath11k_scan_stop(ar);
8989 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8991 goto free_chan_list;
8994 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
8995 msecs_to_jiffies(duration));
9000 kfree(arg->chan_list);
9004 mutex_unlock(&ar->conf_mutex);
9008 static int ath11k_fw_stats_request(struct ath11k *ar,
9009 struct stats_request_params *req_param)
9011 struct ath11k_base *ab = ar->ab;
9012 unsigned long time_left;
9015 lockdep_assert_held(&ar->conf_mutex);
9017 spin_lock_bh(&ar->data_lock);
9018 ar->fw_stats_done = false;
9019 ath11k_fw_stats_pdevs_free(&ar->fw_stats.pdevs);
9020 spin_unlock_bh(&ar->data_lock);
9022 reinit_completion(&ar->fw_stats_complete);
9024 ret = ath11k_wmi_send_stats_request_cmd(ar, req_param);
9026 ath11k_warn(ab, "could not request fw stats (%d)\n",
9031 time_left = wait_for_completion_timeout(&ar->fw_stats_complete,
9040 static int ath11k_mac_op_get_txpower(struct ieee80211_hw *hw,
9041 struct ieee80211_vif *vif,
9044 struct ath11k *ar = hw->priv;
9045 struct ath11k_base *ab = ar->ab;
9046 struct stats_request_params req_param = {0};
9047 struct ath11k_fw_stats_pdev *pdev;
9050 /* Final Tx power is minimum of Target Power, CTL power, Regulatory
9051 * Power, PSD EIRP Power. We just know the Regulatory power from the
9052 * regulatory rules obtained. FW knows all these power and sets the min
9053 * of these. Hence, we request the FW pdev stats in which FW reports
9054 * the minimum of all vdev's channel Tx power.
9056 mutex_lock(&ar->conf_mutex);
9058 if (ar->state != ATH11K_STATE_ON)
9061 /* Firmware doesn't provide Tx power during CAC hence no need to fetch
9064 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
9065 mutex_unlock(&ar->conf_mutex);
9069 req_param.pdev_id = ar->pdev->pdev_id;
9070 req_param.stats_id = WMI_REQUEST_PDEV_STAT;
9072 ret = ath11k_fw_stats_request(ar, &req_param);
9074 ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret);
9078 spin_lock_bh(&ar->data_lock);
9079 pdev = list_first_entry_or_null(&ar->fw_stats.pdevs,
9080 struct ath11k_fw_stats_pdev, list);
9082 spin_unlock_bh(&ar->data_lock);
9086 /* tx power is set as 2 units per dBm in FW. */
9087 *dbm = pdev->chan_tx_power / 2;
9089 spin_unlock_bh(&ar->data_lock);
9090 mutex_unlock(&ar->conf_mutex);
9092 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware %d, reported %d dBm\n",
9093 pdev->chan_tx_power, *dbm);
9097 mutex_unlock(&ar->conf_mutex);
9098 /* We didn't get txpower from FW. Hence, relying on vif->bss_conf.txpower */
9099 *dbm = vif->bss_conf.txpower;
9100 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware NaN, reported %d dBm\n",
9105 static const struct ieee80211_ops ath11k_ops = {
9106 .tx = ath11k_mac_op_tx,
9107 .wake_tx_queue = ieee80211_handle_wake_tx_queue,
9108 .start = ath11k_mac_op_start,
9109 .stop = ath11k_mac_op_stop,
9110 .reconfig_complete = ath11k_mac_op_reconfig_complete,
9111 .add_interface = ath11k_mac_op_add_interface,
9112 .remove_interface = ath11k_mac_op_remove_interface,
9113 .update_vif_offload = ath11k_mac_op_update_vif_offload,
9114 .config = ath11k_mac_op_config,
9115 .bss_info_changed = ath11k_mac_op_bss_info_changed,
9116 .configure_filter = ath11k_mac_op_configure_filter,
9117 .hw_scan = ath11k_mac_op_hw_scan,
9118 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan,
9119 .set_key = ath11k_mac_op_set_key,
9120 .set_rekey_data = ath11k_mac_op_set_rekey_data,
9121 .sta_state = ath11k_mac_op_sta_state,
9122 .sta_set_4addr = ath11k_mac_op_sta_set_4addr,
9123 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr,
9124 .sta_rc_update = ath11k_mac_op_sta_rc_update,
9125 .conf_tx = ath11k_mac_op_conf_tx,
9126 .set_antenna = ath11k_mac_op_set_antenna,
9127 .get_antenna = ath11k_mac_op_get_antenna,
9128 .ampdu_action = ath11k_mac_op_ampdu_action,
9129 .add_chanctx = ath11k_mac_op_add_chanctx,
9130 .remove_chanctx = ath11k_mac_op_remove_chanctx,
9131 .change_chanctx = ath11k_mac_op_change_chanctx,
9132 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx,
9133 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx,
9134 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx,
9135 .set_rts_threshold = ath11k_mac_op_set_rts_threshold,
9136 .set_frag_threshold = ath11k_mac_op_set_frag_threshold,
9137 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask,
9138 .get_survey = ath11k_mac_op_get_survey,
9139 .flush = ath11k_mac_op_flush,
9140 .sta_statistics = ath11k_mac_op_sta_statistics,
9141 CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
9144 .suspend = ath11k_wow_op_suspend,
9145 .resume = ath11k_wow_op_resume,
9146 .set_wakeup = ath11k_wow_op_set_wakeup,
9149 #ifdef CONFIG_ATH11K_DEBUGFS
9150 .vif_add_debugfs = ath11k_debugfs_op_vif_add,
9151 .sta_add_debugfs = ath11k_debugfs_sta_op_add,
9154 #if IS_ENABLED(CONFIG_IPV6)
9155 .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
9157 .get_txpower = ath11k_mac_op_get_txpower,
9159 .set_sar_specs = ath11k_mac_op_set_bios_sar_specs,
9160 .remain_on_channel = ath11k_mac_op_remain_on_channel,
9161 .cancel_remain_on_channel = ath11k_mac_op_cancel_remain_on_channel,
9164 static void ath11k_mac_update_ch_list(struct ath11k *ar,
9165 struct ieee80211_supported_band *band,
9166 u32 freq_low, u32 freq_high)
9170 if (!(freq_low && freq_high))
9173 for (i = 0; i < band->n_channels; i++) {
9174 if (band->channels[i].center_freq < freq_low ||
9175 band->channels[i].center_freq > freq_high)
9176 band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
9180 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
9182 struct ath11k_pdev *pdev = ar->pdev;
9183 struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
9185 if (band == WMI_HOST_WLAN_2G_CAP)
9186 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
9188 if (band == WMI_HOST_WLAN_5G_CAP)
9189 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
9191 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
9196 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
9197 u32 supported_bands)
9199 struct ieee80211_supported_band *band;
9200 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
9204 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
9205 ARRAY_SIZE(ath11k_5ghz_channels) +
9206 ARRAY_SIZE(ath11k_6ghz_channels)) !=
9209 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
9210 temp_reg_cap = reg_cap;
9212 if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
9213 channels = kmemdup(ath11k_2ghz_channels,
9214 sizeof(ath11k_2ghz_channels),
9219 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
9220 band->band = NL80211_BAND_2GHZ;
9221 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
9222 band->channels = channels;
9223 band->n_bitrates = ath11k_g_rates_size;
9224 band->bitrates = ath11k_g_rates;
9225 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
9227 if (ar->ab->hw_params.single_pdev_only) {
9228 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
9229 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9231 ath11k_mac_update_ch_list(ar, band,
9232 temp_reg_cap->low_2ghz_chan,
9233 temp_reg_cap->high_2ghz_chan);
9236 if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
9237 if (reg_cap->high_5ghz_chan >= ATH11K_MIN_6G_FREQ) {
9238 channels = kmemdup(ath11k_6ghz_channels,
9239 sizeof(ath11k_6ghz_channels), GFP_KERNEL);
9241 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9245 ar->supports_6ghz = true;
9246 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
9247 band->band = NL80211_BAND_6GHZ;
9248 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
9249 band->channels = channels;
9250 band->n_bitrates = ath11k_a_rates_size;
9251 band->bitrates = ath11k_a_rates;
9252 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
9254 if (ar->ab->hw_params.single_pdev_only) {
9255 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9256 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9259 ath11k_mac_update_ch_list(ar, band,
9260 temp_reg_cap->low_5ghz_chan,
9261 temp_reg_cap->high_5ghz_chan);
9264 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
9265 channels = kmemdup(ath11k_5ghz_channels,
9266 sizeof(ath11k_5ghz_channels),
9269 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9270 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9274 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
9275 band->band = NL80211_BAND_5GHZ;
9276 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
9277 band->channels = channels;
9278 band->n_bitrates = ath11k_a_rates_size;
9279 band->bitrates = ath11k_a_rates;
9280 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
9282 if (ar->ab->hw_params.single_pdev_only) {
9283 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9284 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9287 ath11k_mac_update_ch_list(ar, band,
9288 temp_reg_cap->low_5ghz_chan,
9289 temp_reg_cap->high_5ghz_chan);
9296 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
9298 struct ath11k_base *ab = ar->ab;
9299 struct ieee80211_iface_combination *combinations;
9300 struct ieee80211_iface_limit *limits;
9303 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
9309 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
9311 kfree(combinations);
9316 limits[0].types |= BIT(NL80211_IFTYPE_STATION);
9319 limits[1].types |= BIT(NL80211_IFTYPE_AP);
9321 if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
9322 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
9323 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
9325 combinations[0].limits = limits;
9326 combinations[0].n_limits = n_limits;
9327 combinations[0].max_interfaces = 16;
9328 combinations[0].num_different_channels = 1;
9329 combinations[0].beacon_int_infra_match = true;
9330 combinations[0].beacon_int_min_gcd = 100;
9331 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9332 BIT(NL80211_CHAN_WIDTH_20) |
9333 BIT(NL80211_CHAN_WIDTH_40) |
9334 BIT(NL80211_CHAN_WIDTH_80) |
9335 BIT(NL80211_CHAN_WIDTH_80P80) |
9336 BIT(NL80211_CHAN_WIDTH_160);
9338 ar->hw->wiphy->iface_combinations = combinations;
9339 ar->hw->wiphy->n_iface_combinations = 1;
9344 static const u8 ath11k_if_types_ext_capa[] = {
9345 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9346 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9347 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9350 static const u8 ath11k_if_types_ext_capa_sta[] = {
9351 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9352 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9353 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9354 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
9357 static const u8 ath11k_if_types_ext_capa_ap[] = {
9358 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9359 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9360 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9361 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
9362 [10] = WLAN_EXT_CAPA11_EMA_SUPPORT,
9365 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
9367 .extended_capabilities = ath11k_if_types_ext_capa,
9368 .extended_capabilities_mask = ath11k_if_types_ext_capa,
9369 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
9371 .iftype = NL80211_IFTYPE_STATION,
9372 .extended_capabilities = ath11k_if_types_ext_capa_sta,
9373 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
9374 .extended_capabilities_len =
9375 sizeof(ath11k_if_types_ext_capa_sta),
9377 .iftype = NL80211_IFTYPE_AP,
9378 .extended_capabilities = ath11k_if_types_ext_capa_ap,
9379 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
9380 .extended_capabilities_len =
9381 sizeof(ath11k_if_types_ext_capa_ap),
9385 static void __ath11k_mac_unregister(struct ath11k *ar)
9387 cancel_work_sync(&ar->regd_update_work);
9389 ieee80211_unregister_hw(ar->hw);
9391 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
9392 idr_destroy(&ar->txmgmt_idr);
9394 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9395 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9396 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9398 kfree(ar->hw->wiphy->iface_combinations[0].limits);
9399 kfree(ar->hw->wiphy->iface_combinations);
9401 SET_IEEE80211_DEV(ar->hw, NULL);
9404 void ath11k_mac_unregister(struct ath11k_base *ab)
9407 struct ath11k_pdev *pdev;
9410 for (i = 0; i < ab->num_radios; i++) {
9411 pdev = &ab->pdevs[i];
9416 __ath11k_mac_unregister(ar);
9419 ath11k_peer_rhash_tbl_destroy(ab);
9422 static int __ath11k_mac_register(struct ath11k *ar)
9424 struct ath11k_base *ab = ar->ab;
9425 struct ath11k_pdev_cap *cap = &ar->pdev->cap;
9426 static const u32 cipher_suites[] = {
9427 WLAN_CIPHER_SUITE_TKIP,
9428 WLAN_CIPHER_SUITE_CCMP,
9429 WLAN_CIPHER_SUITE_AES_CMAC,
9430 WLAN_CIPHER_SUITE_BIP_CMAC_256,
9431 WLAN_CIPHER_SUITE_BIP_GMAC_128,
9432 WLAN_CIPHER_SUITE_BIP_GMAC_256,
9433 WLAN_CIPHER_SUITE_GCMP,
9434 WLAN_CIPHER_SUITE_GCMP_256,
9435 WLAN_CIPHER_SUITE_CCMP_256,
9440 ath11k_pdev_caps_update(ar);
9442 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
9444 SET_IEEE80211_DEV(ar->hw, ab->dev);
9446 ret = ath11k_mac_setup_channels_rates(ar,
9447 cap->supported_bands);
9451 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
9452 ath11k_mac_setup_he_cap(ar, cap);
9454 ret = ath11k_mac_setup_iface_combinations(ar);
9456 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
9457 goto err_free_channels;
9460 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
9461 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
9463 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
9465 if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
9466 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
9468 if (ab->hw_params.supports_multi_bssid) {
9469 ieee80211_hw_set(ar->hw, SUPPORTS_MULTI_BSSID);
9470 ieee80211_hw_set(ar->hw, SUPPORTS_ONLY_HE_MULTI_BSSID);
9473 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
9474 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
9475 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
9476 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
9477 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
9478 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
9479 ieee80211_hw_set(ar->hw, AP_LINK_PS);
9480 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
9481 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
9482 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
9483 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
9484 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
9485 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
9486 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
9487 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
9489 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
9490 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
9491 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
9494 if (cap->nss_ratio_enabled)
9495 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
9497 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
9498 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
9499 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
9500 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
9501 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
9502 ieee80211_hw_set(ar->hw, USES_RSS);
9505 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
9506 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
9508 /* TODO: Check if HT capability advertised from firmware is different
9509 * for each band for a dual band capable radio. It will be tricky to
9510 * handle it when the ht capability different for each band.
9512 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
9513 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
9514 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
9516 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
9517 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
9519 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
9521 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
9522 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
9523 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
9525 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
9526 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
9527 NL80211_FEATURE_AP_SCAN;
9529 ar->max_num_stations = TARGET_NUM_STATIONS(ab);
9530 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
9532 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
9534 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
9535 ar->hw->wiphy->features |=
9536 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
9539 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
9540 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
9541 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
9542 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
9543 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
9544 ar->hw->wiphy->max_sched_scan_plan_interval =
9545 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
9546 ar->hw->wiphy->max_sched_scan_plan_iterations =
9547 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
9548 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
9551 ret = ath11k_wow_init(ar);
9553 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
9554 goto err_free_if_combs;
9557 if (test_bit(WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI,
9558 ar->ab->wmi_ab.svc_map))
9559 wiphy_ext_feature_set(ar->hw->wiphy,
9560 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);
9562 ar->hw->queues = ATH11K_HW_MAX_QUEUES;
9563 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
9564 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
9565 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
9567 ar->hw->vif_data_size = sizeof(struct ath11k_vif);
9568 ar->hw->sta_data_size = sizeof(struct ath11k_sta);
9570 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
9571 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
9572 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
9573 ar->ab->wmi_ab.svc_map)) {
9574 wiphy_ext_feature_set(ar->hw->wiphy,
9575 NL80211_EXT_FEATURE_BSS_COLOR);
9576 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
9579 ar->hw->wiphy->cipher_suites = cipher_suites;
9580 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
9582 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
9583 ar->hw->wiphy->num_iftype_ext_capab =
9584 ARRAY_SIZE(ath11k_iftypes_ext_capa);
9586 if (ar->supports_6ghz) {
9587 wiphy_ext_feature_set(ar->hw->wiphy,
9588 NL80211_EXT_FEATURE_FILS_DISCOVERY);
9589 wiphy_ext_feature_set(ar->hw->wiphy,
9590 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
9593 wiphy_ext_feature_set(ar->hw->wiphy,
9594 NL80211_EXT_FEATURE_SET_SCAN_DWELL);
9596 if (test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map))
9597 wiphy_ext_feature_set(ar->hw->wiphy,
9598 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
9600 ar->hw->wiphy->mbssid_max_interfaces = TARGET_NUM_VDEVS(ab);
9601 ar->hw->wiphy->ema_max_profile_periodicity = TARGET_EMA_MAX_PROFILE_PERIOD;
9603 ath11k_reg_init(ar);
9605 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
9606 ar->hw->netdev_features = NETIF_F_HW_CSUM;
9607 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
9608 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
9611 if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
9612 ab->hw_params.bios_sar_capa)
9613 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
9615 ret = ieee80211_register_hw(ar->hw);
9617 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
9618 goto err_free_if_combs;
9621 if (!ab->hw_params.supports_monitor)
9622 /* There's a race between calling ieee80211_register_hw()
9623 * and here where the monitor mode is enabled for a little
9624 * while. But that time is so short and in practise it make
9625 * a difference in real life.
9627 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
9629 /* Apply the regd received during initialization */
9630 ret = ath11k_regd_update(ar);
9632 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
9633 goto err_unregister_hw;
9636 if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
9637 struct wmi_set_current_country_params set_current_param = {};
9639 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
9640 memcpy(&ar->alpha2, ab->new_alpha2, 2);
9641 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
9644 "failed set cc code for mac register: %d\n", ret);
9647 ret = ath11k_debugfs_register(ar);
9649 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
9650 goto err_unregister_hw;
9656 ieee80211_unregister_hw(ar->hw);
9659 kfree(ar->hw->wiphy->iface_combinations[0].limits);
9660 kfree(ar->hw->wiphy->iface_combinations);
9663 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9664 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9665 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9668 SET_IEEE80211_DEV(ar->hw, NULL);
9672 int ath11k_mac_register(struct ath11k_base *ab)
9675 struct ath11k_pdev *pdev;
9678 u8 mac_addr[ETH_ALEN] = {0};
9680 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9683 /* Initialize channel counters frequency value in hertz */
9684 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
9685 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
9687 ret = ath11k_peer_rhash_tbl_init(ab);
9691 device_get_mac_address(ab->dev, mac_addr);
9693 for (i = 0; i < ab->num_radios; i++) {
9694 pdev = &ab->pdevs[i];
9696 if (ab->pdevs_macaddr_valid) {
9697 ether_addr_copy(ar->mac_addr, pdev->mac_addr);
9699 if (is_zero_ether_addr(mac_addr))
9700 ether_addr_copy(ar->mac_addr, ab->mac_addr);
9702 ether_addr_copy(ar->mac_addr, mac_addr);
9703 ar->mac_addr[4] += i;
9706 idr_init(&ar->txmgmt_idr);
9707 spin_lock_init(&ar->txmgmt_idr_lock);
9709 ret = __ath11k_mac_register(ar);
9713 init_waitqueue_head(&ar->txmgmt_empty_waitq);
9719 for (i = i - 1; i >= 0; i--) {
9720 pdev = &ab->pdevs[i];
9722 __ath11k_mac_unregister(ar);
9725 ath11k_peer_rhash_tbl_destroy(ab);
9730 int ath11k_mac_allocate(struct ath11k_base *ab)
9732 struct ieee80211_hw *hw;
9734 struct ath11k_pdev *pdev;
9738 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9741 for (i = 0; i < ab->num_radios; i++) {
9742 pdev = &ab->pdevs[i];
9743 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9745 ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9755 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9757 ar->wmi = &ab->wmi_ab.wmi[i];
9758 /* FIXME wmi[0] is already initialized during attach,
9759 * Should we do this again?
9761 ath11k_wmi_pdev_attach(ab, i);
9763 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9764 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9765 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9766 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9769 spin_lock_init(&ar->data_lock);
9770 INIT_LIST_HEAD(&ar->arvifs);
9771 INIT_LIST_HEAD(&ar->ppdu_stats_info);
9772 mutex_init(&ar->conf_mutex);
9773 init_completion(&ar->vdev_setup_done);
9774 init_completion(&ar->vdev_delete_done);
9775 init_completion(&ar->peer_assoc_done);
9776 init_completion(&ar->peer_delete_done);
9777 init_completion(&ar->install_key_done);
9778 init_completion(&ar->bss_survey_done);
9779 init_completion(&ar->scan.started);
9780 init_completion(&ar->scan.completed);
9781 init_completion(&ar->scan.on_channel);
9782 init_completion(&ar->thermal.wmi_sync);
9784 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9785 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9787 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9788 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9790 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9792 ar->monitor_vdev_id = -1;
9793 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9794 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9795 init_completion(&ar->completed_11d_scan);
9797 ath11k_fw_stats_init(ar);
9803 ath11k_mac_destroy(ab);
9808 void ath11k_mac_destroy(struct ath11k_base *ab)
9811 struct ath11k_pdev *pdev;
9814 for (i = 0; i < ab->num_radios; i++) {
9815 pdev = &ab->pdevs[i];
9820 ath11k_fw_stats_free(&ar->fw_stats);
9821 ieee80211_free_hw(ar->hw);
9826 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9827 enum wmi_sta_keepalive_method method,
9830 struct ath11k *ar = arvif->ar;
9831 struct wmi_sta_keepalive_arg arg = {};
9834 lockdep_assert_held(&ar->conf_mutex);
9836 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9839 if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9842 arg.vdev_id = arvif->vdev_id;
9844 arg.method = method;
9845 arg.interval = interval;
9847 ret = ath11k_wmi_sta_keepalive(ar, &arg);
9849 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9850 arvif->vdev_id, ret);