drivers/net/wireless/intel/iwlwifi/mvm/mld-mac80211.c

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