drivers/net/wireless/intel/iwlwifi/cfg/22000.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) 2015-2017 Intel Deutschland GmbH
   9  * Copyright (C) 2018-2019 Intel Corporation
  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  * BSD LICENSE
  21  *
  22  * Copyright(c) 2015-2017 Intel Deutschland GmbH
  23  * Copyright (C) 2018-2019 Intel Corporation
  24  * All rights reserved.
  25  *
  26  * Redistribution and use in source and binary forms, with or without
  27  * modification, are permitted provided that the following conditions
  28  * are met:
  29  *
  30  *  * Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  *  * Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in
  34  *    the documentation and/or other materials provided with the
  35  *    distribution.
  36  *  * Neither the name Intel Corporation nor the names of its
  37  *    contributors may be used to endorse or promote products derived
  38  *    from this software without specific prior written permission.
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  41  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  42  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  43  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  44  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  46  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  47  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  48  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  49  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  50  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  51  *
  52  *****************************************************************************/
  53
  54 #include <linux/module.h>
  55 #include <linux/stringify.h>
  56 #include "iwl-config.h"
  57
  58 /* Highest firmware API version supported */
  59 #define IWL_22000_UCODE_API_MAX 48
  60
  61 /* Lowest firmware API version supported */
  62 #define IWL_22000_UCODE_API_MIN 39
  63
  64 /* NVM versions */
  65 #define IWL_22000_NVM_VERSION           0x0a1d
  66
  67 /* Memory offsets and lengths */
  68 #define IWL_22000_DCCM_OFFSET           0x800000 /* LMAC1 */
  69 #define IWL_22000_DCCM_LEN              0x10000 /* LMAC1 */
  70 #define IWL_22000_DCCM2_OFFSET          0x880000
  71 #define IWL_22000_DCCM2_LEN             0x8000
  72 #define IWL_22000_SMEM_OFFSET           0x400000
  73 #define IWL_22000_SMEM_LEN              0xD0000
  74
  75 #define IWL_22000_JF_FW_PRE             "iwlwifi-Qu-a0-jf-b0-"
  76 #define IWL_22000_HR_FW_PRE             "iwlwifi-Qu-a0-hr-a0-"
  77 #define IWL_22000_HR_CDB_FW_PRE         "iwlwifi-QuIcp-z0-hrcdb-a0-"
  78 #define IWL_22000_HR_A_F0_FW_PRE        "iwlwifi-QuQnj-f0-hr-a0-"
  79 #define IWL_22000_HR_B_F0_FW_PRE        "iwlwifi-Qu-b0-hr-b0-"
  80 #define IWL_22000_QU_B_HR_B_FW_PRE      "iwlwifi-Qu-b0-hr-b0-"
  81 #define IWL_22000_HR_B_FW_PRE           "iwlwifi-QuQnj-b0-hr-b0-"
  82 #define IWL_22000_HR_A0_FW_PRE          "iwlwifi-QuQnj-a0-hr-a0-"
  83 #define IWL_QU_C_HR_B_FW_PRE            "iwlwifi-Qu-c0-hr-b0-"
  84 #define IWL_QU_B_JF_B_FW_PRE            "iwlwifi-Qu-b0-jf-b0-"
  85 #define IWL_QU_C_JF_B_FW_PRE            "iwlwifi-Qu-c0-jf-b0-"
  86 #define IWL_QUZ_A_HR_B_FW_PRE           "iwlwifi-QuZ-a0-hr-b0-"
  87 #define IWL_QUZ_A_JF_B_FW_PRE           "iwlwifi-QuZ-a0-jf-b0-"
  88 #define IWL_QNJ_B_JF_B_FW_PRE           "iwlwifi-QuQnj-b0-jf-b0-"
  89 #define IWL_CC_A_FW_PRE                 "iwlwifi-cc-a0-"
  90 #define IWL_22000_SO_A_JF_B_FW_PRE      "iwlwifi-so-a0-jf-b0-"
  91 #define IWL_22000_SO_A_HR_B_FW_PRE      "iwlwifi-so-a0-hr-b0-"
  92 #define IWL_22000_SO_A_GF_A_FW_PRE      "iwlwifi-so-a0-gf-a0-"
  93 #define IWL_22000_TY_A_GF_A_FW_PRE      "iwlwifi-ty-a0-gf-a0-"
  94 #define IWL_22000_SO_A_GF4_A_FW_PRE     "iwlwifi-so-a0-gf4-a0-"
  95
  96 #define IWL_22000_HR_MODULE_FIRMWARE(api) \
  97         IWL_22000_HR_FW_PRE __stringify(api) ".ucode"
  98 #define IWL_22000_JF_MODULE_FIRMWARE(api) \
  99         IWL_22000_JF_FW_PRE __stringify(api) ".ucode"
 100 #define IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(api) \
 101         IWL_22000_HR_A_F0_FW_PRE __stringify(api) ".ucode"
 102 #define IWL_22000_HR_B_F0_QNJ_MODULE_FIRMWARE(api) \
 103         IWL_22000_HR_B_F0_FW_PRE __stringify(api) ".ucode"
 104 #define IWL_22000_QU_B_HR_B_MODULE_FIRMWARE(api) \
 105         IWL_22000_QU_B_HR_B_FW_PRE __stringify(api) ".ucode"
 106 #define IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(api) \
 107         IWL_22000_HR_B_FW_PRE __stringify(api) ".ucode"
 108 #define IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(api) \
 109         IWL_22000_HR_A0_FW_PRE __stringify(api) ".ucode"
 110 #define IWL_QUZ_A_HR_B_MODULE_FIRMWARE(api) \
 111         IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode"
 112 #define IWL_QUZ_A_JF_B_MODULE_FIRMWARE(api) \
 113         IWL_QUZ_A_JF_B_FW_PRE __stringify(api) ".ucode"
 114 #define IWL_QU_C_HR_B_MODULE_FIRMWARE(api) \
 115         IWL_QU_C_HR_B_FW_PRE __stringify(api) ".ucode"
 116 #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \
 117         IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode"
 118 #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api)             \
 119         IWL_QNJ_B_JF_B_FW_PRE __stringify(api) ".ucode"
 120 #define IWL_CC_A_MODULE_FIRMWARE(api)                   \
 121         IWL_CC_A_FW_PRE __stringify(api) ".ucode"
 122 #define IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(api) \
 123         IWL_22000_SO_A_JF_B_FW_PRE __stringify(api) ".ucode"
 124 #define IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(api) \
 125         IWL_22000_SO_A_HR_B_FW_PRE __stringify(api) ".ucode"
 126 #define IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(api) \
 127         IWL_22000_SO_A_GF_A_FW_PRE __stringify(api) ".ucode"
 128 #define IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(api) \
 129         IWL_22000_TY_A_GF_A_FW_PRE __stringify(api) ".ucode"
 130
 131 static const struct iwl_base_params iwl_22000_base_params = {
 132         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 133         .num_of_queues = 512,
 134         .max_tfd_queue_size = 256,
 135         .shadow_ram_support = true,
 136         .led_compensation = 57,
 137         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 138         .max_event_log_size = 512,
 139         .shadow_reg_enable = true,
 140         .pcie_l1_allowed = true,
 141 };
 142
 143 static const struct iwl_base_params iwl_22560_base_params = {
 144         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 145         .num_of_queues = 512,
 146         .max_tfd_queue_size = 65536,
 147         .shadow_ram_support = true,
 148         .led_compensation = 57,
 149         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 150         .max_event_log_size = 512,
 151         .shadow_reg_enable = true,
 152         .pcie_l1_allowed = true,
 153 };
 154
 155 static const struct iwl_ht_params iwl_22000_ht_params = {
 156         .stbc = true,
 157         .ldpc = true,
 158         .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 159 };
 160
 161 #define IWL_DEVICE_22000_COMMON                                         \
 162         .ucode_api_max = IWL_22000_UCODE_API_MAX,                       \
 163         .ucode_api_min = IWL_22000_UCODE_API_MIN,                       \
 164         .led_mode = IWL_LED_RF_STATE,                                   \
 165         .nvm_hw_section_num = 10,                                       \
 166         .non_shared_ant = ANT_B,                                        \
 167         .dccm_offset = IWL_22000_DCCM_OFFSET,                           \
 168         .dccm_len = IWL_22000_DCCM_LEN,                                 \
 169         .dccm2_offset = IWL_22000_DCCM2_OFFSET,                         \
 170         .dccm2_len = IWL_22000_DCCM2_LEN,                               \
 171         .smem_offset = IWL_22000_SMEM_OFFSET,                           \
 172         .smem_len = IWL_22000_SMEM_LEN,                                 \
 173         .features = IWL_TX_CSUM_NETIF_FLAGS | NETIF_F_RXCSUM,           \
 174         .apmg_not_supported = true,                                     \
 175         .mq_rx_supported = true,                                        \
 176         .vht_mu_mimo_supported = true,                                  \
 177         .mac_addr_from_csr = true,                                      \
 178         .ht_params = &iwl_22000_ht_params,                              \
 179         .nvm_ver = IWL_22000_NVM_VERSION,                               \
 180         .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,            \
 181         .use_tfh = true,                                                \
 182         .rf_id = true,                                                  \
 183         .gen2 = true,                                                   \
 184         .nvm_type = IWL_NVM_EXT,                                        \
 185         .dbgc_supported = true,                                         \
 186         .min_umac_error_event_table = 0x400000,                         \
 187         .d3_debug_data_base_addr = 0x401000,                            \
 188         .d3_debug_data_length = 60 * 1024,                              \
 189         .fw_mon_smem_write_ptr_addr = 0xa0c16c,                         \
 190         .fw_mon_smem_write_ptr_msk = 0xfffff,                           \
 191         .fw_mon_smem_cycle_cnt_ptr_addr = 0xa0c174,                     \
 192         .fw_mon_smem_cycle_cnt_ptr_msk = 0xfffff
 193
 194 #define IWL_DEVICE_AX200_COMMON                                         \
 195         IWL_DEVICE_22000_COMMON,                                        \
 196         .umac_prph_offset = 0x300000
 197
 198 #define IWL_DEVICE_22500                                                \
 199         IWL_DEVICE_22000_COMMON,                                        \
 200         .device_family = IWL_DEVICE_FAMILY_22000,                       \
 201         .base_params = &iwl_22000_base_params,                          \
 202         .csr = &iwl_csr_v1,                                             \
 203         .gp2_reg_addr = 0xa02c68
 204
 205 #define IWL_DEVICE_22560                                                \
 206         IWL_DEVICE_22000_COMMON,                                        \
 207         .device_family = IWL_DEVICE_FAMILY_22560,                       \
 208         .base_params = &iwl_22560_base_params,                          \
 209         .csr = &iwl_csr_v2
 210
 211 #define IWL_DEVICE_AX210                                                \
 212         IWL_DEVICE_AX200_COMMON,                                        \
 213         .device_family = IWL_DEVICE_FAMILY_AX210,                       \
 214         .base_params = &iwl_22560_base_params,                          \
 215         .csr = &iwl_csr_v1,                                             \
 216         .min_txq_size = 128,                                            \
 217         .gp2_reg_addr = 0xd02c68,                                       \
 218         .min_256_ba_txq_size = 512
 219
 220 const struct iwl_cfg iwl22000_2ac_cfg_hr = {
 221         .name = "Intel(R) Dual Band Wireless AC 22000",
 222         .fw_name_pre = IWL_22000_HR_FW_PRE,
 223         IWL_DEVICE_22500,
 224 };
 225
 226 const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb = {
 227         .name = "Intel(R) Dual Band Wireless AC 22000",
 228         .fw_name_pre = IWL_22000_HR_CDB_FW_PRE,
 229         IWL_DEVICE_22500,
 230         .cdb = true,
 231 };
 232
 233 const struct iwl_cfg iwl22000_2ac_cfg_jf = {
 234         .name = "Intel(R) Dual Band Wireless AC 22000",
 235         .fw_name_pre = IWL_22000_JF_FW_PRE,
 236         IWL_DEVICE_22500,
 237 };
 238
 239 const struct iwl_cfg iwl_ax101_cfg_qu_hr = {
 240         .name = "Intel(R) Wi-Fi 6 AX101",
 241         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 242         IWL_DEVICE_22500,
 243         /*
 244          * This device doesn't support receiving BlockAck with a large bitmap
 245          * so we need to restrict the size of transmitted aggregation to the
 246          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 247          */
 248         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 249 };
 250
 251 const struct iwl_cfg iwl_ax201_cfg_qu_hr = {
 252         .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 253         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 254         IWL_DEVICE_22500,
 255         /*
 256          * This device doesn't support receiving BlockAck with a large bitmap
 257          * so we need to restrict the size of transmitted aggregation to the
 258          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 259          */
 260         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 261 };
 262
 263 const struct iwl_cfg iwl_ax101_cfg_qu_c0_hr_b0 = {
 264         .name = "Intel(R) Wi-Fi 6 AX101",
 265         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 266         IWL_DEVICE_22500,
 267         /*
 268          * This device doesn't support receiving BlockAck with a large bitmap
 269          * so we need to restrict the size of transmitted aggregation to the
 270          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 271          */
 272         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 273 };
 274
 275 const struct iwl_cfg iwl_ax201_cfg_qu_c0_hr_b0 = {
 276         .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 277         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 278         IWL_DEVICE_22500,
 279         /*
 280          * This device doesn't support receiving BlockAck with a large bitmap
 281          * so we need to restrict the size of transmitted aggregation to the
 282          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 283          */
 284         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 285 };
 286
 287 const struct iwl_cfg iwl_ax101_cfg_quz_hr = {
 288         .name = "Intel(R) Wi-Fi 6 AX101",
 289         .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 290         IWL_DEVICE_22500,
 291         /*
 292          * This device doesn't support receiving BlockAck with a large bitmap
 293          * so we need to restrict the size of transmitted aggregation to the
 294          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 295          */
 296         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 297 };
 298
 299 const struct iwl_cfg iwl_ax201_cfg_quz_hr = {
 300                 .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 301                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 302                 IWL_DEVICE_22500,
 303                 /*
 304          * This device doesn't support receiving BlockAck with a large bitmap
 305          * so we need to restrict the size of transmitted aggregation to the
 306          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 307          */
 308                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 309 };
 310
 311 const struct iwl_cfg iwl_ax1650s_cfg_quz_hr = {
 312                 .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 313                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 314                 IWL_DEVICE_22500,
 315                 /*
 316          * This device doesn't support receiving BlockAck with a large bitmap
 317          * so we need to restrict the size of transmitted aggregation to the
 318          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 319          */
 320                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 321 };
 322
 323 const struct iwl_cfg iwl_ax1650i_cfg_quz_hr = {
 324                 .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 325                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 326                 IWL_DEVICE_22500,
 327                 /*
 328          * This device doesn't support receiving BlockAck with a large bitmap
 329          * so we need to restrict the size of transmitted aggregation to the
 330          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 331          */
 332                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 333 };
 334
 335 const struct iwl_cfg iwl_ax200_cfg_cc = {
 336         .name = "Intel(R) Wi-Fi 6 AX200 160MHz",
 337         .fw_name_pre = IWL_CC_A_FW_PRE,
 338         IWL_DEVICE_22500,
 339         /*
 340          * This device doesn't support receiving BlockAck with a large bitmap
 341          * so we need to restrict the size of transmitted aggregation to the
 342          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 343          */
 344         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 345         .bisr_workaround = 1,
 346 };
 347
 348 const struct iwl_cfg killer1650x_2ax_cfg = {
 349         .name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)",
 350         .fw_name_pre = IWL_CC_A_FW_PRE,
 351         IWL_DEVICE_22500,
 352         /*
 353          * This device doesn't support receiving BlockAck with a large bitmap
 354          * so we need to restrict the size of transmitted aggregation to the
 355          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 356          */
 357         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 358         .bisr_workaround = 1,
 359 };
 360
 361 const struct iwl_cfg killer1650w_2ax_cfg = {
 362         .name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)",
 363         .fw_name_pre = IWL_CC_A_FW_PRE,
 364         IWL_DEVICE_22500,
 365         /*
 366          * This device doesn't support receiving BlockAck with a large bitmap
 367          * so we need to restrict the size of transmitted aggregation to the
 368          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 369          */
 370         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 371         .bisr_workaround = 1,
 372 };
 373
 374 /*
 375  * All JF radio modules are part of the 9000 series, but the MAC part
 376  * looks more like 22000.  That's why this device is here, but called
 377  * 9560 nevertheless.
 378  */
 379 const struct iwl_cfg iwl9461_2ac_cfg_qu_b0_jf_b0 = {
 380         .name = "Intel(R) Wireless-AC 9461",
 381         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 382         IWL_DEVICE_22500,
 383 };
 384
 385 const struct iwl_cfg iwl9462_2ac_cfg_qu_b0_jf_b0 = {
 386         .name = "Intel(R) Wireless-AC 9462",
 387         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 388         IWL_DEVICE_22500,
 389 };
 390
 391 const struct iwl_cfg iwl9560_2ac_cfg_qu_b0_jf_b0 = {
 392         .name = "Intel(R) Wireless-AC 9560",
 393         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 394         IWL_DEVICE_22500,
 395 };
 396
 397 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_b0_jf_b0 = {
 398         .name = "Intel(R) Wireless-AC 9560 160MHz",
 399         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 400         IWL_DEVICE_22500,
 401 };
 402
 403 const struct iwl_cfg iwl9461_2ac_cfg_qu_c0_jf_b0 = {
 404         .name = "Intel(R) Wireless-AC 9461",
 405         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 406         IWL_DEVICE_22500,
 407 };
 408
 409 const struct iwl_cfg iwl9462_2ac_cfg_qu_c0_jf_b0 = {
 410         .name = "Intel(R) Wireless-AC 9462",
 411         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 412         IWL_DEVICE_22500,
 413 };
 414
 415 const struct iwl_cfg iwl9560_2ac_cfg_qu_c0_jf_b0 = {
 416         .name = "Intel(R) Wireless-AC 9560",
 417         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 418         IWL_DEVICE_22500,
 419 };
 420
 421 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_c0_jf_b0 = {
 422         .name = "Intel(R) Wireless-AC 9560 160MHz",
 423         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 424         IWL_DEVICE_22500,
 425 };
 426
 427 const struct iwl_cfg iwl9560_2ac_cfg_qnj_jf_b0 = {
 428         .name = "Intel(R) Wireless-AC 9560 160MHz",
 429         .fw_name_pre = IWL_QNJ_B_JF_B_FW_PRE,
 430         IWL_DEVICE_22500,
 431         /*
 432          * This device doesn't support receiving BlockAck with a large bitmap
 433          * so we need to restrict the size of transmitted aggregation to the
 434          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 435          */
 436         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 437 };
 438
 439 const struct iwl_cfg iwl9560_2ac_cfg_quz_a0_jf_b0_soc = {
 440         .name = "Intel(R) Wireless-AC 9560 160MHz",
 441         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 442         IWL_DEVICE_22500,
 443         /*
 444          * This device doesn't support receiving BlockAck with a large bitmap
 445          * so we need to restrict the size of transmitted aggregation to the
 446          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 447          */
 448         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 449         .integrated = true,
 450         .soc_latency = 5000,
 451 };
 452
 453 const struct iwl_cfg iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc = {
 454         .name = "Intel(R) Wireless-AC 9560 160MHz",
 455         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 456         IWL_DEVICE_22500,
 457         /*
 458          * This device doesn't support receiving BlockAck with a large bitmap
 459          * so we need to restrict the size of transmitted aggregation to the
 460          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 461          */
 462         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 463         .integrated = true,
 464         .soc_latency = 5000,
 465 };
 466
 467 const struct iwl_cfg iwl9461_2ac_cfg_quz_a0_jf_b0_soc = {
 468         .name = "Intel(R) Dual Band Wireless AC 9461",
 469         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 470         IWL_DEVICE_22500,
 471         /*
 472          * This device doesn't support receiving BlockAck with a large bitmap
 473          * so we need to restrict the size of transmitted aggregation to the
 474          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 475          */
 476         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 477         .integrated = true,
 478         .soc_latency = 5000,
 479 };
 480
 481 const struct iwl_cfg iwl9462_2ac_cfg_quz_a0_jf_b0_soc = {
 482         .name = "Intel(R) Dual Band Wireless AC 9462",
 483         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 484         IWL_DEVICE_22500,
 485         /*
 486          * This device doesn't support receiving BlockAck with a large bitmap
 487          * so we need to restrict the size of transmitted aggregation to the
 488          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 489          */
 490         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 491         .integrated = true,
 492         .soc_latency = 5000,
 493 };
 494
 495 const struct iwl_cfg iwl9560_killer_s_2ac_cfg_quz_a0_jf_b0_soc = {
 496         .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)",
 497         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 498         IWL_DEVICE_22500,
 499         /*
 500          * This device doesn't support receiving BlockAck with a large bitmap
 501          * so we need to restrict the size of transmitted aggregation to the
 502          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 503          */
 504         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 505         .integrated = true,
 506         .soc_latency = 5000,
 507 };
 508
 509 const struct iwl_cfg iwl9560_killer_i_2ac_cfg_quz_a0_jf_b0_soc = {
 510         .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)",
 511         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 512         IWL_DEVICE_22500,
 513         /*
 514          * This device doesn't support receiving BlockAck with a large bitmap
 515          * so we need to restrict the size of transmitted aggregation to the
 516          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 517          */
 518         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 519         .integrated = true,
 520         .soc_latency = 5000,
 521 };
 522
 523 const struct iwl_cfg killer1550i_2ac_cfg_qu_b0_jf_b0 = {
 524         .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)",
 525         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 526         IWL_DEVICE_22500,
 527 };
 528
 529 const struct iwl_cfg killer1550s_2ac_cfg_qu_b0_jf_b0 = {
 530         .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)",
 531         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 532         IWL_DEVICE_22500,
 533 };
 534
 535 const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = {
 536         .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 537         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 538         IWL_DEVICE_22500,
 539         /*
 540          * This device doesn't support receiving BlockAck with a large bitmap
 541          * so we need to restrict the size of transmitted aggregation to the
 542          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 543          */
 544         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 545 };
 546
 547 const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = {
 548         .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 549         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 550         IWL_DEVICE_22500,
 551         /*
 552          * This device doesn't support receiving BlockAck with a large bitmap
 553          * so we need to restrict the size of transmitted aggregation to the
 554          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 555          */
 556         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 557 };
 558
 559 const struct iwl_cfg killer1650s_2ax_cfg_qu_c0_hr_b0 = {
 560         .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 561         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 562         IWL_DEVICE_22500,
 563         /*
 564          * This device doesn't support receiving BlockAck with a large bitmap
 565          * so we need to restrict the size of transmitted aggregation to the
 566          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 567          */
 568         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 569 };
 570
 571 const struct iwl_cfg killer1650i_2ax_cfg_qu_c0_hr_b0 = {
 572         .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 573         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 574         IWL_DEVICE_22500,
 575         /*
 576          * This device doesn't support receiving BlockAck with a large bitmap
 577          * so we need to restrict the size of transmitted aggregation to the
 578          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 579          */
 580         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 581 };
 582
 583 const struct iwl_cfg iwl22000_2ax_cfg_jf = {
 584         .name = "Intel(R) Dual Band Wireless AX 22000",
 585         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 586         IWL_DEVICE_22500,
 587         /*
 588          * This device doesn't support receiving BlockAck with a large bitmap
 589          * so we need to restrict the size of transmitted aggregation to the
 590          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 591          */
 592         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 593 };
 594
 595 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0_f0 = {
 596         .name = "Intel(R) Dual Band Wireless AX 22000",
 597         .fw_name_pre = IWL_22000_HR_A_F0_FW_PRE,
 598         IWL_DEVICE_22500,
 599         /*
 600          * This device doesn't support receiving BlockAck with a large bitmap
 601          * so we need to restrict the size of transmitted aggregation to the
 602          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 603          */
 604         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 605 };
 606
 607 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_b0 = {
 608         .name = "Intel(R) Dual Band Wireless AX 22000",
 609         .fw_name_pre = IWL_22000_HR_B_FW_PRE,
 610         IWL_DEVICE_22500,
 611         /*
 612          * This device doesn't support receiving BlockAck with a large bitmap
 613          * so we need to restrict the size of transmitted aggregation to the
 614          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 615          */
 616         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 617 };
 618
 619 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0 = {
 620         .name = "Intel(R) Dual Band Wireless AX 22000",
 621         .fw_name_pre = IWL_22000_HR_A0_FW_PRE,
 622         IWL_DEVICE_22500,
 623         /*
 624          * This device doesn't support receiving BlockAck with a large bitmap
 625          * so we need to restrict the size of transmitted aggregation to the
 626          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 627          */
 628         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 629 };
 630
 631 const struct iwl_cfg iwlax210_2ax_cfg_so_jf_a0 = {
 632         .name = "Intel(R) Wireless-AC 9560 160MHz",
 633         .fw_name_pre = IWL_22000_SO_A_JF_B_FW_PRE,
 634         IWL_DEVICE_AX210,
 635 };
 636
 637 const struct iwl_cfg iwlax210_2ax_cfg_so_hr_a0 = {
 638         .name = "Intel(R) Wi-Fi 7 AX210 160MHz",
 639         .fw_name_pre = IWL_22000_SO_A_HR_B_FW_PRE,
 640         IWL_DEVICE_AX210,
 641 };
 642
 643 const struct iwl_cfg iwlax211_2ax_cfg_so_gf_a0 = {
 644         .name = "Intel(R) Wi-Fi 7 AX211 160MHz",
 645         .fw_name_pre = IWL_22000_SO_A_GF_A_FW_PRE,
 646         .uhb_supported = true,
 647         IWL_DEVICE_AX210,
 648 };
 649
 650 const struct iwl_cfg iwlax210_2ax_cfg_ty_gf_a0 = {
 651         .name = "Intel(R) Wi-Fi 7 AX210 160MHz",
 652         .fw_name_pre = IWL_22000_TY_A_GF_A_FW_PRE,
 653         .uhb_supported = true,
 654         IWL_DEVICE_AX210,
 655 };
 656
 657 const struct iwl_cfg iwlax411_2ax_cfg_so_gf4_a0 = {
 658         .name = "Intel(R) Wi-Fi 7 AX411 160MHz",
 659         .fw_name_pre = IWL_22000_SO_A_GF4_A_FW_PRE,
 660         IWL_DEVICE_AX210,
 661 };
 662
 663 MODULE_FIRMWARE(IWL_22000_HR_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 664 MODULE_FIRMWARE(IWL_22000_JF_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 665 MODULE_FIRMWARE(IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 666 MODULE_FIRMWARE(IWL_22000_HR_B_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 667 MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 668 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 669 MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 670 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 671 MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 672 MODULE_FIRMWARE(IWL_QUZ_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 673 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 674 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 675 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 676 MODULE_FIRMWARE(IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 677 MODULE_FIRMWARE(IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 678 MODULE_FIRMWARE(IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));