[net-next-2.6.git] / drivers / net / stmmac / stmmac_ethtool.c

/*******************************************************************************
  STMMAC Ethtool support

  Copyright (C) 2007-2009  STMicroelectronics Ltd

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
*******************************************************************************/

#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/phy.h>

#include "stmmac.h"

#define REG_SPACE_SIZE	0x1054
#define MAC100_ETHTOOL_NAME	"st_mac100"
#define GMAC_ETHTOOL_NAME	"st_gmac"

struct stmmac_stats {
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
	int stat_offset;
};

#define STMMAC_STAT(m)	\
	{ #m, FIELD_SIZEOF(struct stmmac_extra_stats, m),	\
	offsetof(struct stmmac_priv, xstats.m)}

static const struct  stmmac_stats stmmac_gstrings_stats[] = {
	STMMAC_STAT(tx_underflow),
	STMMAC_STAT(tx_carrier),
	STMMAC_STAT(tx_losscarrier),
	STMMAC_STAT(tx_heartbeat),
	STMMAC_STAT(tx_deferred),
	STMMAC_STAT(tx_vlan),
	STMMAC_STAT(rx_vlan),
	STMMAC_STAT(tx_jabber),
	STMMAC_STAT(tx_frame_flushed),
	STMMAC_STAT(tx_payload_error),
	STMMAC_STAT(tx_ip_header_error),
	STMMAC_STAT(rx_desc),
	STMMAC_STAT(rx_partial),
	STMMAC_STAT(rx_runt),
	STMMAC_STAT(rx_toolong),
	STMMAC_STAT(rx_collision),
	STMMAC_STAT(rx_crc),
	STMMAC_STAT(rx_lenght),
	STMMAC_STAT(rx_mii),
	STMMAC_STAT(rx_multicast),
	STMMAC_STAT(rx_gmac_overflow),
	STMMAC_STAT(rx_watchdog),
	STMMAC_STAT(da_rx_filter_fail),
	STMMAC_STAT(sa_rx_filter_fail),
	STMMAC_STAT(rx_missed_cntr),
	STMMAC_STAT(rx_overflow_cntr),
	STMMAC_STAT(tx_undeflow_irq),
	STMMAC_STAT(tx_process_stopped_irq),
	STMMAC_STAT(tx_jabber_irq),
	STMMAC_STAT(rx_overflow_irq),
	STMMAC_STAT(rx_buf_unav_irq),
	STMMAC_STAT(rx_process_stopped_irq),
	STMMAC_STAT(rx_watchdog_irq),
	STMMAC_STAT(tx_early_irq),
	STMMAC_STAT(fatal_bus_error_irq),
	STMMAC_STAT(threshold),
	STMMAC_STAT(tx_pkt_n),
	STMMAC_STAT(rx_pkt_n),
	STMMAC_STAT(poll_n),
	STMMAC_STAT(sched_timer_n),
	STMMAC_STAT(normal_irq_n),
};
#define STMMAC_STATS_LEN ARRAY_SIZE(stmmac_gstrings_stats)

void stmmac_ethtool_getdrvinfo(struct net_device *dev,
			       struct ethtool_drvinfo *info)
{
	struct stmmac_priv *priv = netdev_priv(dev);

	if (!priv->is_gmac)
		strcpy(info->driver, MAC100_ETHTOOL_NAME);
	else
		strcpy(info->driver, GMAC_ETHTOOL_NAME);

	strcpy(info->version, DRV_MODULE_VERSION);
	info->fw_version[0] = '\0';
	info->n_stats = STMMAC_STATS_LEN;
	return;
}

int stmmac_ethtool_getsettings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	struct phy_device *phy = priv->phydev;
	int rc;
	if (phy == NULL) {
		pr_err("%s: %s: PHY is not registered\n",
		       __func__, dev->name);
		return -ENODEV;
	}
	if (!netif_running(dev)) {
		pr_err("%s: interface is disabled: we cannot track "
		"link speed / duplex setting\n", dev->name);
		return -EBUSY;
	}
	cmd->transceiver = XCVR_INTERNAL;
	spin_lock_irq(&priv->lock);
	rc = phy_ethtool_gset(phy, cmd);
	spin_unlock_irq(&priv->lock);
	return rc;
}

int stmmac_ethtool_setsettings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	struct phy_device *phy = priv->phydev;
	int rc;

	spin_lock(&priv->lock);
	rc = phy_ethtool_sset(phy, cmd);
	spin_unlock(&priv->lock);

	return rc;
}

u32 stmmac_ethtool_getmsglevel(struct net_device *dev)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	return priv->msg_enable;
}

void stmmac_ethtool_setmsglevel(struct net_device *dev, u32 level)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	priv->msg_enable = level;

}

int stmmac_check_if_running(struct net_device *dev)
{
	if (!netif_running(dev))
		return -EBUSY;
	return 0;
}

int stmmac_ethtool_get_regs_len(struct net_device *dev)
{
	return REG_SPACE_SIZE;
}

void stmmac_ethtool_gregs(struct net_device *dev,
			  struct ethtool_regs *regs, void *space)
{
	int i;
	u32 *reg_space = (u32 *) space;

	struct stmmac_priv *priv = netdev_priv(dev);

	memset(reg_space, 0x0, REG_SPACE_SIZE);

	if (!priv->is_gmac) {
		/* MAC registers */
		for (i = 0; i < 12; i++)
			reg_space[i] = readl(dev->base_addr + (i * 4));
		/* DMA registers */
		for (i = 0; i < 9; i++)
			reg_space[i + 12] =
			    readl(dev->base_addr + (DMA_BUS_MODE + (i * 4)));
		reg_space[22] = readl(dev->base_addr + DMA_CUR_TX_BUF_ADDR);
		reg_space[23] = readl(dev->base_addr + DMA_CUR_RX_BUF_ADDR);
	} else {
		/* MAC registers */
		for (i = 0; i < 55; i++)
			reg_space[i] = readl(dev->base_addr + (i * 4));
		/* DMA registers */
		for (i = 0; i < 22; i++)
			reg_space[i + 55] =
			    readl(dev->base_addr + (DMA_BUS_MODE + (i * 4)));
	}

	return;
}

int stmmac_ethtool_set_tx_csum(struct net_device *netdev, u32 data)
{
	if (data)
		netdev->features |= NETIF_F_HW_CSUM;
	else
		netdev->features &= ~NETIF_F_HW_CSUM;

	return 0;
}

u32 stmmac_ethtool_get_rx_csum(struct net_device *dev)
{
	struct stmmac_priv *priv = netdev_priv(dev);

	return priv->rx_csum;
}

static void
stmmac_get_pauseparam(struct net_device *netdev,
		      struct ethtool_pauseparam *pause)
{
	struct stmmac_priv *priv = netdev_priv(netdev);

	spin_lock(&priv->lock);

	pause->rx_pause = 0;
	pause->tx_pause = 0;
	pause->autoneg = priv->phydev->autoneg;

	if (priv->flow_ctrl & FLOW_RX)
		pause->rx_pause = 1;
	if (priv->flow_ctrl & FLOW_TX)
		pause->tx_pause = 1;

	spin_unlock(&priv->lock);
	return;
}

static int
stmmac_set_pauseparam(struct net_device *netdev,
		      struct ethtool_pauseparam *pause)
{
	struct stmmac_priv *priv = netdev_priv(netdev);
	struct phy_device *phy = priv->phydev;
	int new_pause = FLOW_OFF;
	int ret = 0;

	spin_lock(&priv->lock);

	if (pause->rx_pause)
		new_pause |= FLOW_RX;
	if (pause->tx_pause)
		new_pause |= FLOW_TX;

	priv->flow_ctrl = new_pause;

	if (phy->autoneg) {
		if (netif_running(netdev)) {
			struct ethtool_cmd cmd;
			/* auto-negotiation automatically restarted */
			cmd.cmd = ETHTOOL_NWAY_RST;
			cmd.supported = phy->supported;
			cmd.advertising = phy->advertising;
			cmd.autoneg = phy->autoneg;
			cmd.speed = phy->speed;
			cmd.duplex = phy->duplex;
			cmd.phy_address = phy->addr;
			ret = phy_ethtool_sset(phy, &cmd);
		}
	} else {
		unsigned long ioaddr = netdev->base_addr;
		priv->mac_type->ops->flow_ctrl(ioaddr, phy->duplex,
					       priv->flow_ctrl, priv->pause);
	}
	spin_unlock(&priv->lock);
	return ret;
}

static void stmmac_get_ethtool_stats(struct net_device *dev,
				 struct ethtool_stats *dummy, u64 *data)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	unsigned long ioaddr = dev->base_addr;
	int i;

	/* Update HW stats if supported */
	priv->mac_type->ops->dma_diagnostic_fr(&dev->stats, &priv->xstats,
					       ioaddr);

	for (i = 0; i < STMMAC_STATS_LEN; i++) {
		char *p = (char *)priv + stmmac_gstrings_stats[i].stat_offset;
		data[i] = (stmmac_gstrings_stats[i].sizeof_stat ==
		sizeof(u64)) ? (*(u64 *)p) : (*(u32 *)p);
	}

	return;
}

static int stmmac_get_sset_count(struct net_device *netdev, int sset)
{
	switch (sset) {
	case ETH_SS_STATS:
		return STMMAC_STATS_LEN;
	default:
		return -EOPNOTSUPP;
	}
}

static void stmmac_get_strings(struct net_device *dev, u32 stringset, u8 *data)
{
	int i;
	u8 *p = data;

	switch (stringset) {
	case ETH_SS_STATS:
		for (i = 0; i < STMMAC_STATS_LEN; i++) {
			memcpy(p, stmmac_gstrings_stats[i].stat_string,
				ETH_GSTRING_LEN);
			p += ETH_GSTRING_LEN;
		}
		break;
	default:
		WARN_ON(1);
		break;
	}
	return;
}

/* Currently only support WOL through Magic packet. */
static void stmmac_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
{
	struct stmmac_priv *priv = netdev_priv(dev);

	spin_lock_irq(&priv->lock);
	if (priv->wolenabled == PMT_SUPPORTED) {
		wol->supported = WAKE_MAGIC;
		wol->wolopts = priv->wolopts;
	}
	spin_unlock_irq(&priv->lock);
}

static int stmmac_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
{
	struct stmmac_priv *priv = netdev_priv(dev);
	u32 support = WAKE_MAGIC;

	if (priv->wolenabled == PMT_NOT_SUPPORTED)
		return -EINVAL;

	if (wol->wolopts & ~support)
		return -EINVAL;

	if (wol->wolopts == 0)
		device_set_wakeup_enable(priv->device, 0);
	else
		device_set_wakeup_enable(priv->device, 1);

	spin_lock_irq(&priv->lock);
	priv->wolopts = wol->wolopts;
	spin_unlock_irq(&priv->lock);

	return 0;
}

static struct ethtool_ops stmmac_ethtool_ops = {
	.begin = stmmac_check_if_running,
	.get_drvinfo = stmmac_ethtool_getdrvinfo,
	.get_settings = stmmac_ethtool_getsettings,
	.set_settings = stmmac_ethtool_setsettings,
	.get_msglevel = stmmac_ethtool_getmsglevel,
	.set_msglevel = stmmac_ethtool_setmsglevel,
	.get_regs = stmmac_ethtool_gregs,
	.get_regs_len = stmmac_ethtool_get_regs_len,
	.get_link = ethtool_op_get_link,
	.get_rx_csum = stmmac_ethtool_get_rx_csum,
	.get_tx_csum = ethtool_op_get_tx_csum,
	.set_tx_csum = stmmac_ethtool_set_tx_csum,
	.get_sg = ethtool_op_get_sg,
	.set_sg = ethtool_op_set_sg,
	.get_pauseparam = stmmac_get_pauseparam,
	.set_pauseparam = stmmac_set_pauseparam,
	.get_ethtool_stats = stmmac_get_ethtool_stats,
	.get_strings = stmmac_get_strings,
	.get_wol = stmmac_get_wol,
	.set_wol = stmmac_set_wol,
	.get_sset_count	= stmmac_get_sset_count,
#ifdef NETIF_F_TSO
	.get_tso = ethtool_op_get_tso,
	.set_tso = ethtool_op_set_tso,
#endif
};

void stmmac_set_ethtool_ops(struct net_device *netdev)
{
	SET_ETHTOOL_OPS(netdev, &stmmac_ethtool_ops);
}
Commit	Line	Data
47dd7a54 GC	1	/*******************************************************************************
	2	STMMAC Ethtool support
	3
	4	Copyright (C) 2007-2009 STMicroelectronics Ltd
	5
	6	This program is free software; you can redistribute it and/or modify it
	7	under the terms and conditions of the GNU General Public License,
	8	version 2, as published by the Free Software Foundation.
	9
	10	This program is distributed in the hope it will be useful, but WITHOUT
	11	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	more details.
	14
	15	You should have received a copy of the GNU General Public License along with
	16	this program; if not, write to the Free Software Foundation, Inc.,
	17	51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	18
	19	The full GNU General Public License is included in this distribution in
	20	the file called "COPYING".
	21
	22	Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
	23	*******************************************************************************/
	24
	25	#include <linux/etherdevice.h>
	26	#include <linux/ethtool.h>
	27	#include <linux/mii.h>
	28	#include <linux/phy.h>
	29
	30	#include "stmmac.h"
	31
	32	#define REG_SPACE_SIZE 0x1054
	33	#define MAC100_ETHTOOL_NAME "st_mac100"
	34	#define GMAC_ETHTOOL_NAME "st_gmac"
	35
	36	struct stmmac_stats {
	37	char stat_string[ETH_GSTRING_LEN];
	38	int sizeof_stat;
	39	int stat_offset;
	40	};
	41
	42	#define STMMAC_STAT(m) \
	43	{ #m, FIELD_SIZEOF(struct stmmac_extra_stats, m), \
	44	offsetof(struct stmmac_priv, xstats.m)}
	45
	46	static const struct stmmac_stats stmmac_gstrings_stats[] = {
	47	STMMAC_STAT(tx_underflow),
	48	STMMAC_STAT(tx_carrier),
	49	STMMAC_STAT(tx_losscarrier),
	50	STMMAC_STAT(tx_heartbeat),
	51	STMMAC_STAT(tx_deferred),
	52	STMMAC_STAT(tx_vlan),
	53	STMMAC_STAT(rx_vlan),
	54	STMMAC_STAT(tx_jabber),
	55	STMMAC_STAT(tx_frame_flushed),
	56	STMMAC_STAT(tx_payload_error),
	57	STMMAC_STAT(tx_ip_header_error),
	58	STMMAC_STAT(rx_desc),
	59	STMMAC_STAT(rx_partial),
	60	STMMAC_STAT(rx_runt),
	61	STMMAC_STAT(rx_toolong),
	62	STMMAC_STAT(rx_collision),
	63	STMMAC_STAT(rx_crc),
	64	STMMAC_STAT(rx_lenght),
65	STMMAC_STAT(rx_mii),
66	STMMAC_STAT(rx_multicast),
67	STMMAC_STAT(rx_gmac_overflow),
68	STMMAC_STAT(rx_watchdog),
69	STMMAC_STAT(da_rx_filter_fail),
70	STMMAC_STAT(sa_rx_filter_fail),
71	STMMAC_STAT(rx_missed_cntr),
72	STMMAC_STAT(rx_overflow_cntr),
73	STMMAC_STAT(tx_undeflow_irq),
74	STMMAC_STAT(tx_process_stopped_irq),
75	STMMAC_STAT(tx_jabber_irq),
76	STMMAC_STAT(rx_overflow_irq),
77	STMMAC_STAT(rx_buf_unav_irq),
78	STMMAC_STAT(rx_process_stopped_irq),
79	STMMAC_STAT(rx_watchdog_irq),
80	STMMAC_STAT(tx_early_irq),
81	STMMAC_STAT(fatal_bus_error_irq),
82	STMMAC_STAT(threshold),
83	STMMAC_STAT(tx_pkt_n),
84	STMMAC_STAT(rx_pkt_n),
85	STMMAC_STAT(poll_n),
86	STMMAC_STAT(sched_timer_n),
87	STMMAC_STAT(normal_irq_n),
88	};
89	#define STMMAC_STATS_LEN ARRAY_SIZE(stmmac_gstrings_stats)
90
91	void stmmac_ethtool_getdrvinfo(struct net_device *dev,
92	struct ethtool_drvinfo *info)
93	{
94	struct stmmac_priv *priv = netdev_priv(dev);
95
96	if (!priv->is_gmac)
97	strcpy(info->driver, MAC100_ETHTOOL_NAME);
98	else
99	strcpy(info->driver, GMAC_ETHTOOL_NAME);
100
101	strcpy(info->version, DRV_MODULE_VERSION);
102	info->fw_version[0] = '\0';
103	info->n_stats = STMMAC_STATS_LEN;
104	return;
105	}
106
107	int stmmac_ethtool_getsettings(struct net_device dev, struct ethtool_cmd cmd)
108	{
109	struct stmmac_priv *priv = netdev_priv(dev);
110	struct phy_device *phy = priv->phydev;
111	int rc;
112	if (phy == NULL) {
113	pr_err("%s: %s: PHY is not registered\n",
114	__func__, dev->name);
115	return -ENODEV;
116	}
117	if (!netif_running(dev)) {
118	pr_err("%s: interface is disabled: we cannot track "
119	"link speed / duplex setting\n", dev->name);
120	return -EBUSY;
121	}
122	cmd->transceiver = XCVR_INTERNAL;
123	spin_lock_irq(&priv->lock);
124	rc = phy_ethtool_gset(phy, cmd);
125	spin_unlock_irq(&priv->lock);
126	return rc;
127	}
128
129	int stmmac_ethtool_setsettings(struct net_device dev, struct ethtool_cmd cmd)
130	{
131	struct stmmac_priv *priv = netdev_priv(dev);
132	struct phy_device *phy = priv->phydev;
133	int rc;
134
135	spin_lock(&priv->lock);
136	rc = phy_ethtool_sset(phy, cmd);
137	spin_unlock(&priv->lock);
138
139	return rc;
140	}
141
142	u32 stmmac_ethtool_getmsglevel(struct net_device *dev)
143	{
144	struct stmmac_priv *priv = netdev_priv(dev);
145	return priv->msg_enable;
146	}
147
148	void stmmac_ethtool_setmsglevel(struct net_device *dev, u32 level)
149	{
150	struct stmmac_priv *priv = netdev_priv(dev);
151	priv->msg_enable = level;
152
153	}
154
155	int stmmac_check_if_running(struct net_device *dev)
156	{
157	if (!netif_running(dev))
158	return -EBUSY;
159	return 0;
160	}
161
162	int stmmac_ethtool_get_regs_len(struct net_device *dev)
163	{
164	return REG_SPACE_SIZE;
165	}
166
167	void stmmac_ethtool_gregs(struct net_device *dev,
168	struct ethtool_regs regs, void space)
169	{
170	int i;
171	u32 reg_space = (u32 ) space;
172
173	struct stmmac_priv *priv = netdev_priv(dev);
174
175	memset(reg_space, 0x0, REG_SPACE_SIZE);
176
177	if (!priv->is_gmac) {
178	/* MAC registers */
179	for (i = 0; i < 12; i++)
180	reg_space[i] = readl(dev->base_addr + (i * 4));
181	/* DMA registers */
182	for (i = 0; i < 9; i++)
183	reg_space[i + 12] =
184	readl(dev->base_addr + (DMA_BUS_MODE + (i * 4)));
185	reg_space[22] = readl(dev->base_addr + DMA_CUR_TX_BUF_ADDR);
186	reg_space[23] = readl(dev->base_addr + DMA_CUR_RX_BUF_ADDR);
187	} else {
188	/* MAC registers */
189	for (i = 0; i < 55; i++)
190	reg_space[i] = readl(dev->base_addr + (i * 4));
191	/* DMA registers */
192	for (i = 0; i < 22; i++)
193	reg_space[i + 55] =
194	readl(dev->base_addr + (DMA_BUS_MODE + (i * 4)));
195	}
196
197	return;
198	}
199
200	int stmmac_ethtool_set_tx_csum(struct net_device *netdev, u32 data)
201	{
202	if (data)
203	netdev->features \|= NETIF_F_HW_CSUM;
204	else
205	netdev->features &= ~NETIF_F_HW_CSUM;
206
207	return 0;
208	}
209
210	u32 stmmac_ethtool_get_rx_csum(struct net_device *dev)
211	{
212	struct stmmac_priv *priv = netdev_priv(dev);
213
214	return priv->rx_csum;
215	}
216
217	static void
218	stmmac_get_pauseparam(struct net_device *netdev,
219	struct ethtool_pauseparam *pause)
220	{
221	struct stmmac_priv *priv = netdev_priv(netdev);
222
223	spin_lock(&priv->lock);
224
225	pause->rx_pause = 0;
226	pause->tx_pause = 0;
227	pause->autoneg = priv->phydev->autoneg;
228
229	if (priv->flow_ctrl & FLOW_RX)
230	pause->rx_pause = 1;
231	if (priv->flow_ctrl & FLOW_TX)
232	pause->tx_pause = 1;
233
234	spin_unlock(&priv->lock);
235	return;
236	}
237
238	static int
239	stmmac_set_pauseparam(struct net_device *netdev,
240	struct ethtool_pauseparam *pause)
241	{
242	struct stmmac_priv *priv = netdev_priv(netdev);
243	struct phy_device *phy = priv->phydev;
244	int new_pause = FLOW_OFF;
245	int ret = 0;
246
247	spin_lock(&priv->lock);
248
249	if (pause->rx_pause)
250	new_pause \|= FLOW_RX;
251	if (pause->tx_pause)
252	new_pause \|= FLOW_TX;
253
254	priv->flow_ctrl = new_pause;
255
256	if (phy->autoneg) {
257	if (netif_running(netdev)) {
258	struct ethtool_cmd cmd;
259	/* auto-negotiation automatically restarted */
260	cmd.cmd = ETHTOOL_NWAY_RST;
261	cmd.supported = phy->supported;
262	cmd.advertising = phy->advertising;
263	cmd.autoneg = phy->autoneg;
264	cmd.speed = phy->speed;
265	cmd.duplex = phy->duplex;
266	cmd.phy_address = phy->addr;
267	ret = phy_ethtool_sset(phy, &cmd);
268	}
269	} else {
270	unsigned long ioaddr = netdev->base_addr;
271	priv->mac_type->ops->flow_ctrl(ioaddr, phy->duplex,
272	priv->flow_ctrl, priv->pause);
273	}
274	spin_unlock(&priv->lock);
275	return ret;
276	}
277
278	static void stmmac_get_ethtool_stats(struct net_device *dev,
279	struct ethtool_stats dummy, u64 data)
280	{
281	struct stmmac_priv *priv = netdev_priv(dev);
282	unsigned long ioaddr = dev->base_addr;
283	int i;
284
285	/* Update HW stats if supported */
286	priv->mac_type->ops->dma_diagnostic_fr(&dev->stats, &priv->xstats,
287	ioaddr);
288
289	for (i = 0; i < STMMAC_STATS_LEN; i++) {
290	char p = (char )priv + stmmac_gstrings_stats[i].stat_offset;
291	data[i] = (stmmac_gstrings_stats[i].sizeof_stat ==
292	sizeof(u64)) ? ((u64 )p) : ((u32 )p);
293	}
294
295	return;
296	}
297
298	static int stmmac_get_sset_count(struct net_device *netdev, int sset)
299	{
300	switch (sset) {
301	case ETH_SS_STATS:
302	return STMMAC_STATS_LEN;
303	default:
304	return -EOPNOTSUPP;
305	}
306	}
307
308	static void stmmac_get_strings(struct net_device dev, u32 stringset, u8 data)
309	{
310	int i;
311	u8 *p = data;
312
313	switch (stringset) {
314	case ETH_SS_STATS:
315	for (i = 0; i < STMMAC_STATS_LEN; i++) {
316	memcpy(p, stmmac_gstrings_stats[i].stat_string,
317	ETH_GSTRING_LEN);
318	p += ETH_GSTRING_LEN;
319	}
320	break;
321	default:
322	WARN_ON(1);
323	break;
324	}
325	return;
326	}
327
328	/* Currently only support WOL through Magic packet. */
329	static void stmmac_get_wol(struct net_device dev, struct ethtool_wolinfo wol)
330	{
331	struct stmmac_priv *priv = netdev_priv(dev);
332
333	spin_lock_irq(&priv->lock);
334	if (priv->wolenabled == PMT_SUPPORTED) {
335	wol->supported = WAKE_MAGIC;
336	wol->wolopts = priv->wolopts;
337	}
338	spin_unlock_irq(&priv->lock);
339	}
340
341	static int stmmac_set_wol(struct net_device dev, struct ethtool_wolinfo wol)
342	{
343	struct stmmac_priv *priv = netdev_priv(dev);
344	u32 support = WAKE_MAGIC;
345
346	if (priv->wolenabled == PMT_NOT_SUPPORTED)
347	return -EINVAL;
348
349	if (wol->wolopts & ~support)
350	return -EINVAL;
351
352	if (wol->wolopts == 0)
353	device_set_wakeup_enable(priv->device, 0);
354	else
355	device_set_wakeup_enable(priv->device, 1);
356
357	spin_lock_irq(&priv->lock);
358	priv->wolopts = wol->wolopts;
359	spin_unlock_irq(&priv->lock);
360
361	return 0;
362	}
363
364	static struct ethtool_ops stmmac_ethtool_ops = {
365	.begin = stmmac_check_if_running,
366	.get_drvinfo = stmmac_ethtool_getdrvinfo,
367	.get_settings = stmmac_ethtool_getsettings,
368	.set_settings = stmmac_ethtool_setsettings,
369	.get_msglevel = stmmac_ethtool_getmsglevel,
370	.set_msglevel = stmmac_ethtool_setmsglevel,
371	.get_regs = stmmac_ethtool_gregs,
372	.get_regs_len = stmmac_ethtool_get_regs_len,
373	.get_link = ethtool_op_get_link,
374	.get_rx_csum = stmmac_ethtool_get_rx_csum,
375	.get_tx_csum = ethtool_op_get_tx_csum,
376	.set_tx_csum = stmmac_ethtool_set_tx_csum,
377	.get_sg = ethtool_op_get_sg,
378	.set_sg = ethtool_op_set_sg,
379	.get_pauseparam = stmmac_get_pauseparam,
380	.set_pauseparam = stmmac_set_pauseparam,
381	.get_ethtool_stats = stmmac_get_ethtool_stats,
382	.get_strings = stmmac_get_strings,
383	.get_wol = stmmac_get_wol,
384	.set_wol = stmmac_set_wol,
385	.get_sset_count = stmmac_get_sset_count,
386	#ifdef NETIF_F_TSO
387	.get_tso = ethtool_op_get_tso,
388	.set_tso = ethtool_op_set_tso,
389	#endif
390	};
391
392	void stmmac_set_ethtool_ops(struct net_device *netdev)
393	{
394	SET_ETHTOOL_OPS(netdev, &stmmac_ethtool_ops);
395	}