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