1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* Copyright (C) 2023 MediaTek Inc. */ 3 4 #include <linux/etherdevice.h> 5 #include <linux/platform_device.h> 6 #include <linux/pci.h> 7 #include <linux/module.h> 8 #include <linux/ctype.h> 9 #include <net/ipv6.h> 10 #include "mt7925.h" 11 #include "regd.h" 12 #include "mcu.h" 13 #include "mac.h" 14 #include "nan.h" 15 16 static void 17 mt7925_init_he_caps(struct mt792x_phy *phy, enum nl80211_band band, 18 struct ieee80211_sband_iftype_data *data, 19 enum nl80211_iftype iftype) 20 { 21 struct ieee80211_sta_he_cap *he_cap = &data->he_cap; 22 struct ieee80211_he_cap_elem *he_cap_elem = &he_cap->he_cap_elem; 23 struct ieee80211_he_mcs_nss_supp *he_mcs = &he_cap->he_mcs_nss_supp; 24 int i, nss = hweight8(phy->mt76->antenna_mask); 25 u16 mcs_map = 0; 26 27 for (i = 0; i < 8; i++) { 28 if (i < nss) 29 mcs_map |= (IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2)); 30 else 31 mcs_map |= (IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2)); 32 } 33 34 he_cap->has_he = true; 35 36 he_cap_elem->mac_cap_info[0] = IEEE80211_HE_MAC_CAP0_HTC_HE; 37 he_cap_elem->mac_cap_info[3] = IEEE80211_HE_MAC_CAP3_OMI_CONTROL | 38 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_EXT_3; 39 he_cap_elem->mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMSDU_IN_AMPDU; 40 41 if (band == NL80211_BAND_2GHZ) 42 he_cap_elem->phy_cap_info[0] = 43 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G; 44 else 45 he_cap_elem->phy_cap_info[0] = 46 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G | 47 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G; 48 49 he_cap_elem->phy_cap_info[1] = 50 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD; 51 he_cap_elem->phy_cap_info[2] = 52 IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US | 53 IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ | 54 IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ | 55 IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 56 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 57 58 switch (iftype) { 59 case NL80211_IFTYPE_AP: 60 he_cap_elem->mac_cap_info[2] |= 61 IEEE80211_HE_MAC_CAP2_BSR; 62 he_cap_elem->mac_cap_info[4] |= 63 IEEE80211_HE_MAC_CAP4_BQR; 64 he_cap_elem->mac_cap_info[5] |= 65 IEEE80211_HE_MAC_CAP5_OM_CTRL_UL_MU_DATA_DIS_RX; 66 he_cap_elem->phy_cap_info[3] |= 67 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_QPSK | 68 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_QPSK; 69 he_cap_elem->phy_cap_info[6] |= 70 IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE | 71 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT; 72 he_cap_elem->phy_cap_info[9] |= 73 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 74 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 75 break; 76 case NL80211_IFTYPE_STATION: 77 he_cap_elem->mac_cap_info[1] |= 78 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US; 79 80 if (band == NL80211_BAND_2GHZ) 81 he_cap_elem->phy_cap_info[0] |= 82 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G; 83 else 84 he_cap_elem->phy_cap_info[0] |= 85 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G; 86 87 he_cap_elem->phy_cap_info[1] |= 88 IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A | 89 IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US; 90 he_cap_elem->phy_cap_info[3] |= 91 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_QPSK | 92 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_QPSK; 93 he_cap_elem->phy_cap_info[4] |= 94 IEEE80211_HE_PHY_CAP4_SU_BEAMFORMEE | 95 IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_4 | 96 IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_4; 97 he_cap_elem->phy_cap_info[5] |= 98 IEEE80211_HE_PHY_CAP5_NG16_SU_FEEDBACK | 99 IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 100 he_cap_elem->phy_cap_info[6] |= 101 IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_42_SU | 102 IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 103 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 104 IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE | 105 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT; 106 he_cap_elem->phy_cap_info[7] |= 107 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 108 IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI; 109 he_cap_elem->phy_cap_info[8] |= 110 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 111 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 112 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU | 113 IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_484; 114 he_cap_elem->phy_cap_info[9] |= 115 IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 116 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 117 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 118 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 119 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 120 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 121 break; 122 default: 123 break; 124 } 125 126 he_mcs->rx_mcs_80 = cpu_to_le16(mcs_map); 127 he_mcs->tx_mcs_80 = cpu_to_le16(mcs_map); 128 he_mcs->rx_mcs_160 = cpu_to_le16(mcs_map); 129 he_mcs->tx_mcs_160 = cpu_to_le16(mcs_map); 130 131 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 132 133 if (he_cap_elem->phy_cap_info[6] & 134 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) { 135 mt76_connac_gen_ppe_thresh(he_cap->ppe_thres, nss, band); 136 } else { 137 he_cap_elem->phy_cap_info[9] |= 138 u8_encode_bits(IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_16US, 139 IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_MASK); 140 } 141 142 if (band == NL80211_BAND_6GHZ) { 143 struct ieee80211_supported_band *sband = 144 &phy->mt76->sband_5g.sband; 145 struct ieee80211_sta_ht_cap *ht_cap = &sband->ht_cap; 146 147 u16 cap = IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS | 148 IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 149 150 cap |= u16_encode_bits(ht_cap->ampdu_density, 151 IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START) | 152 u16_encode_bits(IEEE80211_VHT_MAX_AMPDU_1024K, 153 IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP) | 154 u16_encode_bits(IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454, 155 IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN); 156 157 data->he_6ghz_capa.capa = cpu_to_le16(cap); 158 } 159 } 160 161 static void 162 mt7925_init_eht_caps(struct mt792x_phy *phy, enum nl80211_band band, 163 struct ieee80211_sband_iftype_data *data) 164 { 165 struct ieee80211_sta_eht_cap *eht_cap = &data->eht_cap; 166 struct ieee80211_eht_cap_elem_fixed *eht_cap_elem = &eht_cap->eht_cap_elem; 167 struct ieee80211_eht_mcs_nss_supp *eht_nss = &eht_cap->eht_mcs_nss_supp; 168 enum nl80211_chan_width width = phy->mt76->chandef.width; 169 int nss = hweight8(phy->mt76->antenna_mask); 170 int sts = hweight16(phy->mt76->chainmask); 171 u8 val; 172 173 if (!phy->dev->has_eht) 174 return; 175 176 eht_cap->has_eht = true; 177 178 eht_cap_elem->mac_cap_info[0] = 179 IEEE80211_EHT_MAC_CAP0_EPCS_PRIO_ACCESS | 180 IEEE80211_EHT_MAC_CAP0_OM_CONTROL; 181 182 eht_cap_elem->phy_cap_info[0] = 183 IEEE80211_EHT_PHY_CAP0_NDP_4_EHT_LFT_32_GI | 184 IEEE80211_EHT_PHY_CAP0_SU_BEAMFORMER | 185 IEEE80211_EHT_PHY_CAP0_SU_BEAMFORMEE; 186 187 if (band == NL80211_BAND_6GHZ && is_320mhz_supported(&phy->dev->mt76)) 188 eht_cap_elem->phy_cap_info[0] |= 189 IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ; 190 191 val = (sts > 3) ? sts - 1 : 3; 192 193 eht_cap_elem->phy_cap_info[0] |= 194 u8_encode_bits(u8_get_bits(val, BIT(0)), 195 IEEE80211_EHT_PHY_CAP0_BEAMFORMEE_SS_80MHZ_MASK); 196 197 eht_cap_elem->phy_cap_info[1] = 198 u8_encode_bits(u8_get_bits(val, GENMASK(2, 1)), 199 IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_80MHZ_MASK) | 200 u8_encode_bits(val, 201 IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_160MHZ_MASK); 202 203 if (band == NL80211_BAND_6GHZ && is_320mhz_supported(&phy->dev->mt76)) 204 eht_cap_elem->phy_cap_info[1] |= 205 u8_encode_bits(val, 206 IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_320MHZ_MASK); 207 208 eht_cap_elem->phy_cap_info[2] = 209 u8_encode_bits(sts - 1, IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_80MHZ_MASK) | 210 u8_encode_bits(sts - 1, IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_160MHZ_MASK); 211 212 if (band == NL80211_BAND_6GHZ && is_320mhz_supported(&phy->dev->mt76)) 213 eht_cap_elem->phy_cap_info[2] |= 214 u8_encode_bits(sts - 1, 215 IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_320MHZ_MASK); 216 217 eht_cap_elem->phy_cap_info[3] = 218 IEEE80211_EHT_PHY_CAP3_NG_16_SU_FEEDBACK | 219 IEEE80211_EHT_PHY_CAP3_NG_16_MU_FEEDBACK | 220 IEEE80211_EHT_PHY_CAP3_CODEBOOK_4_2_SU_FDBK | 221 IEEE80211_EHT_PHY_CAP3_CODEBOOK_7_5_MU_FDBK | 222 IEEE80211_EHT_PHY_CAP3_TRIG_SU_BF_FDBK | 223 IEEE80211_EHT_PHY_CAP3_TRIG_MU_BF_PART_BW_FDBK | 224 IEEE80211_EHT_PHY_CAP3_TRIG_CQI_FDBK; 225 226 eht_cap_elem->phy_cap_info[4] = 227 u8_encode_bits(min_t(int, sts - 1, 2), 228 IEEE80211_EHT_PHY_CAP4_MAX_NC_MASK); 229 230 eht_cap_elem->phy_cap_info[5] = 231 IEEE80211_EHT_PHY_CAP5_NON_TRIG_CQI_FEEDBACK | 232 u8_encode_bits(IEEE80211_EHT_PHY_CAP5_COMMON_NOMINAL_PKT_PAD_16US, 233 IEEE80211_EHT_PHY_CAP5_COMMON_NOMINAL_PKT_PAD_MASK) | 234 u8_encode_bits(u8_get_bits(0x11, GENMASK(1, 0)), 235 IEEE80211_EHT_PHY_CAP5_MAX_NUM_SUPP_EHT_LTF_MASK); 236 237 val = width == NL80211_CHAN_WIDTH_320 ? 0xf : 238 width == NL80211_CHAN_WIDTH_160 ? 0x7 : 239 width == NL80211_CHAN_WIDTH_80 ? 0x3 : 0x1; 240 eht_cap_elem->phy_cap_info[6] = 241 u8_encode_bits(u8_get_bits(0x11, GENMASK(4, 2)), 242 IEEE80211_EHT_PHY_CAP6_MAX_NUM_SUPP_EHT_LTF_MASK) | 243 u8_encode_bits(val, IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_MASK); 244 245 eht_cap_elem->phy_cap_info[7] = 246 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ | 247 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ | 248 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ | 249 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ; 250 251 val = u8_encode_bits(nss, IEEE80211_EHT_MCS_NSS_RX) | 252 u8_encode_bits(nss, IEEE80211_EHT_MCS_NSS_TX); 253 254 eht_nss->bw._80.rx_tx_mcs9_max_nss = val; 255 eht_nss->bw._80.rx_tx_mcs11_max_nss = val; 256 eht_nss->bw._80.rx_tx_mcs13_max_nss = val; 257 eht_nss->bw._160.rx_tx_mcs9_max_nss = val; 258 eht_nss->bw._160.rx_tx_mcs11_max_nss = val; 259 eht_nss->bw._160.rx_tx_mcs13_max_nss = val; 260 if (band == NL80211_BAND_6GHZ && is_320mhz_supported(&phy->dev->mt76)) { 261 eht_nss->bw._320.rx_tx_mcs9_max_nss = val; 262 eht_nss->bw._320.rx_tx_mcs11_max_nss = val; 263 eht_nss->bw._320.rx_tx_mcs13_max_nss = val; 264 } 265 } 266 267 int mt7925_init_mlo_caps(struct mt792x_phy *phy) 268 { 269 struct wiphy *wiphy = phy->mt76->hw->wiphy; 270 static const u8 ext_capa_sta[] = { 271 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 272 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 273 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 274 }; 275 static struct wiphy_iftype_ext_capab ext_capab[] = { 276 { 277 .iftype = NL80211_IFTYPE_STATION, 278 .extended_capabilities = ext_capa_sta, 279 .extended_capabilities_mask = ext_capa_sta, 280 .extended_capabilities_len = sizeof(ext_capa_sta), 281 }, 282 }; 283 284 if (!(phy->chip_cap & MT792x_CHIP_CAP_MLO_EN)) 285 return 0; 286 287 ext_capab[0].eml_capabilities = phy->eml_cap; 288 ext_capab[0].mld_capa_and_ops = 289 u16_encode_bits(0, IEEE80211_MLD_CAP_OP_MAX_SIMUL_LINKS); 290 291 wiphy->flags |= WIPHY_FLAG_SUPPORTS_MLO; 292 wiphy->iftype_ext_capab = ext_capab; 293 wiphy->num_iftype_ext_capab = ARRAY_SIZE(ext_capab); 294 295 return 0; 296 } 297 298 static void 299 __mt7925_set_stream_he_eht_caps(struct mt792x_phy *phy, 300 struct ieee80211_supported_band *sband, 301 enum nl80211_band band) 302 { 303 struct ieee80211_sband_iftype_data *data = phy->iftype[band]; 304 int i, n = 0; 305 306 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 307 switch (i) { 308 case NL80211_IFTYPE_STATION: 309 case NL80211_IFTYPE_AP: 310 break; 311 default: 312 continue; 313 } 314 315 data[n].types_mask = BIT(i); 316 mt7925_init_he_caps(phy, band, &data[n], i); 317 mt7925_init_eht_caps(phy, band, &data[n]); 318 319 n++; 320 } 321 322 _ieee80211_set_sband_iftype_data(sband, data, n); 323 } 324 325 void mt7925_set_stream_he_eht_caps(struct mt792x_phy *phy) 326 { 327 if (phy->mt76->cap.has_2ghz) 328 __mt7925_set_stream_he_eht_caps(phy, &phy->mt76->sband_2g.sband, 329 NL80211_BAND_2GHZ); 330 331 if (phy->mt76->cap.has_5ghz) 332 __mt7925_set_stream_he_eht_caps(phy, &phy->mt76->sband_5g.sband, 333 NL80211_BAND_5GHZ); 334 335 if (phy->mt76->cap.has_6ghz) 336 __mt7925_set_stream_he_eht_caps(phy, &phy->mt76->sband_6g.sband, 337 NL80211_BAND_6GHZ); 338 } 339 340 int __mt7925_start(struct mt792x_phy *phy) 341 { 342 struct mt76_phy *mphy = phy->mt76; 343 int err; 344 345 err = mt7925_mcu_set_channel_domain(mphy); 346 if (err) 347 return err; 348 349 err = mt7925_mcu_set_rts_thresh(phy, 0x92b); 350 if (err) 351 return err; 352 353 mt792x_mac_reset_counters(phy); 354 set_bit(MT76_STATE_RUNNING, &mphy->state); 355 356 ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work, 357 MT792x_WATCHDOG_TIME); 358 359 if (phy->chip_cap & MT792x_CHIP_CAP_WF_RF_PIN_CTRL_EVT_EN) 360 wiphy_rfkill_start_polling(mphy->hw->wiphy); 361 362 return 0; 363 } 364 EXPORT_SYMBOL_GPL(__mt7925_start); 365 366 static int mt7925_start(struct ieee80211_hw *hw) 367 { 368 struct mt792x_phy *phy = mt792x_hw_phy(hw); 369 int err; 370 371 mt792x_mutex_acquire(phy->dev); 372 err = __mt7925_start(phy); 373 mt792x_mutex_release(phy->dev); 374 375 return err; 376 } 377 378 static int mt7925_mac_link_bss_add(struct mt792x_dev *dev, 379 struct ieee80211_bss_conf *link_conf, 380 struct mt792x_link_sta *mlink) 381 { 382 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf); 383 struct ieee80211_vif *vif = link_conf->vif; 384 struct mt792x_vif *mvif = mconf->vif; 385 struct mt76_txq *mtxq; 386 int idx, ret = 0; 387 388 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) { 389 mconf->mt76.idx = MT792x_MAX_INTERFACES; 390 } else { 391 mconf->mt76.idx = __ffs64(~dev->mt76.vif_mask); 392 393 if (mconf->mt76.idx >= MT792x_MAX_INTERFACES) { 394 ret = -ENOSPC; 395 goto out; 396 } 397 } 398 399 mconf->mt76.omac_idx = ieee80211_vif_is_mld(vif) ? 400 0 : mconf->mt76.idx; 401 mconf->mt76.band_idx = 0xff; 402 403 if (is_mt7927(&dev->mt76)) { 404 struct ieee80211_channel *chan; 405 406 if (link_conf->chanreq.oper.chan) 407 chan = link_conf->chanreq.oper.chan; 408 else 409 chan = mvif->phy->mt76->chandef.chan; 410 411 mconf->mt76.band_idx = mt7927_band_idx(chan->band); 412 } 413 414 mconf->mt76.wmm_idx = ieee80211_vif_is_mld(vif) ? 415 0 : mconf->mt76.idx % MT76_CONNAC_MAX_WMM_SETS; 416 mconf->mt76.link_idx = hweight16(mvif->valid_links); 417 418 if (mvif->phy->mt76->chandef.chan && 419 mvif->phy->mt76->chandef.chan->band != NL80211_BAND_2GHZ) 420 mconf->mt76.basic_rates_idx = MT792x_BASIC_RATES_TBL + 4; 421 else 422 mconf->mt76.basic_rates_idx = MT792x_BASIC_RATES_TBL; 423 424 dev->mt76.vif_mask |= BIT_ULL(mconf->mt76.idx); 425 mvif->phy->omac_mask |= BIT_ULL(mconf->mt76.omac_idx); 426 427 idx = MT792x_WTBL_RESERVED - mconf->mt76.idx; 428 429 mlink->wcid.idx = idx; 430 mlink->wcid.tx_info |= MT_WCID_TX_INFO_SET; 431 mt76_wcid_init(&mlink->wcid, 0); 432 433 mt7925_mac_wtbl_update(dev, idx, 434 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 435 436 ewma_rssi_init(&mconf->rssi); 437 438 rcu_assign_pointer(dev->mt76.wcid[idx], &mlink->wcid); 439 440 ret = mt76_connac_mcu_uni_add_dev(&dev->mphy, link_conf, &mconf->mt76, 441 &mlink->wcid, true); 442 if (ret) 443 goto out; 444 445 if (vif->txq) { 446 mtxq = (struct mt76_txq *)vif->txq->drv_priv; 447 mtxq->wcid = idx; 448 } 449 450 out: 451 return ret; 452 } 453 454 static int 455 mt7925_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 456 { 457 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 458 struct mt792x_dev *dev = mt792x_hw_dev(hw); 459 struct mt792x_phy *phy = mt792x_hw_phy(hw); 460 int ret = 0; 461 462 mt792x_mutex_acquire(dev); 463 464 mvif->phy = phy; 465 mvif->bss_conf.vif = mvif; 466 mvif->sta.vif = mvif; 467 mvif->deflink_id = IEEE80211_LINK_UNSPECIFIED; 468 mvif->mlo_pm_state = MT792x_MLO_LINK_DISASSOC; 469 470 ret = mt7925_mac_link_bss_add(dev, &vif->bss_conf, &mvif->sta.deflink); 471 if (ret < 0) 472 goto out; 473 474 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER; 475 if (phy->chip_cap & MT792x_CHIP_CAP_RSSI_NOTIFY_EVT_EN) 476 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_CQM_RSSI; 477 478 INIT_WORK(&mvif->csa_work, mt7925_csa_work); 479 timer_setup(&mvif->csa_timer, mt792x_csa_timer, 0); 480 481 if (vif->type == NL80211_IFTYPE_NAN) 482 dev->nan_vif = vif; 483 out: 484 mt792x_mutex_release(dev); 485 486 return ret; 487 } 488 489 static void 490 mt7925_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 491 { 492 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 493 struct mt792x_dev *dev = mt792x_hw_dev(hw); 494 struct mt792x_bss_conf *mconf; 495 496 mt792x_mutex_acquire(dev); 497 498 if (dev->nan_vif == vif) 499 dev->nan_vif = NULL; 500 501 mconf = mt792x_link_conf_to_mconf(&vif->bss_conf); 502 mt792x_mac_link_bss_remove(dev, mconf, &mvif->sta.deflink); 503 504 mt792x_mutex_release(dev); 505 } 506 507 static void mt7925_roc_iter(void *priv, u8 *mac, 508 struct ieee80211_vif *vif) 509 { 510 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 511 struct mt792x_phy *phy = priv; 512 513 mt7925_mcu_abort_roc(phy, &mvif->bss_conf, phy->roc_token_id); 514 } 515 516 void mt7925_roc_abort_sync(struct mt792x_dev *dev) 517 { 518 struct mt792x_phy *phy = &dev->phy; 519 520 if (!test_and_clear_bit(MT76_STATE_ROC, &phy->mt76->state)) 521 return; 522 523 timer_delete_sync(&phy->roc_timer); 524 525 cancel_work(&phy->roc_work); 526 527 ieee80211_iterate_interfaces(mt76_hw(dev), 528 IEEE80211_IFACE_ITER_RESUME_ALL, 529 mt7925_roc_iter, (void *)phy); 530 } 531 EXPORT_SYMBOL_GPL(mt7925_roc_abort_sync); 532 533 void mt7925_roc_work(struct work_struct *work) 534 { 535 struct mt792x_phy *phy; 536 537 phy = (struct mt792x_phy *)container_of(work, struct mt792x_phy, 538 roc_work); 539 540 if (!test_and_clear_bit(MT76_STATE_ROC, &phy->mt76->state)) 541 return; 542 543 mt792x_mutex_acquire(phy->dev); 544 ieee80211_iterate_active_interfaces(phy->mt76->hw, 545 IEEE80211_IFACE_ITER_RESUME_ALL, 546 mt7925_roc_iter, phy); 547 mt792x_mutex_release(phy->dev); 548 ieee80211_remain_on_channel_expired(phy->mt76->hw); 549 } 550 551 static int mt7925_abort_roc(struct mt792x_phy *phy, 552 struct mt792x_bss_conf *mconf) 553 { 554 int err = 0; 555 556 timer_delete_sync(&phy->roc_timer); 557 cancel_work_sync(&phy->roc_work); 558 559 mt792x_mutex_acquire(phy->dev); 560 if (test_and_clear_bit(MT76_STATE_ROC, &phy->mt76->state)) 561 err = mt7925_mcu_abort_roc(phy, mconf, phy->roc_token_id); 562 mt792x_mutex_release(phy->dev); 563 564 return err; 565 } 566 567 static int mt7925_set_roc(struct mt792x_phy *phy, 568 struct mt792x_bss_conf *mconf, 569 struct ieee80211_channel *chan, 570 int duration, 571 enum mt7925_roc_req type) 572 { 573 int err; 574 575 if (test_and_set_bit(MT76_STATE_ROC, &phy->mt76->state)) 576 return -EBUSY; 577 578 phy->roc_grant = false; 579 580 err = mt7925_mcu_set_roc(phy, mconf, chan, duration, type, 581 ++phy->roc_token_id); 582 if (err < 0) { 583 clear_bit(MT76_STATE_ROC, &phy->mt76->state); 584 goto out; 585 } 586 587 if (!wait_event_timeout(phy->roc_wait, phy->roc_grant, 4 * HZ)) { 588 mt7925_mcu_abort_roc(phy, mconf, phy->roc_token_id); 589 clear_bit(MT76_STATE_ROC, &phy->mt76->state); 590 err = -ETIMEDOUT; 591 } 592 593 out: 594 return err; 595 } 596 597 static int mt7925_set_mlo_roc(struct mt792x_phy *phy, 598 struct mt792x_bss_conf *mconf, 599 u16 sel_links) 600 { 601 int err; 602 603 if (WARN_ON_ONCE(test_and_set_bit(MT76_STATE_ROC, &phy->mt76->state))) 604 return -EBUSY; 605 606 phy->roc_grant = false; 607 608 err = mt7925_mcu_set_mlo_roc(phy, mconf, sel_links, 5, ++phy->roc_token_id); 609 if (err < 0) { 610 clear_bit(MT76_STATE_ROC, &phy->mt76->state); 611 goto out; 612 } 613 614 if (!wait_event_timeout(phy->roc_wait, phy->roc_grant, 4 * HZ)) { 615 mt7925_mcu_abort_roc(phy, mconf, phy->roc_token_id); 616 clear_bit(MT76_STATE_ROC, &phy->mt76->state); 617 err = -ETIMEDOUT; 618 } 619 620 out: 621 return err; 622 } 623 624 static int mt7925_remain_on_channel(struct ieee80211_hw *hw, 625 struct ieee80211_vif *vif, 626 struct ieee80211_channel *chan, 627 int duration, 628 enum ieee80211_roc_type type) 629 { 630 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 631 struct mt792x_phy *phy = mt792x_hw_phy(hw); 632 int err; 633 634 mt792x_mutex_acquire(phy->dev); 635 err = mt7925_set_roc(phy, &mvif->bss_conf, 636 chan, duration, MT7925_ROC_REQ_ROC); 637 mt792x_mutex_release(phy->dev); 638 639 return err; 640 } 641 642 static int mt7925_cancel_remain_on_channel(struct ieee80211_hw *hw, 643 struct ieee80211_vif *vif) 644 { 645 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 646 struct mt792x_phy *phy = mt792x_hw_phy(hw); 647 648 return mt7925_abort_roc(phy, &mvif->bss_conf); 649 } 650 651 static int mt7925_set_link_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 652 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 653 struct ieee80211_key_conf *key, int link_id, 654 struct mt792x_link_sta *mlink) 655 { 656 struct mt792x_dev *dev = mt792x_hw_dev(hw); 657 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 658 struct mt792x_sta *msta = sta ? (struct mt792x_sta *)sta->drv_priv : 659 &mvif->sta; 660 struct ieee80211_bss_conf *link_conf; 661 struct ieee80211_link_sta *link_sta; 662 int idx = key->keyidx, err = 0; 663 struct mt792x_bss_conf *mconf; 664 struct mt76_wcid *wcid; 665 u8 *wcid_keyidx; 666 667 link_conf = mt792x_vif_to_bss_conf(vif, link_id); 668 link_sta = sta ? mt792x_sta_to_link_sta(vif, sta, link_id) : NULL; 669 mconf = mt792x_vif_to_link(mvif, link_id); 670 wcid = &mlink->wcid; 671 wcid_keyidx = &wcid->hw_key_idx; 672 673 /* fall back to sw encryption for unsupported ciphers */ 674 switch (key->cipher) { 675 case WLAN_CIPHER_SUITE_AES_CMAC: 676 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE; 677 wcid_keyidx = &wcid->hw_key_idx2; 678 break; 679 case WLAN_CIPHER_SUITE_WEP40: 680 case WLAN_CIPHER_SUITE_WEP104: 681 if (!mvif->wep_sta) 682 return -EOPNOTSUPP; 683 break; 684 case WLAN_CIPHER_SUITE_TKIP: 685 case WLAN_CIPHER_SUITE_CCMP: 686 case WLAN_CIPHER_SUITE_CCMP_256: 687 case WLAN_CIPHER_SUITE_GCMP: 688 case WLAN_CIPHER_SUITE_GCMP_256: 689 case WLAN_CIPHER_SUITE_SMS4: 690 break; 691 default: 692 return -EOPNOTSUPP; 693 } 694 695 if (cmd == SET_KEY && !mconf->mt76.cipher) { 696 struct mt792x_phy *phy = mt792x_hw_phy(hw); 697 698 mconf->mt76.cipher = mt7925_mcu_get_cipher(key->cipher); 699 mt7925_mcu_add_bss_info(phy, mconf->mt76.ctx, link_conf, 700 link_sta, true); 701 } 702 703 if (cmd == SET_KEY) 704 *wcid_keyidx = idx; 705 else if (idx == *wcid_keyidx) 706 *wcid_keyidx = -1; 707 else 708 goto out; 709 710 mt76_wcid_key_setup(&dev->mt76, wcid, 711 cmd == SET_KEY ? key : NULL); 712 713 err = mt7925_mcu_add_key(&dev->mt76, vif, &mlink->bip, 714 key, MCU_UNI_CMD(STA_REC_UPDATE), 715 &mlink->wcid, cmd, msta); 716 717 if (err) 718 goto out; 719 720 if (key->cipher == WLAN_CIPHER_SUITE_WEP104 || 721 key->cipher == WLAN_CIPHER_SUITE_WEP40) 722 err = mt7925_mcu_add_key(&dev->mt76, vif, &mvif->wep_sta->deflink.bip, 723 key, MCU_WMWA_UNI_CMD(STA_REC_UPDATE), 724 &mvif->wep_sta->deflink.wcid, cmd, msta); 725 out: 726 return err; 727 } 728 729 static int mt7925_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 730 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 731 struct ieee80211_key_conf *key) 732 { 733 struct mt792x_dev *dev = mt792x_hw_dev(hw); 734 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 735 struct mt792x_sta *msta = sta ? (struct mt792x_sta *)sta->drv_priv : 736 &mvif->sta; 737 struct mt792x_link_sta *mlink; 738 int err; 739 740 /* The hardware does not support per-STA RX GTK, fallback 741 * to software mode for these. 742 */ 743 if ((vif->type == NL80211_IFTYPE_ADHOC || 744 vif->type == NL80211_IFTYPE_MESH_POINT) && 745 (key->cipher == WLAN_CIPHER_SUITE_TKIP || 746 key->cipher == WLAN_CIPHER_SUITE_CCMP) && 747 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 748 return -EOPNOTSUPP; 749 750 mt792x_mutex_acquire(dev); 751 752 if (ieee80211_vif_is_mld(vif)) { 753 unsigned int link_id; 754 unsigned long add; 755 756 add = key->link_id != -1 ? BIT(key->link_id) : msta->valid_links; 757 758 for_each_set_bit(link_id, &add, IEEE80211_MLD_MAX_NUM_LINKS) { 759 mlink = mt792x_sta_to_link(msta, link_id); 760 err = mt7925_set_link_key(hw, cmd, vif, sta, key, link_id, 761 mlink); 762 if (err < 0) 763 break; 764 } 765 } else { 766 mlink = mt792x_sta_to_link(msta, vif->bss_conf.link_id); 767 err = mt7925_set_link_key(hw, cmd, vif, sta, key, 768 vif->bss_conf.link_id, mlink); 769 } 770 771 mt792x_mutex_release(dev); 772 773 return err; 774 } 775 776 static void 777 mt7925_pm_interface_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 778 { 779 struct mt792x_dev *dev = priv; 780 struct ieee80211_hw *hw = mt76_hw(dev); 781 bool pm_enable = dev->pm.enable; 782 int err; 783 784 err = mt7925_mcu_set_beacon_filter(dev, vif, pm_enable); 785 if (err < 0) 786 return; 787 788 if (pm_enable) { 789 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER; 790 ieee80211_hw_set(hw, CONNECTION_MONITOR); 791 } else { 792 vif->driver_flags &= ~IEEE80211_VIF_BEACON_FILTER; 793 __clear_bit(IEEE80211_HW_CONNECTION_MONITOR, hw->flags); 794 } 795 } 796 797 static void 798 mt7925_sniffer_interface_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 799 { 800 struct mt792x_dev *dev = priv; 801 struct ieee80211_hw *hw = mt76_hw(dev); 802 struct mt76_connac_pm *pm = &dev->pm; 803 bool monitor = !!(hw->conf.flags & IEEE80211_CONF_MONITOR); 804 805 mt7925_mcu_set_sniffer(dev, vif, monitor); 806 pm->enable = pm->enable_user && !monitor; 807 pm->ds_enable = pm->ds_enable_user && !monitor; 808 809 mt7925_mcu_set_deep_sleep(dev, pm->ds_enable); 810 811 if (monitor) 812 mt7925_mcu_set_beacon_filter(dev, vif, false); 813 } 814 815 void mt7925_set_runtime_pm(struct mt792x_dev *dev) 816 { 817 struct ieee80211_hw *hw = mt76_hw(dev); 818 struct mt76_connac_pm *pm = &dev->pm; 819 bool monitor = !!(hw->conf.flags & IEEE80211_CONF_MONITOR); 820 821 pm->enable = pm->enable_user && !monitor; 822 ieee80211_iterate_active_interfaces(hw, 823 IEEE80211_IFACE_ITER_RESUME_ALL, 824 mt7925_pm_interface_iter, dev); 825 pm->ds_enable = pm->ds_enable_user && !monitor; 826 mt7925_mcu_set_deep_sleep(dev, pm->ds_enable); 827 } 828 829 static int mt7925_config(struct ieee80211_hw *hw, int radio_idx, u32 changed) 830 { 831 struct mt792x_dev *dev = mt792x_hw_dev(hw); 832 int ret = 0; 833 834 mt792x_mutex_acquire(dev); 835 836 if (changed & IEEE80211_CONF_CHANGE_POWER) { 837 ret = mt7925_set_tx_sar_pwr(hw, NULL); 838 if (ret) 839 goto out; 840 } 841 842 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 843 ieee80211_iterate_active_interfaces(hw, 844 IEEE80211_IFACE_ITER_RESUME_ALL, 845 mt7925_sniffer_interface_iter, dev); 846 } 847 848 out: 849 mt792x_mutex_release(dev); 850 851 return ret; 852 } 853 854 static void mt7925_configure_filter(struct ieee80211_hw *hw, 855 unsigned int changed_flags, 856 unsigned int *total_flags, 857 u64 multicast) 858 { 859 #define MT7925_FILTER_FCSFAIL BIT(2) 860 #define MT7925_FILTER_CONTROL BIT(5) 861 #define MT7925_FILTER_OTHER_BSS BIT(6) 862 #define MT7925_FILTER_ENABLE BIT(31) 863 struct mt792x_dev *dev = mt792x_hw_dev(hw); 864 u32 flags = MT7925_FILTER_ENABLE; 865 866 #define MT7925_FILTER(_fif, _type) do { \ 867 if (*total_flags & (_fif)) \ 868 flags |= MT7925_FILTER_##_type; \ 869 } while (0) 870 871 MT7925_FILTER(FIF_FCSFAIL, FCSFAIL); 872 MT7925_FILTER(FIF_CONTROL, CONTROL); 873 MT7925_FILTER(FIF_OTHER_BSS, OTHER_BSS); 874 875 mt792x_mutex_acquire(dev); 876 mt7925_mcu_set_rxfilter(dev, flags, 0, 0); 877 mt792x_mutex_release(dev); 878 879 *total_flags &= (FIF_OTHER_BSS | FIF_FCSFAIL | FIF_CONTROL); 880 } 881 882 static u8 883 mt7925_get_rates_table(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 884 bool beacon, bool mcast) 885 { 886 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 887 struct mt76_phy *mphy = hw->priv; 888 u16 rate; 889 u8 i, idx, ht; 890 891 rate = mt76_connac2_mac_tx_rate_val(mphy, &vif->bss_conf, beacon, mcast); 892 ht = FIELD_GET(MT_TX_RATE_MODE, rate) > MT_PHY_TYPE_OFDM; 893 894 if (beacon && ht) { 895 struct mt792x_dev *dev = mt792x_hw_dev(hw); 896 897 /* must odd index */ 898 idx = MT7925_BEACON_RATES_TBL + 2 * (mvif->idx % 20); 899 mt7925_mac_set_fixed_rate_table(dev, idx, rate); 900 return idx; 901 } 902 903 idx = FIELD_GET(MT_TX_RATE_IDX, rate); 904 for (i = 0; i < ARRAY_SIZE(mt76_rates); i++) 905 if ((mt76_rates[i].hw_value & GENMASK(7, 0)) == idx) 906 return MT792x_BASIC_RATES_TBL + i; 907 908 return mvif->basic_rates_idx; 909 } 910 911 static int mt7925_mac_link_sta_add(struct mt76_dev *mdev, 912 struct ieee80211_vif *vif, 913 struct ieee80211_link_sta *link_sta, 914 struct mt792x_link_sta *mlink) 915 { 916 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 917 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 918 struct ieee80211_bss_conf *link_conf; 919 struct mt792x_bss_conf *mconf; 920 u8 link_id = link_sta->link_id; 921 bool wcid_published = false; 922 struct mt792x_sta *msta; 923 struct mt76_wcid *wcid; 924 bool pm_woken = false; 925 int ret, idx; 926 927 msta = (struct mt792x_sta *)link_sta->sta->drv_priv; 928 929 if (WARN_ON_ONCE(!mlink)) 930 return -EINVAL; 931 932 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT792x_WTBL_STA - 1); 933 if (idx < 0) 934 return -ENOSPC; 935 936 mconf = mt792x_vif_to_link(mvif, link_id); 937 mt76_wcid_init(&mlink->wcid, 0); 938 mlink->wcid.sta = 1; 939 mlink->wcid.idx = idx; 940 mlink->wcid.tx_info |= MT_WCID_TX_INFO_SET; 941 mlink->last_txs = jiffies; 942 mlink->wcid.link_id = link_sta->link_id; 943 mlink->wcid.link_valid = !!link_sta->sta->valid_links; 944 mlink->sta = msta; 945 946 if (link_sta->sta->tdls) 947 set_bit(MT_WCID_FLAG_TDLS_PEER, &mlink->wcid.flags); 948 949 wcid = &mlink->wcid; 950 ewma_signal_init(&wcid->rssi); 951 rcu_assign_pointer(dev->mt76.wcid[wcid->idx], wcid); 952 wcid_published = true; 953 ewma_avg_signal_init(&mlink->avg_ack_signal); 954 memset(mlink->airtime_ac, 0, 955 sizeof(msta->deflink.airtime_ac)); 956 957 ret = mt76_connac_pm_wake(&dev->mphy, &dev->pm); 958 if (ret) 959 goto out_wcid; 960 pm_woken = true; 961 962 mt7925_mac_wtbl_update(dev, idx, 963 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 964 965 link_conf = mt792x_vif_to_bss_conf(vif, link_id); 966 967 /* should update bss info before STA add */ 968 if (vif->type == NL80211_IFTYPE_STATION && !link_sta->sta->tdls) { 969 struct mt792x_link_sta *mlink_bc; 970 971 mlink_bc = mt792x_sta_to_link(&mvif->sta, mconf->link_id); 972 973 if (ieee80211_vif_is_mld(vif)) { 974 ret = mt7925_mcu_add_bss_info_sta(&dev->phy, mconf->mt76.ctx, 975 link_conf, link_sta, 976 mlink_bc->wcid.idx, mlink->wcid.idx, 977 link_sta != mlink->pri_link); 978 if (ret) 979 goto out_pm; 980 } else { 981 ret = mt7925_mcu_add_bss_info_sta(&dev->phy, mconf->mt76.ctx, 982 link_conf, link_sta, 983 mlink_bc->wcid.idx, mlink->wcid.idx, 984 false); 985 if (ret) 986 goto out_pm; 987 } 988 } 989 990 if (ieee80211_vif_is_mld(vif) && 991 link_sta == mlink->pri_link) { 992 ret = mt7925_mcu_sta_update(dev, link_sta, vif, 993 mlink, true, 994 MT76_STA_INFO_STATE_NONE); 995 if (ret) 996 goto out_pm; 997 } else if (ieee80211_vif_is_mld(vif) && 998 link_sta != mlink->pri_link) { 999 struct mt792x_link_sta *pri_mlink; 1000 struct mt76_wcid *pri_wcid; 1001 1002 /* alternative lookup via def_wcid */ 1003 pri_wcid = mlink->wcid.def_wcid; 1004 1005 pri_mlink = pri_wcid ? 1006 container_of(pri_wcid, struct mt792x_link_sta, wcid) : 1007 NULL; 1008 1009 if (WARN_ON_ONCE(!pri_mlink)) { 1010 ret = -EINVAL; 1011 goto out_pm; 1012 } 1013 1014 ret = mt7925_mcu_sta_update(dev, mlink->pri_link, vif, 1015 pri_mlink, true, 1016 MT76_STA_INFO_STATE_ASSOC); 1017 if (ret) 1018 goto out_pm; 1019 1020 ret = mt7925_mcu_sta_update(dev, link_sta, vif, 1021 mlink, true, 1022 MT76_STA_INFO_STATE_ASSOC); 1023 if (ret) 1024 goto out_pm; 1025 } else { 1026 ret = mt7925_mcu_sta_update(dev, link_sta, vif, 1027 mlink, true, 1028 MT76_STA_INFO_STATE_NONE); 1029 if (ret) 1030 goto out_pm; 1031 } 1032 1033 mt76_connac_power_save_sched(&dev->mphy, &dev->pm); 1034 1035 return 0; 1036 1037 out_pm: 1038 if (pm_woken) 1039 mt76_connac_power_save_sched(&dev->mphy, &dev->pm); 1040 out_wcid: 1041 if (wcid_published) { 1042 u16 idx = wcid->idx; 1043 1044 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 1045 mt76_wcid_cleanup(mdev, wcid); 1046 mt76_wcid_mask_clear(mdev->wcid_mask, wcid->idx); 1047 } 1048 return ret; 1049 } 1050 1051 /* 1052 * Host-only unwind for sta_add_links() failures. 1053 * 1054 * If add_links fail due to MCU/firmware timeouts; calling the full remove 1055 * path would send more firmware commands and may hang again. So only rollback 1056 * host-published state here (msta->link/valid_links, dev->mt76.wcid[idx]) and 1057 * free mlink objects (RCU-safe). Firmware state is left for reset/recovery. 1058 */ 1059 static void 1060 mt7925_mac_sta_unwind_links_host(struct mt792x_dev *dev, 1061 struct ieee80211_sta *sta, 1062 unsigned long links) 1063 { 1064 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1065 unsigned int link_id; 1066 1067 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 1068 struct mt792x_link_sta *mlink; 1069 u16 idx; 1070 1071 mlink = rcu_replace_pointer(msta->link[link_id], NULL, 1072 lockdep_is_held(&dev->mt76.mutex)); 1073 if (!mlink) 1074 continue; 1075 1076 msta->valid_links &= ~BIT(link_id); 1077 if (msta->deflink_id == link_id) 1078 msta->deflink_id = IEEE80211_LINK_UNSPECIFIED; 1079 1080 idx = mlink->wcid.idx; 1081 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 1082 mt76_wcid_cleanup(&dev->mt76, &mlink->wcid); 1083 mt76_wcid_mask_clear(dev->mt76.wcid_mask, idx); 1084 1085 if (mlink != &msta->deflink) 1086 kfree_rcu(mlink, rcu_head); 1087 } 1088 } 1089 1090 static int 1091 mt7925_mac_sta_add_links(struct mt792x_dev *dev, struct ieee80211_vif *vif, 1092 struct ieee80211_sta *sta, unsigned long new_links) 1093 { 1094 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1095 unsigned long added_links = 0; 1096 unsigned int link_id; 1097 int err = 0; 1098 1099 for_each_set_bit(link_id, &new_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1100 struct ieee80211_link_sta *link_sta; 1101 struct mt792x_link_sta *mlink; 1102 bool is_deflink = false; 1103 1104 if (msta->deflink_id == IEEE80211_LINK_UNSPECIFIED) { 1105 mlink = &msta->deflink; 1106 is_deflink = true; 1107 } else { 1108 mlink = kzalloc_obj(*mlink); 1109 if (!mlink) { 1110 err = -ENOMEM; 1111 break; 1112 } 1113 } 1114 1115 mlink->sta = msta; 1116 mlink->pri_link = &sta->deflink; 1117 mlink->wcid.def_wcid = &msta->deflink.wcid; 1118 1119 link_sta = mt792x_sta_to_link_sta(vif, sta, link_id); 1120 err = mt7925_mac_link_sta_add(&dev->mt76, vif, link_sta, mlink); 1121 if (err) { 1122 if (!is_deflink) 1123 kfree_rcu(mlink, rcu_head); 1124 break; 1125 } 1126 1127 if (is_deflink) 1128 msta->deflink_id = link_id; 1129 1130 rcu_assign_pointer(msta->link[link_id], mlink); 1131 msta->valid_links |= BIT(link_id); 1132 1133 added_links |= BIT(link_id); 1134 } 1135 1136 if (err && added_links) 1137 mt7925_mac_sta_unwind_links_host(dev, sta, added_links); 1138 1139 return err; 1140 } 1141 1142 int mt7925_mac_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif, 1143 struct ieee80211_sta *sta) 1144 { 1145 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1146 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1147 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1148 int err; 1149 1150 msta->vif = mvif; 1151 1152 if (vif->type == NL80211_IFTYPE_STATION) 1153 mvif->wep_sta = msta; 1154 1155 if (ieee80211_vif_is_mld(vif)) { 1156 msta->deflink_id = IEEE80211_LINK_UNSPECIFIED; 1157 1158 err = mt7925_mac_sta_add_links(dev, vif, sta, sta->valid_links); 1159 } else { 1160 err = mt7925_mac_link_sta_add(mdev, vif, &sta->deflink, 1161 &msta->deflink); 1162 } 1163 1164 return err; 1165 } 1166 EXPORT_SYMBOL_GPL(mt7925_mac_sta_add); 1167 1168 static void 1169 mt7925_mac_set_links(struct mt76_dev *mdev, struct ieee80211_vif *vif) 1170 { 1171 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1172 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1173 struct ieee80211_bss_conf *link_conf = 1174 mt792x_vif_to_bss_conf(vif, mvif->deflink_id); 1175 struct cfg80211_chan_def *chandef = &link_conf->chanreq.oper; 1176 enum nl80211_band band = chandef->chan->band, secondary_band; 1177 1178 u16 sel_links = mt76_select_links(vif, 2); 1179 u8 secondary_link_id = __ffs(~BIT(mvif->deflink_id) & sel_links); 1180 1181 if (!ieee80211_vif_is_mld(vif) || hweight16(sel_links) < 2) 1182 return; 1183 1184 link_conf = mt792x_vif_to_bss_conf(vif, secondary_link_id); 1185 secondary_band = link_conf->chanreq.oper.chan->band; 1186 1187 if (band == NL80211_BAND_2GHZ || 1188 (band == NL80211_BAND_5GHZ && secondary_band == NL80211_BAND_6GHZ)) { 1189 mt7925_abort_roc(mvif->phy, &mvif->bss_conf); 1190 1191 mt792x_mutex_acquire(dev); 1192 1193 mt7925_set_mlo_roc(mvif->phy, &mvif->bss_conf, sel_links); 1194 1195 mt792x_mutex_release(dev); 1196 } 1197 1198 ieee80211_set_active_links_async(vif, sel_links); 1199 } 1200 1201 static void mt7925_mac_link_sta_assoc(struct mt76_dev *mdev, 1202 struct ieee80211_vif *vif, 1203 struct ieee80211_link_sta *link_sta) 1204 { 1205 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1206 struct ieee80211_bss_conf *link_conf; 1207 struct mt792x_link_sta *mlink; 1208 struct mt792x_sta *msta; 1209 1210 mt792x_mutex_acquire(dev); 1211 1212 msta = (struct mt792x_sta *)link_sta->sta->drv_priv; 1213 mlink = mt792x_sta_to_link(msta, link_sta->link_id); 1214 1215 if (ieee80211_vif_is_mld(vif)) { 1216 link_conf = mt792x_vif_to_bss_conf(vif, msta->deflink_id); 1217 } else { 1218 link_conf = mt792x_vif_to_bss_conf(vif, vif->bss_conf.link_id); 1219 } 1220 1221 if (vif->type == NL80211_IFTYPE_STATION && !link_sta->sta->tdls) { 1222 struct mt792x_bss_conf *mconf; 1223 1224 mconf = mt792x_link_conf_to_mconf(link_conf); 1225 mt7925_mcu_add_bss_info(&dev->phy, mconf->mt76.ctx, 1226 link_conf, link_sta, true); 1227 } 1228 1229 ewma_avg_signal_init(&mlink->avg_ack_signal); 1230 1231 mt7925_mac_wtbl_update(dev, mlink->wcid.idx, 1232 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 1233 memset(mlink->airtime_ac, 0, sizeof(mlink->airtime_ac)); 1234 1235 mt7925_mcu_sta_update(dev, link_sta, vif, mlink, true, 1236 MT76_STA_INFO_STATE_ASSOC); 1237 1238 mt792x_mutex_release(dev); 1239 } 1240 1241 int mt7925_mac_sta_event(struct mt76_dev *mdev, struct ieee80211_vif *vif, 1242 struct ieee80211_sta *sta, enum mt76_sta_event ev) 1243 { 1244 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1245 struct ieee80211_link_sta *link_sta = &sta->deflink; 1246 1247 switch (ev) { 1248 case MT76_STA_EVENT_ASSOC: 1249 if (ieee80211_vif_is_mld(vif)) { 1250 struct mt792x_sta *msta = 1251 (struct mt792x_sta *)sta->drv_priv; 1252 1253 link_sta = mt792x_sta_to_link_sta(vif, sta, 1254 msta->deflink_id); 1255 mt7925_mac_set_links(mdev, vif); 1256 } 1257 1258 mt7925_mac_link_sta_assoc(mdev, vif, link_sta); 1259 break; 1260 case MT76_STA_EVENT_AUTHORIZE: 1261 if (vif->type == NL80211_IFTYPE_NAN_DATA) { 1262 int ret; 1263 1264 mt792x_mutex_acquire(dev); 1265 ret = mt792x_nan_map_sta_rec(mdev, vif, sta); 1266 mt792x_mutex_release(dev); 1267 1268 return ret; 1269 } 1270 break; 1271 default: 1272 break; 1273 } 1274 1275 return 0; 1276 } 1277 EXPORT_SYMBOL_GPL(mt7925_mac_sta_event); 1278 1279 static void mt7925_mac_link_sta_remove(struct mt76_dev *mdev, 1280 struct ieee80211_vif *vif, 1281 struct ieee80211_link_sta *link_sta, 1282 struct mt792x_link_sta *mlink) 1283 { 1284 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1285 struct mt76_wcid *wcid = &mlink->wcid; 1286 struct ieee80211_bss_conf *link_conf; 1287 u8 link_id = link_sta->link_id; 1288 u16 idx = wcid->idx; 1289 1290 mt7925_roc_abort_sync(dev); 1291 1292 mt76_connac_free_pending_tx_skbs(&dev->pm, wcid); 1293 mt76_connac_pm_wake(&dev->mphy, &dev->pm); 1294 1295 mt7925_mcu_sta_update(dev, link_sta, vif, mlink, false, 1296 MT76_STA_INFO_STATE_NONE); 1297 mt7925_mac_wtbl_update(dev, mlink->wcid.idx, 1298 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 1299 1300 link_conf = mt792x_vif_to_bss_conf(vif, link_id); 1301 1302 if (vif->type == NL80211_IFTYPE_STATION && !link_sta->sta->tdls) { 1303 struct mt792x_bss_conf *mconf; 1304 1305 mconf = mt792x_link_conf_to_mconf(link_conf); 1306 1307 if (ieee80211_vif_is_mld(vif)) 1308 mt792x_mac_link_bss_remove(dev, mconf, mlink); 1309 else 1310 mt7925_mcu_add_bss_info(&dev->phy, mconf->mt76.ctx, link_conf, 1311 link_sta, false); 1312 } 1313 1314 spin_lock_bh(&mdev->sta_poll_lock); 1315 if (!list_empty(&mlink->wcid.poll_list)) 1316 list_del_init(&mlink->wcid.poll_list); 1317 spin_unlock_bh(&mdev->sta_poll_lock); 1318 1319 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 1320 mt76_wcid_cleanup(mdev, wcid); 1321 mt76_wcid_mask_clear(mdev->wcid_mask, idx); 1322 1323 mt76_connac_power_save_sched(&dev->mphy, &dev->pm); 1324 } 1325 1326 static int 1327 mt7925_mac_sta_remove_links(struct mt792x_dev *dev, struct ieee80211_vif *vif, 1328 struct ieee80211_sta *sta, unsigned long old_links) 1329 { 1330 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1331 struct mt76_dev *mdev = &dev->mt76; 1332 unsigned int link_id; 1333 1334 /* clean up bss before starec */ 1335 for_each_set_bit(link_id, &old_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1336 struct ieee80211_link_sta *link_sta; 1337 struct ieee80211_bss_conf *link_conf; 1338 struct mt792x_bss_conf *mconf; 1339 struct mt792x_link_sta *mlink; 1340 1341 if (vif->type == NL80211_IFTYPE_AP) 1342 break; 1343 1344 if (vif->type == NL80211_IFTYPE_STATION && sta->tdls) 1345 continue; 1346 1347 link_sta = mt792x_sta_to_link_sta(vif, sta, link_id); 1348 if (!link_sta) 1349 continue; 1350 1351 mlink = mt792x_sta_to_link(msta, link_id); 1352 if (!mlink) 1353 continue; 1354 1355 link_conf = mt792x_vif_to_bss_conf(vif, link_id); 1356 if (!link_conf) 1357 continue; 1358 1359 mconf = mt792x_link_conf_to_mconf(link_conf); 1360 1361 mt7925_mcu_add_bss_info(&dev->phy, mconf->mt76.ctx, link_conf, 1362 link_sta, false); 1363 } 1364 1365 for_each_set_bit(link_id, &old_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1366 struct ieee80211_link_sta *link_sta; 1367 struct mt792x_link_sta *mlink; 1368 1369 link_sta = mt792x_sta_to_link_sta(vif, sta, link_id); 1370 if (!link_sta) 1371 continue; 1372 1373 mlink = rcu_replace_pointer(msta->link[link_id], NULL, 1374 lockdep_is_held(&mdev->mutex)); 1375 if (!mlink) 1376 continue; 1377 1378 msta->valid_links &= ~BIT(link_id); 1379 mlink->sta = NULL; 1380 mlink->pri_link = NULL; 1381 1382 mt7925_mac_link_sta_remove(&dev->mt76, vif, link_sta, mlink); 1383 1384 if (mlink != &msta->deflink) 1385 kfree_rcu(mlink, rcu_head); 1386 1387 if (msta->deflink_id == link_id) 1388 msta->deflink_id = IEEE80211_LINK_UNSPECIFIED; 1389 } 1390 1391 return 0; 1392 } 1393 1394 void mt7925_mac_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif, 1395 struct ieee80211_sta *sta) 1396 { 1397 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 1398 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1399 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1400 1401 /* Release NAN peer record before tearing down the STA. */ 1402 if (vif->type == NL80211_IFTYPE_NAN || 1403 vif->type == NL80211_IFTYPE_NAN_DATA) { 1404 int ret = mt792x_nan_set_peer_rec(mdev, sta); 1405 1406 if (ret) 1407 dev_err(mdev->dev, 1408 "NAN: failed to deactivate peer record: %d\n", 1409 ret); 1410 } 1411 1412 /* Release NDP context ID for NAN_DATA sta. */ 1413 if (vif->type == NL80211_IFTYPE_NAN_DATA) { 1414 struct ieee80211_sta *nmi_sta; 1415 1416 rcu_read_lock(); 1417 nmi_sta = rcu_dereference(sta->nmi); 1418 if (nmi_sta) { 1419 struct mt792x_sta *nmi_msta = 1420 (struct mt792x_sta *)nmi_sta->drv_priv; 1421 1422 if (msta->nan_sched.ndp_ctx_assigned) { 1423 clear_bit(msta->nan_sched.ndp_ctx_id, 1424 &nmi_msta->nan_sched.ndp_ctx_bitmap); 1425 msta->nan_sched.ndp_ctx_assigned = false; 1426 } 1427 } 1428 rcu_read_unlock(); 1429 } 1430 1431 if (ieee80211_vif_is_mld(vif)) { 1432 mt7925_mac_sta_remove_links(dev, vif, sta, msta->valid_links); 1433 mt7925_mcu_del_dev(mdev, vif); 1434 } else { 1435 mt7925_mac_link_sta_remove(mdev, vif, &sta->deflink, 1436 &msta->deflink); 1437 } 1438 1439 if (vif->type == NL80211_IFTYPE_STATION) { 1440 mvif->wep_sta = NULL; 1441 ewma_rssi_init(&mvif->bss_conf.rssi); 1442 } 1443 1444 mvif->mlo_pm_state = MT792x_MLO_LINK_DISASSOC; 1445 } 1446 EXPORT_SYMBOL_GPL(mt7925_mac_sta_remove); 1447 1448 static int mt7925_set_rts_threshold(struct ieee80211_hw *hw, int radio_idx, 1449 u32 val) 1450 { 1451 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1452 1453 mt792x_mutex_acquire(dev); 1454 mt7925_mcu_set_rts_thresh(&dev->phy, val); 1455 mt792x_mutex_release(dev); 1456 1457 return 0; 1458 } 1459 1460 static int 1461 mt7925_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1462 struct ieee80211_ampdu_params *params) 1463 { 1464 enum ieee80211_ampdu_mlme_action action = params->action; 1465 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1466 struct ieee80211_sta *sta = params->sta; 1467 struct ieee80211_txq *txq = sta->txq[params->tid]; 1468 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1469 u16 tid = params->tid; 1470 u16 ssn = params->ssn; 1471 struct mt76_txq *mtxq; 1472 int ret = 0; 1473 1474 if (!txq) 1475 return -EINVAL; 1476 1477 mtxq = (struct mt76_txq *)txq->drv_priv; 1478 1479 mt792x_mutex_acquire(dev); 1480 switch (action) { 1481 case IEEE80211_AMPDU_RX_START: 1482 mt76_rx_aggr_start(&dev->mt76, &msta->deflink.wcid, tid, ssn, 1483 params->buf_size); 1484 mt7925_mcu_uni_rx_ba(dev, params, vif, true); 1485 break; 1486 case IEEE80211_AMPDU_RX_STOP: 1487 mt76_rx_aggr_stop(&dev->mt76, &msta->deflink.wcid, tid); 1488 mt7925_mcu_uni_rx_ba(dev, params, vif, false); 1489 break; 1490 case IEEE80211_AMPDU_TX_OPERATIONAL: 1491 mtxq->aggr = true; 1492 mtxq->send_bar = false; 1493 mt7925_mcu_uni_tx_ba(dev, params, vif, true); 1494 break; 1495 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1496 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1497 mtxq->aggr = false; 1498 clear_bit(tid, &msta->deflink.wcid.ampdu_state); 1499 mt7925_mcu_uni_tx_ba(dev, params, vif, false); 1500 break; 1501 case IEEE80211_AMPDU_TX_START: 1502 set_bit(tid, &msta->deflink.wcid.ampdu_state); 1503 ret = IEEE80211_AMPDU_TX_START_IMMEDIATE; 1504 break; 1505 case IEEE80211_AMPDU_TX_STOP_CONT: 1506 mtxq->aggr = false; 1507 clear_bit(tid, &msta->deflink.wcid.ampdu_state); 1508 mt7925_mcu_uni_tx_ba(dev, params, vif, false); 1509 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1510 break; 1511 } 1512 mt792x_mutex_release(dev); 1513 1514 return ret; 1515 } 1516 1517 static void 1518 mt7925_mlo_pm_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 1519 { 1520 struct mt792x_dev *dev = priv; 1521 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1522 unsigned long valid = ieee80211_vif_is_mld(vif) ? 1523 mvif->valid_links : BIT(0); 1524 struct ieee80211_bss_conf *bss_conf; 1525 int i; 1526 1527 if (mvif->mlo_pm_state != MT792x_MLO_CHANGED_PS) 1528 return; 1529 1530 mt792x_mutex_acquire(dev); 1531 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 1532 bss_conf = mt792x_vif_to_bss_conf(vif, i); 1533 mt7925_mcu_uni_bss_ps(dev, bss_conf); 1534 } 1535 mt792x_mutex_release(dev); 1536 } 1537 1538 void mt7925_mlo_pm_work(struct work_struct *work) 1539 { 1540 struct mt792x_dev *dev = container_of(work, struct mt792x_dev, 1541 mlo_pm_work.work); 1542 struct ieee80211_hw *hw = mt76_hw(dev); 1543 1544 ieee80211_iterate_active_interfaces(hw, 1545 IEEE80211_IFACE_ITER_RESUME_ALL, 1546 mt7925_mlo_pm_iter, dev); 1547 } 1548 1549 void mt7925_scan_work(struct work_struct *work) 1550 { 1551 struct mt792x_phy *phy; 1552 struct mt792x_dev *dev; 1553 struct mt76_connac_pm *pm; 1554 1555 phy = (struct mt792x_phy *)container_of(work, struct mt792x_phy, 1556 scan_work.work); 1557 1558 dev = phy->dev; 1559 pm = &dev->pm; 1560 1561 if (pm->suspended) 1562 return; 1563 1564 while (true) { 1565 struct sk_buff *skb; 1566 struct tlv *tlv; 1567 u32 tlv_len; 1568 1569 spin_lock_bh(&phy->dev->mt76.lock); 1570 skb = __skb_dequeue(&phy->scan_event_list); 1571 spin_unlock_bh(&phy->dev->mt76.lock); 1572 1573 if (!skb) 1574 break; 1575 1576 skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4); 1577 tlv = (struct tlv *)skb->data; 1578 tlv_len = skb->len; 1579 1580 mt7925_for_each_tlv(tlv, tlv_len) { 1581 struct mt7925_mcu_scan_chinfo_event *evt; 1582 1583 switch (le16_to_cpu(tlv->tag)) { 1584 case UNI_EVENT_SCAN_DONE_BASIC: 1585 if (test_and_clear_bit(MT76_HW_SCANNING, &phy->mt76->state)) { 1586 struct cfg80211_scan_info info = { 1587 .aborted = false, 1588 }; 1589 ieee80211_scan_completed(phy->mt76->hw, &info); 1590 } 1591 break; 1592 case UNI_EVENT_SCAN_DONE_CHNLINFO: 1593 if (le16_to_cpu(tlv->len) < sizeof(*tlv) + sizeof(*evt)) 1594 break; 1595 1596 evt = (struct mt7925_mcu_scan_chinfo_event *)tlv->data; 1597 1598 mt7925_regd_change(phy, evt->alpha2); 1599 1600 break; 1601 case UNI_EVENT_SCAN_DONE_NLO: 1602 ieee80211_sched_scan_results(phy->mt76->hw); 1603 break; 1604 default: 1605 break; 1606 } 1607 } 1608 1609 dev_kfree_skb(skb); 1610 } 1611 } 1612 1613 static int 1614 mt7925_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1615 struct ieee80211_scan_request *req) 1616 { 1617 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1618 struct mt76_phy *mphy = hw->priv; 1619 int err; 1620 1621 mt792x_mutex_acquire(dev); 1622 err = mt7925_mcu_hw_scan(mphy, vif, req); 1623 mt792x_mutex_release(dev); 1624 1625 return err; 1626 } 1627 1628 static void 1629 mt7925_cancel_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1630 { 1631 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1632 struct mt76_phy *mphy = hw->priv; 1633 1634 mt792x_mutex_acquire(dev); 1635 mt7925_mcu_cancel_hw_scan(mphy, vif); 1636 mt792x_mutex_release(dev); 1637 } 1638 1639 static int 1640 mt7925_start_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1641 struct cfg80211_sched_scan_request *req, 1642 struct ieee80211_scan_ies *ies) 1643 { 1644 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1645 struct mt76_phy *mphy = hw->priv; 1646 int err; 1647 1648 mt792x_mutex_acquire(dev); 1649 1650 err = mt7925_mcu_sched_scan_req(mphy, vif, req, ies); 1651 if (err < 0) 1652 goto out; 1653 1654 err = mt7925_mcu_sched_scan_enable(mphy, vif, true); 1655 out: 1656 mt792x_mutex_release(dev); 1657 1658 return err; 1659 } 1660 1661 static int 1662 mt7925_stop_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1663 { 1664 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1665 struct mt76_phy *mphy = hw->priv; 1666 int err; 1667 1668 mt792x_mutex_acquire(dev); 1669 err = mt7925_mcu_sched_scan_enable(mphy, vif, false); 1670 mt792x_mutex_release(dev); 1671 1672 return err; 1673 } 1674 1675 static int 1676 mt7925_set_antenna(struct ieee80211_hw *hw, int radio_idx, 1677 u32 tx_ant, u32 rx_ant) 1678 { 1679 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1680 struct mt792x_phy *phy = mt792x_hw_phy(hw); 1681 int max_nss = hweight8(hw->wiphy->available_antennas_tx); 1682 1683 if (!tx_ant || tx_ant != rx_ant || ffs(tx_ant) > max_nss) 1684 return -EINVAL; 1685 1686 if ((BIT(hweight8(tx_ant)) - 1) != tx_ant) 1687 tx_ant = BIT(ffs(tx_ant) - 1) - 1; 1688 1689 mt792x_mutex_acquire(dev); 1690 1691 phy->mt76->antenna_mask = tx_ant; 1692 phy->mt76->chainmask = tx_ant; 1693 1694 mt76_set_stream_caps(phy->mt76, true); 1695 mt7925_set_stream_he_eht_caps(phy); 1696 1697 /* TODO: update bmc_wtbl spe_idx when antenna changes */ 1698 mt792x_mutex_release(dev); 1699 1700 return 0; 1701 } 1702 1703 #ifdef CONFIG_PM 1704 static int mt7925_suspend(struct ieee80211_hw *hw, 1705 struct cfg80211_wowlan *wowlan) 1706 { 1707 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1708 struct mt792x_phy *phy = mt792x_hw_phy(hw); 1709 1710 cancel_delayed_work_sync(&phy->scan_work); 1711 cancel_delayed_work_sync(&phy->mt76->mac_work); 1712 1713 cancel_delayed_work_sync(&dev->pm.ps_work); 1714 cancel_delayed_work_sync(&dev->mlo_pm_work); 1715 mt76_connac_free_pending_tx_skbs(&dev->pm, NULL); 1716 1717 mt792x_mutex_acquire(dev); 1718 1719 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state); 1720 ieee80211_iterate_active_interfaces(hw, 1721 IEEE80211_IFACE_ITER_RESUME_ALL, 1722 mt7925_mcu_set_suspend_iter, 1723 &dev->mphy); 1724 1725 mt792x_mutex_release(dev); 1726 1727 return 0; 1728 } 1729 1730 static int mt7925_resume(struct ieee80211_hw *hw) 1731 { 1732 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1733 struct mt792x_phy *phy = mt792x_hw_phy(hw); 1734 1735 mt792x_mutex_acquire(dev); 1736 1737 set_bit(MT76_STATE_RUNNING, &phy->mt76->state); 1738 ieee80211_iterate_active_interfaces(hw, 1739 IEEE80211_IFACE_ITER_RESUME_ALL, 1740 mt7925_mcu_set_suspend_iter, 1741 &dev->mphy); 1742 1743 ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work, 1744 MT792x_WATCHDOG_TIME); 1745 1746 mt792x_mutex_release(dev); 1747 1748 return 0; 1749 } 1750 1751 static void mt7925_set_rekey_data(struct ieee80211_hw *hw, 1752 struct ieee80211_vif *vif, 1753 struct cfg80211_gtk_rekey_data *data) 1754 { 1755 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1756 1757 mt792x_mutex_acquire(dev); 1758 mt76_connac_mcu_update_gtk_rekey(hw, vif, data); 1759 mt792x_mutex_release(dev); 1760 } 1761 #endif /* CONFIG_PM */ 1762 1763 static void mt7925_sta_set_decap_offload(struct ieee80211_hw *hw, 1764 struct ieee80211_vif *vif, 1765 struct ieee80211_sta *sta, 1766 bool enabled) 1767 { 1768 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 1769 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1770 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1771 unsigned long valid = mvif->valid_links; 1772 u8 i; 1773 1774 if (!msta->vif) 1775 return; 1776 1777 mt792x_mutex_acquire(dev); 1778 1779 valid = ieee80211_vif_is_mld(vif) ? mvif->valid_links : BIT(0); 1780 1781 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 1782 struct mt792x_bss_conf *mconf; 1783 struct mt792x_link_sta *mlink; 1784 1785 mconf = mt792x_vif_to_link(mvif, i); 1786 mlink = mt792x_sta_to_link(msta, i); 1787 1788 if (!mlink) 1789 continue; 1790 1791 if (enabled) 1792 set_bit(MT_WCID_FLAG_HDR_TRANS, &mlink->wcid.flags); 1793 else 1794 clear_bit(MT_WCID_FLAG_HDR_TRANS, &mlink->wcid.flags); 1795 1796 if (!mlink->wcid.sta) 1797 continue; 1798 1799 mt7925_mcu_wtbl_update_hdr_trans(dev, vif, mconf, mlink); 1800 } 1801 1802 mt792x_mutex_release(dev); 1803 } 1804 1805 #if IS_ENABLED(CONFIG_IPV6) 1806 static void __mt7925_ipv6_addr_change(struct ieee80211_hw *hw, 1807 struct ieee80211_bss_conf *link_conf, 1808 struct inet6_dev *idev) 1809 { 1810 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf); 1811 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1812 struct inet6_ifaddr *ifa; 1813 struct sk_buff *skb; 1814 u8 idx = 0; 1815 1816 struct { 1817 struct { 1818 u8 bss_idx; 1819 u8 pad[3]; 1820 } __packed hdr; 1821 struct mt7925_arpns_tlv arpns; 1822 struct in6_addr ns_addrs[IEEE80211_BSS_ARP_ADDR_LIST_LEN]; 1823 } req_hdr = { 1824 .hdr = { 1825 .bss_idx = mconf->mt76.idx, 1826 }, 1827 .arpns = { 1828 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ND), 1829 .len = cpu_to_le16(sizeof(req_hdr) - 4), 1830 .enable = true, 1831 }, 1832 }; 1833 1834 read_lock_bh(&idev->lock); 1835 list_for_each_entry(ifa, &idev->addr_list, if_list) { 1836 if (ifa->flags & IFA_F_TENTATIVE) 1837 continue; 1838 req_hdr.ns_addrs[idx] = ifa->addr; 1839 if (++idx >= IEEE80211_BSS_ARP_ADDR_LIST_LEN) 1840 break; 1841 } 1842 read_unlock_bh(&idev->lock); 1843 1844 if (!idx) 1845 return; 1846 1847 req_hdr.arpns.ips_num = idx; 1848 1849 skb = __mt76_mcu_msg_alloc(&dev->mt76, NULL, sizeof(req_hdr), 1850 0, GFP_ATOMIC); 1851 if (!skb) 1852 return; 1853 1854 skb_put_data(skb, &req_hdr, sizeof(req_hdr)); 1855 1856 skb_queue_tail(&dev->ipv6_ns_list, skb); 1857 1858 ieee80211_queue_work(dev->mt76.hw, &dev->ipv6_ns_work); 1859 } 1860 1861 static void mt7925_ipv6_addr_change(struct ieee80211_hw *hw, 1862 struct ieee80211_vif *vif, 1863 struct inet6_dev *idev) 1864 { 1865 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1866 unsigned long valid = ieee80211_vif_is_mld(vif) ? 1867 mvif->valid_links : BIT(0); 1868 struct ieee80211_bss_conf *bss_conf; 1869 int i; 1870 1871 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 1872 bss_conf = mt792x_vif_to_bss_conf(vif, i); 1873 __mt7925_ipv6_addr_change(hw, bss_conf, idev); 1874 } 1875 } 1876 1877 #endif 1878 1879 int mt7925_set_tx_sar_pwr(struct ieee80211_hw *hw, 1880 const struct cfg80211_sar_specs *sar) 1881 { 1882 struct mt76_phy *mphy = hw->priv; 1883 1884 if (sar) { 1885 int err = mt76_init_sar_power(hw, sar); 1886 1887 if (err) 1888 return err; 1889 } 1890 mt792x_init_acpi_sar_power(mt792x_hw_phy(hw), !sar); 1891 1892 return mt7925_mcu_set_rate_txpower(mphy); 1893 } 1894 1895 static int mt7925_set_sar_specs(struct ieee80211_hw *hw, 1896 const struct cfg80211_sar_specs *sar) 1897 { 1898 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1899 int err; 1900 1901 mt792x_mutex_acquire(dev); 1902 err = mt7925_mcu_set_clc(dev, dev->mt76.alpha2, 1903 dev->country_ie_env); 1904 if (err < 0) 1905 goto out; 1906 1907 err = mt7925_set_tx_sar_pwr(hw, sar); 1908 1909 out: 1910 mt792x_mutex_release(dev); 1911 return err; 1912 } 1913 1914 static void 1915 mt7925_channel_switch_beacon(struct ieee80211_hw *hw, 1916 struct ieee80211_vif *vif, 1917 struct cfg80211_chan_def *chandef) 1918 { 1919 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1920 1921 mt792x_mutex_acquire(dev); 1922 mt7925_mcu_uni_add_beacon_offload(dev, hw, vif, true); 1923 mt792x_mutex_release(dev); 1924 } 1925 1926 static int 1927 mt7925_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1928 unsigned int link_id, u16 queue, 1929 const struct ieee80211_tx_queue_params *params) 1930 { 1931 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1932 struct mt792x_bss_conf *mconf = mt792x_vif_to_link(mvif, link_id); 1933 static const u8 mq_to_aci[] = { 1934 [IEEE80211_AC_VO] = 3, 1935 [IEEE80211_AC_VI] = 2, 1936 [IEEE80211_AC_BE] = 0, 1937 [IEEE80211_AC_BK] = 1, 1938 }; 1939 1940 /* firmware uses access class index */ 1941 mconf->queue_params[mq_to_aci[queue]] = *params; 1942 1943 return 0; 1944 } 1945 1946 static int 1947 mt7925_start_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1948 struct ieee80211_bss_conf *link_conf) 1949 { 1950 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1951 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1952 int err; 1953 1954 mt792x_mutex_acquire(dev); 1955 1956 err = mt7925_mcu_add_bss_info(&dev->phy, mvif->bss_conf.mt76.ctx, 1957 link_conf, NULL, true); 1958 if (err) 1959 goto out; 1960 1961 err = mt7925_mcu_set_bss_pm(dev, link_conf, true); 1962 if (err) 1963 goto out; 1964 1965 err = mt7925_mcu_sta_update(dev, NULL, vif, 1966 &mvif->sta.deflink, true, 1967 MT76_STA_INFO_STATE_NONE); 1968 out: 1969 mt792x_mutex_release(dev); 1970 1971 return err; 1972 } 1973 1974 static void 1975 mt7925_stop_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1976 struct ieee80211_bss_conf *link_conf) 1977 { 1978 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1979 struct mt792x_dev *dev = mt792x_hw_dev(hw); 1980 int err; 1981 1982 mt792x_mutex_acquire(dev); 1983 1984 err = mt7925_mcu_set_bss_pm(dev, link_conf, false); 1985 if (err) 1986 goto out; 1987 1988 mt7925_mcu_add_bss_info(&dev->phy, mvif->bss_conf.mt76.ctx, link_conf, 1989 NULL, false); 1990 1991 out: 1992 mt792x_mutex_release(dev); 1993 } 1994 1995 static int 1996 mt7925_add_chanctx(struct ieee80211_hw *hw, 1997 struct ieee80211_chanctx_conf *ctx) 1998 { 1999 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2000 2001 dev->new_ctx = ctx; 2002 2003 return 0; 2004 } 2005 2006 static void 2007 mt7925_remove_chanctx(struct ieee80211_hw *hw, 2008 struct ieee80211_chanctx_conf *ctx) 2009 { 2010 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2011 2012 if (dev->new_ctx == ctx) 2013 dev->new_ctx = NULL; 2014 2015 } 2016 2017 static void 2018 mt7925_change_chanctx(struct ieee80211_hw *hw, 2019 struct ieee80211_chanctx_conf *ctx, 2020 u32 changed) 2021 { 2022 struct mt792x_chanctx *mctx = (struct mt792x_chanctx *)ctx->drv_priv; 2023 struct mt792x_phy *phy = mt792x_hw_phy(hw); 2024 struct mt792x_bss_conf *mconf; 2025 struct ieee80211_vif *vif; 2026 struct mt792x_vif *mvif; 2027 2028 if (!mctx->bss_conf) 2029 return; 2030 2031 mconf = mctx->bss_conf; 2032 mvif = mconf->vif; 2033 vif = container_of((void *)mvif, struct ieee80211_vif, drv_priv); 2034 2035 mt792x_mutex_acquire(phy->dev); 2036 if (vif->type == NL80211_IFTYPE_MONITOR) { 2037 mt7925_mcu_set_sniffer(mvif->phy->dev, vif, true); 2038 mt7925_mcu_config_sniffer(mvif, ctx); 2039 } else { 2040 if (ieee80211_vif_is_mld(vif)) { 2041 unsigned long valid = mvif->valid_links; 2042 u8 i; 2043 2044 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 2045 mconf = mt792x_vif_to_link(mvif, i); 2046 if (mconf && mconf->mt76.ctx == ctx) 2047 break; 2048 } 2049 2050 } else { 2051 mconf = &mvif->bss_conf; 2052 } 2053 2054 if (mconf) { 2055 struct ieee80211_bss_conf *link_conf; 2056 2057 link_conf = mt792x_vif_to_bss_conf(vif, mconf->link_id); 2058 mt7925_mcu_set_chctx(mvif->phy->mt76, &mconf->mt76, 2059 link_conf, ctx); 2060 2061 if (changed & IEEE80211_CHANCTX_CHANGE_PUNCTURING) 2062 mt7925_mcu_set_eht_pp(mvif->phy->mt76, &mconf->mt76, 2063 link_conf, ctx); 2064 } 2065 } 2066 2067 mt792x_mutex_release(phy->dev); 2068 } 2069 2070 static void mt7925_mgd_prepare_tx(struct ieee80211_hw *hw, 2071 struct ieee80211_vif *vif, 2072 struct ieee80211_prep_tx_info *info) 2073 { 2074 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2075 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2076 u16 duration = info->duration ? info->duration : 2077 jiffies_to_msecs(HZ); 2078 2079 mt792x_mutex_acquire(dev); 2080 mt7925_set_roc(mvif->phy, &mvif->bss_conf, 2081 mvif->bss_conf.mt76.ctx->def.chan, duration, 2082 MT7925_ROC_REQ_JOIN); 2083 mt792x_mutex_release(dev); 2084 } 2085 2086 static void mt7925_mgd_complete_tx(struct ieee80211_hw *hw, 2087 struct ieee80211_vif *vif, 2088 struct ieee80211_prep_tx_info *info) 2089 { 2090 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2091 2092 mt7925_abort_roc(mvif->phy, &mvif->bss_conf); 2093 } 2094 2095 static void mt7925_vif_cfg_changed(struct ieee80211_hw *hw, 2096 struct ieee80211_vif *vif, 2097 u64 changed) 2098 { 2099 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2100 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2101 unsigned long valid = ieee80211_vif_is_mld(vif) ? 2102 mvif->valid_links : BIT(0); 2103 struct ieee80211_bss_conf *bss_conf; 2104 int i; 2105 2106 mt792x_mutex_acquire(dev); 2107 2108 if (changed & BSS_CHANGED_ASSOC) { 2109 mt7925_mcu_sta_update(dev, NULL, vif, 2110 &mvif->sta.deflink, true, 2111 MT76_STA_INFO_STATE_ASSOC); 2112 mt7925_mcu_set_beacon_filter(dev, vif, vif->cfg.assoc); 2113 2114 if (ieee80211_vif_is_mld(vif)) 2115 mvif->mlo_pm_state = MT792x_MLO_LINK_ASSOC; 2116 } 2117 2118 if (changed & BSS_CHANGED_ARP_FILTER) { 2119 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 2120 bss_conf = mt792x_vif_to_bss_conf(vif, i); 2121 mt7925_mcu_update_arp_filter(&dev->mt76, bss_conf); 2122 } 2123 } 2124 2125 if (changed & BSS_CHANGED_PS) { 2126 if (hweight16(mvif->valid_links) < 2) { 2127 /* legacy */ 2128 bss_conf = &vif->bss_conf; 2129 mt7925_mcu_uni_bss_ps(dev, bss_conf); 2130 } else { 2131 if (mvif->mlo_pm_state == MT792x_MLO_LINK_ASSOC) { 2132 mvif->mlo_pm_state = MT792x_MLO_CHANGED_PS_PENDING; 2133 } else if (mvif->mlo_pm_state == MT792x_MLO_CHANGED_PS) { 2134 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 2135 bss_conf = mt792x_vif_to_bss_conf(vif, i); 2136 mt7925_mcu_uni_bss_ps(dev, bss_conf); 2137 } 2138 } 2139 } 2140 } 2141 2142 mt792x_mutex_release(dev); 2143 2144 if (vif->type == NL80211_IFTYPE_NAN && 2145 changed & BSS_CHANGED_NAN_LOCAL_SCHED) { 2146 mt7925_nan_local_sched_changed(dev, vif); 2147 } 2148 } 2149 2150 static void mt7925_link_info_changed(struct ieee80211_hw *hw, 2151 struct ieee80211_vif *vif, 2152 struct ieee80211_bss_conf *info, 2153 u64 changed) 2154 { 2155 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2156 struct mt792x_phy *phy = mt792x_hw_phy(hw); 2157 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2158 struct mt792x_bss_conf *mconf; 2159 2160 mconf = mt792x_vif_to_link(mvif, info->link_id); 2161 2162 mt792x_mutex_acquire(dev); 2163 2164 if (changed & BSS_CHANGED_ERP_SLOT) { 2165 int slottime = info->use_short_slot ? 9 : 20; 2166 2167 if (slottime != phy->slottime) { 2168 phy->slottime = slottime; 2169 mt7925_mcu_set_timing(phy, info); 2170 } 2171 } 2172 2173 if (changed & BSS_CHANGED_MCAST_RATE) 2174 mconf->mt76.mcast_rates_idx = 2175 mt7925_get_rates_table(hw, vif, false, true); 2176 2177 if (changed & BSS_CHANGED_BASIC_RATES) 2178 mconf->mt76.basic_rates_idx = 2179 mt7925_get_rates_table(hw, vif, false, false); 2180 2181 if (changed & (BSS_CHANGED_BEACON | 2182 BSS_CHANGED_BEACON_ENABLED)) { 2183 mconf->mt76.beacon_rates_idx = 2184 mt7925_get_rates_table(hw, vif, true, false); 2185 2186 mt7925_mcu_uni_add_beacon_offload(dev, hw, vif, 2187 info->enable_beacon); 2188 } 2189 2190 /* ensure that enable txcmd_mode after bss_info */ 2191 if (changed & (BSS_CHANGED_QOS | BSS_CHANGED_BEACON_ENABLED)) 2192 mt7925_mcu_set_tx(dev, info); 2193 2194 if (mvif->mlo_pm_state == MT792x_MLO_CHANGED_PS_PENDING) { 2195 /* Indicate the secondary setup done */ 2196 mt7925_mcu_uni_bss_bcnft(dev, info, true); 2197 2198 ieee80211_queue_delayed_work(hw, &dev->mlo_pm_work, 5 * HZ); 2199 mvif->mlo_pm_state = MT792x_MLO_CHANGED_PS; 2200 } 2201 2202 if (changed & BSS_CHANGED_CQM) 2203 mt7925_mcu_set_rssimonitor(dev, vif); 2204 2205 mt792x_mutex_release(dev); 2206 } 2207 2208 static int 2209 mt7925_change_vif_links(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2210 u16 old_links, u16 new_links, 2211 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 2212 { 2213 struct mt792x_bss_conf *mconfs[IEEE80211_MLD_MAX_NUM_LINKS] = {}, *mconf; 2214 struct mt792x_link_sta *mlinks[IEEE80211_MLD_MAX_NUM_LINKS] = {}, *mlink; 2215 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2216 unsigned long add = new_links & ~old_links; 2217 unsigned long rem = old_links & ~new_links; 2218 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2219 struct mt792x_phy *phy = mt792x_hw_phy(hw); 2220 struct ieee80211_bss_conf *link_conf; 2221 unsigned int link_id; 2222 int err; 2223 2224 if (old_links == new_links) 2225 return 0; 2226 2227 mt792x_mutex_acquire(dev); 2228 2229 for_each_set_bit(link_id, &rem, IEEE80211_MLD_MAX_NUM_LINKS) { 2230 mconf = mt792x_vif_to_link(mvif, link_id); 2231 mlink = mt792x_sta_to_link(&mvif->sta, link_id); 2232 2233 if (!mconf || !mlink) 2234 continue; 2235 2236 if (mconf != &mvif->bss_conf) { 2237 mt792x_mac_link_bss_remove(dev, mconf, mlink); 2238 devm_kfree(dev->mt76.dev, mconf); 2239 devm_kfree(dev->mt76.dev, mlink); 2240 } 2241 2242 rcu_assign_pointer(mvif->link_conf[link_id], NULL); 2243 rcu_assign_pointer(mvif->sta.link[link_id], NULL); 2244 } 2245 2246 for_each_set_bit(link_id, &add, IEEE80211_MLD_MAX_NUM_LINKS) { 2247 if (!old_links) { 2248 mvif->deflink_id = link_id; 2249 mconf = &mvif->bss_conf; 2250 mlink = &mvif->sta.deflink; 2251 } else { 2252 mconf = devm_kzalloc(dev->mt76.dev, sizeof(*mconf), 2253 GFP_KERNEL); 2254 mlink = devm_kzalloc(dev->mt76.dev, sizeof(*mlink), 2255 GFP_KERNEL); 2256 if (!mconf || !mlink) { 2257 mt792x_mutex_release(dev); 2258 return -ENOMEM; 2259 } 2260 } 2261 2262 mconfs[link_id] = mconf; 2263 mlinks[link_id] = mlink; 2264 mconf->link_id = link_id; 2265 mconf->vif = mvif; 2266 mlink->wcid.link_id = link_id; 2267 mlink->wcid.link_valid = !!vif->valid_links; 2268 mlink->wcid.def_wcid = &mvif->sta.deflink.wcid; 2269 } 2270 2271 if (hweight16(mvif->valid_links) == 0) 2272 mt792x_mac_link_bss_remove(dev, &mvif->bss_conf, 2273 &mvif->sta.deflink); 2274 2275 for_each_set_bit(link_id, &add, IEEE80211_MLD_MAX_NUM_LINKS) { 2276 mconf = mconfs[link_id]; 2277 mlink = mlinks[link_id]; 2278 link_conf = mt792x_vif_to_bss_conf(vif, link_id); 2279 2280 rcu_assign_pointer(mvif->link_conf[link_id], mconf); 2281 rcu_assign_pointer(mvif->sta.link[link_id], mlink); 2282 2283 err = mt7925_mac_link_bss_add(dev, link_conf, mlink); 2284 if (err < 0) 2285 goto free; 2286 2287 if (mconf != &mvif->bss_conf) { 2288 err = mt7925_set_mlo_roc(phy, &mvif->bss_conf, 2289 vif->active_links); 2290 if (err < 0) 2291 goto free; 2292 } 2293 } 2294 2295 mvif->valid_links = new_links; 2296 2297 /* Restore the legacy BSS after disabling MLO */ 2298 if (old_links && !new_links) { 2299 mt792x_mac_link_bss_remove(dev, &mvif->bss_conf, 2300 &mvif->sta.deflink); 2301 err = mt7925_mac_link_bss_add(dev, &vif->bss_conf, 2302 &mvif->sta.deflink); 2303 if (err < 0) { 2304 mt792x_mutex_release(dev); 2305 return err; 2306 } 2307 } 2308 2309 mt792x_mutex_release(dev); 2310 2311 return 0; 2312 2313 free: 2314 for_each_set_bit(link_id, &add, IEEE80211_MLD_MAX_NUM_LINKS) { 2315 rcu_assign_pointer(mvif->link_conf[link_id], NULL); 2316 rcu_assign_pointer(mvif->sta.link[link_id], NULL); 2317 2318 if (mconfs[link_id] != &mvif->bss_conf) 2319 devm_kfree(dev->mt76.dev, mconfs[link_id]); 2320 if (mlinks[link_id] != &mvif->sta.deflink) 2321 devm_kfree(dev->mt76.dev, mlinks[link_id]); 2322 } 2323 2324 mt792x_mutex_release(dev); 2325 2326 return err; 2327 } 2328 2329 static int 2330 mt7925_change_sta_links(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 2331 struct ieee80211_sta *sta, u16 old_links, u16 new_links) 2332 { 2333 unsigned long add = new_links & ~old_links; 2334 unsigned long rem = old_links & ~new_links; 2335 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2336 int err = 0; 2337 2338 if (old_links == new_links) 2339 return 0; 2340 2341 mt792x_mutex_acquire(dev); 2342 2343 err = mt7925_mac_sta_remove_links(dev, vif, sta, rem); 2344 if (err < 0) 2345 goto out; 2346 2347 err = mt7925_mac_sta_add_links(dev, vif, sta, add); 2348 if (err < 0) 2349 goto out; 2350 2351 out: 2352 mt792x_mutex_release(dev); 2353 2354 return err; 2355 } 2356 2357 static int 2358 mt7927_reconfig_band(struct mt792x_dev *dev, struct ieee80211_vif *vif, 2359 struct ieee80211_bss_conf *link_conf, 2360 struct mt792x_bss_conf *mconf, 2361 u8 band_idx) 2362 { 2363 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2364 struct mt792x_link_sta *mlink = &mvif->sta.deflink; 2365 int ret; 2366 2367 ret = mt76_connac_mcu_uni_add_dev(&dev->mphy, link_conf, 2368 &mconf->mt76, &mlink->wcid, 2369 false); 2370 if (ret) 2371 return ret; 2372 2373 mconf->mt76.band_idx = band_idx; 2374 2375 return mt76_connac_mcu_uni_add_dev(&dev->mphy, link_conf, 2376 &mconf->mt76, &mlink->wcid, 2377 true); 2378 } 2379 2380 static int mt7925_assign_vif_chanctx(struct ieee80211_hw *hw, 2381 struct ieee80211_vif *vif, 2382 struct ieee80211_bss_conf *link_conf, 2383 struct ieee80211_chanctx_conf *ctx) 2384 { 2385 struct mt792x_chanctx *mctx = (struct mt792x_chanctx *)ctx->drv_priv; 2386 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2387 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2388 struct ieee80211_bss_conf *pri_link_conf; 2389 struct mt792x_bss_conf *mconf; 2390 u8 band_idx; 2391 2392 mutex_lock(&dev->mt76.mutex); 2393 2394 if (ieee80211_vif_is_mld(vif)) { 2395 mconf = mt792x_vif_to_link(mvif, link_conf->link_id); 2396 pri_link_conf = mt792x_vif_to_bss_conf(vif, mvif->deflink_id); 2397 2398 if (vif->type == NL80211_IFTYPE_STATION && 2399 mconf == &mvif->bss_conf) 2400 mt7925_mcu_add_bss_info(&dev->phy, NULL, pri_link_conf, 2401 NULL, true); 2402 } else { 2403 mconf = &mvif->bss_conf; 2404 2405 if (is_mt7927(&dev->mt76)) { 2406 band_idx = mt7927_band_idx(ctx->def.chan->band); 2407 2408 mt7927_reconfig_band(dev, vif, link_conf, mconf, band_idx); 2409 } 2410 } 2411 2412 mconf->mt76.ctx = ctx; 2413 mctx->bss_conf = mconf; 2414 mutex_unlock(&dev->mt76.mutex); 2415 2416 return 0; 2417 } 2418 2419 static void mt7925_unassign_vif_chanctx(struct ieee80211_hw *hw, 2420 struct ieee80211_vif *vif, 2421 struct ieee80211_bss_conf *link_conf, 2422 struct ieee80211_chanctx_conf *ctx) 2423 { 2424 struct mt792x_chanctx *mctx = (struct mt792x_chanctx *)ctx->drv_priv; 2425 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2426 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2427 struct mt792x_bss_conf *mconf; 2428 2429 mutex_lock(&dev->mt76.mutex); 2430 2431 if (ieee80211_vif_is_mld(vif)) { 2432 mconf = mt792x_vif_to_link(mvif, link_conf->link_id); 2433 2434 if (vif->type == NL80211_IFTYPE_STATION && 2435 mconf == &mvif->bss_conf) 2436 mt7925_mcu_add_bss_info(&dev->phy, NULL, link_conf, 2437 NULL, false); 2438 } else { 2439 mconf = &mvif->bss_conf; 2440 } 2441 2442 mctx->bss_conf = NULL; 2443 mconf->mt76.ctx = NULL; 2444 mutex_unlock(&dev->mt76.mutex); 2445 2446 if (link_conf->csa_active) { 2447 timer_delete_sync(&mvif->csa_timer); 2448 cancel_work_sync(&mvif->csa_work); 2449 } 2450 } 2451 2452 static void mt7925_rfkill_poll(struct ieee80211_hw *hw) 2453 { 2454 struct mt792x_phy *phy = mt792x_hw_phy(hw); 2455 int ret; 2456 2457 mt792x_mutex_acquire(phy->dev); 2458 ret = mt7925_mcu_wf_rf_pin_ctrl(phy); 2459 mt792x_mutex_release(phy->dev); 2460 2461 wiphy_rfkill_set_hw_state(hw->wiphy, ret == 0); 2462 } 2463 2464 static int mt7925_switch_vif_chanctx(struct ieee80211_hw *hw, 2465 struct ieee80211_vif_chanctx_switch *vifs, 2466 int n_vifs, 2467 enum ieee80211_chanctx_switch_mode mode) 2468 { 2469 return mt7925_assign_vif_chanctx(hw, vifs->vif, vifs->link_conf, 2470 vifs->new_ctx); 2471 } 2472 2473 void mt7925_csa_work(struct work_struct *work) 2474 { 2475 struct mt792x_vif *mvif; 2476 struct mt792x_dev *dev; 2477 struct ieee80211_vif *vif; 2478 struct ieee80211_bss_conf *link_conf; 2479 struct mt792x_bss_conf *mconf; 2480 u8 link_id, roc_rtype; 2481 int ret = 0; 2482 2483 mvif = (struct mt792x_vif *)container_of(work, struct mt792x_vif, 2484 csa_work); 2485 dev = mvif->phy->dev; 2486 vif = container_of((void *)mvif, struct ieee80211_vif, drv_priv); 2487 2488 if (ieee80211_vif_is_mld(vif)) 2489 return; 2490 2491 if (!dev->new_ctx) 2492 return; 2493 2494 link_id = 0; 2495 mconf = &mvif->bss_conf; 2496 link_conf = &vif->bss_conf; 2497 roc_rtype = MT7925_ROC_REQ_JOIN; 2498 2499 mt792x_mutex_acquire(dev); 2500 ret = mt7925_set_roc(mvif->phy, mconf, dev->new_ctx->def.chan, 2501 4000, roc_rtype); 2502 mt792x_mutex_release(dev); 2503 if (!ret) { 2504 mt792x_mutex_acquire(dev); 2505 ret = mt7925_mcu_set_chctx(mvif->phy->mt76, &mconf->mt76, link_conf, 2506 dev->new_ctx); 2507 mt792x_mutex_release(dev); 2508 2509 mt7925_abort_roc(mvif->phy, mconf); 2510 } 2511 2512 ieee80211_chswitch_done(vif, !ret, link_id); 2513 } 2514 2515 static int mt7925_pre_channel_switch(struct ieee80211_hw *hw, 2516 struct ieee80211_vif *vif, 2517 struct ieee80211_channel_switch *chsw) 2518 { 2519 if (ieee80211_vif_is_mld(vif)) 2520 return -EOPNOTSUPP; 2521 2522 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) 2523 return -EOPNOTSUPP; 2524 2525 if (!cfg80211_chandef_usable(hw->wiphy, &chsw->chandef, 2526 IEEE80211_CHAN_DISABLED)) 2527 return -EOPNOTSUPP; 2528 2529 return 0; 2530 } 2531 2532 static void mt7925_channel_switch(struct ieee80211_hw *hw, 2533 struct ieee80211_vif *vif, 2534 struct ieee80211_channel_switch *chsw) 2535 { 2536 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2537 u16 beacon_interval; 2538 2539 if (ieee80211_vif_is_mld(vif)) 2540 return; 2541 2542 beacon_interval = vif->bss_conf.beacon_int; 2543 2544 mvif->csa_timer.expires = TU_TO_EXP_TIME(beacon_interval * chsw->count); 2545 add_timer(&mvif->csa_timer); 2546 } 2547 2548 static void mt7925_abort_channel_switch(struct ieee80211_hw *hw, 2549 struct ieee80211_vif *vif, 2550 struct ieee80211_bss_conf *link_conf) 2551 { 2552 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2553 2554 timer_delete_sync(&mvif->csa_timer); 2555 cancel_work_sync(&mvif->csa_work); 2556 } 2557 2558 static void mt7925_channel_switch_rx_beacon(struct ieee80211_hw *hw, 2559 struct ieee80211_vif *vif, 2560 struct ieee80211_channel_switch *chsw) 2561 { 2562 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2563 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2564 u16 beacon_interval; 2565 2566 if (ieee80211_vif_is_mld(vif)) 2567 return; 2568 2569 if (!dev->new_ctx) 2570 return; 2571 2572 beacon_interval = vif->bss_conf.beacon_int; 2573 2574 if (cfg80211_chandef_identical(&chsw->chandef, 2575 &dev->new_ctx->def) && 2576 chsw->count) { 2577 mod_timer(&mvif->csa_timer, 2578 TU_TO_EXP_TIME(beacon_interval * chsw->count)); 2579 } 2580 } 2581 2582 static int mt7925_start_nan(struct ieee80211_hw *hw, 2583 struct ieee80211_vif *vif, 2584 struct cfg80211_nan_conf *conf) 2585 { 2586 struct ieee80211_bss_conf *link_conf = &vif->bss_conf; 2587 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2588 struct ieee80211_channel *chan; 2589 int err = 0; 2590 2591 mt792x_mutex_acquire(dev); 2592 2593 chan = conf->band_cfgs[NL80211_BAND_2GHZ].chan; 2594 if (!chan) { 2595 err = -EINVAL; 2596 goto out; 2597 } 2598 2599 cfg80211_chandef_create(&link_conf->chanreq.oper, chan, 2600 NL80211_CHAN_NO_HT); 2601 2602 err = mt7925_mcu_add_bss_info(&dev->phy, NULL, link_conf, 2603 NULL, true); 2604 if (err < 0) 2605 goto out; 2606 2607 dev->nan_vif = vif; 2608 2609 err = mt7925_nan_set_nmi_addr(dev, vif->addr); 2610 if (err) 2611 goto rollback_bss; 2612 2613 err = mt7925_nan_enable(vif, dev, conf); 2614 if (err) 2615 goto rollback_bss; 2616 2617 goto out; 2618 2619 rollback_bss: 2620 dev->nan_vif = NULL; 2621 mt7925_mcu_add_bss_info(&dev->phy, NULL, link_conf, NULL, false); 2622 2623 out: 2624 mt792x_mutex_release(dev); 2625 2626 return err; 2627 } 2628 2629 static int mt7925_stop_nan(struct ieee80211_hw *hw, 2630 struct ieee80211_vif *vif) 2631 { 2632 struct ieee80211_bss_conf *link_conf = &vif->bss_conf; 2633 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2634 int err, ret; 2635 2636 mt792x_mutex_acquire(dev); 2637 2638 err = mt7925_nan_disable(vif, dev); 2639 2640 ret = mt7925_mcu_add_bss_info(&dev->phy, NULL, link_conf, 2641 NULL, false); 2642 if (!err) 2643 err = ret; 2644 2645 if (dev->nan_vif == vif) 2646 dev->nan_vif = NULL; 2647 2648 mt792x_mutex_release(dev); 2649 2650 return err; 2651 } 2652 2653 static int mt7925_nan_change_conf(struct ieee80211_hw *hw, 2654 struct ieee80211_vif *vif, 2655 struct cfg80211_nan_conf *conf, 2656 u32 changes) 2657 { 2658 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2659 int err = 0; 2660 2661 mt792x_mutex_acquire(dev); 2662 2663 err = mt7925_nan_change_configure(vif, dev, conf); 2664 2665 mt792x_mutex_release(dev); 2666 2667 return err; 2668 } 2669 2670 static int mt7925_nan_peer_sched_changed(struct ieee80211_hw *hw, 2671 struct ieee80211_sta *sta) 2672 { 2673 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2674 int err = 0; 2675 2676 mt792x_mutex_acquire(dev); 2677 2678 err = mt792x_nan_set_peer_schedule(dev, sta); 2679 2680 mt792x_mutex_release(dev); 2681 2682 return err; 2683 } 2684 2685 static void mt7925_sta_pre_rcu_remove(struct ieee80211_hw *hw, 2686 struct ieee80211_vif *vif, 2687 struct ieee80211_sta *sta) 2688 { 2689 struct mt76_phy *phy = hw->priv; 2690 struct mt76_dev *dev = phy->dev; 2691 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 2692 2693 mutex_lock(&dev->mutex); 2694 spin_lock_bh(&dev->status_lock); 2695 2696 if (ieee80211_vif_is_mld(vif)) { 2697 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 2698 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 2699 unsigned long valid = mvif->valid_links; 2700 struct mt792x_link_sta *mlink; 2701 unsigned int link_id; 2702 2703 for_each_set_bit(link_id, &valid, IEEE80211_MLD_MAX_NUM_LINKS) { 2704 mlink = mt792x_sta_to_link(msta, link_id); 2705 if (!mlink || !mlink->wcid.sta) 2706 continue; 2707 if (mlink->wcid.idx < ARRAY_SIZE(dev->wcid)) 2708 rcu_assign_pointer(dev->wcid[mlink->wcid.idx], 2709 NULL); 2710 } 2711 } else { 2712 rcu_assign_pointer(dev->wcid[wcid->idx], NULL); 2713 } 2714 2715 spin_unlock_bh(&dev->status_lock); 2716 mutex_unlock(&dev->mutex); 2717 } 2718 2719 static void mt7925_stop(struct ieee80211_hw *hw, bool suspend) 2720 { 2721 struct mt792x_dev *dev = mt792x_hw_dev(hw); 2722 2723 cancel_delayed_work_sync(&dev->mlo_pm_work); 2724 2725 mt792x_stop(hw, suspend); 2726 } 2727 2728 const struct ieee80211_ops mt7925_ops = { 2729 .tx = mt792x_tx, 2730 .start = mt7925_start, 2731 .stop = mt7925_stop, 2732 .add_interface = mt7925_add_interface, 2733 .remove_interface = mt7925_remove_interface, 2734 .config = mt7925_config, 2735 .conf_tx = mt7925_conf_tx, 2736 .configure_filter = mt7925_configure_filter, 2737 .start_ap = mt7925_start_ap, 2738 .stop_ap = mt7925_stop_ap, 2739 .sta_state = mt76_sta_state, 2740 .sta_pre_rcu_remove = mt7925_sta_pre_rcu_remove, 2741 .set_key = mt7925_set_key, 2742 .sta_set_decap_offload = mt7925_sta_set_decap_offload, 2743 #if IS_ENABLED(CONFIG_IPV6) 2744 .ipv6_addr_change = mt7925_ipv6_addr_change, 2745 #endif /* CONFIG_IPV6 */ 2746 .ampdu_action = mt7925_ampdu_action, 2747 .set_rts_threshold = mt7925_set_rts_threshold, 2748 .wake_tx_queue = mt76_wake_tx_queue, 2749 .release_buffered_frames = mt76_release_buffered_frames, 2750 .channel_switch_beacon = mt7925_channel_switch_beacon, 2751 .get_txpower = mt792x_get_txpower, 2752 .get_stats = mt792x_get_stats, 2753 .get_et_sset_count = mt792x_get_et_sset_count, 2754 .get_et_strings = mt792x_get_et_strings, 2755 .get_et_stats = mt792x_get_et_stats, 2756 .get_tsf = mt792x_get_tsf, 2757 .set_tsf = mt792x_set_tsf, 2758 .get_survey = mt76_get_survey, 2759 .get_antenna = mt76_get_antenna, 2760 .set_antenna = mt7925_set_antenna, 2761 .set_coverage_class = mt792x_set_coverage_class, 2762 .hw_scan = mt7925_hw_scan, 2763 .cancel_hw_scan = mt7925_cancel_hw_scan, 2764 .sta_statistics = mt792x_sta_statistics, 2765 .sched_scan_start = mt7925_start_sched_scan, 2766 .sched_scan_stop = mt7925_stop_sched_scan, 2767 CFG80211_TESTMODE_CMD(mt7925_testmode_cmd) 2768 CFG80211_TESTMODE_DUMP(mt7925_testmode_dump) 2769 #ifdef CONFIG_PM 2770 .suspend = mt7925_suspend, 2771 .resume = mt7925_resume, 2772 .set_wakeup = mt792x_set_wakeup, 2773 .set_rekey_data = mt7925_set_rekey_data, 2774 #endif /* CONFIG_PM */ 2775 .flush = mt792x_flush, 2776 .set_sar_specs = mt7925_set_sar_specs, 2777 .remain_on_channel = mt7925_remain_on_channel, 2778 .cancel_remain_on_channel = mt7925_cancel_remain_on_channel, 2779 .add_chanctx = mt7925_add_chanctx, 2780 .remove_chanctx = mt7925_remove_chanctx, 2781 .change_chanctx = mt7925_change_chanctx, 2782 .assign_vif_chanctx = mt7925_assign_vif_chanctx, 2783 .unassign_vif_chanctx = mt7925_unassign_vif_chanctx, 2784 .mgd_prepare_tx = mt7925_mgd_prepare_tx, 2785 .mgd_complete_tx = mt7925_mgd_complete_tx, 2786 .vif_cfg_changed = mt7925_vif_cfg_changed, 2787 .link_info_changed = mt7925_link_info_changed, 2788 .change_vif_links = mt7925_change_vif_links, 2789 .change_sta_links = mt7925_change_sta_links, 2790 .rfkill_poll = mt7925_rfkill_poll, 2791 2792 .switch_vif_chanctx = mt7925_switch_vif_chanctx, 2793 .pre_channel_switch = mt7925_pre_channel_switch, 2794 .channel_switch = mt7925_channel_switch, 2795 .abort_channel_switch = mt7925_abort_channel_switch, 2796 .channel_switch_rx_beacon = mt7925_channel_switch_rx_beacon, 2797 .start_nan = mt7925_start_nan, 2798 .stop_nan = mt7925_stop_nan, 2799 .nan_change_conf = mt7925_nan_change_conf, 2800 .nan_peer_sched_changed = mt7925_nan_peer_sched_changed, 2801 }; 2802 EXPORT_SYMBOL_GPL(mt7925_ops); 2803 2804 MODULE_AUTHOR("Deren Wu <deren.wu@mediatek.com>"); 2805 MODULE_DESCRIPTION("MediaTek MT7925 core driver"); 2806 MODULE_LICENSE("Dual BSD/GPL"); 2807