Merge tag 'wireless-drivers-next-for-davem-2019-02-22' of git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers-next

Kalle Valo says:

====================
wireless-drivers-next patches for 5.1

Most likely the last set of patches for 5.1. WPA3 support to ath10k
and qtnfmac. FTM support to iwlwifi and ath10k. And of course other
new features and bugfixes.

wireless-drivers was merged due to dependency in mt76.

Major changes:

iwlwifi

* HE radiotap

* FTM (Fine Timing Measurement) initiator and responder implementation

* bump supported firmware API to 46

* VHT extended NSS support

* new PCI IDs for 9260 and 22000 series

ath10k

* change QMI interface to support the new (and backwards incompatible)
  interface from HL3.1 and used in recent HL2.0 branch firmware
  releases

* support WPA3 with WCN3990

* support for mac80211 airtime fairness based on transmit rate
  estimation, the firmware needs to support WMI_SERVICE_PEER_STATS to
  enable this

* report transmit airtime to mac80211 with firmwares having
  WMI_SERVICE_REPORT_AIRTIME feature, this to have more accurate
  airtime fairness based on real transmit time (instead of just
  estimated from transmit rate)

* support Fine Timing Measurement (FTM) responder role

* add dynamic VLAN support with firmware having WMI_SERVICE_PER_PACKET_SW_ENCRYPT

* switch to use SPDX license identifiers

ath

* add new country codes for US

brcmfmac

* support monitor frames with the hardware/ucode header

qtnfmac

* enable WPA3 SAE and OWE support

mt76

* beacon support for USB devices (mesh+ad-hoc only)

rtlwifi

* convert to use SPDX license identifiers

libertas_tf

* get the MAC address before registering the device
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 56 insertions, 7 deletions

diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
index 5e4f8b767d10..ba27dce4c2bb 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
@@ -82,7 +82,6 @@
 #include "fw/api/scan.h"
 #include "time-event.h"
 #include "fw-api.h"
-#include "fw/api/scan.h"
 #include "fw/acpi.h"
 
 #define DRV_DESCRIPTION "The new Intel(R) wireless AGN driver for Linux"
@@ -301,6 +300,14 @@ static const struct iwl_rx_handlers iwl_mvm_rx_handlers[] = {
                    RX_HANDLER_ASYNC_LOCKED),
         RX_HANDLER(MFUART_LOAD_NOTIFICATION, iwl_mvm_rx_mfuart_notif,
                    RX_HANDLER_SYNC),
+        RX_HANDLER_GRP(LOCATION_GROUP, TOF_RESPONDER_STATS,
+                       iwl_mvm_ftm_responder_stats, RX_HANDLER_ASYNC_LOCKED),
+
+        RX_HANDLER_GRP(LOCATION_GROUP, TOF_RANGE_RESPONSE_NOTIF,
+                       iwl_mvm_ftm_range_resp, RX_HANDLER_ASYNC_LOCKED),
+        RX_HANDLER_GRP(LOCATION_GROUP, TOF_LC_NOTIF,
+                       iwl_mvm_ftm_lc_notif, RX_HANDLER_ASYNC_LOCKED),
+
         RX_HANDLER_GRP(DEBUG_GROUP, MFU_ASSERT_DUMP_NTF,
                        iwl_mvm_mfu_assert_dump_notif, RX_HANDLER_SYNC),
         RX_HANDLER_GRP(PROT_OFFLOAD_GROUP, STORED_BEACON_NTF,
@@ -415,12 +422,14 @@ static const struct iwl_hcmd_names iwl_mvm_legacy_names[] = {
 static const struct iwl_hcmd_names iwl_mvm_system_names[] = {
         HCMD_NAME(SHARED_MEM_CFG_CMD),
         HCMD_NAME(INIT_EXTENDED_CFG_CMD),
+        HCMD_NAME(FW_ERROR_RECOVERY_CMD),
 };
 
 /* Please keep this array *SORTED* by hex value.
  * Access is done through binary search
  */
 static const struct iwl_hcmd_names iwl_mvm_mac_conf_names[] = {
+        HCMD_NAME(CHANNEL_SWITCH_TIME_EVENT_CMD),
         HCMD_NAME(CHANNEL_SWITCH_NOA_NOTIF),
 };
 
@@ -445,6 +454,7 @@ static const struct iwl_hcmd_names iwl_mvm_data_path_names[] = {
         HCMD_NAME(TRIGGER_RX_QUEUES_NOTIF_CMD),
         HCMD_NAME(STA_HE_CTXT_CMD),
         HCMD_NAME(RFH_QUEUE_CONFIG_CMD),
+        HCMD_NAME(TLC_MNG_CONFIG_CMD),
         HCMD_NAME(CHEST_COLLECTOR_FILTER_CONFIG_CMD),
         HCMD_NAME(STA_PM_NOTIF),
         HCMD_NAME(MU_GROUP_MGMT_NOTIF),
@@ -591,11 +601,17 @@ static int iwl_mvm_fwrt_send_hcmd(void *ctx, struct iwl_host_cmd *host_cmd)
         return ret;
 }
 
+static bool iwl_mvm_d3_debug_enable(void *ctx)
+{
+        return IWL_MVM_D3_DEBUG;
+}
+
 static const struct iwl_fw_runtime_ops iwl_mvm_fwrt_ops = {
         .dump_start = iwl_mvm_fwrt_dump_start,
         .dump_end = iwl_mvm_fwrt_dump_end,
         .fw_running = iwl_mvm_fwrt_fw_running,
         .send_hcmd = iwl_mvm_fwrt_send_hcmd,
+        .d3_debug_enable = iwl_mvm_d3_debug_enable,
 };
 
 static struct iwl_op_mode *
@@ -690,6 +706,7 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
         INIT_LIST_HEAD(&mvm->aux_roc_te_list);
         INIT_LIST_HEAD(&mvm->async_handlers_list);
         spin_lock_init(&mvm->time_event_lock);
+        INIT_LIST_HEAD(&mvm->ftm_initiator.loc_list);
 
         INIT_WORK(&mvm->async_handlers_wk, iwl_mvm_async_handlers_wk);
         INIT_WORK(&mvm->roc_done_wk, iwl_mvm_roc_done_wk);
@@ -817,8 +834,8 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
         mutex_lock(&mvm->mutex);
         iwl_mvm_ref(mvm, IWL_MVM_REF_INIT_UCODE);
         err = iwl_run_init_mvm_ucode(mvm, true);
-        if (test_bit(IWL_FWRT_STATUS_WAIT_ALIVE, &mvm->fwrt.status))
-                iwl_fw_alive_error_dump(&mvm->fwrt);
+        if (err)
+                iwl_fw_dbg_error_collect(&mvm->fwrt, FW_DBG_TRIGGER_DRIVER);
         if (!iwlmvm_mod_params.init_dbg || !err)
                 iwl_mvm_stop_device(mvm);
         iwl_mvm_unref(mvm, IWL_MVM_REF_INIT_UCODE);
@@ -902,15 +919,15 @@ static void iwl_op_mode_mvm_stop(struct iwl_op_mode *op_mode)
 
         iwl_mvm_thermal_exit(mvm);
 
-        if (mvm->init_status & IWL_MVM_INIT_STATUS_REG_HW_INIT_COMPLETE) {
-                ieee80211_unregister_hw(mvm->hw);
-                mvm->init_status &= ~IWL_MVM_INIT_STATUS_REG_HW_INIT_COMPLETE;
-        }
+        ieee80211_unregister_hw(mvm->hw);
 
         kfree(mvm->scan_cmd);
         kfree(mvm->mcast_filter_cmd);
         mvm->mcast_filter_cmd = NULL;
 
+        kfree(mvm->error_recovery_buf);
+        mvm->error_recovery_buf = NULL;
+
 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_IWLWIFI_DEBUGFS)
         kfree(mvm->d3_resume_sram);
 #endif
@@ -1105,6 +1122,12 @@ static void iwl_mvm_async_cb(struct iwl_op_mode *op_mode,
         iwl_trans_block_txq_ptrs(mvm->trans, false);
 }
 
+static int iwl_mvm_is_static_queue(struct iwl_mvm *mvm, int queue)
+{
+        return queue == mvm->aux_queue || queue == mvm->probe_queue ||
+                queue == mvm->p2p_dev_queue || queue == mvm->snif_queue;
+}
+
 static void iwl_mvm_queue_state_change(struct iwl_op_mode *op_mode,
                                        int hw_queue, bool start)
 {
@@ -1131,6 +1154,15 @@ static void iwl_mvm_queue_state_change(struct iwl_op_mode *op_mode,
                 goto out;
         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 
+        if (iwl_mvm_is_static_queue(mvm, hw_queue)) {
+                if (!start)
+                        ieee80211_stop_queues(mvm->hw);
+                else if (mvmsta->sta_state != IEEE80211_STA_NOTEXIST)
+                        ieee80211_wake_queues(mvm->hw);
+
+                goto out;
+        }
+
         if (iwl_mvm_has_new_tx_api(mvm)) {
                 int tid = mvm->tvqm_info[hw_queue].txq_tid;
 
@@ -1285,12 +1317,29 @@ void iwl_mvm_nic_restart(struct iwl_mvm *mvm, bool fw_error)
                 reprobe->dev = mvm->trans->dev;
                 INIT_WORK(&reprobe->work, iwl_mvm_reprobe_wk);
                 schedule_work(&reprobe->work);
+        } else if (test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
+                            &mvm->status)) {
+                IWL_ERR(mvm, "HW restart already requested, but not started\n");
         } else if (mvm->fwrt.cur_fw_img == IWL_UCODE_REGULAR &&
                    mvm->hw_registered &&
                    !test_bit(STATUS_TRANS_DEAD, &mvm->trans->status)) {
                 /* don't let the transport/FW power down */
                 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
 
+                if (mvm->fw->ucode_capa.error_log_size) {
+                        u32 src_size = mvm->fw->ucode_capa.error_log_size;
+                        u32 src_addr = mvm->fw->ucode_capa.error_log_addr;
+                        u8 *recover_buf = kzalloc(src_size, GFP_ATOMIC);
+
+                        if (recover_buf) {
+                                mvm->error_recovery_buf = recover_buf;
+                                iwl_trans_read_mem_bytes(mvm->trans,
+                                                         src_addr,
+                                                         recover_buf,
+                                                         src_size);
+                        }
+                }
+
                 if (fw_error && mvm->fw_restart > 0)
                         mvm->fw_restart--;
                 set_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status);