The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/contrib/dev/iwlwifi/mvm/mac80211.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
    2 /*
    3  * Copyright (C) 2012-2014, 2018-2022 Intel Corporation
    4  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
    5  * Copyright (C) 2016-2017 Intel Deutschland GmbH
    6  */
    7 #include <linux/kernel.h>
    8 #include <linux/slab.h>
    9 #include <linux/skbuff.h>
   10 #include <linux/netdevice.h>
   11 #include <linux/etherdevice.h>
   12 #include <linux/ip.h>
   13 #include <linux/if_arp.h>
   14 #include <linux/time.h>
   15 #if defined(__FreeBSD__)
   16 #include <linux/math64.h>
   17 #endif
   18 #include <net/mac80211.h>
   19 #include <net/ieee80211_radiotap.h>
   20 #include <net/tcp.h>
   21 #if defined(__FreeBSD__)
   22 #include <linux/udp.h>
   23 #endif
   24 
   25 #include "iwl-drv.h"
   26 #include "iwl-op-mode.h"
   27 #include "iwl-io.h"
   28 #include "mvm.h"
   29 #include "sta.h"
   30 #include "time-event.h"
   31 #include "iwl-eeprom-parse.h"
   32 #include "iwl-phy-db.h"
   33 #ifdef CONFIG_NL80211_TESTMODE
   34 #include "testmode.h"
   35 #endif
   36 #include "fw/error-dump.h"
   37 #include "iwl-prph.h"
   38 #include "iwl-nvm-parse.h"
   39 
   40 static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
   41         {
   42                 .max = 1,
   43                 .types = BIT(NL80211_IFTYPE_STATION),
   44         },
   45         {
   46                 .max = 1,
   47                 .types = BIT(NL80211_IFTYPE_AP) |
   48                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
   49                         BIT(NL80211_IFTYPE_P2P_GO),
   50         },
   51         {
   52                 .max = 1,
   53                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
   54         },
   55 };
   56 
   57 static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
   58         {
   59                 .num_different_channels = 2,
   60                 .max_interfaces = 3,
   61                 .limits = iwl_mvm_limits,
   62                 .n_limits = ARRAY_SIZE(iwl_mvm_limits),
   63         },
   64 };
   65 
   66 static const struct cfg80211_pmsr_capabilities iwl_mvm_pmsr_capa = {
   67         .max_peers = IWL_MVM_TOF_MAX_APS,
   68         .report_ap_tsf = 1,
   69         .randomize_mac_addr = 1,
   70 
   71         .ftm = {
   72                 .supported = 1,
   73                 .asap = 1,
   74                 .non_asap = 1,
   75                 .request_lci = 1,
   76                 .request_civicloc = 1,
   77                 .trigger_based = 1,
   78                 .non_trigger_based = 1,
   79                 .max_bursts_exponent = -1, /* all supported */
   80                 .max_ftms_per_burst = 0, /* no limits */
   81                 .bandwidths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
   82                               BIT(NL80211_CHAN_WIDTH_20) |
   83                               BIT(NL80211_CHAN_WIDTH_40) |
   84                               BIT(NL80211_CHAN_WIDTH_80) |
   85                               BIT(NL80211_CHAN_WIDTH_160),
   86                 .preambles = BIT(NL80211_PREAMBLE_LEGACY) |
   87                              BIT(NL80211_PREAMBLE_HT) |
   88                              BIT(NL80211_PREAMBLE_VHT) |
   89                              BIT(NL80211_PREAMBLE_HE),
   90         },
   91 };
   92 
   93 static int __iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
   94                                  enum set_key_cmd cmd,
   95                                  struct ieee80211_vif *vif,
   96                                  struct ieee80211_sta *sta,
   97                                  struct ieee80211_key_conf *key);
   98 
   99 static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm *mvm)
  100 {
  101         int i;
  102 
  103         memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
  104         for (i = 0; i < NUM_PHY_CTX; i++) {
  105                 mvm->phy_ctxts[i].id = i;
  106                 mvm->phy_ctxts[i].ref = 0;
  107         }
  108 }
  109 
  110 struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy,
  111                                                   const char *alpha2,
  112                                                   enum iwl_mcc_source src_id,
  113                                                   bool *changed)
  114 {
  115         struct ieee80211_regdomain *regd = NULL;
  116         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
  117         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  118         struct iwl_mcc_update_resp *resp;
  119         u8 resp_ver;
  120 
  121         IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);
  122 
  123         lockdep_assert_held(&mvm->mutex);
  124 
  125         resp = iwl_mvm_update_mcc(mvm, alpha2, src_id);
  126         if (IS_ERR_OR_NULL(resp)) {
  127                 IWL_DEBUG_LAR(mvm, "Could not get update from FW %d\n",
  128                               PTR_ERR_OR_ZERO(resp));
  129                 resp = NULL;
  130                 goto out;
  131         }
  132 
  133         if (changed) {
  134                 u32 status = le32_to_cpu(resp->status);
  135 
  136                 *changed = (status == MCC_RESP_NEW_CHAN_PROFILE ||
  137                             status == MCC_RESP_ILLEGAL);
  138         }
  139         resp_ver = iwl_fw_lookup_notif_ver(mvm->fw, IWL_ALWAYS_LONG_GROUP,
  140                                            MCC_UPDATE_CMD, 0);
  141         IWL_DEBUG_LAR(mvm, "MCC update response version: %d\n", resp_ver);
  142 
  143         regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg,
  144                                       __le32_to_cpu(resp->n_channels),
  145                                       resp->channels,
  146                                       __le16_to_cpu(resp->mcc),
  147                                       __le16_to_cpu(resp->geo_info),
  148                                       __le16_to_cpu(resp->cap), resp_ver);
  149         /* Store the return source id */
  150         src_id = resp->source_id;
  151         if (IS_ERR_OR_NULL(regd)) {
  152                 IWL_DEBUG_LAR(mvm, "Could not get parse update from FW %d\n",
  153                               PTR_ERR_OR_ZERO(regd));
  154                 goto out;
  155         }
  156 
  157         IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n",
  158                       regd->alpha2, regd->alpha2[0], regd->alpha2[1], src_id);
  159         mvm->lar_regdom_set = true;
  160         mvm->mcc_src = src_id;
  161 
  162         iwl_mei_set_country_code(__le16_to_cpu(resp->mcc));
  163 
  164 out:
  165         kfree(resp);
  166         return regd;
  167 }
  168 
  169 void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm)
  170 {
  171         bool changed;
  172         struct ieee80211_regdomain *regd;
  173 
  174         if (!iwl_mvm_is_lar_supported(mvm))
  175                 return;
  176 
  177         regd = iwl_mvm_get_current_regdomain(mvm, &changed);
  178         if (!IS_ERR_OR_NULL(regd)) {
  179                 /* only update the regulatory core if changed */
  180                 if (changed)
  181                         regulatory_set_wiphy_regd(mvm->hw->wiphy, regd);
  182 
  183                 kfree(regd);
  184         }
  185 }
  186 
  187 struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm,
  188                                                           bool *changed)
  189 {
  190         return iwl_mvm_get_regdomain(mvm->hw->wiphy, "ZZ",
  191                                      iwl_mvm_is_wifi_mcc_supported(mvm) ?
  192                                      MCC_SOURCE_GET_CURRENT :
  193                                      MCC_SOURCE_OLD_FW, changed);
  194 }
  195 
  196 int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm)
  197 {
  198         enum iwl_mcc_source used_src;
  199         struct ieee80211_regdomain *regd;
  200         int ret;
  201         bool changed;
  202         const struct ieee80211_regdomain *r =
  203                         wiphy_dereference(mvm->hw->wiphy, mvm->hw->wiphy->regd);
  204 
  205         if (!r)
  206                 return -ENOENT;
  207 
  208         /* save the last source in case we overwrite it below */
  209         used_src = mvm->mcc_src;
  210         if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
  211                 /* Notify the firmware we support wifi location updates */
  212                 regd = iwl_mvm_get_current_regdomain(mvm, NULL);
  213                 if (!IS_ERR_OR_NULL(regd))
  214                         kfree(regd);
  215         }
  216 
  217         /* Now set our last stored MCC and source */
  218         regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src,
  219                                      &changed);
  220         if (IS_ERR_OR_NULL(regd))
  221                 return -EIO;
  222 
  223         /* update cfg80211 if the regdomain was changed */
  224         if (changed)
  225                 ret = regulatory_set_wiphy_regd_sync(mvm->hw->wiphy, regd);
  226         else
  227                 ret = 0;
  228 
  229         kfree(regd);
  230         return ret;
  231 }
  232 
  233 static const u8 he_if_types_ext_capa_sta[] = {
  234          [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
  235          [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
  236          [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
  237 };
  238 
  239 static const struct wiphy_iftype_ext_capab he_iftypes_ext_capa[] = {
  240         {
  241                 .iftype = NL80211_IFTYPE_STATION,
  242                 .extended_capabilities = he_if_types_ext_capa_sta,
  243                 .extended_capabilities_mask = he_if_types_ext_capa_sta,
  244                 .extended_capabilities_len = sizeof(he_if_types_ext_capa_sta),
  245         },
  246 };
  247 
  248 static int
  249 iwl_mvm_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
  250 {
  251         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  252         *tx_ant = iwl_mvm_get_valid_tx_ant(mvm);
  253         *rx_ant = iwl_mvm_get_valid_rx_ant(mvm);
  254         return 0;
  255 }
  256 
  257 int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm)
  258 {
  259         struct ieee80211_hw *hw = mvm->hw;
  260         int num_mac, ret, i;
  261         static const u32 mvm_ciphers[] = {
  262                 WLAN_CIPHER_SUITE_WEP40,
  263                 WLAN_CIPHER_SUITE_WEP104,
  264                 WLAN_CIPHER_SUITE_TKIP,
  265                 WLAN_CIPHER_SUITE_CCMP,
  266         };
  267 #ifdef CONFIG_PM_SLEEP
  268         bool unified = fw_has_capa(&mvm->fw->ucode_capa,
  269                                    IWL_UCODE_TLV_CAPA_CNSLDTD_D3_D0_IMG);
  270 #endif
  271 
  272         /* Tell mac80211 our characteristics */
  273         ieee80211_hw_set(hw, SIGNAL_DBM);
  274         ieee80211_hw_set(hw, SPECTRUM_MGMT);
  275         ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
  276         ieee80211_hw_set(hw, WANT_MONITOR_VIF);
  277         ieee80211_hw_set(hw, SUPPORTS_PS);
  278         ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
  279         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
  280         ieee80211_hw_set(hw, TIMING_BEACON_ONLY);
  281         ieee80211_hw_set(hw, CONNECTION_MONITOR);
  282         ieee80211_hw_set(hw, CHANCTX_STA_CSA);
  283         ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
  284         ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
  285         ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);
  286         ieee80211_hw_set(hw, NEEDS_UNIQUE_STA_ADDR);
  287         ieee80211_hw_set(hw, DEAUTH_NEED_MGD_TX_PREP);
  288         ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW);
  289         ieee80211_hw_set(hw, BUFF_MMPDU_TXQ);
  290         ieee80211_hw_set(hw, STA_MMPDU_TXQ);
  291         /*
  292          * On older devices, enabling TX A-MSDU occasionally leads to
  293          * something getting messed up, the command read from the FIFO
  294          * gets out of sync and isn't a TX command, so that we have an
  295          * assert EDC.
  296          *
  297          * It's not clear where the bug is, but since we didn't used to
  298          * support A-MSDU until moving the mac80211 iTXQs, just leave it
  299          * for older devices. We also don't see this issue on any newer
  300          * devices.
  301          */
  302         if (mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_9000)
  303                 ieee80211_hw_set(hw, TX_AMSDU);
  304         ieee80211_hw_set(hw, TX_FRAG_LIST);
  305 
  306         if (iwl_mvm_has_tlc_offload(mvm)) {
  307                 ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
  308                 ieee80211_hw_set(hw, HAS_RATE_CONTROL);
  309         }
  310 
  311         if (iwl_mvm_has_new_rx_api(mvm))
  312                 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER);
  313 
  314         if (fw_has_capa(&mvm->fw->ucode_capa,
  315                         IWL_UCODE_TLV_CAPA_STA_PM_NOTIF)) {
  316                 ieee80211_hw_set(hw, AP_LINK_PS);
  317         } else if (WARN_ON(iwl_mvm_has_new_tx_api(mvm))) {
  318                 /*
  319                  * we absolutely need this for the new TX API since that comes
  320                  * with many more queues than the current code can deal with
  321                  * for station powersave
  322                  */
  323                 return -EINVAL;
  324         }
  325 
  326         if (mvm->trans->num_rx_queues > 1)
  327                 ieee80211_hw_set(hw, USES_RSS);
  328 
  329         if (mvm->trans->max_skb_frags)
  330                 hw->netdev_features = NETIF_F_HIGHDMA | NETIF_F_SG;
  331 
  332         hw->queues = IEEE80211_NUM_ACS;
  333         hw->offchannel_tx_hw_queue = IWL_MVM_OFFCHANNEL_QUEUE;
  334         hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC |
  335                                     IEEE80211_RADIOTAP_MCS_HAVE_STBC;
  336         hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC |
  337                 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED;
  338 
  339         hw->radiotap_timestamp.units_pos =
  340                 IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US |
  341                 IEEE80211_RADIOTAP_TIMESTAMP_SPOS_PLCP_SIG_ACQ;
  342         /* this is the case for CCK frames, it's better (only 8) for OFDM */
  343         hw->radiotap_timestamp.accuracy = 22;
  344 
  345         if (!iwl_mvm_has_tlc_offload(mvm))
  346                 hw->rate_control_algorithm = RS_NAME;
  347 
  348         hw->uapsd_queues = IWL_MVM_UAPSD_QUEUES;
  349         hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
  350         hw->max_tx_fragments = mvm->trans->max_skb_frags;
  351 
  352         BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 6);
  353         memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
  354         hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
  355         hw->wiphy->cipher_suites = mvm->ciphers;
  356 
  357         if (iwl_mvm_has_new_rx_api(mvm)) {
  358                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
  359                         WLAN_CIPHER_SUITE_GCMP;
  360                 hw->wiphy->n_cipher_suites++;
  361                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
  362                         WLAN_CIPHER_SUITE_GCMP_256;
  363                 hw->wiphy->n_cipher_suites++;
  364         }
  365 
  366         if (iwlwifi_mod_params.swcrypto)
  367                 IWL_ERR(mvm,
  368                         "iwlmvm doesn't allow to disable HW crypto, check swcrypto module parameter\n");
  369         if (!iwlwifi_mod_params.bt_coex_active)
  370                 IWL_ERR(mvm,
  371                         "iwlmvm doesn't allow to disable BT Coex, check bt_coex_active module parameter\n");
  372 
  373         ieee80211_hw_set(hw, MFP_CAPABLE);
  374         mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_AES_CMAC;
  375         hw->wiphy->n_cipher_suites++;
  376         if (iwl_mvm_has_new_rx_api(mvm)) {
  377                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
  378                         WLAN_CIPHER_SUITE_BIP_GMAC_128;
  379                 hw->wiphy->n_cipher_suites++;
  380                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
  381                         WLAN_CIPHER_SUITE_BIP_GMAC_256;
  382                 hw->wiphy->n_cipher_suites++;
  383         }
  384 
  385         if (fw_has_capa(&mvm->fw->ucode_capa,
  386                         IWL_UCODE_TLV_CAPA_FTM_CALIBRATED)) {
  387                 wiphy_ext_feature_set(hw->wiphy,
  388                                       NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
  389                 hw->wiphy->pmsr_capa = &iwl_mvm_pmsr_capa;
  390         }
  391 
  392         if (fw_has_capa(&mvm->fw->ucode_capa,
  393                         IWL_UCODE_TLV_CAPA_BIGTK_SUPPORT))
  394                 wiphy_ext_feature_set(hw->wiphy,
  395                                       NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT);
  396 
  397         ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
  398         hw->wiphy->features |=
  399                 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
  400                 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR |
  401                 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
  402 
  403         hw->sta_data_size = sizeof(struct iwl_mvm_sta);
  404         hw->vif_data_size = sizeof(struct iwl_mvm_vif);
  405         hw->chanctx_data_size = sizeof(u16);
  406         hw->txq_data_size = sizeof(struct iwl_mvm_txq);
  407 
  408         hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
  409                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
  410                 BIT(NL80211_IFTYPE_AP) |
  411                 BIT(NL80211_IFTYPE_P2P_GO) |
  412                 BIT(NL80211_IFTYPE_P2P_DEVICE) |
  413                 BIT(NL80211_IFTYPE_ADHOC);
  414 
  415         hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
  416         wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
  417 
  418         /* The new Tx API does not allow to pass the key or keyid of a MPDU to
  419          * the hw, preventing us to control which key(id) to use per MPDU.
  420          * Till that's fixed we can't use Extended Key ID for the newer cards.
  421          */
  422         if (!iwl_mvm_has_new_tx_api(mvm))
  423                 wiphy_ext_feature_set(hw->wiphy,
  424                                       NL80211_EXT_FEATURE_EXT_KEY_ID);
  425         hw->wiphy->features |= NL80211_FEATURE_HT_IBSS;
  426 
  427         hw->wiphy->regulatory_flags |= REGULATORY_ENABLE_RELAX_NO_IR;
  428         if (iwl_mvm_is_lar_supported(mvm))
  429                 hw->wiphy->regulatory_flags |= REGULATORY_WIPHY_SELF_MANAGED;
  430         else
  431                 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
  432                                                REGULATORY_DISABLE_BEACON_HINTS;
  433 
  434         hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
  435         hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
  436         hw->wiphy->flags |= WIPHY_FLAG_SPLIT_SCAN_6GHZ;
  437 
  438         hw->wiphy->iface_combinations = iwl_mvm_iface_combinations;
  439         hw->wiphy->n_iface_combinations =
  440                 ARRAY_SIZE(iwl_mvm_iface_combinations);
  441 
  442         hw->wiphy->max_remain_on_channel_duration = 10000;
  443         hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
  444 
  445         /* Extract MAC address */
  446         memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);
  447         hw->wiphy->addresses = mvm->addresses;
  448         hw->wiphy->n_addresses = 1;
  449 
  450         /* Extract additional MAC addresses if available */
  451         num_mac = (mvm->nvm_data->n_hw_addrs > 1) ?
  452                 min(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;
  453 
  454         for (i = 1; i < num_mac; i++) {
  455                 memcpy(mvm->addresses[i].addr, mvm->addresses[i-1].addr,
  456                        ETH_ALEN);
  457                 mvm->addresses[i].addr[5]++;
  458                 hw->wiphy->n_addresses++;
  459         }
  460 
  461         iwl_mvm_reset_phy_ctxts(mvm);
  462 
  463         hw->wiphy->max_scan_ie_len = iwl_mvm_max_scan_ie_len(mvm);
  464 
  465         hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
  466 
  467         BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
  468         BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK) ||
  469                      IWL_MVM_MAX_LMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK));
  470 
  471         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
  472                 mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
  473         else
  474                 mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
  475 
  476         if (mvm->nvm_data->bands[NL80211_BAND_2GHZ].n_channels)
  477                 hw->wiphy->bands[NL80211_BAND_2GHZ] =
  478                         &mvm->nvm_data->bands[NL80211_BAND_2GHZ];
  479         if (mvm->nvm_data->bands[NL80211_BAND_5GHZ].n_channels) {
  480                 hw->wiphy->bands[NL80211_BAND_5GHZ] =
  481                         &mvm->nvm_data->bands[NL80211_BAND_5GHZ];
  482 
  483                 if (fw_has_capa(&mvm->fw->ucode_capa,
  484                                 IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
  485                     fw_has_api(&mvm->fw->ucode_capa,
  486                                IWL_UCODE_TLV_API_LQ_SS_PARAMS))
  487                         hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.cap |=
  488                                 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
  489         }
  490         if (fw_has_capa(&mvm->fw->ucode_capa,
  491                         IWL_UCODE_TLV_CAPA_PSC_CHAN_SUPPORT) &&
  492             mvm->nvm_data->bands[NL80211_BAND_6GHZ].n_channels)
  493                 hw->wiphy->bands[NL80211_BAND_6GHZ] =
  494                         &mvm->nvm_data->bands[NL80211_BAND_6GHZ];
  495 
  496         hw->wiphy->hw_version = mvm->trans->hw_id;
  497 
  498         if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
  499                 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
  500         else
  501                 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
  502 
  503         hw->wiphy->max_sched_scan_reqs = 1;
  504         hw->wiphy->max_sched_scan_ssids = PROBE_OPTION_MAX;
  505         hw->wiphy->max_match_sets = iwl_umac_scan_get_max_profiles(mvm->fw);
  506         /* we create the 802.11 header and zero length SSID IE. */
  507         hw->wiphy->max_sched_scan_ie_len =
  508                 SCAN_OFFLOAD_PROBE_REQ_SIZE - 24 - 2;
  509         hw->wiphy->max_sched_scan_plans = IWL_MAX_SCHED_SCAN_PLANS;
  510         hw->wiphy->max_sched_scan_plan_interval = U16_MAX;
  511 
  512         /*
  513          * the firmware uses u8 for num of iterations, but 0xff is saved for
  514          * infinite loop, so the maximum number of iterations is actually 254.
  515          */
  516         hw->wiphy->max_sched_scan_plan_iterations = 254;
  517 
  518         hw->wiphy->features |= NL80211_FEATURE_P2P_GO_CTWIN |
  519                                NL80211_FEATURE_LOW_PRIORITY_SCAN |
  520                                NL80211_FEATURE_P2P_GO_OPPPS |
  521                                NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
  522                                NL80211_FEATURE_DYNAMIC_SMPS |
  523                                NL80211_FEATURE_STATIC_SMPS |
  524                                NL80211_FEATURE_SUPPORTS_WMM_ADMISSION;
  525 
  526         if (fw_has_capa(&mvm->fw->ucode_capa,
  527                         IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT))
  528                 hw->wiphy->features |= NL80211_FEATURE_TX_POWER_INSERTION;
  529         if (fw_has_capa(&mvm->fw->ucode_capa,
  530                         IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT))
  531                 hw->wiphy->features |= NL80211_FEATURE_QUIET;
  532 
  533         if (fw_has_capa(&mvm->fw->ucode_capa,
  534                         IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
  535                 hw->wiphy->features |=
  536                         NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES;
  537 
  538         if (fw_has_capa(&mvm->fw->ucode_capa,
  539                         IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT))
  540                 hw->wiphy->features |= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES;
  541 
  542         if (iwl_fw_lookup_cmd_ver(mvm->fw, WOWLAN_KEK_KCK_MATERIAL,
  543                                   IWL_FW_CMD_VER_UNKNOWN) == 3)
  544                 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK;
  545 
  546         if (fw_has_api(&mvm->fw->ucode_capa,
  547                        IWL_UCODE_TLV_API_SCAN_TSF_REPORT)) {
  548                 wiphy_ext_feature_set(hw->wiphy,
  549                                       NL80211_EXT_FEATURE_SCAN_START_TIME);
  550                 wiphy_ext_feature_set(hw->wiphy,
  551                                       NL80211_EXT_FEATURE_BSS_PARENT_TSF);
  552         }
  553 
  554         if (iwl_mvm_is_oce_supported(mvm)) {
  555                 u8 scan_ver = iwl_fw_lookup_cmd_ver(mvm->fw, SCAN_REQ_UMAC, 0);
  556 
  557                 wiphy_ext_feature_set(hw->wiphy,
  558                         NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP);
  559                 wiphy_ext_feature_set(hw->wiphy,
  560                         NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME);
  561                 wiphy_ext_feature_set(hw->wiphy,
  562                         NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE);
  563 
  564                 /* Old firmware also supports probe deferral and suppression */
  565                 if (scan_ver < 15)
  566                         wiphy_ext_feature_set(hw->wiphy,
  567                                               NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION);
  568         }
  569 
  570         if (mvm->nvm_data->sku_cap_11ax_enable &&
  571             !iwlwifi_mod_params.disable_11ax) {
  572                 hw->wiphy->iftype_ext_capab = he_iftypes_ext_capa;
  573                 hw->wiphy->num_iftype_ext_capab =
  574                         ARRAY_SIZE(he_iftypes_ext_capa);
  575 
  576                 ieee80211_hw_set(hw, SUPPORTS_MULTI_BSSID);
  577                 ieee80211_hw_set(hw, SUPPORTS_ONLY_HE_MULTI_BSSID);
  578         }
  579 
  580         mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
  581 
  582 #ifdef CONFIG_PM_SLEEP
  583         if ((unified || mvm->fw->img[IWL_UCODE_WOWLAN].num_sec) &&
  584             mvm->trans->ops->d3_suspend &&
  585             mvm->trans->ops->d3_resume &&
  586             device_can_wakeup(mvm->trans->dev)) {
  587                 mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT |
  588                                      WIPHY_WOWLAN_DISCONNECT |
  589                                      WIPHY_WOWLAN_EAP_IDENTITY_REQ |
  590                                      WIPHY_WOWLAN_RFKILL_RELEASE |
  591                                      WIPHY_WOWLAN_NET_DETECT;
  592                 mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
  593                                      WIPHY_WOWLAN_GTK_REKEY_FAILURE |
  594                                      WIPHY_WOWLAN_4WAY_HANDSHAKE;
  595 
  596                 mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
  597                 mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
  598                 mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
  599                 mvm->wowlan.max_nd_match_sets =
  600                         iwl_umac_scan_get_max_profiles(mvm->fw);
  601                 hw->wiphy->wowlan = &mvm->wowlan;
  602         }
  603 #endif
  604 
  605         ret = iwl_mvm_leds_init(mvm);
  606         if (ret)
  607                 return ret;
  608 
  609         if (fw_has_capa(&mvm->fw->ucode_capa,
  610                         IWL_UCODE_TLV_CAPA_TDLS_SUPPORT)) {
  611                 IWL_DEBUG_TDLS(mvm, "TDLS supported\n");
  612                 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
  613                 ieee80211_hw_set(hw, TDLS_WIDER_BW);
  614         }
  615 
  616         if (fw_has_capa(&mvm->fw->ucode_capa,
  617                         IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH)) {
  618                 IWL_DEBUG_TDLS(mvm, "TDLS channel switch supported\n");
  619                 hw->wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
  620         }
  621 
  622         hw->netdev_features |= mvm->cfg->features;
  623         if (!iwl_mvm_is_csum_supported(mvm))
  624                 hw->netdev_features &= ~IWL_CSUM_NETIF_FLAGS_MASK;
  625 
  626         if (mvm->cfg->vht_mu_mimo_supported)
  627                 wiphy_ext_feature_set(hw->wiphy,
  628                                       NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER);
  629 
  630         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_PROTECTED_TWT))
  631                 wiphy_ext_feature_set(hw->wiphy,
  632                                       NL80211_EXT_FEATURE_PROTECTED_TWT);
  633 
  634         iwl_mvm_vendor_cmds_register(mvm);
  635 
  636         hw->wiphy->available_antennas_tx = iwl_mvm_get_valid_tx_ant(mvm);
  637         hw->wiphy->available_antennas_rx = iwl_mvm_get_valid_rx_ant(mvm);
  638 
  639         ret = ieee80211_register_hw(mvm->hw);
  640         if (ret) {
  641                 iwl_mvm_leds_exit(mvm);
  642         }
  643 
  644         return ret;
  645 }
  646 
  647 static void iwl_mvm_tx_skb(struct iwl_mvm *mvm, struct sk_buff *skb,
  648                            struct ieee80211_sta *sta)
  649 {
  650         if (likely(sta)) {
  651                 if (likely(iwl_mvm_tx_skb_sta(mvm, skb, sta) == 0))
  652                         return;
  653         } else {
  654                 if (likely(iwl_mvm_tx_skb_non_sta(mvm, skb) == 0))
  655                         return;
  656         }
  657 
  658         ieee80211_free_txskb(mvm->hw, skb);
  659 }
  660 
  661 static void iwl_mvm_mac_tx(struct ieee80211_hw *hw,
  662                            struct ieee80211_tx_control *control,
  663                            struct sk_buff *skb)
  664 {
  665         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  666         struct ieee80211_sta *sta = control->sta;
  667         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  668         struct ieee80211_hdr *hdr = (void *)skb->data;
  669         bool offchannel = IEEE80211_SKB_CB(skb)->flags &
  670                 IEEE80211_TX_CTL_TX_OFFCHAN;
  671 
  672         if (iwl_mvm_is_radio_killed(mvm)) {
  673                 IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
  674                 goto drop;
  675         }
  676 
  677         if (offchannel &&
  678             !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
  679             !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status))
  680                 goto drop;
  681 
  682         /*
  683          * bufferable MMPDUs or MMPDUs on STA interfaces come via TXQs
  684          * so we treat the others as broadcast
  685          */
  686         if (ieee80211_is_mgmt(hdr->frame_control))
  687                 sta = NULL;
  688 
  689         /* If there is no sta, and it's not offchannel - send through AP */
  690         if (!sta && info->control.vif->type == NL80211_IFTYPE_STATION &&
  691             !offchannel) {
  692                 struct iwl_mvm_vif *mvmvif =
  693                         iwl_mvm_vif_from_mac80211(info->control.vif);
  694                 u8 ap_sta_id = READ_ONCE(mvmvif->ap_sta_id);
  695 
  696                 if (ap_sta_id < mvm->fw->ucode_capa.num_stations) {
  697                         /* mac80211 holds rcu read lock */
  698                         sta = rcu_dereference(mvm->fw_id_to_mac_id[ap_sta_id]);
  699                         if (IS_ERR_OR_NULL(sta))
  700                                 goto drop;
  701                 }
  702         }
  703 
  704         iwl_mvm_tx_skb(mvm, skb, sta);
  705         return;
  706  drop:
  707         ieee80211_free_txskb(hw, skb);
  708 }
  709 
  710 void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
  711 {
  712         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  713         struct iwl_mvm_txq *mvmtxq = iwl_mvm_txq_from_mac80211(txq);
  714         struct sk_buff *skb = NULL;
  715 
  716         /*
  717          * No need for threads to be pending here, they can leave the first
  718          * taker all the work.
  719          *
  720          * mvmtxq->tx_request logic:
  721          *
  722          * If 0, no one is currently TXing, set to 1 to indicate current thread
  723          * will now start TX and other threads should quit.
  724          *
  725          * If 1, another thread is currently TXing, set to 2 to indicate to
  726          * that thread that there was another request. Since that request may
  727          * have raced with the check whether the queue is empty, the TXing
  728          * thread should check the queue's status one more time before leaving.
  729          * This check is done in order to not leave any TX hanging in the queue
  730          * until the next TX invocation (which may not even happen).
  731          *
  732          * If 2, another thread is currently TXing, and it will already double
  733          * check the queue, so do nothing.
  734          */
  735         if (atomic_fetch_add_unless(&mvmtxq->tx_request, 1, 2))
  736                 return;
  737 
  738         rcu_read_lock();
  739         do {
  740                 while (likely(!mvmtxq->stopped &&
  741                               !test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status))) {
  742                         skb = ieee80211_tx_dequeue(hw, txq);
  743 
  744                         if (!skb) {
  745                                 if (txq->sta)
  746                                         IWL_DEBUG_TX(mvm,
  747                                                      "TXQ of sta %pM tid %d is now empty\n",
  748                                                      txq->sta->addr,
  749                                                      txq->tid);
  750                                 break;
  751                         }
  752 
  753                         iwl_mvm_tx_skb(mvm, skb, txq->sta);
  754                 }
  755         } while (atomic_dec_return(&mvmtxq->tx_request));
  756         rcu_read_unlock();
  757 }
  758 
  759 static void iwl_mvm_mac_wake_tx_queue(struct ieee80211_hw *hw,
  760                                       struct ieee80211_txq *txq)
  761 {
  762         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  763         struct iwl_mvm_txq *mvmtxq = iwl_mvm_txq_from_mac80211(txq);
  764 
  765         /*
  766          * Please note that racing is handled very carefully here:
  767          * mvmtxq->txq_id is updated during allocation, and mvmtxq->list is
  768          * deleted afterwards.
  769          * This means that if:
  770          * mvmtxq->txq_id != INVALID_QUEUE && list_empty(&mvmtxq->list):
  771          *      queue is allocated and we can TX.
  772          * mvmtxq->txq_id != INVALID_QUEUE && !list_empty(&mvmtxq->list):
  773          *      a race, should defer the frame.
  774          * mvmtxq->txq_id == INVALID_QUEUE && list_empty(&mvmtxq->list):
  775          *      need to allocate the queue and defer the frame.
  776          * mvmtxq->txq_id == INVALID_QUEUE && !list_empty(&mvmtxq->list):
  777          *      queue is already scheduled for allocation, no need to allocate,
  778          *      should defer the frame.
  779          */
  780 
  781         /* If the queue is allocated TX and return. */
  782         if (!txq->sta || mvmtxq->txq_id != IWL_MVM_INVALID_QUEUE) {
  783                 /*
  784                  * Check that list is empty to avoid a race where txq_id is
  785                  * already updated, but the queue allocation work wasn't
  786                  * finished
  787                  */
  788                 if (unlikely(txq->sta && !list_empty(&mvmtxq->list)))
  789                         return;
  790 
  791                 iwl_mvm_mac_itxq_xmit(hw, txq);
  792                 return;
  793         }
  794 
  795         /* The list is being deleted only after the queue is fully allocated. */
  796         if (!list_empty(&mvmtxq->list))
  797                 return;
  798 
  799         list_add_tail(&mvmtxq->list, &mvm->add_stream_txqs);
  800         schedule_work(&mvm->add_stream_wk);
  801 }
  802 
  803 #define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...)           \
  804         do {                                                            \
  805                 if (!(le16_to_cpu(_tid_bm) & BIT(_tid)))                \
  806                         break;                                          \
  807                 iwl_fw_dbg_collect_trig(&(_mvm)->fwrt, _trig, _fmt);    \
  808         } while (0)
  809 
  810 static void
  811 iwl_mvm_ampdu_check_trigger(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
  812                             struct ieee80211_sta *sta, u16 tid, u16 rx_ba_ssn,
  813                             enum ieee80211_ampdu_mlme_action action)
  814 {
  815         struct iwl_fw_dbg_trigger_tlv *trig;
  816         struct iwl_fw_dbg_trigger_ba *ba_trig;
  817 
  818         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
  819                                      FW_DBG_TRIGGER_BA);
  820         if (!trig)
  821                 return;
  822 
  823         ba_trig = (void *)trig->data;
  824 
  825         switch (action) {
  826         case IEEE80211_AMPDU_TX_OPERATIONAL: {
  827                 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
  828                 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
  829 
  830                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
  831                                  "TX AGG START: MAC %pM tid %d ssn %d\n",
  832                                  sta->addr, tid, tid_data->ssn);
  833                 break;
  834                 }
  835         case IEEE80211_AMPDU_TX_STOP_CONT:
  836                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid,
  837                                  "TX AGG STOP: MAC %pM tid %d\n",
  838                                  sta->addr, tid);
  839                 break;
  840         case IEEE80211_AMPDU_RX_START:
  841                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
  842                                  "RX AGG START: MAC %pM tid %d ssn %d\n",
  843                                  sta->addr, tid, rx_ba_ssn);
  844                 break;
  845         case IEEE80211_AMPDU_RX_STOP:
  846                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid,
  847                                  "RX AGG STOP: MAC %pM tid %d\n",
  848                                  sta->addr, tid);
  849                 break;
  850         default:
  851                 break;
  852         }
  853 }
  854 
  855 static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw *hw,
  856                                     struct ieee80211_vif *vif,
  857                                     struct ieee80211_ampdu_params *params)
  858 {
  859         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
  860         int ret;
  861         struct ieee80211_sta *sta = params->sta;
  862         enum ieee80211_ampdu_mlme_action action = params->action;
  863         u16 tid = params->tid;
  864         u16 *ssn = &params->ssn;
  865         u16 buf_size = params->buf_size;
  866         bool amsdu = params->amsdu;
  867         u16 timeout = params->timeout;
  868 
  869         IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n",
  870                      sta->addr, tid, action);
  871 
  872         if (!(mvm->nvm_data->sku_cap_11n_enable))
  873                 return -EACCES;
  874 
  875         mutex_lock(&mvm->mutex);
  876 
  877         switch (action) {
  878         case IEEE80211_AMPDU_RX_START:
  879                 if (iwl_mvm_vif_from_mac80211(vif)->ap_sta_id ==
  880                                 iwl_mvm_sta_from_mac80211(sta)->sta_id) {
  881                         struct iwl_mvm_vif *mvmvif;
  882                         u16 macid = iwl_mvm_vif_from_mac80211(vif)->id;
  883                         struct iwl_mvm_tcm_mac *mdata = &mvm->tcm.data[macid];
  884 
  885                         mdata->opened_rx_ba_sessions = true;
  886                         mvmvif = iwl_mvm_vif_from_mac80211(vif);
  887                         cancel_delayed_work(&mvmvif->uapsd_nonagg_detected_wk);
  888                 }
  889                 if (!iwl_enable_rx_ampdu()) {
  890                         ret = -EINVAL;
  891                         break;
  892                 }
  893                 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true, buf_size,
  894                                          timeout);
  895                 break;
  896         case IEEE80211_AMPDU_RX_STOP:
  897                 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false, buf_size,
  898                                          timeout);
  899                 break;
  900         case IEEE80211_AMPDU_TX_START:
  901                 if (!iwl_enable_tx_ampdu()) {
  902                         ret = -EINVAL;
  903                         break;
  904                 }
  905                 ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
  906                 break;
  907         case IEEE80211_AMPDU_TX_STOP_CONT:
  908                 ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
  909                 break;
  910         case IEEE80211_AMPDU_TX_STOP_FLUSH:
  911         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
  912                 ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
  913                 break;
  914         case IEEE80211_AMPDU_TX_OPERATIONAL:
  915                 ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid,
  916                                               buf_size, amsdu);
  917                 break;
  918         default:
  919                 WARN_ON_ONCE(1);
  920                 ret = -EINVAL;
  921                 break;
  922         }
  923 
  924         if (!ret) {
  925                 u16 rx_ba_ssn = 0;
  926 
  927                 if (action == IEEE80211_AMPDU_RX_START)
  928                         rx_ba_ssn = *ssn;
  929 
  930                 iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid,
  931                                             rx_ba_ssn, action);
  932         }
  933         mutex_unlock(&mvm->mutex);
  934 
  935         return ret;
  936 }
  937 
  938 static void iwl_mvm_cleanup_iterator(void *data, u8 *mac,
  939                                      struct ieee80211_vif *vif)
  940 {
  941         struct iwl_mvm *mvm = data;
  942         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
  943 
  944         mvmvif->uploaded = false;
  945         mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
  946 
  947         spin_lock_bh(&mvm->time_event_lock);
  948         iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
  949         spin_unlock_bh(&mvm->time_event_lock);
  950 
  951         mvmvif->phy_ctxt = NULL;
  952         memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
  953         memset(&mvmvif->probe_resp_data, 0, sizeof(mvmvif->probe_resp_data));
  954 }
  955 
  956 static void iwl_mvm_restart_cleanup(struct iwl_mvm *mvm)
  957 {
  958         iwl_mvm_stop_device(mvm);
  959 
  960         mvm->cur_aid = 0;
  961 
  962         mvm->scan_status = 0;
  963         mvm->ps_disabled = false;
  964         mvm->rfkill_safe_init_done = false;
  965 
  966         /* just in case one was running */
  967         iwl_mvm_cleanup_roc_te(mvm);
  968         ieee80211_remain_on_channel_expired(mvm->hw);
  969 
  970         iwl_mvm_ftm_restart(mvm);
  971 
  972         /*
  973          * cleanup all interfaces, even inactive ones, as some might have
  974          * gone down during the HW restart
  975          */
  976         ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
  977 
  978         mvm->p2p_device_vif = NULL;
  979 
  980         iwl_mvm_reset_phy_ctxts(mvm);
  981         memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));
  982         memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
  983         memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
  984 
  985         ieee80211_wake_queues(mvm->hw);
  986 
  987         mvm->vif_count = 0;
  988         mvm->rx_ba_sessions = 0;
  989         mvm->fwrt.dump.conf = FW_DBG_INVALID;
  990         mvm->monitor_on = false;
  991 
  992         /* keep statistics ticking */
  993         iwl_mvm_accu_radio_stats(mvm);
  994 }
  995 
  996 int __iwl_mvm_mac_start(struct iwl_mvm *mvm)
  997 {
  998         int ret;
  999 
 1000         lockdep_assert_held(&mvm->mutex);
 1001 
 1002         ret = iwl_mvm_mei_get_ownership(mvm);
 1003         if (ret)
 1004                 return ret;
 1005 
 1006         if (mvm->mei_nvm_data) {
 1007                 /* We got the NIC, we can now free the MEI NVM data */
 1008                 kfree(mvm->mei_nvm_data);
 1009                 mvm->mei_nvm_data = NULL;
 1010 
 1011                 /*
 1012                  * We can't free the nvm_data we allocated based on the SAP
 1013                  * data because we registered to cfg80211 with the channels
 1014                  * allocated on mvm->nvm_data. Keep a pointer in temp_nvm_data
 1015                  * just in order to be able free it later.
 1016                  * NULLify nvm_data so that we will read the NVM from the
 1017                  * firmware this time.
 1018                  */
 1019                 mvm->temp_nvm_data = mvm->nvm_data;
 1020                 mvm->nvm_data = NULL;
 1021         }
 1022 
 1023         if (test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status)) {
 1024                 /*
 1025                  * Now convert the HW_RESTART_REQUESTED flag to IN_HW_RESTART
 1026                  * so later code will - from now on - see that we're doing it.
 1027                  */
 1028                 set_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
 1029                 clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status);
 1030                 /* Clean up some internal and mac80211 state on restart */
 1031                 iwl_mvm_restart_cleanup(mvm);
 1032         }
 1033         ret = iwl_mvm_up(mvm);
 1034 
 1035         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_POST_INIT,
 1036                                NULL);
 1037         iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_PERIODIC,
 1038                                NULL);
 1039 
 1040         mvm->last_reset_or_resume_time_jiffies = jiffies;
 1041 
 1042         if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
 1043                 /* Something went wrong - we need to finish some cleanup
 1044                  * that normally iwl_mvm_mac_restart_complete() below
 1045                  * would do.
 1046                  */
 1047                 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
 1048         }
 1049 
 1050         return ret;
 1051 }
 1052 
 1053 static int iwl_mvm_mac_start(struct ieee80211_hw *hw)
 1054 {
 1055         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1056         int ret;
 1057         int retry, max_retry = 0;
 1058 
 1059         mutex_lock(&mvm->mutex);
 1060 
 1061         /* we are starting the mac not in error flow, and restart is enabled */
 1062         if (!test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status) &&
 1063             iwlwifi_mod_params.fw_restart) {
 1064                 max_retry = IWL_MAX_INIT_RETRY;
 1065                 /*
 1066                  * This will prevent mac80211 recovery flows to trigger during
 1067                  * init failures
 1068                  */
 1069                 set_bit(IWL_MVM_STATUS_STARTING, &mvm->status);
 1070         }
 1071 
 1072         for (retry = 0; retry <= max_retry; retry++) {
 1073                 ret = __iwl_mvm_mac_start(mvm);
 1074                 if (!ret)
 1075                         break;
 1076 
 1077                 IWL_ERR(mvm, "mac start retry %d\n", retry);
 1078         }
 1079         clear_bit(IWL_MVM_STATUS_STARTING, &mvm->status);
 1080 
 1081         mutex_unlock(&mvm->mutex);
 1082 
 1083         iwl_mvm_mei_set_sw_rfkill_state(mvm);
 1084 
 1085         return ret;
 1086 }
 1087 
 1088 static void iwl_mvm_restart_complete(struct iwl_mvm *mvm)
 1089 {
 1090         int ret;
 1091 
 1092         mutex_lock(&mvm->mutex);
 1093 
 1094         clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
 1095 
 1096         ret = iwl_mvm_update_quotas(mvm, true, NULL);
 1097         if (ret)
 1098                 IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n",
 1099                         ret);
 1100 
 1101         iwl_mvm_send_recovery_cmd(mvm, ERROR_RECOVERY_END_OF_RECOVERY);
 1102 
 1103         /*
 1104          * If we have TDLS peers, remove them. We don't know the last seqno/PN
 1105          * of packets the FW sent out, so we must reconnect.
 1106          */
 1107         iwl_mvm_teardown_tdls_peers(mvm);
 1108 
 1109         mutex_unlock(&mvm->mutex);
 1110 }
 1111 
 1112 static void
 1113 iwl_mvm_mac_reconfig_complete(struct ieee80211_hw *hw,
 1114                               enum ieee80211_reconfig_type reconfig_type)
 1115 {
 1116         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1117 
 1118         switch (reconfig_type) {
 1119         case IEEE80211_RECONFIG_TYPE_RESTART:
 1120                 iwl_mvm_restart_complete(mvm);
 1121                 break;
 1122         case IEEE80211_RECONFIG_TYPE_SUSPEND:
 1123                 break;
 1124         }
 1125 }
 1126 
 1127 void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)
 1128 {
 1129         lockdep_assert_held(&mvm->mutex);
 1130 
 1131         iwl_mvm_ftm_initiator_smooth_stop(mvm);
 1132 
 1133         /* firmware counters are obviously reset now, but we shouldn't
 1134          * partially track so also clear the fw_reset_accu counters.
 1135          */
 1136         memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));
 1137 
 1138         /* async_handlers_wk is now blocked */
 1139 
 1140         if (iwl_fw_lookup_cmd_ver(mvm->fw, ADD_STA, 0) < 12)
 1141                 iwl_mvm_rm_aux_sta(mvm);
 1142 
 1143         iwl_mvm_stop_device(mvm);
 1144 
 1145         iwl_mvm_async_handlers_purge(mvm);
 1146         /* async_handlers_list is empty and will stay empty: HW is stopped */
 1147 
 1148         /*
 1149          * Clear IN_HW_RESTART and HW_RESTART_REQUESTED flag when stopping the
 1150          * hw (as restart_complete() won't be called in this case) and mac80211
 1151          * won't execute the restart.
 1152          * But make sure to cleanup interfaces that have gone down before/during
 1153          * HW restart was requested.
 1154          */
 1155         if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) ||
 1156             test_and_clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
 1157                                &mvm->status))
 1158                 ieee80211_iterate_interfaces(mvm->hw, 0,
 1159                                              iwl_mvm_cleanup_iterator, mvm);
 1160 
 1161         /* We shouldn't have any UIDs still set.  Loop over all the UIDs to
 1162          * make sure there's nothing left there and warn if any is found.
 1163          */
 1164         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
 1165                 int i;
 1166 
 1167                 for (i = 0; i < mvm->max_scans; i++) {
 1168                         if (WARN_ONCE(mvm->scan_uid_status[i],
 1169                                       "UMAC scan UID %d status was not cleaned\n",
 1170                                       i))
 1171                                 mvm->scan_uid_status[i] = 0;
 1172                 }
 1173         }
 1174 }
 1175 
 1176 static void iwl_mvm_mac_stop(struct ieee80211_hw *hw)
 1177 {
 1178         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1179 
 1180         flush_work(&mvm->async_handlers_wk);
 1181         flush_work(&mvm->add_stream_wk);
 1182 
 1183         /*
 1184          * Lock and clear the firmware running bit here already, so that
 1185          * new commands coming in elsewhere, e.g. from debugfs, will not
 1186          * be able to proceed. This is important here because one of those
 1187          * debugfs files causes the firmware dump to be triggered, and if we
 1188          * don't stop debugfs accesses before canceling that it could be
 1189          * retriggered after we flush it but before we've cleared the bit.
 1190          */
 1191         clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
 1192 
 1193         cancel_delayed_work_sync(&mvm->cs_tx_unblock_dwork);
 1194         cancel_delayed_work_sync(&mvm->scan_timeout_dwork);
 1195 
 1196         /*
 1197          * The work item could be running or queued if the
 1198          * ROC time event stops just as we get here.
 1199          */
 1200         flush_work(&mvm->roc_done_wk);
 1201 
 1202         iwl_mvm_mei_set_sw_rfkill_state(mvm);
 1203 
 1204         mutex_lock(&mvm->mutex);
 1205         __iwl_mvm_mac_stop(mvm);
 1206         mutex_unlock(&mvm->mutex);
 1207 
 1208         /*
 1209          * The worker might have been waiting for the mutex, let it run and
 1210          * discover that its list is now empty.
 1211          */
 1212         cancel_work_sync(&mvm->async_handlers_wk);
 1213 }
 1214 
 1215 static struct iwl_mvm_phy_ctxt *iwl_mvm_get_free_phy_ctxt(struct iwl_mvm *mvm)
 1216 {
 1217         u16 i;
 1218 
 1219         lockdep_assert_held(&mvm->mutex);
 1220 
 1221         for (i = 0; i < NUM_PHY_CTX; i++)
 1222                 if (!mvm->phy_ctxts[i].ref)
 1223                         return &mvm->phy_ctxts[i];
 1224 
 1225         IWL_ERR(mvm, "No available PHY context\n");
 1226         return NULL;
 1227 }
 1228 
 1229 static int iwl_mvm_set_tx_power(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 1230                                 s16 tx_power)
 1231 {
 1232         u32 cmd_id = REDUCE_TX_POWER_CMD;
 1233         int len;
 1234         struct iwl_dev_tx_power_cmd cmd = {
 1235                 .common.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
 1236                 .common.mac_context_id =
 1237                         cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
 1238                 .common.pwr_restriction = cpu_to_le16(8 * tx_power),
 1239         };
 1240         u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
 1241                                            IWL_FW_CMD_VER_UNKNOWN);
 1242 
 1243         if (tx_power == IWL_DEFAULT_MAX_TX_POWER)
 1244                 cmd.common.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
 1245 
 1246         if (cmd_ver == 7)
 1247                 len = sizeof(cmd.v7);
 1248         else if (cmd_ver == 6)
 1249                 len = sizeof(cmd.v6);
 1250         else if (fw_has_api(&mvm->fw->ucode_capa,
 1251                             IWL_UCODE_TLV_API_REDUCE_TX_POWER))
 1252                 len = sizeof(cmd.v5);
 1253         else if (fw_has_capa(&mvm->fw->ucode_capa,
 1254                              IWL_UCODE_TLV_CAPA_TX_POWER_ACK))
 1255                 len = sizeof(cmd.v4);
 1256         else
 1257                 len = sizeof(cmd.v3);
 1258 
 1259         /* all structs have the same common part, add it */
 1260         len += sizeof(cmd.common);
 1261 
 1262         return iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, len, &cmd);
 1263 }
 1264 
 1265 static int iwl_mvm_post_channel_switch(struct ieee80211_hw *hw,
 1266                                        struct ieee80211_vif *vif)
 1267 {
 1268         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 1269         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1270         int ret;
 1271 
 1272         mutex_lock(&mvm->mutex);
 1273 
 1274         if (vif->type == NL80211_IFTYPE_STATION) {
 1275                 struct iwl_mvm_sta *mvmsta;
 1276 
 1277                 mvmvif->csa_bcn_pending = false;
 1278                 mvmsta = iwl_mvm_sta_from_staid_protected(mvm,
 1279                                                           mvmvif->ap_sta_id);
 1280 
 1281                 if (WARN_ON(!mvmsta)) {
 1282                         ret = -EIO;
 1283                         goto out_unlock;
 1284                 }
 1285 
 1286                 iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);
 1287 
 1288                 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 1289 
 1290                 if (!fw_has_capa(&mvm->fw->ucode_capa,
 1291                                  IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD)) {
 1292                         ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
 1293                         if (ret)
 1294                                 goto out_unlock;
 1295 
 1296                         iwl_mvm_stop_session_protection(mvm, vif);
 1297                 }
 1298         }
 1299 
 1300         mvmvif->ps_disabled = false;
 1301 
 1302         ret = iwl_mvm_power_update_ps(mvm);
 1303 
 1304 out_unlock:
 1305         if (mvmvif->csa_failed)
 1306                 ret = -EIO;
 1307         mutex_unlock(&mvm->mutex);
 1308 
 1309         return ret;
 1310 }
 1311 
 1312 static void iwl_mvm_abort_channel_switch(struct ieee80211_hw *hw,
 1313                                          struct ieee80211_vif *vif)
 1314 {
 1315         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1316         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 1317         struct iwl_chan_switch_te_cmd cmd = {
 1318                 .mac_id = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
 1319                                                           mvmvif->color)),
 1320                 .action = cpu_to_le32(FW_CTXT_ACTION_REMOVE),
 1321         };
 1322 
 1323         /*
 1324          * In the new flow since FW is in charge of the timing,
 1325          * if driver has canceled the channel switch he will receive the
 1326          * CHANNEL_SWITCH_START_NOTIF notification from FW and then cancel it
 1327          */
 1328         if (iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP,
 1329                                     CHANNEL_SWITCH_ERROR_NOTIF, 0))
 1330                 return;
 1331 
 1332         IWL_DEBUG_MAC80211(mvm, "Abort CSA on mac %d\n", mvmvif->id);
 1333 
 1334         mutex_lock(&mvm->mutex);
 1335         if (!fw_has_capa(&mvm->fw->ucode_capa,
 1336                          IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD))
 1337                 iwl_mvm_remove_csa_period(mvm, vif);
 1338         else
 1339                 WARN_ON(iwl_mvm_send_cmd_pdu(mvm,
 1340                                              WIDE_ID(MAC_CONF_GROUP,
 1341                                                      CHANNEL_SWITCH_TIME_EVENT_CMD),
 1342                                              0, sizeof(cmd), &cmd));
 1343         mvmvif->csa_failed = true;
 1344         mutex_unlock(&mvm->mutex);
 1345 
 1346         iwl_mvm_post_channel_switch(hw, vif);
 1347 }
 1348 
 1349 static void iwl_mvm_channel_switch_disconnect_wk(struct work_struct *wk)
 1350 {
 1351         struct iwl_mvm_vif *mvmvif;
 1352         struct ieee80211_vif *vif;
 1353 
 1354         mvmvif = container_of(wk, struct iwl_mvm_vif, csa_work.work);
 1355         vif = container_of((void *)mvmvif, struct ieee80211_vif, drv_priv);
 1356 
 1357         /* Trigger disconnect (should clear the CSA state) */
 1358         ieee80211_chswitch_done(vif, false);
 1359 }
 1360 
 1361 static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw,
 1362                                      struct ieee80211_vif *vif)
 1363 {
 1364         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1365         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 1366         int ret;
 1367 
 1368         mvmvif->mvm = mvm;
 1369         RCU_INIT_POINTER(mvmvif->probe_resp_data, NULL);
 1370 
 1371         /*
 1372          * Not much to do here. The stack will not allow interface
 1373          * types or combinations that we didn't advertise, so we
 1374          * don't really have to check the types.
 1375          */
 1376 
 1377         mutex_lock(&mvm->mutex);
 1378 
 1379         /* make sure that beacon statistics don't go backwards with FW reset */
 1380         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
 1381                 mvmvif->beacon_stats.accu_num_beacons +=
 1382                         mvmvif->beacon_stats.num_beacons;
 1383 
 1384         /* Allocate resources for the MAC context, and add it to the fw  */
 1385         ret = iwl_mvm_mac_ctxt_init(mvm, vif);
 1386         if (ret)
 1387                 goto out_unlock;
 1388 
 1389         rcu_assign_pointer(mvm->vif_id_to_mac[mvmvif->id], vif);
 1390 
 1391         /* Counting number of interfaces is needed for legacy PM */
 1392         if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
 1393                 mvm->vif_count++;
 1394 
 1395         /*
 1396          * The AP binding flow can be done only after the beacon
 1397          * template is configured (which happens only in the mac80211
 1398          * start_ap() flow), and adding the broadcast station can happen
 1399          * only after the binding.
 1400          * In addition, since modifying the MAC before adding a bcast
 1401          * station is not allowed by the FW, delay the adding of MAC context to
 1402          * the point where we can also add the bcast station.
 1403          * In short: there's not much we can do at this point, other than
 1404          * allocating resources :)
 1405          */
 1406         if (vif->type == NL80211_IFTYPE_AP ||
 1407             vif->type == NL80211_IFTYPE_ADHOC) {
 1408                 ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
 1409                 if (ret) {
 1410                         IWL_ERR(mvm, "Failed to allocate bcast sta\n");
 1411                         goto out_release;
 1412                 }
 1413 
 1414                 /*
 1415                  * Only queue for this station is the mcast queue,
 1416                  * which shouldn't be in TFD mask anyway
 1417                  */
 1418                 ret = iwl_mvm_allocate_int_sta(mvm, &mvmvif->mcast_sta,
 1419                                                0, vif->type,
 1420                                                IWL_STA_MULTICAST);
 1421                 if (ret)
 1422                         goto out_release;
 1423 
 1424                 iwl_mvm_vif_dbgfs_register(mvm, vif);
 1425                 goto out_unlock;
 1426         }
 1427 
 1428         mvmvif->features |= hw->netdev_features;
 1429 
 1430         ret = iwl_mvm_mac_ctxt_add(mvm, vif);
 1431         if (ret)
 1432                 goto out_release;
 1433 
 1434         ret = iwl_mvm_power_update_mac(mvm);
 1435         if (ret)
 1436                 goto out_remove_mac;
 1437 
 1438         /* beacon filtering */
 1439         ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
 1440         if (ret)
 1441                 goto out_remove_mac;
 1442 
 1443         if (!mvm->bf_allowed_vif &&
 1444             vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
 1445                 mvm->bf_allowed_vif = mvmvif;
 1446                 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
 1447                                      IEEE80211_VIF_SUPPORTS_CQM_RSSI;
 1448         }
 1449 
 1450         /*
 1451          * P2P_DEVICE interface does not have a channel context assigned to it,
 1452          * so a dedicated PHY context is allocated to it and the corresponding
 1453          * MAC context is bound to it at this stage.
 1454          */
 1455         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
 1456 
 1457                 mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
 1458                 if (!mvmvif->phy_ctxt) {
 1459                         ret = -ENOSPC;
 1460                         goto out_free_bf;
 1461                 }
 1462 
 1463                 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
 1464                 ret = iwl_mvm_binding_add_vif(mvm, vif);
 1465                 if (ret)
 1466                         goto out_unref_phy;
 1467 
 1468                 ret = iwl_mvm_add_p2p_bcast_sta(mvm, vif);
 1469                 if (ret)
 1470                         goto out_unbind;
 1471 
 1472                 /* Save a pointer to p2p device vif, so it can later be used to
 1473                  * update the p2p device MAC when a GO is started/stopped */
 1474                 mvm->p2p_device_vif = vif;
 1475         }
 1476 
 1477         iwl_mvm_tcm_add_vif(mvm, vif);
 1478         INIT_DELAYED_WORK(&mvmvif->csa_work,
 1479                           iwl_mvm_channel_switch_disconnect_wk);
 1480 
 1481         if (vif->type == NL80211_IFTYPE_MONITOR)
 1482                 mvm->monitor_on = true;
 1483 
 1484         iwl_mvm_vif_dbgfs_register(mvm, vif);
 1485 
 1486         if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
 1487             vif->type == NL80211_IFTYPE_STATION && !vif->p2p &&
 1488             !mvm->csme_vif && mvm->mei_registered) {
 1489                 iwl_mei_set_nic_info(vif->addr, mvm->nvm_data->hw_addr);
 1490                 iwl_mei_set_netdev(ieee80211_vif_to_wdev(vif)->netdev);
 1491                 mvm->csme_vif = vif;
 1492         }
 1493 
 1494         goto out_unlock;
 1495 
 1496  out_unbind:
 1497         iwl_mvm_binding_remove_vif(mvm, vif);
 1498  out_unref_phy:
 1499         iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
 1500  out_free_bf:
 1501         if (mvm->bf_allowed_vif == mvmvif) {
 1502                 mvm->bf_allowed_vif = NULL;
 1503                 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
 1504                                        IEEE80211_VIF_SUPPORTS_CQM_RSSI);
 1505         }
 1506  out_remove_mac:
 1507         mvmvif->phy_ctxt = NULL;
 1508         iwl_mvm_mac_ctxt_remove(mvm, vif);
 1509  out_release:
 1510         if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
 1511                 mvm->vif_count--;
 1512  out_unlock:
 1513         mutex_unlock(&mvm->mutex);
 1514 
 1515         return ret;
 1516 }
 1517 
 1518 static void iwl_mvm_prepare_mac_removal(struct iwl_mvm *mvm,
 1519                                         struct ieee80211_vif *vif)
 1520 {
 1521         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
 1522                 /*
 1523                  * Flush the ROC worker which will flush the OFFCHANNEL queue.
 1524                  * We assume here that all the packets sent to the OFFCHANNEL
 1525                  * queue are sent in ROC session.
 1526                  */
 1527                 flush_work(&mvm->roc_done_wk);
 1528         }
 1529 }
 1530 
 1531 static void iwl_mvm_mac_remove_interface(struct ieee80211_hw *hw,
 1532                                          struct ieee80211_vif *vif)
 1533 {
 1534         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1535         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 1536         struct iwl_probe_resp_data *probe_data;
 1537 
 1538         iwl_mvm_prepare_mac_removal(mvm, vif);
 1539 
 1540         if (!(vif->type == NL80211_IFTYPE_AP ||
 1541               vif->type == NL80211_IFTYPE_ADHOC))
 1542                 iwl_mvm_tcm_rm_vif(mvm, vif);
 1543 
 1544         mutex_lock(&mvm->mutex);
 1545 
 1546         if (vif == mvm->csme_vif) {
 1547                 iwl_mei_set_netdev(NULL);
 1548                 mvm->csme_vif = NULL;
 1549         }
 1550 
 1551         probe_data = rcu_dereference_protected(mvmvif->probe_resp_data,
 1552                                                lockdep_is_held(&mvm->mutex));
 1553         RCU_INIT_POINTER(mvmvif->probe_resp_data, NULL);
 1554         if (probe_data)
 1555                 kfree_rcu(probe_data, rcu_head);
 1556 
 1557         if (mvm->bf_allowed_vif == mvmvif) {
 1558                 mvm->bf_allowed_vif = NULL;
 1559                 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
 1560                                        IEEE80211_VIF_SUPPORTS_CQM_RSSI);
 1561         }
 1562 
 1563         if (vif->bss_conf.ftm_responder)
 1564                 memset(&mvm->ftm_resp_stats, 0, sizeof(mvm->ftm_resp_stats));
 1565 
 1566         iwl_mvm_vif_dbgfs_clean(mvm, vif);
 1567 
 1568         /*
 1569          * For AP/GO interface, the tear down of the resources allocated to the
 1570          * interface is be handled as part of the stop_ap flow.
 1571          */
 1572         if (vif->type == NL80211_IFTYPE_AP ||
 1573             vif->type == NL80211_IFTYPE_ADHOC) {
 1574 #ifdef CONFIG_NL80211_TESTMODE
 1575                 if (vif == mvm->noa_vif) {
 1576                         mvm->noa_vif = NULL;
 1577                         mvm->noa_duration = 0;
 1578                 }
 1579 #endif
 1580                 iwl_mvm_dealloc_int_sta(mvm, &mvmvif->mcast_sta);
 1581                 iwl_mvm_dealloc_bcast_sta(mvm, vif);
 1582                 goto out_release;
 1583         }
 1584 
 1585         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
 1586                 mvm->p2p_device_vif = NULL;
 1587                 iwl_mvm_rm_p2p_bcast_sta(mvm, vif);
 1588                 iwl_mvm_binding_remove_vif(mvm, vif);
 1589                 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
 1590                 mvmvif->phy_ctxt = NULL;
 1591         }
 1592 
 1593         if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE)
 1594                 mvm->vif_count--;
 1595 
 1596         iwl_mvm_power_update_mac(mvm);
 1597         iwl_mvm_mac_ctxt_remove(mvm, vif);
 1598 
 1599         RCU_INIT_POINTER(mvm->vif_id_to_mac[mvmvif->id], NULL);
 1600 
 1601         if (vif->type == NL80211_IFTYPE_MONITOR)
 1602                 mvm->monitor_on = false;
 1603 
 1604 out_release:
 1605         mutex_unlock(&mvm->mutex);
 1606 }
 1607 
 1608 static int iwl_mvm_mac_config(struct ieee80211_hw *hw, u32 changed)
 1609 {
 1610         return 0;
 1611 }
 1612 
 1613 struct iwl_mvm_mc_iter_data {
 1614         struct iwl_mvm *mvm;
 1615         int port_id;
 1616 };
 1617 
 1618 static void iwl_mvm_mc_iface_iterator(void *_data, u8 *mac,
 1619                                       struct ieee80211_vif *vif)
 1620 {
 1621         struct iwl_mvm_mc_iter_data *data = _data;
 1622         struct iwl_mvm *mvm = data->mvm;
 1623         struct iwl_mcast_filter_cmd *cmd = mvm->mcast_filter_cmd;
 1624         struct iwl_host_cmd hcmd = {
 1625                 .id = MCAST_FILTER_CMD,
 1626                 .flags = CMD_ASYNC,
 1627                 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
 1628         };
 1629         int ret, len;
 1630 
 1631         /* if we don't have free ports, mcast frames will be dropped */
 1632         if (WARN_ON_ONCE(data->port_id >= MAX_PORT_ID_NUM))
 1633                 return;
 1634 
 1635         if (vif->type != NL80211_IFTYPE_STATION ||
 1636             !vif->bss_conf.assoc)
 1637                 return;
 1638 
 1639         cmd->port_id = data->port_id++;
 1640         memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
 1641         len = roundup(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);
 1642 
 1643         hcmd.len[0] = len;
 1644         hcmd.data[0] = cmd;
 1645 
 1646         ret = iwl_mvm_send_cmd(mvm, &hcmd);
 1647         if (ret)
 1648                 IWL_ERR(mvm, "mcast filter cmd error. ret=%d\n", ret);
 1649 }
 1650 
 1651 static void iwl_mvm_recalc_multicast(struct iwl_mvm *mvm)
 1652 {
 1653         struct iwl_mvm_mc_iter_data iter_data = {
 1654                 .mvm = mvm,
 1655         };
 1656         int ret;
 1657 
 1658         lockdep_assert_held(&mvm->mutex);
 1659 
 1660         if (WARN_ON_ONCE(!mvm->mcast_filter_cmd))
 1661                 return;
 1662 
 1663         ieee80211_iterate_active_interfaces_atomic(
 1664                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 1665                 iwl_mvm_mc_iface_iterator, &iter_data);
 1666 
 1667         /*
 1668          * Send a (synchronous) ech command so that we wait for the
 1669          * multiple asynchronous MCAST_FILTER_CMD commands sent by
 1670          * the interface iterator. Otherwise, we might get here over
 1671          * and over again (by userspace just sending a lot of these)
 1672          * and the CPU can send them faster than the firmware can
 1673          * process them.
 1674          * Note that the CPU is still faster - but with this we'll
 1675          * actually send fewer commands overall because the CPU will
 1676          * not schedule the work in mac80211 as frequently if it's
 1677          * still running when rescheduled (possibly multiple times).
 1678          */
 1679         ret = iwl_mvm_send_cmd_pdu(mvm, ECHO_CMD, 0, 0, NULL);
 1680         if (ret)
 1681                 IWL_ERR(mvm, "Failed to synchronize multicast groups update\n");
 1682 }
 1683 
 1684 static u64 iwl_mvm_prepare_multicast(struct ieee80211_hw *hw,
 1685                                      struct netdev_hw_addr_list *mc_list)
 1686 {
 1687         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1688         struct iwl_mcast_filter_cmd *cmd;
 1689         struct netdev_hw_addr *addr;
 1690         int addr_count;
 1691         bool pass_all;
 1692         int len;
 1693 
 1694         addr_count = netdev_hw_addr_list_count(mc_list);
 1695         pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES ||
 1696                    IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
 1697         if (pass_all)
 1698                 addr_count = 0;
 1699 
 1700         len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
 1701         cmd = kzalloc(len, GFP_ATOMIC);
 1702         if (!cmd)
 1703                 return 0;
 1704 
 1705         if (pass_all) {
 1706                 cmd->pass_all = 1;
 1707 #if defined(__linux__)
 1708                 return (u64)(unsigned long)cmd;
 1709 #elif defined(__FreeBSD__)
 1710                 return (u64)(uintptr_t)cmd;
 1711 #endif
 1712         }
 1713 
 1714         netdev_hw_addr_list_for_each(addr, mc_list) {
 1715 #if defined(__linux__)
 1716                 IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n",
 1717                                    cmd->count, addr->addr);
 1718 #elif defined(__FreeBSD__)
 1719                 IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %6D\n",
 1720                                    cmd->count, addr->addr, ":");
 1721 #endif
 1722                 memcpy(&cmd->addr_list[cmd->count * ETH_ALEN],
 1723                        addr->addr, ETH_ALEN);
 1724                 cmd->count++;
 1725         }
 1726 
 1727 #if defined(__linux__)
 1728         return (u64)(unsigned long)cmd;
 1729 #elif defined(__FreeBSD__)
 1730         return (u64)(uintptr_t)cmd;
 1731 #endif
 1732 }
 1733 
 1734 static void iwl_mvm_configure_filter(struct ieee80211_hw *hw,
 1735                                      unsigned int changed_flags,
 1736                                      unsigned int *total_flags,
 1737                                      u64 multicast)
 1738 {
 1739         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1740 #if defined(__linux__)
 1741         struct iwl_mcast_filter_cmd *cmd = (void *)(unsigned long)multicast;
 1742 #elif defined(__FreeBSD__)
 1743         struct iwl_mcast_filter_cmd *cmd = (void *)(uintptr_t)multicast;
 1744 #endif
 1745 
 1746         mutex_lock(&mvm->mutex);
 1747 
 1748         /* replace previous configuration */
 1749         kfree(mvm->mcast_filter_cmd);
 1750         mvm->mcast_filter_cmd = cmd;
 1751 
 1752         if (!cmd)
 1753                 goto out;
 1754 
 1755         if (changed_flags & FIF_ALLMULTI)
 1756                 cmd->pass_all = !!(*total_flags & FIF_ALLMULTI);
 1757 
 1758         if (cmd->pass_all)
 1759                 cmd->count = 0;
 1760 
 1761         iwl_mvm_recalc_multicast(mvm);
 1762 out:
 1763         mutex_unlock(&mvm->mutex);
 1764         *total_flags = 0;
 1765 }
 1766 
 1767 static void iwl_mvm_config_iface_filter(struct ieee80211_hw *hw,
 1768                                         struct ieee80211_vif *vif,
 1769                                         unsigned int filter_flags,
 1770                                         unsigned int changed_flags)
 1771 {
 1772         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 1773 
 1774         /* We support only filter for probe requests */
 1775         if (!(changed_flags & FIF_PROBE_REQ))
 1776                 return;
 1777 
 1778         /* Supported only for p2p client interfaces */
 1779         if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc ||
 1780             !vif->p2p)
 1781                 return;
 1782 
 1783         mutex_lock(&mvm->mutex);
 1784         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 1785         mutex_unlock(&mvm->mutex);
 1786 }
 1787 
 1788 static int iwl_mvm_update_mu_groups(struct iwl_mvm *mvm,
 1789                                     struct ieee80211_vif *vif)
 1790 {
 1791         struct iwl_mu_group_mgmt_cmd cmd = {};
 1792 
 1793         memcpy(cmd.membership_status, vif->bss_conf.mu_group.membership,
 1794                WLAN_MEMBERSHIP_LEN);
 1795         memcpy(cmd.user_position, vif->bss_conf.mu_group.position,
 1796                WLAN_USER_POSITION_LEN);
 1797 
 1798         return iwl_mvm_send_cmd_pdu(mvm,
 1799                                     WIDE_ID(DATA_PATH_GROUP,
 1800                                             UPDATE_MU_GROUPS_CMD),
 1801                                     0, sizeof(cmd), &cmd);
 1802 }
 1803 
 1804 static void iwl_mvm_mu_mimo_iface_iterator(void *_data, u8 *mac,
 1805                                            struct ieee80211_vif *vif)
 1806 {
 1807         if (vif->mu_mimo_owner) {
 1808                 struct iwl_mu_group_mgmt_notif *notif = _data;
 1809 
 1810                 /*
 1811                  * MU-MIMO Group Id action frame is little endian. We treat
 1812                  * the data received from firmware as if it came from the
 1813                  * action frame, so no conversion is needed.
 1814                  */
 1815                 ieee80211_update_mu_groups(vif,
 1816                                            (u8 *)&notif->membership_status,
 1817                                            (u8 *)&notif->user_position);
 1818         }
 1819 }
 1820 
 1821 void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm *mvm,
 1822                                struct iwl_rx_cmd_buffer *rxb)
 1823 {
 1824         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 1825         struct iwl_mu_group_mgmt_notif *notif = (void *)pkt->data;
 1826 
 1827         ieee80211_iterate_active_interfaces_atomic(
 1828                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 1829                         iwl_mvm_mu_mimo_iface_iterator, notif);
 1830 }
 1831 
 1832 static u8 iwl_mvm_he_get_ppe_val(u8 *ppe, u8 ppe_pos_bit)
 1833 {
 1834         u8 byte_num = ppe_pos_bit / 8;
 1835         u8 bit_num = ppe_pos_bit % 8;
 1836         u8 residue_bits;
 1837         u8 res;
 1838 
 1839         if (bit_num <= 5)
 1840                 return (ppe[byte_num] >> bit_num) &
 1841                        (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE) - 1);
 1842 
 1843         /*
 1844          * If bit_num > 5, we have to combine bits with next byte.
 1845          * Calculate how many bits we need to take from current byte (called
 1846          * here "residue_bits"), and add them to bits from next byte.
 1847          */
 1848 
 1849         residue_bits = 8 - bit_num;
 1850 
 1851         res = (ppe[byte_num + 1] &
 1852                (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE - residue_bits) - 1)) <<
 1853               residue_bits;
 1854         res += (ppe[byte_num] >> bit_num) & (BIT(residue_bits) - 1);
 1855 
 1856         return res;
 1857 }
 1858 
 1859 static void iwl_mvm_parse_ppe(struct iwl_mvm *mvm,
 1860                               struct iwl_he_pkt_ext_v2 *pkt_ext, u8 nss,
 1861                               u8 ru_index_bitmap, u8 *ppe, u8 ppe_pos_bit)
 1862 {
 1863         int i;
 1864 
 1865         /*
 1866         * FW currently supports only nss == MAX_HE_SUPP_NSS
 1867         *
 1868         * If nss > MAX: we can ignore values we don't support
 1869         * If nss < MAX: we can set zeros in other streams
 1870         */
 1871         if (nss > MAX_HE_SUPP_NSS) {
 1872                 IWL_INFO(mvm, "Got NSS = %d - trimming to %d\n", nss,
 1873                          MAX_HE_SUPP_NSS);
 1874                 nss = MAX_HE_SUPP_NSS;
 1875         }
 1876 
 1877         for (i = 0; i < nss; i++) {
 1878                 u8 ru_index_tmp = ru_index_bitmap << 1;
 1879                 u8 low_th = IWL_HE_PKT_EXT_NONE, high_th = IWL_HE_PKT_EXT_NONE;
 1880                 u8 bw;
 1881 
 1882                 for (bw = 0;
 1883                      bw < ARRAY_SIZE(pkt_ext->pkt_ext_qam_th[i]);
 1884                      bw++) {
 1885                         ru_index_tmp >>= 1;
 1886 
 1887                         if (!(ru_index_tmp & 1))
 1888                                 continue;
 1889 
 1890                         high_th = iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
 1891                         ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
 1892                         low_th = iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
 1893                         ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
 1894 
 1895                         pkt_ext->pkt_ext_qam_th[i][bw][0] = low_th;
 1896                         pkt_ext->pkt_ext_qam_th[i][bw][1] = high_th;
 1897                 }
 1898         }
 1899 }
 1900 
 1901 static void iwl_mvm_set_pkt_ext_from_he_ppe(struct iwl_mvm *mvm,
 1902                                             struct ieee80211_sta *sta,
 1903                                             struct iwl_he_pkt_ext_v2 *pkt_ext)
 1904 {
 1905         u8 nss = (sta->deflink.he_cap.ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) + 1;
 1906         u8 *ppe = &sta->deflink.he_cap.ppe_thres[0];
 1907         u8 ru_index_bitmap =
 1908                 u8_get_bits(*ppe,
 1909                             IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
 1910         /* Starting after PPE header */
 1911         u8 ppe_pos_bit = IEEE80211_HE_PPE_THRES_INFO_HEADER_SIZE;
 1912 
 1913         iwl_mvm_parse_ppe(mvm, pkt_ext, nss, ru_index_bitmap, ppe, ppe_pos_bit);
 1914 }
 1915 
 1916 static void iwl_mvm_set_pkt_ext_from_nominal_padding(struct iwl_he_pkt_ext_v2 *pkt_ext,
 1917                                                      u8 nominal_padding,
 1918                                                      u32 *flags)
 1919 {
 1920         int low_th = -1;
 1921         int high_th = -1;
 1922         int i;
 1923 
 1924         switch (nominal_padding) {
 1925         case IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_0US:
 1926                 low_th = IWL_HE_PKT_EXT_NONE;
 1927                 high_th = IWL_HE_PKT_EXT_NONE;
 1928                 break;
 1929         case IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_8US:
 1930                 low_th = IWL_HE_PKT_EXT_BPSK;
 1931                 high_th = IWL_HE_PKT_EXT_NONE;
 1932                 break;
 1933         case IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_16US:
 1934                 low_th = IWL_HE_PKT_EXT_NONE;
 1935                 high_th = IWL_HE_PKT_EXT_BPSK;
 1936                 break;
 1937         }
 1938 
 1939         /* Set the PPE thresholds accordingly */
 1940         if (low_th >= 0 && high_th >= 0) {
 1941                 for (i = 0; i < MAX_HE_SUPP_NSS; i++) {
 1942                         u8 bw;
 1943 
 1944                         for (bw = 0;
 1945                              bw < ARRAY_SIZE(pkt_ext->pkt_ext_qam_th[i]);
 1946                              bw++) {
 1947                                 pkt_ext->pkt_ext_qam_th[i][bw][0] = low_th;
 1948                                 pkt_ext->pkt_ext_qam_th[i][bw][1] = high_th;
 1949                         }
 1950                 }
 1951 
 1952                 *flags |= STA_CTXT_HE_PACKET_EXT;
 1953         }
 1954 }
 1955 
 1956 static void iwl_mvm_cfg_he_sta(struct iwl_mvm *mvm,
 1957                                struct ieee80211_vif *vif, u8 sta_id)
 1958 {
 1959         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 1960         struct iwl_he_sta_context_cmd_v3 sta_ctxt_cmd = {
 1961                 .sta_id = sta_id,
 1962                 .tid_limit = IWL_MAX_TID_COUNT,
 1963                 .bss_color = vif->bss_conf.he_bss_color.color,
 1964                 .htc_trig_based_pkt_ext = vif->bss_conf.htc_trig_based_pkt_ext,
 1965                 .frame_time_rts_th =
 1966                         cpu_to_le16(vif->bss_conf.frame_time_rts_th),
 1967         };
 1968         struct iwl_he_sta_context_cmd_v2 sta_ctxt_cmd_v2 = {};
 1969         u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, STA_HE_CTXT_CMD);
 1970         u8 ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id, 2);
 1971         int size;
 1972         struct ieee80211_sta *sta;
 1973         u32 flags;
 1974         int i;
 1975         const struct ieee80211_sta_he_cap *own_he_cap = NULL;
 1976         struct ieee80211_chanctx_conf *chanctx_conf;
 1977         const struct ieee80211_supported_band *sband;
 1978         void *cmd;
 1979 
 1980         if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_MBSSID_HE))
 1981                 ver = 1;
 1982 
 1983         switch (ver) {
 1984         case 1:
 1985                 /* same layout as v2 except some data at the end */
 1986                 cmd = &sta_ctxt_cmd_v2;
 1987                 size = sizeof(struct iwl_he_sta_context_cmd_v1);
 1988                 break;
 1989         case 2:
 1990                 cmd = &sta_ctxt_cmd_v2;
 1991                 size = sizeof(struct iwl_he_sta_context_cmd_v2);
 1992                 break;
 1993         case 3:
 1994                 cmd = &sta_ctxt_cmd;
 1995                 size = sizeof(struct iwl_he_sta_context_cmd_v3);
 1996                 break;
 1997         default:
 1998                 IWL_ERR(mvm, "bad STA_HE_CTXT_CMD version %d\n", ver);
 1999                 return;
 2000         }
 2001 
 2002         rcu_read_lock();
 2003 
 2004         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 2005         if (WARN_ON(!chanctx_conf)) {
 2006                 rcu_read_unlock();
 2007                 return;
 2008         }
 2009 
 2010         sband = mvm->hw->wiphy->bands[chanctx_conf->def.chan->band];
 2011         own_he_cap = ieee80211_get_he_iftype_cap(sband,
 2012                                                  ieee80211_vif_type_p2p(vif));
 2013 
 2014         sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_ctxt_cmd.sta_id]);
 2015         if (IS_ERR_OR_NULL(sta)) {
 2016                 rcu_read_unlock();
 2017                 WARN(1, "Can't find STA to configure HE\n");
 2018                 return;
 2019         }
 2020 
 2021         if (!sta->deflink.he_cap.has_he) {
 2022                 rcu_read_unlock();
 2023                 return;
 2024         }
 2025 
 2026         flags = 0;
 2027 
 2028         /* Block 26-tone RU OFDMA transmissions */
 2029         if (mvmvif->he_ru_2mhz_block)
 2030                 flags |= STA_CTXT_HE_RU_2MHZ_BLOCK;
 2031 
 2032         /* HTC flags */
 2033         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[0] &
 2034             IEEE80211_HE_MAC_CAP0_HTC_HE)
 2035                 sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_SUPPORT);
 2036         if ((sta->deflink.he_cap.he_cap_elem.mac_cap_info[1] &
 2037               IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION) ||
 2038             (sta->deflink.he_cap.he_cap_elem.mac_cap_info[2] &
 2039               IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION)) {
 2040                 u8 link_adap =
 2041                         ((sta->deflink.he_cap.he_cap_elem.mac_cap_info[2] &
 2042                           IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION) << 1) +
 2043                          (sta->deflink.he_cap.he_cap_elem.mac_cap_info[1] &
 2044                           IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION);
 2045 
 2046                 if (link_adap == 2)
 2047                         sta_ctxt_cmd.htc_flags |=
 2048                                 cpu_to_le32(IWL_HE_HTC_LINK_ADAP_UNSOLICITED);
 2049                 else if (link_adap == 3)
 2050                         sta_ctxt_cmd.htc_flags |=
 2051                                 cpu_to_le32(IWL_HE_HTC_LINK_ADAP_BOTH);
 2052         }
 2053         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR)
 2054                 sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BSR_SUPP);
 2055         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[3] &
 2056             IEEE80211_HE_MAC_CAP3_OMI_CONTROL)
 2057                 sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_OMI_SUPP);
 2058         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR)
 2059                 sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BQR_SUPP);
 2060 
 2061         /*
 2062          * Initialize the PPE thresholds to "None" (7), as described in Table
 2063          * 9-262ac of 80211.ax/D3.0.
 2064          */
 2065         memset(&sta_ctxt_cmd.pkt_ext, IWL_HE_PKT_EXT_NONE,
 2066                sizeof(sta_ctxt_cmd.pkt_ext));
 2067 
 2068         /* If PPE Thresholds exist, parse them into a FW-familiar format. */
 2069         if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[6] &
 2070                 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
 2071                 iwl_mvm_set_pkt_ext_from_he_ppe(mvm, sta,
 2072                                                 &sta_ctxt_cmd.pkt_ext);
 2073                 flags |= STA_CTXT_HE_PACKET_EXT;
 2074         /* PPE Thresholds doesn't exist - set the API PPE values
 2075         * according to Common Nominal Packet Padding fiels. */
 2076         } else {
 2077                 u8 nominal_padding =
 2078                         u8_get_bits(sta->deflink.he_cap.he_cap_elem.phy_cap_info[9],
 2079                                     IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_MASK);
 2080                 if (nominal_padding != IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_RESERVED)
 2081                         iwl_mvm_set_pkt_ext_from_nominal_padding(&sta_ctxt_cmd.pkt_ext,
 2082                                                                  nominal_padding,
 2083                                                                  &flags);
 2084         }
 2085 
 2086         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[2] &
 2087             IEEE80211_HE_MAC_CAP2_32BIT_BA_BITMAP)
 2088                 flags |= STA_CTXT_HE_32BIT_BA_BITMAP;
 2089 
 2090         if (sta->deflink.he_cap.he_cap_elem.mac_cap_info[2] &
 2091             IEEE80211_HE_MAC_CAP2_ACK_EN)
 2092                 flags |= STA_CTXT_HE_ACK_ENABLED;
 2093 
 2094         rcu_read_unlock();
 2095 
 2096         /* Mark MU EDCA as enabled, unless none detected on some AC */
 2097         flags |= STA_CTXT_HE_MU_EDCA_CW;
 2098         for (i = 0; i < IEEE80211_NUM_ACS; i++) {
 2099                 struct ieee80211_he_mu_edca_param_ac_rec *mu_edca =
 2100                         &mvmvif->queue_params[i].mu_edca_param_rec;
 2101                 u8 ac = iwl_mvm_mac80211_ac_to_ucode_ac(i);
 2102 
 2103                 if (!mvmvif->queue_params[i].mu_edca) {
 2104                         flags &= ~STA_CTXT_HE_MU_EDCA_CW;
 2105                         break;
 2106                 }
 2107 
 2108                 sta_ctxt_cmd.trig_based_txf[ac].cwmin =
 2109                         cpu_to_le16(mu_edca->ecw_min_max & 0xf);
 2110                 sta_ctxt_cmd.trig_based_txf[ac].cwmax =
 2111                         cpu_to_le16((mu_edca->ecw_min_max & 0xf0) >> 4);
 2112                 sta_ctxt_cmd.trig_based_txf[ac].aifsn =
 2113                         cpu_to_le16(mu_edca->aifsn);
 2114                 sta_ctxt_cmd.trig_based_txf[ac].mu_time =
 2115                         cpu_to_le16(mu_edca->mu_edca_timer);
 2116         }
 2117 
 2118 
 2119         if (vif->bss_conf.uora_exists) {
 2120                 flags |= STA_CTXT_HE_TRIG_RND_ALLOC;
 2121 
 2122                 sta_ctxt_cmd.rand_alloc_ecwmin =
 2123                         vif->bss_conf.uora_ocw_range & 0x7;
 2124                 sta_ctxt_cmd.rand_alloc_ecwmax =
 2125                         (vif->bss_conf.uora_ocw_range >> 3) & 0x7;
 2126         }
 2127 
 2128         if (own_he_cap && !(own_he_cap->he_cap_elem.mac_cap_info[2] &
 2129                             IEEE80211_HE_MAC_CAP2_ACK_EN))
 2130                 flags |= STA_CTXT_HE_NIC_NOT_ACK_ENABLED;
 2131 
 2132         if (vif->bss_conf.nontransmitted) {
 2133                 flags |= STA_CTXT_HE_REF_BSSID_VALID;
 2134                 ether_addr_copy(sta_ctxt_cmd.ref_bssid_addr,
 2135                                 vif->bss_conf.transmitter_bssid);
 2136                 sta_ctxt_cmd.max_bssid_indicator =
 2137                         vif->bss_conf.bssid_indicator;
 2138                 sta_ctxt_cmd.bssid_index = vif->bss_conf.bssid_index;
 2139                 sta_ctxt_cmd.ema_ap = vif->bss_conf.ema_ap;
 2140                 sta_ctxt_cmd.profile_periodicity =
 2141                         vif->bss_conf.profile_periodicity;
 2142         }
 2143 
 2144         sta_ctxt_cmd.flags = cpu_to_le32(flags);
 2145 
 2146         if (ver < 3) {
 2147                 /* fields before pkt_ext */
 2148                 BUILD_BUG_ON(offsetof(typeof(sta_ctxt_cmd), pkt_ext) !=
 2149                              offsetof(typeof(sta_ctxt_cmd_v2), pkt_ext));
 2150                 memcpy(&sta_ctxt_cmd_v2, &sta_ctxt_cmd,
 2151                        offsetof(typeof(sta_ctxt_cmd), pkt_ext));
 2152 
 2153                 /* pkt_ext */
 2154                 for (i = 0;
 2155                      i < ARRAY_SIZE(sta_ctxt_cmd_v2.pkt_ext.pkt_ext_qam_th);
 2156                      i++) {
 2157                         u8 bw;
 2158 
 2159                         for (bw = 0;
 2160                              bw < ARRAY_SIZE(sta_ctxt_cmd_v2.pkt_ext.pkt_ext_qam_th[i]);
 2161                              bw++) {
 2162                                 BUILD_BUG_ON(sizeof(sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw]) !=
 2163                                              sizeof(sta_ctxt_cmd_v2.pkt_ext.pkt_ext_qam_th[i][bw]));
 2164 
 2165                                 memcpy(&sta_ctxt_cmd_v2.pkt_ext.pkt_ext_qam_th[i][bw],
 2166                                        &sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw],
 2167                                        sizeof(sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw]));
 2168                         }
 2169                 }
 2170 
 2171                 /* fields after pkt_ext */
 2172                 BUILD_BUG_ON(sizeof(sta_ctxt_cmd) -
 2173                              offsetofend(typeof(sta_ctxt_cmd), pkt_ext) !=
 2174                              sizeof(sta_ctxt_cmd_v2) -
 2175                              offsetofend(typeof(sta_ctxt_cmd_v2), pkt_ext));
 2176                 memcpy((u8 *)&sta_ctxt_cmd_v2 +
 2177                                 offsetofend(typeof(sta_ctxt_cmd_v2), pkt_ext),
 2178                        (u8 *)&sta_ctxt_cmd +
 2179                                 offsetofend(typeof(sta_ctxt_cmd), pkt_ext),
 2180                        sizeof(sta_ctxt_cmd) -
 2181                                 offsetofend(typeof(sta_ctxt_cmd), pkt_ext));
 2182                 sta_ctxt_cmd_v2.reserved3 = 0;
 2183         }
 2184 
 2185         if (iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, size, cmd))
 2186                 IWL_ERR(mvm, "Failed to config FW to work HE!\n");
 2187 }
 2188 
 2189 static void iwl_mvm_protect_assoc(struct iwl_mvm *mvm,
 2190                                   struct ieee80211_vif *vif,
 2191                                   u32 duration_override)
 2192 {
 2193         u32 duration = IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS;
 2194         u32 min_duration = IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS;
 2195 
 2196         if (duration_override > duration)
 2197                 duration = duration_override;
 2198 
 2199         /* Try really hard to protect the session and hear a beacon
 2200          * The new session protection command allows us to protect the
 2201          * session for a much longer time since the firmware will internally
 2202          * create two events: a 300TU one with a very high priority that
 2203          * won't be fragmented which should be enough for 99% of the cases,
 2204          * and another one (which we configure here to be 900TU long) which
 2205          * will have a slightly lower priority, but more importantly, can be
 2206          * fragmented so that it'll allow other activities to run.
 2207          */
 2208         if (fw_has_capa(&mvm->fw->ucode_capa,
 2209                         IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD))
 2210                 iwl_mvm_schedule_session_protection(mvm, vif, 900,
 2211                                                     min_duration, false);
 2212         else
 2213                 iwl_mvm_protect_session(mvm, vif, duration,
 2214                                         min_duration, 500, false);
 2215 }
 2216 
 2217 static void iwl_mvm_bss_info_changed_station(struct iwl_mvm *mvm,
 2218                                              struct ieee80211_vif *vif,
 2219                                              struct ieee80211_bss_conf *bss_conf,
 2220                                              u64 changes)
 2221 {
 2222         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 2223         int ret;
 2224 
 2225         /*
 2226          * Re-calculate the tsf id, as the leader-follower relations depend
 2227          * on the beacon interval, which was not known when the station
 2228          * interface was added.
 2229          */
 2230         if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc) {
 2231                 if (vif->bss_conf.he_support &&
 2232                     !iwlwifi_mod_params.disable_11ax)
 2233                         iwl_mvm_cfg_he_sta(mvm, vif, mvmvif->ap_sta_id);
 2234 
 2235                 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
 2236         }
 2237 
 2238         /* Update MU EDCA params */
 2239         if (changes & BSS_CHANGED_QOS && mvmvif->associated &&
 2240             bss_conf->assoc && vif->bss_conf.he_support &&
 2241             !iwlwifi_mod_params.disable_11ax)
 2242                 iwl_mvm_cfg_he_sta(mvm, vif, mvmvif->ap_sta_id);
 2243 
 2244         /*
 2245          * If we're not associated yet, take the (new) BSSID before associating
 2246          * so the firmware knows. If we're already associated, then use the old
 2247          * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
 2248          * branch for disassociation below.
 2249          */
 2250         if (changes & BSS_CHANGED_BSSID && !mvmvif->associated)
 2251                 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
 2252 
 2253         ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
 2254         if (ret)
 2255                 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
 2256 
 2257         /* after sending it once, adopt mac80211 data */
 2258         memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
 2259         mvmvif->associated = bss_conf->assoc;
 2260 
 2261         if (changes & BSS_CHANGED_ASSOC) {
 2262                 if (bss_conf->assoc) {
 2263                         /* clear statistics to get clean beacon counter */
 2264                         iwl_mvm_request_statistics(mvm, true);
 2265                         memset(&mvmvif->beacon_stats, 0,
 2266                                sizeof(mvmvif->beacon_stats));
 2267 
 2268                         /* add quota for this interface */
 2269                         ret = iwl_mvm_update_quotas(mvm, true, NULL);
 2270                         if (ret) {
 2271                                 IWL_ERR(mvm, "failed to update quotas\n");
 2272                                 return;
 2273                         }
 2274 
 2275                         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
 2276                                      &mvm->status) &&
 2277                             !fw_has_capa(&mvm->fw->ucode_capa,
 2278                                          IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD)) {
 2279                                 /*
 2280                                  * If we're restarting then the firmware will
 2281                                  * obviously have lost synchronisation with
 2282                                  * the AP. It will attempt to synchronise by
 2283                                  * itself, but we can make it more reliable by
 2284                                  * scheduling a session protection time event.
 2285                                  *
 2286                                  * The firmware needs to receive a beacon to
 2287                                  * catch up with synchronisation, use 110% of
 2288                                  * the beacon interval.
 2289                                  *
 2290                                  * Set a large maximum delay to allow for more
 2291                                  * than a single interface.
 2292                                  *
 2293                                  * For new firmware versions, rely on the
 2294                                  * firmware. This is relevant for DCM scenarios
 2295                                  * only anyway.
 2296                                  */
 2297                                 u32 dur = (11 * vif->bss_conf.beacon_int) / 10;
 2298                                 iwl_mvm_protect_session(mvm, vif, dur, dur,
 2299                                                         5 * dur, false);
 2300                         } else if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
 2301                                              &mvm->status) &&
 2302                                    !vif->bss_conf.dtim_period) {
 2303                                 /*
 2304                                  * If we're not restarting and still haven't
 2305                                  * heard a beacon (dtim period unknown) then
 2306                                  * make sure we still have enough minimum time
 2307                                  * remaining in the time event, since the auth
 2308                                  * might actually have taken quite a while
 2309                                  * (especially for SAE) and so the remaining
 2310                                  * time could be small without us having heard
 2311                                  * a beacon yet.
 2312                                  */
 2313                                 iwl_mvm_protect_assoc(mvm, vif, 0);
 2314                         }
 2315 
 2316                         iwl_mvm_sf_update(mvm, vif, false);
 2317                         iwl_mvm_power_vif_assoc(mvm, vif);
 2318                         if (vif->p2p) {
 2319                                 iwl_mvm_update_smps(mvm, vif,
 2320                                                     IWL_MVM_SMPS_REQ_PROT,
 2321                                                     IEEE80211_SMPS_DYNAMIC);
 2322                         }
 2323                 } else if (mvmvif->ap_sta_id != IWL_MVM_INVALID_STA) {
 2324                         iwl_mvm_mei_host_disassociated(mvm);
 2325                         /*
 2326                          * If update fails - SF might be running in associated
 2327                          * mode while disassociated - which is forbidden.
 2328                          */
 2329                         ret = iwl_mvm_sf_update(mvm, vif, false);
 2330                         WARN_ONCE(ret &&
 2331                                   !test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
 2332                                             &mvm->status),
 2333                                   "Failed to update SF upon disassociation\n");
 2334 
 2335                         /*
 2336                          * If we get an assert during the connection (after the
 2337                          * station has been added, but before the vif is set
 2338                          * to associated), mac80211 will re-add the station and
 2339                          * then configure the vif. Since the vif is not
 2340                          * associated, we would remove the station here and
 2341                          * this would fail the recovery.
 2342                          */
 2343                         if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
 2344                                       &mvm->status)) {
 2345                                 /*
 2346                                  * Remove AP station now that
 2347                                  * the MAC is unassoc
 2348                                  */
 2349                                 ret = iwl_mvm_rm_sta_id(mvm, vif,
 2350                                                         mvmvif->ap_sta_id);
 2351                                 if (ret)
 2352                                         IWL_ERR(mvm,
 2353                                                 "failed to remove AP station\n");
 2354 
 2355                                 mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
 2356                         }
 2357 
 2358                         /* remove quota for this interface */
 2359                         ret = iwl_mvm_update_quotas(mvm, false, NULL);
 2360                         if (ret)
 2361                                 IWL_ERR(mvm, "failed to update quotas\n");
 2362 
 2363                         /* this will take the cleared BSSID from bss_conf */
 2364                         ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 2365                         if (ret)
 2366                                 IWL_ERR(mvm,
 2367                                         "failed to update MAC %pM (clear after unassoc)\n",
 2368                                         vif->addr);
 2369                 }
 2370 
 2371                 /*
 2372                  * The firmware tracks the MU-MIMO group on its own.
 2373                  * However, on HW restart we should restore this data.
 2374                  */
 2375                 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
 2376                     (changes & BSS_CHANGED_MU_GROUPS) && vif->mu_mimo_owner) {
 2377                         ret = iwl_mvm_update_mu_groups(mvm, vif);
 2378                         if (ret)
 2379                                 IWL_ERR(mvm,
 2380                                         "failed to update VHT MU_MIMO groups\n");
 2381                 }
 2382 
 2383                 iwl_mvm_recalc_multicast(mvm);
 2384 
 2385                 /* reset rssi values */
 2386                 mvmvif->bf_data.ave_beacon_signal = 0;
 2387 
 2388                 iwl_mvm_bt_coex_vif_change(mvm);
 2389                 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT,
 2390                                     IEEE80211_SMPS_AUTOMATIC);
 2391                 if (fw_has_capa(&mvm->fw->ucode_capa,
 2392                                 IWL_UCODE_TLV_CAPA_UMAC_SCAN))
 2393                         iwl_mvm_config_scan(mvm);
 2394         }
 2395 
 2396         if (changes & BSS_CHANGED_BEACON_INFO) {
 2397                 /*
 2398                  * We received a beacon from the associated AP so
 2399                  * remove the session protection.
 2400                  */
 2401                 iwl_mvm_stop_session_protection(mvm, vif);
 2402 
 2403                 iwl_mvm_sf_update(mvm, vif, false);
 2404                 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
 2405         }
 2406 
 2407         if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS |
 2408                        /*
 2409                         * Send power command on every beacon change,
 2410                         * because we may have not enabled beacon abort yet.
 2411                         */
 2412                        BSS_CHANGED_BEACON_INFO)) {
 2413                 ret = iwl_mvm_power_update_mac(mvm);
 2414                 if (ret)
 2415                         IWL_ERR(mvm, "failed to update power mode\n");
 2416         }
 2417 
 2418         if (changes & BSS_CHANGED_CQM) {
 2419                 IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
 2420                 /* reset cqm events tracking */
 2421                 mvmvif->bf_data.last_cqm_event = 0;
 2422                 if (mvmvif->bf_data.bf_enabled) {
 2423                         ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
 2424                         if (ret)
 2425                                 IWL_ERR(mvm,
 2426                                         "failed to update CQM thresholds\n");
 2427                 }
 2428         }
 2429 
 2430         if (changes & BSS_CHANGED_BANDWIDTH)
 2431                 iwl_mvm_apply_fw_smps_request(vif);
 2432 }
 2433 
 2434 static int iwl_mvm_start_ap_ibss(struct ieee80211_hw *hw,
 2435                                  struct ieee80211_vif *vif,
 2436                                  struct ieee80211_bss_conf *link_conf)
 2437 {
 2438         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2439         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 2440         int ret, i;
 2441 
 2442         mutex_lock(&mvm->mutex);
 2443 
 2444         /* Send the beacon template */
 2445         ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
 2446         if (ret)
 2447                 goto out_unlock;
 2448 
 2449         /*
 2450          * Re-calculate the tsf id, as the leader-follower relations depend on
 2451          * the beacon interval, which was not known when the AP interface
 2452          * was added.
 2453          */
 2454         if (vif->type == NL80211_IFTYPE_AP)
 2455                 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
 2456 
 2457         mvmvif->ap_assoc_sta_count = 0;
 2458 
 2459         /* Add the mac context */
 2460         ret = iwl_mvm_mac_ctxt_add(mvm, vif);
 2461         if (ret)
 2462                 goto out_unlock;
 2463 
 2464         /* Perform the binding */
 2465         ret = iwl_mvm_binding_add_vif(mvm, vif);
 2466         if (ret)
 2467                 goto out_remove;
 2468 
 2469         /*
 2470          * This is not very nice, but the simplest:
 2471          * For older FWs adding the mcast sta before the bcast station may
 2472          * cause assert 0x2b00.
 2473          * This is fixed in later FW so make the order of removal depend on
 2474          * the TLV
 2475          */
 2476         if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
 2477                 ret = iwl_mvm_add_mcast_sta(mvm, vif);
 2478                 if (ret)
 2479                         goto out_unbind;
 2480                 /*
 2481                  * Send the bcast station. At this stage the TBTT and DTIM time
 2482                  * events are added and applied to the scheduler
 2483                  */
 2484                 ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
 2485                 if (ret) {
 2486                         iwl_mvm_rm_mcast_sta(mvm, vif);
 2487                         goto out_unbind;
 2488                 }
 2489         } else {
 2490                 /*
 2491                  * Send the bcast station. At this stage the TBTT and DTIM time
 2492                  * events are added and applied to the scheduler
 2493                  */
 2494                 ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
 2495                 if (ret)
 2496                         goto out_unbind;
 2497                 ret = iwl_mvm_add_mcast_sta(mvm, vif);
 2498                 if (ret) {
 2499                         iwl_mvm_send_rm_bcast_sta(mvm, vif);
 2500                         goto out_unbind;
 2501                 }
 2502         }
 2503 
 2504         /* must be set before quota calculations */
 2505         mvmvif->ap_ibss_active = true;
 2506 
 2507         /* send all the early keys to the device now */
 2508         for (i = 0; i < ARRAY_SIZE(mvmvif->ap_early_keys); i++) {
 2509                 struct ieee80211_key_conf *key = mvmvif->ap_early_keys[i];
 2510 
 2511                 if (!key)
 2512                         continue;
 2513 
 2514                 mvmvif->ap_early_keys[i] = NULL;
 2515 
 2516                 ret = __iwl_mvm_mac_set_key(hw, SET_KEY, vif, NULL, key);
 2517                 if (ret)
 2518                         goto out_quota_failed;
 2519         }
 2520 
 2521         if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
 2522                 iwl_mvm_vif_set_low_latency(mvmvif, true,
 2523                                             LOW_LATENCY_VIF_TYPE);
 2524                 iwl_mvm_send_low_latency_cmd(mvm, true, mvmvif->id);
 2525         }
 2526 
 2527         /* power updated needs to be done before quotas */
 2528         iwl_mvm_power_update_mac(mvm);
 2529 
 2530         ret = iwl_mvm_update_quotas(mvm, false, NULL);
 2531         if (ret)
 2532                 goto out_quota_failed;
 2533 
 2534         /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
 2535         if (vif->p2p && mvm->p2p_device_vif)
 2536                 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
 2537 
 2538         iwl_mvm_bt_coex_vif_change(mvm);
 2539 
 2540         /* we don't support TDLS during DCM */
 2541         if (iwl_mvm_phy_ctx_count(mvm) > 1)
 2542                 iwl_mvm_teardown_tdls_peers(mvm);
 2543 
 2544         iwl_mvm_ftm_restart_responder(mvm, vif);
 2545 
 2546         goto out_unlock;
 2547 
 2548 out_quota_failed:
 2549         iwl_mvm_power_update_mac(mvm);
 2550         mvmvif->ap_ibss_active = false;
 2551         iwl_mvm_send_rm_bcast_sta(mvm, vif);
 2552         iwl_mvm_rm_mcast_sta(mvm, vif);
 2553 out_unbind:
 2554         iwl_mvm_binding_remove_vif(mvm, vif);
 2555 out_remove:
 2556         iwl_mvm_mac_ctxt_remove(mvm, vif);
 2557 out_unlock:
 2558         mutex_unlock(&mvm->mutex);
 2559         return ret;
 2560 }
 2561 
 2562 static int iwl_mvm_start_ap(struct ieee80211_hw *hw,
 2563                             struct ieee80211_vif *vif,
 2564                             struct ieee80211_bss_conf *link_conf)
 2565 {
 2566         return iwl_mvm_start_ap_ibss(hw, vif, link_conf);
 2567 }
 2568 
 2569 static int iwl_mvm_start_ibss(struct ieee80211_hw *hw,
 2570                               struct ieee80211_vif *vif)
 2571 {
 2572         return iwl_mvm_start_ap_ibss(hw, vif, &vif->bss_conf);
 2573 }
 2574 
 2575 static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw,
 2576                                  struct ieee80211_vif *vif,
 2577                                  struct ieee80211_bss_conf *link_conf)
 2578 {
 2579         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2580         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 2581 
 2582         iwl_mvm_prepare_mac_removal(mvm, vif);
 2583 
 2584         mutex_lock(&mvm->mutex);
 2585 
 2586         /* Handle AP stop while in CSA */
 2587         if (rcu_access_pointer(mvm->csa_vif) == vif) {
 2588                 iwl_mvm_remove_time_event(mvm, mvmvif,
 2589                                           &mvmvif->time_event_data);
 2590                 RCU_INIT_POINTER(mvm->csa_vif, NULL);
 2591                 mvmvif->csa_countdown = false;
 2592         }
 2593 
 2594         if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
 2595                 RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
 2596                 mvm->csa_tx_block_bcn_timeout = 0;
 2597         }
 2598 
 2599         mvmvif->ap_ibss_active = false;
 2600         mvm->ap_last_beacon_gp2 = 0;
 2601 
 2602         if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
 2603                 iwl_mvm_vif_set_low_latency(mvmvif, false,
 2604                                             LOW_LATENCY_VIF_TYPE);
 2605                 iwl_mvm_send_low_latency_cmd(mvm, false,  mvmvif->id);
 2606         }
 2607 
 2608         iwl_mvm_bt_coex_vif_change(mvm);
 2609 
 2610         /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
 2611         if (vif->p2p && mvm->p2p_device_vif)
 2612                 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
 2613 
 2614         iwl_mvm_update_quotas(mvm, false, NULL);
 2615 
 2616         iwl_mvm_ftm_responder_clear(mvm, vif);
 2617 
 2618         /*
 2619          * This is not very nice, but the simplest:
 2620          * For older FWs removing the mcast sta before the bcast station may
 2621          * cause assert 0x2b00.
 2622          * This is fixed in later FW (which will stop beaconing when removing
 2623          * bcast station).
 2624          * So make the order of removal depend on the TLV
 2625          */
 2626         if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
 2627                 iwl_mvm_rm_mcast_sta(mvm, vif);
 2628         iwl_mvm_send_rm_bcast_sta(mvm, vif);
 2629         if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE))
 2630                 iwl_mvm_rm_mcast_sta(mvm, vif);
 2631         iwl_mvm_binding_remove_vif(mvm, vif);
 2632 
 2633         iwl_mvm_power_update_mac(mvm);
 2634 
 2635         iwl_mvm_mac_ctxt_remove(mvm, vif);
 2636 
 2637         mutex_unlock(&mvm->mutex);
 2638 }
 2639 
 2640 static void iwl_mvm_stop_ap(struct ieee80211_hw *hw,
 2641                             struct ieee80211_vif *vif,
 2642                             struct ieee80211_bss_conf *link_conf)
 2643 {
 2644         iwl_mvm_stop_ap_ibss(hw, vif, link_conf);
 2645 }
 2646 
 2647 static void iwl_mvm_stop_ibss(struct ieee80211_hw *hw,
 2648                               struct ieee80211_vif *vif)
 2649 {
 2650         iwl_mvm_stop_ap_ibss(hw, vif, &vif->bss_conf);
 2651 }
 2652 
 2653 static void
 2654 iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm *mvm,
 2655                                  struct ieee80211_vif *vif,
 2656                                  struct ieee80211_bss_conf *bss_conf,
 2657                                  u64 changes)
 2658 {
 2659         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 2660 
 2661         /* Changes will be applied when the AP/IBSS is started */
 2662         if (!mvmvif->ap_ibss_active)
 2663                 return;
 2664 
 2665         if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT |
 2666                        BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
 2667             iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL))
 2668                 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
 2669 
 2670         /* Need to send a new beacon template to the FW */
 2671         if (changes & BSS_CHANGED_BEACON &&
 2672             iwl_mvm_mac_ctxt_beacon_changed(mvm, vif))
 2673                 IWL_WARN(mvm, "Failed updating beacon data\n");
 2674 
 2675         if (changes & BSS_CHANGED_FTM_RESPONDER) {
 2676                 int ret = iwl_mvm_ftm_start_responder(mvm, vif);
 2677 
 2678                 if (ret)
 2679                         IWL_WARN(mvm, "Failed to enable FTM responder (%d)\n",
 2680                                  ret);
 2681         }
 2682 
 2683 }
 2684 
 2685 static void iwl_mvm_bss_info_changed(struct ieee80211_hw *hw,
 2686                                      struct ieee80211_vif *vif,
 2687                                      struct ieee80211_bss_conf *bss_conf,
 2688                                      u64 changes)
 2689 {
 2690         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2691 
 2692         mutex_lock(&mvm->mutex);
 2693 
 2694         if (changes & BSS_CHANGED_IDLE && !bss_conf->idle)
 2695                 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
 2696 
 2697         switch (vif->type) {
 2698         case NL80211_IFTYPE_STATION:
 2699                 iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
 2700                 break;
 2701         case NL80211_IFTYPE_AP:
 2702         case NL80211_IFTYPE_ADHOC:
 2703                 iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
 2704                 break;
 2705         case NL80211_IFTYPE_MONITOR:
 2706                 if (changes & BSS_CHANGED_MU_GROUPS)
 2707                         iwl_mvm_update_mu_groups(mvm, vif);
 2708                 break;
 2709         default:
 2710                 /* shouldn't happen */
 2711                 WARN_ON_ONCE(1);
 2712         }
 2713 
 2714         if (changes & BSS_CHANGED_TXPOWER) {
 2715                 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d dBm\n",
 2716                                 bss_conf->txpower);
 2717                 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
 2718         }
 2719 
 2720         mutex_unlock(&mvm->mutex);
 2721 }
 2722 
 2723 static int iwl_mvm_mac_hw_scan(struct ieee80211_hw *hw,
 2724                                struct ieee80211_vif *vif,
 2725                                struct ieee80211_scan_request *hw_req)
 2726 {
 2727         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2728         int ret;
 2729 
 2730         if (hw_req->req.n_channels == 0 ||
 2731             hw_req->req.n_channels > mvm->fw->ucode_capa.n_scan_channels)
 2732                 return -EINVAL;
 2733 
 2734         mutex_lock(&mvm->mutex);
 2735         ret = iwl_mvm_reg_scan_start(mvm, vif, &hw_req->req, &hw_req->ies);
 2736         mutex_unlock(&mvm->mutex);
 2737 
 2738         return ret;
 2739 }
 2740 
 2741 static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw *hw,
 2742                                        struct ieee80211_vif *vif)
 2743 {
 2744         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2745 
 2746         mutex_lock(&mvm->mutex);
 2747 
 2748         /* Due to a race condition, it's possible that mac80211 asks
 2749          * us to stop a hw_scan when it's already stopped.  This can
 2750          * happen, for instance, if we stopped the scan ourselves,
 2751          * called ieee80211_scan_completed() and the userspace called
 2752          * cancel scan scan before ieee80211_scan_work() could run.
 2753          * To handle that, simply return if the scan is not running.
 2754         */
 2755         if (mvm->scan_status & IWL_MVM_SCAN_REGULAR)
 2756                 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
 2757 
 2758         mutex_unlock(&mvm->mutex);
 2759 }
 2760 
 2761 static void
 2762 iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw *hw,
 2763                                   struct ieee80211_sta *sta, u16 tids,
 2764                                   int num_frames,
 2765                                   enum ieee80211_frame_release_type reason,
 2766                                   bool more_data)
 2767 {
 2768         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2769 
 2770         /* Called when we need to transmit (a) frame(s) from mac80211 */
 2771 
 2772         iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
 2773                                           tids, more_data, false);
 2774 }
 2775 
 2776 static void
 2777 iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw *hw,
 2778                                     struct ieee80211_sta *sta, u16 tids,
 2779                                     int num_frames,
 2780                                     enum ieee80211_frame_release_type reason,
 2781                                     bool more_data)
 2782 {
 2783         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2784 
 2785         /* Called when we need to transmit (a) frame(s) from agg or dqa queue */
 2786 
 2787         iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
 2788                                           tids, more_data, true);
 2789 }
 2790 
 2791 static void __iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw,
 2792                                      enum sta_notify_cmd cmd,
 2793                                      struct ieee80211_sta *sta)
 2794 {
 2795         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2796         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 2797         unsigned long txqs = 0, tids = 0;
 2798         int tid;
 2799 
 2800         /*
 2801          * If we have TVQM then we get too high queue numbers - luckily
 2802          * we really shouldn't get here with that because such hardware
 2803          * should have firmware supporting buffer station offload.
 2804          */
 2805         if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
 2806                 return;
 2807 
 2808         spin_lock_bh(&mvmsta->lock);
 2809         for (tid = 0; tid < ARRAY_SIZE(mvmsta->tid_data); tid++) {
 2810                 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
 2811 
 2812                 if (tid_data->txq_id == IWL_MVM_INVALID_QUEUE)
 2813                         continue;
 2814 
 2815                 __set_bit(tid_data->txq_id, &txqs);
 2816 
 2817                 if (iwl_mvm_tid_queued(mvm, tid_data) == 0)
 2818                         continue;
 2819 
 2820                 __set_bit(tid, &tids);
 2821         }
 2822 
 2823         switch (cmd) {
 2824         case STA_NOTIFY_SLEEP:
 2825                 for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT)
 2826                         ieee80211_sta_set_buffered(sta, tid, true);
 2827 
 2828                 if (txqs)
 2829                         iwl_trans_freeze_txq_timer(mvm->trans, txqs, true);
 2830                 /*
 2831                  * The fw updates the STA to be asleep. Tx packets on the Tx
 2832                  * queues to this station will not be transmitted. The fw will
 2833                  * send a Tx response with TX_STATUS_FAIL_DEST_PS.
 2834                  */
 2835                 break;
 2836         case STA_NOTIFY_AWAKE:
 2837                 if (WARN_ON(mvmsta->sta_id == IWL_MVM_INVALID_STA))
 2838                         break;
 2839 
 2840                 if (txqs)
 2841                         iwl_trans_freeze_txq_timer(mvm->trans, txqs, false);
 2842                 iwl_mvm_sta_modify_ps_wake(mvm, sta);
 2843                 break;
 2844         default:
 2845                 break;
 2846         }
 2847         spin_unlock_bh(&mvmsta->lock);
 2848 }
 2849 
 2850 static void iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw,
 2851                                    struct ieee80211_vif *vif,
 2852                                    enum sta_notify_cmd cmd,
 2853                                    struct ieee80211_sta *sta)
 2854 {
 2855         __iwl_mvm_mac_sta_notify(hw, cmd, sta);
 2856 }
 2857 
 2858 void iwl_mvm_sta_pm_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
 2859 {
 2860         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 2861         struct iwl_mvm_pm_state_notification *notif = (void *)pkt->data;
 2862         struct ieee80211_sta *sta;
 2863         struct iwl_mvm_sta *mvmsta;
 2864         bool sleeping = (notif->type != IWL_MVM_PM_EVENT_AWAKE);
 2865 
 2866         if (WARN_ON(notif->sta_id >= mvm->fw->ucode_capa.num_stations))
 2867                 return;
 2868 
 2869         rcu_read_lock();
 2870         sta = rcu_dereference(mvm->fw_id_to_mac_id[notif->sta_id]);
 2871         if (WARN_ON(IS_ERR_OR_NULL(sta))) {
 2872                 rcu_read_unlock();
 2873                 return;
 2874         }
 2875 
 2876         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 2877 
 2878         if (!mvmsta->vif ||
 2879             mvmsta->vif->type != NL80211_IFTYPE_AP) {
 2880                 rcu_read_unlock();
 2881                 return;
 2882         }
 2883 
 2884         if (mvmsta->sleeping != sleeping) {
 2885                 mvmsta->sleeping = sleeping;
 2886                 __iwl_mvm_mac_sta_notify(mvm->hw,
 2887                         sleeping ? STA_NOTIFY_SLEEP : STA_NOTIFY_AWAKE,
 2888                         sta);
 2889                 ieee80211_sta_ps_transition(sta, sleeping);
 2890         }
 2891 
 2892         if (sleeping) {
 2893                 switch (notif->type) {
 2894                 case IWL_MVM_PM_EVENT_AWAKE:
 2895                 case IWL_MVM_PM_EVENT_ASLEEP:
 2896                         break;
 2897                 case IWL_MVM_PM_EVENT_UAPSD:
 2898                         ieee80211_sta_uapsd_trigger(sta, IEEE80211_NUM_TIDS);
 2899                         break;
 2900                 case IWL_MVM_PM_EVENT_PS_POLL:
 2901                         ieee80211_sta_pspoll(sta);
 2902                         break;
 2903                 default:
 2904                         break;
 2905                 }
 2906         }
 2907 
 2908         rcu_read_unlock();
 2909 }
 2910 
 2911 static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw *hw,
 2912                                        struct ieee80211_vif *vif,
 2913                                        struct ieee80211_sta *sta)
 2914 {
 2915         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 2916         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
 2917 
 2918         /*
 2919          * This is called before mac80211 does RCU synchronisation,
 2920          * so here we already invalidate our internal RCU-protected
 2921          * station pointer. The rest of the code will thus no longer
 2922          * be able to find the station this way, and we don't rely
 2923          * on further RCU synchronisation after the sta_state()
 2924          * callback deleted the station.
 2925          */
 2926         mutex_lock(&mvm->mutex);
 2927         if (sta == rcu_access_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id]))
 2928                 rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
 2929                                    ERR_PTR(-ENOENT));
 2930 
 2931         mutex_unlock(&mvm->mutex);
 2932 }
 2933 
 2934 static void iwl_mvm_check_uapsd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 2935                                 const u8 *bssid)
 2936 {
 2937         int i;
 2938 
 2939         if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
 2940                 struct iwl_mvm_tcm_mac *mdata;
 2941 
 2942                 mdata = &mvm->tcm.data[iwl_mvm_vif_from_mac80211(vif)->id];
 2943                 ewma_rate_init(&mdata->uapsd_nonagg_detect.rate);
 2944                 mdata->opened_rx_ba_sessions = false;
 2945         }
 2946 
 2947         if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT))
 2948                 return;
 2949 
 2950         if (vif->p2p && !iwl_mvm_is_p2p_scm_uapsd_supported(mvm)) {
 2951                 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
 2952                 return;
 2953         }
 2954 
 2955         if (!vif->p2p &&
 2956             (iwlwifi_mod_params.uapsd_disable & IWL_DISABLE_UAPSD_BSS)) {
 2957                 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
 2958                 return;
 2959         }
 2960 
 2961         for (i = 0; i < IWL_MVM_UAPSD_NOAGG_LIST_LEN; i++) {
 2962                 if (ether_addr_equal(mvm->uapsd_noagg_bssids[i].addr, bssid)) {
 2963                         vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
 2964                         return;
 2965                 }
 2966         }
 2967 
 2968         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
 2969 }
 2970 
 2971 static void
 2972 iwl_mvm_tdls_check_trigger(struct iwl_mvm *mvm,
 2973                            struct ieee80211_vif *vif, u8 *peer_addr,
 2974                            enum nl80211_tdls_operation action)
 2975 {
 2976         struct iwl_fw_dbg_trigger_tlv *trig;
 2977         struct iwl_fw_dbg_trigger_tdls *tdls_trig;
 2978 
 2979         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
 2980                                      FW_DBG_TRIGGER_TDLS);
 2981         if (!trig)
 2982                 return;
 2983 
 2984         tdls_trig = (void *)trig->data;
 2985 
 2986         if (!(tdls_trig->action_bitmap & BIT(action)))
 2987                 return;
 2988 
 2989         if (tdls_trig->peer_mode &&
 2990             memcmp(tdls_trig->peer, peer_addr, ETH_ALEN) != 0)
 2991                 return;
 2992 
 2993         iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
 2994                                 "TDLS event occurred, peer %pM, action %d",
 2995                                 peer_addr, action);
 2996 }
 2997 
 2998 struct iwl_mvm_he_obss_narrow_bw_ru_data {
 2999         bool tolerated;
 3000 };
 3001 
 3002 static void iwl_mvm_check_he_obss_narrow_bw_ru_iter(struct wiphy *wiphy,
 3003                                                     struct cfg80211_bss *bss,
 3004                                                     void *_data)
 3005 {
 3006         struct iwl_mvm_he_obss_narrow_bw_ru_data *data = _data;
 3007         const struct cfg80211_bss_ies *ies;
 3008         const struct element *elem;
 3009 
 3010         rcu_read_lock();
 3011         ies = rcu_dereference(bss->ies);
 3012         elem = cfg80211_find_elem(WLAN_EID_EXT_CAPABILITY, ies->data,
 3013                                   ies->len);
 3014 
 3015         if (!elem || elem->datalen < 10 ||
 3016             !(elem->data[10] &
 3017               WLAN_EXT_CAPA10_OBSS_NARROW_BW_RU_TOLERANCE_SUPPORT)) {
 3018                 data->tolerated = false;
 3019         }
 3020         rcu_read_unlock();
 3021 }
 3022 
 3023 static void iwl_mvm_check_he_obss_narrow_bw_ru(struct ieee80211_hw *hw,
 3024                                                struct ieee80211_vif *vif)
 3025 {
 3026         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3027         struct iwl_mvm_he_obss_narrow_bw_ru_data iter_data = {
 3028                 .tolerated = true,
 3029         };
 3030 
 3031         if (!(vif->bss_conf.chandef.chan->flags & IEEE80211_CHAN_RADAR)) {
 3032                 mvmvif->he_ru_2mhz_block = false;
 3033                 return;
 3034         }
 3035 
 3036         cfg80211_bss_iter(hw->wiphy, &vif->bss_conf.chandef,
 3037                           iwl_mvm_check_he_obss_narrow_bw_ru_iter,
 3038                           &iter_data);
 3039 
 3040         /*
 3041          * If there is at least one AP on radar channel that cannot
 3042          * tolerate 26-tone RU UL OFDMA transmissions using HE TB PPDU.
 3043          */
 3044         mvmvif->he_ru_2mhz_block = !iter_data.tolerated;
 3045 }
 3046 
 3047 static void iwl_mvm_reset_cca_40mhz_workaround(struct iwl_mvm *mvm,
 3048                                                struct ieee80211_vif *vif)
 3049 {
 3050         struct ieee80211_supported_band *sband;
 3051         const struct ieee80211_sta_he_cap *he_cap;
 3052 
 3053         if (vif->type != NL80211_IFTYPE_STATION)
 3054                 return;
 3055 
 3056         if (!mvm->cca_40mhz_workaround)
 3057                 return;
 3058 
 3059         /* decrement and check that we reached zero */
 3060         mvm->cca_40mhz_workaround--;
 3061         if (mvm->cca_40mhz_workaround)
 3062                 return;
 3063 
 3064         sband = mvm->hw->wiphy->bands[NL80211_BAND_2GHZ];
 3065 
 3066         sband->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 3067 
 3068         he_cap = ieee80211_get_he_iftype_cap(sband,
 3069                                              ieee80211_vif_type_p2p(vif));
 3070 
 3071         if (he_cap) {
 3072                 /* we know that ours is writable */
 3073                 struct ieee80211_sta_he_cap *he = (void *)(uintptr_t)he_cap;
 3074 
 3075                 he->he_cap_elem.phy_cap_info[0] |=
 3076                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G;
 3077         }
 3078 }
 3079 
 3080 static void iwl_mvm_mei_host_associated(struct iwl_mvm *mvm,
 3081                                         struct ieee80211_vif *vif,
 3082                                         struct iwl_mvm_sta *mvm_sta)
 3083 {
 3084 #if IS_ENABLED(CONFIG_IWLMEI)
 3085         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3086         struct iwl_mei_conn_info conn_info = {
 3087                 .ssid_len = vif->bss_conf.ssid_len,
 3088                 .channel = vif->bss_conf.chandef.chan->hw_value,
 3089         };
 3090 
 3091         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
 3092                 return;
 3093 
 3094         if (!mvm->mei_registered)
 3095                 return;
 3096 
 3097         switch (mvm_sta->pairwise_cipher) {
 3098         case WLAN_CIPHER_SUITE_CCMP:
 3099                 conn_info.pairwise_cipher = IWL_MEI_CIPHER_CCMP;
 3100                 break;
 3101         case WLAN_CIPHER_SUITE_GCMP:
 3102                 conn_info.pairwise_cipher = IWL_MEI_CIPHER_GCMP;
 3103                 break;
 3104         case WLAN_CIPHER_SUITE_GCMP_256:
 3105                 conn_info.pairwise_cipher = IWL_MEI_CIPHER_GCMP_256;
 3106                 break;
 3107         case 0:
 3108                 /* open profile */
 3109                 break;
 3110         default:
 3111                 /* cipher not supported, don't send anything to iwlmei */
 3112                 return;
 3113         }
 3114 
 3115         switch (mvmvif->rekey_data.akm) {
 3116         case WLAN_AKM_SUITE_SAE & 0xff:
 3117                 conn_info.auth_mode = IWL_MEI_AKM_AUTH_SAE;
 3118                 break;
 3119         case WLAN_AKM_SUITE_PSK & 0xff:
 3120                 conn_info.auth_mode = IWL_MEI_AKM_AUTH_RSNA_PSK;
 3121                 break;
 3122         case WLAN_AKM_SUITE_8021X & 0xff:
 3123                 conn_info.auth_mode = IWL_MEI_AKM_AUTH_RSNA;
 3124                 break;
 3125         case 0:
 3126                 /* open profile */
 3127                 conn_info.auth_mode = IWL_MEI_AKM_AUTH_OPEN;
 3128                 break;
 3129         default:
 3130                 /* auth method / AKM not supported */
 3131                 /* TODO: All the FT vesions of these? */
 3132                 return;
 3133         }
 3134 
 3135         memcpy(conn_info.ssid, vif->bss_conf.ssid, vif->bss_conf.ssid_len);
 3136         memcpy(conn_info.bssid,  vif->bss_conf.bssid, ETH_ALEN);
 3137 
 3138         /* TODO: add support for collocated AP data */
 3139         iwl_mei_host_associated(&conn_info, NULL);
 3140 #endif
 3141 }
 3142 
 3143 static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,
 3144                                  struct ieee80211_vif *vif,
 3145                                  struct ieee80211_sta *sta,
 3146                                  enum ieee80211_sta_state old_state,
 3147                                  enum ieee80211_sta_state new_state)
 3148 {
 3149         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3150         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3151         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
 3152         int ret;
 3153 
 3154         IWL_DEBUG_MAC80211(mvm, "station %pM state change %d->%d\n",
 3155                            sta->addr, old_state, new_state);
 3156 
 3157         /* this would be a mac80211 bug ... but don't crash */
 3158         if (WARN_ON_ONCE(!mvmvif->phy_ctxt))
 3159                 return test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status) ? 0 : -EINVAL;
 3160 
 3161         /*
 3162          * If we are in a STA removal flow and in DQA mode:
 3163          *
 3164          * This is after the sync_rcu part, so the queues have already been
 3165          * flushed. No more TXs on their way in mac80211's path, and no more in
 3166          * the queues.
 3167          * Also, we won't be getting any new TX frames for this station.
 3168          * What we might have are deferred TX frames that need to be taken care
 3169          * of.
 3170          *
 3171          * Drop any still-queued deferred-frame before removing the STA, and
 3172          * make sure the worker is no longer handling frames for this STA.
 3173          */
 3174         if (old_state == IEEE80211_STA_NONE &&
 3175             new_state == IEEE80211_STA_NOTEXIST) {
 3176                 flush_work(&mvm->add_stream_wk);
 3177 
 3178                 /*
 3179                  * No need to make sure deferred TX indication is off since the
 3180                  * worker will already remove it if it was on
 3181                  */
 3182 
 3183                 /*
 3184                  * Additionally, reset the 40 MHz capability if we disconnected
 3185                  * from the AP now.
 3186                  */
 3187                 iwl_mvm_reset_cca_40mhz_workaround(mvm, vif);
 3188         }
 3189 
 3190         mutex_lock(&mvm->mutex);
 3191         /* track whether or not the station is associated */
 3192         mvm_sta->sta_state = new_state;
 3193 
 3194         if (old_state == IEEE80211_STA_NOTEXIST &&
 3195             new_state == IEEE80211_STA_NONE) {
 3196                 /*
 3197                  * Firmware bug - it'll crash if the beacon interval is less
 3198                  * than 16. We can't avoid connecting at all, so refuse the
 3199                  * station state change, this will cause mac80211 to abandon
 3200                  * attempts to connect to this AP, and eventually wpa_s will
 3201                  * blocklist the AP...
 3202                  */
 3203                 if (vif->type == NL80211_IFTYPE_STATION &&
 3204                     vif->bss_conf.beacon_int < 16) {
 3205                         IWL_ERR(mvm,
 3206                                 "AP %pM beacon interval is %d, refusing due to firmware bug!\n",
 3207                                 sta->addr, vif->bss_conf.beacon_int);
 3208                         ret = -EINVAL;
 3209                         goto out_unlock;
 3210                 }
 3211 
 3212                 if (vif->type == NL80211_IFTYPE_STATION)
 3213                         vif->bss_conf.he_support = sta->deflink.he_cap.has_he;
 3214 
 3215                 if (sta->tdls &&
 3216                     (vif->p2p ||
 3217                      iwl_mvm_tdls_sta_count(mvm, NULL) ==
 3218                                                 IWL_MVM_TDLS_STA_COUNT ||
 3219                      iwl_mvm_phy_ctx_count(mvm) > 1)) {
 3220                         IWL_DEBUG_MAC80211(mvm, "refusing TDLS sta\n");
 3221                         ret = -EBUSY;
 3222                         goto out_unlock;
 3223                 }
 3224 
 3225                 ret = iwl_mvm_add_sta(mvm, vif, sta);
 3226                 if (sta->tdls && ret == 0) {
 3227                         iwl_mvm_recalc_tdls_state(mvm, vif, true);
 3228                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
 3229                                                    NL80211_TDLS_SETUP);
 3230                 }
 3231 
 3232                 sta->max_rc_amsdu_len = 1;
 3233         } else if (old_state == IEEE80211_STA_NONE &&
 3234                    new_state == IEEE80211_STA_AUTH) {
 3235                 /*
 3236                  * EBS may be disabled due to previous failures reported by FW.
 3237                  * Reset EBS status here assuming environment has been changed.
 3238                  */
 3239                 mvm->last_ebs_successful = true;
 3240                 iwl_mvm_check_uapsd(mvm, vif, sta->addr);
 3241                 ret = 0;
 3242         } else if (old_state == IEEE80211_STA_AUTH &&
 3243                    new_state == IEEE80211_STA_ASSOC) {
 3244                 if (vif->type == NL80211_IFTYPE_AP) {
 3245                         vif->bss_conf.he_support = sta->deflink.he_cap.has_he;
 3246                         mvmvif->ap_assoc_sta_count++;
 3247                         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3248                         if (vif->bss_conf.he_support &&
 3249                             !iwlwifi_mod_params.disable_11ax)
 3250                                 iwl_mvm_cfg_he_sta(mvm, vif, mvm_sta->sta_id);
 3251                 } else if (vif->type == NL80211_IFTYPE_STATION) {
 3252                         vif->bss_conf.he_support = sta->deflink.he_cap.has_he;
 3253 
 3254                         mvmvif->he_ru_2mhz_block = false;
 3255                         if (sta->deflink.he_cap.has_he)
 3256                                 iwl_mvm_check_he_obss_narrow_bw_ru(hw, vif);
 3257 
 3258                         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3259                 }
 3260 
 3261                 iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
 3262                                      false);
 3263                 ret = iwl_mvm_update_sta(mvm, vif, sta);
 3264         } else if (old_state == IEEE80211_STA_ASSOC &&
 3265                    new_state == IEEE80211_STA_AUTHORIZED) {
 3266                 ret = 0;
 3267 
 3268                 /* we don't support TDLS during DCM */
 3269                 if (iwl_mvm_phy_ctx_count(mvm) > 1)
 3270                         iwl_mvm_teardown_tdls_peers(mvm);
 3271 
 3272                 if (sta->tdls) {
 3273                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
 3274                                                    NL80211_TDLS_ENABLE_LINK);
 3275                 } else {
 3276                         /* enable beacon filtering */
 3277                         WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
 3278 
 3279                         mvmvif->authorized = 1;
 3280 
 3281                         /*
 3282                          * Now that the station is authorized, i.e., keys were already
 3283                          * installed, need to indicate to the FW that
 3284                          * multicast data frames can be forwarded to the driver
 3285                          */
 3286                         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3287                         iwl_mvm_mei_host_associated(mvm, vif, mvm_sta);
 3288                 }
 3289 
 3290                 iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
 3291                                      true);
 3292         } else if (old_state == IEEE80211_STA_AUTHORIZED &&
 3293                    new_state == IEEE80211_STA_ASSOC) {
 3294                 /* once we move into assoc state, need to update rate scale to
 3295                  * disable using wide bandwidth
 3296                  */
 3297                 iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
 3298                                      false);
 3299                 if (!sta->tdls) {
 3300                         /* Multicast data frames are no longer allowed */
 3301                         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3302 
 3303                         /*
 3304                          * Set this after the above iwl_mvm_mac_ctxt_changed()
 3305                          * to avoid sending high prio again for a little time.
 3306                          */
 3307                         mvmvif->authorized = 0;
 3308 
 3309                         /* disable beacon filtering */
 3310                         ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
 3311                         WARN_ON(ret &&
 3312                                 !test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
 3313                                           &mvm->status));
 3314                 }
 3315                 ret = 0;
 3316         } else if (old_state == IEEE80211_STA_ASSOC &&
 3317                    new_state == IEEE80211_STA_AUTH) {
 3318                 if (vif->type == NL80211_IFTYPE_AP) {
 3319                         mvmvif->ap_assoc_sta_count--;
 3320                         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3321                 } else if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls)
 3322                         iwl_mvm_stop_session_protection(mvm, vif);
 3323                 ret = 0;
 3324         } else if (old_state == IEEE80211_STA_AUTH &&
 3325                    new_state == IEEE80211_STA_NONE) {
 3326                 ret = 0;
 3327         } else if (old_state == IEEE80211_STA_NONE &&
 3328                    new_state == IEEE80211_STA_NOTEXIST) {
 3329                 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls)
 3330                         iwl_mvm_stop_session_protection(mvm, vif);
 3331                 ret = iwl_mvm_rm_sta(mvm, vif, sta);
 3332                 if (sta->tdls) {
 3333                         iwl_mvm_recalc_tdls_state(mvm, vif, false);
 3334                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
 3335                                                    NL80211_TDLS_DISABLE_LINK);
 3336                 }
 3337 
 3338                 if (unlikely(ret &&
 3339                              test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
 3340                                       &mvm->status)))
 3341                         ret = 0;
 3342         } else {
 3343                 ret = -EIO;
 3344         }
 3345  out_unlock:
 3346         mutex_unlock(&mvm->mutex);
 3347 
 3348         if (sta->tdls && ret == 0) {
 3349                 if (old_state == IEEE80211_STA_NOTEXIST &&
 3350                     new_state == IEEE80211_STA_NONE)
 3351                         ieee80211_reserve_tid(sta, IWL_MVM_TDLS_FW_TID);
 3352                 else if (old_state == IEEE80211_STA_NONE &&
 3353                          new_state == IEEE80211_STA_NOTEXIST)
 3354                         ieee80211_unreserve_tid(sta, IWL_MVM_TDLS_FW_TID);
 3355         }
 3356 
 3357         return ret;
 3358 }
 3359 
 3360 static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
 3361 {
 3362         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3363 
 3364         mvm->rts_threshold = value;
 3365 
 3366         return 0;
 3367 }
 3368 
 3369 static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw,
 3370                                   struct ieee80211_vif *vif,
 3371                                   struct ieee80211_sta *sta, u32 changed)
 3372 {
 3373         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3374         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3375 
 3376         if (changed & (IEEE80211_RC_BW_CHANGED |
 3377                        IEEE80211_RC_SUPP_RATES_CHANGED |
 3378                        IEEE80211_RC_NSS_CHANGED))
 3379                 iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
 3380                                      true);
 3381 
 3382         if (vif->type == NL80211_IFTYPE_STATION &&
 3383             changed & IEEE80211_RC_NSS_CHANGED)
 3384                 iwl_mvm_sf_update(mvm, vif, false);
 3385 }
 3386 
 3387 static int iwl_mvm_mac_conf_tx(struct ieee80211_hw *hw,
 3388                                struct ieee80211_vif *vif,
 3389                                unsigned int link_id, u16 ac,
 3390                                const struct ieee80211_tx_queue_params *params)
 3391 {
 3392         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3393         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3394 
 3395         mvmvif->queue_params[ac] = *params;
 3396 
 3397         /*
 3398          * No need to update right away, we'll get BSS_CHANGED_QOS
 3399          * The exception is P2P_DEVICE interface which needs immediate update.
 3400          */
 3401         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
 3402                 int ret;
 3403 
 3404                 mutex_lock(&mvm->mutex);
 3405                 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 3406                 mutex_unlock(&mvm->mutex);
 3407                 return ret;
 3408         }
 3409         return 0;
 3410 }
 3411 
 3412 static void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw *hw,
 3413                                        struct ieee80211_vif *vif,
 3414                                        struct ieee80211_prep_tx_info *info)
 3415 {
 3416         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3417 
 3418         mutex_lock(&mvm->mutex);
 3419         iwl_mvm_protect_assoc(mvm, vif, info->duration);
 3420         mutex_unlock(&mvm->mutex);
 3421 }
 3422 
 3423 static void iwl_mvm_mac_mgd_complete_tx(struct ieee80211_hw *hw,
 3424                                         struct ieee80211_vif *vif,
 3425                                         struct ieee80211_prep_tx_info *info)
 3426 {
 3427         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3428 
 3429         /* for successful cases (auth/assoc), don't cancel session protection */
 3430         if (info->success)
 3431                 return;
 3432 
 3433         mutex_lock(&mvm->mutex);
 3434         iwl_mvm_stop_session_protection(mvm, vif);
 3435         mutex_unlock(&mvm->mutex);
 3436 }
 3437 
 3438 static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw *hw,
 3439                                         struct ieee80211_vif *vif,
 3440                                         struct cfg80211_sched_scan_request *req,
 3441                                         struct ieee80211_scan_ies *ies)
 3442 {
 3443         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3444 
 3445         int ret;
 3446 
 3447         mutex_lock(&mvm->mutex);
 3448 
 3449         if (!vif->bss_conf.idle) {
 3450                 ret = -EBUSY;
 3451                 goto out;
 3452         }
 3453 
 3454         ret = iwl_mvm_sched_scan_start(mvm, vif, req, ies, IWL_MVM_SCAN_SCHED);
 3455 
 3456 out:
 3457         mutex_unlock(&mvm->mutex);
 3458         return ret;
 3459 }
 3460 
 3461 static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw *hw,
 3462                                        struct ieee80211_vif *vif)
 3463 {
 3464         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3465         int ret;
 3466 
 3467         mutex_lock(&mvm->mutex);
 3468 
 3469         /* Due to a race condition, it's possible that mac80211 asks
 3470          * us to stop a sched_scan when it's already stopped.  This
 3471          * can happen, for instance, if we stopped the scan ourselves,
 3472          * called ieee80211_sched_scan_stopped() and the userspace called
 3473          * stop sched scan scan before ieee80211_sched_scan_stopped_work()
 3474          * could run.  To handle this, simply return if the scan is
 3475          * not running.
 3476         */
 3477         if (!(mvm->scan_status & IWL_MVM_SCAN_SCHED)) {
 3478                 mutex_unlock(&mvm->mutex);
 3479                 return 0;
 3480         }
 3481 
 3482         ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, false);
 3483         mutex_unlock(&mvm->mutex);
 3484         iwl_mvm_wait_for_async_handlers(mvm);
 3485 
 3486         return ret;
 3487 }
 3488 
 3489 static int __iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
 3490                                  enum set_key_cmd cmd,
 3491                                  struct ieee80211_vif *vif,
 3492                                  struct ieee80211_sta *sta,
 3493                                  struct ieee80211_key_conf *key)
 3494 {
 3495         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3496         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3497         struct iwl_mvm_sta *mvmsta = NULL;
 3498         struct iwl_mvm_key_pn *ptk_pn;
 3499         int keyidx = key->keyidx;
 3500         int ret, i;
 3501         u8 key_offset;
 3502 
 3503         if (sta)
 3504                 mvmsta = iwl_mvm_sta_from_mac80211(sta);
 3505 
 3506         switch (key->cipher) {
 3507         case WLAN_CIPHER_SUITE_TKIP:
 3508                 if (!mvm->trans->trans_cfg->gen2) {
 3509                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
 3510                         key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
 3511                 } else if (vif->type == NL80211_IFTYPE_STATION) {
 3512                         key->flags |= IEEE80211_KEY_FLAG_PUT_MIC_SPACE;
 3513                 } else {
 3514                         IWL_DEBUG_MAC80211(mvm, "Use SW encryption for TKIP\n");
 3515                         return -EOPNOTSUPP;
 3516                 }
 3517                 break;
 3518         case WLAN_CIPHER_SUITE_CCMP:
 3519         case WLAN_CIPHER_SUITE_GCMP:
 3520         case WLAN_CIPHER_SUITE_GCMP_256:
 3521                 if (!iwl_mvm_has_new_tx_api(mvm))
 3522                         key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
 3523                 break;
 3524         case WLAN_CIPHER_SUITE_AES_CMAC:
 3525         case WLAN_CIPHER_SUITE_BIP_GMAC_128:
 3526         case WLAN_CIPHER_SUITE_BIP_GMAC_256:
 3527                 WARN_ON_ONCE(!ieee80211_hw_check(hw, MFP_CAPABLE));
 3528                 break;
 3529         case WLAN_CIPHER_SUITE_WEP40:
 3530         case WLAN_CIPHER_SUITE_WEP104:
 3531                 if (vif->type == NL80211_IFTYPE_STATION)
 3532                         break;
 3533                 if (iwl_mvm_has_new_tx_api(mvm))
 3534                         return -EOPNOTSUPP;
 3535                 /* support HW crypto on TX */
 3536                 return 0;
 3537         default:
 3538                 return -EOPNOTSUPP;
 3539         }
 3540 
 3541         switch (cmd) {
 3542         case SET_KEY:
 3543                 if (keyidx == 6 || keyidx == 7)
 3544                         rcu_assign_pointer(mvmvif->bcn_prot.keys[keyidx - 6],
 3545                                            key);
 3546 
 3547                 if ((vif->type == NL80211_IFTYPE_ADHOC ||
 3548                      vif->type == NL80211_IFTYPE_AP) && !sta) {
 3549                         /*
 3550                          * GTK on AP interface is a TX-only key, return 0;
 3551                          * on IBSS they're per-station and because we're lazy
 3552                          * we don't support them for RX, so do the same.
 3553                          * CMAC/GMAC in AP/IBSS modes must be done in software.
 3554                          */
 3555                         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
 3556                             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
 3557                             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256) {
 3558                                 ret = -EOPNOTSUPP;
 3559                                 break;
 3560                         }
 3561 
 3562                         if (key->cipher != WLAN_CIPHER_SUITE_GCMP &&
 3563                             key->cipher != WLAN_CIPHER_SUITE_GCMP_256 &&
 3564                             !iwl_mvm_has_new_tx_api(mvm)) {
 3565                                 key->hw_key_idx = STA_KEY_IDX_INVALID;
 3566                                 ret = 0;
 3567                                 break;
 3568                         }
 3569 
 3570                         if (!mvmvif->ap_ibss_active) {
 3571                                 for (i = 0;
 3572                                      i < ARRAY_SIZE(mvmvif->ap_early_keys);
 3573                                      i++) {
 3574                                         if (!mvmvif->ap_early_keys[i]) {
 3575                                                 mvmvif->ap_early_keys[i] = key;
 3576                                                 break;
 3577                                         }
 3578                                 }
 3579 
 3580                                 if (i >= ARRAY_SIZE(mvmvif->ap_early_keys))
 3581                                         ret = -ENOSPC;
 3582                                 else
 3583                                         ret = 0;
 3584 
 3585                                 break;
 3586                         }
 3587                 }
 3588 
 3589                 /* During FW restart, in order to restore the state as it was,
 3590                  * don't try to reprogram keys we previously failed for.
 3591                  */
 3592                 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
 3593                     key->hw_key_idx == STA_KEY_IDX_INVALID) {
 3594                         IWL_DEBUG_MAC80211(mvm,
 3595                                            "skip invalid idx key programming during restart\n");
 3596                         ret = 0;
 3597                         break;
 3598                 }
 3599 
 3600                 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
 3601                     mvmsta && iwl_mvm_has_new_rx_api(mvm) &&
 3602                     key->flags & IEEE80211_KEY_FLAG_PAIRWISE &&
 3603                     (key->cipher == WLAN_CIPHER_SUITE_CCMP ||
 3604                      key->cipher == WLAN_CIPHER_SUITE_GCMP ||
 3605                      key->cipher == WLAN_CIPHER_SUITE_GCMP_256)) {
 3606                         struct ieee80211_key_seq seq;
 3607                         int tid, q;
 3608 
 3609                         WARN_ON(rcu_access_pointer(mvmsta->ptk_pn[keyidx]));
 3610                         ptk_pn = kzalloc(struct_size(ptk_pn, q,
 3611                                                      mvm->trans->num_rx_queues),
 3612                                          GFP_KERNEL);
 3613                         if (!ptk_pn) {
 3614                                 ret = -ENOMEM;
 3615                                 break;
 3616                         }
 3617 
 3618                         for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
 3619                                 ieee80211_get_key_rx_seq(key, tid, &seq);
 3620                                 for (q = 0; q < mvm->trans->num_rx_queues; q++)
 3621                                         memcpy(ptk_pn->q[q].pn[tid],
 3622                                                seq.ccmp.pn,
 3623                                                IEEE80211_CCMP_PN_LEN);
 3624                         }
 3625 
 3626                         rcu_assign_pointer(mvmsta->ptk_pn[keyidx], ptk_pn);
 3627                 }
 3628 
 3629                 /* in HW restart reuse the index, otherwise request a new one */
 3630                 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
 3631                         key_offset = key->hw_key_idx;
 3632                 else
 3633                         key_offset = STA_KEY_IDX_INVALID;
 3634 
 3635                 if (mvmsta && key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
 3636                         mvmsta->pairwise_cipher = key->cipher;
 3637 
 3638                 IWL_DEBUG_MAC80211(mvm, "set hwcrypto key\n");
 3639                 ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);
 3640                 if (ret) {
 3641                         IWL_WARN(mvm, "set key failed\n");
 3642                         key->hw_key_idx = STA_KEY_IDX_INVALID;
 3643                         /*
 3644                          * can't add key for RX, but we don't need it
 3645                          * in the device for TX so still return 0,
 3646                          * unless we have new TX API where we cannot
 3647                          * put key material into the TX_CMD
 3648                          */
 3649                         if (iwl_mvm_has_new_tx_api(mvm))
 3650                                 ret = -EOPNOTSUPP;
 3651                         else
 3652                                 ret = 0;
 3653                 }
 3654 
 3655                 break;
 3656         case DISABLE_KEY:
 3657                 if (keyidx == 6 || keyidx == 7)
 3658                         RCU_INIT_POINTER(mvmvif->bcn_prot.keys[keyidx - 6],
 3659                                          NULL);
 3660 
 3661                 ret = -ENOENT;
 3662                 for (i = 0; i < ARRAY_SIZE(mvmvif->ap_early_keys); i++) {
 3663                         if (mvmvif->ap_early_keys[i] == key) {
 3664                                 mvmvif->ap_early_keys[i] = NULL;
 3665                                 ret = 0;
 3666                         }
 3667                 }
 3668 
 3669                 /* found in pending list - don't do anything else */
 3670                 if (ret == 0)
 3671                         break;
 3672 
 3673                 if (key->hw_key_idx == STA_KEY_IDX_INVALID) {
 3674                         ret = 0;
 3675                         break;
 3676                 }
 3677 
 3678                 if (mvmsta && iwl_mvm_has_new_rx_api(mvm) &&
 3679                     key->flags & IEEE80211_KEY_FLAG_PAIRWISE &&
 3680                     (key->cipher == WLAN_CIPHER_SUITE_CCMP ||
 3681                      key->cipher == WLAN_CIPHER_SUITE_GCMP ||
 3682                      key->cipher == WLAN_CIPHER_SUITE_GCMP_256)) {
 3683                         ptk_pn = rcu_dereference_protected(
 3684                                                 mvmsta->ptk_pn[keyidx],
 3685                                                 lockdep_is_held(&mvm->mutex));
 3686                         RCU_INIT_POINTER(mvmsta->ptk_pn[keyidx], NULL);
 3687                         if (ptk_pn)
 3688                                 kfree_rcu(ptk_pn, rcu_head);
 3689                 }
 3690 
 3691                 IWL_DEBUG_MAC80211(mvm, "disable hwcrypto key\n");
 3692                 ret = iwl_mvm_remove_sta_key(mvm, vif, sta, key);
 3693                 break;
 3694         default:
 3695                 ret = -EINVAL;
 3696         }
 3697 
 3698         return ret;
 3699 }
 3700 
 3701 static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
 3702                                enum set_key_cmd cmd,
 3703                                struct ieee80211_vif *vif,
 3704                                struct ieee80211_sta *sta,
 3705                                struct ieee80211_key_conf *key)
 3706 {
 3707         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3708         int ret;
 3709 
 3710         mutex_lock(&mvm->mutex);
 3711         ret = __iwl_mvm_mac_set_key(hw, cmd, vif, sta, key);
 3712         mutex_unlock(&mvm->mutex);
 3713 
 3714         return ret;
 3715 }
 3716 
 3717 static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw *hw,
 3718                                         struct ieee80211_vif *vif,
 3719                                         struct ieee80211_key_conf *keyconf,
 3720                                         struct ieee80211_sta *sta,
 3721                                         u32 iv32, u16 *phase1key)
 3722 {
 3723         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3724 
 3725         if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID)
 3726                 return;
 3727 
 3728         iwl_mvm_update_tkip_key(mvm, vif, keyconf, sta, iv32, phase1key);
 3729 }
 3730 
 3731 
 3732 static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data *notif_wait,
 3733                                struct iwl_rx_packet *pkt, void *data)
 3734 {
 3735         struct iwl_mvm *mvm =
 3736                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 3737         struct iwl_hs20_roc_res *resp;
 3738         int resp_len = iwl_rx_packet_payload_len(pkt);
 3739         struct iwl_mvm_time_event_data *te_data = data;
 3740 
 3741         if (WARN_ON(pkt->hdr.cmd != HOT_SPOT_CMD))
 3742                 return true;
 3743 
 3744         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
 3745                 IWL_ERR(mvm, "Invalid HOT_SPOT_CMD response\n");
 3746                 return true;
 3747         }
 3748 
 3749         resp = (void *)pkt->data;
 3750 
 3751         IWL_DEBUG_TE(mvm,
 3752                      "Aux ROC: Received response from ucode: status=%d uid=%d\n",
 3753                      resp->status, resp->event_unique_id);
 3754 
 3755         te_data->uid = le32_to_cpu(resp->event_unique_id);
 3756         IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n",
 3757                      te_data->uid);
 3758 
 3759         spin_lock_bh(&mvm->time_event_lock);
 3760         list_add_tail(&te_data->list, &mvm->aux_roc_te_list);
 3761         spin_unlock_bh(&mvm->time_event_lock);
 3762 
 3763         return true;
 3764 }
 3765 
 3766 #define AUX_ROC_MIN_DURATION MSEC_TO_TU(100)
 3767 #define AUX_ROC_MIN_DELAY MSEC_TO_TU(200)
 3768 #define AUX_ROC_MAX_DELAY MSEC_TO_TU(600)
 3769 #define AUX_ROC_SAFETY_BUFFER MSEC_TO_TU(20)
 3770 #define AUX_ROC_MIN_SAFETY_BUFFER MSEC_TO_TU(10)
 3771 static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm *mvm,
 3772                                     struct ieee80211_channel *channel,
 3773                                     struct ieee80211_vif *vif,
 3774                                     int duration)
 3775 {
 3776         int res;
 3777         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3778         struct iwl_mvm_time_event_data *te_data = &mvmvif->hs_time_event_data;
 3779         static const u16 time_event_response[] = { HOT_SPOT_CMD };
 3780         struct iwl_notification_wait wait_time_event;
 3781         u32 dtim_interval = vif->bss_conf.dtim_period *
 3782                 vif->bss_conf.beacon_int;
 3783         u32 req_dur, delay;
 3784         struct iwl_hs20_roc_req aux_roc_req = {
 3785                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
 3786                 .id_and_color =
 3787                         cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
 3788                 .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
 3789         };
 3790         struct iwl_hs20_roc_req_tail *tail = iwl_mvm_chan_info_cmd_tail(mvm,
 3791                 &aux_roc_req.channel_info);
 3792         u16 len = sizeof(aux_roc_req) - iwl_mvm_chan_info_padding(mvm);
 3793 
 3794         /* Set the channel info data */
 3795         iwl_mvm_set_chan_info(mvm, &aux_roc_req.channel_info, channel->hw_value,
 3796                               iwl_mvm_phy_band_from_nl80211(channel->band),
 3797                               PHY_VHT_CHANNEL_MODE20,
 3798                               0);
 3799 
 3800         /* Set the time and duration */
 3801         tail->apply_time = cpu_to_le32(iwl_mvm_get_systime(mvm));
 3802 
 3803         delay = AUX_ROC_MIN_DELAY;
 3804         req_dur = MSEC_TO_TU(duration);
 3805 
 3806         /*
 3807          * If we are associated we want the delay time to be at least one
 3808          * dtim interval so that the FW can wait until after the DTIM and
 3809          * then start the time event, this will potentially allow us to
 3810          * remain off-channel for the max duration.
 3811          * Since we want to use almost a whole dtim interval we would also
 3812          * like the delay to be for 2-3 dtim intervals, in case there are
 3813          * other time events with higher priority.
 3814          */
 3815         if (vif->bss_conf.assoc) {
 3816                 delay = min_t(u32, dtim_interval * 3, AUX_ROC_MAX_DELAY);
 3817                 /* We cannot remain off-channel longer than the DTIM interval */
 3818                 if (dtim_interval <= req_dur) {
 3819                         req_dur = dtim_interval - AUX_ROC_SAFETY_BUFFER;
 3820                         if (req_dur <= AUX_ROC_MIN_DURATION)
 3821                                 req_dur = dtim_interval -
 3822                                         AUX_ROC_MIN_SAFETY_BUFFER;
 3823                 }
 3824         }
 3825 
 3826         tail->duration = cpu_to_le32(req_dur);
 3827         tail->apply_time_max_delay = cpu_to_le32(delay);
 3828 
 3829         IWL_DEBUG_TE(mvm,
 3830                      "ROC: Requesting to remain on channel %u for %ums\n",
 3831                      channel->hw_value, req_dur);
 3832         IWL_DEBUG_TE(mvm,
 3833                      "\t(requested = %ums, max_delay = %ums, dtim_interval = %ums)\n",
 3834                      duration, delay, dtim_interval);
 3835 
 3836         /* Set the node address */
 3837         memcpy(tail->node_addr, vif->addr, ETH_ALEN);
 3838 
 3839         lockdep_assert_held(&mvm->mutex);
 3840 
 3841         spin_lock_bh(&mvm->time_event_lock);
 3842 
 3843         if (WARN_ON(te_data->id == HOT_SPOT_CMD)) {
 3844                 spin_unlock_bh(&mvm->time_event_lock);
 3845                 return -EIO;
 3846         }
 3847 
 3848         te_data->vif = vif;
 3849         te_data->duration = duration;
 3850         te_data->id = HOT_SPOT_CMD;
 3851 
 3852         spin_unlock_bh(&mvm->time_event_lock);
 3853 
 3854         /*
 3855          * Use a notification wait, which really just processes the
 3856          * command response and doesn't wait for anything, in order
 3857          * to be able to process the response and get the UID inside
 3858          * the RX path. Using CMD_WANT_SKB doesn't work because it
 3859          * stores the buffer and then wakes up this thread, by which
 3860          * time another notification (that the time event started)
 3861          * might already be processed unsuccessfully.
 3862          */
 3863         iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event,
 3864                                    time_event_response,
 3865                                    ARRAY_SIZE(time_event_response),
 3866                                    iwl_mvm_rx_aux_roc, te_data);
 3867 
 3868         res = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0, len,
 3869                                    &aux_roc_req);
 3870 
 3871         if (res) {
 3872                 IWL_ERR(mvm, "Couldn't send HOT_SPOT_CMD: %d\n", res);
 3873                 iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
 3874                 goto out_clear_te;
 3875         }
 3876 
 3877         /* No need to wait for anything, so just pass 1 (0 isn't valid) */
 3878         res = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
 3879         /* should never fail */
 3880         WARN_ON_ONCE(res);
 3881 
 3882         if (res) {
 3883  out_clear_te:
 3884                 spin_lock_bh(&mvm->time_event_lock);
 3885                 iwl_mvm_te_clear_data(mvm, te_data);
 3886                 spin_unlock_bh(&mvm->time_event_lock);
 3887         }
 3888 
 3889         return res;
 3890 }
 3891 
 3892 static int iwl_mvm_roc(struct ieee80211_hw *hw,
 3893                        struct ieee80211_vif *vif,
 3894                        struct ieee80211_channel *channel,
 3895                        int duration,
 3896                        enum ieee80211_roc_type type)
 3897 {
 3898         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 3899         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 3900         struct cfg80211_chan_def chandef;
 3901         struct iwl_mvm_phy_ctxt *phy_ctxt;
 3902         bool band_change_removal;
 3903         int ret, i;
 3904 
 3905         IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value,
 3906                            duration, type);
 3907 
 3908         /*
 3909          * Flush the done work, just in case it's still pending, so that
 3910          * the work it does can complete and we can accept new frames.
 3911          */
 3912         flush_work(&mvm->roc_done_wk);
 3913 
 3914         mutex_lock(&mvm->mutex);
 3915 
 3916         switch (vif->type) {
 3917         case NL80211_IFTYPE_STATION:
 3918                 if (fw_has_capa(&mvm->fw->ucode_capa,
 3919                                 IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT)) {
 3920                         /* Use aux roc framework (HS20) */
 3921                         if (iwl_fw_lookup_cmd_ver(mvm->fw, ADD_STA, 0) >= 12) {
 3922                                 u32 lmac_id;
 3923 
 3924                                 lmac_id = iwl_mvm_get_lmac_id(mvm->fw,
 3925                                                               channel->band);
 3926                                 ret = iwl_mvm_add_aux_sta(mvm, lmac_id);
 3927                                 if (WARN(ret,
 3928                                          "Failed to allocate aux station"))
 3929                                         goto out_unlock;
 3930                         }
 3931                         ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
 3932                                                        vif, duration);
 3933                         goto out_unlock;
 3934                 }
 3935                 IWL_ERR(mvm, "hotspot not supported\n");
 3936                 ret = -EINVAL;
 3937                 goto out_unlock;
 3938         case NL80211_IFTYPE_P2P_DEVICE:
 3939                 /* handle below */
 3940                 break;
 3941         default:
 3942                 IWL_ERR(mvm, "vif isn't P2P_DEVICE: %d\n", vif->type);
 3943                 ret = -EINVAL;
 3944                 goto out_unlock;
 3945         }
 3946 
 3947         for (i = 0; i < NUM_PHY_CTX; i++) {
 3948                 phy_ctxt = &mvm->phy_ctxts[i];
 3949                 if (phy_ctxt->ref == 0 || mvmvif->phy_ctxt == phy_ctxt)
 3950                         continue;
 3951 
 3952                 if (phy_ctxt->ref && channel == phy_ctxt->channel) {
 3953                         /*
 3954                          * Unbind the P2P_DEVICE from the current PHY context,
 3955                          * and if the PHY context is not used remove it.
 3956                          */
 3957                         ret = iwl_mvm_binding_remove_vif(mvm, vif);
 3958                         if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
 3959                                 goto out_unlock;
 3960 
 3961                         iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
 3962 
 3963                         /* Bind the P2P_DEVICE to the current PHY Context */
 3964                         mvmvif->phy_ctxt = phy_ctxt;
 3965 
 3966                         ret = iwl_mvm_binding_add_vif(mvm, vif);
 3967                         if (WARN(ret, "Failed binding P2P_DEVICE\n"))
 3968                                 goto out_unlock;
 3969 
 3970                         iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
 3971                         goto schedule_time_event;
 3972                 }
 3973         }
 3974 
 3975         /* Need to update the PHY context only if the ROC channel changed */
 3976         if (channel == mvmvif->phy_ctxt->channel)
 3977                 goto schedule_time_event;
 3978 
 3979         cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
 3980 
 3981         /*
 3982          * Check if the remain-on-channel is on a different band and that
 3983          * requires context removal, see iwl_mvm_phy_ctxt_changed(). If
 3984          * so, we'll need to release and then re-configure here, since we
 3985          * must not remove a PHY context that's part of a binding.
 3986          */
 3987         band_change_removal =
 3988                 fw_has_capa(&mvm->fw->ucode_capa,
 3989                             IWL_UCODE_TLV_CAPA_BINDING_CDB_SUPPORT) &&
 3990                 mvmvif->phy_ctxt->channel->band != chandef.chan->band;
 3991 
 3992         if (mvmvif->phy_ctxt->ref == 1 && !band_change_removal) {
 3993                 /*
 3994                  * Change the PHY context configuration as it is currently
 3995                  * referenced only by the P2P Device MAC (and we can modify it)
 3996                  */
 3997                 ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt,
 3998                                                &chandef, 1, 1);
 3999                 if (ret)
 4000                         goto out_unlock;
 4001         } else {
 4002                 /*
 4003                  * The PHY context is shared with other MACs (or we're trying to
 4004                  * switch bands), so remove the P2P Device from the binding,
 4005                  * allocate an new PHY context and create a new binding.
 4006                  */
 4007                 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
 4008                 if (!phy_ctxt) {
 4009                         ret = -ENOSPC;
 4010                         goto out_unlock;
 4011                 }
 4012 
 4013                 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chandef,
 4014                                                1, 1);
 4015                 if (ret) {
 4016                         IWL_ERR(mvm, "Failed to change PHY context\n");
 4017                         goto out_unlock;
 4018                 }
 4019 
 4020                 /* Unbind the P2P_DEVICE from the current PHY context */
 4021                 ret = iwl_mvm_binding_remove_vif(mvm, vif);
 4022                 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
 4023                         goto out_unlock;
 4024 
 4025                 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
 4026 
 4027                 /* Bind the P2P_DEVICE to the new allocated PHY context */
 4028                 mvmvif->phy_ctxt = phy_ctxt;
 4029 
 4030                 ret = iwl_mvm_binding_add_vif(mvm, vif);
 4031                 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
 4032                         goto out_unlock;
 4033 
 4034                 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
 4035         }
 4036 
 4037 schedule_time_event:
 4038         /* Schedule the time events */
 4039         ret = iwl_mvm_start_p2p_roc(mvm, vif, duration, type);
 4040 
 4041 out_unlock:
 4042         mutex_unlock(&mvm->mutex);
 4043         IWL_DEBUG_MAC80211(mvm, "leave\n");
 4044         return ret;
 4045 }
 4046 
 4047 static int iwl_mvm_cancel_roc(struct ieee80211_hw *hw,
 4048                               struct ieee80211_vif *vif)
 4049 {
 4050         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4051 
 4052         IWL_DEBUG_MAC80211(mvm, "enter\n");
 4053 
 4054         mutex_lock(&mvm->mutex);
 4055         iwl_mvm_stop_roc(mvm, vif);
 4056         mutex_unlock(&mvm->mutex);
 4057 
 4058         IWL_DEBUG_MAC80211(mvm, "leave\n");
 4059         return 0;
 4060 }
 4061 
 4062 struct iwl_mvm_ftm_responder_iter_data {
 4063         bool responder;
 4064         struct ieee80211_chanctx_conf *ctx;
 4065 };
 4066 
 4067 static void iwl_mvm_ftm_responder_chanctx_iter(void *_data, u8 *mac,
 4068                                                struct ieee80211_vif *vif)
 4069 {
 4070         struct iwl_mvm_ftm_responder_iter_data *data = _data;
 4071 
 4072         if (rcu_access_pointer(vif->chanctx_conf) == data->ctx &&
 4073             vif->type == NL80211_IFTYPE_AP && vif->bss_conf.ftmr_params)
 4074                 data->responder = true;
 4075 }
 4076 
 4077 static bool iwl_mvm_is_ftm_responder_chanctx(struct iwl_mvm *mvm,
 4078                                              struct ieee80211_chanctx_conf *ctx)
 4079 {
 4080         struct iwl_mvm_ftm_responder_iter_data data = {
 4081                 .responder = false,
 4082                 .ctx = ctx,
 4083         };
 4084 
 4085         ieee80211_iterate_active_interfaces_atomic(mvm->hw,
 4086                                         IEEE80211_IFACE_ITER_NORMAL,
 4087                                         iwl_mvm_ftm_responder_chanctx_iter,
 4088                                         &data);
 4089         return data.responder;
 4090 }
 4091 
 4092 static int __iwl_mvm_add_chanctx(struct iwl_mvm *mvm,
 4093                                  struct ieee80211_chanctx_conf *ctx)
 4094 {
 4095         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
 4096         struct iwl_mvm_phy_ctxt *phy_ctxt;
 4097         bool responder = iwl_mvm_is_ftm_responder_chanctx(mvm, ctx);
 4098         struct cfg80211_chan_def *def = responder ? &ctx->def : &ctx->min_def;
 4099         int ret;
 4100 
 4101         lockdep_assert_held(&mvm->mutex);
 4102 
 4103         IWL_DEBUG_MAC80211(mvm, "Add channel context\n");
 4104 
 4105         phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
 4106         if (!phy_ctxt) {
 4107                 ret = -ENOSPC;
 4108                 goto out;
 4109         }
 4110 
 4111         ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, def,
 4112                                        ctx->rx_chains_static,
 4113                                        ctx->rx_chains_dynamic);
 4114         if (ret) {
 4115                 IWL_ERR(mvm, "Failed to add PHY context\n");
 4116                 goto out;
 4117         }
 4118 
 4119         iwl_mvm_phy_ctxt_ref(mvm, phy_ctxt);
 4120         *phy_ctxt_id = phy_ctxt->id;
 4121 out:
 4122         return ret;
 4123 }
 4124 
 4125 static int iwl_mvm_add_chanctx(struct ieee80211_hw *hw,
 4126                                struct ieee80211_chanctx_conf *ctx)
 4127 {
 4128         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4129         int ret;
 4130 
 4131         mutex_lock(&mvm->mutex);
 4132         ret = __iwl_mvm_add_chanctx(mvm, ctx);
 4133         mutex_unlock(&mvm->mutex);
 4134 
 4135         return ret;
 4136 }
 4137 
 4138 static void __iwl_mvm_remove_chanctx(struct iwl_mvm *mvm,
 4139                                      struct ieee80211_chanctx_conf *ctx)
 4140 {
 4141         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
 4142         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
 4143 
 4144         lockdep_assert_held(&mvm->mutex);
 4145 
 4146         iwl_mvm_phy_ctxt_unref(mvm, phy_ctxt);
 4147 }
 4148 
 4149 static void iwl_mvm_remove_chanctx(struct ieee80211_hw *hw,
 4150                                    struct ieee80211_chanctx_conf *ctx)
 4151 {
 4152         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4153 
 4154         mutex_lock(&mvm->mutex);
 4155         __iwl_mvm_remove_chanctx(mvm, ctx);
 4156         mutex_unlock(&mvm->mutex);
 4157 }
 4158 
 4159 static void iwl_mvm_change_chanctx(struct ieee80211_hw *hw,
 4160                                    struct ieee80211_chanctx_conf *ctx,
 4161                                    u32 changed)
 4162 {
 4163         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4164         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
 4165         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
 4166         bool responder = iwl_mvm_is_ftm_responder_chanctx(mvm, ctx);
 4167         struct cfg80211_chan_def *def = responder ? &ctx->def : &ctx->min_def;
 4168 
 4169         if (WARN_ONCE((phy_ctxt->ref > 1) &&
 4170                       (changed & ~(IEEE80211_CHANCTX_CHANGE_WIDTH |
 4171                                    IEEE80211_CHANCTX_CHANGE_RX_CHAINS |
 4172                                    IEEE80211_CHANCTX_CHANGE_RADAR |
 4173                                    IEEE80211_CHANCTX_CHANGE_MIN_WIDTH)),
 4174                       "Cannot change PHY. Ref=%d, changed=0x%X\n",
 4175                       phy_ctxt->ref, changed))
 4176                 return;
 4177 
 4178         mutex_lock(&mvm->mutex);
 4179 
 4180         /* we are only changing the min_width, may be a noop */
 4181         if (changed == IEEE80211_CHANCTX_CHANGE_MIN_WIDTH) {
 4182                 if (phy_ctxt->width == def->width)
 4183                         goto out_unlock;
 4184 
 4185                 /* we are just toggling between 20_NOHT and 20 */
 4186                 if (phy_ctxt->width <= NL80211_CHAN_WIDTH_20 &&
 4187                     def->width <= NL80211_CHAN_WIDTH_20)
 4188                         goto out_unlock;
 4189         }
 4190 
 4191         iwl_mvm_bt_coex_vif_change(mvm);
 4192         iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, def,
 4193                                  ctx->rx_chains_static,
 4194                                  ctx->rx_chains_dynamic);
 4195 
 4196 out_unlock:
 4197         mutex_unlock(&mvm->mutex);
 4198 }
 4199 
 4200 static int __iwl_mvm_assign_vif_chanctx(struct iwl_mvm *mvm,
 4201                                         struct ieee80211_vif *vif,
 4202                                         struct ieee80211_chanctx_conf *ctx,
 4203                                         bool switching_chanctx)
 4204 {
 4205         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
 4206         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
 4207         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4208         int ret;
 4209 
 4210         lockdep_assert_held(&mvm->mutex);
 4211 
 4212         mvmvif->phy_ctxt = phy_ctxt;
 4213 
 4214         switch (vif->type) {
 4215         case NL80211_IFTYPE_AP:
 4216                 /* only needed if we're switching chanctx (i.e. during CSA) */
 4217                 if (switching_chanctx) {
 4218                         mvmvif->ap_ibss_active = true;
 4219                         break;
 4220                 }
 4221                 fallthrough;
 4222         case NL80211_IFTYPE_ADHOC:
 4223                 /*
 4224                  * The AP binding flow is handled as part of the start_ap flow
 4225                  * (in bss_info_changed), similarly for IBSS.
 4226                  */
 4227                 ret = 0;
 4228                 goto out;
 4229         case NL80211_IFTYPE_STATION:
 4230                 mvmvif->csa_bcn_pending = false;
 4231                 break;
 4232         case NL80211_IFTYPE_MONITOR:
 4233                 /* always disable PS when a monitor interface is active */
 4234                 mvmvif->ps_disabled = true;
 4235                 break;
 4236         default:
 4237                 ret = -EINVAL;
 4238                 goto out;
 4239         }
 4240 
 4241         ret = iwl_mvm_binding_add_vif(mvm, vif);
 4242         if (ret)
 4243                 goto out;
 4244 
 4245         /*
 4246          * Power state must be updated before quotas,
 4247          * otherwise fw will complain.
 4248          */
 4249         iwl_mvm_power_update_mac(mvm);
 4250 
 4251         /* Setting the quota at this stage is only required for monitor
 4252          * interfaces. For the other types, the bss_info changed flow
 4253          * will handle quota settings.
 4254          */
 4255         if (vif->type == NL80211_IFTYPE_MONITOR) {
 4256                 mvmvif->monitor_active = true;
 4257                 ret = iwl_mvm_update_quotas(mvm, false, NULL);
 4258                 if (ret)
 4259                         goto out_remove_binding;
 4260 
 4261                 ret = iwl_mvm_add_snif_sta(mvm, vif);
 4262                 if (ret)
 4263                         goto out_remove_binding;
 4264 
 4265         }
 4266 
 4267         /* Handle binding during CSA */
 4268         if (vif->type == NL80211_IFTYPE_AP) {
 4269                 iwl_mvm_update_quotas(mvm, false, NULL);
 4270                 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
 4271         }
 4272 
 4273         if (switching_chanctx && vif->type == NL80211_IFTYPE_STATION) {
 4274                 mvmvif->csa_bcn_pending = true;
 4275 
 4276                 if (!fw_has_capa(&mvm->fw->ucode_capa,
 4277                                  IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD)) {
 4278                         u32 duration = 3 * vif->bss_conf.beacon_int;
 4279 
 4280                         /* Protect the session to make sure we hear the first
 4281                          * beacon on the new channel.
 4282                          */
 4283                         iwl_mvm_protect_session(mvm, vif, duration, duration,
 4284                                                 vif->bss_conf.beacon_int / 2,
 4285                                                 true);
 4286                 }
 4287 
 4288                 iwl_mvm_update_quotas(mvm, false, NULL);
 4289         }
 4290 
 4291         goto out;
 4292 
 4293 out_remove_binding:
 4294         iwl_mvm_binding_remove_vif(mvm, vif);
 4295         iwl_mvm_power_update_mac(mvm);
 4296 out:
 4297         if (ret)
 4298                 mvmvif->phy_ctxt = NULL;
 4299         return ret;
 4300 }
 4301 static int iwl_mvm_assign_vif_chanctx(struct ieee80211_hw *hw,
 4302                                       struct ieee80211_vif *vif,
 4303                                       struct ieee80211_bss_conf *link_conf,
 4304                                       struct ieee80211_chanctx_conf *ctx)
 4305 {
 4306         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4307         int ret;
 4308 
 4309         mutex_lock(&mvm->mutex);
 4310         ret = __iwl_mvm_assign_vif_chanctx(mvm, vif, ctx, false);
 4311         mutex_unlock(&mvm->mutex);
 4312 
 4313         return ret;
 4314 }
 4315 
 4316 static void __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm *mvm,
 4317                                            struct ieee80211_vif *vif,
 4318                                            struct ieee80211_chanctx_conf *ctx,
 4319                                            bool switching_chanctx)
 4320 {
 4321         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4322         struct ieee80211_vif *disabled_vif = NULL;
 4323 
 4324         lockdep_assert_held(&mvm->mutex);
 4325         iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
 4326 
 4327         switch (vif->type) {
 4328         case NL80211_IFTYPE_ADHOC:
 4329                 goto out;
 4330         case NL80211_IFTYPE_MONITOR:
 4331                 mvmvif->monitor_active = false;
 4332                 mvmvif->ps_disabled = false;
 4333                 iwl_mvm_rm_snif_sta(mvm, vif);
 4334                 break;
 4335         case NL80211_IFTYPE_AP:
 4336                 /* This part is triggered only during CSA */
 4337                 if (!switching_chanctx || !mvmvif->ap_ibss_active)
 4338                         goto out;
 4339 
 4340                 mvmvif->csa_countdown = false;
 4341 
 4342                 /* Set CS bit on all the stations */
 4343                 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true);
 4344 
 4345                 /* Save blocked iface, the timeout is set on the next beacon */
 4346                 rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif);
 4347 
 4348                 mvmvif->ap_ibss_active = false;
 4349                 break;
 4350         case NL80211_IFTYPE_STATION:
 4351                 if (!switching_chanctx)
 4352                         break;
 4353 
 4354                 disabled_vif = vif;
 4355 
 4356                 if (!fw_has_capa(&mvm->fw->ucode_capa,
 4357                                  IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD))
 4358                         iwl_mvm_mac_ctxt_changed(mvm, vif, true, NULL);
 4359                 break;
 4360         default:
 4361                 break;
 4362         }
 4363 
 4364         iwl_mvm_update_quotas(mvm, false, disabled_vif);
 4365         iwl_mvm_binding_remove_vif(mvm, vif);
 4366 
 4367 out:
 4368         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD) &&
 4369             switching_chanctx)
 4370                 return;
 4371         mvmvif->phy_ctxt = NULL;
 4372         iwl_mvm_power_update_mac(mvm);
 4373 }
 4374 
 4375 static void iwl_mvm_unassign_vif_chanctx(struct ieee80211_hw *hw,
 4376                                          struct ieee80211_vif *vif,
 4377                                          struct ieee80211_bss_conf *link_conf,
 4378                                          struct ieee80211_chanctx_conf *ctx)
 4379 {
 4380         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4381 
 4382         mutex_lock(&mvm->mutex);
 4383         __iwl_mvm_unassign_vif_chanctx(mvm, vif, ctx, false);
 4384         mutex_unlock(&mvm->mutex);
 4385 }
 4386 
 4387 static int
 4388 iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm *mvm,
 4389                                 struct ieee80211_vif_chanctx_switch *vifs)
 4390 {
 4391         int ret;
 4392 
 4393         mutex_lock(&mvm->mutex);
 4394         __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
 4395         __iwl_mvm_remove_chanctx(mvm, vifs[0].old_ctx);
 4396 
 4397         ret = __iwl_mvm_add_chanctx(mvm, vifs[0].new_ctx);
 4398         if (ret) {
 4399                 IWL_ERR(mvm, "failed to add new_ctx during channel switch\n");
 4400                 goto out_reassign;
 4401         }
 4402 
 4403         ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
 4404                                            true);
 4405         if (ret) {
 4406                 IWL_ERR(mvm,
 4407                         "failed to assign new_ctx during channel switch\n");
 4408                 goto out_remove;
 4409         }
 4410 
 4411         /* we don't support TDLS during DCM - can be caused by channel switch */
 4412         if (iwl_mvm_phy_ctx_count(mvm) > 1)
 4413                 iwl_mvm_teardown_tdls_peers(mvm);
 4414 
 4415         goto out;
 4416 
 4417 out_remove:
 4418         __iwl_mvm_remove_chanctx(mvm, vifs[0].new_ctx);
 4419 
 4420 out_reassign:
 4421         if (__iwl_mvm_add_chanctx(mvm, vifs[0].old_ctx)) {
 4422                 IWL_ERR(mvm, "failed to add old_ctx back after failure.\n");
 4423                 goto out_restart;
 4424         }
 4425 
 4426         if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
 4427                                          true)) {
 4428                 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
 4429                 goto out_restart;
 4430         }
 4431 
 4432         goto out;
 4433 
 4434 out_restart:
 4435         /* things keep failing, better restart the hw */
 4436         iwl_mvm_nic_restart(mvm, false);
 4437 
 4438 out:
 4439         mutex_unlock(&mvm->mutex);
 4440 
 4441         return ret;
 4442 }
 4443 
 4444 static int
 4445 iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm *mvm,
 4446                                     struct ieee80211_vif_chanctx_switch *vifs)
 4447 {
 4448         int ret;
 4449 
 4450         mutex_lock(&mvm->mutex);
 4451         __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
 4452 
 4453         ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
 4454                                            true);
 4455         if (ret) {
 4456                 IWL_ERR(mvm,
 4457                         "failed to assign new_ctx during channel switch\n");
 4458                 goto out_reassign;
 4459         }
 4460 
 4461         goto out;
 4462 
 4463 out_reassign:
 4464         if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
 4465                                          true)) {
 4466                 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
 4467                 goto out_restart;
 4468         }
 4469 
 4470         goto out;
 4471 
 4472 out_restart:
 4473         /* things keep failing, better restart the hw */
 4474         iwl_mvm_nic_restart(mvm, false);
 4475 
 4476 out:
 4477         mutex_unlock(&mvm->mutex);
 4478 
 4479         return ret;
 4480 }
 4481 
 4482 static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw *hw,
 4483                                       struct ieee80211_vif_chanctx_switch *vifs,
 4484                                       int n_vifs,
 4485                                       enum ieee80211_chanctx_switch_mode mode)
 4486 {
 4487         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4488         int ret;
 4489 
 4490         /* we only support a single-vif right now */
 4491         if (n_vifs > 1)
 4492                 return -EOPNOTSUPP;
 4493 
 4494         switch (mode) {
 4495         case CHANCTX_SWMODE_SWAP_CONTEXTS:
 4496                 ret = iwl_mvm_switch_vif_chanctx_swap(mvm, vifs);
 4497                 break;
 4498         case CHANCTX_SWMODE_REASSIGN_VIF:
 4499                 ret = iwl_mvm_switch_vif_chanctx_reassign(mvm, vifs);
 4500                 break;
 4501         default:
 4502                 ret = -EOPNOTSUPP;
 4503                 break;
 4504         }
 4505 
 4506         return ret;
 4507 }
 4508 
 4509 static int iwl_mvm_tx_last_beacon(struct ieee80211_hw *hw)
 4510 {
 4511         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4512 
 4513         return mvm->ibss_manager;
 4514 }
 4515 
 4516 static int iwl_mvm_set_tim(struct ieee80211_hw *hw,
 4517                            struct ieee80211_sta *sta,
 4518                            bool set)
 4519 {
 4520         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4521         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
 4522 
 4523         if (!mvm_sta || !mvm_sta->vif) {
 4524                 IWL_ERR(mvm, "Station is not associated to a vif\n");
 4525                 return -EINVAL;
 4526         }
 4527 
 4528         return iwl_mvm_mac_ctxt_beacon_changed(mvm, mvm_sta->vif);
 4529 }
 4530 
 4531 #ifdef CONFIG_NL80211_TESTMODE
 4532 static const struct nla_policy iwl_mvm_tm_policy[IWL_MVM_TM_ATTR_MAX + 1] = {
 4533         [IWL_MVM_TM_ATTR_CMD] = { .type = NLA_U32 },
 4534         [IWL_MVM_TM_ATTR_NOA_DURATION] = { .type = NLA_U32 },
 4535         [IWL_MVM_TM_ATTR_BEACON_FILTER_STATE] = { .type = NLA_U32 },
 4536 };
 4537 
 4538 static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm *mvm,
 4539                                       struct ieee80211_vif *vif,
 4540                                       void *data, int len)
 4541 {
 4542         struct nlattr *tb[IWL_MVM_TM_ATTR_MAX + 1];
 4543         int err;
 4544         u32 noa_duration;
 4545 
 4546         err = nla_parse_deprecated(tb, IWL_MVM_TM_ATTR_MAX, data, len,
 4547                                    iwl_mvm_tm_policy, NULL);
 4548         if (err)
 4549                 return err;
 4550 
 4551         if (!tb[IWL_MVM_TM_ATTR_CMD])
 4552                 return -EINVAL;
 4553 
 4554         switch (nla_get_u32(tb[IWL_MVM_TM_ATTR_CMD])) {
 4555         case IWL_MVM_TM_CMD_SET_NOA:
 4556                 if (!vif || vif->type != NL80211_IFTYPE_AP || !vif->p2p ||
 4557                     !vif->bss_conf.enable_beacon ||
 4558                     !tb[IWL_MVM_TM_ATTR_NOA_DURATION])
 4559                         return -EINVAL;
 4560 
 4561                 noa_duration = nla_get_u32(tb[IWL_MVM_TM_ATTR_NOA_DURATION]);
 4562                 if (noa_duration >= vif->bss_conf.beacon_int)
 4563                         return -EINVAL;
 4564 
 4565                 mvm->noa_duration = noa_duration;
 4566                 mvm->noa_vif = vif;
 4567 
 4568                 return iwl_mvm_update_quotas(mvm, true, NULL);
 4569         case IWL_MVM_TM_CMD_SET_BEACON_FILTER:
 4570                 /* must be associated client vif - ignore authorized */
 4571                 if (!vif || vif->type != NL80211_IFTYPE_STATION ||
 4572                     !vif->bss_conf.assoc || !vif->bss_conf.dtim_period ||
 4573                     !tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE])
 4574                         return -EINVAL;
 4575 
 4576                 if (nla_get_u32(tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE]))
 4577                         return iwl_mvm_enable_beacon_filter(mvm, vif, 0);
 4578                 return iwl_mvm_disable_beacon_filter(mvm, vif, 0);
 4579         }
 4580 
 4581         return -EOPNOTSUPP;
 4582 }
 4583 
 4584 static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw *hw,
 4585                                     struct ieee80211_vif *vif,
 4586                                     void *data, int len)
 4587 {
 4588         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4589         int err;
 4590 
 4591         mutex_lock(&mvm->mutex);
 4592         err = __iwl_mvm_mac_testmode_cmd(mvm, vif, data, len);
 4593         mutex_unlock(&mvm->mutex);
 4594 
 4595         return err;
 4596 }
 4597 #endif
 4598 
 4599 static void iwl_mvm_channel_switch(struct ieee80211_hw *hw,
 4600                                    struct ieee80211_vif *vif,
 4601                                    struct ieee80211_channel_switch *chsw)
 4602 {
 4603         /* By implementing this operation, we prevent mac80211 from
 4604          * starting its own channel switch timer, so that we can call
 4605          * ieee80211_chswitch_done() ourselves at the right time
 4606          * (which is when the absence time event starts).
 4607          */
 4608 
 4609         IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw),
 4610                            "dummy channel switch op\n");
 4611 }
 4612 
 4613 static int iwl_mvm_schedule_client_csa(struct iwl_mvm *mvm,
 4614                                        struct ieee80211_vif *vif,
 4615                                        struct ieee80211_channel_switch *chsw)
 4616 {
 4617         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4618         struct iwl_chan_switch_te_cmd cmd = {
 4619                 .mac_id = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
 4620                                                           mvmvif->color)),
 4621                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
 4622                 .tsf = cpu_to_le32(chsw->timestamp),
 4623                 .cs_count = chsw->count,
 4624                 .cs_mode = chsw->block_tx,
 4625         };
 4626 
 4627         lockdep_assert_held(&mvm->mutex);
 4628 
 4629         if (chsw->delay)
 4630                 cmd.cs_delayed_bcn_count =
 4631                         DIV_ROUND_UP(chsw->delay, vif->bss_conf.beacon_int);
 4632 
 4633         return iwl_mvm_send_cmd_pdu(mvm,
 4634                                     WIDE_ID(MAC_CONF_GROUP,
 4635                                             CHANNEL_SWITCH_TIME_EVENT_CMD),
 4636                                     0, sizeof(cmd), &cmd);
 4637 }
 4638 
 4639 static int iwl_mvm_old_pre_chan_sw_sta(struct iwl_mvm *mvm,
 4640                                        struct ieee80211_vif *vif,
 4641                                        struct ieee80211_channel_switch *chsw)
 4642 {
 4643         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4644         u32 apply_time;
 4645 
 4646         /* Schedule the time event to a bit before beacon 1,
 4647          * to make sure we're in the new channel when the
 4648          * GO/AP arrives. In case count <= 1 immediately schedule the
 4649          * TE (this might result with some packet loss or connection
 4650          * loss).
 4651          */
 4652         if (chsw->count <= 1)
 4653                 apply_time = 0;
 4654         else
 4655                 apply_time = chsw->device_timestamp +
 4656                         ((vif->bss_conf.beacon_int * (chsw->count - 1) -
 4657                           IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT) * 1024);
 4658 
 4659         if (chsw->block_tx)
 4660                 iwl_mvm_csa_client_absent(mvm, vif);
 4661 
 4662         if (mvmvif->bf_data.bf_enabled) {
 4663                 int ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
 4664 
 4665                 if (ret)
 4666                         return ret;
 4667         }
 4668 
 4669         iwl_mvm_schedule_csa_period(mvm, vif, vif->bss_conf.beacon_int,
 4670                                     apply_time);
 4671 
 4672         return 0;
 4673 }
 4674 
 4675 #define IWL_MAX_CSA_BLOCK_TX 1500
 4676 static int iwl_mvm_pre_channel_switch(struct ieee80211_hw *hw,
 4677                                       struct ieee80211_vif *vif,
 4678                                       struct ieee80211_channel_switch *chsw)
 4679 {
 4680         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4681         struct ieee80211_vif *csa_vif;
 4682         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4683         int ret;
 4684 
 4685         mutex_lock(&mvm->mutex);
 4686 
 4687         mvmvif->csa_failed = false;
 4688 
 4689         IWL_DEBUG_MAC80211(mvm, "pre CSA to freq %d\n",
 4690                            chsw->chandef.center_freq1);
 4691 
 4692         iwl_fw_dbg_trigger_simple_stop(&mvm->fwrt,
 4693                                        ieee80211_vif_to_wdev(vif),
 4694                                        FW_DBG_TRIGGER_CHANNEL_SWITCH);
 4695 
 4696         switch (vif->type) {
 4697         case NL80211_IFTYPE_AP:
 4698                 csa_vif =
 4699                         rcu_dereference_protected(mvm->csa_vif,
 4700                                                   lockdep_is_held(&mvm->mutex));
 4701                 if (WARN_ONCE(csa_vif && csa_vif->csa_active,
 4702                               "Another CSA is already in progress")) {
 4703                         ret = -EBUSY;
 4704                         goto out_unlock;
 4705                 }
 4706 
 4707                 /* we still didn't unblock tx. prevent new CS meanwhile */
 4708                 if (rcu_dereference_protected(mvm->csa_tx_blocked_vif,
 4709                                               lockdep_is_held(&mvm->mutex))) {
 4710                         ret = -EBUSY;
 4711                         goto out_unlock;
 4712                 }
 4713 
 4714                 rcu_assign_pointer(mvm->csa_vif, vif);
 4715 
 4716                 if (WARN_ONCE(mvmvif->csa_countdown,
 4717                               "Previous CSA countdown didn't complete")) {
 4718                         ret = -EBUSY;
 4719                         goto out_unlock;
 4720                 }
 4721 
 4722                 mvmvif->csa_target_freq = chsw->chandef.chan->center_freq;
 4723 
 4724                 break;
 4725         case NL80211_IFTYPE_STATION:
 4726                 /*
 4727                  * In the new flow FW is in charge of timing the switch so there
 4728                  * is no need for all of this
 4729                  */
 4730                 if (iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP,
 4731                                             CHANNEL_SWITCH_ERROR_NOTIF,
 4732                                             0))
 4733                         break;
 4734 
 4735                 /*
 4736                  * We haven't configured the firmware to be associated yet since
 4737                  * we don't know the dtim period. In this case, the firmware can't
 4738                  * track the beacons.
 4739                  */
 4740                 if (!vif->bss_conf.assoc || !vif->bss_conf.dtim_period) {
 4741                         ret = -EBUSY;
 4742                         goto out_unlock;
 4743                 }
 4744 
 4745                 if (chsw->delay > IWL_MAX_CSA_BLOCK_TX)
 4746                         schedule_delayed_work(&mvmvif->csa_work, 0);
 4747 
 4748                 if (chsw->block_tx) {
 4749                         /*
 4750                          * In case of undetermined / long time with immediate
 4751                          * quiet monitor status to gracefully disconnect
 4752                          */
 4753                         if (!chsw->count ||
 4754                             chsw->count * vif->bss_conf.beacon_int >
 4755                             IWL_MAX_CSA_BLOCK_TX)
 4756                                 schedule_delayed_work(&mvmvif->csa_work,
 4757                                                       msecs_to_jiffies(IWL_MAX_CSA_BLOCK_TX));
 4758                 }
 4759 
 4760                 if (!fw_has_capa(&mvm->fw->ucode_capa,
 4761                                  IWL_UCODE_TLV_CAPA_CHANNEL_SWITCH_CMD)) {
 4762                         ret = iwl_mvm_old_pre_chan_sw_sta(mvm, vif, chsw);
 4763                         if (ret)
 4764                                 goto out_unlock;
 4765                 } else {
 4766                         iwl_mvm_schedule_client_csa(mvm, vif, chsw);
 4767                 }
 4768 
 4769                 mvmvif->csa_count = chsw->count;
 4770                 mvmvif->csa_misbehave = false;
 4771                 break;
 4772         default:
 4773                 break;
 4774         }
 4775 
 4776         mvmvif->ps_disabled = true;
 4777 
 4778         ret = iwl_mvm_power_update_ps(mvm);
 4779         if (ret)
 4780                 goto out_unlock;
 4781 
 4782         /* we won't be on this channel any longer */
 4783         iwl_mvm_teardown_tdls_peers(mvm);
 4784 
 4785 out_unlock:
 4786         mutex_unlock(&mvm->mutex);
 4787 
 4788         return ret;
 4789 }
 4790 
 4791 static void iwl_mvm_channel_switch_rx_beacon(struct ieee80211_hw *hw,
 4792                                              struct ieee80211_vif *vif,
 4793                                              struct ieee80211_channel_switch *chsw)
 4794 {
 4795         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4796         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4797         struct iwl_chan_switch_te_cmd cmd = {
 4798                 .mac_id = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
 4799                                                           mvmvif->color)),
 4800                 .action = cpu_to_le32(FW_CTXT_ACTION_MODIFY),
 4801                 .tsf = cpu_to_le32(chsw->timestamp),
 4802                 .cs_count = chsw->count,
 4803                 .cs_mode = chsw->block_tx,
 4804         };
 4805 
 4806         /*
 4807          * In the new flow FW is in charge of timing the switch so there is no
 4808          * need for all of this
 4809          */
 4810         if (iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP,
 4811                                     CHANNEL_SWITCH_ERROR_NOTIF, 0))
 4812                 return;
 4813 
 4814         if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_CS_MODIFY))
 4815                 return;
 4816 
 4817         IWL_DEBUG_MAC80211(mvm, "Modify CSA on mac %d count = %d (old %d) mode = %d\n",
 4818                            mvmvif->id, chsw->count, mvmvif->csa_count, chsw->block_tx);
 4819 
 4820         if (chsw->count >= mvmvif->csa_count && chsw->block_tx) {
 4821                 if (mvmvif->csa_misbehave) {
 4822                         /* Second time, give up on this AP*/
 4823                         iwl_mvm_abort_channel_switch(hw, vif);
 4824                         ieee80211_chswitch_done(vif, false);
 4825                         mvmvif->csa_misbehave = false;
 4826                         return;
 4827                 }
 4828                 mvmvif->csa_misbehave = true;
 4829         }
 4830         mvmvif->csa_count = chsw->count;
 4831 
 4832         mutex_lock(&mvm->mutex);
 4833         if (mvmvif->csa_failed)
 4834                 goto out_unlock;
 4835 
 4836         WARN_ON(iwl_mvm_send_cmd_pdu(mvm,
 4837                                      WIDE_ID(MAC_CONF_GROUP,
 4838                                              CHANNEL_SWITCH_TIME_EVENT_CMD),
 4839                                      0, sizeof(cmd), &cmd));
 4840 out_unlock:
 4841         mutex_unlock(&mvm->mutex);
 4842 }
 4843 
 4844 static void iwl_mvm_flush_no_vif(struct iwl_mvm *mvm, u32 queues, bool drop)
 4845 {
 4846         int i;
 4847 
 4848         if (!iwl_mvm_has_new_tx_api(mvm)) {
 4849                 if (drop) {
 4850                         mutex_lock(&mvm->mutex);
 4851                         iwl_mvm_flush_tx_path(mvm,
 4852                                 iwl_mvm_flushable_queues(mvm) & queues);
 4853                         mutex_unlock(&mvm->mutex);
 4854                 } else {
 4855                         iwl_trans_wait_tx_queues_empty(mvm->trans, queues);
 4856                 }
 4857                 return;
 4858         }
 4859 
 4860         mutex_lock(&mvm->mutex);
 4861         for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++) {
 4862                 struct ieee80211_sta *sta;
 4863 
 4864                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
 4865                                                 lockdep_is_held(&mvm->mutex));
 4866                 if (IS_ERR_OR_NULL(sta))
 4867                         continue;
 4868 
 4869                 if (drop)
 4870                         iwl_mvm_flush_sta_tids(mvm, i, 0xFFFF);
 4871                 else
 4872                         iwl_mvm_wait_sta_queues_empty(mvm,
 4873                                         iwl_mvm_sta_from_mac80211(sta));
 4874         }
 4875         mutex_unlock(&mvm->mutex);
 4876 }
 4877 
 4878 static void iwl_mvm_mac_flush(struct ieee80211_hw *hw,
 4879                               struct ieee80211_vif *vif, u32 queues, bool drop)
 4880 {
 4881         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4882         struct iwl_mvm_vif *mvmvif;
 4883         struct iwl_mvm_sta *mvmsta;
 4884         struct ieee80211_sta *sta;
 4885         int i;
 4886         u32 msk = 0;
 4887 
 4888         if (!vif) {
 4889                 iwl_mvm_flush_no_vif(mvm, queues, drop);
 4890                 return;
 4891         }
 4892 
 4893         if (vif->type != NL80211_IFTYPE_STATION)
 4894                 return;
 4895 
 4896         /* Make sure we're done with the deferred traffic before flushing */
 4897         flush_work(&mvm->add_stream_wk);
 4898 
 4899         mutex_lock(&mvm->mutex);
 4900         mvmvif = iwl_mvm_vif_from_mac80211(vif);
 4901 
 4902         /* flush the AP-station and all TDLS peers */
 4903         for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++) {
 4904                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
 4905                                                 lockdep_is_held(&mvm->mutex));
 4906                 if (IS_ERR_OR_NULL(sta))
 4907                         continue;
 4908 
 4909                 mvmsta = iwl_mvm_sta_from_mac80211(sta);
 4910                 if (mvmsta->vif != vif)
 4911                         continue;
 4912 
 4913                 /* make sure only TDLS peers or the AP are flushed */
 4914                 WARN_ON(i != mvmvif->ap_sta_id && !sta->tdls);
 4915 
 4916                 if (drop) {
 4917                         if (iwl_mvm_flush_sta(mvm, mvmsta, false))
 4918                                 IWL_ERR(mvm, "flush request fail\n");
 4919                 } else {
 4920                         msk |= mvmsta->tfd_queue_msk;
 4921                         if (iwl_mvm_has_new_tx_api(mvm))
 4922                                 iwl_mvm_wait_sta_queues_empty(mvm, mvmsta);
 4923                 }
 4924         }
 4925 
 4926         mutex_unlock(&mvm->mutex);
 4927 
 4928         /* this can take a while, and we may need/want other operations
 4929          * to succeed while doing this, so do it without the mutex held
 4930          */
 4931         if (!drop && !iwl_mvm_has_new_tx_api(mvm))
 4932                 iwl_trans_wait_tx_queues_empty(mvm->trans, msk);
 4933 }
 4934 
 4935 static int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx,
 4936                                   struct survey_info *survey)
 4937 {
 4938         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 4939         int ret;
 4940 
 4941         memset(survey, 0, sizeof(*survey));
 4942 
 4943         /* only support global statistics right now */
 4944         if (idx != 0)
 4945                 return -ENOENT;
 4946 
 4947         if (!fw_has_capa(&mvm->fw->ucode_capa,
 4948                          IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
 4949                 return -ENOENT;
 4950 
 4951         mutex_lock(&mvm->mutex);
 4952 
 4953         if (iwl_mvm_firmware_running(mvm)) {
 4954                 ret = iwl_mvm_request_statistics(mvm, false);
 4955                 if (ret)
 4956                         goto out;
 4957         }
 4958 
 4959         survey->filled = SURVEY_INFO_TIME |
 4960                          SURVEY_INFO_TIME_RX |
 4961                          SURVEY_INFO_TIME_TX |
 4962                          SURVEY_INFO_TIME_SCAN;
 4963         survey->time = mvm->accu_radio_stats.on_time_rf +
 4964                        mvm->radio_stats.on_time_rf;
 4965         do_div(survey->time, USEC_PER_MSEC);
 4966 
 4967         survey->time_rx = mvm->accu_radio_stats.rx_time +
 4968                           mvm->radio_stats.rx_time;
 4969         do_div(survey->time_rx, USEC_PER_MSEC);
 4970 
 4971         survey->time_tx = mvm->accu_radio_stats.tx_time +
 4972                           mvm->radio_stats.tx_time;
 4973         do_div(survey->time_tx, USEC_PER_MSEC);
 4974 
 4975         survey->time_scan = mvm->accu_radio_stats.on_time_scan +
 4976                             mvm->radio_stats.on_time_scan;
 4977         do_div(survey->time_scan, USEC_PER_MSEC);
 4978 
 4979         ret = 0;
 4980  out:
 4981         mutex_unlock(&mvm->mutex);
 4982         return ret;
 4983 }
 4984 
 4985 static void iwl_mvm_set_sta_rate(u32 rate_n_flags, struct rate_info *rinfo)
 4986 {
 4987         u32 format = rate_n_flags & RATE_MCS_MOD_TYPE_MSK;
 4988 
 4989         switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) {
 4990         case RATE_MCS_CHAN_WIDTH_20:
 4991                 rinfo->bw = RATE_INFO_BW_20;
 4992                 break;
 4993         case RATE_MCS_CHAN_WIDTH_40:
 4994                 rinfo->bw = RATE_INFO_BW_40;
 4995                 break;
 4996         case RATE_MCS_CHAN_WIDTH_80:
 4997                 rinfo->bw = RATE_INFO_BW_80;
 4998                 break;
 4999         case RATE_MCS_CHAN_WIDTH_160:
 5000                 rinfo->bw = RATE_INFO_BW_160;
 5001                 break;
 5002         }
 5003 
 5004         if (format == RATE_MCS_CCK_MSK ||
 5005             format == RATE_MCS_LEGACY_OFDM_MSK) {
 5006                 int rate = u32_get_bits(rate_n_flags, RATE_LEGACY_RATE_MSK);
 5007 
 5008                 /* add the offset needed to get to the legacy ofdm indices */
 5009                 if (format == RATE_MCS_LEGACY_OFDM_MSK)
 5010                         rate += IWL_FIRST_OFDM_RATE;
 5011 
 5012                 switch (rate) {
 5013                 case IWL_RATE_1M_INDEX:
 5014                         rinfo->legacy = 10;
 5015                         break;
 5016                 case IWL_RATE_2M_INDEX:
 5017                         rinfo->legacy = 20;
 5018                         break;
 5019                 case IWL_RATE_5M_INDEX:
 5020                         rinfo->legacy = 55;
 5021                         break;
 5022                 case IWL_RATE_11M_INDEX:
 5023                         rinfo->legacy = 110;
 5024                         break;
 5025                 case IWL_RATE_6M_INDEX:
 5026                         rinfo->legacy = 60;
 5027                         break;
 5028                 case IWL_RATE_9M_INDEX:
 5029                         rinfo->legacy = 90;
 5030                         break;
 5031                 case IWL_RATE_12M_INDEX:
 5032                         rinfo->legacy = 120;
 5033                         break;
 5034                 case IWL_RATE_18M_INDEX:
 5035                         rinfo->legacy = 180;
 5036                         break;
 5037                 case IWL_RATE_24M_INDEX:
 5038                         rinfo->legacy = 240;
 5039                         break;
 5040                 case IWL_RATE_36M_INDEX:
 5041                         rinfo->legacy = 360;
 5042                         break;
 5043                 case IWL_RATE_48M_INDEX:
 5044                         rinfo->legacy = 480;
 5045                         break;
 5046                 case IWL_RATE_54M_INDEX:
 5047                         rinfo->legacy = 540;
 5048                 }
 5049                 return;
 5050         }
 5051 
 5052         rinfo->nss = u32_get_bits(rate_n_flags,
 5053                                   RATE_MCS_NSS_MSK) + 1;
 5054         rinfo->mcs = format == RATE_MCS_HT_MSK ?
 5055                 RATE_HT_MCS_INDEX(rate_n_flags) :
 5056                 u32_get_bits(rate_n_flags, RATE_MCS_CODE_MSK);
 5057 
 5058         if (format == RATE_MCS_HE_MSK) {
 5059                 u32 gi_ltf = u32_get_bits(rate_n_flags,
 5060                                           RATE_MCS_HE_GI_LTF_MSK);
 5061 
 5062                 rinfo->flags |= RATE_INFO_FLAGS_HE_MCS;
 5063 
 5064                 if (rate_n_flags & RATE_MCS_HE_106T_MSK) {
 5065                         rinfo->bw = RATE_INFO_BW_HE_RU;
 5066                         rinfo->he_ru_alloc = NL80211_RATE_INFO_HE_RU_ALLOC_106;
 5067                 }
 5068 
 5069                 switch (rate_n_flags & RATE_MCS_HE_TYPE_MSK) {
 5070                 case RATE_MCS_HE_TYPE_SU:
 5071                 case RATE_MCS_HE_TYPE_EXT_SU:
 5072                         if (gi_ltf == 0 || gi_ltf == 1)
 5073                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_0_8;
 5074                         else if (gi_ltf == 2)
 5075                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_1_6;
 5076                         else if (gi_ltf == 3)
 5077                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_3_2;
 5078                         else
 5079                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_0_8;
 5080                         break;
 5081                 case RATE_MCS_HE_TYPE_MU:
 5082                         if (gi_ltf == 0 || gi_ltf == 1)
 5083                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_0_8;
 5084                         else if (gi_ltf == 2)
 5085                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_1_6;
 5086                         else
 5087                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_3_2;
 5088                         break;
 5089                 case RATE_MCS_HE_TYPE_TRIG:
 5090                         if (gi_ltf == 0 || gi_ltf == 1)
 5091                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_1_6;
 5092                         else
 5093                                 rinfo->he_gi = NL80211_RATE_INFO_HE_GI_3_2;
 5094                         break;
 5095                 }
 5096 
 5097                 if (rate_n_flags & RATE_HE_DUAL_CARRIER_MODE_MSK)
 5098                         rinfo->he_dcm = 1;
 5099                 return;
 5100         }
 5101 
 5102         if (rate_n_flags & RATE_MCS_SGI_MSK)
 5103                 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
 5104 
 5105         if (format == RATE_MCS_HT_MSK) {
 5106                 rinfo->flags |= RATE_INFO_FLAGS_MCS;
 5107 
 5108         } else if (format == RATE_MCS_VHT_MSK) {
 5109                 rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
 5110         }
 5111 
 5112 }
 5113 
 5114 static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw,
 5115                                        struct ieee80211_vif *vif,
 5116                                        struct ieee80211_sta *sta,
 5117                                        struct station_info *sinfo)
 5118 {
 5119         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5120         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 5121         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 5122 
 5123         if (mvmsta->avg_energy) {
 5124                 sinfo->signal_avg = -(s8)mvmsta->avg_energy;
 5125                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
 5126         }
 5127 
 5128         if (iwl_mvm_has_tlc_offload(mvm)) {
 5129                 struct iwl_lq_sta_rs_fw *lq_sta = &mvmsta->lq_sta.rs_fw;
 5130 
 5131                 iwl_mvm_set_sta_rate(lq_sta->last_rate_n_flags, &sinfo->txrate);
 5132                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
 5133         }
 5134 
 5135         /* if beacon filtering isn't on mac80211 does it anyway */
 5136         if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
 5137                 return;
 5138 
 5139         if (!vif->bss_conf.assoc)
 5140                 return;
 5141 
 5142         mutex_lock(&mvm->mutex);
 5143 
 5144         if (mvmvif->ap_sta_id != mvmsta->sta_id)
 5145                 goto unlock;
 5146 
 5147         if (iwl_mvm_request_statistics(mvm, false))
 5148                 goto unlock;
 5149 
 5150         sinfo->rx_beacon = mvmvif->beacon_stats.num_beacons +
 5151                            mvmvif->beacon_stats.accu_num_beacons;
 5152         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_RX);
 5153         if (mvmvif->beacon_stats.avg_signal) {
 5154                 /* firmware only reports a value after RXing a few beacons */
 5155                 sinfo->rx_beacon_signal_avg = mvmvif->beacon_stats.avg_signal;
 5156                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
 5157         }
 5158  unlock:
 5159         mutex_unlock(&mvm->mutex);
 5160 }
 5161 
 5162 static void iwl_mvm_event_mlme_callback_ini(struct iwl_mvm *mvm,
 5163                                             struct ieee80211_vif *vif,
 5164                                             const  struct ieee80211_mlme_event *mlme)
 5165 {
 5166         if ((mlme->data == ASSOC_EVENT || mlme->data == AUTH_EVENT) &&
 5167             (mlme->status == MLME_DENIED || mlme->status == MLME_TIMEOUT)) {
 5168                 iwl_dbg_tlv_time_point(&mvm->fwrt,
 5169                                        IWL_FW_INI_TIME_POINT_ASSOC_FAILED,
 5170                                        NULL);
 5171                 return;
 5172         }
 5173 
 5174         if (mlme->data == DEAUTH_RX_EVENT || mlme->data == DEAUTH_TX_EVENT) {
 5175                 iwl_dbg_tlv_time_point(&mvm->fwrt,
 5176                                        IWL_FW_INI_TIME_POINT_DEASSOC,
 5177                                        NULL);
 5178                 return;
 5179         }
 5180 }
 5181 
 5182 static void iwl_mvm_event_mlme_callback(struct iwl_mvm *mvm,
 5183                                         struct ieee80211_vif *vif,
 5184                                         const struct ieee80211_event *event)
 5185 {
 5186 #define CHECK_MLME_TRIGGER(_cnt, _fmt...)                               \
 5187         do {                                                            \
 5188                 if ((trig_mlme->_cnt) && --(trig_mlme->_cnt))           \
 5189                         break;                                          \
 5190                 iwl_fw_dbg_collect_trig(&(mvm)->fwrt, trig, _fmt);      \
 5191         } while (0)
 5192 
 5193         struct iwl_fw_dbg_trigger_tlv *trig;
 5194         struct iwl_fw_dbg_trigger_mlme *trig_mlme;
 5195 
 5196         if (iwl_trans_dbg_ini_valid(mvm->trans)) {
 5197                 iwl_mvm_event_mlme_callback_ini(mvm, vif, &event->u.mlme);
 5198                 return;
 5199         }
 5200 
 5201         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
 5202                                      FW_DBG_TRIGGER_MLME);
 5203         if (!trig)
 5204                 return;
 5205 
 5206         trig_mlme = (void *)trig->data;
 5207 
 5208         if (event->u.mlme.data == ASSOC_EVENT) {
 5209                 if (event->u.mlme.status == MLME_DENIED)
 5210                         CHECK_MLME_TRIGGER(stop_assoc_denied,
 5211                                            "DENIED ASSOC: reason %d",
 5212                                             event->u.mlme.reason);
 5213                 else if (event->u.mlme.status == MLME_TIMEOUT)
 5214                         CHECK_MLME_TRIGGER(stop_assoc_timeout,
 5215                                            "ASSOC TIMEOUT");
 5216         } else if (event->u.mlme.data == AUTH_EVENT) {
 5217                 if (event->u.mlme.status == MLME_DENIED)
 5218                         CHECK_MLME_TRIGGER(stop_auth_denied,
 5219                                            "DENIED AUTH: reason %d",
 5220                                            event->u.mlme.reason);
 5221                 else if (event->u.mlme.status == MLME_TIMEOUT)
 5222                         CHECK_MLME_TRIGGER(stop_auth_timeout,
 5223                                            "AUTH TIMEOUT");
 5224         } else if (event->u.mlme.data == DEAUTH_RX_EVENT) {
 5225                 CHECK_MLME_TRIGGER(stop_rx_deauth,
 5226                                    "DEAUTH RX %d", event->u.mlme.reason);
 5227         } else if (event->u.mlme.data == DEAUTH_TX_EVENT) {
 5228                 CHECK_MLME_TRIGGER(stop_tx_deauth,
 5229                                    "DEAUTH TX %d", event->u.mlme.reason);
 5230         }
 5231 #undef CHECK_MLME_TRIGGER
 5232 }
 5233 
 5234 static void iwl_mvm_event_bar_rx_callback(struct iwl_mvm *mvm,
 5235                                           struct ieee80211_vif *vif,
 5236                                           const struct ieee80211_event *event)
 5237 {
 5238         struct iwl_fw_dbg_trigger_tlv *trig;
 5239         struct iwl_fw_dbg_trigger_ba *ba_trig;
 5240 
 5241         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
 5242                                      FW_DBG_TRIGGER_BA);
 5243         if (!trig)
 5244                 return;
 5245 
 5246         ba_trig = (void *)trig->data;
 5247 
 5248         if (!(le16_to_cpu(ba_trig->rx_bar) & BIT(event->u.ba.tid)))
 5249                 return;
 5250 
 5251         iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
 5252                                 "BAR received from %pM, tid %d, ssn %d",
 5253                                 event->u.ba.sta->addr, event->u.ba.tid,
 5254                                 event->u.ba.ssn);
 5255 }
 5256 
 5257 static void iwl_mvm_mac_event_callback(struct ieee80211_hw *hw,
 5258                                        struct ieee80211_vif *vif,
 5259                                        const struct ieee80211_event *event)
 5260 {
 5261         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5262 
 5263         switch (event->type) {
 5264         case MLME_EVENT:
 5265                 iwl_mvm_event_mlme_callback(mvm, vif, event);
 5266                 break;
 5267         case BAR_RX_EVENT:
 5268                 iwl_mvm_event_bar_rx_callback(mvm, vif, event);
 5269                 break;
 5270         case BA_FRAME_TIMEOUT:
 5271                 iwl_mvm_event_frame_timeout_callback(mvm, vif, event->u.ba.sta,
 5272                                                      event->u.ba.tid);
 5273                 break;
 5274         default:
 5275                 break;
 5276         }
 5277 }
 5278 
 5279 void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm *mvm,
 5280                                      enum iwl_mvm_rxq_notif_type type,
 5281                                      bool sync,
 5282                                      const void *data, u32 size)
 5283 {
 5284         struct {
 5285                 struct iwl_rxq_sync_cmd cmd;
 5286                 struct iwl_mvm_internal_rxq_notif notif;
 5287         } __packed cmd = {
 5288                 .cmd.rxq_mask = cpu_to_le32(BIT(mvm->trans->num_rx_queues) - 1),
 5289                 .cmd.count =
 5290                         cpu_to_le32(sizeof(struct iwl_mvm_internal_rxq_notif) +
 5291                                     size),
 5292                 .notif.type = type,
 5293                 .notif.sync = sync,
 5294         };
 5295         struct iwl_host_cmd hcmd = {
 5296                 .id = WIDE_ID(DATA_PATH_GROUP, TRIGGER_RX_QUEUES_NOTIF_CMD),
 5297                 .data[0] = &cmd,
 5298                 .len[0] = sizeof(cmd),
 5299                 .data[1] = data,
 5300                 .len[1] = size,
 5301                 .flags = sync ? 0 : CMD_ASYNC,
 5302         };
 5303         int ret;
 5304 
 5305         /* size must be a multiple of DWORD */
 5306         if (WARN_ON(cmd.cmd.count & cpu_to_le32(3)))
 5307                 return;
 5308 
 5309         if (!iwl_mvm_has_new_rx_api(mvm))
 5310                 return;
 5311 
 5312         if (sync) {
 5313                 cmd.notif.cookie = mvm->queue_sync_cookie;
 5314                 mvm->queue_sync_state = (1 << mvm->trans->num_rx_queues) - 1;
 5315         }
 5316 
 5317         ret = iwl_mvm_send_cmd(mvm, &hcmd);
 5318         if (ret) {
 5319                 IWL_ERR(mvm, "Failed to trigger RX queues sync (%d)\n", ret);
 5320                 goto out;
 5321         }
 5322 
 5323         if (sync) {
 5324                 lockdep_assert_held(&mvm->mutex);
 5325                 ret = wait_event_timeout(mvm->rx_sync_waitq,
 5326                                          READ_ONCE(mvm->queue_sync_state) == 0 ||
 5327                                          iwl_mvm_is_radio_killed(mvm),
 5328                                          HZ);
 5329                 WARN_ONCE(!ret && !iwl_mvm_is_radio_killed(mvm),
 5330                           "queue sync: failed to sync, state is 0x%lx\n",
 5331                           mvm->queue_sync_state);
 5332         }
 5333 
 5334 out:
 5335         if (sync) {
 5336                 mvm->queue_sync_state = 0;
 5337                 mvm->queue_sync_cookie++;
 5338         }
 5339 }
 5340 
 5341 static void iwl_mvm_sync_rx_queues(struct ieee80211_hw *hw)
 5342 {
 5343         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5344 
 5345         mutex_lock(&mvm->mutex);
 5346         iwl_mvm_sync_rx_queues_internal(mvm, IWL_MVM_RXQ_EMPTY, true, NULL, 0);
 5347         mutex_unlock(&mvm->mutex);
 5348 }
 5349 
 5350 static int
 5351 iwl_mvm_mac_get_ftm_responder_stats(struct ieee80211_hw *hw,
 5352                                     struct ieee80211_vif *vif,
 5353                                     struct cfg80211_ftm_responder_stats *stats)
 5354 {
 5355         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5356         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 5357 
 5358         if (vif->p2p || vif->type != NL80211_IFTYPE_AP ||
 5359             !mvmvif->ap_ibss_active || !vif->bss_conf.ftm_responder)
 5360                 return -EINVAL;
 5361 
 5362         mutex_lock(&mvm->mutex);
 5363         *stats = mvm->ftm_resp_stats;
 5364         mutex_unlock(&mvm->mutex);
 5365 
 5366         stats->filled = BIT(NL80211_FTM_STATS_SUCCESS_NUM) |
 5367                         BIT(NL80211_FTM_STATS_PARTIAL_NUM) |
 5368                         BIT(NL80211_FTM_STATS_FAILED_NUM) |
 5369                         BIT(NL80211_FTM_STATS_ASAP_NUM) |
 5370                         BIT(NL80211_FTM_STATS_NON_ASAP_NUM) |
 5371                         BIT(NL80211_FTM_STATS_TOTAL_DURATION_MSEC) |
 5372                         BIT(NL80211_FTM_STATS_UNKNOWN_TRIGGERS_NUM) |
 5373                         BIT(NL80211_FTM_STATS_RESCHEDULE_REQUESTS_NUM) |
 5374                         BIT(NL80211_FTM_STATS_OUT_OF_WINDOW_TRIGGERS_NUM);
 5375 
 5376         return 0;
 5377 }
 5378 
 5379 static int iwl_mvm_start_pmsr(struct ieee80211_hw *hw,
 5380                               struct ieee80211_vif *vif,
 5381                               struct cfg80211_pmsr_request *request)
 5382 {
 5383         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5384         int ret;
 5385 
 5386         mutex_lock(&mvm->mutex);
 5387         ret = iwl_mvm_ftm_start(mvm, vif, request);
 5388         mutex_unlock(&mvm->mutex);
 5389 
 5390         return ret;
 5391 }
 5392 
 5393 static void iwl_mvm_abort_pmsr(struct ieee80211_hw *hw,
 5394                                struct ieee80211_vif *vif,
 5395                                struct cfg80211_pmsr_request *request)
 5396 {
 5397         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5398 
 5399         mutex_lock(&mvm->mutex);
 5400         iwl_mvm_ftm_abort(mvm, request);
 5401         mutex_unlock(&mvm->mutex);
 5402 }
 5403 
 5404 static bool iwl_mvm_can_hw_csum(struct sk_buff *skb)
 5405 {
 5406         u8 protocol = ip_hdr(skb)->protocol;
 5407 
 5408         if (!IS_ENABLED(CONFIG_INET))
 5409                 return false;
 5410 
 5411         return protocol == IPPROTO_TCP || protocol == IPPROTO_UDP;
 5412 }
 5413 
 5414 static bool iwl_mvm_mac_can_aggregate(struct ieee80211_hw *hw,
 5415                                       struct sk_buff *head,
 5416                                       struct sk_buff *skb)
 5417 {
 5418         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 5419 
 5420         if (mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_BZ)
 5421                 return iwl_mvm_tx_csum_bz(mvm, head, true) ==
 5422                        iwl_mvm_tx_csum_bz(mvm, skb, true);
 5423 
 5424         /* For now don't aggregate IPv6 in AMSDU */
 5425         if (skb->protocol != htons(ETH_P_IP))
 5426                 return false;
 5427 
 5428         if (!iwl_mvm_is_csum_supported(mvm))
 5429                 return true;
 5430 
 5431         return iwl_mvm_can_hw_csum(skb) == iwl_mvm_can_hw_csum(head);
 5432 }
 5433 
 5434 const struct ieee80211_ops iwl_mvm_hw_ops = {
 5435         .tx = iwl_mvm_mac_tx,
 5436         .wake_tx_queue = iwl_mvm_mac_wake_tx_queue,
 5437         .ampdu_action = iwl_mvm_mac_ampdu_action,
 5438         .get_antenna = iwl_mvm_op_get_antenna,
 5439         .start = iwl_mvm_mac_start,
 5440         .reconfig_complete = iwl_mvm_mac_reconfig_complete,
 5441         .stop = iwl_mvm_mac_stop,
 5442         .add_interface = iwl_mvm_mac_add_interface,
 5443         .remove_interface = iwl_mvm_mac_remove_interface,
 5444         .config = iwl_mvm_mac_config,
 5445         .prepare_multicast = iwl_mvm_prepare_multicast,
 5446         .configure_filter = iwl_mvm_configure_filter,
 5447         .config_iface_filter = iwl_mvm_config_iface_filter,
 5448         .bss_info_changed = iwl_mvm_bss_info_changed,
 5449         .hw_scan = iwl_mvm_mac_hw_scan,
 5450         .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan,
 5451         .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove,
 5452         .sta_state = iwl_mvm_mac_sta_state,
 5453         .sta_notify = iwl_mvm_mac_sta_notify,
 5454         .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames,
 5455         .release_buffered_frames = iwl_mvm_mac_release_buffered_frames,
 5456         .set_rts_threshold = iwl_mvm_mac_set_rts_threshold,
 5457         .sta_rc_update = iwl_mvm_sta_rc_update,
 5458         .conf_tx = iwl_mvm_mac_conf_tx,
 5459         .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx,
 5460         .mgd_complete_tx = iwl_mvm_mac_mgd_complete_tx,
 5461         .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover,
 5462         .flush = iwl_mvm_mac_flush,
 5463         .sched_scan_start = iwl_mvm_mac_sched_scan_start,
 5464         .sched_scan_stop = iwl_mvm_mac_sched_scan_stop,
 5465         .set_key = iwl_mvm_mac_set_key,
 5466         .update_tkip_key = iwl_mvm_mac_update_tkip_key,
 5467         .remain_on_channel = iwl_mvm_roc,
 5468         .cancel_remain_on_channel = iwl_mvm_cancel_roc,
 5469         .add_chanctx = iwl_mvm_add_chanctx,
 5470         .remove_chanctx = iwl_mvm_remove_chanctx,
 5471         .change_chanctx = iwl_mvm_change_chanctx,
 5472         .assign_vif_chanctx = iwl_mvm_assign_vif_chanctx,
 5473         .unassign_vif_chanctx = iwl_mvm_unassign_vif_chanctx,
 5474         .switch_vif_chanctx = iwl_mvm_switch_vif_chanctx,
 5475 
 5476         .start_ap = iwl_mvm_start_ap,
 5477         .stop_ap = iwl_mvm_stop_ap,
 5478         .join_ibss = iwl_mvm_start_ibss,
 5479         .leave_ibss = iwl_mvm_stop_ibss,
 5480 
 5481         .tx_last_beacon = iwl_mvm_tx_last_beacon,
 5482 
 5483         .set_tim = iwl_mvm_set_tim,
 5484 
 5485         .channel_switch = iwl_mvm_channel_switch,
 5486         .pre_channel_switch = iwl_mvm_pre_channel_switch,
 5487         .post_channel_switch = iwl_mvm_post_channel_switch,
 5488         .abort_channel_switch = iwl_mvm_abort_channel_switch,
 5489         .channel_switch_rx_beacon = iwl_mvm_channel_switch_rx_beacon,
 5490 
 5491         .tdls_channel_switch = iwl_mvm_tdls_channel_switch,
 5492         .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch,
 5493         .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch,
 5494 
 5495         .event_callback = iwl_mvm_mac_event_callback,
 5496 
 5497         .sync_rx_queues = iwl_mvm_sync_rx_queues,
 5498 
 5499         CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd)
 5500 
 5501 #ifdef CONFIG_PM_SLEEP
 5502         /* look at d3.c */
 5503         .suspend = iwl_mvm_suspend,
 5504         .resume = iwl_mvm_resume,
 5505         .set_wakeup = iwl_mvm_set_wakeup,
 5506         .set_rekey_data = iwl_mvm_set_rekey_data,
 5507 #if IS_ENABLED(CONFIG_IPV6)
 5508         .ipv6_addr_change = iwl_mvm_ipv6_addr_change,
 5509 #endif
 5510         .set_default_unicast_key = iwl_mvm_set_default_unicast_key,
 5511 #endif
 5512         .get_survey = iwl_mvm_mac_get_survey,
 5513         .sta_statistics = iwl_mvm_mac_sta_statistics,
 5514         .get_ftm_responder_stats = iwl_mvm_mac_get_ftm_responder_stats,
 5515         .start_pmsr = iwl_mvm_start_pmsr,
 5516         .abort_pmsr = iwl_mvm_abort_pmsr,
 5517 
 5518         .can_aggregate_in_amsdu = iwl_mvm_mac_can_aggregate,
 5519 #ifdef CONFIG_IWLWIFI_DEBUGFS
 5520         .sta_add_debugfs = iwl_mvm_sta_add_debugfs,
 5521 #endif
 5522 };

Cache object: 275aa09bf9275439b842dca0be7562dd


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.