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

Commit 3c439b55 authored by Jack Morgenstein's avatar Jack Morgenstein Committed by Roland Dreier
Browse files

mlx4_core: Allow choosing flow steering mode 



Device managed flow steering will be enabled only under administrator
directive provided through setting the existing module parameter
log_num_mgm_entry_size to -1 (if the device actually supports flow
steering).  If flow steering isn't requested or not available, the
driver will use the value of log_num_mgm_entry_size and B0 steering.

Signed-off-by: default avatarJack Morgenstein <jackm@dev.mellanox.co.il>
Signed-off-by: default avatarOr Gerlitz <ogerlitz@mellanox.com>
Signed-off-by: default avatarRoland Dreier <roland@purestorage.com>
parent 7b8157be

drivers/net/ethernet/mellanox/mlx4/main.c

+44 −8
Original line number Diff line number Diff line
@@ -85,15 +85,15 @@ static int probe_vf; 
module_param(probe_vf, int, 0644);

MODULE_PARM_DESC(probe_vf, "number of vfs to probe by pf driver (num_vfs > 0)");



int mlx4_log_num_mgm_entry_size = 10;

int mlx4_log_num_mgm_entry_size = MLX4_DEFAULT_MGM_LOG_ENTRY_SIZE;

module_param_named(log_num_mgm_entry_size,

			mlx4_log_num_mgm_entry_size, int, 0444);

MODULE_PARM_DESC(log_num_mgm_entry_size, "log mgm size, that defines the num"

					 " of qp per mcg, for example:"

					 " 10 gives 248.range: 9<="

					 " 10 gives 248.range: 7 <="

					 " log_num_mgm_entry_size <= 12."

					 " Not in use with device managed"

					 " flow steering");

					 " To activate device managed"

					 " flow steering when available, set to -1");



static bool enable_64b_cqe_eqe;

module_param(enable_64b_cqe_eqe, bool, 0444);
@@ -1318,12 +1318,30 @@ static void mlx4_parav_master_pf_caps(struct mlx4_dev *dev) 
	}

}



static int choose_log_fs_mgm_entry_size(int qp_per_entry)

{

	int i = MLX4_MIN_MGM_LOG_ENTRY_SIZE;



	for (i = MLX4_MIN_MGM_LOG_ENTRY_SIZE; i <= MLX4_MAX_MGM_LOG_ENTRY_SIZE;

	      i++) {

		if (qp_per_entry <= 4 * ((1 << i) / 16 - 2))

			break;

	}



	return (i <= MLX4_MAX_MGM_LOG_ENTRY_SIZE) ? i : -1;

}



static void choose_steering_mode(struct mlx4_dev *dev,

				 struct mlx4_dev_cap *dev_cap)

{

	if (dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_FS_EN &&

	if (mlx4_log_num_mgm_entry_size == -1 &&

	    dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_FS_EN &&

	    (!mlx4_is_mfunc(dev) ||

	     (dev_cap->fs_max_num_qp_per_entry >= (num_vfs + 1)))) {

	     (dev_cap->fs_max_num_qp_per_entry >= (num_vfs + 1))) &&

	    choose_log_fs_mgm_entry_size(dev_cap->fs_max_num_qp_per_entry) >=

		MLX4_MIN_MGM_LOG_ENTRY_SIZE) {

		dev->oper_log_mgm_entry_size =

			choose_log_fs_mgm_entry_size(dev_cap->fs_max_num_qp_per_entry);

		dev->caps.steering_mode = MLX4_STEERING_MODE_DEVICE_MANAGED;

		dev->caps.num_qp_per_mgm = dev_cap->fs_max_num_qp_per_entry;

		dev->caps.fs_log_max_ucast_qp_range_size =
@@ -1340,10 +1358,17 @@ static void choose_steering_mode(struct mlx4_dev *dev, 
				mlx4_warn(dev, "Must have both UC_STEER and MC_STEER flags "

					  "set to use B0 steering. Falling back to A0 steering mode.\n");

		}

		dev->oper_log_mgm_entry_size =

			mlx4_log_num_mgm_entry_size > 0 ?

			mlx4_log_num_mgm_entry_size :

			MLX4_DEFAULT_MGM_LOG_ENTRY_SIZE;

		dev->caps.num_qp_per_mgm = mlx4_get_qp_per_mgm(dev);

	}

	mlx4_dbg(dev, "Steering mode is: %s\n",

		 mlx4_steering_mode_str(dev->caps.steering_mode));

	mlx4_dbg(dev, "Steering mode is: %s, oper_log_mgm_entry_size = %d, "

		 "modparam log_num_mgm_entry_size = %d\n",

		 mlx4_steering_mode_str(dev->caps.steering_mode),

		 dev->oper_log_mgm_entry_size,

		 mlx4_log_num_mgm_entry_size);

}



static int mlx4_init_hca(struct mlx4_dev *dev)
@@ -2479,6 +2504,17 @@ static int __init mlx4_verify_params(void) 
		port_type_array[0] = true;

	}



	if (mlx4_log_num_mgm_entry_size != -1 &&

	    (mlx4_log_num_mgm_entry_size < MLX4_MIN_MGM_LOG_ENTRY_SIZE ||

	     mlx4_log_num_mgm_entry_size > MLX4_MAX_MGM_LOG_ENTRY_SIZE)) {

		pr_warning("mlx4_core: mlx4_log_num_mgm_entry_size (%d) not "

			   "in legal range (-1 or %d..%d)\n",

			   mlx4_log_num_mgm_entry_size,

			   MLX4_MIN_MGM_LOG_ENTRY_SIZE,

			   MLX4_MAX_MGM_LOG_ENTRY_SIZE);

		return -1;

	}



	return 0;

}

drivers/net/ethernet/mellanox/mlx4/mcg.c

+1 −6
Original line number Diff line number Diff line
@@ -54,12 +54,7 @@ struct mlx4_mgm { 


int mlx4_get_mgm_entry_size(struct mlx4_dev *dev)

{

	if (dev->caps.steering_mode ==

	    MLX4_STEERING_MODE_DEVICE_MANAGED)

		return 1 << MLX4_FS_MGM_LOG_ENTRY_SIZE;

	else

		return min((1 << mlx4_log_num_mgm_entry_size),

			   MLX4_MAX_MGM_ENTRY_SIZE);

	return 1 << dev->oper_log_mgm_entry_size;

}



int mlx4_get_qp_per_mgm(struct mlx4_dev *dev)

drivers/net/ethernet/mellanox/mlx4/mlx4.h

+4 −2
Original line number Diff line number Diff line
@@ -94,8 +94,10 @@ enum { 
};



enum {

	MLX4_MAX_MGM_ENTRY_SIZE = 0x1000,

	MLX4_MAX_QP_PER_MGM	= 4 * (MLX4_MAX_MGM_ENTRY_SIZE / 16 - 2),

	MLX4_DEFAULT_MGM_LOG_ENTRY_SIZE = 10,

	MLX4_MIN_MGM_LOG_ENTRY_SIZE = 7,

	MLX4_MAX_MGM_LOG_ENTRY_SIZE = 12,

	MLX4_MAX_QP_PER_MGM = 4 * ((1 << MLX4_MAX_MGM_LOG_ENTRY_SIZE) / 16 - 2),

	MLX4_MTT_ENTRY_PER_SEG	= 8,

};

include/linux/mlx4/device.h

+1 −0
Original line number Diff line number Diff line
@@ -625,6 +625,7 @@ struct mlx4_dev { 
	u8			rev_id;

	char			board_id[MLX4_BOARD_ID_LEN];

	int			num_vfs;

	int			oper_log_mgm_entry_size;

	u64			regid_promisc_array[MLX4_MAX_PORTS + 1];

	u64			regid_allmulti_array[MLX4_MAX_PORTS + 1];

};