1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2018-2019, Intel Corporation. */ 3 4 #include <asm/unaligned.h> 5 #include <linux/uuid.h> 6 #include <linux/crc32.h> 7 #include <linux/pldmfw.h> 8 #include "ice.h" 9 #include "ice_fw_update.h" 10 11 struct ice_fwu_priv { 12 struct pldmfw context; 13 14 struct ice_pf *pf; 15 struct netlink_ext_ack *extack; 16 17 /* Track which NVM banks to activate at the end of the update */ 18 u8 activate_flags; 19 }; 20 21 /** 22 * ice_send_package_data - Send record package data to firmware 23 * @context: PLDM fw update structure 24 * @data: pointer to the package data 25 * @length: length of the package data 26 * 27 * Send a copy of the package data associated with the PLDM record matching 28 * this device to the firmware. 29 * 30 * Note that this function sends an AdminQ command that will fail unless the 31 * NVM resource has been acquired. 32 * 33 * Returns: zero on success, or a negative error code on failure. 34 */ 35 static int 36 ice_send_package_data(struct pldmfw *context, const u8 *data, u16 length) 37 { 38 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context); 39 struct netlink_ext_ack *extack = priv->extack; 40 struct device *dev = context->dev; 41 struct ice_pf *pf = priv->pf; 42 struct ice_hw *hw = &pf->hw; 43 enum ice_status status; 44 u8 *package_data; 45 46 package_data = kmemdup(data, length, GFP_KERNEL); 47 if (!package_data) 48 return -ENOMEM; 49 50 status = ice_nvm_set_pkg_data(hw, false, package_data, length, NULL); 51 52 kfree(package_data); 53 54 if (status) { 55 dev_err(dev, "Failed to send record package data to firmware, err %s aq_err %s\n", 56 ice_stat_str(status), 57 ice_aq_str(hw->adminq.sq_last_status)); 58 NL_SET_ERR_MSG_MOD(extack, "Failed to record package data to firmware"); 59 return -EIO; 60 } 61 62 return 0; 63 } 64 65 /** 66 * ice_check_component_response - Report firmware response to a component 67 * @pf: device private data structure 68 * @id: component id being checked 69 * @response: indicates whether this component can be updated 70 * @code: code indicating reason for response 71 * @extack: netlink extended ACK structure 72 * 73 * Check whether firmware indicates if this component can be updated. Report 74 * a suitable error message over the netlink extended ACK if the component 75 * cannot be updated. 76 * 77 * Returns: zero if the component can be updated, or -ECANCELED of the 78 * firmware indicates the component cannot be updated. 79 */ 80 static int 81 ice_check_component_response(struct ice_pf *pf, u16 id, u8 response, u8 code, 82 struct netlink_ext_ack *extack) 83 { 84 struct device *dev = ice_pf_to_dev(pf); 85 const char *component; 86 87 switch (id) { 88 case NVM_COMP_ID_OROM: 89 component = "fw.undi"; 90 break; 91 case NVM_COMP_ID_NVM: 92 component = "fw.mgmt"; 93 break; 94 case NVM_COMP_ID_NETLIST: 95 component = "fw.netlist"; 96 break; 97 default: 98 WARN(1, "Unexpected unknown component identifier 0x%02x", id); 99 return -EINVAL; 100 } 101 102 dev_dbg(dev, "%s: firmware response 0x%x, code 0x%x\n", 103 component, response, code); 104 105 switch (response) { 106 case ICE_AQ_NVM_PASS_COMP_CAN_BE_UPDATED: 107 /* firmware indicated this update is good to proceed */ 108 return 0; 109 case ICE_AQ_NVM_PASS_COMP_CAN_MAY_BE_UPDATEABLE: 110 dev_warn(dev, "firmware recommends not updating %s, as it may result in a downgrade. continuing anyways\n", component); 111 return 0; 112 case ICE_AQ_NVM_PASS_COMP_CAN_NOT_BE_UPDATED: 113 dev_info(dev, "firmware has rejected updating %s\n", component); 114 break; 115 } 116 117 switch (code) { 118 case ICE_AQ_NVM_PASS_COMP_STAMP_IDENTICAL_CODE: 119 dev_err(dev, "Component comparison stamp for %s is identical to the running image\n", 120 component); 121 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is identical to running image"); 122 break; 123 case ICE_AQ_NVM_PASS_COMP_STAMP_LOWER: 124 dev_err(dev, "Component comparison stamp for %s is lower than the running image\n", 125 component); 126 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is lower than running image"); 127 break; 128 case ICE_AQ_NVM_PASS_COMP_INVALID_STAMP_CODE: 129 dev_err(dev, "Component comparison stamp for %s is invalid\n", 130 component); 131 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is invalid"); 132 break; 133 case ICE_AQ_NVM_PASS_COMP_CONFLICT_CODE: 134 dev_err(dev, "%s conflicts with a previous component table\n", 135 component); 136 NL_SET_ERR_MSG_MOD(extack, "Component table conflict occurred"); 137 break; 138 case ICE_AQ_NVM_PASS_COMP_PRE_REQ_NOT_MET_CODE: 139 dev_err(dev, "Pre-requisites for component %s have not been met\n", 140 component); 141 NL_SET_ERR_MSG_MOD(extack, "Component pre-requisites not met"); 142 break; 143 case ICE_AQ_NVM_PASS_COMP_NOT_SUPPORTED_CODE: 144 dev_err(dev, "%s is not a supported component\n", 145 component); 146 NL_SET_ERR_MSG_MOD(extack, "Component not supported"); 147 break; 148 case ICE_AQ_NVM_PASS_COMP_CANNOT_DOWNGRADE_CODE: 149 dev_err(dev, "Security restrictions prevent %s from being downgraded\n", 150 component); 151 NL_SET_ERR_MSG_MOD(extack, "Component cannot be downgraded"); 152 break; 153 case ICE_AQ_NVM_PASS_COMP_INCOMPLETE_IMAGE_CODE: 154 dev_err(dev, "Received an incomplete component image for %s\n", 155 component); 156 NL_SET_ERR_MSG_MOD(extack, "Incomplete component image"); 157 break; 158 case ICE_AQ_NVM_PASS_COMP_VER_STR_IDENTICAL_CODE: 159 dev_err(dev, "Component version for %s is identical to the running image\n", 160 component); 161 NL_SET_ERR_MSG_MOD(extack, "Component version is identical to running image"); 162 break; 163 case ICE_AQ_NVM_PASS_COMP_VER_STR_LOWER_CODE: 164 dev_err(dev, "Component version for %s is lower than the running image\n", 165 component); 166 NL_SET_ERR_MSG_MOD(extack, "Component version is lower than the running image"); 167 break; 168 default: 169 dev_err(dev, "Unexpected response code 0x02%x for %s\n", 170 code, component); 171 NL_SET_ERR_MSG_MOD(extack, "Received unexpected response code from firmware"); 172 break; 173 } 174 175 return -ECANCELED; 176 } 177 178 /** 179 * ice_send_component_table - Send PLDM component table to firmware 180 * @context: PLDM fw update structure 181 * @component: the component to process 182 * @transfer_flag: relative transfer order of this component 183 * 184 * Read relevant data from the component and forward it to the device 185 * firmware. Check the response to determine if the firmware indicates that 186 * the update can proceed. 187 * 188 * This function sends AdminQ commands related to the NVM, and assumes that 189 * the NVM resource has been acquired. 190 * 191 * Returns: zero on success, or a negative error code on failure. 192 */ 193 static int 194 ice_send_component_table(struct pldmfw *context, struct pldmfw_component *component, 195 u8 transfer_flag) 196 { 197 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context); 198 struct netlink_ext_ack *extack = priv->extack; 199 struct ice_aqc_nvm_comp_tbl *comp_tbl; 200 u8 comp_response, comp_response_code; 201 struct device *dev = context->dev; 202 struct ice_pf *pf = priv->pf; 203 struct ice_hw *hw = &pf->hw; 204 enum ice_status status; 205 size_t length; 206 207 switch (component->identifier) { 208 case NVM_COMP_ID_OROM: 209 case NVM_COMP_ID_NVM: 210 case NVM_COMP_ID_NETLIST: 211 break; 212 default: 213 dev_err(dev, "Unable to update due to a firmware component with unknown ID %u\n", 214 component->identifier); 215 NL_SET_ERR_MSG_MOD(extack, "Unable to update due to unknown firmware component"); 216 return -EOPNOTSUPP; 217 } 218 219 length = struct_size(comp_tbl, cvs, component->version_len); 220 comp_tbl = kzalloc(length, GFP_KERNEL); 221 if (!comp_tbl) 222 return -ENOMEM; 223 224 comp_tbl->comp_class = cpu_to_le16(component->classification); 225 comp_tbl->comp_id = cpu_to_le16(component->identifier); 226 comp_tbl->comp_class_idx = FWU_COMP_CLASS_IDX_NOT_USE; 227 comp_tbl->comp_cmp_stamp = cpu_to_le32(component->comparison_stamp); 228 comp_tbl->cvs_type = component->version_type; 229 comp_tbl->cvs_len = component->version_len; 230 memcpy(comp_tbl->cvs, component->version_string, component->version_len); 231 232 status = ice_nvm_pass_component_tbl(hw, (u8 *)comp_tbl, length, 233 transfer_flag, &comp_response, 234 &comp_response_code, NULL); 235 236 kfree(comp_tbl); 237 238 if (status) { 239 dev_err(dev, "Failed to transfer component table to firmware, err %s aq_err %s\n", 240 ice_stat_str(status), 241 ice_aq_str(hw->adminq.sq_last_status)); 242 NL_SET_ERR_MSG_MOD(extack, "Failed to transfer component table to firmware"); 243 return -EIO; 244 } 245 246 return ice_check_component_response(pf, component->identifier, comp_response, 247 comp_response_code, extack); 248 } 249 250 /** 251 * ice_write_one_nvm_block - Write an NVM block and await completion response 252 * @pf: the PF data structure 253 * @module: the module to write to 254 * @offset: offset in bytes 255 * @block_size: size of the block to write, up to 4k 256 * @block: pointer to block of data to write 257 * @last_cmd: whether this is the last command 258 * @extack: netlink extended ACK structure 259 * 260 * Write a block of data to a flash module, and await for the completion 261 * response message from firmware. 262 * 263 * Note this function assumes the caller has acquired the NVM resource. 264 * 265 * Returns: zero on success, or a negative error code on failure. 266 */ 267 static int 268 ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset, 269 u16 block_size, u8 *block, bool last_cmd, 270 struct netlink_ext_ack *extack) 271 { 272 u16 completion_module, completion_retval; 273 struct device *dev = ice_pf_to_dev(pf); 274 struct ice_rq_event_info event; 275 struct ice_hw *hw = &pf->hw; 276 enum ice_status status; 277 u32 completion_offset; 278 int err; 279 280 memset(&event, 0, sizeof(event)); 281 282 status = ice_aq_update_nvm(hw, module, offset, block_size, block, 283 last_cmd, 0, NULL); 284 if (status) { 285 dev_err(dev, "Failed to program flash module 0x%02x at offset %u, err %s aq_err %s\n", 286 module, offset, ice_stat_str(status), 287 ice_aq_str(hw->adminq.sq_last_status)); 288 NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module"); 289 return -EIO; 290 } 291 292 /* In most cases, firmware reports a write completion within a few 293 * milliseconds. However, it has been observed that a completion might 294 * take more than a second to complete in some cases. The timeout here 295 * is conservative and is intended to prevent failure to update when 296 * firmware is slow to respond. 297 */ 298 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write, 15 * HZ, &event); 299 if (err) { 300 dev_err(dev, "Timed out waiting for firmware write completion for module 0x%02x, err %d\n", 301 module, err); 302 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware"); 303 return -EIO; 304 } 305 306 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid); 307 completion_retval = le16_to_cpu(event.desc.retval); 308 309 completion_offset = le16_to_cpu(event.desc.params.nvm.offset_low); 310 completion_offset |= event.desc.params.nvm.offset_high << 16; 311 312 if (completion_module != module) { 313 dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n", 314 completion_module, module); 315 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response"); 316 return -EIO; 317 } 318 319 if (completion_offset != offset) { 320 dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n", 321 completion_offset, offset); 322 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response"); 323 return -EIO; 324 } 325 326 if (completion_retval) { 327 dev_err(dev, "Firmware failed to program flash module 0x%02x at offset %u, completion err %s\n", 328 module, offset, 329 ice_aq_str((enum ice_aq_err)completion_retval)); 330 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module"); 331 return -EIO; 332 } 333 334 return 0; 335 } 336 337 /** 338 * ice_write_nvm_module - Write data to an NVM module 339 * @pf: the PF driver structure 340 * @module: the module id to program 341 * @component: the name of the component being updated 342 * @image: buffer of image data to write to the NVM 343 * @length: length of the buffer 344 * @extack: netlink extended ACK structure 345 * 346 * Loop over the data for a given NVM module and program it in 4 Kb 347 * blocks. Notify devlink core of progress after each block is programmed. 348 * Loops over a block of data and programs the NVM in 4k block chunks. 349 * 350 * Note this function assumes the caller has acquired the NVM resource. 351 * 352 * Returns: zero on success, or a negative error code on failure. 353 */ 354 static int 355 ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component, 356 const u8 *image, u32 length, 357 struct netlink_ext_ack *extack) 358 { 359 struct devlink *devlink; 360 u32 offset = 0; 361 bool last_cmd; 362 u8 *block; 363 int err; 364 365 devlink = priv_to_devlink(pf); 366 367 devlink_flash_update_status_notify(devlink, "Flashing", 368 component, 0, length); 369 370 block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL); 371 if (!block) 372 return -ENOMEM; 373 374 do { 375 u32 block_size; 376 377 block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset); 378 last_cmd = !(offset + block_size < length); 379 380 /* ice_aq_update_nvm may copy the firmware response into the 381 * buffer, so we must make a copy since the source data is 382 * constant. 383 */ 384 memcpy(block, image + offset, block_size); 385 386 err = ice_write_one_nvm_block(pf, module, offset, block_size, 387 block, last_cmd, extack); 388 if (err) 389 break; 390 391 offset += block_size; 392 393 devlink_flash_update_status_notify(devlink, "Flashing", 394 component, offset, length); 395 } while (!last_cmd); 396 397 if (err) 398 devlink_flash_update_status_notify(devlink, "Flashing failed", 399 component, length, length); 400 else 401 devlink_flash_update_status_notify(devlink, "Flashing done", 402 component, length, length); 403 404 kfree(block); 405 return err; 406 } 407 408 /** 409 * ice_erase_nvm_module - Erase an NVM module and await firmware completion 410 * @pf: the PF data structure 411 * @module: the module to erase 412 * @component: name of the component being updated 413 * @extack: netlink extended ACK structure 414 * 415 * Erase the inactive NVM bank associated with this module, and await for 416 * a completion response message from firmware. 417 * 418 * Note this function assumes the caller has acquired the NVM resource. 419 * 420 * Returns: zero on success, or a negative error code on failure. 421 */ 422 static int 423 ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component, 424 struct netlink_ext_ack *extack) 425 { 426 u16 completion_module, completion_retval; 427 struct device *dev = ice_pf_to_dev(pf); 428 struct ice_rq_event_info event; 429 struct ice_hw *hw = &pf->hw; 430 struct devlink *devlink; 431 enum ice_status status; 432 int err; 433 434 memset(&event, 0, sizeof(event)); 435 436 devlink = priv_to_devlink(pf); 437 438 devlink_flash_update_status_notify(devlink, "Erasing", component, 0, 0); 439 440 status = ice_aq_erase_nvm(hw, module, NULL); 441 if (status) { 442 dev_err(dev, "Failed to erase %s (module 0x%02x), err %s aq_err %s\n", 443 component, module, ice_stat_str(status), 444 ice_aq_str(hw->adminq.sq_last_status)); 445 NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module"); 446 err = -EIO; 447 goto out_notify_devlink; 448 } 449 450 /* Yes, this really can take minutes to complete */ 451 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_erase, 300 * HZ, &event); 452 if (err) { 453 dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n", 454 component, module, err); 455 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware"); 456 goto out_notify_devlink; 457 } 458 459 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid); 460 completion_retval = le16_to_cpu(event.desc.retval); 461 462 if (completion_module != module) { 463 dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n", 464 component, completion_module, module); 465 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response"); 466 err = -EIO; 467 goto out_notify_devlink; 468 } 469 470 if (completion_retval) { 471 dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n", 472 component, module, 473 ice_aq_str((enum ice_aq_err)completion_retval)); 474 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash"); 475 err = -EIO; 476 goto out_notify_devlink; 477 } 478 479 out_notify_devlink: 480 if (err) 481 devlink_flash_update_status_notify(devlink, "Erasing failed", 482 component, 0, 0); 483 else 484 devlink_flash_update_status_notify(devlink, "Erasing done", 485 component, 0, 0); 486 487 return err; 488 } 489 490 /** 491 * ice_switch_flash_banks - Tell firmware to switch NVM banks 492 * @pf: Pointer to the PF data structure 493 * @activate_flags: flags used for the activation command 494 * @extack: netlink extended ACK structure 495 * 496 * Notify firmware to activate the newly written flash banks, and wait for the 497 * firmware response. 498 * 499 * Returns: zero on success or an error code on failure. 500 */ 501 static int ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags, 502 struct netlink_ext_ack *extack) 503 { 504 struct device *dev = ice_pf_to_dev(pf); 505 struct ice_rq_event_info event; 506 struct ice_hw *hw = &pf->hw; 507 enum ice_status status; 508 u16 completion_retval; 509 int err; 510 511 memset(&event, 0, sizeof(event)); 512 513 status = ice_nvm_write_activate(hw, activate_flags); 514 if (status) { 515 dev_err(dev, "Failed to switch active flash banks, err %s aq_err %s\n", 516 ice_stat_str(status), 517 ice_aq_str(hw->adminq.sq_last_status)); 518 NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks"); 519 return -EIO; 520 } 521 522 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write_activate, 30 * HZ, 523 &event); 524 if (err) { 525 dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n", 526 err); 527 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware"); 528 return err; 529 } 530 531 completion_retval = le16_to_cpu(event.desc.retval); 532 if (completion_retval) { 533 dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n", 534 ice_aq_str((enum ice_aq_err)completion_retval)); 535 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks"); 536 return -EIO; 537 } 538 539 return 0; 540 } 541 542 /** 543 * ice_flash_component - Flash a component of the NVM 544 * @context: PLDM fw update structure 545 * @component: the component table to program 546 * 547 * Program the flash contents for a given component. First, determine the 548 * module id. Then, erase the secondary bank for this module. Finally, write 549 * the contents of the component to the NVM. 550 * 551 * Note this function assumes the caller has acquired the NVM resource. 552 * 553 * Returns: zero on success, or a negative error code on failure. 554 */ 555 static int 556 ice_flash_component(struct pldmfw *context, struct pldmfw_component *component) 557 { 558 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context); 559 struct netlink_ext_ack *extack = priv->extack; 560 struct ice_pf *pf = priv->pf; 561 const char *name; 562 u16 module; 563 u8 flag; 564 int err; 565 566 switch (component->identifier) { 567 case NVM_COMP_ID_OROM: 568 module = ICE_SR_1ST_OROM_BANK_PTR; 569 flag = ICE_AQC_NVM_ACTIV_SEL_OROM; 570 name = "fw.undi"; 571 break; 572 case NVM_COMP_ID_NVM: 573 module = ICE_SR_1ST_NVM_BANK_PTR; 574 flag = ICE_AQC_NVM_ACTIV_SEL_NVM; 575 name = "fw.mgmt"; 576 break; 577 case NVM_COMP_ID_NETLIST: 578 module = ICE_SR_NETLIST_BANK_PTR; 579 flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST; 580 name = "fw.netlist"; 581 break; 582 default: 583 /* This should not trigger, since we check the id before 584 * sending the component table to firmware. 585 */ 586 WARN(1, "Unexpected unknown component identifier 0x%02x", 587 component->identifier); 588 return -EINVAL; 589 } 590 591 /* Mark this component for activating at the end */ 592 priv->activate_flags |= flag; 593 594 err = ice_erase_nvm_module(pf, module, name, extack); 595 if (err) 596 return err; 597 598 return ice_write_nvm_module(pf, module, name, component->component_data, 599 component->component_size, extack); 600 } 601 602 /** 603 * ice_finalize_update - Perform last steps to complete device update 604 * @context: PLDM fw update structure 605 * 606 * Called as the last step of the update process. Complete the update by 607 * telling the firmware to switch active banks, and perform a reset of 608 * configured. 609 * 610 * Returns: 0 on success, or an error code on failure. 611 */ 612 static int ice_finalize_update(struct pldmfw *context) 613 { 614 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context); 615 struct netlink_ext_ack *extack = priv->extack; 616 struct ice_pf *pf = priv->pf; 617 int err; 618 619 /* Finally, notify firmware to activate the written NVM banks */ 620 err = ice_switch_flash_banks(pf, priv->activate_flags, extack); 621 if (err) 622 return err; 623 624 return 0; 625 } 626 627 static const struct pldmfw_ops ice_fwu_ops = { 628 .match_record = &pldmfw_op_pci_match_record, 629 .send_package_data = &ice_send_package_data, 630 .send_component_table = &ice_send_component_table, 631 .flash_component = &ice_flash_component, 632 .finalize_update = &ice_finalize_update, 633 }; 634 635 /** 636 * ice_flash_pldm_image - Write a PLDM-formatted firmware image to the device 637 * @pf: private device driver structure 638 * @fw: firmware object pointing to the relevant firmware file 639 * @extack: netlink extended ACK structure 640 * 641 * Parse the data for a given firmware file, verifying that it is a valid PLDM 642 * formatted image that matches this device. 643 * 644 * Extract the device record Package Data and Component Tables and send them 645 * to the firmware. Extract and write the flash data for each of the three 646 * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify 647 * firmware once the data is written to the inactive banks. 648 * 649 * Returns: zero on success or a negative error code on failure. 650 */ 651 int ice_flash_pldm_image(struct ice_pf *pf, const struct firmware *fw, 652 struct netlink_ext_ack *extack) 653 { 654 struct device *dev = ice_pf_to_dev(pf); 655 struct ice_hw *hw = &pf->hw; 656 struct ice_fwu_priv priv; 657 enum ice_status status; 658 int err; 659 660 memset(&priv, 0, sizeof(priv)); 661 662 priv.context.ops = &ice_fwu_ops; 663 priv.context.dev = dev; 664 priv.extack = extack; 665 priv.pf = pf; 666 priv.activate_flags = ICE_AQC_NVM_PRESERVE_ALL; 667 668 status = ice_acquire_nvm(hw, ICE_RES_WRITE); 669 if (status) { 670 dev_err(dev, "Failed to acquire device flash lock, err %s aq_err %s\n", 671 ice_stat_str(status), 672 ice_aq_str(hw->adminq.sq_last_status)); 673 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock"); 674 return -EIO; 675 } 676 677 err = pldmfw_flash_image(&priv.context, fw); 678 679 ice_release_nvm(hw); 680 681 return err; 682 } 683 684 /** 685 * ice_check_for_pending_update - Check for a pending flash update 686 * @pf: the PF driver structure 687 * @component: if not NULL, the name of the component being updated 688 * @extack: Netlink extended ACK structure 689 * 690 * Check whether the device already has a pending flash update. If such an 691 * update is found, cancel it so that the requested update may proceed. 692 * 693 * Returns: zero on success, or a negative error code on failure. 694 */ 695 int ice_check_for_pending_update(struct ice_pf *pf, const char *component, 696 struct netlink_ext_ack *extack) 697 { 698 struct devlink *devlink = priv_to_devlink(pf); 699 struct device *dev = ice_pf_to_dev(pf); 700 struct ice_hw_dev_caps *dev_caps; 701 struct ice_hw *hw = &pf->hw; 702 enum ice_status status; 703 u8 pending = 0; 704 int err; 705 706 dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL); 707 if (!dev_caps) 708 return -ENOMEM; 709 710 /* Read the most recent device capabilities from firmware. Do not use 711 * the cached values in hw->dev_caps, because the pending update flag 712 * may have changed, e.g. if an update was previously completed and 713 * the system has not yet rebooted. 714 */ 715 status = ice_discover_dev_caps(hw, dev_caps); 716 if (status) { 717 NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities"); 718 kfree(dev_caps); 719 return -EIO; 720 } 721 722 if (dev_caps->common_cap.nvm_update_pending_nvm) { 723 dev_info(dev, "The fw.mgmt flash component has a pending update\n"); 724 pending |= ICE_AQC_NVM_ACTIV_SEL_NVM; 725 } 726 727 if (dev_caps->common_cap.nvm_update_pending_orom) { 728 dev_info(dev, "The fw.undi flash component has a pending update\n"); 729 pending |= ICE_AQC_NVM_ACTIV_SEL_OROM; 730 } 731 732 if (dev_caps->common_cap.nvm_update_pending_netlist) { 733 dev_info(dev, "The fw.netlist flash component has a pending update\n"); 734 pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST; 735 } 736 737 kfree(dev_caps); 738 739 /* If the flash_update request is for a specific component, ignore all 740 * of the other components. 741 */ 742 if (component) { 743 if (strcmp(component, "fw.mgmt") == 0) 744 pending &= ICE_AQC_NVM_ACTIV_SEL_NVM; 745 else if (strcmp(component, "fw.undi") == 0) 746 pending &= ICE_AQC_NVM_ACTIV_SEL_OROM; 747 else if (strcmp(component, "fw.netlist") == 0) 748 pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST; 749 else 750 WARN(1, "Unexpected flash component %s", component); 751 } 752 753 /* There is no previous pending update, so this request may continue */ 754 if (!pending) 755 return 0; 756 757 /* In order to allow overwriting a previous pending update, notify 758 * firmware to cancel that update by issuing the appropriate command. 759 */ 760 devlink_flash_update_status_notify(devlink, 761 "Canceling previous pending update", 762 component, 0, 0); 763 764 status = ice_acquire_nvm(hw, ICE_RES_WRITE); 765 if (status) { 766 dev_err(dev, "Failed to acquire device flash lock, err %s aq_err %s\n", 767 ice_stat_str(status), 768 ice_aq_str(hw->adminq.sq_last_status)); 769 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock"); 770 return -EIO; 771 } 772 773 pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV; 774 err = ice_switch_flash_banks(pf, pending, extack); 775 776 ice_release_nvm(hw); 777 778 return err; 779 } 780