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 #include "iwl-prph.h" 58 59 /* Highest firmware API version supported */ 60 #define IWL_22000_UCODE_API_MAX 52 61 62 /* Lowest firmware API version supported */ 63 #define IWL_22000_UCODE_API_MIN 39 64 65 /* NVM versions */ 66 #define IWL_22000_NVM_VERSION 0x0a1d 67 68 /* Memory offsets and lengths */ 69 #define IWL_22000_DCCM_OFFSET 0x800000 /* LMAC1 */ 70 #define IWL_22000_DCCM_LEN 0x10000 /* LMAC1 */ 71 #define IWL_22000_DCCM2_OFFSET 0x880000 72 #define IWL_22000_DCCM2_LEN 0x8000 73 #define IWL_22000_SMEM_OFFSET 0x400000 74 #define IWL_22000_SMEM_LEN 0xD0000 75 76 #define IWL_22000_JF_FW_PRE "iwlwifi-Qu-a0-jf-b0-" 77 #define IWL_22000_HR_FW_PRE "iwlwifi-Qu-a0-hr-a0-" 78 #define IWL_22000_HR_CDB_FW_PRE "iwlwifi-QuIcp-z0-hrcdb-a0-" 79 #define IWL_22000_HR_A_F0_FW_PRE "iwlwifi-QuQnj-f0-hr-a0-" 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_QU_B_HR_B_MODULE_FIRMWARE(api) \ 103 IWL_22000_QU_B_HR_B_FW_PRE __stringify(api) ".ucode" 104 #define IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(api) \ 105 IWL_22000_HR_B_FW_PRE __stringify(api) ".ucode" 106 #define IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(api) \ 107 IWL_22000_HR_A0_FW_PRE __stringify(api) ".ucode" 108 #define IWL_QUZ_A_HR_B_MODULE_FIRMWARE(api) \ 109 IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode" 110 #define IWL_QUZ_A_JF_B_MODULE_FIRMWARE(api) \ 111 IWL_QUZ_A_JF_B_FW_PRE __stringify(api) ".ucode" 112 #define IWL_QU_C_HR_B_MODULE_FIRMWARE(api) \ 113 IWL_QU_C_HR_B_FW_PRE __stringify(api) ".ucode" 114 #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \ 115 IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode" 116 #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api) \ 117 IWL_QNJ_B_JF_B_FW_PRE __stringify(api) ".ucode" 118 #define IWL_CC_A_MODULE_FIRMWARE(api) \ 119 IWL_CC_A_FW_PRE __stringify(api) ".ucode" 120 #define IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(api) \ 121 IWL_22000_SO_A_JF_B_FW_PRE __stringify(api) ".ucode" 122 #define IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(api) \ 123 IWL_22000_SO_A_HR_B_FW_PRE __stringify(api) ".ucode" 124 #define IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(api) \ 125 IWL_22000_SO_A_GF_A_FW_PRE __stringify(api) ".ucode" 126 #define IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(api) \ 127 IWL_22000_TY_A_GF_A_FW_PRE __stringify(api) ".ucode" 128 129 static const struct iwl_base_params iwl_22000_base_params = { 130 .eeprom_size = OTP_LOW_IMAGE_SIZE_32K, 131 .num_of_queues = 512, 132 .max_tfd_queue_size = 256, 133 .shadow_ram_support = true, 134 .led_compensation = 57, 135 .wd_timeout = IWL_LONG_WD_TIMEOUT, 136 .max_event_log_size = 512, 137 .shadow_reg_enable = true, 138 .pcie_l1_allowed = true, 139 }; 140 141 static const struct iwl_base_params iwl_ax210_base_params = { 142 .eeprom_size = OTP_LOW_IMAGE_SIZE_32K, 143 .num_of_queues = 512, 144 .max_tfd_queue_size = 65536, 145 .shadow_ram_support = true, 146 .led_compensation = 57, 147 .wd_timeout = IWL_LONG_WD_TIMEOUT, 148 .max_event_log_size = 512, 149 .shadow_reg_enable = true, 150 .pcie_l1_allowed = true, 151 }; 152 153 static const struct iwl_ht_params iwl_22000_ht_params = { 154 .stbc = true, 155 .ldpc = true, 156 .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ), 157 }; 158 159 #define IWL_DEVICE_22000_COMMON \ 160 .ucode_api_max = IWL_22000_UCODE_API_MAX, \ 161 .ucode_api_min = IWL_22000_UCODE_API_MIN, \ 162 .led_mode = IWL_LED_RF_STATE, \ 163 .nvm_hw_section_num = 10, \ 164 .non_shared_ant = ANT_B, \ 165 .dccm_offset = IWL_22000_DCCM_OFFSET, \ 166 .dccm_len = IWL_22000_DCCM_LEN, \ 167 .dccm2_offset = IWL_22000_DCCM2_OFFSET, \ 168 .dccm2_len = IWL_22000_DCCM2_LEN, \ 169 .smem_offset = IWL_22000_SMEM_OFFSET, \ 170 .smem_len = IWL_22000_SMEM_LEN, \ 171 .features = IWL_TX_CSUM_NETIF_FLAGS | NETIF_F_RXCSUM, \ 172 .apmg_not_supported = true, \ 173 .trans.mq_rx_supported = true, \ 174 .vht_mu_mimo_supported = true, \ 175 .mac_addr_from_csr = true, \ 176 .ht_params = &iwl_22000_ht_params, \ 177 .nvm_ver = IWL_22000_NVM_VERSION, \ 178 .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, \ 179 .trans.use_tfh = true, \ 180 .trans.rf_id = true, \ 181 .trans.gen2 = true, \ 182 .nvm_type = IWL_NVM_EXT, \ 183 .dbgc_supported = true, \ 184 .min_umac_error_event_table = 0x400000, \ 185 .d3_debug_data_base_addr = 0x401000, \ 186 .d3_debug_data_length = 60 * 1024, \ 187 .mon_smem_regs = { \ 188 .write_ptr = { \ 189 .addr = LDBG_M2S_BUF_WPTR, \ 190 .mask = LDBG_M2S_BUF_WPTR_VAL_MSK, \ 191 }, \ 192 .cycle_cnt = { \ 193 .addr = LDBG_M2S_BUF_WRAP_CNT, \ 194 .mask = LDBG_M2S_BUF_WRAP_CNT_VAL_MSK, \ 195 }, \ 196 } 197 198 #define IWL_DEVICE_22500 \ 199 IWL_DEVICE_22000_COMMON, \ 200 .trans.device_family = IWL_DEVICE_FAMILY_22000, \ 201 .trans.base_params = &iwl_22000_base_params, \ 202 .trans.csr = &iwl_csr_v1, \ 203 .gp2_reg_addr = 0xa02c68, \ 204 .mon_dram_regs = { \ 205 .write_ptr = { \ 206 .addr = MON_BUFF_WRPTR_VER2, \ 207 .mask = 0xffffffff, \ 208 }, \ 209 .cycle_cnt = { \ 210 .addr = MON_BUFF_CYCLE_CNT_VER2, \ 211 .mask = 0xffffffff, \ 212 }, \ 213 } 214 215 #define IWL_DEVICE_AX210 \ 216 IWL_DEVICE_22000_COMMON, \ 217 .trans.umac_prph_offset = 0x300000, \ 218 .trans.device_family = IWL_DEVICE_FAMILY_AX210, \ 219 .trans.base_params = &iwl_ax210_base_params, \ 220 .trans.csr = &iwl_csr_v1, \ 221 .min_txq_size = 128, \ 222 .gp2_reg_addr = 0xd02c68, \ 223 .min_256_ba_txq_size = 512, \ 224 .mon_dram_regs = { \ 225 .write_ptr = { \ 226 .addr = DBGC_CUR_DBGBUF_STATUS, \ 227 .mask = DBGC_CUR_DBGBUF_STATUS_OFFSET_MSK, \ 228 }, \ 229 .cycle_cnt = { \ 230 .addr = DBGC_DBGBUF_WRAP_AROUND, \ 231 .mask = 0xffffffff, \ 232 }, \ 233 .cur_frag = { \ 234 .addr = DBGC_CUR_DBGBUF_STATUS, \ 235 .mask = DBGC_CUR_DBGBUF_STATUS_IDX_MSK, \ 236 }, \ 237 } 238 239 /* 240 * If the device doesn't support HE, no need to have that many buffers. 241 * 22000 devices can split multiple frames into a single RB, so fewer are 242 * needed; AX210 cannot (but use smaller RBs by default) - these sizes 243 * were picked according to 8 MSDUs inside 256 A-MSDUs in an A-MPDU, with 244 * additional overhead to account for processing time. 245 */ 246 #define IWL_NUM_RBDS_NON_HE 512 247 #define IWL_NUM_RBDS_22000_HE 2048 248 #define IWL_NUM_RBDS_AX210_HE 4096 249 250 const struct iwl_cfg iwl22000_2ac_cfg_hr = { 251 .name = "Intel(R) Dual Band Wireless AC 22000", 252 .fw_name_pre = IWL_22000_HR_FW_PRE, 253 IWL_DEVICE_22500, 254 .num_rbds = IWL_NUM_RBDS_NON_HE, 255 }; 256 257 const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb = { 258 .name = "Intel(R) Dual Band Wireless AC 22000", 259 .fw_name_pre = IWL_22000_HR_CDB_FW_PRE, 260 IWL_DEVICE_22500, 261 .cdb = true, 262 .num_rbds = IWL_NUM_RBDS_NON_HE, 263 }; 264 265 const struct iwl_cfg iwl22000_2ac_cfg_jf = { 266 .name = "Intel(R) Dual Band Wireless AC 22000", 267 .fw_name_pre = IWL_22000_JF_FW_PRE, 268 IWL_DEVICE_22500, 269 .num_rbds = IWL_NUM_RBDS_NON_HE, 270 }; 271 272 const struct iwl_cfg iwl_ax101_cfg_qu_hr = { 273 .name = "Intel(R) Wi-Fi 6 AX101", 274 .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, 275 IWL_DEVICE_22500, 276 /* 277 * This device doesn't support receiving BlockAck with a large bitmap 278 * so we need to restrict the size of transmitted aggregation to the 279 * HT size; mac80211 would otherwise pick the HE max (256) by default. 280 */ 281 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 282 .tx_with_siso_diversity = true, 283 .num_rbds = IWL_NUM_RBDS_22000_HE, 284 }; 285 286 const struct iwl_cfg iwl_ax201_cfg_qu_hr = { 287 .name = "Intel(R) Wi-Fi 6 AX201 160MHz", 288 .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, 289 IWL_DEVICE_22500, 290 /* 291 * This device doesn't support receiving BlockAck with a large bitmap 292 * so we need to restrict the size of transmitted aggregation to the 293 * HT size; mac80211 would otherwise pick the HE max (256) by default. 294 */ 295 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 296 .num_rbds = IWL_NUM_RBDS_22000_HE, 297 }; 298 299 const struct iwl_cfg iwl_ax101_cfg_qu_c0_hr_b0 = { 300 .name = "Intel(R) Wi-Fi 6 AX101", 301 .fw_name_pre = IWL_QU_C_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 .num_rbds = IWL_NUM_RBDS_22000_HE, 310 }; 311 312 const struct iwl_cfg iwl_ax201_cfg_qu_c0_hr_b0 = { 313 .name = "Intel(R) Wi-Fi 6 AX201 160MHz", 314 .fw_name_pre = IWL_QU_C_HR_B_FW_PRE, 315 IWL_DEVICE_22500, 316 /* 317 * This device doesn't support receiving BlockAck with a large bitmap 318 * so we need to restrict the size of transmitted aggregation to the 319 * HT size; mac80211 would otherwise pick the HE max (256) by default. 320 */ 321 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 322 .num_rbds = IWL_NUM_RBDS_22000_HE, 323 }; 324 325 const struct iwl_cfg iwl_ax101_cfg_quz_hr = { 326 .name = "Intel(R) Wi-Fi 6 AX101", 327 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, 328 IWL_DEVICE_22500, 329 /* 330 * This device doesn't support receiving BlockAck with a large bitmap 331 * so we need to restrict the size of transmitted aggregation to the 332 * HT size; mac80211 would otherwise pick the HE max (256) by default. 333 */ 334 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 335 .num_rbds = IWL_NUM_RBDS_22000_HE, 336 }; 337 338 const struct iwl_cfg iwl_ax201_cfg_quz_hr = { 339 .name = "Intel(R) Wi-Fi 6 AX201 160MHz", 340 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, 341 IWL_DEVICE_22500, 342 /* 343 * This device doesn't support receiving BlockAck with a large bitmap 344 * so we need to restrict the size of transmitted aggregation to the 345 * HT size; mac80211 would otherwise pick the HE max (256) by default. 346 */ 347 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 348 .num_rbds = IWL_NUM_RBDS_22000_HE, 349 }; 350 351 const struct iwl_cfg iwl_ax1650s_cfg_quz_hr = { 352 .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)", 353 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, 354 IWL_DEVICE_22500, 355 /* 356 * This device doesn't support receiving BlockAck with a large bitmap 357 * so we need to restrict the size of transmitted aggregation to the 358 * HT size; mac80211 would otherwise pick the HE max (256) by default. 359 */ 360 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 361 .num_rbds = IWL_NUM_RBDS_22000_HE, 362 }; 363 364 const struct iwl_cfg iwl_ax1650i_cfg_quz_hr = { 365 .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)", 366 .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, 367 IWL_DEVICE_22500, 368 /* 369 * This device doesn't support receiving BlockAck with a large bitmap 370 * so we need to restrict the size of transmitted aggregation to the 371 * HT size; mac80211 would otherwise pick the HE max (256) by default. 372 */ 373 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 374 .num_rbds = IWL_NUM_RBDS_22000_HE, 375 }; 376 377 const struct iwl_cfg iwl_ax200_cfg_cc = { 378 .name = "Intel(R) Wi-Fi 6 AX200 160MHz", 379 .fw_name_pre = IWL_CC_A_FW_PRE, 380 IWL_DEVICE_22500, 381 /* 382 * This device doesn't support receiving BlockAck with a large bitmap 383 * so we need to restrict the size of transmitted aggregation to the 384 * HT size; mac80211 would otherwise pick the HE max (256) by default. 385 */ 386 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 387 .trans.bisr_workaround = 1, 388 .num_rbds = IWL_NUM_RBDS_22000_HE, 389 }; 390 391 const struct iwl_cfg killer1650x_2ax_cfg = { 392 .name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)", 393 .fw_name_pre = IWL_CC_A_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 .trans.bisr_workaround = 1, 402 .num_rbds = IWL_NUM_RBDS_22000_HE, 403 }; 404 405 const struct iwl_cfg killer1650w_2ax_cfg = { 406 .name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)", 407 .fw_name_pre = IWL_CC_A_FW_PRE, 408 IWL_DEVICE_22500, 409 /* 410 * This device doesn't support receiving BlockAck with a large bitmap 411 * so we need to restrict the size of transmitted aggregation to the 412 * HT size; mac80211 would otherwise pick the HE max (256) by default. 413 */ 414 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 415 .trans.bisr_workaround = 1, 416 .num_rbds = IWL_NUM_RBDS_22000_HE, 417 }; 418 419 /* 420 * All JF radio modules are part of the 9000 series, but the MAC part 421 * looks more like 22000. That's why this device is here, but called 422 * 9560 nevertheless. 423 */ 424 const struct iwl_cfg iwl9461_2ac_cfg_qu_b0_jf_b0 = { 425 .name = "Intel(R) Wireless-AC 9461", 426 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 427 IWL_DEVICE_22500, 428 .num_rbds = IWL_NUM_RBDS_NON_HE, 429 }; 430 431 const struct iwl_cfg iwl9462_2ac_cfg_qu_b0_jf_b0 = { 432 .name = "Intel(R) Wireless-AC 9462", 433 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 434 IWL_DEVICE_22500, 435 .num_rbds = IWL_NUM_RBDS_NON_HE, 436 }; 437 438 const struct iwl_cfg iwl9560_2ac_cfg_qu_b0_jf_b0 = { 439 .name = "Intel(R) Wireless-AC 9560", 440 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 441 IWL_DEVICE_22500, 442 .num_rbds = IWL_NUM_RBDS_NON_HE, 443 }; 444 445 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_b0_jf_b0 = { 446 .name = "Intel(R) Wireless-AC 9560 160MHz", 447 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 448 IWL_DEVICE_22500, 449 .num_rbds = IWL_NUM_RBDS_NON_HE, 450 }; 451 452 const struct iwl_cfg iwl9461_2ac_cfg_qu_c0_jf_b0 = { 453 .name = "Intel(R) Wireless-AC 9461", 454 .fw_name_pre = IWL_QU_C_JF_B_FW_PRE, 455 IWL_DEVICE_22500, 456 .num_rbds = IWL_NUM_RBDS_NON_HE, 457 }; 458 459 const struct iwl_cfg iwl9462_2ac_cfg_qu_c0_jf_b0 = { 460 .name = "Intel(R) Wireless-AC 9462", 461 .fw_name_pre = IWL_QU_C_JF_B_FW_PRE, 462 IWL_DEVICE_22500, 463 .num_rbds = IWL_NUM_RBDS_NON_HE, 464 }; 465 466 const struct iwl_cfg iwl9560_2ac_cfg_qu_c0_jf_b0 = { 467 .name = "Intel(R) Wireless-AC 9560", 468 .fw_name_pre = IWL_QU_C_JF_B_FW_PRE, 469 IWL_DEVICE_22500, 470 .num_rbds = IWL_NUM_RBDS_NON_HE, 471 }; 472 473 const struct iwl_cfg iwl9560_2ac_160_cfg_qu_c0_jf_b0 = { 474 .name = "Intel(R) Wireless-AC 9560 160MHz", 475 .fw_name_pre = IWL_QU_C_JF_B_FW_PRE, 476 IWL_DEVICE_22500, 477 .num_rbds = IWL_NUM_RBDS_NON_HE, 478 }; 479 480 const struct iwl_cfg iwl9560_2ac_cfg_qnj_jf_b0 = { 481 .name = "Intel(R) Wireless-AC 9560 160MHz", 482 .fw_name_pre = IWL_QNJ_B_JF_B_FW_PRE, 483 IWL_DEVICE_22500, 484 /* 485 * This device doesn't support receiving BlockAck with a large bitmap 486 * so we need to restrict the size of transmitted aggregation to the 487 * HT size; mac80211 would otherwise pick the HE max (256) by default. 488 */ 489 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 490 .num_rbds = IWL_NUM_RBDS_NON_HE, 491 }; 492 493 const struct iwl_cfg iwl9560_2ac_cfg_quz_a0_jf_b0_soc = { 494 .name = "Intel(R) Wireless-AC 9560 160MHz", 495 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 496 IWL_DEVICE_22500, 497 /* 498 * This device doesn't support receiving BlockAck with a large bitmap 499 * so we need to restrict the size of transmitted aggregation to the 500 * HT size; mac80211 would otherwise pick the HE max (256) by default. 501 */ 502 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 503 .integrated = true, 504 .soc_latency = 5000, 505 .num_rbds = IWL_NUM_RBDS_NON_HE, 506 }; 507 508 const struct iwl_cfg iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc = { 509 .name = "Intel(R) Wireless-AC 9560 160MHz", 510 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 511 IWL_DEVICE_22500, 512 /* 513 * This device doesn't support receiving BlockAck with a large bitmap 514 * so we need to restrict the size of transmitted aggregation to the 515 * HT size; mac80211 would otherwise pick the HE max (256) by default. 516 */ 517 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 518 .integrated = true, 519 .soc_latency = 5000, 520 .num_rbds = IWL_NUM_RBDS_NON_HE, 521 }; 522 523 const struct iwl_cfg iwl9461_2ac_cfg_quz_a0_jf_b0_soc = { 524 .name = "Intel(R) Dual Band Wireless AC 9461", 525 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 526 IWL_DEVICE_22500, 527 /* 528 * This device doesn't support receiving BlockAck with a large bitmap 529 * so we need to restrict the size of transmitted aggregation to the 530 * HT size; mac80211 would otherwise pick the HE max (256) by default. 531 */ 532 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 533 .integrated = true, 534 .soc_latency = 5000, 535 .num_rbds = IWL_NUM_RBDS_NON_HE, 536 }; 537 538 const struct iwl_cfg iwl9462_2ac_cfg_quz_a0_jf_b0_soc = { 539 .name = "Intel(R) Dual Band Wireless AC 9462", 540 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 541 IWL_DEVICE_22500, 542 /* 543 * This device doesn't support receiving BlockAck with a large bitmap 544 * so we need to restrict the size of transmitted aggregation to the 545 * HT size; mac80211 would otherwise pick the HE max (256) by default. 546 */ 547 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 548 .integrated = true, 549 .soc_latency = 5000, 550 .num_rbds = IWL_NUM_RBDS_NON_HE, 551 }; 552 553 const struct iwl_cfg iwl9560_killer_s_2ac_cfg_quz_a0_jf_b0_soc = { 554 .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)", 555 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 556 IWL_DEVICE_22500, 557 /* 558 * This device doesn't support receiving BlockAck with a large bitmap 559 * so we need to restrict the size of transmitted aggregation to the 560 * HT size; mac80211 would otherwise pick the HE max (256) by default. 561 */ 562 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 563 .integrated = true, 564 .soc_latency = 5000, 565 .num_rbds = IWL_NUM_RBDS_NON_HE, 566 }; 567 568 const struct iwl_cfg iwl9560_killer_i_2ac_cfg_quz_a0_jf_b0_soc = { 569 .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)", 570 .fw_name_pre = IWL_QUZ_A_JF_B_FW_PRE, 571 IWL_DEVICE_22500, 572 /* 573 * This device doesn't support receiving BlockAck with a large bitmap 574 * so we need to restrict the size of transmitted aggregation to the 575 * HT size; mac80211 would otherwise pick the HE max (256) by default. 576 */ 577 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 578 .integrated = true, 579 .soc_latency = 5000, 580 .num_rbds = IWL_NUM_RBDS_NON_HE, 581 }; 582 583 const struct iwl_cfg killer1550i_2ac_cfg_qu_b0_jf_b0 = { 584 .name = "Killer (R) Wireless-AC 1550i Wireless Network Adapter (9560NGW)", 585 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 586 IWL_DEVICE_22500, 587 .num_rbds = IWL_NUM_RBDS_NON_HE, 588 }; 589 590 const struct iwl_cfg killer1550s_2ac_cfg_qu_b0_jf_b0 = { 591 .name = "Killer (R) Wireless-AC 1550s Wireless Network Adapter (9560NGW)", 592 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 593 IWL_DEVICE_22500, 594 .num_rbds = IWL_NUM_RBDS_NON_HE, 595 }; 596 597 const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = { 598 .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)", 599 .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, 600 IWL_DEVICE_22500, 601 /* 602 * This device doesn't support receiving BlockAck with a large bitmap 603 * so we need to restrict the size of transmitted aggregation to the 604 * HT size; mac80211 would otherwise pick the HE max (256) by default. 605 */ 606 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 607 .num_rbds = IWL_NUM_RBDS_22000_HE, 608 }; 609 610 const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = { 611 .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)", 612 .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, 613 IWL_DEVICE_22500, 614 /* 615 * This device doesn't support receiving BlockAck with a large bitmap 616 * so we need to restrict the size of transmitted aggregation to the 617 * HT size; mac80211 would otherwise pick the HE max (256) by default. 618 */ 619 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 620 .num_rbds = IWL_NUM_RBDS_22000_HE, 621 }; 622 623 const struct iwl_cfg killer1650s_2ax_cfg_qu_c0_hr_b0 = { 624 .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)", 625 .fw_name_pre = IWL_QU_C_HR_B_FW_PRE, 626 IWL_DEVICE_22500, 627 /* 628 * This device doesn't support receiving BlockAck with a large bitmap 629 * so we need to restrict the size of transmitted aggregation to the 630 * HT size; mac80211 would otherwise pick the HE max (256) by default. 631 */ 632 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 633 .num_rbds = IWL_NUM_RBDS_22000_HE, 634 }; 635 636 const struct iwl_cfg killer1650i_2ax_cfg_qu_c0_hr_b0 = { 637 .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)", 638 .fw_name_pre = IWL_QU_C_HR_B_FW_PRE, 639 IWL_DEVICE_22500, 640 /* 641 * This device doesn't support receiving BlockAck with a large bitmap 642 * so we need to restrict the size of transmitted aggregation to the 643 * HT size; mac80211 would otherwise pick the HE max (256) by default. 644 */ 645 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 646 .num_rbds = IWL_NUM_RBDS_22000_HE, 647 }; 648 649 const struct iwl_cfg iwl22000_2ax_cfg_jf = { 650 .name = "Intel(R) Dual Band Wireless AX 22000", 651 .fw_name_pre = IWL_QU_B_JF_B_FW_PRE, 652 IWL_DEVICE_22500, 653 /* 654 * This device doesn't support receiving BlockAck with a large bitmap 655 * so we need to restrict the size of transmitted aggregation to the 656 * HT size; mac80211 would otherwise pick the HE max (256) by default. 657 */ 658 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 659 .num_rbds = IWL_NUM_RBDS_22000_HE, 660 }; 661 662 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0_f0 = { 663 .name = "Intel(R) Dual Band Wireless AX 22000", 664 .fw_name_pre = IWL_22000_HR_A_F0_FW_PRE, 665 IWL_DEVICE_22500, 666 /* 667 * This device doesn't support receiving BlockAck with a large bitmap 668 * so we need to restrict the size of transmitted aggregation to the 669 * HT size; mac80211 would otherwise pick the HE max (256) by default. 670 */ 671 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 672 .num_rbds = IWL_NUM_RBDS_22000_HE, 673 }; 674 675 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_b0 = { 676 .name = "Intel(R) Dual Band Wireless AX 22000", 677 .fw_name_pre = IWL_22000_HR_B_FW_PRE, 678 IWL_DEVICE_22500, 679 /* 680 * This device doesn't support receiving BlockAck with a large bitmap 681 * so we need to restrict the size of transmitted aggregation to the 682 * HT size; mac80211 would otherwise pick the HE max (256) by default. 683 */ 684 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 685 .num_rbds = IWL_NUM_RBDS_22000_HE, 686 }; 687 688 const struct iwl_cfg iwl22000_2ax_cfg_qnj_hr_a0 = { 689 .name = "Intel(R) Dual Band Wireless AX 22000", 690 .fw_name_pre = IWL_22000_HR_A0_FW_PRE, 691 IWL_DEVICE_22500, 692 /* 693 * This device doesn't support receiving BlockAck with a large bitmap 694 * so we need to restrict the size of transmitted aggregation to the 695 * HT size; mac80211 would otherwise pick the HE max (256) by default. 696 */ 697 .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, 698 .num_rbds = IWL_NUM_RBDS_22000_HE, 699 }; 700 701 const struct iwl_cfg iwlax210_2ax_cfg_so_jf_a0 = { 702 .name = "Intel(R) Wireless-AC 9560 160MHz", 703 .fw_name_pre = IWL_22000_SO_A_JF_B_FW_PRE, 704 IWL_DEVICE_AX210, 705 .num_rbds = IWL_NUM_RBDS_NON_HE, 706 }; 707 708 const struct iwl_cfg iwlax210_2ax_cfg_so_hr_a0 = { 709 .name = "Intel(R) Wi-Fi 7 AX210 160MHz", 710 .fw_name_pre = IWL_22000_SO_A_HR_B_FW_PRE, 711 IWL_DEVICE_AX210, 712 .num_rbds = IWL_NUM_RBDS_AX210_HE, 713 }; 714 715 const struct iwl_cfg iwlax211_2ax_cfg_so_gf_a0 = { 716 .name = "Intel(R) Wi-Fi 7 AX211 160MHz", 717 .fw_name_pre = IWL_22000_SO_A_GF_A_FW_PRE, 718 .uhb_supported = true, 719 IWL_DEVICE_AX210, 720 .num_rbds = IWL_NUM_RBDS_AX210_HE, 721 }; 722 723 const struct iwl_cfg iwlax210_2ax_cfg_ty_gf_a0 = { 724 .name = "Intel(R) Wi-Fi 7 AX210 160MHz", 725 .fw_name_pre = IWL_22000_TY_A_GF_A_FW_PRE, 726 .uhb_supported = true, 727 IWL_DEVICE_AX210, 728 .num_rbds = IWL_NUM_RBDS_AX210_HE, 729 }; 730 731 const struct iwl_cfg iwlax411_2ax_cfg_so_gf4_a0 = { 732 .name = "Intel(R) Wi-Fi 7 AX411 160MHz", 733 .fw_name_pre = IWL_22000_SO_A_GF4_A_FW_PRE, 734 IWL_DEVICE_AX210, 735 .num_rbds = IWL_NUM_RBDS_AX210_HE, 736 }; 737 738 MODULE_FIRMWARE(IWL_22000_HR_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 739 MODULE_FIRMWARE(IWL_22000_JF_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 740 MODULE_FIRMWARE(IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 741 MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 742 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 743 MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 744 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 745 MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 746 MODULE_FIRMWARE(IWL_QUZ_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 747 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 748 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 749 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 750 MODULE_FIRMWARE(IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 751 MODULE_FIRMWARE(IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 752 MODULE_FIRMWARE(IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); 753