/******************************************************************************
 *
 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
 * Copyright(c) 2018        Intel Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************************/

#include <fuchsia/hardware/wlan/associnfo/c/banjo.h>
#include <string.h>
#include <zircon/status.h>

#include <ddk/hw/wlan/ieee80211/c/banjo.h>

#include "third_party/iwlwifi/fw/api/nan.h"
#include "third_party/iwlwifi/fw/error-dump.h"
#include "third_party/iwlwifi/iwl-eeprom-parse.h"
#include "third_party/iwlwifi/iwl-io.h"
#include "third_party/iwlwifi/iwl-nvm-parse.h"
#include "third_party/iwlwifi/iwl-op-mode.h"
#include "third_party/iwlwifi/iwl-phy-db.h"
#include "third_party/iwlwifi/iwl-prph.h"
#include "third_party/iwlwifi/iwl-vendor-cmd.h"
#include "third_party/iwlwifi/mvm/mvm.h"
#include "third_party/iwlwifi/mvm/sta.h"
#include "third_party/iwlwifi/mvm/time-event.h"
#include "third_party/iwlwifi/mvm/tof.h"
#include "third_party/iwlwifi/platform/ieee80211_include.h"
#include "third_party/iwlwifi/platform/rcu.h"
#ifdef CPTCFG_IWLWIFI_DEVICE_TESTMODE
#include "third_party/iwlwifi/iwl-dnt-cfg.h"
#include "third_party/iwlwifi/iwl-dnt-dispatch.h"
#endif
#ifdef CPTCFG_NL80211_TESTMODE
#include "third_party/iwlwifi/fw/testmode.h"
#endif

#if 0  // NEEDS_PORTING
static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
    {
        .max = CPTCFG_IWLWIFI_NUM_STA_INTERFACES,
        .types = BIT(NL80211_IFTYPE_STATION),
    },
    {
        .max = 1,
        .types =
            BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO),
    },
    {
        .max = 1,
        .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
    },
};

static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
    {
        .num_different_channels = CPTCFG_IWLWIFI_NUM_CHANNELS,
        .max_interfaces = CPTCFG_IWLWIFI_NUM_STA_INTERFACES + 2,
        .limits = iwl_mvm_limits,
        .n_limits = ARRAY_SIZE(iwl_mvm_limits),
    },
};

static const struct ieee80211_iface_limit iwl_mvm_limits_nan[] = {
    {
        .max = CPTCFG_IWLWIFI_NUM_STA_INTERFACES,
        .types = BIT(NL80211_IFTYPE_STATION),
    },
    {
        .max = 1,
        .types =
            BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO),
    },
    {
        .max = 1,
        .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
    },
    {
        .max = 1,
        .types = BIT(NL80211_IFTYPE_NAN),
    },
};

static const struct ieee80211_iface_combination iwl_mvm_iface_combinations_nan[] = {
    {
        .num_different_channels = CPTCFG_IWLWIFI_NUM_CHANNELS,
        .max_interfaces = CPTCFG_IWLWIFI_NUM_STA_INTERFACES + 3,
        .limits = iwl_mvm_limits_nan,
        .n_limits = ARRAY_SIZE(iwl_mvm_limits_nan),
    },
};

#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
/*
 * Use the reserved field to indicate magic values.
 * these values will only be used internally by the driver,
 * and won't make it to the fw (reserved will be 0).
 * BC_FILTER_MAGIC_IP - configure the val of this attribute to
 *  be the vif's ip address. in case there is not a single
 *  ip address (0, or more than 1), this attribute will
 *  be skipped.
 * BC_FILTER_MAGIC_MAC - set the val of this attribute to
 *  the LSB bytes of the vif's mac address
 */
enum {
    BC_FILTER_MAGIC_NONE = 0,
    BC_FILTER_MAGIC_IP,
    BC_FILTER_MAGIC_MAC,
};

static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters[] = {
    {
        /* arp */
        .discard = 0,
        .frame_type = BCAST_FILTER_FRAME_TYPE_ALL,
        .attrs =
            {
                {
                    /* frame type - arp, hw type - ethernet */
                    .offset_type = BCAST_FILTER_OFFSET_PAYLOAD_START,
                    .offset = sizeof(rfc1042_header),
                    .val = cpu_to_be32(0x08060001),
                    .mask = cpu_to_be32(0xffffffff),
                },
                {
                    /* arp dest ip */
                    .offset_type = BCAST_FILTER_OFFSET_PAYLOAD_START,
                    .offset = sizeof(rfc1042_header) + 2 + sizeof(struct arphdr) + ETH_ALEN +
                              sizeof(__be32) + ETH_ALEN,
                    .mask = cpu_to_be32(0xffffffff),
                    /* mark it as special field */
                    .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_IP),
                },
            },
    },
    {
        /* dhcp offer bcast */
        .discard = 0,
        .frame_type = BCAST_FILTER_FRAME_TYPE_IPV4,
        .attrs =
            {
                {
                    /* udp dest port - 68 (bootp client)*/
                    .offset_type = BCAST_FILTER_OFFSET_IP_END,
                    .offset = offsetof(struct udphdr, dest),
                    .val = cpu_to_be32(0x00440000),
                    .mask = cpu_to_be32(0xffff0000),
                },
                {
                    /* dhcp - lsb bytes of client hw address */
                    .offset_type = BCAST_FILTER_OFFSET_IP_END,
                    .offset = 38,
                    .mask = cpu_to_be32(0xffffffff),
                    /* mark it as special field */
                    .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_MAC),
                },
            },
    },
    /* last filter must be empty */
    {},
};
#endif
#endif  // NEEDS_PORTING

void iwl_mvm_ref(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
  if (!iwl_mvm_is_d0i3_supported(mvm)) {
    return;
  }

  IWL_DEBUG_RPM(mvm, "Take mvm reference - type %d\n", ref_type);
  mtx_lock(&mvm->refs_lock);
  mvm->refs[ref_type]++;
  mtx_unlock(&mvm->refs_lock);
  iwl_trans_ref(mvm->trans);
}

void iwl_mvm_unref(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
  if (!iwl_mvm_is_d0i3_supported(mvm)) {
    return;
  }

  IWL_DEBUG_RPM(mvm, "Leave mvm reference - type %d\n", ref_type);
  mtx_lock(&mvm->refs_lock);
  if (WARN_ON(!mvm->refs[ref_type])) {
    mtx_unlock(&mvm->refs_lock);
    return;
  }
  mvm->refs[ref_type]--;
  mtx_unlock(&mvm->refs_lock);
  iwl_trans_unref(mvm->trans);
}

static void iwl_mvm_unref_all_except(struct iwl_mvm* mvm, enum iwl_mvm_ref_type except_ref) {
  enum iwl_mvm_ref_type i, j;

  if (!iwl_mvm_is_d0i3_supported(mvm)) {
    return;
  }

  mtx_lock(&mvm->refs_lock);
  for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
    if (except_ref == i || !mvm->refs[i]) {
      continue;
    }

    IWL_DEBUG_RPM(mvm, "Cleanup: remove mvm ref type %d (%d)\n", i, mvm->refs[i]);
    for (j = 0; j < mvm->refs[i]; j++) {
      iwl_trans_unref(mvm->trans);
    }
    mvm->refs[i] = 0;
  }
  mtx_unlock(&mvm->refs_lock);
}

bool iwl_mvm_ref_taken(struct iwl_mvm* mvm) {
  int i;
  bool taken = false;

  if (!iwl_mvm_is_d0i3_supported(mvm)) {
    return true;
  }

  mtx_lock(&mvm->refs_lock);
  for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
    if (mvm->refs[i]) {
      taken = true;
      break;
    }
  }
  mtx_unlock(&mvm->refs_lock);

  return taken;
}

zx_status_t iwl_mvm_ref_sync(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
  iwl_mvm_ref(mvm, ref_type);

#if 0   // NEEDS_PORTING
    if (!wait_event_timeout(mvm->d0i3_exit_waitq, !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
                            HZ)) {
        WARN_ON_ONCE(1);
        iwl_mvm_unref(mvm, ref_type);
        return -EIO;
    }
#endif  // NEEDS_PORTING

  return ZX_OK;
}

static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm* mvm) {
  int i;

  memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
  for (i = 0; i < NUM_PHY_CTX; i++) {
    mvm->phy_ctxts[i].id = i;
    mvm->phy_ctxts[i].ref = 0;
  }
}

zx_status_t iwl_mvm_get_regdomain(struct iwl_mvm* mvm, const char* alpha2,
                                  enum iwl_mcc_source src_id, bool* changed,
                                  wlanphy_country_t* out_country) {
  wlanphy_country_t country = {};
  wlanphy_country_t* regd = &country;
  struct iwl_mcc_update_resp* resp;

  ZX_ASSERT(out_country);

  IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);

  iwl_assert_lock_held(&mvm->mutex);

  zx_status_t ret = iwl_mvm_update_mcc(mvm, alpha2, src_id, &resp);
  if (ret != ZX_OK) {
    IWL_DEBUG_LAR(mvm, "Could not get update from FW %s\n", zx_status_get_string(ret));
    goto out;
  }

  if (changed) {
    uint32_t status = le32_to_cpu(resp->status);

    *changed = (status == MCC_RESP_NEW_CHAN_PROFILE || status == MCC_RESP_ILLEGAL);
  }

#if 1  // NEEDS_PORTING
  country.alpha2[0] = le16_to_cpu(resp->mcc) >> 8;
  country.alpha2[1] = le16_to_cpu(resp->mcc) & 0xff;
  *out_country = *regd;
#else   // NEEDS_PORTING
  // TODO(fxbug.dev/87321): port iwl_parse_nvm_mcc_info()
  struct ieee80211_regdomain* regd = iwl_parse_nvm_mcc_info(
      mvm->trans->dev, mvm->cfg, __le32_to_cpu(resp->n_channels), resp->channels,
      __le16_to_cpu(resp->mcc), __le16_to_cpu(resp->geo_info));
#endif  // NEEDS_PORTING

  /* Store the return source id */
  src_id = resp->source_id;
  free(resp);
  if (ret != ZX_OK) {
    IWL_DEBUG_LAR(mvm, "Could not get parse update from FW: %s\n", zx_status_get_string(ret));
    goto out;
  }

  IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %c%c (0x%x, 0x%x) src=%d\n", regd->alpha2[0],
                regd->alpha2[1], regd->alpha2[0], regd->alpha2[1], src_id);
  mvm->lar_regdom_set = true;
  mvm->mcc_src = src_id;

out:
  return ret;
}

#if 0   // NEEDS_PORTING
void iwl_mvm_update_changed_regdom(struct iwl_mvm* mvm) {
    bool changed;
    struct ieee80211_regdomain* regd;

    if (!iwl_mvm_is_lar_supported(mvm)) { return; }

    regd = iwl_mvm_get_current_regdomain(mvm, &changed);
    if (!IS_ERR_OR_NULL(regd)) {
        /* only update the regulatory core if changed */
        if (changed) { regulatory_set_wiphy_regd(mvm->hw->wiphy, regd); }

        kfree(regd);
    }
}
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_get_current_regdomain(struct iwl_mvm* mvm, bool* changed,
                                          wlanphy_country_t* out_country) {
  return iwl_mvm_get_regdomain(
      mvm, "ZZ", iwl_mvm_is_wifi_mcc_supported(mvm) ? MCC_SOURCE_GET_CURRENT : MCC_SOURCE_OLD_FW,
      changed, out_country);
}

#if 0  // NEEDS_PORTING
int iwl_mvm_init_fw_regd(struct iwl_mvm* mvm) {
    enum iwl_mcc_source used_src;
    struct ieee80211_regdomain* regd;
    int ret;
    bool changed;
    const struct ieee80211_regdomain* r = rtnl_dereference(mvm->hw->wiphy->regd);

    if (!r) { return -ENOENT; }

    /* save the last source in case we overwrite it below */
    used_src = mvm->mcc_src;
    if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
        /* Notify the firmware we support wifi location updates */
        regd = iwl_mvm_get_current_regdomain(mvm, NULL);
        if (!IS_ERR_OR_NULL(regd)) { kfree(regd); }
    }

    /* Now set our last stored MCC and source */
    regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src, &changed);
    if (IS_ERR_OR_NULL(regd)) { return -EIO; }

    /* update cfg80211 if the regdomain was changed */
    if (changed) {
        ret = regulatory_set_wiphy_regd_sync_rtnl(mvm->hw->wiphy, regd);
    } else {
        ret = 0;
    }

    kfree(regd);
    return ret;
}

const static uint8_t he_if_types_ext_capa_sta[] = {
    [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
    [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
    [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
};

#ifdef CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE
const static uint8_t he_if_types_ext_capa_ap[] = {
    [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
    [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
    [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
};
#endif /* CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE */

const static struct wiphy_iftype_ext_capab he_iftypes_ext_capa[] = {
    {
        .iftype = NL80211_IFTYPE_STATION,
        .extended_capabilities = he_if_types_ext_capa_sta,
        .extended_capabilities_mask = he_if_types_ext_capa_sta,
        .extended_capabilities_len = sizeof(he_if_types_ext_capa_sta),
    },
#ifdef CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE
    {
        .iftype = NL80211_IFTYPE_AP,
        .extended_capabilities = he_if_types_ext_capa_ap,
        .extended_capabilities_mask = he_if_types_ext_capa_ap,
        .extended_capabilities_len = sizeof(he_if_types_ext_capa_ap),
    },
#endif  /* CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE */
};
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_mac_setup_register(struct iwl_mvm* mvm) {
#if 0   // NEEDS_PORTING: for cipher
    BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 6);
    memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
    hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
    hw->wiphy->cipher_suites = mvm->ciphers;

    if (iwl_mvm_has_new_rx_api(mvm)) {
        mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_GCMP;
        hw->wiphy->n_cipher_suites++;
        mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_GCMP_256;
        hw->wiphy->n_cipher_suites++;
    }

    /* Enable 11w if software crypto is not enabled (as the
     * firmware will interpret some mgmt packets, so enabling it
     * with software crypto isn't safe).
     */
    if (!iwlwifi_mod_params.swcrypto) {
        ieee80211_hw_set(hw, MFP_CAPABLE);
        mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_AES_CMAC;
        hw->wiphy->n_cipher_suites++;
        if (iwl_mvm_has_new_rx_api(mvm)) {
            mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_BIP_GMAC_128;
            hw->wiphy->n_cipher_suites++;
            mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_BIP_GMAC_256;
            hw->wiphy->n_cipher_suites++;
        }
    }

    /* currently FW API supports only one optional cipher scheme */
    if (mvm->fw->cs[0].cipher) {
        const struct iwl_fw_cipher_scheme* fwcs = &mvm->fw->cs[0];
        struct ieee80211_cipher_scheme* cs = &mvm->cs[0];

        mvm->hw->n_cipher_schemes = 1;

        cs->cipher = le32_to_cpu(fwcs->cipher);
        cs->iftype = BIT(NL80211_IFTYPE_STATION);
        cs->hdr_len = fwcs->hdr_len;
        cs->pn_len = fwcs->pn_len;
        cs->pn_off = fwcs->pn_off;
        cs->key_idx_off = fwcs->key_idx_off;
        cs->key_idx_mask = fwcs->key_idx_mask;
        cs->key_idx_shift = fwcs->key_idx_shift;
        cs->mic_len = fwcs->mic_len;

        mvm->hw->cipher_schemes = mvm->cs;
        mvm->ciphers[hw->wiphy->n_cipher_suites] = cs->cipher;
        hw->wiphy->n_cipher_suites++;
    }
#endif  // NEEDS_PORTING

#if 0  // TODO(fxbug.dev/36682): We need nvm.c porting iwl_nvm_init()
    /* Extract MAC address */
    memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);

    /* Extract additional MAC addresses if available */
    size_t num_mac =
        (mvm->nvm_data->n_hw_addrs > 1) ? MIN(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;

    for (size_t i = 1; i < num_mac; i++) {
        memcpy(mvm->addresses[i].addr, mvm->addresses[i - 1].addr, ETH_ALEN);
        mvm->addresses[i].addr[5]++;
    }
#endif

  iwl_mvm_reset_phy_ctxts(mvm);

  BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
  BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > IWL_MVM_SCAN_MASK_HWEIGHT32 ||
               IWL_MVM_MAX_LMAC_SCANS > IWL_MVM_SCAN_MASK_HWEIGHT32);

  if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
    mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
  } else {
    mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
  }

  mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;

#ifdef CONFIG_PM_SLEEP
  if (iwl_mvm_is_d0i3_supported(mvm) && device_can_wakeup(mvm->trans->dev)) {
    mvm->wowlan.flags = WIPHY_WOWLAN_ANY;
    hw->wiphy->wowlan = &mvm->wowlan;
  }

  if (mvm->fw->img[IWL_UCODE_WOWLAN].num_sec && mvm->trans->ops->d3_suspend &&
      mvm->trans->ops->d3_resume && device_can_wakeup(mvm->trans->dev)) {
    mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT |
                         WIPHY_WOWLAN_EAP_IDENTITY_REQ | WIPHY_WOWLAN_RFKILL_RELEASE |
                         WIPHY_WOWLAN_NET_DETECT;
    if (!iwlwifi_mod_params.swcrypto)
      mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | WIPHY_WOWLAN_GTK_REKEY_FAILURE |
                           WIPHY_WOWLAN_4WAY_HANDSHAKE;

    mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
    mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
    mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
    mvm->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES;
    hw->wiphy->wowlan = &mvm->wowlan;
  }
#endif

#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
  /* assign default bcast filtering configuration */
  mvm->bcast_filters = iwl_mvm_default_bcast_filters;
#endif

#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
  iwl_mvm_set_wiphy_vendor_commands(hw->wiphy);
#endif

  zx_status_t ret = iwl_mvm_leds_init(mvm);
  if (ret) {
    return ret;
  }

  mvm->init_status |= IWL_MVM_INIT_STATUS_REG_HW_INIT_COMPLETE;

  return ZX_OK;
}

#if 0   // NEEDS_PORTING
static bool iwl_mvm_defer_tx(struct iwl_mvm* mvm, struct ieee80211_sta* sta, struct sk_buff* skb) {
    struct iwl_mvm_sta* mvmsta;
    bool defer = false;

    /*
     * double check the IN_D0I3 flag both before and after
     * taking the spinlock, in order to prevent taking
     * the spinlock when not needed.
     */
    if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status))) { return false; }

    spin_lock(&mvm->d0i3_tx_lock);
    /*
     * testing the flag again ensures the skb dequeue
     * loop (on d0i3 exit) hasn't run yet.
     */
    if (!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)) { goto out; }

    mvmsta = iwl_mvm_sta_from_mac80211(sta);
    if (mvmsta->sta_id == IWL_MVM_INVALID_STA || mvmsta->sta_id != mvm->d0i3_ap_sta_id) {
        goto out;
    }

    __skb_queue_tail(&mvm->d0i3_tx, skb);

    /* trigger wakeup */
    iwl_mvm_ref(mvm, IWL_MVM_REF_TX);
    iwl_mvm_unref(mvm, IWL_MVM_REF_TX);

    defer = true;
out:
    spin_unlock(&mvm->d0i3_tx_lock);
    return defer;
}
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_mac_tx(struct iwl_mvm_vif* mvmvif, struct iwl_mvm_sta* mvmsta,
                           struct ieee80211_mac_packet* pkt) {
  iwl_assert_lock_held(&mvmvif->mvm->mutex);

  if (mvmvif->mac_role != WLAN_MAC_ROLE_CLIENT) {
    IWL_ERR(mvmvif, "%s(): not supported MAC role %d yet\n", __func__, mvmvif->mac_role);
    return ZX_ERR_INVALID_ARGS;
  }

  return iwl_mvm_tx_skb(mvmvif->mvm, pkt, mvmsta);

#if 0   // NEEDS_PORTING
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct ieee80211_sta* sta = control->sta;
    struct ieee80211_tx_info* info = IEEE80211_SKB_CB(skb);
    struct ieee80211_hdr* hdr = (void*)skb->data;
    bool offchannel = IEEE80211_SKB_CB(skb)->flags & IEEE80211_TX_CTL_TX_OFFCHAN;

    if (iwl_mvm_is_radio_killed(mvm)) {
        IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
        goto drop;
    }

    if (offchannel && !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
        !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status)) {
        goto drop;
    }

    /* treat non-bufferable MMPDUs on AP interfaces as broadcast */
    if ((info->control.vif->type == NL80211_IFTYPE_AP ||
         info->control.vif->type == NL80211_IFTYPE_ADHOC) &&
        ieee80211_is_mgmt(hdr->frame_control) &&
        !ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
        sta = NULL;
    }

    /* If there is no sta, and it's not offchannel - send through AP */
    if (!sta && info->control.vif->type == NL80211_IFTYPE_STATION && !offchannel) {
        struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(info->control.vif);
        uint8_t ap_sta_id = READ_ONCE(mvmvif->ap_sta_id);

        if (ap_sta_id < IWL_MVM_STATION_COUNT) {
            /* mac80211 holds rcu read lock */
            sta = rcu_dereference(mvm->fw_id_to_mac_id[ap_sta_id]);
            if (IS_ERR_OR_NULL(sta)) { goto drop; }
        }
    }

    if (sta) {
        if (iwl_mvm_defer_tx(mvm, sta, skb)) { return; }
        if (iwl_mvm_tx_skb(mvm, skb, sta)) { goto drop; }
        return;
    }

    if (iwl_mvm_tx_skb_non_sta(mvm, skb)) { goto drop; }
    return;
drop:
    ieee80211_free_txskb(hw, skb);
#endif  // NEEDS_PORTING
}

void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw* hw, struct ieee80211_txq* txq) {
#if 0   // NEEDS_PORTING
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_txq* mvmtxq = iwl_mvm_txq_from_mac80211(txq);
    struct sk_buff* skb = NULL;

    spin_lock(&mvmtxq->tx_path_lock);

    rcu_read_lock();
    while (likely(!mvmtxq->stopped && (mvm->trans->system_pm_mode == IWL_PLAT_PM_MODE_DISABLED))) {
        skb = ieee80211_tx_dequeue(hw, txq);

        if (!skb) { break; }

        if (!txq->sta) {
            iwl_mvm_tx_skb_non_sta(mvm, skb);
        } else {
            iwl_mvm_tx_skb(mvm, skb, txq->sta);
        }
    }
    rcu_read_unlock();

    spin_unlock(&mvmtxq->tx_path_lock);
#endif  // NEEDS_PORTING
}

#if 0  // NEEDS_PORTING
static void iwl_mvm_mac_wake_tx_queue(struct ieee80211_hw* hw, struct ieee80211_txq* txq) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_txq* mvmtxq = iwl_mvm_txq_from_mac80211(txq);

    /*
     * Please note that racing is handled very carefully here:
     * mvmtxq->txq_id is updated during allocation, and mvmtxq->list is
     * deleted afterwards.
     * This means that if:
     * mvmtxq->txq_id != INVALID_QUEUE && list_empty(&mvmtxq->list):
     *  queue is allocated and we can TX.
     * mvmtxq->txq_id != INVALID_QUEUE && !list_empty(&mvmtxq->list):
     *  a race, should defer the frame.
     * mvmtxq->txq_id == INVALID_QUEUE && list_empty(&mvmtxq->list):
     *  need to allocate the queue and defer the frame.
     * mvmtxq->txq_id == INVALID_QUEUE && !list_empty(&mvmtxq->list):
     *  queue is already scheduled for allocation, no need to allocate,
     *  should defer the frame.
     */

    /* If the queue is allocated TX and return. */
    if (!txq->sta || mvmtxq->txq_id != IWL_MVM_INVALID_QUEUE) {
        /*
         * Check that list is empty to avoid a race where txq_id is
         * already updated, but the queue allocation work wasn't
         * finished
         */
        if (unlikely(txq->sta && !list_empty(&mvmtxq->list))) { return; }

        iwl_mvm_mac_itxq_xmit(hw, txq);
        return;
    }

    /* The list is being deleted only after the queue is fully allocated. */
    if (!list_empty(&mvmtxq->list)) { return; }

    list_add_tail(&mvmtxq->list, &mvm->add_stream_txqs);
    schedule_work(&mvm->add_stream_wk);
}

static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg* cfg) {
    if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG) { return false; }
    return true;
}

static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg* cfg) {
    if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG) { return false; }
    if (iwlwifi_mod_params.disable_11n & IWL_ENABLE_HT_TXAGG) { return true; }

    /* enabled by default */
    return true;
}

#define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...) \
  do {                                                        \
    if (!(le16_to_cpu(_tid_bm) & BIT(_tid)))                  \
      break;                                                  \
    iwl_fw_dbg_collect_trig(&(_mvm)->fwrt, _trig, _fmt);      \
  } while (0)

static void iwl_mvm_ampdu_check_trigger(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                        struct ieee80211_sta* sta, uint16_t tid, uint16_t rx_ba_ssn,
                                        enum ieee80211_ampdu_mlme_action action) {
    struct iwl_fw_dbg_trigger_tlv* trig;
    struct iwl_fw_dbg_trigger_ba* ba_trig;

    trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), FW_DBG_TRIGGER_BA);
    if (!trig) { return; }

    ba_trig = (void*)trig->data;

    switch (action) {
    case IEEE80211_AMPDU_TX_OPERATIONAL: {
        struct iwl_mvm_sta* mvmsta = iwl_mvm_sta_from_mac80211(sta);
        struct iwl_mvm_tid_data* tid_data = &mvmsta->tid_data[tid];

        CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
                         "TX AGG START: MAC %pM tid %d ssn %d\n", sta->addr, tid, tid_data->ssn);
        break;
    }
    case IEEE80211_AMPDU_TX_STOP_CONT:
        CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid, "TX AGG STOP: MAC %pM tid %d\n",
                         sta->addr, tid);
        break;
    case IEEE80211_AMPDU_RX_START:
        CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
                         "RX AGG START: MAC %pM tid %d ssn %d\n", sta->addr, tid, rx_ba_ssn);
        break;
    case IEEE80211_AMPDU_RX_STOP:
        CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid, "RX AGG STOP: MAC %pM tid %d\n",
                         sta->addr, tid);
        break;
    default:
        break;
    }
}

static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                    struct ieee80211_ampdu_params* params) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int ret;
    bool tx_agg_ref = false;
    struct ieee80211_sta* sta = params->sta;
    enum ieee80211_ampdu_mlme_action action = params->action;
    uint16_t tid = params->tid;
    uint16_t* ssn = &params->ssn;
    uint16_t buf_size = params->buf_size;
    bool amsdu = params->amsdu;
    uint16_t timeout = params->timeout;

    IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n", sta->addr, tid, action);

    if (!(mvm->nvm_data->sku_cap_11n_enable)) { return -EACCES; }

    /* return from D0i3 before starting a new Tx aggregation */
    switch (action) {
    case IEEE80211_AMPDU_TX_START:
    case IEEE80211_AMPDU_TX_STOP_CONT:
    case IEEE80211_AMPDU_TX_STOP_FLUSH:
    case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
    case IEEE80211_AMPDU_TX_OPERATIONAL:
        /*
         * for tx start, wait synchronously until D0i3 exit to
         * get the correct sequence number for the tid.
         * additionally, some other ampdu actions use direct
         * target access, which is not handled automatically
         * by the trans layer (unlike commands), so wait for
         * d0i3 exit in these cases as well.
         */
        ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_TX_AGG);
        if (ret) { return ret; }

        tx_agg_ref = true;
        break;
    default:
        break;
    }

    mutex_lock(&mvm->mutex);

    switch (action) {
    case IEEE80211_AMPDU_RX_START:
        if (iwl_mvm_vif_from_mac80211(vif)->ap_sta_id == iwl_mvm_sta_from_mac80211(sta)->sta_id) {
            struct iwl_mvm_vif* mvmvif;
            uint16_t macid = iwl_mvm_vif_from_mac80211(vif)->id;
            struct iwl_mvm_tcm_mac* mdata = &mvm->tcm.data[macid];

            mdata->opened_rx_ba_sessions = true;
            mvmvif = iwl_mvm_vif_from_mac80211(vif);
            cancel_delayed_work(&mvmvif->uapsd_nonagg_detected_wk);
        }
        if (!iwl_enable_rx_ampdu(mvm->cfg)) {
            ret = -EINVAL;
            break;
        }
        ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true, buf_size, timeout);
        break;
    case IEEE80211_AMPDU_RX_STOP:
        ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false, buf_size, timeout);
        break;
    case IEEE80211_AMPDU_TX_START:
        if (!iwl_enable_tx_ampdu(mvm->cfg)) {
            ret = -EINVAL;
            break;
        }
        ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
        break;
    case IEEE80211_AMPDU_TX_STOP_CONT:
        ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
        break;
    case IEEE80211_AMPDU_TX_STOP_FLUSH:
    case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
        ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
        break;
    case IEEE80211_AMPDU_TX_OPERATIONAL:
        ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid, buf_size, amsdu);
        break;
    default:
        WARN_ON_ONCE(1);
        ret = -EINVAL;
        break;
    }

    if (!ret) {
        uint16_t rx_ba_ssn = 0;

        if (action == IEEE80211_AMPDU_RX_START) { rx_ba_ssn = *ssn; }

        iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid, rx_ba_ssn, action);
    }
    mutex_unlock(&mvm->mutex);

    /*
     * If the tid is marked as started, we won't use it for offloaded
     * traffic on the next D0i3 entry. It's safe to unref.
     */
    if (tx_agg_ref) { iwl_mvm_unref(mvm, IWL_MVM_REF_TX_AGG); }

    return ret;
}

static void iwl_mvm_cleanup_iterator(void* data, uint8_t* mac, struct ieee80211_vif* vif) {
    struct iwl_mvm* mvm = data;
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    mvmvif->uploaded = false;
    mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;

    spin_lock_bh(&mvm->time_event_lock);
    iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
    spin_unlock_bh(&mvm->time_event_lock);

    mvmvif->phy_ctxt = NULL;
    memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
    memset(&mvmvif->probe_resp_data, 0, sizeof(mvmvif->probe_resp_data));
}
#endif  // NEEDS_PORTING

static void iwl_mvm_restart_cleanup(struct iwl_mvm* mvm) {
#if 0  // NEEDS_PORTING
    /* clear the D3 reconfig, we only need it to avoid dumping a
     * firmware coredump on reconfiguration, we shouldn't do that
     * on D3->D0 transition
     */
    if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status)) {
        mvm->fwrt.dump.desc = &iwl_dump_desc_assert;
        iwl_fw_error_dump(&mvm->fwrt);

#ifdef CPTCFG_IWLWIFI_DEVICE_TESTMODE
        iwl_dnt_dispatch_handle_nic_err(mvm->trans);
#endif
    }
#endif  // NEEDS_PORTING

  /* cleanup all stale references (scan, roc), but keep the
   * ucode_down ref until reconfig is complete
   */
  iwl_mvm_unref_all_except(mvm, IWL_MVM_REF_UCODE_DOWN);

  iwl_mvm_stop_device(mvm);

  mvm->scan_status = 0;
  mvm->ps_disabled = false;
  mvm->calibrating = false;

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
  /*
   * In case that 2g coex was enabled - and now the FW is being
   * restarted, we need to disable 2g coex mode in the driver as well
   * so that the fw & driver will be synced on the mode.
   */
  mvm->coex_2g_enabled = false;
#endif

#if 0   // NEEDS_PORTING
    /* just in case one was running */
    iwl_mvm_cleanup_roc_te(mvm);
    ieee80211_remain_on_channel_expired(mvm->hw);
#endif  // NEEDS_PORTING

#if 0   // NEEDS_PORTING
    /*
     * cleanup all interfaces, even inactive ones, as some might have
     * gone down during the HW restart
     */
    ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
#endif  // NEEDS_PORTING

  mvm->p2p_device_vif = NULL;
  mvm->d0i3_ap_sta_id = IWL_MVM_INVALID_STA;

  iwl_mvm_reset_phy_ctxts(mvm);
  memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));
  memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
  memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));

#if 0   // NEEDS_PORTING
    ieee80211_wake_queues(mvm->hw);
#endif  // NEEDS_PORTING

  /* clear any stale d0i3 state */
  clear_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status);

  mvm->vif_count = 0;
  mvm->rx_ba_sessions = 0;
  mvm->fwrt.dump.conf = FW_DBG_INVALID;
  mvm->monitor_on = false;

  /* keep statistics ticking */
  iwl_mvm_accu_radio_stats(mvm);
}

zx_status_t __iwl_mvm_mac_start(struct iwl_mvm* mvm) {
  zx_status_t ret;

  if (mvm->mac_started) {
    // Silently return ZX_OK for now. TODO(fxbug.dev/93496).
    return ZX_OK;
  }

  iwl_assert_lock_held(&mvm->mutex);

  if (test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status)) {
    /*
     * Now convert the HW_RESTART_REQUESTED flag to IN_HW_RESTART
     * so later code will - from now on - see that we're doing it.
     */
    set_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
    clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status);
    /* Clean up some internal and mac80211 state on restart */
    iwl_mvm_restart_cleanup(mvm);
  } else {
    /* Hold the reference to prevent runtime suspend while
     * the start procedure runs.  It's a bit confusing
     * that the UCODE_DOWN reference is taken, but it just
     * means "UCODE is not UP yet". ( TODO: rename this
     * reference).
     */
    iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
  }
  ret = iwl_mvm_up(mvm);

#if 0   // NEEDS_PORTING
    iwl_fw_dbg_apply_point(&mvm->fwrt, IWL_FW_INI_APPLY_POST_INIT);
#endif  // NEEDS_PORTING

  if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
    /* Something went wrong - we need to finish some cleanup
     * that normally iwl_mvm_mac_restart_complete() below
     * would do.
     */
    clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
#ifdef CONFIG_PM
    iwl_mvm_d0i3_enable_tx(mvm, NULL);
#endif
  }
  if (ret == ZX_OK)
    mvm->mac_started = true;

  return ret;
}

zx_status_t iwl_mvm_mac_start(struct iwl_mvm* mvm) {
  zx_status_t ret;

#if 0   // NEEDS_PORTING
    /* Some hw restart cleanups must not hold the mutex */
    if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
        /*
         * Make sure we are out of d0i3. This is needed
         * to make sure the reference accounting is correct
         * (and there is no stale d0i3_exit_work).
         */
        wait_event_timeout(mvm->d0i3_exit_waitq, !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
                           HZ);
    }
#endif  // NEEDS_PORTING

  mtx_lock(&mvm->mutex);
  ret = __iwl_mvm_mac_start(mvm);
  mtx_unlock(&mvm->mutex);

  return ret;
}

#if 0  // NEEDS_PORTING
static void iwl_mvm_restart_complete(struct iwl_mvm* mvm) {
    int ret;

    mutex_lock(&mvm->mutex);

    clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
#ifdef CONFIG_PM
    iwl_mvm_d0i3_enable_tx(mvm, NULL);
#endif
    ret = iwl_mvm_update_quotas(mvm, true, NULL);
    if (ret) { IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n", ret); }

    /* allow transport/FW low power modes */
    iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);

    /*
     * If we have TDLS peers, remove them. We don't know the last seqno/PN
     * of packets the FW sent out, so we must reconnect.
     */
    iwl_mvm_teardown_tdls_peers(mvm);

    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_resume_complete(struct iwl_mvm* mvm) {
    if (iwl_mvm_is_d0i3_supported(mvm) && iwl_mvm_enter_d0i3_on_suspend(mvm))
        WARN_ONCE(!wait_event_timeout(mvm->d0i3_exit_waitq,
                                      !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status), HZ),
                  "D0i3 exit on resume timed out\n");
}

static void iwl_mvm_mac_reconfig_complete(struct ieee80211_hw* hw,
                                          enum ieee80211_reconfig_type reconfig_type) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    switch (reconfig_type) {
    case IEEE80211_RECONFIG_TYPE_RESTART:
        iwl_mvm_restart_complete(mvm);
        break;
    case IEEE80211_RECONFIG_TYPE_SUSPEND:
        iwl_mvm_resume_complete(mvm);
        break;
    }
}
#endif  // NEEDS_PORTING

void __iwl_mvm_mac_stop(struct iwl_mvm* mvm) {
  iwl_assert_lock_held(&mvm->mutex);

  /* firmware counters are obviously reset now, but we shouldn't
   * partially track so also clear the fw_reset_accu counters.
   */
  memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));

  /* async_handlers_wk is now blocked */

#if 0   // NEEDS_PORTING
    /*
     * The work item could be running or queued if the
     * ROC time event stops just as we get here.
     */
    flush_work(&mvm->roc_done_wk);
#endif  // NEEDS_PORTING

  iwl_mvm_stop_device(mvm);

  iwl_mvm_async_handlers_purge(mvm);
  /* async_handlers_list is empty and will stay empty: HW is stopped */

  /* the fw is stopped, the aux sta is dead: clean up driver state */
  iwl_mvm_del_aux_sta(mvm);

#if 0   // NEEDS_PORTING
    /*
     * Clear IN_HW_RESTART and HW_RESTART_REQUESTED flag when stopping the
     * hw (as restart_complete() won't be called in this case) and mac80211
     * won't execute the restart.
     * But make sure to cleanup interfaces that have gone down before/during
     * HW restart was requested.
     */
    if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) ||
        test_and_clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status)) {
        ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
    }
#endif  // NEEDS_PORTING

  /* We shouldn't have any UIDs still set.  Loop over all the UIDs to
   * make sure there's nothing left there and warn if any is found.
   */
  if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
    for (unsigned int i = 0; i < mvm->max_scans; i++) {
      if (mvm->scan_uid_status[i]) {
        IWL_WARN(mvm, "UMAC scan UID %d status was not cleaned\n", i);
        mvm->scan_uid_status[i] = 0;
      }
    }
  }
}

void iwl_mvm_mac_stop(struct iwl_mvm* mvm) {
#if 0   // NEEDS_PORTING
    flush_work(&mvm->d0i3_exit_work);
    flush_work(&mvm->async_handlers_wk);
    flush_work(&mvm->add_stream_wk);
#endif  // NEEDS_PORTING

  /*
   * Lock and clear the firmware running bit here already, so that
   * new commands coming in elsewhere, e.g. from debugfs, will not
   * be able to proceed. This is important here because one of those
   * debugfs files causes the firmware dump to be triggered, and if we
   * don't stop debugfs accesses before canceling that it could be
   * retriggered after we flush it but before we've cleared the bit.
   */
  clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);

  iwl_fw_cancel_dump(&mvm->fwrt);

#if 0  // NEEDS_PORTING
#ifdef CPTCFG_MAC80211_LATENCY_MEASUREMENTS
    cancel_delayed_work_sync(&mvm->tx_latency_watchdog_wk);
#endif  /* CPTCFG_MAC80211_LATENCY_MEASUREMENTS */
    cancel_delayed_work_sync(&mvm->cs_tx_unblock_dwork);
#endif  // NEEDS_PORTING

  iwl_task_release_sync(mvm->scan_timeout_task);
  mvm->scan_timeout_task = NULL;
  iwl_fw_free_dump_desc(&mvm->fwrt);

  mtx_lock(&mvm->mutex);
  __iwl_mvm_mac_stop(mvm);
  mtx_unlock(&mvm->mutex);

#if 0   // NEEDS_PORTING
    /*
     * The worker might have been waiting for the mutex, let it run and
     * discover that its list is now empty.
     */
    cancel_work_sync(&mvm->async_handlers_wk);
#endif  // NEEDS_PORTING
}

static struct iwl_mvm_phy_ctxt* iwl_mvm_get_free_phy_ctxt(struct iwl_mvm* mvm) {
  uint16_t i;

  iwl_assert_lock_held(&mvm->mutex);

  for (i = 0; i < NUM_PHY_CTX; i++) {
    if (!mvm->phy_ctxts[i].ref) {
      return &mvm->phy_ctxts[i];
    }
  }

  IWL_ERR(mvm, "No available PHY context\n");
  return NULL;
}

#if 0  // NEEDS_PORTING
static int iwl_mvm_set_tx_power(struct iwl_mvm* mvm, struct ieee80211_vif* vif, int16_t tx_power) {
    int len;
    union {
        struct iwl_dev_tx_power_cmd v5;
        struct iwl_dev_tx_power_cmd_v4 v4;
    } cmd = {
        .v5.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
        .v5.v3.mac_context_id = cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
        .v5.v3.pwr_restriction = cpu_to_le16(8 * tx_power),
    };

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    /*
     * if set Tx power request did not come from Frequency Manager(FM)
     * Take minimum between wanted Tx power to FM Tx power limit
     */
    if (mvmvif->phy_ctxt && tx_power > mvmvif->phy_ctxt->fm_tx_power_limit) {
        cmd.v5.v3.pwr_restriction = cpu_to_le16(mvmvif->phy_ctxt->fm_tx_power_limit);
    }
#endif

    if (tx_power == IWL_DEFAULT_MAX_TX_POWER) {
        cmd.v5.v3.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
    }

    if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_REDUCE_TX_POWER)) {
        len = sizeof(cmd.v5);
    } else if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK)) {
        len = sizeof(cmd.v4);
    } else {
        len = sizeof(cmd.v4.v3);
    }

    return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
}

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
int iwl_mvm_fm_set_tx_power(struct iwl_mvm* mvm, struct ieee80211_vif* vif, int8_t txpower) {
    int ret;

    mutex_lock(&mvm->mutex);
    /* set Tx power to min between drivers limit and FM limit */
    ret = iwl_mvm_set_tx_power(mvm, vif, min_t(int8_t, txpower, vif->bss_conf.txpower));
    mutex_unlock(&mvm->mutex);
    return ret;
}

/*
 * Updates Tx power limitation for the mac if FM has already limited
 * the Tx power on the channel that this mac is using.
 */
static void iwl_mvm_update_ctx_tx_power_limit(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                              struct iwl_mvm_phy_ctxt* phy_ctxt) {
    /* Tx power has not been limited by FM */
    if (phy_ctxt->fm_tx_power_limit == IWL_DEFAULT_MAX_TX_POWER) { return; }
    iwl_mvm_set_tx_power(mvm, vif, phy_ctxt->fm_tx_power_limit);
}
#endif
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_find_free_mvmvif_slot(struct iwl_mvm* mvm, int* ret_idx) {
  int idx;

  ZX_ASSERT(ret_idx);

  iwl_assert_lock_held(&mvm->mutex);

  for (idx = 0; idx < MAX_NUM_MVMVIF; idx++) {
    if (!mvm->mvmvif[idx]) {
      *ret_idx = idx;
      return ZX_OK;
    }
  }
  return ZX_ERR_NO_RESOURCES;
}

// This function doesn't take the ownership of the mvmvif after binding. It just adds a reference
// from mvm to the mvmvif instance.
zx_status_t iwl_mvm_bind_mvmvif(struct iwl_mvm* mvm, int idx, struct iwl_mvm_vif* mvmvif) {
  iwl_assert_lock_held(&mvm->mutex);

  ZX_ASSERT(mvmvif);

  if (mvm->mvmvif[idx]) {
    IWL_ERR(mvm, "mvm->mvmvif[%d] has been binded.\n", idx);
    return ZX_ERR_ALREADY_EXISTS;
  }

  mvm->mvmvif[idx] = mvmvif;
  return ZX_OK;
}

void iwl_mvm_unbind_mvmvif(struct iwl_mvm* mvm, int idx) {
  iwl_assert_lock_held(&mvm->mutex);
  mvm->mvmvif[idx] = NULL;
}

zx_status_t iwl_mvm_mac_add_interface(struct iwl_mvm_vif* mvmvif) {
  struct iwl_mvm* mvm = mvmvif->mvm;
  mvmvif->probe_resp_data = NULL;

  /*
   * make sure D0i3 exit is completed, otherwise a target access
   * during tx queue configuration could be done when still in
   * D0i3 state.
   */
  zx_status_t ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_ADD_IF);
  if (ret != ZX_OK) {
    return ret;
  }

  /*
   * Not much to do here. The stack will not allow interface
   * types or combinations that we didn't advertise, so we
   * don't really have to check the types.
   */

  mtx_lock(&mvm->mutex);

  /* make sure that beacon statistics don't go backwards with FW reset */
  if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
    mvmvif->beacon_stats.accu_num_beacons += mvmvif->beacon_stats.num_beacons;
  }

  /* Allocate resources for the MAC context, and add it to the fw  */
  ret = iwl_mvm_mac_ctxt_init(mvmvif);
  if (ret != ZX_OK) {
    goto out_unlock;
  }

#if 0   // NEEDS_PORTING
    /* Currently not much to do for NAN */
    if (vif->type == NL80211_IFTYPE_NAN) { goto out_unlock; }

    /* Counting number of interfaces is needed for legacy PM */
    if (vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count++; }

    /*
     * The AP binding flow can be done only after the beacon
     * template is configured (which happens only in the mac80211
     * start_ap() flow), and adding the broadcast station can happen
     * only after the binding.
     * In addition, since modifying the MAC before adding a bcast
     * station is not allowed by the FW, delay the adding of MAC context to
     * the point where we can also add the bcast station.
     * In short: there's not much we can do at this point, other than
     * allocating resources :)
     */
    if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC) {
        ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
        if (ret) {
            IWL_ERR(mvm, "Failed to allocate bcast sta\n");
            goto out_release;
        }

        /*
         * Only queue for this station is the mcast queue,
         * which shouldn't be in TFD mask anyway
         */
        ret = iwl_mvm_allocate_int_sta(mvm, &mvmvif->mcast_sta, 0, vif->type, IWL_STA_MULTICAST);
        if (ret) { goto out_release; }

        iwl_mvm_vif_dbgfs_register(mvm, vif);
        goto out_unlock;
    }

    mvmvif->features |= hw->netdev_features;
#endif  // NEEDS_PORTING
  mvm->vif_count++;

  ret = iwl_mvm_mac_ctxt_add(mvmvif);
  if (ret != ZX_OK) {
    goto out_release;
  }

#if 0  // NEEDS_PORTING
    ret = iwl_mvm_power_update_mac(mvm);
    if (ret) { goto out_remove_mac; }

    /* beacon filtering */
    ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
    if (ret != ZX_OK) { goto out_remove_mac; }

    if (!mvm->bf_allowed_vif && vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
        mvm->bf_allowed_vif = mvmvif;
        vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI;
    }

    /*
     * P2P_DEVICE interface does not have a channel context assigned to it,
     * so a dedicated PHY context is allocated to it and the corresponding
     * MAC context is bound to it at this stage.
     */
    if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
        mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
        if (!mvmvif->phy_ctxt) {
            ret = -ENOSPC;
            goto out_free_bf;
        }

        iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
        ret = iwl_mvm_binding_add_vif(mvm, vif);
        if (ret) { goto out_unref_phy; }

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
        iwl_mvm_update_ctx_tx_power_limit(mvm, vif, mvmvif->phy_ctxt);
#endif

        ret = iwl_mvm_add_p2p_bcast_sta(mvm, vif);
        if (ret) { goto out_unbind; }

        /* Save a pointer to p2p device vif, so it can later be used to
         * update the p2p device MAC when a GO is started/stopped */
        mvm->p2p_device_vif = vif;
    }

    iwl_mvm_tcm_add_vif(mvm, vif);

    if (vif->type == NL80211_IFTYPE_MONITOR) { mvm->monitor_on = true; }

    iwl_mvm_vif_dbgfs_register(mvm, vif);
#endif  // NEEDS_PORTING
  goto out_unlock;

#if 0   // NEEDS_PORTING
out_unbind:
    iwl_mvm_binding_remove_vif(mvm, vif);
out_unref_phy:
    iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
out_free_bf:
    if (mvm->bf_allowed_vif == mvmvif) {
        mvm->bf_allowed_vif = NULL;
        vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI);
    }
out_remove_mac:
#endif  // NEEDS_PORTING
  mvmvif->phy_ctxt = NULL;
  iwl_mvm_mac_ctxt_remove(mvmvif);
out_release:
#if 0   // NEEDS_PORTING
    if (vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count--; }
#endif  // NEEDS_PORTING
  mvm->vif_count--;
out_unlock:
  mtx_unlock(&mvm->mutex);

  iwl_mvm_unref(mvm, IWL_MVM_REF_ADD_IF);

  return ret;
}

#if 0   // NEEDS_PORTING
static void iwl_mvm_prepare_mac_removal(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
    if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
        /*
         * Flush the ROC worker which will flush the OFFCHANNEL queue.
         * We assume here that all the packets sent to the OFFCHANNEL
         * queue are sent in ROC session.
         */
        flush_work(&mvm->roc_done_wk);
    }
}
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_mac_remove_interface(struct iwl_mvm_vif* mvmvif) {
  struct iwl_mvm* mvm = mvmvif->mvm;
  struct iwl_probe_resp_data* probe_data;

#if 0   // NEEDS_PORTING
    iwl_mvm_prepare_mac_removal(mvm, vif);

    if (vif->type == NL80211_IFTYPE_NAN) {
        struct wireless_dev* wdev = ieee80211_vif_to_wdev(vif);
        /* cfg80211 should stop NAN before interface removal */
        if (wdev && WARN_ON(wdev_running(wdev))) { iwl_mvm_stop_nan(hw, vif); }

        return;
    }

    if (!(vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC)) {
        iwl_mvm_tcm_rm_vif(mvm, vif);
    }
#endif  // NEEDS_PORTING

  mtx_lock(&mvm->mutex);

  probe_data = iwl_rcu_exchange(mvmvif->probe_resp_data, NULL);
  if (probe_data) {
    iwl_rcu_free_sync(mvm->dev, probe_data);
  }

#if 0  // NEEDS_PORTING
    if (mvm->bf_allowed_vif == mvmvif) {
        mvm->bf_allowed_vif = NULL;
        vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI);
    }

    iwl_mvm_vif_dbgfs_clean(mvm, vif);

    /*
     * For AP/GO interface, the tear down of the resources allocated to the
     * interface is be handled as part of the stop_ap flow.
     */
    if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC) {
#ifdef CPTCFG_NL80211_TESTMODE
        if (vif == mvm->noa_vif) {
            mvm->noa_vif = NULL;
            mvm->noa_duration = 0;
        }
#endif
        iwl_mvm_dealloc_int_sta(mvm, &mvmvif->mcast_sta);
        iwl_mvm_dealloc_bcast_sta(mvm, vif);
        goto out_release;
    }
#endif  // NEEDS_PORTING

#ifdef CPTCFG_IWLMVM_P2P_OPPPS_TEST_WA
  if (mvmvif == mvm->p2p_opps_test_wa_vif) {
    mvm->p2p_opps_test_wa_vif = NULL;
  }
#endif

#if 0   // NEEDS_PORTING
    if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
        mvm->p2p_device_vif = NULL;
        iwl_mvm_rm_p2p_bcast_sta(mvm, vif);
        iwl_mvm_binding_remove_vif(mvm, vif);
        iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
        mvmvif->phy_ctxt = NULL;
    }

    if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count--; }
#endif  // NEEDS_PORTING
  if (mvm->vif_count) {
    mvm->vif_count--;
  }

#if 0   // NEEDS_PORTING
    iwl_mvm_power_update_mac(mvm);
#endif  // NEEDS_PORTING
  zx_status_t ret = iwl_mvm_mac_ctxt_remove(mvmvif);

#if 0   // NEEDS_PORTING
    if (vif->type == NL80211_IFTYPE_MONITOR) { mvm->monitor_on = false; }
#endif  // NEEDS_PORTING

#ifdef CPTCFG_IWLMVM_TDLS_PEER_CACHE
  iwl_mvm_tdls_peer_cache_clear(mvm, vif);
#endif /* CPTCFG_IWLMVM_TDLS_PEER_CACHE */

#if 0   // NEEDS_PORTING
out_release:
#endif  // NEEDS_PORTING
  mtx_unlock(&mvm->mutex);

  return ret;
}

#if 0   // NEEDS_PORTING
static int iwl_mvm_mac_config(struct ieee80211_hw* hw, uint32_t changed) {
    return 0;
}
#endif  // NEEDS_PORTING

struct iwl_mvm_mc_iter_data {
  struct iwl_mvm* mvm;
  int port_id;
};

// Once the interface becomes an associated client interface, the driver uses the pre-configured
// MCAST_FILTER_CMD to tell firmware the multicast packets it is interested so that the firmware
// can forward them to driver when the firmware receives them.
//
static void iwl_mvm_mc_iface_iterator(void* _data, struct iwl_mvm_vif* mvmvif) {
  struct iwl_mvm_mc_iter_data* data = _data;
  struct iwl_mvm* mvm = data->mvm;
  struct iwl_mcast_filter_cmd* cmd = mvm->mcast_filter_cmd;
  struct iwl_host_cmd hcmd = {
      .id = MCAST_FILTER_CMD,
      .flags = CMD_ASYNC,
      .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
  };
  int ret, len;

#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
  if (!(mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL) && mvm->mcast_active_filter_cmd) {
    cmd = mvm->mcast_active_filter_cmd;
  }
#endif

  /* if we don't have free ports, mcast frames will be dropped */
  if (data->port_id >= MAX_PORT_ID_NUM) {
    IWL_WARN(mvmvif, "%s(): port id (%d) is larger than max port number (%d)\n", __func__,
             data->port_id, MAX_PORT_ID_NUM);
    return;
  }

  // Only client interface can continue. Other interfaces will be ignored.
  if (mvmvif->mac_role != WLAN_MAC_ROLE_CLIENT || !mvmvif->bss_conf.assoc) {
    IWL_ERR(mvmvif, "unexpected state while setting mcast filter. role: %d!=%d or assoc: %d!=%d\n",
            mvmvif->mac_role, WLAN_MAC_ROLE_CLIENT, mvmvif->bss_conf.assoc, true);
    return;
  }

  cmd->port_id = data->port_id++;
  memcpy(cmd->bssid, mvmvif->bss_conf.bssid, ETH_ALEN);
  len = ROUND_UP(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);

  hcmd.len[0] = len;
  hcmd.data[0] = cmd;

  ret = iwl_mvm_send_cmd(mvm, &hcmd);
  if (ret != ZX_OK) {
    IWL_ERR(mvmvif, "mcast filter cmd error. ret=%s\n", zx_status_get_string(ret));
  }
}

// Traverse all interfaces and set the multicast filter for associated client interface.
static void iwl_mvm_recalc_multicast(struct iwl_mvm* mvm) {
  struct iwl_mvm_mc_iter_data iter_data = {
      .mvm = mvm,
  };

  iwl_assert_lock_held(&mvm->mutex);

  if (!mvm->mcast_filter_cmd) {
    IWL_WARN(mvm, "%s(): mcast_filter_cmd is NULL\n", __func__);
    return;
  }

  ieee80211_iterate_active_interfaces_atomic(mvm, iwl_mvm_mc_iface_iterator, &iter_data);
}

#if 0   // NEEDS_PORTING
// TODO(51238): implement iwl_mvm_prepare_multicast()
static uint64_t iwl_mvm_prepare_multicast(struct ieee80211_hw* hw,
                                          struct netdev_hw_addr_list* mc_list) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mcast_filter_cmd* cmd;
    struct netdev_hw_addr* addr;
    int addr_count;
    bool pass_all;
    int len;

    addr_count = netdev_hw_addr_list_count(mc_list);
    pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES || IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
    if (pass_all) { addr_count = 0; }

    len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
    cmd = kzalloc(len, GFP_ATOMIC);
    if (!cmd) { return 0; }

    if (pass_all) {
        cmd->pass_all = 1;
        return (uint64_t)(unsigned long)cmd;
    }

    netdev_hw_addr_list_for_each(addr, mc_list) {
        IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n", cmd->count, addr->addr);
        memcpy(&cmd->addr_list[cmd->count * ETH_ALEN], addr->addr, ETH_ALEN);
        cmd->count++;
    }

    return (uint64_t)(unsigned long)cmd;
}
#endif  // NEEDS_PORTING

void iwl_mvm_configure_filter(struct iwl_mvm* mvm) {
  // There are 3 multicast addresses we want firmware to pass it to driver.
  // TODO(51238): remove the hardcoded mcast_addrs after iwl_mvm_prepare_multicast() is implemented.
  uint8_t mcast_addrs[][ETH_ALEN] = {
      {
          // IPv6 mutlicast address
          0x33,
          0x33,
          0x00,
          0x00,
          0x00,
          0x01,
      },
      {
          // IPv6 mutlicast address
          0x33,
          0x33,
          0x00,
          0x00,
          0x00,
          0x02,
      },
      {
          // IPv4 mutlicast address
          0x01,
          0x00,
          0x5e,
          0x00,
          0x00,
          0x01,
      },
  };

  struct iwl_mcast_filter_cmd* cmd =
      calloc(1, sizeof(struct iwl_mcast_filter_cmd) + sizeof(mcast_addrs));

  mtx_lock(&mvm->mutex);

  /* replace previous configuration */
  free(mvm->mcast_filter_cmd);
  mvm->mcast_filter_cmd = cmd;
  if (!cmd) {
    goto out;
  }

  if (cmd->pass_all) {
    cmd->count = 0;
  }

  for (size_t i = 0; i < ARRAY_SIZE(mcast_addrs); i++) {
    size_t offset = i * ETH_ALEN;
    memcpy(&cmd->addr_list[offset], mcast_addrs[i], ETH_ALEN);
  }
  cmd->count = ARRAY_SIZE(mcast_addrs);

#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
  iwl_mvm_active_rx_filters(mvm);
#endif
  iwl_mvm_recalc_multicast(mvm);
out:
  mtx_unlock(&mvm->mutex);
}

#if 0  // NEEDS_PORTING
static void iwl_mvm_config_iface_filter(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                        unsigned int filter_flags, unsigned int changed_flags) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    /* We support only filter for probe requests */
    if (!(changed_flags & FIF_PROBE_REQ)) { return; }

    /* Supported only for p2p client interfaces */
    if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc || !vif->p2p) { return; }

    mutex_lock(&mvm->mutex);
    iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
    mutex_unlock(&mvm->mutex);
}

#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
struct iwl_bcast_iter_data {
    struct iwl_mvm* mvm;
    struct iwl_bcast_filter_cmd* cmd;
    uint8_t current_filter;
};

static void iwl_mvm_set_bcast_filter(struct ieee80211_vif* vif,
                                     const struct iwl_fw_bcast_filter* in_filter,
                                     struct iwl_fw_bcast_filter* out_filter) {
    struct iwl_fw_bcast_filter_attr* attr;
    int i;

    memcpy(out_filter, in_filter, sizeof(*out_filter));

    for (i = 0; i < ARRAY_SIZE(out_filter->attrs); i++) {
        attr = &out_filter->attrs[i];

        if (!attr->mask) { break; }

        switch (attr->reserved1) {
        case cpu_to_le16(BC_FILTER_MAGIC_IP):
            if (vif->bss_conf.arp_addr_cnt != 1) {
                attr->mask = 0;
                continue;
            }

            attr->val = vif->bss_conf.arp_addr_list[0];
            break;
        case cpu_to_le16(BC_FILTER_MAGIC_MAC):
            attr->val = *(__be32*)&vif->addr[2];
            break;
        default:
            break;
        }
        attr->reserved1 = 0;
        out_filter->num_attrs++;
    }
}

static void iwl_mvm_bcast_filter_iterator(void* _data, uint8_t* mac, struct ieee80211_vif* vif) {
    struct iwl_bcast_iter_data* data = _data;
    struct iwl_mvm* mvm = data->mvm;
    struct iwl_bcast_filter_cmd* cmd = data->cmd;
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct iwl_fw_bcast_mac* bcast_mac;
    int i;

    if (WARN_ON(mvmvif->id >= ARRAY_SIZE(cmd->macs))) { return; }

    bcast_mac = &cmd->macs[mvmvif->id];

    /*
     * enable filtering only for associated stations, but not for P2P
     * Clients
     */
    if (vif->type != NL80211_IFTYPE_STATION || vif->p2p || !vif->bss_conf.assoc) { return; }

    bcast_mac->default_discard = 1;

    /* copy all configured filters */
    for (i = 0; mvm->bcast_filters[i].attrs[0].mask; i++) {
        /*
         * Make sure we don't exceed our filters limit.
         * if there is still a valid filter to be configured,
         * be on the safe side and just allow bcast for this mac.
         */
        if (WARN_ON_ONCE(data->current_filter >= ARRAY_SIZE(cmd->filters))) {
            bcast_mac->default_discard = 0;
            bcast_mac->attached_filters = 0;
            break;
        }

        iwl_mvm_set_bcast_filter(vif, &mvm->bcast_filters[i], &cmd->filters[data->current_filter]);

        /* skip current filter if it contains no attributes */
        if (!cmd->filters[data->current_filter].num_attrs) { continue; }

        /* attach the filter to current mac */
        bcast_mac->attached_filters |= cpu_to_le16(BIT(data->current_filter));

        data->current_filter++;
    }
}

bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm* mvm, struct iwl_bcast_filter_cmd* cmd) {
    struct iwl_bcast_iter_data iter_data = {
        .mvm = mvm,
        .cmd = cmd,
    };

    if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL) { return false; }

    memset(cmd, 0, sizeof(*cmd));
    cmd->max_bcast_filters = ARRAY_SIZE(cmd->filters);
    cmd->max_macs = ARRAY_SIZE(cmd->macs);

#ifdef CPTCFG_IWLWIFI_DEBUGFS
    /* use debugfs filters/macs if override is configured */
    if (mvm->dbgfs_bcast_filtering.override) {
        memcpy(cmd->filters, &mvm->dbgfs_bcast_filtering.cmd.filters, sizeof(cmd->filters));
        memcpy(cmd->macs, &mvm->dbgfs_bcast_filtering.cmd.macs, sizeof(cmd->macs));
        return true;
    }
#endif

    /* if no filters are configured, do nothing */
    if (!mvm->bcast_filters) { return false; }

#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
    if (!(mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL) &&
        mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_BCAST) {
        cmd->disable = 1;
        return true;
    }
#endif
    /* configure and attach these filters for each associated sta vif */
    ieee80211_iterate_active_interfaces(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
                                        iwl_mvm_bcast_filter_iterator, &iter_data);

    return true;
}

int iwl_mvm_configure_bcast_filter(struct iwl_mvm* mvm) {
    struct iwl_bcast_filter_cmd cmd;

    if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING)) { return 0; }

    if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd)) { return 0; }

    return iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0, sizeof(cmd), &cmd);
}
#else
inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm* mvm) {
    return 0;
}
#endif

static int iwl_mvm_update_mu_groups(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
    struct iwl_mu_group_mgmt_cmd cmd = {};

    memcpy(cmd.membership_status, vif->bss_conf.mu_group.membership, WLAN_MEMBERSHIP_LEN);
    memcpy(cmd.user_position, vif->bss_conf.mu_group.position, WLAN_USER_POSITION_LEN);

    return iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(DATA_PATH_GROUP, UPDATE_MU_GROUPS_CMD), 0, sizeof(cmd),
                                &cmd);
}

static void iwl_mvm_mu_mimo_iface_iterator(void* _data, uint8_t* mac, struct ieee80211_vif* vif) {
    if (vif->mu_mimo_owner) {
        struct iwl_mu_group_mgmt_notif* notif = _data;

        /*
         * MU-MIMO Group Id action frame is little endian. We treat
         * the data received from firmware as if it came from the
         * action frame, so no conversion is needed.
         */
        ieee80211_update_mu_groups(vif, (uint8_t*)&notif->membership_status,
                                   (uint8_t*)&notif->user_position);
    }
}

void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) {
    struct iwl_rx_packet* pkt = rxb_addr(rxb);
    struct iwl_mu_group_mgmt_notif* notif = (void*)pkt->data;

    ieee80211_iterate_active_interfaces_atomic(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
                                               iwl_mvm_mu_mimo_iface_iterator, notif);
}

static uint8_t iwl_mvm_he_get_ppe_val(uint8_t* ppe, uint8_t ppe_pos_bit) {
    uint8_t byte_num = ppe_pos_bit / 8;
    uint8_t bit_num = ppe_pos_bit % 8;
    uint8_t residue_bits;
    uint8_t res;

    if (bit_num <= 5) {
        return (ppe[byte_num] >> bit_num) & (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE) - 1);
    }

    /*
     * If bit_num > 5, we have to combine bits with next byte.
     * Calculate how many bits we need to take from current byte (called
     * here "residue_bits"), and add them to bits from next byte.
     */

    residue_bits = 8 - bit_num;

    res = (ppe[byte_num + 1] & (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE - residue_bits) - 1))
          << residue_bits;
    res += (ppe[byte_num] >> bit_num) & (BIT(residue_bits) - 1);

    return res;
}

static const uint8_t mac80211_ac_to_ucode_ac[] = {AC_VO, AC_VI, AC_BE, AC_BK};

static void iwl_mvm_cfg_he_sta(struct iwl_mvm* mvm, struct ieee80211_vif* vif, uint8_t sta_id) {
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct iwl_he_sta_context_cmd sta_ctxt_cmd = {
        .sta_id = sta_id,
        .tid_limit = IWL_MAX_TID_COUNT,
        .bss_color = vif->bss_conf.bss_color,
        .htc_trig_based_pkt_ext = vif->bss_conf.htc_trig_based_pkt_ext,
        .frame_time_rts_th = cpu_to_le16(vif->bss_conf.frame_time_rts_th),
    };
    struct ieee80211_sta* sta;
    uint32_t flags;
    int i;

    rcu_read_lock();

    sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_ctxt_cmd.sta_id]);
    if (IS_ERR(sta)) {
        rcu_read_unlock();
        WARN(1, "Can't find STA to configure HE\n");
        return;
    }

    if (!sta->he_cap.has_he) {
        rcu_read_unlock();
        return;
    }

    flags = 0;

    /* HTC flags */
    if (sta->he_cap.he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_HTC_HE) {
        sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_SUPPORT);
    }
    if ((sta->he_cap.he_cap_elem.mac_cap_info[1] & IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION) ||
        (sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION)) {
        uint8_t link_adap =
            ((sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION)
             << 1) +
            (sta->he_cap.he_cap_elem.mac_cap_info[1] & IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION);

        if (link_adap == 2) {
            sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_LINK_ADAP_UNSOLICITED);
        } else if (link_adap == 3) {
            sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_LINK_ADAP_BOTH);
        }
    }
    if (sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR) {
        sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BSR_SUPP);
    }
    if (sta->he_cap.he_cap_elem.mac_cap_info[3] & IEEE80211_HE_MAC_CAP3_OMI_CONTROL) {
        sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_OMI_SUPP);
    }
    if (sta->he_cap.he_cap_elem.mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR) {
        sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BQR_SUPP);
    }

    /*
     * Initialize the PPE thresholds to "None" (7), as described in Table
     * 9-262ac of 80211.ax/D3.0.
     */
    memset(&sta_ctxt_cmd.pkt_ext, 7, sizeof(sta_ctxt_cmd.pkt_ext));

    /* If PPE Thresholds exist, parse them into a FW-familiar format. */
    if (sta->he_cap.he_cap_elem.phy_cap_info[6] & IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
        uint8_t nss = (sta->he_cap.ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) + 1;
        uint8_t ru_index_bitmap =
            (sta->he_cap.ppe_thres[0] & IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
            IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
        uint8_t* ppe = &sta->he_cap.ppe_thres[0];
        uint8_t ppe_pos_bit = 7; /* Starting after PPE header */

        /*
         * FW currently supports only nss == MAX_HE_SUPP_NSS
         *
         * If nss > MAX: we can ignore values we don't support
         * If nss < MAX: we can set zeros in other streams
         */
        if (nss > MAX_HE_SUPP_NSS) {
            IWL_INFO(mvm, "Got NSS = %d - trimming to %d\n", nss, MAX_HE_SUPP_NSS);
            nss = MAX_HE_SUPP_NSS;
        }

        for (i = 0; i < nss; i++) {
            uint8_t ru_index_tmp = ru_index_bitmap << 1;
            uint8_t bw;

            for (bw = 0; bw < MAX_HE_CHANNEL_BW_INDX; bw++) {
                ru_index_tmp >>= 1;
                if (!(ru_index_tmp & 1)) { continue; }

                sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw][1] =
                    iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
                ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
                sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw][0] =
                    iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
                ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
            }
        }

        flags |= STA_CTXT_HE_PACKET_EXT;
    }
    rcu_read_unlock();

    /* Mark MU EDCA as enabled, unless none detected on some AC */
    flags |= STA_CTXT_HE_MU_EDCA_CW;
    for (i = 0; i < IEEE80211_AC_MAX; i++) {
        struct ieee80211_he_mu_edca_param_ac_rec* mu_edca =
            &mvmvif->queue_params[i].mu_edca_param_rec;
        uint8_t ac = mac80211_ac_to_ucode_ac[i];

        if (!mvmvif->queue_params[i].mu_edca) {
            flags &= ~STA_CTXT_HE_MU_EDCA_CW;
            break;
        }

        sta_ctxt_cmd.trig_based_txf[ac].cwmin = cpu_to_le16(mu_edca->ecw_min_max & 0xf);
        sta_ctxt_cmd.trig_based_txf[ac].cwmax = cpu_to_le16((mu_edca->ecw_min_max & 0xf0) >> 4);
        sta_ctxt_cmd.trig_based_txf[ac].aifsn = cpu_to_le16(mu_edca->aifsn & 0xf);
        sta_ctxt_cmd.trig_based_txf[ac].mu_time = cpu_to_le16(mu_edca->mu_edca_timer);
    }

    if (vif->bss_conf.multi_sta_back_32bit) { flags |= STA_CTXT_HE_32BIT_BA_BITMAP; }

    if (vif->bss_conf.ack_enabled) { flags |= STA_CTXT_HE_ACK_ENABLED; }

    if (vif->bss_conf.uora_exists) {
        flags |= STA_CTXT_HE_TRIG_RND_ALLOC;

        sta_ctxt_cmd.rand_alloc_ecwmin = vif->bss_conf.uora_ocw_range & 0x7;
        sta_ctxt_cmd.rand_alloc_ecwmax = (vif->bss_conf.uora_ocw_range >> 3) & 0x7;
    }

    if (!(sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_ACK_EN)) {
        flags |= STA_CTXT_HE_NIC_NOT_ACK_ENABLED;
    }

#ifdef CPTCFG_IWLWIFI_SUPPORT_DEBUG_OVERRIDES
    if (mvm->trans->dbg_cfg.no_ack_en & 0x2) { flags &= ~STA_CTXT_HE_ACK_ENABLED; }
#endif

    /* TODO: support Multi BSSID IE */

    sta_ctxt_cmd.flags = cpu_to_le32(flags);

    if (iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(STA_HE_CTXT_CMD, DATA_PATH_GROUP, 0), 0,
                             sizeof(sta_ctxt_cmd), &sta_ctxt_cmd)) {
        IWL_ERR(mvm, "Failed to config FW to work HE!\n");
    }
}

static void iwl_mvm_bss_info_changed_station(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                             struct ieee80211_bss_conf* bss_conf,
                                             uint32_t changes) {
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    int ret;

    /*
     * Re-calculate the tsf id, as the master-slave relations depend on the
     * beacon interval, which was not known when the station interface was
     * added.
     */
    if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc) {
        if (vif->bss_conf.he_support && !iwlwifi_mod_params.disable_11ax) {
            iwl_mvm_cfg_he_sta(mvm, vif, mvmvif->ap_sta_id);
        }

        iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
    }

    /*
     * If we're not associated yet, take the (new) BSSID before associating
     * so the firmware knows. If we're already associated, then use the old
     * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
     * branch for disassociation below.
     */
    if (changes & BSS_CHANGED_BSSID && !mvmvif->associated) {
        memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
    }

    ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
    if (ret) { IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); }

    /* after sending it once, adopt mac80211 data */
    memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
    mvmvif->associated = bss_conf->assoc;

    if (changes & BSS_CHANGED_ASSOC) {
        if (bss_conf->assoc) {
            /* clear statistics to get clean beacon counter */
            iwl_mvm_request_statistics(mvm, true);
            memset(&mvmvif->beacon_stats, 0, sizeof(mvmvif->beacon_stats));

            /* add quota for this interface */
            ret = iwl_mvm_update_quotas(mvm, true, NULL);
            if (ret) {
                IWL_ERR(mvm, "failed to update quotas\n");
                return;
            }

            if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
                /*
                 * If we're restarting then the firmware will
                 * obviously have lost synchronisation with
                 * the AP. It will attempt to synchronise by
                 * itself, but we can make it more reliable by
                 * scheduling a session protection time event.
                 *
                 * The firmware needs to receive a beacon to
                 * catch up with synchronisation, use 110% of
                 * the beacon interval.
                 *
                 * Set a large maximum delay to allow for more
                 * than a single interface.
                 */
                uint32_t dur = (11 * vif->bss_conf.beacon_int) / 10;
                iwl_mvm_protect_session(mvm, vif, dur, dur, 5 * dur, false);
            }

            iwl_mvm_sf_update(mvm, vif, false);
            iwl_mvm_power_vif_assoc(mvm, vif);
            if (vif->p2p) {
                iwl_mvm_ref(mvm, IWL_MVM_REF_P2P_CLIENT);
                iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_PROT, IEEE80211_SMPS_DYNAMIC);
            }
        } else if (mvmvif->ap_sta_id != IWL_MVM_INVALID_STA) {
            /*
             * If update fails - SF might be running in associated
             * mode while disassociated - which is forbidden.
             */
            WARN_ONCE(iwl_mvm_sf_update(mvm, vif, false),
                      "Failed to update SF upon disassociation\n");

            /*
             * If we get an assert during the connection (after the
             * station has been added, but before the vif is set
             * to associated), mac80211 will re-add the station and
             * then configure the vif. Since the vif is not
             * associated, we would remove the station here and
             * this would fail the recovery.
             */
            if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
                /*
                 * Remove AP station now that
                 * the MAC is unassoc
                 */
                ret = iwl_mvm_rm_sta_id(mvm, vif, mvmvif->ap_sta_id);
                if (ret) { IWL_ERR(mvm, "failed to remove AP station\n"); }

                if (mvm->d0i3_ap_sta_id == mvmvif->ap_sta_id) {
                    mvm->d0i3_ap_sta_id = IWL_MVM_INVALID_STA;
                }
                mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
            }

            /* remove quota for this interface */
            ret = iwl_mvm_update_quotas(mvm, false, NULL);
            if (ret) { IWL_ERR(mvm, "failed to update quotas\n"); }

            if (vif->p2p) { iwl_mvm_unref(mvm, IWL_MVM_REF_P2P_CLIENT); }

            /* this will take the cleared BSSID from bss_conf */
            ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
            if (ret) {
                IWL_ERR(mvm, "failed to update MAC %pM (clear after unassoc)\n", vif->addr);
            }
        }

        /*
         * The firmware tracks the MU-MIMO group on its own.
         * However, on HW restart we should restore this data.
         */
        if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
            (changes & BSS_CHANGED_MU_GROUPS) && vif->mu_mimo_owner) {
            ret = iwl_mvm_update_mu_groups(mvm, vif);
            if (ret) { IWL_ERR(mvm, "failed to update VHT MU_MIMO groups\n"); }
        }

        iwl_mvm_recalc_multicast(mvm);
        iwl_mvm_configure_bcast_filter(mvm);

        /* reset rssi values */
        mvmvif->bf_data.ave_beacon_signal = 0;

        iwl_mvm_bt_coex_vif_change(mvm);
        iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT, IEEE80211_SMPS_AUTOMATIC);
        if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
            iwl_mvm_config_scan(mvm);
        }
    }

    if (changes & BSS_CHANGED_BEACON_INFO) {
        /*
         * We received a beacon from the associated AP so
         * remove the session protection.
         */
        iwl_mvm_stop_session_protection(mvm, vif);

        iwl_mvm_sf_update(mvm, vif, false);
        WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
    }

    if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS |
                   /*
                    * Send power command on every beacon change,
                    * because we may have not enabled beacon abort yet.
                    */
                   BSS_CHANGED_BEACON_INFO)) {
        ret = iwl_mvm_power_update_mac(mvm);
        if (ret) { IWL_ERR(mvm, "failed to update power mode\n"); }
    }

    if (changes & BSS_CHANGED_TXPOWER) {
        IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n", bss_conf->txpower);
        iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
    }

    if (changes & BSS_CHANGED_CQM) {
        IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
        /* reset cqm events tracking */
        mvmvif->bf_data.last_cqm_event = 0;
        if (mvmvif->bf_data.bf_enabled) {
            ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
            if (ret) { IWL_ERR(mvm, "failed to update CQM thresholds\n"); }
        }
    }

    if (changes & BSS_CHANGED_ARP_FILTER) {
        IWL_DEBUG_MAC80211(mvm, "arp filter changed\n");
        iwl_mvm_configure_bcast_filter(mvm);
    }
}

static int iwl_mvm_start_ap_ibss(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    int ret;

    /*
     * iwl_mvm_mac_ctxt_add() might read directly from the device
     * (the system time), so make sure it is available.
     */
    ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_START_AP);
    if (ret) { return ret; }

    mutex_lock(&mvm->mutex);

    /* Send the beacon template */
    ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
    if (ret) { goto out_unlock; }

    /*
     * Re-calculate the tsf id, as the master-slave relations depend on the
     * beacon interval, which was not known when the AP interface was added.
     */
    if (vif->type == NL80211_IFTYPE_AP) { iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif); }

    mvmvif->ap_assoc_sta_count = 0;

    /* Add the mac context */
    ret = iwl_mvm_mac_ctxt_add(mvm, vif);
    if (ret) { goto out_unlock; }

    /* Perform the binding */
    ret = iwl_mvm_binding_add_vif(mvm, vif);
    if (ret) { goto out_remove; }

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
    iwl_mvm_update_ctx_tx_power_limit(mvm, vif, mvmvif->phy_ctxt);
#endif

    /*
     * This is not very nice, but the simplest:
     * For older FWs adding the mcast sta before the bcast station may
     * cause assert 0x2b00.
     * This is fixed in later FW so make the order of removal depend on
     * the TLV
     */
    if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
        ret = iwl_mvm_add_mcast_sta(mvm, vif);
        if (ret) { goto out_unbind; }
        /*
         * Send the bcast station. At this stage the TBTT and DTIM time
         * events are added and applied to the scheduler
         */
        ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
        if (ret) {
            iwl_mvm_rm_mcast_sta(mvm, vif);
            goto out_unbind;
        }
    } else {
        /*
         * Send the bcast station. At this stage the TBTT and DTIM time
         * events are added and applied to the scheduler
         */
        ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
        if (ret) { goto out_unbind; }
        ret = iwl_mvm_add_mcast_sta(mvm, vif);
        if (ret) {
            iwl_mvm_send_rm_bcast_sta(mvm, vif);
            goto out_unbind;
        }
    }

    /* must be set before quota calculations */
    mvmvif->ap_ibss_active = true;

    if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
        iwl_mvm_vif_set_low_latency(mvmvif, true, LOW_LATENCY_VIF_TYPE);
        iwl_mvm_send_low_latency_cmd(mvm, true, mvmvif->id);
    }

    /* power updated needs to be done before quotas */
    iwl_mvm_power_update_mac(mvm);

    ret = iwl_mvm_update_quotas(mvm, false, NULL);
    if (ret) { goto out_quota_failed; }

    /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
    if (vif->p2p && mvm->p2p_device_vif) {
        iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
    }

    iwl_mvm_ref(mvm, IWL_MVM_REF_AP_IBSS);

    iwl_mvm_bt_coex_vif_change(mvm);

    /* we don't support TDLS during DCM */
    if (iwl_mvm_phy_ctx_count(mvm) > 1) { iwl_mvm_teardown_tdls_peers(mvm); }

    goto out_unlock;

out_quota_failed:
    iwl_mvm_power_update_mac(mvm);
    mvmvif->ap_ibss_active = false;
    iwl_mvm_send_rm_bcast_sta(mvm, vif);
    iwl_mvm_rm_mcast_sta(mvm, vif);
out_unbind:
    iwl_mvm_binding_remove_vif(mvm, vif);
out_remove:
    iwl_mvm_mac_ctxt_remove(mvm, vif);
out_unlock:
    mutex_unlock(&mvm->mutex);
    iwl_mvm_unref(mvm, IWL_MVM_REF_START_AP);
    return ret;
}

static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    iwl_mvm_prepare_mac_removal(mvm, vif);

    mutex_lock(&mvm->mutex);

    /* Handle AP stop while in CSA */
    if (rcu_access_pointer(mvm->csa_vif) == vif) {
        iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
        RCU_INIT_POINTER(mvm->csa_vif, NULL);
        mvmvif->csa_countdown = false;
    }

    if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
        RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
        mvm->csa_tx_block_bcn_timeout = 0;
    }

    mvmvif->ap_ibss_active = false;
    mvm->ap_last_beacon_gp2 = 0;

    if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
        iwl_mvm_vif_set_low_latency(mvmvif, false, LOW_LATENCY_VIF_TYPE);
        iwl_mvm_send_low_latency_cmd(mvm, false, mvmvif->id);
    }

    iwl_mvm_bt_coex_vif_change(mvm);

    iwl_mvm_unref(mvm, IWL_MVM_REF_AP_IBSS);

    /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
    if (vif->p2p && mvm->p2p_device_vif) {
        iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
    }

    iwl_mvm_update_quotas(mvm, false, NULL);

    /*
     * This is not very nice, but the simplest:
     * For older FWs removing the mcast sta before the bcast station may
     * cause assert 0x2b00.
     * This is fixed in later FW (which will stop beaconing when removing
     * bcast station).
     * So make the order of removal depend on the TLV
     */
    if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
        iwl_mvm_rm_mcast_sta(mvm, vif);
    }
    iwl_mvm_send_rm_bcast_sta(mvm, vif);
    if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
        iwl_mvm_rm_mcast_sta(mvm, vif);
    }
    iwl_mvm_binding_remove_vif(mvm, vif);

    iwl_mvm_power_update_mac(mvm);

    iwl_mvm_mac_ctxt_remove(mvm, vif);

    kfree(mvmvif->ap_wep_key);
    mvmvif->ap_wep_key = NULL;

    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                             struct ieee80211_bss_conf* bss_conf,
                                             uint32_t changes) {
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    /* Changes will be applied when the AP/IBSS is started */
    if (!mvmvif->ap_ibss_active) { return; }

    if (changes &
            (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT | BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
        iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL)) {
        IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
    }

    /* Need to send a new beacon template to the FW */
    if (changes & BSS_CHANGED_BEACON && iwl_mvm_mac_ctxt_beacon_changed(mvm, vif)) {
        IWL_WARN(mvm, "Failed updating beacon data\n");
    }

    if (changes & BSS_CHANGED_TXPOWER) {
        IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n", bss_conf->txpower);
        iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
    }
}

static void iwl_mvm_bss_info_changed(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                     struct ieee80211_bss_conf* bss_conf, uint32_t changes) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    /*
     * iwl_mvm_bss_info_changed_station() might call
     * iwl_mvm_protect_session(), which reads directly from
     * the device (the system time), so make sure it is available.
     */
    if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_BSS_CHANGED)) { return; }

    mutex_lock(&mvm->mutex);

    if (changes & BSS_CHANGED_IDLE && !bss_conf->idle) {
        iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
    }

    switch (vif->type) {
    case NL80211_IFTYPE_STATION:
        iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
        break;
    case NL80211_IFTYPE_AP:
    case NL80211_IFTYPE_ADHOC:
        iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
        break;
    case NL80211_IFTYPE_MONITOR:
        if (changes & BSS_CHANGED_MU_GROUPS) { iwl_mvm_update_mu_groups(mvm, vif); }
        break;
    default:
        /* shouldn't happen */
        WARN_ON_ONCE(1);
    }

    mutex_unlock(&mvm->mutex);
    iwl_mvm_unref(mvm, IWL_MVM_REF_BSS_CHANGED);
}
#endif  // NEEDS_PORTING

// Modified from original iwl_mvm_mac_hw_scan() to split call path for active and passive.
zx_status_t iwl_mvm_mac_hw_scan_passive(struct iwl_mvm_vif* mvmvif,
                                        const wlan_softmac_passive_scan_args_t* passive_scan_args,
                                        uint64_t* out_scan_id) {
  struct iwl_mvm* mvm = mvmvif->mvm;
  zx_status_t ret;

  if (passive_scan_args->channels_count == 0 ||
      passive_scan_args->channels_count > mvm->fw->ucode_capa.n_scan_channels) {
    IWL_WARN(mvmvif, "Cannot scan: invalid #channel (%zu). FW's cap (%d)\n",
             passive_scan_args->channels_count, mvm->fw->ucode_capa.n_scan_channels);
    return ZX_ERR_INVALID_ARGS;
  }

  mtx_lock(&mvm->mutex);
  ret = iwl_mvm_reg_scan_start_passive(mvmvif, passive_scan_args);
  mtx_unlock(&mvm->mutex);

  if (ret != ZX_OK) {
    return ret;
  }

  // TODO(fxbug.dev/88934): scan_id is always 0
  *out_scan_id = 0;
  return ret;
}

#if 0   // NEEDS_PORTING
static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    mutex_lock(&mvm->mutex);

    /* Due to a race condition, it's possible that mac80211 asks
     * us to stop a hw_scan when it's already stopped.  This can
     * happen, for instance, if we stopped the scan ourselves,
     * called ieee80211_scan_completed() and the userspace called
     * cancel scan scan before ieee80211_scan_work() could run.
     * To handle that, simply return if the scan is not running.
     */
    if (mvm->scan_status & IWL_MVM_SCAN_REGULAR) {
        iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
    }

    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw* hw, struct ieee80211_sta* sta,
                                              uint16_t tids, int num_frames,
                                              enum ieee80211_frame_release_type reason,
                                              bool more_data) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    /* Called when we need to transmit (a) frame(s) from mac80211 */

    iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames, tids, more_data, false);
}

static void iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw* hw, struct ieee80211_sta* sta,
                                                uint16_t tids, int num_frames,
                                                enum ieee80211_frame_release_type reason,
                                                bool more_data) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    /* Called when we need to transmit (a) frame(s) from agg or dqa queue */

    iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames, tids, more_data, true);
}

static void __iwl_mvm_mac_sta_notify(struct ieee80211_hw* hw, enum sta_notify_cmd cmd,
                                     struct ieee80211_sta* sta) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_sta* mvmsta = iwl_mvm_sta_from_mac80211(sta);
    unsigned long txqs = 0, tids = 0;
    int tid;

    /*
     * If we have TVQM then we get too high queue numbers - luckily
     * we really shouldn't get here with that because such hardware
     * should have firmware supporting buffer station offload.
     */
    if (WARN_ON(iwl_mvm_has_new_tx_api(mvm))) { return; }

    spin_lock_bh(&mvmsta->lock);
    for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
        struct iwl_mvm_tid_data* tid_data = &mvmsta->tid_data[tid];

        if (tid_data->txq_id == IWL_MVM_INVALID_QUEUE) { continue; }

        __set_bit(tid_data->txq_id, &txqs);

        if (iwl_mvm_tid_queued(mvm, tid_data) == 0) { continue; }

        __set_bit(tid, &tids);
    }

    switch (cmd) {
    case STA_NOTIFY_SLEEP:
        for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT) ieee80211_sta_set_buffered(sta, tid, true);

        if (txqs) { iwl_trans_freeze_txq_timer(mvm->trans, txqs, true); }
        /*
         * The fw updates the STA to be asleep. Tx packets on the Tx
         * queues to this station will not be transmitted. The fw will
         * send a Tx response with TX_STATUS_FAIL_DEST_PS.
         */
        break;
    case STA_NOTIFY_AWAKE:
        if (WARN_ON(mvmsta->sta_id == IWL_MVM_INVALID_STA)) { break; }

        if (txqs) { iwl_trans_freeze_txq_timer(mvm->trans, txqs, false); }
        iwl_mvm_sta_modify_ps_wake(mvm, sta);
        break;
    default:
        break;
    }
    spin_unlock_bh(&mvmsta->lock);
}

static void iwl_mvm_mac_sta_notify(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                   enum sta_notify_cmd cmd, struct ieee80211_sta* sta) {
    __iwl_mvm_mac_sta_notify(hw, cmd, sta);
}

void iwl_mvm_sta_pm_notif(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) {
    struct iwl_rx_packet* pkt = rxb_addr(rxb);
    struct iwl_mvm_pm_state_notification* notif = (void*)pkt->data;
    struct ieee80211_sta* sta;
    struct iwl_mvm_sta* mvmsta;
    bool sleeping = (notif->type != IWL_MVM_PM_EVENT_AWAKE);

    if (WARN_ON(notif->sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id))) { return; }

    rcu_read_lock();
    sta = rcu_dereference(mvm->fw_id_to_mac_id[notif->sta_id]);
    if (WARN_ON(IS_ERR_OR_NULL(sta))) {
        rcu_read_unlock();
        return;
    }

    mvmsta = iwl_mvm_sta_from_mac80211(sta);

    if (!mvmsta->vif || mvmsta->vif->type != NL80211_IFTYPE_AP) {
        rcu_read_unlock();
        return;
    }

    if (mvmsta->sleeping != sleeping) {
        mvmsta->sleeping = sleeping;
        __iwl_mvm_mac_sta_notify(mvm->hw, sleeping ? STA_NOTIFY_SLEEP : STA_NOTIFY_AWAKE, sta);
        ieee80211_sta_ps_transition(sta, sleeping);
    }

    if (sleeping) {
        switch (notif->type) {
        case IWL_MVM_PM_EVENT_AWAKE:
        case IWL_MVM_PM_EVENT_ASLEEP:
            break;
        case IWL_MVM_PM_EVENT_UAPSD:
            ieee80211_sta_uapsd_trigger(sta, fuchsia_wlan_ieee80211_TIDS_MAX);
            break;
        case IWL_MVM_PM_EVENT_PS_POLL:
            ieee80211_sta_pspoll(sta);
            break;
        default:
            break;
        }
    }

    rcu_read_unlock();
}

static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                       struct ieee80211_sta* sta) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_sta* mvm_sta = iwl_mvm_sta_from_mac80211(sta);

    /*
     * This is called before mac80211 does RCU synchronisation,
     * so here we already invalidate our internal RCU-protected
     * station pointer. The rest of the code will thus no longer
     * be able to find the station this way, and we don't rely
     * on further RCU synchronisation after the sta_state()
     * callback deleted the station.
     */
    mutex_lock(&mvm->mutex);
    if (sta == rcu_access_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id])) {
        rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id], ERR_PTR(-ENOENT));
    }

    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_check_uapsd(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                const uint8_t* bssid) {
    int i;

    if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
        struct iwl_mvm_tcm_mac* mdata;

        mdata = &mvm->tcm.data[iwl_mvm_vif_from_mac80211(vif)->id];
        ewma_rate_init(&mdata->uapsd_nonagg_detect.rate);
        mdata->opened_rx_ba_sessions = false;
    }

    if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT)) { return; }

    if (vif->p2p && !iwl_mvm_is_p2p_scm_uapsd_supported(mvm)) {
        vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
        return;
    }

    if (!vif->p2p && (iwlwifi_mod_params.uapsd_disable & IWL_DISABLE_UAPSD_BSS)) {
        vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
        return;
    }

    for (i = 0; i < IWL_MVM_UAPSD_NOAGG_LIST_LEN; i++) {
        if (ether_addr_equal(mvm->uapsd_noagg_bssids[i].addr, bssid)) {
            vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
            return;
        }
    }

    vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
}

static void iwl_mvm_tdls_check_trigger(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                       uint8_t* peer_addr, enum nl80211_tdls_operation action) {
    struct iwl_fw_dbg_trigger_tlv* trig;
    struct iwl_fw_dbg_trigger_tdls* tdls_trig;

    trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), FW_DBG_TRIGGER_TDLS);
    if (!trig) { return; }

    tdls_trig = (void*)trig->data;

    if (!(tdls_trig->action_bitmap & BIT(action))) { return; }

    if (tdls_trig->peer_mode && memcmp(tdls_trig->peer, peer_addr, ETH_ALEN) != 0) { return; }

    iwl_fw_dbg_collect_trig(&mvm->fwrt, trig, "TDLS event occurred, peer %pM, action %d", peer_addr,
                            action);
}
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_mac_sta_state(struct iwl_mvm_vif* mvmvif, struct iwl_mvm_sta* mvm_sta,
                                  enum iwl_sta_state old_state, enum iwl_sta_state new_state) {
  struct iwl_mvm* mvm = mvmvif->mvm;
  zx_status_t ret;

  IWL_DEBUG_MAC80211(mvm, "station state change %d->%d\n", old_state, new_state);

  /* this would be a mac80211 bug ... but don't crash */
  if (!mvmvif->phy_ctxt) {
    return ZX_ERR_BAD_STATE;
  }

#if 0   // NEEDS_PORTING
    /*
     * If we are in a STA removal flow and in DQA mode:
     *
     * This is after the sync_rcu part, so the queues have already been
     * flushed. No more TXs on their way in mac80211's path, and no more in
     * the queues.
     * Also, we won't be getting any new TX frames for this station.
     * What we might have are deferred TX frames that need to be taken care
     * of.
     *
     * Drop any still-queued deferred-frame before removing the STA, and
     * make sure the worker is no longer handling frames for this STA.
     */
    if (old_state == IEEE80211_STA_NONE && new_state == IEEE80211_STA_NOTEXIST) {
        flush_work(&mvm->add_stream_wk);

        /*
         * No need to make sure deferred TX indication is off since the
         * worker will already remove it if it was on
         */
    }
#endif  // NEEDS_PORTING

  mtx_lock(&mvm->mutex);
  /* track whether or not the station is associated */
  mvm_sta->sta_state = new_state;

  if (old_state == IWL_STA_NOTEXIST && new_state == IWL_STA_NONE) {
    /*
     * Firmware bug - it'll crash if the beacon interval is less
     * than 16. We can't avoid connecting at all, so refuse the
     * station state change, this will cause mac80211 to abandon
     * attempts to connect to this AP, and eventually wpa_s will
     * blacklist the AP...
     */
    if (mvmvif->mac_role == WLAN_MAC_ROLE_CLIENT && mvmvif->bss_conf.beacon_int < 16) {
      IWL_ERR(mvm, "AP %pM beacon interval is %d, refusing due to firmware bug!\n", mvm_sta->addr,
              mvmvif->bss_conf.beacon_int);
      ret = ZX_ERR_INVALID_ARGS;
      goto out_unlock;
    }

#if 0   // NEEDS_PORTING
        if (sta->tdls && (vif->p2p || iwl_mvm_tdls_sta_count(mvm, NULL) == IWL_MVM_TDLS_STA_COUNT ||
                          iwl_mvm_phy_ctx_count(mvm) > 1)) {
            IWL_DEBUG_MAC80211(mvm, "refusing TDLS sta\n");
            ret = -EBUSY;
            goto out_unlock;
        }
#endif  // NEEDS_PORTING

    ret = iwl_mvm_add_sta(mvmvif, mvm_sta);
#if 0   // NEEDS_PORTING
        if (sta->tdls && ret == 0) {
            iwl_mvm_recalc_tdls_state(mvm, vif, true);
            iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr, NL80211_TDLS_SETUP);
        }

        sta->max_rc_amsdu_len = 1;
#endif  // NEEDS_PORTING
  } else if (old_state == IWL_STA_NONE && new_state == IWL_STA_AUTH) {
#if 0   // NEEDS_PORTING
        /*
         * EBS may be disabled due to previous failures reported by FW.
         * Reset EBS status here assuming environment has been changed.
         */
        mvm->last_ebs_successful = true;
        iwl_mvm_check_uapsd(mvm, vif, sta->addr);
#endif  // NEEDS_PORTING

    ret = ZX_OK;

  } else if (old_state == IWL_STA_AUTH && new_state == IWL_STA_ASSOC) {
#if 0  // NEEDS_PORTING
       // TODO(36677): Supports AP role
        if (mvmvif->mac_role == WLAN_MAC_ROLE_AP) {
            mvmvif->ap_assoc_sta_count++;
            iwl_mvm_mac_ctxt_changed(mvmvif, false, NULL);
            if (vif->bss_conf.he_support && !iwlwifi_mod_params.disable_11ax) {
                iwl_mvm_cfg_he_sta(mvmvif, mvm_sta->sta_id);
            }
        }

#endif  // NEEDS_PORTING
    iwl_mvm_rs_rate_init(mvm, mvm_sta, false);

    ret = iwl_mvm_update_sta(mvm, mvm_sta);

  } else if (old_state == IWL_STA_ASSOC && new_state == IWL_STA_AUTHORIZED) {
#if 0   // NEEDS_PORTING
        /* we don't support TDLS during DCM */
        if (iwl_mvm_phy_ctx_count(mvm) > 1) { iwl_mvm_teardown_tdls_peers(mvm); }

        if (sta->tdls) {
            iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr, NL80211_TDLS_ENABLE_LINK);
        }
#endif  // NEEDS_PORTING

    /* enable beacon filtering */
    if (ZX_OK != iwl_mvm_enable_beacon_filter(mvmvif, 0)) {
      IWL_WARN(mvm, "cannot enable beacon filter\n");
    }
    ret = ZX_OK;

#if 0   // NEEDS_PORTING
        iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band, true);

        // TODO(36677): Supports AP role
        /* if wep is used, need to set the key for the station now */
        if (mvmvif->mac_role == WLAN_MAC_ROLE_AP && mvmvif->ap_wep_key) {
            ret = iwl_mvm_set_sta_key(mvm, vif, sta, mvmvif->ap_wep_key, STA_KEY_IDX_INVALID);
        } else {
            ret = ZX_OK;
        }
#endif  // NEEDS_PORTING
  } else if (old_state == IWL_STA_AUTHORIZED && new_state == IWL_STA_ASSOC) {
    /* disable beacon filtering */
    if (ZX_OK != iwl_mvm_disable_beacon_filter(mvmvif, 0)) {
      IWL_WARN(mvm, "cannot enable beacon filter\n");
    }
    ret = ZX_OK;
  } else if (old_state == IWL_STA_ASSOC && new_state == IWL_STA_AUTH) {
#if 0   // NEEDS_PORTING
        // TODO(36677): Supports AP role
        if (mvmvif->mac_role == WLAN_MAC_ROLE_AP) {
            mvmvif->ap_assoc_sta_count--;
            iwl_mvm_mac_ctxt_changed(mvmvif, false, NULL);
        }
#endif  // NEEDS_PORTING
    ret = ZX_OK;
  } else if (old_state == IWL_STA_AUTH && new_state == IWL_STA_NONE) {
    ret = ZX_OK;
  } else if (old_state == IWL_STA_NONE && new_state == IWL_STA_NOTEXIST) {
    ret = iwl_mvm_rm_sta(mvmvif, mvm_sta);
#if 0   // NEEDS_PORTING
        if (sta->tdls) {
            iwl_mvm_recalc_tdls_state(mvm, vif, false);
            iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr, NL80211_TDLS_DISABLE_LINK);
        }
#endif  // NEEDS_PORTING
  } else {
    IWL_ERR(mvmvif, "set_state(): state transition is invalid (%d -> %d).\n", old_state, new_state);
    ret = ZX_ERR_IO;
  }
out_unlock:
  mtx_unlock(&mvm->mutex);

#if 0   // NEEDS_PORTING
    if (sta->tdls && ret == 0) {
        if (old_state == IWL_STA_NOTEXIST && new_state == IWL_STA_NONE) {
            ieee80211_reserve_tid(sta, IWL_MVM_TDLS_FW_TID);
        } else if (old_state == IWL_STA_NONE && new_state == IWL_STA_NOTEXIST) {
            ieee80211_unreserve_tid(sta, IWL_MVM_TDLS_FW_TID);
        }
    }
#endif  // NEEDS_PORTING

  return ret;
}

#if 0   // NEEDS_PORTING
static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw* hw, uint32_t value) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    mvm->rts_threshold = value;

    return 0;
}

static void iwl_mvm_sta_rc_update(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                  struct ieee80211_sta* sta, uint32_t changed) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    if (vif->type == NL80211_IFTYPE_STATION && changed & IEEE80211_RC_NSS_CHANGED) {
        iwl_mvm_sf_update(mvm, vif, false);
    }
}

static int iwl_mvm_mac_conf_tx(struct ieee80211_hw* hw, struct ieee80211_vif* vif, uint16_t ac,
                               const struct ieee80211_tx_queue_params* params) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    mvmvif->queue_params[ac] = *params;

    /*
     * No need to update right away, we'll get BSS_CHANGED_QOS
     * The exception is P2P_DEVICE interface which needs immediate update.
     */
    if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
        int ret;

        mutex_lock(&mvm->mutex);
        ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
        mutex_unlock(&mvm->mutex);
        return ret;
    }
    return 0;
}
#endif  // NEEDS_PORTING

// Prepare for transmitting a management frame for association before associated.
//
// This function is used to tell firmware to sync the channel time.
//
void iwl_mvm_mac_mgd_prepare_tx(struct iwl_mvm* mvm, struct iwl_mvm_vif* mvmvif,
                                uint16_t req_duration) {
  uint32_t duration = IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS;
  uint32_t min_duration = IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS;

  /*
   * iwl_mvm_protect_session() reads directly from the device
   * (the system time), so make sure it is available.
   */
  if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PREPARE_TX)) {
    return;
  }

  if (req_duration > duration) {
    duration = req_duration;
  }

  mtx_lock(&mvm->mutex);
  /* Try really hard to protect the session and hear a beacon */
  iwl_mvm_protect_session(mvm, mvmvif, duration, min_duration, 500, false);
  mtx_unlock(&mvm->mutex);

  iwl_mvm_unref(mvm, IWL_MVM_REF_PREPARE_TX);
}

#if 0   // NEEDS_PORTING
static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                        struct cfg80211_sched_scan_request* req,
                                        struct ieee80211_scan_ies* ies) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    int ret;

    mutex_lock(&mvm->mutex);

    if (!vif->bss_conf.idle) {
        ret = -EBUSY;
        goto out;
    }

    ret = iwl_mvm_sched_scan_start(mvm, vif, req, ies, IWL_MVM_SCAN_SCHED);

out:
    mutex_unlock(&mvm->mutex);
    return ret;
}

static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int ret;

    mutex_lock(&mvm->mutex);

    /* Due to a race condition, it's possible that mac80211 asks
     * us to stop a sched_scan when it's already stopped.  This
     * can happen, for instance, if we stopped the scan ourselves,
     * called ieee80211_sched_scan_stopped() and the userspace called
     * stop sched scan scan before ieee80211_sched_scan_stopped_work()
     * could run.  To handle this, simply return if the scan is
     * not running.
     */
    if (!(mvm->scan_status & IWL_MVM_SCAN_SCHED)) {
        mutex_unlock(&mvm->mutex);
        return 0;
    }

    ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, false);
    mutex_unlock(&mvm->mutex);
    iwl_mvm_wait_for_async_handlers(mvm);

    return ret;
}

static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
			       enum set_key_cmd cmd,
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
{
	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
	struct iwl_mvm_sta *mvmsta;
	struct iwl_mvm_key_pn *ptk_pn;
	int keyidx = key->keyidx;
	int ret;
	u8 key_offset;

	if (iwlwifi_mod_params.swcrypto) {
		IWL_DEBUG_MAC80211(mvm, "leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

	switch (key->cipher) {
	case WLAN_CIPHER_SUITE_TKIP:
		if (!mvm->trans->cfg->gen2) {
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
			key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
		} else if (vif->type == NL80211_IFTYPE_STATION) {
			key->flags |= IEEE80211_KEY_FLAG_PUT_MIC_SPACE;
		} else {
			IWL_DEBUG_MAC80211(mvm, "Use SW encryption for TKIP\n");
			return -EOPNOTSUPP;
		}
		break;
	case WLAN_CIPHER_SUITE_CCMP:
	case WLAN_CIPHER_SUITE_GCMP:
	case WLAN_CIPHER_SUITE_GCMP_256:
		if (!iwl_mvm_has_new_tx_api(mvm))
			key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
		break;
	case WLAN_CIPHER_SUITE_AES_CMAC:
	case WLAN_CIPHER_SUITE_BIP_GMAC_128:
	case WLAN_CIPHER_SUITE_BIP_GMAC_256:
		WARN_ON_ONCE(!ieee80211_hw_check(hw, MFP_CAPABLE));
		break;
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
		if (vif->type == NL80211_IFTYPE_AP) {
			struct iwl_mvm_vif *mvmvif =
				iwl_mvm_vif_from_mac80211(vif);

			mvmvif->ap_wep_key = kmemdup(key,
						     sizeof(*key) + key->keylen,
						     GFP_KERNEL);
			if (!mvmvif->ap_wep_key)
				return -ENOMEM;
		}

		if (vif->type != NL80211_IFTYPE_STATION)
			return 0;
		break;
	default:
		/* currently FW supports only one optional cipher scheme */
		if (hw->n_cipher_schemes &&
		    hw->cipher_schemes->cipher == key->cipher)
			key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
		else
			return -EOPNOTSUPP;
	}

	switch (cmd) {
	case SET_KEY:
		ret = iwl_mvm_mac_add_key(vif, sta, key);
	case DISABLE_KEY:
		ret = iwl_mvm_mac_remove_key(vif, sta, key);
	default:
		ret = -EINVAL;
	}

	return ret;
}
#endif  // NEEDS_PORTING

zx_status_t iwl_mvm_mac_add_key(struct iwl_mvm_vif* mvmvif, struct iwl_mvm_sta* mvmsta,
                                struct ieee80211_key_conf* key) {
  zx_status_t ret = ZX_OK;
  struct iwl_mvm* mvm = mvmvif->mvm;
  struct iwl_mvm_key_pn* ptk_pn = NULL;
  uint8_t key_offset = 0;

  // Fuchsia only supports a limited selection of cipher types for now.
  switch (key->cipher) {
    case CIPHER_SUITE_TYPE_CCMP_128:
      // Note: the Linux iwlwifi driver requests IEEE80211_KEY_FLAG_PUT_IV_SPACE from the mac80211
      // stack.  We will apply equivalent functionality manually to Incoming packets from Fuchsia.
      if (iwl_mvm_has_new_tx_api(mvm)) {
        return ZX_ERR_NOT_SUPPORTED;
      }
      break;
    case CIPHER_SUITE_TYPE_BIP_CMAC_128:
      break;
    default:
      return ZX_ERR_NOT_SUPPORTED;
  }

  mtx_lock(&mvm->mutex);

  if ((mvmvif->mac_role == WLAN_MAC_ROLE_MESH || mvmvif->mac_role == WLAN_MAC_ROLE_AP) && !mvmsta) {
    /*
     * GTK on AP interface is a TX-only key, return 0;
     * on IBSS they're per-station and because we're lazy
     * we don't support them for RX, so do the same.
     * CMAC/GMAC in AP/IBSS modes must be done in software.
     */
    if (key->cipher == CIPHER_SUITE_TYPE_BIP_CMAC_128 ||
        key->cipher == CIPHER_SUITE_TYPE_BIP_GMAC_128 ||
        key->cipher == CIPHER_SUITE_TYPE_BIP_GMAC_256) {
      ret = ZX_ERR_NOT_SUPPORTED;
    } else {
      ret = ZX_OK;
    }

    if (key->cipher != CIPHER_SUITE_TYPE_GCMP_128 && key->cipher != CIPHER_SUITE_TYPE_GCMP_256 &&
        !iwl_mvm_has_new_tx_api(mvm)) {
      key->hw_key_idx = STA_KEY_IDX_INVALID;
      goto out;
    }
  }

  /* During FW restart, in order to restore the state as it was,
   * don't try to reprogram keys we previously failed for.
   */
  if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
      key->hw_key_idx == STA_KEY_IDX_INVALID) {
    IWL_DEBUG_MAC80211(mvm, "skip invalid idx key programming during restart\n");
    ret = ZX_OK;
    goto out;
  }

  if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) && mvmsta &&
      iwl_mvm_has_new_rx_api(mvm) && key->key_type == WLAN_KEY_TYPE_PAIRWISE &&
      (key->cipher == CIPHER_SUITE_TYPE_CCMP_128 || key->cipher == CIPHER_SUITE_TYPE_GCMP_128 ||
       key->cipher == CIPHER_SUITE_TYPE_GCMP_256)) {
    int tid, q;

    ptk_pn = calloc(1, sizeof(*ptk_pn) + sizeof(ptk_pn->q->pn) * mvm->trans->num_rx_queues);
    if (!ptk_pn) {
      ret = ZX_ERR_NO_MEMORY;
      goto out;
    }

    for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
      for (q = 0; q < mvm->trans->num_rx_queues; q++) {
        /* The packet number in packet byte order is little-endian */
        uint64_t pn_le = cpu_to_le64(key->rx_seq);
        memcpy(ptk_pn->q[q].pn[tid], &pn_le, fuchsia_wlan_ieee80211_CCMP_PN_LEN);
      }
    }

    struct iwl_mvm_key_pn* old_ptk_pn = iwl_rcu_exchange(mvmsta->ptk_pn[key->keyidx], ptk_pn);
    if (old_ptk_pn) {
      iwl_rcu_free_sync(mvm->dev, old_ptk_pn);
    }
  }

  /* in HW restart reuse the index, otherwise request a new one */
  if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
    key_offset = 0;
  } else {
    key_offset = STA_KEY_IDX_INVALID;
  }

  IWL_DEBUG_MAC80211(mvm, "set hwcrypto key\n");
  ret = iwl_mvm_set_sta_key(mvm, mvmvif, mvmsta, key, key_offset);
  if (ret != ZX_OK) {
    IWL_ERR(mvm, "set key failed: %s\n", zx_status_get_string(ret));
    /*
     * can't add key for RX, but we don't need it
     * in the device for TX so still return 0
     */
    ret = ZX_OK;
    goto out;
  }

out:
  mtx_unlock(&mvm->mutex);
  return ret;
}

zx_status_t iwl_mvm_mac_remove_key(struct iwl_mvm_vif* mvmvif, struct iwl_mvm_sta* mvmsta,
                                   const struct ieee80211_key_conf* key) {
  zx_status_t ret = ZX_OK;
  struct iwl_mvm* mvm = mvmvif->mvm;
  struct iwl_mvm_key_pn* ptk_pn = NULL;

  mtx_lock(&mvm->mutex);

  if (key->hw_key_idx == STA_KEY_IDX_INVALID) {
    ret = 0;
    goto out;
  }

  if (mvmsta && iwl_mvm_has_new_rx_api(mvm) && key->key_type == WLAN_KEY_TYPE_PAIRWISE &&
      (key->cipher == CIPHER_SUITE_TYPE_CCMP_128 || key->cipher == CIPHER_SUITE_TYPE_GCMP_128 ||
       key->cipher == CIPHER_SUITE_TYPE_GCMP_256)) {
    ptk_pn = iwl_rcu_exchange(mvmsta->ptk_pn[key->keyidx], NULL);
    if (ptk_pn)
      iwl_rcu_free_sync(mvm->dev, ptk_pn);
  }

  IWL_DEBUG_MAC80211(mvm, "disable hwcrypto key\n");
  ret = iwl_mvm_remove_sta_key(mvm, mvmvif, mvmsta, key);

out:
  mtx_unlock(&mvm->mutex);
  return ret;
}

#if 0  // NEEDS_PORTING
static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                        struct ieee80211_key_conf* keyconf,
                                        struct ieee80211_sta* sta, uint32_t iv32,
                                        uint16_t* phase1key) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID) { return; }

    iwl_mvm_update_tkip_key(mvm, vif, keyconf, sta, iv32, phase1key);
}

static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data* notif_wait, struct iwl_rx_packet* pkt,
                               void* data) {
    struct iwl_mvm* mvm = container_of(notif_wait, struct iwl_mvm, notif_wait);
    struct iwl_hs20_roc_res* resp;
    int resp_len = iwl_rx_packet_payload_len(pkt);
    struct iwl_mvm_time_event_data* te_data = data;

    if (WARN_ON(pkt->hdr.cmd != HOT_SPOT_CMD)) { return true; }

    if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
        IWL_ERR(mvm, "Invalid HOT_SPOT_CMD response\n");
        return true;
    }

    resp = (void*)pkt->data;

    IWL_DEBUG_TE(mvm, "Aux ROC: Received response from ucode: status=%d uid=%d\n", resp->status,
                 resp->event_unique_id);

    te_data->uid = le32_to_cpu(resp->event_unique_id);
    IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n", te_data->uid);

    spin_lock_bh(&mvm->time_event_lock);
    list_add_tail(&te_data->list, &mvm->aux_roc_te_list);
    spin_unlock_bh(&mvm->time_event_lock);

    return true;
}

#define AUX_ROC_MIN_DURATION MSEC_TO_TU(100)
#define AUX_ROC_MIN_DELAY MSEC_TO_TU(200)
#define AUX_ROC_MAX_DELAY MSEC_TO_TU(600)
#define AUX_ROC_SAFETY_BUFFER MSEC_TO_TU(20)
#define AUX_ROC_MIN_SAFETY_BUFFER MSEC_TO_TU(10)
static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm* mvm, struct ieee80211_channel* channel,
                                    struct ieee80211_vif* vif, int duration) {
    int res, time_reg = DEVICE_SYSTEM_TIME_REG;
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct iwl_mvm_time_event_data* te_data = &mvmvif->hs_time_event_data;
    static const uint16_t time_event_response[] = {HOT_SPOT_CMD};
    struct iwl_notification_wait wait_time_event;
    uint32_t dtim_interval = vif->bss_conf.dtim_period * vif->bss_conf.beacon_int;
    uint32_t req_dur, delay;
    struct iwl_hs20_roc_req aux_roc_req = {
        .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
        .id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
        .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
        /* Set the channel info data */
        .channel_info.band = (channel->band == NL80211_BAND_2GHZ) ? PHY_BAND_24 : PHY_BAND_5,
        .channel_info.channel = channel->hw_value,
        .channel_info.width = PHY_VHT_CHANNEL_MODE20,
        /* Set the time and duration */
        .apply_time = cpu_to_le32(iwl_read_prph(mvm->trans, time_reg)),
    };

    delay = AUX_ROC_MIN_DELAY;
    req_dur = MSEC_TO_TU(duration);

    /*
     * If we are associated we want the delay time to be at least one
     * dtim interval so that the FW can wait until after the DTIM and
     * then start the time event, this will potentially allow us to
     * remain off-channel for the max duration.
     * Since we want to use almost a whole dtim interval we would also
     * like the delay to be for 2-3 dtim intervals, in case there are
     * other time events with higher priority.
     */
    if (vif->bss_conf.assoc) {
        delay = min_t(uint32_t, dtim_interval * 3, AUX_ROC_MAX_DELAY);
        /* We cannot remain off-channel longer than the DTIM interval */
        if (dtim_interval <= req_dur) {
            req_dur = dtim_interval - AUX_ROC_SAFETY_BUFFER;
            if (req_dur <= AUX_ROC_MIN_DURATION) {
                req_dur = dtim_interval - AUX_ROC_MIN_SAFETY_BUFFER;
            }
        }
    }

    aux_roc_req.duration = cpu_to_le32(req_dur);
    aux_roc_req.apply_time_max_delay = cpu_to_le32(delay);

    IWL_DEBUG_TE(mvm,
                 "ROC: Requesting to remain on channel %u for %ums (requested = %ums, max_delay = "
                 "%ums, dtim_interval = %ums)\n",
                 channel->hw_value, req_dur, duration, delay, dtim_interval);
    /* Set the node address */
    memcpy(aux_roc_req.node_addr, vif->addr, ETH_ALEN);

    iwl_assert_lock_held(&mvm->mutex);

    spin_lock_bh(&mvm->time_event_lock);

    if (WARN_ON(te_data->id == HOT_SPOT_CMD)) {
        spin_unlock_bh(&mvm->time_event_lock);
        return -EIO;
    }

    te_data->vif = vif;
    te_data->duration = duration;
    te_data->id = HOT_SPOT_CMD;

    spin_unlock_bh(&mvm->time_event_lock);

    /*
     * Use a notification wait, which really just processes the
     * command response and doesn't wait for anything, in order
     * to be able to process the response and get the UID inside
     * the RX path. Using CMD_WANT_SKB doesn't work because it
     * stores the buffer and then wakes up this thread, by which
     * time another notification (that the time event started)
     * might already be processed unsuccessfully.
     */
    iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event, time_event_response,
                               ARRAY_SIZE(time_event_response), iwl_mvm_rx_aux_roc, te_data);

    res = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0, sizeof(aux_roc_req), &aux_roc_req);

    if (res) {
        IWL_ERR(mvm, "Couldn't send HOT_SPOT_CMD: %d\n", res);
        iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
        goto out_clear_te;
    }

    /* No need to wait for anything, so just pass 1 (0 isn't valid) */
    res = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
    /* should never fail */
    WARN_ON_ONCE(res);

    if (res) {
    out_clear_te:
        spin_lock_bh(&mvm->time_event_lock);
        iwl_mvm_te_clear_data(mvm, te_data);
        spin_unlock_bh(&mvm->time_event_lock);
    }

    return res;
}

static int iwl_mvm_roc(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                       struct ieee80211_channel* channel, int duration,
                       enum ieee80211_roc_type type) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct cfg80211_chan_def chandef;
    struct iwl_mvm_phy_ctxt* phy_ctxt;
    int ret, i;

    IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value, duration, type);

    /*
     * Flush the done work, just in case it's still pending, so that
     * the work it does can complete and we can accept new frames.
     */
    flush_work(&mvm->roc_done_wk);

    mutex_lock(&mvm->mutex);

    switch (vif->type) {
    case NL80211_IFTYPE_STATION:
        if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT)) {
            /* Use aux roc framework (HS20) */
            ret = iwl_mvm_send_aux_roc_cmd(mvm, channel, vif, duration);
            goto out_unlock;
        }
        IWL_ERR(mvm, "hotspot not supported\n");
        ret = -EINVAL;
        goto out_unlock;
    case NL80211_IFTYPE_P2P_DEVICE:
        /* handle below */
        break;
    default:
        IWL_ERR(mvm, "vif isn't P2P_DEVICE: %d\n", vif->type);
        ret = -EINVAL;
        goto out_unlock;
    }

    for (i = 0; i < NUM_PHY_CTX; i++) {
        phy_ctxt = &mvm->phy_ctxts[i];
        if (phy_ctxt->ref == 0 || mvmvif->phy_ctxt == phy_ctxt) { continue; }

        if (phy_ctxt->ref && channel == phy_ctxt->channel) {
            /*
             * Unbind the P2P_DEVICE from the current PHY context,
             * and if the PHY context is not used remove it.
             */
            ret = iwl_mvm_binding_remove_vif(mvm, vif);
            if (WARN(ret, "Failed unbinding P2P_DEVICE\n")) { goto out_unlock; }

            iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);

            /* Bind the P2P_DEVICE to the current PHY Context */
            mvmvif->phy_ctxt = phy_ctxt;

            ret = iwl_mvm_binding_add_vif(mvm, vif);
            if (WARN(ret, "Failed binding P2P_DEVICE\n")) { goto out_unlock; }

            iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
            goto schedule_time_event;
        }
    }

    /* Need to update the PHY context only if the ROC channel changed */
    if (channel == mvmvif->phy_ctxt->channel) { goto schedule_time_event; }

    cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);

    /*
     * Change the PHY context configuration as it is currently referenced
     * only by the P2P Device MAC
     */
    if (mvmvif->phy_ctxt->ref == 1) {
        ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt, &chandef, 1, 1);
        if (ret) { goto out_unlock; }
    } else {
        /*
         * The PHY context is shared with other MACs. Need to remove the
         * P2P Device from the binding, allocate an new PHY context and
         * create a new binding
         */
        phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
        if (!phy_ctxt) {
            ret = -ENOSPC;
            goto out_unlock;
        }

        ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chandef, 1, 1);
        if (ret) {
            IWL_ERR(mvm, "Failed to change PHY context\n");
            goto out_unlock;
        }

        /* Unbind the P2P_DEVICE from the current PHY context */
        ret = iwl_mvm_binding_remove_vif(mvm, vif);
        if (WARN(ret, "Failed unbinding P2P_DEVICE\n")) { goto out_unlock; }

        iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);

        /* Bind the P2P_DEVICE to the new allocated PHY context */
        mvmvif->phy_ctxt = phy_ctxt;

        ret = iwl_mvm_binding_add_vif(mvm, vif);
        if (WARN(ret, "Failed binding P2P_DEVICE\n")) { goto out_unlock; }

        iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
    }

schedule_time_event:
    /* Schedule the time events */
    ret = iwl_mvm_start_p2p_roc(mvm, vif, duration, type);

out_unlock:
    mutex_unlock(&mvm->mutex);
    IWL_DEBUG_MAC80211(mvm, "leave\n");
    return ret;
}

static int iwl_mvm_cancel_roc(struct ieee80211_hw* hw) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    IWL_DEBUG_MAC80211(mvm, "enter\n");

    mutex_lock(&mvm->mutex);
    iwl_mvm_stop_roc(mvm);
    mutex_unlock(&mvm->mutex);

    IWL_DEBUG_MAC80211(mvm, "leave\n");
    return 0;
}
#endif  // NEEDS_PORTING

static zx_status_t __iwl_mvm_add_chanctx(struct iwl_mvm* mvm, const wlan_channel_t* chandef,
                                         uint16_t* phy_ctxt_id) {
  struct iwl_mvm_phy_ctxt* phy_ctxt;
  zx_status_t ret;

  iwl_assert_lock_held(&mvm->mutex);

  IWL_DEBUG_MAC80211(mvm, "Add channel context\n");

  phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
  if (!phy_ctxt) {
    ret = ZX_ERR_NO_RESOURCES;
    goto out;
  }

  // TODO(45353): support MIMO Rx.
  ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, chandef, 1, 1);
  if (ret != ZX_OK) {
    IWL_ERR(mvm, "Failed to add PHY context\n");
    goto out;
  }

  iwl_mvm_phy_ctxt_ref(mvm, phy_ctxt);
  *phy_ctxt_id = phy_ctxt->id;

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
  iwl_mvm_fm_notify_channel_change(ctx, IWL_FM_ADD_CHANCTX);
#endif

out:
  return ret;
}

zx_status_t iwl_mvm_add_chanctx(struct iwl_mvm* mvm, const wlan_channel_t* chandef,
                                uint16_t* phy_ctxt_id) {
  zx_status_t ret;

  mtx_lock(&mvm->mutex);
  ret = __iwl_mvm_add_chanctx(mvm, chandef, phy_ctxt_id);
  mtx_unlock(&mvm->mutex);

  return ret;
}

static zx_status_t __iwl_mvm_remove_chanctx(struct iwl_mvm* mvm, uint16_t phy_ctxt_id) {
  struct iwl_mvm_phy_ctxt* phy_ctxt = &mvm->phy_ctxts[phy_ctxt_id];

  iwl_assert_lock_held(&mvm->mutex);

  return iwl_mvm_phy_ctxt_unref(mvm, phy_ctxt);
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
  iwl_mvm_fm_notify_channel_change(ctx, IWL_FM_REMOVE_CHANCTX);
#endif
}

zx_status_t iwl_mvm_remove_chanctx(struct iwl_mvm* mvm, uint16_t phy_ctxt_id) {
  zx_status_t ret;
  mtx_lock(&mvm->mutex);
  ret = __iwl_mvm_remove_chanctx(mvm, phy_ctxt_id);
  mtx_unlock(&mvm->mutex);
  return ret;
}

zx_status_t iwl_mvm_change_chanctx(struct iwl_mvm* mvm, uint16_t phy_ctxt_id,
                                   const wlan_channel_t* chandef) {
  struct iwl_mvm_phy_ctxt* phy_ctxt = &mvm->phy_ctxts[phy_ctxt_id];

  if (phy_ctxt->ref > 1) {
    IWL_WARN(mvm, "Cannot change PHY. Ref=%d\n", phy_ctxt->ref);
    return ZX_ERR_BAD_STATE;
  }

  mtx_lock(&mvm->mutex);

#if 0   // NEEDS_PORTING
    /* we are only changing the min_width, may be a noop */
    if (changed == IEEE80211_CHANCTX_CHANGE_MIN_WIDTH) {
        if (phy_ctxt->width == def->width) { goto out_unlock; }

        /* we are just toggling between 20_NOHT and 20 */
        if (phy_ctxt->width <= NL80211_CHAN_WIDTH_20 && def->width <= NL80211_CHAN_WIDTH_20) {
            goto out_unlock;
        }
    }

    iwl_mvm_bt_coex_vif_change(mvm);
#endif  // NEEDS_PORTING

  // TODO(45353): support MIMO Rx.
  zx_status_t ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, chandef, 1, 1);
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
  iwl_mvm_fm_notify_channel_change(ctx, IWL_FM_CHANGE_CHANCTX);
#endif

  mtx_unlock(&mvm->mutex);

  return ret;
}

static zx_status_t __iwl_mvm_assign_vif_chanctx(struct iwl_mvm_vif* mvmvif,
                                                const wlan_channel_t* chandef,
                                                bool switching_chanctx) {
  zx_status_t ret;

  iwl_assert_lock_held(&mvmvif->mvm->mutex);

  // Assume mvmvif->phy_ctxt had been assigned in mac_start().
  if (!mvmvif->phy_ctxt) {
    IWL_ERR(mvmvif, "PHY context is not assigned yet.\n");
    return ZX_ERR_BAD_STATE;
  }

  switch (mvmvif->mac_role) {
#if 0   // NEEDS_PORTING
    case NL80211_IFTYPE_AP:
        /* only needed if we're switching chanctx (i.e. during CSA) */
        if (switching_chanctx) {
            mvmvif->ap_ibss_active = true;
            break;
        }
    case NL80211_IFTYPE_ADHOC:
        /*
         * The AP binding flow is handled as part of the start_ap flow
         * (in bss_info_changed), similarly for IBSS.
         */
        ret = 0;
        goto out;
#endif  // NEEDS_PORTING
    case WLAN_MAC_ROLE_CLIENT:
      mvmvif->csa_bcn_pending = false;
      break;
#if 0   // NEEDS_PORTING
    case NL80211_IFTYPE_MONITOR:
        /* always disable PS when a monitor interface is active */
        mvmvif->ps_disabled = true;
        break;
#endif  // NEEDS_PORTING
    default:
      ret = ZX_ERR_NOT_SUPPORTED;
      IWL_ERR(mvmvif, "%s(): mac_role: %d not supported yet\n", __func__, mvmvif->mac_role);
      goto out;
  }

  ret = iwl_mvm_binding_add_vif(mvmvif);
  if (ret != ZX_OK) {
    IWL_ERR(mvmvif, "Cannot add vif binding: %s\n", zx_status_get_string(ret));
    goto out;
  }

#ifdef CPTCFG_IWLWIFI_FRQ_MGR
  iwl_mvm_update_ctx_tx_power_limit(mvm, vif, mvmvif->phy_ctxt);
#endif

  /*
   * Power state must be updated before quotas,
   * otherwise fw will complain.
   */
  iwl_mvm_power_update_mac(mvmvif->mvm);

#if 0   // NEEDS_PORTING
    /* Setting the quota at this stage is only required for monitor
     * interfaces. For the other types, the bss_info changed flow
     * will handle quota settings.
     */
    if (vif->type == NL80211_IFTYPE_MONITOR) {
        mvmvif->monitor_active = true;
        ret = iwl_mvm_update_quotas(mvm, false, NULL);
        if (ret) { goto out_remove_binding; }

        ret = iwl_mvm_add_snif_sta(mvm, vif);
        if (ret) { goto out_remove_binding; }
    }

    /* Handle binding during CSA */
    if (vif->type == NL80211_IFTYPE_AP) {
        iwl_mvm_update_quotas(mvm, false, NULL);
        iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
    }
#endif  // NEEDS_PORTING

  if (switching_chanctx && mvmvif->mac_role == WLAN_MAC_ROLE_CLIENT) {
    uint32_t duration = 3 * mvmvif->bss_conf.beacon_int;

    /* iwl_mvm_protect_session() reads directly from the
     * device (the system time), so make sure it is
     * available.
     */
    ret = iwl_mvm_ref_sync(mvmvif->mvm, IWL_MVM_REF_PROTECT_CSA);
    if (ret != ZX_OK) {
      goto out_remove_binding;
    }

    /* Protect the session to make sure we hear the first
     * beacon on the new channel.
     */
    mvmvif->csa_bcn_pending = true;
    iwl_mvm_protect_session(mvmvif->mvm, mvmvif, duration, duration,
                            mvmvif->bss_conf.beacon_int / 2, true);

    iwl_mvm_unref(mvmvif->mvm, IWL_MVM_REF_PROTECT_CSA);

#if 0   // NEEDS_PORTING
        iwl_mvm_update_quotas(mvm, false, NULL);
#endif  // NEEDS_PORTING
  }

  goto out;

out_remove_binding:
  iwl_mvm_binding_remove_vif(mvmvif);
  iwl_mvm_power_update_mac(mvmvif->mvm);
out:
  if (ret != ZX_OK) {
    mvmvif->phy_ctxt = NULL;
  }
  return ret;
}

zx_status_t iwl_mvm_assign_vif_chanctx(struct iwl_mvm_vif* mvmvif, const wlan_channel_t* chandef) {
  zx_status_t ret;

  mtx_lock(&mvmvif->mvm->mutex);
  ret = __iwl_mvm_assign_vif_chanctx(mvmvif, chandef, false);
  mtx_unlock(&mvmvif->mvm->mutex);

  return ret;
}

static zx_status_t __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm_vif* mvmvif,
                                                  bool switching_chanctx) {
#if 0   // NEEDS_PORTING
    struct ieee80211_vif* disabled_vif = NULL;
#endif  // NEEDS_PORTING

  iwl_assert_lock_held(&mvmvif->mvm->mutex);

  zx_status_t ret;

  switch (mvmvif->mac_role) {
#if 0   // NEEDS_PORTING
    case NL80211_IFTYPE_ADHOC:
        goto out;
    case NL80211_IFTYPE_MONITOR:
        mvmvif->monitor_active = false;
        mvmvif->ps_disabled = false;
        iwl_mvm_rm_snif_sta(mvm, vif);
        break;
    case NL80211_IFTYPE_AP:
        /* This part is triggered only during CSA */
        if (!switching_chanctx || !mvmvif->ap_ibss_active) { goto out; }

        mvmvif->csa_countdown = false;

        /* Set CS bit on all the stations */
        iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true);

        /* Save blocked iface, the timeout is set on the next beacon */
        rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif);

        mvmvif->ap_ibss_active = false;
        break;
#endif  // NEEDS_PORTING
    case WLAN_MAC_ROLE_CLIENT:
      if (!switching_chanctx) {
        break;
      }

#if 0   // NEEDS_PORTING
        disabled_vif = vif;
#endif  // NEEDS_PORTING

      ret = iwl_mvm_mac_ctxt_changed(mvmvif, true, NULL);
      if (ret != ZX_OK) {
        IWL_ERR(mvmvif, "Cannot update MAC context while unassigning: %s\n",
                zx_status_get_string(ret));
      }
      break;
    default:
      break;
  }

#if 0   // NEEDS_PORTING
  // TODO(43218): support multiple interfaces. Port iwl_mvm_update_quotas() in mvm/quota.c.
  iwl_mvm_update_quotas(mvm, false, disabled_vif);
#endif  // NEEDS_PORTING

  ret = iwl_mvm_binding_remove_vif(mvmvif);
  if (ret != ZX_OK) {
    IWL_ERR(mvmvif, "cannot remove VIF binding: %s\n", zx_status_get_string(ret));
  }

#if 0   // NEEDS_PORTING
out:
#endif  // NEEDS_PORTING

  mvmvif->phy_ctxt = NULL;
  ret = iwl_mvm_power_update_mac(mvmvif->mvm);
  if (ret != ZX_OK) {
    IWL_ERR(mvmvif, "cannot update the power setting of MAC: %s\n", zx_status_get_string(ret));
  }

  return ZX_OK;
}

zx_status_t iwl_mvm_unassign_vif_chanctx(struct iwl_mvm_vif* mvmvif) {
  mtx_lock(&mvmvif->mvm->mutex);
  zx_status_t ret = __iwl_mvm_unassign_vif_chanctx(mvmvif, false);
  mtx_unlock(&mvmvif->mvm->mutex);

  return ret;
}

#if 0  // NEEDS_PORTING
static int iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm* mvm,
                                           struct ieee80211_vif_chanctx_switch* vifs) {
    int ret;

    mutex_lock(&mvm->mutex);
    __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
    __iwl_mvm_remove_chanctx(mvm, vifs[0].old_ctx);

    ret = __iwl_mvm_add_chanctx(mvm, vifs[0].new_ctx);
    if (ret) {
        IWL_ERR(mvm, "failed to add new_ctx during channel switch\n");
        goto out_reassign;
    }

    ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx, true);
    if (ret) {
        IWL_ERR(mvm, "failed to assign new_ctx during channel switch\n");
        goto out_remove;
    }

    /* we don't support TDLS during DCM - can be caused by channel switch */
    if (iwl_mvm_phy_ctx_count(mvm) > 1) { iwl_mvm_teardown_tdls_peers(mvm); }

    goto out;

out_remove:
    __iwl_mvm_remove_chanctx(mvm, vifs[0].new_ctx);

out_reassign:
    if (__iwl_mvm_add_chanctx(mvm, vifs[0].old_ctx)) {
        IWL_ERR(mvm, "failed to add old_ctx back after failure.\n");
        goto out_restart;
    }

    if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true)) {
        IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
        goto out_restart;
    }

    goto out;

out_restart:
    /* things keep failing, better restart the hw */
    iwl_mvm_nic_restart(mvm, false);

out:
    mutex_unlock(&mvm->mutex);

    return ret;
}

static int iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm* mvm,
                                               struct ieee80211_vif_chanctx_switch* vifs) {
    int ret;

    mutex_lock(&mvm->mutex);
    __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);

    ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx, true);
    if (ret) {
        IWL_ERR(mvm, "failed to assign new_ctx during channel switch\n");
        goto out_reassign;
    }

    goto out;

out_reassign:
    if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true)) {
        IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
        goto out_restart;
    }

    goto out;

out_restart:
    /* things keep failing, better restart the hw */
    iwl_mvm_nic_restart(mvm, false);

out:
    mutex_unlock(&mvm->mutex);

    return ret;
}

static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw* hw,
                                      struct ieee80211_vif_chanctx_switch* vifs, int n_vifs,
                                      enum ieee80211_chanctx_switch_mode mode) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int ret;

    /* we only support a single-vif right now */
    if (n_vifs > 1) { return -EOPNOTSUPP; }

    switch (mode) {
    case CHANCTX_SWMODE_SWAP_CONTEXTS:
        ret = iwl_mvm_switch_vif_chanctx_swap(mvm, vifs);
        break;
    case CHANCTX_SWMODE_REASSIGN_VIF:
        ret = iwl_mvm_switch_vif_chanctx_reassign(mvm, vifs);
        break;
    default:
        ret = -EOPNOTSUPP;
        break;
    }

    return ret;
}

static int iwl_mvm_tx_last_beacon(struct ieee80211_hw* hw) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    return mvm->ibss_manager;
}

static int iwl_mvm_set_tim(struct ieee80211_hw* hw, struct ieee80211_sta* sta, bool set) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_sta* mvm_sta = iwl_mvm_sta_from_mac80211(sta);

    if (!mvm_sta || !mvm_sta->vif) {
        IWL_ERR(mvm, "Station is not associated to a vif\n");
        return -EINVAL;
    }

    return iwl_mvm_mac_ctxt_beacon_changed(mvm, mvm_sta->vif);
}

#ifdef CPTCFG_NL80211_TESTMODE
static const struct nla_policy iwl_mvm_tm_policy[IWL_TM_ATTR_MAX + 1] = {
    [IWL_TM_ATTR_CMD] = {.type = NLA_U32},
    [IWL_TM_ATTR_NOA_DURATION] = {.type = NLA_U32},
    [IWL_TM_ATTR_BEACON_FILTER_STATE] = {.type = NLA_U32},
};

static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm* mvm, struct ieee80211_vif* vif, void* data,
                                      int len) {
    struct nlattr* tb[IWL_TM_ATTR_MAX + 1];
    int err;
    uint32_t noa_duration;

    err = nla_parse(tb, IWL_TM_ATTR_MAX, data, len, iwl_mvm_tm_policy, NULL);
    if (err) { return err; }

    if (!tb[IWL_TM_ATTR_CMD]) { return -EINVAL; }

    switch (nla_get_u32(tb[IWL_TM_ATTR_CMD])) {
    case IWL_TM_CMD_SET_NOA:
        if (!vif || vif->type != NL80211_IFTYPE_AP || !vif->p2p || !vif->bss_conf.enable_beacon ||
            !tb[IWL_TM_ATTR_NOA_DURATION]) {
            return -EINVAL;
        }

        noa_duration = nla_get_u32(tb[IWL_TM_ATTR_NOA_DURATION]);
        if (noa_duration >= vif->bss_conf.beacon_int) { return -EINVAL; }

        mvm->noa_duration = noa_duration;
        mvm->noa_vif = vif;

        if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_DYNAMIC_QUOTA)) {
#ifdef CPTCFG_IWLWIFI_DEBUG_HOST_CMD_ENABLED
            int beacon_int = vif->bss_conf.beacon_int;
            int max_quota_percent = (100 * (beacon_int - noa_duration)) / beacon_int;

            return iwl_mvm_dhc_quota_enforce(mvm, iwl_mvm_vif_from_mac80211(vif),
                                             max_quota_percent);
#else
            return -EOPNOTSUPP;
#endif
        }

        return iwl_mvm_update_quotas(mvm, true, NULL);
    case IWL_TM_CMD_SET_BEACON_FILTER:
        /* must be associated client vif - ignore authorized */
        if (!vif || vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc ||
            !vif->bss_conf.dtim_period || !tb[IWL_TM_ATTR_BEACON_FILTER_STATE]) {
            return -EINVAL;
        }

        if (nla_get_u32(tb[IWL_TM_ATTR_BEACON_FILTER_STATE])) {
            return iwl_mvm_enable_beacon_filter(mvm, vif, 0);
        }
        return iwl_mvm_disable_beacon_filter(mvm, vif, 0);
    }

    return -EOPNOTSUPP;
}

static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw* hw, struct ieee80211_vif* vif, void* data,
                                    int len) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int err;

    mutex_lock(&mvm->mutex);
    err = __iwl_mvm_mac_testmode_cmd(mvm, vif, data, len);
    mutex_unlock(&mvm->mutex);

    return err;
}
#endif

static void iwl_mvm_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                   struct ieee80211_channel_switch* chsw) {
    /* By implementing this operation, we prevent mac80211 from
     * starting its own channel switch timer, so that we can call
     * ieee80211_chswitch_done() ourselves at the right time
     * (which is when the absence time event starts).
     */

    IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw), "dummy channel switch op\n");
}

static int iwl_mvm_pre_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                      struct ieee80211_channel_switch* chsw) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct ieee80211_vif* csa_vif;
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    uint32_t apply_time;
    int ret;

    mutex_lock(&mvm->mutex);

    mvmvif->csa_failed = false;

    IWL_DEBUG_MAC80211(mvm, "pre CSA to freq %d\n", chsw->chandef.center_freq1);

    iwl_fw_dbg_trigger_simple_stop(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
                                   FW_DBG_TRIGGER_CHANNEL_SWITCH);

    switch (vif->type) {
    case NL80211_IFTYPE_AP:
        csa_vif = rcu_dereference_protected(mvm->csa_vif, lockdep_is_held(&mvm->mutex));
        if (WARN_ONCE(csa_vif && csa_vif->csa_active, "Another CSA is already in progress")) {
            ret = -EBUSY;
            goto out_unlock;
        }

        /* we still didn't unblock tx. prevent new CS meanwhile */
        if (rcu_dereference_protected(mvm->csa_tx_blocked_vif, lockdep_is_held(&mvm->mutex))) {
            ret = -EBUSY;
            goto out_unlock;
        }

        rcu_assign_pointer(mvm->csa_vif, vif);

        if (WARN_ONCE(mvmvif->csa_countdown, "Previous CSA countdown didn't complete")) {
            ret = -EBUSY;
            goto out_unlock;
        }

        mvmvif->csa_target_freq = chsw->chandef.chan->center_freq;

        break;
    case NL80211_IFTYPE_STATION:
        /* Schedule the time event to a bit before beacon 1,
         * to make sure we're in the new channel when the
         * GO/AP arrives. In case count <= 1 immediately schedule the
         * TE (this might result with some packet loss or connection
         * loss).
         */
        if (chsw->count <= 1) {
            apply_time = 0;
        } else
            apply_time = chsw->device_timestamp + ((vif->bss_conf.beacon_int * (chsw->count - 1) -
                                                    IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT) *
                                                   1024);

        if (chsw->block_tx) { iwl_mvm_csa_client_absent(mvm, vif); }

        iwl_mvm_schedule_csa_period(mvm, vif, vif->bss_conf.beacon_int, apply_time);
        if (mvmvif->bf_data.bf_enabled) {
            ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
            if (ret) { goto out_unlock; }
        }

        break;
    default:
        break;
    }

    mvmvif->ps_disabled = true;

    ret = iwl_mvm_power_update_ps(mvm);
    if (ret) { goto out_unlock; }

    /* we won't be on this channel any longer */
    iwl_mvm_teardown_tdls_peers(mvm);

out_unlock:
    mutex_unlock(&mvm->mutex);

    return ret;
}

static int iwl_mvm_post_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int ret;

    mutex_lock(&mvm->mutex);

    if (mvmvif->csa_failed) {
        mvmvif->csa_failed = false;
        ret = -EIO;
        goto out_unlock;
    }

    if (vif->type == NL80211_IFTYPE_STATION) {
        struct iwl_mvm_sta* mvmsta;

        mvmvif->csa_bcn_pending = false;
        mvmsta = iwl_mvm_sta_from_staid_protected(mvm, mvmvif->ap_sta_id);

        if (WARN_ON(!mvmsta)) {
            ret = -EIO;
            goto out_unlock;
        }

        iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);

        iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);

        ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
        if (ret) { goto out_unlock; }

        iwl_mvm_stop_session_protection(mvm, vif);
    }

    mvmvif->ps_disabled = false;

    ret = iwl_mvm_power_update_ps(mvm);

out_unlock:
    mutex_unlock(&mvm->mutex);

    return ret;
}

static void iwl_mvm_flush_no_vif(struct iwl_mvm* mvm, uint32_t queues, bool drop) {
    int i;

    if (!iwl_mvm_has_new_tx_api(mvm)) {
        if (drop) {
            mutex_lock(&mvm->mutex);
            iwl_mvm_flush_tx_path(mvm, iwl_mvm_flushable_queues(mvm) & queues, 0);
            mutex_unlock(&mvm->mutex);
        } else {
            iwl_trans_wait_tx_queues_empty(mvm->trans, queues);
        }
        return;
    }

    mutex_lock(&mvm->mutex);
    for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
        struct ieee80211_sta* sta;

        sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i], lockdep_is_held(&mvm->mutex));
        if (IS_ERR_OR_NULL(sta)) { continue; }

        if (drop) {
            iwl_mvm_flush_sta_tids(mvm, i, 0xFF, 0);
        } else {
            iwl_mvm_wait_sta_queues_empty(mvm, iwl_mvm_sta_from_mac80211(sta));
        }
    }
    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_mac_flush(struct ieee80211_hw* hw, struct ieee80211_vif* vif, uint32_t queues,
                              bool drop) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif;
    struct iwl_mvm_sta* mvmsta;
    struct ieee80211_sta* sta;
    int i;
    uint32_t msk = 0;

    if (!vif) {
        iwl_mvm_flush_no_vif(mvm, queues, drop);
        return;
    }

    if (vif->type != NL80211_IFTYPE_STATION) { return; }

    /* Make sure we're done with the deferred traffic before flushing */
    flush_work(&mvm->add_stream_wk);

    mutex_lock(&mvm->mutex);
    mvmvif = iwl_mvm_vif_from_mac80211(vif);

    /* flush the AP-station and all TDLS peers */
    for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
        sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i], lockdep_is_held(&mvm->mutex));
        if (IS_ERR_OR_NULL(sta)) { continue; }

        mvmsta = iwl_mvm_sta_from_mac80211(sta);
        if (mvmsta->vif != vif) { continue; }

        /* make sure only TDLS peers or the AP are flushed */
        WARN_ON(i != mvmvif->ap_sta_id && !sta->tdls);

        if (drop) {
            if (iwl_mvm_flush_sta(mvm, mvmsta, false, 0)) { IWL_ERR(mvm, "flush request fail\n"); }
        } else {
            msk |= mvmsta->tfd_queue_msk;
            if (iwl_mvm_has_new_tx_api(mvm)) { iwl_mvm_wait_sta_queues_empty(mvm, mvmsta); }
        }
    }

    mutex_unlock(&mvm->mutex);

    /* this can take a while, and we may need/want other operations
     * to succeed while doing this, so do it without the mutex held
     */
    if (!drop && !iwl_mvm_has_new_tx_api(mvm)) { iwl_trans_wait_tx_queues_empty(mvm->trans, msk); }
}

static int iwl_mvm_mac_get_survey(struct ieee80211_hw* hw, int idx, struct survey_info* survey) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    int ret;

    memset(survey, 0, sizeof(*survey));

    /* only support global statistics right now */
    if (idx != 0) { return -ENOENT; }

    if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS)) {
        return -ENOENT;
    }

    mutex_lock(&mvm->mutex);

    if (iwl_mvm_firmware_running(mvm)) {
        ret = iwl_mvm_request_statistics(mvm, false);
        if (ret) { goto out; }
    }

    survey->filled =
        SURVEY_INFO_TIME | SURVEY_INFO_TIME_RX | SURVEY_INFO_TIME_TX | SURVEY_INFO_TIME_SCAN;
    survey->time = mvm->accu_radio_stats.on_time_rf + mvm->radio_stats.on_time_rf;
    do_div(survey->time, USEC_PER_MSEC);

    survey->time_rx = mvm->accu_radio_stats.rx_time + mvm->radio_stats.rx_time;
    do_div(survey->time_rx, USEC_PER_MSEC);

    survey->time_tx = mvm->accu_radio_stats.tx_time + mvm->radio_stats.tx_time;
    do_div(survey->time_tx, USEC_PER_MSEC);

    survey->time_scan = mvm->accu_radio_stats.on_time_scan + mvm->radio_stats.on_time_scan;
    do_div(survey->time_scan, USEC_PER_MSEC);

    ret = 0;
out:
    mutex_unlock(&mvm->mutex);
    return ret;
}

static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                       struct ieee80211_sta* sta, struct station_info* sinfo) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
    struct iwl_mvm_sta* mvmsta = iwl_mvm_sta_from_mac80211(sta);

    if (mvmsta->avg_energy) {
        sinfo->signal_avg = mvmsta->avg_energy;
        sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
    }

    /* if beacon filtering isn't on mac80211 does it anyway */
    if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER)) { return; }

    if (!vif->bss_conf.assoc) { return; }

    mutex_lock(&mvm->mutex);

    if (mvmvif->ap_sta_id != mvmsta->sta_id) { goto unlock; }

    if (iwl_mvm_request_statistics(mvm, false)) { goto unlock; }

    sinfo->rx_beacon = mvmvif->beacon_stats.num_beacons + mvmvif->beacon_stats.accu_num_beacons;
    sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_RX);
    if (mvmvif->beacon_stats.avg_signal) {
        /* firmware only reports a value after RXing a few beacons */
        sinfo->rx_beacon_signal_avg = mvmvif->beacon_stats.avg_signal;
        sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
    }
unlock:
    mutex_unlock(&mvm->mutex);
}

static void iwl_mvm_event_mlme_callback(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                        const struct ieee80211_event* event) {
#define CHECK_MLME_TRIGGER(_cnt, _fmt...)              \
  do {                                                 \
    if ((trig_mlme->_cnt) && --(trig_mlme->_cnt))      \
      break;                                           \
    iwl_fw_dbg_collect_trig(&(mvm)->fwrt, trig, _fmt); \
  } while (0)

    struct iwl_fw_dbg_trigger_tlv* trig;
    struct iwl_fw_dbg_trigger_mlme* trig_mlme;

    trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), FW_DBG_TRIGGER_MLME);
    if (!trig) { return; }

    trig_mlme = (void*)trig->data;

    if (event->u.mlme.data == ASSOC_EVENT) {
        if (event->u.mlme.status == MLME_DENIED) {
            CHECK_MLME_TRIGGER(stop_assoc_denied, "DENIED ASSOC: reason %d", event->u.mlme.reason);
        } else if (event->u.mlme.status == MLME_TIMEOUT) {
            CHECK_MLME_TRIGGER(stop_assoc_timeout, "ASSOC TIMEOUT");
        }
    } else if (event->u.mlme.data == AUTH_EVENT) {
        if (event->u.mlme.status == MLME_DENIED) {
            CHECK_MLME_TRIGGER(stop_auth_denied, "DENIED AUTH: reason %d", event->u.mlme.reason);
        } else if (event->u.mlme.status == MLME_TIMEOUT) {
            CHECK_MLME_TRIGGER(stop_auth_timeout, "AUTH TIMEOUT");
        }
    } else if (event->u.mlme.data == DEAUTH_RX_EVENT) {
        CHECK_MLME_TRIGGER(stop_rx_deauth, "DEAUTH RX %d", event->u.mlme.reason);
    } else if (event->u.mlme.data == DEAUTH_TX_EVENT) {
        CHECK_MLME_TRIGGER(stop_tx_deauth, "DEAUTH TX %d", event->u.mlme.reason);
    }
#undef CHECK_MLME_TRIGGER
}

static void iwl_mvm_event_bar_rx_callback(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                          const struct ieee80211_event* event) {
    struct iwl_fw_dbg_trigger_tlv* trig;
    struct iwl_fw_dbg_trigger_ba* ba_trig;

    trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), FW_DBG_TRIGGER_BA);
    if (!trig) { return; }

    ba_trig = (void*)trig->data;

    if (!(le16_to_cpu(ba_trig->rx_bar) & BIT(event->u.ba.tid))) { return; }

    iwl_fw_dbg_collect_trig(&mvm->fwrt, trig, "BAR received from %pM, tid %d, ssn %d",
                            event->u.ba.sta->addr, event->u.ba.tid, event->u.ba.ssn);
}

#ifdef CPTCFG_MAC80211_LATENCY_MEASUREMENTS
#define MARKER_CMD_TX_LAT_PAYLOAD_SIZE 5
#define MARKER_CMD_TX_LAT_TID_OFFSET 12
#define MARKER_CMD_TX_LAT_DEFAULT_WIN 1000
#define MARKER_CMD_TX_LAT_UNKNOWN 0xffffffff

static uint32_t iwl_mvm_send_latency_marker_cmd(struct iwl_mvm* mvm, uint32_t msrmnt, uint16_t seq,
                                                uint16_t tid) {
    struct timespec ts;
    int ret;
    struct iwl_mvm_marker_rsp* rsp;
    struct iwl_mvm_marker* marker;
    struct iwl_host_cmd cmd = {
        .id = MARKER_CMD,
        .flags = CMD_WANT_SKB,
    };
    uint32_t cmd_size =
        sizeof(struct iwl_mvm_marker) + MARKER_CMD_TX_LAT_PAYLOAD_SIZE * sizeof(uint32_t);

    getnstimeofday(&ts);

    marker = kzalloc(cmd_size, GFP_KERNEL);
    if (!marker) { return -ENOMEM; }

    cmd.data[0] = marker;
    cmd.len[0] = cmd_size;

    marker->dw_len = 0x8;
    marker->marker_id = MARKER_ID_TX_FRAME_LATENCY;
    marker->timestamp = cpu_to_le64(ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
    /* metadata[0]-frame latency */
    marker->metadata[0] = cpu_to_le32(msrmnt);
    /* metadata[1]-delta in msec from UTC to frame enter the kernel */
    marker->metadata[1] = cpu_to_le32(MARKER_CMD_TX_LAT_UNKNOWN);
    /* metadata[2]-delta in msec from UTC to frame enter the NIC */
    marker->metadata[2] = cpu_to_le32(MARKER_CMD_TX_LAT_UNKNOWN);
    /* metadata[3]-delta in msec from UTC to frecieved from the NIC */
    marker->metadata[3] = cpu_to_le32(MARKER_CMD_TX_LAT_UNKNOWN);
    /* metadata[4]-bits:16-31-TFD Queue ID, 12-15-TID, 0-11-sequence */
    marker->metadata[4] =
        cpu_to_le32(0xffff0000 | ((0xf & tid) << MARKER_CMD_TX_LAT_TID_OFFSET) | (seq & 0x0fff));

    mutex_lock(&mvm->mutex);
    ret = iwl_mvm_send_cmd(mvm, &cmd);
    mutex_unlock(&mvm->mutex);
    if (ret) {
        IWL_ERR(mvm, "Couldn't send MARKER_CMD: %d\n", ret);
        goto out;
    }

    rsp = (void*)cmd.resp_pkt->data;
    ret = le32_to_cpu(rsp->gp2);
    iwl_free_resp(&cmd);
out:
    kfree(marker);
    return ret;
}

/*
 * Trigger the fw log collection in case of a Tx packet that has crossed a
 * configured threshold.
 *
 * There are 3 differnt modes of triggering:
 *
 * Immediate Internal buffer mode:
 * The driver will retrieve monitor/usniffer data on the first driver
 * notification and wait for 1 second (during this 1 second it will not issue
 * another monitor/usniffer retrieve request). During this 1 second the driver
 * will store all notifications data to the trace including GP2 timestamp for
 * every notification. Also special mark will be sent to the firmware for every
 * notification.
 *
 * Delayed Internal buffer mode:
 * During the window interval the driver will calculate which tx had the
 * largest latency. When the monitor_collect_window expires the driver will
 * retrieve monitor/sniffer and print the notification for the packet with max
 * latency to the trace including GP2 timestamp. Also special mark will be sent
 * to the firmware for every notification.
 *
 * Continuous External buffer mode:
 * The mode is used when we are able to direct the usniffer logs to an external
 * memory device (should be started/stopped Manually).
 * During the window interval the driver will calculate which tx had the
 * largest latency. When the monitor_collect_window expires the driver print
 * the notification for the packet with max latency to the trace including GP2
 * timestamp. Also special mark will be sent to the firmware for every
 * notification.
 */

/*
 * TX latency monitor watchdog is armed upon first latency notification.
 * It fires when monitor window is expired and does the following:
 * - immediate internal buffer mode: just reset start_round_ts flag
 * - delayed internal buffer mode: writes metadata to trace-cmd and collects
 *   firmware dump
 * - continuous external buffer mode: just writes metadata to trace-cmd
 */
void iwl_mvm_tx_latency_watchdog_wk(struct work_struct* wk) {
    struct iwl_mvm* mvm = container_of(wk, struct iwl_mvm, tx_latency_watchdog_wk.work);
    struct iwl_fw_dbg_trigger_tlv* trig;
    struct ieee80211_tx_latency_event* tx_lat = &mvm->last_tx_lat_event;
    struct ieee80211_tx_latency_event* max = &mvm->round_max_tx_lat;
    uint32_t round_dur = tx_lat->monitor_collec_wind;

    mvm->start_round_ts = 0;

    if (!round_dur) { return; }

    if (tx_lat->mode == IEEE80211_TX_LATENCY_EXT_BUF) {
        trace_iwlwifi_dev_tx_latency_thrshld(mvm->dev, max->msrmnt, max->pkt_start, max->pkt_end,
                                             max->tid, max->event_time, max->seq,
                                             mvm->max_tx_latency_gp2, 1);
        return;
    }

    trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TX_LATENCY);
    trace_iwlwifi_dev_tx_latency_thrshld(mvm->dev, max->msrmnt, max->pkt_start, max->pkt_end,
                                         max->tid, max->event_time, max->seq,
                                         mvm->max_tx_latency_gp2, 1);
    iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
                            "Tx Latency threshold was crossed, seq: 0x%x, msrmnt: %d.", max->seq,
                            max->msrmnt);
}

/*
 * TX latency monitor work is scheduled upon every latency event. Regardless of
 * the monitor mode it as a first step sends firmware marker command containing
 * problematic packet's data - latency measurement, sequence number and TID.
 * It also obtains GP2 timestamp for this marker command.
 * The rest depends on monitor mode as follows:
 * 1. Immediate Internal Buffer mode.
 *    - arms watchdog to fire after monitor period (1 sec)
 *    - write packet's metadata to trace-cmd
 *    - only if the packet is the first one starting the monitor period,
 *      collect firmware dump
 * 2. Delayed Internal Buffer mode.
 *    - arms watchdog to fire after user defined monitor period
 *    - save largest latency packet's metadata
 * 3. Continuous External Buffer mode with delay.
 *    - arms watchdog to fire after user defined monitor period
 *    - save largest latency packet's metadata
 * 4. Continuous External Buffer mode without delay.
 *    - write packet's metadata to trace-cmd
 */
void iwl_mvm_tx_latency_wk(struct work_struct* wk) {
    struct iwl_mvm* mvm = container_of(wk, struct iwl_mvm, tx_latency_wk);
    struct iwl_fw_dbg_trigger_tlv* trig;
    struct ieee80211_tx_latency_event* tx_lat = &mvm->last_tx_lat_event;
    struct ieee80211_tx_latency_event* max = &mvm->round_max_tx_lat;
    s64 ts = ktime_to_ms(ktime_get());
    uint32_t round_dur = tx_lat->monitor_collec_wind;
    uint32_t round_end =
        tx_lat->monitor_collec_wind ? tx_lat->monitor_collec_wind : MARKER_CMD_TX_LAT_DEFAULT_WIN;
    bool first_pkt = false;
    uint32_t gp2 = 0;
    uint32_t delay = 0;

    if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TX_LATENCY)) { return; }

    trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TX_LATENCY);

    tx_lat->event_time = ktime_to_ms(ktime_get());

    gp2 = iwl_mvm_send_latency_marker_cmd(mvm, tx_lat->msrmnt, tx_lat->seq, tx_lat->tid);
    /*
     * If this is the first packet that crossed the threshold in the round
     * update start time stamp
     */
    if (!mvm->start_round_ts) {
        mvm->start_round_ts = ts;
        first_pkt = true;
        memcpy(max, tx_lat, sizeof(*tx_lat));
        mvm->max_tx_latency_gp2 = gp2;
        if (round_dur) {
            delay = msecs_to_jiffies(round_dur);
        } else if (tx_lat->mode == IEEE80211_TX_LATENCY_INT_BUF) {
            delay = msecs_to_jiffies(round_end);
        }
        if (delay) { schedule_delayed_work(&mvm->tx_latency_watchdog_wk, delay); }
    }

    /*
     * Updated the packet with the max latency.
     */
    if (round_dur && max->msrmnt < tx_lat->msrmnt) {
        memcpy(max, tx_lat, sizeof(*tx_lat));
        mvm->max_tx_latency_gp2 = gp2;
    }

    if (round_dur) { return; }

    if (tx_lat->mode == IEEE80211_TX_LATENCY_EXT_BUF) {
        trace_iwlwifi_dev_tx_latency_thrshld(mvm->dev, tx_lat->msrmnt, tx_lat->pkt_start,
                                             tx_lat->pkt_end, tx_lat->tid, tx_lat->event_time,
                                             tx_lat->seq, gp2, 0);
        return;
    }

    trace_iwlwifi_dev_tx_latency_thrshld(mvm->dev, tx_lat->msrmnt, tx_lat->pkt_start,
                                         tx_lat->pkt_end, tx_lat->tid, tx_lat->event_time,
                                         tx_lat->seq, gp2, 0);
    if (first_pkt)
        iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
                                "Tx Latency threshold was crossed, seq: 0x%x, msrmnt: %d.",
                                tx_lat->seq, tx_lat->msrmnt);
}

static void iwl_mvm_event_tx_latency_callback(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                              const struct ieee80211_event* event) {
    memcpy(&mvm->last_tx_lat_event, &event->u.tx_lat, sizeof(event->u.tx_lat));
    schedule_work(&mvm->tx_latency_wk);
}
#endif /* CPTCFG_MAC80211_LATENCY_MEASUREMENTS */

static void iwl_mvm_mac_event_callback(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                       const struct ieee80211_event* event) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    switch (event->type) {
    case MLME_EVENT:
        iwl_mvm_event_mlme_callback(mvm, vif, event);
        break;
    case BAR_RX_EVENT:
        iwl_mvm_event_bar_rx_callback(mvm, vif, event);
        break;
    case BA_FRAME_TIMEOUT:
        iwl_mvm_event_frame_timeout_callback(mvm, vif, event->u.ba.sta, event->u.ba.tid);
        break;
#ifdef CPTCFG_MAC80211_LATENCY_MEASUREMENTS
    case TX_LATENCY_EVENT:
        iwl_mvm_event_tx_latency_callback(mvm, vif, event);
        break;
#endif /* CPTCFG_MAC80211_LATENCY_MEASUREMENTS */
    default:
        break;
    }
}

void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm* mvm, struct iwl_mvm_internal_rxq_notif* notif,
                                     uint32_t size) {
    uint32_t qmask = BIT(mvm->trans->num_rx_queues) - 1;
    int ret;

    iwl_assert_lock_held(&mvm->mutex);

    if (!iwl_mvm_has_new_rx_api(mvm)) { return; }

    notif->cookie = mvm->queue_sync_cookie;

    if (notif->sync) { atomic_set(&mvm->queue_sync_counter, mvm->trans->num_rx_queues); }

    ret = iwl_mvm_notify_rx_queue(mvm, qmask, (uint8_t*)notif, size);
    if (ret) {
        IWL_ERR(mvm, "Failed to trigger RX queues sync (%d)\n", ret);
        goto out;
    }

    if (notif->sync) {
        ret = wait_event_timeout(
            mvm->rx_sync_waitq,
            atomic_read(&mvm->queue_sync_counter) == 0 || iwl_mvm_is_radio_killed(mvm), HZ);
        WARN_ON_ONCE(!ret && !iwl_mvm_is_radio_killed(mvm));
    }

out:
    atomic_set(&mvm->queue_sync_counter, 0);
    mvm->queue_sync_cookie++;
}

static void iwl_mvm_sync_rx_queues(struct ieee80211_hw* hw) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
    struct iwl_mvm_internal_rxq_notif data = {
        .type = IWL_MVM_RXQ_EMPTY,
        .sync = 1,
    };

    mutex_lock(&mvm->mutex);
    iwl_mvm_sync_rx_queues_internal(mvm, &data, sizeof(data));
    mutex_unlock(&mvm->mutex);
}

static bool iwl_mvm_can_hw_csum(struct sk_buff* skb) {
#if IS_ENABLED(CONFIG_INET)
    uint8_t protocol = ip_hdr(skb)->protocol;

    if (protocol != IPPROTO_TCP || protocol != IPPROTO_UDP) { return false; }
    return true;
#else
    return false;
#endif
}

static bool iwl_mvm_mac_can_aggregate(struct ieee80211_hw* hw, struct sk_buff* head,
                                      struct sk_buff* skb) {
    struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);

    /* For now don't aggregate IPv6 in AMSDU */
    if (skb->protocol != htons(ETH_P_IP)) { return false; }

    if (!iwl_mvm_is_csum_supported(mvm)) { return true; }

    return iwl_mvm_can_hw_csum(skb) == iwl_mvm_can_hw_csum(head);
}
#endif  // NEEDS_PORTING

const struct ieee80211_ops iwl_mvm_hw_ops = {
#if 0  // NEEDS_PORTING
    .tx = iwl_mvm_mac_tx,
    .wake_tx_queue = iwl_mvm_mac_wake_tx_queue,
    .ampdu_action = iwl_mvm_mac_ampdu_action,
    .start = iwl_mvm_mac_start,
    .reconfig_complete = iwl_mvm_mac_reconfig_complete,
    .stop = iwl_mvm_mac_stop,
    .add_interface = iwl_mvm_mac_add_interface,
    .remove_interface = iwl_mvm_mac_remove_interface,
    .config = iwl_mvm_mac_config,
    .prepare_multicast = iwl_mvm_prepare_multicast,
    .configure_filter = iwl_mvm_configure_filter,
    .config_iface_filter = iwl_mvm_config_iface_filter,
    .bss_info_changed = iwl_mvm_bss_info_changed,
    .hw_scan = iwl_mvm_mac_hw_scan,
    .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan,
    .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove,
    .sta_state = iwl_mvm_mac_sta_state,
    .sta_notify = iwl_mvm_mac_sta_notify,
    .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames,
    .release_buffered_frames = iwl_mvm_mac_release_buffered_frames,
    .set_rts_threshold = iwl_mvm_mac_set_rts_threshold,
    .sta_rc_update = iwl_mvm_sta_rc_update,
    .conf_tx = iwl_mvm_mac_conf_tx,
    .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx,
    .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover,
    .flush = iwl_mvm_mac_flush,
    .sched_scan_start = iwl_mvm_mac_sched_scan_start,
    .sched_scan_stop = iwl_mvm_mac_sched_scan_stop,
    .set_key = iwl_mvm_mac_set_key,
    .update_tkip_key = iwl_mvm_mac_update_tkip_key,
    .remain_on_channel = iwl_mvm_roc,
    .cancel_remain_on_channel = iwl_mvm_cancel_roc,
    .add_chanctx = iwl_mvm_add_chanctx,
    .remove_chanctx = iwl_mvm_remove_chanctx,
    .change_chanctx = iwl_mvm_change_chanctx,
    .assign_vif_chanctx = iwl_mvm_assign_vif_chanctx,
    .unassign_vif_chanctx = iwl_mvm_unassign_vif_chanctx,
    .switch_vif_chanctx = iwl_mvm_switch_vif_chanctx,

    .start_ap = iwl_mvm_start_ap_ibss,
    .stop_ap = iwl_mvm_stop_ap_ibss,
    .join_ibss = iwl_mvm_start_ap_ibss,
    .leave_ibss = iwl_mvm_stop_ap_ibss,

    .tx_last_beacon = iwl_mvm_tx_last_beacon,

    .set_tim = iwl_mvm_set_tim,

    .channel_switch = iwl_mvm_channel_switch,
    .pre_channel_switch = iwl_mvm_pre_channel_switch,
    .post_channel_switch = iwl_mvm_post_channel_switch,

    .tdls_channel_switch = iwl_mvm_tdls_channel_switch,
    .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch,
    .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch,

    .event_callback = iwl_mvm_mac_event_callback,

    .sync_rx_queues = iwl_mvm_sync_rx_queues,

    CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd)

#ifdef CONFIG_PM_SLEEP
        /* look at d3.c */
        .suspend = iwl_mvm_suspend,
    .resume = iwl_mvm_resume,
    .set_wakeup = iwl_mvm_set_wakeup,
    .set_rekey_data = iwl_mvm_set_rekey_data,
#if IS_ENABLED(CONFIG_IPV6)
    .ipv6_addr_change = iwl_mvm_ipv6_addr_change,
#endif
    .set_default_unicast_key = iwl_mvm_set_default_unicast_key,
#endif
    .get_survey = iwl_mvm_mac_get_survey,
    .sta_statistics = iwl_mvm_mac_sta_statistics,

    .start_nan = iwl_mvm_start_nan,
    .stop_nan = iwl_mvm_stop_nan,
    .add_nan_func = iwl_mvm_add_nan_func,
    .del_nan_func = iwl_mvm_del_nan_func,

    .can_aggregate_in_amsdu = iwl_mvm_mac_can_aggregate,
#ifdef CPTCFG_IWLWIFI_DEBUGFS
    .sta_add_debugfs = iwl_mvm_sta_add_debugfs,
#endif
#endif  // NEEDS_PORTING
};