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 46
  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_22000_SU_Z0_FW_PRE          "iwlwifi-su-z0-"
  84 #define IWL_QU_B_JF_B_FW_PRE            "iwlwifi-Qu-b0-jf-b0-"
  85 #define IWL_QUZ_A_HR_B_FW_PRE           "iwlwifi-QuZ-a0-hr-b0-"
  86 #define IWL_QNJ_B_JF_B_FW_PRE           "iwlwifi-QuQnj-b0-jf-b0-"
  87 #define IWL_CC_A_FW_PRE                 "iwlwifi-cc-a0-"
  88 #define IWL_22000_SO_A_JF_B_FW_PRE      "iwlwifi-so-a0-jf-b0-"
  89 #define IWL_22000_SO_A_HR_B_FW_PRE      "iwlwifi-so-a0-hr-b0-"
  90 #define IWL_22000_SO_A_GF_A_FW_PRE      "iwlwifi-so-a0-gf-a0-"
  91 #define IWL_22000_TY_A_GF_A_FW_PRE      "iwlwifi-ty-a0-gf-a0-"
  92
  93 #define IWL_22000_HR_MODULE_FIRMWARE(api) \
  94         IWL_22000_HR_FW_PRE __stringify(api) ".ucode"
  95 #define IWL_22000_JF_MODULE_FIRMWARE(api) \
  96         IWL_22000_JF_FW_PRE __stringify(api) ".ucode"
  97 #define IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(api) \
  98         IWL_22000_HR_A_F0_FW_PRE __stringify(api) ".ucode"
  99 #define IWL_22000_HR_B_F0_QNJ_MODULE_FIRMWARE(api) \
 100         IWL_22000_HR_B_F0_FW_PRE __stringify(api) ".ucode"
 101 #define IWL_22000_QU_B_HR_B_MODULE_FIRMWARE(api) \
 102         IWL_22000_QU_B_HR_B_FW_PRE __stringify(api) ".ucode"
 103 #define IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(api) \
 104         IWL_22000_HR_B_FW_PRE __stringify(api) ".ucode"
 105 #define IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(api) \
 106         IWL_22000_HR_A0_FW_PRE __stringify(api) ".ucode"
 107 #define IWL_22000_SU_Z0_MODULE_FIRMWARE(api) \
 108         IWL_22000_SU_Z0_FW_PRE __stringify(api) ".ucode"
 109 #define IWL_QUZ_A_HR_B_MODULE_FIRMWARE(api) \
 110         IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode"
 111 #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \
 112         IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode"
 113 #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api)             \
 114         IWL_QNJ_B_JF_B_FW_PRE __stringify(api) ".ucode"
 115 #define IWL_CC_A_MODULE_FIRMWARE(api)                   \
 116         IWL_CC_A_FW_PRE __stringify(api) ".ucode"
 117 #define IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(api) \
 118         IWL_22000_SO_A_JF_B_FW_PRE __stringify(api) ".ucode"
 119 #define IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(api) \
 120         IWL_22000_SO_A_HR_B_FW_PRE __stringify(api) ".ucode"
 121 #define IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(api) \
 122         IWL_22000_SO_A_GF_A_FW_PRE __stringify(api) ".ucode"
 123 #define IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(api) \
 124         IWL_22000_TY_A_GF_A_FW_PRE __stringify(api) ".ucode"
 125
 126 static const struct iwl_base_params iwl_22000_base_params = {
 127         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 128         .num_of_queues = 512,
 129         .max_tfd_queue_size = 256,
 130         .shadow_ram_support = true,
 131         .led_compensation = 57,
 132         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 133         .max_event_log_size = 512,
 134         .shadow_reg_enable = true,
 135         .pcie_l1_allowed = true,
 136 };
 137
 138 static const struct iwl_base_params iwl_22560_base_params = {
 139         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 140         .num_of_queues = 512,
 141         .max_tfd_queue_size = 65536,
 142         .shadow_ram_support = true,
 143         .led_compensation = 57,
 144         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 145         .max_event_log_size = 512,
 146         .shadow_reg_enable = true,
 147         .pcie_l1_allowed = true,
 148 };
 149
 150 static const struct iwl_ht_params iwl_22000_ht_params = {
 151         .stbc = true,
 152         .ldpc = true,
 153         .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 154 };
 155
 156 #define IWL_DEVICE_22000_COMMON                                         \
 157         .ucode_api_max = IWL_22000_UCODE_API_MAX,                       \
 158         .ucode_api_min = IWL_22000_UCODE_API_MIN,                       \
 159         .led_mode = IWL_LED_RF_STATE,                                   \
 160         .nvm_hw_section_num = 10,                                       \
 161         .non_shared_ant = ANT_B,                                        \
 162         .dccm_offset = IWL_22000_DCCM_OFFSET,                           \
 163         .dccm_len = IWL_22000_DCCM_LEN,                                 \
 164         .dccm2_offset = IWL_22000_DCCM2_OFFSET,                         \
 165         .dccm2_len = IWL_22000_DCCM2_LEN,                               \
 166         .smem_offset = IWL_22000_SMEM_OFFSET,                           \
 167         .smem_len = IWL_22000_SMEM_LEN,                                 \
 168         .features = IWL_TX_CSUM_NETIF_FLAGS | NETIF_F_RXCSUM,           \
 169         .apmg_not_supported = true,                                     \
 170         .mq_rx_supported = true,                                        \
 171         .vht_mu_mimo_supported = true,                                  \
 172         .mac_addr_from_csr = true,                                      \
 173         .ht_params = &iwl_22000_ht_params,                              \
 174         .nvm_ver = IWL_22000_NVM_VERSION,                               \
 175         .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,            \
 176         .use_tfh = true,                                                \
 177         .rf_id = true,                                                  \
 178         .gen2 = true,                                                   \
 179         .nvm_type = IWL_NVM_EXT,                                        \
 180         .dbgc_supported = true,                                         \
 181         .min_umac_error_event_table = 0x400000,                         \
 182         .d3_debug_data_base_addr = 0x401000,                            \
 183         .d3_debug_data_length = 60 * 1024
 184
 185 #define IWL_DEVICE_AX200_COMMON                                         \
 186         IWL_DEVICE_22000_COMMON,                                        \
 187         .umac_prph_offset = 0x300000
 188
 189 #define IWL_DEVICE_22500                                                \
 190         IWL_DEVICE_22000_COMMON,                                        \
 191         .device_family = IWL_DEVICE_FAMILY_22000,                       \
 192         .base_params = &iwl_22000_base_params,                          \
 193         .csr = &iwl_csr_v1
 194
 195 #define IWL_DEVICE_22560                                                \
 196         IWL_DEVICE_22000_COMMON,                                        \
 197         .device_family = IWL_DEVICE_FAMILY_22560,                       \
 198         .base_params = &iwl_22560_base_params,                          \
 199         .csr = &iwl_csr_v2
 200
 201 #define IWL_DEVICE_AX210                                                \
 202         IWL_DEVICE_AX200_COMMON,                                        \
 203         .device_family = IWL_DEVICE_FAMILY_AX210,                       \
 204         .base_params = &iwl_22560_base_params,                          \
 205         .csr = &iwl_csr_v1,                                             \
 206         .min_txq_size = 128
 207
 208 const struct iwl_cfg iwl22000_2ac_cfg_hr = {
 209         .name = "Intel(R) Dual Band Wireless AC 22000",
 210         .fw_name_pre = IWL_22000_HR_FW_PRE,
 211         IWL_DEVICE_22500,
 212 };
 213
 214 const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb = {
 215         .name = "Intel(R) Dual Band Wireless AC 22000",
 216         .fw_name_pre = IWL_22000_HR_CDB_FW_PRE,
 217         IWL_DEVICE_22500,
 218         .cdb = true,
 219 };
 220
 221 const struct iwl_cfg iwl22000_2ac_cfg_jf = {
 222         .name = "Intel(R) Dual Band Wireless AC 22000",
 223         .fw_name_pre = IWL_22000_JF_FW_PRE,
 224         IWL_DEVICE_22500,
 225 };
 226
 227 const struct iwl_cfg iwl_ax101_cfg_qu_hr = {
 228         .name = "Intel(R) Wi-Fi 6 AX101",
 229         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 230         IWL_DEVICE_22500,
 231         /*
 232          * This device doesn't support receiving BlockAck with a large bitmap
 233          * so we need to restrict the size of transmitted aggregation to the
 234          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 235          */
 236         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 237 };
 238
 239 const struct iwl_cfg iwl_ax101_cfg_quz_hr = {
 240         .name = "Intel(R) Wi-Fi 6 AX101",
 241         .fw_name_pre = IWL_QUZ_A_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_ax200_cfg_cc = {
 252         .name = "Intel(R) Wi-Fi 6 AX200 160MHz",
 253         .fw_name_pre = IWL_CC_A_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         .bisr_workaround = 1,
 262 };
 263
 264 const struct iwl_cfg killer1650x_2ax_cfg = {
 265         .name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)",
 266         .fw_name_pre = IWL_CC_A_FW_PRE,
 267         IWL_DEVICE_22500,
 268         /*
 269          * This device doesn't support receiving BlockAck with a large bitmap
 270          * so we need to restrict the size of transmitted aggregation to the
 271          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 272          */
 273         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 274         .bisr_workaround = 1,
 275 };
 276
 277 const struct iwl_cfg killer1650w_2ax_cfg = {
 278         .name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)",
 279         .fw_name_pre = IWL_CC_A_FW_PRE,
 280         IWL_DEVICE_22500,
 281         /*
 282          * This device doesn't support receiving BlockAck with a large bitmap
 283          * so we need to restrict the size of transmitted aggregation to the
 284          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 285          */
 286         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 287         .bisr_workaround = 1,
 288 };
 289
 290 /*
 291  * All JF radio modules are part of the 9000 series, but the MAC part
 292  * looks more like 22000.  That's why this device is here, but called
 293  * 9560 nevertheless.
 294  */
 295 const struct iwl_cfg iwl9461_2ac_cfg_qu_b0_jf_b0 = {
 296         .name = "Intel(R) Wireless-AC 9461",
 297         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 298         IWL_DEVICE_22500,
 299 };
 300
 301 const struct iwl_cfg iwl9462_2ac_cfg_qu_b0_jf_b0 = {
 302         .name = "Intel(R) Wireless-AC 9462",
 303         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 304         IWL_DEVICE_22500,
 305 };
 306
 307 const struct iwl_cfg iwl9560_2ac_cfg_qu_b0_jf_b0 = {
 308         .name = "Intel(R) Wireless-AC 9560",
 309         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 310         IWL_DEVICE_22500,
 311 };
 312
 313 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_b0_jf_b0 = {
 314         .name = "Intel(R) Wireless-AC 9560 160MHz",
 315         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 316         IWL_DEVICE_22500,
 317 };
 318
 319 const struct iwl_cfg iwl9560_2ac_cfg_qnj_jf_b0 = {
 320         .name = "Intel(R) Wireless-AC 9560 160MHz",
 321         .fw_name_pre = IWL_QNJ_B_JF_B_FW_PRE,
 322         IWL_DEVICE_22500,
 323         /*
 324          * This device doesn't support receiving BlockAck with a large bitmap
 325          * so we need to restrict the size of transmitted aggregation to the
 326          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 327          */
 328         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 329 };
 330
 331 const struct iwl_cfg killer1550i_2ac_cfg_qu_b0_jf_b0 = {
 332         .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)",
 333         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 334         IWL_DEVICE_22500,
 335 };
 336
 337 const struct iwl_cfg killer1550s_2ac_cfg_qu_b0_jf_b0 = {
 338         .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)",
 339         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 340         IWL_DEVICE_22500,
 341 };
 342
 343 const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = {
 344         .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 345         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 346         IWL_DEVICE_22500,
 347         /*
 348          * This device doesn't support receiving BlockAck with a large bitmap
 349          * so we need to restrict the size of transmitted aggregation to the
 350          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 351          */
 352         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 353 };
 354
 355 const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = {
 356         .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 357         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 358         IWL_DEVICE_22500,
 359         /*
 360          * This device doesn't support receiving BlockAck with a large bitmap
 361          * so we need to restrict the size of transmitted aggregation to the
 362          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 363          */
 364         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 365 };
 366
 367 const struct iwl_cfg iwl22000_2ax_cfg_jf = {
 368         .name = "Intel(R) Dual Band Wireless AX 22000",
 369         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 370         IWL_DEVICE_22500,
 371         /*
 372          * This device doesn't support receiving BlockAck with a large bitmap
 373          * so we need to restrict the size of transmitted aggregation to the
 374          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 375          */
 376         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 377 };
 378
 379 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0_f0 = {
 380         .name = "Intel(R) Dual Band Wireless AX 22000",
 381         .fw_name_pre = IWL_22000_HR_A_F0_FW_PRE,
 382         IWL_DEVICE_22500,
 383         /*
 384          * This device doesn't support receiving BlockAck with a large bitmap
 385          * so we need to restrict the size of transmitted aggregation to the
 386          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 387          */
 388         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 389 };
 390
 391 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_b0 = {
 392         .name = "Intel(R) Dual Band Wireless AX 22000",
 393         .fw_name_pre = IWL_22000_HR_B_FW_PRE,
 394         IWL_DEVICE_22500,
 395         /*
 396          * This device doesn't support receiving BlockAck with a large bitmap
 397          * so we need to restrict the size of transmitted aggregation to the
 398          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 399          */
 400         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 401 };
 402
 403 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0 = {
 404         .name = "Intel(R) Dual Band Wireless AX 22000",
 405         .fw_name_pre = IWL_22000_HR_A0_FW_PRE,
 406         IWL_DEVICE_22500,
 407         /*
 408          * This device doesn't support receiving BlockAck with a large bitmap
 409          * so we need to restrict the size of transmitted aggregation to the
 410          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 411          */
 412         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 413 };
 414
 415 const struct iwl_cfg iwl22560_2ax_cfg_su_cdb = {
 416         .name = "Intel(R) Dual Band Wireless AX 22560",
 417         .fw_name_pre = IWL_22000_SU_Z0_FW_PRE,
 418         IWL_DEVICE_22560,
 419         .cdb = true,
 420         /*
 421          * This device doesn't support receiving BlockAck with a large bitmap
 422          * so we need to restrict the size of transmitted aggregation to the
 423          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 424          */
 425         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 426 };
 427
 428 const struct iwl_cfg iwlax210_2ax_cfg_so_jf_a0 = {
 429         .name = "Intel(R) Wireless-AC 9560 160MHz",
 430         .fw_name_pre = IWL_22000_SO_A_JF_B_FW_PRE,
 431         IWL_DEVICE_AX210,
 432 };
 433
 434 const struct iwl_cfg iwlax210_2ax_cfg_so_hr_a0 = {
 435         .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 436         .fw_name_pre = IWL_22000_SO_A_HR_B_FW_PRE,
 437         IWL_DEVICE_AX210,
 438 };
 439
 440 const struct iwl_cfg iwlax210_2ax_cfg_so_gf_a0 = {
 441         .name = "Intel(R) Wi-Fi 7 AX211 160MHz",
 442         .fw_name_pre = IWL_22000_SO_A_GF_A_FW_PRE,
 443         IWL_DEVICE_AX210,
 444 };
 445
 446 const struct iwl_cfg iwlax210_2ax_cfg_ty_gf_a0 = {
 447         .name = "Intel(R) Wi-Fi 7 AX210 160MHz",
 448         .fw_name_pre = IWL_22000_TY_A_GF_A_FW_PRE,
 449         IWL_DEVICE_AX210,
 450 };
 451
 452 MODULE_FIRMWARE(IWL_22000_HR_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 453 MODULE_FIRMWARE(IWL_22000_JF_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 454 MODULE_FIRMWARE(IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 455 MODULE_FIRMWARE(IWL_22000_HR_B_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 456 MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 457 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 458 MODULE_FIRMWARE(IWL_22000_SU_Z0_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 459 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 460 MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 461 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 462 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 463 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 464 MODULE_FIRMWARE(IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 465 MODULE_FIRMWARE(IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 466 MODULE_FIRMWARE(IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));