drivers/net/wireless/intel/iwlwifi/cfg/22000.c

/* [<][>][^][v][top][bottom][index][help] */
   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 50
  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_QU_B_HR_B_FW_PRE      "iwlwifi-Qu-b0-hr-b0-"
  80 #define IWL_22000_HR_B_FW_PRE           "iwlwifi-QuQnj-b0-hr-b0-"
  81 #define IWL_22000_HR_A0_FW_PRE          "iwlwifi-QuQnj-a0-hr-a0-"
  82 #define IWL_QU_C_HR_B_FW_PRE            "iwlwifi-Qu-c0-hr-b0-"
  83 #define IWL_QU_B_JF_B_FW_PRE            "iwlwifi-Qu-b0-jf-b0-"
  84 #define IWL_QU_C_JF_B_FW_PRE            "iwlwifi-Qu-c0-jf-b0-"
  85 #define IWL_QUZ_A_HR_B_FW_PRE           "iwlwifi-QuZ-a0-hr-b0-"
  86 #define IWL_QUZ_A_JF_B_FW_PRE           "iwlwifi-QuZ-a0-jf-b0-"
  87 #define IWL_QNJ_B_JF_B_FW_PRE           "iwlwifi-QuQnj-b0-jf-b0-"
  88 #define IWL_CC_A_FW_PRE                 "iwlwifi-cc-a0-"
  89 #define IWL_22000_SO_A_JF_B_FW_PRE      "iwlwifi-so-a0-jf-b0-"
  90 #define IWL_22000_SO_A_HR_B_FW_PRE      "iwlwifi-so-a0-hr-b0-"
  91 #define IWL_22000_SO_A_GF_A_FW_PRE      "iwlwifi-so-a0-gf-a0-"
  92 #define IWL_22000_TY_A_GF_A_FW_PRE      "iwlwifi-ty-a0-gf-a0-"
  93 #define IWL_22000_SO_A_GF4_A_FW_PRE     "iwlwifi-so-a0-gf4-a0-"
  94 
  95 #define IWL_22000_HR_MODULE_FIRMWARE(api) \
  96         IWL_22000_HR_FW_PRE __stringify(api) ".ucode"
  97 #define IWL_22000_JF_MODULE_FIRMWARE(api) \
  98         IWL_22000_JF_FW_PRE __stringify(api) ".ucode"
  99 #define IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(api) \
 100         IWL_22000_HR_A_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_QUZ_A_HR_B_MODULE_FIRMWARE(api) \
 108         IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode"
 109 #define IWL_QUZ_A_JF_B_MODULE_FIRMWARE(api) \
 110         IWL_QUZ_A_JF_B_FW_PRE __stringify(api) ".ucode"
 111 #define IWL_QU_C_HR_B_MODULE_FIRMWARE(api) \
 112         IWL_QU_C_HR_B_FW_PRE __stringify(api) ".ucode"
 113 #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \
 114         IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode"
 115 #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api)             \
 116         IWL_QNJ_B_JF_B_FW_PRE __stringify(api) ".ucode"
 117 #define IWL_CC_A_MODULE_FIRMWARE(api)                   \
 118         IWL_CC_A_FW_PRE __stringify(api) ".ucode"
 119 #define IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(api) \
 120         IWL_22000_SO_A_JF_B_FW_PRE __stringify(api) ".ucode"
 121 #define IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(api) \
 122         IWL_22000_SO_A_HR_B_FW_PRE __stringify(api) ".ucode"
 123 #define IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(api) \
 124         IWL_22000_SO_A_GF_A_FW_PRE __stringify(api) ".ucode"
 125 #define IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(api) \
 126         IWL_22000_TY_A_GF_A_FW_PRE __stringify(api) ".ucode"
 127 
 128 static const struct iwl_base_params iwl_22000_base_params = {
 129         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 130         .num_of_queues = 512,
 131         .max_tfd_queue_size = 256,
 132         .shadow_ram_support = true,
 133         .led_compensation = 57,
 134         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 135         .max_event_log_size = 512,
 136         .shadow_reg_enable = true,
 137         .pcie_l1_allowed = true,
 138 };
 139 
 140 static const struct iwl_base_params iwl_22560_base_params = {
 141         .eeprom_size = OTP_LOW_IMAGE_SIZE_32K,
 142         .num_of_queues = 512,
 143         .max_tfd_queue_size = 65536,
 144         .shadow_ram_support = true,
 145         .led_compensation = 57,
 146         .wd_timeout = IWL_LONG_WD_TIMEOUT,
 147         .max_event_log_size = 512,
 148         .shadow_reg_enable = true,
 149         .pcie_l1_allowed = true,
 150 };
 151 
 152 static const struct iwl_ht_params iwl_22000_ht_params = {
 153         .stbc = true,
 154         .ldpc = true,
 155         .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 156 };
 157 
 158 #define IWL_DEVICE_22000_COMMON                                         \
 159         .ucode_api_max = IWL_22000_UCODE_API_MAX,                       \
 160         .ucode_api_min = IWL_22000_UCODE_API_MIN,                       \
 161         .led_mode = IWL_LED_RF_STATE,                                   \
 162         .nvm_hw_section_num = 10,                                       \
 163         .non_shared_ant = ANT_B,                                        \
 164         .dccm_offset = IWL_22000_DCCM_OFFSET,                           \
 165         .dccm_len = IWL_22000_DCCM_LEN,                                 \
 166         .dccm2_offset = IWL_22000_DCCM2_OFFSET,                         \
 167         .dccm2_len = IWL_22000_DCCM2_LEN,                               \
 168         .smem_offset = IWL_22000_SMEM_OFFSET,                           \
 169         .smem_len = IWL_22000_SMEM_LEN,                                 \
 170         .features = IWL_TX_CSUM_NETIF_FLAGS | NETIF_F_RXCSUM,           \
 171         .apmg_not_supported = true,                                     \
 172         .trans.mq_rx_supported = true,                                  \
 173         .vht_mu_mimo_supported = true,                                  \
 174         .mac_addr_from_csr = true,                                      \
 175         .ht_params = &iwl_22000_ht_params,                              \
 176         .nvm_ver = IWL_22000_NVM_VERSION,                               \
 177         .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K,            \
 178         .trans.use_tfh = true,                                          \
 179         .trans.rf_id = true,                                            \
 180         .trans.gen2 = true,                                             \
 181         .nvm_type = IWL_NVM_EXT,                                        \
 182         .dbgc_supported = true,                                         \
 183         .min_umac_error_event_table = 0x400000,                         \
 184         .d3_debug_data_base_addr = 0x401000,                            \
 185         .d3_debug_data_length = 60 * 1024,                              \
 186         .fw_mon_smem_write_ptr_addr = 0xa0c16c,                         \
 187         .fw_mon_smem_write_ptr_msk = 0xfffff,                           \
 188         .fw_mon_smem_cycle_cnt_ptr_addr = 0xa0c174,                     \
 189         .fw_mon_smem_cycle_cnt_ptr_msk = 0xfffff
 190 
 191 #define IWL_DEVICE_22500                                                \
 192         IWL_DEVICE_22000_COMMON,                                        \
 193         .trans.device_family = IWL_DEVICE_FAMILY_22000,                 \
 194         .trans.base_params = &iwl_22000_base_params,                    \
 195         .trans.csr = &iwl_csr_v1,                                       \
 196         .gp2_reg_addr = 0xa02c68
 197 
 198 #define IWL_DEVICE_22560                                                \
 199         IWL_DEVICE_22000_COMMON,                                        \
 200         .trans.device_family = IWL_DEVICE_FAMILY_22560,                 \
 201         .trans.base_params = &iwl_22560_base_params,                    \
 202         .trans.csr = &iwl_csr_v2
 203 
 204 #define IWL_DEVICE_AX210                                                \
 205         IWL_DEVICE_22000_COMMON,                                        \
 206         .trans.umac_prph_offset = 0x300000,                             \
 207         .trans.device_family = IWL_DEVICE_FAMILY_AX210,                 \
 208         .trans.base_params = &iwl_22560_base_params,                    \
 209         .trans.csr = &iwl_csr_v1,                                       \
 210         .min_txq_size = 128,                                            \
 211         .gp2_reg_addr = 0xd02c68,                                       \
 212         .min_256_ba_txq_size = 512
 213 
 214 const struct iwl_cfg iwl22000_2ac_cfg_hr = {
 215         .name = "Intel(R) Dual Band Wireless AC 22000",
 216         .fw_name_pre = IWL_22000_HR_FW_PRE,
 217         IWL_DEVICE_22500,
 218 };
 219 
 220 const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb = {
 221         .name = "Intel(R) Dual Band Wireless AC 22000",
 222         .fw_name_pre = IWL_22000_HR_CDB_FW_PRE,
 223         IWL_DEVICE_22500,
 224         .cdb = true,
 225 };
 226 
 227 const struct iwl_cfg iwl22000_2ac_cfg_jf = {
 228         .name = "Intel(R) Dual Band Wireless AC 22000",
 229         .fw_name_pre = IWL_22000_JF_FW_PRE,
 230         IWL_DEVICE_22500,
 231 };
 232 
 233 const struct iwl_cfg iwl_ax101_cfg_qu_hr = {
 234         .name = "Intel(R) Wi-Fi 6 AX101",
 235         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 236         IWL_DEVICE_22500,
 237         /*
 238          * This device doesn't support receiving BlockAck with a large bitmap
 239          * so we need to restrict the size of transmitted aggregation to the
 240          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 241          */
 242         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 243         .tx_with_siso_diversity = true,
 244 };
 245 
 246 const struct iwl_cfg iwl_ax201_cfg_qu_hr = {
 247         .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 248         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 249         IWL_DEVICE_22500,
 250         /*
 251          * This device doesn't support receiving BlockAck with a large bitmap
 252          * so we need to restrict the size of transmitted aggregation to the
 253          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 254          */
 255         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 256 };
 257 
 258 const struct iwl_cfg iwl_ax101_cfg_qu_c0_hr_b0 = {
 259         .name = "Intel(R) Wi-Fi 6 AX101",
 260         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 261         IWL_DEVICE_22500,
 262         /*
 263          * This device doesn't support receiving BlockAck with a large bitmap
 264          * so we need to restrict the size of transmitted aggregation to the
 265          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 266          */
 267         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 268 };
 269 
 270 const struct iwl_cfg iwl_ax201_cfg_qu_c0_hr_b0 = {
 271         .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 272         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 273         IWL_DEVICE_22500,
 274         /*
 275          * This device doesn't support receiving BlockAck with a large bitmap
 276          * so we need to restrict the size of transmitted aggregation to the
 277          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 278          */
 279         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 280 };
 281 
 282 const struct iwl_cfg iwl_ax101_cfg_quz_hr = {
 283         .name = "Intel(R) Wi-Fi 6 AX101",
 284         .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 285         IWL_DEVICE_22500,
 286         /*
 287          * This device doesn't support receiving BlockAck with a large bitmap
 288          * so we need to restrict the size of transmitted aggregation to the
 289          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 290          */
 291         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 292 };
 293 
 294 const struct iwl_cfg iwl_ax201_cfg_quz_hr = {
 295                 .name = "Intel(R) Wi-Fi 6 AX201 160MHz",
 296                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 297                 IWL_DEVICE_22500,
 298                 /*
 299          * This device doesn't support receiving BlockAck with a large bitmap
 300          * so we need to restrict the size of transmitted aggregation to the
 301          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 302          */
 303                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 304 };
 305 
 306 const struct iwl_cfg iwl_ax1650s_cfg_quz_hr = {
 307                 .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 308                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 309                 IWL_DEVICE_22500,
 310                 /*
 311          * This device doesn't support receiving BlockAck with a large bitmap
 312          * so we need to restrict the size of transmitted aggregation to the
 313          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 314          */
 315                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 316 };
 317 
 318 const struct iwl_cfg iwl_ax1650i_cfg_quz_hr = {
 319                 .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 320                 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
 321                 IWL_DEVICE_22500,
 322                 /*
 323          * This device doesn't support receiving BlockAck with a large bitmap
 324          * so we need to restrict the size of transmitted aggregation to the
 325          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 326          */
 327                 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 328 };
 329 
 330 const struct iwl_cfg iwl_ax200_cfg_cc = {
 331         .name = "Intel(R) Wi-Fi 6 AX200 160MHz",
 332         .fw_name_pre = IWL_CC_A_FW_PRE,
 333         IWL_DEVICE_22500,
 334         /*
 335          * This device doesn't support receiving BlockAck with a large bitmap
 336          * so we need to restrict the size of transmitted aggregation to the
 337          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 338          */
 339         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 340         .trans.bisr_workaround = 1,
 341 };
 342 
 343 const struct iwl_cfg killer1650x_2ax_cfg = {
 344         .name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)",
 345         .fw_name_pre = IWL_CC_A_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         .trans.bisr_workaround = 1,
 354 };
 355 
 356 const struct iwl_cfg killer1650w_2ax_cfg = {
 357         .name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)",
 358         .fw_name_pre = IWL_CC_A_FW_PRE,
 359         IWL_DEVICE_22500,
 360         /*
 361          * This device doesn't support receiving BlockAck with a large bitmap
 362          * so we need to restrict the size of transmitted aggregation to the
 363          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 364          */
 365         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 366         .trans.bisr_workaround = 1,
 367 };
 368 
 369 /*
 370  * All JF radio modules are part of the 9000 series, but the MAC part
 371  * looks more like 22000.  That's why this device is here, but called
 372  * 9560 nevertheless.
 373  */
 374 const struct iwl_cfg iwl9461_2ac_cfg_qu_b0_jf_b0 = {
 375         .name = "Intel(R) Wireless-AC 9461",
 376         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 377         IWL_DEVICE_22500,
 378 };
 379 
 380 const struct iwl_cfg iwl9462_2ac_cfg_qu_b0_jf_b0 = {
 381         .name = "Intel(R) Wireless-AC 9462",
 382         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 383         IWL_DEVICE_22500,
 384 };
 385 
 386 const struct iwl_cfg iwl9560_2ac_cfg_qu_b0_jf_b0 = {
 387         .name = "Intel(R) Wireless-AC 9560",
 388         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 389         IWL_DEVICE_22500,
 390 };
 391 
 392 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_b0_jf_b0 = {
 393         .name = "Intel(R) Wireless-AC 9560 160MHz",
 394         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 395         IWL_DEVICE_22500,
 396 };
 397 
 398 const struct iwl_cfg iwl9461_2ac_cfg_qu_c0_jf_b0 = {
 399         .name = "Intel(R) Wireless-AC 9461",
 400         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 401         IWL_DEVICE_22500,
 402 };
 403 
 404 const struct iwl_cfg iwl9462_2ac_cfg_qu_c0_jf_b0 = {
 405         .name = "Intel(R) Wireless-AC 9462",
 406         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 407         IWL_DEVICE_22500,
 408 };
 409 
 410 const struct iwl_cfg iwl9560_2ac_cfg_qu_c0_jf_b0 = {
 411         .name = "Intel(R) Wireless-AC 9560",
 412         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 413         IWL_DEVICE_22500,
 414 };
 415 
 416 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_c0_jf_b0 = {
 417         .name = "Intel(R) Wireless-AC 9560 160MHz",
 418         .fw_name_pre = IWL_QU_C_JF_B_FW_PRE,
 419         IWL_DEVICE_22500,
 420 };
 421 
 422 const struct iwl_cfg iwl9560_2ac_cfg_qnj_jf_b0 = {
 423         .name = "Intel(R) Wireless-AC 9560 160MHz",
 424         .fw_name_pre = IWL_QNJ_B_JF_B_FW_PRE,
 425         IWL_DEVICE_22500,
 426         /*
 427          * This device doesn't support receiving BlockAck with a large bitmap
 428          * so we need to restrict the size of transmitted aggregation to the
 429          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 430          */
 431         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 432 };
 433 
 434 const struct iwl_cfg iwl9560_2ac_cfg_quz_a0_jf_b0_soc = {
 435         .name = "Intel(R) Wireless-AC 9560 160MHz",
 436         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 437         IWL_DEVICE_22500,
 438         /*
 439          * This device doesn't support receiving BlockAck with a large bitmap
 440          * so we need to restrict the size of transmitted aggregation to the
 441          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 442          */
 443         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 444         .integrated = true,
 445         .soc_latency = 5000,
 446 };
 447 
 448 const struct iwl_cfg iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc = {
 449         .name = "Intel(R) Wireless-AC 9560 160MHz",
 450         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 451         IWL_DEVICE_22500,
 452         /*
 453          * This device doesn't support receiving BlockAck with a large bitmap
 454          * so we need to restrict the size of transmitted aggregation to the
 455          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 456          */
 457         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 458         .integrated = true,
 459         .soc_latency = 5000,
 460 };
 461 
 462 const struct iwl_cfg iwl9461_2ac_cfg_quz_a0_jf_b0_soc = {
 463         .name = "Intel(R) Dual Band Wireless AC 9461",
 464         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 465         IWL_DEVICE_22500,
 466         /*
 467          * This device doesn't support receiving BlockAck with a large bitmap
 468          * so we need to restrict the size of transmitted aggregation to the
 469          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 470          */
 471         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 472         .integrated = true,
 473         .soc_latency = 5000,
 474 };
 475 
 476 const struct iwl_cfg iwl9462_2ac_cfg_quz_a0_jf_b0_soc = {
 477         .name = "Intel(R) Dual Band Wireless AC 9462",
 478         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 479         IWL_DEVICE_22500,
 480         /*
 481          * This device doesn't support receiving BlockAck with a large bitmap
 482          * so we need to restrict the size of transmitted aggregation to the
 483          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 484          */
 485         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 486         .integrated = true,
 487         .soc_latency = 5000,
 488 };
 489 
 490 const struct iwl_cfg iwl9560_killer_s_2ac_cfg_quz_a0_jf_b0_soc = {
 491         .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)",
 492         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 493         IWL_DEVICE_22500,
 494         /*
 495          * This device doesn't support receiving BlockAck with a large bitmap
 496          * so we need to restrict the size of transmitted aggregation to the
 497          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 498          */
 499         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 500         .integrated = true,
 501         .soc_latency = 5000,
 502 };
 503 
 504 const struct iwl_cfg iwl9560_killer_i_2ac_cfg_quz_a0_jf_b0_soc = {
 505         .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)",
 506         .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE,
 507         IWL_DEVICE_22500,
 508         /*
 509          * This device doesn't support receiving BlockAck with a large bitmap
 510          * so we need to restrict the size of transmitted aggregation to the
 511          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 512          */
 513         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 514         .integrated = true,
 515         .soc_latency = 5000,
 516 };
 517 
 518 const struct iwl_cfg killer1550i_2ac_cfg_qu_b0_jf_b0 = {
 519         .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)",
 520         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 521         IWL_DEVICE_22500,
 522 };
 523 
 524 const struct iwl_cfg killer1550s_2ac_cfg_qu_b0_jf_b0 = {
 525         .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)",
 526         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 527         IWL_DEVICE_22500,
 528 };
 529 
 530 const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = {
 531         .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 532         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 533         IWL_DEVICE_22500,
 534         /*
 535          * This device doesn't support receiving BlockAck with a large bitmap
 536          * so we need to restrict the size of transmitted aggregation to the
 537          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 538          */
 539         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 540 };
 541 
 542 const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = {
 543         .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 544         .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 545         IWL_DEVICE_22500,
 546         /*
 547          * This device doesn't support receiving BlockAck with a large bitmap
 548          * so we need to restrict the size of transmitted aggregation to the
 549          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 550          */
 551         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 552 };
 553 
 554 const struct iwl_cfg killer1650s_2ax_cfg_qu_c0_hr_b0 = {
 555         .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 556         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 557         IWL_DEVICE_22500,
 558         /*
 559          * This device doesn't support receiving BlockAck with a large bitmap
 560          * so we need to restrict the size of transmitted aggregation to the
 561          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 562          */
 563         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 564 };
 565 
 566 const struct iwl_cfg killer1650i_2ax_cfg_qu_c0_hr_b0 = {
 567         .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 568         .fw_name_pre = IWL_QU_C_HR_B_FW_PRE,
 569         IWL_DEVICE_22500,
 570         /*
 571          * This device doesn't support receiving BlockAck with a large bitmap
 572          * so we need to restrict the size of transmitted aggregation to the
 573          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 574          */
 575         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 576 };
 577 
 578 const struct iwl_cfg iwl22000_2ax_cfg_jf = {
 579         .name = "Intel(R) Dual Band Wireless AX 22000",
 580         .fw_name_pre = IWL_QU_B_JF_B_FW_PRE,
 581         IWL_DEVICE_22500,
 582         /*
 583          * This device doesn't support receiving BlockAck with a large bitmap
 584          * so we need to restrict the size of transmitted aggregation to the
 585          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 586          */
 587         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 588 };
 589 
 590 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0_f0 = {
 591         .name = "Intel(R) Dual Band Wireless AX 22000",
 592         .fw_name_pre = IWL_22000_HR_A_F0_FW_PRE,
 593         IWL_DEVICE_22500,
 594         /*
 595          * This device doesn't support receiving BlockAck with a large bitmap
 596          * so we need to restrict the size of transmitted aggregation to the
 597          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 598          */
 599         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 600 };
 601 
 602 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_b0 = {
 603         .name = "Intel(R) Dual Band Wireless AX 22000",
 604         .fw_name_pre = IWL_22000_HR_B_FW_PRE,
 605         IWL_DEVICE_22500,
 606         /*
 607          * This device doesn't support receiving BlockAck with a large bitmap
 608          * so we need to restrict the size of transmitted aggregation to the
 609          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 610          */
 611         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 612 };
 613 
 614 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0 = {
 615         .name = "Intel(R) Dual Band Wireless AX 22000",
 616         .fw_name_pre = IWL_22000_HR_A0_FW_PRE,
 617         IWL_DEVICE_22500,
 618         /*
 619          * This device doesn't support receiving BlockAck with a large bitmap
 620          * so we need to restrict the size of transmitted aggregation to the
 621          * HT size; mac80211 would otherwise pick the HE max (256) by default.
 622          */
 623         .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 624 };
 625 
 626 const struct iwl_cfg iwlax210_2ax_cfg_so_jf_a0 = {
 627         .name = "Intel(R) Wireless-AC 9560 160MHz",
 628         .fw_name_pre = IWL_22000_SO_A_JF_B_FW_PRE,
 629         IWL_DEVICE_AX210,
 630 };
 631 
 632 const struct iwl_cfg iwlax210_2ax_cfg_so_hr_a0 = {
 633         .name = "Intel(R) Wi-Fi 7 AX210 160MHz",
 634         .fw_name_pre = IWL_22000_SO_A_HR_B_FW_PRE,
 635         IWL_DEVICE_AX210,
 636 };
 637 
 638 const struct iwl_cfg iwlax211_2ax_cfg_so_gf_a0 = {
 639         .name = "Intel(R) Wi-Fi 7 AX211 160MHz",
 640         .fw_name_pre = IWL_22000_SO_A_GF_A_FW_PRE,
 641         .uhb_supported = true,
 642         IWL_DEVICE_AX210,
 643 };
 644 
 645 const struct iwl_cfg iwlax210_2ax_cfg_ty_gf_a0 = {
 646         .name = "Intel(R) Wi-Fi 7 AX210 160MHz",
 647         .fw_name_pre = IWL_22000_TY_A_GF_A_FW_PRE,
 648         .uhb_supported = true,
 649         IWL_DEVICE_AX210,
 650 };
 651 
 652 const struct iwl_cfg iwlax411_2ax_cfg_so_gf4_a0 = {
 653         .name = "Intel(R) Wi-Fi 7 AX411 160MHz",
 654         .fw_name_pre = IWL_22000_SO_A_GF4_A_FW_PRE,
 655         IWL_DEVICE_AX210,
 656 };
 657 
 658 MODULE_FIRMWARE(IWL_22000_HR_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 659 MODULE_FIRMWARE(IWL_22000_JF_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 660 MODULE_FIRMWARE(IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 661 MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 662 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 663 MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 664 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 665 MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 666 MODULE_FIRMWARE(IWL_QUZ_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 667 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 668 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 669 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 670 MODULE_FIRMWARE(IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 671 MODULE_FIRMWARE(IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 672 MODULE_FIRMWARE(IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
