1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2019, Intel Corporation. */
4 #include <asm/unaligned.h>
5 #include <linux/uuid.h>
6 #include <linux/crc32.h>
7 #include <linux/pldmfw.h>
9 #include "ice_fw_update.h"
12 struct pldmfw context;
15 struct netlink_ext_ack *extack;
17 /* Track which NVM banks to activate at the end of the update */
20 /* Track the firmware response of the required reset to complete the
23 * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
24 * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
25 * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
29 /* Track if EMP reset is available */
30 u8 emp_reset_available;
34 * ice_send_package_data - Send record package data to firmware
35 * @context: PLDM fw update structure
36 * @data: pointer to the package data
37 * @length: length of the package data
39 * Send a copy of the package data associated with the PLDM record matching
40 * this device to the firmware.
42 * Note that this function sends an AdminQ command that will fail unless the
43 * NVM resource has been acquired.
45 * Returns: zero on success, or a negative error code on failure.
48 ice_send_package_data(struct pldmfw *context, const u8 *data, u16 length)
50 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
51 struct netlink_ext_ack *extack = priv->extack;
52 struct device *dev = context->dev;
53 struct ice_pf *pf = priv->pf;
54 struct ice_hw *hw = &pf->hw;
58 dev_dbg(dev, "Sending PLDM record package data to firmware\n");
60 package_data = kmemdup(data, length, GFP_KERNEL);
64 status = ice_nvm_set_pkg_data(hw, false, package_data, length, NULL);
69 dev_err(dev, "Failed to send record package data to firmware, err %d aq_err %s\n",
70 status, ice_aq_str(hw->adminq.sq_last_status));
71 NL_SET_ERR_MSG_MOD(extack, "Failed to record package data to firmware");
79 * ice_check_component_response - Report firmware response to a component
80 * @pf: device private data structure
81 * @id: component id being checked
82 * @response: indicates whether this component can be updated
83 * @code: code indicating reason for response
84 * @extack: netlink extended ACK structure
86 * Check whether firmware indicates if this component can be updated. Report
87 * a suitable error message over the netlink extended ACK if the component
90 * Returns: zero if the component can be updated, or -ECANCELED of the
91 * firmware indicates the component cannot be updated.
94 ice_check_component_response(struct ice_pf *pf, u16 id, u8 response, u8 code,
95 struct netlink_ext_ack *extack)
97 struct device *dev = ice_pf_to_dev(pf);
98 const char *component;
101 case NVM_COMP_ID_OROM:
102 component = "fw.undi";
104 case NVM_COMP_ID_NVM:
105 component = "fw.mgmt";
107 case NVM_COMP_ID_NETLIST:
108 component = "fw.netlist";
111 WARN(1, "Unexpected unknown component identifier 0x%02x", id);
115 dev_dbg(dev, "%s: firmware response 0x%x, code 0x%x\n",
116 component, response, code);
119 case ICE_AQ_NVM_PASS_COMP_CAN_BE_UPDATED:
120 /* firmware indicated this update is good to proceed */
122 case ICE_AQ_NVM_PASS_COMP_CAN_MAY_BE_UPDATEABLE:
123 dev_warn(dev, "firmware recommends not updating %s, as it may result in a downgrade. continuing anyways\n", component);
125 case ICE_AQ_NVM_PASS_COMP_CAN_NOT_BE_UPDATED:
126 dev_info(dev, "firmware has rejected updating %s\n", component);
131 case ICE_AQ_NVM_PASS_COMP_STAMP_IDENTICAL_CODE:
132 dev_err(dev, "Component comparison stamp for %s is identical to the running image\n",
134 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is identical to running image");
136 case ICE_AQ_NVM_PASS_COMP_STAMP_LOWER:
137 dev_err(dev, "Component comparison stamp for %s is lower than the running image\n",
139 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is lower than running image");
141 case ICE_AQ_NVM_PASS_COMP_INVALID_STAMP_CODE:
142 dev_err(dev, "Component comparison stamp for %s is invalid\n",
144 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is invalid");
146 case ICE_AQ_NVM_PASS_COMP_CONFLICT_CODE:
147 dev_err(dev, "%s conflicts with a previous component table\n",
149 NL_SET_ERR_MSG_MOD(extack, "Component table conflict occurred");
151 case ICE_AQ_NVM_PASS_COMP_PRE_REQ_NOT_MET_CODE:
152 dev_err(dev, "Pre-requisites for component %s have not been met\n",
154 NL_SET_ERR_MSG_MOD(extack, "Component pre-requisites not met");
156 case ICE_AQ_NVM_PASS_COMP_NOT_SUPPORTED_CODE:
157 dev_err(dev, "%s is not a supported component\n",
159 NL_SET_ERR_MSG_MOD(extack, "Component not supported");
161 case ICE_AQ_NVM_PASS_COMP_CANNOT_DOWNGRADE_CODE:
162 dev_err(dev, "Security restrictions prevent %s from being downgraded\n",
164 NL_SET_ERR_MSG_MOD(extack, "Component cannot be downgraded");
166 case ICE_AQ_NVM_PASS_COMP_INCOMPLETE_IMAGE_CODE:
167 dev_err(dev, "Received an incomplete component image for %s\n",
169 NL_SET_ERR_MSG_MOD(extack, "Incomplete component image");
171 case ICE_AQ_NVM_PASS_COMP_VER_STR_IDENTICAL_CODE:
172 dev_err(dev, "Component version for %s is identical to the running image\n",
174 NL_SET_ERR_MSG_MOD(extack, "Component version is identical to running image");
176 case ICE_AQ_NVM_PASS_COMP_VER_STR_LOWER_CODE:
177 dev_err(dev, "Component version for %s is lower than the running image\n",
179 NL_SET_ERR_MSG_MOD(extack, "Component version is lower than the running image");
182 dev_err(dev, "Unexpected response code 0x02%x for %s\n",
184 NL_SET_ERR_MSG_MOD(extack, "Received unexpected response code from firmware");
192 * ice_send_component_table - Send PLDM component table to firmware
193 * @context: PLDM fw update structure
194 * @component: the component to process
195 * @transfer_flag: relative transfer order of this component
197 * Read relevant data from the component and forward it to the device
198 * firmware. Check the response to determine if the firmware indicates that
199 * the update can proceed.
201 * This function sends AdminQ commands related to the NVM, and assumes that
202 * the NVM resource has been acquired.
204 * Returns: zero on success, or a negative error code on failure.
207 ice_send_component_table(struct pldmfw *context, struct pldmfw_component *component,
210 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
211 struct netlink_ext_ack *extack = priv->extack;
212 struct ice_aqc_nvm_comp_tbl *comp_tbl;
213 u8 comp_response, comp_response_code;
214 struct device *dev = context->dev;
215 struct ice_pf *pf = priv->pf;
216 struct ice_hw *hw = &pf->hw;
220 switch (component->identifier) {
221 case NVM_COMP_ID_OROM:
222 case NVM_COMP_ID_NVM:
223 case NVM_COMP_ID_NETLIST:
226 dev_err(dev, "Unable to update due to a firmware component with unknown ID %u\n",
227 component->identifier);
228 NL_SET_ERR_MSG_MOD(extack, "Unable to update due to unknown firmware component");
232 length = struct_size(comp_tbl, cvs, component->version_len);
233 comp_tbl = kzalloc(length, GFP_KERNEL);
237 comp_tbl->comp_class = cpu_to_le16(component->classification);
238 comp_tbl->comp_id = cpu_to_le16(component->identifier);
239 comp_tbl->comp_class_idx = FWU_COMP_CLASS_IDX_NOT_USE;
240 comp_tbl->comp_cmp_stamp = cpu_to_le32(component->comparison_stamp);
241 comp_tbl->cvs_type = component->version_type;
242 comp_tbl->cvs_len = component->version_len;
243 memcpy(comp_tbl->cvs, component->version_string, component->version_len);
245 dev_dbg(dev, "Sending component table to firmware:\n");
247 status = ice_nvm_pass_component_tbl(hw, (u8 *)comp_tbl, length,
248 transfer_flag, &comp_response,
249 &comp_response_code, NULL);
254 dev_err(dev, "Failed to transfer component table to firmware, err %d aq_err %s\n",
255 status, ice_aq_str(hw->adminq.sq_last_status));
256 NL_SET_ERR_MSG_MOD(extack, "Failed to transfer component table to firmware");
260 return ice_check_component_response(pf, component->identifier, comp_response,
261 comp_response_code, extack);
265 * ice_write_one_nvm_block - Write an NVM block and await completion response
266 * @pf: the PF data structure
267 * @module: the module to write to
268 * @offset: offset in bytes
269 * @block_size: size of the block to write, up to 4k
270 * @block: pointer to block of data to write
271 * @last_cmd: whether this is the last command
272 * @reset_level: storage for reset level required
273 * @extack: netlink extended ACK structure
275 * Write a block of data to a flash module, and await for the completion
276 * response message from firmware.
278 * Note this function assumes the caller has acquired the NVM resource.
280 * On successful return, reset level indicates the device reset required to
281 * complete the update.
283 * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
284 * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
285 * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
287 * Returns: zero on success, or a negative error code on failure.
290 ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset,
291 u16 block_size, u8 *block, bool last_cmd,
292 u8 *reset_level, struct netlink_ext_ack *extack)
294 u16 completion_module, completion_retval;
295 struct device *dev = ice_pf_to_dev(pf);
296 struct ice_rq_event_info event;
297 struct ice_hw *hw = &pf->hw;
298 u32 completion_offset;
301 memset(&event, 0, sizeof(event));
303 dev_dbg(dev, "Writing block of %u bytes for module 0x%02x at offset %u\n",
304 block_size, module, offset);
306 err = ice_aq_update_nvm(hw, module, offset, block_size, block,
309 dev_err(dev, "Failed to flash module 0x%02x with block of size %u at offset %u, err %d aq_err %s\n",
310 module, block_size, offset, err,
311 ice_aq_str(hw->adminq.sq_last_status));
312 NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module");
316 /* In most cases, firmware reports a write completion within a few
317 * milliseconds. However, it has been observed that a completion might
318 * take more than a second to complete in some cases. The timeout here
319 * is conservative and is intended to prevent failure to update when
320 * firmware is slow to respond.
322 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write, 15 * HZ, &event);
324 dev_err(dev, "Timed out while trying to flash module 0x%02x with block of size %u at offset %u, err %d\n",
325 module, block_size, offset, err);
326 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
330 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid);
331 completion_retval = le16_to_cpu(event.desc.retval);
333 completion_offset = le16_to_cpu(event.desc.params.nvm.offset_low);
334 completion_offset |= event.desc.params.nvm.offset_high << 16;
336 if (completion_module != module) {
337 dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n",
338 completion_module, module);
339 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
343 if (completion_offset != offset) {
344 dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n",
345 completion_offset, offset);
346 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
350 if (completion_retval) {
351 dev_err(dev, "Firmware failed to flash module 0x%02x with block of size %u at offset %u, err %s\n",
352 module, block_size, offset,
353 ice_aq_str((enum ice_aq_err)completion_retval));
354 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module");
358 /* For the last command to write the NVM bank, newer versions of
359 * firmware indicate the required level of reset to complete
360 * activation of firmware. If the firmware supports this, cache the
361 * response for indicating to the user later. Otherwise, assume that
362 * a full power cycle is required.
364 if (reset_level && last_cmd && module == ICE_SR_1ST_NVM_BANK_PTR) {
365 if (hw->dev_caps.common_cap.pcie_reset_avoidance) {
366 *reset_level = (event.desc.params.nvm.cmd_flags &
367 ICE_AQC_NVM_RESET_LVL_M);
368 dev_dbg(dev, "Firmware reported required reset level as %u\n",
371 *reset_level = ICE_AQC_NVM_POR_FLAG;
372 dev_dbg(dev, "Firmware doesn't support indicating required reset level. Assuming a power cycle is required\n");
380 * ice_write_nvm_module - Write data to an NVM module
381 * @pf: the PF driver structure
382 * @module: the module id to program
383 * @component: the name of the component being updated
384 * @image: buffer of image data to write to the NVM
385 * @length: length of the buffer
386 * @reset_level: storage for reset level required
387 * @extack: netlink extended ACK structure
389 * Loop over the data for a given NVM module and program it in 4 Kb
390 * blocks. Notify devlink core of progress after each block is programmed.
391 * Loops over a block of data and programs the NVM in 4k block chunks.
393 * Note this function assumes the caller has acquired the NVM resource.
395 * Returns: zero on success, or a negative error code on failure.
398 ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component,
399 const u8 *image, u32 length, u8 *reset_level,
400 struct netlink_ext_ack *extack)
402 struct device *dev = ice_pf_to_dev(pf);
403 struct devlink *devlink;
409 dev_dbg(dev, "Beginning write of flash component '%s', module 0x%02x\n", component, module);
411 devlink = priv_to_devlink(pf);
413 devlink_flash_update_status_notify(devlink, "Flashing",
414 component, 0, length);
416 block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
423 block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);
424 last_cmd = !(offset + block_size < length);
426 /* ice_aq_update_nvm may copy the firmware response into the
427 * buffer, so we must make a copy since the source data is
430 memcpy(block, image + offset, block_size);
432 err = ice_write_one_nvm_block(pf, module, offset, block_size,
433 block, last_cmd, reset_level,
438 offset += block_size;
440 devlink_flash_update_status_notify(devlink, "Flashing",
441 component, offset, length);
444 dev_dbg(dev, "Completed write of flash component '%s', module 0x%02x\n", component, module);
447 devlink_flash_update_status_notify(devlink, "Flashing failed",
448 component, length, length);
450 devlink_flash_update_status_notify(devlink, "Flashing done",
451 component, length, length);
457 /* Length in seconds to wait before timing out when erasing a flash module.
458 * Yes, erasing really can take minutes to complete.
460 #define ICE_FW_ERASE_TIMEOUT 300
463 * ice_erase_nvm_module - Erase an NVM module and await firmware completion
464 * @pf: the PF data structure
465 * @module: the module to erase
466 * @component: name of the component being updated
467 * @extack: netlink extended ACK structure
469 * Erase the inactive NVM bank associated with this module, and await for
470 * a completion response message from firmware.
472 * Note this function assumes the caller has acquired the NVM resource.
474 * Returns: zero on success, or a negative error code on failure.
477 ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component,
478 struct netlink_ext_ack *extack)
480 u16 completion_module, completion_retval;
481 struct device *dev = ice_pf_to_dev(pf);
482 struct ice_rq_event_info event;
483 struct ice_hw *hw = &pf->hw;
484 struct devlink *devlink;
487 dev_dbg(dev, "Beginning erase of flash component '%s', module 0x%02x\n", component, module);
489 memset(&event, 0, sizeof(event));
491 devlink = priv_to_devlink(pf);
493 devlink_flash_update_timeout_notify(devlink, "Erasing", component, ICE_FW_ERASE_TIMEOUT);
495 err = ice_aq_erase_nvm(hw, module, NULL);
497 dev_err(dev, "Failed to erase %s (module 0x%02x), err %d aq_err %s\n",
498 component, module, err,
499 ice_aq_str(hw->adminq.sq_last_status));
500 NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module");
502 goto out_notify_devlink;
505 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_erase, ICE_FW_ERASE_TIMEOUT * HZ, &event);
507 dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n",
508 component, module, err);
509 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
510 goto out_notify_devlink;
513 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid);
514 completion_retval = le16_to_cpu(event.desc.retval);
516 if (completion_module != module) {
517 dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n",
518 component, completion_module, module);
519 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
521 goto out_notify_devlink;
524 if (completion_retval) {
525 dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n",
527 ice_aq_str((enum ice_aq_err)completion_retval));
528 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash");
530 goto out_notify_devlink;
533 dev_dbg(dev, "Completed erase of flash component '%s', module 0x%02x\n", component, module);
537 devlink_flash_update_status_notify(devlink, "Erasing failed",
540 devlink_flash_update_status_notify(devlink, "Erasing done",
547 * ice_switch_flash_banks - Tell firmware to switch NVM banks
548 * @pf: Pointer to the PF data structure
549 * @activate_flags: flags used for the activation command
550 * @emp_reset_available: on return, indicates if EMP reset is available
551 * @extack: netlink extended ACK structure
553 * Notify firmware to activate the newly written flash banks, and wait for the
556 * Returns: zero on success or an error code on failure.
559 ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags,
560 u8 *emp_reset_available, struct netlink_ext_ack *extack)
562 struct device *dev = ice_pf_to_dev(pf);
563 struct ice_rq_event_info event;
564 struct ice_hw *hw = &pf->hw;
565 u16 completion_retval;
569 memset(&event, 0, sizeof(event));
571 err = ice_nvm_write_activate(hw, activate_flags, &response_flags);
573 dev_err(dev, "Failed to switch active flash banks, err %d aq_err %s\n",
574 err, ice_aq_str(hw->adminq.sq_last_status));
575 NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks");
579 /* Newer versions of firmware have support to indicate whether an EMP
580 * reset to reload firmware is available. For older firmware, EMP
581 * reset is always available.
583 if (emp_reset_available) {
584 if (hw->dev_caps.common_cap.reset_restrict_support) {
585 *emp_reset_available = response_flags & ICE_AQC_NVM_EMPR_ENA;
586 dev_dbg(dev, "Firmware indicated that EMP reset is %s\n",
587 *emp_reset_available ?
588 "available" : "not available");
590 *emp_reset_available = ICE_AQC_NVM_EMPR_ENA;
591 dev_dbg(dev, "Firmware does not support restricting EMP reset availability\n");
595 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write_activate, 30 * HZ,
598 dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",
600 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
604 completion_retval = le16_to_cpu(event.desc.retval);
605 if (completion_retval) {
606 dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n",
607 ice_aq_str((enum ice_aq_err)completion_retval));
608 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks");
616 * ice_flash_component - Flash a component of the NVM
617 * @context: PLDM fw update structure
618 * @component: the component table to program
620 * Program the flash contents for a given component. First, determine the
621 * module id. Then, erase the secondary bank for this module. Finally, write
622 * the contents of the component to the NVM.
624 * Note this function assumes the caller has acquired the NVM resource.
626 * Returns: zero on success, or a negative error code on failure.
629 ice_flash_component(struct pldmfw *context, struct pldmfw_component *component)
631 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
632 struct netlink_ext_ack *extack = priv->extack;
633 struct ice_pf *pf = priv->pf;
640 switch (component->identifier) {
641 case NVM_COMP_ID_OROM:
642 module = ICE_SR_1ST_OROM_BANK_PTR;
643 flag = ICE_AQC_NVM_ACTIV_SEL_OROM;
647 case NVM_COMP_ID_NVM:
648 module = ICE_SR_1ST_NVM_BANK_PTR;
649 flag = ICE_AQC_NVM_ACTIV_SEL_NVM;
650 reset_level = &priv->reset_level;
653 case NVM_COMP_ID_NETLIST:
654 module = ICE_SR_NETLIST_BANK_PTR;
655 flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST;
660 /* This should not trigger, since we check the id before
661 * sending the component table to firmware.
663 WARN(1, "Unexpected unknown component identifier 0x%02x",
664 component->identifier);
668 /* Mark this component for activating at the end */
669 priv->activate_flags |= flag;
671 err = ice_erase_nvm_module(pf, module, name, extack);
675 return ice_write_nvm_module(pf, module, name, component->component_data,
676 component->component_size, reset_level,
681 * ice_finalize_update - Perform last steps to complete device update
682 * @context: PLDM fw update structure
684 * Called as the last step of the update process. Complete the update by
685 * telling the firmware to switch active banks, and perform a reset of
688 * Returns: 0 on success, or an error code on failure.
690 static int ice_finalize_update(struct pldmfw *context)
692 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
693 struct netlink_ext_ack *extack = priv->extack;
694 struct ice_pf *pf = priv->pf;
695 struct devlink *devlink;
698 /* Finally, notify firmware to activate the written NVM banks */
699 err = ice_switch_flash_banks(pf, priv->activate_flags,
700 &priv->emp_reset_available, extack);
704 devlink = priv_to_devlink(pf);
706 /* If the required reset is EMPR, but EMPR is disabled, report that
707 * a reboot is required instead.
709 if (priv->reset_level == ICE_AQC_NVM_EMPR_FLAG &&
710 !priv->emp_reset_available) {
711 dev_dbg(ice_pf_to_dev(pf), "Firmware indicated EMP reset as sufficient, but EMP reset is disabled\n");
712 priv->reset_level = ICE_AQC_NVM_PERST_FLAG;
715 switch (priv->reset_level) {
716 case ICE_AQC_NVM_EMPR_FLAG:
717 devlink_flash_update_status_notify(devlink,
718 "Activate new firmware by devlink reload",
721 case ICE_AQC_NVM_PERST_FLAG:
722 devlink_flash_update_status_notify(devlink,
723 "Activate new firmware by rebooting the system",
726 case ICE_AQC_NVM_POR_FLAG:
728 devlink_flash_update_status_notify(devlink,
729 "Activate new firmware by power cycling the system",
734 pf->fw_emp_reset_disabled = !priv->emp_reset_available;
739 static const struct pldmfw_ops ice_fwu_ops = {
740 .match_record = &pldmfw_op_pci_match_record,
741 .send_package_data = &ice_send_package_data,
742 .send_component_table = &ice_send_component_table,
743 .flash_component = &ice_flash_component,
744 .finalize_update = &ice_finalize_update,
748 * ice_get_pending_updates - Check if the component has a pending update
749 * @pf: the PF driver structure
750 * @pending: on return, bitmap of updates pending
751 * @extack: Netlink extended ACK
753 * Check if the device has any pending updates on any flash components.
755 * Returns: zero on success, or a negative error code on failure. Updates
756 * pending with the bitmap of pending updates.
758 int ice_get_pending_updates(struct ice_pf *pf, u8 *pending,
759 struct netlink_ext_ack *extack)
761 struct device *dev = ice_pf_to_dev(pf);
762 struct ice_hw_dev_caps *dev_caps;
763 struct ice_hw *hw = &pf->hw;
766 dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
770 /* Read the most recent device capabilities from firmware. Do not use
771 * the cached values in hw->dev_caps, because the pending update flag
772 * may have changed, e.g. if an update was previously completed and
773 * the system has not yet rebooted.
775 err = ice_discover_dev_caps(hw, dev_caps);
777 NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
784 if (dev_caps->common_cap.nvm_update_pending_nvm) {
785 dev_info(dev, "The fw.mgmt flash component has a pending update\n");
786 *pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
789 if (dev_caps->common_cap.nvm_update_pending_orom) {
790 dev_info(dev, "The fw.undi flash component has a pending update\n");
791 *pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
794 if (dev_caps->common_cap.nvm_update_pending_netlist) {
795 dev_info(dev, "The fw.netlist flash component has a pending update\n");
796 *pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
805 * ice_cancel_pending_update - Cancel any pending update for a component
806 * @pf: the PF driver structure
807 * @component: if not NULL, the name of the component being updated
808 * @extack: Netlink extended ACK structure
810 * Cancel any pending update for the specified component. If component is
811 * NULL, all device updates will be canceled.
813 * Returns: zero on success, or a negative error code on failure.
816 ice_cancel_pending_update(struct ice_pf *pf, const char *component,
817 struct netlink_ext_ack *extack)
819 struct devlink *devlink = priv_to_devlink(pf);
820 struct device *dev = ice_pf_to_dev(pf);
821 struct ice_hw *hw = &pf->hw;
825 err = ice_get_pending_updates(pf, &pending, extack);
829 /* If the flash_update request is for a specific component, ignore all
830 * of the other components.
833 if (strcmp(component, "fw.mgmt") == 0)
834 pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
835 else if (strcmp(component, "fw.undi") == 0)
836 pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
837 else if (strcmp(component, "fw.netlist") == 0)
838 pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
840 WARN(1, "Unexpected flash component %s", component);
843 /* There is no previous pending update, so this request may continue */
847 /* In order to allow overwriting a previous pending update, notify
848 * firmware to cancel that update by issuing the appropriate command.
850 devlink_flash_update_status_notify(devlink,
851 "Canceling previous pending update",
854 err = ice_acquire_nvm(hw, ICE_RES_WRITE);
856 dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
857 err, ice_aq_str(hw->adminq.sq_last_status));
858 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
862 pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
863 err = ice_switch_flash_banks(pf, pending, NULL, extack);
867 /* Since we've canceled the pending update, we no longer know if EMP
868 * reset is restricted.
870 pf->fw_emp_reset_disabled = false;
876 * ice_devlink_flash_update - Write a firmware image to the device
877 * @devlink: pointer to devlink associated with the device to update
878 * @params: devlink flash update parameters
879 * @extack: netlink extended ACK structure
881 * Parse the data for a given firmware file, verifying that it is a valid PLDM
882 * formatted image that matches this device.
884 * Extract the device record Package Data and Component Tables and send them
885 * to the firmware. Extract and write the flash data for each of the three
886 * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify
887 * firmware once the data is written to the inactive banks.
889 * Returns: zero on success or a negative error code on failure.
891 int ice_devlink_flash_update(struct devlink *devlink,
892 struct devlink_flash_update_params *params,
893 struct netlink_ext_ack *extack)
895 struct ice_pf *pf = devlink_priv(devlink);
896 struct device *dev = ice_pf_to_dev(pf);
897 struct ice_hw *hw = &pf->hw;
898 struct ice_fwu_priv priv;
902 if (!params->overwrite_mask) {
903 /* preserve all settings and identifiers */
904 preservation = ICE_AQC_NVM_PRESERVE_ALL;
905 } else if (params->overwrite_mask == DEVLINK_FLASH_OVERWRITE_SETTINGS) {
906 /* overwrite settings, but preserve the vital device identifiers */
907 preservation = ICE_AQC_NVM_PRESERVE_SELECTED;
908 } else if (params->overwrite_mask == (DEVLINK_FLASH_OVERWRITE_SETTINGS |
909 DEVLINK_FLASH_OVERWRITE_IDENTIFIERS)) {
910 /* overwrite both settings and identifiers, preserve nothing */
911 preservation = ICE_AQC_NVM_NO_PRESERVATION;
913 NL_SET_ERR_MSG_MOD(extack, "Requested overwrite mask is not supported");
917 if (!hw->dev_caps.common_cap.nvm_unified_update) {
918 NL_SET_ERR_MSG_MOD(extack, "Current firmware does not support unified update");
922 memset(&priv, 0, sizeof(priv));
924 priv.context.ops = &ice_fwu_ops;
925 priv.context.dev = dev;
926 priv.extack = extack;
928 priv.activate_flags = preservation;
930 devlink_flash_update_status_notify(devlink, "Preparing to flash", NULL, 0, 0);
932 err = ice_cancel_pending_update(pf, NULL, extack);
936 err = ice_acquire_nvm(hw, ICE_RES_WRITE);
938 dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
939 err, ice_aq_str(hw->adminq.sq_last_status));
940 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
944 err = pldmfw_flash_image(&priv.context, params->fw);
945 if (err == -ENOENT) {
946 dev_err(dev, "Firmware image has no record matching this device\n");
947 NL_SET_ERR_MSG_MOD(extack, "Firmware image has no record matching this device");
949 /* Do not set a generic extended ACK message here. A more
950 * specific message may already have been set by one of our
953 dev_err(dev, "Failed to flash PLDM image, err %d", err);