1 /******************************************************************************
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.
8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
11 * Copyright(c) 2018 - 2019 Intel Corporation
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of version 2 of the GNU General Public License as
15 * published by the Free Software Foundation.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * The full GNU General Public License is included in this distribution
23 * in the file called COPYING.
25 * Contact Information:
26 * Intel Linux Wireless <linuxwifi@intel.com>
27 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
32 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
33 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
34 * Copyright(c) 2018 - 2019 Intel Corporation
35 * All rights reserved.
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
41 * * Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * * Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in
45 * the documentation and/or other materials provided with the
47 * * Neither the name Intel Corporation nor the names of its
48 * contributors may be used to endorse or promote products derived
49 * from this software without specific prior written permission.
51 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
52 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
53 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
54 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
55 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
56 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
57 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
61 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *****************************************************************************/
64 #include <net/mac80211.h>
65 #include <linux/netdevice.h>
67 #include "iwl-trans.h"
68 #include "iwl-op-mode.h"
70 #include "iwl-debug.h"
71 #include "iwl-csr.h" /* for iwl_mvm_rx_card_state_notif */
72 #include "iwl-io.h" /* for iwl_mvm_rx_card_state_notif */
78 #include "iwl-phy-db.h"
79 #include "iwl-modparams.h"
80 #include "iwl-nvm-parse.h"
82 #define MVM_UCODE_ALIVE_TIMEOUT HZ
83 #define MVM_UCODE_CALIB_TIMEOUT (2*HZ)
85 #define UCODE_VALID_OK cpu_to_le32(0x1)
87 struct iwl_mvm_alive_data
{
92 static int iwl_send_tx_ant_cfg(struct iwl_mvm
*mvm
, u8 valid_tx_ant
)
94 struct iwl_tx_ant_cfg_cmd tx_ant_cmd
= {
95 .valid
= cpu_to_le32(valid_tx_ant
),
98 IWL_DEBUG_FW(mvm
, "select valid tx ant: %u\n", valid_tx_ant
);
99 return iwl_mvm_send_cmd_pdu(mvm
, TX_ANT_CONFIGURATION_CMD
, 0,
100 sizeof(tx_ant_cmd
), &tx_ant_cmd
);
103 static int iwl_send_rss_cfg_cmd(struct iwl_mvm
*mvm
)
106 struct iwl_rss_config_cmd cmd
= {
107 .flags
= cpu_to_le32(IWL_RSS_ENABLE
),
108 .hash_mask
= BIT(IWL_RSS_HASH_TYPE_IPV4_TCP
) |
109 BIT(IWL_RSS_HASH_TYPE_IPV4_UDP
) |
110 BIT(IWL_RSS_HASH_TYPE_IPV4_PAYLOAD
) |
111 BIT(IWL_RSS_HASH_TYPE_IPV6_TCP
) |
112 BIT(IWL_RSS_HASH_TYPE_IPV6_UDP
) |
113 BIT(IWL_RSS_HASH_TYPE_IPV6_PAYLOAD
),
116 if (mvm
->trans
->num_rx_queues
== 1)
119 /* Do not direct RSS traffic to Q 0 which is our fallback queue */
120 for (i
= 0; i
< ARRAY_SIZE(cmd
.indirection_table
); i
++)
121 cmd
.indirection_table
[i
] =
122 1 + (i
% (mvm
->trans
->num_rx_queues
- 1));
123 netdev_rss_key_fill(cmd
.secret_key
, sizeof(cmd
.secret_key
));
125 return iwl_mvm_send_cmd_pdu(mvm
, RSS_CONFIG_CMD
, 0, sizeof(cmd
), &cmd
);
128 static int iwl_configure_rxq(struct iwl_mvm
*mvm
)
130 int i
, num_queues
, size
, ret
;
131 struct iwl_rfh_queue_config
*cmd
;
132 struct iwl_host_cmd hcmd
= {
133 .id
= WIDE_ID(DATA_PATH_GROUP
, RFH_QUEUE_CONFIG_CMD
),
134 .dataflags
[0] = IWL_HCMD_DFL_NOCOPY
,
137 /* Do not configure default queue, it is configured via context info */
138 num_queues
= mvm
->trans
->num_rx_queues
- 1;
140 size
= struct_size(cmd
, data
, num_queues
);
142 cmd
= kzalloc(size
, GFP_KERNEL
);
146 cmd
->num_queues
= num_queues
;
148 for (i
= 0; i
< num_queues
; i
++) {
149 struct iwl_trans_rxq_dma_data data
;
151 cmd
->data
[i
].q_num
= i
+ 1;
152 iwl_trans_get_rxq_dma_data(mvm
->trans
, i
+ 1, &data
);
154 cmd
->data
[i
].fr_bd_cb
= cpu_to_le64(data
.fr_bd_cb
);
155 cmd
->data
[i
].urbd_stts_wrptr
=
156 cpu_to_le64(data
.urbd_stts_wrptr
);
157 cmd
->data
[i
].ur_bd_cb
= cpu_to_le64(data
.ur_bd_cb
);
158 cmd
->data
[i
].fr_bd_wid
= cpu_to_le32(data
.fr_bd_wid
);
164 ret
= iwl_mvm_send_cmd(mvm
, &hcmd
);
171 static int iwl_mvm_send_dqa_cmd(struct iwl_mvm
*mvm
)
173 struct iwl_dqa_enable_cmd dqa_cmd
= {
174 .cmd_queue
= cpu_to_le32(IWL_MVM_DQA_CMD_QUEUE
),
176 u32 cmd_id
= iwl_cmd_id(DQA_ENABLE_CMD
, DATA_PATH_GROUP
, 0);
179 ret
= iwl_mvm_send_cmd_pdu(mvm
, cmd_id
, 0, sizeof(dqa_cmd
), &dqa_cmd
);
181 IWL_ERR(mvm
, "Failed to send DQA enabling command: %d\n", ret
);
183 IWL_DEBUG_FW(mvm
, "Working in DQA mode\n");
188 void iwl_mvm_mfu_assert_dump_notif(struct iwl_mvm
*mvm
,
189 struct iwl_rx_cmd_buffer
*rxb
)
191 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
192 struct iwl_mfu_assert_dump_notif
*mfu_dump_notif
= (void *)pkt
->data
;
193 __le32
*dump_data
= mfu_dump_notif
->data
;
194 int n_words
= le32_to_cpu(mfu_dump_notif
->data_size
) / sizeof(__le32
);
197 if (mfu_dump_notif
->index_num
== 0)
198 IWL_INFO(mvm
, "MFUART assert id 0x%x occurred\n",
199 le32_to_cpu(mfu_dump_notif
->assert_id
));
201 for (i
= 0; i
< n_words
; i
++)
203 "MFUART assert dump, dword %u: 0x%08x\n",
204 le16_to_cpu(mfu_dump_notif
->index_num
) *
206 le32_to_cpu(dump_data
[i
]));
209 static bool iwl_alive_fn(struct iwl_notif_wait_data
*notif_wait
,
210 struct iwl_rx_packet
*pkt
, void *data
)
212 struct iwl_mvm
*mvm
=
213 container_of(notif_wait
, struct iwl_mvm
, notif_wait
);
214 struct iwl_mvm_alive_data
*alive_data
= data
;
215 struct mvm_alive_resp_v3
*palive3
;
216 struct mvm_alive_resp
*palive
;
217 struct iwl_umac_alive
*umac
;
218 struct iwl_lmac_alive
*lmac1
;
219 struct iwl_lmac_alive
*lmac2
= NULL
;
221 u32 lmac_error_event_table
, umac_error_event_table
;
223 if (iwl_rx_packet_payload_len(pkt
) == sizeof(*palive
)) {
224 palive
= (void *)pkt
->data
;
225 umac
= &palive
->umac_data
;
226 lmac1
= &palive
->lmac_data
[0];
227 lmac2
= &palive
->lmac_data
[1];
228 status
= le16_to_cpu(palive
->status
);
230 palive3
= (void *)pkt
->data
;
231 umac
= &palive3
->umac_data
;
232 lmac1
= &palive3
->lmac_data
;
233 status
= le16_to_cpu(palive3
->status
);
236 lmac_error_event_table
=
237 le32_to_cpu(lmac1
->dbg_ptrs
.error_event_table_ptr
);
238 iwl_fw_lmac1_set_alive_err_table(mvm
->trans
, lmac_error_event_table
);
241 mvm
->trans
->dbg
.lmac_error_event_table
[1] =
242 le32_to_cpu(lmac2
->dbg_ptrs
.error_event_table_ptr
);
244 umac_error_event_table
= le32_to_cpu(umac
->dbg_ptrs
.error_info_addr
);
246 if (!umac_error_event_table
) {
247 mvm
->support_umac_log
= false;
248 } else if (umac_error_event_table
>=
249 mvm
->trans
->cfg
->min_umac_error_event_table
) {
250 mvm
->support_umac_log
= true;
253 "Not valid error log pointer 0x%08X for %s uCode\n",
254 umac_error_event_table
,
255 (mvm
->fwrt
.cur_fw_img
== IWL_UCODE_INIT
) ?
257 mvm
->support_umac_log
= false;
260 if (mvm
->support_umac_log
)
261 iwl_fw_umac_set_alive_err_table(mvm
->trans
,
262 umac_error_event_table
);
264 alive_data
->scd_base_addr
= le32_to_cpu(lmac1
->dbg_ptrs
.scd_base_ptr
);
265 alive_data
->valid
= status
== IWL_ALIVE_STATUS_OK
;
268 "Alive ucode status 0x%04x revision 0x%01X 0x%01X\n",
269 status
, lmac1
->ver_type
, lmac1
->ver_subtype
);
272 IWL_DEBUG_FW(mvm
, "Alive ucode CDB\n");
275 "UMAC version: Major - 0x%x, Minor - 0x%x\n",
276 le32_to_cpu(umac
->umac_major
),
277 le32_to_cpu(umac
->umac_minor
));
279 iwl_fwrt_update_fw_versions(&mvm
->fwrt
, lmac1
, umac
);
284 static bool iwl_wait_init_complete(struct iwl_notif_wait_data
*notif_wait
,
285 struct iwl_rx_packet
*pkt
, void *data
)
287 WARN_ON(pkt
->hdr
.cmd
!= INIT_COMPLETE_NOTIF
);
292 static bool iwl_wait_phy_db_entry(struct iwl_notif_wait_data
*notif_wait
,
293 struct iwl_rx_packet
*pkt
, void *data
)
295 struct iwl_phy_db
*phy_db
= data
;
297 if (pkt
->hdr
.cmd
!= CALIB_RES_NOTIF_PHY_DB
) {
298 WARN_ON(pkt
->hdr
.cmd
!= INIT_COMPLETE_NOTIF
);
302 WARN_ON(iwl_phy_db_set_section(phy_db
, pkt
));
307 static int iwl_mvm_load_ucode_wait_alive(struct iwl_mvm
*mvm
,
308 enum iwl_ucode_type ucode_type
)
310 struct iwl_notification_wait alive_wait
;
311 struct iwl_mvm_alive_data alive_data
= {};
312 const struct fw_img
*fw
;
314 enum iwl_ucode_type old_type
= mvm
->fwrt
.cur_fw_img
;
315 static const u16 alive_cmd
[] = { MVM_ALIVE
};
317 ucode_type
== IWL_UCODE_INIT
|| iwl_mvm_has_unified_ucode(mvm
);
319 if (ucode_type
== IWL_UCODE_REGULAR
&&
320 iwl_fw_dbg_conf_usniffer(mvm
->fw
, FW_DBG_START_FROM_ALIVE
) &&
321 !(fw_has_capa(&mvm
->fw
->ucode_capa
,
322 IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED
)))
323 fw
= iwl_get_ucode_image(mvm
->fw
, IWL_UCODE_REGULAR_USNIFFER
);
325 fw
= iwl_get_ucode_image(mvm
->fw
, ucode_type
);
328 iwl_fw_set_current_image(&mvm
->fwrt
, ucode_type
);
329 clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING
, &mvm
->status
);
331 iwl_init_notification_wait(&mvm
->notif_wait
, &alive_wait
,
332 alive_cmd
, ARRAY_SIZE(alive_cmd
),
333 iwl_alive_fn
, &alive_data
);
336 * We want to load the INIT firmware even in RFKILL
337 * For the unified firmware case, the ucode_type is not
338 * INIT, but we still need to run it.
340 ret
= iwl_trans_start_fw(mvm
->trans
, fw
, run_in_rfkill
);
342 iwl_fw_set_current_image(&mvm
->fwrt
, old_type
);
343 iwl_remove_notification(&mvm
->notif_wait
, &alive_wait
);
348 * Some things may run in the background now, but we
349 * just wait for the ALIVE notification here.
351 ret
= iwl_wait_notification(&mvm
->notif_wait
, &alive_wait
,
352 MVM_UCODE_ALIVE_TIMEOUT
);
354 struct iwl_trans
*trans
= mvm
->trans
;
356 if (ret
== -ETIMEDOUT
)
357 iwl_fw_dbg_error_collect(&mvm
->fwrt
,
358 FW_DBG_TRIGGER_ALIVE_TIMEOUT
);
360 if (trans
->trans_cfg
->device_family
>= IWL_DEVICE_FAMILY_22000
)
362 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
363 iwl_read_umac_prph(trans
, UMAG_SB_CPU_1_STATUS
),
364 iwl_read_umac_prph(trans
,
365 UMAG_SB_CPU_2_STATUS
));
366 else if (trans
->trans_cfg
->device_family
>=
367 IWL_DEVICE_FAMILY_8000
)
369 "SecBoot CPU1 Status: 0x%x, CPU2 Status: 0x%x\n",
370 iwl_read_prph(trans
, SB_CPU_1_STATUS
),
371 iwl_read_prph(trans
, SB_CPU_2_STATUS
));
372 iwl_fw_set_current_image(&mvm
->fwrt
, old_type
);
376 if (!alive_data
.valid
) {
377 IWL_ERR(mvm
, "Loaded ucode is not valid!\n");
378 iwl_fw_set_current_image(&mvm
->fwrt
, old_type
);
382 iwl_trans_fw_alive(mvm
->trans
, alive_data
.scd_base_addr
);
385 * Note: all the queues are enabled as part of the interface
386 * initialization, but in firmware restart scenarios they
387 * could be stopped, so wake them up. In firmware restart,
388 * mac80211 will have the queues stopped as well until the
389 * reconfiguration completes. During normal startup, they
393 memset(&mvm
->queue_info
, 0, sizeof(mvm
->queue_info
));
395 * Set a 'fake' TID for the command queue, since we use the
396 * hweight() of the tid_bitmap as a refcount now. Not that
397 * we ever even consider the command queue as one we might
398 * want to reuse, but be safe nevertheless.
400 mvm
->queue_info
[IWL_MVM_DQA_CMD_QUEUE
].tid_bitmap
=
401 BIT(IWL_MAX_TID_COUNT
+ 2);
403 set_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING
, &mvm
->status
);
404 #ifdef CONFIG_IWLWIFI_DEBUGFS
405 iwl_fw_set_dbg_rec_on(&mvm
->fwrt
);
411 static int iwl_run_unified_mvm_ucode(struct iwl_mvm
*mvm
, bool read_nvm
)
413 struct iwl_notification_wait init_wait
;
414 struct iwl_nvm_access_complete_cmd nvm_complete
= {};
415 struct iwl_init_extended_cfg_cmd init_cfg
= {
416 .init_flags
= cpu_to_le32(BIT(IWL_INIT_NVM
)),
418 static const u16 init_complete
[] = {
423 if (mvm
->trans
->cfg
->tx_with_siso_diversity
)
424 init_cfg
.init_flags
|= cpu_to_le32(BIT(IWL_INIT_PHY
));
426 lockdep_assert_held(&mvm
->mutex
);
428 mvm
->rfkill_safe_init_done
= false;
430 iwl_init_notification_wait(&mvm
->notif_wait
,
433 ARRAY_SIZE(init_complete
),
434 iwl_wait_init_complete
,
437 iwl_dbg_tlv_time_point(&mvm
->fwrt
, IWL_FW_INI_TIME_POINT_EARLY
, NULL
);
439 /* Will also start the device */
440 ret
= iwl_mvm_load_ucode_wait_alive(mvm
, IWL_UCODE_REGULAR
);
442 IWL_ERR(mvm
, "Failed to start RT ucode: %d\n", ret
);
445 iwl_dbg_tlv_time_point(&mvm
->fwrt
, IWL_FW_INI_TIME_POINT_AFTER_ALIVE
,
448 /* Send init config command to mark that we are sending NVM access
451 ret
= iwl_mvm_send_cmd_pdu(mvm
, WIDE_ID(SYSTEM_GROUP
,
452 INIT_EXTENDED_CFG_CMD
),
454 sizeof(init_cfg
), &init_cfg
);
456 IWL_ERR(mvm
, "Failed to run init config command: %d\n",
461 /* Load NVM to NIC if needed */
462 if (mvm
->nvm_file_name
) {
463 iwl_read_external_nvm(mvm
->trans
, mvm
->nvm_file_name
,
465 iwl_mvm_load_nvm_to_nic(mvm
);
468 if (IWL_MVM_PARSE_NVM
&& read_nvm
) {
469 ret
= iwl_nvm_init(mvm
);
471 IWL_ERR(mvm
, "Failed to read NVM: %d\n", ret
);
476 ret
= iwl_mvm_send_cmd_pdu(mvm
, WIDE_ID(REGULATORY_AND_NVM_GROUP
,
477 NVM_ACCESS_COMPLETE
),
479 sizeof(nvm_complete
), &nvm_complete
);
481 IWL_ERR(mvm
, "Failed to run complete NVM access: %d\n",
486 /* We wait for the INIT complete notification */
487 ret
= iwl_wait_notification(&mvm
->notif_wait
, &init_wait
,
488 MVM_UCODE_ALIVE_TIMEOUT
);
492 /* Read the NVM only at driver load time, no need to do this twice */
493 if (!IWL_MVM_PARSE_NVM
&& read_nvm
) {
494 mvm
->nvm_data
= iwl_get_nvm(mvm
->trans
, mvm
->fw
);
495 if (IS_ERR(mvm
->nvm_data
)) {
496 ret
= PTR_ERR(mvm
->nvm_data
);
497 mvm
->nvm_data
= NULL
;
498 IWL_ERR(mvm
, "Failed to read NVM: %d\n", ret
);
503 mvm
->rfkill_safe_init_done
= true;
508 iwl_remove_notification(&mvm
->notif_wait
, &init_wait
);
512 static int iwl_send_phy_cfg_cmd(struct iwl_mvm
*mvm
)
514 struct iwl_phy_cfg_cmd phy_cfg_cmd
;
515 enum iwl_ucode_type ucode_type
= mvm
->fwrt
.cur_fw_img
;
517 if (iwl_mvm_has_unified_ucode(mvm
) &&
518 !mvm
->trans
->cfg
->tx_with_siso_diversity
)
521 if (mvm
->trans
->cfg
->tx_with_siso_diversity
) {
523 * TODO: currently we don't set the antenna but letting the NIC
524 * to decide which antenna to use. This should come from BIOS.
526 phy_cfg_cmd
.phy_cfg
=
527 cpu_to_le32(FW_PHY_CFG_CHAIN_SAD_ENABLED
);
531 phy_cfg_cmd
.phy_cfg
= cpu_to_le32(iwl_mvm_get_phy_config(mvm
));
533 /* set flags extra PHY configuration flags from the device's cfg */
534 phy_cfg_cmd
.phy_cfg
|= cpu_to_le32(mvm
->cfg
->extra_phy_cfg_flags
);
536 phy_cfg_cmd
.calib_control
.event_trigger
=
537 mvm
->fw
->default_calib
[ucode_type
].event_trigger
;
538 phy_cfg_cmd
.calib_control
.flow_trigger
=
539 mvm
->fw
->default_calib
[ucode_type
].flow_trigger
;
541 IWL_DEBUG_INFO(mvm
, "Sending Phy CFG command: 0x%x\n",
542 phy_cfg_cmd
.phy_cfg
);
544 return iwl_mvm_send_cmd_pdu(mvm
, PHY_CONFIGURATION_CMD
, 0,
545 sizeof(phy_cfg_cmd
), &phy_cfg_cmd
);
548 int iwl_run_init_mvm_ucode(struct iwl_mvm
*mvm
, bool read_nvm
)
550 struct iwl_notification_wait calib_wait
;
551 static const u16 init_complete
[] = {
553 CALIB_RES_NOTIF_PHY_DB
557 if (iwl_mvm_has_unified_ucode(mvm
))
558 return iwl_run_unified_mvm_ucode(mvm
, true);
560 lockdep_assert_held(&mvm
->mutex
);
562 mvm
->rfkill_safe_init_done
= false;
564 iwl_init_notification_wait(&mvm
->notif_wait
,
567 ARRAY_SIZE(init_complete
),
568 iwl_wait_phy_db_entry
,
571 /* Will also start the device */
572 ret
= iwl_mvm_load_ucode_wait_alive(mvm
, IWL_UCODE_INIT
);
574 IWL_ERR(mvm
, "Failed to start INIT ucode: %d\n", ret
);
578 if (mvm
->trans
->trans_cfg
->device_family
< IWL_DEVICE_FAMILY_8000
) {
579 ret
= iwl_mvm_send_bt_init_conf(mvm
);
584 /* Read the NVM only at driver load time, no need to do this twice */
586 ret
= iwl_nvm_init(mvm
);
588 IWL_ERR(mvm
, "Failed to read NVM: %d\n", ret
);
593 /* In case we read the NVM from external file, load it to the NIC */
594 if (mvm
->nvm_file_name
)
595 iwl_mvm_load_nvm_to_nic(mvm
);
597 WARN_ONCE(mvm
->nvm_data
->nvm_version
< mvm
->trans
->cfg
->nvm_ver
,
598 "Too old NVM version (0x%0x, required = 0x%0x)",
599 mvm
->nvm_data
->nvm_version
, mvm
->trans
->cfg
->nvm_ver
);
602 * abort after reading the nvm in case RF Kill is on, we will complete
603 * the init seq later when RF kill will switch to off
605 if (iwl_mvm_is_radio_hw_killed(mvm
)) {
606 IWL_DEBUG_RF_KILL(mvm
,
607 "jump over all phy activities due to RF kill\n");
611 mvm
->rfkill_safe_init_done
= true;
613 /* Send TX valid antennas before triggering calibrations */
614 ret
= iwl_send_tx_ant_cfg(mvm
, iwl_mvm_get_valid_tx_ant(mvm
));
618 ret
= iwl_send_phy_cfg_cmd(mvm
);
620 IWL_ERR(mvm
, "Failed to run INIT calibrations: %d\n",
626 * Some things may run in the background now, but we
627 * just wait for the calibration complete notification.
629 ret
= iwl_wait_notification(&mvm
->notif_wait
, &calib_wait
,
630 MVM_UCODE_CALIB_TIMEOUT
);
634 if (iwl_mvm_is_radio_hw_killed(mvm
)) {
635 IWL_DEBUG_RF_KILL(mvm
, "RFKILL while calibrating.\n");
638 IWL_ERR(mvm
, "Failed to run INIT calibrations: %d\n",
645 iwl_remove_notification(&mvm
->notif_wait
, &calib_wait
);
647 mvm
->rfkill_safe_init_done
= false;
648 if (iwlmvm_mod_params
.init_dbg
&& !mvm
->nvm_data
) {
649 /* we want to debug INIT and we have no NVM - fake */
650 mvm
->nvm_data
= kzalloc(sizeof(struct iwl_nvm_data
) +
651 sizeof(struct ieee80211_channel
) +
652 sizeof(struct ieee80211_rate
),
656 mvm
->nvm_data
->bands
[0].channels
= mvm
->nvm_data
->channels
;
657 mvm
->nvm_data
->bands
[0].n_channels
= 1;
658 mvm
->nvm_data
->bands
[0].n_bitrates
= 1;
659 mvm
->nvm_data
->bands
[0].bitrates
=
660 (void *)mvm
->nvm_data
->channels
+ 1;
661 mvm
->nvm_data
->bands
[0].bitrates
->hw_value
= 10;
667 static int iwl_mvm_config_ltr(struct iwl_mvm
*mvm
)
669 struct iwl_ltr_config_cmd cmd
= {
670 .flags
= cpu_to_le32(LTR_CFG_FLAG_FEATURE_ENABLE
),
673 if (!mvm
->trans
->ltr_enabled
)
676 return iwl_mvm_send_cmd_pdu(mvm
, LTR_CONFIG
, 0,
681 int iwl_mvm_sar_select_profile(struct iwl_mvm
*mvm
, int prof_a
, int prof_b
)
684 struct iwl_dev_tx_power_cmd v5
;
685 struct iwl_dev_tx_power_cmd_v4 v4
;
690 cmd
.v5
.v3
.set_mode
= cpu_to_le32(IWL_TX_POWER_MODE_SET_CHAINS
);
692 if (fw_has_api(&mvm
->fw
->ucode_capa
,
693 IWL_UCODE_TLV_API_REDUCE_TX_POWER
))
694 len
= sizeof(cmd
.v5
);
695 else if (fw_has_capa(&mvm
->fw
->ucode_capa
,
696 IWL_UCODE_TLV_CAPA_TX_POWER_ACK
))
697 len
= sizeof(struct iwl_dev_tx_power_cmd_v4
);
699 len
= sizeof(cmd
.v4
.v3
);
702 if (iwl_sar_select_profile(&mvm
->fwrt
, cmd
.v5
.v3
.per_chain_restriction
,
705 IWL_DEBUG_RADIO(mvm
, "Sending REDUCE_TX_POWER_CMD per chain\n");
706 return iwl_mvm_send_cmd_pdu(mvm
, REDUCE_TX_POWER_CMD
, 0, len
, &cmd
);
709 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm
*mvm
)
711 union geo_tx_power_profiles_cmd geo_tx_cmd
;
714 struct iwl_host_cmd cmd
;
716 if (fw_has_api(&mvm
->fwrt
.fw
->ucode_capa
,
717 IWL_UCODE_TLV_API_SAR_TABLE_VER
)) {
718 geo_tx_cmd
.geo_cmd
.ops
=
719 cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE
);
720 len
= sizeof(geo_tx_cmd
.geo_cmd
);
722 geo_tx_cmd
.geo_cmd_v1
.ops
=
723 cpu_to_le32(IWL_PER_CHAIN_OFFSET_GET_CURRENT_TABLE
);
724 len
= sizeof(geo_tx_cmd
.geo_cmd_v1
);
727 if (!iwl_sar_geo_support(&mvm
->fwrt
))
730 cmd
= (struct iwl_host_cmd
){
731 .id
= WIDE_ID(PHY_OPS_GROUP
, GEO_TX_POWER_LIMIT
),
733 .flags
= CMD_WANT_SKB
,
734 .data
= { &geo_tx_cmd
},
737 ret
= iwl_mvm_send_cmd(mvm
, &cmd
);
739 IWL_ERR(mvm
, "Failed to get geographic profile info %d\n", ret
);
742 ret
= iwl_validate_sar_geo_profile(&mvm
->fwrt
, &cmd
);
747 static int iwl_mvm_sar_geo_init(struct iwl_mvm
*mvm
)
749 u16 cmd_wide_id
= WIDE_ID(PHY_OPS_GROUP
, GEO_TX_POWER_LIMIT
);
750 union geo_tx_power_profiles_cmd cmd
;
753 cmd
.geo_cmd
.ops
= cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES
);
755 iwl_sar_geo_init(&mvm
->fwrt
, cmd
.geo_cmd
.table
);
757 cmd
.geo_cmd
.table_revision
= cpu_to_le32(mvm
->fwrt
.geo_rev
);
759 if (!fw_has_api(&mvm
->fwrt
.fw
->ucode_capa
,
760 IWL_UCODE_TLV_API_SAR_TABLE_VER
)) {
761 len
= sizeof(struct iwl_geo_tx_power_profiles_cmd_v1
);
763 len
= sizeof(cmd
.geo_cmd
);
766 return iwl_mvm_send_cmd_pdu(mvm
, cmd_wide_id
, 0, len
, &cmd
);
769 static int iwl_mvm_get_ppag_table(struct iwl_mvm
*mvm
)
771 union acpi_object
*wifi_pkg
, *data
, *enabled
;
772 int i
, j
, ret
, tbl_rev
;
775 mvm
->fwrt
.ppag_table
.enabled
= cpu_to_le32(0);
776 data
= iwl_acpi_get_object(mvm
->dev
, ACPI_PPAG_METHOD
);
778 return PTR_ERR(data
);
780 wifi_pkg
= iwl_acpi_get_wifi_pkg(mvm
->dev
, data
,
781 ACPI_PPAG_WIFI_DATA_SIZE
, &tbl_rev
);
783 if (IS_ERR(wifi_pkg
)) {
784 ret
= PTR_ERR(wifi_pkg
);
793 enabled
= &wifi_pkg
->package
.elements
[1];
794 if (enabled
->type
!= ACPI_TYPE_INTEGER
||
795 (enabled
->integer
.value
!= 0 && enabled
->integer
.value
!= 1)) {
800 mvm
->fwrt
.ppag_table
.enabled
= cpu_to_le32(enabled
->integer
.value
);
801 if (!mvm
->fwrt
.ppag_table
.enabled
) {
807 * read, verify gain values and save them into the PPAG table.
808 * first sub-band (j=0) corresponds to Low-Band (2.4GHz), and the
809 * following sub-bands to High-Band (5GHz).
811 for (i
= 0; i
< ACPI_PPAG_NUM_CHAINS
; i
++) {
812 for (j
= 0; j
< ACPI_PPAG_NUM_SUB_BANDS
; j
++) {
813 union acpi_object
*ent
;
815 ent
= &wifi_pkg
->package
.elements
[idx
++];
816 if (ent
->type
!= ACPI_TYPE_INTEGER
||
817 (j
== 0 && ent
->integer
.value
> ACPI_PPAG_MAX_LB
) ||
818 (j
== 0 && ent
->integer
.value
< ACPI_PPAG_MIN_LB
) ||
819 (j
!= 0 && ent
->integer
.value
> ACPI_PPAG_MAX_HB
) ||
820 (j
!= 0 && ent
->integer
.value
< ACPI_PPAG_MIN_HB
)) {
821 mvm
->fwrt
.ppag_table
.enabled
= cpu_to_le32(0);
825 mvm
->fwrt
.ppag_table
.gain
[i
][j
] = ent
->integer
.value
;
834 int iwl_mvm_ppag_send_cmd(struct iwl_mvm
*mvm
)
838 if (!fw_has_capa(&mvm
->fw
->ucode_capa
, IWL_UCODE_TLV_CAPA_SET_PPAG
)) {
840 "PPAG capability not supported by FW, command not sent.\n");
844 IWL_DEBUG_RADIO(mvm
, "Sending PER_PLATFORM_ANT_GAIN_CMD\n");
845 IWL_DEBUG_RADIO(mvm
, "PPAG is %s\n",
846 mvm
->fwrt
.ppag_table
.enabled
? "enabled" : "disabled");
848 for (i
= 0; i
< ACPI_PPAG_NUM_CHAINS
; i
++) {
849 for (j
= 0; j
< ACPI_PPAG_NUM_SUB_BANDS
; j
++) {
851 "PPAG table: chain[%d] band[%d]: gain = %d\n",
852 i
, j
, mvm
->fwrt
.ppag_table
.gain
[i
][j
]);
856 ret
= iwl_mvm_send_cmd_pdu(mvm
, WIDE_ID(PHY_OPS_GROUP
,
857 PER_PLATFORM_ANT_GAIN_CMD
),
858 0, sizeof(mvm
->fwrt
.ppag_table
),
859 &mvm
->fwrt
.ppag_table
);
861 IWL_ERR(mvm
, "failed to send PER_PLATFORM_ANT_GAIN_CMD (%d)\n",
867 static int iwl_mvm_ppag_init(struct iwl_mvm
*mvm
)
871 ret
= iwl_mvm_get_ppag_table(mvm
);
874 "PPAG BIOS table invalid or unavailable. (%d)\n",
878 return iwl_mvm_ppag_send_cmd(mvm
);
881 #else /* CONFIG_ACPI */
883 inline int iwl_mvm_sar_select_profile(struct iwl_mvm
*mvm
,
884 int prof_a
, int prof_b
)
889 inline int iwl_mvm_get_sar_geo_profile(struct iwl_mvm
*mvm
)
894 static int iwl_mvm_sar_geo_init(struct iwl_mvm
*mvm
)
899 int iwl_mvm_ppag_send_cmd(struct iwl_mvm
*mvm
)
904 static int iwl_mvm_ppag_init(struct iwl_mvm
*mvm
)
908 #endif /* CONFIG_ACPI */
910 void iwl_mvm_send_recovery_cmd(struct iwl_mvm
*mvm
, u32 flags
)
912 u32 error_log_size
= mvm
->fw
->ucode_capa
.error_log_size
;
916 struct iwl_fw_error_recovery_cmd recovery_cmd
= {
917 .flags
= cpu_to_le32(flags
),
920 struct iwl_host_cmd host_cmd
= {
921 .id
= WIDE_ID(SYSTEM_GROUP
, FW_ERROR_RECOVERY_CMD
),
922 .flags
= CMD_WANT_SKB
,
923 .data
= {&recovery_cmd
, },
924 .len
= {sizeof(recovery_cmd
), },
927 /* no error log was defined in TLV */
931 if (flags
& ERROR_RECOVERY_UPDATE_DB
) {
932 /* no buf was allocated while HW reset */
933 if (!mvm
->error_recovery_buf
)
936 host_cmd
.data
[1] = mvm
->error_recovery_buf
;
937 host_cmd
.len
[1] = error_log_size
;
938 host_cmd
.dataflags
[1] = IWL_HCMD_DFL_NOCOPY
;
939 recovery_cmd
.buf_size
= cpu_to_le32(error_log_size
);
942 ret
= iwl_mvm_send_cmd(mvm
, &host_cmd
);
943 kfree(mvm
->error_recovery_buf
);
944 mvm
->error_recovery_buf
= NULL
;
947 IWL_ERR(mvm
, "Failed to send recovery cmd %d\n", ret
);
951 /* skb respond is only relevant in ERROR_RECOVERY_UPDATE_DB */
952 if (flags
& ERROR_RECOVERY_UPDATE_DB
) {
953 resp
= le32_to_cpu(*(__le32
*)host_cmd
.resp_pkt
->data
);
956 "Failed to send recovery cmd blob was invalid %d\n",
961 static int iwl_mvm_sar_init(struct iwl_mvm
*mvm
)
965 ret
= iwl_sar_get_wrds_table(&mvm
->fwrt
);
968 "WRDS SAR BIOS table invalid or unavailable. (%d)\n",
971 * If not available, don't fail and don't bother with EWRD.
972 * Return 1 to tell that we can't use WGDS either.
977 ret
= iwl_sar_get_ewrd_table(&mvm
->fwrt
);
978 /* if EWRD is not available, we can still use WRDS, so don't fail */
981 "EWRD SAR BIOS table invalid or unavailable. (%d)\n",
984 ret
= iwl_mvm_sar_select_profile(mvm
, 1, 1);
986 * If we don't have profile 0 from BIOS, just skip it. This
987 * means that SAR Geo will not be enabled either, even if we
988 * have other valid profiles.
996 static int iwl_mvm_load_rt_fw(struct iwl_mvm
*mvm
)
1000 if (iwl_mvm_has_unified_ucode(mvm
))
1001 return iwl_run_unified_mvm_ucode(mvm
, false);
1003 ret
= iwl_run_init_mvm_ucode(mvm
, false);
1006 IWL_ERR(mvm
, "Failed to run INIT ucode: %d\n", ret
);
1008 if (iwlmvm_mod_params
.init_dbg
)
1013 iwl_fw_dbg_stop_sync(&mvm
->fwrt
);
1014 iwl_trans_stop_device(mvm
->trans
);
1015 ret
= iwl_trans_start_hw(mvm
->trans
);
1019 iwl_dbg_tlv_time_point(&mvm
->fwrt
, IWL_FW_INI_TIME_POINT_EARLY
, NULL
);
1021 mvm
->rfkill_safe_init_done
= false;
1022 ret
= iwl_mvm_load_ucode_wait_alive(mvm
, IWL_UCODE_REGULAR
);
1026 mvm
->rfkill_safe_init_done
= true;
1028 iwl_dbg_tlv_time_point(&mvm
->fwrt
, IWL_FW_INI_TIME_POINT_AFTER_ALIVE
,
1031 return iwl_init_paging(&mvm
->fwrt
, mvm
->fwrt
.cur_fw_img
);
1034 int iwl_mvm_up(struct iwl_mvm
*mvm
)
1037 struct ieee80211_channel
*chan
;
1038 struct cfg80211_chan_def chandef
;
1039 struct ieee80211_supported_band
*sband
= NULL
;
1041 lockdep_assert_held(&mvm
->mutex
);
1043 ret
= iwl_trans_start_hw(mvm
->trans
);
1047 ret
= iwl_mvm_load_rt_fw(mvm
);
1049 IWL_ERR(mvm
, "Failed to start RT ucode: %d\n", ret
);
1050 if (ret
!= -ERFKILL
)
1051 iwl_fw_dbg_error_collect(&mvm
->fwrt
,
1052 FW_DBG_TRIGGER_DRIVER
);
1056 iwl_get_shared_mem_conf(&mvm
->fwrt
);
1058 ret
= iwl_mvm_sf_update(mvm
, NULL
, false);
1060 IWL_ERR(mvm
, "Failed to initialize Smart Fifo\n");
1062 if (!iwl_trans_dbg_ini_valid(mvm
->trans
)) {
1063 mvm
->fwrt
.dump
.conf
= FW_DBG_INVALID
;
1064 /* if we have a destination, assume EARLY START */
1065 if (mvm
->fw
->dbg
.dest_tlv
)
1066 mvm
->fwrt
.dump
.conf
= FW_DBG_START_FROM_ALIVE
;
1067 iwl_fw_start_dbg_conf(&mvm
->fwrt
, FW_DBG_START_FROM_ALIVE
);
1070 ret
= iwl_send_tx_ant_cfg(mvm
, iwl_mvm_get_valid_tx_ant(mvm
));
1074 if (!iwl_mvm_has_unified_ucode(mvm
)) {
1075 /* Send phy db control command and then phy db calibration */
1076 ret
= iwl_send_phy_db_data(mvm
->phy_db
);
1081 ret
= iwl_send_phy_cfg_cmd(mvm
);
1085 ret
= iwl_mvm_send_bt_init_conf(mvm
);
1089 /* Init RSS configuration */
1090 if (mvm
->trans
->trans_cfg
->device_family
>= IWL_DEVICE_FAMILY_22000
) {
1091 ret
= iwl_configure_rxq(mvm
);
1093 IWL_ERR(mvm
, "Failed to configure RX queues: %d\n",
1099 if (iwl_mvm_has_new_rx_api(mvm
)) {
1100 ret
= iwl_send_rss_cfg_cmd(mvm
);
1102 IWL_ERR(mvm
, "Failed to configure RSS queues: %d\n",
1108 /* init the fw <-> mac80211 STA mapping */
1109 for (i
= 0; i
< ARRAY_SIZE(mvm
->fw_id_to_mac_id
); i
++)
1110 RCU_INIT_POINTER(mvm
->fw_id_to_mac_id
[i
], NULL
);
1112 mvm
->tdls_cs
.peer
.sta_id
= IWL_MVM_INVALID_STA
;
1114 /* reset quota debouncing buffer - 0xff will yield invalid data */
1115 memset(&mvm
->last_quota_cmd
, 0xff, sizeof(mvm
->last_quota_cmd
));
1117 if (fw_has_capa(&mvm
->fw
->ucode_capa
, IWL_UCODE_TLV_CAPA_DQA_SUPPORT
)) {
1118 ret
= iwl_mvm_send_dqa_cmd(mvm
);
1123 /* Add auxiliary station for scanning */
1124 ret
= iwl_mvm_add_aux_sta(mvm
);
1128 /* Add all the PHY contexts */
1130 while (!sband
&& i
< NUM_NL80211_BANDS
)
1131 sband
= mvm
->hw
->wiphy
->bands
[i
++];
1133 if (WARN_ON_ONCE(!sband
))
1136 chan
= &sband
->channels
[0];
1138 cfg80211_chandef_create(&chandef
, chan
, NL80211_CHAN_NO_HT
);
1139 for (i
= 0; i
< NUM_PHY_CTX
; i
++) {
1141 * The channel used here isn't relevant as it's
1142 * going to be overwritten in the other flows.
1143 * For now use the first channel we have.
1145 ret
= iwl_mvm_phy_ctxt_add(mvm
, &mvm
->phy_ctxts
[i
],
1151 if (iwl_mvm_is_tt_in_fw(mvm
)) {
1152 /* in order to give the responsibility of ct-kill and
1153 * TX backoff to FW we need to send empty temperature reporting
1154 * cmd during init time
1156 iwl_mvm_send_temp_report_ths_cmd(mvm
);
1158 /* Initialize tx backoffs to the minimal possible */
1159 iwl_mvm_tt_tx_backoff(mvm
, 0);
1162 #ifdef CONFIG_THERMAL
1163 /* TODO: read the budget from BIOS / Platform NVM */
1166 * In case there is no budget from BIOS / Platform NVM the default
1167 * budget should be 2000mW (cooling state 0).
1169 if (iwl_mvm_is_ctdp_supported(mvm
)) {
1170 ret
= iwl_mvm_ctdp_command(mvm
, CTDP_CMD_OPERATION_START
,
1171 mvm
->cooling_dev
.cur_state
);
1177 if (!fw_has_capa(&mvm
->fw
->ucode_capa
, IWL_UCODE_TLV_CAPA_SET_LTR_GEN2
))
1178 WARN_ON(iwl_mvm_config_ltr(mvm
));
1180 ret
= iwl_mvm_power_update_device(mvm
);
1185 * RTNL is not taken during Ct-kill, but we don't need to scan/Tx
1186 * anyway, so don't init MCC.
1188 if (!test_bit(IWL_MVM_STATUS_HW_CTKILL
, &mvm
->status
)) {
1189 ret
= iwl_mvm_init_mcc(mvm
);
1194 if (fw_has_capa(&mvm
->fw
->ucode_capa
, IWL_UCODE_TLV_CAPA_UMAC_SCAN
)) {
1195 mvm
->scan_type
= IWL_SCAN_TYPE_NOT_SET
;
1196 mvm
->hb_scan_type
= IWL_SCAN_TYPE_NOT_SET
;
1197 ret
= iwl_mvm_config_scan(mvm
);
1202 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
))
1203 iwl_mvm_send_recovery_cmd(mvm
, ERROR_RECOVERY_UPDATE_DB
);
1205 if (iwl_acpi_get_eckv(mvm
->dev
, &mvm
->ext_clock_valid
))
1206 IWL_DEBUG_INFO(mvm
, "ECKV table doesn't exist in BIOS\n");
1208 ret
= iwl_mvm_ppag_init(mvm
);
1212 ret
= iwl_mvm_sar_init(mvm
);
1214 ret
= iwl_mvm_sar_geo_init(mvm
);
1215 } else if (ret
> 0 && !iwl_sar_get_wgds_table(&mvm
->fwrt
)) {
1217 * If basic SAR is not available, we check for WGDS,
1218 * which should *not* be available either. If it is
1219 * available, issue an error, because we can't use SAR
1220 * Geo without basic SAR.
1222 IWL_ERR(mvm
, "BIOS contains WGDS but no WRDS\n");
1228 iwl_mvm_leds_sync(mvm
);
1230 IWL_DEBUG_INFO(mvm
, "RT uCode started.\n");
1233 if (!iwlmvm_mod_params
.init_dbg
|| !ret
)
1234 iwl_mvm_stop_device(mvm
);
1238 int iwl_mvm_load_d3_fw(struct iwl_mvm
*mvm
)
1242 lockdep_assert_held(&mvm
->mutex
);
1244 ret
= iwl_trans_start_hw(mvm
->trans
);
1248 ret
= iwl_mvm_load_ucode_wait_alive(mvm
, IWL_UCODE_WOWLAN
);
1250 IWL_ERR(mvm
, "Failed to start WoWLAN firmware: %d\n", ret
);
1254 ret
= iwl_send_tx_ant_cfg(mvm
, iwl_mvm_get_valid_tx_ant(mvm
));
1258 /* Send phy db control command and then phy db calibration*/
1259 ret
= iwl_send_phy_db_data(mvm
->phy_db
);
1263 ret
= iwl_send_phy_cfg_cmd(mvm
);
1267 /* init the fw <-> mac80211 STA mapping */
1268 for (i
= 0; i
< ARRAY_SIZE(mvm
->fw_id_to_mac_id
); i
++)
1269 RCU_INIT_POINTER(mvm
->fw_id_to_mac_id
[i
], NULL
);
1271 /* Add auxiliary station for scanning */
1272 ret
= iwl_mvm_add_aux_sta(mvm
);
1278 iwl_mvm_stop_device(mvm
);
1282 void iwl_mvm_rx_card_state_notif(struct iwl_mvm
*mvm
,
1283 struct iwl_rx_cmd_buffer
*rxb
)
1285 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1286 struct iwl_card_state_notif
*card_state_notif
= (void *)pkt
->data
;
1287 u32 flags
= le32_to_cpu(card_state_notif
->flags
);
1289 IWL_DEBUG_RF_KILL(mvm
, "Card state received: HW:%s SW:%s CT:%s\n",
1290 (flags
& HW_CARD_DISABLED
) ? "Kill" : "On",
1291 (flags
& SW_CARD_DISABLED
) ? "Kill" : "On",
1292 (flags
& CT_KILL_CARD_DISABLED
) ?
1293 "Reached" : "Not reached");
1296 void iwl_mvm_rx_mfuart_notif(struct iwl_mvm
*mvm
,
1297 struct iwl_rx_cmd_buffer
*rxb
)
1299 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1300 struct iwl_mfuart_load_notif
*mfuart_notif
= (void *)pkt
->data
;
1303 "MFUART: installed ver: 0x%08x, external ver: 0x%08x, status: 0x%08x, duration: 0x%08x\n",
1304 le32_to_cpu(mfuart_notif
->installed_ver
),
1305 le32_to_cpu(mfuart_notif
->external_ver
),
1306 le32_to_cpu(mfuart_notif
->status
),
1307 le32_to_cpu(mfuart_notif
->duration
));
1309 if (iwl_rx_packet_payload_len(pkt
) == sizeof(*mfuart_notif
))
1311 "MFUART: image size: 0x%08x\n",
1312 le32_to_cpu(mfuart_notif
->image_size
));