linux/drivers/net/ethernet/intel/ice/ice_fw_update.c
<<
>>
Prefs
   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
  11struct 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 */
  35static int
  36ice_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 */
  82static int
  83ice_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 */
 195static int
 196ice_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 */
 271static int
 272ice_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 */
 361static int
 362ice_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 */
 439static int
 440ice_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
 499out_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 */
 521static 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 */
 575static int
 576ice_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 */
 632static 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
 642static 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 */
 667int 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 */
 722int 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