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 iwl22000_2ax_cfg_jf = {
560 	.name = "Intel(R) Dual Band Wireless AX 22000",
561 	.fw_name_pre = IWL_QU_B_JF_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 iwl22000_2ax_cfg_qnj_hr_a0_f0 = {
572 	.name = "Intel(R) Dual Band Wireless AX 22000",
573 	.fw_name_pre = IWL_22000_HR_A_F0_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_qnj_hr_b0 = {
584 	.name = "Intel(R) Dual Band Wireless AX 22000",
585 	.fw_name_pre = IWL_22000_HR_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 = {
596 	.name = "Intel(R) Dual Band Wireless AX 22000",
597 	.fw_name_pre = IWL_22000_HR_A0_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 iwlax210_2ax_cfg_so_jf_a0 = {
608 	.name = "Intel(R) Wireless-AC 9560 160MHz",
609 	.fw_name_pre = IWL_22000_SO_A_JF_B_FW_PRE,
610 	IWL_DEVICE_AX210,
611 };
612 
613 const struct iwl_cfg iwlax210_2ax_cfg_so_hr_a0 = {
614 	.name = "Intel(R) Wi-Fi 7 AX210 160MHz",
615 	.fw_name_pre = IWL_22000_SO_A_HR_B_FW_PRE,
616 	IWL_DEVICE_AX210,
617 };
618 
619 const struct iwl_cfg iwlax211_2ax_cfg_so_gf_a0 = {
620 	.name = "Intel(R) Wi-Fi 7 AX211 160MHz",
621 	.fw_name_pre = IWL_22000_SO_A_GF_A_FW_PRE,
622 	.uhb_supported = true,
623 	IWL_DEVICE_AX210,
624 };
625 
626 const struct iwl_cfg iwlax210_2ax_cfg_ty_gf_a0 = {
627 	.name = "Intel(R) Wi-Fi 7 AX210 160MHz",
628 	.fw_name_pre = IWL_22000_TY_A_GF_A_FW_PRE,
629 	.uhb_supported = true,
630 	IWL_DEVICE_AX210,
631 };
632 
633 const struct iwl_cfg iwlax411_2ax_cfg_so_gf4_a0 = {
634 	.name = "Intel(R) Wi-Fi 7 AX411 160MHz",
635 	.fw_name_pre = IWL_22000_SO_A_GF4_A_FW_PRE,
636 	IWL_DEVICE_AX210,
637 };
638 
639 MODULE_FIRMWARE(IWL_22000_HR_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
640 MODULE_FIRMWARE(IWL_22000_JF_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
641 MODULE_FIRMWARE(IWL_22000_HR_A_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
642 MODULE_FIRMWARE(IWL_22000_HR_B_F0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
643 MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
644 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
645 MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
646 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
647 MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
648 MODULE_FIRMWARE(IWL_QUZ_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
649 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
650 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
651 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
652 MODULE_FIRMWARE(IWL_22000_SO_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
653 MODULE_FIRMWARE(IWL_22000_SO_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
654 MODULE_FIRMWARE(IWL_22000_TY_A_GF_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
655