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

Commit 6938843d 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-05

This series contains updates to ice driver.

Brett fixes the setting of num_q_vectors by using the maximum number
between the allocated transmit and receive queues.

Anirudh simplifies the code to use a helper function to return the main
VSI, which is the first element in the pf->vsi array.  Adds a pointer
check to prevent a NULL pointer dereference.  Adds a check to ensure we
do not initialize DCB on devices that are not DCB capable.  Does some
housekeeping on the code to remove unnecessary indirection and reduce
the PF structure by removing elements that are not needed since the
values they were storing can be readily gotten from
ice_get_avail_*_count()'s.  Updates the printed strings to make it
easier to search the logs for driver capabilities.

Jesse cleans up unnecessary function arguments.  Updated the code to use
prefetch() to add some efficiency to the driver to avoid a cache miss.
Did some housekeeping on the code to remove the configurable transmit
work limit via ethtool which ended up creating performance overhead.
Made additional performance enhancements by updating the driver to start
out with a reasonable number of descriptors by changing the default to
2048.

Mitch fixes the reset logic for VFs by clearing VF_MBX_ARQLEN register
when the source of the reset is not PFR.

Lukasz updates the driver to include a similar fix for the i40e driver
by reporting link down for VF's when the PF queues are not enabled.

Akeem updates the driver to report the VF link status once we get VF
resources so that we can reflect the link status similarly to how the PF
reports link speed.

Ashish updates the transmit context structure based on recent changes to
the hardware specification.

Dave updates the DCB logic to allow a delayed registration for MIB
change events so that the driver is not accepting events before it is
ready for them.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 742ca781 5c875c1a

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

+11 −35
Original line number Diff line number Diff line
@@ -47,23 +47,8 @@ extern const char ice_drv_ver[]; 
#define ICE_MIN_NUM_DESC	64

#define ICE_MAX_NUM_DESC	8160

#define ICE_DFLT_MIN_RX_DESC	512

/* if the default number of Rx descriptors between ICE_MAX_NUM_DESC and the

 * number of descriptors to fill up an entire page is greater than or equal to

 * ICE_DFLT_MIN_RX_DESC set it based on page size, otherwise set it to

 * ICE_DFLT_MIN_RX_DESC

 */

#define ICE_DFLT_NUM_RX_DESC \

	min_t(u16, ICE_MAX_NUM_DESC, \

	      max_t(u16, ALIGN(PAGE_SIZE / sizeof(union ice_32byte_rx_desc), \

			       ICE_REQ_DESC_MULTIPLE), \

		    ICE_DFLT_MIN_RX_DESC))

/* set default number of Tx descriptors to the minimum between ICE_MAX_NUM_DESC

 * and the number of descriptors to fill up an entire page

 */

#define ICE_DFLT_NUM_TX_DESC	min_t(u16, ICE_MAX_NUM_DESC, \

				      ALIGN(PAGE_SIZE / \

					    sizeof(struct ice_tx_desc), \

					    ICE_REQ_DESC_MULTIPLE))

#define ICE_DFLT_NUM_TX_DESC	256

#define ICE_DFLT_NUM_RX_DESC	2048



#define ICE_DFLT_TRAFFIC_CLASS	BIT(0)

#define ICE_INT_NAME_STR_LEN	(IFNAMSIZ + 16)
@@ -247,9 +232,6 @@ struct ice_vsi { 
	u16 vsi_num;			/* HW (absolute) index of this VSI */

	u16 idx;			/* software index in pf->vsi[] */



	/* Interrupt thresholds */

	u16 work_lmt;



	s16 vf_id;			/* VF ID for SR-IOV VSIs */



	u16 ethtype;			/* Ethernet protocol for pause frame */
@@ -371,8 +353,6 @@ struct ice_pf { 
	u32 num_lan_msix;	/* Total MSIX vectors for base driver */

	u16 num_lan_tx;		/* num LAN Tx queues setup */

	u16 num_lan_rx;		/* num LAN Rx queues setup */

	u16 q_left_tx;		/* remaining num Tx queues left unclaimed */

	u16 q_left_rx;		/* remaining num Rx queues left unclaimed */

	u16 next_vsi;		/* Next free slot in pf->vsi[] - 0-based! */

	u16 num_alloc_vsi;

	u16 corer_count;	/* Core reset count */
@@ -425,21 +405,15 @@ ice_irq_dynamic_ena(struct ice_hw *hw, struct ice_vsi *vsi, 
}



/**

 * ice_find_vsi_by_type - Find and return VSI of a given type

 * @pf: PF to search for VSI

 * @type: Value indicating type of VSI we are looking for

 * ice_get_main_vsi - Get the PF VSI

 * @pf: PF instance

 *

 * returns pf->vsi[0], which by definition is the PF VSI

 */

static inline struct ice_vsi *

ice_find_vsi_by_type(struct ice_pf *pf, enum ice_vsi_type type)

static inline struct ice_vsi *ice_get_main_vsi(struct ice_pf *pf)

{

	int i;



	for (i = 0; i < pf->num_alloc_vsi; i++) {

		struct ice_vsi *vsi = pf->vsi[i];



		if (vsi && vsi->type == type)

			return vsi;

	}

	if (pf->vsi)

		return pf->vsi[0];



	return NULL;

}
@@ -447,6 +421,8 @@ ice_find_vsi_by_type(struct ice_pf *pf, enum ice_vsi_type type) 
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);

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);

void ice_update_pf_stats(struct ice_pf *pf);

int ice_up(struct ice_vsi *vsi);

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

+22 −21
Original line number Diff line number Diff line
@@ -1132,6 +1132,7 @@ const struct ice_ctx_ele ice_tlan_ctx_info[] = { 
	ICE_CTX_STORE(ice_tlan_ctx, vmvf_type,			2,	78),

	ICE_CTX_STORE(ice_tlan_ctx, src_vsi,			10,	80),

	ICE_CTX_STORE(ice_tlan_ctx, tsyn_ena,			1,	90),

	ICE_CTX_STORE(ice_tlan_ctx, internal_usage_flag,	1,	91),

	ICE_CTX_STORE(ice_tlan_ctx, alt_vlan,			1,	92),

	ICE_CTX_STORE(ice_tlan_ctx, cpuid,			8,	93),

	ICE_CTX_STORE(ice_tlan_ctx, wb_mode,			1,	101),
@@ -1150,7 +1151,7 @@ const struct ice_ctx_ele ice_tlan_ctx_info[] = { 
	ICE_CTX_STORE(ice_tlan_ctx, drop_ena,			1,	165),

	ICE_CTX_STORE(ice_tlan_ctx, cache_prof_idx,		2,	166),

	ICE_CTX_STORE(ice_tlan_ctx, pkt_shaper_prof_idx,	3,	168),

	ICE_CTX_STORE(ice_tlan_ctx, int_q_state,		110,	171),

	ICE_CTX_STORE(ice_tlan_ctx, int_q_state,		122,	171),

	{ 0 }

};
@@ -1550,29 +1551,29 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
		case ICE_AQC_CAPS_VALID_FUNCTIONS:

			caps->valid_functions = number;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: valid functions = %d\n", prefix,

				  "%s: valid_functions (bitmap) = %d\n", prefix,

				  caps->valid_functions);

			break;

		case ICE_AQC_CAPS_SRIOV:

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

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: SR-IOV = %d\n", prefix,

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

				  caps->sr_iov_1_1);

			break;

		case ICE_AQC_CAPS_VF:

			if (dev_p) {

				dev_p->num_vfs_exposed = number;

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: VFs exposed = %d\n", prefix,

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

					  dev_p->num_vfs_exposed);

			} else if (func_p) {

				func_p->num_allocd_vfs = number;

				func_p->vf_base_id = logical_id;

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: VFs allocated = %d\n", prefix,

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

					  func_p->num_allocd_vfs);

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: VF base_id = %d\n", prefix,

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

					  func_p->vf_base_id);

			}

			break;
@@ -1580,17 +1581,17 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
			if (dev_p) {

				dev_p->num_vsi_allocd_to_host = number;

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: num VSI alloc to host = %d\n",

					  "%s: num_vsi_allocd_to_host = %d\n",

					  prefix,

					  dev_p->num_vsi_allocd_to_host);

			} else if (func_p) {

				func_p->guar_num_vsi =

					ice_get_num_per_func(hw, ICE_MAX_VSI);

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: num guaranteed VSI (fw) = %d\n",

					  "%s: guar_num_vsi (fw) = %d\n",

					  prefix, number);

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: num guaranteed VSI = %d\n",

					  "%s: guar_num_vsi = %d\n",

					  prefix, func_p->guar_num_vsi);

			}

			break;
@@ -1599,56 +1600,56 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
			caps->active_tc_bitmap = logical_id;

			caps->maxtc = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: DCB = %d\n", prefix, caps->dcb);

				  "%s: dcb = %d\n", prefix, caps->dcb);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: active TC bitmap = %d\n", prefix,

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

				  caps->active_tc_bitmap);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: TC max = %d\n", prefix, caps->maxtc);

				  "%s: maxtc = %d\n", prefix, caps->maxtc);

			break;

		case ICE_AQC_CAPS_RSS:

			caps->rss_table_size = number;

			caps->rss_table_entry_width = logical_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: RSS table size = %d\n", prefix,

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

				  caps->rss_table_size);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: RSS table width = %d\n", prefix,

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

				  caps->rss_table_entry_width);

			break;

		case ICE_AQC_CAPS_RXQS:

			caps->num_rxq = number;

			caps->rxq_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: num Rx queues = %d\n", prefix,

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

				  caps->num_rxq);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: Rx first queue ID = %d\n", prefix,

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

				  caps->rxq_first_id);

			break;

		case ICE_AQC_CAPS_TXQS:

			caps->num_txq = number;

			caps->txq_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: num Tx queues = %d\n", prefix,

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

				  caps->num_txq);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: Tx first queue ID = %d\n", prefix,

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

				  caps->txq_first_id);

			break;

		case ICE_AQC_CAPS_MSIX:

			caps->num_msix_vectors = number;

			caps->msix_vector_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: MSIX vector count = %d\n", prefix,

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

				  caps->num_msix_vectors);

			ice_debug(hw, ICE_DBG_INIT,

				  "%s: MSIX first vector index = %d\n", prefix,

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

				  caps->msix_vector_first_id);

			break;

		case ICE_AQC_CAPS_MAX_MTU:

			caps->max_mtu = number;

			ice_debug(hw, ICE_DBG_INIT, "%s: max MTU = %d\n",

			ice_debug(hw, ICE_DBG_INIT, "%s: max_mtu = %d\n",

				  prefix, caps->max_mtu);

			break;

		default:

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

+35 −4
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ ice_aq_get_lldp_mib(struct ice_hw *hw, u8 bridge_type, u8 mib_type, void *buf, 
 * Enable or Disable posting of an event on ARQ when LLDP MIB

 * associated with the interface changes (0x0A01)

 */

enum ice_status

static enum ice_status

ice_aq_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_update,

			   struct ice_sq_cd *cd)

{
@@ -943,10 +943,11 @@ enum ice_status ice_get_dcb_cfg(struct ice_port_info *pi) 
/**

 * ice_init_dcb

 * @hw: pointer to the HW struct

 * @enable_mib_change: enable MIB change event

 *

 * Update DCB configuration from the Firmware

 */

enum ice_status ice_init_dcb(struct ice_hw *hw)

enum ice_status ice_init_dcb(struct ice_hw *hw, bool enable_mib_change)

{

	struct ice_port_info *pi = hw->port_info;

	enum ice_status ret = 0;
@@ -972,9 +973,39 @@ enum ice_status ice_init_dcb(struct ice_hw *hw) 
	}



	/* Configure the LLDP MIB change event */

	if (enable_mib_change) {

		ret = ice_aq_cfg_lldp_mib_change(hw, true, NULL);

		if (!ret)

			pi->is_sw_lldp = false;

	}



	return ret;

}



/**

 * ice_cfg_lldp_mib_change

 * @hw: pointer to the HW struct

 * @ena_mib: enable/disable MIB change event

 *

 * Configure (disable/enable) MIB

 */

enum ice_status ice_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_mib)

{

	struct ice_port_info *pi = hw->port_info;

	enum ice_status ret;



	if (!hw->func_caps.common_cap.dcb)

		return ICE_ERR_NOT_SUPPORTED;



	/* Get DCBX status */

	pi->dcbx_status = ice_get_dcbx_status(hw);



	if (pi->dcbx_status == ICE_DCBX_STATUS_DIS)

		return ICE_ERR_NOT_READY;



	ret = ice_aq_cfg_lldp_mib_change(hw, ena_mib, NULL);

	if (!ret)

		pi->is_sw_lldp = !ena_mib;



	return ret;

}

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

+4 −7
Original line number Diff line number Diff line
@@ -125,7 +125,7 @@ ice_aq_get_dcb_cfg(struct ice_hw *hw, u8 mib_type, u8 bridgetype, 
		   struct ice_dcbx_cfg *dcbcfg);

enum ice_status ice_get_dcb_cfg(struct ice_port_info *pi);

enum ice_status ice_set_dcb_cfg(struct ice_port_info *pi);

enum ice_status ice_init_dcb(struct ice_hw *hw);

enum ice_status ice_init_dcb(struct ice_hw *hw, bool enable_mib_change);

enum ice_status

ice_query_port_ets(struct ice_port_info *pi,

		   struct ice_aqc_port_ets_elem *buf, u16 buf_size,
@@ -139,9 +139,7 @@ ice_aq_start_lldp(struct ice_hw *hw, bool persist, struct ice_sq_cd *cd); 
enum ice_status

ice_aq_start_stop_dcbx(struct ice_hw *hw, bool start_dcbx_agent,

		       bool *dcbx_agent_status, struct ice_sq_cd *cd);

enum ice_status

ice_aq_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_update,

			   struct ice_sq_cd *cd);

enum ice_status ice_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_mib);

#else /* CONFIG_DCB */

static inline enum ice_status

ice_aq_stop_lldp(struct ice_hw __always_unused *hw,
@@ -172,9 +170,8 @@ ice_aq_start_stop_dcbx(struct ice_hw __always_unused *hw, 
}



static inline enum ice_status

ice_aq_cfg_lldp_mib_change(struct ice_hw __always_unused *hw,

			   bool __always_unused ena_update,

			   struct ice_sq_cd __always_unused *cd)

ice_cfg_lldp_mib_change(struct ice_hw __always_unused *hw,

			bool __always_unused ena_mib)

{

	return 0;

}

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

+2 −5
Original line number Diff line number Diff line
@@ -318,7 +318,7 @@ void ice_dcb_rebuild(struct ice_pf *pf) 
		goto dcb_error;

	}



	ice_init_dcb(&pf->hw);

	ice_init_dcb(&pf->hw, true);

	if (pf->hw.port_info->dcbx_status == ICE_DCBX_STATUS_DIS)

		pf->hw.port_info->is_sw_lldp = true;

	else
@@ -451,7 +451,7 @@ int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 


	port_info = hw->port_info;



	err = ice_init_dcb(hw);

	err = ice_init_dcb(hw, false);

	if (err && !port_info->is_sw_lldp) {

		dev_err(&pf->pdev->dev, "Error initializing DCB %d\n", err);

		goto dcb_init_err;
@@ -474,7 +474,6 @@ int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 
		}



		pf->dcbx_cap = DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE;

		set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags);

		return 0;

	}
@@ -483,8 +482,6 @@ int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 
	/* DCBX in FW and LLDP enabled in FW */

	pf->dcbx_cap = DCB_CAP_DCBX_LLD_MANAGED | DCB_CAP_DCBX_VER_IEEE;



	set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags);



	err = ice_dcb_init_cfg(pf, locked);

	if (err)

		goto dcb_init_err;