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

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of version 2 of the GNU General Public License as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  23  * USA
  24  *
  25  * The full GNU General Public License is included in this distribution
  26  * in the file called COPYING.
  27  *
  28  * Contact Information:
  29  *  Intel Linux Wireless <ilw@linux.intel.com>
  30  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  31  *
  32  * BSD LICENSE
  33  *
  34  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  35  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  *
  42  *  * Redistributions of source code must retain the above copyright
  43  *    notice, this list of conditions and the following disclaimer.
  44  *  * Redistributions in binary form must reproduce the above copyright
  45  *    notice, this list of conditions and the following disclaimer in
  46  *    the documentation and/or other materials provided with the
  47  *    distribution.
  48  *  * Neither the name Intel Corporation nor the names of its
  49  *    contributors may be used to endorse or promote products derived
  50  *    from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  53  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  54  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  55  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  56  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  57  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  58  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  59  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  60  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  61  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63  *
  64  *****************************************************************************/
  65 #include <linux/kernel.h>
  66 #include <linux/slab.h>
  67 #include <linux/skbuff.h>
  68 #include <linux/netdevice.h>
  69 #include <linux/etherdevice.h>
  70 #include <linux/ip.h>
  71 #include <linux/if_arp.h>
  72 #include <linux/devcoredump.h>
  73 #include <linux/time.h>
  74 #include <net/mac80211.h>
  75 #include <net/ieee80211_radiotap.h>
  76 #include <net/tcp.h>
  77
  78 #include "iwl-op-mode.h"
  79 #include "iwl-io.h"
  80 #include "mvm.h"
  81 #include "sta.h"
  82 #include "time-event.h"
  83 #include "iwl-eeprom-parse.h"
  84 #include "iwl-phy-db.h"
  85 #include "testmode.h"
  86 #include "iwl-fw-error-dump.h"
  87 #include "iwl-prph.h"
  88 #include "iwl-csr.h"
  89 #include "iwl-nvm-parse.h"
  90 #include "fw-dbg.h"
  91
  92 static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
  93         {
  94                 .max = 1,
  95                 .types = BIT(NL80211_IFTYPE_STATION),
  96         },
  97         {
  98                 .max = 1,
  99                 .types = BIT(NL80211_IFTYPE_AP) |
 100                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
 101                         BIT(NL80211_IFTYPE_P2P_GO),
 102         },
 103         {
 104                 .max = 1,
 105                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
 106         },
 107 };
 108
 109 static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
 110         {
 111                 .num_different_channels = 2,
 112                 .max_interfaces = 3,
 113                 .limits = iwl_mvm_limits,
 114                 .n_limits = ARRAY_SIZE(iwl_mvm_limits),
 115         },
 116 };
 117
 118 #ifdef CONFIG_PM_SLEEP
 119 static const struct nl80211_wowlan_tcp_data_token_feature
 120 iwl_mvm_wowlan_tcp_token_feature = {
 121         .min_len = 0,
 122         .max_len = 255,
 123         .bufsize = IWL_WOWLAN_REMOTE_WAKE_MAX_TOKENS,
 124 };
 125
 126 static const struct wiphy_wowlan_tcp_support iwl_mvm_wowlan_tcp_support = {
 127         .tok = &iwl_mvm_wowlan_tcp_token_feature,
 128         .data_payload_max = IWL_WOWLAN_TCP_MAX_PACKET_LEN -
 129                             sizeof(struct ethhdr) -
 130                             sizeof(struct iphdr) -
 131                             sizeof(struct tcphdr),
 132         .data_interval_max = 65535, /* __le16 in API */
 133         .wake_payload_max = IWL_WOWLAN_REMOTE_WAKE_MAX_PACKET_LEN -
 134                             sizeof(struct ethhdr) -
 135                             sizeof(struct iphdr) -
 136                             sizeof(struct tcphdr),
 137         .seq = true,
 138 };
 139 #endif
 140
 141 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
 142 /*
 143  * Use the reserved field to indicate magic values.
 144  * these values will only be used internally by the driver,
 145  * and won't make it to the fw (reserved will be 0).
 146  * BC_FILTER_MAGIC_IP - configure the val of this attribute to
 147  *      be the vif's ip address. in case there is not a single
 148  *      ip address (0, or more than 1), this attribute will
 149  *      be skipped.
 150  * BC_FILTER_MAGIC_MAC - set the val of this attribute to
 151  *      the LSB bytes of the vif's mac address
 152  */
 153 enum {
 154         BC_FILTER_MAGIC_NONE = 0,
 155         BC_FILTER_MAGIC_IP,
 156         BC_FILTER_MAGIC_MAC,
 157 };
 158
 159 static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters[] = {
 160         {
 161                 /* arp */
 162                 .discard = 0,
 163                 .frame_type = BCAST_FILTER_FRAME_TYPE_ALL,
 164                 .attrs = {
 165                         {
 166                                 /* frame type - arp, hw type - ethernet */
 167                                 .offset_type =
 168                                         BCAST_FILTER_OFFSET_PAYLOAD_START,
 169                                 .offset = sizeof(rfc1042_header),
 170                                 .val = cpu_to_be32(0x08060001),
 171                                 .mask = cpu_to_be32(0xffffffff),
 172                         },
 173                         {
 174                                 /* arp dest ip */
 175                                 .offset_type =
 176                                         BCAST_FILTER_OFFSET_PAYLOAD_START,
 177                                 .offset = sizeof(rfc1042_header) + 2 +
 178                                           sizeof(struct arphdr) +
 179                                           ETH_ALEN + sizeof(__be32) +
 180                                           ETH_ALEN,
 181                                 .mask = cpu_to_be32(0xffffffff),
 182                                 /* mark it as special field */
 183                                 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_IP),
 184                         },
 185                 },
 186         },
 187         {
 188                 /* dhcp offer bcast */
 189                 .discard = 0,
 190                 .frame_type = BCAST_FILTER_FRAME_TYPE_IPV4,
 191                 .attrs = {
 192                         {
 193                                 /* udp dest port - 68 (bootp client)*/
 194                                 .offset_type = BCAST_FILTER_OFFSET_IP_END,
 195                                 .offset = offsetof(struct udphdr, dest),
 196                                 .val = cpu_to_be32(0x00440000),
 197                                 .mask = cpu_to_be32(0xffff0000),
 198                         },
 199                         {
 200                                 /* dhcp - lsb bytes of client hw address */
 201                                 .offset_type = BCAST_FILTER_OFFSET_IP_END,
 202                                 .offset = 38,
 203                                 .mask = cpu_to_be32(0xffffffff),
 204                                 /* mark it as special field */
 205                                 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_MAC),
 206                         },
 207                 },
 208         },
 209         /* last filter must be empty */
 210         {},
 211 };
 212 #endif
 213
 214 void iwl_mvm_ref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
 215 {
 216         if (!iwl_mvm_is_d0i3_supported(mvm))
 217                 return;
 218
 219         IWL_DEBUG_RPM(mvm, "Take mvm reference - type %d\n", ref_type);
 220         spin_lock_bh(&mvm->refs_lock);
 221         mvm->refs[ref_type]++;
 222         spin_unlock_bh(&mvm->refs_lock);
 223         iwl_trans_ref(mvm->trans);
 224 }
 225
 226 void iwl_mvm_unref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
 227 {
 228         if (!iwl_mvm_is_d0i3_supported(mvm))
 229                 return;
 230
 231         IWL_DEBUG_RPM(mvm, "Leave mvm reference - type %d\n", ref_type);
 232         spin_lock_bh(&mvm->refs_lock);
 233         WARN_ON(!mvm->refs[ref_type]--);
 234         spin_unlock_bh(&mvm->refs_lock);
 235         iwl_trans_unref(mvm->trans);
 236 }
 237
 238 static void iwl_mvm_unref_all_except(struct iwl_mvm *mvm,
 239                                      enum iwl_mvm_ref_type except_ref)
 240 {
 241         int i, j;
 242
 243         if (!iwl_mvm_is_d0i3_supported(mvm))
 244                 return;
 245
 246         spin_lock_bh(&mvm->refs_lock);
 247         for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
 248                 if (except_ref == i || !mvm->refs[i])
 249                         continue;
 250
 251                 IWL_DEBUG_RPM(mvm, "Cleanup: remove mvm ref type %d (%d)\n",
 252                               i, mvm->refs[i]);
 253                 for (j = 0; j < mvm->refs[i]; j++)
 254                         iwl_trans_unref(mvm->trans);
 255                 mvm->refs[i] = 0;
 256         }
 257         spin_unlock_bh(&mvm->refs_lock);
 258 }
 259
 260 bool iwl_mvm_ref_taken(struct iwl_mvm *mvm)
 261 {
 262         int i;
 263         bool taken = false;
 264
 265         if (!iwl_mvm_is_d0i3_supported(mvm))
 266                 return true;
 267
 268         spin_lock_bh(&mvm->refs_lock);
 269         for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
 270                 if (mvm->refs[i]) {
 271                         taken = true;
 272                         break;
 273                 }
 274         }
 275         spin_unlock_bh(&mvm->refs_lock);
 276
 277         return taken;
 278 }
 279
 280 int iwl_mvm_ref_sync(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
 281 {
 282         iwl_mvm_ref(mvm, ref_type);
 283
 284         if (!wait_event_timeout(mvm->d0i3_exit_waitq,
 285                                 !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
 286                                 HZ)) {
 287                 WARN_ON_ONCE(1);
 288                 iwl_mvm_unref(mvm, ref_type);
 289                 return -EIO;
 290         }
 291
 292         return 0;
 293 }
 294
 295 static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm *mvm)
 296 {
 297         int i;
 298
 299         memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
 300         for (i = 0; i < NUM_PHY_CTX; i++) {
 301                 mvm->phy_ctxts[i].id = i;
 302                 mvm->phy_ctxts[i].ref = 0;
 303         }
 304 }
 305
 306 struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy,
 307                                                   const char *alpha2,
 308                                                   enum iwl_mcc_source src_id,
 309                                                   bool *changed)
 310 {
 311         struct ieee80211_regdomain *regd = NULL;
 312         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
 313         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 314         struct iwl_mcc_update_resp *resp;
 315
 316         IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);
 317
 318         lockdep_assert_held(&mvm->mutex);
 319
 320         resp = iwl_mvm_update_mcc(mvm, alpha2, src_id);
 321         if (IS_ERR_OR_NULL(resp)) {
 322                 IWL_DEBUG_LAR(mvm, "Could not get update from FW %d\n",
 323                               PTR_ERR_OR_ZERO(resp));
 324                 goto out;
 325         }
 326
 327         if (changed)
 328                 *changed = (resp->status == MCC_RESP_NEW_CHAN_PROFILE);
 329
 330         regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg,
 331                                       __le32_to_cpu(resp->n_channels),
 332                                       resp->channels,
 333                                       __le16_to_cpu(resp->mcc));
 334         /* Store the return source id */
 335         src_id = resp->source_id;
 336         kfree(resp);
 337         if (IS_ERR_OR_NULL(regd)) {
 338                 IWL_DEBUG_LAR(mvm, "Could not get parse update from FW %d\n",
 339                               PTR_ERR_OR_ZERO(regd));
 340                 goto out;
 341         }
 342
 343         IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n",
 344                       regd->alpha2, regd->alpha2[0], regd->alpha2[1], src_id);
 345         mvm->lar_regdom_set = true;
 346         mvm->mcc_src = src_id;
 347
 348 out:
 349         return regd;
 350 }
 351
 352 void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm)
 353 {
 354         bool changed;
 355         struct ieee80211_regdomain *regd;
 356
 357         if (!iwl_mvm_is_lar_supported(mvm))
 358                 return;
 359
 360         regd = iwl_mvm_get_current_regdomain(mvm, &changed);
 361         if (!IS_ERR_OR_NULL(regd)) {
 362                 /* only update the regulatory core if changed */
 363                 if (changed)
 364                         regulatory_set_wiphy_regd(mvm->hw->wiphy, regd);
 365
 366                 kfree(regd);
 367         }
 368 }
 369
 370 struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm,
 371                                                           bool *changed)
 372 {
 373         return iwl_mvm_get_regdomain(mvm->hw->wiphy, "ZZ",
 374                                      iwl_mvm_is_wifi_mcc_supported(mvm) ?
 375                                      MCC_SOURCE_GET_CURRENT :
 376                                      MCC_SOURCE_OLD_FW, changed);
 377 }
 378
 379 int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm)
 380 {
 381         enum iwl_mcc_source used_src;
 382         struct ieee80211_regdomain *regd;
 383         int ret;
 384         bool changed;
 385         const struct ieee80211_regdomain *r =
 386                         rtnl_dereference(mvm->hw->wiphy->regd);
 387
 388         if (!r)
 389                 return -ENOENT;
 390
 391         /* save the last source in case we overwrite it below */
 392         used_src = mvm->mcc_src;
 393         if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
 394                 /* Notify the firmware we support wifi location updates */
 395                 regd = iwl_mvm_get_current_regdomain(mvm, NULL);
 396                 if (!IS_ERR_OR_NULL(regd))
 397                         kfree(regd);
 398         }
 399
 400         /* Now set our last stored MCC and source */
 401         regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src,
 402                                      &changed);
 403         if (IS_ERR_OR_NULL(regd))
 404                 return -EIO;
 405
 406         /* update cfg80211 if the regdomain was changed */
 407         if (changed)
 408                 ret = regulatory_set_wiphy_regd_sync_rtnl(mvm->hw->wiphy, regd);
 409         else
 410                 ret = 0;
 411
 412         kfree(regd);
 413         return ret;
 414 }
 415
 416 int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm)
 417 {
 418         struct ieee80211_hw *hw = mvm->hw;
 419         int num_mac, ret, i;
 420         static const u32 mvm_ciphers[] = {
 421                 WLAN_CIPHER_SUITE_WEP40,
 422                 WLAN_CIPHER_SUITE_WEP104,
 423                 WLAN_CIPHER_SUITE_TKIP,
 424                 WLAN_CIPHER_SUITE_CCMP,
 425         };
 426
 427         /* Tell mac80211 our characteristics */
 428         ieee80211_hw_set(hw, SIGNAL_DBM);
 429         ieee80211_hw_set(hw, SPECTRUM_MGMT);
 430         ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
 431         ieee80211_hw_set(hw, QUEUE_CONTROL);
 432         ieee80211_hw_set(hw, WANT_MONITOR_VIF);
 433         ieee80211_hw_set(hw, SUPPORTS_PS);
 434         ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
 435         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
 436         ieee80211_hw_set(hw, TIMING_BEACON_ONLY);
 437         ieee80211_hw_set(hw, CONNECTION_MONITOR);
 438         ieee80211_hw_set(hw, CHANCTX_STA_CSA);
 439         ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
 440         ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
 441
 442         hw->queues = mvm->first_agg_queue;
 443         hw->offchannel_tx_hw_queue = IWL_MVM_OFFCHANNEL_QUEUE;
 444         hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC |
 445                                     IEEE80211_RADIOTAP_MCS_HAVE_STBC;
 446         hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC |
 447                 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED;
 448         hw->rate_control_algorithm = "iwl-mvm-rs";
 449         hw->uapsd_queues = IWL_MVM_UAPSD_QUEUES;
 450         hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
 451
 452         BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 2);
 453         memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
 454         hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
 455         hw->wiphy->cipher_suites = mvm->ciphers;
 456
 457         /*
 458          * Enable 11w if advertised by firmware and software crypto
 459          * is not enabled (as the firmware will interpret some mgmt
 460          * packets, so enabling it with software crypto isn't safe)
 461          */
 462         if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_MFP &&
 463             !iwlwifi_mod_params.sw_crypto) {
 464                 ieee80211_hw_set(hw, MFP_CAPABLE);
 465                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
 466                         WLAN_CIPHER_SUITE_AES_CMAC;
 467                 hw->wiphy->n_cipher_suites++;
 468         }
 469
 470         /* currently FW API supports only one optional cipher scheme */
 471         if (mvm->fw->cs[0].cipher) {
 472                 mvm->hw->n_cipher_schemes = 1;
 473                 mvm->hw->cipher_schemes = &mvm->fw->cs[0];
 474                 mvm->ciphers[hw->wiphy->n_cipher_suites] =
 475                         mvm->fw->cs[0].cipher;
 476                 hw->wiphy->n_cipher_suites++;
 477         }
 478
 479         ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
 480         hw->wiphy->features |=
 481                 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
 482                 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR |
 483                 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
 484
 485         hw->sta_data_size = sizeof(struct iwl_mvm_sta);
 486         hw->vif_data_size = sizeof(struct iwl_mvm_vif);
 487         hw->chanctx_data_size = sizeof(u16);
 488
 489         hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
 490                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
 491                 BIT(NL80211_IFTYPE_AP) |
 492                 BIT(NL80211_IFTYPE_P2P_GO) |
 493                 BIT(NL80211_IFTYPE_P2P_DEVICE) |
 494                 BIT(NL80211_IFTYPE_ADHOC);
 495
 496         hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 497         hw->wiphy->regulatory_flags |= REGULATORY_ENABLE_RELAX_NO_IR;
 498         if (iwl_mvm_is_lar_supported(mvm))
 499                 hw->wiphy->regulatory_flags |= REGULATORY_WIPHY_SELF_MANAGED;
 500         else
 501                 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
 502                                                REGULATORY_DISABLE_BEACON_HINTS;
 503
 504         if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_GO_UAPSD)
 505                 hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
 506
 507         hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
 508
 509         hw->wiphy->iface_combinations = iwl_mvm_iface_combinations;
 510         hw->wiphy->n_iface_combinations =
 511                 ARRAY_SIZE(iwl_mvm_iface_combinations);
 512
 513         hw->wiphy->max_remain_on_channel_duration = 10000;
 514         hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
 515         /* we can compensate an offset of up to 3 channels = 15 MHz */
 516         hw->wiphy->max_adj_channel_rssi_comp = 3 * 5;
 517
 518         /* Extract MAC address */
 519         memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);
 520         hw->wiphy->addresses = mvm->addresses;
 521         hw->wiphy->n_addresses = 1;
 522
 523         /* Extract additional MAC addresses if available */
 524         num_mac = (mvm->nvm_data->n_hw_addrs > 1) ?
 525                 min(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;
 526
 527         for (i = 1; i < num_mac; i++) {
 528                 memcpy(mvm->addresses[i].addr, mvm->addresses[i-1].addr,
 529                        ETH_ALEN);
 530                 mvm->addresses[i].addr[5]++;
 531                 hw->wiphy->n_addresses++;
 532         }
 533
 534         iwl_mvm_reset_phy_ctxts(mvm);
 535
 536         hw->wiphy->max_scan_ie_len = iwl_mvm_max_scan_ie_len(mvm);
 537
 538         hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
 539
 540         BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
 541         BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK) ||
 542                      IWL_MVM_MAX_LMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK));
 543
 544         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
 545                 mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
 546         else
 547                 mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
 548
 549         if (mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels)
 550                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
 551                         &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
 552         if (mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels) {
 553                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 554                         &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
 555
 556                 if (fw_has_capa(&mvm->fw->ucode_capa,
 557                                 IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
 558                     fw_has_api(&mvm->fw->ucode_capa,
 559                                IWL_UCODE_TLV_API_LQ_SS_PARAMS))
 560                         hw->wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap.cap |=
 561                                 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
 562         }
 563
 564         hw->wiphy->hw_version = mvm->trans->hw_id;
 565
 566         if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
 567                 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
 568         else
 569                 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
 570
 571         hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
 572         hw->wiphy->max_sched_scan_ssids = PROBE_OPTION_MAX;
 573         hw->wiphy->max_match_sets = IWL_SCAN_MAX_PROFILES;
 574         /* we create the 802.11 header and zero length SSID IE. */
 575         hw->wiphy->max_sched_scan_ie_len =
 576                 SCAN_OFFLOAD_PROBE_REQ_SIZE - 24 - 2;
 577         hw->wiphy->max_sched_scan_plans = IWL_MAX_SCHED_SCAN_PLANS;
 578         hw->wiphy->max_sched_scan_plan_interval = U16_MAX;
 579
 580         /*
 581          * the firmware uses u8 for num of iterations, but 0xff is saved for
 582          * infinite loop, so the maximum number of iterations is actually 254.
 583          */
 584         hw->wiphy->max_sched_scan_plan_iterations = 254;
 585
 586         hw->wiphy->features |= NL80211_FEATURE_P2P_GO_CTWIN |
 587                                NL80211_FEATURE_LOW_PRIORITY_SCAN |
 588                                NL80211_FEATURE_P2P_GO_OPPPS |
 589                                NL80211_FEATURE_DYNAMIC_SMPS |
 590                                NL80211_FEATURE_STATIC_SMPS |
 591                                NL80211_FEATURE_SUPPORTS_WMM_ADMISSION;
 592
 593         if (fw_has_capa(&mvm->fw->ucode_capa,
 594                         IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT))
 595                 hw->wiphy->features |= NL80211_FEATURE_TX_POWER_INSERTION;
 596         if (fw_has_capa(&mvm->fw->ucode_capa,
 597                         IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT))
 598                 hw->wiphy->features |= NL80211_FEATURE_QUIET;
 599
 600         if (fw_has_capa(&mvm->fw->ucode_capa,
 601                         IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
 602                 hw->wiphy->features |=
 603                         NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES;
 604
 605         if (fw_has_capa(&mvm->fw->ucode_capa,
 606                         IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT))
 607                 hw->wiphy->features |= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES;
 608
 609         mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
 610
 611 #ifdef CONFIG_PM_SLEEP
 612         if (iwl_mvm_is_d0i3_supported(mvm) &&
 613             device_can_wakeup(mvm->trans->dev)) {
 614                 mvm->wowlan.flags = WIPHY_WOWLAN_ANY;
 615                 hw->wiphy->wowlan = &mvm->wowlan;
 616         }
 617
 618         if (mvm->fw->img[IWL_UCODE_WOWLAN].sec[0].len &&
 619             mvm->trans->ops->d3_suspend &&
 620             mvm->trans->ops->d3_resume &&
 621             device_can_wakeup(mvm->trans->dev)) {
 622                 mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT |
 623                                      WIPHY_WOWLAN_DISCONNECT |
 624                                      WIPHY_WOWLAN_EAP_IDENTITY_REQ |
 625                                      WIPHY_WOWLAN_RFKILL_RELEASE |
 626                                      WIPHY_WOWLAN_NET_DETECT;
 627                 if (!iwlwifi_mod_params.sw_crypto)
 628                         mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
 629                                              WIPHY_WOWLAN_GTK_REKEY_FAILURE |
 630                                              WIPHY_WOWLAN_4WAY_HANDSHAKE;
 631
 632                 mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
 633                 mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
 634                 mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
 635                 mvm->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES;
 636                 mvm->wowlan.tcp = &iwl_mvm_wowlan_tcp_support;
 637                 hw->wiphy->wowlan = &mvm->wowlan;
 638         }
 639 #endif
 640
 641 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
 642         /* assign default bcast filtering configuration */
 643         mvm->bcast_filters = iwl_mvm_default_bcast_filters;
 644 #endif
 645
 646         ret = iwl_mvm_leds_init(mvm);
 647         if (ret)
 648                 return ret;
 649
 650         if (fw_has_capa(&mvm->fw->ucode_capa,
 651                         IWL_UCODE_TLV_CAPA_TDLS_SUPPORT)) {
 652                 IWL_DEBUG_TDLS(mvm, "TDLS supported\n");
 653                 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
 654                 ieee80211_hw_set(hw, TDLS_WIDER_BW);
 655         }
 656
 657         if (fw_has_capa(&mvm->fw->ucode_capa,
 658                         IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH)) {
 659                 IWL_DEBUG_TDLS(mvm, "TDLS channel switch supported\n");
 660                 hw->wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
 661         }
 662
 663         hw->netdev_features |= mvm->cfg->features;
 664         if (!iwl_mvm_is_csum_supported(mvm))
 665                 hw->netdev_features &= ~NETIF_F_RXCSUM;
 666
 667         ret = ieee80211_register_hw(mvm->hw);
 668         if (ret)
 669                 iwl_mvm_leds_exit(mvm);
 670
 671         return ret;
 672 }
 673
 674 static bool iwl_mvm_defer_tx(struct iwl_mvm *mvm,
 675                              struct ieee80211_sta *sta,
 676                              struct sk_buff *skb)
 677 {
 678         struct iwl_mvm_sta *mvmsta;
 679         bool defer = false;
 680
 681         /*
 682          * double check the IN_D0I3 flag both before and after
 683          * taking the spinlock, in order to prevent taking
 684          * the spinlock when not needed.
 685          */
 686         if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)))
 687                 return false;
 688
 689         spin_lock(&mvm->d0i3_tx_lock);
 690         /*
 691          * testing the flag again ensures the skb dequeue
 692          * loop (on d0i3 exit) hasn't run yet.
 693          */
 694         if (!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status))
 695                 goto out;
 696
 697         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 698         if (mvmsta->sta_id == IWL_MVM_STATION_COUNT ||
 699             mvmsta->sta_id != mvm->d0i3_ap_sta_id)
 700                 goto out;
 701
 702         __skb_queue_tail(&mvm->d0i3_tx, skb);
 703         ieee80211_stop_queues(mvm->hw);
 704
 705         /* trigger wakeup */
 706         iwl_mvm_ref(mvm, IWL_MVM_REF_TX);
 707         iwl_mvm_unref(mvm, IWL_MVM_REF_TX);
 708
 709         defer = true;
 710 out:
 711         spin_unlock(&mvm->d0i3_tx_lock);
 712         return defer;
 713 }
 714
 715 static void iwl_mvm_mac_tx(struct ieee80211_hw *hw,
 716                            struct ieee80211_tx_control *control,
 717                            struct sk_buff *skb)
 718 {
 719         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 720         struct ieee80211_sta *sta = control->sta;
 721         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 722         struct ieee80211_hdr *hdr = (void *)skb->data;
 723
 724         if (iwl_mvm_is_radio_killed(mvm)) {
 725                 IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
 726                 goto drop;
 727         }
 728
 729         if (IEEE80211_SKB_CB(skb)->hw_queue == IWL_MVM_OFFCHANNEL_QUEUE &&
 730             !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
 731             !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status))
 732                 goto drop;
 733
 734         /* treat non-bufferable MMPDUs as broadcast if sta is sleeping */
 735         if (unlikely(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER &&
 736                      ieee80211_is_mgmt(hdr->frame_control) &&
 737                      !ieee80211_is_deauth(hdr->frame_control) &&
 738                      !ieee80211_is_disassoc(hdr->frame_control) &&
 739                      !ieee80211_is_action(hdr->frame_control)))
 740                 sta = NULL;
 741
 742         if (sta) {
 743                 if (iwl_mvm_defer_tx(mvm, sta, skb))
 744                         return;
 745                 if (iwl_mvm_tx_skb(mvm, skb, sta))
 746                         goto drop;
 747                 return;
 748         }
 749
 750         if (iwl_mvm_tx_skb_non_sta(mvm, skb))
 751                 goto drop;
 752         return;
 753  drop:
 754         ieee80211_free_txskb(hw, skb);
 755 }
 756
 757 static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg *cfg)
 758 {
 759         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG)
 760                 return false;
 761         return true;
 762 }
 763
 764 static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg *cfg)
 765 {
 766         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG)
 767                 return false;
 768         if (iwlwifi_mod_params.disable_11n & IWL_ENABLE_HT_TXAGG)
 769                 return true;
 770
 771         /* enabled by default */
 772         return true;
 773 }
 774
 775 #define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...)   \
 776         do {                                                    \
 777                 if (!(le16_to_cpu(_tid_bm) & BIT(_tid)))        \
 778                         break;                                  \
 779                 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt); \
 780         } while (0)
 781
 782 static void
 783 iwl_mvm_ampdu_check_trigger(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 784                             struct ieee80211_sta *sta, u16 tid, u16 rx_ba_ssn,
 785                             enum ieee80211_ampdu_mlme_action action)
 786 {
 787         struct iwl_fw_dbg_trigger_tlv *trig;
 788         struct iwl_fw_dbg_trigger_ba *ba_trig;
 789
 790         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
 791                 return;
 792
 793         trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
 794         ba_trig = (void *)trig->data;
 795
 796         if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
 797                 return;
 798
 799         switch (action) {
 800         case IEEE80211_AMPDU_TX_OPERATIONAL: {
 801                 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 802                 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
 803
 804                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
 805                                  "TX AGG START: MAC %pM tid %d ssn %d\n",
 806                                  sta->addr, tid, tid_data->ssn);
 807                 break;
 808                 }
 809         case IEEE80211_AMPDU_TX_STOP_CONT:
 810                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid,
 811                                  "TX AGG STOP: MAC %pM tid %d\n",
 812                                  sta->addr, tid);
 813                 break;
 814         case IEEE80211_AMPDU_RX_START:
 815                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
 816                                  "RX AGG START: MAC %pM tid %d ssn %d\n",
 817                                  sta->addr, tid, rx_ba_ssn);
 818                 break;
 819         case IEEE80211_AMPDU_RX_STOP:
 820                 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid,
 821                                  "RX AGG STOP: MAC %pM tid %d\n",
 822                                  sta->addr, tid);
 823                 break;
 824         default:
 825                 break;
 826         }
 827 }
 828
 829 static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw *hw,
 830                                     struct ieee80211_vif *vif,
 831                                     enum ieee80211_ampdu_mlme_action action,
 832                                     struct ieee80211_sta *sta, u16 tid,
 833                                     u16 *ssn, u8 buf_size, bool amsdu)
 834 {
 835         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 836         int ret;
 837         bool tx_agg_ref = false;
 838
 839         IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n",
 840                      sta->addr, tid, action);
 841
 842         if (!(mvm->nvm_data->sku_cap_11n_enable))
 843                 return -EACCES;
 844
 845         /* return from D0i3 before starting a new Tx aggregation */
 846         switch (action) {
 847         case IEEE80211_AMPDU_TX_START:
 848         case IEEE80211_AMPDU_TX_STOP_CONT:
 849         case IEEE80211_AMPDU_TX_STOP_FLUSH:
 850         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
 851         case IEEE80211_AMPDU_TX_OPERATIONAL:
 852                 /*
 853                  * for tx start, wait synchronously until D0i3 exit to
 854                  * get the correct sequence number for the tid.
 855                  * additionally, some other ampdu actions use direct
 856                  * target access, which is not handled automatically
 857                  * by the trans layer (unlike commands), so wait for
 858                  * d0i3 exit in these cases as well.
 859                  */
 860                 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_TX_AGG);
 861                 if (ret)
 862                         return ret;
 863
 864                 tx_agg_ref = true;
 865                 break;
 866         default:
 867                 break;
 868         }
 869
 870         mutex_lock(&mvm->mutex);
 871
 872         switch (action) {
 873         case IEEE80211_AMPDU_RX_START:
 874                 if (!iwl_enable_rx_ampdu(mvm->cfg)) {
 875                         ret = -EINVAL;
 876                         break;
 877                 }
 878                 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true);
 879                 break;
 880         case IEEE80211_AMPDU_RX_STOP:
 881                 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false);
 882                 break;
 883         case IEEE80211_AMPDU_TX_START:
 884                 if (!iwl_enable_tx_ampdu(mvm->cfg)) {
 885                         ret = -EINVAL;
 886                         break;
 887                 }
 888                 ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
 889                 break;
 890         case IEEE80211_AMPDU_TX_STOP_CONT:
 891                 ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
 892                 break;
 893         case IEEE80211_AMPDU_TX_STOP_FLUSH:
 894         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
 895                 ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
 896                 break;
 897         case IEEE80211_AMPDU_TX_OPERATIONAL:
 898                 ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid, buf_size);
 899                 break;
 900         default:
 901                 WARN_ON_ONCE(1);
 902                 ret = -EINVAL;
 903                 break;
 904         }
 905
 906         if (!ret) {
 907                 u16 rx_ba_ssn = 0;
 908
 909                 if (action == IEEE80211_AMPDU_RX_START)
 910                         rx_ba_ssn = *ssn;
 911
 912                 iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid,
 913                                             rx_ba_ssn, action);
 914         }
 915         mutex_unlock(&mvm->mutex);
 916
 917         /*
 918          * If the tid is marked as started, we won't use it for offloaded
 919          * traffic on the next D0i3 entry. It's safe to unref.
 920          */
 921         if (tx_agg_ref)
 922                 iwl_mvm_unref(mvm, IWL_MVM_REF_TX_AGG);
 923
 924         return ret;
 925 }
 926
 927 static void iwl_mvm_cleanup_iterator(void *data, u8 *mac,
 928                                      struct ieee80211_vif *vif)
 929 {
 930         struct iwl_mvm *mvm = data;
 931         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 932
 933         mvmvif->uploaded = false;
 934         mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
 935
 936         spin_lock_bh(&mvm->time_event_lock);
 937         iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
 938         spin_unlock_bh(&mvm->time_event_lock);
 939
 940         mvmvif->phy_ctxt = NULL;
 941         memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
 942 }
 943
 944 static void iwl_mvm_restart_cleanup(struct iwl_mvm *mvm)
 945 {
 946         /* clear the D3 reconfig, we only need it to avoid dumping a
 947          * firmware coredump on reconfiguration, we shouldn't do that
 948          * on D3->D0 transition
 949          */
 950         if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status)) {
 951                 mvm->fw_dump_desc = &iwl_mvm_dump_desc_assert;
 952                 iwl_mvm_fw_error_dump(mvm);
 953         }
 954
 955         /* cleanup all stale references (scan, roc), but keep the
 956          * ucode_down ref until reconfig is complete
 957          */
 958         iwl_mvm_unref_all_except(mvm, IWL_MVM_REF_UCODE_DOWN);
 959
 960         iwl_trans_stop_device(mvm->trans);
 961
 962         mvm->scan_status = 0;
 963         mvm->ps_disabled = false;
 964         mvm->calibrating = false;
 965
 966         /* just in case one was running */
 967         ieee80211_remain_on_channel_expired(mvm->hw);
 968
 969         /*
 970          * cleanup all interfaces, even inactive ones, as some might have
 971          * gone down during the HW restart
 972          */
 973         ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
 974
 975         mvm->p2p_device_vif = NULL;
 976         mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
 977
 978         iwl_mvm_reset_phy_ctxts(mvm);
 979         memset(mvm->sta_drained, 0, sizeof(mvm->sta_drained));
 980         memset(mvm->tfd_drained, 0, sizeof(mvm->tfd_drained));
 981         memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
 982         memset(&mvm->last_bt_notif_old, 0, sizeof(mvm->last_bt_notif_old));
 983         memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
 984         memset(&mvm->last_bt_ci_cmd_old, 0, sizeof(mvm->last_bt_ci_cmd_old));
 985         memset(&mvm->bt_ack_kill_msk, 0, sizeof(mvm->bt_ack_kill_msk));
 986         memset(&mvm->bt_cts_kill_msk, 0, sizeof(mvm->bt_cts_kill_msk));
 987
 988         ieee80211_wake_queues(mvm->hw);
 989
 990         /* clear any stale d0i3 state */
 991         clear_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status);
 992
 993         mvm->vif_count = 0;
 994         mvm->rx_ba_sessions = 0;
 995         mvm->fw_dbg_conf = FW_DBG_INVALID;
 996         mvm->scan_type = IWL_SCAN_TYPE_NOT_SET;
 997
 998         /* keep statistics ticking */
 999         iwl_mvm_accu_radio_stats(mvm);
1000 }
1001
1002 int __iwl_mvm_mac_start(struct iwl_mvm *mvm)
1003 {
1004         int ret;
1005
1006         lockdep_assert_held(&mvm->mutex);
1007
1008         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1009                 /* Clean up some internal and mac80211 state on restart */
1010                 iwl_mvm_restart_cleanup(mvm);
1011         } else {
1012                 /* Hold the reference to prevent runtime suspend while
1013                  * the start procedure runs.  It's a bit confusing
1014                  * that the UCODE_DOWN reference is taken, but it just
1015                  * means "UCODE is not UP yet". ( TODO: rename this
1016                  * reference).
1017                  */
1018                 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
1019         }
1020         ret = iwl_mvm_up(mvm);
1021
1022         if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1023                 /* Something went wrong - we need to finish some cleanup
1024                  * that normally iwl_mvm_mac_restart_complete() below
1025                  * would do.
1026                  */
1027                 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1028                 iwl_mvm_d0i3_enable_tx(mvm, NULL);
1029         }
1030
1031         return ret;
1032 }
1033
1034 static int iwl_mvm_mac_start(struct ieee80211_hw *hw)
1035 {
1036         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1037         int ret;
1038
1039         /* Some hw restart cleanups must not hold the mutex */
1040         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1041                 /*
1042                  * Make sure we are out of d0i3. This is needed
1043                  * to make sure the reference accounting is correct
1044                  * (and there is no stale d0i3_exit_work).
1045                  */
1046                 wait_event_timeout(mvm->d0i3_exit_waitq,
1047                                    !test_bit(IWL_MVM_STATUS_IN_D0I3,
1048                                              &mvm->status),
1049                                    HZ);
1050         }
1051
1052         mutex_lock(&mvm->mutex);
1053         ret = __iwl_mvm_mac_start(mvm);
1054         mutex_unlock(&mvm->mutex);
1055
1056         return ret;
1057 }
1058
1059 static void iwl_mvm_restart_complete(struct iwl_mvm *mvm)
1060 {
1061         int ret;
1062
1063         mutex_lock(&mvm->mutex);
1064
1065         clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1066         iwl_mvm_d0i3_enable_tx(mvm, NULL);
1067         ret = iwl_mvm_update_quotas(mvm, true, NULL);
1068         if (ret)
1069                 IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n",
1070                         ret);
1071
1072         /* allow transport/FW low power modes */
1073         iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1074
1075         /*
1076          * If we have TDLS peers, remove them. We don't know the last seqno/PN
1077          * of packets the FW sent out, so we must reconnect.
1078          */
1079         iwl_mvm_teardown_tdls_peers(mvm);
1080
1081         mutex_unlock(&mvm->mutex);
1082 }
1083
1084 static void iwl_mvm_resume_complete(struct iwl_mvm *mvm)
1085 {
1086         if (!iwl_mvm_is_d0i3_supported(mvm))
1087                 return;
1088
1089         if (mvm->trans->d0i3_mode == IWL_D0I3_MODE_ON_SUSPEND)
1090                 if (!wait_event_timeout(mvm->d0i3_exit_waitq,
1091                                         !test_bit(IWL_MVM_STATUS_IN_D0I3,
1092                                                   &mvm->status),
1093                                         HZ))
1094                         WARN_ONCE(1, "D0i3 exit on resume timed out\n");
1095 }
1096
1097 static void
1098 iwl_mvm_mac_reconfig_complete(struct ieee80211_hw *hw,
1099                               enum ieee80211_reconfig_type reconfig_type)
1100 {
1101         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1102
1103         switch (reconfig_type) {
1104         case IEEE80211_RECONFIG_TYPE_RESTART:
1105                 iwl_mvm_restart_complete(mvm);
1106                 break;
1107         case IEEE80211_RECONFIG_TYPE_SUSPEND:
1108                 iwl_mvm_resume_complete(mvm);
1109                 break;
1110         }
1111 }
1112
1113 void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)
1114 {
1115         lockdep_assert_held(&mvm->mutex);
1116
1117         /* firmware counters are obviously reset now, but we shouldn't
1118          * partially track so also clear the fw_reset_accu counters.
1119          */
1120         memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));
1121
1122         /* async_handlers_wk is now blocked */
1123
1124         /*
1125          * The work item could be running or queued if the
1126          * ROC time event stops just as we get here.
1127          */
1128         flush_work(&mvm->roc_done_wk);
1129
1130         iwl_trans_stop_device(mvm->trans);
1131
1132         iwl_mvm_async_handlers_purge(mvm);
1133         /* async_handlers_list is empty and will stay empty: HW is stopped */
1134
1135         /* the fw is stopped, the aux sta is dead: clean up driver state */
1136         iwl_mvm_del_aux_sta(mvm);
1137
1138         /*
1139          * Clear IN_HW_RESTART flag when stopping the hw (as restart_complete()
1140          * won't be called in this case).
1141          * But make sure to cleanup interfaces that have gone down before/during
1142          * HW restart was requested.
1143          */
1144         if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1145                 ieee80211_iterate_interfaces(mvm->hw, 0,
1146                                              iwl_mvm_cleanup_iterator, mvm);
1147
1148         /* We shouldn't have any UIDs still set.  Loop over all the UIDs to
1149          * make sure there's nothing left there and warn if any is found.
1150          */
1151         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1152                 int i;
1153
1154                 for (i = 0; i < mvm->max_scans; i++) {
1155                         if (WARN_ONCE(mvm->scan_uid_status[i],
1156                                       "UMAC scan UID %d status was not cleaned\n",
1157                                       i))
1158                                 mvm->scan_uid_status[i] = 0;
1159                 }
1160         }
1161
1162         mvm->ucode_loaded = false;
1163 }
1164
1165 static void iwl_mvm_mac_stop(struct ieee80211_hw *hw)
1166 {
1167         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1168
1169         flush_work(&mvm->d0i3_exit_work);
1170         flush_work(&mvm->async_handlers_wk);
1171         cancel_delayed_work_sync(&mvm->fw_dump_wk);
1172         iwl_mvm_free_fw_dump_desc(mvm);
1173
1174         mutex_lock(&mvm->mutex);
1175         __iwl_mvm_mac_stop(mvm);
1176         mutex_unlock(&mvm->mutex);
1177
1178         /*
1179          * The worker might have been waiting for the mutex, let it run and
1180          * discover that its list is now empty.
1181          */
1182         cancel_work_sync(&mvm->async_handlers_wk);
1183 }
1184
1185 static struct iwl_mvm_phy_ctxt *iwl_mvm_get_free_phy_ctxt(struct iwl_mvm *mvm)
1186 {
1187         u16 i;
1188
1189         lockdep_assert_held(&mvm->mutex);
1190
1191         for (i = 0; i < NUM_PHY_CTX; i++)
1192                 if (!mvm->phy_ctxts[i].ref)
1193                         return &mvm->phy_ctxts[i];
1194
1195         IWL_ERR(mvm, "No available PHY context\n");
1196         return NULL;
1197 }
1198
1199 static int iwl_mvm_set_tx_power(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1200                                 s16 tx_power)
1201 {
1202         struct iwl_dev_tx_power_cmd cmd = {
1203                 .v2.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
1204                 .v2.mac_context_id =
1205                         cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
1206                 .v2.pwr_restriction = cpu_to_le16(8 * tx_power),
1207         };
1208         int len = sizeof(cmd);
1209
1210         if (tx_power == IWL_DEFAULT_MAX_TX_POWER)
1211                 cmd.v2.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
1212
1213         if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_TX_POWER_CHAIN))
1214                 len = sizeof(cmd.v2);
1215
1216         return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
1217 }
1218
1219 static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw,
1220                                      struct ieee80211_vif *vif)
1221 {
1222         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1223         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1224         int ret;
1225
1226         mvmvif->mvm = mvm;
1227
1228         /*
1229          * make sure D0i3 exit is completed, otherwise a target access
1230          * during tx queue configuration could be done when still in
1231          * D0i3 state.
1232          */
1233         ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_ADD_IF);
1234         if (ret)
1235                 return ret;
1236
1237         /*
1238          * Not much to do here. The stack will not allow interface
1239          * types or combinations that we didn't advertise, so we
1240          * don't really have to check the types.
1241          */
1242
1243         mutex_lock(&mvm->mutex);
1244
1245         /* make sure that beacon statistics don't go backwards with FW reset */
1246         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1247                 mvmvif->beacon_stats.accu_num_beacons +=
1248                         mvmvif->beacon_stats.num_beacons;
1249
1250         /* Allocate resources for the MAC context, and add it to the fw  */
1251         ret = iwl_mvm_mac_ctxt_init(mvm, vif);
1252         if (ret)
1253                 goto out_unlock;
1254
1255         /* Counting number of interfaces is needed for legacy PM */
1256         if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1257                 mvm->vif_count++;
1258
1259         /*
1260          * The AP binding flow can be done only after the beacon
1261          * template is configured (which happens only in the mac80211
1262          * start_ap() flow), and adding the broadcast station can happen
1263          * only after the binding.
1264          * In addition, since modifying the MAC before adding a bcast
1265          * station is not allowed by the FW, delay the adding of MAC context to
1266          * the point where we can also add the bcast station.
1267          * In short: there's not much we can do at this point, other than
1268          * allocating resources :)
1269          */
1270         if (vif->type == NL80211_IFTYPE_AP ||
1271             vif->type == NL80211_IFTYPE_ADHOC) {
1272                 ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
1273                 if (ret) {
1274                         IWL_ERR(mvm, "Failed to allocate bcast sta\n");
1275                         goto out_release;
1276                 }
1277
1278                 iwl_mvm_vif_dbgfs_register(mvm, vif);
1279                 goto out_unlock;
1280         }
1281
1282         mvmvif->features |= hw->netdev_features;
1283
1284         ret = iwl_mvm_mac_ctxt_add(mvm, vif);
1285         if (ret)
1286                 goto out_release;
1287
1288         ret = iwl_mvm_power_update_mac(mvm);
1289         if (ret)
1290                 goto out_remove_mac;
1291
1292         /* beacon filtering */
1293         ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
1294         if (ret)
1295                 goto out_remove_mac;
1296
1297         if (!mvm->bf_allowed_vif &&
1298             vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
1299                 mvm->bf_allowed_vif = mvmvif;
1300                 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
1301                                      IEEE80211_VIF_SUPPORTS_CQM_RSSI;
1302         }
1303
1304         /*
1305          * P2P_DEVICE interface does not have a channel context assigned to it,
1306          * so a dedicated PHY context is allocated to it and the corresponding
1307          * MAC context is bound to it at this stage.
1308          */
1309         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1310
1311                 mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
1312                 if (!mvmvif->phy_ctxt) {
1313                         ret = -ENOSPC;
1314                         goto out_free_bf;
1315                 }
1316
1317                 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
1318                 ret = iwl_mvm_binding_add_vif(mvm, vif);
1319                 if (ret)
1320                         goto out_unref_phy;
1321
1322                 ret = iwl_mvm_add_bcast_sta(mvm, vif);
1323                 if (ret)
1324                         goto out_unbind;
1325
1326                 /* Save a pointer to p2p device vif, so it can later be used to
1327                  * update the p2p device MAC when a GO is started/stopped */
1328                 mvm->p2p_device_vif = vif;
1329         }
1330
1331         iwl_mvm_vif_dbgfs_register(mvm, vif);
1332         goto out_unlock;
1333
1334  out_unbind:
1335         iwl_mvm_binding_remove_vif(mvm, vif);
1336  out_unref_phy:
1337         iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
1338  out_free_bf:
1339         if (mvm->bf_allowed_vif == mvmvif) {
1340                 mvm->bf_allowed_vif = NULL;
1341                 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
1342                                        IEEE80211_VIF_SUPPORTS_CQM_RSSI);
1343         }
1344  out_remove_mac:
1345         mvmvif->phy_ctxt = NULL;
1346         iwl_mvm_mac_ctxt_remove(mvm, vif);
1347  out_release:
1348         if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1349                 mvm->vif_count--;
1350
1351         iwl_mvm_mac_ctxt_release(mvm, vif);
1352  out_unlock:
1353         mutex_unlock(&mvm->mutex);
1354
1355         iwl_mvm_unref(mvm, IWL_MVM_REF_ADD_IF);
1356
1357         return ret;
1358 }
1359
1360 static void iwl_mvm_prepare_mac_removal(struct iwl_mvm *mvm,
1361                                         struct ieee80211_vif *vif)
1362 {
1363         u32 tfd_msk = iwl_mvm_mac_get_queues_mask(vif);
1364
1365         if (tfd_msk) {
1366                 /*
1367                  * mac80211 first removes all the stations of the vif and
1368                  * then removes the vif. When it removes a station it also
1369                  * flushes the AMPDU session. So by now, all the AMPDU sessions
1370                  * of all the stations of this vif are closed, and the queues
1371                  * of these AMPDU sessions are properly closed.
1372                  * We still need to take care of the shared queues of the vif.
1373                  * Flush them here.
1374                  */
1375                 mutex_lock(&mvm->mutex);
1376                 iwl_mvm_flush_tx_path(mvm, tfd_msk, 0);
1377                 mutex_unlock(&mvm->mutex);
1378
1379                 /*
1380                  * There are transports that buffer a few frames in the host.
1381                  * For these, the flush above isn't enough since while we were
1382                  * flushing, the transport might have sent more frames to the
1383                  * device. To solve this, wait here until the transport is
1384                  * empty. Technically, this could have replaced the flush
1385                  * above, but flush is much faster than draining. So flush
1386                  * first, and drain to make sure we have no frames in the
1387                  * transport anymore.
1388                  * If a station still had frames on the shared queues, it is
1389                  * already marked as draining, so to complete the draining, we
1390                  * just need to wait until the transport is empty.
1391                  */
1392                 iwl_trans_wait_tx_queue_empty(mvm->trans, tfd_msk);
1393         }
1394
1395         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1396                 /*
1397                  * Flush the ROC worker which will flush the OFFCHANNEL queue.
1398                  * We assume here that all the packets sent to the OFFCHANNEL
1399                  * queue are sent in ROC session.
1400                  */
1401                 flush_work(&mvm->roc_done_wk);
1402         } else {
1403                 /*
1404                  * By now, all the AC queues are empty. The AGG queues are
1405                  * empty too. We already got all the Tx responses for all the
1406                  * packets in the queues. The drain work can have been
1407                  * triggered. Flush it.
1408                  */
1409                 flush_work(&mvm->sta_drained_wk);
1410         }
1411 }
1412
1413 static void iwl_mvm_mac_remove_interface(struct ieee80211_hw *hw,
1414                                          struct ieee80211_vif *vif)
1415 {
1416         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1417         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1418
1419         iwl_mvm_prepare_mac_removal(mvm, vif);
1420
1421         mutex_lock(&mvm->mutex);
1422
1423         if (mvm->bf_allowed_vif == mvmvif) {
1424                 mvm->bf_allowed_vif = NULL;
1425                 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
1426                                        IEEE80211_VIF_SUPPORTS_CQM_RSSI);
1427         }
1428
1429         iwl_mvm_vif_dbgfs_clean(mvm, vif);
1430
1431         /*
1432          * For AP/GO interface, the tear down of the resources allocated to the
1433          * interface is be handled as part of the stop_ap flow.
1434          */
1435         if (vif->type == NL80211_IFTYPE_AP ||
1436             vif->type == NL80211_IFTYPE_ADHOC) {
1437 #ifdef CONFIG_NL80211_TESTMODE
1438                 if (vif == mvm->noa_vif) {
1439                         mvm->noa_vif = NULL;
1440                         mvm->noa_duration = 0;
1441                 }
1442 #endif
1443                 iwl_mvm_dealloc_bcast_sta(mvm, vif);
1444                 goto out_release;
1445         }
1446
1447         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1448                 mvm->p2p_device_vif = NULL;
1449                 iwl_mvm_rm_bcast_sta(mvm, vif);
1450                 iwl_mvm_binding_remove_vif(mvm, vif);
1451                 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
1452                 mvmvif->phy_ctxt = NULL;
1453         }
1454
1455         if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE)
1456                 mvm->vif_count--;
1457
1458         iwl_mvm_power_update_mac(mvm);
1459         iwl_mvm_mac_ctxt_remove(mvm, vif);
1460
1461 out_release:
1462         iwl_mvm_mac_ctxt_release(mvm, vif);
1463         mutex_unlock(&mvm->mutex);
1464 }
1465
1466 static int iwl_mvm_mac_config(struct ieee80211_hw *hw, u32 changed)
1467 {
1468         return 0;
1469 }
1470
1471 struct iwl_mvm_mc_iter_data {
1472         struct iwl_mvm *mvm;
1473         int port_id;
1474 };
1475
1476 static void iwl_mvm_mc_iface_iterator(void *_data, u8 *mac,
1477                                       struct ieee80211_vif *vif)
1478 {
1479         struct iwl_mvm_mc_iter_data *data = _data;
1480         struct iwl_mvm *mvm = data->mvm;
1481         struct iwl_mcast_filter_cmd *cmd = mvm->mcast_filter_cmd;
1482         int ret, len;
1483
1484         /* if we don't have free ports, mcast frames will be dropped */
1485         if (WARN_ON_ONCE(data->port_id >= MAX_PORT_ID_NUM))
1486                 return;
1487
1488         if (vif->type != NL80211_IFTYPE_STATION ||
1489             !vif->bss_conf.assoc)
1490                 return;
1491
1492         cmd->port_id = data->port_id++;
1493         memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
1494         len = roundup(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);
1495
1496         ret = iwl_mvm_send_cmd_pdu(mvm, MCAST_FILTER_CMD, CMD_ASYNC, len, cmd);
1497         if (ret)
1498                 IWL_ERR(mvm, "mcast filter cmd error. ret=%d\n", ret);
1499 }
1500
1501 static void iwl_mvm_recalc_multicast(struct iwl_mvm *mvm)
1502 {
1503         struct iwl_mvm_mc_iter_data iter_data = {
1504                 .mvm = mvm,
1505         };
1506
1507         lockdep_assert_held(&mvm->mutex);
1508
1509         if (WARN_ON_ONCE(!mvm->mcast_filter_cmd))
1510                 return;
1511
1512         ieee80211_iterate_active_interfaces_atomic(
1513                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
1514                 iwl_mvm_mc_iface_iterator, &iter_data);
1515 }
1516
1517 static u64 iwl_mvm_prepare_multicast(struct ieee80211_hw *hw,
1518                                      struct netdev_hw_addr_list *mc_list)
1519 {
1520         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1521         struct iwl_mcast_filter_cmd *cmd;
1522         struct netdev_hw_addr *addr;
1523         int addr_count;
1524         bool pass_all;
1525         int len;
1526
1527         addr_count = netdev_hw_addr_list_count(mc_list);
1528         pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES ||
1529                    IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
1530         if (pass_all)
1531                 addr_count = 0;
1532
1533         len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
1534         cmd = kzalloc(len, GFP_ATOMIC);
1535         if (!cmd)
1536                 return 0;
1537
1538         if (pass_all) {
1539                 cmd->pass_all = 1;
1540                 return (u64)(unsigned long)cmd;
1541         }
1542
1543         netdev_hw_addr_list_for_each(addr, mc_list) {
1544                 IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n",
1545                                    cmd->count, addr->addr);
1546                 memcpy(&cmd->addr_list[cmd->count * ETH_ALEN],
1547                        addr->addr, ETH_ALEN);
1548                 cmd->count++;
1549         }
1550
1551         return (u64)(unsigned long)cmd;
1552 }
1553
1554 static void iwl_mvm_configure_filter(struct ieee80211_hw *hw,
1555                                      unsigned int changed_flags,
1556                                      unsigned int *total_flags,
1557                                      u64 multicast)
1558 {
1559         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1560         struct iwl_mcast_filter_cmd *cmd = (void *)(unsigned long)multicast;
1561
1562         mutex_lock(&mvm->mutex);
1563
1564         /* replace previous configuration */
1565         kfree(mvm->mcast_filter_cmd);
1566         mvm->mcast_filter_cmd = cmd;
1567
1568         if (!cmd)
1569                 goto out;
1570
1571         iwl_mvm_recalc_multicast(mvm);
1572 out:
1573         mutex_unlock(&mvm->mutex);
1574         *total_flags = 0;
1575 }
1576
1577 static void iwl_mvm_config_iface_filter(struct ieee80211_hw *hw,
1578                                         struct ieee80211_vif *vif,
1579                                         unsigned int filter_flags,
1580                                         unsigned int changed_flags)
1581 {
1582         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1583
1584         /* We support only filter for probe requests */
1585         if (!(changed_flags & FIF_PROBE_REQ))
1586                 return;
1587
1588         /* Supported only for p2p client interfaces */
1589         if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc ||
1590             !vif->p2p)
1591                 return;
1592
1593         mutex_lock(&mvm->mutex);
1594         iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
1595         mutex_unlock(&mvm->mutex);
1596 }
1597
1598 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1599 struct iwl_bcast_iter_data {
1600         struct iwl_mvm *mvm;
1601         struct iwl_bcast_filter_cmd *cmd;
1602         u8 current_filter;
1603 };
1604
1605 static void
1606 iwl_mvm_set_bcast_filter(struct ieee80211_vif *vif,
1607                          const struct iwl_fw_bcast_filter *in_filter,
1608                          struct iwl_fw_bcast_filter *out_filter)
1609 {
1610         struct iwl_fw_bcast_filter_attr *attr;
1611         int i;
1612
1613         memcpy(out_filter, in_filter, sizeof(*out_filter));
1614
1615         for (i = 0; i < ARRAY_SIZE(out_filter->attrs); i++) {
1616                 attr = &out_filter->attrs[i];
1617
1618                 if (!attr->mask)
1619                         break;
1620
1621                 switch (attr->reserved1) {
1622                 case cpu_to_le16(BC_FILTER_MAGIC_IP):
1623                         if (vif->bss_conf.arp_addr_cnt != 1) {
1624                                 attr->mask = 0;
1625                                 continue;
1626                         }
1627
1628                         attr->val = vif->bss_conf.arp_addr_list[0];
1629                         break;
1630                 case cpu_to_le16(BC_FILTER_MAGIC_MAC):
1631                         attr->val = *(__be32 *)&vif->addr[2];
1632                         break;
1633                 default:
1634                         break;
1635                 }
1636                 attr->reserved1 = 0;
1637                 out_filter->num_attrs++;
1638         }
1639 }
1640
1641 static void iwl_mvm_bcast_filter_iterator(void *_data, u8 *mac,
1642                                           struct ieee80211_vif *vif)
1643 {
1644         struct iwl_bcast_iter_data *data = _data;
1645         struct iwl_mvm *mvm = data->mvm;
1646         struct iwl_bcast_filter_cmd *cmd = data->cmd;
1647         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1648         struct iwl_fw_bcast_mac *bcast_mac;
1649         int i;
1650
1651         if (WARN_ON(mvmvif->id >= ARRAY_SIZE(cmd->macs)))
1652                 return;
1653
1654         bcast_mac = &cmd->macs[mvmvif->id];
1655
1656         /*
1657          * enable filtering only for associated stations, but not for P2P
1658          * Clients
1659          */
1660         if (vif->type != NL80211_IFTYPE_STATION || vif->p2p ||
1661             !vif->bss_conf.assoc)
1662                 return;
1663
1664         bcast_mac->default_discard = 1;
1665
1666         /* copy all configured filters */
1667         for (i = 0; mvm->bcast_filters[i].attrs[0].mask; i++) {
1668                 /*
1669                  * Make sure we don't exceed our filters limit.
1670                  * if there is still a valid filter to be configured,
1671                  * be on the safe side and just allow bcast for this mac.
1672                  */
1673                 if (WARN_ON_ONCE(data->current_filter >=
1674                                  ARRAY_SIZE(cmd->filters))) {
1675                         bcast_mac->default_discard = 0;
1676                         bcast_mac->attached_filters = 0;
1677                         break;
1678                 }
1679
1680                 iwl_mvm_set_bcast_filter(vif,
1681                                          &mvm->bcast_filters[i],
1682                                          &cmd->filters[data->current_filter]);
1683
1684                 /* skip current filter if it contains no attributes */
1685                 if (!cmd->filters[data->current_filter].num_attrs)
1686                         continue;
1687
1688                 /* attach the filter to current mac */
1689                 bcast_mac->attached_filters |=
1690                                 cpu_to_le16(BIT(data->current_filter));
1691
1692                 data->current_filter++;
1693         }
1694 }
1695
1696 bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm,
1697                                     struct iwl_bcast_filter_cmd *cmd)
1698 {
1699         struct iwl_bcast_iter_data iter_data = {
1700                 .mvm = mvm,
1701                 .cmd = cmd,
1702         };
1703
1704         if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL)
1705                 return false;
1706
1707         memset(cmd, 0, sizeof(*cmd));
1708         cmd->max_bcast_filters = ARRAY_SIZE(cmd->filters);
1709         cmd->max_macs = ARRAY_SIZE(cmd->macs);
1710
1711 #ifdef CONFIG_IWLWIFI_DEBUGFS
1712         /* use debugfs filters/macs if override is configured */
1713         if (mvm->dbgfs_bcast_filtering.override) {
1714                 memcpy(cmd->filters, &mvm->dbgfs_bcast_filtering.cmd.filters,
1715                        sizeof(cmd->filters));
1716                 memcpy(cmd->macs, &mvm->dbgfs_bcast_filtering.cmd.macs,
1717                        sizeof(cmd->macs));
1718                 return true;
1719         }
1720 #endif
1721
1722         /* if no filters are configured, do nothing */
1723         if (!mvm->bcast_filters)
1724                 return false;
1725
1726         /* configure and attach these filters for each associated sta vif */
1727         ieee80211_iterate_active_interfaces(
1728                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
1729                 iwl_mvm_bcast_filter_iterator, &iter_data);
1730
1731         return true;
1732 }
1733 static int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm,
1734                                           struct ieee80211_vif *vif)
1735 {
1736         struct iwl_bcast_filter_cmd cmd;
1737
1738         if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING))
1739                 return 0;
1740
1741         if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd))
1742                 return 0;
1743
1744         return iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0,
1745                                     sizeof(cmd), &cmd);
1746 }
1747 #else
1748 static inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm,
1749                                                  struct ieee80211_vif *vif)
1750 {
1751         return 0;
1752 }
1753 #endif
1754
1755 static void iwl_mvm_bss_info_changed_station(struct iwl_mvm *mvm,
1756                                              struct ieee80211_vif *vif,
1757                                              struct ieee80211_bss_conf *bss_conf,
1758                                              u32 changes)
1759 {
1760         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1761         int ret;
1762
1763         /*
1764          * Re-calculate the tsf id, as the master-slave relations depend on the
1765          * beacon interval, which was not known when the station interface was
1766          * added.
1767          */
1768         if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc)
1769                 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
1770
1771         /*
1772          * If we're not associated yet, take the (new) BSSID before associating
1773          * so the firmware knows. If we're already associated, then use the old
1774          * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
1775          * branch for disassociation below.
1776          */
1777         if (changes & BSS_CHANGED_BSSID && !mvmvif->associated)
1778                 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
1779
1780         ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
1781         if (ret)
1782                 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
1783
1784         /* after sending it once, adopt mac80211 data */
1785         memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
1786         mvmvif->associated = bss_conf->assoc;
1787
1788         if (changes & BSS_CHANGED_ASSOC) {
1789                 if (bss_conf->assoc) {
1790                         /* clear statistics to get clean beacon counter */
1791                         iwl_mvm_request_statistics(mvm, true);
1792                         memset(&mvmvif->beacon_stats, 0,
1793                                sizeof(mvmvif->beacon_stats));
1794
1795                         /* add quota for this interface */
1796                         ret = iwl_mvm_update_quotas(mvm, true, NULL);
1797                         if (ret) {
1798                                 IWL_ERR(mvm, "failed to update quotas\n");
1799                                 return;
1800                         }
1801
1802                         if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
1803                                      &mvm->status)) {
1804                                 /*
1805                                  * If we're restarting then the firmware will
1806                                  * obviously have lost synchronisation with
1807                                  * the AP. It will attempt to synchronise by
1808                                  * itself, but we can make it more reliable by
1809                                  * scheduling a session protection time event.
1810                                  *
1811                                  * The firmware needs to receive a beacon to
1812                                  * catch up with synchronisation, use 110% of
1813                                  * the beacon interval.
1814                                  *
1815                                  * Set a large maximum delay to allow for more
1816                                  * than a single interface.
1817                                  */
1818                                 u32 dur = (11 * vif->bss_conf.beacon_int) / 10;
1819                                 iwl_mvm_protect_session(mvm, vif, dur, dur,
1820                                                         5 * dur, false);
1821                         }
1822
1823                         iwl_mvm_sf_update(mvm, vif, false);
1824                         iwl_mvm_power_vif_assoc(mvm, vif);
1825                         if (vif->p2p) {
1826                                 iwl_mvm_ref(mvm, IWL_MVM_REF_P2P_CLIENT);
1827                                 iwl_mvm_update_smps(mvm, vif,
1828                                                     IWL_MVM_SMPS_REQ_PROT,
1829                                                     IEEE80211_SMPS_DYNAMIC);
1830                         }
1831                 } else if (mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT) {
1832                         /*
1833                          * If update fails - SF might be running in associated
1834                          * mode while disassociated - which is forbidden.
1835                          */
1836                         WARN_ONCE(iwl_mvm_sf_update(mvm, vif, false),
1837                                   "Failed to update SF upon disassociation\n");
1838
1839                         /* remove AP station now that the MAC is unassoc */
1840                         ret = iwl_mvm_rm_sta_id(mvm, vif, mvmvif->ap_sta_id);
1841                         if (ret)
1842                                 IWL_ERR(mvm, "failed to remove AP station\n");
1843
1844                         if (mvm->d0i3_ap_sta_id == mvmvif->ap_sta_id)
1845                                 mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
1846                         mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
1847                         /* remove quota for this interface */
1848                         ret = iwl_mvm_update_quotas(mvm, false, NULL);
1849                         if (ret)
1850                                 IWL_ERR(mvm, "failed to update quotas\n");
1851
1852                         if (vif->p2p)
1853                                 iwl_mvm_unref(mvm, IWL_MVM_REF_P2P_CLIENT);
1854
1855                         /* this will take the cleared BSSID from bss_conf */
1856                         ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
1857                         if (ret)
1858                                 IWL_ERR(mvm,
1859                                         "failed to update MAC %pM (clear after unassoc)\n",
1860                                         vif->addr);
1861                 }
1862
1863                 iwl_mvm_recalc_multicast(mvm);
1864                 iwl_mvm_configure_bcast_filter(mvm, vif);
1865
1866                 /* reset rssi values */
1867                 mvmvif->bf_data.ave_beacon_signal = 0;
1868
1869                 iwl_mvm_bt_coex_vif_change(mvm);
1870                 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT,
1871                                     IEEE80211_SMPS_AUTOMATIC);
1872                 if (fw_has_capa(&mvm->fw->ucode_capa,
1873                                 IWL_UCODE_TLV_CAPA_UMAC_SCAN))
1874                         iwl_mvm_config_scan(mvm);
1875         } else if (changes & BSS_CHANGED_BEACON_INFO) {
1876                 /*
1877                  * We received a beacon _after_ association so
1878                  * remove the session protection.
1879                  */
1880                 iwl_mvm_remove_time_event(mvm, mvmvif,
1881                                           &mvmvif->time_event_data);
1882         }
1883
1884         if (changes & BSS_CHANGED_BEACON_INFO) {
1885                 iwl_mvm_sf_update(mvm, vif, false);
1886                 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
1887         }
1888
1889         if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS)) {
1890                 ret = iwl_mvm_power_update_mac(mvm);
1891                 if (ret)
1892                         IWL_ERR(mvm, "failed to update power mode\n");
1893         }
1894
1895         if (changes & BSS_CHANGED_TXPOWER) {
1896                 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
1897                                 bss_conf->txpower);
1898                 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
1899         }
1900
1901         if (changes & BSS_CHANGED_CQM) {
1902                 IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
1903                 /* reset cqm events tracking */
1904                 mvmvif->bf_data.last_cqm_event = 0;
1905                 if (mvmvif->bf_data.bf_enabled) {
1906                         ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
1907                         if (ret)
1908                                 IWL_ERR(mvm,
1909                                         "failed to update CQM thresholds\n");
1910                 }
1911         }
1912
1913         if (changes & BSS_CHANGED_ARP_FILTER) {
1914                 IWL_DEBUG_MAC80211(mvm, "arp filter changed\n");
1915                 iwl_mvm_configure_bcast_filter(mvm, vif);
1916         }
1917 }
1918
1919 static int iwl_mvm_start_ap_ibss(struct ieee80211_hw *hw,
1920                                  struct ieee80211_vif *vif)
1921 {
1922         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1923         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1924         int ret;
1925
1926         /*
1927          * iwl_mvm_mac_ctxt_add() might read directly from the device
1928          * (the system time), so make sure it is available.
1929          */
1930         ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_START_AP);
1931         if (ret)
1932                 return ret;
1933
1934         mutex_lock(&mvm->mutex);
1935
1936         /* Send the beacon template */
1937         ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
1938         if (ret)
1939                 goto out_unlock;
1940
1941         /*
1942          * Re-calculate the tsf id, as the master-slave relations depend on the
1943          * beacon interval, which was not known when the AP interface was added.
1944          */
1945         if (vif->type == NL80211_IFTYPE_AP)
1946                 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
1947
1948         mvmvif->ap_assoc_sta_count = 0;
1949
1950         /* Add the mac context */
1951         ret = iwl_mvm_mac_ctxt_add(mvm, vif);
1952         if (ret)
1953                 goto out_unlock;
1954
1955         /* Perform the binding */
1956         ret = iwl_mvm_binding_add_vif(mvm, vif);
1957         if (ret)
1958                 goto out_remove;
1959
1960         /* Send the bcast station. At this stage the TBTT and DTIM time events
1961          * are added and applied to the scheduler */
1962         ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
1963         if (ret)
1964                 goto out_unbind;
1965
1966         /* must be set before quota calculations */
1967         mvmvif->ap_ibss_active = true;
1968
1969         /* power updated needs to be done before quotas */
1970         iwl_mvm_power_update_mac(mvm);
1971
1972         ret = iwl_mvm_update_quotas(mvm, false, NULL);
1973         if (ret)
1974                 goto out_quota_failed;
1975
1976         /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
1977         if (vif->p2p && mvm->p2p_device_vif)
1978                 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
1979
1980         iwl_mvm_ref(mvm, IWL_MVM_REF_AP_IBSS);
1981
1982         iwl_mvm_bt_coex_vif_change(mvm);
1983
1984         /* we don't support TDLS during DCM */
1985         if (iwl_mvm_phy_ctx_count(mvm) > 1)
1986                 iwl_mvm_teardown_tdls_peers(mvm);
1987
1988         goto out_unlock;
1989
1990 out_quota_failed:
1991         iwl_mvm_power_update_mac(mvm);
1992         mvmvif->ap_ibss_active = false;
1993         iwl_mvm_send_rm_bcast_sta(mvm, vif);
1994 out_unbind:
1995         iwl_mvm_binding_remove_vif(mvm, vif);
1996 out_remove:
1997         iwl_mvm_mac_ctxt_remove(mvm, vif);
1998 out_unlock:
1999         mutex_unlock(&mvm->mutex);
2000         iwl_mvm_unref(mvm, IWL_MVM_REF_START_AP);
2001         return ret;
2002 }
2003
2004 static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw,
2005                                  struct ieee80211_vif *vif)
2006 {
2007         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2008         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2009
2010         iwl_mvm_prepare_mac_removal(mvm, vif);
2011
2012         mutex_lock(&mvm->mutex);
2013
2014         /* Handle AP stop while in CSA */
2015         if (rcu_access_pointer(mvm->csa_vif) == vif) {
2016                 iwl_mvm_remove_time_event(mvm, mvmvif,
2017                                           &mvmvif->time_event_data);
2018                 RCU_INIT_POINTER(mvm->csa_vif, NULL);
2019                 mvmvif->csa_countdown = false;
2020         }
2021
2022         if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
2023                 RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
2024                 mvm->csa_tx_block_bcn_timeout = 0;
2025         }
2026
2027         mvmvif->ap_ibss_active = false;
2028         mvm->ap_last_beacon_gp2 = 0;
2029
2030         iwl_mvm_bt_coex_vif_change(mvm);
2031
2032         iwl_mvm_unref(mvm, IWL_MVM_REF_AP_IBSS);
2033
2034         /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
2035         if (vif->p2p && mvm->p2p_device_vif)
2036                 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
2037
2038         iwl_mvm_update_quotas(mvm, false, NULL);
2039         iwl_mvm_send_rm_bcast_sta(mvm, vif);
2040         iwl_mvm_binding_remove_vif(mvm, vif);
2041
2042         iwl_mvm_power_update_mac(mvm);
2043
2044         iwl_mvm_mac_ctxt_remove(mvm, vif);
2045
2046         mutex_unlock(&mvm->mutex);
2047 }
2048
2049 static void
2050 iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm *mvm,
2051                                  struct ieee80211_vif *vif,
2052                                  struct ieee80211_bss_conf *bss_conf,
2053                                  u32 changes)
2054 {
2055         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2056
2057         /* Changes will be applied when the AP/IBSS is started */
2058         if (!mvmvif->ap_ibss_active)
2059                 return;
2060
2061         if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT |
2062                        BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
2063             iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL))
2064                 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
2065
2066         /* Need to send a new beacon template to the FW */
2067         if (changes & BSS_CHANGED_BEACON &&
2068             iwl_mvm_mac_ctxt_beacon_changed(mvm, vif))
2069                 IWL_WARN(mvm, "Failed updating beacon data\n");
2070
2071         if (changes & BSS_CHANGED_TXPOWER) {
2072                 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
2073                                 bss_conf->txpower);
2074                 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
2075         }
2076
2077 }
2078
2079 static void iwl_mvm_bss_info_changed(struct ieee80211_hw *hw,
2080                                      struct ieee80211_vif *vif,
2081                                      struct ieee80211_bss_conf *bss_conf,
2082                                      u32 changes)
2083 {
2084         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2085
2086         /*
2087          * iwl_mvm_bss_info_changed_station() might call
2088          * iwl_mvm_protect_session(), which reads directly from
2089          * the device (the system time), so make sure it is available.
2090          */
2091         if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_BSS_CHANGED))
2092                 return;
2093
2094         mutex_lock(&mvm->mutex);
2095
2096         if (changes & BSS_CHANGED_IDLE && !bss_conf->idle)
2097                 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
2098
2099         switch (vif->type) {
2100         case NL80211_IFTYPE_STATION:
2101                 iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
2102                 break;
2103         case NL80211_IFTYPE_AP:
2104         case NL80211_IFTYPE_ADHOC:
2105                 iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
2106                 break;
2107         default:
2108                 /* shouldn't happen */
2109                 WARN_ON_ONCE(1);
2110         }
2111
2112         mutex_unlock(&mvm->mutex);
2113         iwl_mvm_unref(mvm, IWL_MVM_REF_BSS_CHANGED);
2114 }
2115
2116 static int iwl_mvm_mac_hw_scan(struct ieee80211_hw *hw,
2117                                struct ieee80211_vif *vif,
2118                                struct ieee80211_scan_request *hw_req)
2119 {
2120         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2121         int ret;
2122
2123         if (hw_req->req.n_channels == 0 ||
2124             hw_req->req.n_channels > mvm->fw->ucode_capa.n_scan_channels)
2125                 return -EINVAL;
2126
2127         mutex_lock(&mvm->mutex);
2128         ret = iwl_mvm_reg_scan_start(mvm, vif, &hw_req->req, &hw_req->ies);
2129         mutex_unlock(&mvm->mutex);
2130
2131         return ret;
2132 }
2133
2134 static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw *hw,
2135                                        struct ieee80211_vif *vif)
2136 {
2137         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2138
2139         mutex_lock(&mvm->mutex);
2140
2141         /* Due to a race condition, it's possible that mac80211 asks
2142          * us to stop a hw_scan when it's already stopped.  This can
2143          * happen, for instance, if we stopped the scan ourselves,
2144          * called ieee80211_scan_completed() and the userspace called
2145          * cancel scan scan before ieee80211_scan_work() could run.
2146          * To handle that, simply return if the scan is not running.
2147         */
2148         if (mvm->scan_status & IWL_MVM_SCAN_REGULAR)
2149                 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
2150
2151         mutex_unlock(&mvm->mutex);
2152 }
2153
2154 static void
2155 iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw *hw,
2156                                   struct ieee80211_sta *sta, u16 tids,
2157                                   int num_frames,
2158                                   enum ieee80211_frame_release_type reason,
2159                                   bool more_data)
2160 {
2161         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2162
2163         /* Called when we need to transmit (a) frame(s) from mac80211 */
2164
2165         iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2166                                           tids, more_data, false);
2167 }
2168
2169 static void
2170 iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw *hw,
2171                                     struct ieee80211_sta *sta, u16 tids,
2172                                     int num_frames,
2173                                     enum ieee80211_frame_release_type reason,
2174                                     bool more_data)
2175 {
2176         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2177
2178         /* Called when we need to transmit (a) frame(s) from agg queue */
2179
2180         iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2181                                           tids, more_data, true);
2182 }
2183
2184 static void iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw,
2185                                    struct ieee80211_vif *vif,
2186                                    enum sta_notify_cmd cmd,
2187                                    struct ieee80211_sta *sta)
2188 {
2189         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2190         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2191         unsigned long txqs = 0, tids = 0;
2192         int tid;
2193
2194         spin_lock_bh(&mvmsta->lock);
2195         for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
2196                 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2197
2198                 if (tid_data->state != IWL_AGG_ON &&
2199                     tid_data->state != IWL_EMPTYING_HW_QUEUE_DELBA)
2200                         continue;
2201
2202                 __set_bit(tid_data->txq_id, &txqs);
2203
2204                 if (iwl_mvm_tid_queued(tid_data) == 0)
2205                         continue;
2206
2207                 __set_bit(tid, &tids);
2208         }
2209
2210         switch (cmd) {
2211         case STA_NOTIFY_SLEEP:
2212                 if (atomic_read(&mvm->pending_frames[mvmsta->sta_id]) > 0)
2213                         ieee80211_sta_block_awake(hw, sta, true);
2214
2215                 for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT)
2216                         ieee80211_sta_set_buffered(sta, tid, true);
2217
2218                 if (txqs)
2219                         iwl_trans_freeze_txq_timer(mvm->trans, txqs, true);
2220                 /*
2221                  * The fw updates the STA to be asleep. Tx packets on the Tx
2222                  * queues to this station will not be transmitted. The fw will
2223                  * send a Tx response with TX_STATUS_FAIL_DEST_PS.
2224                  */
2225                 break;
2226         case STA_NOTIFY_AWAKE:
2227                 if (WARN_ON(mvmsta->sta_id == IWL_MVM_STATION_COUNT))
2228                         break;
2229
2230                 if (txqs)
2231                         iwl_trans_freeze_txq_timer(mvm->trans, txqs, false);
2232                 iwl_mvm_sta_modify_ps_wake(mvm, sta);
2233                 break;
2234         default:
2235                 break;
2236         }
2237         spin_unlock_bh(&mvmsta->lock);
2238 }
2239
2240 static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw *hw,
2241                                        struct ieee80211_vif *vif,
2242                                        struct ieee80211_sta *sta)
2243 {
2244         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2245         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2246         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
2247
2248         /*
2249          * This is called before mac80211 does RCU synchronisation,
2250          * so here we already invalidate our internal RCU-protected
2251          * station pointer. The rest of the code will thus no longer
2252          * be able to find the station this way, and we don't rely
2253          * on further RCU synchronisation after the sta_state()
2254          * callback deleted the station.
2255          */
2256         mutex_lock(&mvm->mutex);
2257         if (sta == rcu_access_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id]))
2258                 rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
2259                                    ERR_PTR(-ENOENT));
2260
2261         if (mvm_sta->vif->type == NL80211_IFTYPE_AP) {
2262                 mvmvif->ap_assoc_sta_count--;
2263                 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2264         }
2265
2266         mutex_unlock(&mvm->mutex);
2267 }
2268
2269 static void iwl_mvm_check_uapsd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2270                                 const u8 *bssid)
2271 {
2272         if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT))
2273                 return;
2274
2275         if (iwlwifi_mod_params.uapsd_disable) {
2276                 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
2277                 return;
2278         }
2279
2280         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
2281 }
2282
2283 static void
2284 iwl_mvm_tdls_check_trigger(struct iwl_mvm *mvm,
2285                            struct ieee80211_vif *vif, u8 *peer_addr,
2286                            enum nl80211_tdls_operation action)
2287 {
2288         struct iwl_fw_dbg_trigger_tlv *trig;
2289         struct iwl_fw_dbg_trigger_tdls *tdls_trig;
2290
2291         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TDLS))
2292                 return;
2293
2294         trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TDLS);
2295         tdls_trig = (void *)trig->data;
2296         if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
2297                 return;
2298
2299         if (!(tdls_trig->action_bitmap & BIT(action)))
2300                 return;
2301
2302         if (tdls_trig->peer_mode &&
2303             memcmp(tdls_trig->peer, peer_addr, ETH_ALEN) != 0)
2304                 return;
2305
2306         iwl_mvm_fw_dbg_collect_trig(mvm, trig,
2307                                     "TDLS event occurred, peer %pM, action %d",
2308                                     peer_addr, action);
2309 }
2310
2311 static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,
2312                                  struct ieee80211_vif *vif,
2313                                  struct ieee80211_sta *sta,
2314                                  enum ieee80211_sta_state old_state,
2315                                  enum ieee80211_sta_state new_state)
2316 {
2317         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2318         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2319         int ret;
2320
2321         IWL_DEBUG_MAC80211(mvm, "station %pM state change %d->%d\n",
2322                            sta->addr, old_state, new_state);
2323
2324         /* this would be a mac80211 bug ... but don't crash */
2325         if (WARN_ON_ONCE(!mvmvif->phy_ctxt))
2326                 return -EINVAL;
2327
2328         /* if a STA is being removed, reuse its ID */
2329         flush_work(&mvm->sta_drained_wk);
2330
2331         mutex_lock(&mvm->mutex);
2332         if (old_state == IEEE80211_STA_NOTEXIST &&
2333             new_state == IEEE80211_STA_NONE) {
2334                 /*
2335                  * Firmware bug - it'll crash if the beacon interval is less
2336                  * than 16. We can't avoid connecting at all, so refuse the
2337                  * station state change, this will cause mac80211 to abandon
2338                  * attempts to connect to this AP, and eventually wpa_s will
2339                  * blacklist the AP...
2340                  */
2341                 if (vif->type == NL80211_IFTYPE_STATION &&
2342                     vif->bss_conf.beacon_int < 16) {
2343                         IWL_ERR(mvm,
2344                                 "AP %pM beacon interval is %d, refusing due to firmware bug!\n",
2345                                 sta->addr, vif->bss_conf.beacon_int);
2346                         ret = -EINVAL;
2347                         goto out_unlock;
2348                 }
2349
2350                 if (sta->tdls &&
2351                     (vif->p2p ||
2352                      iwl_mvm_tdls_sta_count(mvm, NULL) ==
2353                                                 IWL_MVM_TDLS_STA_COUNT ||
2354                      iwl_mvm_phy_ctx_count(mvm) > 1)) {
2355                         IWL_DEBUG_MAC80211(mvm, "refusing TDLS sta\n");
2356                         ret = -EBUSY;
2357                         goto out_unlock;
2358                 }
2359
2360                 ret = iwl_mvm_add_sta(mvm, vif, sta);
2361                 if (sta->tdls && ret == 0) {
2362                         iwl_mvm_recalc_tdls_state(mvm, vif, true);
2363                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2364                                                    NL80211_TDLS_SETUP);
2365                 }
2366         } else if (old_state == IEEE80211_STA_NONE &&
2367                    new_state == IEEE80211_STA_AUTH) {
2368                 /*
2369                  * EBS may be disabled due to previous failures reported by FW.
2370                  * Reset EBS status here assuming environment has been changed.
2371                  */
2372                 mvm->last_ebs_successful = true;
2373                 iwl_mvm_check_uapsd(mvm, vif, sta->addr);
2374                 ret = 0;
2375         } else if (old_state == IEEE80211_STA_AUTH &&
2376                    new_state == IEEE80211_STA_ASSOC) {
2377                 ret = iwl_mvm_update_sta(mvm, vif, sta);
2378                 if (ret == 0)
2379                         iwl_mvm_rs_rate_init(mvm, sta,
2380                                              mvmvif->phy_ctxt->channel->band,
2381                                              true);
2382         } else if (old_state == IEEE80211_STA_ASSOC &&
2383                    new_state == IEEE80211_STA_AUTHORIZED) {
2384
2385                 /* we don't support TDLS during DCM */
2386                 if (iwl_mvm_phy_ctx_count(mvm) > 1)
2387                         iwl_mvm_teardown_tdls_peers(mvm);
2388
2389                 if (sta->tdls)
2390                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2391                                                    NL80211_TDLS_ENABLE_LINK);
2392
2393                 /* enable beacon filtering */
2394                 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
2395                 ret = 0;
2396         } else if (old_state == IEEE80211_STA_AUTHORIZED &&
2397                    new_state == IEEE80211_STA_ASSOC) {
2398                 /* disable beacon filtering */
2399                 WARN_ON(iwl_mvm_disable_beacon_filter(mvm, vif, 0));
2400                 ret = 0;
2401         } else if (old_state == IEEE80211_STA_ASSOC &&
2402                    new_state == IEEE80211_STA_AUTH) {
2403                 ret = 0;
2404         } else if (old_state == IEEE80211_STA_AUTH &&
2405                    new_state == IEEE80211_STA_NONE) {
2406                 ret = 0;
2407         } else if (old_state == IEEE80211_STA_NONE &&
2408                    new_state == IEEE80211_STA_NOTEXIST) {
2409                 ret = iwl_mvm_rm_sta(mvm, vif, sta);
2410                 if (sta->tdls) {
2411                         iwl_mvm_recalc_tdls_state(mvm, vif, false);
2412                         iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2413                                                    NL80211_TDLS_DISABLE_LINK);
2414                 }
2415         } else {
2416                 ret = -EIO;
2417         }
2418  out_unlock:
2419         mutex_unlock(&mvm->mutex);
2420
2421         if (sta->tdls && ret == 0) {
2422                 if (old_state == IEEE80211_STA_NOTEXIST &&
2423                     new_state == IEEE80211_STA_NONE)
2424                         ieee80211_reserve_tid(sta, IWL_MVM_TDLS_FW_TID);
2425                 else if (old_state == IEEE80211_STA_NONE &&
2426                          new_state == IEEE80211_STA_NOTEXIST)
2427                         ieee80211_unreserve_tid(sta, IWL_MVM_TDLS_FW_TID);
2428         }
2429
2430         return ret;
2431 }
2432
2433 static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2434 {
2435         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2436
2437         mvm->rts_threshold = value;
2438
2439         return 0;
2440 }
2441
2442 static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw,
2443                                   struct ieee80211_vif *vif,
2444                                   struct ieee80211_sta *sta, u32 changed)
2445 {
2446         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2447
2448         if (vif->type == NL80211_IFTYPE_STATION &&
2449             changed & IEEE80211_RC_NSS_CHANGED)
2450                 iwl_mvm_sf_update(mvm, vif, false);
2451 }
2452
2453 static int iwl_mvm_mac_conf_tx(struct ieee80211_hw *hw,
2454                                struct ieee80211_vif *vif, u16 ac,
2455                                const struct ieee80211_tx_queue_params *params)
2456 {
2457         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2458         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2459
2460         mvmvif->queue_params[ac] = *params;
2461
2462         /*
2463          * No need to update right away, we'll get BSS_CHANGED_QOS
2464          * The exception is P2P_DEVICE interface which needs immediate update.
2465          */
2466         if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
2467                 int ret;
2468
2469                 mutex_lock(&mvm->mutex);
2470                 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2471                 mutex_unlock(&mvm->mutex);
2472                 return ret;
2473         }
2474         return 0;
2475 }
2476
2477 static void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw *hw,
2478                                       struct ieee80211_vif *vif)
2479 {
2480         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2481         u32 duration = min(IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS,
2482                            200 + vif->bss_conf.beacon_int);
2483         u32 min_duration = min(IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS,
2484                                100 + vif->bss_conf.beacon_int);
2485
2486         if (WARN_ON_ONCE(vif->bss_conf.assoc))
2487                 return;
2488
2489         /*
2490          * iwl_mvm_protect_session() reads directly from the device
2491          * (the system time), so make sure it is available.
2492          */
2493         if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PREPARE_TX))
2494                 return;
2495
2496         mutex_lock(&mvm->mutex);
2497         /* Try really hard to protect the session and hear a beacon */
2498         iwl_mvm_protect_session(mvm, vif, duration, min_duration, 500, false);
2499         mutex_unlock(&mvm->mutex);
2500
2501         iwl_mvm_unref(mvm, IWL_MVM_REF_PREPARE_TX);
2502 }
2503
2504 static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw *hw,
2505                                         struct ieee80211_vif *vif,
2506                                         struct cfg80211_sched_scan_request *req,
2507                                         struct ieee80211_scan_ies *ies)
2508 {
2509         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2510
2511         int ret;
2512
2513         mutex_lock(&mvm->mutex);
2514
2515         if (!vif->bss_conf.idle) {
2516                 ret = -EBUSY;
2517                 goto out;
2518         }
2519
2520         ret = iwl_mvm_sched_scan_start(mvm, vif, req, ies, IWL_MVM_SCAN_SCHED);
2521
2522 out:
2523         mutex_unlock(&mvm->mutex);
2524         return ret;
2525 }
2526
2527 static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw *hw,
2528                                        struct ieee80211_vif *vif)
2529 {
2530         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2531         int ret;
2532
2533         mutex_lock(&mvm->mutex);
2534
2535         /* Due to a race condition, it's possible that mac80211 asks
2536          * us to stop a sched_scan when it's already stopped.  This
2537          * can happen, for instance, if we stopped the scan ourselves,
2538          * called ieee80211_sched_scan_stopped() and the userspace called
2539          * stop sched scan scan before ieee80211_sched_scan_stopped_work()
2540          * could run.  To handle this, simply return if the scan is
2541          * not running.
2542         */
2543         if (!(mvm->scan_status & IWL_MVM_SCAN_SCHED)) {
2544                 mutex_unlock(&mvm->mutex);
2545                 return 0;
2546         }
2547
2548         ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, false);
2549         mutex_unlock(&mvm->mutex);
2550         iwl_mvm_wait_for_async_handlers(mvm);
2551
2552         return ret;
2553 }
2554
2555 static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
2556                                enum set_key_cmd cmd,
2557                                struct ieee80211_vif *vif,
2558                                struct ieee80211_sta *sta,
2559                                struct ieee80211_key_conf *key)
2560 {
2561         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2562         int ret;
2563         u8 key_offset;
2564
2565         if (iwlwifi_mod_params.sw_crypto) {
2566                 IWL_DEBUG_MAC80211(mvm, "leave - hwcrypto disabled\n");
2567                 return -EOPNOTSUPP;
2568         }
2569
2570         switch (key->cipher) {
2571         case WLAN_CIPHER_SUITE_TKIP:
2572                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
2573                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2574                 break;
2575         case WLAN_CIPHER_SUITE_CCMP:
2576                 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2577                 break;
2578         case WLAN_CIPHER_SUITE_AES_CMAC:
2579                 WARN_ON_ONCE(!ieee80211_hw_check(hw, MFP_CAPABLE));
2580                 break;
2581         case WLAN_CIPHER_SUITE_WEP40:
2582         case WLAN_CIPHER_SUITE_WEP104:
2583                 /* For non-client mode, only use WEP keys for TX as we probably
2584                  * don't have a station yet anyway and would then have to keep
2585                  * track of the keys, linking them to each of the clients/peers
2586                  * as they appear. For now, don't do that, for performance WEP
2587                  * offload doesn't really matter much, but we need it for some
2588                  * other offload features in client mode.
2589                  */
2590                 if (vif->type != NL80211_IFTYPE_STATION)
2591                         return 0;
2592                 break;
2593         default:
2594                 /* currently FW supports only one optional cipher scheme */
2595                 if (hw->n_cipher_schemes &&
2596                     hw->cipher_schemes->cipher == key->cipher)
2597                         key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2598                 else
2599                         return -EOPNOTSUPP;
2600         }
2601
2602         mutex_lock(&mvm->mutex);
2603
2604         switch (cmd) {
2605         case SET_KEY:
2606                 if ((vif->type == NL80211_IFTYPE_ADHOC ||
2607                      vif->type == NL80211_IFTYPE_AP) && !sta) {
2608                         /*
2609                          * GTK on AP interface is a TX-only key, return 0;
2610                          * on IBSS they're per-station and because we're lazy
2611                          * we don't support them for RX, so do the same.
2612                          */
2613                         ret = 0;
2614                         key->hw_key_idx = STA_KEY_IDX_INVALID;
2615                         break;
2616                 }
2617
2618                 /* During FW restart, in order to restore the state as it was,
2619                  * don't try to reprogram keys we previously failed for.
2620                  */
2621                 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
2622                     key->hw_key_idx == STA_KEY_IDX_INVALID) {
2623                         IWL_DEBUG_MAC80211(mvm,
2624                                            "skip invalid idx key programming during restart\n");
2625                         ret = 0;
2626                         break;
2627                 }
2628
2629                 /* in HW restart reuse the index, otherwise request a new one */
2630                 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
2631                         key_offset = key->hw_key_idx;
2632                 else
2633                         key_offset = STA_KEY_IDX_INVALID;
2634
2635                 IWL_DEBUG_MAC80211(mvm, "set hwcrypto key\n");
2636                 ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);
2637                 if (ret) {
2638                         IWL_WARN(mvm, "set key failed\n");
2639                         /*
2640                          * can't add key for RX, but we don't need it
2641                          * in the device for TX so still return 0
2642                          */
2643                         key->hw_key_idx = STA_KEY_IDX_INVALID;
2644                         ret = 0;
2645                 }
2646
2647                 break;
2648         case DISABLE_KEY:
2649                 if (key->hw_key_idx == STA_KEY_IDX_INVALID) {
2650                         ret = 0;
2651                         break;
2652                 }
2653
2654                 IWL_DEBUG_MAC80211(mvm, "disable hwcrypto key\n");
2655                 ret = iwl_mvm_remove_sta_key(mvm, vif, sta, key);
2656                 break;
2657         default:
2658                 ret = -EINVAL;
2659         }
2660
2661         mutex_unlock(&mvm->mutex);
2662         return ret;
2663 }
2664
2665 static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw *hw,
2666                                         struct ieee80211_vif *vif,
2667                                         struct ieee80211_key_conf *keyconf,
2668                                         struct ieee80211_sta *sta,
2669                                         u32 iv32, u16 *phase1key)
2670 {
2671         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2672
2673         if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID)
2674                 return;
2675
2676         iwl_mvm_update_tkip_key(mvm, vif, keyconf, sta, iv32, phase1key);
2677 }
2678
2679
2680 static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data *notif_wait,
2681                                struct iwl_rx_packet *pkt, void *data)
2682 {
2683         struct iwl_mvm *mvm =
2684                 container_of(notif_wait, struct iwl_mvm, notif_wait);
2685         struct iwl_hs20_roc_res *resp;
2686         int resp_len = iwl_rx_packet_payload_len(pkt);
2687         struct iwl_mvm_time_event_data *te_data = data;
2688
2689         if (WARN_ON(pkt->hdr.cmd != HOT_SPOT_CMD))
2690                 return true;
2691
2692         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
2693                 IWL_ERR(mvm, "Invalid HOT_SPOT_CMD response\n");
2694                 return true;
2695         }
2696
2697         resp = (void *)pkt->data;
2698
2699         IWL_DEBUG_TE(mvm,
2700                      "Aux ROC: Recieved response from ucode: status=%d uid=%d\n",
2701                      resp->status, resp->event_unique_id);
2702
2703         te_data->uid = le32_to_cpu(resp->event_unique_id);
2704         IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n",
2705                      te_data->uid);
2706
2707         spin_lock_bh(&mvm->time_event_lock);
2708         list_add_tail(&te_data->list, &mvm->aux_roc_te_list);
2709         spin_unlock_bh(&mvm->time_event_lock);
2710
2711         return true;
2712 }
2713
2714 #define AUX_ROC_MIN_DURATION MSEC_TO_TU(100)
2715 #define AUX_ROC_MIN_DELAY MSEC_TO_TU(200)
2716 #define AUX_ROC_MAX_DELAY MSEC_TO_TU(600)
2717 #define AUX_ROC_SAFETY_BUFFER MSEC_TO_TU(20)
2718 #define AUX_ROC_MIN_SAFETY_BUFFER MSEC_TO_TU(10)
2719 static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm *mvm,
2720                                     struct ieee80211_channel *channel,
2721                                     struct ieee80211_vif *vif,
2722                                     int duration)
2723 {
2724         int res, time_reg = DEVICE_SYSTEM_TIME_REG;
2725         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2726         struct iwl_mvm_time_event_data *te_data = &mvmvif->hs_time_event_data;
2727         static const u16 time_event_response[] = { HOT_SPOT_CMD };
2728         struct iwl_notification_wait wait_time_event;
2729         u32 dtim_interval = vif->bss_conf.dtim_period *
2730                 vif->bss_conf.beacon_int;
2731         u32 req_dur, delay;
2732         struct iwl_hs20_roc_req aux_roc_req = {
2733                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
2734                 .id_and_color =
2735                         cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
2736                 .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
2737                 /* Set the channel info data */
2738                 .channel_info.band = (channel->band == IEEE80211_BAND_2GHZ) ?
2739                         PHY_BAND_24 : PHY_BAND_5,
2740                 .channel_info.channel = channel->hw_value,
2741                 .channel_info.width = PHY_VHT_CHANNEL_MODE20,
2742                 /* Set the time and duration */
2743                 .apply_time = cpu_to_le32(iwl_read_prph(mvm->trans, time_reg)),
2744          };
2745
2746         delay = AUX_ROC_MIN_DELAY;
2747         req_dur = MSEC_TO_TU(duration);
2748
2749         /*
2750          * If we are associated we want the delay time to be at least one
2751          * dtim interval so that the FW can wait until after the DTIM and
2752          * then start the time event, this will potentially allow us to
2753          * remain off-channel for the max duration.
2754          * Since we want to use almost a whole dtim interval we would also
2755          * like the delay to be for 2-3 dtim intervals, in case there are
2756          * other time events with higher priority.
2757          */
2758         if (vif->bss_conf.assoc) {
2759                 delay = min_t(u32, dtim_interval * 3, AUX_ROC_MAX_DELAY);
2760                 /* We cannot remain off-channel longer than the DTIM interval */
2761                 if (dtim_interval <= req_dur) {
2762                         req_dur = dtim_interval - AUX_ROC_SAFETY_BUFFER;
2763                         if (req_dur <= AUX_ROC_MIN_DURATION)
2764                                 req_dur = dtim_interval -
2765                                         AUX_ROC_MIN_SAFETY_BUFFER;
2766                 }
2767         }
2768
2769         aux_roc_req.duration = cpu_to_le32(req_dur);
2770         aux_roc_req.apply_time_max_delay = cpu_to_le32(delay);
2771
2772         IWL_DEBUG_TE(mvm,
2773                      "ROC: Requesting to remain on channel %u for %ums (requested = %ums, max_delay = %ums, dtim_interval = %ums)\n",
2774                      channel->hw_value, req_dur, duration, delay,
2775                      dtim_interval);
2776         /* Set the node address */
2777         memcpy(aux_roc_req.node_addr, vif->addr, ETH_ALEN);
2778
2779         lockdep_assert_held(&mvm->mutex);
2780
2781         spin_lock_bh(&mvm->time_event_lock);
2782
2783         if (WARN_ON(te_data->id == HOT_SPOT_CMD)) {
2784                 spin_unlock_bh(&mvm->time_event_lock);
2785                 return -EIO;
2786         }
2787
2788         te_data->vif = vif;
2789         te_data->duration = duration;
2790         te_data->id = HOT_SPOT_CMD;
2791
2792         spin_unlock_bh(&mvm->time_event_lock);
2793
2794         /*
2795          * Use a notification wait, which really just processes the
2796          * command response and doesn't wait for anything, in order
2797          * to be able to process the response and get the UID inside
2798          * the RX path. Using CMD_WANT_SKB doesn't work because it
2799          * stores the buffer and then wakes up this thread, by which
2800          * time another notification (that the time event started)
2801          * might already be processed unsuccessfully.
2802          */
2803         iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event,
2804                                    time_event_response,
2805                                    ARRAY_SIZE(time_event_response),
2806                                    iwl_mvm_rx_aux_roc, te_data);
2807
2808         res = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0, sizeof(aux_roc_req),
2809                                    &aux_roc_req);
2810
2811         if (res) {
2812                 IWL_ERR(mvm, "Couldn't send HOT_SPOT_CMD: %d\n", res);
2813                 iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
2814                 goto out_clear_te;
2815         }
2816
2817         /* No need to wait for anything, so just pass 1 (0 isn't valid) */
2818         res = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
2819         /* should never fail */
2820         WARN_ON_ONCE(res);
2821
2822         if (res) {
2823  out_clear_te:
2824                 spin_lock_bh(&mvm->time_event_lock);
2825                 iwl_mvm_te_clear_data(mvm, te_data);
2826                 spin_unlock_bh(&mvm->time_event_lock);
2827         }
2828
2829         return res;
2830 }
2831
2832 static int iwl_mvm_roc(struct ieee80211_hw *hw,
2833                        struct ieee80211_vif *vif,
2834                        struct ieee80211_channel *channel,
2835                        int duration,
2836                        enum ieee80211_roc_type type)
2837 {
2838         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2839         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2840         struct cfg80211_chan_def chandef;
2841         struct iwl_mvm_phy_ctxt *phy_ctxt;
2842         int ret, i;
2843
2844         IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value,
2845                            duration, type);
2846
2847         flush_work(&mvm->roc_done_wk);
2848
2849         mutex_lock(&mvm->mutex);
2850
2851         switch (vif->type) {
2852         case NL80211_IFTYPE_STATION:
2853                 if (fw_has_capa(&mvm->fw->ucode_capa,
2854                                 IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT)) {
2855                         /* Use aux roc framework (HS20) */
2856                         ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
2857                                                        vif, duration);
2858                         goto out_unlock;
2859                 }
2860                 IWL_ERR(mvm, "hotspot not supported\n");
2861                 ret = -EINVAL;
2862                 goto out_unlock;
2863         case NL80211_IFTYPE_P2P_DEVICE:
2864                 /* handle below */
2865                 break;
2866         default:
2867                 IWL_ERR(mvm, "vif isn't P2P_DEVICE: %d\n", vif->type);
2868                 ret = -EINVAL;
2869                 goto out_unlock;
2870         }
2871
2872         for (i = 0; i < NUM_PHY_CTX; i++) {
2873                 phy_ctxt = &mvm->phy_ctxts[i];
2874                 if (phy_ctxt->ref == 0 || mvmvif->phy_ctxt == phy_ctxt)
2875                         continue;
2876
2877                 if (phy_ctxt->ref && channel == phy_ctxt->channel) {
2878                         /*
2879                          * Unbind the P2P_DEVICE from the current PHY context,
2880                          * and if the PHY context is not used remove it.
2881                          */
2882                         ret = iwl_mvm_binding_remove_vif(mvm, vif);
2883                         if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
2884                                 goto out_unlock;
2885
2886                         iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
2887
2888                         /* Bind the P2P_DEVICE to the current PHY Context */
2889                         mvmvif->phy_ctxt = phy_ctxt;
2890
2891                         ret = iwl_mvm_binding_add_vif(mvm, vif);
2892                         if (WARN(ret, "Failed binding P2P_DEVICE\n"))
2893                                 goto out_unlock;
2894
2895                         iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
2896                         goto schedule_time_event;
2897                 }
2898         }
2899
2900         /* Need to update the PHY context only if the ROC channel changed */
2901         if (channel == mvmvif->phy_ctxt->channel)
2902                 goto schedule_time_event;
2903
2904         cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
2905
2906         /*
2907          * Change the PHY context configuration as it is currently referenced
2908          * only by the P2P Device MAC
2909          */
2910         if (mvmvif->phy_ctxt->ref == 1) {
2911                 ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt,
2912                                                &chandef, 1, 1);
2913                 if (ret)
2914                         goto out_unlock;
2915         } else {
2916                 /*
2917                  * The PHY context is shared with other MACs. Need to remove the
2918                  * P2P Device from the binding, allocate an new PHY context and
2919                  * create a new binding
2920                  */
2921                 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
2922                 if (!phy_ctxt) {
2923                         ret = -ENOSPC;
2924                         goto out_unlock;
2925                 }
2926
2927                 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chandef,
2928                                                1, 1);
2929                 if (ret) {
2930                         IWL_ERR(mvm, "Failed to change PHY context\n");
2931                         goto out_unlock;
2932                 }
2933
2934                 /* Unbind the P2P_DEVICE from the current PHY context */
2935                 ret = iwl_mvm_binding_remove_vif(mvm, vif);
2936                 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
2937                         goto out_unlock;
2938
2939                 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
2940
2941                 /* Bind the P2P_DEVICE to the new allocated PHY context */
2942                 mvmvif->phy_ctxt = phy_ctxt;
2943
2944                 ret = iwl_mvm_binding_add_vif(mvm, vif);
2945                 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
2946                         goto out_unlock;
2947
2948                 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
2949         }
2950
2951 schedule_time_event:
2952         /* Schedule the time events */
2953         ret = iwl_mvm_start_p2p_roc(mvm, vif, duration, type);
2954
2955 out_unlock:
2956         mutex_unlock(&mvm->mutex);
2957         IWL_DEBUG_MAC80211(mvm, "leave\n");
2958         return ret;
2959 }
2960
2961 static int iwl_mvm_cancel_roc(struct ieee80211_hw *hw)
2962 {
2963         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2964
2965         IWL_DEBUG_MAC80211(mvm, "enter\n");
2966
2967         mutex_lock(&mvm->mutex);
2968         iwl_mvm_stop_roc(mvm);
2969         mutex_unlock(&mvm->mutex);
2970
2971         IWL_DEBUG_MAC80211(mvm, "leave\n");
2972         return 0;
2973 }
2974
2975 static int __iwl_mvm_add_chanctx(struct iwl_mvm *mvm,
2976                                  struct ieee80211_chanctx_conf *ctx)
2977 {
2978         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
2979         struct iwl_mvm_phy_ctxt *phy_ctxt;
2980         int ret;
2981
2982         lockdep_assert_held(&mvm->mutex);
2983
2984         IWL_DEBUG_MAC80211(mvm, "Add channel context\n");
2985
2986         phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
2987         if (!phy_ctxt) {
2988                 ret = -ENOSPC;
2989                 goto out;
2990         }
2991
2992         ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
2993                                        ctx->rx_chains_static,
2994                                        ctx->rx_chains_dynamic);
2995         if (ret) {
2996                 IWL_ERR(mvm, "Failed to add PHY context\n");
2997                 goto out;
2998         }
2999
3000         iwl_mvm_phy_ctxt_ref(mvm, phy_ctxt);
3001         *phy_ctxt_id = phy_ctxt->id;
3002 out:
3003         return ret;
3004 }
3005
3006 static int iwl_mvm_add_chanctx(struct ieee80211_hw *hw,
3007                                struct ieee80211_chanctx_conf *ctx)
3008 {
3009         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3010         int ret;
3011
3012         mutex_lock(&mvm->mutex);
3013         ret = __iwl_mvm_add_chanctx(mvm, ctx);
3014         mutex_unlock(&mvm->mutex);
3015
3016         return ret;
3017 }
3018
3019 static void __iwl_mvm_remove_chanctx(struct iwl_mvm *mvm,
3020                                      struct ieee80211_chanctx_conf *ctx)
3021 {
3022         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3023         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
3024
3025         lockdep_assert_held(&mvm->mutex);
3026
3027         iwl_mvm_phy_ctxt_unref(mvm, phy_ctxt);
3028 }
3029
3030 static void iwl_mvm_remove_chanctx(struct ieee80211_hw *hw,
3031                                    struct ieee80211_chanctx_conf *ctx)
3032 {
3033         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3034
3035         mutex_lock(&mvm->mutex);
3036         __iwl_mvm_remove_chanctx(mvm, ctx);
3037         mutex_unlock(&mvm->mutex);
3038 }
3039
3040 static void iwl_mvm_change_chanctx(struct ieee80211_hw *hw,
3041                                    struct ieee80211_chanctx_conf *ctx,
3042                                    u32 changed)
3043 {
3044         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3045         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3046         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
3047
3048         if (WARN_ONCE((phy_ctxt->ref > 1) &&
3049                       (changed & ~(IEEE80211_CHANCTX_CHANGE_WIDTH |
3050                                    IEEE80211_CHANCTX_CHANGE_RX_CHAINS |
3051                                    IEEE80211_CHANCTX_CHANGE_RADAR |
3052                                    IEEE80211_CHANCTX_CHANGE_MIN_WIDTH)),
3053                       "Cannot change PHY. Ref=%d, changed=0x%X\n",
3054                       phy_ctxt->ref, changed))
3055                 return;
3056
3057         mutex_lock(&mvm->mutex);
3058         iwl_mvm_bt_coex_vif_change(mvm);
3059         iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
3060                                  ctx->rx_chains_static,
3061                                  ctx->rx_chains_dynamic);
3062         mutex_unlock(&mvm->mutex);
3063 }
3064
3065 static int __iwl_mvm_assign_vif_chanctx(struct iwl_mvm *mvm,
3066                                         struct ieee80211_vif *vif,
3067                                         struct ieee80211_chanctx_conf *ctx,
3068                                         bool switching_chanctx)
3069 {
3070         u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3071         struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
3072         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3073         int ret;
3074
3075         lockdep_assert_held(&mvm->mutex);
3076
3077         mvmvif->phy_ctxt = phy_ctxt;
3078
3079         switch (vif->type) {
3080         case NL80211_IFTYPE_AP:
3081                 /* only needed if we're switching chanctx (i.e. during CSA) */
3082                 if (switching_chanctx) {
3083                         mvmvif->ap_ibss_active = true;
3084                         break;
3085                 }
3086         case NL80211_IFTYPE_ADHOC:
3087                 /*
3088                  * The AP binding flow is handled as part of the start_ap flow
3089                  * (in bss_info_changed), similarly for IBSS.
3090                  */
3091                 ret = 0;
3092                 goto out;
3093         case NL80211_IFTYPE_STATION:
3094                 break;
3095         case NL80211_IFTYPE_MONITOR:
3096                 /* always disable PS when a monitor interface is active */
3097                 mvmvif->ps_disabled = true;
3098                 break;
3099         default:
3100                 ret = -EINVAL;
3101                 goto out;
3102         }
3103
3104         ret = iwl_mvm_binding_add_vif(mvm, vif);
3105         if (ret)
3106                 goto out;
3107
3108         /*
3109          * Power state must be updated before quotas,
3110          * otherwise fw will complain.
3111          */
3112         iwl_mvm_power_update_mac(mvm);
3113
3114         /* Setting the quota at this stage is only required for monitor
3115          * interfaces. For the other types, the bss_info changed flow
3116          * will handle quota settings.
3117          */
3118         if (vif->type == NL80211_IFTYPE_MONITOR) {
3119                 mvmvif->monitor_active = true;
3120                 ret = iwl_mvm_update_quotas(mvm, false, NULL);
3121                 if (ret)
3122                         goto out_remove_binding;
3123         }
3124
3125         /* Handle binding during CSA */
3126         if (vif->type == NL80211_IFTYPE_AP) {
3127                 iwl_mvm_update_quotas(mvm, false, NULL);
3128                 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
3129         }
3130
3131         if (switching_chanctx && vif->type == NL80211_IFTYPE_STATION) {
3132                 u32 duration = 2 * vif->bss_conf.beacon_int;
3133
3134                 /* iwl_mvm_protect_session() reads directly from the
3135                  * device (the system time), so make sure it is
3136                  * available.
3137                  */
3138                 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_CSA);
3139                 if (ret)
3140                         goto out_remove_binding;
3141
3142                 /* Protect the session to make sure we hear the first
3143                  * beacon on the new channel.
3144                  */
3145                 iwl_mvm_protect_session(mvm, vif, duration, duration,
3146                                         vif->bss_conf.beacon_int / 2,
3147                                         true);
3148
3149                 iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_CSA);
3150
3151                 iwl_mvm_update_quotas(mvm, false, NULL);
3152         }
3153
3154         goto out;
3155
3156 out_remove_binding:
3157         iwl_mvm_binding_remove_vif(mvm, vif);
3158         iwl_mvm_power_update_mac(mvm);
3159 out:
3160         if (ret)
3161                 mvmvif->phy_ctxt = NULL;
3162         return ret;
3163 }
3164 static int iwl_mvm_assign_vif_chanctx(struct ieee80211_hw *hw,
3165                                       struct ieee80211_vif *vif,
3166                                       struct ieee80211_chanctx_conf *ctx)
3167 {
3168         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3169         int ret;
3170
3171         mutex_lock(&mvm->mutex);
3172         ret = __iwl_mvm_assign_vif_chanctx(mvm, vif, ctx, false);
3173         mutex_unlock(&mvm->mutex);
3174
3175         return ret;
3176 }
3177
3178 static void __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm *mvm,
3179                                            struct ieee80211_vif *vif,
3180                                            struct ieee80211_chanctx_conf *ctx,
3181                                            bool switching_chanctx)
3182 {
3183         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3184         struct ieee80211_vif *disabled_vif = NULL;
3185
3186         lockdep_assert_held(&mvm->mutex);
3187
3188         iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
3189
3190         switch (vif->type) {
3191         case NL80211_IFTYPE_ADHOC:
3192                 goto out;
3193         case NL80211_IFTYPE_MONITOR:
3194                 mvmvif->monitor_active = false;
3195                 mvmvif->ps_disabled = false;
3196                 break;
3197         case NL80211_IFTYPE_AP:
3198                 /* This part is triggered only during CSA */
3199                 if (!switching_chanctx || !mvmvif->ap_ibss_active)
3200                         goto out;
3201
3202                 mvmvif->csa_countdown = false;
3203
3204                 /* Set CS bit on all the stations */
3205                 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true);
3206
3207                 /* Save blocked iface, the timeout is set on the next beacon */
3208                 rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif);
3209
3210                 mvmvif->ap_ibss_active = false;
3211                 break;
3212         case NL80211_IFTYPE_STATION:
3213                 if (!switching_chanctx)
3214                         break;
3215
3216                 disabled_vif = vif;
3217
3218                 iwl_mvm_mac_ctxt_changed(mvm, vif, true, NULL);
3219                 break;
3220         default:
3221                 break;
3222         }
3223
3224         iwl_mvm_update_quotas(mvm, false, disabled_vif);
3225         iwl_mvm_binding_remove_vif(mvm, vif);
3226
3227 out:
3228         mvmvif->phy_ctxt = NULL;
3229         iwl_mvm_power_update_mac(mvm);
3230 }
3231
3232 static void iwl_mvm_unassign_vif_chanctx(struct ieee80211_hw *hw,
3233                                          struct ieee80211_vif *vif,
3234                                          struct ieee80211_chanctx_conf *ctx)
3235 {
3236         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3237
3238         mutex_lock(&mvm->mutex);
3239         __iwl_mvm_unassign_vif_chanctx(mvm, vif, ctx, false);
3240         mutex_unlock(&mvm->mutex);
3241 }
3242
3243 static int
3244 iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm *mvm,
3245                                 struct ieee80211_vif_chanctx_switch *vifs)
3246 {
3247         int ret;
3248
3249         mutex_lock(&mvm->mutex);
3250         __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
3251         __iwl_mvm_remove_chanctx(mvm, vifs[0].old_ctx);
3252
3253         ret = __iwl_mvm_add_chanctx(mvm, vifs[0].new_ctx);
3254         if (ret) {
3255                 IWL_ERR(mvm, "failed to add new_ctx during channel switch\n");
3256                 goto out_reassign;
3257         }
3258
3259         ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3260                                            true);
3261         if (ret) {
3262                 IWL_ERR(mvm,
3263                         "failed to assign new_ctx during channel switch\n");
3264                 goto out_remove;
3265         }
3266
3267         /* we don't support TDLS during DCM - can be caused by channel switch */
3268         if (iwl_mvm_phy_ctx_count(mvm) > 1)
3269                 iwl_mvm_teardown_tdls_peers(mvm);
3270
3271         goto out;
3272
3273 out_remove:
3274         __iwl_mvm_remove_chanctx(mvm, vifs[0].new_ctx);
3275
3276 out_reassign:
3277         if (__iwl_mvm_add_chanctx(mvm, vifs[0].old_ctx)) {
3278                 IWL_ERR(mvm, "failed to add old_ctx back after failure.\n");
3279                 goto out_restart;
3280         }
3281
3282         if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3283                                          true)) {
3284                 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3285                 goto out_restart;
3286         }
3287
3288         goto out;
3289
3290 out_restart:
3291         /* things keep failing, better restart the hw */
3292         iwl_mvm_nic_restart(mvm, false);
3293
3294 out:
3295         mutex_unlock(&mvm->mutex);
3296
3297         return ret;
3298 }
3299
3300 static int
3301 iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm *mvm,
3302                                     struct ieee80211_vif_chanctx_switch *vifs)
3303 {
3304         int ret;
3305
3306         mutex_lock(&mvm->mutex);
3307         __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
3308
3309         ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3310                                            true);
3311         if (ret) {
3312                 IWL_ERR(mvm,
3313                         "failed to assign new_ctx during channel switch\n");
3314                 goto out_reassign;
3315         }
3316
3317         goto out;
3318
3319 out_reassign:
3320         if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3321                                          true)) {
3322                 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3323                 goto out_restart;
3324         }
3325
3326         goto out;
3327
3328 out_restart:
3329         /* things keep failing, better restart the hw */
3330         iwl_mvm_nic_restart(mvm, false);
3331
3332 out:
3333         mutex_unlock(&mvm->mutex);
3334
3335         return ret;
3336 }
3337
3338 static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw *hw,
3339                                       struct ieee80211_vif_chanctx_switch *vifs,
3340                                       int n_vifs,
3341                                       enum ieee80211_chanctx_switch_mode mode)
3342 {
3343         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3344         int ret;
3345
3346         /* we only support a single-vif right now */
3347         if (n_vifs > 1)
3348                 return -EOPNOTSUPP;
3349
3350         switch (mode) {
3351         case CHANCTX_SWMODE_SWAP_CONTEXTS:
3352                 ret = iwl_mvm_switch_vif_chanctx_swap(mvm, vifs);
3353                 break;
3354         case CHANCTX_SWMODE_REASSIGN_VIF:
3355                 ret = iwl_mvm_switch_vif_chanctx_reassign(mvm, vifs);
3356                 break;
3357         default:
3358                 ret = -EOPNOTSUPP;
3359                 break;
3360         }
3361
3362         return ret;
3363 }
3364
3365 static int iwl_mvm_set_tim(struct ieee80211_hw *hw,
3366                            struct ieee80211_sta *sta,
3367                            bool set)
3368 {
3369         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3370         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
3371
3372         if (!mvm_sta || !mvm_sta->vif) {
3373                 IWL_ERR(mvm, "Station is not associated to a vif\n");
3374                 return -EINVAL;
3375         }
3376
3377         return iwl_mvm_mac_ctxt_beacon_changed(mvm, mvm_sta->vif);
3378 }
3379
3380 #ifdef CONFIG_NL80211_TESTMODE
3381 static const struct nla_policy iwl_mvm_tm_policy[IWL_MVM_TM_ATTR_MAX + 1] = {
3382         [IWL_MVM_TM_ATTR_CMD] = { .type = NLA_U32 },
3383         [IWL_MVM_TM_ATTR_NOA_DURATION] = { .type = NLA_U32 },
3384         [IWL_MVM_TM_ATTR_BEACON_FILTER_STATE] = { .type = NLA_U32 },
3385 };
3386
3387 static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm *mvm,
3388                                       struct ieee80211_vif *vif,
3389                                       void *data, int len)
3390 {
3391         struct nlattr *tb[IWL_MVM_TM_ATTR_MAX + 1];
3392         int err;
3393         u32 noa_duration;
3394
3395         err = nla_parse(tb, IWL_MVM_TM_ATTR_MAX, data, len, iwl_mvm_tm_policy);
3396         if (err)
3397                 return err;
3398
3399         if (!tb[IWL_MVM_TM_ATTR_CMD])
3400                 return -EINVAL;
3401
3402         switch (nla_get_u32(tb[IWL_MVM_TM_ATTR_CMD])) {
3403         case IWL_MVM_TM_CMD_SET_NOA:
3404                 if (!vif || vif->type != NL80211_IFTYPE_AP || !vif->p2p ||
3405                     !vif->bss_conf.enable_beacon ||
3406                     !tb[IWL_MVM_TM_ATTR_NOA_DURATION])
3407                         return -EINVAL;
3408
3409                 noa_duration = nla_get_u32(tb[IWL_MVM_TM_ATTR_NOA_DURATION]);
3410                 if (noa_duration >= vif->bss_conf.beacon_int)
3411                         return -EINVAL;
3412
3413                 mvm->noa_duration = noa_duration;
3414                 mvm->noa_vif = vif;
3415
3416                 return iwl_mvm_update_quotas(mvm, false, NULL);
3417         case IWL_MVM_TM_CMD_SET_BEACON_FILTER:
3418                 /* must be associated client vif - ignore authorized */
3419                 if (!vif || vif->type != NL80211_IFTYPE_STATION ||
3420                     !vif->bss_conf.assoc || !vif->bss_conf.dtim_period ||
3421                     !tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE])
3422                         return -EINVAL;
3423
3424                 if (nla_get_u32(tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE]))
3425                         return iwl_mvm_enable_beacon_filter(mvm, vif, 0);
3426                 return iwl_mvm_disable_beacon_filter(mvm, vif, 0);
3427         }
3428
3429         return -EOPNOTSUPP;
3430 }
3431
3432 static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw *hw,
3433                                     struct ieee80211_vif *vif,
3434                                     void *data, int len)
3435 {
3436         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3437         int err;
3438
3439         mutex_lock(&mvm->mutex);
3440         err = __iwl_mvm_mac_testmode_cmd(mvm, vif, data, len);
3441         mutex_unlock(&mvm->mutex);
3442
3443         return err;
3444 }
3445 #endif
3446
3447 static void iwl_mvm_channel_switch(struct ieee80211_hw *hw,
3448                                    struct ieee80211_vif *vif,
3449                                    struct ieee80211_channel_switch *chsw)
3450 {
3451         /* By implementing this operation, we prevent mac80211 from
3452          * starting its own channel switch timer, so that we can call
3453          * ieee80211_chswitch_done() ourselves at the right time
3454          * (which is when the absence time event starts).
3455          */
3456
3457         IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw),
3458                            "dummy channel switch op\n");
3459 }
3460
3461 static int iwl_mvm_pre_channel_switch(struct ieee80211_hw *hw,
3462                                       struct ieee80211_vif *vif,
3463                                       struct ieee80211_channel_switch *chsw)
3464 {
3465         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3466         struct ieee80211_vif *csa_vif;
3467         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3468         u32 apply_time;
3469         int ret;
3470
3471         mutex_lock(&mvm->mutex);
3472
3473         mvmvif->csa_failed = false;
3474
3475         IWL_DEBUG_MAC80211(mvm, "pre CSA to freq %d\n",
3476                            chsw->chandef.center_freq1);
3477
3478         iwl_fw_dbg_trigger_simple_stop(mvm, vif, FW_DBG_TRIGGER_CHANNEL_SWITCH);
3479
3480         switch (vif->type) {
3481         case NL80211_IFTYPE_AP:
3482                 csa_vif =
3483                         rcu_dereference_protected(mvm->csa_vif,
3484                                                   lockdep_is_held(&mvm->mutex));
3485                 if (WARN_ONCE(csa_vif && csa_vif->csa_active,
3486                               "Another CSA is already in progress")) {
3487                         ret = -EBUSY;
3488                         goto out_unlock;
3489                 }
3490
3491                 rcu_assign_pointer(mvm->csa_vif, vif);
3492
3493                 if (WARN_ONCE(mvmvif->csa_countdown,
3494                               "Previous CSA countdown didn't complete")) {
3495                         ret = -EBUSY;
3496                         goto out_unlock;
3497                 }
3498
3499                 break;
3500         case NL80211_IFTYPE_STATION:
3501                 /* Schedule the time event to a bit before beacon 1,
3502                  * to make sure we're in the new channel when the
3503                  * GO/AP arrives.
3504                  */
3505                 apply_time = chsw->device_timestamp +
3506                         ((vif->bss_conf.beacon_int * (chsw->count - 1) -
3507                           IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT) * 1024);
3508
3509                 if (chsw->block_tx)
3510                         iwl_mvm_csa_client_absent(mvm, vif);
3511
3512                 iwl_mvm_schedule_csa_period(mvm, vif, vif->bss_conf.beacon_int,
3513                                             apply_time);
3514                 if (mvmvif->bf_data.bf_enabled) {
3515                         ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
3516                         if (ret)
3517                                 goto out_unlock;
3518                 }
3519
3520                 break;
3521         default:
3522                 break;
3523         }
3524
3525         mvmvif->ps_disabled = true;
3526
3527         ret = iwl_mvm_power_update_ps(mvm);
3528         if (ret)
3529                 goto out_unlock;
3530
3531         /* we won't be on this channel any longer */
3532         iwl_mvm_teardown_tdls_peers(mvm);
3533
3534 out_unlock:
3535         mutex_unlock(&mvm->mutex);
3536
3537         return ret;
3538 }
3539
3540 static int iwl_mvm_post_channel_switch(struct ieee80211_hw *hw,
3541                                        struct ieee80211_vif *vif)
3542 {
3543         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3544         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3545         int ret;
3546
3547         mutex_lock(&mvm->mutex);
3548
3549         if (mvmvif->csa_failed) {
3550                 mvmvif->csa_failed = false;
3551                 ret = -EIO;
3552                 goto out_unlock;
3553         }
3554
3555         if (vif->type == NL80211_IFTYPE_STATION) {
3556                 struct iwl_mvm_sta *mvmsta;
3557
3558                 mvmsta = iwl_mvm_sta_from_staid_protected(mvm,
3559                                                           mvmvif->ap_sta_id);
3560
3561                 if (WARN_ON(!mvmsta)) {
3562                         ret = -EIO;
3563                         goto out_unlock;
3564                 }
3565
3566                 iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);
3567
3568                 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
3569
3570                 ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
3571                 if (ret)
3572                         goto out_unlock;
3573
3574                 iwl_mvm_stop_session_protection(mvm, vif);
3575         }
3576
3577         mvmvif->ps_disabled = false;
3578
3579         ret = iwl_mvm_power_update_ps(mvm);
3580
3581 out_unlock:
3582         mutex_unlock(&mvm->mutex);
3583
3584         return ret;
3585 }
3586
3587 static void iwl_mvm_mac_flush(struct ieee80211_hw *hw,
3588                               struct ieee80211_vif *vif, u32 queues, bool drop)
3589 {
3590         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3591         struct iwl_mvm_vif *mvmvif;
3592         struct iwl_mvm_sta *mvmsta;
3593         struct ieee80211_sta *sta;
3594         int i;
3595         u32 msk = 0;
3596
3597         if (!vif || vif->type != NL80211_IFTYPE_STATION)
3598                 return;
3599
3600         mutex_lock(&mvm->mutex);
3601         mvmvif = iwl_mvm_vif_from_mac80211(vif);
3602
3603         /* flush the AP-station and all TDLS peers */
3604         for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
3605                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
3606                                                 lockdep_is_held(&mvm->mutex));
3607                 if (IS_ERR_OR_NULL(sta))
3608                         continue;
3609
3610                 mvmsta = iwl_mvm_sta_from_mac80211(sta);
3611                 if (mvmsta->vif != vif)
3612                         continue;
3613
3614                 /* make sure only TDLS peers or the AP are flushed */
3615                 WARN_ON(i != mvmvif->ap_sta_id && !sta->tdls);
3616
3617                 msk |= mvmsta->tfd_queue_msk;
3618         }
3619
3620         if (drop) {
3621                 if (iwl_mvm_flush_tx_path(mvm, msk, 0))
3622                         IWL_ERR(mvm, "flush request fail\n");
3623                 mutex_unlock(&mvm->mutex);
3624         } else {
3625                 mutex_unlock(&mvm->mutex);
3626
3627                 /* this can take a while, and we may need/want other operations
3628                  * to succeed while doing this, so do it without the mutex held
3629                  */
3630                 iwl_trans_wait_tx_queue_empty(mvm->trans, msk);
3631         }
3632 }
3633
3634 static int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx,
3635                                   struct survey_info *survey)
3636 {
3637         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3638         int ret;
3639
3640         memset(survey, 0, sizeof(*survey));
3641
3642         /* only support global statistics right now */
3643         if (idx != 0)
3644                 return -ENOENT;
3645
3646         if (fw_has_capa(&mvm->fw->ucode_capa,
3647                         IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
3648                 return -ENOENT;
3649
3650         mutex_lock(&mvm->mutex);
3651
3652         if (mvm->ucode_loaded) {
3653                 ret = iwl_mvm_request_statistics(mvm, false);
3654                 if (ret)
3655                         goto out;
3656         }
3657
3658         survey->filled = SURVEY_INFO_TIME |
3659                          SURVEY_INFO_TIME_RX |
3660                          SURVEY_INFO_TIME_TX |
3661                          SURVEY_INFO_TIME_SCAN;
3662         survey->time = mvm->accu_radio_stats.on_time_rf +
3663                        mvm->radio_stats.on_time_rf;
3664         do_div(survey->time, USEC_PER_MSEC);
3665
3666         survey->time_rx = mvm->accu_radio_stats.rx_time +
3667                           mvm->radio_stats.rx_time;
3668         do_div(survey->time_rx, USEC_PER_MSEC);
3669
3670         survey->time_tx = mvm->accu_radio_stats.tx_time +
3671                           mvm->radio_stats.tx_time;
3672         do_div(survey->time_tx, USEC_PER_MSEC);
3673
3674         survey->time_scan = mvm->accu_radio_stats.on_time_scan +
3675                             mvm->radio_stats.on_time_scan;
3676         do_div(survey->time_scan, USEC_PER_MSEC);
3677
3678         ret = 0;
3679  out:
3680         mutex_unlock(&mvm->mutex);
3681         return ret;
3682 }
3683
3684 static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw,
3685                                        struct ieee80211_vif *vif,
3686                                        struct ieee80211_sta *sta,
3687                                        struct station_info *sinfo)
3688 {
3689         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3690         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3691         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3692
3693         if (fw_has_capa(&mvm->fw->ucode_capa,
3694                         IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
3695                 return;
3696
3697         /* if beacon filtering isn't on mac80211 does it anyway */
3698         if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
3699                 return;
3700
3701         if (!vif->bss_conf.assoc)
3702                 return;
3703
3704         mutex_lock(&mvm->mutex);
3705
3706         if (mvmvif->ap_sta_id != mvmsta->sta_id)
3707                 goto unlock;
3708
3709         if (iwl_mvm_request_statistics(mvm, false))
3710                 goto unlock;
3711
3712         sinfo->rx_beacon = mvmvif->beacon_stats.num_beacons +
3713                            mvmvif->beacon_stats.accu_num_beacons;
3714         sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_RX);
3715         if (mvmvif->beacon_stats.avg_signal) {
3716                 /* firmware only reports a value after RXing a few beacons */
3717                 sinfo->rx_beacon_signal_avg = mvmvif->beacon_stats.avg_signal;
3718                 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
3719         }
3720  unlock:
3721         mutex_unlock(&mvm->mutex);
3722 }
3723
3724 static void iwl_mvm_event_mlme_callback(struct iwl_mvm *mvm,
3725                                         struct ieee80211_vif *vif,
3726                                         const struct ieee80211_event *event)
3727 {
3728 #define CHECK_MLME_TRIGGER(_mvm, _trig, _buf, _cnt, _fmt...)    \
3729         do {                                                    \
3730                 if ((_cnt) && --(_cnt))                         \
3731                         break;                                  \
3732                 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt);\
3733         } while (0)
3734
3735         struct iwl_fw_dbg_trigger_tlv *trig;
3736         struct iwl_fw_dbg_trigger_mlme *trig_mlme;
3737
3738         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_MLME))
3739                 return;
3740
3741         trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_MLME);
3742         trig_mlme = (void *)trig->data;
3743         if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3744                 return;
3745
3746         if (event->u.mlme.data == ASSOC_EVENT) {
3747                 if (event->u.mlme.status == MLME_DENIED)
3748                         CHECK_MLME_TRIGGER(mvm, trig, buf,
3749                                            trig_mlme->stop_assoc_denied,
3750                                            "DENIED ASSOC: reason %d",
3751                                             event->u.mlme.reason);
3752                 else if (event->u.mlme.status == MLME_TIMEOUT)
3753                         CHECK_MLME_TRIGGER(mvm, trig, buf,
3754                                            trig_mlme->stop_assoc_timeout,
3755                                            "ASSOC TIMEOUT");
3756         } else if (event->u.mlme.data == AUTH_EVENT) {
3757                 if (event->u.mlme.status == MLME_DENIED)
3758                         CHECK_MLME_TRIGGER(mvm, trig, buf,
3759                                            trig_mlme->stop_auth_denied,
3760                                            "DENIED AUTH: reason %d",
3761                                            event->u.mlme.reason);
3762                 else if (event->u.mlme.status == MLME_TIMEOUT)
3763                         CHECK_MLME_TRIGGER(mvm, trig, buf,
3764                                            trig_mlme->stop_auth_timeout,
3765                                            "AUTH TIMEOUT");
3766         } else if (event->u.mlme.data == DEAUTH_RX_EVENT) {
3767                 CHECK_MLME_TRIGGER(mvm, trig, buf,
3768                                    trig_mlme->stop_rx_deauth,
3769                                    "DEAUTH RX %d", event->u.mlme.reason);
3770         } else if (event->u.mlme.data == DEAUTH_TX_EVENT) {
3771                 CHECK_MLME_TRIGGER(mvm, trig, buf,
3772                                    trig_mlme->stop_tx_deauth,
3773                                    "DEAUTH TX %d", event->u.mlme.reason);
3774         }
3775 #undef CHECK_MLME_TRIGGER
3776 }
3777
3778 static void iwl_mvm_event_bar_rx_callback(struct iwl_mvm *mvm,
3779                                           struct ieee80211_vif *vif,
3780                                           const struct ieee80211_event *event)
3781 {
3782         struct iwl_fw_dbg_trigger_tlv *trig;
3783         struct iwl_fw_dbg_trigger_ba *ba_trig;
3784
3785         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
3786                 return;
3787
3788         trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
3789         ba_trig = (void *)trig->data;
3790         if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3791                 return;
3792
3793         if (!(le16_to_cpu(ba_trig->rx_bar) & BIT(event->u.ba.tid)))
3794                 return;
3795
3796         iwl_mvm_fw_dbg_collect_trig(mvm, trig,
3797                                     "BAR received from %pM, tid %d, ssn %d",
3798                                     event->u.ba.sta->addr, event->u.ba.tid,
3799                                     event->u.ba.ssn);
3800 }
3801
3802 static void
3803 iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm,
3804                                      struct ieee80211_vif *vif,
3805                                      const struct ieee80211_event *event)
3806 {
3807         struct iwl_fw_dbg_trigger_tlv *trig;
3808         struct iwl_fw_dbg_trigger_ba *ba_trig;
3809
3810         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
3811                 return;
3812
3813         trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
3814         ba_trig = (void *)trig->data;
3815         if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3816                 return;
3817
3818         if (!(le16_to_cpu(ba_trig->frame_timeout) & BIT(event->u.ba.tid)))
3819                 return;
3820
3821         iwl_mvm_fw_dbg_collect_trig(mvm, trig,
3822                                     "Frame from %pM timed out, tid %d",
3823                                     event->u.ba.sta->addr, event->u.ba.tid);
3824 }
3825
3826 static void iwl_mvm_mac_event_callback(struct ieee80211_hw *hw,
3827                                        struct ieee80211_vif *vif,
3828                                        const struct ieee80211_event *event)
3829 {
3830         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3831
3832         switch (event->type) {
3833         case MLME_EVENT:
3834                 iwl_mvm_event_mlme_callback(mvm, vif, event);
3835                 break;
3836         case BAR_RX_EVENT:
3837                 iwl_mvm_event_bar_rx_callback(mvm, vif, event);
3838                 break;
3839         case BA_FRAME_TIMEOUT:
3840                 iwl_mvm_event_frame_timeout_callback(mvm, vif, event);
3841                 break;
3842         default:
3843                 break;
3844         }
3845 }
3846
3847 const struct ieee80211_ops iwl_mvm_hw_ops = {
3848         .tx = iwl_mvm_mac_tx,
3849         .ampdu_action = iwl_mvm_mac_ampdu_action,
3850         .start = iwl_mvm_mac_start,
3851         .reconfig_complete = iwl_mvm_mac_reconfig_complete,
3852         .stop = iwl_mvm_mac_stop,
3853         .add_interface = iwl_mvm_mac_add_interface,
3854         .remove_interface = iwl_mvm_mac_remove_interface,
3855         .config = iwl_mvm_mac_config,
3856         .prepare_multicast = iwl_mvm_prepare_multicast,
3857         .configure_filter = iwl_mvm_configure_filter,
3858         .config_iface_filter = iwl_mvm_config_iface_filter,
3859         .bss_info_changed = iwl_mvm_bss_info_changed,
3860         .hw_scan = iwl_mvm_mac_hw_scan,
3861         .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan,
3862         .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove,
3863         .sta_state = iwl_mvm_mac_sta_state,
3864         .sta_notify = iwl_mvm_mac_sta_notify,
3865         .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames,
3866         .release_buffered_frames = iwl_mvm_mac_release_buffered_frames,
3867         .set_rts_threshold = iwl_mvm_mac_set_rts_threshold,
3868         .sta_rc_update = iwl_mvm_sta_rc_update,
3869         .conf_tx = iwl_mvm_mac_conf_tx,
3870         .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx,
3871         .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover,
3872         .flush = iwl_mvm_mac_flush,
3873         .sched_scan_start = iwl_mvm_mac_sched_scan_start,
3874         .sched_scan_stop = iwl_mvm_mac_sched_scan_stop,
3875         .set_key = iwl_mvm_mac_set_key,
3876         .update_tkip_key = iwl_mvm_mac_update_tkip_key,
3877         .remain_on_channel = iwl_mvm_roc,
3878         .cancel_remain_on_channel = iwl_mvm_cancel_roc,
3879         .add_chanctx = iwl_mvm_add_chanctx,
3880         .remove_chanctx = iwl_mvm_remove_chanctx,
3881         .change_chanctx = iwl_mvm_change_chanctx,
3882         .assign_vif_chanctx = iwl_mvm_assign_vif_chanctx,
3883         .unassign_vif_chanctx = iwl_mvm_unassign_vif_chanctx,
3884         .switch_vif_chanctx = iwl_mvm_switch_vif_chanctx,
3885
3886         .start_ap = iwl_mvm_start_ap_ibss,
3887         .stop_ap = iwl_mvm_stop_ap_ibss,
3888         .join_ibss = iwl_mvm_start_ap_ibss,
3889         .leave_ibss = iwl_mvm_stop_ap_ibss,
3890
3891         .set_tim = iwl_mvm_set_tim,
3892
3893         .channel_switch = iwl_mvm_channel_switch,
3894         .pre_channel_switch = iwl_mvm_pre_channel_switch,
3895         .post_channel_switch = iwl_mvm_post_channel_switch,
3896
3897         .tdls_channel_switch = iwl_mvm_tdls_channel_switch,
3898         .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch,
3899         .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch,
3900
3901         .event_callback = iwl_mvm_mac_event_callback,
3902
3903         CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd)
3904
3905 #ifdef CONFIG_PM_SLEEP
3906         /* look at d3.c */
3907         .suspend = iwl_mvm_suspend,
3908         .resume = iwl_mvm_resume,
3909         .set_wakeup = iwl_mvm_set_wakeup,
3910         .set_rekey_data = iwl_mvm_set_rekey_data,
3911 #if IS_ENABLED(CONFIG_IPV6)
3912         .ipv6_addr_change = iwl_mvm_ipv6_addr_change,
3913 #endif
3914         .set_default_unicast_key = iwl_mvm_set_default_unicast_key,
3915 #endif
3916         .get_survey = iwl_mvm_mac_get_survey,
3917         .sta_statistics = iwl_mvm_mac_sta_statistics,
3918 };