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

Commit e82a08b0 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'mlx5e-next' 



Amir Vadai says:

====================
net/mlx5e: Driver update 29-Jul-2015

This patchset contain bug fixes and code cleaning patches to the ConnectX-4
Ethernet driver.

Patchset was applied and tested over commit 8c1a91f1 ("Merge branch
'mlx4-802.1ad-accel'")
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents dcc38c03 98e81b0a

drivers/net/ethernet/mellanox/mlx5/core/en.h

+0 −3
Original line number Diff line number Diff line
@@ -389,7 +389,6 @@ struct mlx5e_flow_table { 


struct mlx5e_priv {

	/* priv data path fields - start */

	int                        num_tc;

	int                        default_vlan_prio;

	struct mlx5e_sq            **txq_to_sq_map;

	/* priv data path fields - end */
@@ -497,8 +496,6 @@ void mlx5e_del_all_vlan_rules(struct mlx5e_priv *priv); 


int mlx5e_open_locked(struct net_device *netdev);

int mlx5e_close_locked(struct net_device *netdev);

int mlx5e_update_priv_params(struct mlx5e_priv *priv,

			     struct mlx5e_params *new_params);



static inline void mlx5e_tx_notify_hw(struct mlx5e_sq *sq,

				      struct mlx5e_tx_wqe *wqe, int bf_sz)

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c

+42 −21
Original line number Diff line number Diff line
@@ -173,7 +173,7 @@ static int mlx5e_get_sset_count(struct net_device *dev, int sset) 
	case ETH_SS_STATS:

		return NUM_VPORT_COUNTERS +

		       priv->params.num_channels * NUM_RQ_STATS +

		       priv->params.num_channels * priv->num_tc *

		       priv->params.num_channels * priv->params.num_tc *

						   NUM_SQ_STATS;

	/* fallthrough */

	default:
@@ -207,7 +207,7 @@ static void mlx5e_get_strings(struct net_device *dev, 
					"rx%d_%s", i, rq_stats_strings[j]);



		for (i = 0; i < priv->params.num_channels; i++)

			for (tc = 0; tc < priv->num_tc; tc++)

			for (tc = 0; tc < priv->params.num_tc; tc++)

				for (j = 0; j < NUM_SQ_STATS; j++)

					sprintf(data +

						(idx++) * ETH_GSTRING_LEN,
@@ -242,7 +242,7 @@ static void mlx5e_get_ethtool_stats(struct net_device *dev, 
				       ((u64 *)&priv->channel[i]->rq.stats)[j];



	for (i = 0; i < priv->params.num_channels; i++)

		for (tc = 0; tc < priv->num_tc; tc++)

		for (tc = 0; tc < priv->params.num_tc; tc++)

			for (j = 0; j < NUM_SQ_STATS; j++)

				data[idx++] = !test_bit(MLX5E_STATE_OPENED,

							&priv->state) ? 0 :
@@ -264,7 +264,7 @@ static int mlx5e_set_ringparam(struct net_device *dev, 
			       struct ethtool_ringparam *param)

{

	struct mlx5e_priv *priv = netdev_priv(dev);

	struct mlx5e_params new_params;

	bool was_opened;

	u16 min_rx_wqes;

	u8 log_rq_size;

	u8 log_sq_size;
@@ -316,11 +316,18 @@ static int mlx5e_set_ringparam(struct net_device *dev, 
		return 0;



	mutex_lock(&priv->state_lock);

	new_params = priv->params;

	new_params.log_rq_size = log_rq_size;

	new_params.log_sq_size = log_sq_size;

	new_params.min_rx_wqes = min_rx_wqes;

	err = mlx5e_update_priv_params(priv, &new_params);



	was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

	if (was_opened)

		mlx5e_close_locked(dev);



	priv->params.log_rq_size = log_rq_size;

	priv->params.log_sq_size = log_sq_size;

	priv->params.min_rx_wqes = min_rx_wqes;



	if (was_opened)

		err = mlx5e_open_locked(dev);



	mutex_unlock(&priv->state_lock);



	return err;
@@ -342,7 +349,7 @@ static int mlx5e_set_channels(struct net_device *dev, 
	struct mlx5e_priv *priv = netdev_priv(dev);

	int ncv = priv->mdev->priv.eq_table.num_comp_vectors;

	unsigned int count = ch->combined_count;

	struct mlx5e_params new_params;

	bool was_opened;

	int err = 0;



	if (!count) {
@@ -365,9 +372,16 @@ static int mlx5e_set_channels(struct net_device *dev, 
		return 0;



	mutex_lock(&priv->state_lock);

	new_params = priv->params;

	new_params.num_channels = count;

	err = mlx5e_update_priv_params(priv, &new_params);



	was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

	if (was_opened)

		mlx5e_close_locked(dev);



	priv->params.num_channels = count;



	if (was_opened)

		err = mlx5e_open_locked(dev);



	mutex_unlock(&priv->state_lock);



	return err;
@@ -673,10 +687,10 @@ static int mlx5e_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, 
	return 0;

}



static int mlx5e_set_rxfh(struct net_device *netdev, const u32 *indir,

static int mlx5e_set_rxfh(struct net_device *dev, const u32 *indir,

			  const u8 *key, const u8 hfunc)

{

	struct mlx5e_priv *priv = netdev_priv(netdev);

	struct mlx5e_priv *priv = netdev_priv(dev);

	int err = 0;



	if (hfunc == ETH_RSS_HASH_NO_CHANGE)
@@ -690,8 +704,8 @@ static int mlx5e_set_rxfh(struct net_device *netdev, const u32 *indir, 


	priv->params.rss_hfunc = hfunc;

	if (test_bit(MLX5E_STATE_OPENED, &priv->state)) {

		mlx5e_close_locked(priv->netdev);

		err = mlx5e_open_locked(priv->netdev);

		mlx5e_close_locked(dev);

		err = mlx5e_open_locked(dev);

	}



	mutex_unlock(&priv->state_lock);
@@ -724,7 +738,7 @@ static int mlx5e_set_tunable(struct net_device *dev, 
{

	struct mlx5e_priv *priv = netdev_priv(dev);

	struct mlx5_core_dev *mdev = priv->mdev;

	struct mlx5e_params new_params;

	bool was_opened;

	u32 val;

	int err = 0;
@@ -737,9 +751,16 @@ static int mlx5e_set_tunable(struct net_device *dev, 
		}



		mutex_lock(&priv->state_lock);

		new_params = priv->params;

		new_params.tx_max_inline = val;

		err = mlx5e_update_priv_params(priv, &new_params);



		was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

		if (was_opened)

			mlx5e_close_locked(dev);



		priv->params.tx_max_inline = val;



		if (was_opened)

			err = mlx5e_open_locked(dev);



		mutex_unlock(&priv->state_lock);

		break;

	default:

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

+43 −76
Original line number Diff line number Diff line
@@ -117,7 +117,7 @@ void mlx5e_update_stats(struct mlx5e_priv *priv) 
		s->rx_csum_none	+= rq_stats->csum_none;

		s->rx_wqe_err   += rq_stats->wqe_err;



		for (j = 0; j < priv->num_tc; j++) {

		for (j = 0; j < priv->params.num_tc; j++) {

			sq_stats = &priv->channel[i]->sq[j].stats;



			s->tso_packets		+= sq_stats->tso_packets;
@@ -345,11 +345,11 @@ static int mlx5e_enable_rq(struct mlx5e_rq *rq, struct mlx5e_rq_param *param) 


	memcpy(rqc, param->rqc, sizeof(param->rqc));



	MLX5_SET(rqc,  rqc, cqn,		c->rq.cq.mcq.cqn);

	MLX5_SET(rqc,  rqc, cqn,		rq->cq.mcq.cqn);

	MLX5_SET(rqc,  rqc, state,		MLX5_RQC_STATE_RST);

	MLX5_SET(rqc,  rqc, flush_in_error_en,	1);

	MLX5_SET(wq,   wq,  log_wq_pg_sz,	rq->wq_ctrl.buf.page_shift -

						PAGE_SHIFT);

						MLX5_ADAPTER_PAGE_SHIFT);

	MLX5_SET64(wq, wq,  dbr_addr,		rq->wq_ctrl.db.dma);



	mlx5_fill_page_array(&rq->wq_ctrl.buf,
@@ -577,7 +577,6 @@ static int mlx5e_enable_sq(struct mlx5e_sq *sq, struct mlx5e_sq_param *param) 


	memcpy(sqc, param->sqc, sizeof(param->sqc));



	MLX5_SET(sqc,  sqc, user_index,		sq->tc);

	MLX5_SET(sqc,  sqc, tis_num_0,		priv->tisn[sq->tc]);

	MLX5_SET(sqc,  sqc, cqn,		c->sq[sq->tc].cq.mcq.cqn);

	MLX5_SET(sqc,  sqc, state,		MLX5_SQC_STATE_RST);
@@ -587,7 +586,7 @@ static int mlx5e_enable_sq(struct mlx5e_sq *sq, struct mlx5e_sq_param *param) 
	MLX5_SET(wq,   wq, wq_type,       MLX5_WQ_TYPE_CYCLIC);

	MLX5_SET(wq,   wq, uar_page,      sq->uar.index);

	MLX5_SET(wq,   wq, log_wq_pg_sz,  sq->wq_ctrl.buf.page_shift -

					  PAGE_SHIFT);

					  MLX5_ADAPTER_PAGE_SHIFT);

	MLX5_SET64(wq, wq, dbr_addr,      sq->wq_ctrl.db.dma);



	mlx5_fill_page_array(&sq->wq_ctrl.buf,
@@ -782,7 +781,7 @@ static int mlx5e_enable_cq(struct mlx5e_cq *cq, struct mlx5e_cq_param *param) 
	MLX5_SET(cqc,   cqc, c_eqn,         eqn);

	MLX5_SET(cqc,   cqc, uar_page,      mcq->uar->index);

	MLX5_SET(cqc,   cqc, log_page_size, cq->wq_ctrl.buf.page_shift -

					    PAGE_SHIFT);

					    MLX5_ADAPTER_PAGE_SHIFT);

	MLX5_SET64(cqc, cqc, dbr_addr,      cq->wq_ctrl.db.dma);



	err = mlx5_core_create_cq(mdev, mcq, in, inlen);
@@ -938,7 +937,7 @@ static int mlx5e_open_channel(struct mlx5e_priv *priv, int ix, 
	c->pdev     = &priv->mdev->pdev->dev;

	c->netdev   = priv->netdev;

	c->mkey_be  = cpu_to_be32(priv->mr.key);

	c->num_tc   = priv->num_tc;

	c->num_tc   = priv->params.num_tc;



	mlx5e_build_tc_to_txq_map(c, priv->params.num_channels);
@@ -1069,27 +1068,28 @@ static void mlx5e_build_channel_param(struct mlx5e_priv *priv, 
static int mlx5e_open_channels(struct mlx5e_priv *priv)

{

	struct mlx5e_channel_param cparam;

	int nch = priv->params.num_channels;

	int err = -ENOMEM;

	int i;

	int j;



	priv->channel = kcalloc(priv->params.num_channels,

				sizeof(struct mlx5e_channel *), GFP_KERNEL);

	priv->channel = kcalloc(nch, sizeof(struct mlx5e_channel *),

				GFP_KERNEL);



	priv->txq_to_sq_map = kcalloc(priv->params.num_channels * priv->num_tc,

	priv->txq_to_sq_map = kcalloc(nch * priv->params.num_tc,

				      sizeof(struct mlx5e_sq *), GFP_KERNEL);



	if (!priv->channel || !priv->txq_to_sq_map)

		goto err_free_txq_to_sq_map;



	mlx5e_build_channel_param(priv, &cparam);

	for (i = 0; i < priv->params.num_channels; i++) {

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

		err = mlx5e_open_channel(priv, i, &cparam, &priv->channel[i]);

		if (err)

			goto err_close_channels;

	}



	for (j = 0; j < priv->params.num_channels; j++) {

	for (j = 0; j < nch; j++) {

		err = mlx5e_wait_for_min_rx_wqes(&priv->channel[j]->rq);

		if (err)

			goto err_close_channels;
@@ -1140,11 +1140,10 @@ static void mlx5e_close_tis(struct mlx5e_priv *priv, int tc) 


static int mlx5e_open_tises(struct mlx5e_priv *priv)

{

	int num_tc = priv->num_tc;

	int err;

	int tc;



	for (tc = 0; tc < num_tc; tc++) {

	for (tc = 0; tc < priv->params.num_tc; tc++) {

		err = mlx5e_open_tis(priv, tc);

		if (err)

			goto err_close_tises;
@@ -1161,10 +1160,9 @@ static int mlx5e_open_tises(struct mlx5e_priv *priv) 


static void mlx5e_close_tises(struct mlx5e_priv *priv)

{

	int num_tc = priv->num_tc;

	int tc;



	for (tc = 0; tc < num_tc; tc++)

	for (tc = 0; tc < priv->params.num_tc; tc++)

		mlx5e_close_tis(priv, tc);

}
@@ -1190,7 +1188,6 @@ static int mlx5e_open_rqt(struct mlx5e_priv *priv) 
{

	struct mlx5_core_dev *mdev = priv->mdev;

	u32 *in;

	u32 out[MLX5_ST_SZ_DW(create_rqt_out)];

	void *rqtc;

	int inlen;

	int err;
@@ -1218,12 +1215,7 @@ static int mlx5e_open_rqt(struct mlx5e_priv *priv) 
		MLX5_SET(rqtc, rqtc, rq_num[i], priv->channel[ix]->rq.rqn);

	}



	MLX5_SET(create_rqt_in, in, opcode, MLX5_CMD_OP_CREATE_RQT);



	memset(out, 0, sizeof(out));

	err = mlx5_cmd_exec_check_status(mdev, in, inlen, out, sizeof(out));

	if (!err)

		priv->rqtn = MLX5_GET(create_rqt_out, out, rqtn);

	err = mlx5_core_create_rqt(mdev, in, inlen, &priv->rqtn);



	kvfree(in);
@@ -1232,16 +1224,7 @@ static int mlx5e_open_rqt(struct mlx5e_priv *priv) 


static void mlx5e_close_rqt(struct mlx5e_priv *priv)

{

	u32 in[MLX5_ST_SZ_DW(destroy_rqt_in)];

	u32 out[MLX5_ST_SZ_DW(destroy_rqt_out)];



	memset(in, 0, sizeof(in));



	MLX5_SET(destroy_rqt_in, in, opcode, MLX5_CMD_OP_DESTROY_RQT);

	MLX5_SET(destroy_rqt_in, in, rqtn, priv->rqtn);



	mlx5_cmd_exec_check_status(priv->mdev, in, sizeof(in), out,

				   sizeof(out));

	mlx5_core_destroy_rqt(priv->mdev, priv->rqtn);

}



static void mlx5e_build_tir_ctx(struct mlx5e_priv *priv, u32 *tirc, int tt)
@@ -1587,26 +1570,6 @@ static int mlx5e_close(struct net_device *netdev) 
	return err;

}



int mlx5e_update_priv_params(struct mlx5e_priv *priv,

			     struct mlx5e_params *new_params)

{

	int err = 0;

	int was_opened;



	WARN_ON(!mutex_is_locked(&priv->state_lock));



	was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

	if (was_opened)

		mlx5e_close_locked(priv->netdev);



	priv->params = *new_params;



	if (was_opened)

		err = mlx5e_open_locked(priv->netdev);



	return err;

}



static struct rtnl_link_stats64 *

mlx5e_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)

{
@@ -1656,20 +1619,22 @@ static int mlx5e_set_features(struct net_device *netdev, 
			      netdev_features_t features)

{

	struct mlx5e_priv *priv = netdev_priv(netdev);

	int err = 0;

	netdev_features_t changes = features ^ netdev->features;

	struct mlx5e_params new_params;

	bool update_params = false;



	mutex_lock(&priv->state_lock);

	new_params = priv->params;



	if (changes & NETIF_F_LRO) {

		new_params.lro_en = !!(features & NETIF_F_LRO);

		update_params = true;

	}

		bool was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);



	if (update_params)

		mlx5e_update_priv_params(priv, &new_params);

		if (was_opened)

			mlx5e_close_locked(priv->netdev);



		priv->params.lro_en = !!(features & NETIF_F_LRO);



		if (was_opened)

			err = mlx5e_open_locked(priv->netdev);

	}



	if (changes & NETIF_F_HW_VLAN_CTAG_FILTER) {

		if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
@@ -1687,8 +1652,9 @@ static int mlx5e_change_mtu(struct net_device *netdev, int new_mtu) 
{

	struct mlx5e_priv *priv = netdev_priv(netdev);

	struct mlx5_core_dev *mdev = priv->mdev;

	bool was_opened;

	int max_mtu;

	int err;

	int err = 0;



	mlx5_query_port_max_mtu(mdev, &max_mtu, 1);
@@ -1700,8 +1666,16 @@ static int mlx5e_change_mtu(struct net_device *netdev, int new_mtu) 
	}



	mutex_lock(&priv->state_lock);



	was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

	if (was_opened)

		mlx5e_close_locked(netdev);



	netdev->mtu = new_mtu;

	err = mlx5e_update_priv_params(priv, &priv->params);



	if (was_opened)

		err = mlx5e_open_locked(netdev);



	mutex_unlock(&priv->state_lock);



	return err;
@@ -1786,7 +1760,6 @@ static void mlx5e_build_netdev_priv(struct mlx5_core_dev *mdev, 
	priv->mdev                         = mdev;

	priv->netdev                       = netdev;

	priv->params.num_channels          = num_comp_vectors;

	priv->num_tc                       = priv->params.num_tc;

	priv->default_vlan_prio            = priv->params.default_vlan_prio;



	spin_lock_init(&priv->async_events_spinlock);
@@ -1811,9 +1784,8 @@ static void mlx5e_build_netdev(struct net_device *netdev) 


	SET_NETDEV_DEV(netdev, &mdev->pdev->dev);



	if (priv->num_tc > 1) {

	if (priv->params.num_tc > 1)

		mlx5e_netdev_ops.ndo_select_queue = mlx5e_select_queue;

	}



	netdev->netdev_ops        = &mlx5e_netdev_ops;

	netdev->watchdog_timeo    = 15 * HZ;
@@ -1897,36 +1869,31 @@ static void *mlx5e_create_netdev(struct mlx5_core_dev *mdev) 


	err = mlx5_alloc_map_uar(mdev, &priv->cq_uar);

	if (err) {

		netdev_err(netdev, "%s: mlx5_alloc_map_uar failed, %d\n",

			   __func__, err);

		mlx5_core_err(mdev, "alloc_map uar failed, %d\n", err);

		goto err_free_netdev;

	}



	err = mlx5_core_alloc_pd(mdev, &priv->pdn);

	if (err) {

		netdev_err(netdev, "%s: mlx5_core_alloc_pd failed, %d\n",

			   __func__, err);

		mlx5_core_err(mdev, "alloc pd failed, %d\n", err);

		goto err_unmap_free_uar;

	}



	err = mlx5_alloc_transport_domain(mdev, &priv->tdn);

	if (err) {

		netdev_err(netdev, "%s: mlx5_alloc_transport_domain failed, %d\n",

			   __func__, err);

		mlx5_core_err(mdev, "alloc td failed, %d\n", err);

		goto err_dealloc_pd;

	}



	err = mlx5e_create_mkey(priv, priv->pdn, &priv->mr);

	if (err) {

		netdev_err(netdev, "%s: mlx5e_create_mkey failed, %d\n",

			   __func__, err);

		mlx5_core_err(mdev, "create mkey failed, %d\n", err);

		goto err_dealloc_transport_domain;

	}



	err = register_netdev(netdev);

	if (err) {

		netdev_err(netdev, "%s: register_netdev failed, %d\n",

			   __func__, err);

		mlx5_core_err(mdev, "register_netdev failed, %d\n", err);

		goto err_destroy_mkey;

	}

drivers/net/ethernet/mellanox/mlx5/core/mlx5_core.h

+6 −1
Original line number Diff line number Diff line
@@ -73,7 +73,12 @@ static inline int mlx5_cmd_exec_check_status(struct mlx5_core_dev *dev, u32 *in, 
					     int in_size, u32 *out,

					     int out_size)

{

	mlx5_cmd_exec(dev, in, in_size, out, out_size);

	int err;



	err = mlx5_cmd_exec(dev, in, in_size, out, out_size);

	if (err)

		return err;



	return mlx5_cmd_status_to_err((struct mlx5_outbox_hdr *)out);

}

drivers/net/ethernet/mellanox/mlx5/core/transobj.c

+29 −0
Original line number Diff line number Diff line
@@ -358,3 +358,32 @@ int mlx5_core_arm_xsrq(struct mlx5_core_dev *dev, u32 xsrqn, u16 lwm) 
	return  mlx5_cmd_exec_check_status(dev, in, sizeof(in), out,

					   sizeof(out));

}



int mlx5_core_create_rqt(struct mlx5_core_dev *dev, u32 *in, int inlen,

			 u32 *rqtn)

{

	u32 out[MLX5_ST_SZ_DW(create_rqt_out)];

	int err;



	MLX5_SET(create_rqt_in, in, opcode, MLX5_CMD_OP_CREATE_RQT);



	memset(out, 0, sizeof(out));

	err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));

	if (!err)

		*rqtn = MLX5_GET(create_rqt_out, out, rqtn);



	return err;

}



void mlx5_core_destroy_rqt(struct mlx5_core_dev *dev, u32 rqtn)

{

	u32 in[MLX5_ST_SZ_DW(destroy_rqt_in)];

	u32 out[MLX5_ST_SZ_DW(destroy_rqt_out)];



	memset(in, 0, sizeof(in));



	MLX5_SET(destroy_rqt_in, in, opcode, MLX5_CMD_OP_DESTROY_RQT);

	MLX5_SET(destroy_rqt_in, in, rqtn, rqtn);



	mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));

}