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