path: root/sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c

/*-
 * Copyright (c) 2015 Mellanox Technologies. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#include "en.h"
#include <net/sff8472.h>

void
mlx5e_create_stats(struct sysctl_ctx_list *ctx,
    struct sysctl_oid_list *parent, const char *buffer,
    const char **desc, unsigned num, u64 * arg)
{
	struct sysctl_oid *node;
	unsigned x;

	sysctl_ctx_init(ctx);

	node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO,
	    buffer, CTLFLAG_RD, NULL, "Statistics");
	if (node == NULL)
		return;
	for (x = 0; x != num; x++) {
		SYSCTL_ADD_UQUAD(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
		    desc[2 * x], CTLFLAG_RD, arg + x, desc[2 * x + 1]);
	}
}

static int
mlx5e_ethtool_handler(SYSCTL_HANDLER_ARGS)
{
	struct mlx5e_priv *priv = arg1;
	uint64_t value;
	int was_opened;
	int error;

	PRIV_LOCK(priv);
	value = priv->params_ethtool.arg[arg2];
	error = sysctl_handle_64(oidp, &value, 0, req);
	if (error || req->newptr == NULL ||
	    value == priv->params_ethtool.arg[arg2])
		goto done;

	/* assign new value */
	priv->params_ethtool.arg[arg2] = value;

	/* check if device is gone */
	if (priv->gone) {
		error = ENXIO;
		goto done;
	}

	if (&priv->params_ethtool.arg[arg2] == &priv->params_ethtool.rx_pauseframe_control ||
	    &priv->params_ethtool.arg[arg2] == &priv->params_ethtool.tx_pauseframe_control) {
		/* range check parameters */
		priv->params_ethtool.rx_pauseframe_control =
		    priv->params_ethtool.rx_pauseframe_control ? 1 : 0;
		priv->params_ethtool.tx_pauseframe_control =
		    priv->params_ethtool.tx_pauseframe_control ? 1 : 0;

		/* update firmware */
		error = -mlx5_set_port_pause(priv->mdev, 1,
		    priv->params_ethtool.rx_pauseframe_control,
		    priv->params_ethtool.tx_pauseframe_control);
		goto done;
	}

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

	/* import TX queue size */
	if (priv->params_ethtool.tx_queue_size <
	    (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)) {
		priv->params_ethtool.tx_queue_size =
		    (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE);
	} else if (priv->params_ethtool.tx_queue_size >
	    priv->params_ethtool.tx_queue_size_max) {
		priv->params_ethtool.tx_queue_size =
		    priv->params_ethtool.tx_queue_size_max;
	}
	priv->params.log_sq_size =
	    order_base_2(priv->params_ethtool.tx_queue_size);

	/* import RX queue size */
	if (priv->params_ethtool.rx_queue_size <
	    (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE)) {
		priv->params_ethtool.rx_queue_size =
		    (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE);
	} else if (priv->params_ethtool.rx_queue_size >
	    priv->params_ethtool.rx_queue_size_max) {
		priv->params_ethtool.rx_queue_size =
		    priv->params_ethtool.rx_queue_size_max;
	}
	priv->params.log_rq_size =
	    order_base_2(priv->params_ethtool.rx_queue_size);

	priv->params.min_rx_wqes = min_t (u16,
	          priv->params_ethtool.rx_queue_size - 1,
	          MLX5E_PARAMS_DEFAULT_MIN_RX_WQES);

	/* import number of channels */
	if (priv->params_ethtool.channels < 1)
		priv->params_ethtool.channels = 1;
	else if (priv->params_ethtool.channels >
	    (u64) priv->mdev->priv.eq_table.num_comp_vectors) {
		priv->params_ethtool.channels =
		    (u64) priv->mdev->priv.eq_table.num_comp_vectors;
	}
	priv->params.num_channels = priv->params_ethtool.channels;

	/* import RX mode */
	if (priv->params_ethtool.rx_coalesce_mode != 0)
		priv->params_ethtool.rx_coalesce_mode = 1;
	priv->params.rx_cq_moderation_mode = priv->params_ethtool.rx_coalesce_mode;

	/* import RX coal time */
	if (priv->params_ethtool.rx_coalesce_usecs < 1)
		priv->params_ethtool.rx_coalesce_usecs = 0;
	else if (priv->params_ethtool.rx_coalesce_usecs >
	    MLX5E_FLD_MAX(cqc, cq_period)) {
		priv->params_ethtool.rx_coalesce_usecs =
		    MLX5E_FLD_MAX(cqc, cq_period);
	}
	priv->params.rx_cq_moderation_usec = priv->params_ethtool.rx_coalesce_usecs;

	/* import RX coal pkts */
	if (priv->params_ethtool.rx_coalesce_pkts < 1)
		priv->params_ethtool.rx_coalesce_pkts = 0;
	else if (priv->params_ethtool.rx_coalesce_pkts >
	    MLX5E_FLD_MAX(cqc, cq_max_count)) {
		priv->params_ethtool.rx_coalesce_pkts =
		    MLX5E_FLD_MAX(cqc, cq_max_count);
	}
	priv->params.rx_cq_moderation_pkts = priv->params_ethtool.rx_coalesce_pkts;

	/* import TX coal time */
	if (priv->params_ethtool.tx_coalesce_usecs < 1)
		priv->params_ethtool.tx_coalesce_usecs = 0;
	else if (priv->params_ethtool.tx_coalesce_usecs >
	    MLX5E_FLD_MAX(cqc, cq_period)) {
		priv->params_ethtool.tx_coalesce_usecs =
		    MLX5E_FLD_MAX(cqc, cq_period);
	}
	priv->params.tx_cq_moderation_usec = priv->params_ethtool.tx_coalesce_usecs;

	/* import TX coal pkts */
	if (priv->params_ethtool.tx_coalesce_pkts < 1)
		priv->params_ethtool.tx_coalesce_pkts = 0;
	else if (priv->params_ethtool.tx_coalesce_pkts >
	    MLX5E_FLD_MAX(cqc, cq_max_count)) {
		priv->params_ethtool.tx_coalesce_pkts = MLX5E_FLD_MAX(cqc, cq_max_count);
	}
	priv->params.tx_cq_moderation_pkts = priv->params_ethtool.tx_coalesce_pkts;

	/* we always agree to turn off HW LRO - but not always to turn on */
	if (priv->params_ethtool.hw_lro) {
		if (priv->params_ethtool.hw_lro != 1) {
			priv->params_ethtool.hw_lro = priv->params.hw_lro_en;
			error = EINVAL;
			goto done;
		}
		if (priv->ifp->if_capenable & IFCAP_LRO)
			priv->params.hw_lro_en = !!MLX5_CAP_ETH(priv->mdev, lro_cap);
		else {
			/* set the correct (0) value to params_ethtool.hw_lro, issue a warning and return error */
			priv->params_ethtool.hw_lro = 0;
			error = EINVAL;
			if_printf(priv->ifp, "Can't set HW_LRO to a device with LRO turned off");
			goto done;
		}
	} else {
		priv->params.hw_lro_en = false;
	}

	if (was_opened)
		mlx5e_open_locked(priv->ifp);
done:
	PRIV_UNLOCK(priv);
	return (error);
}

/*
 * Read the first three bytes of the eeprom in order to get the needed info
 * for the whole reading.
 * Byte 0 - Identifier byte
 * Byte 1 - Revision byte
 * Byte 2 - Status byte
 */
static int
mlx5e_get_eeprom_info(struct mlx5e_priv *priv, struct mlx5e_eeprom *eeprom)
{
	struct mlx5_core_dev *dev = priv->mdev;
	u32 data = 0;
	int size_read = 0;
	int ret;

	ret = mlx5_query_module_num(dev, &eeprom->module_num);
	if (ret) {
		if_printf(priv->ifp, "%s:%d: Failed query module error=%d\n",
		    __func__, __LINE__, ret);
		return (ret);
	}

	/* Read the first three bytes to get Identifier, Revision and Status */
	ret = mlx5_query_eeprom(dev, eeprom->i2c_addr, eeprom->page_num,
	    eeprom->device_addr, MLX5E_EEPROM_INFO_BYTES, eeprom->module_num, &data,
	    &size_read);
	if (ret) {
		if_printf(priv->ifp, "%s:%d: Failed query eeprom module error=0x%x\n",
		    __func__, __LINE__, ret);
		return (ret);
	}

	switch (data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK) {
	case SFF_8024_ID_QSFP:
		eeprom->type = MLX5E_ETH_MODULE_SFF_8436;
		eeprom->len = MLX5E_ETH_MODULE_SFF_8436_LEN;
		break;
	case SFF_8024_ID_QSFPPLUS:
	case SFF_8024_ID_QSFP28:
		if ((data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK) == SFF_8024_ID_QSFP28 ||
		    ((data & MLX5_EEPROM_REVISION_ID_BYTE_MASK) >> 8) >= 0x3) {
			eeprom->type = MLX5E_ETH_MODULE_SFF_8636;
			eeprom->len = MLX5E_ETH_MODULE_SFF_8636_LEN;
		} else {
			eeprom->type = MLX5E_ETH_MODULE_SFF_8436;
			eeprom->len = MLX5E_ETH_MODULE_SFF_8436_LEN;
		}
		if ((data & MLX5_EEPROM_PAGE_3_VALID_BIT_MASK) == 0)
			eeprom->page_valid = 1;
		break;
	case SFF_8024_ID_SFP:
		eeprom->type = MLX5E_ETH_MODULE_SFF_8472;
		eeprom->len = MLX5E_ETH_MODULE_SFF_8472_LEN;
		break;
	default:
		if_printf(priv->ifp, "%s:%d: Not recognized cable type = 0x%x(%s)\n",
		    __func__, __LINE__, data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK,
		    sff_8024_id[data & MLX5_EEPROM_IDENTIFIER_BYTE_MASK]);
		return (EINVAL);
	}
	return (0);
}

/* Read both low and high pages of the eeprom */
static int
mlx5e_get_eeprom(struct mlx5e_priv *priv, struct mlx5e_eeprom *ee)
{
	struct mlx5_core_dev *dev = priv->mdev;
	int size_read = 0;
	int ret;

	if (ee->len == 0)
		return (EINVAL);

	/* Read low page of the eeprom */
	while (ee->device_addr < ee->len) {
		ret = mlx5_query_eeprom(dev, ee->i2c_addr, ee->page_num, ee->device_addr,
		    ee->len - ee->device_addr, ee->module_num,
		    ee->data + (ee->device_addr / 4), &size_read);
		if (ret) {
			if_printf(priv->ifp, "%s:%d: Failed reading eeprom, "
			    "error = 0x%02x\n", __func__, __LINE__, ret);
			return (ret);
		}
		ee->device_addr += size_read;
	}

	/* Read high page of the eeprom */
	if (ee->page_valid) {
		ee->device_addr = MLX5E_EEPROM_HIGH_PAGE_OFFSET;
		ee->page_num = MLX5E_EEPROM_HIGH_PAGE;
		size_read = 0;
		while (ee->device_addr < MLX5E_EEPROM_PAGE_LENGTH) {
			ret = mlx5_query_eeprom(dev, ee->i2c_addr, ee->page_num,
			    ee->device_addr, MLX5E_EEPROM_PAGE_LENGTH - ee->device_addr,
			    ee->module_num, ee->data + (ee->len / 4) +
			    ((ee->device_addr - MLX5E_EEPROM_HIGH_PAGE_OFFSET) / 4),
			    &size_read);
			if (ret) {
				if_printf(priv->ifp, "%s:%d: Failed reading eeprom, "
				    "error = 0x%02x\n", __func__, __LINE__, ret);
				return (ret);
			}
			ee->device_addr += size_read;
		}
	}
	return (0);
}

static void
mlx5e_print_eeprom(struct mlx5e_eeprom *eeprom)
{
	int i, j = 0;
	int row = 0;

	printf("\nOffset\t\tValues\n");
	printf("------\t\t------\n");
	while (row < eeprom->len) {
		printf("0x%04x\t\t", row);
		for (i = 0; i < 16; i++) {
			printf("%02x ", ((u8 *)eeprom->data)[j]);
			j++;
			row++;
		}
		printf("\n");
	}

	if (eeprom->page_valid) {
		row = MLX5E_EEPROM_HIGH_PAGE_OFFSET;
		printf("\nUpper Page 0x03\n");
		printf("\nOffset\t\tValues\n");
		printf("------\t\t------\n");
		while (row < MLX5E_EEPROM_PAGE_LENGTH) {
			printf("0x%04x\t\t", row);
			for (i = 0; i < 16; i++) {
				printf("%02x ", ((u8 *)eeprom->data)[j]);
				j++;
				row++;
			}
			printf("\n");
		}
	}
}

/*
 * Read cable EEPROM module information by first inspecting the first
 * three bytes to get the initial information for a whole reading.
 * Information will be printed to dmesg.
 */
static int
mlx5e_read_eeprom(SYSCTL_HANDLER_ARGS)
{
	struct mlx5e_priv *priv = arg1;
	struct mlx5e_eeprom eeprom;
	int error;
	int result = 0;

	PRIV_LOCK(priv);
	error = sysctl_handle_int(oidp, &result, 0, req);
	if (error || !req->newptr)
		goto done;

	/* Check if device is gone */
	if (priv->gone) {
		error = ENXIO;
		goto done;
	}

	if (result == 1) {
		eeprom.i2c_addr = MLX5E_I2C_ADDR_LOW;
		eeprom.device_addr = 0;
		eeprom.page_num = MLX5E_EEPROM_LOW_PAGE;
		eeprom.page_valid = 0;

		/* Read three first bytes to get important info */
		error = mlx5e_get_eeprom_info(priv, &eeprom);
		if (error) {
			if_printf(priv->ifp, "%s:%d: Failed reading eeprom's "
			    "initial information\n", __func__, __LINE__);
			error = 0;
			goto done;
		}
		/*
		 * Allocate needed length buffer and additional space for
		 * page 0x03
		 */
		eeprom.data = malloc(eeprom.len + MLX5E_EEPROM_PAGE_LENGTH,
		    M_MLX5EN, M_WAITOK | M_ZERO);

		/* Read the whole eeprom information */
		error = mlx5e_get_eeprom(priv, &eeprom);
		if (error) {
			if_printf(priv->ifp, "%s:%d: Failed reading eeprom\n",
			    __func__, __LINE__);
			error = 0;
			/*
			 * Continue printing partial information in case of
			 * an error
			 */
		}
		mlx5e_print_eeprom(&eeprom);
		free(eeprom.data, M_MLX5EN);
	}
done:
	PRIV_UNLOCK(priv);
	return (error);
}

static const char *mlx5e_params_desc[] = {
	MLX5E_PARAMS(MLX5E_STATS_DESC)
};

static const char *mlx5e_port_stats_debug_desc[] = {
	MLX5E_PORT_STATS_DEBUG(MLX5E_STATS_DESC)
};

static int
mlx5e_ethtool_debug_stats(SYSCTL_HANDLER_ARGS)
{
	struct mlx5e_priv *priv = arg1;
	int error;
	int sys_debug;

	sys_debug = priv->sysctl_debug;
	error = sysctl_handle_int(oidp, &priv->sysctl_debug, 0, req);
	if (error || !req->newptr)
		return (error);
	priv->sysctl_debug = !!priv->sysctl_debug;
	if (sys_debug == priv->sysctl_debug)
		return (error);
	if (priv->sysctl_debug)
		mlx5e_create_stats(&priv->stats.port_stats_debug.ctx,
		    SYSCTL_CHILDREN(priv->sysctl_ifnet), "debug_stats",
		    mlx5e_port_stats_debug_desc, MLX5E_PORT_STATS_DEBUG_NUM,
		    priv->stats.port_stats_debug.arg);
	else
		sysctl_ctx_free(&priv->stats.port_stats_debug.ctx);
	return (error);
}

void
mlx5e_create_ethtool(struct mlx5e_priv *priv)
{
	struct sysctl_oid *node;
	const char *pnameunit;
	unsigned x;

	/* set some defaults */
	priv->params_ethtool.tx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
	priv->params_ethtool.rx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE;
	priv->params_ethtool.tx_queue_size = 1 << priv->params.log_sq_size;
	priv->params_ethtool.rx_queue_size = 1 << priv->params.log_rq_size;
	priv->params_ethtool.channels = priv->params.num_channels;
	priv->params_ethtool.coalesce_pkts_max = MLX5E_FLD_MAX(cqc, cq_max_count);
	priv->params_ethtool.coalesce_usecs_max = MLX5E_FLD_MAX(cqc, cq_period);
	priv->params_ethtool.rx_coalesce_mode = priv->params.rx_cq_moderation_mode;
	priv->params_ethtool.rx_coalesce_usecs = priv->params.rx_cq_moderation_usec;
	priv->params_ethtool.rx_coalesce_pkts = priv->params.rx_cq_moderation_pkts;
	priv->params_ethtool.tx_coalesce_usecs = priv->params.tx_cq_moderation_usec;
	priv->params_ethtool.tx_coalesce_pkts = priv->params.tx_cq_moderation_pkts;
	priv->params_ethtool.hw_lro = priv->params.hw_lro_en;

	/* create root node */
	node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
	    SYSCTL_CHILDREN(priv->sysctl_ifnet), OID_AUTO,
	    "conf", CTLFLAG_RW, NULL, "Configuration");
	if (node == NULL)
		return;
	for (x = 0; x != MLX5E_PARAMS_NUM; x++) {
		/* check for read-only parameter */
		if (strstr(mlx5e_params_desc[2 * x], "_max") != NULL) {
			SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
			    mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RD |
			    CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
			    mlx5e_params_desc[2 * x + 1]);
		} else {
			SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
			    mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RWTUN |
			    CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
			    mlx5e_params_desc[2 * x + 1]);
		}
	}

	SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
	    "debug_stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, priv,
	    0, &mlx5e_ethtool_debug_stats, "I", "Extended debug statistics");

	pnameunit = device_get_nameunit(priv->mdev->pdev->dev.bsddev);

	SYSCTL_ADD_STRING(&priv->sysctl_ctx, SYSCTL_CHILDREN(node),
	    OID_AUTO, "device_name", CTLFLAG_RD,
	    __DECONST(void *, pnameunit), 0,
	    "PCI device name");

	/* EEPROM support */
	SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO, "eeprom_info",
	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, priv, 0,
	    mlx5e_read_eeprom, "I", "EEPROM information");
}