Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6cd476d2 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/jkirsher/next-queue 



Jeff Kirsher says:

====================
100GbE Intel Wired LAN Driver Updates 2019-09-12

This series contains updates to ice driver to implement and support
loading a Dynamic Device Personalization (DDP) package from lib/firmware
onto the device.

Paul updates the way the driver version is stored in the driver so that
we can pass the driver version to the firmware.  Passing of the driver
version to the firmware is needed for the DDP package to ensure we have
the appropriate support in the driver for the features in the package.

Lukasz fixes how the firmware version is stored to align with how the
firmware stores its own version.  Also extended the log message to
display additional useful information such as NVM version, API patch
information and firmware build hash.

Tony adds the needed driver support to check, load and store the DDP
package.  Also add support for the ability to load DDP packages intended
for specific hardware devices, as well as what to do when loading of the
DDP package fails to load.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 069841ef 2de12566

drivers/net/ethernet/intel/ice/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ ice-y := ice_main.o \ 
	 ice_sched.o	\

	 ice_lib.o	\

	 ice_txrx.o	\

	 ice_flex_pipe.o	\

	 ice_ethtool.o

ice-$(CONFIG_PCI_IOV) += ice_virtchnl_pf.o ice_sriov.o

ice-$(CONFIG_DCB) += ice_dcb.o ice_dcb_lib.o

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

+15 −1
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/firmware.h>

#include <linux/netdevice.h>

#include <linux/compiler.h>

#include <linux/etherdevice.h>
@@ -29,6 +30,7 @@ 
#include <linux/sctp.h>

#include <linux/ipv6.h>

#include <linux/if_bridge.h>

#include <linux/ctype.h>

#include <linux/avf/virtchnl.h>

#include <net/ipv6.h>

#include "ice_devids.h"
@@ -52,7 +54,6 @@ extern const char ice_drv_ver[]; 


#define ICE_DFLT_TRAFFIC_CLASS	BIT(0)

#define ICE_INT_NAME_STR_LEN	(IFNAMSIZ + 16)

#define ICE_ETHTOOL_FWVER_LEN	32

#define ICE_AQ_LEN		64

#define ICE_MBXSQ_LEN		64

#define ICE_MBXRQ_LEN		512
@@ -307,6 +308,7 @@ enum ice_pf_flags { 
	ICE_FLAG_SRIOV_CAPABLE,

	ICE_FLAG_DCB_CAPABLE,

	ICE_FLAG_DCB_ENA,

	ICE_FLAG_ADV_FEATURES,

	ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA,

	ICE_FLAG_NO_MEDIA,

	ICE_FLAG_FW_LLDP_AGENT,
@@ -404,6 +406,17 @@ ice_irq_dynamic_ena(struct ice_hw *hw, struct ice_vsi *vsi, 
	wr32(hw, GLINT_DYN_CTL(vector), val);

}



/**

 * ice_netdev_to_pf - Retrieve the PF struct associated with a netdev

 * @netdev: pointer to the netdev struct

 */

static inline struct ice_pf *ice_netdev_to_pf(struct net_device *netdev)

{

	struct ice_netdev_priv *np = netdev_priv(netdev);



	return np->vsi->back;

}



/**

 * ice_get_main_vsi - Get the PF VSI

 * @pf: PF instance
@@ -421,6 +434,7 @@ static inline struct ice_vsi *ice_get_main_vsi(struct ice_pf *pf) 
int ice_vsi_setup_tx_rings(struct ice_vsi *vsi);

int ice_vsi_setup_rx_rings(struct ice_vsi *vsi);

void ice_set_ethtool_ops(struct net_device *netdev);

void ice_set_ethtool_safe_mode_ops(struct net_device *netdev);

u16 ice_get_avail_txq_count(struct ice_pf *pf);

u16 ice_get_avail_rxq_count(struct ice_pf *pf);

void ice_update_vsi_stats(struct ice_vsi *vsi);

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

+73 −0
Original line number Diff line number Diff line
@@ -33,6 +33,17 @@ struct ice_aqc_get_ver { 
	u8 api_patch;

};



/* Send driver version (indirect 0x0002) */

struct ice_aqc_driver_ver {

	u8 major_ver;

	u8 minor_ver;

	u8 build_ver;

	u8 subbuild_ver;

	u8 reserved[4];

	__le32 addr_high;

	__le32 addr_low;

};



/* Queue Shutdown (direct 0x0003) */

struct ice_aqc_q_shutdown {

	u8 driver_unloading;
@@ -1519,6 +1530,56 @@ struct ice_aqc_get_clear_fw_log { 
	__le32 addr_low;

};



/* Download Package (indirect 0x0C40) */

/* Also used for Update Package (indirect 0x0C42) */

struct ice_aqc_download_pkg {

	u8 flags;

#define ICE_AQC_DOWNLOAD_PKG_LAST_BUF	0x01

	u8 reserved[3];

	__le32 reserved1;

	__le32 addr_high;

	__le32 addr_low;

};



struct ice_aqc_download_pkg_resp {

	__le32 error_offset;

	__le32 error_info;

	__le32 addr_high;

	__le32 addr_low;

};



/* Get Package Info List (indirect 0x0C43) */

struct ice_aqc_get_pkg_info_list {

	__le32 reserved1;

	__le32 reserved2;

	__le32 addr_high;

	__le32 addr_low;

};



/* Version format for packages */

struct ice_pkg_ver {

	u8 major;

	u8 minor;

	u8 update;

	u8 draft;

};



#define ICE_PKG_NAME_SIZE	32



struct ice_aqc_get_pkg_info {

	struct ice_pkg_ver ver;

	char name[ICE_PKG_NAME_SIZE];

	u8 is_in_nvm;

	u8 is_active;

	u8 is_active_at_boot;

	u8 is_modified;

};



/* Get Package Info List response buffer format (0x0C43) */

struct ice_aqc_get_pkg_info_resp {

	__le32 count;

	struct ice_aqc_get_pkg_info pkg_info[1];

};

/**

 * struct ice_aq_desc - Admin Queue (AQ) descriptor

 * @flags: ICE_AQ_FLAG_* flags
@@ -1547,6 +1608,7 @@ struct ice_aq_desc { 
		u8 raw[16];

		struct ice_aqc_generic generic;

		struct ice_aqc_get_ver get_ver;

		struct ice_aqc_driver_ver driver_ver;

		struct ice_aqc_q_shutdown q_shutdown;

		struct ice_aqc_req_res res_owner;

		struct ice_aqc_manage_mac_read mac_read;
@@ -1580,6 +1642,7 @@ struct ice_aq_desc { 
		struct ice_aqc_add_update_free_vsi_resp add_update_free_vsi_res;

		struct ice_aqc_fw_logging fw_logging;

		struct ice_aqc_get_clear_fw_log get_clear_fw_log;

		struct ice_aqc_download_pkg download_pkg;

		struct ice_aqc_set_mac_lb set_mac_lb;

		struct ice_aqc_alloc_free_res_cmd sw_res_ctrl;

		struct ice_aqc_set_event_mask set_event_mask;
@@ -1612,12 +1675,18 @@ enum ice_aq_err { 
	ICE_AQ_RC_EEXIST	= 13, /* Object already exists */

	ICE_AQ_RC_ENOSPC	= 16, /* No space left or allocation failure */

	ICE_AQ_RC_ENOSYS	= 17, /* Function not implemented */

	ICE_AQ_RC_ENOSEC	= 24, /* Missing security manifest */

	ICE_AQ_RC_EBADSIG	= 25, /* Bad RSA signature */

	ICE_AQ_RC_ESVN		= 26, /* SVN number prohibits this package */

	ICE_AQ_RC_EBADMAN	= 27, /* Manifest hash mismatch */

	ICE_AQ_RC_EBADBUF	= 28, /* Buffer hash mismatches manifest */

};



/* Admin Queue command opcodes */

enum ice_adminq_opc {

	/* AQ commands */

	ice_aqc_opc_get_ver				= 0x0001,

	ice_aqc_opc_driver_ver				= 0x0002,

	ice_aqc_opc_q_shutdown				= 0x0003,



	/* resource ownership */
@@ -1699,6 +1768,10 @@ enum ice_adminq_opc { 
	ice_aqc_opc_add_txqs				= 0x0C30,

	ice_aqc_opc_dis_txqs				= 0x0C31,



	/* package commands */

	ice_aqc_opc_download_pkg			= 0x0C40,

	ice_aqc_opc_get_pkg_info_list			= 0x0C43,



	/* debug commands */

	ice_aqc_opc_fw_logging				= 0xFF09,

	ice_aqc_opc_fw_logging_info			= 0xFF10,

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

+172 −2
Original line number Diff line number Diff line
@@ -728,6 +728,29 @@ static void ice_get_itr_intrl_gran(struct ice_hw *hw) 
	}

}



/**

 * ice_get_nvm_version - get cached NVM version data

 * @hw: pointer to the hardware structure

 * @oem_ver: 8 bit NVM version

 * @oem_build: 16 bit NVM build number

 * @oem_patch: 8 NVM patch number

 * @ver_hi: high 16 bits of the NVM version

 * @ver_lo: low 16 bits of the NVM version

 */

void

ice_get_nvm_version(struct ice_hw *hw, u8 *oem_ver, u16 *oem_build,

		    u8 *oem_patch, u8 *ver_hi, u8 *ver_lo)

{

	struct ice_nvm_info *nvm = &hw->nvm;



	*oem_ver = (u8)((nvm->oem_ver & ICE_OEM_VER_MASK) >> ICE_OEM_VER_SHIFT);

	*oem_patch = (u8)(nvm->oem_ver & ICE_OEM_VER_PATCH_MASK);

	*oem_build = (u16)((nvm->oem_ver & ICE_OEM_VER_BUILD_MASK) >>

			   ICE_OEM_VER_BUILD_SHIFT);

	*ver_hi = (nvm->ver & ICE_NVM_VER_HI_MASK) >> ICE_NVM_VER_HI_SHIFT;

	*ver_lo = (nvm->ver & ICE_NVM_VER_LO_MASK) >> ICE_NVM_VER_LO_SHIFT;

}



/**

 * ice_init_hw - main hardware initialization routine

 * @hw: pointer to the hardware structure
@@ -859,7 +882,9 @@ enum ice_status ice_init_hw(struct ice_hw *hw) 


	ice_init_flex_flds(hw, ICE_RXDID_FLEX_NIC);

	ice_init_flex_flds(hw, ICE_RXDID_FLEX_NIC_2);



	status = ice_init_hw_tbls(hw);

	if (status)

		goto err_unroll_fltr_mgmt_struct;

	return 0;



err_unroll_fltr_mgmt_struct:
@@ -887,6 +912,8 @@ void ice_deinit_hw(struct ice_hw *hw) 


	ice_sched_cleanup_all(hw);

	ice_sched_clear_agg(hw);

	ice_free_seg(hw);

	ice_free_hw_tbls(hw);



	if (hw->port_info) {

		devm_kfree(ice_hw_to_dev(hw), hw->port_info);
@@ -1207,6 +1234,12 @@ ice_debug_cq(struct ice_hw *hw, u32 __maybe_unused mask, void *desc, void *buf, 


/* FW Admin Queue command wrappers */



/* Software lock/mutex that is meant to be held while the Global Config Lock

 * in firmware is acquired by the software to prevent most (but not all) types

 * of AQ commands from being sent to FW

 */

DEFINE_MUTEX(ice_global_cfg_lock_sw);



/**

 * ice_aq_send_cmd - send FW Admin Queue command to FW Admin Queue

 * @hw: pointer to the HW struct
@@ -1221,7 +1254,38 @@ enum ice_status 
ice_aq_send_cmd(struct ice_hw *hw, struct ice_aq_desc *desc, void *buf,

		u16 buf_size, struct ice_sq_cd *cd)

{

	return ice_sq_send_cmd(hw, &hw->adminq, desc, buf, buf_size, cd);

	struct ice_aqc_req_res *cmd = &desc->params.res_owner;

	bool lock_acquired = false;

	enum ice_status status;



	/* When a package download is in process (i.e. when the firmware's

	 * Global Configuration Lock resource is held), only the Download

	 * Package, Get Version, Get Package Info List and Release Resource

	 * (with resource ID set to Global Config Lock) AdminQ commands are

	 * allowed; all others must block until the package download completes

	 * and the Global Config Lock is released.  See also

	 * ice_acquire_global_cfg_lock().

	 */

	switch (le16_to_cpu(desc->opcode)) {

	case ice_aqc_opc_download_pkg:

	case ice_aqc_opc_get_pkg_info_list:

	case ice_aqc_opc_get_ver:

		break;

	case ice_aqc_opc_release_res:

		if (le16_to_cpu(cmd->res_id) == ICE_AQC_RES_ID_GLBL_LOCK)

			break;

		/* fall-through */

	default:

		mutex_lock(&ice_global_cfg_lock_sw);

		lock_acquired = true;

		break;

	}



	status = ice_sq_send_cmd(hw, &hw->adminq, desc, buf, buf_size, cd);

	if (lock_acquired)

		mutex_unlock(&ice_global_cfg_lock_sw);



	return status;

}



/**
@@ -1258,6 +1322,43 @@ enum ice_status ice_aq_get_fw_ver(struct ice_hw *hw, struct ice_sq_cd *cd) 
	return status;

}



/**

 * ice_aq_send_driver_ver

 * @hw: pointer to the HW struct

 * @dv: driver's major, minor version

 * @cd: pointer to command details structure or NULL

 *

 * Send the driver version (0x0002) to the firmware

 */

enum ice_status

ice_aq_send_driver_ver(struct ice_hw *hw, struct ice_driver_ver *dv,

		       struct ice_sq_cd *cd)

{

	struct ice_aqc_driver_ver *cmd;

	struct ice_aq_desc desc;

	u16 len;



	cmd = &desc.params.driver_ver;



	if (!dv)

		return ICE_ERR_PARAM;



	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_driver_ver);



	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);

	cmd->major_ver = dv->major_ver;

	cmd->minor_ver = dv->minor_ver;

	cmd->build_ver = dv->build_ver;

	cmd->subbuild_ver = dv->subbuild_ver;



	len = 0;

	while (len < sizeof(dv->driver_string) &&

	       isascii(dv->driver_string[len]) && dv->driver_string[len])

		len++;



	return ice_aq_send_cmd(hw, &desc, dv->driver_string, len, cd);

}



/**

 * ice_aq_q_shutdown

 * @hw: pointer to the HW struct
@@ -1745,6 +1846,75 @@ ice_discover_caps(struct ice_hw *hw, enum ice_adminq_opc opc) 
	return status;

}



/**

 * ice_set_safe_mode_caps - Override dev/func capabilities when in safe mode

 * @hw: pointer to the hardware structure

 */

void ice_set_safe_mode_caps(struct ice_hw *hw)

{

	struct ice_hw_func_caps *func_caps = &hw->func_caps;

	struct ice_hw_dev_caps *dev_caps = &hw->dev_caps;

	u32 valid_func, rxq_first_id, txq_first_id;

	u32 msix_vector_first_id, max_mtu;

	u32 num_func = 0;

	u8 i;



	/* cache some func_caps values that should be restored after memset */

	valid_func = func_caps->common_cap.valid_functions;

	txq_first_id = func_caps->common_cap.txq_first_id;

	rxq_first_id = func_caps->common_cap.rxq_first_id;

	msix_vector_first_id = func_caps->common_cap.msix_vector_first_id;

	max_mtu = func_caps->common_cap.max_mtu;



	/* unset func capabilities */

	memset(func_caps, 0, sizeof(*func_caps));



	/* restore cached values */

	func_caps->common_cap.valid_functions = valid_func;

	func_caps->common_cap.txq_first_id = txq_first_id;

	func_caps->common_cap.rxq_first_id = rxq_first_id;

	func_caps->common_cap.msix_vector_first_id = msix_vector_first_id;

	func_caps->common_cap.max_mtu = max_mtu;



	/* one Tx and one Rx queue in safe mode */

	func_caps->common_cap.num_rxq = 1;

	func_caps->common_cap.num_txq = 1;



	/* two MSIX vectors, one for traffic and one for misc causes */

	func_caps->common_cap.num_msix_vectors = 2;

	func_caps->guar_num_vsi = 1;



	/* cache some dev_caps values that should be restored after memset */

	valid_func = dev_caps->common_cap.valid_functions;

	txq_first_id = dev_caps->common_cap.txq_first_id;

	rxq_first_id = dev_caps->common_cap.rxq_first_id;

	msix_vector_first_id = dev_caps->common_cap.msix_vector_first_id;

	max_mtu = dev_caps->common_cap.max_mtu;



	/* unset dev capabilities */

	memset(dev_caps, 0, sizeof(*dev_caps));



	/* restore cached values */

	dev_caps->common_cap.valid_functions = valid_func;

	dev_caps->common_cap.txq_first_id = txq_first_id;

	dev_caps->common_cap.rxq_first_id = rxq_first_id;

	dev_caps->common_cap.msix_vector_first_id = msix_vector_first_id;

	dev_caps->common_cap.max_mtu = max_mtu;



	/* valid_func is a bitmap. get number of functions */

#define ICE_MAX_FUNCS 8

	for (i = 0; i < ICE_MAX_FUNCS; i++)

		if (valid_func & BIT(i))

			num_func++;



	/* one Tx and one Rx queue per function in safe mode */

	dev_caps->common_cap.num_rxq = num_func;

	dev_caps->common_cap.num_txq = num_func;



	/* two MSIX vectors per function */

	dev_caps->common_cap.num_msix_vectors = 2 * num_func;

}



/**

 * ice_get_caps - get info about the HW

 * @hw: pointer to the hardware structure

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

+12 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 


#include "ice.h"

#include "ice_type.h"

#include "ice_flex_pipe.h"

#include "ice_switch.h"

#include <linux/avf/virtchnl.h>
@@ -41,6 +42,8 @@ ice_sq_send_cmd(struct ice_hw *hw, struct ice_ctl_q_info *cq, 
void ice_clear_pxe_mode(struct ice_hw *hw);

enum ice_status ice_get_caps(struct ice_hw *hw);



void ice_set_safe_mode_caps(struct ice_hw *hw);



void ice_dev_onetime_setup(struct ice_hw *hw);



enum ice_status
@@ -66,11 +69,17 @@ void ice_fill_dflt_direct_cmd_desc(struct ice_aq_desc *desc, u16 opcode); 
extern const struct ice_ctx_ele ice_tlan_ctx_info[];

enum ice_status

ice_set_ctx(u8 *src_ctx, u8 *dest_ctx, const struct ice_ctx_ele *ce_info);



extern struct mutex ice_global_cfg_lock_sw;



enum ice_status

ice_aq_send_cmd(struct ice_hw *hw, struct ice_aq_desc *desc,

		void *buf, u16 buf_size, struct ice_sq_cd *cd);

enum ice_status ice_aq_get_fw_ver(struct ice_hw *hw, struct ice_sq_cd *cd);



enum ice_status

ice_aq_send_driver_ver(struct ice_hw *hw, struct ice_driver_ver *dv,

		       struct ice_sq_cd *cd);

enum ice_status

ice_aq_get_phy_caps(struct ice_port_info *pi, bool qual_mods, u8 report_mode,

		    struct ice_aqc_get_phy_caps_data *caps,
@@ -130,6 +139,9 @@ ice_stat_update40(struct ice_hw *hw, u32 reg, bool prev_stat_loaded, 
void

ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,

		  u64 *prev_stat, u64 *cur_stat);

void

ice_get_nvm_version(struct ice_hw *hw, u8 *oem_ver, u16 *oem_build,

		    u8 *oem_patch, u8 *ver_hi, u8 *ver_lo);

enum ice_status

ice_sched_query_elem(struct ice_hw *hw, u32 node_teid,

		     struct ice_aqc_get_elem *buf);