drivers/net/ethernet/intel/ice/ice_fw_update.c

   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         if (err == -ENOENT) {
 706                 dev_err(dev, "Firmware image has no record matching this device\n");
 707                 NL_SET_ERR_MSG_MOD(extack, "Firmware image has no record matching this device");
 708         } else if (err) {
 709                 /* Do not set a generic extended ACK message here. A more
 710                  * specific message may already have been set by one of our
 711                  * ops.
 712                  */
 713                 dev_err(dev, "Failed to flash PLDM image, err %d", err);
 714         }
 715
 716         ice_release_nvm(hw);
 717
 718         return err;
 719 }
 720
 721 /**
 722  * ice_check_for_pending_update - Check for a pending flash update
 723  * @pf: the PF driver structure
 724  * @component: if not NULL, the name of the component being updated
 725  * @extack: Netlink extended ACK structure
 726  *
 727  * Check whether the device already has a pending flash update. If such an
 728  * update is found, cancel it so that the requested update may proceed.
 729  *
 730  * Returns: zero on success, or a negative error code on failure.
 731  */
 732 int ice_check_for_pending_update(struct ice_pf *pf, const char *component,
 733                                  struct netlink_ext_ack *extack)
 734 {
 735         struct devlink *devlink = priv_to_devlink(pf);
 736         struct device *dev = ice_pf_to_dev(pf);
 737         struct ice_hw_dev_caps *dev_caps;
 738         struct ice_hw *hw = &pf->hw;
 739         enum ice_status status;
 740         u8 pending = 0;
 741         int err;
 742
 743         dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
 744         if (!dev_caps)
 745                 return -ENOMEM;
 746
 747         /* Read the most recent device capabilities from firmware. Do not use
 748          * the cached values in hw->dev_caps, because the pending update flag
 749          * may have changed, e.g. if an update was previously completed and
 750          * the system has not yet rebooted.
 751          */
 752         status = ice_discover_dev_caps(hw, dev_caps);
 753         if (status) {
 754                 NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
 755                 kfree(dev_caps);
 756                 return -EIO;
 757         }
 758
 759         if (dev_caps->common_cap.nvm_update_pending_nvm) {
 760                 dev_info(dev, "The fw.mgmt flash component has a pending update\n");
 761                 pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
 762         }
 763
 764         if (dev_caps->common_cap.nvm_update_pending_orom) {
 765                 dev_info(dev, "The fw.undi flash component has a pending update\n");
 766                 pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
 767         }
 768
 769         if (dev_caps->common_cap.nvm_update_pending_netlist) {
 770                 dev_info(dev, "The fw.netlist flash component has a pending update\n");
 771                 pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
 772         }
 773
 774         kfree(dev_caps);
 775
 776         /* If the flash_update request is for a specific component, ignore all
 777          * of the other components.
 778          */
 779         if (component) {
 780                 if (strcmp(component, "fw.mgmt") == 0)
 781                         pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
 782                 else if (strcmp(component, "fw.undi") == 0)
 783                         pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
 784                 else if (strcmp(component, "fw.netlist") == 0)
 785                         pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
 786                 else
 787                         WARN(1, "Unexpected flash component %s", component);
 788         }
 789
 790         /* There is no previous pending update, so this request may continue */
 791         if (!pending)
 792                 return 0;
 793
 794         /* In order to allow overwriting a previous pending update, notify
 795          * firmware to cancel that update by issuing the appropriate command.
 796          */
 797         devlink_flash_update_status_notify(devlink,
 798                                            "Canceling previous pending update",
 799                                            component, 0, 0);
 800
 801         status = ice_acquire_nvm(hw, ICE_RES_WRITE);
 802         if (status) {
 803                 dev_err(dev, "Failed to acquire device flash lock, err %s aq_err %s\n",
 804                         ice_stat_str(status),
 805                         ice_aq_str(hw->adminq.sq_last_status));
 806                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
 807                 return -EIO;
 808         }
 809
 810         pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
 811         err = ice_switch_flash_banks(pf, pending, extack);
 812
 813         ice_release_nvm(hw);
 814
 815         return err;
 816 }