1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2022-2023 Intel Corporation 4 */ 5 #include "mvm.h" 6 7 static int iwl_mvm_mld_mac_add_interface(struct ieee80211_hw *hw, 8 struct ieee80211_vif *vif) 9 { 10 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 11 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 12 int ret; 13 14 mutex_lock(&mvm->mutex); 15 16 iwl_mvm_mac_init_mvmvif(mvm, mvmvif); 17 18 mvmvif->mvm = mvm; 19 20 /* Not much to do here. The stack will not allow interface 21 * types or combinations that we didn't advertise, so we 22 * don't really have to check the types. 23 */ 24 25 /* make sure that beacon statistics don't go backwards with FW reset */ 26 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) 27 mvmvif->deflink.beacon_stats.accu_num_beacons += 28 mvmvif->deflink.beacon_stats.num_beacons; 29 30 /* Allocate resources for the MAC context, and add it to the fw */ 31 ret = iwl_mvm_mac_ctxt_init(mvm, vif); 32 if (ret) 33 goto out_unlock; 34 35 rcu_assign_pointer(mvm->vif_id_to_mac[mvmvif->id], vif); 36 37 mvmvif->features |= hw->netdev_features; 38 39 /* reset deflink MLO parameters */ 40 mvmvif->deflink.fw_link_id = IWL_MVM_FW_LINK_ID_INVALID; 41 mvmvif->deflink.active = 0; 42 /* the first link always points to the default one */ 43 mvmvif->link[0] = &mvmvif->deflink; 44 45 ret = iwl_mvm_mld_mac_ctxt_add(mvm, vif); 46 if (ret) 47 goto out_unlock; 48 49 /* beacon filtering */ 50 ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0); 51 if (ret) 52 goto out_remove_mac; 53 54 if (!mvm->bf_allowed_vif && 55 vif->type == NL80211_IFTYPE_STATION && !vif->p2p) { 56 mvm->bf_allowed_vif = mvmvif; 57 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 58 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 59 } 60 61 ret = iwl_mvm_add_link(mvm, vif, &vif->bss_conf); 62 if (ret) 63 goto out_free_bf; 64 65 /* Save a pointer to p2p device vif, so it can later be used to 66 * update the p2p device MAC when a GO is started/stopped 67 */ 68 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) 69 mvm->p2p_device_vif = vif; 70 71 ret = iwl_mvm_power_update_mac(mvm); 72 if (ret) 73 goto out_free_bf; 74 75 iwl_mvm_tcm_add_vif(mvm, vif); 76 77 if (vif->type == NL80211_IFTYPE_MONITOR) { 78 mvm->monitor_on = true; 79 ieee80211_hw_set(mvm->hw, RX_INCLUDES_FCS); 80 } 81 82 iwl_mvm_vif_dbgfs_register(mvm, vif); 83 84 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) && 85 vif->type == NL80211_IFTYPE_STATION && !vif->p2p && 86 !mvm->csme_vif && mvm->mei_registered) { 87 iwl_mei_set_nic_info(vif->addr, mvm->nvm_data->hw_addr); 88 iwl_mei_set_netdev(ieee80211_vif_to_wdev(vif)->netdev); 89 mvm->csme_vif = vif; 90 } 91 92 goto out_unlock; 93 94 out_free_bf: 95 if (mvm->bf_allowed_vif == mvmvif) { 96 mvm->bf_allowed_vif = NULL; 97 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | 98 IEEE80211_VIF_SUPPORTS_CQM_RSSI); 99 } 100 out_remove_mac: 101 mvmvif->link[0] = NULL; 102 iwl_mvm_mld_mac_ctxt_remove(mvm, vif); 103 out_unlock: 104 mutex_unlock(&mvm->mutex); 105 106 return ret; 107 } 108 109 static void iwl_mvm_mld_mac_remove_interface(struct ieee80211_hw *hw, 110 struct ieee80211_vif *vif) 111 { 112 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 113 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 114 struct iwl_probe_resp_data *probe_data; 115 116 iwl_mvm_prepare_mac_removal(mvm, vif); 117 118 if (!(vif->type == NL80211_IFTYPE_AP || 119 vif->type == NL80211_IFTYPE_ADHOC)) 120 iwl_mvm_tcm_rm_vif(mvm, vif); 121 122 mutex_lock(&mvm->mutex); 123 124 if (vif == mvm->csme_vif) { 125 iwl_mei_set_netdev(NULL); 126 mvm->csme_vif = NULL; 127 } 128 129 if (mvm->bf_allowed_vif == mvmvif) { 130 mvm->bf_allowed_vif = NULL; 131 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | 132 IEEE80211_VIF_SUPPORTS_CQM_RSSI); 133 } 134 135 if (vif->bss_conf.ftm_responder) 136 memset(&mvm->ftm_resp_stats, 0, sizeof(mvm->ftm_resp_stats)); 137 138 iwl_mvm_vif_dbgfs_clean(mvm, vif); 139 140 /* For AP/GO interface, the tear down of the resources allocated to the 141 * interface is be handled as part of the stop_ap flow. 142 */ 143 if (vif->type == NL80211_IFTYPE_AP || 144 vif->type == NL80211_IFTYPE_ADHOC) { 145 #ifdef CONFIG_NL80211_TESTMODE 146 if (vif == mvm->noa_vif) { 147 mvm->noa_vif = NULL; 148 mvm->noa_duration = 0; 149 } 150 #endif 151 } 152 153 iwl_mvm_power_update_mac(mvm); 154 155 /* Before the interface removal, mac80211 would cancel the ROC, and the 156 * ROC worker would be scheduled if needed. The worker would be flushed 157 * in iwl_mvm_prepare_mac_removal() and thus at this point the link is 158 * not active. So need only to remove the link. 159 */ 160 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) { 161 if (mvmvif->deflink.phy_ctxt) { 162 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->deflink.phy_ctxt); 163 mvmvif->deflink.phy_ctxt = NULL; 164 } 165 mvm->p2p_device_vif = NULL; 166 iwl_mvm_remove_link(mvm, vif, &vif->bss_conf); 167 } else { 168 iwl_mvm_disable_link(mvm, vif, &vif->bss_conf); 169 } 170 171 iwl_mvm_mld_mac_ctxt_remove(mvm, vif); 172 173 RCU_INIT_POINTER(mvm->vif_id_to_mac[mvmvif->id], NULL); 174 175 probe_data = rcu_dereference_protected(mvmvif->deflink.probe_resp_data, 176 lockdep_is_held(&mvm->mutex)); 177 RCU_INIT_POINTER(mvmvif->deflink.probe_resp_data, NULL); 178 if (probe_data) 179 kfree_rcu(probe_data, rcu_head); 180 181 if (vif->type == NL80211_IFTYPE_MONITOR) { 182 mvm->monitor_on = false; 183 __clear_bit(IEEE80211_HW_RX_INCLUDES_FCS, mvm->hw->flags); 184 } 185 186 mutex_unlock(&mvm->mutex); 187 } 188 189 static unsigned int iwl_mvm_mld_count_active_links(struct ieee80211_vif *vif) 190 { 191 unsigned int n_active = 0; 192 int i; 193 194 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 195 struct ieee80211_bss_conf *link_conf; 196 197 link_conf = link_conf_dereference_protected(vif, i); 198 if (link_conf && 199 rcu_access_pointer(link_conf->chanctx_conf)) 200 n_active++; 201 } 202 203 return n_active; 204 } 205 206 static int iwl_mvm_esr_mode_active(struct iwl_mvm *mvm, 207 struct ieee80211_vif *vif) 208 { 209 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 210 int link_id, ret = 0; 211 212 mvmvif->esr_active = true; 213 214 /* Disable SMPS overrideing by user */ 215 vif->driver_flags |= IEEE80211_VIF_DISABLE_SMPS_OVERRIDE; 216 217 iwl_mvm_update_smps_on_active_links(mvm, vif, IWL_MVM_SMPS_REQ_FW, 218 IEEE80211_SMPS_OFF); 219 220 for_each_mvm_vif_valid_link(mvmvif, link_id) { 221 struct iwl_mvm_vif_link_info *link = mvmvif->link[link_id]; 222 223 if (!link->phy_ctxt) 224 continue; 225 226 ret = iwl_mvm_phy_send_rlc(mvm, link->phy_ctxt, 2, 2); 227 if (ret) 228 break; 229 230 link->phy_ctxt->rlc_disabled = true; 231 } 232 233 return ret; 234 } 235 236 static int 237 __iwl_mvm_mld_assign_vif_chanctx(struct iwl_mvm *mvm, 238 struct ieee80211_vif *vif, 239 struct ieee80211_bss_conf *link_conf, 240 struct ieee80211_chanctx_conf *ctx, 241 bool switching_chanctx) 242 { 243 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv; 244 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id]; 245 unsigned int n_active = iwl_mvm_mld_count_active_links(vif); 246 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 247 unsigned int link_id = link_conf->link_id; 248 int ret; 249 250 /* if the assigned one was not counted yet, count it now */ 251 if (!rcu_access_pointer(link_conf->chanctx_conf)) 252 n_active++; 253 254 if (n_active > iwl_mvm_max_active_links(mvm, vif)) 255 return -EOPNOTSUPP; 256 257 if (WARN_ON_ONCE(!mvmvif->link[link_id])) 258 return -EINVAL; 259 260 /* mac parameters such as HE support can change at this stage 261 * For sta, need first to configure correct state from drv_sta_state 262 * and only after that update mac config. 263 */ 264 if (vif->type == NL80211_IFTYPE_AP) { 265 ret = iwl_mvm_mld_mac_ctxt_changed(mvm, vif, false); 266 if (ret) { 267 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); 268 return -EINVAL; 269 } 270 } 271 272 mvmvif->link[link_id]->phy_ctxt = phy_ctxt; 273 274 if (iwl_mvm_is_esr_supported(mvm->fwrt.trans) && n_active > 1) { 275 mvmvif->link[link_id]->listen_lmac = true; 276 ret = iwl_mvm_esr_mode_active(mvm, vif); 277 if (ret) { 278 IWL_ERR(mvm, "failed to activate ESR mode (%d)\n", ret); 279 goto out; 280 } 281 } 282 283 if (switching_chanctx) { 284 /* reactivate if we turned this off during channel switch */ 285 if (vif->type == NL80211_IFTYPE_AP) 286 mvmvif->ap_ibss_active = true; 287 } 288 289 /* send it first with phy context ID */ 290 ret = iwl_mvm_link_changed(mvm, vif, link_conf, 0, false); 291 if (ret) 292 goto out; 293 294 /* Initialize rate control for the AP station, since we might be 295 * doing a link switch here - we cannot initialize it before since 296 * this needs the phy context assigned (and in FW?), and we cannot 297 * do it later because it needs to be initialized as soon as we're 298 * able to TX on the link, i.e. when active. 299 */ 300 if (mvmvif->ap_sta) { 301 struct ieee80211_link_sta *link_sta; 302 303 rcu_read_lock(); 304 link_sta = rcu_dereference(mvmvif->ap_sta->link[link_id]); 305 306 if (!WARN_ON_ONCE(!link_sta)) 307 iwl_mvm_rs_rate_init(mvm, vif, mvmvif->ap_sta, 308 link_conf, link_sta, 309 phy_ctxt->channel->band); 310 rcu_read_unlock(); 311 } 312 313 /* then activate */ 314 ret = iwl_mvm_link_changed(mvm, vif, link_conf, 315 LINK_CONTEXT_MODIFY_ACTIVE | 316 LINK_CONTEXT_MODIFY_RATES_INFO, 317 true); 318 if (ret) 319 goto out; 320 321 /* 322 * Power state must be updated before quotas, 323 * otherwise fw will complain. 324 */ 325 iwl_mvm_power_update_mac(mvm); 326 327 if (vif->type == NL80211_IFTYPE_MONITOR) { 328 ret = iwl_mvm_mld_add_snif_sta(mvm, vif, link_conf); 329 if (ret) 330 goto deactivate; 331 } 332 333 return 0; 334 335 deactivate: 336 iwl_mvm_link_changed(mvm, vif, link_conf, LINK_CONTEXT_MODIFY_ACTIVE, 337 false); 338 out: 339 mvmvif->link[link_id]->phy_ctxt = NULL; 340 iwl_mvm_power_update_mac(mvm); 341 return ret; 342 } 343 344 static int iwl_mvm_mld_assign_vif_chanctx(struct ieee80211_hw *hw, 345 struct ieee80211_vif *vif, 346 struct ieee80211_bss_conf *link_conf, 347 struct ieee80211_chanctx_conf *ctx) 348 { 349 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 350 int ret; 351 352 mutex_lock(&mvm->mutex); 353 ret = __iwl_mvm_mld_assign_vif_chanctx(mvm, vif, link_conf, ctx, false); 354 mutex_unlock(&mvm->mutex); 355 356 return ret; 357 } 358 359 static int iwl_mvm_esr_mode_inactive(struct iwl_mvm *mvm, 360 struct ieee80211_vif *vif) 361 { 362 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 363 struct ieee80211_bss_conf *link_conf; 364 int link_id, ret = 0; 365 366 mvmvif->esr_active = false; 367 368 vif->driver_flags &= ~IEEE80211_VIF_DISABLE_SMPS_OVERRIDE; 369 370 iwl_mvm_update_smps_on_active_links(mvm, vif, IWL_MVM_SMPS_REQ_FW, 371 IEEE80211_SMPS_AUTOMATIC); 372 373 for_each_vif_active_link(vif, link_conf, link_id) { 374 struct ieee80211_chanctx_conf *chanctx_conf; 375 struct iwl_mvm_phy_ctxt *phy_ctxt; 376 u8 static_chains, dynamic_chains; 377 378 mvmvif->link[link_id]->listen_lmac = false; 379 380 rcu_read_lock(); 381 382 chanctx_conf = rcu_dereference(link_conf->chanctx_conf); 383 phy_ctxt = mvmvif->link[link_id]->phy_ctxt; 384 385 if (!chanctx_conf || !phy_ctxt) { 386 rcu_read_unlock(); 387 continue; 388 } 389 390 phy_ctxt->rlc_disabled = false; 391 static_chains = chanctx_conf->rx_chains_static; 392 dynamic_chains = chanctx_conf->rx_chains_dynamic; 393 394 rcu_read_unlock(); 395 396 ret = iwl_mvm_phy_send_rlc(mvm, phy_ctxt, static_chains, 397 dynamic_chains); 398 if (ret) 399 break; 400 } 401 402 return ret; 403 } 404 405 static void 406 __iwl_mvm_mld_unassign_vif_chanctx(struct iwl_mvm *mvm, 407 struct ieee80211_vif *vif, 408 struct ieee80211_bss_conf *link_conf, 409 struct ieee80211_chanctx_conf *ctx, 410 bool switching_chanctx) 411 412 { 413 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 414 unsigned int n_active = iwl_mvm_mld_count_active_links(vif); 415 unsigned int link_id = link_conf->link_id; 416 417 /* shouldn't happen, but verify link_id is valid before accessing */ 418 if (WARN_ON_ONCE(!mvmvif->link[link_id])) 419 return; 420 421 if (vif->type == NL80211_IFTYPE_AP && switching_chanctx) { 422 mvmvif->csa_countdown = false; 423 424 /* Set CS bit on all the stations */ 425 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true); 426 427 /* Save blocked iface, the timeout is set on the next beacon */ 428 rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif); 429 430 mvmvif->ap_ibss_active = false; 431 } 432 433 iwl_mvm_link_changed(mvm, vif, link_conf, 434 LINK_CONTEXT_MODIFY_ACTIVE, false); 435 436 if (iwl_mvm_is_esr_supported(mvm->fwrt.trans) && n_active > 1) { 437 int ret = iwl_mvm_esr_mode_inactive(mvm, vif); 438 439 if (ret) 440 IWL_ERR(mvm, "failed to deactivate ESR mode (%d)\n", 441 ret); 442 } 443 444 if (vif->type == NL80211_IFTYPE_MONITOR) 445 iwl_mvm_mld_rm_snif_sta(mvm, vif); 446 447 if (switching_chanctx) 448 return; 449 mvmvif->link[link_id]->phy_ctxt = NULL; 450 iwl_mvm_power_update_mac(mvm); 451 } 452 453 static void iwl_mvm_mld_unassign_vif_chanctx(struct ieee80211_hw *hw, 454 struct ieee80211_vif *vif, 455 struct ieee80211_bss_conf *link_conf, 456 struct ieee80211_chanctx_conf *ctx) 457 { 458 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 459 460 mutex_lock(&mvm->mutex); 461 __iwl_mvm_mld_unassign_vif_chanctx(mvm, vif, link_conf, ctx, false); 462 mutex_unlock(&mvm->mutex); 463 } 464 465 static int iwl_mvm_mld_start_ap_ibss(struct ieee80211_hw *hw, 466 struct ieee80211_vif *vif, 467 struct ieee80211_bss_conf *link_conf) 468 { 469 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 470 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 471 int ret; 472 473 mutex_lock(&mvm->mutex); 474 /* Send the beacon template */ 475 ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif, link_conf); 476 if (ret) 477 goto out_unlock; 478 479 /* the link should be already activated when assigning chan context */ 480 ret = iwl_mvm_link_changed(mvm, vif, link_conf, 481 LINK_CONTEXT_MODIFY_ALL & 482 ~LINK_CONTEXT_MODIFY_ACTIVE, 483 true); 484 if (ret) 485 goto out_unlock; 486 487 ret = iwl_mvm_mld_add_mcast_sta(mvm, vif, link_conf); 488 if (ret) 489 goto out_unlock; 490 491 /* Send the bcast station. At this stage the TBTT and DTIM time 492 * events are added and applied to the scheduler 493 */ 494 ret = iwl_mvm_mld_add_bcast_sta(mvm, vif, link_conf); 495 if (ret) 496 goto out_rm_mcast; 497 498 if (iwl_mvm_start_ap_ibss_common(hw, vif, &ret)) 499 goto out_failed; 500 501 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */ 502 if (vif->p2p && mvm->p2p_device_vif) 503 iwl_mvm_mld_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false); 504 505 iwl_mvm_bt_coex_vif_change(mvm); 506 507 /* we don't support TDLS during DCM */ 508 if (iwl_mvm_phy_ctx_count(mvm) > 1) 509 iwl_mvm_teardown_tdls_peers(mvm); 510 511 iwl_mvm_ftm_restart_responder(mvm, vif, link_conf); 512 513 goto out_unlock; 514 515 out_failed: 516 iwl_mvm_power_update_mac(mvm); 517 mvmvif->ap_ibss_active = false; 518 iwl_mvm_mld_rm_bcast_sta(mvm, vif, link_conf); 519 out_rm_mcast: 520 iwl_mvm_mld_rm_mcast_sta(mvm, vif, link_conf); 521 out_unlock: 522 mutex_unlock(&mvm->mutex); 523 return ret; 524 } 525 526 static int iwl_mvm_mld_start_ap(struct ieee80211_hw *hw, 527 struct ieee80211_vif *vif, 528 struct ieee80211_bss_conf *link_conf) 529 { 530 return iwl_mvm_mld_start_ap_ibss(hw, vif, link_conf); 531 } 532 533 static int iwl_mvm_mld_start_ibss(struct ieee80211_hw *hw, 534 struct ieee80211_vif *vif) 535 { 536 return iwl_mvm_mld_start_ap_ibss(hw, vif, &vif->bss_conf); 537 } 538 539 static void iwl_mvm_mld_stop_ap_ibss(struct ieee80211_hw *hw, 540 struct ieee80211_vif *vif, 541 struct ieee80211_bss_conf *link_conf) 542 { 543 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 544 545 mutex_lock(&mvm->mutex); 546 547 iwl_mvm_stop_ap_ibss_common(mvm, vif); 548 549 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */ 550 if (vif->p2p && mvm->p2p_device_vif) 551 iwl_mvm_mld_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false); 552 553 iwl_mvm_ftm_responder_clear(mvm, vif); 554 555 iwl_mvm_mld_rm_bcast_sta(mvm, vif, link_conf); 556 iwl_mvm_mld_rm_mcast_sta(mvm, vif, link_conf); 557 558 iwl_mvm_power_update_mac(mvm); 559 mutex_unlock(&mvm->mutex); 560 } 561 562 static void iwl_mvm_mld_stop_ap(struct ieee80211_hw *hw, 563 struct ieee80211_vif *vif, 564 struct ieee80211_bss_conf *link_conf) 565 { 566 iwl_mvm_mld_stop_ap_ibss(hw, vif, link_conf); 567 } 568 569 static void iwl_mvm_mld_stop_ibss(struct ieee80211_hw *hw, 570 struct ieee80211_vif *vif) 571 { 572 iwl_mvm_mld_stop_ap_ibss(hw, vif, &vif->bss_conf); 573 } 574 575 static int iwl_mvm_mld_mac_sta_state(struct ieee80211_hw *hw, 576 struct ieee80211_vif *vif, 577 struct ieee80211_sta *sta, 578 enum ieee80211_sta_state old_state, 579 enum ieee80211_sta_state new_state) 580 { 581 static const struct iwl_mvm_sta_state_ops callbacks = { 582 .add_sta = iwl_mvm_mld_add_sta, 583 .update_sta = iwl_mvm_mld_update_sta, 584 .rm_sta = iwl_mvm_mld_rm_sta, 585 .mac_ctxt_changed = iwl_mvm_mld_mac_ctxt_changed, 586 }; 587 588 return iwl_mvm_mac_sta_state_common(hw, vif, sta, old_state, new_state, 589 &callbacks); 590 } 591 592 static void 593 iwl_mvm_mld_link_info_changed_station(struct iwl_mvm *mvm, 594 struct ieee80211_vif *vif, 595 struct ieee80211_bss_conf *link_conf, 596 u64 changes) 597 { 598 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 599 bool has_he, has_eht; 600 u32 link_changes = 0; 601 int ret; 602 603 if (WARN_ON_ONCE(!mvmvif->link[link_conf->link_id])) 604 return; 605 606 has_he = link_conf->he_support && !iwlwifi_mod_params.disable_11ax; 607 has_eht = link_conf->eht_support && !iwlwifi_mod_params.disable_11be; 608 609 /* Update EDCA params */ 610 if (changes & BSS_CHANGED_QOS && vif->cfg.assoc && link_conf->qos) 611 link_changes |= LINK_CONTEXT_MODIFY_QOS_PARAMS; 612 613 if (changes & BSS_CHANGED_ERP_SLOT) 614 link_changes |= LINK_CONTEXT_MODIFY_RATES_INFO; 615 616 if (vif->cfg.assoc && (has_he || has_eht)) { 617 IWL_DEBUG_MAC80211(mvm, "Associated in HE mode\n"); 618 link_changes |= LINK_CONTEXT_MODIFY_HE_PARAMS; 619 } 620 621 /* Update EHT Puncturing info */ 622 if (changes & BSS_CHANGED_EHT_PUNCTURING && vif->cfg.assoc) 623 link_changes |= LINK_CONTEXT_MODIFY_EHT_PARAMS; 624 625 if (link_changes) { 626 ret = iwl_mvm_link_changed(mvm, vif, link_conf, link_changes, 627 true); 628 if (ret) 629 IWL_ERR(mvm, "failed to update link\n"); 630 } 631 632 ret = iwl_mvm_mld_mac_ctxt_changed(mvm, vif, false); 633 if (ret) 634 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); 635 636 memcpy(mvmvif->link[link_conf->link_id]->bssid, link_conf->bssid, 637 ETH_ALEN); 638 639 iwl_mvm_bss_info_changed_station_common(mvm, vif, link_conf, changes); 640 } 641 642 static bool iwl_mvm_mld_vif_have_valid_ap_sta(struct iwl_mvm_vif *mvmvif) 643 { 644 int i; 645 646 for_each_mvm_vif_valid_link(mvmvif, i) { 647 if (mvmvif->link[i]->ap_sta_id != IWL_MVM_INVALID_STA) 648 return true; 649 } 650 651 return false; 652 } 653 654 static void iwl_mvm_mld_vif_delete_all_stas(struct iwl_mvm *mvm, 655 struct ieee80211_vif *vif) 656 { 657 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 658 int i, ret; 659 660 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) 661 return; 662 663 for_each_mvm_vif_valid_link(mvmvif, i) { 664 struct iwl_mvm_vif_link_info *link = mvmvif->link[i]; 665 666 if (!link) 667 continue; 668 669 iwl_mvm_sec_key_remove_ap(mvm, vif, link, i); 670 ret = iwl_mvm_mld_rm_sta_id(mvm, link->ap_sta_id); 671 if (ret) 672 IWL_ERR(mvm, "failed to remove AP station\n"); 673 674 link->ap_sta_id = IWL_MVM_INVALID_STA; 675 } 676 } 677 678 static void iwl_mvm_mld_vif_cfg_changed_station(struct iwl_mvm *mvm, 679 struct ieee80211_vif *vif, 680 u64 changes) 681 { 682 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 683 struct ieee80211_bss_conf *link_conf; 684 bool protect = false; 685 unsigned int i; 686 int ret; 687 688 /* This might get called without active links during the 689 * chanctx switch, but we don't care about it anyway. 690 */ 691 if (changes == BSS_CHANGED_IDLE) 692 return; 693 694 ret = iwl_mvm_mld_mac_ctxt_changed(mvm, vif, false); 695 if (ret) 696 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); 697 698 mvmvif->associated = vif->cfg.assoc; 699 700 if (changes & BSS_CHANGED_ASSOC) { 701 if (vif->cfg.assoc) { 702 /* clear statistics to get clean beacon counter */ 703 iwl_mvm_request_statistics(mvm, true); 704 iwl_mvm_sf_update(mvm, vif, false); 705 iwl_mvm_power_vif_assoc(mvm, vif); 706 707 for_each_mvm_vif_valid_link(mvmvif, i) { 708 memset(&mvmvif->link[i]->beacon_stats, 0, 709 sizeof(mvmvif->link[i]->beacon_stats)); 710 711 if (vif->p2p) { 712 iwl_mvm_update_smps(mvm, vif, 713 IWL_MVM_SMPS_REQ_PROT, 714 IEEE80211_SMPS_DYNAMIC, i); 715 } 716 717 rcu_read_lock(); 718 link_conf = rcu_dereference(vif->link_conf[i]); 719 if (link_conf && !link_conf->dtim_period) 720 protect = true; 721 rcu_read_unlock(); 722 } 723 724 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) && 725 protect) { 726 /* If we're not restarting and still haven't 727 * heard a beacon (dtim period unknown) then 728 * make sure we still have enough minimum time 729 * remaining in the time event, since the auth 730 * might actually have taken quite a while 731 * (especially for SAE) and so the remaining 732 * time could be small without us having heard 733 * a beacon yet. 734 */ 735 iwl_mvm_protect_assoc(mvm, vif, 0); 736 } 737 738 iwl_mvm_sf_update(mvm, vif, false); 739 740 /* FIXME: need to decide about misbehaving AP handling */ 741 iwl_mvm_power_vif_assoc(mvm, vif); 742 } else if (iwl_mvm_mld_vif_have_valid_ap_sta(mvmvif)) { 743 iwl_mvm_mei_host_disassociated(mvm); 744 745 /* If update fails - SF might be running in associated 746 * mode while disassociated - which is forbidden. 747 */ 748 ret = iwl_mvm_sf_update(mvm, vif, false); 749 WARN_ONCE(ret && 750 !test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, 751 &mvm->status), 752 "Failed to update SF upon disassociation\n"); 753 754 /* If we get an assert during the connection (after the 755 * station has been added, but before the vif is set 756 * to associated), mac80211 will re-add the station and 757 * then configure the vif. Since the vif is not 758 * associated, we would remove the station here and 759 * this would fail the recovery. 760 */ 761 iwl_mvm_mld_vif_delete_all_stas(mvm, vif); 762 } 763 764 iwl_mvm_bss_info_changed_station_assoc(mvm, vif, changes); 765 } 766 767 if (changes & BSS_CHANGED_PS) { 768 ret = iwl_mvm_power_update_mac(mvm); 769 if (ret) 770 IWL_ERR(mvm, "failed to update power mode\n"); 771 } 772 } 773 774 static void 775 iwl_mvm_mld_link_info_changed_ap_ibss(struct iwl_mvm *mvm, 776 struct ieee80211_vif *vif, 777 struct ieee80211_bss_conf *link_conf, 778 u64 changes) 779 { 780 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 781 u32 link_changes = LINK_CONTEXT_MODIFY_PROTECT_FLAGS | 782 LINK_CONTEXT_MODIFY_QOS_PARAMS; 783 784 /* Changes will be applied when the AP/IBSS is started */ 785 if (!mvmvif->ap_ibss_active) 786 return; 787 788 if (link_conf->he_support) 789 link_changes |= LINK_CONTEXT_MODIFY_HE_PARAMS; 790 791 if (changes & BSS_CHANGED_ERP_SLOT) 792 link_changes |= LINK_CONTEXT_MODIFY_RATES_INFO; 793 794 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_SLOT | 795 BSS_CHANGED_HT | 796 BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS | 797 BSS_CHANGED_HE_BSS_COLOR) && 798 iwl_mvm_link_changed(mvm, vif, link_conf, 799 link_changes, true)) 800 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); 801 802 /* Need to send a new beacon template to the FW */ 803 if (changes & BSS_CHANGED_BEACON && 804 iwl_mvm_mac_ctxt_beacon_changed(mvm, vif, link_conf)) 805 IWL_WARN(mvm, "Failed updating beacon data\n"); 806 807 /* FIXME: need to decide if we need FTM responder per link */ 808 if (changes & BSS_CHANGED_FTM_RESPONDER) { 809 int ret = iwl_mvm_ftm_start_responder(mvm, vif, link_conf); 810 811 if (ret) 812 IWL_WARN(mvm, "Failed to enable FTM responder (%d)\n", 813 ret); 814 } 815 } 816 817 static void iwl_mvm_mld_link_info_changed(struct ieee80211_hw *hw, 818 struct ieee80211_vif *vif, 819 struct ieee80211_bss_conf *link_conf, 820 u64 changes) 821 { 822 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 823 824 mutex_lock(&mvm->mutex); 825 826 switch (vif->type) { 827 case NL80211_IFTYPE_STATION: 828 iwl_mvm_mld_link_info_changed_station(mvm, vif, link_conf, 829 changes); 830 break; 831 case NL80211_IFTYPE_AP: 832 case NL80211_IFTYPE_ADHOC: 833 iwl_mvm_mld_link_info_changed_ap_ibss(mvm, vif, link_conf, 834 changes); 835 break; 836 case NL80211_IFTYPE_MONITOR: 837 if (changes & BSS_CHANGED_MU_GROUPS) 838 iwl_mvm_update_mu_groups(mvm, vif); 839 break; 840 default: 841 /* shouldn't happen */ 842 WARN_ON_ONCE(1); 843 } 844 845 if (changes & BSS_CHANGED_TXPOWER) { 846 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d dBm\n", 847 link_conf->txpower); 848 iwl_mvm_set_tx_power(mvm, vif, link_conf->txpower); 849 } 850 851 mutex_unlock(&mvm->mutex); 852 } 853 854 static void iwl_mvm_mld_vif_cfg_changed(struct ieee80211_hw *hw, 855 struct ieee80211_vif *vif, 856 u64 changes) 857 { 858 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 859 860 mutex_lock(&mvm->mutex); 861 862 if (changes & BSS_CHANGED_IDLE && !vif->cfg.idle) 863 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true); 864 865 if (vif->type == NL80211_IFTYPE_STATION) 866 iwl_mvm_mld_vif_cfg_changed_station(mvm, vif, changes); 867 868 mutex_unlock(&mvm->mutex); 869 } 870 871 static int 872 iwl_mvm_mld_switch_vif_chanctx(struct ieee80211_hw *hw, 873 struct ieee80211_vif_chanctx_switch *vifs, 874 int n_vifs, 875 enum ieee80211_chanctx_switch_mode mode) 876 { 877 static const struct iwl_mvm_switch_vif_chanctx_ops ops = { 878 .__assign_vif_chanctx = __iwl_mvm_mld_assign_vif_chanctx, 879 .__unassign_vif_chanctx = __iwl_mvm_mld_unassign_vif_chanctx, 880 }; 881 882 return iwl_mvm_switch_vif_chanctx_common(hw, vifs, n_vifs, mode, &ops); 883 } 884 885 static void iwl_mvm_mld_config_iface_filter(struct ieee80211_hw *hw, 886 struct ieee80211_vif *vif, 887 unsigned int filter_flags, 888 unsigned int changed_flags) 889 { 890 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 891 892 /* We support only filter for probe requests */ 893 if (!(changed_flags & FIF_PROBE_REQ)) 894 return; 895 896 /* Supported only for p2p client interfaces */ 897 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc || 898 !vif->p2p) 899 return; 900 901 mutex_lock(&mvm->mutex); 902 iwl_mvm_mld_mac_ctxt_changed(mvm, vif, false); 903 mutex_unlock(&mvm->mutex); 904 } 905 906 static int 907 iwl_mvm_mld_mac_conf_tx(struct ieee80211_hw *hw, 908 struct ieee80211_vif *vif, 909 unsigned int link_id, u16 ac, 910 const struct ieee80211_tx_queue_params *params) 911 { 912 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 913 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 914 struct iwl_mvm_vif_link_info *mvm_link = mvmvif->link[link_id]; 915 916 if (!mvm_link) 917 return -EINVAL; 918 919 mvm_link->queue_params[ac] = *params; 920 921 /* No need to update right away, we'll get BSS_CHANGED_QOS 922 * The exception is P2P_DEVICE interface which needs immediate update. 923 */ 924 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) { 925 int ret; 926 927 mutex_lock(&mvm->mutex); 928 ret = iwl_mvm_link_changed(mvm, vif, &vif->bss_conf, 929 LINK_CONTEXT_MODIFY_QOS_PARAMS, 930 true); 931 mutex_unlock(&mvm->mutex); 932 return ret; 933 } 934 return 0; 935 } 936 937 static int iwl_mvm_mld_roc_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 938 { 939 int ret; 940 941 lockdep_assert_held(&mvm->mutex); 942 943 /* The PHY context ID might have changed so need to set it */ 944 ret = iwl_mvm_link_changed(mvm, vif, &vif->bss_conf, 0, false); 945 if (WARN(ret, "Failed to set PHY context ID\n")) 946 return ret; 947 948 ret = iwl_mvm_link_changed(mvm, vif, &vif->bss_conf, 949 LINK_CONTEXT_MODIFY_ACTIVE | 950 LINK_CONTEXT_MODIFY_RATES_INFO, 951 true); 952 953 if (WARN(ret, "Failed linking P2P_DEVICE\n")) 954 return ret; 955 956 /* The station and queue allocation must be done only after the linking 957 * is done, as otherwise the FW might incorrectly configure its state. 958 */ 959 return iwl_mvm_mld_add_bcast_sta(mvm, vif, &vif->bss_conf); 960 } 961 962 static int iwl_mvm_mld_roc(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 963 struct ieee80211_channel *channel, int duration, 964 enum ieee80211_roc_type type) 965 { 966 static const struct iwl_mvm_roc_ops ops = { 967 .add_aux_sta_for_hs20 = iwl_mvm_mld_add_aux_sta, 968 .link = iwl_mvm_mld_roc_link, 969 }; 970 971 return iwl_mvm_roc_common(hw, vif, channel, duration, type, &ops); 972 } 973 974 static int 975 iwl_mvm_mld_change_vif_links(struct ieee80211_hw *hw, 976 struct ieee80211_vif *vif, 977 u16 old_links, u16 new_links, 978 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 979 { 980 struct iwl_mvm_vif_link_info *new_link[IEEE80211_MLD_MAX_NUM_LINKS] = {}; 981 unsigned int n_active = iwl_mvm_mld_count_active_links(vif); 982 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 983 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 984 u16 removed = old_links & ~new_links; 985 u16 added = new_links & ~old_links; 986 int err, i; 987 988 if (hweight16(new_links) > 1 && 989 n_active > iwl_mvm_max_active_links(mvm, vif)) 990 return -EOPNOTSUPP; 991 992 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 993 int r; 994 995 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) 996 break; 997 998 if (!(added & BIT(i))) 999 continue; 1000 new_link[i] = kzalloc(sizeof(*new_link[i]), GFP_KERNEL); 1001 if (!new_link[i]) { 1002 err = -ENOMEM; 1003 goto free; 1004 } 1005 1006 new_link[i]->bcast_sta.sta_id = IWL_MVM_INVALID_STA; 1007 new_link[i]->mcast_sta.sta_id = IWL_MVM_INVALID_STA; 1008 new_link[i]->ap_sta_id = IWL_MVM_INVALID_STA; 1009 new_link[i]->fw_link_id = IWL_MVM_FW_LINK_ID_INVALID; 1010 1011 for (r = 0; r < NUM_IWL_MVM_SMPS_REQ; r++) 1012 new_link[i]->smps_requests[r] = 1013 IEEE80211_SMPS_AUTOMATIC; 1014 } 1015 1016 mutex_lock(&mvm->mutex); 1017 1018 if (old_links == 0) { 1019 err = iwl_mvm_disable_link(mvm, vif, &vif->bss_conf); 1020 if (err) 1021 goto out_err; 1022 mvmvif->link[0] = NULL; 1023 } 1024 1025 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) { 1026 if (removed & BIT(i)) { 1027 struct ieee80211_bss_conf *link_conf = old[i]; 1028 1029 err = iwl_mvm_disable_link(mvm, vif, link_conf); 1030 if (err) 1031 goto out_err; 1032 kfree(mvmvif->link[i]); 1033 mvmvif->link[i] = NULL; 1034 } else if (added & BIT(i)) { 1035 struct ieee80211_bss_conf *link_conf; 1036 1037 link_conf = link_conf_dereference_protected(vif, i); 1038 if (WARN_ON(!link_conf)) 1039 continue; 1040 1041 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, 1042 &mvm->status)) 1043 mvmvif->link[i] = new_link[i]; 1044 new_link[i] = NULL; 1045 err = iwl_mvm_add_link(mvm, vif, link_conf); 1046 if (err) 1047 goto out_err; 1048 } 1049 } 1050 1051 err = 0; 1052 if (new_links == 0) { 1053 mvmvif->link[0] = &mvmvif->deflink; 1054 err = iwl_mvm_add_link(mvm, vif, &vif->bss_conf); 1055 } 1056 1057 out_err: 1058 /* we really don't have a good way to roll back here ... */ 1059 mutex_unlock(&mvm->mutex); 1060 1061 free: 1062 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) 1063 kfree(new_link[i]); 1064 return err; 1065 } 1066 1067 static int 1068 iwl_mvm_mld_change_sta_links(struct ieee80211_hw *hw, 1069 struct ieee80211_vif *vif, 1070 struct ieee80211_sta *sta, 1071 u16 old_links, u16 new_links) 1072 { 1073 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 1074 int ret; 1075 1076 mutex_lock(&mvm->mutex); 1077 ret = iwl_mvm_mld_update_sta_links(mvm, vif, sta, old_links, new_links); 1078 mutex_unlock(&mvm->mutex); 1079 1080 return ret; 1081 } 1082 1083 const struct ieee80211_ops iwl_mvm_mld_hw_ops = { 1084 .tx = iwl_mvm_mac_tx, 1085 .wake_tx_queue = iwl_mvm_mac_wake_tx_queue, 1086 .ampdu_action = iwl_mvm_mac_ampdu_action, 1087 .get_antenna = iwl_mvm_op_get_antenna, 1088 .start = iwl_mvm_mac_start, 1089 .reconfig_complete = iwl_mvm_mac_reconfig_complete, 1090 .stop = iwl_mvm_mac_stop, 1091 .add_interface = iwl_mvm_mld_mac_add_interface, 1092 .remove_interface = iwl_mvm_mld_mac_remove_interface, 1093 .config = iwl_mvm_mac_config, 1094 .prepare_multicast = iwl_mvm_prepare_multicast, 1095 .configure_filter = iwl_mvm_configure_filter, 1096 .config_iface_filter = iwl_mvm_mld_config_iface_filter, 1097 .link_info_changed = iwl_mvm_mld_link_info_changed, 1098 .vif_cfg_changed = iwl_mvm_mld_vif_cfg_changed, 1099 .hw_scan = iwl_mvm_mac_hw_scan, 1100 .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan, 1101 .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove, 1102 .sta_state = iwl_mvm_mld_mac_sta_state, 1103 .sta_notify = iwl_mvm_mac_sta_notify, 1104 .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames, 1105 .release_buffered_frames = iwl_mvm_mac_release_buffered_frames, 1106 .set_rts_threshold = iwl_mvm_mac_set_rts_threshold, 1107 .sta_rc_update = iwl_mvm_sta_rc_update, 1108 .conf_tx = iwl_mvm_mld_mac_conf_tx, 1109 .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx, 1110 .mgd_complete_tx = iwl_mvm_mac_mgd_complete_tx, 1111 .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover, 1112 .flush = iwl_mvm_mac_flush, 1113 .flush_sta = iwl_mvm_mac_flush_sta, 1114 .sched_scan_start = iwl_mvm_mac_sched_scan_start, 1115 .sched_scan_stop = iwl_mvm_mac_sched_scan_stop, 1116 .set_key = iwl_mvm_mac_set_key, 1117 .update_tkip_key = iwl_mvm_mac_update_tkip_key, 1118 .remain_on_channel = iwl_mvm_mld_roc, 1119 .cancel_remain_on_channel = iwl_mvm_cancel_roc, 1120 .add_chanctx = iwl_mvm_add_chanctx, 1121 .remove_chanctx = iwl_mvm_remove_chanctx, 1122 .change_chanctx = iwl_mvm_change_chanctx, 1123 .assign_vif_chanctx = iwl_mvm_mld_assign_vif_chanctx, 1124 .unassign_vif_chanctx = iwl_mvm_mld_unassign_vif_chanctx, 1125 .switch_vif_chanctx = iwl_mvm_mld_switch_vif_chanctx, 1126 1127 .start_ap = iwl_mvm_mld_start_ap, 1128 .stop_ap = iwl_mvm_mld_stop_ap, 1129 .join_ibss = iwl_mvm_mld_start_ibss, 1130 .leave_ibss = iwl_mvm_mld_stop_ibss, 1131 1132 .tx_last_beacon = iwl_mvm_tx_last_beacon, 1133 1134 .set_tim = iwl_mvm_set_tim, 1135 1136 .channel_switch = iwl_mvm_channel_switch, 1137 .pre_channel_switch = iwl_mvm_pre_channel_switch, 1138 .post_channel_switch = iwl_mvm_post_channel_switch, 1139 .abort_channel_switch = iwl_mvm_abort_channel_switch, 1140 .channel_switch_rx_beacon = iwl_mvm_channel_switch_rx_beacon, 1141 1142 .tdls_channel_switch = iwl_mvm_tdls_channel_switch, 1143 .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch, 1144 .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch, 1145 1146 .event_callback = iwl_mvm_mac_event_callback, 1147 1148 .sync_rx_queues = iwl_mvm_sync_rx_queues, 1149 1150 CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd) 1151 1152 #ifdef CONFIG_PM_SLEEP 1153 /* look at d3.c */ 1154 .suspend = iwl_mvm_suspend, 1155 .resume = iwl_mvm_resume, 1156 .set_wakeup = iwl_mvm_set_wakeup, 1157 .set_rekey_data = iwl_mvm_set_rekey_data, 1158 #if IS_ENABLED(CONFIG_IPV6) 1159 .ipv6_addr_change = iwl_mvm_ipv6_addr_change, 1160 #endif 1161 .set_default_unicast_key = iwl_mvm_set_default_unicast_key, 1162 #endif 1163 .get_survey = iwl_mvm_mac_get_survey, 1164 .sta_statistics = iwl_mvm_mac_sta_statistics, 1165 .get_ftm_responder_stats = iwl_mvm_mac_get_ftm_responder_stats, 1166 .start_pmsr = iwl_mvm_start_pmsr, 1167 .abort_pmsr = iwl_mvm_abort_pmsr, 1168 1169 #ifdef CONFIG_IWLWIFI_DEBUGFS 1170 .link_sta_add_debugfs = iwl_mvm_link_sta_add_debugfs, 1171 #endif 1172 .set_hw_timestamp = iwl_mvm_set_hw_timestamp, 1173 1174 .change_vif_links = iwl_mvm_mld_change_vif_links, 1175 .change_sta_links = iwl_mvm_mld_change_sta_links, 1176 }; 1177