Commit 4ecc8633 authored by Brett Creeley's avatar Brett Creeley Committed by Tony Nguyen
Browse files

ice: Add support for VF rate limiting 



Implement ndo_set_vf_rate to support setting of min_tx_rate and
max_tx_rate; set the appropriate bandwidth in the scheduler for the
node representing the specified VF VSI.

Co-developed-by: default avatarTarun Singh <tarun.k.singh@intel.com>
Signed-off-by: default avatarTarun Singh <tarun.k.singh@intel.com>
Signed-off-by: default avatarBrett Creeley <brett.creeley@intel.com>
Tested-by: default avatarKonrad Jankowski <konrad0.jankowski@intel.com>
Signed-off-by: default avatarTony Nguyen <anthony.l.nguyen@intel.com>
parent 05be9463

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

+174 −0
Original line number Diff line number Diff line
@@ -3600,6 +3600,180 @@ int ice_clear_dflt_vsi(struct ice_sw *sw) 
	return 0;

}



/**

 * ice_get_link_speed_mbps - get link speed in Mbps

 * @vsi: the VSI whose link speed is being queried

 *

 * Return current VSI link speed and 0 if the speed is unknown.

 */

int ice_get_link_speed_mbps(struct ice_vsi *vsi)

{

	switch (vsi->port_info->phy.link_info.link_speed) {

	case ICE_AQ_LINK_SPEED_100GB:

		return SPEED_100000;

	case ICE_AQ_LINK_SPEED_50GB:

		return SPEED_50000;

	case ICE_AQ_LINK_SPEED_40GB:

		return SPEED_40000;

	case ICE_AQ_LINK_SPEED_25GB:

		return SPEED_25000;

	case ICE_AQ_LINK_SPEED_20GB:

		return SPEED_20000;

	case ICE_AQ_LINK_SPEED_10GB:

		return SPEED_10000;

	case ICE_AQ_LINK_SPEED_5GB:

		return SPEED_5000;

	case ICE_AQ_LINK_SPEED_2500MB:

		return SPEED_2500;

	case ICE_AQ_LINK_SPEED_1000MB:

		return SPEED_1000;

	case ICE_AQ_LINK_SPEED_100MB:

		return SPEED_100;

	case ICE_AQ_LINK_SPEED_10MB:

		return SPEED_10;

	case ICE_AQ_LINK_SPEED_UNKNOWN:

	default:

		return 0;

	}

}



/**

 * ice_get_link_speed_kbps - get link speed in Kbps

 * @vsi: the VSI whose link speed is being queried

 *

 * Return current VSI link speed and 0 if the speed is unknown.

 */

static int ice_get_link_speed_kbps(struct ice_vsi *vsi)

{

	int speed_mbps;



	speed_mbps = ice_get_link_speed_mbps(vsi);



	return speed_mbps * 1000;

}



/**

 * ice_set_min_bw_limit - setup minimum BW limit for Tx based on min_tx_rate

 * @vsi: VSI to be configured

 * @min_tx_rate: min Tx rate in Kbps to be configured as BW limit

 *

 * If the min_tx_rate is specified as 0 that means to clear the minimum BW limit

 * profile, otherwise a non-zero value will force a minimum BW limit for the VSI

 * on TC 0.

 */

int ice_set_min_bw_limit(struct ice_vsi *vsi, u64 min_tx_rate)

{

	struct ice_pf *pf = vsi->back;

	enum ice_status status;

	struct device *dev;

	int speed;



	dev = ice_pf_to_dev(pf);

	if (!vsi->port_info) {

		dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",

			vsi->idx, vsi->type);

		return -EINVAL;

	}



	speed = ice_get_link_speed_kbps(vsi);

	if (min_tx_rate > (u64)speed) {

		dev_err(dev, "invalid min Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",

			min_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,

			speed);

		return -EINVAL;

	}



	/* Configure min BW for VSI limit */

	if (min_tx_rate) {

		status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,

						   ICE_MIN_BW, min_tx_rate);

		if (status) {

			dev_err(dev, "failed to set min Tx rate(%llu Kbps) for %s %d\n",

				min_tx_rate, ice_vsi_type_str(vsi->type),

				vsi->idx);

			return -EIO;

		}



		dev_dbg(dev, "set min Tx rate(%llu Kbps) for %s\n",

			min_tx_rate, ice_vsi_type_str(vsi->type));

	} else {

		status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,

							vsi->idx, 0,

							ICE_MIN_BW);

		if (status) {

			dev_err(dev, "failed to clear min Tx rate configuration for %s %d\n",

				ice_vsi_type_str(vsi->type), vsi->idx);

			return -EIO;

		}



		dev_dbg(dev, "cleared min Tx rate configuration for %s %d\n",

			ice_vsi_type_str(vsi->type), vsi->idx);

	}



	return 0;

}



/**

 * ice_set_max_bw_limit - setup maximum BW limit for Tx based on max_tx_rate

 * @vsi: VSI to be configured

 * @max_tx_rate: max Tx rate in Kbps to be configured as BW limit

 *

 * If the max_tx_rate is specified as 0 that means to clear the maximum BW limit

 * profile, otherwise a non-zero value will force a maximum BW limit for the VSI

 * on TC 0.

 */

int ice_set_max_bw_limit(struct ice_vsi *vsi, u64 max_tx_rate)

{

	struct ice_pf *pf = vsi->back;

	enum ice_status status;

	struct device *dev;

	int speed;



	dev = ice_pf_to_dev(pf);

	if (!vsi->port_info) {

		dev_dbg(dev, "VSI %d, type %u specified doesn't have valid port_info\n",

			vsi->idx, vsi->type);

		return -EINVAL;

	}



	speed = ice_get_link_speed_kbps(vsi);

	if (max_tx_rate > (u64)speed) {

		dev_err(dev, "invalid max Tx rate %llu Kbps specified for %s %d is greater than current link speed %u Kbps\n",

			max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx,

			speed);

		return -EINVAL;

	}



	/* Configure max BW for VSI limit */

	if (max_tx_rate) {

		status = ice_cfg_vsi_bw_lmt_per_tc(vsi->port_info, vsi->idx, 0,

						   ICE_MAX_BW, max_tx_rate);

		if (status) {

			dev_err(dev, "failed setting max Tx rate(%llu Kbps) for %s %d\n",

				max_tx_rate, ice_vsi_type_str(vsi->type),

				vsi->idx);

			return -EIO;

		}



		dev_dbg(dev, "set max Tx rate(%llu Kbps) for %s %d\n",

			max_tx_rate, ice_vsi_type_str(vsi->type), vsi->idx);

	} else {

		status = ice_cfg_vsi_bw_dflt_lmt_per_tc(vsi->port_info,

							vsi->idx, 0,

							ICE_MAX_BW);

		if (status) {

			dev_err(dev, "failed clearing max Tx rate configuration for %s %d\n",

				ice_vsi_type_str(vsi->type), vsi->idx);

			return -EIO;

		}



		dev_dbg(dev, "cleared max Tx rate configuration for %s %d\n",

			ice_vsi_type_str(vsi->type), vsi->idx);

	}



	return 0;

}



/**

 * ice_set_link - turn on/off physical link

 * @vsi: VSI to modify physical link on

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

+3 −1
Original line number Diff line number Diff line
@@ -116,7 +116,9 @@ bool ice_is_vsi_dflt_vsi(struct ice_sw *sw, struct ice_vsi *vsi); 
int ice_set_dflt_vsi(struct ice_sw *sw, struct ice_vsi *vsi);



int ice_clear_dflt_vsi(struct ice_sw *sw);



int ice_set_min_bw_limit(struct ice_vsi *vsi, u64 min_tx_rate);

int ice_set_max_bw_limit(struct ice_vsi *vsi, u64 max_tx_rate);

int ice_get_link_speed_mbps(struct ice_vsi *vsi);

int

ice_vsi_update_security(struct ice_vsi *vsi, void (*fill)(struct ice_vsi_ctx *));

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

+1 −0
Original line number Diff line number Diff line
@@ -7390,6 +7390,7 @@ static const struct net_device_ops ice_netdev_ops = { 
	.ndo_set_vf_vlan = ice_set_vf_port_vlan,

	.ndo_set_vf_link_state = ice_set_vf_link_state,

	.ndo_get_vf_stats = ice_get_vf_stats,

	.ndo_set_vf_rate = ice_set_vf_bw,

	.ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid,

	.ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid,

	.ndo_setup_tc = ice_setup_tc,

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

+130 −0
Original line number Diff line number Diff line
@@ -3770,6 +3770,136 @@ ice_cfg_q_bw_dflt_lmt(struct ice_port_info *pi, u16 vsi_handle, u8 tc, 
				      ICE_SCHED_DFLT_BW);

}



/**

 * ice_sched_get_node_by_id_type - get node from ID type

 * @pi: port information structure

 * @id: identifier

 * @agg_type: type of aggregator

 * @tc: traffic class

 *

 * This function returns node identified by ID of type aggregator, and

 * based on traffic class (TC). This function needs to be called with

 * the scheduler lock held.

 */

static struct ice_sched_node *

ice_sched_get_node_by_id_type(struct ice_port_info *pi, u32 id,

			      enum ice_agg_type agg_type, u8 tc)

{

	struct ice_sched_node *node = NULL;



	switch (agg_type) {

	case ICE_AGG_TYPE_VSI: {

		struct ice_vsi_ctx *vsi_ctx;

		u16 vsi_handle = (u16)id;



		if (!ice_is_vsi_valid(pi->hw, vsi_handle))

			break;

		/* Get sched_vsi_info */

		vsi_ctx = ice_get_vsi_ctx(pi->hw, vsi_handle);

		if (!vsi_ctx)

			break;

		node = vsi_ctx->sched.vsi_node[tc];

		break;

	}



	case ICE_AGG_TYPE_AGG: {

		struct ice_sched_node *tc_node;



		tc_node = ice_sched_get_tc_node(pi, tc);

		if (tc_node)

			node = ice_sched_get_agg_node(pi, tc_node, id);

		break;

	}



	default:

		break;

	}



	return node;

}



/**

 * ice_sched_set_node_bw_lmt_per_tc - set node BW limit per TC

 * @pi: port information structure

 * @id: ID (software VSI handle or AGG ID)

 * @agg_type: aggregator type (VSI or AGG type node)

 * @tc: traffic class

 * @rl_type: min or max

 * @bw: bandwidth in Kbps

 *

 * This function sets BW limit of VSI or Aggregator scheduling node

 * based on TC information from passed in argument BW.

 */

static enum ice_status

ice_sched_set_node_bw_lmt_per_tc(struct ice_port_info *pi, u32 id,

				 enum ice_agg_type agg_type, u8 tc,

				 enum ice_rl_type rl_type, u32 bw)

{

	enum ice_status status = ICE_ERR_PARAM;

	struct ice_sched_node *node;



	if (!pi)

		return status;



	if (rl_type == ICE_UNKNOWN_BW)

		return status;



	mutex_lock(&pi->sched_lock);

	node = ice_sched_get_node_by_id_type(pi, id, agg_type, tc);

	if (!node) {

		ice_debug(pi->hw, ICE_DBG_SCHED, "Wrong id, agg type, or tc\n");

		goto exit_set_node_bw_lmt_per_tc;

	}

	if (bw == ICE_SCHED_DFLT_BW)

		status = ice_sched_set_node_bw_dflt_lmt(pi, node, rl_type);

	else

		status = ice_sched_set_node_bw_lmt(pi, node, rl_type, bw);



exit_set_node_bw_lmt_per_tc:

	mutex_unlock(&pi->sched_lock);

	return status;

}



/**

 * ice_cfg_vsi_bw_lmt_per_tc - configure VSI BW limit per TC

 * @pi: port information structure

 * @vsi_handle: software VSI handle

 * @tc: traffic class

 * @rl_type: min or max

 * @bw: bandwidth in Kbps

 *

 * This function configures BW limit of VSI scheduling node based on TC

 * information.

 */

enum ice_status

ice_cfg_vsi_bw_lmt_per_tc(struct ice_port_info *pi, u16 vsi_handle, u8 tc,

			  enum ice_rl_type rl_type, u32 bw)

{

	return ice_sched_set_node_bw_lmt_per_tc(pi, vsi_handle,

						ICE_AGG_TYPE_VSI,

						tc, rl_type, bw);

}



/**

 * ice_cfg_vsi_bw_dflt_lmt_per_tc - configure default VSI BW limit per TC

 * @pi: port information structure

 * @vsi_handle: software VSI handle

 * @tc: traffic class

 * @rl_type: min or max

 *

 * This function configures default BW limit of VSI scheduling node based on TC

 * information.

 */

enum ice_status

ice_cfg_vsi_bw_dflt_lmt_per_tc(struct ice_port_info *pi, u16 vsi_handle, u8 tc,

			       enum ice_rl_type rl_type)

{

	return ice_sched_set_node_bw_lmt_per_tc(pi, vsi_handle,

						ICE_AGG_TYPE_VSI,

						tc, rl_type,

						ICE_SCHED_DFLT_BW);

}



/**

 * ice_cfg_rl_burst_size - Set burst size value

 * @hw: pointer to the HW struct

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

+6 −0
Original line number Diff line number Diff line
@@ -103,6 +103,12 @@ ice_cfg_q_bw_lmt(struct ice_port_info *pi, u16 vsi_handle, u8 tc, 
enum ice_status

ice_cfg_q_bw_dflt_lmt(struct ice_port_info *pi, u16 vsi_handle, u8 tc,

		      u16 q_handle, enum ice_rl_type rl_type);

enum ice_status

ice_cfg_vsi_bw_lmt_per_tc(struct ice_port_info *pi, u16 vsi_handle, u8 tc,

			  enum ice_rl_type rl_type, u32 bw);

enum ice_status

ice_cfg_vsi_bw_dflt_lmt_per_tc(struct ice_port_info *pi, u16 vsi_handle, u8 tc,

			       enum ice_rl_type rl_type);

enum ice_status ice_cfg_rl_burst_size(struct ice_hw *hw, u32 bytes);

void ice_sched_replay_agg_vsi_preinit(struct ice_hw *hw);

void ice_sched_replay_agg(struct ice_hw *hw);