Add ability to flash modules' firmware
Subsystems (7)
v2 cover Add ability to flash modules' firmware
CMIS compliant modules such as QSFP-DD might be running a firmware that can be updated in a vendor-neutral way by exchanging messages between the host and the module as described in section 7.2.2 of revision 4.0 of the CMIS standard.
According to the CMIS standard, the firmware update process is done using a CDB commands sequence.
CDB (Command Data Block Message Communication) reads and writes are performed on memory map pages 9Fh-AFh according to the CMIS standard, section 8.12 of revision 4.0.
Add a pair of new ethtool messages that allow:
* User space to trigger firmware update of transceiver modules
* The kernel to notify user space about the progress of the process
The user interface is designed to be asynchronous in order to avoid RTNL being held for too long and to allow several modules to be updated simultaneously. The interface is designed with CMIS compliant modules in mind, but kept generic enough to accommodate future use cases, if these arise.
The kernel interface that will implement the firmware update using CDB command will include 2 layers that will be added under ethtool:
* The upper layer that will be triggered from the module layer, is cmis_ fw_update.
* The lower one is cmis_cdb.
In the future there might be more operations to implement using CDB commands. Therefore, the idea is to keep the cmis_cdb interface clean and the cmis_fw_update specific to the cdb commands handling it.
The communication between the kernel and the driver will be done using two ethtool operations that enable reading and writing the transceiver module EEPROM.
The operation ethtool_ops::get_module_eeprom_by_page, that is already implemented, will be used for reading from the EEPROM the CDB reply, e.g. reading module setting, state, etc.
The operation ethtool_ops::set_module_eeprom_by_page, that is added in the current patchset, will be used for writing to the EEPROM the CDB command such as start firmware image, run firmware image, etc.
Therefore in order for a driver to implement module flashing, that driver needs to implement the two functions mentioned above.
Patchset overview:
Patch #1-#2: Implement the EEPROM writing in mlxsw. Patch #3: Define the interface between the kernel and user space. Patch #4: Add ability to notify the flashing firmware progress. Patch #5: Add firmware flashing in progress flag.
Patch #6: Add extended compliance codes.
Patch #7: Add the cdb layer.
Patch #8: Add the fw_update layer.
Patch #9: Add ability to flash transceiver modules' firmware.
Danielle Ratson (7):
ethtool: Add an interface for flashing transceiver modules' firmware
ethtool: Add flashing transceiver modules' firmware notifications
ability
include: netdevice: Add module firmware flashing in progress flag to
net_device
net: sfp: Add more extended compliance codes
ethtool: cmis_cdb: Add a layer for supporting CDB commands
ethtool: cmis_fw_update: add a layer for supporting firmware update
using CDB
ethtool: Add ability to flash transceiver modules' firmware
Ido Schimmel (2):
ethtool: Add ethtool operation to write to a transceiver module EEPROM
mlxsw: Implement ethtool operation to write to a transceiver module
EEPROM
Documentation/netlink/specs/ethtool.yaml | 63 +++ Documentation/networking/ethtool-netlink.rst | 62 +++ .../net/ethernet/mellanox/mlxsw/core_env.c | 57 ++ .../net/ethernet/mellanox/mlxsw/core_env.h | 6 + drivers/net/ethernet/mellanox/mlxsw/minimal.c | 15 + .../mellanox/mlxsw/spectrum_ethtool.c | 15 + include/linux/ethtool.h | 20 +- include/linux/netdevice.h | 4 +- include/linux/sfp.h | 6 + include/uapi/linux/ethtool.h | 18 + include/uapi/linux/ethtool_netlink.h | 20 + net/ethtool/Makefile | 2 +- net/ethtool/cmis.h | 119 ++++ net/ethtool/cmis_cdb.c | 525 ++++++++++++++++++ net/ethtool/cmis_fw_update.c | 367 ++++++++++++ net/ethtool/module.c | 238 ++++++++ net/ethtool/module_fw.h | 38 ++ net/ethtool/netlink.c | 7 + net/ethtool/netlink.h | 2 + 19 files changed, 1574 insertions(+), 10 deletions(-) create mode 100644 net/ethtool/cmis.h create mode 100644 net/ethtool/cmis_cdb.c create mode 100644 net/ethtool/cmis_fw_update.c create mode 100644 net/ethtool/module_fw.h
Signature · 1 line
2.43.0
RFC PATCH v2 1/9 ethtool: Add ethtool operation to write to a transceiver module EEPROM
From: Ido Schimmel <[email protected]>
Ethtool can already retrieve information from a transceiver module EEPROM by invoking the ethtool_ops::get_module_eeprom_by_page operation. Add a corresponding operation that allows ethtool to write to a transceiver module EEPROM.
The new write operation is purely an in-kernel API and is not exposed to user space.
The purpose of this operation is not to enable arbitrary read / write access, but to allow the kernel to write to specific addresses as part of transceiver module firmware flashing. In the future, more functionality can be implemented on top of these read / write operations.
Adjust the comments of the 'ethtool_module_eeprom' structure as it is no longer used only for read access.
---
Notes:
v2:
* Rephrase kernel-doc.
* Add a note in the commit message.
include/linux/ethtool.h | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-)
include/linux/ethtool.h +12 -8
@@ -474,17 +474,16 @@ struct ethtool_rmon_stats {#define ETH_MODULE_MAX_I2C_ADDRESS 0x7f/** -* struct ethtool_module_eeprom - EEPROM dump from specified page -* @offset: Offset within the specified EEPROM page to begin read, in bytes. -* @length: Number of bytes to read. -* @page: Page number to read from. -* @bank: Page bank number to read from, if applicable by EEPROM spec. +* struct ethtool_module_eeprom - plug-in module EEPROM read / write parameters +* @offset: When @offset is 0-127, offset is from the beggining of the EEPROM, +* And when @offset is 128-255 then it is the offset within the +* specified page. Offset is in bytes. +* @length: Number of bytes to read / write. +* @page: Page number. +* @bank: Bank number, if supported by EEPROM spec. * @i2c_address: I2C address of a page. Value less than 0x7f expected. Most * EEPROMs use 0x50 or 0x51. * @data: Pointer to buffer with EEPROM data of @length size. -* -* This can be used to manage pages during EEPROM dump in ethtool and pass -* required information to the driver. */ struct ethtool_module_eeprom {u32 offset;
@@ -789,6 +788,8 @@ struct ethtool_rxfh_param {* @get_module_eeprom_by_page: Get a region of plug-in module EEPROM data from * specified page. Returns a negative error code or the amount of bytes * read. +* @set_module_eeprom_by_page: Write to a region of plug-in module EEPROM, +* from kernel space only. Returns a negative error code or zero. * @get_eth_phy_stats: Query some of the IEEE 802.3 PHY statistics. * @get_eth_mac_stats: Query some of the IEEE 802.3 MAC statistics. * @get_eth_ctrl_stats: Query some of the IEEE 802.3 MAC Ctrl statistics.
@@ -921,6 +922,9 @@ struct ethtool_ops {int (*get_module_eeprom_by_page)(struct net_device *dev,const struct ethtool_module_eeprom *page,struct netlink_ext_ack *extack); +int (*set_module_eeprom_by_page)(struct net_device *dev, +const struct ethtool_module_eeprom *page, +struct netlink_ext_ack *extack);void (*get_eth_phy_stats)(struct net_device *dev,struct ethtool_eth_phy_stats *phy_stats); void (*get_eth_mac_stats)(struct net_device *dev,
Signature · 1 line
2.43.0
RFC PATCH v2 2/9 mlxsw: Implement ethtool operation to write to a transceiver module EEPROM
In reply to Danielle RatsonFrom: Ido Schimmel <[email protected]>
Implement the ethtool_ops::set_module_eeprom_by_page operation to allow ethtool to write to a transceiver module EEPROM, in a similar fashion to the ethtool_ops::get_module_eeprom_by_page operation.
--- .../net/ethernet/mellanox/mlxsw/core_env.c | 57 +++++++++++++++++++ .../net/ethernet/mellanox/mlxsw/core_env.h | 6 ++ drivers/net/ethernet/mellanox/mlxsw/minimal.c | 15 +++++ .../mellanox/mlxsw/spectrum_ethtool.c | 15 +++++ 4 files changed, 93 insertions(+)
drivers/net/ethernet/mellanox/mlxsw/core_env.c +57 -0
@@ -513,6 +513,63 @@ mlxsw_env_get_module_eeprom_by_page(struct mlxsw_core *mlxsw_core, }EXPORT_SYMBOL (mlxsw_env_get_module_eeprom_by_page); +int +mlxsw_env_set_module_eeprom_by_page (struct mlxsw_core *mlxsw_core, +u8 slot_index,u8 module, +const struct ethtool_module_eeprom *page, +struct netlink_ext_ack *extack) +{ +struct mlxsw_env *mlxsw_env =mlxsw_core_env (mlxsw_core); +u32 bytes_written =0 ; +u16 device_addr; +int err; + +if (!mlxsw_env_linecard_is_active (mlxsw_env, slot_index)) { +NL_SET_ERR_MSG_MOD (extack, +"Cannot write to EEPROM of a module on an inactive line card" ); +return -EIO ; + } + + err =mlxsw_env_validate_module_type (mlxsw_core, slot_index, module); +if (err) { +NL_SET_ERR_MSG_MOD (extack,"EEPROM is not equipped on port module type" ); +return err; + } + + device_addr = page->offset; + +while (bytes_written < page->length) { +char mcia_pl[MLXSW_REG_MCIA_LEN ]; +char eeprom_tmp[128 ] = {}; +u8 size; + + size =min_t (u8, page->length - bytes_written, + mlxsw_env->max_eeprom_len); + +mlxsw_reg_mcia_pack (mcia_pl, slot_index, module, page->page, + device_addr + bytes_written, size, + page->i2c_address); +mlxsw_reg_mcia_bank_number_set (mcia_pl, page->bank); +memcpy (eeprom_tmp, page->data + bytes_written, size); +mlxsw_reg_mcia_eeprom_memcpy_to (mcia_pl, eeprom_tmp); + + err =mlxsw_reg_write (mlxsw_core,MLXSW_REG (mcia), mcia_pl); +if (err) { +NL_SET_ERR_MSG_MOD (extack,"Failed to access module's EEPROM" ); +return err; + } + + err =mlxsw_env_mcia_status_process (mcia_pl, extack); +if (err) +return err; + + bytes_written += size; + } + +return 0 ; +} +EXPORT_SYMBOL (mlxsw_env_set_module_eeprom_by_page); +static int mlxsw_env_module_reset (struct mlxsw_core *mlxsw_core,u8 slot_index,u8 module) {
drivers/net/ethernet/mellanox/mlxsw/core_env.h +6 -0
@@ -28,6 +28,12 @@ mlxsw_env_get_module_eeprom_by_page(struct mlxsw_core *mlxsw_core,const struct ethtool_module_eeprom *page, struct netlink_ext_ack *extack); +int +mlxsw_env_set_module_eeprom_by_page (struct mlxsw_core *mlxsw_core, +u8 slot_index,u8 module, +const struct ethtool_module_eeprom *page, +struct netlink_ext_ack *extack); +int mlxsw_env_reset_module (struct net_device *netdev,struct mlxsw_core *mlxsw_core,u8 slot_index,u8 module,u32 *flags);
drivers/net/ethernet/mellanox/mlxsw/minimal.c +15 -0
@@ -140,6 +140,20 @@ mlxsw_m_get_module_eeprom_by_page(struct net_device *netdev, page, extack); } +static int +mlxsw_m_set_module_eeprom_by_page (struct net_device *netdev, +const struct ethtool_module_eeprom *page, +struct netlink_ext_ack *extack) +{ +struct mlxsw_m_port *mlxsw_m_port =netdev_priv (netdev); +struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core; + +return mlxsw_env_set_module_eeprom_by_page (core, + mlxsw_m_port->slot_index, + mlxsw_m_port->module, + page, extack); +} +static int mlxsw_m_reset (struct net_device *netdev,u32 *flags) {struct mlxsw_m_port *mlxsw_m_port =netdev_priv (netdev);
@@ -181,6 +195,7 @@ static const struct ethtool_ops mlxsw_m_port_ethtool_ops = { .get_module_info = mlxsw_m_get_module_info, .get_module_eeprom = mlxsw_m_get_module_eeprom, .get_module_eeprom_by_page = mlxsw_m_get_module_eeprom_by_page, + .set_module_eeprom_by_page = mlxsw_m_set_module_eeprom_by_page, .reset = mlxsw_m_reset, .get_module_power_mode = mlxsw_m_get_module_power_mode, .set_module_power_mode = mlxsw_m_set_module_power_mode,
drivers/net/ethernet/mellanox/mlxsw/spectrum_ethtool.c +15 -0
@@ -1067,6 +1067,20 @@ mlxsw_sp_get_module_eeprom_by_page(struct net_device *dev, module, page, extack); } +static int +mlxsw_sp_set_module_eeprom_by_page (struct net_device *dev, +const struct ethtool_module_eeprom *page, +struct netlink_ext_ack *extack) +{ +struct mlxsw_sp_port *mlxsw_sp_port =netdev_priv (dev); +struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; +u8 slot_index = mlxsw_sp_port->mapping.slot_index; +u8 module = mlxsw_sp_port->mapping.module; + +return mlxsw_env_set_module_eeprom_by_page (mlxsw_sp->core, slot_index, + module, page, extack); +} +static int mlxsw_sp_get_ts_info (struct net_device *netdev,struct ethtool_ts_info *info) {
@@ -1256,6 +1270,7 @@ const struct ethtool_ops mlxsw_sp_port_ethtool_ops = { .get_module_info = mlxsw_sp_get_module_info, .get_module_eeprom = mlxsw_sp_get_module_eeprom, .get_module_eeprom_by_page = mlxsw_sp_get_module_eeprom_by_page, + .set_module_eeprom_by_page = mlxsw_sp_set_module_eeprom_by_page, .get_ts_info = mlxsw_sp_get_ts_info, .get_eth_phy_stats = mlxsw_sp_get_eth_phy_stats, .get_eth_mac_stats = mlxsw_sp_get_eth_mac_stats,
Signature · 1 line
2.43.0
RFC PATCH v2 3/9 ethtool: Add an interface for flashing transceiver modules' firmware
In reply to Danielle RatsonCMIS compliant modules such as QSFP-DD might be running a firmware that can be updated in a vendor-neutral way by exchanging messages between the host and the module as described in section 7.3.1 of revision 5.2 of the CMIS standard.
Add a pair of new ethtool messages that allow:
* User space to trigger firmware update of transceiver modules
* The kernel to notify user space about the progress of the process
The user interface is designed to be asynchronous in order to avoid RTNL being held for too long and to allow several modules to be updated simultaneously. The interface is designed with CMIS compliant modules in mind, but kept generic enough to accommodate future use cases, if these arise.
---
Notes:
v2:
* Change the status attr to be u32 and make it an enum in the yaml file.
* total attr: u64 -> uint.
Documentation/netlink/specs/ethtool.yaml | 63 ++++++++++++++++++++ Documentation/networking/ethtool-netlink.rst | 62 +++++++++++++++++++ include/uapi/linux/ethtool.h | 18 ++++++ include/uapi/linux/ethtool_netlink.h | 20 +++++++ 4 files changed, 163 insertions(+)
Documentation/netlink/specs/ethtool.yaml +63 -0
@@ -16,6 +16,11 @@ definitions: name: stringset type: enum entries: [] + - + name: module-fw-flash-status + type: enum + entries: [ started, in_progress, completed, error ] + attribute-sets: -
@@ -942,6 +947,39 @@ attribute-sets: - name: burst-tmr type: u32 + - + name: module-fw-flash + attributes: + - + name: header + type: nest + nested-attributes: header + - + name: file-name + type: string + - + name: password + type: u32 + - + name: module-fw-flash-ntf + attributes: + - + name: header + type: nest + nested-attributes: header + - + name: status + type: u32 + enum: module-fw-flash-status + - + name: status-msg + type: string + - + name: done + type: u64 + - + name: total + type: u64 operations: enum-model: directional
@@ -1693,3 +1731,28 @@ operations: name: mm-ntf doc: Notification for change in MAC Merge configuration. notify: mm-get + - + name: module-fw-flash-act + doc: Flash transceiver module firmware. + + attribute-set: module-fw-flash + + do: + request: + attributes: + - header + - file-name + - password + - + name: module-fw-flash-ntf + doc: Notification for firmware flashing progress and status. + + attribute-set: module-fw-flash-ntf + + event: + attributes: + - header + - status + - status-msg + - done + - total
Documentation/networking/ethtool-netlink.rst +62 -0
84 lines not on this page · raw message
include/uapi/linux/ethtool.h +18 -0
@@ -822,6 +822,24 @@ enum ethtool_mm_verify_status { ETHTOOL_MM_VERIFY_STATUS_DISABLED, }; +/** +* enum ethtool_module_fw_flash_status - plug-in module firmware flashing status +* @ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED: The firmware flashing process has +* started. +* @ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS: The firmware flashing process +* is in progress. +* @ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED: The firmware flashing process was +* completed successfully. +* @ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR: The firmware flashing process was +* stopped due to an error. +*/ +enum ethtool_module_fw_flash_status { +ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED =1 , +ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS , +ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED , +ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR , +}; +/** * struct ethtool_gstrings - string set for data tagging * @cmd: Command number = %ETHTOOL_GSTRINGS
include/uapi/linux/ethtool_netlink.h +20 -0
@@ -57,6 +57,7 @@ enum {ETHTOOL_MSG_PLCA_GET_STATUS ,ETHTOOL_MSG_MM_GET ,ETHTOOL_MSG_MM_SET , +ETHTOOL_MSG_MODULE_FW_FLASH_ACT ,/* add new constants above here */ __ETHTOOL_MSG_USER_CNT,
@@ -109,6 +110,7 @@ enum {ETHTOOL_MSG_PLCA_NTF ,ETHTOOL_MSG_MM_GET_REPLY ,ETHTOOL_MSG_MM_NTF , +ETHTOOL_MSG_MODULE_FW_FLASH_NTF ,/* add new constants above here */ __ETHTOOL_MSG_KERNEL_CNT,
@@ -976,6 +978,24 @@ enum { ETHTOOL_A_MM_MAX = (__ETHTOOL_A_MM_CNT - 1) }; +/* MODULE_FW_FLASH */ + +enum { +ETHTOOL_A_MODULE_FW_FLASH_UNSPEC , +ETHTOOL_A_MODULE_FW_FLASH_HEADER ,/* nest - _A_HEADER_* */ +ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME ,/* string */ +ETHTOOL_A_MODULE_FW_FLASH_PASSWORD ,/* u32 */ +ETHTOOL_A_MODULE_FW_FLASH_PAD , +ETHTOOL_A_MODULE_FW_FLASH_STATUS ,/* u8 */ +ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG ,/* string */ +ETHTOOL_A_MODULE_FW_FLASH_DONE ,/* u64 */ +ETHTOOL_A_MODULE_FW_FLASH_TOTAL ,/* u64 */ + +/* add new constants above here */ + __ETHTOOL_A_MODULE_FW_FLASH_CNT, +ETHTOOL_A_MODULE_FW_FLASH_MAX = (__ETHTOOL_A_MODULE_FW_FLASH_CNT -1 ) +}; +/* generic netlink info */ #define ETHTOOL_GENL_NAME "ethtool"#define ETHTOOL_GENL_VERSION 1
Signature · 1 line
2.43.0
RFC PATCH v2 4/9 ethtool: Add flashing transceiver modules' firmware notifications ability
In reply to Danielle RatsonAdd progress notifications ability to user space while flashing modules' firmware by implementing the interface between the user space and the kernel.
--- net/ethtool/module.c | 76 +++++++++++++++++++++++++++++++++++++++++ net/ethtool/module_fw.h | 10 ++++++ 2 files changed, 86 insertions(+) create mode 100644 net/ethtool/module_fw.h
net/ethtool/module.c +76 -0
@@ -5,6 +5,7 @@#include "netlink.h" #include "common.h" #include "bitset.h" +#include "module_fw.h" struct module_req_info {struct ethnl_req_info base;
@@ -158,3 +159,78 @@ const struct ethnl_request_ops ethnl_module_request_ops = { .set = ethnl_set_module, .set_ntf_cmd = ETHTOOL_MSG_MODULE_NTF, }; + +/* MODULE_FW_FLASH_NTF */ + +static void +ethnl_module_fw_flash_ntf (struct net_device *dev, +enum ethtool_module_fw_flash_status status, +const char *status_msg,u64 done,u64 total) +{ +struct sk_buff *skb; +void *hdr; +int ret; + + skb =genlmsg_new (NLMSG_GOODSIZE ,GFP_KERNEL ); +if (!skb) +return ; + + hdr =ethnl_bcastmsg_put (skb,ETHTOOL_MSG_MODULE_FW_FLASH_NTF ); +if (!hdr) + goto err_skb; + + ret =ethnl_fill_reply_header (skb, dev, +ETHTOOL_A_MODULE_FW_FLASH_HEADER ); +if (ret <0 ) + goto err_skb; + +if (nla_put_u8 (skb,ETHTOOL_A_MODULE_FW_FLASH_STATUS , status)) + goto err_skb; + +if (status_msg && +nla_put_string (skb,ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG , + status_msg)) + goto err_skb; + +if (nla_put_u64_64bit (skb,ETHTOOL_A_MODULE_FW_FLASH_DONE , done, +ETHTOOL_A_MODULE_FW_FLASH_PAD )) + goto err_skb; + +if (nla_put_u64_64bit (skb,ETHTOOL_A_MODULE_FW_FLASH_TOTAL , + total,ETHTOOL_A_MODULE_FW_FLASH_PAD )) + goto err_skb; + +genlmsg_end (skb, hdr); +ethnl_multicast (skb, dev); +return ; + +err_skb: +nlmsg_free (skb); +} + +void ethnl_module_fw_flash_ntf_err (struct net_device *dev, +const char *status_msg) +{ +ethnl_module_fw_flash_ntf (dev,ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR , + status_msg,0 ,0 ); +} + +void ethnl_module_fw_flash_ntf_start (struct net_device *dev) +{ +ethnl_module_fw_flash_ntf (dev,ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED , +NULL ,0 ,0 ); +} + +void ethnl_module_fw_flash_ntf_complete (struct net_device *dev) +{ +ethnl_module_fw_flash_ntf (dev,ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED , +NULL ,0 ,0 ); +} + +void ethnl_module_fw_flash_ntf_in_progress (struct net_device *dev,u64 done, +u64 total) +{ +ethnl_module_fw_flash_ntf (dev, +ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS , +NULL , done, total); +}
net/ethtool/module_fw.h new file +10 -0
@@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#include <uapi/linux/ethtool.h> + +void ethnl_module_fw_flash_ntf_err (struct net_device *dev, +const char *status_msg); +void ethnl_module_fw_flash_ntf_start (struct net_device *dev); +void ethnl_module_fw_flash_ntf_complete (struct net_device *dev); +void ethnl_module_fw_flash_ntf_in_progress (struct net_device *dev,u64 done, +u64 total);
Signature · 1 line
2.43.0
RFC PATCH v2 5/9 include: netdevice: Add module firmware flashing in progress flag to net_device
In reply to Danielle RatsonSome operations cannot be performed during the firmware flashing process. For example, flashing firmware on a device which is already in a flashing process should be forbidden.
In order to veto those scenarios, add a flag in 'struct net_device' that indicates when a firmware flash is taking place on the module.
--- include/linux/netdevice.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
include/linux/netdevice.h +3 -1
@@ -2061,6 +2061,8 @@ enum netdev_stat_type {* * @threaded: napi threaded mode is enabled * +* @module_fw_flash_in_progress: Module firmware flashing is in progress. +* * @net_notifier_list: List of per-net netdev notifier block * that follow this device when it is moved * to another network namespace.
@@ -2447,7 +2449,7 @@ struct net_device {bool proto_down; unsigned wol_enabled:1; unsigned threaded:1; - + unsigned module_fw_flash_in_progress:1;struct list_head net_notifier_list;#if IS_ENABLED (CONFIG_MACSEC )
Signature · 1 line
2.43.0
RFC PATCH v2 6/9 net: sfp: Add more extended compliance codes
In reply to Danielle RatsonSFF-8024 is used to define various constants re-used in several SFF SFP-related specifications.
Add SFF-8024 extended compliance code definitions for CMIS compliant modules and use them in the next patch to determine the firmware flashing work.
--- include/linux/sfp.h | 6 ++++++ 1 file changed, 6 insertions(+)
include/linux/sfp.h +6 -0
@@ -284,6 +284,12 @@ enum {SFF8024_ID_QSFP_8438 =0x0c ,SFF8024_ID_QSFP_8436_8636 =0x0d ,SFF8024_ID_QSFP28_8636 =0x11 , +SFF8024_ID_QSFP_DD =0x18 , +SFF8024_ID_OSFP =0x19 , +SFF8024_ID_DSFP =0x1B , +SFF8024_ID_QSFP_PLUS_CMIS =0x1E , +SFF8024_ID_SFP_DD_CMIS =0x1F , +SFF8024_ID_SFP_PLUS_CMIS =0x20 ,SFF8024_ENCODING_UNSPEC =0x00 , SFF8024_ENCODING_8B10B = 0x01,
Signature · 1 line
2.43.0
RFC PATCH v2 7/9 ethtool: cmis_cdb: Add a layer for supporting CDB commands
In reply to Danielle RatsonCDB (Command Data Block Message Communication) reads and writes are performed on memory map pages 9Fh-AFh according to the CMIS standard, section 8.20 of revision 5.2.
Page 9Fh is used to specify the CDB command to be executed and also provides an area for a local payload (LPL).
According to the CMIS standard, the firmware update process is done using a CDB commands sequence that will be implemented in the next patch.
The kernel interface that will implement the firmware update using CDB command will include 2 layers that will be added under ethtool:
* The upper layer that will be triggered from the module layer, is cmis_fw_update.
* The lower one is cmis_cdb.
In the future there might be more operations to implement using CDB commands. Therefore, the idea is to keep the CDB interface clean and the cmis_fw_update specific to the CDB commands handling it.
These two layers will communicate using the API the consists of three functions:
- struct ethtool_cmis_cdb *
ethtool_cmis_cdb_init(struct net_device *dev,
struct ethtool_module_fw_flash_params *params); - void ethtool_cmis_cdb_fini(struct ethtool_cmis_cdb *cdb); - int ethtool_cmis_cdb_execute_cmd(struct net_device *dev, struct ethtool_cmis_cdb_cmd_args *args);
Add the CDB layer to support initializing, finishing and executing CDB commands:
* The initialization process will include creating of an ethtool_cmis_cdb instance, querying the module CDB support, entering and validating the password from user space (CMD 0x0000) and querying the module features (CMD 0x0040).
* The finishing API will simply free the ethtool_cmis_cdb instance.
* The executing process will write the CDB command to EEPROM using set_module_eeprom_by_page() that was presented earlier, and will process the reply from EEPROM.
---
Notes:
v2:
* Remove kmalloc from ethtool_cmis_page_init() and use the local payload for page_data->data instead.
* Return void in ethtool_cmis_page_init().
* Remove ethtool_cmis_page_fini().
* Restruct ethtool_cmis_cdb_execute_cmd() to align the page_init changes.
* Kmalloc the CDB command response.
net/ethtool/Makefile | 2 +- net/ethtool/cmis.h | 112 +++++++++ net/ethtool/cmis_cdb.c | 525 ++++++++++++++++++++++++++++++++++++++++ net/ethtool/module_fw.h | 10 + 4 files changed, 648 insertions(+), 1 deletion(-) create mode 100644 net/ethtool/cmis.h create mode 100644 net/ethtool/cmis_cdb.c
net/ethtool/Makefile +1 -1
@@ -8,4 +8,4 @@ ethtool_nl-y := netlink.o bitset.o strset.o linkinfo.o linkmodes.o rss.o \ linkstate.o debug.o wol.o features.o privflags.o rings.o \ channels.o coalesce.o pause.o eee.o tsinfo.o cabletest.o \ tunnels.o fec.o eeprom.o stats.o phc_vclocks.o mm.o \ - module.o pse-pd.o plca.o mm.o + module.o cmis_cdb.o pse-pd.o plca.o mm.o
net/ethtool/cmis.h new file +112 -0
112 lines not on this page · raw message
net/ethtool/cmis_cdb.c new file +525 -0
525 lines not on this page · raw message
net/ethtool/module_fw.h +10 -0
@@ -8,3 +8,13 @@ void ethnl_module_fw_flash_ntf_start(struct net_device *dev);void ethnl_module_fw_flash_ntf_complete (struct net_device *dev);void ethnl_module_fw_flash_ntf_in_progress (struct net_device *dev,u64 done,u64 total); + +/** +* struct ethtool_module_fw_flash_params - module firmware flashing parameters +* @password: Module password. Only valid when @pass_valid is set. +* @password_valid: Whether the module password is valid or not. +*/ +struct ethtool_module_fw_flash_params { +__be32 password; +u8 password_valid:1 ; +};
Signature · 1 line
2.43.0
RFC PATCH v2 8/9 ethtool: cmis_fw_update: add a layer for supporting firmware update using CDB
In reply to Danielle RatsonAccording to the CMIS standard, the firmware update process is done using a CDB commands sequence.
Implement a work that will be triggered from the module layer in the next patch the will initiate and execute all the CDB commands in order, to eventually complete the firmware update process.
This flashing process includes, writing the firmware image, running the new firmware image and committing it after testing, so that it will run upon reset.
This work will also notify user space about the progress of the firmware update process.
---
Notes:
v2:
* Name labels after the target in ethtool_cmis_fw_update().
* Remove ethtool_cmis_fw_update() export.
* Switch between the lines that sets module_fw_flash_in_progress to false and netdev_puts.
net/ethtool/Makefile | 2 +- net/ethtool/cmis.h | 7 + net/ethtool/cmis_fw_update.c | 367 +++++++++++++++++++++++++++++++++++ net/ethtool/module_fw.h | 18 ++ 4 files changed, 393 insertions(+), 1 deletion(-) create mode 100644 net/ethtool/cmis_fw_update.c
net/ethtool/Makefile +1 -1
@@ -8,4 +8,4 @@ ethtool_nl-y := netlink.o bitset.o strset.o linkinfo.o linkmodes.o rss.o \ linkstate.o debug.o wol.o features.o privflags.o rings.o \ channels.o coalesce.o pause.o eee.o tsinfo.o cabletest.o \ tunnels.o fec.o eeprom.o stats.o phc_vclocks.o mm.o \ - module.o cmis_cdb.o pse-pd.o plca.o mm.o + module.o cmis_fw_update.o cmis_cdb.o pse-pd.o plca.o mm.o
net/ethtool/cmis.h +7 -0
@@ -20,6 +20,12 @@ struct ethtool_cmis_cdb {enum ethtool_cmis_cdb_cmd_id {ETHTOOL_CMIS_CDB_CMD_QUERY_STATUS =0x0000 ,ETHTOOL_CMIS_CDB_CMD_MODULE_FEATURES =0x0040 , +ETHTOOL_CMIS_CDB_CMD_FW_MANAGMENT_FEATURES =0x0041 , +ETHTOOL_CMIS_CDB_CMD_START_FW_DOWNLOAD =0x0101 , +ETHTOOL_CMIS_CDB_CMD_WRITE_FW_BLOCK_LPL =0x0103 , +ETHTOOL_CMIS_CDB_CMD_COMPLETE_FW_DOWNLOAD =0x0107 , +ETHTOOL_CMIS_CDB_CMD_RUN_FW_IMAGE =0x0109 , +ETHTOOL_CMIS_CDB_CMD_COMMIT_FW_IMAGE =0x010A , };/**
@@ -47,6 +53,7 @@ struct ethtool_cmis_cdb_request {#define CDB_F_COMPLETION_VALID BIT(0)#define CDB_F_STATUS_VALID BIT(1) +#define CDB_F_MODULE_STATE_VALID BIT(2)/** * struct ethtool_cmis_cdb_cmd_args - CDB commands execution arguments
net/ethtool/cmis_fw_update.c new file +367 -0
367 lines not on this page · raw message
net/ethtool/module_fw.h +18 -0
@@ -9,6 +9,8 @@ void ethnl_module_fw_flash_ntf_complete(struct net_device *dev);void ethnl_module_fw_flash_ntf_in_progress (struct net_device *dev,u64 done,u64 total); +void ethtool_cmis_fw_update (struct work_struct *work); +/** * struct ethtool_module_fw_flash_params - module firmware flashing parameters * @password: Module password. Only valid when @pass_valid is set.
@@ -18,3 +20,19 @@ struct ethtool_module_fw_flash_params {__be32 password; u8 password_valid:1; }; + +/** +* struct ethtool_module_fw_flash - module firmware flashing +* @dev: Pointer to the net_device to be flashed. +* @dev_tracker: Refcount tracker for @dev. +* @params: Module firmware flashing parameters. +* @work: The flashing firmware work. +* @fw: Firmware to flash. +*/ +struct ethtool_module_fw_flash { +struct net_device *dev; +netdevice_tracker dev_tracker; +struct ethtool_module_fw_flash_params params; +struct work_struct work; +const struct firmware *fw; +};
Signature · 1 line
2.43.0
RFC PATCH v2 9/9 ethtool: Add ability to flash transceiver modules' firmware
In reply to Danielle RatsonAdd the ability to flash the modules' firmware by implementing the interface between the user space and the kernel.
Example from a succeeding implementation:
# ethtool --flash-module-firmware swp40 file test.bin
Transceiver module firmware flashing started for device eth0
Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 0%
[...]
Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 50%
[...]
Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 100%
Transceiver module firmware flashing completed for device eth0
---
Notes:
v2:
* Alphabetical order on includes.
* s/request_firmware/request_firmware_direct.
* Add GENL_REQ_ATTR_CHECK() on the file_name instead of NL_SET_ERR_MSG_ATTR().
* Remove file_name from struct ethtool_module_fw_flash_params, and create a local const char *file_name instead.
* Rename some includes and use SFP_PHYS_ID for the SFF-8024 identifier value offset.
* Remove struct module_sff8024_id_rpl and use a one-byte local field instead.
net/ethtool/module.c | 162 ++++++++++++++++++++++++++++++++++++++++++ net/ethtool/netlink.c | 7 ++ net/ethtool/netlink.h | 2 + 3 files changed, 171 insertions(+)
net/ethtool/module.c +162 -0
@@ -1,6 +1,8 @@// SPDX-License-Identifier: GPL-2.0-only #include <linux/ethtool.h> +#include <linux/firmware.h> +#include <linux/sfp.h> #include "netlink.h" #include "common.h"
@@ -160,6 +162,166 @@ const struct ethnl_request_ops ethnl_module_request_ops = { .set_ntf_cmd = ETHTOOL_MSG_MODULE_NTF, }; +/* MODULE_FW_FLASH_ACT */ + +const struct nla_policy +ethnl_module_fw_flash_act_policy[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD +1 ] = { + [ETHTOOL_A_MODULE_FW_FLASH_HEADER ] = +NLA_POLICY_NESTED (ethnl_header_policy), + [ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME ] = { .type =NLA_NUL_STRING }, + [ETHTOOL_A_MODULE_FW_FLASH_PASSWORD ] = { .type =NLA_U32 }, +}; + +#define MODULE_EEPROM_PHYS_ID_PAGE 0 +#define MODULE_EEPROM_PHYS_ID_I2C_ADDR 0x50 + +static int module_flash_fw_work_init (struct ethtool_module_fw_flash *module_fw, +struct net_device *dev, +struct netlink_ext_ack *extack) +{ +const struct ethtool_ops *ops = dev->ethtool_ops; +struct ethtool_module_eeprom page_data = {}; +u8 phys_id; +int err; + +/* Fetch the SFF-8024 Identifier Value. For all supported standards, it +* is located at I2C address 0x50, byte 0. See section 4.1 in SFF-8024, +* revision 4.9. +*/ + page_data.page =MODULE_EEPROM_PHYS_ID_PAGE ; + page_data.offset =SFP_PHYS_ID ; + page_data.length =sizeof (phys_id); + page_data.i2c_address =MODULE_EEPROM_PHYS_ID_I2C_ADDR ; + page_data.data = &phys_id; + + err = ops->get_module_eeprom_by_page (dev, &page_data, extack); +if (err <0 ) +return err; + +switch (phys_id) { +case SFF8024_ID_QSFP_DD : +case SFF8024_ID_OSFP : +case SFF8024_ID_DSFP : +case SFF8024_ID_QSFP_PLUS_CMIS : +case SFF8024_ID_SFP_DD_CMIS : +case SFF8024_ID_SFP_PLUS_CMIS : +INIT_WORK (&module_fw->work, ethtool_cmis_fw_update); +break ; +default : +NL_SET_ERR_MSG (extack, +"Module type does not support firmware flashing" ); +return -EOPNOTSUPP ; + } + +return 0 ; +} + +static int +module_flash_fw_schedule (struct net_device *dev,const char *file_name, +struct ethtool_module_fw_flash_params *params, +struct netlink_ext_ack *extack) +{ +const struct ethtool_ops *ops = dev->ethtool_ops; +struct ethtool_module_fw_flash *module_fw; +int err; + +if (!ops->set_module_eeprom_by_page || + !ops->get_module_eeprom_by_page) { +NL_SET_ERR_MSG (extack, +"Flashing module firmware is not supported by this device" ); +return -EOPNOTSUPP ; + } + +if (dev->module_fw_flash_in_progress) { +NL_SET_ERR_MSG (extack,"Module firmware flashing already in progress" ); +return -EBUSY ; + } + + module_fw =kzalloc (sizeof (*module_fw),GFP_KERNEL ); +if (!module_fw) +return -ENOMEM ; + + module_fw->params = *params; + err =request_firmware_direct (&module_fw->fw, file_name, &dev->dev); +if (err) { +NL_SET_ERR_MSG (extack, +"Failed to request module firmware image" ); + goto err_request_firmware; + } + + err =module_flash_fw_work_init (module_fw, dev, extack); +if (err <0 ) { +NL_SET_ERR_MSG (extack, +"Flashing module firmware is not supported by this device" ); + goto err_work_init; + } + + dev->module_fw_flash_in_progress = true; +netdev_hold (dev, &module_fw->dev_tracker,GFP_KERNEL ); + module_fw->dev = dev; + +schedule_work (&module_fw->work); + +return 0 ; + +err_work_init: +release_firmware (module_fw->fw); +err_request_firmware: +kfree (module_fw); +return err; +} + +static int module_flash_fw (struct net_device *dev,struct nlattr **tb, +struct genl_info *info) +{ +struct ethtool_module_fw_flash_params params = {}; +const char *file_name; +struct nlattr *attr; + +if (GENL_REQ_ATTR_CHECK (info,ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME )) +return -EINVAL ; + + file_name =nla_data (tb[ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME ]); + + attr = tb[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD ]; +if (attr) { + params.password =cpu_to_be32 (nla_get_u32 (attr)); + params.password_valid = true; + } + +return module_flash_fw_schedule (dev, file_name, ¶ms, info->extack); +} + +int ethnl_act_module_fw_flash (struct sk_buff *skb,struct genl_info *info) +{ +struct ethnl_req_info req_info = {}; +struct nlattr **tb = info->attrs; +struct net_device *dev; +int ret; + + ret =ethnl_parse_header_dev_get (&req_info, + tb[ETHTOOL_A_MODULE_FW_FLASH_HEADER ], +genl_info_net (info), info->extack, + true); +if (ret <0 ) +return ret; + dev = req_info.dev; + +rtnl_lock (); + ret =ethnl_ops_begin (dev); +if (ret <0 ) + goto out_rtnl; + + ret =module_flash_fw (dev, tb, info); + +ethnl_ops_complete (dev); + +out_rtnl: +rtnl_unlock (); +ethnl_parse_header_dev_put (&req_info); +return ret; +} +/* MODULE_FW_FLASH_NTF */ static void
net/ethtool/netlink.c +7 -0
@@ -1129,6 +1129,13 @@ static const struct genl_ops ethtool_genl_ops[] = { .policy = ethnl_mm_set_policy, .maxattr = ARRAY_SIZE(ethnl_mm_set_policy) - 1, }, + { + .cmd = ETHTOOL_MSG_MODULE_FW_FLASH_ACT, + .flags = GENL_UNS_ADMIN_PERM, + .doit = ethnl_act_module_fw_flash, + .policy = ethnl_module_fw_flash_act_policy, + .maxattr = ARRAY_SIZE(ethnl_module_fw_flash_act_policy) - 1, + }, };static const struct genl_multicast_group ethtool_nl_mcgrps[] = {
net/ethtool/netlink.h +2 -0
@@ -441,6 +441,7 @@ extern const struct nla_policy ethnl_plca_set_cfg_policy[ETHTOOL_A_PLCA_MAX + 1]extern const struct nla_policy ethnl_plca_get_status_policy[ETHTOOL_A_PLCA_HEADER +1 ];extern const struct nla_policy ethnl_mm_get_policy[ETHTOOL_A_MM_HEADER +1 ];extern const struct nla_policy ethnl_mm_set_policy[ETHTOOL_A_MM_MAX +1 ]; +extern const struct nla_policy ethnl_module_fw_flash_act_policy[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD +1 ];int ethnl_set_features (struct sk_buff *skb,struct genl_info *info);int ethnl_act_cable_test (struct sk_buff *skb,struct genl_info *info);
@@ -448,6 +449,7 @@ int ethnl_act_cable_test_tdr(struct sk_buff *skb, struct genl_info *info);int ethnl_tunnel_info_doit (struct sk_buff *skb,struct genl_info *info);int ethnl_tunnel_info_start (struct netlink_callback *cb);int ethnl_tunnel_info_dumpit (struct sk_buff *skb,struct netlink_callback *cb); +int ethnl_act_module_fw_flash (struct sk_buff *skb,struct genl_info *info);extern const char stats_std_names[__ETHTOOL_STATS_CNT][ETH_GSTRING_LEN ];extern const char stats_eth_phy_names[__ETHTOOL_A_STATS_ETH_PHY_CNT][ETH_GSTRING_LEN ];
Signature · 1 line
2.43.0