[linux-2.6-block.git] / drivers / net / ethernet / freescale / dpaa / dpaa_ethtool.c

/* Copyright 2008-2016 Freescale Semiconductor, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *	 notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of Freescale Semiconductor nor the
 *	 names of its contributors may be used to endorse or promote products
 *	 derived from this software without specific prior written permission.
 *
 *
 * ALTERNATIVELY, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") as published by the Free Software
 * Foundation, either version 2 of that License or (at your option) any
 * later version.
 *
 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``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 Freescale Semiconductor 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.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/string.h>

#include "dpaa_eth.h"
#include "mac.h"

static const char dpaa_stats_percpu[][ETH_GSTRING_LEN] = {
	"interrupts",
	"rx packets",
	"tx packets",
	"tx confirm",
	"tx S/G",
	"tx error",
	"rx error",
};

static char dpaa_stats_global[][ETH_GSTRING_LEN] = {
	/* dpa rx errors */
	"rx dma error",
	"rx frame physical error",
	"rx frame size error",
	"rx header error",

	/* demultiplexing errors */
	"qman cg_tdrop",
	"qman wred",
	"qman error cond",
	"qman early window",
	"qman late window",
	"qman fq tdrop",
	"qman fq retired",
	"qman orp disabled",

	/* congestion related stats */
	"congestion time (ms)",
	"entered congestion",
	"congested (0/1)"
};

#define DPAA_STATS_PERCPU_LEN ARRAY_SIZE(dpaa_stats_percpu)
#define DPAA_STATS_GLOBAL_LEN ARRAY_SIZE(dpaa_stats_global)

static int dpaa_get_link_ksettings(struct net_device *net_dev,
				   struct ethtool_link_ksettings *cmd)
{
	if (!net_dev->phydev) {
		netdev_dbg(net_dev, "phy device not initialized\n");
		return 0;
	}

	phy_ethtool_ksettings_get(net_dev->phydev, cmd);

	return 0;
}

static int dpaa_set_link_ksettings(struct net_device *net_dev,
				   const struct ethtool_link_ksettings *cmd)
{
	int err;

	if (!net_dev->phydev) {
		netdev_err(net_dev, "phy device not initialized\n");
		return -ENODEV;
	}

	err = phy_ethtool_ksettings_set(net_dev->phydev, cmd);
	if (err < 0)
		netdev_err(net_dev, "phy_ethtool_ksettings_set() = %d\n", err);

	return err;
}

static void dpaa_get_drvinfo(struct net_device *net_dev,
			     struct ethtool_drvinfo *drvinfo)
{
	int len;

	strlcpy(drvinfo->driver, KBUILD_MODNAME,
		sizeof(drvinfo->driver));
	len = snprintf(drvinfo->version, sizeof(drvinfo->version),
		       "%X", 0);
	len = snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
		       "%X", 0);

	if (len >= sizeof(drvinfo->fw_version)) {
		/* Truncated output */
		netdev_notice(net_dev, "snprintf() = %d\n", len);
	}
	strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
		sizeof(drvinfo->bus_info));
}

static u32 dpaa_get_msglevel(struct net_device *net_dev)
{
	return ((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable;
}

static void dpaa_set_msglevel(struct net_device *net_dev,
			      u32 msg_enable)
{
	((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable = msg_enable;
}

static int dpaa_nway_reset(struct net_device *net_dev)
{
	int err;

	if (!net_dev->phydev) {
		netdev_err(net_dev, "phy device not initialized\n");
		return -ENODEV;
	}

	err = 0;
	if (net_dev->phydev->autoneg) {
		err = phy_start_aneg(net_dev->phydev);
		if (err < 0)
			netdev_err(net_dev, "phy_start_aneg() = %d\n",
				   err);
	}

	return err;
}

static void dpaa_get_pauseparam(struct net_device *net_dev,
				struct ethtool_pauseparam *epause)
{
	struct mac_device *mac_dev;
	struct dpaa_priv *priv;

	priv = netdev_priv(net_dev);
	mac_dev = priv->mac_dev;

	if (!net_dev->phydev) {
		netdev_err(net_dev, "phy device not initialized\n");
		return;
	}

	epause->autoneg = mac_dev->autoneg_pause;
	epause->rx_pause = mac_dev->rx_pause_active;
	epause->tx_pause = mac_dev->tx_pause_active;
}

static int dpaa_set_pauseparam(struct net_device *net_dev,
			       struct ethtool_pauseparam *epause)
{
	struct mac_device *mac_dev;
	struct phy_device *phydev;
	bool rx_pause, tx_pause;
	struct dpaa_priv *priv;
	u32 newadv, oldadv;
	int err;

	priv = netdev_priv(net_dev);
	mac_dev = priv->mac_dev;

	phydev = net_dev->phydev;
	if (!phydev) {
		netdev_err(net_dev, "phy device not initialized\n");
		return -ENODEV;
	}

	if (!(phydev->supported & SUPPORTED_Pause) ||
	    (!(phydev->supported & SUPPORTED_Asym_Pause) &&
	    (epause->rx_pause != epause->tx_pause)))
		return -EINVAL;

	/* The MAC should know how to handle PAUSE frame autonegotiation before
	 * adjust_link is triggered by a forced renegotiation of sym/asym PAUSE
	 * settings.
	 */
	mac_dev->autoneg_pause = !!epause->autoneg;
	mac_dev->rx_pause_req = !!epause->rx_pause;
	mac_dev->tx_pause_req = !!epause->tx_pause;

	/* Determine the sym/asym advertised PAUSE capabilities from the desired
	 * rx/tx pause settings.
	 */
	newadv = 0;
	if (epause->rx_pause)
		newadv = ADVERTISED_Pause | ADVERTISED_Asym_Pause;
	if (epause->tx_pause)
		newadv |= ADVERTISED_Asym_Pause;

	oldadv = phydev->advertising &
			(ADVERTISED_Pause | ADVERTISED_Asym_Pause);

	/* If there are differences between the old and the new advertised
	 * values, restart PHY autonegotiation and advertise the new values.
	 */
	if (oldadv != newadv) {
		phydev->advertising &= ~(ADVERTISED_Pause
				| ADVERTISED_Asym_Pause);
		phydev->advertising |= newadv;
		if (phydev->autoneg) {
			err = phy_start_aneg(phydev);
			if (err < 0)
				netdev_err(net_dev, "phy_start_aneg() = %d\n",
					   err);
		}
	}

	fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
	err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
	if (err < 0)
		netdev_err(net_dev, "set_mac_active_pause() = %d\n", err);

	return err;
}

static int dpaa_get_sset_count(struct net_device *net_dev, int type)
{
	unsigned int total_stats, num_stats;

	num_stats   = num_online_cpus() + 1;
	total_stats = num_stats * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM) +
			DPAA_STATS_GLOBAL_LEN;

	switch (type) {
	case ETH_SS_STATS:
		return total_stats;
	default:
		return -EOPNOTSUPP;
	}
}

static void copy_stats(struct dpaa_percpu_priv *percpu_priv, int num_cpus,
		       int crr_cpu, u64 *bp_count, u64 *data)
{
	int num_values = num_cpus + 1;
	int crr = 0, j;

	/* update current CPU's stats and also add them to the total values */
	data[crr * num_values + crr_cpu] = percpu_priv->in_interrupt;
	data[crr++ * num_values + num_cpus] += percpu_priv->in_interrupt;

	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_packets;
	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_packets;

	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_packets;
	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_packets;

	data[crr * num_values + crr_cpu] = percpu_priv->tx_confirm;
	data[crr++ * num_values + num_cpus] += percpu_priv->tx_confirm;

	data[crr * num_values + crr_cpu] = percpu_priv->tx_frag_skbuffs;
	data[crr++ * num_values + num_cpus] += percpu_priv->tx_frag_skbuffs;

	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_errors;
	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_errors;

	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_errors;
	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_errors;

	for (j = 0; j < DPAA_BPS_NUM; j++) {
		data[crr * num_values + crr_cpu] = bp_count[j];
		data[crr++ * num_values + num_cpus] += bp_count[j];
	}
}

static void dpaa_get_ethtool_stats(struct net_device *net_dev,
				   struct ethtool_stats *stats, u64 *data)
{
	u64 bp_count[DPAA_BPS_NUM], cg_time, cg_num;
	struct dpaa_percpu_priv *percpu_priv;
	struct dpaa_rx_errors rx_errors;
	unsigned int num_cpus, offset;
	struct dpaa_ern_cnt ern_cnt;
	struct dpaa_bp *dpaa_bp;
	struct dpaa_priv *priv;
	int total_stats, i, j;
	bool cg_status;

	total_stats = dpaa_get_sset_count(net_dev, ETH_SS_STATS);
	priv     = netdev_priv(net_dev);
	num_cpus = num_online_cpus();

	memset(&bp_count, 0, sizeof(bp_count));
	memset(&rx_errors, 0, sizeof(struct dpaa_rx_errors));
	memset(&ern_cnt, 0, sizeof(struct dpaa_ern_cnt));
	memset(data, 0, total_stats * sizeof(u64));

	for_each_online_cpu(i) {
		percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
		for (j = 0; j < DPAA_BPS_NUM; j++) {
			dpaa_bp = priv->dpaa_bps[j];
			if (!dpaa_bp->percpu_count)
				continue;
			bp_count[j] = *(per_cpu_ptr(dpaa_bp->percpu_count, i));
		}
		rx_errors.dme += percpu_priv->rx_errors.dme;
		rx_errors.fpe += percpu_priv->rx_errors.fpe;
		rx_errors.fse += percpu_priv->rx_errors.fse;
		rx_errors.phe += percpu_priv->rx_errors.phe;

		ern_cnt.cg_tdrop     += percpu_priv->ern_cnt.cg_tdrop;
		ern_cnt.wred         += percpu_priv->ern_cnt.wred;
		ern_cnt.err_cond     += percpu_priv->ern_cnt.err_cond;
		ern_cnt.early_window += percpu_priv->ern_cnt.early_window;
		ern_cnt.late_window  += percpu_priv->ern_cnt.late_window;
		ern_cnt.fq_tdrop     += percpu_priv->ern_cnt.fq_tdrop;
		ern_cnt.fq_retired   += percpu_priv->ern_cnt.fq_retired;
		ern_cnt.orp_zero     += percpu_priv->ern_cnt.orp_zero;

		copy_stats(percpu_priv, num_cpus, i, bp_count, data);
	}

	offset = (num_cpus + 1) * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM);
	memcpy(data + offset, &rx_errors, sizeof(struct dpaa_rx_errors));

	offset += sizeof(struct dpaa_rx_errors) / sizeof(u64);
	memcpy(data + offset, &ern_cnt, sizeof(struct dpaa_ern_cnt));

	/* gather congestion related counters */
	cg_num    = 0;
	cg_status = 0;
	cg_time   = jiffies_to_msecs(priv->cgr_data.congested_jiffies);
	if (qman_query_cgr_congested(&priv->cgr_data.cgr, &cg_status) == 0) {
		cg_num    = priv->cgr_data.cgr_congested_count;

		/* reset congestion stats (like QMan API does */
		priv->cgr_data.congested_jiffies   = 0;
		priv->cgr_data.cgr_congested_count = 0;
	}

	offset += sizeof(struct dpaa_ern_cnt) / sizeof(u64);
	data[offset++] = cg_time;
	data[offset++] = cg_num;
	data[offset++] = cg_status;
}

static void dpaa_get_strings(struct net_device *net_dev, u32 stringset,
			     u8 *data)
{
	unsigned int i, j, num_cpus, size;
	char string_cpu[ETH_GSTRING_LEN];
	u8 *strings;

	memset(string_cpu, 0, sizeof(string_cpu));
	strings   = data;
	num_cpus  = num_online_cpus();
	size      = DPAA_STATS_GLOBAL_LEN * ETH_GSTRING_LEN;

	for (i = 0; i < DPAA_STATS_PERCPU_LEN; i++) {
		for (j = 0; j < num_cpus; j++) {
			snprintf(string_cpu, ETH_GSTRING_LEN, "%s [CPU %d]",
				 dpaa_stats_percpu[i], j);
			memcpy(strings, string_cpu, ETH_GSTRING_LEN);
			strings += ETH_GSTRING_LEN;
		}
		snprintf(string_cpu, ETH_GSTRING_LEN, "%s [TOTAL]",
			 dpaa_stats_percpu[i]);
		memcpy(strings, string_cpu, ETH_GSTRING_LEN);
		strings += ETH_GSTRING_LEN;
	}
	for (i = 0; i < DPAA_BPS_NUM; i++) {
		for (j = 0; j < num_cpus; j++) {
			snprintf(string_cpu, ETH_GSTRING_LEN,
				 "bpool %c [CPU %d]", 'a' + i, j);
			memcpy(strings, string_cpu, ETH_GSTRING_LEN);
			strings += ETH_GSTRING_LEN;
		}
		snprintf(string_cpu, ETH_GSTRING_LEN, "bpool %c [TOTAL]",
			 'a' + i);
		memcpy(strings, string_cpu, ETH_GSTRING_LEN);
		strings += ETH_GSTRING_LEN;
	}
	memcpy(strings, dpaa_stats_global, size);
}

static int dpaa_get_hash_opts(struct net_device *dev,
			      struct ethtool_rxnfc *cmd)
{
	struct dpaa_priv *priv = netdev_priv(dev);

	cmd->data = 0;

	switch (cmd->flow_type) {
	case TCP_V4_FLOW:
	case TCP_V6_FLOW:
	case UDP_V4_FLOW:
	case UDP_V6_FLOW:
		if (priv->keygen_in_use)
			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
		/* Fall through */
	case IPV4_FLOW:
	case IPV6_FLOW:
	case SCTP_V4_FLOW:
	case SCTP_V6_FLOW:
	case AH_ESP_V4_FLOW:
	case AH_ESP_V6_FLOW:
	case AH_V4_FLOW:
	case AH_V6_FLOW:
	case ESP_V4_FLOW:
	case ESP_V6_FLOW:
		if (priv->keygen_in_use)
			cmd->data |= RXH_IP_SRC | RXH_IP_DST;
		break;
	default:
		cmd->data = 0;
		break;
	}

	return 0;
}

static int dpaa_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
			  u32 *unused)
{
	int ret = -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_GRXFH:
		ret = dpaa_get_hash_opts(dev, cmd);
		break;
	default:
		break;
	}

	return ret;
}

static void dpaa_set_hash(struct net_device *net_dev, bool enable)
{
	struct mac_device *mac_dev;
	struct fman_port *rxport;
	struct dpaa_priv *priv;

	priv = netdev_priv(net_dev);
	mac_dev = priv->mac_dev;
	rxport = mac_dev->port[0];

	fman_port_use_kg_hash(rxport, enable);
	priv->keygen_in_use = enable;
}

static int dpaa_set_hash_opts(struct net_device *dev,
			      struct ethtool_rxnfc *nfc)
{
	int ret = -EINVAL;

	/* we support hashing on IPv4/v6 src/dest IP and L4 src/dest port */
	if (nfc->data &
	    ~(RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 | RXH_L4_B_2_3))
		return -EINVAL;

	switch (nfc->flow_type) {
	case TCP_V4_FLOW:
	case TCP_V6_FLOW:
	case UDP_V4_FLOW:
	case UDP_V6_FLOW:
	case IPV4_FLOW:
	case IPV6_FLOW:
	case SCTP_V4_FLOW:
	case SCTP_V6_FLOW:
	case AH_ESP_V4_FLOW:
	case AH_ESP_V6_FLOW:
	case AH_V4_FLOW:
	case AH_V6_FLOW:
	case ESP_V4_FLOW:
	case ESP_V6_FLOW:
		dpaa_set_hash(dev, !!nfc->data);
		ret = 0;
		break;
	default:
		break;
	}

	return ret;
}

static int dpaa_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
{
	int ret = -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_SRXFH:
		ret = dpaa_set_hash_opts(dev, cmd);
		break;
	default:
		break;
	}

	return ret;
}

const struct ethtool_ops dpaa_ethtool_ops = {
	.get_drvinfo = dpaa_get_drvinfo,
	.get_msglevel = dpaa_get_msglevel,
	.set_msglevel = dpaa_set_msglevel,
	.nway_reset = dpaa_nway_reset,
	.get_pauseparam = dpaa_get_pauseparam,
	.set_pauseparam = dpaa_set_pauseparam,
	.get_link = ethtool_op_get_link,
	.get_sset_count = dpaa_get_sset_count,
	.get_ethtool_stats = dpaa_get_ethtool_stats,
	.get_strings = dpaa_get_strings,
	.get_link_ksettings = dpaa_get_link_ksettings,
	.set_link_ksettings = dpaa_set_link_ksettings,
	.get_rxnfc = dpaa_get_rxnfc,
	.set_rxnfc = dpaa_set_rxnfc,
};
Commit	Line	Data
b0cdb168 MB	1	/* Copyright 2008-2016 Freescale Semiconductor, Inc.
	2	*
	3	* Redistribution and use in source and binary forms, with or without
	4	* modification, are permitted provided that the following conditions are met:
	5	* * Redistributions of source code must retain the above copyright
	6	* notice, this list of conditions and the following disclaimer.
	7	* * Redistributions in binary form must reproduce the above copyright
	8	* notice, this list of conditions and the following disclaimer in the
	9	* documentation and/or other materials provided with the distribution.
	10	* * Neither the name of Freescale Semiconductor nor the
	11	* names of its contributors may be used to endorse or promote products
	12	* derived from this software without specific prior written permission.
	13	*
	14	*
	15	* ALTERNATIVELY, this software may be distributed under the terms of the
	16	* GNU General Public License ("GPL") as published by the Free Software
	17	* Foundation, either version 2 of that License or (at your option) any
	18	* later version.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
	21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	22	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	23	* DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
	24	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	25	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	26	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	27	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	28	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	29	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	30	*/
	31
	32	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	33
	34	#include <linux/string.h>
	35
	36	#include "dpaa_eth.h"
	37	#include "mac.h"
	38
b0ce0d02 MB	39	static const char dpaa_stats_percpu[][ETH_GSTRING_LEN] = {
	40	"interrupts",
	41	"rx packets",
	42	"tx packets",
	43	"tx confirm",
	44	"tx S/G",
	45	"tx error",
	46	"rx error",
	47	};
	48
	49	static char dpaa_stats_global[][ETH_GSTRING_LEN] = {
	50	/* dpa rx errors */
	51	"rx dma error",
	52	"rx frame physical error",
	53	"rx frame size error",
	54	"rx header error",
	55
	56	/* demultiplexing errors */
	57	"qman cg_tdrop",
	58	"qman wred",
	59	"qman error cond",
	60	"qman early window",
	61	"qman late window",
	62	"qman fq tdrop",
	63	"qman fq retired",
	64	"qman orp disabled",
	65
	66	/* congestion related stats */
	67	"congestion time (ms)",
	68	"entered congestion",
	69	"congested (0/1)"
	70	};
	71
	72	#define DPAA_STATS_PERCPU_LEN ARRAY_SIZE(dpaa_stats_percpu)
	73	#define DPAA_STATS_GLOBAL_LEN ARRAY_SIZE(dpaa_stats_global)
	74
28fa4f30 PR	75	static int dpaa_get_link_ksettings(struct net_device *net_dev,
28fa4f30 PR	76	struct ethtool_link_ksettings *cmd)
b0cdb168	77	{
b0cdb168 MB	78	if (!net_dev->phydev) {
	79	netdev_dbg(net_dev, "phy device not initialized\n");
	80	return 0;
	81	}
	82
5514174f	83	phy_ethtool_ksettings_get(net_dev->phydev, cmd);
b0cdb168	84
5514174f	85	return 0;
b0cdb168 MB	86	}
b0cdb168 MB	87
28fa4f30 PR	88	static int dpaa_set_link_ksettings(struct net_device *net_dev,
28fa4f30 PR	89	const struct ethtool_link_ksettings *cmd)
b0cdb168 MB	90	{
	91	int err;
	92
	93	if (!net_dev->phydev) {
	94	netdev_err(net_dev, "phy device not initialized\n");
	95	return -ENODEV;
	96	}
	97
28fa4f30	98	err = phy_ethtool_ksettings_set(net_dev->phydev, cmd);
b0cdb168	99	if (err < 0)
28fa4f30	100	netdev_err(net_dev, "phy_ethtool_ksettings_set() = %d\n", err);
b0cdb168 MB	101
	102	return err;
	103	}
	104
	105	static void dpaa_get_drvinfo(struct net_device *net_dev,
	106	struct ethtool_drvinfo *drvinfo)
	107	{
	108	int len;
	109
	110	strlcpy(drvinfo->driver, KBUILD_MODNAME,
	111	sizeof(drvinfo->driver));
	112	len = snprintf(drvinfo->version, sizeof(drvinfo->version),
	113	"%X", 0);
	114	len = snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
	115	"%X", 0);
	116
	117	if (len >= sizeof(drvinfo->fw_version)) {
	118	/* Truncated output */
	119	netdev_notice(net_dev, "snprintf() = %d\n", len);
	120	}
	121	strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
	122	sizeof(drvinfo->bus_info));
	123	}
	124
	125	static u32 dpaa_get_msglevel(struct net_device *net_dev)
	126	{
	127	return ((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable;
	128	}
	129
	130	static void dpaa_set_msglevel(struct net_device *net_dev,
	131	u32 msg_enable)
	132	{
	133	((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable = msg_enable;
	134	}
	135
	136	static int dpaa_nway_reset(struct net_device *net_dev)
	137	{
	138	int err;
	139
	140	if (!net_dev->phydev) {
	141	netdev_err(net_dev, "phy device not initialized\n");
	142	return -ENODEV;
	143	}
	144
	145	err = 0;
	146	if (net_dev->phydev->autoneg) {
	147	err = phy_start_aneg(net_dev->phydev);
	148	if (err < 0)
	149	netdev_err(net_dev, "phy_start_aneg() = %d\n",
	150	err);
	151	}
	152
	153	return err;
	154	}
	155
	156	static void dpaa_get_pauseparam(struct net_device *net_dev,
	157	struct ethtool_pauseparam *epause)
	158	{
	159	struct mac_device *mac_dev;
	160	struct dpaa_priv *priv;
	161
	162	priv = netdev_priv(net_dev);
	163	mac_dev = priv->mac_dev;
	164
165	if (!net_dev->phydev) {
166	netdev_err(net_dev, "phy device not initialized\n");
167	return;
168	}
169
170	epause->autoneg = mac_dev->autoneg_pause;
171	epause->rx_pause = mac_dev->rx_pause_active;
172	epause->tx_pause = mac_dev->tx_pause_active;
173	}
174
175	static int dpaa_set_pauseparam(struct net_device *net_dev,
176	struct ethtool_pauseparam *epause)
177	{
178	struct mac_device *mac_dev;
179	struct phy_device *phydev;
180	bool rx_pause, tx_pause;
181	struct dpaa_priv *priv;
182	u32 newadv, oldadv;
183	int err;
184
185	priv = netdev_priv(net_dev);
186	mac_dev = priv->mac_dev;
187
188	phydev = net_dev->phydev;
189	if (!phydev) {
190	netdev_err(net_dev, "phy device not initialized\n");
191	return -ENODEV;
192	}
193
194	if (!(phydev->supported & SUPPORTED_Pause) \|\|
195	(!(phydev->supported & SUPPORTED_Asym_Pause) &&
196	(epause->rx_pause != epause->tx_pause)))
197	return -EINVAL;
198
199	/* The MAC should know how to handle PAUSE frame autonegotiation before
200	* adjust_link is triggered by a forced renegotiation of sym/asym PAUSE
201	* settings.
202	*/
203	mac_dev->autoneg_pause = !!epause->autoneg;
204	mac_dev->rx_pause_req = !!epause->rx_pause;
205	mac_dev->tx_pause_req = !!epause->tx_pause;
206
207	/* Determine the sym/asym advertised PAUSE capabilities from the desired
208	* rx/tx pause settings.
209	*/
210	newadv = 0;
211	if (epause->rx_pause)
212	newadv = ADVERTISED_Pause \| ADVERTISED_Asym_Pause;
213	if (epause->tx_pause)
214	newadv \|= ADVERTISED_Asym_Pause;
215
216	oldadv = phydev->advertising &
217	(ADVERTISED_Pause \| ADVERTISED_Asym_Pause);
218
219	/* If there are differences between the old and the new advertised
220	* values, restart PHY autonegotiation and advertise the new values.
221	*/
222	if (oldadv != newadv) {
223	phydev->advertising &= ~(ADVERTISED_Pause
224	\| ADVERTISED_Asym_Pause);
225	phydev->advertising \|= newadv;
226	if (phydev->autoneg) {
227	err = phy_start_aneg(phydev);
228	if (err < 0)
229	netdev_err(net_dev, "phy_start_aneg() = %d\n",
230	err);
231	}
232	}
233
234	fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
235	err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
236	if (err < 0)
237	netdev_err(net_dev, "set_mac_active_pause() = %d\n", err);
238
239	return err;
240	}
241
b0ce0d02 MB	242	static int dpaa_get_sset_count(struct net_device *net_dev, int type)
	243	{
	244	unsigned int total_stats, num_stats;
	245
	246	num_stats = num_online_cpus() + 1;
	247	total_stats = num_stats * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM) +
	248	DPAA_STATS_GLOBAL_LEN;
	249
	250	switch (type) {
	251	case ETH_SS_STATS:
	252	return total_stats;
	253	default:
	254	return -EOPNOTSUPP;
	255	}
	256	}
	257
	258	static void copy_stats(struct dpaa_percpu_priv *percpu_priv, int num_cpus,
	259	int crr_cpu, u64 bp_count, u64 data)
	260	{
	261	int num_values = num_cpus + 1;
	262	int crr = 0, j;
	263
	264	/* update current CPU's stats and also add them to the total values */
	265	data[crr * num_values + crr_cpu] = percpu_priv->in_interrupt;
	266	data[crr++ * num_values + num_cpus] += percpu_priv->in_interrupt;
	267
	268	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_packets;
	269	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_packets;
	270
	271	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_packets;
	272	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_packets;
	273
	274	data[crr * num_values + crr_cpu] = percpu_priv->tx_confirm;
	275	data[crr++ * num_values + num_cpus] += percpu_priv->tx_confirm;
	276
	277	data[crr * num_values + crr_cpu] = percpu_priv->tx_frag_skbuffs;
	278	data[crr++ * num_values + num_cpus] += percpu_priv->tx_frag_skbuffs;
	279
	280	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_errors;
	281	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_errors;
	282
	283	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_errors;
	284	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_errors;
	285
	286	for (j = 0; j < DPAA_BPS_NUM; j++) {
	287	data[crr * num_values + crr_cpu] = bp_count[j];
	288	data[crr++ * num_values + num_cpus] += bp_count[j];
	289	}
	290	}
	291
	292	static void dpaa_get_ethtool_stats(struct net_device *net_dev,
	293	struct ethtool_stats stats, u64 data)
	294	{
	295	u64 bp_count[DPAA_BPS_NUM], cg_time, cg_num;
	296	struct dpaa_percpu_priv *percpu_priv;
	297	struct dpaa_rx_errors rx_errors;
	298	unsigned int num_cpus, offset;
	299	struct dpaa_ern_cnt ern_cnt;
	300	struct dpaa_bp *dpaa_bp;
	301	struct dpaa_priv *priv;
	302	int total_stats, i, j;
	303	bool cg_status;
	304
	305	total_stats = dpaa_get_sset_count(net_dev, ETH_SS_STATS);
306	priv = netdev_priv(net_dev);
307	num_cpus = num_online_cpus();
308
309	memset(&bp_count, 0, sizeof(bp_count));
310	memset(&rx_errors, 0, sizeof(struct dpaa_rx_errors));
311	memset(&ern_cnt, 0, sizeof(struct dpaa_ern_cnt));
312	memset(data, 0, total_stats * sizeof(u64));
313
314	for_each_online_cpu(i) {
315	percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
316	for (j = 0; j < DPAA_BPS_NUM; j++) {
317	dpaa_bp = priv->dpaa_bps[j];
318	if (!dpaa_bp->percpu_count)
319	continue;
320	bp_count[j] = *(per_cpu_ptr(dpaa_bp->percpu_count, i));
321	}
322	rx_errors.dme += percpu_priv->rx_errors.dme;
323	rx_errors.fpe += percpu_priv->rx_errors.fpe;
324	rx_errors.fse += percpu_priv->rx_errors.fse;
325	rx_errors.phe += percpu_priv->rx_errors.phe;
326
327	ern_cnt.cg_tdrop += percpu_priv->ern_cnt.cg_tdrop;
328	ern_cnt.wred += percpu_priv->ern_cnt.wred;
329	ern_cnt.err_cond += percpu_priv->ern_cnt.err_cond;
330	ern_cnt.early_window += percpu_priv->ern_cnt.early_window;
331	ern_cnt.late_window += percpu_priv->ern_cnt.late_window;
332	ern_cnt.fq_tdrop += percpu_priv->ern_cnt.fq_tdrop;
333	ern_cnt.fq_retired += percpu_priv->ern_cnt.fq_retired;
334	ern_cnt.orp_zero += percpu_priv->ern_cnt.orp_zero;
335
336	copy_stats(percpu_priv, num_cpus, i, bp_count, data);
337	}
338
339	offset = (num_cpus + 1) * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM);
340	memcpy(data + offset, &rx_errors, sizeof(struct dpaa_rx_errors));
341
342	offset += sizeof(struct dpaa_rx_errors) / sizeof(u64);
343	memcpy(data + offset, &ern_cnt, sizeof(struct dpaa_ern_cnt));
344
345	/* gather congestion related counters */
346	cg_num = 0;
347	cg_status = 0;
348	cg_time = jiffies_to_msecs(priv->cgr_data.congested_jiffies);
349	if (qman_query_cgr_congested(&priv->cgr_data.cgr, &cg_status) == 0) {
350	cg_num = priv->cgr_data.cgr_congested_count;
351
352	/* reset congestion stats (like QMan API does */
353	priv->cgr_data.congested_jiffies = 0;
354	priv->cgr_data.cgr_congested_count = 0;
355	}
356
357	offset += sizeof(struct dpaa_ern_cnt) / sizeof(u64);
358	data[offset++] = cg_time;
359	data[offset++] = cg_num;
360	data[offset++] = cg_status;
361	}
362
363	static void dpaa_get_strings(struct net_device *net_dev, u32 stringset,
364	u8 *data)
365	{
366	unsigned int i, j, num_cpus, size;
367	char string_cpu[ETH_GSTRING_LEN];
368	u8 *strings;
369
370	memset(string_cpu, 0, sizeof(string_cpu));
371	strings = data;
372	num_cpus = num_online_cpus();
373	size = DPAA_STATS_GLOBAL_LEN * ETH_GSTRING_LEN;
374
375	for (i = 0; i < DPAA_STATS_PERCPU_LEN; i++) {
376	for (j = 0; j < num_cpus; j++) {
377	snprintf(string_cpu, ETH_GSTRING_LEN, "%s [CPU %d]",
378	dpaa_stats_percpu[i], j);
379	memcpy(strings, string_cpu, ETH_GSTRING_LEN);
380	strings += ETH_GSTRING_LEN;
381	}
382	snprintf(string_cpu, ETH_GSTRING_LEN, "%s [TOTAL]",
383	dpaa_stats_percpu[i]);
384	memcpy(strings, string_cpu, ETH_GSTRING_LEN);
385	strings += ETH_GSTRING_LEN;
386	}
387	for (i = 0; i < DPAA_BPS_NUM; i++) {
388	for (j = 0; j < num_cpus; j++) {
389	snprintf(string_cpu, ETH_GSTRING_LEN,
390	"bpool %c [CPU %d]", 'a' + i, j);
391	memcpy(strings, string_cpu, ETH_GSTRING_LEN);
392	strings += ETH_GSTRING_LEN;
393	}
394	snprintf(string_cpu, ETH_GSTRING_LEN, "bpool %c [TOTAL]",
395	'a' + i);
396	memcpy(strings, string_cpu, ETH_GSTRING_LEN);
397	strings += ETH_GSTRING_LEN;
398	}
399	memcpy(strings, dpaa_stats_global, size);
400	}
401
bcf0994b MB	402	static int dpaa_get_hash_opts(struct net_device *dev,
	403	struct ethtool_rxnfc *cmd)
	404	{
056057e2 MB	405	struct dpaa_priv *priv = netdev_priv(dev);
056057e2 MB	406
bcf0994b MB	407	cmd->data = 0;
	408
	409	switch (cmd->flow_type) {
	410	case TCP_V4_FLOW:
	411	case TCP_V6_FLOW:
	412	case UDP_V4_FLOW:
	413	case UDP_V6_FLOW:
056057e2 MB	414	if (priv->keygen_in_use)
056057e2 MB	415	cmd->data \|= RXH_L4_B_0_1 \| RXH_L4_B_2_3;
bcf0994b MB	416	/* Fall through */
	417	case IPV4_FLOW:
	418	case IPV6_FLOW:
	419	case SCTP_V4_FLOW:
	420	case SCTP_V6_FLOW:
	421	case AH_ESP_V4_FLOW:
	422	case AH_ESP_V6_FLOW:
	423	case AH_V4_FLOW:
	424	case AH_V6_FLOW:
	425	case ESP_V4_FLOW:
	426	case ESP_V6_FLOW:
056057e2 MB	427	if (priv->keygen_in_use)
056057e2 MB	428	cmd->data \|= RXH_IP_SRC \| RXH_IP_DST;
bcf0994b MB	429	break;
	430	default:
	431	cmd->data = 0;
	432	break;
	433	}
	434
	435	return 0;
	436	}
	437
	438	static int dpaa_get_rxnfc(struct net_device dev, struct ethtool_rxnfc cmd,
	439	u32 *unused)
	440	{
	441	int ret = -EOPNOTSUPP;
	442
	443	switch (cmd->cmd) {
	444	case ETHTOOL_GRXFH:
	445	ret = dpaa_get_hash_opts(dev, cmd);
	446	break;
	447	default:
	448	break;
	449	}
	450
	451	return ret;
	452	}
	453
	454	static void dpaa_set_hash(struct net_device *net_dev, bool enable)
	455	{
	456	struct mac_device *mac_dev;
	457	struct fman_port *rxport;
	458	struct dpaa_priv *priv;
	459
	460	priv = netdev_priv(net_dev);
	461	mac_dev = priv->mac_dev;
	462	rxport = mac_dev->port[0];
	463
	464	fman_port_use_kg_hash(rxport, enable);
056057e2	465	priv->keygen_in_use = enable;
bcf0994b MB	466	}
	467
	468	static int dpaa_set_hash_opts(struct net_device *dev,
	469	struct ethtool_rxnfc *nfc)
	470	{
	471	int ret = -EINVAL;
	472
	473	/* we support hashing on IPv4/v6 src/dest IP and L4 src/dest port */
	474	if (nfc->data &
	475	~(RXH_IP_SRC \| RXH_IP_DST \| RXH_L4_B_0_1 \| RXH_L4_B_2_3))
	476	return -EINVAL;
	477
	478	switch (nfc->flow_type) {
	479	case TCP_V4_FLOW:
	480	case TCP_V6_FLOW:
	481	case UDP_V4_FLOW:
	482	case UDP_V6_FLOW:
	483	case IPV4_FLOW:
	484	case IPV6_FLOW:
	485	case SCTP_V4_FLOW:
	486	case SCTP_V6_FLOW:
	487	case AH_ESP_V4_FLOW:
	488	case AH_ESP_V6_FLOW:
	489	case AH_V4_FLOW:
	490	case AH_V6_FLOW:
	491	case ESP_V4_FLOW:
	492	case ESP_V6_FLOW:
	493	dpaa_set_hash(dev, !!nfc->data);
	494	ret = 0;
	495	break;
	496	default:
	497	break;
	498	}
	499
	500	return ret;
	501	}
	502
	503	static int dpaa_set_rxnfc(struct net_device dev, struct ethtool_rxnfc cmd)
	504	{
	505	int ret = -EOPNOTSUPP;
	506
	507	switch (cmd->cmd) {
	508	case ETHTOOL_SRXFH:
	509	ret = dpaa_set_hash_opts(dev, cmd);
	510	break;
	511	default:
	512	break;
	513	}
	514
	515	return ret;
	516	}
	517
b0cdb168	518	const struct ethtool_ops dpaa_ethtool_ops = {
b0cdb168 MB	519	.get_drvinfo = dpaa_get_drvinfo,
	520	.get_msglevel = dpaa_get_msglevel,
	521	.set_msglevel = dpaa_set_msglevel,
	522	.nway_reset = dpaa_nway_reset,
	523	.get_pauseparam = dpaa_get_pauseparam,
	524	.set_pauseparam = dpaa_set_pauseparam,
	525	.get_link = ethtool_op_get_link,
b0ce0d02 MB	526	.get_sset_count = dpaa_get_sset_count,
	527	.get_ethtool_stats = dpaa_get_ethtool_stats,
	528	.get_strings = dpaa_get_strings,
28fa4f30 PR	529	.get_link_ksettings = dpaa_get_link_ksettings,
28fa4f30 PR	530	.set_link_ksettings = dpaa_set_link_ksettings,
bcf0994b MB	531	.get_rxnfc = dpaa_get_rxnfc,
bcf0994b MB	532	.set_rxnfc = dpaa_set_rxnfc,
b0cdb168	533	};