1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2024-2025 Intel Corporation 4 */ 5 6 #include <net/mac80211.h> 7 #include <linux/ip.h> 8 9 #include "mld.h" 10 #include "mac80211.h" 11 #include "phy.h" 12 #include "iface.h" 13 #include "power.h" 14 #include "sta.h" 15 #include "agg.h" 16 #include "scan.h" 17 #include "d3.h" 18 #include "tlc.h" 19 #include "key.h" 20 #include "ap.h" 21 #include "tx.h" 22 #include "roc.h" 23 #include "mlo.h" 24 #include "stats.h" 25 #include "ftm-initiator.h" 26 #include "low_latency.h" 27 #include "fw/api/scan.h" 28 #include "fw/api/context.h" 29 #include "fw/api/filter.h" 30 #include "fw/api/sta.h" 31 #include "fw/api/tdls.h" 32 #ifdef CONFIG_PM_SLEEP 33 #include "fw/api/d3.h" 34 #endif /* CONFIG_PM_SLEEP */ 35 #include "iwl-trans.h" 36 37 #define IWL_MLD_LIMITS(ap) \ 38 { \ 39 .max = 2, \ 40 .types = BIT(NL80211_IFTYPE_STATION), \ 41 }, \ 42 { \ 43 .max = 1, \ 44 .types = ap | \ 45 BIT(NL80211_IFTYPE_P2P_CLIENT) | \ 46 BIT(NL80211_IFTYPE_P2P_GO), \ 47 }, \ 48 { \ 49 .max = 1, \ 50 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), \ 51 } 52 53 static const struct ieee80211_iface_limit iwl_mld_limits[] = { 54 IWL_MLD_LIMITS(0) 55 }; 56 57 static const struct ieee80211_iface_limit iwl_mld_limits_ap[] = { 58 IWL_MLD_LIMITS(BIT(NL80211_IFTYPE_AP)) 59 }; 60 61 static const struct ieee80211_iface_combination 62 iwl_mld_iface_combinations[] = { 63 { 64 .num_different_channels = 2, 65 .max_interfaces = 4, 66 .limits = iwl_mld_limits, 67 .n_limits = ARRAY_SIZE(iwl_mld_limits), 68 }, 69 { 70 .num_different_channels = 1, 71 .max_interfaces = 4, 72 .limits = iwl_mld_limits_ap, 73 .n_limits = ARRAY_SIZE(iwl_mld_limits_ap), 74 }, 75 }; 76 77 static const u8 if_types_ext_capa_sta[] = { 78 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 79 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 80 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF | 81 WLAN_EXT_CAPA8_MAX_MSDU_IN_AMSDU_LSB, 82 [8] = WLAN_EXT_CAPA9_MAX_MSDU_IN_AMSDU_MSB, 83 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 84 }; 85 86 #define IWL_MLD_EMLSR_CAPA (IEEE80211_EML_CAP_EMLSR_SUPP | \ 87 IEEE80211_EML_CAP_EMLSR_PADDING_DELAY_32US << \ 88 __bf_shf(IEEE80211_EML_CAP_EMLSR_PADDING_DELAY) | \ 89 IEEE80211_EML_CAP_EMLSR_TRANSITION_DELAY_64US << \ 90 __bf_shf(IEEE80211_EML_CAP_EMLSR_TRANSITION_DELAY)) 91 #define IWL_MLD_CAPA_OPS (FIELD_PREP_CONST( \ 92 IEEE80211_MLD_CAP_OP_TID_TO_LINK_MAP_NEG_SUPP, \ 93 IEEE80211_MLD_CAP_OP_TID_TO_LINK_MAP_NEG_SUPP_SAME) | \ 94 IEEE80211_MLD_CAP_OP_LINK_RECONF_SUPPORT) 95 96 static const struct wiphy_iftype_ext_capab iftypes_ext_capa[] = { 97 { 98 .iftype = NL80211_IFTYPE_STATION, 99 .extended_capabilities = if_types_ext_capa_sta, 100 .extended_capabilities_mask = if_types_ext_capa_sta, 101 .extended_capabilities_len = sizeof(if_types_ext_capa_sta), 102 /* relevant only if EHT is supported */ 103 .eml_capabilities = IWL_MLD_EMLSR_CAPA, 104 .mld_capa_and_ops = IWL_MLD_CAPA_OPS, 105 }, 106 }; 107 108 static void iwl_mld_hw_set_addresses(struct iwl_mld *mld) 109 { 110 struct wiphy *wiphy = mld->wiphy; 111 int num_addrs = 1; 112 113 /* Extract MAC address */ 114 memcpy(mld->addresses[0].addr, mld->nvm_data->hw_addr, ETH_ALEN); 115 wiphy->addresses = mld->addresses; 116 wiphy->n_addresses = 1; 117 118 /* Extract additional MAC addresses if available */ 119 if (mld->nvm_data->n_hw_addrs > 1) 120 num_addrs = min(mld->nvm_data->n_hw_addrs, 121 IWL_MLD_MAX_ADDRESSES); 122 123 for (int i = 1; i < num_addrs; i++) { 124 memcpy(mld->addresses[i].addr, 125 mld->addresses[i - 1].addr, 126 ETH_ALEN); 127 mld->addresses[i].addr[ETH_ALEN - 1]++; 128 wiphy->n_addresses++; 129 } 130 } 131 132 static void iwl_mld_hw_set_channels(struct iwl_mld *mld) 133 { 134 struct wiphy *wiphy = mld->wiphy; 135 struct ieee80211_supported_band *bands = mld->nvm_data->bands; 136 137 wiphy->bands[NL80211_BAND_2GHZ] = &bands[NL80211_BAND_2GHZ]; 138 wiphy->bands[NL80211_BAND_5GHZ] = &bands[NL80211_BAND_5GHZ]; 139 140 if (bands[NL80211_BAND_6GHZ].n_channels) 141 wiphy->bands[NL80211_BAND_6GHZ] = &bands[NL80211_BAND_6GHZ]; 142 } 143 144 static void iwl_mld_hw_set_security(struct iwl_mld *mld) 145 { 146 struct ieee80211_hw *hw = mld->hw; 147 static const u32 mld_ciphers[] = { 148 WLAN_CIPHER_SUITE_WEP40, 149 WLAN_CIPHER_SUITE_WEP104, 150 WLAN_CIPHER_SUITE_TKIP, 151 WLAN_CIPHER_SUITE_CCMP, 152 WLAN_CIPHER_SUITE_GCMP, 153 WLAN_CIPHER_SUITE_GCMP_256, 154 WLAN_CIPHER_SUITE_AES_CMAC, 155 WLAN_CIPHER_SUITE_BIP_GMAC_128, 156 WLAN_CIPHER_SUITE_BIP_GMAC_256 157 }; 158 159 hw->wiphy->n_cipher_suites = ARRAY_SIZE(mld_ciphers); 160 hw->wiphy->cipher_suites = mld_ciphers; 161 162 ieee80211_hw_set(hw, MFP_CAPABLE); 163 wiphy_ext_feature_set(hw->wiphy, 164 NL80211_EXT_FEATURE_BEACON_PROTECTION); 165 } 166 167 static void iwl_mld_hw_set_antennas(struct iwl_mld *mld) 168 { 169 struct wiphy *wiphy = mld->wiphy; 170 171 wiphy->available_antennas_tx = iwl_mld_get_valid_tx_ant(mld); 172 wiphy->available_antennas_rx = iwl_mld_get_valid_rx_ant(mld); 173 } 174 175 static void iwl_mld_hw_set_pm(struct iwl_mld *mld) 176 { 177 #ifdef CONFIG_PM_SLEEP 178 struct wiphy *wiphy = mld->wiphy; 179 180 if (!device_can_wakeup(mld->trans->dev)) 181 return; 182 183 mld->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT | 184 WIPHY_WOWLAN_DISCONNECT | 185 WIPHY_WOWLAN_EAP_IDENTITY_REQ | 186 WIPHY_WOWLAN_RFKILL_RELEASE | 187 WIPHY_WOWLAN_NET_DETECT | 188 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | 189 WIPHY_WOWLAN_GTK_REKEY_FAILURE | 190 WIPHY_WOWLAN_4WAY_HANDSHAKE; 191 192 mld->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS; 193 mld->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN; 194 mld->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN; 195 mld->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES_V2; 196 197 wiphy->wowlan = &mld->wowlan; 198 #endif /* CONFIG_PM_SLEEP */ 199 } 200 201 static void iwl_mac_hw_set_radiotap(struct iwl_mld *mld) 202 { 203 struct ieee80211_hw *hw = mld->hw; 204 205 hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC | 206 IEEE80211_RADIOTAP_MCS_HAVE_STBC; 207 208 hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC | 209 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED; 210 211 hw->radiotap_timestamp.units_pos = 212 IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US | 213 IEEE80211_RADIOTAP_TIMESTAMP_SPOS_PLCP_SIG_ACQ; 214 215 /* this is the case for CCK frames, it's better (only 8) for OFDM */ 216 hw->radiotap_timestamp.accuracy = 22; 217 } 218 219 static void iwl_mac_hw_set_flags(struct iwl_mld *mld) 220 { 221 struct ieee80211_hw *hw = mld->hw; 222 223 ieee80211_hw_set(hw, USES_RSS); 224 ieee80211_hw_set(hw, HANDLES_QUIET_CSA); 225 ieee80211_hw_set(hw, AP_LINK_PS); 226 ieee80211_hw_set(hw, SIGNAL_DBM); 227 ieee80211_hw_set(hw, SPECTRUM_MGMT); 228 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); 229 ieee80211_hw_set(hw, WANT_MONITOR_VIF); 230 ieee80211_hw_set(hw, SUPPORTS_PS); 231 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); 232 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 233 ieee80211_hw_set(hw, CONNECTION_MONITOR); 234 ieee80211_hw_set(hw, CHANCTX_STA_CSA); 235 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT); 236 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS); 237 ieee80211_hw_set(hw, NEEDS_UNIQUE_STA_ADDR); 238 ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW); 239 ieee80211_hw_set(hw, BUFF_MMPDU_TXQ); 240 ieee80211_hw_set(hw, STA_MMPDU_TXQ); 241 ieee80211_hw_set(hw, TX_AMSDU); 242 ieee80211_hw_set(hw, TX_FRAG_LIST); 243 ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW); 244 ieee80211_hw_set(hw, HAS_RATE_CONTROL); 245 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER); 246 ieee80211_hw_set(hw, DISALLOW_PUNCTURING_5GHZ); 247 ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS); 248 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU); 249 ieee80211_hw_set(hw, TDLS_WIDER_BW); 250 } 251 252 static void iwl_mac_hw_set_wiphy(struct iwl_mld *mld) 253 { 254 struct ieee80211_hw *hw = mld->hw; 255 struct wiphy *wiphy = hw->wiphy; 256 const struct iwl_ucode_capabilities *ucode_capa = &mld->fw->ucode_capa; 257 258 snprintf(wiphy->fw_version, 259 sizeof(wiphy->fw_version), 260 "%.31s", mld->fw->fw_version); 261 262 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 263 BIT(NL80211_IFTYPE_P2P_CLIENT) | 264 BIT(NL80211_IFTYPE_AP) | 265 BIT(NL80211_IFTYPE_P2P_GO) | 266 BIT(NL80211_IFTYPE_P2P_DEVICE) | 267 BIT(NL80211_IFTYPE_ADHOC); 268 269 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR | 270 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR | 271 NL80211_FEATURE_ND_RANDOM_MAC_ADDR | 272 NL80211_FEATURE_HT_IBSS | 273 NL80211_FEATURE_P2P_GO_CTWIN | 274 NL80211_FEATURE_LOW_PRIORITY_SCAN | 275 NL80211_FEATURE_P2P_GO_OPPPS | 276 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 277 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION | 278 NL80211_FEATURE_TX_POWER_INSERTION | 279 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES; 280 281 wiphy->flags |= WIPHY_FLAG_IBSS_RSN | 282 WIPHY_FLAG_AP_UAPSD | 283 WIPHY_FLAG_HAS_CHANNEL_SWITCH | 284 WIPHY_FLAG_SPLIT_SCAN_6GHZ | 285 WIPHY_FLAG_SUPPORTS_TDLS | 286 WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK; 287 288 if (mld->nvm_data->sku_cap_11be_enable && 289 !iwlwifi_mod_params.disable_11ax && 290 !iwlwifi_mod_params.disable_11be) 291 wiphy->flags |= WIPHY_FLAG_SUPPORTS_MLO; 292 293 /* the firmware uses u8 for num of iterations, but 0xff is saved for 294 * infinite loop, so the maximum number of iterations is actually 254. 295 */ 296 wiphy->max_sched_scan_plan_iterations = 254; 297 wiphy->max_sched_scan_ie_len = iwl_mld_scan_max_template_size(); 298 wiphy->max_scan_ie_len = iwl_mld_scan_max_template_size(); 299 wiphy->max_sched_scan_ssids = PROBE_OPTION_MAX; 300 wiphy->max_scan_ssids = PROBE_OPTION_MAX; 301 wiphy->max_sched_scan_plans = IWL_MAX_SCHED_SCAN_PLANS; 302 wiphy->max_sched_scan_reqs = 1; 303 wiphy->max_sched_scan_plan_interval = U16_MAX; 304 wiphy->max_match_sets = IWL_SCAN_MAX_PROFILES_V2; 305 306 wiphy->max_remain_on_channel_duration = 10000; 307 308 wiphy->hw_version = mld->trans->hw_id; 309 310 wiphy->hw_timestamp_max_peers = 1; 311 312 wiphy->iface_combinations = iwl_mld_iface_combinations; 313 wiphy->n_iface_combinations = ARRAY_SIZE(iwl_mld_iface_combinations); 314 315 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_VHT_IBSS); 316 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_DFS_CONCURRENT); 317 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_LEGACY); 318 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SCAN_START_TIME); 319 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BSS_PARENT_TSF); 320 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT); 321 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP); 322 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME); 323 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE); 324 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER); 325 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SPP_AMSDU_SUPPORT); 326 327 if (fw_has_capa(ucode_capa, IWL_UCODE_TLV_CAPA_PROTECTED_TWT)) 328 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_PROTECTED_TWT); 329 330 wiphy->iftype_ext_capab = NULL; 331 wiphy->num_iftype_ext_capab = 0; 332 333 if (!iwlwifi_mod_params.disable_11ax) { 334 wiphy->iftype_ext_capab = iftypes_ext_capa; 335 wiphy->num_iftype_ext_capab = ARRAY_SIZE(iftypes_ext_capa); 336 337 ieee80211_hw_set(hw, SUPPORTS_MULTI_BSSID); 338 ieee80211_hw_set(hw, SUPPORTS_ONLY_HE_MULTI_BSSID); 339 } 340 341 if (iwlmld_mod_params.power_scheme != IWL_POWER_SCHEME_CAM) 342 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 343 else 344 wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 345 } 346 347 static void iwl_mac_hw_set_misc(struct iwl_mld *mld) 348 { 349 struct ieee80211_hw *hw = mld->hw; 350 351 hw->queues = IEEE80211_NUM_ACS; 352 353 hw->netdev_features = NETIF_F_HIGHDMA | NETIF_F_SG; 354 hw->netdev_features |= mld->cfg->features; 355 356 hw->max_tx_fragments = mld->trans->max_skb_frags; 357 hw->max_listen_interval = IWL_MLD_CONN_LISTEN_INTERVAL; 358 359 hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL; 360 hw->uapsd_queues = IEEE80211_WMM_IE_STA_QOSINFO_AC_VO | 361 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI | 362 IEEE80211_WMM_IE_STA_QOSINFO_AC_BK | 363 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE; 364 365 hw->chanctx_data_size = sizeof(struct iwl_mld_phy); 366 hw->vif_data_size = sizeof(struct iwl_mld_vif); 367 hw->sta_data_size = sizeof(struct iwl_mld_sta); 368 hw->txq_data_size = sizeof(struct iwl_mld_txq); 369 370 /* TODO: Remove this division when IEEE80211_MAX_AMPDU_BUF_EHT size 371 * is supported. 372 * Note: ensure that IWL_DEFAULT_QUEUE_SIZE_EHT is updated accordingly. 373 */ 374 hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_EHT / 2; 375 } 376 377 static int iwl_mld_hw_verify_preconditions(struct iwl_mld *mld) 378 { 379 /* 11ax is expected to be enabled for all supported devices */ 380 if (WARN_ON(!mld->nvm_data->sku_cap_11ax_enable)) 381 return -EINVAL; 382 383 /* LAR is expected to be enabled for all supported devices */ 384 if (WARN_ON(!mld->nvm_data->lar_enabled)) 385 return -EINVAL; 386 387 /* All supported devices are currently using version 3 of the cmd. 388 * Since version 3, IWL_SCAN_MAX_PROFILES_V2 shall be used where 389 * necessary. 390 */ 391 if (WARN_ON(iwl_fw_lookup_cmd_ver(mld->fw, 392 SCAN_OFFLOAD_UPDATE_PROFILES_CMD, 393 IWL_FW_CMD_VER_UNKNOWN) != 3)) 394 return -EINVAL; 395 396 return 0; 397 } 398 399 int iwl_mld_register_hw(struct iwl_mld *mld) 400 { 401 /* verify once essential preconditions required for setting 402 * the hw capabilities 403 */ 404 if (iwl_mld_hw_verify_preconditions(mld)) 405 return -EINVAL; 406 407 iwl_mld_hw_set_addresses(mld); 408 iwl_mld_hw_set_channels(mld); 409 iwl_mld_hw_set_security(mld); 410 iwl_mld_hw_set_pm(mld); 411 iwl_mld_hw_set_antennas(mld); 412 iwl_mac_hw_set_radiotap(mld); 413 iwl_mac_hw_set_flags(mld); 414 iwl_mac_hw_set_wiphy(mld); 415 iwl_mac_hw_set_misc(mld); 416 417 SET_IEEE80211_DEV(mld->hw, mld->trans->dev); 418 419 return ieee80211_register_hw(mld->hw); 420 } 421 422 static void 423 iwl_mld_mac80211_tx(struct ieee80211_hw *hw, 424 struct ieee80211_tx_control *control, struct sk_buff *skb) 425 { 426 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 427 struct ieee80211_sta *sta = control->sta; 428 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 429 struct ieee80211_hdr *hdr = (void *)skb->data; 430 u32 link_id = u32_get_bits(info->control.flags, 431 IEEE80211_TX_CTRL_MLO_LINK); 432 433 /* In AP mode, mgmt frames are sent on the bcast station, 434 * so the FW can't translate the MLD addr to the link addr. Do it here 435 */ 436 if (ieee80211_is_mgmt(hdr->frame_control) && sta && 437 link_id != IEEE80211_LINK_UNSPECIFIED && 438 !ieee80211_is_probe_resp(hdr->frame_control)) { 439 /* translate MLD addresses to LINK addresses */ 440 struct ieee80211_link_sta *link_sta = 441 rcu_dereference(sta->link[link_id]); 442 struct ieee80211_bss_conf *link_conf = 443 rcu_dereference(info->control.vif->link_conf[link_id]); 444 struct ieee80211_mgmt *mgmt; 445 446 if (WARN_ON(!link_sta || !link_conf)) { 447 ieee80211_free_txskb(hw, skb); 448 return; 449 } 450 451 mgmt = (void *)hdr; 452 memcpy(mgmt->da, link_sta->addr, ETH_ALEN); 453 memcpy(mgmt->sa, link_conf->addr, ETH_ALEN); 454 memcpy(mgmt->bssid, link_conf->bssid, ETH_ALEN); 455 } 456 457 iwl_mld_tx_skb(mld, skb, NULL); 458 } 459 460 static void 461 iwl_mld_restart_cleanup(struct iwl_mld *mld) 462 { 463 iwl_cleanup_mld(mld); 464 465 ieee80211_iterate_interfaces(mld->hw, IEEE80211_IFACE_ITER_ACTIVE, 466 iwl_mld_cleanup_vif, NULL); 467 468 ieee80211_iterate_stations_atomic(mld->hw, 469 iwl_mld_cleanup_sta, NULL); 470 471 iwl_mld_ftm_restart_cleanup(mld); 472 } 473 474 static 475 int iwl_mld_mac80211_start(struct ieee80211_hw *hw) 476 { 477 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 478 bool in_d3 = false; 479 int ret = 0; 480 481 lockdep_assert_wiphy(mld->wiphy); 482 483 #ifdef CONFIG_PM_SLEEP 484 /* Unless the host goes into hibernate the FW always stays on and 485 * the d3_resume flow is used. When wowlan is configured, mac80211 486 * would call it's resume callback and the wowlan_resume flow 487 * would be used. 488 */ 489 490 in_d3 = mld->fw_status.in_d3; 491 if (in_d3) { 492 /* mac80211 already cleaned up the state, no need for cleanup */ 493 ret = iwl_mld_no_wowlan_resume(mld); 494 if (ret) 495 iwl_mld_stop_fw(mld); 496 } 497 #endif /* CONFIG_PM_SLEEP */ 498 499 if (mld->fw_status.in_hw_restart) { 500 iwl_mld_stop_fw(mld); 501 iwl_mld_restart_cleanup(mld); 502 } 503 504 if (!in_d3 || ret) { 505 ret = iwl_mld_start_fw(mld); 506 if (ret) 507 goto error; 508 } 509 510 mld->scan.last_start_time_jiffies = jiffies; 511 512 iwl_dbg_tlv_time_point(&mld->fwrt, IWL_FW_INI_TIME_POINT_POST_INIT, 513 NULL); 514 iwl_dbg_tlv_time_point(&mld->fwrt, IWL_FW_INI_TIME_POINT_PERIODIC, 515 NULL); 516 517 return 0; 518 519 error: 520 /* If we failed to restart the hw, there is nothing useful 521 * we can do but indicate we are no longer in restart. 522 */ 523 mld->fw_status.in_hw_restart = false; 524 525 return ret; 526 } 527 528 static 529 void iwl_mld_mac80211_stop(struct ieee80211_hw *hw, bool suspend) 530 { 531 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 532 533 lockdep_assert_wiphy(mld->wiphy); 534 535 wiphy_work_cancel(mld->wiphy, &mld->add_txqs_wk); 536 537 /* if the suspend flow fails the fw is in error. Stop it here, and it 538 * will be started upon wakeup 539 */ 540 if (!suspend || 541 (IS_ENABLED(CONFIG_PM_SLEEP) && iwl_mld_no_wowlan_suspend(mld))) 542 iwl_mld_stop_fw(mld); 543 544 /* Clear in_hw_restart flag when stopping the hw, as mac80211 won't 545 * execute the restart. 546 */ 547 mld->fw_status.in_hw_restart = false; 548 549 /* We shouldn't have any UIDs still set. Loop over all the UIDs to 550 * make sure there's nothing left there and warn if any is found. 551 */ 552 for (int i = 0; i < ARRAY_SIZE(mld->scan.uid_status); i++) 553 if (WARN_ONCE(mld->scan.uid_status[i], 554 "UMAC scan UID %d status was not cleaned (0x%x 0x%x)\n", 555 i, mld->scan.uid_status[i], mld->scan.status)) 556 mld->scan.uid_status[i] = 0; 557 } 558 559 static 560 int iwl_mld_mac80211_config(struct ieee80211_hw *hw, u32 changed) 561 { 562 return 0; 563 } 564 565 static 566 int iwl_mld_mac80211_add_interface(struct ieee80211_hw *hw, 567 struct ieee80211_vif *vif) 568 { 569 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 570 int ret; 571 572 lockdep_assert_wiphy(mld->wiphy); 573 574 /* Construct mld_vif, add it to fw, and map its ID to ieee80211_vif */ 575 ret = iwl_mld_add_vif(mld, vif); 576 if (ret) 577 return ret; 578 579 /* 580 * Add the default link, but not if this is an MLD vif as that implies 581 * the HW is restarting and it will be configured by change_vif_links. 582 */ 583 if (!ieee80211_vif_is_mld(vif)) 584 ret = iwl_mld_add_link(mld, &vif->bss_conf); 585 if (ret) 586 goto err; 587 588 if (vif->type == NL80211_IFTYPE_STATION) { 589 vif->driver_flags |= IEEE80211_VIF_REMOVE_AP_AFTER_DISASSOC; 590 if (!vif->p2p) 591 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 592 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 593 } 594 595 if (vif->p2p || iwl_fw_lookup_cmd_ver(mld->fw, PHY_CONTEXT_CMD, 0) < 5) 596 vif->driver_flags |= IEEE80211_VIF_IGNORE_OFDMA_WIDER_BW; 597 598 /* 599 * For an MLD vif (in restart) we may not have a link; delay the call 600 * the initial change_vif_links. 601 */ 602 if (vif->type == NL80211_IFTYPE_STATION && 603 !ieee80211_vif_is_mld(vif)) 604 iwl_mld_update_mac_power(mld, vif, false); 605 606 if (vif->type == NL80211_IFTYPE_MONITOR) { 607 mld->monitor.on = true; 608 ieee80211_hw_set(mld->hw, RX_INCLUDES_FCS); 609 } 610 611 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) 612 mld->p2p_device_vif = vif; 613 614 return 0; 615 616 err: 617 iwl_mld_rm_vif(mld, vif); 618 return ret; 619 } 620 621 static 622 void iwl_mld_mac80211_remove_interface(struct ieee80211_hw *hw, 623 struct ieee80211_vif *vif) 624 { 625 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 626 627 lockdep_assert_wiphy(mld->wiphy); 628 629 if (ieee80211_vif_type_p2p(vif) == NL80211_IFTYPE_STATION) 630 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | 631 IEEE80211_VIF_SUPPORTS_CQM_RSSI); 632 633 if (vif->type == NL80211_IFTYPE_MONITOR) { 634 __clear_bit(IEEE80211_HW_RX_INCLUDES_FCS, mld->hw->flags); 635 mld->monitor.on = false; 636 } 637 638 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) 639 mld->p2p_device_vif = NULL; 640 641 iwl_mld_remove_link(mld, &vif->bss_conf); 642 643 #ifdef CONFIG_IWLWIFI_DEBUGFS 644 debugfs_remove(iwl_mld_vif_from_mac80211(vif)->dbgfs_slink); 645 #endif 646 647 iwl_mld_rm_vif(mld, vif); 648 } 649 650 struct iwl_mld_mc_iter_data { 651 struct iwl_mld *mld; 652 int port_id; 653 }; 654 655 static void iwl_mld_mc_iface_iterator(void *data, u8 *mac, 656 struct ieee80211_vif *vif) 657 { 658 struct iwl_mld_mc_iter_data *mc_data = data; 659 struct iwl_mld *mld = mc_data->mld; 660 struct iwl_mcast_filter_cmd *cmd = mld->mcast_filter_cmd; 661 struct iwl_host_cmd hcmd = { 662 .id = MCAST_FILTER_CMD, 663 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 664 }; 665 int ret, len; 666 667 /* If we don't have free ports, mcast frames will be dropped */ 668 if (WARN_ON_ONCE(mc_data->port_id >= MAX_PORT_ID_NUM)) 669 return; 670 671 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) 672 return; 673 674 cmd->port_id = mc_data->port_id++; 675 ether_addr_copy(cmd->bssid, vif->bss_conf.bssid); 676 len = roundup(sizeof(*cmd) + cmd->count * ETH_ALEN, 4); 677 678 hcmd.len[0] = len; 679 hcmd.data[0] = cmd; 680 681 ret = iwl_mld_send_cmd(mld, &hcmd); 682 if (ret) 683 IWL_ERR(mld, "mcast filter cmd error. ret=%d\n", ret); 684 } 685 686 void iwl_mld_recalc_multicast_filter(struct iwl_mld *mld) 687 { 688 struct iwl_mld_mc_iter_data iter_data = { 689 .mld = mld, 690 }; 691 692 if (WARN_ON_ONCE(!mld->mcast_filter_cmd)) 693 return; 694 695 ieee80211_iterate_active_interfaces(mld->hw, 696 IEEE80211_IFACE_ITER_NORMAL, 697 iwl_mld_mc_iface_iterator, 698 &iter_data); 699 } 700 701 static u64 702 iwl_mld_mac80211_prepare_multicast(struct ieee80211_hw *hw, 703 struct netdev_hw_addr_list *mc_list) 704 { 705 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 706 struct iwl_mcast_filter_cmd *cmd; 707 struct netdev_hw_addr *addr; 708 int addr_count = netdev_hw_addr_list_count(mc_list); 709 bool pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES; 710 int len; 711 712 if (pass_all) 713 addr_count = 0; 714 715 /* len must be a multiple of 4 */ 716 len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4); 717 cmd = kzalloc(len, GFP_ATOMIC); 718 if (!cmd) 719 return 0; 720 721 if (pass_all) { 722 cmd->pass_all = 1; 723 goto out; 724 } 725 726 netdev_hw_addr_list_for_each(addr, mc_list) { 727 IWL_DEBUG_MAC80211(mld, "mcast addr (%d): %pM\n", 728 cmd->count, addr->addr); 729 ether_addr_copy(&cmd->addr_list[cmd->count * ETH_ALEN], 730 addr->addr); 731 cmd->count++; 732 } 733 734 out: 735 return (u64)(unsigned long)cmd; 736 } 737 738 static 739 void iwl_mld_mac80211_configure_filter(struct ieee80211_hw *hw, 740 unsigned int changed_flags, 741 unsigned int *total_flags, 742 u64 multicast) 743 { 744 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 745 struct iwl_mcast_filter_cmd *cmd = (void *)(unsigned long)multicast; 746 747 /* Replace previous configuration */ 748 kfree(mld->mcast_filter_cmd); 749 mld->mcast_filter_cmd = cmd; 750 751 if (!cmd) 752 goto out; 753 754 if (changed_flags & FIF_ALLMULTI) 755 cmd->pass_all = !!(*total_flags & FIF_ALLMULTI); 756 757 if (cmd->pass_all) 758 cmd->count = 0; 759 760 iwl_mld_recalc_multicast_filter(mld); 761 out: 762 *total_flags = 0; 763 } 764 765 static 766 void iwl_mld_mac80211_wake_tx_queue(struct ieee80211_hw *hw, 767 struct ieee80211_txq *txq) 768 { 769 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 770 struct iwl_mld_txq *mld_txq = iwl_mld_txq_from_mac80211(txq); 771 772 if (likely(mld_txq->status.allocated) || !txq->sta) { 773 iwl_mld_tx_from_txq(mld, txq); 774 return; 775 } 776 777 /* We don't support TSPEC tids. %IEEE80211_NUM_TIDS is for mgmt */ 778 if (txq->tid != IEEE80211_NUM_TIDS && txq->tid >= IWL_MAX_TID_COUNT) { 779 IWL_DEBUG_MAC80211(mld, "TID %d is not supported\n", txq->tid); 780 return; 781 } 782 783 /* The worker will handle any packets we leave on the txq now */ 784 785 spin_lock_bh(&mld->add_txqs_lock); 786 /* The list is being deleted only after the queue is fully allocated. */ 787 if (list_empty(&mld_txq->list) && 788 /* recheck under lock, otherwise it can be added twice */ 789 !mld_txq->status.allocated) { 790 list_add_tail(&mld_txq->list, &mld->txqs_to_add); 791 wiphy_work_queue(mld->wiphy, &mld->add_txqs_wk); 792 } 793 spin_unlock_bh(&mld->add_txqs_lock); 794 } 795 796 static void iwl_mld_teardown_tdls_peers(struct iwl_mld *mld) 797 { 798 lockdep_assert_wiphy(mld->wiphy); 799 800 for (int i = 0; i < mld->fw->ucode_capa.num_stations; i++) { 801 struct ieee80211_link_sta *link_sta; 802 struct iwl_mld_sta *mld_sta; 803 804 link_sta = wiphy_dereference(mld->wiphy, 805 mld->fw_id_to_link_sta[i]); 806 if (IS_ERR_OR_NULL(link_sta)) 807 continue; 808 809 if (!link_sta->sta->tdls) 810 continue; 811 812 mld_sta = iwl_mld_sta_from_mac80211(link_sta->sta); 813 814 ieee80211_tdls_oper_request(mld_sta->vif, link_sta->addr, 815 NL80211_TDLS_TEARDOWN, 816 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED, 817 GFP_KERNEL); 818 } 819 } 820 821 static 822 int iwl_mld_add_chanctx(struct ieee80211_hw *hw, 823 struct ieee80211_chanctx_conf *ctx) 824 { 825 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 826 struct iwl_mld_phy *phy = iwl_mld_phy_from_mac80211(ctx); 827 int fw_id = iwl_mld_allocate_fw_phy_id(mld); 828 int ret; 829 830 if (fw_id < 0) 831 return fw_id; 832 833 phy->mld = mld; 834 phy->fw_id = fw_id; 835 phy->chandef = *iwl_mld_get_chandef_from_chanctx(mld, ctx); 836 837 ret = iwl_mld_phy_fw_action(mld, ctx, FW_CTXT_ACTION_ADD); 838 if (ret) { 839 mld->used_phy_ids &= ~BIT(phy->fw_id); 840 return ret; 841 } 842 843 if (hweight8(mld->used_phy_ids) > 1) 844 iwl_mld_teardown_tdls_peers(mld); 845 846 return 0; 847 } 848 849 static 850 void iwl_mld_remove_chanctx(struct ieee80211_hw *hw, 851 struct ieee80211_chanctx_conf *ctx) 852 { 853 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 854 struct iwl_mld_phy *phy = iwl_mld_phy_from_mac80211(ctx); 855 856 iwl_mld_phy_fw_action(mld, ctx, FW_CTXT_ACTION_REMOVE); 857 mld->used_phy_ids &= ~BIT(phy->fw_id); 858 } 859 860 static 861 void iwl_mld_change_chanctx(struct ieee80211_hw *hw, 862 struct ieee80211_chanctx_conf *ctx, u32 changed) 863 { 864 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 865 struct iwl_mld_phy *phy = iwl_mld_phy_from_mac80211(ctx); 866 struct cfg80211_chan_def *chandef = 867 iwl_mld_get_chandef_from_chanctx(mld, ctx); 868 869 /* We don't care about these */ 870 if (!(changed & ~(IEEE80211_CHANCTX_CHANGE_RX_CHAINS | 871 IEEE80211_CHANCTX_CHANGE_RADAR | 872 IEEE80211_CHANCTX_CHANGE_CHANNEL))) 873 return; 874 875 /* Check if a FW update is required */ 876 877 if (changed & IEEE80211_CHANCTX_CHANGE_AP) 878 goto update; 879 880 if (chandef->chan == phy->chandef.chan && 881 chandef->center_freq1 == phy->chandef.center_freq1 && 882 chandef->punctured == phy->chandef.punctured) { 883 /* Check if we are toggling between HT and non-HT, no-op */ 884 if (phy->chandef.width == chandef->width || 885 (phy->chandef.width <= NL80211_CHAN_WIDTH_20 && 886 chandef->width <= NL80211_CHAN_WIDTH_20)) 887 return; 888 } 889 update: 890 891 iwl_mld_update_phy_chandef(mld, ctx); 892 } 893 894 static u8 895 iwl_mld_chandef_get_primary_80(struct cfg80211_chan_def *chandef) 896 { 897 int data_start; 898 int control_start; 899 int bw; 900 901 if (chandef->width == NL80211_CHAN_WIDTH_320) 902 bw = 320; 903 else if (chandef->width == NL80211_CHAN_WIDTH_160) 904 bw = 160; 905 else 906 return 0; 907 908 /* data is bw wide so the start is half the width */ 909 data_start = chandef->center_freq1 - bw / 2; 910 /* control is 20Mhz width */ 911 control_start = chandef->chan->center_freq - 10; 912 913 return (control_start - data_start) / 80; 914 } 915 916 static bool iwl_mld_can_activate_link(struct iwl_mld *mld, 917 struct ieee80211_vif *vif, 918 struct ieee80211_bss_conf *link) 919 { 920 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 921 struct iwl_mld_sta *mld_sta; 922 struct iwl_mld_link_sta *link_sta; 923 924 /* In association, we activate the assoc link before adding the STA. */ 925 if (!mld_vif->ap_sta || !vif->cfg.assoc) 926 return true; 927 928 mld_sta = iwl_mld_sta_from_mac80211(mld_vif->ap_sta); 929 930 /* When switching links, we need to wait with the activation until the 931 * STA was added to the FW. It'll be activated in 932 * iwl_mld_update_link_stas 933 */ 934 link_sta = wiphy_dereference(mld->wiphy, mld_sta->link[link->link_id]); 935 936 /* In restart we can have a link_sta that doesn't exist in FW yet */ 937 return link_sta && link_sta->in_fw; 938 } 939 940 static 941 int iwl_mld_assign_vif_chanctx(struct ieee80211_hw *hw, 942 struct ieee80211_vif *vif, 943 struct ieee80211_bss_conf *link, 944 struct ieee80211_chanctx_conf *ctx) 945 { 946 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 947 struct iwl_mld_link *mld_link = iwl_mld_link_from_mac80211(link); 948 unsigned int n_active = iwl_mld_count_active_links(mld, vif); 949 int ret; 950 951 lockdep_assert_wiphy(mld->wiphy); 952 953 if (WARN_ON(!mld_link)) 954 return -EINVAL; 955 956 /* if the assigned one was not counted yet, count it now */ 957 if (!rcu_access_pointer(mld_link->chan_ctx)) { 958 n_active++; 959 960 /* Track addition of non-BSS link */ 961 if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) { 962 ret = iwl_mld_emlsr_check_non_bss_block(mld, 1); 963 if (ret) 964 return ret; 965 } 966 } 967 968 /* for AP, mac parameters such as HE support are updated at this stage. */ 969 if (vif->type == NL80211_IFTYPE_AP) { 970 ret = iwl_mld_mac_fw_action(mld, vif, FW_CTXT_ACTION_MODIFY); 971 972 if (ret) { 973 IWL_ERR(mld, "failed to update MAC %pM\n", vif->addr); 974 return -EINVAL; 975 } 976 } 977 978 rcu_assign_pointer(mld_link->chan_ctx, ctx); 979 980 if (n_active > 1) { 981 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 982 983 iwl_mld_leave_omi_bw_reduction(mld); 984 985 /* Indicate to mac80211 that EML is enabled */ 986 vif->driver_flags |= IEEE80211_VIF_EML_ACTIVE; 987 988 if (vif->active_links & BIT(mld_vif->emlsr.selected_links)) 989 mld_vif->emlsr.primary = mld_vif->emlsr.selected_primary; 990 else 991 mld_vif->emlsr.primary = __ffs(vif->active_links); 992 993 iwl_dbg_tlv_time_point(&mld->fwrt, IWL_FW_INI_TIME_ESR_LINK_UP, 994 NULL); 995 } 996 997 /* First send the link command with the phy context ID. 998 * Now that we have the phy, we know the band so also the rates 999 */ 1000 ret = iwl_mld_change_link_in_fw(mld, link, 1001 LINK_CONTEXT_MODIFY_RATES_INFO); 1002 if (ret) 1003 goto err; 1004 1005 /* TODO: Initialize rate control for the AP station, since we might be 1006 * doing a link switch here - we cannot initialize it before since 1007 * this needs the phy context assigned (and in FW?), and we cannot 1008 * do it later because it needs to be initialized as soon as we're 1009 * able to TX on the link, i.e. when active. (task=link-switch) 1010 */ 1011 1012 /* Now activate the link */ 1013 if (iwl_mld_can_activate_link(mld, vif, link)) { 1014 ret = iwl_mld_activate_link(mld, link); 1015 if (ret) 1016 goto err; 1017 } 1018 1019 if (vif->type == NL80211_IFTYPE_STATION) 1020 iwl_mld_send_ap_tx_power_constraint_cmd(mld, vif, link); 1021 1022 if (vif->type == NL80211_IFTYPE_MONITOR) { 1023 ret = iwl_mld_add_mon_sta(mld, vif, link); 1024 if (ret) 1025 goto deactivate_link; 1026 1027 mld->monitor.p80 = 1028 iwl_mld_chandef_get_primary_80(&vif->bss_conf.chanreq.oper); 1029 } 1030 1031 return 0; 1032 1033 deactivate_link: 1034 if (mld_link->active) 1035 iwl_mld_deactivate_link(mld, link); 1036 err: 1037 RCU_INIT_POINTER(mld_link->chan_ctx, NULL); 1038 return ret; 1039 } 1040 1041 static 1042 void iwl_mld_unassign_vif_chanctx(struct ieee80211_hw *hw, 1043 struct ieee80211_vif *vif, 1044 struct ieee80211_bss_conf *link, 1045 struct ieee80211_chanctx_conf *ctx) 1046 { 1047 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1048 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1049 struct iwl_mld_link *mld_link = iwl_mld_link_from_mac80211(link); 1050 unsigned int n_active = iwl_mld_count_active_links(mld, vif); 1051 1052 if (WARN_ON(!mld_link)) 1053 return; 1054 1055 /* Track removal of non-BSS link */ 1056 if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) 1057 iwl_mld_emlsr_check_non_bss_block(mld, -1); 1058 1059 iwl_mld_deactivate_link(mld, link); 1060 1061 if (vif->type == NL80211_IFTYPE_MONITOR) 1062 iwl_mld_remove_mon_sta(mld, vif, link); 1063 1064 if (n_active > 1) { 1065 /* Indicate to mac80211 that EML is disabled */ 1066 vif->driver_flags &= ~IEEE80211_VIF_EML_ACTIVE; 1067 1068 iwl_dbg_tlv_time_point(&mld->fwrt, 1069 IWL_FW_INI_TIME_ESR_LINK_DOWN, 1070 NULL); 1071 } 1072 1073 RCU_INIT_POINTER(mld_link->chan_ctx, NULL); 1074 1075 /* in the non-MLO case, remove/re-add the link to clean up FW state. 1076 * In MLO, it'll be done in drv_change_vif_link 1077 */ 1078 if (!ieee80211_vif_is_mld(vif) && !mld_vif->ap_sta && 1079 !WARN_ON_ONCE(vif->cfg.assoc) && 1080 vif->type != NL80211_IFTYPE_AP && !mld->fw_status.in_hw_restart) { 1081 iwl_mld_remove_link(mld, link); 1082 iwl_mld_add_link(mld, link); 1083 } 1084 } 1085 1086 static 1087 int iwl_mld_mac80211_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 1088 { 1089 return 0; 1090 } 1091 1092 static void 1093 iwl_mld_link_info_changed_ap_ibss(struct iwl_mld *mld, 1094 struct ieee80211_vif *vif, 1095 struct ieee80211_bss_conf *link, 1096 u64 changes) 1097 { 1098 u32 link_changes = 0; 1099 1100 if (changes & BSS_CHANGED_ERP_SLOT) 1101 link_changes |= LINK_CONTEXT_MODIFY_RATES_INFO; 1102 1103 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT)) 1104 link_changes |= LINK_CONTEXT_MODIFY_PROTECT_FLAGS; 1105 1106 if (changes & (BSS_CHANGED_QOS | BSS_CHANGED_BANDWIDTH)) 1107 link_changes |= LINK_CONTEXT_MODIFY_QOS_PARAMS; 1108 1109 if (changes & BSS_CHANGED_HE_BSS_COLOR) 1110 link_changes |= LINK_CONTEXT_MODIFY_HE_PARAMS; 1111 1112 if (link_changes) 1113 iwl_mld_change_link_in_fw(mld, link, link_changes); 1114 1115 if (changes & BSS_CHANGED_BEACON) 1116 iwl_mld_update_beacon_template(mld, vif, link); 1117 } 1118 1119 static 1120 u32 iwl_mld_link_changed_mapping(struct iwl_mld *mld, 1121 struct ieee80211_vif *vif, 1122 struct ieee80211_bss_conf *link_conf, 1123 u64 changes) 1124 { 1125 u32 link_changes = 0; 1126 bool has_he, has_eht; 1127 1128 if (changes & BSS_CHANGED_QOS && vif->cfg.assoc && link_conf->qos) 1129 link_changes |= LINK_CONTEXT_MODIFY_QOS_PARAMS; 1130 1131 if (changes & (BSS_CHANGED_ERP_PREAMBLE | BSS_CHANGED_BASIC_RATES | 1132 BSS_CHANGED_ERP_SLOT)) 1133 link_changes |= LINK_CONTEXT_MODIFY_RATES_INFO; 1134 1135 if (changes & (BSS_CHANGED_HT | BSS_CHANGED_ERP_CTS_PROT)) 1136 link_changes |= LINK_CONTEXT_MODIFY_PROTECT_FLAGS; 1137 1138 /* TODO: task=MLO check mac80211's HE flags and if command is needed 1139 * every time there's a link change. Currently used flags are 1140 * BSS_CHANGED_HE_OBSS_PD and BSS_CHANGED_HE_BSS_COLOR. 1141 */ 1142 has_he = link_conf->he_support && !iwlwifi_mod_params.disable_11ax; 1143 has_eht = link_conf->eht_support && !iwlwifi_mod_params.disable_11be; 1144 1145 if (vif->cfg.assoc && (has_he || has_eht)) { 1146 IWL_DEBUG_MAC80211(mld, "Associated in HE mode\n"); 1147 link_changes |= LINK_CONTEXT_MODIFY_HE_PARAMS; 1148 } 1149 1150 return link_changes; 1151 } 1152 1153 static void 1154 iwl_mld_mac80211_link_info_changed_sta(struct iwl_mld *mld, 1155 struct ieee80211_vif *vif, 1156 struct ieee80211_bss_conf *link_conf, 1157 u64 changes) 1158 { 1159 u32 link_changes = iwl_mld_link_changed_mapping(mld, vif, link_conf, 1160 changes); 1161 1162 if (link_changes) 1163 iwl_mld_change_link_in_fw(mld, link_conf, link_changes); 1164 1165 if (changes & BSS_CHANGED_TPE) 1166 iwl_mld_send_ap_tx_power_constraint_cmd(mld, vif, link_conf); 1167 1168 if (changes & BSS_CHANGED_BEACON_INFO) 1169 iwl_mld_update_mac_power(mld, vif, false); 1170 1171 /* The firmware will wait quite a while after association before it 1172 * starts filtering the beacons. We can safely enable beacon filtering 1173 * upon CQM configuration, even if we didn't get a beacon yet. 1174 */ 1175 if (changes & (BSS_CHANGED_CQM | BSS_CHANGED_BEACON_INFO)) 1176 iwl_mld_enable_beacon_filter(mld, link_conf, false); 1177 1178 /* If we have used OMI before to reduce bandwidth to 80 MHz and then 1179 * increased to 160 MHz again, and then the AP changes to 320 MHz, it 1180 * will think that we're limited to 160 MHz right now. Update it by 1181 * requesting a new OMI bandwidth. 1182 */ 1183 if (changes & BSS_CHANGED_BANDWIDTH) { 1184 enum ieee80211_sta_rx_bandwidth bw; 1185 1186 bw = ieee80211_chan_width_to_rx_bw(link_conf->chanreq.oper.width); 1187 1188 iwl_mld_omi_ap_changed_bw(mld, link_conf, bw); 1189 1190 } 1191 1192 if (changes & BSS_CHANGED_BANDWIDTH) 1193 iwl_mld_retry_emlsr(mld, vif); 1194 } 1195 1196 static int iwl_mld_update_mu_groups(struct iwl_mld *mld, 1197 struct ieee80211_bss_conf *link_conf) 1198 { 1199 struct iwl_mu_group_mgmt_cmd cmd = {}; 1200 1201 BUILD_BUG_ON(sizeof(cmd.membership_status) != 1202 sizeof(link_conf->mu_group.membership)); 1203 BUILD_BUG_ON(sizeof(cmd.user_position) != 1204 sizeof(link_conf->mu_group.position)); 1205 1206 memcpy(cmd.membership_status, link_conf->mu_group.membership, 1207 WLAN_MEMBERSHIP_LEN); 1208 memcpy(cmd.user_position, link_conf->mu_group.position, 1209 WLAN_USER_POSITION_LEN); 1210 1211 return iwl_mld_send_cmd_pdu(mld, 1212 WIDE_ID(DATA_PATH_GROUP, 1213 UPDATE_MU_GROUPS_CMD), 1214 &cmd); 1215 } 1216 1217 static void 1218 iwl_mld_mac80211_link_info_changed(struct ieee80211_hw *hw, 1219 struct ieee80211_vif *vif, 1220 struct ieee80211_bss_conf *link_conf, 1221 u64 changes) 1222 { 1223 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1224 1225 switch (vif->type) { 1226 case NL80211_IFTYPE_STATION: 1227 iwl_mld_mac80211_link_info_changed_sta(mld, vif, link_conf, 1228 changes); 1229 break; 1230 case NL80211_IFTYPE_AP: 1231 case NL80211_IFTYPE_ADHOC: 1232 iwl_mld_link_info_changed_ap_ibss(mld, vif, link_conf, 1233 changes); 1234 break; 1235 case NL80211_IFTYPE_MONITOR: 1236 /* The firmware tracks this on its own in STATION mode, but 1237 * obviously not in sniffer mode. 1238 */ 1239 if (changes & BSS_CHANGED_MU_GROUPS) 1240 iwl_mld_update_mu_groups(mld, link_conf); 1241 break; 1242 default: 1243 /* shouldn't happen */ 1244 WARN_ON_ONCE(1); 1245 } 1246 1247 /* We now know our BSSID, we can configure the MAC context with 1248 * eht_support if needed. 1249 */ 1250 if (changes & BSS_CHANGED_BSSID) 1251 iwl_mld_mac_fw_action(mld, vif, FW_CTXT_ACTION_MODIFY); 1252 1253 if (changes & BSS_CHANGED_TXPOWER) 1254 iwl_mld_set_tx_power(mld, link_conf, link_conf->txpower); 1255 } 1256 1257 static void 1258 iwl_mld_smps_workaround(struct iwl_mld *mld, struct ieee80211_vif *vif, bool enable) 1259 { 1260 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1261 bool workaround_required = 1262 iwl_fw_lookup_cmd_ver(mld->fw, MAC_PM_POWER_TABLE, 0) < 2; 1263 1264 if (!workaround_required) 1265 return; 1266 1267 /* Send the device-level power commands since the 1268 * firmware checks the POWER_TABLE_CMD's POWER_SAVE_EN bit to 1269 * determine SMPS mode. 1270 */ 1271 if (mld_vif->ps_disabled == !enable) 1272 return; 1273 1274 mld_vif->ps_disabled = !enable; 1275 1276 iwl_mld_update_device_power(mld, false); 1277 } 1278 1279 static 1280 void iwl_mld_mac80211_vif_cfg_changed(struct ieee80211_hw *hw, 1281 struct ieee80211_vif *vif, 1282 u64 changes) 1283 { 1284 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1285 int ret; 1286 1287 lockdep_assert_wiphy(mld->wiphy); 1288 1289 if (vif->type != NL80211_IFTYPE_STATION) 1290 return; 1291 1292 if (changes & BSS_CHANGED_ASSOC) { 1293 ret = iwl_mld_mac_fw_action(mld, vif, FW_CTXT_ACTION_MODIFY); 1294 if (ret) 1295 IWL_ERR(mld, "failed to update context\n"); 1296 1297 if (vif->cfg.assoc) { 1298 /* Clear statistics to get clean beacon counter, and 1299 * ask for periodic statistics, as they are needed for 1300 * link selection and RX OMI decisions. 1301 */ 1302 iwl_mld_clear_stats_in_fw(mld); 1303 iwl_mld_request_periodic_fw_stats(mld, true); 1304 1305 iwl_mld_set_vif_associated(mld, vif); 1306 } else { 1307 iwl_mld_request_periodic_fw_stats(mld, false); 1308 } 1309 } 1310 1311 if (changes & BSS_CHANGED_PS) { 1312 iwl_mld_smps_workaround(mld, vif, vif->cfg.ps); 1313 iwl_mld_update_mac_power(mld, vif, false); 1314 } 1315 1316 /* TODO: task=MLO BSS_CHANGED_MLD_VALID_LINKS/CHANGED_MLD_TTLM */ 1317 } 1318 1319 static int 1320 iwl_mld_mac80211_hw_scan(struct ieee80211_hw *hw, 1321 struct ieee80211_vif *vif, 1322 struct ieee80211_scan_request *hw_req) 1323 { 1324 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1325 1326 if (WARN_ON(!hw_req->req.n_channels || 1327 hw_req->req.n_channels > 1328 mld->fw->ucode_capa.n_scan_channels)) 1329 return -EINVAL; 1330 1331 return iwl_mld_regular_scan_start(mld, vif, &hw_req->req, &hw_req->ies); 1332 } 1333 1334 static void 1335 iwl_mld_mac80211_cancel_hw_scan(struct ieee80211_hw *hw, 1336 struct ieee80211_vif *vif) 1337 { 1338 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1339 1340 /* Due to a race condition, it's possible that mac80211 asks 1341 * us to stop a hw_scan when it's already stopped. This can 1342 * happen, for instance, if we stopped the scan ourselves, 1343 * called ieee80211_scan_completed() and the userspace called 1344 * cancel scan before ieee80211_scan_work() could run. 1345 * To handle that, simply return if the scan is not running. 1346 */ 1347 if (mld->scan.status & IWL_MLD_SCAN_REGULAR) 1348 iwl_mld_scan_stop(mld, IWL_MLD_SCAN_REGULAR, true); 1349 } 1350 1351 static int 1352 iwl_mld_mac80211_sched_scan_start(struct ieee80211_hw *hw, 1353 struct ieee80211_vif *vif, 1354 struct cfg80211_sched_scan_request *req, 1355 struct ieee80211_scan_ies *ies) 1356 { 1357 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1358 1359 return iwl_mld_sched_scan_start(mld, vif, req, ies, IWL_MLD_SCAN_SCHED); 1360 } 1361 1362 static int 1363 iwl_mld_mac80211_sched_scan_stop(struct ieee80211_hw *hw, 1364 struct ieee80211_vif *vif) 1365 { 1366 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1367 1368 /* Due to a race condition, it's possible that mac80211 asks 1369 * us to stop a sched_scan when it's already stopped. This 1370 * can happen, for instance, if we stopped the scan ourselves, 1371 * called ieee80211_sched_scan_stopped() and the userspace called 1372 * stop sched scan before ieee80211_sched_scan_stopped_work() 1373 * could run. To handle this, simply return if the scan is 1374 * not running. 1375 */ 1376 if (!(mld->scan.status & IWL_MLD_SCAN_SCHED)) 1377 return 0; 1378 1379 return iwl_mld_scan_stop(mld, IWL_MLD_SCAN_SCHED, false); 1380 } 1381 1382 static void 1383 iwl_mld_restart_complete_vif(void *data, u8 *mac, struct ieee80211_vif *vif) 1384 { 1385 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1386 struct ieee80211_bss_conf *link_conf; 1387 struct iwl_mld *mld = data; 1388 int link_id; 1389 1390 for_each_vif_active_link(vif, link_conf, link_id) { 1391 enum ieee80211_sta_rx_bandwidth bw; 1392 struct iwl_mld_link *mld_link; 1393 1394 mld_link = wiphy_dereference(mld->wiphy, 1395 mld_vif->link[link_id]); 1396 1397 if (WARN_ON_ONCE(!mld_link)) 1398 continue; 1399 1400 bw = mld_link->rx_omi.bw_in_progress; 1401 if (bw) 1402 iwl_mld_change_link_omi_bw(mld, link_conf, bw); 1403 } 1404 } 1405 1406 static void 1407 iwl_mld_mac80211_reconfig_complete(struct ieee80211_hw *hw, 1408 enum ieee80211_reconfig_type reconfig_type) 1409 { 1410 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1411 1412 switch (reconfig_type) { 1413 case IEEE80211_RECONFIG_TYPE_RESTART: 1414 mld->fw_status.in_hw_restart = false; 1415 iwl_mld_send_recovery_cmd(mld, ERROR_RECOVERY_END_OF_RECOVERY); 1416 1417 ieee80211_iterate_interfaces(mld->hw, 1418 IEEE80211_IFACE_ITER_NORMAL, 1419 iwl_mld_restart_complete_vif, mld); 1420 1421 iwl_trans_finish_sw_reset(mld->trans); 1422 /* no need to lock, adding in parallel would schedule too */ 1423 if (!list_empty(&mld->txqs_to_add)) 1424 wiphy_work_queue(mld->wiphy, &mld->add_txqs_wk); 1425 1426 IWL_INFO(mld, "restart completed\n"); 1427 break; 1428 case IEEE80211_RECONFIG_TYPE_SUSPEND: 1429 break; 1430 } 1431 } 1432 1433 static 1434 void iwl_mld_mac80211_mgd_prepare_tx(struct ieee80211_hw *hw, 1435 struct ieee80211_vif *vif, 1436 struct ieee80211_prep_tx_info *info) 1437 { 1438 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1439 u32 duration = IWL_MLD_SESSION_PROTECTION_ASSOC_TIME_MS; 1440 1441 /* After a successful association the connection is etalibeshed 1442 * and we can rely on the quota to send the disassociation frame. 1443 */ 1444 if (info->was_assoc) 1445 return; 1446 1447 if (info->duration > duration) 1448 duration = info->duration; 1449 1450 iwl_mld_schedule_session_protection(mld, vif, duration, 1451 IWL_MLD_SESSION_PROTECTION_MIN_TIME_MS, 1452 info->link_id); 1453 } 1454 1455 static 1456 void iwl_mld_mac_mgd_complete_tx(struct ieee80211_hw *hw, 1457 struct ieee80211_vif *vif, 1458 struct ieee80211_prep_tx_info *info) 1459 { 1460 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1461 1462 /* Successful authentication is the only case that requires to let 1463 * the session protection go. We'll need it for the upcoming 1464 * association. For all the other cases, we need to cancel the session 1465 * protection. 1466 * After successful association the connection is established and 1467 * further mgd tx can rely on the quota. 1468 */ 1469 if (info->success && info->subtype == IEEE80211_STYPE_AUTH) 1470 return; 1471 1472 /* The firmware will be on medium after we configure the vif as 1473 * associated. Removing the session protection allows the firmware 1474 * to stop being on medium. In order to ensure the continuity of our 1475 * presence on medium, we need first to configure the vif as associated 1476 * and only then, remove the session protection. 1477 * Currently, mac80211 calls vif_cfg_changed() first and then, 1478 * drv_mgd_complete_tx(). Ensure that this assumption stays true by 1479 * a warning. 1480 */ 1481 WARN_ON(info->success && 1482 (info->subtype == IEEE80211_STYPE_ASSOC_REQ || 1483 info->subtype == IEEE80211_STYPE_REASSOC_REQ) && 1484 !vif->cfg.assoc); 1485 1486 iwl_mld_cancel_session_protection(mld, vif, info->link_id); 1487 } 1488 1489 static int 1490 iwl_mld_mac80211_conf_tx(struct ieee80211_hw *hw, 1491 struct ieee80211_vif *vif, 1492 unsigned int link_id, u16 ac, 1493 const struct ieee80211_tx_queue_params *params) 1494 { 1495 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1496 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1497 struct iwl_mld_link *link; 1498 1499 lockdep_assert_wiphy(mld->wiphy); 1500 1501 link = iwl_mld_link_dereference_check(mld_vif, link_id); 1502 if (!link) 1503 return -EINVAL; 1504 1505 link->queue_params[ac] = *params; 1506 1507 /* No need to update right away, we'll get BSS_CHANGED_QOS 1508 * The exception is P2P_DEVICE interface which needs immediate update. 1509 */ 1510 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) 1511 iwl_mld_change_link_in_fw(mld, &vif->bss_conf, 1512 LINK_CONTEXT_MODIFY_QOS_PARAMS); 1513 1514 return 0; 1515 } 1516 1517 static void iwl_mld_set_uapsd(struct iwl_mld *mld, struct ieee80211_vif *vif) 1518 { 1519 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD; 1520 1521 if (vif->type != NL80211_IFTYPE_STATION) 1522 return; 1523 1524 if (vif->p2p && 1525 !(iwlwifi_mod_params.uapsd_disable & IWL_DISABLE_UAPSD_P2P_CLIENT)) 1526 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 1527 1528 if (!vif->p2p && 1529 !(iwlwifi_mod_params.uapsd_disable & IWL_DISABLE_UAPSD_BSS)) 1530 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 1531 } 1532 1533 int iwl_mld_tdls_sta_count(struct iwl_mld *mld) 1534 { 1535 int count = 0; 1536 1537 lockdep_assert_wiphy(mld->wiphy); 1538 1539 for (int i = 0; i < mld->fw->ucode_capa.num_stations; i++) { 1540 struct ieee80211_link_sta *link_sta; 1541 1542 link_sta = wiphy_dereference(mld->wiphy, 1543 mld->fw_id_to_link_sta[i]); 1544 if (IS_ERR_OR_NULL(link_sta)) 1545 continue; 1546 1547 if (!link_sta->sta->tdls) 1548 continue; 1549 1550 count++; 1551 } 1552 1553 return count; 1554 } 1555 1556 static void iwl_mld_check_he_obss_narrow_bw_ru_iter(struct wiphy *wiphy, 1557 struct cfg80211_bss *bss, 1558 void *_data) 1559 { 1560 bool *tolerated = _data; 1561 const struct cfg80211_bss_ies *ies; 1562 const struct element *elem; 1563 1564 rcu_read_lock(); 1565 ies = rcu_dereference(bss->ies); 1566 elem = cfg80211_find_elem(WLAN_EID_EXT_CAPABILITY, ies->data, 1567 ies->len); 1568 1569 if (!elem || elem->datalen < 10 || 1570 !(elem->data[10] & 1571 WLAN_EXT_CAPA10_OBSS_NARROW_BW_RU_TOLERANCE_SUPPORT)) { 1572 *tolerated = false; 1573 } 1574 rcu_read_unlock(); 1575 } 1576 1577 static void 1578 iwl_mld_check_he_obss_narrow_bw_ru(struct iwl_mld *mld, 1579 struct iwl_mld_link *mld_link, 1580 struct ieee80211_bss_conf *link_conf) 1581 { 1582 bool tolerated = true; 1583 1584 if (WARN_ON_ONCE(!link_conf->chanreq.oper.chan)) 1585 return; 1586 1587 if (!(link_conf->chanreq.oper.chan->flags & IEEE80211_CHAN_RADAR)) { 1588 mld_link->he_ru_2mhz_block = false; 1589 return; 1590 } 1591 1592 cfg80211_bss_iter(mld->wiphy, &link_conf->chanreq.oper, 1593 iwl_mld_check_he_obss_narrow_bw_ru_iter, &tolerated); 1594 1595 /* If there is at least one AP on radar channel that cannot 1596 * tolerate 26-tone RU UL OFDMA transmissions using HE TB PPDU. 1597 */ 1598 mld_link->he_ru_2mhz_block = !tolerated; 1599 } 1600 1601 static void iwl_mld_link_set_2mhz_block(struct iwl_mld *mld, 1602 struct ieee80211_vif *vif, 1603 struct ieee80211_sta *sta) 1604 { 1605 struct ieee80211_link_sta *link_sta; 1606 unsigned int link_id; 1607 1608 for_each_sta_active_link(vif, sta, link_sta, link_id) { 1609 struct ieee80211_bss_conf *link_conf = 1610 link_conf_dereference_protected(vif, link_id); 1611 struct iwl_mld_link *mld_link = 1612 iwl_mld_link_from_mac80211(link_conf); 1613 1614 if (WARN_ON(!link_conf || !mld_link)) 1615 continue; 1616 1617 if (link_sta->he_cap.has_he) 1618 iwl_mld_check_he_obss_narrow_bw_ru(mld, mld_link, 1619 link_conf); 1620 } 1621 } 1622 1623 static int iwl_mld_move_sta_state_up(struct iwl_mld *mld, 1624 struct ieee80211_vif *vif, 1625 struct ieee80211_sta *sta, 1626 enum ieee80211_sta_state old_state, 1627 enum ieee80211_sta_state new_state) 1628 { 1629 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1630 int tdls_count = 0; 1631 int ret; 1632 1633 if (old_state == IEEE80211_STA_NOTEXIST && 1634 new_state == IEEE80211_STA_NONE) { 1635 if (sta->tdls) { 1636 if (vif->p2p || hweight8(mld->used_phy_ids) != 1) 1637 return -EBUSY; 1638 1639 tdls_count = iwl_mld_tdls_sta_count(mld); 1640 if (tdls_count >= IWL_TDLS_STA_COUNT) 1641 return -EBUSY; 1642 } 1643 1644 /* 1645 * If this is the first STA (i.e. the AP) it won't do 1646 * anything, otherwise must leave for any new STA on 1647 * any other interface, or for TDLS, etc. 1648 * Need to call this _before_ adding the STA so it can 1649 * look up the one STA to use to ask mac80211 to leave 1650 * OMI; in the unlikely event that adding the new STA 1651 * then fails we'll just re-enter OMI later (via the 1652 * statistics notification handling.) 1653 */ 1654 iwl_mld_leave_omi_bw_reduction(mld); 1655 1656 ret = iwl_mld_add_sta(mld, sta, vif, STATION_TYPE_PEER); 1657 if (ret) 1658 return ret; 1659 1660 /* just added first TDLS STA, so disable PM */ 1661 if (sta->tdls && tdls_count == 0) 1662 iwl_mld_update_mac_power(mld, vif, false); 1663 1664 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) 1665 mld_vif->ap_sta = sta; 1666 1667 /* Initialize TLC here already - this really tells 1668 * the firmware only what the supported legacy rates are 1669 * (may be) since it's initialized already from what the 1670 * AP advertised in the beacon/probe response. This will 1671 * allow the firmware to send auth/assoc frames with one 1672 * of the supported rates already, rather than having to 1673 * use a mandatory rate. 1674 * If we're the AP, we'll just assume mandatory rates at 1675 * this point, but we know nothing about the STA anyway. 1676 */ 1677 iwl_mld_config_tlc(mld, vif, sta); 1678 1679 return ret; 1680 } else if (old_state == IEEE80211_STA_NONE && 1681 new_state == IEEE80211_STA_AUTH) { 1682 iwl_mld_set_uapsd(mld, vif); 1683 return 0; 1684 } else if (old_state == IEEE80211_STA_AUTH && 1685 new_state == IEEE80211_STA_ASSOC) { 1686 ret = iwl_mld_update_all_link_stations(mld, sta); 1687 1688 if (vif->type == NL80211_IFTYPE_STATION) 1689 iwl_mld_link_set_2mhz_block(mld, vif, sta); 1690 /* Now the link_sta's capabilities are set, update the FW */ 1691 iwl_mld_config_tlc(mld, vif, sta); 1692 1693 if (vif->type == NL80211_IFTYPE_AP) { 1694 /* Update MAC_CFG_FILTER_ACCEPT_BEACON if at least 1695 * one sta is associated 1696 */ 1697 if (++mld_vif->num_associated_stas == 1) 1698 ret = iwl_mld_mac_fw_action(mld, vif, 1699 FW_CTXT_ACTION_MODIFY); 1700 } 1701 1702 return ret; 1703 } else if (old_state == IEEE80211_STA_ASSOC && 1704 new_state == IEEE80211_STA_AUTHORIZED) { 1705 ret = 0; 1706 1707 if (!sta->tdls) { 1708 mld_vif->authorized = true; 1709 1710 /* Ensure any block due to a non-BSS link is synced */ 1711 iwl_mld_emlsr_check_non_bss_block(mld, 0); 1712 1713 /* Block EMLSR until a certain throughput it reached */ 1714 if (!mld->fw_status.in_hw_restart && 1715 IWL_MLD_ENTER_EMLSR_TPT_THRESH > 0) 1716 iwl_mld_block_emlsr(mld_vif->mld, vif, 1717 IWL_MLD_EMLSR_BLOCKED_TPT, 1718 0); 1719 1720 /* clear COEX_HIGH_PRIORITY_ENABLE */ 1721 ret = iwl_mld_mac_fw_action(mld, vif, 1722 FW_CTXT_ACTION_MODIFY); 1723 if (ret) 1724 return ret; 1725 iwl_mld_smps_workaround(mld, vif, vif->cfg.ps); 1726 } 1727 1728 /* MFP is set by default before the station is authorized. 1729 * Clear it here in case it's not used. 1730 */ 1731 if (!sta->mfp) 1732 ret = iwl_mld_update_all_link_stations(mld, sta); 1733 1734 /* We can use wide bandwidth now, not only 20 MHz */ 1735 iwl_mld_config_tlc(mld, vif, sta); 1736 1737 return ret; 1738 } else { 1739 return -EINVAL; 1740 } 1741 } 1742 1743 static int iwl_mld_move_sta_state_down(struct iwl_mld *mld, 1744 struct ieee80211_vif *vif, 1745 struct ieee80211_sta *sta, 1746 enum ieee80211_sta_state old_state, 1747 enum ieee80211_sta_state new_state) 1748 { 1749 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1750 1751 if (old_state == IEEE80211_STA_AUTHORIZED && 1752 new_state == IEEE80211_STA_ASSOC) { 1753 if (!sta->tdls) { 1754 mld_vif->authorized = false; 1755 1756 memset(&mld_vif->emlsr.zeroed_on_not_authorized, 0, 1757 sizeof(mld_vif->emlsr.zeroed_on_not_authorized)); 1758 1759 wiphy_delayed_work_cancel(mld->wiphy, 1760 &mld_vif->emlsr.prevent_done_wk); 1761 wiphy_delayed_work_cancel(mld->wiphy, 1762 &mld_vif->emlsr.tmp_non_bss_done_wk); 1763 wiphy_work_cancel(mld->wiphy, &mld_vif->emlsr.unblock_tpt_wk); 1764 wiphy_delayed_work_cancel(mld->wiphy, 1765 &mld_vif->emlsr.check_tpt_wk); 1766 1767 iwl_mld_reset_cca_40mhz_workaround(mld, vif); 1768 iwl_mld_smps_workaround(mld, vif, true); 1769 } 1770 1771 /* once we move into assoc state, need to update the FW to 1772 * stop using wide bandwidth 1773 */ 1774 iwl_mld_config_tlc(mld, vif, sta); 1775 } else if (old_state == IEEE80211_STA_ASSOC && 1776 new_state == IEEE80211_STA_AUTH) { 1777 if (vif->type == NL80211_IFTYPE_AP && 1778 !WARN_ON(!mld_vif->num_associated_stas)) { 1779 /* Update MAC_CFG_FILTER_ACCEPT_BEACON if the last sta 1780 * is disassociating 1781 */ 1782 if (--mld_vif->num_associated_stas == 0) 1783 iwl_mld_mac_fw_action(mld, vif, 1784 FW_CTXT_ACTION_MODIFY); 1785 } 1786 } else if (old_state == IEEE80211_STA_AUTH && 1787 new_state == IEEE80211_STA_NONE) { 1788 /* nothing */ 1789 } else if (old_state == IEEE80211_STA_NONE && 1790 new_state == IEEE80211_STA_NOTEXIST) { 1791 iwl_mld_remove_sta(mld, sta); 1792 1793 if (sta->tdls && iwl_mld_tdls_sta_count(mld) == 0) { 1794 /* just removed last TDLS STA, so enable PM */ 1795 iwl_mld_update_mac_power(mld, vif, false); 1796 } 1797 } else { 1798 return -EINVAL; 1799 } 1800 return 0; 1801 } 1802 1803 static int iwl_mld_mac80211_sta_state(struct ieee80211_hw *hw, 1804 struct ieee80211_vif *vif, 1805 struct ieee80211_sta *sta, 1806 enum ieee80211_sta_state old_state, 1807 enum ieee80211_sta_state new_state) 1808 { 1809 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1810 struct iwl_mld_sta *mld_sta = iwl_mld_sta_from_mac80211(sta); 1811 1812 IWL_DEBUG_MAC80211(mld, "station %pM state change %d->%d\n", 1813 sta->addr, old_state, new_state); 1814 1815 mld_sta->sta_state = new_state; 1816 1817 if (old_state < new_state) 1818 return iwl_mld_move_sta_state_up(mld, vif, sta, old_state, 1819 new_state); 1820 else 1821 return iwl_mld_move_sta_state_down(mld, vif, sta, old_state, 1822 new_state); 1823 } 1824 1825 static void iwl_mld_mac80211_flush(struct ieee80211_hw *hw, 1826 struct ieee80211_vif *vif, 1827 u32 queues, bool drop) 1828 { 1829 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1830 1831 /* Make sure we're done with the deferred traffic before flushing */ 1832 iwl_mld_add_txq_list(mld); 1833 1834 for (int i = 0; i < mld->fw->ucode_capa.num_stations; i++) { 1835 struct ieee80211_link_sta *link_sta = 1836 wiphy_dereference(mld->wiphy, 1837 mld->fw_id_to_link_sta[i]); 1838 1839 if (IS_ERR_OR_NULL(link_sta)) 1840 continue; 1841 1842 /* Check that the sta belongs to the given vif */ 1843 if (vif && vif != iwl_mld_sta_from_mac80211(link_sta->sta)->vif) 1844 continue; 1845 1846 if (drop) 1847 iwl_mld_flush_sta_txqs(mld, link_sta->sta); 1848 else 1849 iwl_mld_wait_sta_txqs_empty(mld, link_sta->sta); 1850 } 1851 } 1852 1853 static void iwl_mld_mac80211_flush_sta(struct ieee80211_hw *hw, 1854 struct ieee80211_vif *vif, 1855 struct ieee80211_sta *sta) 1856 { 1857 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1858 1859 iwl_mld_flush_sta_txqs(mld, sta); 1860 } 1861 1862 static int 1863 iwl_mld_mac80211_ampdu_action(struct ieee80211_hw *hw, 1864 struct ieee80211_vif *vif, 1865 struct ieee80211_ampdu_params *params) 1866 { 1867 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1868 struct ieee80211_sta *sta = params->sta; 1869 enum ieee80211_ampdu_mlme_action action = params->action; 1870 u16 tid = params->tid; 1871 u16 ssn = params->ssn; 1872 u16 buf_size = params->buf_size; 1873 u16 timeout = params->timeout; 1874 int ret; 1875 1876 IWL_DEBUG_HT(mld, "A-MPDU action on addr %pM tid: %d action: %d\n", 1877 sta->addr, tid, action); 1878 1879 switch (action) { 1880 case IEEE80211_AMPDU_RX_START: 1881 ret = iwl_mld_ampdu_rx_start(mld, sta, tid, ssn, buf_size, 1882 timeout); 1883 break; 1884 case IEEE80211_AMPDU_RX_STOP: 1885 ret = iwl_mld_ampdu_rx_stop(mld, sta, tid); 1886 break; 1887 default: 1888 /* The mac80211 TX_AMPDU_SETUP_IN_HW flag is set for all 1889 * devices, since all support TX A-MPDU offload in hardware. 1890 * Therefore, no TX action should be requested here. 1891 */ 1892 WARN_ON_ONCE(1); 1893 return -EINVAL; 1894 } 1895 1896 return ret; 1897 } 1898 1899 static bool iwl_mld_can_hw_csum(struct sk_buff *skb) 1900 { 1901 u8 protocol = ip_hdr(skb)->protocol; 1902 1903 return protocol == IPPROTO_TCP || protocol == IPPROTO_UDP; 1904 } 1905 1906 static bool iwl_mld_mac80211_can_aggregate(struct ieee80211_hw *hw, 1907 struct sk_buff *head, 1908 struct sk_buff *skb) 1909 { 1910 if (!IS_ENABLED(CONFIG_INET)) 1911 return false; 1912 1913 /* For now don't aggregate IPv6 in AMSDU */ 1914 if (skb->protocol != htons(ETH_P_IP)) 1915 return false; 1916 1917 /* Allow aggregation only if both frames have the same HW csum offload 1918 * capability, ensuring consistent HW or SW csum handling in A-MSDU. 1919 */ 1920 return iwl_mld_can_hw_csum(skb) == iwl_mld_can_hw_csum(head); 1921 } 1922 1923 static void iwl_mld_mac80211_sync_rx_queues(struct ieee80211_hw *hw) 1924 { 1925 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1926 1927 iwl_mld_sync_rx_queues(mld, IWL_MLD_RXQ_EMPTY, NULL, 0); 1928 } 1929 1930 static void iwl_mld_sta_rc_update(struct ieee80211_hw *hw, 1931 struct ieee80211_vif *vif, 1932 struct ieee80211_link_sta *link_sta, 1933 u32 changed) 1934 { 1935 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1936 1937 if (changed & (IEEE80211_RC_BW_CHANGED | 1938 IEEE80211_RC_SUPP_RATES_CHANGED | 1939 IEEE80211_RC_NSS_CHANGED)) { 1940 struct ieee80211_bss_conf *link = 1941 link_conf_dereference_check(vif, link_sta->link_id); 1942 1943 if (WARN_ON(!link)) 1944 return; 1945 1946 iwl_mld_config_tlc_link(mld, vif, link, link_sta); 1947 } 1948 } 1949 1950 #ifdef CONFIG_PM_SLEEP 1951 static void iwl_mld_set_wakeup(struct ieee80211_hw *hw, bool enabled) 1952 { 1953 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1954 1955 device_set_wakeup_enable(mld->trans->dev, enabled); 1956 } 1957 1958 /* Returns 0 on success. 1 if failed to suspend with wowlan: 1959 * If the circumstances didn't satisfy the conditions for suspension 1960 * with wowlan, mac80211 would use the no_wowlan flow. 1961 * If an error had occurred we update the trans status and state here 1962 * and the result will be stopping the FW. 1963 */ 1964 static int 1965 iwl_mld_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan) 1966 { 1967 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1968 int ret; 1969 1970 iwl_fw_runtime_suspend(&mld->fwrt); 1971 1972 ret = iwl_mld_wowlan_suspend(mld, wowlan); 1973 if (ret) { 1974 if (ret < 0) { 1975 mld->trans->state = IWL_TRANS_NO_FW; 1976 set_bit(STATUS_FW_ERROR, &mld->trans->status); 1977 } 1978 return 1; 1979 } 1980 1981 if (iwl_mld_no_wowlan_suspend(mld)) 1982 return 1; 1983 1984 return 0; 1985 } 1986 1987 static int iwl_mld_resume(struct ieee80211_hw *hw) 1988 { 1989 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1990 int ret; 1991 1992 ret = iwl_mld_wowlan_resume(mld); 1993 if (ret) 1994 return ret; 1995 1996 iwl_fw_runtime_resume(&mld->fwrt); 1997 1998 iwl_mld_low_latency_restart(mld); 1999 2000 return 0; 2001 } 2002 #endif 2003 2004 static int iwl_mld_alloc_ptk_pn(struct iwl_mld *mld, 2005 struct iwl_mld_sta *mld_sta, 2006 struct ieee80211_key_conf *key, 2007 struct iwl_mld_ptk_pn **ptk_pn) 2008 { 2009 u8 num_rx_queues = mld->trans->num_rx_queues; 2010 int keyidx = key->keyidx; 2011 struct ieee80211_key_seq seq; 2012 2013 if (WARN_ON(keyidx >= ARRAY_SIZE(mld_sta->ptk_pn))) 2014 return -EINVAL; 2015 2016 WARN_ON(rcu_access_pointer(mld_sta->ptk_pn[keyidx])); 2017 *ptk_pn = kzalloc(struct_size(*ptk_pn, q, num_rx_queues), 2018 GFP_KERNEL); 2019 if (!*ptk_pn) 2020 return -ENOMEM; 2021 2022 for (u8 tid = 0; tid < IWL_MAX_TID_COUNT; tid++) { 2023 ieee80211_get_key_rx_seq(key, tid, &seq); 2024 for (u8 q = 0; q < num_rx_queues; q++) 2025 memcpy((*ptk_pn)->q[q].pn[tid], seq.ccmp.pn, 2026 IEEE80211_CCMP_PN_LEN); 2027 } 2028 2029 rcu_assign_pointer(mld_sta->ptk_pn[keyidx], *ptk_pn); 2030 2031 return 0; 2032 } 2033 2034 static int iwl_mld_set_key_add(struct iwl_mld *mld, 2035 struct ieee80211_vif *vif, 2036 struct ieee80211_sta *sta, 2037 struct ieee80211_key_conf *key) 2038 { 2039 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2040 struct iwl_mld_sta *mld_sta = 2041 sta ? iwl_mld_sta_from_mac80211(sta) : NULL; 2042 struct iwl_mld_ptk_pn *ptk_pn = NULL; 2043 int keyidx = key->keyidx; 2044 int ret; 2045 2046 /* Will be set to 0 if added successfully */ 2047 key->hw_key_idx = STA_KEY_IDX_INVALID; 2048 2049 switch (key->cipher) { 2050 case WLAN_CIPHER_SUITE_WEP40: 2051 case WLAN_CIPHER_SUITE_WEP104: 2052 IWL_DEBUG_MAC80211(mld, "Use SW encryption for WEP\n"); 2053 return -EOPNOTSUPP; 2054 case WLAN_CIPHER_SUITE_TKIP: 2055 if (vif->type == NL80211_IFTYPE_STATION) { 2056 key->flags |= IEEE80211_KEY_FLAG_PUT_MIC_SPACE; 2057 break; 2058 } 2059 IWL_DEBUG_MAC80211(mld, "Use SW encryption for TKIP\n"); 2060 return -EOPNOTSUPP; 2061 case WLAN_CIPHER_SUITE_CCMP: 2062 case WLAN_CIPHER_SUITE_GCMP: 2063 case WLAN_CIPHER_SUITE_GCMP_256: 2064 case WLAN_CIPHER_SUITE_AES_CMAC: 2065 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 2066 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 2067 break; 2068 default: 2069 return -EOPNOTSUPP; 2070 } 2071 2072 if (vif->type == NL80211_IFTYPE_STATION && 2073 (keyidx == 6 || keyidx == 7)) 2074 rcu_assign_pointer(mld_vif->bigtks[keyidx - 6], key); 2075 2076 /* After exiting from RFKILL, hostapd configures GTK/ITGK before the 2077 * AP is started, but those keys can't be sent to the FW before the 2078 * MCAST/BCAST STAs are added to it (which happens upon AP start). 2079 * Store it here to be sent later when the AP is started. 2080 */ 2081 if ((vif->type == NL80211_IFTYPE_ADHOC || 2082 vif->type == NL80211_IFTYPE_AP) && !sta && 2083 !mld_vif->ap_ibss_active) 2084 return iwl_mld_store_ap_early_key(mld, key, mld_vif); 2085 2086 if (!mld->fw_status.in_hw_restart && mld_sta && 2087 key->flags & IEEE80211_KEY_FLAG_PAIRWISE && 2088 (key->cipher == WLAN_CIPHER_SUITE_CCMP || 2089 key->cipher == WLAN_CIPHER_SUITE_GCMP || 2090 key->cipher == WLAN_CIPHER_SUITE_GCMP_256)) { 2091 ret = iwl_mld_alloc_ptk_pn(mld, mld_sta, key, &ptk_pn); 2092 if (ret) 2093 return ret; 2094 } 2095 2096 IWL_DEBUG_MAC80211(mld, "set hwcrypto key (sta:%pM, id:%d)\n", 2097 sta ? sta->addr : NULL, keyidx); 2098 2099 ret = iwl_mld_add_key(mld, vif, sta, key); 2100 if (ret) { 2101 IWL_WARN(mld, "set key failed (%d)\n", ret); 2102 if (ptk_pn) { 2103 RCU_INIT_POINTER(mld_sta->ptk_pn[keyidx], NULL); 2104 kfree(ptk_pn); 2105 } 2106 2107 return -EOPNOTSUPP; 2108 } 2109 2110 return 0; 2111 } 2112 2113 static void iwl_mld_set_key_remove(struct iwl_mld *mld, 2114 struct ieee80211_vif *vif, 2115 struct ieee80211_sta *sta, 2116 struct ieee80211_key_conf *key) 2117 { 2118 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2119 struct iwl_mld_sta *mld_sta = 2120 sta ? iwl_mld_sta_from_mac80211(sta) : NULL; 2121 int keyidx = key->keyidx; 2122 2123 if (vif->type == NL80211_IFTYPE_STATION && 2124 (keyidx == 6 || keyidx == 7)) 2125 RCU_INIT_POINTER(mld_vif->bigtks[keyidx - 6], NULL); 2126 2127 if (mld_sta && key->flags & IEEE80211_KEY_FLAG_PAIRWISE && 2128 (key->cipher == WLAN_CIPHER_SUITE_CCMP || 2129 key->cipher == WLAN_CIPHER_SUITE_GCMP || 2130 key->cipher == WLAN_CIPHER_SUITE_GCMP_256)) { 2131 struct iwl_mld_ptk_pn *ptk_pn; 2132 2133 if (WARN_ON(keyidx >= ARRAY_SIZE(mld_sta->ptk_pn))) 2134 return; 2135 2136 ptk_pn = wiphy_dereference(mld->wiphy, 2137 mld_sta->ptk_pn[keyidx]); 2138 RCU_INIT_POINTER(mld_sta->ptk_pn[keyidx], NULL); 2139 if (!WARN_ON(!ptk_pn)) 2140 kfree_rcu(ptk_pn, rcu_head); 2141 } 2142 2143 /* if this key was stored to be added later to the FW - free it here */ 2144 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 2145 iwl_mld_free_ap_early_key(mld, key, mld_vif); 2146 2147 /* We already removed it */ 2148 if (key->hw_key_idx == STA_KEY_IDX_INVALID) 2149 return; 2150 2151 IWL_DEBUG_MAC80211(mld, "disable hwcrypto key\n"); 2152 2153 iwl_mld_remove_key(mld, vif, sta, key); 2154 } 2155 2156 static int iwl_mld_mac80211_set_key(struct ieee80211_hw *hw, 2157 enum set_key_cmd cmd, 2158 struct ieee80211_vif *vif, 2159 struct ieee80211_sta *sta, 2160 struct ieee80211_key_conf *key) 2161 { 2162 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2163 int ret; 2164 2165 switch (cmd) { 2166 case SET_KEY: 2167 ret = iwl_mld_set_key_add(mld, vif, sta, key); 2168 if (ret) 2169 ret = -EOPNOTSUPP; 2170 break; 2171 case DISABLE_KEY: 2172 iwl_mld_set_key_remove(mld, vif, sta, key); 2173 ret = 0; 2174 break; 2175 default: 2176 ret = -EINVAL; 2177 break; 2178 } 2179 2180 return ret; 2181 } 2182 2183 static int 2184 iwl_mld_pre_channel_switch(struct ieee80211_hw *hw, 2185 struct ieee80211_vif *vif, 2186 struct ieee80211_channel_switch *chsw) 2187 { 2188 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2189 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2190 struct iwl_mld_link *mld_link = 2191 iwl_mld_link_dereference_check(mld_vif, chsw->link_id); 2192 u8 primary; 2193 int selected; 2194 2195 lockdep_assert_wiphy(mld->wiphy); 2196 2197 if (WARN_ON(!mld_link)) 2198 return -EINVAL; 2199 2200 IWL_DEBUG_MAC80211(mld, "pre CSA to freq %d\n", 2201 chsw->chandef.center_freq1); 2202 2203 if (!iwl_mld_emlsr_active(vif)) 2204 return 0; 2205 2206 primary = iwl_mld_get_primary_link(vif); 2207 2208 /* stay on the primary link unless it is undergoing a CSA with quiet */ 2209 if (chsw->link_id == primary && chsw->block_tx) 2210 selected = iwl_mld_get_other_link(vif, primary); 2211 else 2212 selected = primary; 2213 2214 /* Remember to tell the firmware that this link can't tx 2215 * Note that this logic seems to be unrelated to emlsr, but it 2216 * really is needed only when emlsr is active. When we have a 2217 * single link, the firmware will handle all this on its own. 2218 * In multi-link scenarios, we can learn about the CSA from 2219 * another link and this logic is too complex for the firmware 2220 * to track. 2221 * Since we want to de-activate the link that got a CSA with mode=1, 2222 * we need to tell the firmware not to send any frame on that link 2223 * as the firmware may not be aware that link is under a CSA 2224 * with mode=1 (no Tx allowed). 2225 */ 2226 mld_link->silent_deactivation = chsw->block_tx; 2227 iwl_mld_exit_emlsr(mld, vif, IWL_MLD_EMLSR_EXIT_CSA, selected); 2228 2229 return 0; 2230 } 2231 2232 static void 2233 iwl_mld_channel_switch(struct ieee80211_hw *hw, 2234 struct ieee80211_vif *vif, 2235 struct ieee80211_channel_switch *chsw) 2236 { 2237 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2238 2239 /* By implementing this operation, we prevent mac80211 from 2240 * starting its own channel switch timer, so that we can call 2241 * ieee80211_chswitch_done() ourselves at the right time 2242 * (Upon receiving the channel_switch_start notification from the fw) 2243 */ 2244 IWL_DEBUG_MAC80211(mld, 2245 "dummy channel switch op\n"); 2246 } 2247 2248 static int 2249 iwl_mld_post_channel_switch(struct ieee80211_hw *hw, 2250 struct ieee80211_vif *vif, 2251 struct ieee80211_bss_conf *link_conf) 2252 { 2253 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2254 struct iwl_mld_link *mld_link = iwl_mld_link_from_mac80211(link_conf); 2255 2256 lockdep_assert_wiphy(mld->wiphy); 2257 2258 WARN_ON(mld_link->silent_deactivation); 2259 2260 return 0; 2261 } 2262 2263 static void 2264 iwl_mld_abort_channel_switch(struct ieee80211_hw *hw, 2265 struct ieee80211_vif *vif, 2266 struct ieee80211_bss_conf *link_conf) 2267 { 2268 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2269 struct iwl_mld_link *mld_link = iwl_mld_link_from_mac80211(link_conf); 2270 2271 IWL_DEBUG_MAC80211(mld, 2272 "abort channel switch op\n"); 2273 mld_link->silent_deactivation = false; 2274 } 2275 2276 static int 2277 iwl_mld_switch_vif_chanctx_swap(struct ieee80211_hw *hw, 2278 struct ieee80211_vif_chanctx_switch *vifs) 2279 { 2280 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2281 int ret; 2282 2283 iwl_mld_unassign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2284 vifs[0].old_ctx); 2285 iwl_mld_remove_chanctx(hw, vifs[0].old_ctx); 2286 2287 ret = iwl_mld_add_chanctx(hw, vifs[0].new_ctx); 2288 if (ret) { 2289 IWL_ERR(mld, "failed to add new_ctx during channel switch\n"); 2290 goto out_reassign; 2291 } 2292 2293 ret = iwl_mld_assign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2294 vifs[0].new_ctx); 2295 if (ret) { 2296 IWL_ERR(mld, 2297 "failed to assign new_ctx during channel switch\n"); 2298 goto out_remove; 2299 } 2300 2301 return 0; 2302 2303 out_remove: 2304 iwl_mld_remove_chanctx(hw, vifs[0].new_ctx); 2305 out_reassign: 2306 if (iwl_mld_add_chanctx(hw, vifs[0].old_ctx)) { 2307 IWL_ERR(mld, "failed to add old_ctx after failure\n"); 2308 return ret; 2309 } 2310 2311 if (iwl_mld_assign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2312 vifs[0].old_ctx)) 2313 IWL_ERR(mld, "failed to reassign old_ctx after failure\n"); 2314 2315 return ret; 2316 } 2317 2318 static int 2319 iwl_mld_switch_vif_chanctx_reassign(struct ieee80211_hw *hw, 2320 struct ieee80211_vif_chanctx_switch *vifs) 2321 { 2322 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2323 int ret; 2324 2325 iwl_mld_unassign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2326 vifs[0].old_ctx); 2327 ret = iwl_mld_assign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2328 vifs[0].new_ctx); 2329 if (ret) { 2330 IWL_ERR(mld, 2331 "failed to assign new_ctx during channel switch\n"); 2332 goto out_reassign; 2333 } 2334 2335 return 0; 2336 2337 out_reassign: 2338 if (iwl_mld_assign_vif_chanctx(hw, vifs[0].vif, vifs[0].link_conf, 2339 vifs[0].old_ctx)) 2340 IWL_ERR(mld, "failed to reassign old_ctx after failure\n"); 2341 2342 return ret; 2343 } 2344 2345 static int 2346 iwl_mld_switch_vif_chanctx(struct ieee80211_hw *hw, 2347 struct ieee80211_vif_chanctx_switch *vifs, 2348 int n_vifs, 2349 enum ieee80211_chanctx_switch_mode mode) 2350 { 2351 int ret; 2352 2353 /* we only support a single-vif right now */ 2354 if (n_vifs > 1) 2355 return -EOPNOTSUPP; 2356 2357 switch (mode) { 2358 case CHANCTX_SWMODE_SWAP_CONTEXTS: 2359 ret = iwl_mld_switch_vif_chanctx_swap(hw, vifs); 2360 break; 2361 case CHANCTX_SWMODE_REASSIGN_VIF: 2362 ret = iwl_mld_switch_vif_chanctx_reassign(hw, vifs); 2363 break; 2364 default: 2365 ret = -EOPNOTSUPP; 2366 break; 2367 } 2368 2369 return ret; 2370 } 2371 2372 static void iwl_mld_sta_pre_rcu_remove(struct ieee80211_hw *hw, 2373 struct ieee80211_vif *vif, 2374 struct ieee80211_sta *sta) 2375 { 2376 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2377 struct iwl_mld_sta *mld_sta = iwl_mld_sta_from_mac80211(sta); 2378 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2379 struct iwl_mld_link_sta *mld_link_sta; 2380 u8 link_id; 2381 2382 lockdep_assert_wiphy(mld->wiphy); 2383 2384 /* This is called before mac80211 does RCU synchronisation, 2385 * so here we already invalidate our internal RCU-protected 2386 * station pointer. The rest of the code will thus no longer 2387 * be able to find the station this way, and we don't rely 2388 * on further RCU synchronisation after the sta_state() 2389 * callback deleted the station. 2390 */ 2391 for_each_mld_link_sta(mld_sta, mld_link_sta, link_id) 2392 RCU_INIT_POINTER(mld->fw_id_to_link_sta[mld_link_sta->fw_id], 2393 NULL); 2394 2395 if (sta == mld_vif->ap_sta) 2396 mld_vif->ap_sta = NULL; 2397 } 2398 2399 static void 2400 iwl_mld_mac80211_mgd_protect_tdls_discover(struct ieee80211_hw *hw, 2401 struct ieee80211_vif *vif, 2402 unsigned int link_id) 2403 { 2404 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2405 struct ieee80211_bss_conf *link_conf; 2406 u32 duration; 2407 int ret; 2408 2409 link_conf = wiphy_dereference(hw->wiphy, vif->link_conf[link_id]); 2410 if (WARN_ON_ONCE(!link_conf)) 2411 return; 2412 2413 /* Protect the session to hear the TDLS setup response on the channel */ 2414 2415 duration = 2 * link_conf->dtim_period * link_conf->beacon_int; 2416 2417 ret = iwl_mld_start_session_protection(mld, vif, duration, duration, 2418 link_id, HZ / 5); 2419 if (ret) 2420 IWL_ERR(mld, 2421 "Failed to start session protection for TDLS: %d\n", 2422 ret); 2423 } 2424 2425 static bool iwl_mld_can_activate_links(struct ieee80211_hw *hw, 2426 struct ieee80211_vif *vif, 2427 u16 desired_links) 2428 { 2429 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2430 int n_links = hweight16(desired_links); 2431 2432 /* Check if HW supports the wanted number of links */ 2433 return n_links <= iwl_mld_max_active_links(mld, vif); 2434 } 2435 2436 static int 2437 iwl_mld_change_vif_links(struct ieee80211_hw *hw, 2438 struct ieee80211_vif *vif, 2439 u16 old_links, u16 new_links, 2440 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 2441 { 2442 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2443 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2444 struct ieee80211_bss_conf *link_conf; 2445 u16 removed = old_links & ~new_links; 2446 u16 added = new_links & ~old_links; 2447 int err; 2448 2449 lockdep_assert_wiphy(mld->wiphy); 2450 2451 /* 2452 * No bits designate non-MLO mode. We can handle MLO exit/enter by 2453 * simply mapping that to link ID zero internally. 2454 * Note that mac80211 does such a non-MLO to MLO switch during restart 2455 * if it was in MLO before. In that case, we do not have a link to 2456 * remove. 2457 */ 2458 if (old_links == 0 && !mld->fw_status.in_hw_restart) 2459 removed |= BIT(0); 2460 2461 if (new_links == 0) 2462 added |= BIT(0); 2463 2464 for (int i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 2465 if (removed & BIT(i) && !WARN_ON(!old[i])) 2466 iwl_mld_remove_link(mld, old[i]); 2467 } 2468 2469 for (int i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 2470 if (added & BIT(i)) { 2471 link_conf = link_conf_dereference_protected(vif, i); 2472 if (!link_conf) { 2473 err = -EINVAL; 2474 goto remove_added_links; 2475 } 2476 2477 err = iwl_mld_add_link(mld, link_conf); 2478 if (err) 2479 goto remove_added_links; 2480 } 2481 } 2482 2483 /* 2484 * Ensure we always have a valid primary_link. When using multiple 2485 * links the proper value is set in assign_vif_chanctx. 2486 */ 2487 mld_vif->emlsr.primary = new_links ? __ffs(new_links) : 0; 2488 2489 /* 2490 * Special MLO restart case. We did not have a link when the interface 2491 * was added, so do the power configuration now. 2492 */ 2493 if (old_links == 0 && mld->fw_status.in_hw_restart) 2494 iwl_mld_update_mac_power(mld, vif, false); 2495 2496 return 0; 2497 2498 remove_added_links: 2499 for (int i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 2500 if (!(added & BIT(i))) 2501 continue; 2502 2503 link_conf = link_conf_dereference_protected(vif, i); 2504 if (!link_conf || !iwl_mld_link_from_mac80211(link_conf)) 2505 continue; 2506 2507 iwl_mld_remove_link(mld, link_conf); 2508 } 2509 2510 if (WARN_ON(!iwl_mld_error_before_recovery(mld))) 2511 return err; 2512 2513 /* reconfig will fix us anyway */ 2514 return 0; 2515 } 2516 2517 static int iwl_mld_change_sta_links(struct ieee80211_hw *hw, 2518 struct ieee80211_vif *vif, 2519 struct ieee80211_sta *sta, 2520 u16 old_links, u16 new_links) 2521 { 2522 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2523 2524 return iwl_mld_update_link_stas(mld, vif, sta, old_links, new_links); 2525 } 2526 2527 static int iwl_mld_mac80211_join_ibss(struct ieee80211_hw *hw, 2528 struct ieee80211_vif *vif) 2529 { 2530 return iwl_mld_start_ap_ibss(hw, vif, &vif->bss_conf); 2531 } 2532 2533 static void iwl_mld_mac80211_leave_ibss(struct ieee80211_hw *hw, 2534 struct ieee80211_vif *vif) 2535 { 2536 return iwl_mld_stop_ap_ibss(hw, vif, &vif->bss_conf); 2537 } 2538 2539 static int iwl_mld_mac80211_tx_last_beacon(struct ieee80211_hw *hw) 2540 { 2541 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2542 2543 return mld->ibss_manager; 2544 } 2545 2546 #define IWL_MLD_EMLSR_BLOCKED_TMP_NON_BSS_TIMEOUT (5 * HZ) 2547 2548 static void iwl_mld_vif_iter_emlsr_block_tmp_non_bss(void *_data, u8 *mac, 2549 struct ieee80211_vif *vif) 2550 { 2551 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 2552 int ret; 2553 2554 if (!iwl_mld_vif_has_emlsr_cap(vif)) 2555 return; 2556 2557 ret = iwl_mld_block_emlsr_sync(mld_vif->mld, vif, 2558 IWL_MLD_EMLSR_BLOCKED_TMP_NON_BSS, 2559 iwl_mld_get_primary_link(vif)); 2560 if (ret) 2561 return; 2562 2563 wiphy_delayed_work_queue(mld_vif->mld->wiphy, 2564 &mld_vif->emlsr.tmp_non_bss_done_wk, 2565 IWL_MLD_EMLSR_BLOCKED_TMP_NON_BSS_TIMEOUT); 2566 } 2567 2568 static void iwl_mld_prep_add_interface(struct ieee80211_hw *hw, 2569 enum nl80211_iftype type) 2570 { 2571 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2572 2573 IWL_DEBUG_MAC80211(mld, "prep_add_interface: type=%u\n", type); 2574 2575 if (!(type == NL80211_IFTYPE_AP || 2576 type == NL80211_IFTYPE_P2P_GO || 2577 type == NL80211_IFTYPE_P2P_CLIENT)) 2578 return; 2579 2580 ieee80211_iterate_active_interfaces_mtx(mld->hw, 2581 IEEE80211_IFACE_ITER_NORMAL, 2582 iwl_mld_vif_iter_emlsr_block_tmp_non_bss, 2583 NULL); 2584 } 2585 2586 static int iwl_mld_set_hw_timestamp(struct ieee80211_hw *hw, 2587 struct ieee80211_vif *vif, 2588 struct cfg80211_set_hw_timestamp *hwts) 2589 { 2590 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2591 u32 protocols = 0; 2592 2593 /* HW timestamping is only supported for a specific station */ 2594 if (!hwts->macaddr) 2595 return -EOPNOTSUPP; 2596 2597 if (hwts->enable) 2598 protocols = 2599 IWL_TIME_SYNC_PROTOCOL_TM | IWL_TIME_SYNC_PROTOCOL_FTM; 2600 2601 return iwl_mld_time_sync_config(mld, hwts->macaddr, protocols); 2602 } 2603 2604 static int iwl_mld_start_pmsr(struct ieee80211_hw *hw, 2605 struct ieee80211_vif *vif, 2606 struct cfg80211_pmsr_request *request) 2607 { 2608 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 2609 2610 return iwl_mld_ftm_start(mld, vif, request); 2611 } 2612 2613 const struct ieee80211_ops iwl_mld_hw_ops = { 2614 .tx = iwl_mld_mac80211_tx, 2615 .start = iwl_mld_mac80211_start, 2616 .stop = iwl_mld_mac80211_stop, 2617 .config = iwl_mld_mac80211_config, 2618 .add_interface = iwl_mld_mac80211_add_interface, 2619 .remove_interface = iwl_mld_mac80211_remove_interface, 2620 .conf_tx = iwl_mld_mac80211_conf_tx, 2621 .prepare_multicast = iwl_mld_mac80211_prepare_multicast, 2622 .configure_filter = iwl_mld_mac80211_configure_filter, 2623 .reconfig_complete = iwl_mld_mac80211_reconfig_complete, 2624 .wake_tx_queue = iwl_mld_mac80211_wake_tx_queue, 2625 .add_chanctx = iwl_mld_add_chanctx, 2626 .remove_chanctx = iwl_mld_remove_chanctx, 2627 .change_chanctx = iwl_mld_change_chanctx, 2628 .assign_vif_chanctx = iwl_mld_assign_vif_chanctx, 2629 .unassign_vif_chanctx = iwl_mld_unassign_vif_chanctx, 2630 .set_rts_threshold = iwl_mld_mac80211_set_rts_threshold, 2631 .link_info_changed = iwl_mld_mac80211_link_info_changed, 2632 .vif_cfg_changed = iwl_mld_mac80211_vif_cfg_changed, 2633 .set_key = iwl_mld_mac80211_set_key, 2634 .hw_scan = iwl_mld_mac80211_hw_scan, 2635 .cancel_hw_scan = iwl_mld_mac80211_cancel_hw_scan, 2636 .sched_scan_start = iwl_mld_mac80211_sched_scan_start, 2637 .sched_scan_stop = iwl_mld_mac80211_sched_scan_stop, 2638 .mgd_prepare_tx = iwl_mld_mac80211_mgd_prepare_tx, 2639 .mgd_complete_tx = iwl_mld_mac_mgd_complete_tx, 2640 .sta_state = iwl_mld_mac80211_sta_state, 2641 .sta_statistics = iwl_mld_mac80211_sta_statistics, 2642 .flush = iwl_mld_mac80211_flush, 2643 .flush_sta = iwl_mld_mac80211_flush_sta, 2644 .ampdu_action = iwl_mld_mac80211_ampdu_action, 2645 .can_aggregate_in_amsdu = iwl_mld_mac80211_can_aggregate, 2646 .sync_rx_queues = iwl_mld_mac80211_sync_rx_queues, 2647 .link_sta_rc_update = iwl_mld_sta_rc_update, 2648 .start_ap = iwl_mld_start_ap_ibss, 2649 .stop_ap = iwl_mld_stop_ap_ibss, 2650 .pre_channel_switch = iwl_mld_pre_channel_switch, 2651 .channel_switch = iwl_mld_channel_switch, 2652 .post_channel_switch = iwl_mld_post_channel_switch, 2653 .abort_channel_switch = iwl_mld_abort_channel_switch, 2654 .switch_vif_chanctx = iwl_mld_switch_vif_chanctx, 2655 .sta_pre_rcu_remove = iwl_mld_sta_pre_rcu_remove, 2656 .remain_on_channel = iwl_mld_start_roc, 2657 .cancel_remain_on_channel = iwl_mld_cancel_roc, 2658 .can_activate_links = iwl_mld_can_activate_links, 2659 .change_vif_links = iwl_mld_change_vif_links, 2660 .change_sta_links = iwl_mld_change_sta_links, 2661 #ifdef CONFIG_PM_SLEEP 2662 .suspend = iwl_mld_suspend, 2663 .resume = iwl_mld_resume, 2664 .set_wakeup = iwl_mld_set_wakeup, 2665 .set_rekey_data = iwl_mld_set_rekey_data, 2666 #if IS_ENABLED(CONFIG_IPV6) 2667 .ipv6_addr_change = iwl_mld_ipv6_addr_change, 2668 #endif /* IS_ENABLED(CONFIG_IPV6) */ 2669 #endif /* CONFIG_PM_SLEEP */ 2670 #ifdef CONFIG_IWLWIFI_DEBUGFS 2671 .vif_add_debugfs = iwl_mld_add_vif_debugfs, 2672 .link_add_debugfs = iwl_mld_add_link_debugfs, 2673 .link_sta_add_debugfs = iwl_mld_add_link_sta_debugfs, 2674 #endif 2675 .mgd_protect_tdls_discover = iwl_mld_mac80211_mgd_protect_tdls_discover, 2676 .join_ibss = iwl_mld_mac80211_join_ibss, 2677 .leave_ibss = iwl_mld_mac80211_leave_ibss, 2678 .tx_last_beacon = iwl_mld_mac80211_tx_last_beacon, 2679 .prep_add_interface = iwl_mld_prep_add_interface, 2680 .set_hw_timestamp = iwl_mld_set_hw_timestamp, 2681 .start_pmsr = iwl_mld_start_pmsr, 2682 }; 2683