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

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

Merge branch 'mellanox-next' 

Amir Vadai says:

====================
Mellanox ethernet driver update Oct-27-2014

This patchset introduces some small bug fixes, support in get/set of
vlan offload and get/set/capabilities of the link.

First 7 patches by Saeed, add support in setting/getting link speed and getting
cable capabilities.
Next 2 patches also by Saeed, enable the user to turn rx/tx vlan offloading on
and off.
Jenni fixed a bug in error flow during device initalization.
Ido and Jack fixed some code duplication and errors discovered by static checker.
last patch by me is a fix to make ethtool report the actual rings used by
indirection QP.

Patches were applied and tested against commit 61ed53de ("Merge tag 'ntb-3.18'
of git://github.com/jonmason/ntb"

)
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 941d8ebc d5ec899a

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

+9 −0
Original line number Diff line number Diff line
@@ -1338,6 +1338,15 @@ static struct mlx4_cmd_info cmd_info[] = { 
		.verify = NULL,

		.wrapper = mlx4_QUERY_IF_STAT_wrapper

	},

	{

		.opcode = MLX4_CMD_ACCESS_REG,

		.has_inbox = true,

		.has_outbox = true,

		.out_is_imm = false,

		.encode_slave_id = false,

		.verify = NULL,

		.wrapper = NULL,

	},

	/* Native multicast commands are not available for guests */

	{

		.opcode = MLX4_CMD_QP_ATTACH,

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

+0 −46
Original line number Diff line number Diff line
@@ -35,52 +35,6 @@ 


#include "mlx4_en.h"



int mlx4_en_timestamp_config(struct net_device *dev, int tx_type, int rx_filter)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_en_dev *mdev = priv->mdev;

	int port_up = 0;

	int err = 0;



	if (priv->hwtstamp_config.tx_type == tx_type &&

	    priv->hwtstamp_config.rx_filter == rx_filter)

		return 0;



	mutex_lock(&mdev->state_lock);

	if (priv->port_up) {

		port_up = 1;

		mlx4_en_stop_port(dev, 1);

	}



	mlx4_en_free_resources(priv);



	en_warn(priv, "Changing Time Stamp configuration\n");



	priv->hwtstamp_config.tx_type = tx_type;

	priv->hwtstamp_config.rx_filter = rx_filter;



	if (rx_filter != HWTSTAMP_FILTER_NONE)

		dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;

	else

		dev->features |= NETIF_F_HW_VLAN_CTAG_RX;



	err = mlx4_en_alloc_resources(priv);

	if (err) {

		en_err(priv, "Failed reallocating port resources\n");

		goto out;

	}

	if (port_up) {

		err = mlx4_en_start_port(dev);

		if (err)

			en_err(priv, "Failed starting port\n");

	}



out:

	mutex_unlock(&mdev->state_lock);

	netdev_features_change(dev);

	return err;

}



/* mlx4_en_read_clock - read raw cycle counter (to be used by time counter)

 */

static cycle_t mlx4_en_read_clock(const struct cyclecounter *tc)

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

+486 −17
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <linux/ethtool.h>

#include <linux/netdevice.h>

#include <linux/mlx4/driver.h>

#include <linux/mlx4/device.h>

#include <linux/in.h>

#include <net/ip.h>
@@ -374,7 +375,302 @@ static void mlx4_en_get_strings(struct net_device *dev, 
	}

}



static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)

static u32 mlx4_en_autoneg_get(struct net_device *dev)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_en_dev *mdev = priv->mdev;

	u32 autoneg = AUTONEG_DISABLE;



	if ((mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP) &&

	    (priv->port_state.flags & MLX4_EN_PORT_ANE))

		autoneg = AUTONEG_ENABLE;



	return autoneg;

}



static u32 ptys_get_supported_port(struct mlx4_ptys_reg *ptys_reg)

{

	u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);



	if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_T)

			 | MLX4_PROT_MASK(MLX4_1000BASE_T)

			 | MLX4_PROT_MASK(MLX4_100BASE_TX))) {

			return SUPPORTED_TP;

	}



	if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_CR)

			 | MLX4_PROT_MASK(MLX4_10GBASE_SR)

			 | MLX4_PROT_MASK(MLX4_56GBASE_SR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_CR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_SR4)

			 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII))) {

			return SUPPORTED_FIBRE;

	}



	if (eth_proto & (MLX4_PROT_MASK(MLX4_56GBASE_KR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_KR4)

			 | MLX4_PROT_MASK(MLX4_20GBASE_KR2)

			 | MLX4_PROT_MASK(MLX4_10GBASE_KR)

			 | MLX4_PROT_MASK(MLX4_10GBASE_KX4)

			 | MLX4_PROT_MASK(MLX4_1000BASE_KX))) {

			return SUPPORTED_Backplane;

	}

	return 0;

}



static u32 ptys_get_active_port(struct mlx4_ptys_reg *ptys_reg)

{

	u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_oper);



	if (!eth_proto) /* link down */

		eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);



	if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_T)

			 | MLX4_PROT_MASK(MLX4_1000BASE_T)

			 | MLX4_PROT_MASK(MLX4_100BASE_TX))) {

			return PORT_TP;

	}



	if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_SR)

			 | MLX4_PROT_MASK(MLX4_56GBASE_SR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_SR4)

			 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII))) {

			return PORT_FIBRE;

	}



	if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_CR)

			 | MLX4_PROT_MASK(MLX4_56GBASE_CR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_CR4))) {

			return PORT_DA;

	}



	if (eth_proto & (MLX4_PROT_MASK(MLX4_56GBASE_KR4)

			 | MLX4_PROT_MASK(MLX4_40GBASE_KR4)

			 | MLX4_PROT_MASK(MLX4_20GBASE_KR2)

			 | MLX4_PROT_MASK(MLX4_10GBASE_KR)

			 | MLX4_PROT_MASK(MLX4_10GBASE_KX4)

			 | MLX4_PROT_MASK(MLX4_1000BASE_KX))) {

			return PORT_NONE;

	}

	return PORT_OTHER;

}



#define MLX4_LINK_MODES_SZ \

	(FIELD_SIZEOF(struct mlx4_ptys_reg, eth_proto_cap) * 8)



enum ethtool_report {

	SUPPORTED = 0,

	ADVERTISED = 1,

	SPEED = 2

};



/* Translates mlx4 link mode to equivalent ethtool Link modes/speed */

static u32 ptys2ethtool_map[MLX4_LINK_MODES_SZ][3] = {

	[MLX4_100BASE_TX] = {

		SUPPORTED_100baseT_Full,

		ADVERTISED_100baseT_Full,

		SPEED_100

		},



	[MLX4_1000BASE_T] = {

		SUPPORTED_1000baseT_Full,

		ADVERTISED_1000baseT_Full,

		SPEED_1000

		},

	[MLX4_1000BASE_CX_SGMII] = {

		SUPPORTED_1000baseKX_Full,

		ADVERTISED_1000baseKX_Full,

		SPEED_1000

		},

	[MLX4_1000BASE_KX] = {

		SUPPORTED_1000baseKX_Full,

		ADVERTISED_1000baseKX_Full,

		SPEED_1000

		},



	[MLX4_10GBASE_T] = {

		SUPPORTED_10000baseT_Full,

		ADVERTISED_10000baseT_Full,

		SPEED_10000

		},

	[MLX4_10GBASE_CX4] = {

		SUPPORTED_10000baseKX4_Full,

		ADVERTISED_10000baseKX4_Full,

		SPEED_10000

		},

	[MLX4_10GBASE_KX4] = {

		SUPPORTED_10000baseKX4_Full,

		ADVERTISED_10000baseKX4_Full,

		SPEED_10000

		},

	[MLX4_10GBASE_KR] = {

		SUPPORTED_10000baseKR_Full,

		ADVERTISED_10000baseKR_Full,

		SPEED_10000

		},

	[MLX4_10GBASE_CR] = {

		SUPPORTED_10000baseKR_Full,

		ADVERTISED_10000baseKR_Full,

		SPEED_10000

		},

	[MLX4_10GBASE_SR] = {

		SUPPORTED_10000baseKR_Full,

		ADVERTISED_10000baseKR_Full,

		SPEED_10000

		},



	[MLX4_20GBASE_KR2] = {

		SUPPORTED_20000baseMLD2_Full | SUPPORTED_20000baseKR2_Full,

		ADVERTISED_20000baseMLD2_Full | ADVERTISED_20000baseKR2_Full,

		SPEED_20000

		},



	[MLX4_40GBASE_CR4] = {

		SUPPORTED_40000baseCR4_Full,

		ADVERTISED_40000baseCR4_Full,

		SPEED_40000

		},

	[MLX4_40GBASE_KR4] = {

		SUPPORTED_40000baseKR4_Full,

		ADVERTISED_40000baseKR4_Full,

		SPEED_40000

		},

	[MLX4_40GBASE_SR4] = {

		SUPPORTED_40000baseSR4_Full,

		ADVERTISED_40000baseSR4_Full,

		SPEED_40000

		},



	[MLX4_56GBASE_KR4] = {

		SUPPORTED_56000baseKR4_Full,

		ADVERTISED_56000baseKR4_Full,

		SPEED_56000

		},

	[MLX4_56GBASE_CR4] = {

		SUPPORTED_56000baseCR4_Full,

		ADVERTISED_56000baseCR4_Full,

		SPEED_56000

		},

	[MLX4_56GBASE_SR4] = {

		SUPPORTED_56000baseSR4_Full,

		ADVERTISED_56000baseSR4_Full,

		SPEED_56000

		},

};



static u32 ptys2ethtool_link_modes(u32 eth_proto, enum ethtool_report report)

{

	int i;

	u32 link_modes = 0;



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

		if (eth_proto & MLX4_PROT_MASK(i))

			link_modes |= ptys2ethtool_map[i][report];

	}

	return link_modes;

}



static u32 ethtool2ptys_link_modes(u32 link_modes, enum ethtool_report report)

{

	int i;

	u32 ptys_modes = 0;



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

		if (ptys2ethtool_map[i][report] & link_modes)

			ptys_modes |= 1 << i;

	}

	return ptys_modes;

}



/* Convert actual speed (SPEED_XXX) to ptys link modes */

static u32 speed2ptys_link_modes(u32 speed)

{

	int i;

	u32 ptys_modes = 0;



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

		if (ptys2ethtool_map[i][SPEED] == speed)

			ptys_modes |= 1 << i;

	}

	return ptys_modes;

}



static int ethtool_get_ptys_settings(struct net_device *dev,

				     struct ethtool_cmd *cmd)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_ptys_reg ptys_reg;

	u32 eth_proto;

	int ret;



	memset(&ptys_reg, 0, sizeof(ptys_reg));

	ptys_reg.local_port = priv->port;

	ptys_reg.proto_mask = MLX4_PTYS_EN;

	ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev,

				   MLX4_ACCESS_REG_QUERY, &ptys_reg);

	if (ret) {

		en_warn(priv, "Failed to run mlx4_ACCESS_PTYS_REG status(%x)",

			ret);

		return ret;

	}

	en_dbg(DRV, priv, "ptys_reg.proto_mask       %x\n",

	       ptys_reg.proto_mask);

	en_dbg(DRV, priv, "ptys_reg.eth_proto_cap    %x\n",

	       be32_to_cpu(ptys_reg.eth_proto_cap));

	en_dbg(DRV, priv, "ptys_reg.eth_proto_admin  %x\n",

	       be32_to_cpu(ptys_reg.eth_proto_admin));

	en_dbg(DRV, priv, "ptys_reg.eth_proto_oper   %x\n",

	       be32_to_cpu(ptys_reg.eth_proto_oper));

	en_dbg(DRV, priv, "ptys_reg.eth_proto_lp_adv %x\n",

	       be32_to_cpu(ptys_reg.eth_proto_lp_adv));



	cmd->supported = 0;

	cmd->advertising = 0;



	cmd->supported |= ptys_get_supported_port(&ptys_reg);



	eth_proto = be32_to_cpu(ptys_reg.eth_proto_cap);

	cmd->supported |= ptys2ethtool_link_modes(eth_proto, SUPPORTED);



	eth_proto = be32_to_cpu(ptys_reg.eth_proto_admin);

	cmd->advertising |= ptys2ethtool_link_modes(eth_proto, ADVERTISED);



	cmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;

	cmd->advertising |= (priv->prof->tx_pause) ? ADVERTISED_Pause : 0;



	cmd->advertising |= (priv->prof->tx_pause ^ priv->prof->rx_pause) ?

		ADVERTISED_Asym_Pause : 0;



	cmd->port = ptys_get_active_port(&ptys_reg);

	cmd->transceiver = (SUPPORTED_TP & cmd->supported) ?

		XCVR_EXTERNAL : XCVR_INTERNAL;



	if (mlx4_en_autoneg_get(dev)) {

		cmd->supported |= SUPPORTED_Autoneg;

		cmd->advertising |= ADVERTISED_Autoneg;

	}



	cmd->autoneg = (priv->port_state.flags & MLX4_EN_PORT_ANC) ?

		AUTONEG_ENABLE : AUTONEG_DISABLE;



	eth_proto = be32_to_cpu(ptys_reg.eth_proto_lp_adv);

	cmd->lp_advertising = ptys2ethtool_link_modes(eth_proto, ADVERTISED);



	cmd->lp_advertising |= (priv->port_state.flags & MLX4_EN_PORT_ANC) ?

			ADVERTISED_Autoneg : 0;



	cmd->phy_address = 0;

	cmd->mdio_support = 0;

	cmd->maxtxpkt = 0;

	cmd->maxrxpkt = 0;

	cmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

	cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;



	return ret;

}



static void ethtool_get_default_settings(struct net_device *dev,

					 struct ethtool_cmd *cmd)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	int trans_type;
@@ -382,18 +678,7 @@ static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
	cmd->autoneg = AUTONEG_DISABLE;

	cmd->supported = SUPPORTED_10000baseT_Full;

	cmd->advertising = ADVERTISED_10000baseT_Full;



	if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))

		return -ENOMEM;



	trans_type = priv->port_state.transciver;

	if (netif_carrier_ok(dev)) {

		ethtool_cmd_speed_set(cmd, priv->port_state.link_speed);

		cmd->duplex = DUPLEX_FULL;

	} else {

		ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);

		cmd->duplex = DUPLEX_UNKNOWN;

	}

	trans_type = priv->port_state.transceiver;



	if (trans_type > 0 && trans_type <= 0xC) {

		cmd->port = PORT_FIBRE;
@@ -409,17 +694,118 @@ static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
		cmd->port = -1;

		cmd->transceiver = -1;

	}

}



static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	int ret = -EINVAL;



	if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))

		return -ENOMEM;



	en_dbg(DRV, priv, "query port state.flags ANC(%x) ANE(%x)\n",

	       priv->port_state.flags & MLX4_EN_PORT_ANC,

	       priv->port_state.flags & MLX4_EN_PORT_ANE);



	if (priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL)

		ret = ethtool_get_ptys_settings(dev, cmd);

	if (ret) /* ETH PROT CRTL is not supported or PTYS CMD failed */

		ethtool_get_default_settings(dev, cmd);



	if (netif_carrier_ok(dev)) {

		ethtool_cmd_speed_set(cmd, priv->port_state.link_speed);

		cmd->duplex = DUPLEX_FULL;

	} else {

		ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);

		cmd->duplex = DUPLEX_UNKNOWN;

	}

	return 0;

}



/* Calculate PTYS admin according ethtool speed (SPEED_XXX) */

static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, u32 speed,

				   __be32 proto_cap)

{

	__be32 proto_admin = 0;



	if (!speed) { /* Speed = 0 ==> Reset Link modes */

		proto_admin = proto_cap;

		en_info(priv, "Speed was set to 0, Reset advertised Link Modes to default (%x)\n",

			be32_to_cpu(proto_cap));

	} else {

		u32 ptys_link_modes = speed2ptys_link_modes(speed);



		proto_admin = cpu_to_be32(ptys_link_modes) & proto_cap;

		en_info(priv, "Setting Speed to %d\n", speed);

	}

	return proto_admin;

}



static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)

{

	if ((cmd->autoneg == AUTONEG_ENABLE) ||

	    (ethtool_cmd_speed(cmd) != SPEED_10000) ||

	    (cmd->duplex != DUPLEX_FULL))

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_ptys_reg ptys_reg;

	__be32 proto_admin;

	int ret;



	u32 ptys_adv = ethtool2ptys_link_modes(cmd->advertising, ADVERTISED);

	int speed = ethtool_cmd_speed(cmd);



	en_dbg(DRV, priv, "Set Speed=%d adv=0x%x autoneg=%d duplex=%d\n",

	       speed, cmd->advertising, cmd->autoneg, cmd->duplex);



	if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL) ||

	    (cmd->autoneg == AUTONEG_ENABLE) || (cmd->duplex == DUPLEX_HALF))

		return -EINVAL;



	/* Nothing to change */

	memset(&ptys_reg, 0, sizeof(ptys_reg));

	ptys_reg.local_port = priv->port;

	ptys_reg.proto_mask = MLX4_PTYS_EN;

	ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev,

				   MLX4_ACCESS_REG_QUERY, &ptys_reg);

	if (ret) {

		en_warn(priv, "Failed to QUERY mlx4_ACCESS_PTYS_REG status(%x)\n",

			ret);

		return 0;

	}



	proto_admin = cpu_to_be32(ptys_adv);

	if (speed >= 0 && speed != priv->port_state.link_speed)

		/* If speed was set then speed decides :-) */

		proto_admin = speed_set_ptys_admin(priv, speed,

						   ptys_reg.eth_proto_cap);



	proto_admin &= ptys_reg.eth_proto_cap;



	if (proto_admin == ptys_reg.eth_proto_admin)

		return 0; /* Nothing to change */



	if (!proto_admin) {

		en_warn(priv, "Not supported link mode(s) requested, check supported link modes.\n");

		return -EINVAL; /* nothing to change due to bad input */

	}



	en_dbg(DRV, priv, "mlx4_ACCESS_PTYS_REG SET: ptys_reg.eth_proto_admin = 0x%x\n",

	       be32_to_cpu(proto_admin));



	ptys_reg.eth_proto_admin = proto_admin;

	ret = mlx4_ACCESS_PTYS_REG(priv->mdev->dev, MLX4_ACCESS_REG_WRITE,

				   &ptys_reg);

	if (ret) {

		en_warn(priv, "Failed to write mlx4_ACCESS_PTYS_REG eth_proto_admin(0x%x) status(0x%x)",

			be32_to_cpu(ptys_reg.eth_proto_admin), ret);

		return ret;

	}



	en_warn(priv, "Port link mode changed, restarting port...\n");

	mutex_lock(&priv->mdev->state_lock);

	if (priv->port_up) {

		mlx4_en_stop_port(dev, 1);

		if (mlx4_en_start_port(dev))

			en_err(priv, "Failed restarting port %d\n", priv->port);

	}

	mutex_unlock(&priv->mdev->state_lock);

	return 0;

}
@@ -596,6 +982,7 @@ static int mlx4_en_get_rxfh(struct net_device *dev, u32 *ring_index, u8 *key) 
	int err = 0;



	rss_rings = priv->prof->rss_rings ?: priv->rx_ring_num;

	rss_rings = 1 << ilog2(rss_rings);



	while (n--) {

		ring_index[n] = rss_map->qps[n % rss_rings].qpn -
@@ -1309,6 +1696,86 @@ static int mlx4_en_set_tunable(struct net_device *dev, 
	return ret;

}



static int mlx4_en_get_module_info(struct net_device *dev,

				   struct ethtool_modinfo *modinfo)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_en_dev *mdev = priv->mdev;

	int ret;

	u8 data[4];



	/* Read first 2 bytes to get Module & REV ID */

	ret = mlx4_get_module_info(mdev->dev, priv->port,

				   0/*offset*/, 2/*size*/, data);

	if (ret < 2)

		return -EIO;



	switch (data[0] /* identifier */) {

	case MLX4_MODULE_ID_QSFP:

		modinfo->type = ETH_MODULE_SFF_8436;

		modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;

		break;

	case MLX4_MODULE_ID_QSFP_PLUS:

		if (data[1] >= 0x3) { /* revision id */

			modinfo->type = ETH_MODULE_SFF_8636;

			modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;

		} else {

			modinfo->type = ETH_MODULE_SFF_8436;

			modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;

		}

		break;

	case MLX4_MODULE_ID_QSFP28:

		modinfo->type = ETH_MODULE_SFF_8636;

		modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;

		break;

	case MLX4_MODULE_ID_SFP:

		modinfo->type = ETH_MODULE_SFF_8472;

		modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;

		break;

	default:

		return -ENOSYS;

	}



	return 0;

}



static int mlx4_en_get_module_eeprom(struct net_device *dev,

				     struct ethtool_eeprom *ee,

				     u8 *data)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_en_dev *mdev = priv->mdev;

	int offset = ee->offset;

	int i = 0, ret;



	if (ee->len == 0)

		return -EINVAL;



	memset(data, 0, ee->len);



	while (i < ee->len) {

		en_dbg(DRV, priv,

		       "mlx4_get_module_info i(%d) offset(%d) len(%d)\n",

		       i, offset, ee->len - i);



		ret = mlx4_get_module_info(mdev->dev, priv->port,

					   offset, ee->len - i, data + i);



		if (!ret) /* Done reading */

			return 0;



		if (ret < 0) {

			en_err(priv,

			       "mlx4_get_module_info i(%d) offset(%d) bytes_to_read(%d) - FAILED (0x%x)\n",

			       i, offset, ee->len - i, ret);

			return 0;

		}



		i += ret;

		offset += ret;

	}

	return 0;

}



const struct ethtool_ops mlx4_en_ethtool_ops = {

	.get_drvinfo = mlx4_en_get_drvinfo,
@@ -1341,6 +1808,8 @@ const struct ethtool_ops mlx4_en_ethtool_ops = { 
	.get_priv_flags = mlx4_en_get_priv_flags,

	.get_tunable		= mlx4_en_get_tunable,

	.set_tunable		= mlx4_en_set_tunable,

	.get_module_info = mlx4_en_get_module_info,

	.get_module_eeprom = mlx4_en_get_module_eeprom

};

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

+3 −9
Original line number Diff line number Diff line
@@ -221,15 +221,12 @@ static void *mlx4_en_add(struct mlx4_dev *dev) 
{

	struct mlx4_en_dev *mdev;

	int i;

	int err;



	printk_once(KERN_INFO "%s", mlx4_en_version);



	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);

	if (!mdev) {

		err = -ENOMEM;

	if (!mdev)

		goto err_free_res;

	}



	if (mlx4_pd_alloc(dev, &mdev->priv_pdn))

		goto err_free_dev;
@@ -264,8 +261,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev) 
	}



	/* Build device profile according to supplied module parameters */

	err = mlx4_en_get_profile(mdev);

	if (err) {

	if (mlx4_en_get_profile(mdev)) {

		mlx4_err(mdev, "Bad module parameters, aborting\n");

		goto err_mr;

	}
@@ -286,10 +282,8 @@ static void *mlx4_en_add(struct mlx4_dev *dev) 
	 * Note: we cannot use the shared workqueue because of deadlocks caused

	 *       by the rtnl lock */

	mdev->workqueue = create_singlethread_workqueue("mlx4_en");

	if (!mdev->workqueue) {

		err = -ENOMEM;

	if (!mdev->workqueue)

		goto err_mr;

	}



	/* At this stage all non-port specific tasks are complete:

	 * mark the card state as up */

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

+106 −20
Original line number Diff line number Diff line
@@ -575,7 +575,7 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv) 
	struct mlx4_mac_entry *entry;

	int index = 0;

	int err = 0;

	u64 reg_id;

	u64 reg_id = 0;

	int *qpn = &priv->base_qpn;

	u64 mac = mlx4_mac_to_u64(priv->dev->dev_addr);
@@ -1843,8 +1843,7 @@ void mlx4_en_stop_port(struct net_device *dev, int detach) 
		}

		local_bh_enable();



		while (test_bit(NAPI_STATE_SCHED, &cq->napi.state))

			msleep(1);

		napi_synchronize(&cq->napi);

		mlx4_en_deactivate_rx_ring(priv, priv->rx_ring[i]);

		mlx4_en_deactivate_cq(priv, cq);
@@ -2157,7 +2156,7 @@ static int mlx4_en_hwtstamp_set(struct net_device *dev, struct ifreq *ifr) 
		return -ERANGE;

	}



	if (mlx4_en_timestamp_config(dev, config.tx_type, config.rx_filter)) {

	if (mlx4_en_reset_config(dev, config, dev->features)) {

		config.tx_type = HWTSTAMP_TX_OFF;

		config.rx_filter = HWTSTAMP_FILTER_NONE;

	}
@@ -2190,6 +2189,16 @@ static int mlx4_en_set_features(struct net_device *netdev, 
		netdev_features_t features)

{

	struct mlx4_en_priv *priv = netdev_priv(netdev);

	int ret = 0;



	if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_RX)) {

		en_info(priv, "Turn %s RX vlan strip offload\n",

			(features & NETIF_F_HW_VLAN_CTAG_RX) ? "ON" : "OFF");

		ret = mlx4_en_reset_config(netdev, priv->hwtstamp_config,

					   features);

		if (ret)

			return ret;

	}



	if (features & NETIF_F_LOOPBACK)

		priv->ctrl_flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK);
@@ -2431,6 +2440,21 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 


	priv = netdev_priv(dev);

	memset(priv, 0, sizeof(struct mlx4_en_priv));

	spin_lock_init(&priv->stats_lock);

	INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);

	INIT_WORK(&priv->watchdog_task, mlx4_en_restart);

	INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);

	INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);

	INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);

#ifdef CONFIG_MLX4_EN_VXLAN

	INIT_WORK(&priv->vxlan_add_task, mlx4_en_add_vxlan_offloads);

	INIT_WORK(&priv->vxlan_del_task, mlx4_en_del_vxlan_offloads);

#endif

#ifdef CONFIG_RFS_ACCEL

	INIT_LIST_HEAD(&priv->filters);

	spin_lock_init(&priv->filters_lock);

#endif



	priv->dev = dev;

	priv->mdev = mdev;

	priv->ddev = &mdev->pdev->dev;
@@ -2462,16 +2486,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 
	priv->cqe_size = mdev->dev->caps.cqe_size;

	priv->mac_index = -1;

	priv->msg_enable = MLX4_EN_MSG_LEVEL;

	spin_lock_init(&priv->stats_lock);

	INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);

	INIT_WORK(&priv->watchdog_task, mlx4_en_restart);

	INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);

	INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);

	INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);

#ifdef CONFIG_MLX4_EN_VXLAN

	INIT_WORK(&priv->vxlan_add_task, mlx4_en_add_vxlan_offloads);

	INIT_WORK(&priv->vxlan_del_task, mlx4_en_del_vxlan_offloads);

#endif

#ifdef CONFIG_MLX4_EN_DCB

	if (!mlx4_is_slave(priv->mdev->dev)) {

		if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_SET_ETH_SCHED) {
@@ -2514,11 +2528,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 
	if (err)

		goto out;



#ifdef CONFIG_RFS_ACCEL

	INIT_LIST_HEAD(&priv->filters);

	spin_lock_init(&priv->filters_lock);

#endif



	/* Initialize time stamping config */

	priv->hwtstamp_config.flags = 0;

	priv->hwtstamp_config.tx_type = HWTSTAMP_TX_OFF;
@@ -2559,7 +2568,8 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 
	dev->features = dev->hw_features | NETIF_F_HIGHDMA |

			NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX |

			NETIF_F_HW_VLAN_CTAG_FILTER;

	dev->hw_features |= NETIF_F_LOOPBACK;

	dev->hw_features |= NETIF_F_LOOPBACK |

			NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;



	if (mdev->dev->caps.steering_mode ==

	    MLX4_STEERING_MODE_DEVICE_MANAGED)
@@ -2633,3 +2643,79 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 
	return err;

}



int mlx4_en_reset_config(struct net_device *dev,

			 struct hwtstamp_config ts_config,

			 netdev_features_t features)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	struct mlx4_en_dev *mdev = priv->mdev;

	int port_up = 0;

	int err = 0;



	if (priv->hwtstamp_config.tx_type == ts_config.tx_type &&

	    priv->hwtstamp_config.rx_filter == ts_config.rx_filter &&

	    !DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX))

		return 0; /* Nothing to change */



	if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX) &&

	    (features & NETIF_F_HW_VLAN_CTAG_RX) &&

	    (priv->hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE)) {

		en_warn(priv, "Can't turn ON rx vlan offload while time-stamping rx filter is ON\n");

		return -EINVAL;

	}



	mutex_lock(&mdev->state_lock);

	if (priv->port_up) {

		port_up = 1;

		mlx4_en_stop_port(dev, 1);

	}



	mlx4_en_free_resources(priv);



	en_warn(priv, "Changing device configuration rx filter(%x) rx vlan(%x)\n",

		ts_config.rx_filter, !!(features & NETIF_F_HW_VLAN_CTAG_RX));



	priv->hwtstamp_config.tx_type = ts_config.tx_type;

	priv->hwtstamp_config.rx_filter = ts_config.rx_filter;



	if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX)) {

		if (features & NETIF_F_HW_VLAN_CTAG_RX)

			dev->features |= NETIF_F_HW_VLAN_CTAG_RX;

		else

			dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;

	} else if (ts_config.rx_filter == HWTSTAMP_FILTER_NONE) {

		/* RX time-stamping is OFF, update the RX vlan offload

		 * to the latest wanted state

		 */

		if (dev->wanted_features & NETIF_F_HW_VLAN_CTAG_RX)

			dev->features |= NETIF_F_HW_VLAN_CTAG_RX;

		else

			dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;

	}



	/* RX vlan offload and RX time-stamping can't co-exist !

	 * Regardless of the caller's choice,

	 * Turn Off RX vlan offload in case of time-stamping is ON

	 */

	if (ts_config.rx_filter != HWTSTAMP_FILTER_NONE) {

		if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)

			en_warn(priv, "Turning off RX vlan offload since RX time-stamping is ON\n");

		dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;

	}



	err = mlx4_en_alloc_resources(priv);

	if (err) {

		en_err(priv, "Failed reallocating port resources\n");

		goto out;

	}

	if (port_up) {

		err = mlx4_en_start_port(dev);

		if (err)

			en_err(priv, "Failed starting port\n");

	}



out:

	mutex_unlock(&mdev->state_lock);

	netdev_features_change(dev);

	return err;

}