Commit 8e4a2adc 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-08-26

This series contains updates to ice driver only.

Usha fixes the statistics reported on 4 port NICs which were reporting
the incorrect statistics due to using the incorrect port identifier.

Victor fixes an issue when trying to traverse to the first node of a
requested layer by adding a sibling head pointer for each layer per
traffic class.

Anirudh cleans up the locking and logic for enabling and disabling
VSI's to make it more consistent.  Updates the driver to do dynamic
allocation of queue management bitmaps and arrays, rather than
statically allocating them which consumes more memory than required.
Refactor the logic in ice_ena_msix_range() for clarity and add
additional checks for when requested resources exceed what is available.

Jesse updates the debugging print statements to make it more useful when
dealing with link and PHY related issues.

Krzysztof adds a local variable to the VSI rebuild path to improve
readability.

Akeem limits the reporting of MDD events from VFs so that the kernel
log is not clogged up with MDD events which are duplicate or potentially
false positives.  Fixed a reset issue that would result in the system
getting into a state that could only be resolved by a reboot by
testing if the VF is in a disabled state during a reset.

Michal adds a check to avoid trying to access memory that has not be
allocated by checking the number of queue pairs.

Jake fixes a static analysis warning due to a cast of a u8 to unsigned
long, so just update ice_is_tc_ena() to take a unsigned long so that a
cast is not necessary.

Colin Ian King fixes a potential infinite loop where a u8 is being
compared to an int.

Maciej refactors the queue handling functions that work on queue arrays
so that the logic can be done for a single queue.

Paul adds support for VFs to enable and disable single queues.

Henry fixed the order of operations in ice_remove() which was trying to
use adminq operations that were already disabled.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 3894793e ae2bdbb4

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

+6 −6
Original line number Diff line number Diff line
@@ -73,8 +73,6 @@ extern const char ice_drv_ver[]; 
#define ICE_MBXRQ_LEN		512

#define ICE_MIN_MSIX		2

#define ICE_NO_VSI		0xffff

#define ICE_MAX_TXQS		2048

#define ICE_MAX_RXQS		2048

#define ICE_VSI_MAP_CONTIG	0

#define ICE_VSI_MAP_SCATTER	1

#define ICE_MAX_SCATTER_TXQS	16
@@ -284,8 +282,8 @@ struct ice_vsi { 
	/* queue information */

	u8 tx_mapping_mode;		 /* ICE_MAP_MODE_[CONTIG|SCATTER] */

	u8 rx_mapping_mode;		 /* ICE_MAP_MODE_[CONTIG|SCATTER] */

	u16 txq_map[ICE_MAX_TXQS];	 /* index in pf->avail_txqs */

	u16 rxq_map[ICE_MAX_RXQS];	 /* index in pf->avail_rxqs */

	u16 *txq_map;			 /* index in pf->avail_txqs */

	u16 *rxq_map;			 /* index in pf->avail_rxqs */

	u16 alloc_txq;			 /* Allocated Tx queues */

	u16 num_txq;			 /* Used Tx queues */

	u16 alloc_rxq;			 /* Allocated Rx queues */
@@ -355,9 +353,9 @@ struct ice_pf { 
	u16 num_vf_qps;			/* num queue pairs per VF */

	u16 num_vf_msix;		/* num vectors per VF */

	DECLARE_BITMAP(state, __ICE_STATE_NBITS);

	DECLARE_BITMAP(avail_txqs, ICE_MAX_TXQS);

	DECLARE_BITMAP(avail_rxqs, ICE_MAX_RXQS);

	DECLARE_BITMAP(flags, ICE_PF_FLAGS_NBITS);

	unsigned long *avail_txqs;	/* bitmap to track PF Tx queue usage */

	unsigned long *avail_rxqs;	/* bitmap to track PF Rx queue usage */

	unsigned long serv_tmr_period;

	unsigned long serv_tmr_prev;

	struct timer_list serv_tmr;
@@ -368,6 +366,8 @@ struct ice_pf { 
	u32 hw_csum_rx_error;

	u32 oicr_idx;		/* Other interrupt cause MSIX vector index */

	u32 num_avail_sw_msix;	/* remaining MSIX SW vectors left unclaimed */

	u16 max_pf_txqs;	/* Total Tx queues PF wide */

	u16 max_pf_rxqs;	/* Total Rx queues PF wide */

	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 */

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

+44 −19
Original line number Diff line number Diff line
@@ -263,21 +263,23 @@ enum ice_status 
ice_aq_get_link_info(struct ice_port_info *pi, bool ena_lse,

		     struct ice_link_status *link, struct ice_sq_cd *cd)

{

	struct ice_link_status *hw_link_info_old, *hw_link_info;

	struct ice_aqc_get_link_status_data link_data = { 0 };

	struct ice_aqc_get_link_status *resp;

	struct ice_link_status *li_old, *li;

	enum ice_media_type *hw_media_type;

	struct ice_fc_info *hw_fc_info;

	bool tx_pause, rx_pause;

	struct ice_aq_desc desc;

	enum ice_status status;

	struct ice_hw *hw;

	u16 cmd_flags;



	if (!pi)

		return ICE_ERR_PARAM;

	hw_link_info_old = &pi->phy.link_info_old;

	hw = pi->hw;

	li_old = &pi->phy.link_info_old;

	hw_media_type = &pi->phy.media_type;

	hw_link_info = &pi->phy.link_info;

	li = &pi->phy.link_info;

	hw_fc_info = &pi->fc;



	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_link_status);
@@ -286,27 +288,27 @@ ice_aq_get_link_info(struct ice_port_info *pi, bool ena_lse, 
	resp->cmd_flags = cpu_to_le16(cmd_flags);

	resp->lport_num = pi->lport;



	status = ice_aq_send_cmd(pi->hw, &desc, &link_data, sizeof(link_data),

				 cd);

	status = ice_aq_send_cmd(hw, &desc, &link_data, sizeof(link_data), cd);



	if (status)

		return status;



	/* save off old link status information */

	*hw_link_info_old = *hw_link_info;

	*li_old = *li;



	/* update current link status information */

	hw_link_info->link_speed = le16_to_cpu(link_data.link_speed);

	hw_link_info->phy_type_low = le64_to_cpu(link_data.phy_type_low);

	hw_link_info->phy_type_high = le64_to_cpu(link_data.phy_type_high);

	li->link_speed = le16_to_cpu(link_data.link_speed);

	li->phy_type_low = le64_to_cpu(link_data.phy_type_low);

	li->phy_type_high = le64_to_cpu(link_data.phy_type_high);

	*hw_media_type = ice_get_media_type(pi);

	hw_link_info->link_info = link_data.link_info;

	hw_link_info->an_info = link_data.an_info;

	hw_link_info->ext_info = link_data.ext_info;

	hw_link_info->max_frame_size = le16_to_cpu(link_data.max_frame_size);

	hw_link_info->fec_info = link_data.cfg & ICE_AQ_FEC_MASK;

	hw_link_info->topo_media_conflict = link_data.topo_media_conflict;

	hw_link_info->pacing = link_data.cfg & ICE_AQ_CFG_PACING_M;

	li->link_info = link_data.link_info;

	li->an_info = link_data.an_info;

	li->ext_info = link_data.ext_info;

	li->max_frame_size = le16_to_cpu(link_data.max_frame_size);

	li->fec_info = link_data.cfg & ICE_AQ_FEC_MASK;

	li->topo_media_conflict = link_data.topo_media_conflict;

	li->pacing = link_data.cfg & (ICE_AQ_CFG_PACING_M |

				      ICE_AQ_CFG_PACING_TYPE_M);



	/* update fc info */

	tx_pause = !!(link_data.an_info & ICE_AQ_LINK_PAUSE_TX);
@@ -320,12 +322,24 @@ ice_aq_get_link_info(struct ice_port_info *pi, bool ena_lse, 
	else

		hw_fc_info->current_mode = ICE_FC_NONE;



	hw_link_info->lse_ena =

		!!(resp->cmd_flags & cpu_to_le16(ICE_AQ_LSE_IS_ENABLED));

	li->lse_ena = !!(resp->cmd_flags & cpu_to_le16(ICE_AQ_LSE_IS_ENABLED));



	ice_debug(hw, ICE_DBG_LINK, "link_speed = 0x%x\n", li->link_speed);

	ice_debug(hw, ICE_DBG_LINK, "phy_type_low = 0x%llx\n",

		  (unsigned long long)li->phy_type_low);

	ice_debug(hw, ICE_DBG_LINK, "phy_type_high = 0x%llx\n",

		  (unsigned long long)li->phy_type_high);

	ice_debug(hw, ICE_DBG_LINK, "media_type = 0x%x\n", *hw_media_type);

	ice_debug(hw, ICE_DBG_LINK, "link_info = 0x%x\n", li->link_info);

	ice_debug(hw, ICE_DBG_LINK, "an_info = 0x%x\n", li->an_info);

	ice_debug(hw, ICE_DBG_LINK, "ext_info = 0x%x\n", li->ext_info);

	ice_debug(hw, ICE_DBG_LINK, "lse_ena = 0x%x\n", li->lse_ena);

	ice_debug(hw, ICE_DBG_LINK, "max_frame = 0x%x\n", li->max_frame_size);

	ice_debug(hw, ICE_DBG_LINK, "pacing = 0x%x\n", li->pacing);



	/* save link status information */

	if (link)

		*link = *hw_link_info;

		*link = *li;



	/* flag cleared so calling functions don't call AQ again */

	pi->phy.get_link_info = false;
@@ -2000,6 +2014,17 @@ ice_aq_set_phy_cfg(struct ice_hw *hw, u8 lport, 
	desc.params.set_phy.lport_num = lport;

	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);



	ice_debug(hw, ICE_DBG_LINK, "phy_type_low = 0x%llx\n",

		  (unsigned long long)le64_to_cpu(cfg->phy_type_low));

	ice_debug(hw, ICE_DBG_LINK, "phy_type_high = 0x%llx\n",

		  (unsigned long long)le64_to_cpu(cfg->phy_type_high));

	ice_debug(hw, ICE_DBG_LINK, "caps = 0x%x\n", cfg->caps);

	ice_debug(hw, ICE_DBG_LINK, "low_power_ctrl = 0x%x\n",

		  cfg->low_power_ctrl);

	ice_debug(hw, ICE_DBG_LINK, "eee_cap = 0x%x\n", cfg->eee_cap);

	ice_debug(hw, ICE_DBG_LINK, "eeer_value = 0x%x\n", cfg->eeer_value);

	ice_debug(hw, ICE_DBG_LINK, "link_fec_opt = 0x%x\n", cfg->link_fec_opt);



	return ice_aq_send_cmd(hw, &desc, cfg, sizeof(*cfg), cd);

}

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

+7 −6
Original line number Diff line number Diff line
@@ -500,30 +500,31 @@ void ice_update_dcb_stats(struct ice_pf *pf) 
{

	struct ice_hw_port_stats *prev_ps, *cur_ps;

	struct ice_hw *hw = &pf->hw;

	u8 pf_id = hw->pf_id;

	u8 port;

	int i;



	port = hw->port_info->lport;

	prev_ps = &pf->stats_prev;

	cur_ps = &pf->stats;



	for (i = 0; i < 8; i++) {

		ice_stat_update32(hw, GLPRT_PXOFFRXC(pf_id, i),

		ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i),

				  pf->stat_prev_loaded,

				  &prev_ps->priority_xoff_rx[i],

				  &cur_ps->priority_xoff_rx[i]);

		ice_stat_update32(hw, GLPRT_PXONRXC(pf_id, i),

		ice_stat_update32(hw, GLPRT_PXONRXC(port, i),

				  pf->stat_prev_loaded,

				  &prev_ps->priority_xon_rx[i],

				  &cur_ps->priority_xon_rx[i]);

		ice_stat_update32(hw, GLPRT_PXONTXC(pf_id, i),

		ice_stat_update32(hw, GLPRT_PXONTXC(port, i),

				  pf->stat_prev_loaded,

				  &prev_ps->priority_xon_tx[i],

				  &cur_ps->priority_xon_tx[i]);

		ice_stat_update32(hw, GLPRT_PXOFFTXC(pf_id, i),

		ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i),

				  pf->stat_prev_loaded,

				  &prev_ps->priority_xoff_tx[i],

				  &cur_ps->priority_xoff_tx[i]);

		ice_stat_update32(hw, GLPRT_RXON2OFFCNT(pf_id, i),

		ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i),

				  pf->stat_prev_loaded,

				  &prev_ps->priority_xon_2_xoff[i],

				  &cur_ps->priority_xon_2_xoff[i]);

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

+244 −154
Original line number Diff line number Diff line
@@ -191,25 +191,27 @@ static int ice_pf_rxq_wait(struct ice_pf *pf, int pf_q, bool ena) 
}



/**

 * ice_vsi_ctrl_rx_rings - Start or stop a VSI's Rx rings

 * ice_vsi_ctrl_rx_ring - Start or stop a VSI's Rx ring

 * @vsi: the VSI being configured

 * @ena: start or stop the Rx rings

 * @rxq_idx: Rx queue index

 */

static int ice_vsi_ctrl_rx_rings(struct ice_vsi *vsi, bool ena)

#ifndef CONFIG_PCI_IOV

static

#endif /* !CONFIG_PCI_IOV */

int ice_vsi_ctrl_rx_ring(struct ice_vsi *vsi, bool ena, u16 rxq_idx)

{

	int pf_q = vsi->rxq_map[rxq_idx];

	struct ice_pf *pf = vsi->back;

	struct ice_hw *hw = &pf->hw;

	int i, ret = 0;



	for (i = 0; i < vsi->num_rxq; i++) {

		int pf_q = vsi->rxq_map[i];

	int ret = 0;

	u32 rx_reg;



	rx_reg = rd32(hw, QRX_CTRL(pf_q));



	/* Skip if the queue is already in the requested state */

	if (ena == !!(rx_reg & QRX_CTRL_QENA_STAT_M))

			continue;

		return 0;



	/* turn on/off the queue */

	if (ena)
@@ -220,12 +222,27 @@ static int ice_vsi_ctrl_rx_rings(struct ice_vsi *vsi, bool ena) 


	/* wait for the change to finish */

	ret = ice_pf_rxq_wait(pf, pf_q, ena);

		if (ret) {

	if (ret)

		dev_err(&pf->pdev->dev,

			"VSI idx %d Rx ring %d %sable timeout\n",

			vsi->idx, pf_q, (ena ? "en" : "dis"));

			break;



	return ret;

}



/**

 * ice_vsi_ctrl_rx_rings - Start or stop a VSI's Rx rings

 * @vsi: the VSI being configured

 * @ena: start or stop the Rx rings

 */

static int ice_vsi_ctrl_rx_rings(struct ice_vsi *vsi, bool ena)

{

	int i, ret = 0;



	for (i = 0; i < vsi->num_rxq; i++) {

		ret = ice_vsi_ctrl_rx_ring(vsi, ena, i);

		if (ret)

			break;

	}



	return ret;
@@ -246,12 +263,24 @@ static int ice_vsi_alloc_arrays(struct ice_vsi *vsi) 
	vsi->tx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_txq,

				     sizeof(*vsi->tx_rings), GFP_KERNEL);

	if (!vsi->tx_rings)

		goto err_txrings;

		return -ENOMEM;



	vsi->rx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_rxq,

				     sizeof(*vsi->rx_rings), GFP_KERNEL);

	if (!vsi->rx_rings)

		goto err_rxrings;

		goto err_rings;



	vsi->txq_map = devm_kcalloc(&pf->pdev->dev, vsi->alloc_txq,

				    sizeof(*vsi->txq_map), GFP_KERNEL);



	if (!vsi->txq_map)

		goto err_txq_map;



	vsi->rxq_map = devm_kcalloc(&pf->pdev->dev, vsi->alloc_rxq,

				    sizeof(*vsi->rxq_map), GFP_KERNEL);

	if (!vsi->rxq_map)

		goto err_rxq_map;





	/* There is no need to allocate q_vectors for a loopback VSI. */

	if (vsi->type == ICE_VSI_LB)
@@ -266,10 +295,13 @@ static int ice_vsi_alloc_arrays(struct ice_vsi *vsi) 
	return 0;



err_vectors:

	devm_kfree(&pf->pdev->dev, vsi->rxq_map);

err_rxq_map:

	devm_kfree(&pf->pdev->dev, vsi->txq_map);

err_txq_map:

	devm_kfree(&pf->pdev->dev, vsi->rx_rings);

err_rxrings:

err_rings:

	devm_kfree(&pf->pdev->dev, vsi->tx_rings);

err_txrings:

	return -ENOMEM;

}
@@ -416,6 +448,14 @@ static void ice_vsi_free_arrays(struct ice_vsi *vsi) 
		devm_kfree(&pf->pdev->dev, vsi->rx_rings);

		vsi->rx_rings = NULL;

	}

	if (vsi->txq_map) {

		devm_kfree(&pf->pdev->dev, vsi->txq_map);

		vsi->txq_map = NULL;

	}

	if (vsi->rxq_map) {

		devm_kfree(&pf->pdev->dev, vsi->rxq_map);

		vsi->rxq_map = NULL;

	}

}



/**
@@ -647,7 +687,7 @@ static int ice_vsi_get_qs(struct ice_vsi *vsi) 
	struct ice_qs_cfg tx_qs_cfg = {

		.qs_mutex = &pf->avail_q_mutex,

		.pf_map = pf->avail_txqs,

		.pf_map_size = ICE_MAX_TXQS,

		.pf_map_size = pf->max_pf_txqs,

		.q_count = vsi->alloc_txq,

		.scatter_count = ICE_MAX_SCATTER_TXQS,

		.vsi_map = vsi->txq_map,
@@ -657,7 +697,7 @@ static int ice_vsi_get_qs(struct ice_vsi *vsi) 
	struct ice_qs_cfg rx_qs_cfg = {

		.qs_mutex = &pf->avail_q_mutex,

		.pf_map = pf->avail_rxqs,

		.pf_map_size = ICE_MAX_RXQS,

		.pf_map_size = pf->max_pf_rxqs,

		.q_count = vsi->alloc_rxq,

		.scatter_count = ICE_MAX_SCATTER_RXQS,

		.vsi_map = vsi->rxq_map,
@@ -1649,43 +1689,26 @@ setup_rings: 
}



/**

 * ice_vsi_cfg_txqs - Configure the VSI for Tx

 * @vsi: the VSI being configured

 * @rings: Tx ring array to be configured

 * @offset: offset within vsi->txq_map

 *

 * Return 0 on success and a negative value on error

 * Configure the Tx VSI for operation.

 * ice_vsi_cfg_txq - Configure single Tx queue

 * @vsi: the VSI that queue belongs to

 * @ring: Tx ring to be configured

 * @tc_q_idx: queue index within given TC

 * @qg_buf: queue group buffer

 * @tc: TC that Tx ring belongs to

 */

static int

ice_vsi_cfg_txqs(struct ice_vsi *vsi, struct ice_ring **rings, int offset)

ice_vsi_cfg_txq(struct ice_vsi *vsi, struct ice_ring *ring, u16 tc_q_idx,

		struct ice_aqc_add_tx_qgrp *qg_buf, u8 tc)

{

	struct ice_aqc_add_tx_qgrp *qg_buf;

	struct ice_tlan_ctx tlan_ctx = { 0 };

	struct ice_aqc_add_txqs_perq *txq;

	struct ice_pf *pf = vsi->back;

	u8 num_q_grps, q_idx = 0;

	u8 buf_len = sizeof(*qg_buf);

	enum ice_status status;

	u16 buf_len, i, pf_q;

	int err = 0, tc;



	buf_len = sizeof(*qg_buf);

	qg_buf = devm_kzalloc(&pf->pdev->dev, buf_len, GFP_KERNEL);

	if (!qg_buf)

		return -ENOMEM;



	qg_buf->num_txqs = 1;

	num_q_grps = 1;



	/* set up and configure the Tx queues for each enabled TC */

	ice_for_each_traffic_class(tc) {

		if (!(vsi->tc_cfg.ena_tc & BIT(tc)))

			break;



		for (i = 0; i < vsi->tc_cfg.tc_info[tc].qcount_tx; i++) {

			struct ice_tlan_ctx tlan_ctx = { 0 };

	u16 pf_q;



			pf_q = vsi->txq_map[q_idx + offset];

			ice_setup_tx_ctx(rings[q_idx], &tlan_ctx, pf_q);

	pf_q = ring->reg_idx;

	ice_setup_tx_ctx(ring, &tlan_ctx, pf_q);

	/* copy context contents into the qg_buf */

	qg_buf->txqs[0].txq_id = cpu_to_le16(pf_q);

	ice_set_ctx((u8 *)&tlan_ctx, qg_buf->txqs[0].txq_ctx,
@@ -1694,17 +1717,20 @@ ice_vsi_cfg_txqs(struct ice_vsi *vsi, struct ice_ring **rings, int offset) 
	/* init queue specific tail reg. It is referred as

	 * transmit comm scheduler queue doorbell.

	 */

			rings[q_idx]->tail =

				pf->hw.hw_addr + QTX_COMM_DBELL(pf_q);

			status = ice_ena_vsi_txq(vsi->port_info, vsi->idx, tc,

						 i, num_q_grps, qg_buf,

						 buf_len, NULL);

	ring->tail = pf->hw.hw_addr + QTX_COMM_DBELL(pf_q);



	/* Add unique software queue handle of the Tx queue per

	 * TC into the VSI Tx ring

	 */

	ring->q_handle = tc_q_idx;



	status = ice_ena_vsi_txq(vsi->port_info, vsi->idx, tc, ring->q_handle,

				 1, qg_buf, buf_len, NULL);

	if (status) {

		dev_err(&pf->pdev->dev,

			"Failed to set LAN Tx queue context, error: %d\n",

			status);

				err = -ENODEV;

				goto err_cfg_txqs;

		return -ENODEV;

	}



	/* Add Tx Queue TEID into the VSI Tx ring from the
@@ -1713,8 +1739,45 @@ ice_vsi_cfg_txqs(struct ice_vsi *vsi, struct ice_ring **rings, int offset) 
	 */

	txq = &qg_buf->txqs[0];

	if (pf_q == le16_to_cpu(txq->txq_id))

				rings[q_idx]->txq_teid =

					le32_to_cpu(txq->q_teid);

		ring->txq_teid = le32_to_cpu(txq->q_teid);



	return 0;

}



/**

 * ice_vsi_cfg_txqs - Configure the VSI for Tx

 * @vsi: the VSI being configured

 * @rings: Tx ring array to be configured

 * @offset: offset within vsi->txq_map

 *

 * Return 0 on success and a negative value on error

 * Configure the Tx VSI for operation.

 */

static int

ice_vsi_cfg_txqs(struct ice_vsi *vsi, struct ice_ring **rings, int offset)

{

	struct ice_aqc_add_tx_qgrp *qg_buf;

	struct ice_pf *pf = vsi->back;

	u16 q_idx = 0, i;

	int err = 0;

	u8 tc;



	qg_buf = devm_kzalloc(&pf->pdev->dev, sizeof(*qg_buf), GFP_KERNEL);

	if (!qg_buf)

		return -ENOMEM;



	qg_buf->num_txqs = 1;



	/* set up and configure the Tx queues for each enabled TC */

	ice_for_each_traffic_class(tc) {

		if (!(vsi->tc_cfg.ena_tc & BIT(tc)))

			break;



		for (i = 0; i < vsi->tc_cfg.tc_info[tc].qcount_tx; i++) {

			err = ice_vsi_cfg_txq(vsi, rings[q_idx], i + offset,

					      qg_buf, tc);

			if (err)

				goto err_cfg_txqs;



			q_idx++;

		}
@@ -2061,67 +2124,31 @@ void ice_trigger_sw_intr(struct ice_hw *hw, struct ice_q_vector *q_vector) 
}



/**

 * ice_vsi_stop_tx_rings - Disable Tx rings

 * ice_vsi_stop_tx_ring - Disable single Tx ring

 * @vsi: the VSI being configured

 * @rst_src: reset source

 * @rel_vmvf_num: Relative ID of VF/VM

 * @rings: Tx ring array to be stopped

 * @offset: offset within vsi->txq_map

 * @ring: Tx ring to be stopped

 * @txq_meta: Meta data of Tx ring to be stopped

 */

static int

ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,

		      u16 rel_vmvf_num, struct ice_ring **rings, int offset)

#ifndef CONFIG_PCI_IOV

static

#endif /* !CONFIG_PCI_IOV */

int

ice_vsi_stop_tx_ring(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,

		     u16 rel_vmvf_num, struct ice_ring *ring,

		     struct ice_txq_meta *txq_meta)

{

	struct ice_pf *pf = vsi->back;

	struct ice_q_vector *q_vector;

	struct ice_hw *hw = &pf->hw;

	int tc, q_idx = 0, err = 0;

	u16 *q_ids, *q_handles, i;

	enum ice_status status;

	u32 *q_teids, val;



	if (vsi->num_txq > ICE_LAN_TXQ_MAX_QDIS)

		return -EINVAL;



	q_teids = devm_kcalloc(&pf->pdev->dev, vsi->num_txq, sizeof(*q_teids),

			       GFP_KERNEL);

	if (!q_teids)

		return -ENOMEM;



	q_ids = devm_kcalloc(&pf->pdev->dev, vsi->num_txq, sizeof(*q_ids),

			     GFP_KERNEL);

	if (!q_ids) {

		err = -ENOMEM;

		goto err_alloc_q_ids;

	}



	q_handles = devm_kcalloc(&pf->pdev->dev, vsi->num_txq,

				 sizeof(*q_handles), GFP_KERNEL);

	if (!q_handles) {

		err = -ENOMEM;

		goto err_alloc_q_handles;

	}



	/* set up the Tx queue list to be disabled for each enabled TC */

	ice_for_each_traffic_class(tc) {

		if (!(vsi->tc_cfg.ena_tc & BIT(tc)))

			break;



		for (i = 0; i < vsi->tc_cfg.tc_info[tc].qcount_tx; i++) {

			struct ice_q_vector *q_vector;



			if (!rings || !rings[q_idx]) {

				err = -EINVAL;

				goto err_out;

			}



			q_ids[i] = vsi->txq_map[q_idx + offset];

			q_teids[i] = rings[q_idx]->txq_teid;

			q_handles[i] = i;

	u32 val;



	/* clear cause_ena bit for disabled queues */

			val = rd32(hw, QINT_TQCTL(rings[i]->reg_idx));

	val = rd32(hw, QINT_TQCTL(ring->reg_idx));

	val &= ~QINT_TQCTL_CAUSE_ENA_M;

			wr32(hw, QINT_TQCTL(rings[i]->reg_idx), val);

	wr32(hw, QINT_TQCTL(ring->reg_idx), val);



	/* software is expected to wait for 100 ns */

	ndelay(100);
@@ -2129,45 +2156,105 @@ ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src, 
	/* trigger a software interrupt for the vector

	 * associated to the queue to schedule NAPI handler

	 */

			q_vector = rings[i]->q_vector;

	q_vector = ring->q_vector;

	if (q_vector)

		ice_trigger_sw_intr(hw, q_vector);



			q_idx++;

		}

		status = ice_dis_vsi_txq(vsi->port_info, vsi->idx, tc,

					 vsi->num_txq, q_handles, q_ids,

					 q_teids, rst_src, rel_vmvf_num, NULL);

	status = ice_dis_vsi_txq(vsi->port_info, txq_meta->vsi_idx,

				 txq_meta->tc, 1, &txq_meta->q_handle,

				 &txq_meta->q_id, &txq_meta->q_teid, rst_src,

				 rel_vmvf_num, NULL);



		/* if the disable queue command was exercised during an active

		 * reset flow, ICE_ERR_RESET_ONGOING is returned. This is not

		 * an error as the reset operation disables queues at the

		 * hardware level anyway.

	/* if the disable queue command was exercised during an

	 * active reset flow, ICE_ERR_RESET_ONGOING is returned.

	 * This is not an error as the reset operation disables

	 * queues at the hardware level anyway.

	 */

	if (status == ICE_ERR_RESET_ONGOING) {

			dev_dbg(&pf->pdev->dev,

		dev_dbg(&vsi->back->pdev->dev,

			"Reset in progress. LAN Tx queues already disabled\n");

	} else if (status == ICE_ERR_DOES_NOT_EXIST) {

			dev_dbg(&pf->pdev->dev,

				"LAN Tx queues does not exist, nothing to disabled\n");

		dev_dbg(&vsi->back->pdev->dev,

			"LAN Tx queues do not exist, nothing to disable\n");

	} else if (status) {

			dev_err(&pf->pdev->dev,

				"Failed to disable LAN Tx queues, error: %d\n",

				status);

			err = -ENODEV;

		dev_err(&vsi->back->pdev->dev,

			"Failed to disable LAN Tx queues, error: %d\n", status);

		return -ENODEV;

	}



	return 0;

}



err_out:

	devm_kfree(&pf->pdev->dev, q_handles);

/**

 * ice_fill_txq_meta - Prepare the Tx queue's meta data

 * @vsi: VSI that ring belongs to

 * @ring: ring that txq_meta will be based on

 * @txq_meta: a helper struct that wraps Tx queue's information

 *

 * Set up a helper struct that will contain all the necessary fields that

 * are needed for stopping Tx queue

 */

#ifndef CONFIG_PCI_IOV

static

#endif /* !CONFIG_PCI_IOV */

void

ice_fill_txq_meta(struct ice_vsi *vsi, struct ice_ring *ring,

		  struct ice_txq_meta *txq_meta)

{

	u8 tc = 0;



#ifdef CONFIG_DCB

	tc = ring->dcb_tc;

#endif /* CONFIG_DCB */

	txq_meta->q_id = ring->reg_idx;

	txq_meta->q_teid = ring->txq_teid;

	txq_meta->q_handle = ring->q_handle;

	txq_meta->vsi_idx = vsi->idx;

	txq_meta->tc = tc;

}



err_alloc_q_handles:

	devm_kfree(&pf->pdev->dev, q_ids);

/**

 * ice_vsi_stop_tx_rings - Disable Tx rings

 * @vsi: the VSI being configured

 * @rst_src: reset source

 * @rel_vmvf_num: Relative ID of VF/VM

 * @rings: Tx ring array to be stopped

 */

static int

ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,

		      u16 rel_vmvf_num, struct ice_ring **rings)

{

	u16 i, q_idx = 0;

	int status;

	u8 tc;



err_alloc_q_ids:

	devm_kfree(&pf->pdev->dev, q_teids);

	if (vsi->num_txq > ICE_LAN_TXQ_MAX_QDIS)

		return -EINVAL;



	return err;

	/* set up the Tx queue list to be disabled for each enabled TC */

	ice_for_each_traffic_class(tc) {

		if (!(vsi->tc_cfg.ena_tc & BIT(tc)))

			break;



		for (i = 0; i < vsi->tc_cfg.tc_info[tc].qcount_tx; i++) {

			struct ice_txq_meta txq_meta = { };



			if (!rings || !rings[q_idx])

				return -EINVAL;



			ice_fill_txq_meta(vsi, rings[q_idx], &txq_meta);

			status = ice_vsi_stop_tx_ring(vsi, rst_src,

						      rel_vmvf_num,

						      rings[q_idx], &txq_meta);



			if (status)

				return status;



			q_idx++;

		}

	}



	return 0;

}



/**
@@ -2180,8 +2267,7 @@ int 
ice_vsi_stop_lan_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,

			  u16 rel_vmvf_num)

{

	return ice_vsi_stop_tx_rings(vsi, rst_src, rel_vmvf_num, vsi->tx_rings,

				     0);

	return ice_vsi_stop_tx_rings(vsi, rst_src, rel_vmvf_num, vsi->tx_rings);

}



/**
@@ -2955,6 +3041,7 @@ int ice_vsi_rebuild(struct ice_vsi *vsi) 
		vsi->base_vector = 0;

	}



	ice_vsi_put_qs(vsi);

	ice_vsi_clear_rings(vsi);

	ice_vsi_free_arrays(vsi);

	ice_dev_onetime_setup(&pf->hw);
@@ -2962,6 +3049,12 @@ int ice_vsi_rebuild(struct ice_vsi *vsi) 
		ice_vsi_set_num_qs(vsi, vf->vf_id);

	else

		ice_vsi_set_num_qs(vsi, ICE_INVAL_VFID);



	ret = ice_vsi_alloc_arrays(vsi);

	if (ret < 0)

		goto err_vsi;



	ice_vsi_get_qs(vsi);

	ice_vsi_set_tc_cfg(vsi);



	/* Initialize VSI struct elements and create VSI in FW */
@@ -2969,9 +3062,6 @@ int ice_vsi_rebuild(struct ice_vsi *vsi) 
	if (ret < 0)

		goto err_vsi;



	ret = ice_vsi_alloc_arrays(vsi);

	if (ret < 0)

		goto err_vsi;



	switch (vsi->type) {

	case ICE_VSI_PF:

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

+26 −2
Original line number Diff line number Diff line
@@ -6,7 +6,21 @@ 


#include "ice.h"



int ice_add_mac_to_list(struct ice_vsi *vsi, struct list_head *add_list,

struct ice_txq_meta {

	/* Tx-scheduler element identifier */

	u32 q_teid;

	/* Entry in VSI's txq_map bitmap */

	u16 q_id;

	/* Relative index of Tx queue within TC */

	u16 q_handle;

	/* VSI index that Tx queue belongs to */

	u16 vsi_idx;

	/* TC number that Tx queue belongs to */

	u8 tc;

};



int

ice_add_mac_to_list(struct ice_vsi *vsi, struct list_head *add_list,

		    const u8 *macaddr);



void ice_free_fltr_list(struct device *dev, struct list_head *h);
@@ -25,6 +39,16 @@ ice_cfg_txq_interrupt(struct ice_vsi *vsi, u16 txq, u16 msix_idx, u16 itr_idx); 


void

ice_cfg_rxq_interrupt(struct ice_vsi *vsi, u16 rxq, u16 msix_idx, u16 itr_idx);



int

ice_vsi_stop_tx_ring(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,

		     u16 rel_vmvf_num, struct ice_ring *ring,

		     struct ice_txq_meta *txq_meta);



void ice_fill_txq_meta(struct ice_vsi *vsi, struct ice_ring *ring,

		       struct ice_txq_meta *txq_meta);



int ice_vsi_ctrl_rx_ring(struct ice_vsi *vsi, bool ena, u16 rxq_idx);

#endif /* CONFIG_PCI_IOV */



int ice_vsi_add_vlan(struct ice_vsi *vsi, u16 vid);

CRA Git | Maintained and supported by SUSTech CRA and CCSE