[net-next-2.6.git] / drivers / net / qlge / qlge_ethtool.c

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/pagemap.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/dmapool.h>
#include <linux/mempool.h>
#include <linux/spinlock.h>
#include <linux/kthread.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <net/ipv6.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/if_arp.h>
#include <linux/if_ether.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/if_vlan.h>
#include <linux/delay.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>


#include "qlge.h"

static int ql_update_ring_coalescing(struct ql_adapter *qdev)
{
	int i, status = 0;
	struct rx_ring *rx_ring;
	struct cqicb *cqicb;

	if (!netif_running(qdev->ndev))
		return status;

	/* Skip the default queue, and update the outbound handler
	 * queues if they changed.
	 */
	cqicb = (struct cqicb *)&qdev->rx_ring[qdev->rss_ring_count];
	if (le16_to_cpu(cqicb->irq_delay) != qdev->tx_coalesce_usecs ||
		le16_to_cpu(cqicb->pkt_delay) !=
				qdev->tx_max_coalesced_frames) {
		for (i = qdev->rss_ring_count; i < qdev->rx_ring_count; i++) {
			rx_ring = &qdev->rx_ring[i];
			cqicb = (struct cqicb *)rx_ring;
			cqicb->irq_delay = cpu_to_le16(qdev->tx_coalesce_usecs);
			cqicb->pkt_delay =
			    cpu_to_le16(qdev->tx_max_coalesced_frames);
			cqicb->flags = FLAGS_LI;
			status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
						CFG_LCQ, rx_ring->cq_id);
			if (status) {
				QPRINTK(qdev, IFUP, ERR,
					"Failed to load CQICB.\n");
				goto exit;
			}
		}
	}

	/* Update the inbound (RSS) handler queues if they changed. */
	cqicb = (struct cqicb *)&qdev->rx_ring[0];
	if (le16_to_cpu(cqicb->irq_delay) != qdev->rx_coalesce_usecs ||
		le16_to_cpu(cqicb->pkt_delay) !=
					qdev->rx_max_coalesced_frames) {
		for (i = 0; i < qdev->rss_ring_count; i++, rx_ring++) {
			rx_ring = &qdev->rx_ring[i];
			cqicb = (struct cqicb *)rx_ring;
			cqicb->irq_delay = cpu_to_le16(qdev->rx_coalesce_usecs);
			cqicb->pkt_delay =
			    cpu_to_le16(qdev->rx_max_coalesced_frames);
			cqicb->flags = FLAGS_LI;
			status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
						CFG_LCQ, rx_ring->cq_id);
			if (status) {
				QPRINTK(qdev, IFUP, ERR,
					"Failed to load CQICB.\n");
				goto exit;
			}
		}
	}
exit:
	return status;
}

static void ql_update_stats(struct ql_adapter *qdev)
{
	u32 i;
	u64 data;
	u64 *iter = &qdev->nic_stats.tx_pkts;

	spin_lock(&qdev->stats_lock);
	if (ql_sem_spinlock(qdev, qdev->xg_sem_mask)) {
			QPRINTK(qdev, DRV, ERR,
				"Couldn't get xgmac sem.\n");
		goto quit;
	}
	/*
	 * Get TX statistics.
	 */
	for (i = 0x200; i < 0x280; i += 8) {
		if (ql_read_xgmac_reg64(qdev, i, &data)) {
			QPRINTK(qdev, DRV, ERR,
				"Error reading status register 0x%.04x.\n", i);
			goto end;
		} else
			*iter = data;
		iter++;
	}

	/*
	 * Get RX statistics.
	 */
	for (i = 0x300; i < 0x3d0; i += 8) {
		if (ql_read_xgmac_reg64(qdev, i, &data)) {
			QPRINTK(qdev, DRV, ERR,
				"Error reading status register 0x%.04x.\n", i);
			goto end;
		} else
			*iter = data;
		iter++;
	}

end:
	ql_sem_unlock(qdev, qdev->xg_sem_mask);
quit:
	spin_unlock(&qdev->stats_lock);

	QL_DUMP_STAT(qdev);

	return;
}

static char ql_stats_str_arr[][ETH_GSTRING_LEN] = {
	{"tx_pkts"},
	{"tx_bytes"},
	{"tx_mcast_pkts"},
	{"tx_bcast_pkts"},
	{"tx_ucast_pkts"},
	{"tx_ctl_pkts"},
	{"tx_pause_pkts"},
	{"tx_64_pkts"},
	{"tx_65_to_127_pkts"},
	{"tx_128_to_255_pkts"},
	{"tx_256_511_pkts"},
	{"tx_512_to_1023_pkts"},
	{"tx_1024_to_1518_pkts"},
	{"tx_1519_to_max_pkts"},
	{"tx_undersize_pkts"},
	{"tx_oversize_pkts"},
	{"rx_bytes"},
	{"rx_bytes_ok"},
	{"rx_pkts"},
	{"rx_pkts_ok"},
	{"rx_bcast_pkts"},
	{"rx_mcast_pkts"},
	{"rx_ucast_pkts"},
	{"rx_undersize_pkts"},
	{"rx_oversize_pkts"},
	{"rx_jabber_pkts"},
	{"rx_undersize_fcerr_pkts"},
	{"rx_drop_events"},
	{"rx_fcerr_pkts"},
	{"rx_align_err"},
	{"rx_symbol_err"},
	{"rx_mac_err"},
	{"rx_ctl_pkts"},
	{"rx_pause_pkts"},
	{"rx_64_pkts"},
	{"rx_65_to_127_pkts"},
	{"rx_128_255_pkts"},
	{"rx_256_511_pkts"},
	{"rx_512_to_1023_pkts"},
	{"rx_1024_to_1518_pkts"},
	{"rx_1519_to_max_pkts"},
	{"rx_len_err_pkts"},
};

static void ql_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
{
	switch (stringset) {
	case ETH_SS_STATS:
		memcpy(buf, ql_stats_str_arr, sizeof(ql_stats_str_arr));
		break;
	}
}

static int ql_get_sset_count(struct net_device *dev, int sset)
{
	switch (sset) {
	case ETH_SS_STATS:
		return ARRAY_SIZE(ql_stats_str_arr);
	default:
		return -EOPNOTSUPP;
	}
}

static void
ql_get_ethtool_stats(struct net_device *ndev,
		     struct ethtool_stats *stats, u64 *data)
{
	struct ql_adapter *qdev = netdev_priv(ndev);
	struct nic_stats *s = &qdev->nic_stats;

	ql_update_stats(qdev);

	*data++ = s->tx_pkts;
	*data++ = s->tx_bytes;
	*data++ = s->tx_mcast_pkts;
	*data++ = s->tx_bcast_pkts;
	*data++ = s->tx_ucast_pkts;
	*data++ = s->tx_ctl_pkts;
	*data++ = s->tx_pause_pkts;
	*data++ = s->tx_64_pkt;
	*data++ = s->tx_65_to_127_pkt;
	*data++ = s->tx_128_to_255_pkt;
	*data++ = s->tx_256_511_pkt;
	*data++ = s->tx_512_to_1023_pkt;
	*data++ = s->tx_1024_to_1518_pkt;
	*data++ = s->tx_1519_to_max_pkt;
	*data++ = s->tx_undersize_pkt;
	*data++ = s->tx_oversize_pkt;
	*data++ = s->rx_bytes;
	*data++ = s->rx_bytes_ok;
	*data++ = s->rx_pkts;
	*data++ = s->rx_pkts_ok;
	*data++ = s->rx_bcast_pkts;
	*data++ = s->rx_mcast_pkts;
	*data++ = s->rx_ucast_pkts;
	*data++ = s->rx_undersize_pkts;
	*data++ = s->rx_oversize_pkts;
	*data++ = s->rx_jabber_pkts;
	*data++ = s->rx_undersize_fcerr_pkts;
	*data++ = s->rx_drop_events;
	*data++ = s->rx_fcerr_pkts;
	*data++ = s->rx_align_err;
	*data++ = s->rx_symbol_err;
	*data++ = s->rx_mac_err;
	*data++ = s->rx_ctl_pkts;
	*data++ = s->rx_pause_pkts;
	*data++ = s->rx_64_pkts;
	*data++ = s->rx_65_to_127_pkts;
	*data++ = s->rx_128_255_pkts;
	*data++ = s->rx_256_511_pkts;
	*data++ = s->rx_512_to_1023_pkts;
	*data++ = s->rx_1024_to_1518_pkts;
	*data++ = s->rx_1519_to_max_pkts;
	*data++ = s->rx_len_err_pkts;
}

static int ql_get_settings(struct net_device *ndev,
			      struct ethtool_cmd *ecmd)
{
	struct ql_adapter *qdev = netdev_priv(ndev);

	ecmd->supported = SUPPORTED_10000baseT_Full;
	ecmd->advertising = ADVERTISED_10000baseT_Full;
	ecmd->autoneg = AUTONEG_ENABLE;
	ecmd->transceiver = XCVR_EXTERNAL;
	if ((qdev->link_status & STS_LINK_TYPE_MASK) ==
				STS_LINK_TYPE_10GBASET) {
		ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
		ecmd->advertising |= (ADVERTISED_TP | ADVERTISED_Autoneg);
		ecmd->port = PORT_TP;
	} else {
		ecmd->supported |= SUPPORTED_FIBRE;
		ecmd->advertising |= ADVERTISED_FIBRE;
		ecmd->port = PORT_FIBRE;
	}

	ecmd->speed = SPEED_10000;
	ecmd->duplex = DUPLEX_FULL;

	return 0;
}

static void ql_get_drvinfo(struct net_device *ndev,
			   struct ethtool_drvinfo *drvinfo)
{
	struct ql_adapter *qdev = netdev_priv(ndev);
	strncpy(drvinfo->driver, qlge_driver_name, 32);
	strncpy(drvinfo->version, qlge_driver_version, 32);
	snprintf(drvinfo->fw_version, 32, "v%d.%d.%d",
		 (qdev->fw_rev_id & 0x00ff0000) >> 16,
		 (qdev->fw_rev_id & 0x0000ff00) >> 8,
		 (qdev->fw_rev_id & 0x000000ff));
	strncpy(drvinfo->bus_info, pci_name(qdev->pdev), 32);
	drvinfo->n_stats = 0;
	drvinfo->testinfo_len = 0;
	drvinfo->regdump_len = 0;
	drvinfo->eedump_len = 0;
}

static int ql_get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
{
	struct ql_adapter *qdev = netdev_priv(dev);

	c->rx_coalesce_usecs = qdev->rx_coalesce_usecs;
	c->tx_coalesce_usecs = qdev->tx_coalesce_usecs;

	/* This chip coalesces as follows:
	 * If a packet arrives, hold off interrupts until
	 * cqicb->int_delay expires, but if no other packets arrive don't
	 * wait longer than cqicb->pkt_int_delay. But ethtool doesn't use a
	 * timer to coalesce on a frame basis.  So, we have to take ethtool's
	 * max_coalesced_frames value and convert it to a delay in microseconds.
	 * We do this by using a basic thoughput of 1,000,000 frames per
	 * second @ (1024 bytes).  This means one frame per usec. So it's a
	 * simple one to one ratio.
	 */
	c->rx_max_coalesced_frames = qdev->rx_max_coalesced_frames;
	c->tx_max_coalesced_frames = qdev->tx_max_coalesced_frames;

	return 0;
}

static int ql_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *c)
{
	struct ql_adapter *qdev = netdev_priv(ndev);

	/* Validate user parameters. */
	if (c->rx_coalesce_usecs > qdev->rx_ring_size / 2)
		return -EINVAL;
       /* Don't wait more than 10 usec. */
	if (c->rx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
		return -EINVAL;
	if (c->tx_coalesce_usecs > qdev->tx_ring_size / 2)
		return -EINVAL;
	if (c->tx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
		return -EINVAL;

	/* Verify a change took place before updating the hardware. */
	if (qdev->rx_coalesce_usecs == c->rx_coalesce_usecs &&
	    qdev->tx_coalesce_usecs == c->tx_coalesce_usecs &&
	    qdev->rx_max_coalesced_frames == c->rx_max_coalesced_frames &&
	    qdev->tx_max_coalesced_frames == c->tx_max_coalesced_frames)
		return 0;

	qdev->rx_coalesce_usecs = c->rx_coalesce_usecs;
	qdev->tx_coalesce_usecs = c->tx_coalesce_usecs;
	qdev->rx_max_coalesced_frames = c->rx_max_coalesced_frames;
	qdev->tx_max_coalesced_frames = c->tx_max_coalesced_frames;

	return ql_update_ring_coalescing(qdev);
}

static u32 ql_get_rx_csum(struct net_device *netdev)
{
	struct ql_adapter *qdev = netdev_priv(netdev);
	return qdev->rx_csum;
}

static int ql_set_rx_csum(struct net_device *netdev, uint32_t data)
{
	struct ql_adapter *qdev = netdev_priv(netdev);
	qdev->rx_csum = data;
	return 0;
}

static int ql_set_tso(struct net_device *ndev, uint32_t data)
{

	if (data) {
		ndev->features |= NETIF_F_TSO;
		ndev->features |= NETIF_F_TSO6;
	} else {
		ndev->features &= ~NETIF_F_TSO;
		ndev->features &= ~NETIF_F_TSO6;
	}
	return 0;
}

static u32 ql_get_msglevel(struct net_device *ndev)
{
	struct ql_adapter *qdev = netdev_priv(ndev);
	return qdev->msg_enable;
}

static void ql_set_msglevel(struct net_device *ndev, u32 value)
{
	struct ql_adapter *qdev = netdev_priv(ndev);
	qdev->msg_enable = value;
}

const struct ethtool_ops qlge_ethtool_ops = {
	.get_settings = ql_get_settings,
	.get_drvinfo = ql_get_drvinfo,
	.get_msglevel = ql_get_msglevel,
	.set_msglevel = ql_set_msglevel,
	.get_link = ethtool_op_get_link,
	.get_rx_csum = ql_get_rx_csum,
	.set_rx_csum = ql_set_rx_csum,
	.get_tx_csum = ethtool_op_get_tx_csum,
	.set_tx_csum = ethtool_op_set_tx_csum,
	.get_sg = ethtool_op_get_sg,
	.set_sg = ethtool_op_set_sg,
	.get_tso = ethtool_op_get_tso,
	.set_tso = ql_set_tso,
	.get_coalesce = ql_get_coalesce,
	.set_coalesce = ql_set_coalesce,
	.get_sset_count = ql_get_sset_count,
	.get_strings = ql_get_strings,
	.get_ethtool_stats = ql_get_ethtool_stats,
};
Commit	Line	Data
c4e84bde RM	1	#include <linux/kernel.h>
	2	#include <linux/init.h>
	3	#include <linux/types.h>
	4	#include <linux/module.h>
	5	#include <linux/list.h>
	6	#include <linux/pci.h>
	7	#include <linux/dma-mapping.h>
	8	#include <linux/pagemap.h>
	9	#include <linux/sched.h>
	10	#include <linux/slab.h>
	11	#include <linux/dmapool.h>
	12	#include <linux/mempool.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/kthread.h>
	15	#include <linux/interrupt.h>
	16	#include <linux/errno.h>
	17	#include <linux/ioport.h>
	18	#include <linux/in.h>
	19	#include <linux/ip.h>
	20	#include <linux/ipv6.h>
	21	#include <net/ipv6.h>
	22	#include <linux/tcp.h>
	23	#include <linux/udp.h>
	24	#include <linux/if_arp.h>
	25	#include <linux/if_ether.h>
	26	#include <linux/netdevice.h>
	27	#include <linux/etherdevice.h>
	28	#include <linux/ethtool.h>
	29	#include <linux/skbuff.h>
	30	#include <linux/rtnetlink.h>
	31	#include <linux/if_vlan.h>
c4e84bde RM	32	#include <linux/delay.h>
	33	#include <linux/mm.h>
	34	#include <linux/vmalloc.h>
	35
c4e84bde RM	36
	37	#include "qlge.h"
	38
	39	static int ql_update_ring_coalescing(struct ql_adapter *qdev)
	40	{
	41	int i, status = 0;
	42	struct rx_ring *rx_ring;
	43	struct cqicb *cqicb;
	44
	45	if (!netif_running(qdev->ndev))
	46	return status;
	47
c4e84bde RM	48	/* Skip the default queue, and update the outbound handler
	49	* queues if they changed.
	50	*/
b2014ff8	51	cqicb = (struct cqicb *)&qdev->rx_ring[qdev->rss_ring_count];
c4e84bde	52	if (le16_to_cpu(cqicb->irq_delay) != qdev->tx_coalesce_usecs \|\|
b2014ff8 RM	53	le16_to_cpu(cqicb->pkt_delay) !=
	54	qdev->tx_max_coalesced_frames) {
	55	for (i = qdev->rss_ring_count; i < qdev->rx_ring_count; i++) {
c4e84bde RM	56	rx_ring = &qdev->rx_ring[i];
c4e84bde RM	57	cqicb = (struct cqicb *)rx_ring;
8306c952	58	cqicb->irq_delay = cpu_to_le16(qdev->tx_coalesce_usecs);
c4e84bde	59	cqicb->pkt_delay =
8306c952	60	cpu_to_le16(qdev->tx_max_coalesced_frames);
c4e84bde	61	cqicb->flags = FLAGS_LI;
e332471c	62	status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
c4e84bde RM	63	CFG_LCQ, rx_ring->cq_id);
	64	if (status) {
	65	QPRINTK(qdev, IFUP, ERR,
	66	"Failed to load CQICB.\n");
	67	goto exit;
	68	}
	69	}
	70	}
	71
	72	/* Update the inbound (RSS) handler queues if they changed. */
b2014ff8	73	cqicb = (struct cqicb *)&qdev->rx_ring[0];
c4e84bde	74	if (le16_to_cpu(cqicb->irq_delay) != qdev->rx_coalesce_usecs \|\|
b2014ff8 RM	75	le16_to_cpu(cqicb->pkt_delay) !=
	76	qdev->rx_max_coalesced_frames) {
	77	for (i = 0; i < qdev->rss_ring_count; i++, rx_ring++) {
c4e84bde RM	78	rx_ring = &qdev->rx_ring[i];
c4e84bde RM	79	cqicb = (struct cqicb *)rx_ring;
8306c952	80	cqicb->irq_delay = cpu_to_le16(qdev->rx_coalesce_usecs);
c4e84bde	81	cqicb->pkt_delay =
8306c952	82	cpu_to_le16(qdev->rx_max_coalesced_frames);
c4e84bde	83	cqicb->flags = FLAGS_LI;
e332471c	84	status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
c4e84bde RM	85	CFG_LCQ, rx_ring->cq_id);
	86	if (status) {
	87	QPRINTK(qdev, IFUP, ERR,
	88	"Failed to load CQICB.\n");
	89	goto exit;
	90	}
	91	}
	92	}
	93	exit:
c4e84bde RM	94	return status;
	95	}
	96
2f22d22e	97	static void ql_update_stats(struct ql_adapter *qdev)
c4e84bde RM	98	{
	99	u32 i;
	100	u64 data;
	101	u64 *iter = &qdev->nic_stats.tx_pkts;
	102
	103	spin_lock(&qdev->stats_lock);
	104	if (ql_sem_spinlock(qdev, qdev->xg_sem_mask)) {
	105	QPRINTK(qdev, DRV, ERR,
	106	"Couldn't get xgmac sem.\n");
	107	goto quit;
	108	}
	109	/*
	110	* Get TX statistics.
	111	*/
	112	for (i = 0x200; i < 0x280; i += 8) {
	113	if (ql_read_xgmac_reg64(qdev, i, &data)) {
	114	QPRINTK(qdev, DRV, ERR,
	115	"Error reading status register 0x%.04x.\n", i);
	116	goto end;
	117	} else
	118	*iter = data;
	119	iter++;
	120	}
	121
	122	/*
	123	* Get RX statistics.
	124	*/
	125	for (i = 0x300; i < 0x3d0; i += 8) {
	126	if (ql_read_xgmac_reg64(qdev, i, &data)) {
	127	QPRINTK(qdev, DRV, ERR,
	128	"Error reading status register 0x%.04x.\n", i);
	129	goto end;
	130	} else
	131	*iter = data;
	132	iter++;
	133	}
	134
	135	end:
	136	ql_sem_unlock(qdev, qdev->xg_sem_mask);
	137	quit:
	138	spin_unlock(&qdev->stats_lock);
	139
	140	QL_DUMP_STAT(qdev);
	141
	142	return;
	143	}
	144
	145	static char ql_stats_str_arr[][ETH_GSTRING_LEN] = {
	146	{"tx_pkts"},
	147	{"tx_bytes"},
	148	{"tx_mcast_pkts"},
	149	{"tx_bcast_pkts"},
	150	{"tx_ucast_pkts"},
	151	{"tx_ctl_pkts"},
	152	{"tx_pause_pkts"},
	153	{"tx_64_pkts"},
	154	{"tx_65_to_127_pkts"},
	155	{"tx_128_to_255_pkts"},
	156	{"tx_256_511_pkts"},
	157	{"tx_512_to_1023_pkts"},
	158	{"tx_1024_to_1518_pkts"},
	159	{"tx_1519_to_max_pkts"},
	160	{"tx_undersize_pkts"},
	161	{"tx_oversize_pkts"},
162	{"rx_bytes"},
163	{"rx_bytes_ok"},
164	{"rx_pkts"},
165	{"rx_pkts_ok"},
166	{"rx_bcast_pkts"},
167	{"rx_mcast_pkts"},
168	{"rx_ucast_pkts"},
169	{"rx_undersize_pkts"},
170	{"rx_oversize_pkts"},
171	{"rx_jabber_pkts"},
172	{"rx_undersize_fcerr_pkts"},
173	{"rx_drop_events"},
174	{"rx_fcerr_pkts"},
175	{"rx_align_err"},
176	{"rx_symbol_err"},
177	{"rx_mac_err"},
178	{"rx_ctl_pkts"},
179	{"rx_pause_pkts"},
180	{"rx_64_pkts"},
181	{"rx_65_to_127_pkts"},
182	{"rx_128_255_pkts"},
183	{"rx_256_511_pkts"},
184	{"rx_512_to_1023_pkts"},
185	{"rx_1024_to_1518_pkts"},
186	{"rx_1519_to_max_pkts"},
187	{"rx_len_err_pkts"},
188	};
189
190	static void ql_get_strings(struct net_device dev, u32 stringset, u8 buf)
191	{
192	switch (stringset) {
193	case ETH_SS_STATS:
194	memcpy(buf, ql_stats_str_arr, sizeof(ql_stats_str_arr));
195	break;
196	}
197	}
198
199	static int ql_get_sset_count(struct net_device *dev, int sset)
200	{
201	switch (sset) {
202	case ETH_SS_STATS:
203	return ARRAY_SIZE(ql_stats_str_arr);
204	default:
205	return -EOPNOTSUPP;
206	}
207	}
208
209	static void
210	ql_get_ethtool_stats(struct net_device *ndev,
211	struct ethtool_stats stats, u64 data)
212	{
213	struct ql_adapter *qdev = netdev_priv(ndev);
214	struct nic_stats *s = &qdev->nic_stats;
215
216	ql_update_stats(qdev);
217
218	*data++ = s->tx_pkts;
219	*data++ = s->tx_bytes;
220	*data++ = s->tx_mcast_pkts;
221	*data++ = s->tx_bcast_pkts;
222	*data++ = s->tx_ucast_pkts;
223	*data++ = s->tx_ctl_pkts;
224	*data++ = s->tx_pause_pkts;
225	*data++ = s->tx_64_pkt;
226	*data++ = s->tx_65_to_127_pkt;
227	*data++ = s->tx_128_to_255_pkt;
228	*data++ = s->tx_256_511_pkt;
229	*data++ = s->tx_512_to_1023_pkt;
230	*data++ = s->tx_1024_to_1518_pkt;
231	*data++ = s->tx_1519_to_max_pkt;
232	*data++ = s->tx_undersize_pkt;
233	*data++ = s->tx_oversize_pkt;
234	*data++ = s->rx_bytes;
235	*data++ = s->rx_bytes_ok;
236	*data++ = s->rx_pkts;
237	*data++ = s->rx_pkts_ok;
238	*data++ = s->rx_bcast_pkts;
239	*data++ = s->rx_mcast_pkts;
240	*data++ = s->rx_ucast_pkts;
241	*data++ = s->rx_undersize_pkts;
242	*data++ = s->rx_oversize_pkts;
243	*data++ = s->rx_jabber_pkts;
244	*data++ = s->rx_undersize_fcerr_pkts;
245	*data++ = s->rx_drop_events;
246	*data++ = s->rx_fcerr_pkts;
247	*data++ = s->rx_align_err;
248	*data++ = s->rx_symbol_err;
249	*data++ = s->rx_mac_err;
250	*data++ = s->rx_ctl_pkts;
251	*data++ = s->rx_pause_pkts;
252	*data++ = s->rx_64_pkts;
253	*data++ = s->rx_65_to_127_pkts;
254	*data++ = s->rx_128_255_pkts;
255	*data++ = s->rx_256_511_pkts;
256	*data++ = s->rx_512_to_1023_pkts;
257	*data++ = s->rx_1024_to_1518_pkts;
258	*data++ = s->rx_1519_to_max_pkts;
259	*data++ = s->rx_len_err_pkts;
260	}
261
262	static int ql_get_settings(struct net_device *ndev,
263	struct ethtool_cmd *ecmd)
264	{
265	struct ql_adapter *qdev = netdev_priv(ndev);
266
267	ecmd->supported = SUPPORTED_10000baseT_Full;
268	ecmd->advertising = ADVERTISED_10000baseT_Full;
269	ecmd->autoneg = AUTONEG_ENABLE;
270	ecmd->transceiver = XCVR_EXTERNAL;
b82808b7 RM	271	if ((qdev->link_status & STS_LINK_TYPE_MASK) ==
b82808b7 RM	272	STS_LINK_TYPE_10GBASET) {
c4e84bde RM	273	ecmd->supported \|= (SUPPORTED_TP \| SUPPORTED_Autoneg);
	274	ecmd->advertising \|= (ADVERTISED_TP \| ADVERTISED_Autoneg);
	275	ecmd->port = PORT_TP;
	276	} else {
	277	ecmd->supported \|= SUPPORTED_FIBRE;
	278	ecmd->advertising \|= ADVERTISED_FIBRE;
	279	ecmd->port = PORT_FIBRE;
	280	}
	281
	282	ecmd->speed = SPEED_10000;
	283	ecmd->duplex = DUPLEX_FULL;
	284
	285	return 0;
	286	}
	287
	288	static void ql_get_drvinfo(struct net_device *ndev,
	289	struct ethtool_drvinfo *drvinfo)
	290	{
	291	struct ql_adapter *qdev = netdev_priv(ndev);
	292	strncpy(drvinfo->driver, qlge_driver_name, 32);
	293	strncpy(drvinfo->version, qlge_driver_version, 32);
cfec0cbc RM	294	snprintf(drvinfo->fw_version, 32, "v%d.%d.%d",
	295	(qdev->fw_rev_id & 0x00ff0000) >> 16,
	296	(qdev->fw_rev_id & 0x0000ff00) >> 8,
	297	(qdev->fw_rev_id & 0x000000ff));
c4e84bde RM	298	strncpy(drvinfo->bus_info, pci_name(qdev->pdev), 32);
	299	drvinfo->n_stats = 0;
	300	drvinfo->testinfo_len = 0;
	301	drvinfo->regdump_len = 0;
	302	drvinfo->eedump_len = 0;
	303	}
	304
	305	static int ql_get_coalesce(struct net_device dev, struct ethtool_coalesce c)
	306	{
	307	struct ql_adapter *qdev = netdev_priv(dev);
	308
	309	c->rx_coalesce_usecs = qdev->rx_coalesce_usecs;
	310	c->tx_coalesce_usecs = qdev->tx_coalesce_usecs;
	311
	312	/* This chip coalesces as follows:
	313	* If a packet arrives, hold off interrupts until
	314	* cqicb->int_delay expires, but if no other packets arrive don't
	315	* wait longer than cqicb->pkt_int_delay. But ethtool doesn't use a
	316	* timer to coalesce on a frame basis. So, we have to take ethtool's
	317	* max_coalesced_frames value and convert it to a delay in microseconds.
	318	* We do this by using a basic thoughput of 1,000,000 frames per
	319	* second @ (1024 bytes). This means one frame per usec. So it's a
	320	* simple one to one ratio.
	321	*/
	322	c->rx_max_coalesced_frames = qdev->rx_max_coalesced_frames;
	323	c->tx_max_coalesced_frames = qdev->tx_max_coalesced_frames;
	324
	325	return 0;
	326	}
	327
	328	static int ql_set_coalesce(struct net_device ndev, struct ethtool_coalesce c)
	329	{
	330	struct ql_adapter *qdev = netdev_priv(ndev);
	331
	332	/* Validate user parameters. */
	333	if (c->rx_coalesce_usecs > qdev->rx_ring_size / 2)
	334	return -EINVAL;
	335	/* Don't wait more than 10 usec. */
	336	if (c->rx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
	337	return -EINVAL;
	338	if (c->tx_coalesce_usecs > qdev->tx_ring_size / 2)
	339	return -EINVAL;
	340	if (c->tx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
	341	return -EINVAL;
	342
	343	/* Verify a change took place before updating the hardware. */
	344	if (qdev->rx_coalesce_usecs == c->rx_coalesce_usecs &&
	345	qdev->tx_coalesce_usecs == c->tx_coalesce_usecs &&
	346	qdev->rx_max_coalesced_frames == c->rx_max_coalesced_frames &&
	347	qdev->tx_max_coalesced_frames == c->tx_max_coalesced_frames)
	348	return 0;
	349
	350	qdev->rx_coalesce_usecs = c->rx_coalesce_usecs;
	351	qdev->tx_coalesce_usecs = c->tx_coalesce_usecs;
	352	qdev->rx_max_coalesced_frames = c->rx_max_coalesced_frames;
	353	qdev->tx_max_coalesced_frames = c->tx_max_coalesced_frames;
	354
	355	return ql_update_ring_coalescing(qdev);
	356	}
	357
	358	static u32 ql_get_rx_csum(struct net_device *netdev)
	359	{
	360	struct ql_adapter *qdev = netdev_priv(netdev);
	361	return qdev->rx_csum;
362	}
363
364	static int ql_set_rx_csum(struct net_device *netdev, uint32_t data)
365	{
366	struct ql_adapter *qdev = netdev_priv(netdev);
367	qdev->rx_csum = data;
368	return 0;
369	}
370
371	static int ql_set_tso(struct net_device *ndev, uint32_t data)
372	{
373
374	if (data) {
375	ndev->features \|= NETIF_F_TSO;
376	ndev->features \|= NETIF_F_TSO6;
377	} else {
378	ndev->features &= ~NETIF_F_TSO;
379	ndev->features &= ~NETIF_F_TSO6;
380	}
381	return 0;
382	}
383
384	static u32 ql_get_msglevel(struct net_device *ndev)
385	{
386	struct ql_adapter *qdev = netdev_priv(ndev);
387	return qdev->msg_enable;
388	}
389
390	static void ql_set_msglevel(struct net_device *ndev, u32 value)
391	{
392	struct ql_adapter *qdev = netdev_priv(ndev);
393	qdev->msg_enable = value;
394	}
395
396	const struct ethtool_ops qlge_ethtool_ops = {
397	.get_settings = ql_get_settings,
398	.get_drvinfo = ql_get_drvinfo,
399	.get_msglevel = ql_get_msglevel,
400	.set_msglevel = ql_set_msglevel,
401	.get_link = ethtool_op_get_link,
402	.get_rx_csum = ql_get_rx_csum,
403	.set_rx_csum = ql_set_rx_csum,
404	.get_tx_csum = ethtool_op_get_tx_csum,
00acd0d2	405	.set_tx_csum = ethtool_op_set_tx_csum,
c4e84bde RM	406	.get_sg = ethtool_op_get_sg,
	407	.set_sg = ethtool_op_set_sg,
	408	.get_tso = ethtool_op_get_tso,
	409	.set_tso = ql_set_tso,
	410	.get_coalesce = ql_get_coalesce,
	411	.set_coalesce = ql_set_coalesce,
	412	.get_sset_count = ql_get_sset_count,
	413	.get_strings = ql_get_strings,
	414	.get_ethtool_stats = ql_get_ethtool_stats,
	415	};
	416