Commit 4134c846 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/nex 


t-queue

Tony Nguyen says:

====================
100GbE Intel Wired LAN Driver Updates 2021-12-15

This series contains updates to ice driver only.

Jake makes changes to flash update. This includes the following:

 * a new shadow-ram region similar to NVM region but for the device shadow
   RAM contents. This is distinct from NVM region because shadow RAM is
   built up during device init and may be different from the raw NVM flash
   data.
 * refactoring of the ice_flash_pldm_image to become the main flash update
   entry point. This is simpler than having both an
   ice_devlink_flash_update and an ice_flash_pldm_image. It will make
   additions like dry-run easier in the future.
 * reducing time to read Option ROM version information.
 * adding support for firmware activation via devlink reload, when
   possible.

The major new work is the reload support, which allows activating firmware
immediately without a reboot when possible. Reload support only supports
firmware activation.

Jesse improves transmit code: utilizing newer netif_tx* API, adding some
prefetch calls, correcting expected conditions when calling ice_vsi_down(),
and utilizing __netdev_tx_sent_queue() call.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 823f7a54 9c99d099

Documentation/networking/devlink/ice.rst

+22 −2
Original line number Diff line number Diff line
@@ -26,8 +26,10 @@ The ``ice`` driver reports the following versions 
    * - ``fw.mgmt``

      - running

      - 2.1.7

      - 3-digit version number of the management firmware that controls the

        PHY, link, etc.

      - 3-digit version number of the management firmware running on the

        Embedded Management Processor of the device. It controls the PHY,

        link, access to device resources, etc. Intel documentation refers to

        this as the EMP firmware.

    * - ``fw.mgmt.api``

      - running

      - 1.5.1
@@ -119,6 +121,24 @@ preserving settings, and thus ``DEVLINK_FLASH_OVERWRITE_IDENTIFIERS`` on its 
own will be rejected. If no overwrite mask is provided, the firmware will be

instructed to preserve all settings and identifying fields when updating.



Reload

======



The ``ice`` driver supports activating new firmware after a flash update

using ``DEVLINK_CMD_RELOAD`` with the ``DEVLINK_RELOAD_ACTION_FW_ACTIVATE``

action.



.. code:: shell



    $ devlink dev reload pci/0000:01:00.0 reload action fw_activate



The new firmware is activated by issuing a device specific Embedded

Management Processor reset which requests the device to reset and reload the

EMP firmware image.



The driver does not currently support reloading the driver via

``DEVLINK_RELOAD_ACTION_DRIVER_REINIT``.



Regions

=======

drivers/net/ethernet/intel/ice/ice.h

+2 −0
Original line number Diff line number Diff line
@@ -503,6 +503,7 @@ struct ice_pf { 
	struct pci_dev *pdev;



	struct devlink_region *nvm_region;

	struct devlink_region *sram_region;

	struct devlink_region *devcaps_region;



	/* devlink port data */
@@ -552,6 +553,7 @@ struct ice_pf { 
	spinlock_t aq_wait_lock;

	struct hlist_head aq_wait_list;

	wait_queue_head_t aq_wait_queue;

	bool fw_emp_reset_disabled;



	wait_queue_head_t reset_wait_queue;

drivers/net/ethernet/intel/ice/ice_adminq_cmd.h

+7 −0
Original line number Diff line number Diff line
@@ -117,6 +117,8 @@ struct ice_aqc_list_caps_elem { 
#define ICE_AQC_CAPS_NET_VER				0x004C

#define ICE_AQC_CAPS_PENDING_NET_VER			0x004D

#define ICE_AQC_CAPS_RDMA				0x0051

#define ICE_AQC_CAPS_PCIE_RESET_AVOIDANCE		0x0076

#define ICE_AQC_CAPS_POST_UPDATE_RESET_RESTRICT		0x0077

#define ICE_AQC_CAPS_NVM_MGMT				0x0080



	u8 major_ver;
@@ -1408,6 +1410,11 @@ struct ice_aqc_nvm { 
#define ICE_AQC_NVM_REVERT_LAST_ACTIV	BIT(6) /* Write Activate only */

#define ICE_AQC_NVM_ACTIV_SEL_MASK	ICE_M(0x7, 3)

#define ICE_AQC_NVM_FLASH_ONLY		BIT(7)

#define ICE_AQC_NVM_RESET_LVL_M		ICE_M(0x3, 0) /* Write reply only */

#define ICE_AQC_NVM_POR_FLAG		0

#define ICE_AQC_NVM_PERST_FLAG		1

#define ICE_AQC_NVM_EMPR_FLAG		2

#define ICE_AQC_NVM_EMPR_ENA		BIT(0) /* Write Activate reply only */

	__le16 module_typeid;

	__le16 length;

#define ICE_AQC_NVM_ERASE_LEN	0xFFFF

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

+12 −0
Original line number Diff line number Diff line
@@ -2068,6 +2068,18 @@ ice_parse_common_caps(struct ice_hw *hw, struct ice_hw_common_caps *caps, 
		ice_debug(hw, ICE_DBG_INIT, "%s: max_mtu = %d\n",

			  prefix, caps->max_mtu);

		break;

	case ICE_AQC_CAPS_PCIE_RESET_AVOIDANCE:

		caps->pcie_reset_avoidance = (number > 0);

		ice_debug(hw, ICE_DBG_INIT,

			  "%s: pcie_reset_avoidance = %d\n", prefix,

			  caps->pcie_reset_avoidance);

		break;

	case ICE_AQC_CAPS_POST_UPDATE_RESET_RESTRICT:

		caps->reset_restrict_support = (number == 1);

		ice_debug(hw, ICE_DBG_INIT,

			  "%s: reset_restrict_support = %d\n", prefix,

			  caps->reset_restrict_support);

		break;

	default:

		/* Not one of the recognized common capabilities */

		found = false;

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

+167 −35
Original line number Diff line number Diff line
@@ -371,57 +371,105 @@ static int ice_devlink_info_get(struct devlink *devlink, 
}



/**

 * ice_devlink_flash_update - Update firmware stored in flash on the device

 * @devlink: pointer to devlink associated with device to update

 * @params: flash update parameters

 * ice_devlink_reload_empr_start - Start EMP reset to activate new firmware

 * @devlink: pointer to the devlink instance to reload

 * @netns_change: if true, the network namespace is changing

 * @action: the action to perform. Must be DEVLINK_RELOAD_ACTION_FW_ACTIVATE

 * @limit: limits on what reload should do, such as not resetting

 * @extack: netlink extended ACK structure

 *

 * Perform a device flash update. The bulk of the update logic is contained

 * within the ice_flash_pldm_image function.

 * Allow user to activate new Embedded Management Processor firmware by

 * issuing device specific EMP reset. Called in response to

 * a DEVLINK_CMD_RELOAD with the DEVLINK_RELOAD_ACTION_FW_ACTIVATE.

 *

 * Returns: zero on success, or an error code on failure.

 * Note that teardown and rebuild of the driver state happens automatically as

 * part of an interrupt and watchdog task. This is because all physical

 * functions on the device must be able to reset when an EMP reset occurs from

 * any source.

 */

static int

ice_devlink_flash_update(struct devlink *devlink,

			 struct devlink_flash_update_params *params,

ice_devlink_reload_empr_start(struct devlink *devlink, bool netns_change,

			      enum devlink_reload_action action,

			      enum devlink_reload_limit limit,

			      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;

	u8 preservation;

	u8 pending;

	int err;



	if (!params->overwrite_mask) {

		/* preserve all settings and identifiers */

		preservation = ICE_AQC_NVM_PRESERVE_ALL;

	} else if (params->overwrite_mask == DEVLINK_FLASH_OVERWRITE_SETTINGS) {

		/* overwrite settings, but preserve the vital device identifiers */

		preservation = ICE_AQC_NVM_PRESERVE_SELECTED;

	} else if (params->overwrite_mask == (DEVLINK_FLASH_OVERWRITE_SETTINGS |

					      DEVLINK_FLASH_OVERWRITE_IDENTIFIERS)) {

		/* overwrite both settings and identifiers, preserve nothing */

		preservation = ICE_AQC_NVM_NO_PRESERVATION;

	} else {

		NL_SET_ERR_MSG_MOD(extack, "Requested overwrite mask is not supported");

		return -EOPNOTSUPP;

	err = ice_get_pending_updates(pf, &pending, extack);

	if (err)

		return err;



	/* pending is a bitmask of which flash banks have a pending update,

	 * including the main NVM bank, the Option ROM bank, and the netlist

	 * bank. If any of these bits are set, then there is a pending update

	 * waiting to be activated.

	 */

	if (!pending) {

		NL_SET_ERR_MSG_MOD(extack, "No pending firmware update");

		return -ECANCELED;

	}



	if (!hw->dev_caps.common_cap.nvm_unified_update) {

		NL_SET_ERR_MSG_MOD(extack, "Current firmware does not support unified update");

		return -EOPNOTSUPP;

	if (pf->fw_emp_reset_disabled) {

		NL_SET_ERR_MSG_MOD(extack, "EMP reset is not available. To activate firmware, a reboot or power cycle is needed");

		return -ECANCELED;

	}



	err = ice_check_for_pending_update(pf, NULL, extack);

	if (err)

	dev_dbg(dev, "Issuing device EMP reset to activate firmware\n");



	err = ice_aq_nvm_update_empr(hw);

	if (err) {

		dev_err(dev, "Failed to trigger EMP device reset to reload firmware, err %d aq_err %s\n",

			err, ice_aq_str(hw->adminq.sq_last_status));

		NL_SET_ERR_MSG_MOD(extack, "Failed to trigger EMP device reset to reload firmware");

		return err;

	}



	return 0;

}



/**

 * ice_devlink_reload_empr_finish - Wait for EMP reset to finish

 * @devlink: pointer to the devlink instance reloading

 * @action: the action requested

 * @limit: limits imposed by userspace, such as not resetting

 * @actions_performed: on return, indicate what actions actually performed

 * @extack: netlink extended ACK structure

 *

 * Wait for driver to finish rebuilding after EMP reset is completed. This

 * includes time to wait for both the actual device reset as well as the time

 * for the driver's rebuild to complete.

 */

static int

ice_devlink_reload_empr_finish(struct devlink *devlink,

			       enum devlink_reload_action action,

			       enum devlink_reload_limit limit,

			       u32 *actions_performed,

			       struct netlink_ext_ack *extack)

{

	struct ice_pf *pf = devlink_priv(devlink);

	int err;



	devlink_flash_update_status_notify(devlink, "Preparing to flash", NULL, 0, 0);

	*actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);



	return ice_flash_pldm_image(pf, params->fw, preservation, extack);

	err = ice_wait_for_reset(pf, 60 * HZ);

	if (err) {

		NL_SET_ERR_MSG_MOD(extack, "Device still resetting after 1 minute");

		return err;

	}



	return 0;

}



static const struct devlink_ops ice_devlink_ops = {

	.supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,

	.reload_actions = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),

	/* The ice driver currently does not support driver reinit */

	.reload_down = ice_devlink_reload_empr_start,

	.reload_up = ice_devlink_reload_empr_finish,

	.eswitch_mode_get = ice_eswitch_mode_get,

	.eswitch_mode_set = ice_eswitch_mode_set,

	.info_get = ice_devlink_info_get,
@@ -582,6 +630,7 @@ void ice_devlink_register(struct ice_pf *pf) 
{

	struct devlink *devlink = priv_to_devlink(pf);



	devlink_set_features(devlink, DEVLINK_F_RELOAD);

	devlink_register(devlink);

}
@@ -739,16 +788,20 @@ void ice_devlink_destroy_vf_port(struct ice_vf *vf) 
}



/**

 * ice_devlink_nvm_snapshot - Capture a snapshot of the Shadow RAM contents

 * ice_devlink_nvm_snapshot - Capture a snapshot of the NVM flash contents

 * @devlink: the devlink instance

 * @ops: the devlink region being snapshotted

 * @extack: extended ACK response structure

 * @data: on exit points to snapshot data buffer

 *

 * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for

 * the shadow-ram devlink region. It captures a snapshot of the shadow ram

 * contents. This snapshot can later be viewed via the devlink-region

 * interface.

 * the nvm-flash devlink region. It captures a snapshot of the full NVM flash

 * contents, including both banks of flash. This snapshot can later be viewed

 * via the devlink-region interface.

 *

 * It captures the flash using the FLASH_ONLY bit set when reading via

 * firmware, so it does not read the current Shadow RAM contents. For that,

 * use the shadow-ram region.

 *

 * @returns zero on success, and updates the data pointer. Returns a non-zero

 * error code on failure.
@@ -795,6 +848,66 @@ static int ice_devlink_nvm_snapshot(struct devlink *devlink, 
	return 0;

}



/**

 * ice_devlink_sram_snapshot - Capture a snapshot of the Shadow RAM contents

 * @devlink: the devlink instance

 * @ops: the devlink region being snapshotted

 * @extack: extended ACK response structure

 * @data: on exit points to snapshot data buffer

 *

 * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for

 * the shadow-ram devlink region. It captures a snapshot of the shadow ram

 * contents. This snapshot can later be viewed via the devlink-region

 * interface.

 *

 * @returns zero on success, and updates the data pointer. Returns a non-zero

 * error code on failure.

 */

static int

ice_devlink_sram_snapshot(struct devlink *devlink,

			  const struct devlink_region_ops __always_unused *ops,

			  struct netlink_ext_ack *extack, u8 **data)

{

	struct ice_pf *pf = devlink_priv(devlink);

	struct device *dev = ice_pf_to_dev(pf);

	struct ice_hw *hw = &pf->hw;

	u8 *sram_data;

	u32 sram_size;

	int err;



	sram_size = hw->flash.sr_words * 2u;

	sram_data = vzalloc(sram_size);

	if (!sram_data)

		return -ENOMEM;



	err = ice_acquire_nvm(hw, ICE_RES_READ);

	if (err) {

		dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",

			err, hw->adminq.sq_last_status);

		NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");

		vfree(sram_data);

		return err;

	}



	/* Read from the Shadow RAM, rather than directly from NVM */

	err = ice_read_flat_nvm(hw, 0, &sram_size, sram_data, true);

	if (err) {

		dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",

			sram_size, err, hw->adminq.sq_last_status);

		NL_SET_ERR_MSG_MOD(extack,

				   "Failed to read Shadow RAM contents");

		ice_release_nvm(hw);

		vfree(sram_data);

		return err;

	}



	ice_release_nvm(hw);



	*data = sram_data;



	return 0;

}



/**

 * ice_devlink_devcaps_snapshot - Capture snapshot of device capabilities

 * @devlink: the devlink instance
@@ -845,6 +958,12 @@ static const struct devlink_region_ops ice_nvm_region_ops = { 
	.snapshot = ice_devlink_nvm_snapshot,

};



static const struct devlink_region_ops ice_sram_region_ops = {

	.name = "shadow-ram",

	.destructor = vfree,

	.snapshot = ice_devlink_sram_snapshot,

};



static const struct devlink_region_ops ice_devcaps_region_ops = {

	.name = "device-caps",

	.destructor = vfree,
@@ -862,7 +981,7 @@ void ice_devlink_init_regions(struct ice_pf *pf) 
{

	struct devlink *devlink = priv_to_devlink(pf);

	struct device *dev = ice_pf_to_dev(pf);

	u64 nvm_size;

	u64 nvm_size, sram_size;



	nvm_size = pf->hw.flash.flash_size;

	pf->nvm_region = devlink_region_create(devlink, &ice_nvm_region_ops, 1,
@@ -873,6 +992,15 @@ void ice_devlink_init_regions(struct ice_pf *pf) 
		pf->nvm_region = NULL;

	}



	sram_size = pf->hw.flash.sr_words * 2u;

	pf->sram_region = devlink_region_create(devlink, &ice_sram_region_ops,

						1, sram_size);

	if (IS_ERR(pf->sram_region)) {

		dev_err(dev, "failed to create shadow-ram devlink region, err %ld\n",

			PTR_ERR(pf->sram_region));

		pf->sram_region = NULL;

	}



	pf->devcaps_region = devlink_region_create(devlink,

						   &ice_devcaps_region_ops, 10,

						   ICE_AQ_MAX_BUF_LEN);
@@ -893,6 +1021,10 @@ void ice_devlink_destroy_regions(struct ice_pf *pf) 
{

	if (pf->nvm_region)

		devlink_region_destroy(pf->nvm_region);



	if (pf->sram_region)

		devlink_region_destroy(pf->sram_region);



	if (pf->devcaps_region)

		devlink_region_destroy(pf->devcaps_region);

}