ice: implement display of stored flash versions
Subsystems (2)
cover ice: implement display of stored flash versions
The devlink info interface supports the ability for drivers to report the version of firmware that is stored (downloaded) to the device, but is not yet active.
This series implements support for this in the ice driver, for most flash versions. This includes the UNDI Option ROM, the Netlist module, and the fw.bundle_id.
To support this, two major angles of refactor were necessary. First, the ice driver's main driving loop for reporting versions is refactored to allow for a context structure. This enabled more easily extending the available information without having to permanently cache the firmware values in the driver structures.
Second, the way that we read the firmware versions for most fields needed to change. The existing methods of reading the flash values were based on reading from sections of the initialized Shadow RAM. These values get loaded when the device is booting up. Because of this, they were not capable of being used to report the inactive versions stored within the non-running binary sections we downloaded.
To support this, ice_read_flash_module is further abstracted to think in terms of "active" and "inactive" banks, rather than focusing on "read from the 1st or 2nd bank". Further, the function is extended to allow reading arbitrary sizes beyond just one word at a time.
For each of the 3 major firmware components, the version function is extended to allow requesting the flash bank to read from (active or inactive). To handle this, the exact algorithm used in each function must be changed.
For the main NVM version which includes the bundle_id, this is simple. The location we read from is now the section within the NVM bank that is used to initialize the Shadow RAM.
For the netlist module, we simply replace the module-based reads that request the firmware to handle the low level details with direct calls to read the netlist directly. This slightly changes the offsets we use because the firmware interface strips out the type field at the start of the netlist block.
For the UNDI Option ROM firmware things are not so simple. The existing method for reading the Option ROM requires reading from the Boot Configuration block. This area is populated with the running Option ROM version field when the device is loading the firmware. There is no equivalent for reading the inactive version. Instead of reading from this section, a new algorithm based on scanning for the actual version block data in the Option ROM binary is introduced. This data is encoded within a packed structure that begins with the 4-byte '$CIV' ASCII string, and uses a simple modulo 256 checksum for integrity. We scan the Option ROM section of the flash for this data, rather than reading the copied value in the Boot Configuration block.
With these changes, the ice driver will now report the stored versions for many of the firmware components when an update has been initiated but the device has not yet switched to the new bank. The major exception missing is the management firmware version (fw.mgmt and the related sub fields). This data is not encoded in a way that is easy to parse out from the inactive image. The driver is normally informed of the firmware version as part of its initial messaging over the Admin Queue. It may be theoretically possible to determine where exactly within the firmware binary the version fields are stored, but this is not implemented in this patch.
Jacob Keller (7):
ice: introduce context struct for info report
ice: refactor interface for ice_read_flash_module
ice: allow reading inactive flash security revision
ice: allow reading arbitrary size data with read_flash_module
ice: display some stored NVM versions via devlink info
ice: display stored netlist versions via devlink info
ice: display stored UNDI firmware version via devlink info
.../net/ethernet/intel/ice/ice_adminq_cmd.h | 27 - drivers/net/ethernet/intel/ice/ice_devlink.c | 247 +++++++-- drivers/net/ethernet/intel/ice/ice_main.c | 2 + drivers/net/ethernet/intel/ice/ice_nvm.c | 509 ++++++++++++------ drivers/net/ethernet/intel/ice/ice_nvm.h | 14 + drivers/net/ethernet/intel/ice/ice_status.h | 1 + drivers/net/ethernet/intel/ice/ice_type.h | 52 +- 7 files changed, 609 insertions(+), 243 deletions(-)
base-commit: a96d90adbc085e947f2b02cd744dc32aab9d00ae
Signature · 1 line
2.29.0
PATCH 1/7 ice: introduce context struct for info report
The ice driver uses an array of structures which link an info name with a function that formats the associated version data into a string.
All existing format functions simply format already captured static data from the driver hw structure. Future changes will introduce format functions for reporting the versions of flash sections stored but not yet applied. This type of version data is not stored as a member of the hw structure. This is because (a) it might not yet exist in the case there is no pending flash update, and (b) even if it does, it might change such as if an update is canceled or replaced by a new update before finalizing.
We could simply have each format function gather its own data upon being called. However, in some cases the raw binary version data is a combination of multiple different reported fields. Additionally, the current interface doesn't have a way for the function to indicate that the version doesn't exist.
Refactor this function interface to take a new ice_info_ctx structure instead of the buffer pointer and length. This context structure allows for future extensions to pre-gather version data that is stored within the context struct instead of the hw struct.
Allocate this context structure initially at the start of ice_devlink_info_get. We use dynamic allocation instead of a local stack variable in order to avoid using too much kernel stack once we extend it with additional data structures.
Modify the main loop that drives the info reporting so that the version buffer string is always cleared between each format. Explicitly check that the format function actually filled in a version string of non-zero length. If the string is not provided, simply skip this version without reporting an error. This allows for introducing format functions of versions which may or may not be present, such as the version of a pending update that has not yet been activated.
--- drivers/net/ethernet/intel/ice/ice_devlink.c | 117 ++++++++++++------- 1 file changed, 72 insertions(+), 45 deletions(-)
drivers/net/ethernet/intel/ice/ice_devlink.c +72 -45
@@ -6,144 +6,159 @@#include "ice_devlink.h" #include "ice_fw_update.h" -static void ice_info_get_dsn (struct ice_pf *pf,char *buf,size_t len) +/* context for devlink info version reporting */ +struct ice_info_ctx { +char buf[128 ]; +}; + +/* The following functions are used to format specific strings for various +* devlink info versions. The ctx parameter is used to provide the storage +* buffer, as well as any ancillary information calculated when the info +* request was made. +* +* If a version does not exist, for example a "stored" version that does not +* exist because no update is pending, the function should leave the buffer in +* the ctx structure empty and return 0. +*/ + +static void ice_info_get_dsn (struct ice_pf *pf,struct ice_info_ctx *ctx) {u8 dsn[8 ];/* Copy the DSN into an array in Big Endian format */ put_unaligned_be64 (pci_get_dsn (pf->pdev), dsn); -snprintf (buf, len,"%8phD" , dsn); +snprintf (ctx->buf,sizeof (ctx->buf),"%8phD" , dsn); } -static int ice_info_pba (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_pba (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw;enum ice_status status; - status =ice_read_pba_string (hw, (u8 *)buf, len); + status =ice_read_pba_string (hw, (u8 *)ctx->buf,sizeof (ctx->buf));if (status)return -EIO ;return 0 ; } -static int ice_info_fw_mgmt (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_fw_mgmt (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw; -snprintf (buf, len,"%u.%u.%u" , hw->fw_maj_ver, hw->fw_min_ver, +snprintf (ctx->buf,sizeof (ctx->buf),"%u.%u.%u" , hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch);return 0 ; } -static int ice_info_fw_api (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_fw_api (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw; -snprintf (buf, len,"%u.%u" , hw->api_maj_ver, hw->api_min_ver); +snprintf (ctx->buf,sizeof (ctx->buf),"%u.%u" , hw->api_maj_ver, hw->api_min_ver);return 0 ; } -static int ice_info_fw_build (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_fw_build (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw; -snprintf (buf, len,"0x%08x" , hw->fw_build); +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , hw->fw_build);return 0 ; } -static int ice_info_fw_srev (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_fw_srev (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_nvm_info *nvm = &pf->hw.flash.nvm; -snprintf (buf, len,"%u" , nvm->srev); +snprintf (ctx->buf,sizeof (ctx->buf),"%u" , nvm->srev);return 0 ; } -static int ice_info_orom_ver (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_orom_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_orom_info *orom = &pf->hw.flash.orom; -snprintf (buf, len,"%u.%u.%u" , orom->major, orom->build, orom->patch); +snprintf (ctx->buf,sizeof (ctx->buf),"%u.%u.%u" , orom->major, orom->build, orom->patch);return 0 ; } -static int ice_info_orom_srev (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_orom_srev (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_orom_info *orom = &pf->hw.flash.orom; -snprintf (buf, len,"%u" , orom->srev); +snprintf (ctx->buf,sizeof (ctx->buf),"%u" , orom->srev);return 0 ; } -static int ice_info_nvm_ver (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_nvm_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_nvm_info *nvm = &pf->hw.flash.nvm; -snprintf (buf, len,"%x.%02x" , nvm->major, nvm->minor); +snprintf (ctx->buf,sizeof (ctx->buf),"%x.%02x" , nvm->major, nvm->minor);return 0 ; } -static int ice_info_eetrack (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_eetrack (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_nvm_info *nvm = &pf->hw.flash.nvm; -snprintf (buf, len,"0x%08x" , nvm->eetrack); +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , nvm->eetrack);return 0 ; } -static int ice_info_ddp_pkg_name (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_ddp_pkg_name (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw; -snprintf (buf, len,"%s" , hw->active_pkg_name); +snprintf (ctx->buf,sizeof (ctx->buf),"%s" , hw->active_pkg_name);return 0 ; } -static int ice_info_ddp_pkg_version (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_ddp_pkg_version (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_pkg_ver *pkg = &pf->hw.active_pkg_ver; -snprintf (buf, len,"%u.%u.%u.%u" , pkg->major, pkg->minor, pkg->update, +snprintf (ctx->buf,sizeof (ctx->buf),"%u.%u.%u.%u" , pkg->major, pkg->minor, pkg->update, pkg->draft);return 0 ; } -static int ice_info_ddp_pkg_bundle_id (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_ddp_pkg_bundle_id (struct ice_pf *pf,struct ice_info_ctx *ctx) { -snprintf (buf, len,"0x%08x" , pf->hw.active_track_id); +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , pf->hw.active_track_id);return 0 ; } -static int ice_info_netlist_ver (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_netlist_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_netlist_info *netlist = &pf->hw.flash.netlist;/* The netlist version fields are BCD formatted */ -snprintf (buf, len,"%x.%x.%x-%x.%x.%x" , netlist->major, netlist->minor, +snprintf (ctx->buf,sizeof (ctx->buf),"%x.%x.%x-%x.%x.%x" , netlist->major, netlist->minor, netlist->type >>16 , netlist->type &0xFFFF , netlist->rev, netlist->cust_ver);return 0 ; } -static int ice_info_netlist_build (struct ice_pf *pf,char *buf,size_t len) +static int ice_info_netlist_build (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_netlist_info *netlist = &pf->hw.flash.netlist; -snprintf (buf, len,"0x%08x" , netlist->hash); +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , netlist->hash);return 0 ; }
@@ -160,7 +175,7 @@ enum ice_version_type {static const struct ice_devlink_version {enum ice_version_type type;const char *key; -int (*getter)(struct ice_pf *pf,char *buf,size_t len); +int (*getter)(struct ice_pf *pf,struct ice_info_ctx *ctx); } ice_devlink_versions[] = {fixed (DEVLINK_INFO_VERSION_GENERIC_BOARD_ID , ice_info_pba),running (DEVLINK_INFO_VERSION_GENERIC_FW_MGMT , ice_info_fw_mgmt),
@@ -194,60 +209,72 @@ static int ice_devlink_info_get(struct devlink *devlink, struct netlink_ext_ack *extack) {struct ice_pf *pf =devlink_priv (devlink); -char buf[100 ]; +struct ice_info_ctx *ctx;size_t i;int err; + ctx =kzalloc (sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return -ENOMEM ; + err =devlink_info_driver_name_put (req,KBUILD_MODNAME );if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set driver name" ); -return err; + goto out_free_ctx; } -ice_info_get_dsn (pf, buf,sizeof (buf)); +ice_info_get_dsn (pf, ctx); - err =devlink_info_serial_number_put (req, buf); + err =devlink_info_serial_number_put (req, ctx->buf);if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set serial number" ); -return err; + goto out_free_ctx; }for (i =0 ; i <ARRAY_SIZE (ice_devlink_versions); i++) {enum ice_version_type type = ice_devlink_versions[i].type;const char *key = ice_devlink_versions[i].key; - err = ice_devlink_versions[i].getter (pf, buf,sizeof (buf)); +memset (ctx->buf,0 ,sizeof (ctx->buf)); + + err = ice_devlink_versions[i].getter (pf, ctx);if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to obtain version info" ); -return err; + goto out_free_ctx; } +/* Do not report missing versions */ +if (ctx->buf[0 ] =='\0' ) +continue ; +switch (type) {case ICE_VERSION_FIXED : - err =devlink_info_version_fixed_put (req, key, buf); + err =devlink_info_version_fixed_put (req, key, ctx->buf);if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set fixed version" ); -return err; + goto out_free_ctx; }break ;case ICE_VERSION_RUNNING : - err =devlink_info_version_running_put (req, key, buf); + err =devlink_info_version_running_put (req, key, ctx->buf);if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set running version" ); -return err; + goto out_free_ctx; }break ;case ICE_VERSION_STORED : - err =devlink_info_version_stored_put (req, key, buf); + err =devlink_info_version_stored_put (req, key, ctx->buf);if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set stored version" ); -return err; + goto out_free_ctx; }break ; } } -return 0 ; +out_free_ctx: +kfree (ctx); +return err; }enum ice_devlink_param_id {
Signature · 1 line
2.29.0
PATCH 2/7 ice: refactor interface for ice_read_flash_module
In reply to Jacob KellerThe ice_read_flash_module interface for reading from the various NVM modules was introduced in commit 682fa08580ac ("ice: read security revision to ice_nvm_info and ice_orom_info")
It's purpose is two-fold. First, it enables reading data from the CSS header, used to allow accessing the image security revisions. Second, it allowed reading from either the 1st or the 2nd NVM bank. This interface was necessary because the device has two copies of each module. Only one bank is active at a time, but it could be different for each module. The driver had to determine which bank was active and then use that to calculate the offset into the flash to read.
Future plans include allowing access to read not just from the active flash bank, but also the inactive bank. This will be useful for enabling display of the version information for a pending flash update.
The current abstraction in ice_read_flash_module is to specify the exact bank to read. This requires callers to know whether to read from the 1st or 2nd flash bank. This is the wrong abstraction level, since in most cases the decision point from a caller's perspective is whether to read from the active bank or the inactive bank.
Add a new ice_bank_select enumeration, used to indicate whether a flow wants to read from the active, or inactive flash bank. Refactor ice_read_flash_module to take this new enumeration instead of a raw flash bank.
Have ice_read_flash_module select which bank to read from based on the cached data we load during NVM initialization. With this change, it will be come easier to implement reading version data from the inactive flash banks in a future change.
--- drivers/net/ethernet/intel/ice/ice_nvm.c | 116 +++++++++++++++------- drivers/net/ethernet/intel/ice/ice_type.h | 9 ++ 2 files changed, 91 insertions(+), 34 deletions(-)
drivers/net/ethernet/intel/ice/ice_nvm.c +82 -34
@@ -233,6 +233,74 @@ void ice_release_nvm(struct ice_hw *hw)ice_release_res (hw,ICE_NVM_RES_ID ); } +/** +* ice_get_flash_bank_offset - Get offset into requested flash bank +* @hw: pointer to the HW structure +* @bank: whether to read from the active or inactive flash bank +* @module: the module to read from +* +* Based on the module, lookup the module offset from the beginning of the +* flash. +* +* Returns the flash offset. Note that a value of zero is invalid and must be +* treated as an error. +*/ +static u32 ice_get_flash_bank_offset (struct ice_hw *hw,enum ice_bank_select bank,u16 module) +{ +struct ice_bank_info *banks = &hw->flash.banks; +enum ice_flash_bank active_bank; +bool second_bank_active; +u32 offset, size; + +switch (module) { +case ICE_SR_1ST_NVM_BANK_PTR : + offset = banks->nvm_ptr; + size = banks->nvm_size; + active_bank = banks->nvm_bank; +break ; +case ICE_SR_1ST_OROM_BANK_PTR : + offset = banks->orom_ptr; + size = banks->orom_size; + active_bank = banks->orom_bank; +break ; +case ICE_SR_NETLIST_BANK_PTR : + offset = banks->netlist_ptr; + size = banks->netlist_size; + active_bank = banks->netlist_bank; +break ; +default : +ice_debug (hw,ICE_DBG_NVM ,"Unexpected value for flash module: 0x%04x\n" , module); +return 0 ; + } + +switch (active_bank) { +case ICE_1ST_FLASH_BANK : + second_bank_active = false; +break ; +case ICE_2ND_FLASH_BANK : + second_bank_active = true; +break ; +default : +ice_debug (hw,ICE_DBG_NVM ,"Unexpected value for active flash bank: %u\n" , + active_bank); +return 0 ; + } + +/* The second flash bank is stored immediately following the first +* bank. Based on whether the 1st or 2nd bank is active, and whether +* we want the active or inactive bank, calculate the desired offset. +*/ +switch (bank) { +case ICE_ACTIVE_FLASH_BANK : +return offset + (second_bank_active ? size :0 ); +case ICE_INACTIVE_FLASH_BANK : +return offset + (second_bank_active ?0 : size); + } + +ice_debug (hw,ICE_DBG_NVM ,"Unexpected value for flash bank selection: %u\n" , bank); +return 0 ; +} +/** * ice_read_flash_module - Read a word from one of the main NVM modules * @hw: pointer to the HW structure
@@ -241,47 +309,27 @@ void ice_release_nvm(struct ice_hw *hw)* @offset: the offset into the module in words * @data: storage for the word read from the flash * -* Read a word from the specified bank of the module. The bank must be either -* the 1st or 2nd bank. The word will be read using flat NVM access, and -* relies on the hw->flash.banks data being setup by -* ice_determine_active_flash_banks() during initialization. +* Read a word from the specified flash module. The bank parameter indicates +* whether or not to read from the active bank or the inactive bank of that +* module. +* +* The word will be read using flat NVM access, and relies on the +* hw->flash.banks data being setup by ice_determine_active_flash_banks() +* during initialization. */ static enum ice_status -ice_read_flash_module (struct ice_hw *hw,enum ice_flash_bank bank,u16 module, +ice_read_flash_module (struct ice_hw *hw,enum ice_bank_select bank,u16 module,u32 offset,u16 *data) { -struct ice_bank_info *banks = &hw->flash.banks;u32 bytes =sizeof (u16);enum ice_status status;__le16 data_local; -bool second_bank;u32 start; -switch (bank) { -case ICE_1ST_FLASH_BANK : - second_bank = false; -break ; -case ICE_2ND_FLASH_BANK : - second_bank = true; -break ; -case ICE_INVALID_FLASH_BANK : -default : -ice_debug (hw,ICE_DBG_NVM ,"Unexpected flash bank %u\n" , bank); -return ICE_ERR_PARAM ; - } - -switch (module) { -case ICE_SR_1ST_NVM_BANK_PTR : - start = banks->nvm_ptr + (second_bank ? banks->nvm_size :0 ); -break ; -case ICE_SR_1ST_OROM_BANK_PTR : - start = banks->orom_ptr + (second_bank ? banks->orom_size :0 ); -break ; -case ICE_SR_NETLIST_BANK_PTR : - start = banks->netlist_ptr + (second_bank ? banks->netlist_size :0 ); -break ; -default : -ice_debug (hw,ICE_DBG_NVM ,"Unexpected flash module 0x%04x\n" , module); + start =ice_get_flash_bank_offset (hw, bank, module); +if (!start) { +ice_debug (hw,ICE_DBG_NVM ,"Unable to calculate flash bank offset for module 0x%04x\n" , + module);return ICE_ERR_PARAM ; }
@@ -311,7 +359,7 @@ ice_read_flash_module(struct ice_hw *hw, enum ice_flash_bank bank, u16 module,static enum ice_status ice_read_active_nvm_module (struct ice_hw *hw,u32 offset,u16 *data) { -return ice_read_flash_module (hw, hw->flash.banks.nvm_bank, +return ice_read_flash_module (hw,ICE_ACTIVE_FLASH_BANK ,ICE_SR_1ST_NVM_BANK_PTR , offset, data); }
@@ -328,7 +376,7 @@ ice_read_active_nvm_module(struct ice_hw *hw, u32 offset, u16 *data)static enum ice_status ice_read_active_orom_module (struct ice_hw *hw,u32 offset,u16 *data) { -return ice_read_flash_module (hw, hw->flash.banks.orom_bank, +return ice_read_flash_module (hw,ICE_ACTIVE_FLASH_BANK ,ICE_SR_1ST_OROM_BANK_PTR , offset, data); }
drivers/net/ethernet/intel/ice/ice_type.h +9 -0
@@ -350,6 +350,15 @@ enum ice_flash_bank { ICE_2ND_FLASH_BANK, }; +/* Enumeration of which flash bank is desired to read from, either the active +* bank or the inactive bank. Used to abstract 1st and 2nd bank notion from +* code which just wants to read the active or inactive flash bank. +*/ +enum ice_bank_select { +ICE_ACTIVE_FLASH_BANK , +ICE_INACTIVE_FLASH_BANK , +}; +/* information for accessing NVM, OROM, and Netlist flash banks */ struct ice_bank_info {u32 nvm_ptr;/* Pointer to 1st NVM bank */
Signature · 1 line
2.29.0
PATCH 3/7 ice: allow reading inactive flash security revision
In reply to Jacob KellerModify ice_get_nvm_srev and ice_get_orom_srev to take the ice_flash_bank enumeration that specifies whether to read from the active or the inactive flash module. Rename and refactor the ice_read_active_nvm_module and ice_read_active_orom_module functions to take the bank enum value as well.
With this change, ice_get_nvm_srev and ice_get_orom_srev will be usable in a future change to implement reading the version data for a pending flash image.
--- drivers/net/ethernet/intel/ice/ice_nvm.c | 36 +++++++++++++----------- 1 file changed, 19 insertions(+), 17 deletions(-)
drivers/net/ethernet/intel/ice/ice_nvm.c +19 -17
@@ -348,8 +348,9 @@ ice_read_flash_module(struct ice_hw *hw, enum ice_bank_select bank, u16 module, }/** -* ice_read_active_nvm_module - Read from the active main NVM module +* ice_read_nvm_module - Read from the active main NVM module * @hw: pointer to the HW structure +* @bank: whether to read from active or inactive NVM module * @offset: offset into the NVM module to read, in words * @data: storage for returned word value *
@@ -357,15 +358,15 @@ ice_read_flash_module(struct ice_hw *hw, enum ice_bank_select bank, u16 module,* header at the start of the NVM module. */ static enum ice_status -ice_read_active_nvm_module (struct ice_hw *hw,u32 offset,u16 *data) +ice_read_nvm_module (struct ice_hw *hw,enum ice_bank_select bank,u32 offset,u16 *data) { -return ice_read_flash_module (hw,ICE_ACTIVE_FLASH_BANK , -ICE_SR_1ST_NVM_BANK_PTR , offset, data); +return ice_read_flash_module (hw, bank,ICE_SR_1ST_NVM_BANK_PTR , offset, data); }/** -* ice_read_active_orom_module - Read from the active Option ROM module +* ice_read_orom_module - Read from the active Option ROM module * @hw: pointer to the HW structure +* @bank: whether to read from active or inactive OROM module * @offset: offset into the OROM module to read, in words * @data: storage for returned word value *
@@ -374,10 +375,9 @@ ice_read_active_nvm_module(struct ice_hw *hw, u32 offset, u16 *data)* module instead of at the beginning. */ static enum ice_status -ice_read_active_orom_module (struct ice_hw *hw,u32 offset,u16 *data) +ice_read_orom_module (struct ice_hw *hw,enum ice_bank_select bank,u32 offset,u16 *data) { -return ice_read_flash_module (hw,ICE_ACTIVE_FLASH_BANK , -ICE_SR_1ST_OROM_BANK_PTR , offset, data); +return ice_read_flash_module (hw, bank,ICE_SR_1ST_OROM_BANK_PTR , offset, data); }/**
@@ -529,21 +529,22 @@ ice_read_pba_string(struct ice_hw *hw, u8 *pba_num, u32 pba_num_size)/** * ice_get_nvm_srev - Read the security revision from the NVM CSS header * @hw: pointer to the HW struct +* @bank: whether to read from the active or inactive flash bank * @srev: storage for security revision * * Read the security revision out of the CSS header of the active NVM module * bank. */ -static enum ice_status ice_get_nvm_srev (struct ice_hw *hw,u32 *srev) +static enum ice_status ice_get_nvm_srev (struct ice_hw *hw,enum ice_bank_select bank,u32 *srev) {enum ice_status status;u16 srev_l, srev_h; - status =ice_read_active_nvm_module (hw,ICE_NVM_CSS_SREV_L , &srev_l); + status =ice_read_nvm_module (hw, bank,ICE_NVM_CSS_SREV_L , &srev_l);if (status)return status; - status =ice_read_active_nvm_module (hw,ICE_NVM_CSS_SREV_H , &srev_h); + status =ice_read_nvm_module (hw, bank,ICE_NVM_CSS_SREV_H , &srev_h);if (status)return status;
@@ -587,7 +588,7 @@ ice_get_nvm_ver_info(struct ice_hw *hw, struct ice_nvm_info *nvm) nvm->eetrack = (eetrack_hi <<16 ) | eetrack_lo; - status =ice_get_nvm_srev (hw, &nvm->srev); + status =ice_get_nvm_srev (hw,ICE_ACTIVE_FLASH_BANK , &nvm->srev);if (status)ice_debug (hw,ICE_DBG_NVM ,"Failed to read NVM security revision.\n" );
@@ -597,12 +598,13 @@ ice_get_nvm_ver_info(struct ice_hw *hw, struct ice_nvm_info *nvm)/** * ice_get_orom_srev - Read the security revision from the OROM CSS header * @hw: pointer to the HW struct +* @bank: whether to read from active or inactive flash module * @srev: storage for security revision * * Read the security revision out of the CSS header of the active OROM module * bank. */ -static enum ice_status ice_get_orom_srev (struct ice_hw *hw,u32 *srev) +static enum ice_status ice_get_orom_srev (struct ice_hw *hw,enum ice_bank_select bank,u32 *srev) {enum ice_status status;u16 srev_l, srev_h;
@@ -615,16 +617,16 @@ static enum ice_status ice_get_orom_srev(struct ice_hw *hw, u32 *srev) }/* calculate how far into the Option ROM the CSS header starts. Note -* that ice_read_active_orom_module takes a word offset so we need to +* that ice_read_orom_module takes a word offset so we need to * divide by 2 here. */ css_start = (hw->flash.banks.orom_size -ICE_NVM_OROM_TRAILER_LENGTH ) /2 ; - status =ice_read_active_orom_module (hw, css_start +ICE_NVM_CSS_SREV_L , &srev_l); + status =ice_read_orom_module (hw, bank, css_start +ICE_NVM_CSS_SREV_L , &srev_l);if (status)return status; - status =ice_read_active_orom_module (hw, css_start +ICE_NVM_CSS_SREV_H , &srev_h); + status =ice_read_orom_module (hw, bank, css_start +ICE_NVM_CSS_SREV_H , &srev_h);if (status)return status;
@@ -685,7 +687,7 @@ ice_get_orom_ver_info(struct ice_hw *hw, struct ice_orom_info *orom) orom->build = (u16)((combo_ver &ICE_OROM_VER_BUILD_MASK ) >>ICE_OROM_VER_BUILD_SHIFT ); - status =ice_get_orom_srev (hw, &orom->srev); + status =ice_get_orom_srev (hw,ICE_ACTIVE_FLASH_BANK , &orom->srev);if (status)ice_debug (hw,ICE_DBG_NVM ,"Failed to read Option ROM security revision.\n" );
Signature · 1 line
2.29.0
PATCH 4/7 ice: allow reading arbitrary size data with read_flash_module
In reply to Jacob KellerRefactor ice_read_flash_module so that it takes a size and a length value, rather than always reading in 2-byte increments. The ice_read_nvm_module and ice_read_orom_module wrapper functions will still read a u16 with the byte-swapping enabled.
This will be used in a future change to implement reading of the CIVD data from the Option ROM module.
--- drivers/net/ethernet/intel/ice/ice_nvm.c | 34 ++++++++++++++++-------- 1 file changed, 23 insertions(+), 11 deletions(-)
drivers/net/ethernet/intel/ice/ice_nvm.c +23 -11
@@ -306,10 +306,11 @@ static u32 ice_get_flash_bank_offset(struct ice_hw *hw, enum ice_bank_select ban* @hw: pointer to the HW structure * @bank: which bank of the module to read * @module: the module to read -* @offset: the offset into the module in words +* @offset: the offset into the module in bytes * @data: storage for the word read from the flash +* @length: bytes of data to read * -* Read a word from the specified flash module. The bank parameter indicates +* Read data from the specified flash module. The bank parameter indicates * whether or not to read from the active bank or the inactive bank of that * module. *
@@ -319,11 +320,9 @@ static u32 ice_get_flash_bank_offset(struct ice_hw *hw, enum ice_bank_select ban*/ static enum ice_status ice_read_flash_module (struct ice_hw *hw,enum ice_bank_select bank,u16 module, -u32 offset,u16 *data) +u32 offset,u8 *data,u32 length) { -u32 bytes =sizeof (u16);enum ice_status status; -__le16 data_local;u32 start; start =ice_get_flash_bank_offset (hw, bank, module);
@@ -337,10 +336,7 @@ ice_read_flash_module(struct ice_hw *hw, enum ice_bank_select bank, u16 module,if (status)return status; - status =ice_read_flat_nvm (hw, start + offset *sizeof (u16), &bytes, - (__force u8 *)&data_local, false); -if (!status) - *data =le16_to_cpu (data_local); + status =ice_read_flat_nvm (hw, start + offset, &length, data, false);ice_release_nvm (hw);
@@ -360,7 +356,15 @@ ice_read_flash_module(struct ice_hw *hw, enum ice_bank_select bank, u16 module,static enum ice_status ice_read_nvm_module (struct ice_hw *hw,enum ice_bank_select bank,u32 offset,u16 *data) { -return ice_read_flash_module (hw, bank,ICE_SR_1ST_NVM_BANK_PTR , offset, data); +enum ice_status status; +__le16 data_local; + + status =ice_read_flash_module (hw, bank,ICE_SR_1ST_NVM_BANK_PTR , offset *sizeof (u16), + (__force u8 *)&data_local,sizeof (u16)); +if (!status) + *data =le16_to_cpu (data_local); + +return status; }/**
@@ -377,7 +381,15 @@ ice_read_nvm_module(struct ice_hw *hw, enum ice_bank_select bank, u32 offset, u1static enum ice_status ice_read_orom_module (struct ice_hw *hw,enum ice_bank_select bank,u32 offset,u16 *data) { -return ice_read_flash_module (hw, bank,ICE_SR_1ST_OROM_BANK_PTR , offset, data); +enum ice_status status; +__le16 data_local; + + status =ice_read_flash_module (hw, bank,ICE_SR_1ST_OROM_BANK_PTR , offset *sizeof (u16), + (__force u8 *)&data_local,sizeof (u16)); +if (!status) + *data =le16_to_cpu (data_local); + +return status; }/**
Signature · 1 line
2.29.0
PATCH 5/7 ice: display some stored NVM versions via devlink info
In reply to Jacob KellerThe devlink info interface supports drivers reporting "stored" versions. These versions indicate the version of an update that has been downloaded to the device, but is not yet active.
Add a new function to read some of the fw.mgmt version data from the inactive flash section. This function, ice_get_inactive_nvm_ver, will read the NVM version data from the inactive section of flash.
To avoid code duplication, we refactor ice_get_nvm_ver_info so that it takes the bank parameter for specifying which flash bank to read from. Instead of reading from the copy stored in the Shadow RAM, always read from the copy of the specified flash bank.
Note that the start of the Shadow RAM copy is not directly following the CSS header, but is actually aligned to the next 64-byte boundary. The correct word offset must be rounded up to 32-bytes.
When reporting the versions via devlink info, first read the device capabilities. If there is a pending flash update, use this new function to extract the inactive flash versions. Add the stored fields to the flash version map structure so that they will be displayed when available.
It should be noted that it is not currently feasible to extract all of the related versions for the management firmware. This patch adds support for displaying "fw.mgmt.srev", "fw.psid.api", and "fw.bundle_id". The management firmware versions are more difficult to extract from the binary and have not been implemented in this change.
Future changes will introduce support for reading the UNDI Option ROM version and the version associated with the Netlist module.
--- drivers/net/ethernet/intel/ice/ice_devlink.c | 57 ++++++++++++++++++++ drivers/net/ethernet/intel/ice/ice_nvm.c | 44 ++++++++++++--- drivers/net/ethernet/intel/ice/ice_nvm.h | 2 + drivers/net/ethernet/intel/ice/ice_type.h | 8 ++- 4 files changed, 104 insertions(+), 7 deletions(-)
drivers/net/ethernet/intel/ice/ice_devlink.c +57 -0
@@ -9,6 +9,8 @@/* context for devlink info version reporting */ struct ice_info_ctx {char buf[128 ]; +struct ice_nvm_info pending_nvm; +struct ice_hw_dev_caps dev_caps; };/* The following functions are used to format specific strings for various
@@ -80,6 +82,16 @@ static int ice_info_fw_srev(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_fw_srev (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_nvm_info *nvm = &ctx->pending_nvm; + +if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) +snprintf (ctx->buf,sizeof (ctx->buf),"%u" , nvm->srev); + +return 0 ; +} +static int ice_info_orom_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_orom_info *orom = &pf->hw.flash.orom;
@@ -107,6 +119,16 @@ static int ice_info_nvm_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_nvm_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_nvm_info *nvm = &ctx->pending_nvm; + +if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) +snprintf (ctx->buf,sizeof (ctx->buf),"%x.%02x" , nvm->major, nvm->minor); + +return 0 ; +} +static int ice_info_eetrack (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
@@ -116,6 +138,16 @@ static int ice_info_eetrack(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_eetrack (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_nvm_info *nvm = &ctx->pending_nvm; + +if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , nvm->eetrack); + +return 0 ; +} +static int ice_info_ddp_pkg_name (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_hw *hw = &pf->hw;
@@ -165,6 +197,7 @@ static int ice_info_netlist_build(struct ice_pf *pf, struct ice_info_ctx *ctx)#define fixed (key, getter) { ICE_VERSION_FIXED, key, getter }#define running (key, getter) { ICE_VERSION_RUNNING, key, getter } +#define stored (key, getter) { ICE_VERSION_STORED, key, getter }enum ice_version_type {ICE_VERSION_FIXED ,
@@ -182,10 +215,13 @@ static const struct ice_devlink_version {running ("fw.mgmt.api" , ice_info_fw_api),running ("fw.mgmt.build" , ice_info_fw_build),running ("fw.mgmt.srev" , ice_info_fw_srev), +stored ("fw.mgmt.srev" , ice_info_pending_fw_srev),running (DEVLINK_INFO_VERSION_GENERIC_FW_UNDI , ice_info_orom_ver),running ("fw.undi.srev" , ice_info_orom_srev),running ("fw.psid.api" , ice_info_nvm_ver), +stored ("fw.psid.api" , ice_info_pending_nvm_ver),running (DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID , ice_info_eetrack), +stored (DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID , ice_info_pending_eetrack),running ("fw.app.name" , ice_info_ddp_pkg_name),running (DEVLINK_INFO_VERSION_GENERIC_FW_APP , ice_info_ddp_pkg_version), running("fw.app.bundle_id", ice_info_ddp_pkg_bundle_id),
@@ -209,7 +245,10 @@ static int ice_devlink_info_get(struct devlink *devlink, struct netlink_ext_ack *extack) {struct ice_pf *pf =devlink_priv (devlink); +struct device *dev =ice_pf_to_dev (pf); +struct ice_hw *hw = &pf->hw;struct ice_info_ctx *ctx; +enum ice_status status;size_t i;int err;
@@ -217,6 +256,24 @@ static int ice_devlink_info_get(struct devlink *devlink,if (!ctx)return -ENOMEM ; +/* discover capabilities first */ + status =ice_discover_dev_caps (hw, &ctx->dev_caps); +if (status) { + err = -EIO ; + goto out_free_ctx; + } + +if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) { + status =ice_get_inactive_nvm_ver (hw, &ctx->pending_nvm); +if (status) { +dev_dbg (dev,"Unable to read inactive NVM version data, status %s aq_err %s\n" , +ice_stat_str (status),ice_aq_str (hw->adminq.sq_last_status)); + +/* disable display of pending Option ROM */ + ctx->dev_caps.common_cap.nvm_update_pending_nvm = false; + } + } + err =devlink_info_driver_name_put (req,KBUILD_MODNAME );if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set driver name" );
drivers/net/ethernet/intel/ice/ice_nvm.c +38 -6
95 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_nvm.h +2 -0
@@ -18,6 +18,8 @@ ice_get_nvm_minsrevs(struct ice_hw *hw, struct ice_minsrev_info *minsrevs);enum ice_status ice_update_nvm_minsrevs (struct ice_hw *hw,struct ice_minsrev_info *minsrevs);enum ice_status +ice_get_inactive_nvm_ver (struct ice_hw *hw,struct ice_nvm_info *nvm); +enum ice_status ice_read_pba_string (struct ice_hw *hw,u8 *pba_num,u32 pba_num_size);enum ice_status ice_init_nvm (struct ice_hw *hw);enum ice_status ice_read_sr_word (struct ice_hw *hw,u16 offset,u16 *data);
drivers/net/ethernet/intel/ice/ice_type.h +7 -1
@@ -848,8 +848,14 @@ struct ice_hw_port_stats {#define ICE_NVM_CSS_SREV_L 0x14#define ICE_NVM_CSS_SREV_H 0x15 +/* Length of CSS header section in words */ +#define ICE_CSS_HEADER_LENGTH 330 + +/* Offset of Shadow RAM copy in the NVM bank area. */ +#define ICE_NVM_SR_COPY_WORD_OFFSET roundup(ICE_CSS_HEADER_LENGTH, 32) +/* Size in bytes of Option ROM trailer */ -#define ICE_NVM_OROM_TRAILER_LENGTH 660 +#define ICE_NVM_OROM_TRAILER_LENGTH (2 * ICE_CSS_HEADER_LENGTH)/* Auxiliary field, mask, and shift definition for Shadow RAM and NVM Flash */ #define ICE_SR_CTRL_WORD_1_S 0x06
Signature · 1 line
2.29.0
PATCH 6/7 ice: display stored netlist versions via devlink info
In reply to Jacob KellerAdd a function to read the inactive netlist bank for version information. To support this, refactor how we read the netlist version data. Instead of using the firmware AQ interface with a module ID, read from the flash as a flat NVM, using ice_read_flash_module.
This change requires a slight adjustment to the offset values used, as reading from the flat NVM includes the type field (which was stripped by firmware previously). Cleanup the macro names and move them to ice_type.h. For clarity in how we calculate the offsets and so that programmers can easily map the offset value to the data sheet, use a wrapper macro to account for the offset adjustments.
Use the newly added ice_get_inactive_netlist_ver function to extract the version data from the pending netlist module update. Add the stored variants of "fw.netlist", and "fw.netlist.build" to the info version map array.
With this change, we now report the pending netlist module version if we detect a pending but not complete netlist update when reporting firmware versions.
--- .../net/ethernet/intel/ice/ice_adminq_cmd.h | 27 --- drivers/net/ethernet/intel/ice/ice_devlink.c | 38 ++++ drivers/net/ethernet/intel/ice/ice_main.c | 2 + drivers/net/ethernet/intel/ice/ice_nvm.c | 164 +++++++++++------- drivers/net/ethernet/intel/ice/ice_nvm.h | 2 + drivers/net/ethernet/intel/ice/ice_status.h | 1 + drivers/net/ethernet/intel/ice/ice_type.h | 35 ++++ 7 files changed, 176 insertions(+), 93 deletions(-)
drivers/net/ethernet/intel/ice/ice_adminq_cmd.h +0 -27
@@ -1343,33 +1343,6 @@ struct ice_aqc_nvm_checksum {#define ICE_AQC_NVM_MINSREV_MOD_ID 0x130 -/* The result of netlist NVM read comes in a TLV format. The actual data -* (netlist header) starts from word offset 1 (byte 2). The FW strips -* out the type field from the TLV header so all the netlist fields -* should adjust their offset value by 1 word (2 bytes) in order to map -* their correct location. -*/ -#define ICE_AQC_NVM_LINK_TOPO_NETLIST_MOD_ID 0x11B -#define ICE_AQC_NVM_LINK_TOPO_NETLIST_LEN_OFFSET 1 -#define ICE_AQC_NVM_LINK_TOPO_NETLIST_LEN 2/* In bytes */ -#define ICE_AQC_NVM_NETLIST_NODE_COUNT_OFFSET 2 -#define ICE_AQC_NVM_NETLIST_NODE_COUNT_LEN 2/* In bytes */ -#define ICE_AQC_NVM_NETLIST_NODE_COUNT_M ICE_M(0x3FF, 0) -#define ICE_AQC_NVM_NETLIST_ID_BLK_START_OFFSET 5 -#define ICE_AQC_NVM_NETLIST_ID_BLK_LEN 0x30/* In words */ - -/* netlist ID block field offsets (word offsets) */ -#define ICE_AQC_NVM_NETLIST_ID_BLK_MAJOR_VER_LOW 2 -#define ICE_AQC_NVM_NETLIST_ID_BLK_MAJOR_VER_HIGH 3 -#define ICE_AQC_NVM_NETLIST_ID_BLK_MINOR_VER_LOW 4 -#define ICE_AQC_NVM_NETLIST_ID_BLK_MINOR_VER_HIGH 5 -#define ICE_AQC_NVM_NETLIST_ID_BLK_TYPE_LOW 6 -#define ICE_AQC_NVM_NETLIST_ID_BLK_TYPE_HIGH 7 -#define ICE_AQC_NVM_NETLIST_ID_BLK_REV_LOW 8 -#define ICE_AQC_NVM_NETLIST_ID_BLK_REV_HIGH 9 -#define ICE_AQC_NVM_NETLIST_ID_BLK_SHA_HASH 0xA -#define ICE_AQC_NVM_NETLIST_ID_BLK_CUST_VER 0x2F -/* Used for reading and writing MinSRev using 0x0701 and 0x0703. Note that the * type field is excluded from the section when reading and writing from * a module using the module_typeid field with these AQ commands.
drivers/net/ethernet/intel/ice/ice_devlink.c +38 -0
@@ -10,6 +10,7 @@struct ice_info_ctx {char buf[128 ];struct ice_nvm_info pending_nvm; +struct ice_netlist_info pending_netlist;struct ice_hw_dev_caps dev_caps; };
@@ -195,6 +196,30 @@ static int ice_info_netlist_build(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_netlist_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_netlist_info *netlist = &ctx->pending_netlist; + +/* The netlist version fields are BCD formatted */ +if (ctx->dev_caps.common_cap.nvm_update_pending_netlist) +snprintf (ctx->buf,sizeof (ctx->buf),"%x.%x.%x-%x.%x.%x" , + netlist->major, netlist->minor, + netlist->type >>16 , netlist->type &0xFFFF , netlist->rev, + netlist->cust_ver); + +return 0 ; +} + +static int ice_info_pending_netlist_build (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_netlist_info *netlist = &ctx->pending_netlist; + +if (ctx->dev_caps.common_cap.nvm_update_pending_netlist) +snprintf (ctx->buf,sizeof (ctx->buf),"0x%08x" , netlist->hash); + +return 0 ; +} +#define fixed (key, getter) { ICE_VERSION_FIXED, key, getter }#define running (key, getter) { ICE_VERSION_RUNNING, key, getter }#define stored (key, getter) { ICE_VERSION_STORED, key, getter }
@@ -226,7 +251,9 @@ static const struct ice_devlink_version {running (DEVLINK_INFO_VERSION_GENERIC_FW_APP , ice_info_ddp_pkg_version),running ("fw.app.bundle_id" , ice_info_ddp_pkg_bundle_id),running ("fw.netlist" , ice_info_netlist_ver), +stored ("fw.netlist" , ice_info_pending_netlist_ver),running ("fw.netlist.build" , ice_info_netlist_build), + stored("fw.netlist.build", ice_info_pending_netlist_build), };/**
@@ -274,6 +301,17 @@ static int ice_devlink_info_get(struct devlink *devlink, } } +if (ctx->dev_caps.common_cap.nvm_update_pending_netlist) { + status =ice_get_inactive_netlist_ver (hw, &ctx->pending_netlist); +if (status) { +dev_dbg (dev,"Unable to read inactive Netlist version data, status %s aq_err %s\n" , +ice_stat_str (status),ice_aq_str (hw->adminq.sq_last_status)); + +/* disable display of pending Option ROM */ + ctx->dev_caps.common_cap.nvm_update_pending_netlist = false; + } + } + err =devlink_info_driver_name_put (req,KBUILD_MODNAME );if (err) {NL_SET_ERR_MSG_MOD (extack,"Unable to set driver name" );
drivers/net/ethernet/intel/ice/ice_main.c +2 -0
@@ -6310,6 +6310,8 @@ const char *ice_stat_str(enum ice_status stat_err)return "ICE_ERR_OUT_OF_RANGE" ;case ICE_ERR_ALREADY_EXISTS :return "ICE_ERR_ALREADY_EXISTS" ; +case ICE_ERR_NVM : +return "ICE_ERR_NVM" ;case ICE_ERR_NVM_CHECKSUM :return "ICE_ERR_NVM_CHECKSUM" ;case ICE_ERR_BUF_TOO_SHORT :
drivers/net/ethernet/intel/ice/ice_nvm.c +98 -66
196 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_nvm.h +2 -0
@@ -20,6 +20,8 @@ ice_update_nvm_minsrevs(struct ice_hw *hw, struct ice_minsrev_info *minsrevs);enum ice_status ice_get_inactive_nvm_ver (struct ice_hw *hw,struct ice_nvm_info *nvm);enum ice_status +ice_get_inactive_netlist_ver (struct ice_hw *hw,struct ice_netlist_info *netlist); +enum ice_status ice_read_pba_string (struct ice_hw *hw,u8 *pba_num,u32 pba_num_size);enum ice_status ice_init_nvm (struct ice_hw *hw);enum ice_status ice_read_sr_word (struct ice_hw *hw,u16 offset,u16 *data);
drivers/net/ethernet/intel/ice/ice_status.h +1 -0
@@ -29,6 +29,7 @@ enum ice_status {ICE_ERR_HW_TABLE =-19 ,ICE_ERR_FW_DDP_MISMATCH =-20 , +ICE_ERR_NVM =-50 ,ICE_ERR_NVM_CHECKSUM =-51 ,ICE_ERR_BUF_TOO_SHORT =-52 , ICE_ERR_NVM_BLANK_MODE = -53,
drivers/net/ethernet/intel/ice/ice_type.h +35 -0
@@ -857,6 +857,41 @@ struct ice_hw_port_stats {/* Size in bytes of Option ROM trailer */ #define ICE_NVM_OROM_TRAILER_LENGTH (2 * ICE_CSS_HEADER_LENGTH) +/* The Link Topology Netlist section is stored as a series of words. It is +* stored in the NVM as a TLV, with the first two words containing the type +* and length. +*/ +#define ICE_NETLIST_LINK_TOPO_MOD_ID 0x011B +#define ICE_NETLIST_TYPE_OFFSET 0x0000 +#define ICE_NETLIST_LEN_OFFSET 0x0001 + +/* The Link Topology section follows the TLV header. When reading the netlist +* using ice_read_netlist_module, we need to account for the 2-word TLV +* header. +*/ +#define ICE_NETLIST_LINK_TOPO_OFFSET (n) ((n) + 2) + +#define ICE_LINK_TOPO_MODULE_LEN ICE_NETLIST_LINK_TOPO_OFFSET(0x0000) +#define ICE_LINK_TOPO_NODE_COUNT ICE_NETLIST_LINK_TOPO_OFFSET(0x0001) + +#define ICE_LINK_TOPO_NODE_COUNT_M ICE_M(0x3FF, 0) + +/* The Netlist ID Block is located after all of the Link Topology nodes. */ +#define ICE_NETLIST_ID_BLK_SIZE 0x30 +#define ICE_NETLIST_ID_BLK_OFFSET (n) ICE_NETLIST_LINK_TOPO_OFFSET(0x0004 + 2 * (n)) + +/* netlist ID block field offsets (word offsets) */ +#define ICE_NETLIST_ID_BLK_MAJOR_VER_LOW 0x02 +#define ICE_NETLIST_ID_BLK_MAJOR_VER_HIGH 0x03 +#define ICE_NETLIST_ID_BLK_MINOR_VER_LOW 0x04 +#define ICE_NETLIST_ID_BLK_MINOR_VER_HIGH 0x05 +#define ICE_NETLIST_ID_BLK_TYPE_LOW 0x06 +#define ICE_NETLIST_ID_BLK_TYPE_HIGH 0x07 +#define ICE_NETLIST_ID_BLK_REV_LOW 0x08 +#define ICE_NETLIST_ID_BLK_REV_HIGH 0x09 +#define ICE_NETLIST_ID_BLK_SHA_HASH_WORD (n) (0x0A + (n)) +#define ICE_NETLIST_ID_BLK_CUST_VER 0x2F +/* Auxiliary field, mask, and shift definition for Shadow RAM and NVM Flash */ #define ICE_SR_CTRL_WORD_1_S 0x06#define ICE_SR_CTRL_WORD_1_M (0x03 << ICE_SR_CTRL_WORD_1_S)
Signature · 1 line
2.29.0
PATCH 7/7 ice: display stored UNDI firmware version via devlink info
In reply to Jacob KellerJust as we recently added support for other stored firmware flash versions, support display of the stored UNDI Option ROM version via devlink info.
To do this, we need to introduce a new ice_get_inactive_orom_ver function. This is a little trickier than with other flash versions. The Option ROM version data was being read from a special "Boot Configuration" block of the NVM Preserved Field Area. This block only contains the *active* Option ROM version data. It is populated when the device firmware finishes updating the Option ROM.
This method is ineffective at reading the stored Option ROM version data. Instead of reading from this section of the flash, replace this version extraction with one which locates the Combo Version information from within the Option ROM binary.
This data is stored within the Option ROM at a 512 byte offset, in a simple structured format. The structure uses a simple modulo 256 checksum for integrity verification. Scan through the Option ROM to locate the CIVD data section, and extract the Combo Version.
Refactor ice_get_orom_ver_info so that it takes the bank select enumeration parameter. Use this to implement ice_get_inactive_orom_ver.
Although all ice devices have a Boot Configuration block in the NVM PFA, not all devices have a valid Option ROM. In this case, the old ice_get_orom_ver_info would "succeed" but report a version of all zeros. The new implementation would fail to locate the $CIV section in the Option ROM and report an error. Thus, we must ensure that ice_init_nvm does not fail if ice_get_orom_ver_info fails.
Use the new ice_get_inactive_orom_ver to allow reporting the Option ROM versions for a pending update via devlink info.
--- drivers/net/ethernet/intel/ice/ice_devlink.c | 35 +++++ drivers/net/ethernet/intel/ice/ice_nvm.c | 127 +++++++++++++------ drivers/net/ethernet/intel/ice/ice_nvm.h | 10 ++ 3 files changed, 130 insertions(+), 42 deletions(-)
drivers/net/ethernet/intel/ice/ice_devlink.c +35 -0
@@ -9,6 +9,7 @@/* context for devlink info version reporting */ struct ice_info_ctx {char buf[128 ]; +struct ice_orom_info pending_orom;struct ice_nvm_info pending_nvm;struct ice_netlist_info pending_netlist;struct ice_hw_dev_caps dev_caps;
@@ -102,6 +103,17 @@ static int ice_info_orom_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_orom_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_orom_info *orom = &ctx->pending_orom; + +if (ctx->dev_caps.common_cap.nvm_update_pending_orom) +snprintf (ctx->buf,sizeof (ctx->buf),"%u.%u.%u" , + orom->major, orom->build, orom->patch); + +return 0 ; +} +static int ice_info_orom_srev (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_orom_info *orom = &pf->hw.flash.orom;
@@ -111,6 +123,16 @@ static int ice_info_orom_srev(struct ice_pf *pf, struct ice_info_ctx *ctx)return 0 ; } +static int ice_info_pending_orom_srev (struct ice_pf *pf,struct ice_info_ctx *ctx) +{ +struct ice_orom_info *orom = &ctx->pending_orom; + +if (ctx->dev_caps.common_cap.nvm_update_pending_orom) +snprintf (ctx->buf,sizeof (ctx->buf),"%u" , orom->srev); + +return 0 ; +} +static int ice_info_nvm_ver (struct ice_pf *pf,struct ice_info_ctx *ctx) {struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
@@ -242,7 +264,9 @@ static const struct ice_devlink_version {running ("fw.mgmt.srev" , ice_info_fw_srev),stored ("fw.mgmt.srev" , ice_info_pending_fw_srev),running (DEVLINK_INFO_VERSION_GENERIC_FW_UNDI , ice_info_orom_ver), +stored (DEVLINK_INFO_VERSION_GENERIC_FW_UNDI , ice_info_pending_orom_ver),running ("fw.undi.srev" , ice_info_orom_srev), +stored ("fw.undi.srev" , ice_info_pending_orom_srev),running ("fw.psid.api" , ice_info_nvm_ver),stored ("fw.psid.api" , ice_info_pending_nvm_ver), running(DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID, ice_info_eetrack),
@@ -290,6 +314,17 @@ static int ice_devlink_info_get(struct devlink *devlink, goto out_free_ctx; } +if (ctx->dev_caps.common_cap.nvm_update_pending_orom) { + status =ice_get_inactive_orom_ver (hw, &ctx->pending_orom); +if (status) { +dev_dbg (dev,"Unable to read inactive Option ROM version data, status %s aq_err %s\n" , +ice_stat_str (status),ice_aq_str (hw->adminq.sq_last_status)); + +/* disable display of pending Option ROM */ + ctx->dev_caps.common_cap.nvm_update_pending_orom = false; + } + } +if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) { status =ice_get_inactive_nvm_ver (hw, &ctx->pending_nvm);if (status) {
drivers/net/ethernet/intel/ice/ice_nvm.c +85 -42
160 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_nvm.h +10 -0
@@ -4,6 +4,14 @@#ifndef _ICE_NVM_H_#define _ICE_NVM_H_ +struct ice_orom_civd_info { +u8 signature[4 ];/* Must match ASCII '$CIV' characters */ +u8 checksum;/* Simple modulo 256 sum of all structure bytes must equal 0 */ +__le32 combo_ver;/* Combo Image Version number */ +u8 combo_name_len;/* Length of the unicode combo image version string, max of 32 */ +__le16 combo_name[32 ];/* Unicode string representing the Combo Image version */ +} __packed; +enum ice_status ice_acquire_nvm (struct ice_hw *hw,enum ice_aq_res_access_type access);void ice_release_nvm (struct ice_hw *hw);
@@ -18,6 +26,8 @@ ice_get_nvm_minsrevs(struct ice_hw *hw, struct ice_minsrev_info *minsrevs);enum ice_status ice_update_nvm_minsrevs (struct ice_hw *hw,struct ice_minsrev_info *minsrevs);enum ice_status +ice_get_inactive_orom_ver (struct ice_hw *hw,struct ice_orom_info *orom); +enum ice_status ice_get_inactive_nvm_ver (struct ice_hw *hw,struct ice_nvm_info *nvm);enum ice_status ice_get_inactive_netlist_ver (struct ice_hw *hw,struct ice_netlist_info *netlist);
Signature · 1 line
2.29.0