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

Kalle Valo says:

====================
wireless-drivers fixes for 4.15

First set of fixes for 4.15. Most important here is the iwlwifi fix
for scan command firmware interface change.

ath10k

* fix CCMP-256, GCMP and GCMP-256 in raw mode, it was never working

wcn36xx

* fix device tree node search

iwlwifi

* fix a regression with firmware API change of scan cmd (introduced in
  firmware version 34)

* add a bunch of PCI IDs and fix configuration structs for A000 devices

* fix the exported firmware name strings for 9000 and A000 devices
====================

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

10 files changed, 335 insertions, 90 deletions

diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index e31438541ee1..7d295ee71534 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
@@ -566,18 +566,16 @@ static int ath10k_htt_rx_crypto_param_len(struct ath10k *ar,
 
 #define MICHAEL_MIC_LEN 8
 
-static int ath10k_htt_rx_crypto_tail_len(struct ath10k *ar,
-                                         enum htt_rx_mpdu_encrypt_type type)
+static int ath10k_htt_rx_crypto_mic_len(struct ath10k *ar,
+                                        enum htt_rx_mpdu_encrypt_type type)
 {
         switch (type) {
         case HTT_RX_MPDU_ENCRYPT_NONE:
-                return 0;
         case HTT_RX_MPDU_ENCRYPT_WEP40:
         case HTT_RX_MPDU_ENCRYPT_WEP104:
-                return IEEE80211_WEP_ICV_LEN;
         case HTT_RX_MPDU_ENCRYPT_TKIP_WITHOUT_MIC:
         case HTT_RX_MPDU_ENCRYPT_TKIP_WPA:
-                return IEEE80211_TKIP_ICV_LEN;
+                return 0;
         case HTT_RX_MPDU_ENCRYPT_AES_CCM_WPA2:
                 return IEEE80211_CCMP_MIC_LEN;
         case HTT_RX_MPDU_ENCRYPT_AES_CCM256_WPA2:
@@ -594,6 +592,31 @@ static int ath10k_htt_rx_crypto_tail_len(struct ath10k *ar,
         return 0;
 }
 
+static int ath10k_htt_rx_crypto_icv_len(struct ath10k *ar,
+                                        enum htt_rx_mpdu_encrypt_type type)
+{
+        switch (type) {
+        case HTT_RX_MPDU_ENCRYPT_NONE:
+        case HTT_RX_MPDU_ENCRYPT_AES_CCM_WPA2:
+        case HTT_RX_MPDU_ENCRYPT_AES_CCM256_WPA2:
+        case HTT_RX_MPDU_ENCRYPT_AES_GCMP_WPA2:
+        case HTT_RX_MPDU_ENCRYPT_AES_GCMP256_WPA2:
+                return 0;
+        case HTT_RX_MPDU_ENCRYPT_WEP40:
+        case HTT_RX_MPDU_ENCRYPT_WEP104:
+                return IEEE80211_WEP_ICV_LEN;
+        case HTT_RX_MPDU_ENCRYPT_TKIP_WITHOUT_MIC:
+        case HTT_RX_MPDU_ENCRYPT_TKIP_WPA:
+                return IEEE80211_TKIP_ICV_LEN;
+        case HTT_RX_MPDU_ENCRYPT_WEP128:
+        case HTT_RX_MPDU_ENCRYPT_WAPI:
+                break;
+        }
+
+        ath10k_warn(ar, "unsupported encryption type %d\n", type);
+        return 0;
+}
+
 struct amsdu_subframe_hdr {
         u8 dst[ETH_ALEN];
         u8 src[ETH_ALEN];
@@ -1063,25 +1086,27 @@ static void ath10k_htt_rx_h_undecap_raw(struct ath10k *ar,
         /* Tail */
         if (status->flag & RX_FLAG_IV_STRIPPED) {
                 skb_trim(msdu, msdu->len -
-                         ath10k_htt_rx_crypto_tail_len(ar, enctype));
+                         ath10k_htt_rx_crypto_mic_len(ar, enctype));
+
+                skb_trim(msdu, msdu->len -
+                         ath10k_htt_rx_crypto_icv_len(ar, enctype));
         } else {
                 /* MIC */
-                if ((status->flag & RX_FLAG_MIC_STRIPPED) &&
-                    enctype == HTT_RX_MPDU_ENCRYPT_AES_CCM_WPA2)
-                        skb_trim(msdu, msdu->len - 8);
+                if (status->flag & RX_FLAG_MIC_STRIPPED)
+                        skb_trim(msdu, msdu->len -
+                                 ath10k_htt_rx_crypto_mic_len(ar, enctype));
 
                 /* ICV */
-                if (status->flag & RX_FLAG_ICV_STRIPPED &&
-                    enctype != HTT_RX_MPDU_ENCRYPT_AES_CCM_WPA2)
+                if (status->flag & RX_FLAG_ICV_STRIPPED)
                         skb_trim(msdu, msdu->len -
-                                 ath10k_htt_rx_crypto_tail_len(ar, enctype));
+                                 ath10k_htt_rx_crypto_icv_len(ar, enctype));
         }
 
         /* MMIC */
         if ((status->flag & RX_FLAG_MMIC_STRIPPED) &&
             !ieee80211_has_morefrags(hdr->frame_control) &&
             enctype == HTT_RX_MPDU_ENCRYPT_TKIP_WPA)
-                skb_trim(msdu, msdu->len - 8);
+                skb_trim(msdu, msdu->len - MICHAEL_MIC_LEN);
 
         /* Head */
         if (status->flag & RX_FLAG_IV_STRIPPED) {
diff --git a/drivers/net/wireless/ath/wcn36xx/main.c b/drivers/net/wireless/ath/wcn36xx/main.c
index 71812a2dd513..f7d228b5ba93 100644
--- a/drivers/net/wireless/ath/wcn36xx/main.c
+++ b/drivers/net/wireless/ath/wcn36xx/main.c
@@ -1233,7 +1233,7 @@ static int wcn36xx_platform_get_resources(struct wcn36xx *wcn,
         }
 
         /* External RF module */
-        iris_node = of_find_node_by_name(mmio_node, "iris");
+        iris_node = of_get_child_by_name(mmio_node, "iris");
         if (iris_node) {
                 if (of_device_is_compatible(iris_node, "qcom,wcn3620"))
                         wcn->rf_id = RF_IRIS_WCN3620;
diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/9000.c b/drivers/net/wireless/intel/iwlwifi/cfg/9000.c
index af7c4f36b66f..e7e75b458005 100644
--- a/drivers/net/wireless/intel/iwlwifi/cfg/9000.c
+++ b/drivers/net/wireless/intel/iwlwifi/cfg/9000.c
@@ -72,18 +72,21 @@
 #define IWL9000_SMEM_OFFSET             0x400000
 #define IWL9000_SMEM_LEN                0x68000
 
-#define  IWL9000_FW_PRE "iwlwifi-9000-pu-a0-jf-a0-"
+#define  IWL9000A_FW_PRE "iwlwifi-9000-pu-a0-jf-a0-"
+#define  IWL9000B_FW_PRE "iwlwifi-9000-pu-b0-jf-b0-"
 #define  IWL9000RFB_FW_PRE "iwlwifi-9000-pu-a0-jf-b0-"
 #define  IWL9260A_FW_PRE "iwlwifi-9260-th-a0-jf-a0-"
 #define  IWL9260B_FW_PRE "iwlwifi-9260-th-b0-jf-b0-"
-#define IWL9000_MODULE_FIRMWARE(api) \
-        IWL9000_FW_PRE "-" __stringify(api) ".ucode"
+#define IWL9000A_MODULE_FIRMWARE(api) \
+        IWL9000A_FW_PRE __stringify(api) ".ucode"
+#define IWL9000B_MODULE_FIRMWARE(api) \
+        IWL9000B_FW_PRE __stringify(api) ".ucode"
 #define IWL9000RFB_MODULE_FIRMWARE(api) \
-        IWL9000RFB_FW_PRE "-" __stringify(api) ".ucode"
+        IWL9000RFB_FW_PRE __stringify(api) ".ucode"
 #define IWL9260A_MODULE_FIRMWARE(api) \
-        IWL9260A_FW_PRE "-" __stringify(api) ".ucode"
+        IWL9260A_FW_PRE __stringify(api) ".ucode"
 #define IWL9260B_MODULE_FIRMWARE(api) \
-        IWL9260B_FW_PRE "-" __stringify(api) ".ucode"
+        IWL9260B_FW_PRE __stringify(api) ".ucode"
 
 #define NVM_HW_SECTION_NUM_FAMILY_9000          10
 
@@ -194,7 +197,48 @@ const struct iwl_cfg iwl9460_2ac_cfg = {
         .nvm_ver = IWL9000_NVM_VERSION,
         .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
         .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
+};
+
+const struct iwl_cfg iwl9460_2ac_cfg_soc = {
+        .name = "Intel(R) Dual Band Wireless AC 9460",
+        .fw_name_pre = IWL9000A_FW_PRE,
+        .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE,
+        .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE,
+        IWL_DEVICE_9000,
+        .ht_params = &iwl9000_ht_params,
+        .nvm_ver = IWL9000_NVM_VERSION,
+        .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
+        .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
         .integrated = true,
+        .soc_latency = 5000,
+};
+
+const struct iwl_cfg iwl9461_2ac_cfg_soc = {
+                .name = "Intel(R) Dual Band Wireless AC 9461",
+                .fw_name_pre = IWL9000A_FW_PRE,
+                .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE,
+                .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE,
+                IWL_DEVICE_9000,
+                .ht_params = &iwl9000_ht_params,
+                .nvm_ver = IWL9000_NVM_VERSION,
+                .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
+                .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
+                .integrated = true,
+                .soc_latency = 5000,
+};
+
+const struct iwl_cfg iwl9462_2ac_cfg_soc = {
+                .name = "Intel(R) Dual Band Wireless AC 9462",
+                .fw_name_pre = IWL9000A_FW_PRE,
+                .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE,
+                .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE,
+                IWL_DEVICE_9000,
+                .ht_params = &iwl9000_ht_params,
+                .nvm_ver = IWL9000_NVM_VERSION,
+                .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
+                .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
+                .integrated = true,
+                .soc_latency = 5000,
 };
 
 const struct iwl_cfg iwl9560_2ac_cfg = {
@@ -206,10 +250,23 @@ const struct iwl_cfg iwl9560_2ac_cfg = {
         .nvm_ver = IWL9000_NVM_VERSION,
         .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
         .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
-        .integrated = true,
 };
 
-MODULE_FIRMWARE(IWL9000_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
+const struct iwl_cfg iwl9560_2ac_cfg_soc = {
+        .name = "Intel(R) Dual Band Wireless AC 9560",
+        .fw_name_pre = IWL9000A_FW_PRE,
+        .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE,
+        .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE,
+        IWL_DEVICE_9000,
+        .ht_params = &iwl9000_ht_params,
+        .nvm_ver = IWL9000_NVM_VERSION,
+        .nvm_calib_ver = IWL9000_TX_POWER_VERSION,
+        .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,
+        .integrated = true,
+        .soc_latency = 5000,
+};
+MODULE_FIRMWARE(IWL9000A_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
+MODULE_FIRMWARE(IWL9000B_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL9000RFB_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL9260A_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL9260B_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX));
diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/a000.c b/drivers/net/wireless/intel/iwlwifi/cfg/a000.c
index ea8206515171..705f83b02e13 100644
--- a/drivers/net/wireless/intel/iwlwifi/cfg/a000.c
+++ b/drivers/net/wireless/intel/iwlwifi/cfg/a000.c
@@ -80,15 +80,15 @@
 #define IWL_A000_HR_A0_FW_PRE   "iwlwifi-QuQnj-a0-hr-a0-"
 
 #define IWL_A000_HR_MODULE_FIRMWARE(api) \
-        IWL_A000_HR_FW_PRE "-" __stringify(api) ".ucode"
+        IWL_A000_HR_FW_PRE __stringify(api) ".ucode"
 #define IWL_A000_JF_MODULE_FIRMWARE(api) \
-        IWL_A000_JF_FW_PRE "-" __stringify(api) ".ucode"
+        IWL_A000_JF_FW_PRE __stringify(api) ".ucode"
 #define IWL_A000_HR_F0_QNJ_MODULE_FIRMWARE(api) \
-        IWL_A000_HR_F0_FW_PRE "-" __stringify(api) ".ucode"
+        IWL_A000_HR_F0_FW_PRE __stringify(api) ".ucode"
 #define IWL_A000_JF_B0_QNJ_MODULE_FIRMWARE(api) \
-        IWL_A000_JF_B0_FW_PRE "-" __stringify(api) ".ucode"
+        IWL_A000_JF_B0_FW_PRE __stringify(api) ".ucode"
 #define IWL_A000_HR_A0_QNJ_MODULE_FIRMWARE(api) \
-        IWL_A000_HR_A0_FW_PRE "-" __stringify(api) ".ucode"
+        IWL_A000_HR_A0_FW_PRE __stringify(api) ".ucode"
 
 #define NVM_HW_SECTION_NUM_FAMILY_A000          10
 
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h b/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h
index 5a40092febfb..3bfc657f6b42 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h
@@ -531,6 +531,8 @@ struct iwl_scan_config_v1 {
 } __packed; /* SCAN_CONFIG_DB_CMD_API_S */
 
 #define SCAN_TWO_LMACS 2
+#define SCAN_LB_LMAC_IDX 0
+#define SCAN_HB_LMAC_IDX 1
 
 struct iwl_scan_config {
         __le32 flags;
@@ -578,6 +580,7 @@ enum iwl_umac_scan_general_flags {
         IWL_UMAC_SCAN_GEN_FLAGS_MATCH                   = BIT(9),
         IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL          = BIT(10),
         IWL_UMAC_SCAN_GEN_FLAGS_LMAC2_FRAGMENTED        = BIT(11),
+        IWL_UMAC_SCAN_GEN_FLAGS_ADAPTIVE_DWELL          = BIT(13),
 };
 
 /**
@@ -631,12 +634,17 @@ struct iwl_scan_req_umac_tail {
  * @uid: scan id, &enum iwl_umac_scan_uid_offsets
  * @ooc_priority: out of channel priority - &enum iwl_scan_priority
  * @general_flags: &enum iwl_umac_scan_general_flags
- * @reserved2: for future use and alignment
  * @scan_start_mac_id: report the scan start TSF time according to this mac TSF
  * @extended_dwell: dwell time for channels 1, 6 and 11
  * @active_dwell: dwell time for active scan
  * @passive_dwell: dwell time for passive scan
  * @fragmented_dwell: dwell time for fragmented passive scan
+ * @adwell_default_n_aps: for adaptive dwell the default number of APs
+ *      per channel
+ * @adwell_default_n_aps_social: for adaptive dwell the default
+ *      number of APs per social (1,6,11) channel
+ * @adwell_max_budget: for adaptive dwell the maximal budget of TU to be added
+ *      to total scan time
  * @max_out_time: max out of serving channel time, per LMAC - for CDB there
  *      are 2 LMACs
  * @suspend_time: max suspend time, per LMAC - for CDB there are 2 LMACs
@@ -644,6 +652,8 @@ struct iwl_scan_req_umac_tail {
  * @channel_flags: &enum iwl_scan_channel_flags
  * @n_channels: num of channels in scan request
  * @reserved: for future use and alignment
+ * @reserved2: for future use and alignment
+ * @reserved3: for future use and alignment
  * @data: &struct iwl_scan_channel_cfg_umac and
  *      &struct iwl_scan_req_umac_tail
  */
@@ -651,41 +661,64 @@ struct iwl_scan_req_umac {
         __le32 flags;
         __le32 uid;
         __le32 ooc_priority;
-        /* SCAN_GENERAL_PARAMS_API_S_VER_4 */
         __le16 general_flags;
-        u8 reserved2;
+        u8 reserved;
         u8 scan_start_mac_id;
-        u8 extended_dwell;
-        u8 active_dwell;
-        u8 passive_dwell;
-        u8 fragmented_dwell;
         union {
                 struct {
+                        u8 extended_dwell;
+                        u8 active_dwell;
+                        u8 passive_dwell;
+                        u8 fragmented_dwell;
                         __le32 max_out_time;
                         __le32 suspend_time;
                         __le32 scan_priority;
-                        /* SCAN_CHANNEL_PARAMS_API_S_VER_4 */
+                        /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */
                         u8 channel_flags;
                         u8 n_channels;
-                        __le16 reserved;
+                        __le16 reserved2;
                         u8 data[];
                 } v1; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_1 */
                 struct {
+                        u8 extended_dwell;
+                        u8 active_dwell;
+                        u8 passive_dwell;
+                        u8 fragmented_dwell;
                         __le32 max_out_time[SCAN_TWO_LMACS];
                         __le32 suspend_time[SCAN_TWO_LMACS];
                         __le32 scan_priority;
-                        /* SCAN_CHANNEL_PARAMS_API_S_VER_4 */
+                        /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */
                         u8 channel_flags;
                         u8 n_channels;
-                        __le16 reserved;
+                        __le16 reserved2;
                         u8 data[];
                 } v6; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_6 */
+                struct {
+                        u8 active_dwell;
+                        u8 passive_dwell;
+                        u8 fragmented_dwell;
+                        u8 adwell_default_n_aps;
+                        u8 adwell_default_n_aps_social;
+                        u8 reserved3;
+                        __le16 adwell_max_budget;
+                        __le32 max_out_time[SCAN_TWO_LMACS];
+                        __le32 suspend_time[SCAN_TWO_LMACS];
+                        __le32 scan_priority;
+                        /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */
+                        u8 channel_flags;
+                        u8 n_channels;
+                        __le16 reserved2;
+                        u8 data[];
+                } v7; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_7 */
         };
 } __packed;
 
-#define IWL_SCAN_REQ_UMAC_SIZE sizeof(struct iwl_scan_req_umac)
+#define IWL_SCAN_REQ_UMAC_SIZE_V7 sizeof(struct iwl_scan_req_umac)
+#define IWL_SCAN_REQ_UMAC_SIZE_V6 (sizeof(struct iwl_scan_req_umac) - \
+                                   2 * sizeof(u8) - sizeof(__le16))
 #define IWL_SCAN_REQ_UMAC_SIZE_V1 (sizeof(struct iwl_scan_req_umac) - \
-                                   2 * sizeof(__le32))
+                                   2 * sizeof(__le32) - 2 * sizeof(u8) - \
+                                   sizeof(__le16))
 
 /**
  * struct iwl_umac_scan_abort
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/file.h b/drivers/net/wireless/intel/iwlwifi/fw/file.h
index 740d97093d1c..37a5c5b4eda6 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/file.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/file.h
@@ -264,6 +264,7 @@ enum iwl_ucode_tlv_api {
         IWL_UCODE_TLV_API_STA_TYPE              = (__force iwl_ucode_tlv_api_t)30,
         IWL_UCODE_TLV_API_NAN2_VER2             = (__force iwl_ucode_tlv_api_t)31,
         /* API Set 1 */
+        IWL_UCODE_TLV_API_ADAPTIVE_DWELL        = (__force iwl_ucode_tlv_api_t)32,
         IWL_UCODE_TLV_API_NEW_BEACON_TEMPLATE   = (__force iwl_ucode_tlv_api_t)34,
         IWL_UCODE_TLV_API_NEW_RX_STATS          = (__force iwl_ucode_tlv_api_t)35,
         IWL_UCODE_TLV_API_COEX_ATS_EXTERNAL     = (__force iwl_ucode_tlv_api_t)37,
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
index d1263a554420..e21e46cf6f9a 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
@@ -366,6 +366,7 @@ struct iwl_cfg {
         u32 dccm2_len;
         u32 smem_offset;
         u32 smem_len;
+        u32 soc_latency;
         u16 nvm_ver;
         u16 nvm_calib_ver;
         u16 rx_with_siso_diversity:1,
@@ -472,6 +473,10 @@ extern const struct iwl_cfg iwl9260_2ac_cfg;
 extern const struct iwl_cfg iwl9270_2ac_cfg;
 extern const struct iwl_cfg iwl9460_2ac_cfg;
 extern const struct iwl_cfg iwl9560_2ac_cfg;
+extern const struct iwl_cfg iwl9460_2ac_cfg_soc;
+extern const struct iwl_cfg iwl9461_2ac_cfg_soc;
+extern const struct iwl_cfg iwl9462_2ac_cfg_soc;
+extern const struct iwl_cfg iwl9560_2ac_cfg_soc;
 extern const struct iwl_cfg iwla000_2ac_cfg_hr;
 extern const struct iwl_cfg iwla000_2ac_cfg_hr_cdb;
 extern const struct iwl_cfg iwla000_2ac_cfg_jf;
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
index 0e18c5066f04..4575595ab022 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
@@ -1142,6 +1142,12 @@ static inline bool iwl_mvm_is_d0i3_supported(struct iwl_mvm *mvm)
                             IWL_UCODE_TLV_CAPA_D0I3_SUPPORT);
 }
 
+static inline bool iwl_mvm_is_adaptive_dwell_supported(struct iwl_mvm *mvm)
+{
+        return fw_has_api(&mvm->fw->ucode_capa,
+                          IWL_UCODE_TLV_API_ADAPTIVE_DWELL);
+}
+
 static inline bool iwl_mvm_enter_d0i3_on_suspend(struct iwl_mvm *mvm)
 {
         /* For now we only use this mode to differentiate between
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
index 774122fed454..e4fd476e9ccb 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
@@ -130,6 +130,19 @@ struct iwl_mvm_scan_params {
         u32 measurement_dwell;
 };
 
+static inline void *iwl_mvm_get_scan_req_umac_data(struct iwl_mvm *mvm)
+{
+        struct iwl_scan_req_umac *cmd = mvm->scan_cmd;
+
+        if (iwl_mvm_is_adaptive_dwell_supported(mvm))
+                return (void *)&cmd->v7.data;
+
+        if (iwl_mvm_has_new_tx_api(mvm))
+                return (void *)&cmd->v6.data;
+
+        return (void *)&cmd->v1.data;
+}
+
 static u8 iwl_mvm_scan_rx_ant(struct iwl_mvm *mvm)
 {
         if (mvm->scan_rx_ant != ANT_NONE)
@@ -1075,25 +1088,57 @@ static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm,
 {
         struct iwl_mvm_scan_timing_params *timing = &scan_timing[params->type];
 
+        if (iwl_mvm_is_regular_scan(params))
+                cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6);
+        else
+                cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_2);
+
+        if (iwl_mvm_is_adaptive_dwell_supported(mvm)) {
+                if (params->measurement_dwell) {
+                        cmd->v7.active_dwell = params->measurement_dwell;
+                        cmd->v7.passive_dwell = params->measurement_dwell;
+                } else {
+                        cmd->v7.active_dwell = IWL_SCAN_DWELL_ACTIVE;
+                        cmd->v7.passive_dwell = IWL_SCAN_DWELL_PASSIVE;
+                }
+                cmd->v7.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED;
+
+                cmd->v7.scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6);
+                cmd->v7.max_out_time[SCAN_LB_LMAC_IDX] =
+                        cpu_to_le32(timing->max_out_time);
+                cmd->v7.suspend_time[SCAN_LB_LMAC_IDX] =
+                        cpu_to_le32(timing->suspend_time);
+                if (iwl_mvm_is_cdb_supported(mvm)) {
+                        cmd->v7.max_out_time[SCAN_HB_LMAC_IDX] =
+                                cpu_to_le32(timing->max_out_time);
+                        cmd->v7.suspend_time[SCAN_HB_LMAC_IDX] =
+                                cpu_to_le32(timing->suspend_time);
+                }
+
+                return;
+        }
+
         if (params->measurement_dwell) {
-                cmd->active_dwell = params->measurement_dwell;
-                cmd->passive_dwell = params->measurement_dwell;
-                cmd->extended_dwell = params->measurement_dwell;
+                cmd->v1.active_dwell = params->measurement_dwell;
+                cmd->v1.passive_dwell = params->measurement_dwell;
+                cmd->v1.extended_dwell = params->measurement_dwell;
         } else {
-                cmd->active_dwell = IWL_SCAN_DWELL_ACTIVE;
-                cmd->passive_dwell = IWL_SCAN_DWELL_PASSIVE;
-                cmd->extended_dwell = IWL_SCAN_DWELL_EXTENDED;
+                cmd->v1.active_dwell = IWL_SCAN_DWELL_ACTIVE;
+                cmd->v1.passive_dwell = IWL_SCAN_DWELL_PASSIVE;
+                cmd->v1.extended_dwell = IWL_SCAN_DWELL_EXTENDED;
         }
-        cmd->fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED;
+        cmd->v1.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED;
 
         if (iwl_mvm_has_new_tx_api(mvm)) {
                 cmd->v6.scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6);
-                cmd->v6.max_out_time[0] = cpu_to_le32(timing->max_out_time);
-                cmd->v6.suspend_time[0] = cpu_to_le32(timing->suspend_time);
+                cmd->v6.max_out_time[SCAN_LB_LMAC_IDX] =
+                        cpu_to_le32(timing->max_out_time);
+                cmd->v6.suspend_time[SCAN_LB_LMAC_IDX] =
+                        cpu_to_le32(timing->suspend_time);
                 if (iwl_mvm_is_cdb_supported(mvm)) {
-                        cmd->v6.max_out_time[1] =
+                        cmd->v6.max_out_time[SCAN_HB_LMAC_IDX] =
                                 cpu_to_le32(timing->max_out_time);
-                        cmd->v6.suspend_time[1] =
+                        cmd->v6.suspend_time[SCAN_HB_LMAC_IDX] =
                                 cpu_to_le32(timing->suspend_time);
                 }
         } else {
@@ -1102,11 +1147,6 @@ static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm,
                 cmd->v1.scan_priority =
                         cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6);
         }
-
-        if (iwl_mvm_is_regular_scan(params))
-                cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6);
-        else
-                cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_2);
 }
 
 static void
@@ -1178,8 +1218,7 @@ static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
                              int type)
 {
         struct iwl_scan_req_umac *cmd = mvm->scan_cmd;
-        void *cmd_data = iwl_mvm_has_new_tx_api(mvm) ?
-                         (void *)&cmd->v6.data : (void *)&cmd->v1.data;
+        void *cmd_data = iwl_mvm_get_scan_req_umac_data(mvm);
         struct iwl_scan_req_umac_tail *sec_part = cmd_data +
                 sizeof(struct iwl_scan_channel_cfg_umac) *
                         mvm->fw->ucode_capa.n_scan_channels;
@@ -1216,7 +1255,10 @@ static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
                                 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
                                 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD;
 
-        if (iwl_mvm_has_new_tx_api(mvm)) {
+        if (iwl_mvm_is_adaptive_dwell_supported(mvm)) {
+                cmd->v7.channel_flags = channel_flags;
+                cmd->v7.n_channels = params->n_channels;
+        } else if (iwl_mvm_has_new_tx_api(mvm)) {
                 cmd->v6.channel_flags = channel_flags;
                 cmd->v6.n_channels = params->n_channels;
         } else {
@@ -1661,8 +1703,10 @@ int iwl_mvm_scan_size(struct iwl_mvm *mvm)
 {
         int base_size = IWL_SCAN_REQ_UMAC_SIZE_V1;
 
-        if (iwl_mvm_has_new_tx_api(mvm))
-                base_size = IWL_SCAN_REQ_UMAC_SIZE;
+        if (iwl_mvm_is_adaptive_dwell_supported(mvm))
+                base_size = IWL_SCAN_REQ_UMAC_SIZE_V7;
+        else if (iwl_mvm_has_new_tx_api(mvm))
+                base_size = IWL_SCAN_REQ_UMAC_SIZE_V6;
 
         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
                 return base_size +
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
index 4a21c12276d7..f21fe59faccf 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
@@ -535,47 +535,121 @@ static const struct pci_device_id iwl_hw_card_ids[] = {
         {IWL_PCI_DEVICE(0x2526, 0x0238, iwl9560_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x023C, iwl9560_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x0260, iwl9460_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2526, 0x0264, iwl9461_2ac_cfg_soc)},
         {IWL_PCI_DEVICE(0x2526, 0x02A0, iwl9460_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x02A4, iwl9460_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2526, 0x1010, iwl9260_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x1030, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2526, 0x1210, iwl9260_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x1410, iwl9270_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x2526, 0x1420, iwl9460_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2526, 0x1420, iwl9460_2ac_cfg_soc)},
         {IWL_PCI_DEVICE(0x2526, 0x1610, iwl9270_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x4010, iwl9260_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x4030, iwl9560_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0x40A4, iwl9460_2ac_cfg)},
         {IWL_PCI_DEVICE(0x2526, 0xA014, iwl9260_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2526, 0x42A4, iwl9462_2ac_cfg_soc)},
         {IWL_PCI_DEVICE(0x271B, 0x0010, iwl9160_2ac_cfg)},
         {IWL_PCI_DEVICE(0x271B, 0x0014, iwl9160_2ac_cfg)},
         {IWL_PCI_DEVICE(0x271B, 0x0210, iwl9160_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x31DC, 0x003C, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x31DC, 0x0060, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0034, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0038, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x003C, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0060, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0210, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0310, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0410, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0510, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0610, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0710, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x0A10, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x2010, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0x9DF0, 0x2A10, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x003C, iwl9560_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x0060, iwl9460_2ac_cfg)},
-        {IWL_PCI_DEVICE(0xA370, 0x1030, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x271B, 0x0214, iwl9260_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0034, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0038, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x003C, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0060, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x0064, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x00A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x00A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x0230, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0234, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0238, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x023C, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x0260, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x0264, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x02A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x2720, 0x4030, iwl9560_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x2720, 0x40A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x0064, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x00A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x00A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x0260, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x0264, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x02A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x30DC, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x003C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0060, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0064, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x00A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x00A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0230, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0234, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0238, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x023C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0260, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x0264, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x02A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x4030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x4034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x31DC, 0x40A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x34F0, 0x0030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x34F0, 0x0034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x34F0, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0038, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x003C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0060, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0064, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x00A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x00A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0210, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0230, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0234, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0238, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x023C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0260, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0264, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x02A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0310, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0410, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0510, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0610, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0710, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x0A10, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x2010, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x2A10, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x4030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x4034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0x9DF0, 0x40A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x003C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0060, iwl9460_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0064, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x00A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x00A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0230, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0234, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0238, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x023C, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0260, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x0264, iwl9461_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x02A0, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x02A4, iwl9462_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x1030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x4030, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x4034, iwl9560_2ac_cfg_soc)},
+        {IWL_PCI_DEVICE(0xA370, 0x40A4, iwl9462_2ac_cfg_soc)},
 
 /* a000 Series */
         {IWL_PCI_DEVICE(0x2720, 0x0A10, iwla000_2ac_cfg_hr_cdb)},