[thirdparty/linux.git] / drivers / net / ethernet / freescale / ucc_geth_ethtool.c

/*
 * Copyright (c) 2007 Freescale Semiconductor, Inc. All rights reserved.
 *
 * Description: QE UCC Gigabit Ethernet Ethtool API Set
 *
 * Author: Li Yang <leoli@freescale.com>
 *
 * Limitation:
 * Can only get/set settings of the first queue.
 * Need to re-open the interface manually after changing some parameters.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/stddef.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/phy.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <linux/uaccess.h>
#include <asm/types.h>

#include "ucc_geth.h"

static const char hw_stat_gstrings[][ETH_GSTRING_LEN] = {
	"tx-64-frames",
	"tx-65-127-frames",
	"tx-128-255-frames",
	"rx-64-frames",
	"rx-65-127-frames",
	"rx-128-255-frames",
	"tx-bytes-ok",
	"tx-pause-frames",
	"tx-multicast-frames",
	"tx-broadcast-frames",
	"rx-frames",
	"rx-bytes-ok",
	"rx-bytes-all",
	"rx-multicast-frames",
	"rx-broadcast-frames",
	"stats-counter-carry",
	"stats-counter-mask",
	"rx-dropped-frames",
};

static const char tx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
	"tx-single-collision",
	"tx-multiple-collision",
	"tx-late-collsion",
	"tx-aborted-frames",
	"tx-lost-frames",
	"tx-carrier-sense-errors",
	"tx-frames-ok",
	"tx-excessive-differ-frames",
	"tx-256-511-frames",
	"tx-512-1023-frames",
	"tx-1024-1518-frames",
	"tx-jumbo-frames",
};

static const char rx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
	"rx-crc-errors",
	"rx-alignment-errors",
	"rx-in-range-length-errors",
	"rx-out-of-range-length-errors",
	"rx-too-long-frames",
	"rx-runt",
	"rx-very-long-event",
	"rx-symbol-errors",
	"rx-busy-drop-frames",
	"reserved",
	"reserved",
	"rx-mismatch-drop-frames",
	"rx-small-than-64",
	"rx-256-511-frames",
	"rx-512-1023-frames",
	"rx-1024-1518-frames",
	"rx-jumbo-frames",
	"rx-mac-error-loss",
	"rx-pause-frames",
	"reserved",
	"rx-vlan-removed",
	"rx-vlan-replaced",
	"rx-vlan-inserted",
	"rx-ip-checksum-errors",
};

#define UEC_HW_STATS_LEN ARRAY_SIZE(hw_stat_gstrings)
#define UEC_TX_FW_STATS_LEN ARRAY_SIZE(tx_fw_stat_gstrings)
#define UEC_RX_FW_STATS_LEN ARRAY_SIZE(rx_fw_stat_gstrings)

static int
uec_get_ksettings(struct net_device *netdev, struct ethtool_link_ksettings *cmd)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct phy_device *phydev = ugeth->phydev;

	if (!phydev)
		return -ENODEV;

	return phy_ethtool_ksettings_get(phydev, cmd);
}

static int
uec_set_ksettings(struct net_device *netdev,
		  const struct ethtool_link_ksettings *cmd)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct phy_device *phydev = ugeth->phydev;

	if (!phydev)
		return -ENODEV;

	return phy_ethtool_ksettings_set(phydev, cmd);
}

static void
uec_get_pauseparam(struct net_device *netdev,
                     struct ethtool_pauseparam *pause)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);

	pause->autoneg = ugeth->phydev->autoneg;

	if (ugeth->ug_info->receiveFlowControl)
		pause->rx_pause = 1;
	if (ugeth->ug_info->transmitFlowControl)
		pause->tx_pause = 1;
}

static int
uec_set_pauseparam(struct net_device *netdev,
                     struct ethtool_pauseparam *pause)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	int ret = 0;

	ugeth->ug_info->receiveFlowControl = pause->rx_pause;
	ugeth->ug_info->transmitFlowControl = pause->tx_pause;

	if (ugeth->phydev->autoneg) {
		if (netif_running(netdev)) {
			/* FIXME: automatically restart */
			netdev_info(netdev, "Please re-open the interface\n");
		}
	} else {
		struct ucc_geth_info *ug_info = ugeth->ug_info;

		ret = init_flow_control_params(ug_info->aufc,
					ug_info->receiveFlowControl,
					ug_info->transmitFlowControl,
					ug_info->pausePeriod,
					ug_info->extensionField,
					&ugeth->uccf->uf_regs->upsmr,
					&ugeth->ug_regs->uempr,
					&ugeth->ug_regs->maccfg1);
	}

	return ret;
}

static uint32_t
uec_get_msglevel(struct net_device *netdev)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	return ugeth->msg_enable;
}

static void
uec_set_msglevel(struct net_device *netdev, uint32_t data)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	ugeth->msg_enable = data;
}

static int
uec_get_regs_len(struct net_device *netdev)
{
	return sizeof(struct ucc_geth);
}

static void
uec_get_regs(struct net_device *netdev,
               struct ethtool_regs *regs, void *p)
{
	int i;
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	u32 __iomem *ug_regs = (u32 __iomem *)ugeth->ug_regs;
	u32 *buff = p;

	for (i = 0; i < sizeof(struct ucc_geth) / sizeof(u32); i++)
		buff[i] = in_be32(&ug_regs[i]);
}

static void
uec_get_ringparam(struct net_device *netdev,
                    struct ethtool_ringparam *ring)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct ucc_geth_info *ug_info = ugeth->ug_info;
	int queue = 0;

	ring->rx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	ring->rx_mini_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	ring->rx_jumbo_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	ring->tx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;

	ring->rx_pending = ug_info->bdRingLenRx[queue];
	ring->rx_mini_pending = ug_info->bdRingLenRx[queue];
	ring->rx_jumbo_pending = ug_info->bdRingLenRx[queue];
	ring->tx_pending = ug_info->bdRingLenTx[queue];
}

static int
uec_set_ringparam(struct net_device *netdev,
                    struct ethtool_ringparam *ring)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct ucc_geth_info *ug_info = ugeth->ug_info;
	int queue = 0, ret = 0;

	if (ring->rx_pending < UCC_GETH_RX_BD_RING_SIZE_MIN) {
		netdev_info(netdev, "RxBD ring size must be no smaller than %d\n",
			    UCC_GETH_RX_BD_RING_SIZE_MIN);
		return -EINVAL;
	}
	if (ring->rx_pending % UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT) {
		netdev_info(netdev, "RxBD ring size must be multiple of %d\n",
			    UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT);
		return -EINVAL;
	}
	if (ring->tx_pending < UCC_GETH_TX_BD_RING_SIZE_MIN) {
		netdev_info(netdev, "TxBD ring size must be no smaller than %d\n",
			    UCC_GETH_TX_BD_RING_SIZE_MIN);
		return -EINVAL;
	}

	ug_info->bdRingLenRx[queue] = ring->rx_pending;
	ug_info->bdRingLenTx[queue] = ring->tx_pending;

	if (netif_running(netdev)) {
		/* FIXME: restart automatically */
		netdev_info(netdev, "Please re-open the interface\n");
	}

	return ret;
}

static int uec_get_sset_count(struct net_device *netdev, int sset)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	u32 stats_mode = ugeth->ug_info->statisticsMode;
	int len = 0;

	switch (sset) {
	case ETH_SS_STATS:
		if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE)
			len += UEC_HW_STATS_LEN;
		if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX)
			len += UEC_TX_FW_STATS_LEN;
		if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
			len += UEC_RX_FW_STATS_LEN;

		return len;

	default:
		return -EOPNOTSUPP;
	}
}

static void uec_get_strings(struct net_device *netdev, u32 stringset, u8 *buf)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	u32 stats_mode = ugeth->ug_info->statisticsMode;

	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
		memcpy(buf, hw_stat_gstrings, UEC_HW_STATS_LEN *
			       	ETH_GSTRING_LEN);
		buf += UEC_HW_STATS_LEN * ETH_GSTRING_LEN;
	}
	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
		memcpy(buf, tx_fw_stat_gstrings, UEC_TX_FW_STATS_LEN *
			       	ETH_GSTRING_LEN);
		buf += UEC_TX_FW_STATS_LEN * ETH_GSTRING_LEN;
	}
	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
		memcpy(buf, rx_fw_stat_gstrings, UEC_RX_FW_STATS_LEN *
			       	ETH_GSTRING_LEN);
}

static void uec_get_ethtool_stats(struct net_device *netdev,
		struct ethtool_stats *stats, uint64_t *data)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	u32 stats_mode = ugeth->ug_info->statisticsMode;
	u32 __iomem *base;
	int i, j = 0;

	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
		if (ugeth->ug_regs)
			base = (u32 __iomem *)&ugeth->ug_regs->tx64;
		else
			base = NULL;

		for (i = 0; i < UEC_HW_STATS_LEN; i++)
			data[j++] = base ? in_be32(&base[i]) : 0;
	}
	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
		base = (u32 __iomem *)ugeth->p_tx_fw_statistics_pram;
		for (i = 0; i < UEC_TX_FW_STATS_LEN; i++)
			data[j++] = base ? in_be32(&base[i]) : 0;
	}
	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX) {
		base = (u32 __iomem *)ugeth->p_rx_fw_statistics_pram;
		for (i = 0; i < UEC_RX_FW_STATS_LEN; i++)
			data[j++] = base ? in_be32(&base[i]) : 0;
	}
}

/* Report driver information */
static void
uec_get_drvinfo(struct net_device *netdev,
                       struct ethtool_drvinfo *drvinfo)
{
	strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
	strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
	strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
	strlcpy(drvinfo->bus_info, "QUICC ENGINE", sizeof(drvinfo->bus_info));
}

#ifdef CONFIG_PM

static void uec_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct phy_device *phydev = ugeth->phydev;

	if (phydev && phydev->irq)
		wol->supported |= WAKE_PHY;
	if (qe_alive_during_sleep())
		wol->supported |= WAKE_MAGIC;

	wol->wolopts = ugeth->wol_en;
}

static int uec_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
{
	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	struct phy_device *phydev = ugeth->phydev;

	if (wol->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
		return -EINVAL;
	else if (wol->wolopts & WAKE_PHY && (!phydev || !phydev->irq))
		return -EINVAL;
	else if (wol->wolopts & WAKE_MAGIC && !qe_alive_during_sleep())
		return -EINVAL;

	ugeth->wol_en = wol->wolopts;
	device_set_wakeup_enable(&netdev->dev, ugeth->wol_en);

	return 0;
}

#else
#define uec_get_wol NULL
#define uec_set_wol NULL
#endif /* CONFIG_PM */

static const struct ethtool_ops uec_ethtool_ops = {
	.get_drvinfo            = uec_get_drvinfo,
	.get_regs_len           = uec_get_regs_len,
	.get_regs               = uec_get_regs,
	.get_msglevel           = uec_get_msglevel,
	.set_msglevel           = uec_set_msglevel,
	.nway_reset             = phy_ethtool_nway_reset,
	.get_link               = ethtool_op_get_link,
	.get_ringparam          = uec_get_ringparam,
	.set_ringparam          = uec_set_ringparam,
	.get_pauseparam         = uec_get_pauseparam,
	.set_pauseparam         = uec_set_pauseparam,
	.get_sset_count		= uec_get_sset_count,
	.get_strings            = uec_get_strings,
	.get_ethtool_stats      = uec_get_ethtool_stats,
	.get_wol		= uec_get_wol,
	.set_wol		= uec_set_wol,
	.get_ts_info		= ethtool_op_get_ts_info,
	.get_link_ksettings	= uec_get_ksettings,
	.set_link_ksettings	= uec_set_ksettings,
};

void uec_set_ethtool_ops(struct net_device *netdev)
{
	netdev->ethtool_ops = &uec_ethtool_ops;
}
Commit	Line	Data
ac421852 LY	1	/*
	2	* Copyright (c) 2007 Freescale Semiconductor, Inc. All rights reserved.
	3	*
	4	* Description: QE UCC Gigabit Ethernet Ethtool API Set
	5	*
	6	* Author: Li Yang <leoli@freescale.com>
	7	*
7d2e3cb7	8	* Limitation:
70f23fd6	9	* Can only get/set settings of the first queue.
98a1708d	10	* Need to re-open the interface manually after changing some parameters.
ac421852 LY	11	*
	12	* This program is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by the
	14	* Free Software Foundation; either version 2 of the License, or (at your
	15	* option) any later version.
	16	*/
	17
	18	#include <linux/kernel.h>
ac421852	19	#include <linux/errno.h>
ac421852 LY	20	#include <linux/stddef.h>
	21	#include <linux/interrupt.h>
	22	#include <linux/netdevice.h>
	23	#include <linux/etherdevice.h>
	24	#include <linux/skbuff.h>
	25	#include <linux/spinlock.h>
	26	#include <linux/mm.h>
	27	#include <linux/delay.h>
	28	#include <linux/dma-mapping.h>
ac421852 LY	29	#include <linux/ethtool.h>
	30	#include <linux/mii.h>
	31	#include <linux/phy.h>
	32
	33	#include <asm/io.h>
	34	#include <asm/irq.h>
7c0f6ba6	35	#include <linux/uaccess.h>
ac421852	36	#include <asm/types.h>
ac421852 LY	37
ac421852 LY	38	#include "ucc_geth.h"
ac421852	39
c84d8055	40	static const char hw_stat_gstrings[][ETH_GSTRING_LEN] = {
ac421852 LY	41	"tx-64-frames",
	42	"tx-65-127-frames",
	43	"tx-128-255-frames",
	44	"rx-64-frames",
	45	"rx-65-127-frames",
	46	"rx-128-255-frames",
	47	"tx-bytes-ok",
	48	"tx-pause-frames",
	49	"tx-multicast-frames",
	50	"tx-broadcast-frames",
	51	"rx-frames",
	52	"rx-bytes-ok",
	53	"rx-bytes-all",
	54	"rx-multicast-frames",
	55	"rx-broadcast-frames",
	56	"stats-counter-carry",
	57	"stats-counter-mask",
	58	"rx-dropped-frames",
	59	};
	60
c84d8055	61	static const char tx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
ac421852 LY	62	"tx-single-collision",
	63	"tx-multiple-collision",
	64	"tx-late-collsion",
	65	"tx-aborted-frames",
	66	"tx-lost-frames",
	67	"tx-carrier-sense-errors",
	68	"tx-frames-ok",
	69	"tx-excessive-differ-frames",
	70	"tx-256-511-frames",
08722bc4	71	"tx-512-1023-frames",
ac421852 LY	72	"tx-1024-1518-frames",
	73	"tx-jumbo-frames",
	74	};
	75
c84d8055	76	static const char rx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
ac421852 LY	77	"rx-crc-errors",
	78	"rx-alignment-errors",
	79	"rx-in-range-length-errors",
	80	"rx-out-of-range-length-errors",
	81	"rx-too-long-frames",
	82	"rx-runt",
	83	"rx-very-long-event",
	84	"rx-symbol-errors",
	85	"rx-busy-drop-frames",
	86	"reserved",
	87	"reserved",
	88	"rx-mismatch-drop-frames",
	89	"rx-small-than-64",
	90	"rx-256-511-frames",
	91	"rx-512-1023-frames",
	92	"rx-1024-1518-frames",
	93	"rx-jumbo-frames",
	94	"rx-mac-error-loss",
	95	"rx-pause-frames",
	96	"reserved",
	97	"rx-vlan-removed",
	98	"rx-vlan-replaced",
	99	"rx-vlan-inserted",
	100	"rx-ip-checksum-errors",
	101	};
	102
	103	#define UEC_HW_STATS_LEN ARRAY_SIZE(hw_stat_gstrings)
	104	#define UEC_TX_FW_STATS_LEN ARRAY_SIZE(tx_fw_stat_gstrings)
	105	#define UEC_RX_FW_STATS_LEN ARRAY_SIZE(rx_fw_stat_gstrings)
	106
ac421852	107	static int
5e74bf2d	108	uec_get_ksettings(struct net_device netdev, struct ethtool_link_ksettings cmd)
ac421852 LY	109	{
	110	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	111	struct phy_device *phydev = ugeth->phydev;
ac421852 LY	112
	113	if (!phydev)
	114	return -ENODEV;
	115
5e74bf2d	116	return phy_ethtool_ksettings_get(phydev, cmd);
ac421852 LY	117	}
	118
	119	static int
5e74bf2d PR	120	uec_set_ksettings(struct net_device *netdev,
5e74bf2d PR	121	const struct ethtool_link_ksettings *cmd)
ac421852 LY	122	{
	123	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	124	struct phy_device *phydev = ugeth->phydev;
	125
	126	if (!phydev)
	127	return -ENODEV;
	128
5e74bf2d	129	return phy_ethtool_ksettings_set(phydev, cmd);
ac421852 LY	130	}
	131
	132	static void
	133	uec_get_pauseparam(struct net_device *netdev,
	134	struct ethtool_pauseparam *pause)
	135	{
	136	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	137
	138	pause->autoneg = ugeth->phydev->autoneg;
	139
	140	if (ugeth->ug_info->receiveFlowControl)
	141	pause->rx_pause = 1;
	142	if (ugeth->ug_info->transmitFlowControl)
	143	pause->tx_pause = 1;
	144	}
	145
	146	static int
	147	uec_set_pauseparam(struct net_device *netdev,
	148	struct ethtool_pauseparam *pause)
	149	{
	150	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	151	int ret = 0;
	152
	153	ugeth->ug_info->receiveFlowControl = pause->rx_pause;
	154	ugeth->ug_info->transmitFlowControl = pause->tx_pause;
7d2e3cb7	155
ac421852 LY	156	if (ugeth->phydev->autoneg) {
	157	if (netif_running(netdev)) {
	158	/* FIXME: automatically restart */
c84d8055	159	netdev_info(netdev, "Please re-open the interface\n");
ac421852 LY	160	}
	161	} else {
	162	struct ucc_geth_info *ug_info = ugeth->ug_info;
	163
	164	ret = init_flow_control_params(ug_info->aufc,
	165	ug_info->receiveFlowControl,
	166	ug_info->transmitFlowControl,
	167	ug_info->pausePeriod,
	168	ug_info->extensionField,
	169	&ugeth->uccf->uf_regs->upsmr,
	170	&ugeth->ug_regs->uempr,
	171	&ugeth->ug_regs->maccfg1);
	172	}
	173
	174	return ret;
	175	}
	176
	177	static uint32_t
	178	uec_get_msglevel(struct net_device *netdev)
	179	{
	180	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	181	return ugeth->msg_enable;
	182	}
	183
	184	static void
	185	uec_set_msglevel(struct net_device *netdev, uint32_t data)
	186	{
	187	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	188	ugeth->msg_enable = data;
	189	}
	190
	191	static int
	192	uec_get_regs_len(struct net_device *netdev)
	193	{
	194	return sizeof(struct ucc_geth);
	195	}
	196
	197	static void
	198	uec_get_regs(struct net_device *netdev,
	199	struct ethtool_regs regs, void p)
	200	{
	201	int i;
	202	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	203	u32 __iomem ug_regs = (u32 __iomem )ugeth->ug_regs;
	204	u32 *buff = p;
	205
	206	for (i = 0; i < sizeof(struct ucc_geth) / sizeof(u32); i++)
	207	buff[i] = in_be32(&ug_regs[i]);
	208	}
	209
	210	static void
	211	uec_get_ringparam(struct net_device *netdev,
	212	struct ethtool_ringparam *ring)
	213	{
	214	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	215	struct ucc_geth_info *ug_info = ugeth->ug_info;
	216	int queue = 0;
	217
	218	ring->rx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	219	ring->rx_mini_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	220	ring->rx_jumbo_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	221	ring->tx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
	222
	223	ring->rx_pending = ug_info->bdRingLenRx[queue];
224	ring->rx_mini_pending = ug_info->bdRingLenRx[queue];
225	ring->rx_jumbo_pending = ug_info->bdRingLenRx[queue];
226	ring->tx_pending = ug_info->bdRingLenTx[queue];
227	}
228
229	static int
230	uec_set_ringparam(struct net_device *netdev,
231	struct ethtool_ringparam *ring)
232	{
233	struct ucc_geth_private *ugeth = netdev_priv(netdev);
234	struct ucc_geth_info *ug_info = ugeth->ug_info;
235	int queue = 0, ret = 0;
236
237	if (ring->rx_pending < UCC_GETH_RX_BD_RING_SIZE_MIN) {
c84d8055 JP	238	netdev_info(netdev, "RxBD ring size must be no smaller than %d\n",
c84d8055 JP	239	UCC_GETH_RX_BD_RING_SIZE_MIN);
ac421852 LY	240	return -EINVAL;
	241	}
	242	if (ring->rx_pending % UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT) {
c84d8055 JP	243	netdev_info(netdev, "RxBD ring size must be multiple of %d\n",
c84d8055 JP	244	UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT);
ac421852 LY	245	return -EINVAL;
	246	}
	247	if (ring->tx_pending < UCC_GETH_TX_BD_RING_SIZE_MIN) {
c84d8055 JP	248	netdev_info(netdev, "TxBD ring size must be no smaller than %d\n",
c84d8055 JP	249	UCC_GETH_TX_BD_RING_SIZE_MIN);
ac421852 LY	250	return -EINVAL;
	251	}
	252
	253	ug_info->bdRingLenRx[queue] = ring->rx_pending;
	254	ug_info->bdRingLenTx[queue] = ring->tx_pending;
	255
	256	if (netif_running(netdev)) {
	257	/* FIXME: restart automatically */
c84d8055	258	netdev_info(netdev, "Please re-open the interface\n");
ac421852 LY	259	}
	260
	261	return ret;
	262	}
	263
b9f2c044	264	static int uec_get_sset_count(struct net_device *netdev, int sset)
ac421852 LY	265	{
	266	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	267	u32 stats_mode = ugeth->ug_info->statisticsMode;
	268	int len = 0;
	269
b9f2c044 JG	270	switch (sset) {
	271	case ETH_SS_STATS:
	272	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE)
	273	len += UEC_HW_STATS_LEN;
	274	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX)
	275	len += UEC_TX_FW_STATS_LEN;
	276	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
	277	len += UEC_RX_FW_STATS_LEN;
	278
	279	return len;
ac421852	280
b9f2c044 JG	281	default:
	282	return -EOPNOTSUPP;
	283	}
ac421852 LY	284	}
	285
	286	static void uec_get_strings(struct net_device netdev, u32 stringset, u8 buf)
	287	{
	288	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	289	u32 stats_mode = ugeth->ug_info->statisticsMode;
	290
	291	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
	292	memcpy(buf, hw_stat_gstrings, UEC_HW_STATS_LEN *
	293	ETH_GSTRING_LEN);
	294	buf += UEC_HW_STATS_LEN * ETH_GSTRING_LEN;
	295	}
	296	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
	297	memcpy(buf, tx_fw_stat_gstrings, UEC_TX_FW_STATS_LEN *
	298	ETH_GSTRING_LEN);
	299	buf += UEC_TX_FW_STATS_LEN * ETH_GSTRING_LEN;
	300	}
	301	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
25f03dcf	302	memcpy(buf, rx_fw_stat_gstrings, UEC_RX_FW_STATS_LEN *
ac421852 LY	303	ETH_GSTRING_LEN);
	304	}
	305
	306	static void uec_get_ethtool_stats(struct net_device *netdev,
	307	struct ethtool_stats stats, uint64_t data)
	308	{
	309	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	310	u32 stats_mode = ugeth->ug_info->statisticsMode;
	311	u32 __iomem *base;
	312	int i, j = 0;
	313
	314	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
e0ad2cd8 AV	315	if (ugeth->ug_regs)
	316	base = (u32 __iomem *)&ugeth->ug_regs->tx64;
	317	else
	318	base = NULL;
	319
ac421852	320	for (i = 0; i < UEC_HW_STATS_LEN; i++)
e0ad2cd8	321	data[j++] = base ? in_be32(&base[i]) : 0;
ac421852 LY	322	}
	323	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
	324	base = (u32 __iomem *)ugeth->p_tx_fw_statistics_pram;
	325	for (i = 0; i < UEC_TX_FW_STATS_LEN; i++)
18acfa25	326	data[j++] = base ? in_be32(&base[i]) : 0;
ac421852 LY	327	}
	328	if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX) {
	329	base = (u32 __iomem *)ugeth->p_rx_fw_statistics_pram;
	330	for (i = 0; i < UEC_RX_FW_STATS_LEN; i++)
18acfa25	331	data[j++] = base ? in_be32(&base[i]) : 0;
ac421852 LY	332	}
	333	}
	334
ac421852 LY	335	/* Report driver information */
	336	static void
	337	uec_get_drvinfo(struct net_device *netdev,
	338	struct ethtool_drvinfo *drvinfo)
	339	{
7826d43f JP	340	strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
	341	strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
	342	strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
	343	strlcpy(drvinfo->bus_info, "QUICC ENGINE", sizeof(drvinfo->bus_info));
ac421852 LY	344	}
ac421852 LY	345
2394905f AV	346	#ifdef CONFIG_PM
	347
	348	static void uec_get_wol(struct net_device netdev, struct ethtool_wolinfo wol)
	349	{
	350	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	351	struct phy_device *phydev = ugeth->phydev;
	352
	353	if (phydev && phydev->irq)
	354	wol->supported \|= WAKE_PHY;
	355	if (qe_alive_during_sleep())
	356	wol->supported \|= WAKE_MAGIC;
	357
	358	wol->wolopts = ugeth->wol_en;
	359	}
	360
	361	static int uec_set_wol(struct net_device netdev, struct ethtool_wolinfo wol)
	362	{
	363	struct ucc_geth_private *ugeth = netdev_priv(netdev);
	364	struct phy_device *phydev = ugeth->phydev;
	365
	366	if (wol->wolopts & ~(WAKE_PHY \| WAKE_MAGIC))
	367	return -EINVAL;
	368	else if (wol->wolopts & WAKE_PHY && (!phydev \|\| !phydev->irq))
	369	return -EINVAL;
	370	else if (wol->wolopts & WAKE_MAGIC && !qe_alive_during_sleep())
	371	return -EINVAL;
	372
	373	ugeth->wol_en = wol->wolopts;
	374	device_set_wakeup_enable(&netdev->dev, ugeth->wol_en);
	375
	376	return 0;
	377	}
	378
	379	#else
	380	#define uec_get_wol NULL
	381	#define uec_set_wol NULL
	382	#endif /* CONFIG_PM */
	383
ac421852	384	static const struct ethtool_ops uec_ethtool_ops = {
ac421852 LY	385	.get_drvinfo = uec_get_drvinfo,
	386	.get_regs_len = uec_get_regs_len,
	387	.get_regs = uec_get_regs,
	388	.get_msglevel = uec_get_msglevel,
	389	.set_msglevel = uec_set_msglevel,
e06986fa	390	.nway_reset = phy_ethtool_nway_reset,
ac421852 LY	391	.get_link = ethtool_op_get_link,
	392	.get_ringparam = uec_get_ringparam,
	393	.set_ringparam = uec_set_ringparam,
	394	.get_pauseparam = uec_get_pauseparam,
	395	.set_pauseparam = uec_set_pauseparam,
b9f2c044	396	.get_sset_count = uec_get_sset_count,
ac421852 LY	397	.get_strings = uec_get_strings,
ac421852 LY	398	.get_ethtool_stats = uec_get_ethtool_stats,
2394905f AV	399	.get_wol = uec_get_wol,
2394905f AV	400	.set_wol = uec_set_wol,
e117d6dd	401	.get_ts_info = ethtool_op_get_ts_info,
5e74bf2d PR	402	.get_link_ksettings = uec_get_ksettings,
5e74bf2d PR	403	.set_link_ksettings = uec_set_ksettings,
ac421852 LY	404	};
	405
	406	void uec_set_ethtool_ops(struct net_device *netdev)
	407	{
7ad24ea4	408	netdev->ethtool_ops = &uec_ethtool_ops;
ac421852	409	}