1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2017 Intel Deutschland GmbH 4 * Copyright (C) 2018-2023 Intel Corporation 5 */ 6 #include "rs.h" 7 #include "fw-api.h" 8 #include "sta.h" 9 #include "iwl-op-mode.h" 10 #include "mvm.h" 11 12 static u8 rs_fw_bw_from_sta_bw(const struct ieee80211_link_sta *link_sta) 13 { 14 switch (link_sta->bandwidth) { 15 case IEEE80211_STA_RX_BW_320: 16 return IWL_TLC_MNG_CH_WIDTH_320MHZ; 17 case IEEE80211_STA_RX_BW_160: 18 return IWL_TLC_MNG_CH_WIDTH_160MHZ; 19 case IEEE80211_STA_RX_BW_80: 20 return IWL_TLC_MNG_CH_WIDTH_80MHZ; 21 case IEEE80211_STA_RX_BW_40: 22 return IWL_TLC_MNG_CH_WIDTH_40MHZ; 23 case IEEE80211_STA_RX_BW_20: 24 default: 25 return IWL_TLC_MNG_CH_WIDTH_20MHZ; 26 } 27 } 28 29 static u8 rs_fw_set_active_chains(u8 chains) 30 { 31 u8 fw_chains = 0; 32 33 if (chains & ANT_A) 34 fw_chains |= IWL_TLC_MNG_CHAIN_A_MSK; 35 if (chains & ANT_B) 36 fw_chains |= IWL_TLC_MNG_CHAIN_B_MSK; 37 38 return fw_chains; 39 } 40 41 static u8 rs_fw_sgi_cw_support(struct ieee80211_link_sta *link_sta) 42 { 43 struct ieee80211_sta_ht_cap *ht_cap = &link_sta->ht_cap; 44 struct ieee80211_sta_vht_cap *vht_cap = &link_sta->vht_cap; 45 struct ieee80211_sta_he_cap *he_cap = &link_sta->he_cap; 46 u8 supp = 0; 47 48 if (he_cap->has_he) 49 return 0; 50 51 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20) 52 supp |= BIT(IWL_TLC_MNG_CH_WIDTH_20MHZ); 53 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40) 54 supp |= BIT(IWL_TLC_MNG_CH_WIDTH_40MHZ); 55 if (vht_cap->cap & IEEE80211_VHT_CAP_SHORT_GI_80) 56 supp |= BIT(IWL_TLC_MNG_CH_WIDTH_80MHZ); 57 if (vht_cap->cap & IEEE80211_VHT_CAP_SHORT_GI_160) 58 supp |= BIT(IWL_TLC_MNG_CH_WIDTH_160MHZ); 59 60 return supp; 61 } 62 63 static u16 rs_fw_get_config_flags(struct iwl_mvm *mvm, 64 struct ieee80211_vif *vif, 65 struct ieee80211_link_sta *link_sta, 66 const struct ieee80211_sta_he_cap *sband_he_cap) 67 { 68 struct ieee80211_sta_ht_cap *ht_cap = &link_sta->ht_cap; 69 struct ieee80211_sta_vht_cap *vht_cap = &link_sta->vht_cap; 70 struct ieee80211_sta_he_cap *he_cap = &link_sta->he_cap; 71 bool vht_ena = vht_cap->vht_supported; 72 u16 flags = 0; 73 74 /* get STBC flags */ 75 if (mvm->cfg->ht_params->stbc && 76 (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1)) { 77 if (he_cap->has_he && he_cap->he_cap_elem.phy_cap_info[2] & 78 IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ) 79 flags |= IWL_TLC_MNG_CFG_FLAGS_STBC_MSK; 80 else if (vht_cap->cap & IEEE80211_VHT_CAP_RXSTBC_MASK) 81 flags |= IWL_TLC_MNG_CFG_FLAGS_STBC_MSK; 82 else if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) 83 flags |= IWL_TLC_MNG_CFG_FLAGS_STBC_MSK; 84 } 85 86 if (mvm->cfg->ht_params->ldpc && 87 ((ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) || 88 (vht_ena && (vht_cap->cap & IEEE80211_VHT_CAP_RXLDPC)))) 89 flags |= IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK; 90 91 /* consider LDPC support in case of HE */ 92 if (he_cap->has_he && (he_cap->he_cap_elem.phy_cap_info[1] & 93 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD)) 94 flags |= IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK; 95 96 if (sband_he_cap && 97 !(sband_he_cap->he_cap_elem.phy_cap_info[1] & 98 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD)) 99 flags &= ~IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK; 100 101 if (he_cap->has_he && 102 (he_cap->he_cap_elem.phy_cap_info[3] & 103 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK && 104 sband_he_cap && 105 sband_he_cap->he_cap_elem.phy_cap_info[3] & 106 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK)) 107 flags |= IWL_TLC_MNG_CFG_FLAGS_HE_DCM_NSS_1_MSK; 108 109 return flags; 110 } 111 112 static 113 int rs_fw_vht_highest_rx_mcs_index(const struct ieee80211_sta_vht_cap *vht_cap, 114 int nss) 115 { 116 u16 rx_mcs = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) & 117 (0x3 << (2 * (nss - 1))); 118 rx_mcs >>= (2 * (nss - 1)); 119 120 switch (rx_mcs) { 121 case IEEE80211_VHT_MCS_SUPPORT_0_7: 122 return IWL_TLC_MNG_HT_RATE_MCS7; 123 case IEEE80211_VHT_MCS_SUPPORT_0_8: 124 return IWL_TLC_MNG_HT_RATE_MCS8; 125 case IEEE80211_VHT_MCS_SUPPORT_0_9: 126 return IWL_TLC_MNG_HT_RATE_MCS9; 127 default: 128 WARN_ON_ONCE(1); 129 break; 130 } 131 132 return 0; 133 } 134 135 static void 136 rs_fw_vht_set_enabled_rates(const struct ieee80211_link_sta *link_sta, 137 const struct ieee80211_sta_vht_cap *vht_cap, 138 struct iwl_tlc_config_cmd_v4 *cmd) 139 { 140 u16 supp; 141 int i, highest_mcs; 142 u8 max_nss = link_sta->rx_nss; 143 struct ieee80211_vht_cap ieee_vht_cap = { 144 .vht_cap_info = cpu_to_le32(vht_cap->cap), 145 .supp_mcs = vht_cap->vht_mcs, 146 }; 147 148 /* the station support only a single receive chain */ 149 if (link_sta->smps_mode == IEEE80211_SMPS_STATIC) 150 max_nss = 1; 151 152 for (i = 0; i < max_nss && i < IWL_TLC_NSS_MAX; i++) { 153 int nss = i + 1; 154 155 highest_mcs = rs_fw_vht_highest_rx_mcs_index(vht_cap, nss); 156 if (!highest_mcs) 157 continue; 158 159 supp = BIT(highest_mcs + 1) - 1; 160 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_20) 161 supp &= ~BIT(IWL_TLC_MNG_HT_RATE_MCS9); 162 163 cmd->ht_rates[i][IWL_TLC_MCS_PER_BW_80] = cpu_to_le16(supp); 164 /* 165 * Check if VHT extended NSS indicates that the bandwidth/NSS 166 * configuration is supported - only for MCS 0 since we already 167 * decoded the MCS bits anyway ourselves. 168 */ 169 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_160 && 170 ieee80211_get_vht_max_nss(&ieee_vht_cap, 171 IEEE80211_VHT_CHANWIDTH_160MHZ, 172 0, true, nss) >= nss) 173 cmd->ht_rates[i][IWL_TLC_MCS_PER_BW_160] = 174 cmd->ht_rates[i][IWL_TLC_MCS_PER_BW_80]; 175 } 176 } 177 178 static u16 rs_fw_he_ieee80211_mcs_to_rs_mcs(u16 mcs) 179 { 180 switch (mcs) { 181 case IEEE80211_HE_MCS_SUPPORT_0_7: 182 return BIT(IWL_TLC_MNG_HT_RATE_MCS7 + 1) - 1; 183 case IEEE80211_HE_MCS_SUPPORT_0_9: 184 return BIT(IWL_TLC_MNG_HT_RATE_MCS9 + 1) - 1; 185 case IEEE80211_HE_MCS_SUPPORT_0_11: 186 return BIT(IWL_TLC_MNG_HT_RATE_MCS11 + 1) - 1; 187 case IEEE80211_HE_MCS_NOT_SUPPORTED: 188 return 0; 189 } 190 191 WARN(1, "invalid HE MCS %d\n", mcs); 192 return 0; 193 } 194 195 static void 196 rs_fw_he_set_enabled_rates(const struct ieee80211_link_sta *link_sta, 197 const struct ieee80211_sta_he_cap *sband_he_cap, 198 struct iwl_tlc_config_cmd_v4 *cmd) 199 { 200 const struct ieee80211_sta_he_cap *he_cap = &link_sta->he_cap; 201 u16 mcs_160 = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160); 202 u16 mcs_80 = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80); 203 u16 tx_mcs_80 = le16_to_cpu(sband_he_cap->he_mcs_nss_supp.tx_mcs_80); 204 u16 tx_mcs_160 = le16_to_cpu(sband_he_cap->he_mcs_nss_supp.tx_mcs_160); 205 int i; 206 u8 nss = link_sta->rx_nss; 207 208 /* the station support only a single receive chain */ 209 if (link_sta->smps_mode == IEEE80211_SMPS_STATIC) 210 nss = 1; 211 212 for (i = 0; i < nss && i < IWL_TLC_NSS_MAX; i++) { 213 u16 _mcs_160 = (mcs_160 >> (2 * i)) & 0x3; 214 u16 _mcs_80 = (mcs_80 >> (2 * i)) & 0x3; 215 u16 _tx_mcs_160 = (tx_mcs_160 >> (2 * i)) & 0x3; 216 u16 _tx_mcs_80 = (tx_mcs_80 >> (2 * i)) & 0x3; 217 218 /* If one side doesn't support - mark both as not supporting */ 219 if (_mcs_80 == IEEE80211_HE_MCS_NOT_SUPPORTED || 220 _tx_mcs_80 == IEEE80211_HE_MCS_NOT_SUPPORTED) { 221 _mcs_80 = IEEE80211_HE_MCS_NOT_SUPPORTED; 222 _tx_mcs_80 = IEEE80211_HE_MCS_NOT_SUPPORTED; 223 } 224 if (_mcs_80 > _tx_mcs_80) 225 _mcs_80 = _tx_mcs_80; 226 cmd->ht_rates[i][IWL_TLC_MCS_PER_BW_80] = 227 cpu_to_le16(rs_fw_he_ieee80211_mcs_to_rs_mcs(_mcs_80)); 228 229 /* If one side doesn't support - mark both as not supporting */ 230 if (_mcs_160 == IEEE80211_HE_MCS_NOT_SUPPORTED || 231 _tx_mcs_160 == IEEE80211_HE_MCS_NOT_SUPPORTED) { 232 _mcs_160 = IEEE80211_HE_MCS_NOT_SUPPORTED; 233 _tx_mcs_160 = IEEE80211_HE_MCS_NOT_SUPPORTED; 234 } 235 if (_mcs_160 > _tx_mcs_160) 236 _mcs_160 = _tx_mcs_160; 237 cmd->ht_rates[i][IWL_TLC_MCS_PER_BW_160] = 238 cpu_to_le16(rs_fw_he_ieee80211_mcs_to_rs_mcs(_mcs_160)); 239 } 240 } 241 242 static u8 rs_fw_eht_max_nss(u8 rx_nss, u8 tx_nss) 243 { 244 u8 tx = u8_get_bits(tx_nss, IEEE80211_EHT_MCS_NSS_TX); 245 u8 rx = u8_get_bits(rx_nss, IEEE80211_EHT_MCS_NSS_RX); 246 /* the max nss that can be used, 247 * is the min with our tx capa and the peer rx capa. 248 */ 249 return min(tx, rx); 250 } 251 252 #define MAX_NSS_MCS(mcs_num, rx, tx) \ 253 rs_fw_eht_max_nss((rx)->rx_tx_mcs ##mcs_num## _max_nss, \ 254 (tx)->rx_tx_mcs ##mcs_num## _max_nss) 255 256 static void rs_fw_set_eht_mcs_nss(__le16 ht_rates[][3], 257 enum IWL_TLC_MCS_PER_BW bw, 258 u8 max_nss, u16 mcs_msk) 259 { 260 if (max_nss >= 2) 261 ht_rates[IWL_TLC_NSS_2][bw] |= cpu_to_le16(mcs_msk); 262 263 if (max_nss >= 1) 264 ht_rates[IWL_TLC_NSS_1][bw] |= cpu_to_le16(mcs_msk); 265 } 266 267 static const 268 struct ieee80211_eht_mcs_nss_supp_bw * 269 rs_fw_rs_mcs2eht_mcs(enum IWL_TLC_MCS_PER_BW bw, 270 const struct ieee80211_eht_mcs_nss_supp *eht_mcs) 271 { 272 switch (bw) { 273 case IWL_TLC_MCS_PER_BW_80: 274 return &eht_mcs->bw._80; 275 case IWL_TLC_MCS_PER_BW_160: 276 return &eht_mcs->bw._160; 277 case IWL_TLC_MCS_PER_BW_320: 278 return &eht_mcs->bw._320; 279 default: 280 return NULL; 281 } 282 } 283 284 static void 285 rs_fw_eht_set_enabled_rates(struct ieee80211_vif *vif, 286 const struct ieee80211_link_sta *link_sta, 287 const struct ieee80211_sta_he_cap *sband_he_cap, 288 const struct ieee80211_sta_eht_cap *sband_eht_cap, 289 struct iwl_tlc_config_cmd_v4 *cmd) 290 { 291 /* peer RX mcs capa */ 292 const struct ieee80211_eht_mcs_nss_supp *eht_rx_mcs = 293 &link_sta->eht_cap.eht_mcs_nss_supp; 294 /* our TX mcs capa */ 295 const struct ieee80211_eht_mcs_nss_supp *eht_tx_mcs = 296 &sband_eht_cap->eht_mcs_nss_supp; 297 298 enum IWL_TLC_MCS_PER_BW bw; 299 struct ieee80211_eht_mcs_nss_supp_20mhz_only mcs_rx_20; 300 struct ieee80211_eht_mcs_nss_supp_20mhz_only mcs_tx_20; 301 302 /* peer is 20Mhz only */ 303 if (vif->type == NL80211_IFTYPE_AP && 304 !(link_sta->he_cap.he_cap_elem.phy_cap_info[0] & 305 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_MASK_ALL)) { 306 mcs_rx_20 = eht_rx_mcs->only_20mhz; 307 } else { 308 mcs_rx_20.rx_tx_mcs7_max_nss = eht_rx_mcs->bw._80.rx_tx_mcs9_max_nss; 309 mcs_rx_20.rx_tx_mcs9_max_nss = eht_rx_mcs->bw._80.rx_tx_mcs9_max_nss; 310 mcs_rx_20.rx_tx_mcs11_max_nss = eht_rx_mcs->bw._80.rx_tx_mcs11_max_nss; 311 mcs_rx_20.rx_tx_mcs13_max_nss = eht_rx_mcs->bw._80.rx_tx_mcs13_max_nss; 312 } 313 314 /* nic is 20Mhz only */ 315 if (!(sband_he_cap->he_cap_elem.phy_cap_info[0] & 316 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_MASK_ALL)) { 317 mcs_tx_20 = eht_tx_mcs->only_20mhz; 318 } else { 319 mcs_tx_20.rx_tx_mcs7_max_nss = eht_tx_mcs->bw._80.rx_tx_mcs9_max_nss; 320 mcs_tx_20.rx_tx_mcs9_max_nss = eht_tx_mcs->bw._80.rx_tx_mcs9_max_nss; 321 mcs_tx_20.rx_tx_mcs11_max_nss = eht_tx_mcs->bw._80.rx_tx_mcs11_max_nss; 322 mcs_tx_20.rx_tx_mcs13_max_nss = eht_tx_mcs->bw._80.rx_tx_mcs13_max_nss; 323 } 324 325 /* rates for 20/40/80 bw */ 326 bw = IWL_TLC_MCS_PER_BW_80; 327 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 328 MAX_NSS_MCS(7, &mcs_rx_20, &mcs_tx_20), GENMASK(7, 0)); 329 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 330 MAX_NSS_MCS(9, &mcs_rx_20, &mcs_tx_20), GENMASK(9, 8)); 331 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 332 MAX_NSS_MCS(11, &mcs_rx_20, &mcs_tx_20), GENMASK(11, 10)); 333 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 334 MAX_NSS_MCS(13, &mcs_rx_20, &mcs_tx_20), GENMASK(13, 12)); 335 336 /* rate for 160/320 bw */ 337 for (bw = IWL_TLC_MCS_PER_BW_160; bw <= IWL_TLC_MCS_PER_BW_320; bw++) { 338 const struct ieee80211_eht_mcs_nss_supp_bw *mcs_rx = 339 rs_fw_rs_mcs2eht_mcs(bw, eht_rx_mcs); 340 const struct ieee80211_eht_mcs_nss_supp_bw *mcs_tx = 341 rs_fw_rs_mcs2eht_mcs(bw, eht_tx_mcs); 342 343 /* got unsupported index for bw */ 344 if (!mcs_rx || !mcs_tx) 345 continue; 346 347 /* break out if we don't support the bandwidth */ 348 if (cmd->max_ch_width < (bw + IWL_TLC_MNG_CH_WIDTH_80MHZ)) 349 break; 350 351 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 352 MAX_NSS_MCS(9, mcs_rx, mcs_tx), GENMASK(9, 0)); 353 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 354 MAX_NSS_MCS(11, mcs_rx, mcs_tx), GENMASK(11, 10)); 355 rs_fw_set_eht_mcs_nss(cmd->ht_rates, bw, 356 MAX_NSS_MCS(13, mcs_rx, mcs_tx), GENMASK(13, 12)); 357 } 358 359 /* the station support only a single receive chain */ 360 if (link_sta->smps_mode == IEEE80211_SMPS_STATIC || 361 link_sta->rx_nss < 2) 362 memset(cmd->ht_rates[IWL_TLC_NSS_2], 0, 363 sizeof(cmd->ht_rates[IWL_TLC_NSS_2])); 364 } 365 366 static void rs_fw_set_supp_rates(struct ieee80211_vif *vif, 367 struct ieee80211_link_sta *link_sta, 368 struct ieee80211_supported_band *sband, 369 const struct ieee80211_sta_he_cap *sband_he_cap, 370 const struct ieee80211_sta_eht_cap *sband_eht_cap, 371 struct iwl_tlc_config_cmd_v4 *cmd) 372 { 373 int i; 374 u16 supp = 0; 375 unsigned long tmp; /* must be unsigned long for for_each_set_bit */ 376 const struct ieee80211_sta_ht_cap *ht_cap = &link_sta->ht_cap; 377 const struct ieee80211_sta_vht_cap *vht_cap = &link_sta->vht_cap; 378 const struct ieee80211_sta_he_cap *he_cap = &link_sta->he_cap; 379 380 /* non HT rates */ 381 tmp = link_sta->supp_rates[sband->band]; 382 for_each_set_bit(i, &tmp, BITS_PER_LONG) 383 supp |= BIT(sband->bitrates[i].hw_value); 384 385 cmd->non_ht_rates = cpu_to_le16(supp); 386 cmd->mode = IWL_TLC_MNG_MODE_NON_HT; 387 388 /* HT/VHT rates */ 389 if (link_sta->eht_cap.has_eht && sband_he_cap && sband_eht_cap) { 390 cmd->mode = IWL_TLC_MNG_MODE_EHT; 391 rs_fw_eht_set_enabled_rates(vif, link_sta, sband_he_cap, 392 sband_eht_cap, cmd); 393 } else if (he_cap->has_he && sband_he_cap) { 394 cmd->mode = IWL_TLC_MNG_MODE_HE; 395 rs_fw_he_set_enabled_rates(link_sta, sband_he_cap, cmd); 396 } else if (vht_cap->vht_supported) { 397 cmd->mode = IWL_TLC_MNG_MODE_VHT; 398 rs_fw_vht_set_enabled_rates(link_sta, vht_cap, cmd); 399 } else if (ht_cap->ht_supported) { 400 cmd->mode = IWL_TLC_MNG_MODE_HT; 401 cmd->ht_rates[IWL_TLC_NSS_1][IWL_TLC_MCS_PER_BW_80] = 402 cpu_to_le16(ht_cap->mcs.rx_mask[0]); 403 404 /* the station support only a single receive chain */ 405 if (link_sta->smps_mode == IEEE80211_SMPS_STATIC) 406 cmd->ht_rates[IWL_TLC_NSS_2][IWL_TLC_MCS_PER_BW_80] = 407 0; 408 else 409 cmd->ht_rates[IWL_TLC_NSS_2][IWL_TLC_MCS_PER_BW_80] = 410 cpu_to_le16(ht_cap->mcs.rx_mask[1]); 411 } 412 } 413 414 void iwl_mvm_tlc_update_notif(struct iwl_mvm *mvm, 415 struct iwl_rx_cmd_buffer *rxb) 416 { 417 struct iwl_rx_packet *pkt = rxb_addr(rxb); 418 struct iwl_tlc_update_notif *notif; 419 struct ieee80211_sta *sta; 420 struct ieee80211_link_sta *link_sta; 421 struct iwl_mvm_sta *mvmsta; 422 struct iwl_mvm_link_sta *mvm_link_sta; 423 struct iwl_lq_sta_rs_fw *lq_sta; 424 u32 flags; 425 426 rcu_read_lock(); 427 428 notif = (void *)pkt->data; 429 link_sta = rcu_dereference(mvm->fw_id_to_link_sta[notif->sta_id]); 430 sta = rcu_dereference(mvm->fw_id_to_mac_id[notif->sta_id]); 431 if (IS_ERR_OR_NULL(sta) || !link_sta) { 432 /* can happen in remove station flow where mvm removed internally 433 * the station before removing from FW 434 */ 435 IWL_DEBUG_RATE(mvm, 436 "Invalid mvm RCU pointer for sta id (%d) in TLC notification\n", 437 notif->sta_id); 438 goto out; 439 } 440 441 mvmsta = iwl_mvm_sta_from_mac80211(sta); 442 443 if (!mvmsta) { 444 IWL_ERR(mvm, "Invalid sta id (%d) in FW TLC notification\n", 445 notif->sta_id); 446 goto out; 447 } 448 449 flags = le32_to_cpu(notif->flags); 450 451 mvm_link_sta = rcu_dereference(mvmsta->link[link_sta->link_id]); 452 if (!mvm_link_sta) { 453 IWL_DEBUG_RATE(mvm, 454 "Invalid mvmsta RCU pointer for link (%d) of sta id (%d) in TLC notification\n", 455 link_sta->link_id, notif->sta_id); 456 goto out; 457 } 458 lq_sta = &mvm_link_sta->lq_sta.rs_fw; 459 460 if (flags & IWL_TLC_NOTIF_FLAG_RATE) { 461 char pretty_rate[100]; 462 463 if (iwl_fw_lookup_notif_ver(mvm->fw, DATA_PATH_GROUP, 464 TLC_MNG_UPDATE_NOTIF, 0) < 3) { 465 rs_pretty_print_rate_v1(pretty_rate, 466 sizeof(pretty_rate), 467 le32_to_cpu(notif->rate)); 468 IWL_DEBUG_RATE(mvm, 469 "Got rate in old format. Rate: %s. Converting.\n", 470 pretty_rate); 471 lq_sta->last_rate_n_flags = 472 iwl_new_rate_from_v1(le32_to_cpu(notif->rate)); 473 } else { 474 lq_sta->last_rate_n_flags = le32_to_cpu(notif->rate); 475 } 476 rs_pretty_print_rate(pretty_rate, sizeof(pretty_rate), 477 lq_sta->last_rate_n_flags); 478 IWL_DEBUG_RATE(mvm, "new rate: %s\n", pretty_rate); 479 } 480 481 if (flags & IWL_TLC_NOTIF_FLAG_AMSDU && !mvm_link_sta->orig_amsdu_len) { 482 u16 size = le32_to_cpu(notif->amsdu_size); 483 int i; 484 485 if (link_sta->agg.max_amsdu_len < size) { 486 /* 487 * In debug link_sta->agg.max_amsdu_len < size 488 * so also check with orig_amsdu_len which holds the 489 * original data before debugfs changed the value 490 */ 491 WARN_ON(mvm_link_sta->orig_amsdu_len < size); 492 goto out; 493 } 494 495 mvmsta->amsdu_enabled = le32_to_cpu(notif->amsdu_enabled); 496 mvmsta->max_amsdu_len = size; 497 link_sta->agg.max_rc_amsdu_len = mvmsta->max_amsdu_len; 498 499 for (i = 0; i < IWL_MAX_TID_COUNT; i++) { 500 if (mvmsta->amsdu_enabled & BIT(i)) 501 link_sta->agg.max_tid_amsdu_len[i] = 502 iwl_mvm_max_amsdu_size(mvm, sta, i); 503 else 504 /* 505 * Not so elegant, but this will effectively 506 * prevent AMSDU on this TID 507 */ 508 link_sta->agg.max_tid_amsdu_len[i] = 1; 509 } 510 511 IWL_DEBUG_RATE(mvm, 512 "AMSDU update. AMSDU size: %d, AMSDU selected size: %d, AMSDU TID bitmap 0x%X\n", 513 le32_to_cpu(notif->amsdu_size), size, 514 mvmsta->amsdu_enabled); 515 } 516 out: 517 rcu_read_unlock(); 518 } 519 520 u16 rs_fw_get_max_amsdu_len(struct ieee80211_sta *sta, 521 struct ieee80211_bss_conf *link_conf, 522 struct ieee80211_link_sta *link_sta) 523 { 524 #if defined(__linux__) 525 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); 526 #endif 527 const struct ieee80211_sta_vht_cap *vht_cap = &link_sta->vht_cap; 528 const struct ieee80211_sta_ht_cap *ht_cap = &link_sta->ht_cap; 529 const struct ieee80211_sta_eht_cap *eht_cap = &link_sta->eht_cap; 530 531 if (WARN_ON_ONCE(!link_conf->chandef.chan)) 532 return IEEE80211_MAX_MPDU_LEN_VHT_3895; 533 534 if (link_conf->chandef.chan->band == NL80211_BAND_6GHZ) { 535 switch (le16_get_bits(link_sta->he_6ghz_capa.capa, 536 IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN)) { 537 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454: 538 return IEEE80211_MAX_MPDU_LEN_VHT_11454; 539 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991: 540 return IEEE80211_MAX_MPDU_LEN_VHT_7991; 541 default: 542 return IEEE80211_MAX_MPDU_LEN_VHT_3895; 543 } 544 } else if (link_conf->chandef.chan->band == NL80211_BAND_2GHZ && 545 eht_cap->has_eht) { 546 switch (u8_get_bits(eht_cap->eht_cap_elem.mac_cap_info[0], 547 IEEE80211_EHT_MAC_CAP0_MAX_MPDU_LEN_MASK)) { 548 case IEEE80211_EHT_MAC_CAP0_MAX_MPDU_LEN_11454: 549 return IEEE80211_MAX_MPDU_LEN_VHT_11454; 550 case IEEE80211_EHT_MAC_CAP0_MAX_MPDU_LEN_7991: 551 return IEEE80211_MAX_MPDU_LEN_VHT_7991; 552 default: 553 return IEEE80211_MAX_MPDU_LEN_VHT_3895; 554 } 555 } else if (vht_cap->vht_supported) { 556 switch (vht_cap->cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK) { 557 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454: 558 return IEEE80211_MAX_MPDU_LEN_VHT_11454; 559 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991: 560 return IEEE80211_MAX_MPDU_LEN_VHT_7991; 561 default: 562 return IEEE80211_MAX_MPDU_LEN_VHT_3895; 563 } 564 } else if (ht_cap->ht_supported) { 565 if (ht_cap->cap & IEEE80211_HT_CAP_MAX_AMSDU) 566 /* 567 * agg is offloaded so we need to assume that agg 568 * are enabled and max mpdu in ampdu is 4095 569 * (spec 802.11-2016 9.3.2.1) 570 */ 571 return IEEE80211_MAX_MPDU_LEN_HT_BA; 572 else 573 return IEEE80211_MAX_MPDU_LEN_HT_3839; 574 } 575 576 /* in legacy mode no amsdu is enabled so return zero */ 577 return 0; 578 } 579 580 void iwl_mvm_rs_fw_rate_init(struct iwl_mvm *mvm, 581 struct ieee80211_vif *vif, 582 struct ieee80211_sta *sta, 583 struct ieee80211_bss_conf *link_conf, 584 struct ieee80211_link_sta *link_sta, 585 enum nl80211_band band) 586 { 587 struct ieee80211_hw *hw = mvm->hw; 588 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); 589 u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, TLC_MNG_CONFIG_CMD); 590 struct ieee80211_supported_band *sband = hw->wiphy->bands[band]; 591 u16 max_amsdu_len = rs_fw_get_max_amsdu_len(sta, link_conf, link_sta); 592 const struct ieee80211_sta_he_cap *sband_he_cap = 593 ieee80211_get_he_iftype_cap_vif(sband, vif); 594 const struct ieee80211_sta_eht_cap *sband_eht_cap = 595 ieee80211_get_eht_iftype_cap_vif(sband, vif); 596 struct iwl_mvm_link_sta *mvm_link_sta; 597 struct iwl_lq_sta_rs_fw *lq_sta; 598 struct iwl_tlc_config_cmd_v4 cfg_cmd = { 599 .max_ch_width = mvmsta->authorized ? 600 rs_fw_bw_from_sta_bw(link_sta) : IWL_TLC_MNG_CH_WIDTH_20MHZ, 601 .flags = cpu_to_le16(rs_fw_get_config_flags(mvm, vif, link_sta, 602 sband_he_cap)), 603 .chains = rs_fw_set_active_chains(iwl_mvm_get_valid_tx_ant(mvm)), 604 .sgi_ch_width_supp = rs_fw_sgi_cw_support(link_sta), 605 .max_mpdu_len = iwl_mvm_is_csum_supported(mvm) ? 606 cpu_to_le16(max_amsdu_len) : 0, 607 }; 608 unsigned int link_id = link_conf->link_id; 609 int cmd_ver; 610 int ret; 611 612 /* Enable external EHT LTF only for GL device and if there's 613 * mutual support by AP and client 614 */ 615 if (CSR_HW_REV_TYPE(mvm->trans->hw_rev) == IWL_CFG_MAC_TYPE_GL && 616 sband_eht_cap && 617 sband_eht_cap->eht_cap_elem.phy_cap_info[5] & 618 IEEE80211_EHT_PHY_CAP5_SUPP_EXTRA_EHT_LTF && 619 link_sta->eht_cap.has_eht && 620 link_sta->eht_cap.eht_cap_elem.phy_cap_info[5] & 621 IEEE80211_EHT_PHY_CAP5_SUPP_EXTRA_EHT_LTF) { 622 IWL_DEBUG_RATE(mvm, "Set support for Extra EHT LTF\n"); 623 cfg_cmd.flags |= 624 cpu_to_le16(IWL_TLC_MNG_CFG_FLAGS_EHT_EXTRA_LTF_MSK); 625 } 626 627 rcu_read_lock(); 628 mvm_link_sta = rcu_dereference(mvmsta->link[link_id]); 629 if (WARN_ON_ONCE(!mvm_link_sta)) { 630 rcu_read_unlock(); 631 return; 632 } 633 634 cfg_cmd.sta_id = mvm_link_sta->sta_id; 635 636 lq_sta = &mvm_link_sta->lq_sta.rs_fw; 637 memset(lq_sta, 0, offsetof(typeof(*lq_sta), pers)); 638 639 rcu_read_unlock(); 640 641 #ifdef CONFIG_IWLWIFI_DEBUGFS 642 iwl_mvm_reset_frame_stats(mvm); 643 #endif 644 rs_fw_set_supp_rates(vif, link_sta, sband, 645 sband_he_cap, sband_eht_cap, 646 &cfg_cmd); 647 648 /* 649 * since TLC offload works with one mode we can assume 650 * that only vht/ht is used and also set it as station max amsdu 651 */ 652 sta->deflink.agg.max_amsdu_len = max_amsdu_len; 653 654 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, 655 WIDE_ID(DATA_PATH_GROUP, 656 TLC_MNG_CONFIG_CMD), 657 0); 658 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, sta_id=%d, max_ch_width=%d, mode=%d\n", 659 cfg_cmd.sta_id, cfg_cmd.max_ch_width, cfg_cmd.mode); 660 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, chains=0x%X, ch_wid_supp=%d, flags=0x%X\n", 661 cfg_cmd.chains, cfg_cmd.sgi_ch_width_supp, cfg_cmd.flags); 662 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, mpdu_len=%d, no_ht_rate=0x%X, tx_op=%d\n", 663 cfg_cmd.max_mpdu_len, cfg_cmd.non_ht_rates, cfg_cmd.max_tx_op); 664 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, ht_rate[0][0]=0x%X, ht_rate[1][0]=0x%X\n", 665 cfg_cmd.ht_rates[0][0], cfg_cmd.ht_rates[1][0]); 666 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, ht_rate[0][1]=0x%X, ht_rate[1][1]=0x%X\n", 667 cfg_cmd.ht_rates[0][1], cfg_cmd.ht_rates[1][1]); 668 IWL_DEBUG_RATE(mvm, "TLC CONFIG CMD, ht_rate[0][2]=0x%X, ht_rate[1][2]=0x%X\n", 669 cfg_cmd.ht_rates[0][2], cfg_cmd.ht_rates[1][2]); 670 if (cmd_ver == 4) { 671 ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, CMD_ASYNC, 672 sizeof(cfg_cmd), &cfg_cmd); 673 } else if (cmd_ver < 4) { 674 struct iwl_tlc_config_cmd_v3 cfg_cmd_v3 = { 675 .sta_id = cfg_cmd.sta_id, 676 .max_ch_width = cfg_cmd.max_ch_width, 677 .mode = cfg_cmd.mode, 678 .chains = cfg_cmd.chains, 679 .amsdu = !!cfg_cmd.max_mpdu_len, 680 .flags = cfg_cmd.flags, 681 .non_ht_rates = cfg_cmd.non_ht_rates, 682 .ht_rates[0][0] = cfg_cmd.ht_rates[0][0], 683 .ht_rates[0][1] = cfg_cmd.ht_rates[0][1], 684 .ht_rates[1][0] = cfg_cmd.ht_rates[1][0], 685 .ht_rates[1][1] = cfg_cmd.ht_rates[1][1], 686 .sgi_ch_width_supp = cfg_cmd.sgi_ch_width_supp, 687 .max_mpdu_len = cfg_cmd.max_mpdu_len, 688 }; 689 690 u16 cmd_size = sizeof(cfg_cmd_v3); 691 692 /* In old versions of the API the struct is 4 bytes smaller */ 693 if (iwl_fw_lookup_cmd_ver(mvm->fw, 694 WIDE_ID(DATA_PATH_GROUP, 695 TLC_MNG_CONFIG_CMD), 0) < 3) 696 cmd_size -= 4; 697 698 ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, CMD_ASYNC, cmd_size, 699 &cfg_cmd_v3); 700 } else { 701 ret = -EINVAL; 702 } 703 704 if (ret) 705 IWL_ERR(mvm, "Failed to send rate scale config (%d)\n", ret); 706 } 707 708 int rs_fw_tx_protection(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta, 709 bool enable) 710 { 711 /* TODO: need to introduce a new FW cmd since LQ cmd is not relevant */ 712 IWL_DEBUG_RATE(mvm, "tx protection - not implemented yet.\n"); 713 return 0; 714 } 715 716 void iwl_mvm_rs_add_sta_link(struct iwl_mvm *mvm, 717 struct iwl_mvm_link_sta *link_sta) 718 { 719 struct iwl_lq_sta_rs_fw *lq_sta; 720 721 lq_sta = &link_sta->lq_sta.rs_fw; 722 723 lq_sta->pers.drv = mvm; 724 lq_sta->pers.sta_id = link_sta->sta_id; 725 lq_sta->pers.chains = 0; 726 memset(lq_sta->pers.chain_signal, 0, 727 sizeof(lq_sta->pers.chain_signal)); 728 lq_sta->pers.last_rssi = S8_MIN; 729 lq_sta->last_rate_n_flags = 0; 730 731 #ifdef CONFIG_MAC80211_DEBUGFS 732 lq_sta->pers.dbg_fixed_rate = 0; 733 #endif 734 } 735 736 void iwl_mvm_rs_add_sta(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta) 737 { 738 unsigned int link_id; 739 740 IWL_DEBUG_RATE(mvm, "create station rate scale window\n"); 741 742 for (link_id = 0; link_id < ARRAY_SIZE(mvmsta->link); link_id++) { 743 struct iwl_mvm_link_sta *link = 744 rcu_dereference_protected(mvmsta->link[link_id], 745 lockdep_is_held(&mvm->mutex)); 746 if (!link) 747 continue; 748 749 iwl_mvm_rs_add_sta_link(mvm, link); 750 } 751 } 752