PageRenderTime 70ms CodeModel.GetById 14ms app.highlight 50ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/ethernet/qlogic/qlge/qlge_ethtool.c

http://github.com/mirrors/linux
C | 728 lines | 610 code | 74 blank | 44 comment | 69 complexity | 327df11cbd4cc839f274a6ec0d578190 MD5 | raw file
  1#include <linux/kernel.h>
  2#include <linux/types.h>
  3#include <linux/module.h>
  4#include <linux/list.h>
  5#include <linux/pci.h>
  6#include <linux/dma-mapping.h>
  7#include <linux/pagemap.h>
  8#include <linux/sched.h>
  9#include <linux/dmapool.h>
 10#include <linux/mempool.h>
 11#include <linux/spinlock.h>
 12#include <linux/kthread.h>
 13#include <linux/interrupt.h>
 14#include <linux/errno.h>
 15#include <linux/ioport.h>
 16#include <linux/in.h>
 17#include <linux/ip.h>
 18#include <linux/ipv6.h>
 19#include <net/ipv6.h>
 20#include <linux/tcp.h>
 21#include <linux/udp.h>
 22#include <linux/if_arp.h>
 23#include <linux/if_ether.h>
 24#include <linux/netdevice.h>
 25#include <linux/etherdevice.h>
 26#include <linux/ethtool.h>
 27#include <linux/skbuff.h>
 28#include <linux/rtnetlink.h>
 29#include <linux/if_vlan.h>
 30#include <linux/delay.h>
 31#include <linux/mm.h>
 32#include <linux/vmalloc.h>
 33
 34
 35#include "qlge.h"
 36
 37struct ql_stats {
 38	char stat_string[ETH_GSTRING_LEN];
 39	int sizeof_stat;
 40	int stat_offset;
 41};
 42
 43#define QL_SIZEOF(m) FIELD_SIZEOF(struct ql_adapter, m)
 44#define QL_OFF(m) offsetof(struct ql_adapter, m)
 45
 46static const struct ql_stats ql_gstrings_stats[] = {
 47	{"tx_pkts", QL_SIZEOF(nic_stats.tx_pkts), QL_OFF(nic_stats.tx_pkts)},
 48	{"tx_bytes", QL_SIZEOF(nic_stats.tx_bytes), QL_OFF(nic_stats.tx_bytes)},
 49	{"tx_mcast_pkts", QL_SIZEOF(nic_stats.tx_mcast_pkts),
 50					QL_OFF(nic_stats.tx_mcast_pkts)},
 51	{"tx_bcast_pkts", QL_SIZEOF(nic_stats.tx_bcast_pkts),
 52					QL_OFF(nic_stats.tx_bcast_pkts)},
 53	{"tx_ucast_pkts", QL_SIZEOF(nic_stats.tx_ucast_pkts),
 54					QL_OFF(nic_stats.tx_ucast_pkts)},
 55	{"tx_ctl_pkts", QL_SIZEOF(nic_stats.tx_ctl_pkts),
 56					QL_OFF(nic_stats.tx_ctl_pkts)},
 57	{"tx_pause_pkts", QL_SIZEOF(nic_stats.tx_pause_pkts),
 58					QL_OFF(nic_stats.tx_pause_pkts)},
 59	{"tx_64_pkts", QL_SIZEOF(nic_stats.tx_64_pkt),
 60					QL_OFF(nic_stats.tx_64_pkt)},
 61	{"tx_65_to_127_pkts", QL_SIZEOF(nic_stats.tx_65_to_127_pkt),
 62					QL_OFF(nic_stats.tx_65_to_127_pkt)},
 63	{"tx_128_to_255_pkts", QL_SIZEOF(nic_stats.tx_128_to_255_pkt),
 64					QL_OFF(nic_stats.tx_128_to_255_pkt)},
 65	{"tx_256_511_pkts", QL_SIZEOF(nic_stats.tx_256_511_pkt),
 66					QL_OFF(nic_stats.tx_256_511_pkt)},
 67	{"tx_512_to_1023_pkts",	QL_SIZEOF(nic_stats.tx_512_to_1023_pkt),
 68					QL_OFF(nic_stats.tx_512_to_1023_pkt)},
 69	{"tx_1024_to_1518_pkts", QL_SIZEOF(nic_stats.tx_1024_to_1518_pkt),
 70					QL_OFF(nic_stats.tx_1024_to_1518_pkt)},
 71	{"tx_1519_to_max_pkts",	QL_SIZEOF(nic_stats.tx_1519_to_max_pkt),
 72					QL_OFF(nic_stats.tx_1519_to_max_pkt)},
 73	{"tx_undersize_pkts", QL_SIZEOF(nic_stats.tx_undersize_pkt),
 74					QL_OFF(nic_stats.tx_undersize_pkt)},
 75	{"tx_oversize_pkts", QL_SIZEOF(nic_stats.tx_oversize_pkt),
 76					QL_OFF(nic_stats.tx_oversize_pkt)},
 77	{"rx_bytes", QL_SIZEOF(nic_stats.rx_bytes), QL_OFF(nic_stats.rx_bytes)},
 78	{"rx_bytes_ok",	QL_SIZEOF(nic_stats.rx_bytes_ok),
 79					QL_OFF(nic_stats.rx_bytes_ok)},
 80	{"rx_pkts", QL_SIZEOF(nic_stats.rx_pkts), QL_OFF(nic_stats.rx_pkts)},
 81	{"rx_pkts_ok", QL_SIZEOF(nic_stats.rx_pkts_ok),
 82					QL_OFF(nic_stats.rx_pkts_ok)},
 83	{"rx_bcast_pkts", QL_SIZEOF(nic_stats.rx_bcast_pkts),
 84					QL_OFF(nic_stats.rx_bcast_pkts)},
 85	{"rx_mcast_pkts", QL_SIZEOF(nic_stats.rx_mcast_pkts),
 86					QL_OFF(nic_stats.rx_mcast_pkts)},
 87	{"rx_ucast_pkts", QL_SIZEOF(nic_stats.rx_ucast_pkts),
 88					QL_OFF(nic_stats.rx_ucast_pkts)},
 89	{"rx_undersize_pkts", QL_SIZEOF(nic_stats.rx_undersize_pkts),
 90					QL_OFF(nic_stats.rx_undersize_pkts)},
 91	{"rx_oversize_pkts", QL_SIZEOF(nic_stats.rx_oversize_pkts),
 92					QL_OFF(nic_stats.rx_oversize_pkts)},
 93	{"rx_jabber_pkts", QL_SIZEOF(nic_stats.rx_jabber_pkts),
 94					QL_OFF(nic_stats.rx_jabber_pkts)},
 95	{"rx_undersize_fcerr_pkts",
 96		QL_SIZEOF(nic_stats.rx_undersize_fcerr_pkts),
 97				QL_OFF(nic_stats.rx_undersize_fcerr_pkts)},
 98	{"rx_drop_events", QL_SIZEOF(nic_stats.rx_drop_events),
 99					QL_OFF(nic_stats.rx_drop_events)},
100	{"rx_fcerr_pkts", QL_SIZEOF(nic_stats.rx_fcerr_pkts),
101					QL_OFF(nic_stats.rx_fcerr_pkts)},
102	{"rx_align_err", QL_SIZEOF(nic_stats.rx_align_err),
103					QL_OFF(nic_stats.rx_align_err)},
104	{"rx_symbol_err", QL_SIZEOF(nic_stats.rx_symbol_err),
105					QL_OFF(nic_stats.rx_symbol_err)},
106	{"rx_mac_err", QL_SIZEOF(nic_stats.rx_mac_err),
107					QL_OFF(nic_stats.rx_mac_err)},
108	{"rx_ctl_pkts",	QL_SIZEOF(nic_stats.rx_ctl_pkts),
109					QL_OFF(nic_stats.rx_ctl_pkts)},
110	{"rx_pause_pkts", QL_SIZEOF(nic_stats.rx_pause_pkts),
111					QL_OFF(nic_stats.rx_pause_pkts)},
112	{"rx_64_pkts", QL_SIZEOF(nic_stats.rx_64_pkts),
113					QL_OFF(nic_stats.rx_64_pkts)},
114	{"rx_65_to_127_pkts", QL_SIZEOF(nic_stats.rx_65_to_127_pkts),
115					QL_OFF(nic_stats.rx_65_to_127_pkts)},
116	{"rx_128_255_pkts", QL_SIZEOF(nic_stats.rx_128_255_pkts),
117					QL_OFF(nic_stats.rx_128_255_pkts)},
118	{"rx_256_511_pkts", QL_SIZEOF(nic_stats.rx_256_511_pkts),
119					QL_OFF(nic_stats.rx_256_511_pkts)},
120	{"rx_512_to_1023_pkts",	QL_SIZEOF(nic_stats.rx_512_to_1023_pkts),
121					QL_OFF(nic_stats.rx_512_to_1023_pkts)},
122	{"rx_1024_to_1518_pkts", QL_SIZEOF(nic_stats.rx_1024_to_1518_pkts),
123					QL_OFF(nic_stats.rx_1024_to_1518_pkts)},
124	{"rx_1519_to_max_pkts",	QL_SIZEOF(nic_stats.rx_1519_to_max_pkts),
125					QL_OFF(nic_stats.rx_1519_to_max_pkts)},
126	{"rx_len_err_pkts", QL_SIZEOF(nic_stats.rx_len_err_pkts),
127					QL_OFF(nic_stats.rx_len_err_pkts)},
128	{"rx_code_err",	QL_SIZEOF(nic_stats.rx_code_err),
129					QL_OFF(nic_stats.rx_code_err)},
130	{"rx_oversize_err", QL_SIZEOF(nic_stats.rx_oversize_err),
131					QL_OFF(nic_stats.rx_oversize_err)},
132	{"rx_undersize_err", QL_SIZEOF(nic_stats.rx_undersize_err),
133					QL_OFF(nic_stats.rx_undersize_err)},
134	{"rx_preamble_err", QL_SIZEOF(nic_stats.rx_preamble_err),
135					QL_OFF(nic_stats.rx_preamble_err)},
136	{"rx_frame_len_err", QL_SIZEOF(nic_stats.rx_frame_len_err),
137					QL_OFF(nic_stats.rx_frame_len_err)},
138	{"rx_crc_err", QL_SIZEOF(nic_stats.rx_crc_err),
139					QL_OFF(nic_stats.rx_crc_err)},
140	{"rx_err_count", QL_SIZEOF(nic_stats.rx_err_count),
141					QL_OFF(nic_stats.rx_err_count)},
142	{"tx_cbfc_pause_frames0", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames0),
143				QL_OFF(nic_stats.tx_cbfc_pause_frames0)},
144	{"tx_cbfc_pause_frames1", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames1),
145				QL_OFF(nic_stats.tx_cbfc_pause_frames1)},
146	{"tx_cbfc_pause_frames2", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames2),
147				QL_OFF(nic_stats.tx_cbfc_pause_frames2)},
148	{"tx_cbfc_pause_frames3", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames3),
149				QL_OFF(nic_stats.tx_cbfc_pause_frames3)},
150	{"tx_cbfc_pause_frames4", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames4),
151				QL_OFF(nic_stats.tx_cbfc_pause_frames4)},
152	{"tx_cbfc_pause_frames5", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames5),
153				QL_OFF(nic_stats.tx_cbfc_pause_frames5)},
154	{"tx_cbfc_pause_frames6", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames6),
155				QL_OFF(nic_stats.tx_cbfc_pause_frames6)},
156	{"tx_cbfc_pause_frames7", QL_SIZEOF(nic_stats.tx_cbfc_pause_frames7),
157				QL_OFF(nic_stats.tx_cbfc_pause_frames7)},
158	{"rx_cbfc_pause_frames0", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames0),
159				QL_OFF(nic_stats.rx_cbfc_pause_frames0)},
160	{"rx_cbfc_pause_frames1", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames1),
161				QL_OFF(nic_stats.rx_cbfc_pause_frames1)},
162	{"rx_cbfc_pause_frames2", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames2),
163				QL_OFF(nic_stats.rx_cbfc_pause_frames2)},
164	{"rx_cbfc_pause_frames3", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames3),
165				QL_OFF(nic_stats.rx_cbfc_pause_frames3)},
166	{"rx_cbfc_pause_frames4", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames4),
167				QL_OFF(nic_stats.rx_cbfc_pause_frames4)},
168	{"rx_cbfc_pause_frames5", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames5),
169				QL_OFF(nic_stats.rx_cbfc_pause_frames5)},
170	{"rx_cbfc_pause_frames6", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames6),
171				QL_OFF(nic_stats.rx_cbfc_pause_frames6)},
172	{"rx_cbfc_pause_frames7", QL_SIZEOF(nic_stats.rx_cbfc_pause_frames7),
173				QL_OFF(nic_stats.rx_cbfc_pause_frames7)},
174	{"rx_nic_fifo_drop", QL_SIZEOF(nic_stats.rx_nic_fifo_drop),
175					QL_OFF(nic_stats.rx_nic_fifo_drop)},
176};
177
178static const char ql_gstrings_test[][ETH_GSTRING_LEN] = {
179	"Loopback test  (offline)"
180};
181#define QLGE_TEST_LEN (sizeof(ql_gstrings_test) / ETH_GSTRING_LEN)
182#define QLGE_STATS_LEN ARRAY_SIZE(ql_gstrings_stats)
183#define QLGE_RCV_MAC_ERR_STATS	7
184
185static int ql_update_ring_coalescing(struct ql_adapter *qdev)
186{
187	int i, status = 0;
188	struct rx_ring *rx_ring;
189	struct cqicb *cqicb;
190
191	if (!netif_running(qdev->ndev))
192		return status;
193
194	/* Skip the default queue, and update the outbound handler
195	 * queues if they changed.
196	 */
197	cqicb = (struct cqicb *)&qdev->rx_ring[qdev->rss_ring_count];
198	if (le16_to_cpu(cqicb->irq_delay) != qdev->tx_coalesce_usecs ||
199		le16_to_cpu(cqicb->pkt_delay) !=
200				qdev->tx_max_coalesced_frames) {
201		for (i = qdev->rss_ring_count; i < qdev->rx_ring_count; i++) {
202			rx_ring = &qdev->rx_ring[i];
203			cqicb = (struct cqicb *)rx_ring;
204			cqicb->irq_delay = cpu_to_le16(qdev->tx_coalesce_usecs);
205			cqicb->pkt_delay =
206			    cpu_to_le16(qdev->tx_max_coalesced_frames);
207			cqicb->flags = FLAGS_LI;
208			status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
209						CFG_LCQ, rx_ring->cq_id);
210			if (status) {
211				netif_err(qdev, ifup, qdev->ndev,
212					  "Failed to load CQICB.\n");
213				goto exit;
214			}
215		}
216	}
217
218	/* Update the inbound (RSS) handler queues if they changed. */
219	cqicb = (struct cqicb *)&qdev->rx_ring[0];
220	if (le16_to_cpu(cqicb->irq_delay) != qdev->rx_coalesce_usecs ||
221		le16_to_cpu(cqicb->pkt_delay) !=
222					qdev->rx_max_coalesced_frames) {
223		for (i = 0; i < qdev->rss_ring_count; i++, rx_ring++) {
224			rx_ring = &qdev->rx_ring[i];
225			cqicb = (struct cqicb *)rx_ring;
226			cqicb->irq_delay = cpu_to_le16(qdev->rx_coalesce_usecs);
227			cqicb->pkt_delay =
228			    cpu_to_le16(qdev->rx_max_coalesced_frames);
229			cqicb->flags = FLAGS_LI;
230			status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
231						CFG_LCQ, rx_ring->cq_id);
232			if (status) {
233				netif_err(qdev, ifup, qdev->ndev,
234					  "Failed to load CQICB.\n");
235				goto exit;
236			}
237		}
238	}
239exit:
240	return status;
241}
242
243static void ql_update_stats(struct ql_adapter *qdev)
244{
245	u32 i;
246	u64 data;
247	u64 *iter = &qdev->nic_stats.tx_pkts;
248
249	spin_lock(&qdev->stats_lock);
250	if (ql_sem_spinlock(qdev, qdev->xg_sem_mask)) {
251			netif_err(qdev, drv, qdev->ndev,
252				  "Couldn't get xgmac sem.\n");
253		goto quit;
254	}
255	/*
256	 * Get TX statistics.
257	 */
258	for (i = 0x200; i < 0x280; i += 8) {
259		if (ql_read_xgmac_reg64(qdev, i, &data)) {
260			netif_err(qdev, drv, qdev->ndev,
261				  "Error reading status register 0x%.04x.\n",
262				  i);
263			goto end;
264		} else
265			*iter = data;
266		iter++;
267	}
268
269	/*
270	 * Get RX statistics.
271	 */
272	for (i = 0x300; i < 0x3d0; i += 8) {
273		if (ql_read_xgmac_reg64(qdev, i, &data)) {
274			netif_err(qdev, drv, qdev->ndev,
275				  "Error reading status register 0x%.04x.\n",
276				  i);
277			goto end;
278		} else
279			*iter = data;
280		iter++;
281	}
282
283	/* Update receive mac error statistics */
284	iter += QLGE_RCV_MAC_ERR_STATS;
285
286	/*
287	 * Get Per-priority TX pause frame counter statistics.
288	 */
289	for (i = 0x500; i < 0x540; i += 8) {
290		if (ql_read_xgmac_reg64(qdev, i, &data)) {
291			netif_err(qdev, drv, qdev->ndev,
292				  "Error reading status register 0x%.04x.\n",
293				  i);
294			goto end;
295		} else
296			*iter = data;
297		iter++;
298	}
299
300	/*
301	 * Get Per-priority RX pause frame counter statistics.
302	 */
303	for (i = 0x568; i < 0x5a8; i += 8) {
304		if (ql_read_xgmac_reg64(qdev, i, &data)) {
305			netif_err(qdev, drv, qdev->ndev,
306				  "Error reading status register 0x%.04x.\n",
307				  i);
308			goto end;
309		} else
310			*iter = data;
311		iter++;
312	}
313
314	/*
315	 * Get RX NIC FIFO DROP statistics.
316	 */
317	if (ql_read_xgmac_reg64(qdev, 0x5b8, &data)) {
318		netif_err(qdev, drv, qdev->ndev,
319			  "Error reading status register 0x%.04x.\n", i);
320		goto end;
321	} else
322		*iter = data;
323end:
324	ql_sem_unlock(qdev, qdev->xg_sem_mask);
325quit:
326	spin_unlock(&qdev->stats_lock);
327
328	QL_DUMP_STAT(qdev);
329}
330
331static void ql_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
332{
333	int index;
334	switch (stringset) {
335	case ETH_SS_TEST:
336		memcpy(buf, *ql_gstrings_test, QLGE_TEST_LEN * ETH_GSTRING_LEN);
337		break;
338	case ETH_SS_STATS:
339		for (index = 0; index < QLGE_STATS_LEN; index++) {
340			memcpy(buf + index * ETH_GSTRING_LEN,
341				ql_gstrings_stats[index].stat_string,
342				ETH_GSTRING_LEN);
343		}
344		break;
345	}
346}
347
348static int ql_get_sset_count(struct net_device *dev, int sset)
349{
350	switch (sset) {
351	case ETH_SS_TEST:
352		return QLGE_TEST_LEN;
353	case ETH_SS_STATS:
354		return QLGE_STATS_LEN;
355	default:
356		return -EOPNOTSUPP;
357	}
358}
359
360static void
361ql_get_ethtool_stats(struct net_device *ndev,
362		     struct ethtool_stats *stats, u64 *data)
363{
364	struct ql_adapter *qdev = netdev_priv(ndev);
365	int index, length;
366
367	length = QLGE_STATS_LEN;
368	ql_update_stats(qdev);
369
370	for (index = 0; index < length; index++) {
371		char *p = (char *)qdev +
372			ql_gstrings_stats[index].stat_offset;
373		*data++ = (ql_gstrings_stats[index].sizeof_stat ==
374			sizeof(u64)) ? *(u64 *)p : (*(u32 *)p);
375	}
376}
377
378static int ql_get_settings(struct net_device *ndev,
379			      struct ethtool_cmd *ecmd)
380{
381	struct ql_adapter *qdev = netdev_priv(ndev);
382
383	ecmd->supported = SUPPORTED_10000baseT_Full;
384	ecmd->advertising = ADVERTISED_10000baseT_Full;
385	ecmd->transceiver = XCVR_EXTERNAL;
386	if ((qdev->link_status & STS_LINK_TYPE_MASK) ==
387				STS_LINK_TYPE_10GBASET) {
388		ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
389		ecmd->advertising |= (ADVERTISED_TP | ADVERTISED_Autoneg);
390		ecmd->port = PORT_TP;
391		ecmd->autoneg = AUTONEG_ENABLE;
392	} else {
393		ecmd->supported |= SUPPORTED_FIBRE;
394		ecmd->advertising |= ADVERTISED_FIBRE;
395		ecmd->port = PORT_FIBRE;
396	}
397
398	ethtool_cmd_speed_set(ecmd, SPEED_10000);
399	ecmd->duplex = DUPLEX_FULL;
400
401	return 0;
402}
403
404static void ql_get_drvinfo(struct net_device *ndev,
405			   struct ethtool_drvinfo *drvinfo)
406{
407	struct ql_adapter *qdev = netdev_priv(ndev);
408	strlcpy(drvinfo->driver, qlge_driver_name, sizeof(drvinfo->driver));
409	strlcpy(drvinfo->version, qlge_driver_version,
410		sizeof(drvinfo->version));
411	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
412		 "v%d.%d.%d",
413		 (qdev->fw_rev_id & 0x00ff0000) >> 16,
414		 (qdev->fw_rev_id & 0x0000ff00) >> 8,
415		 (qdev->fw_rev_id & 0x000000ff));
416	strlcpy(drvinfo->bus_info, pci_name(qdev->pdev),
417		sizeof(drvinfo->bus_info));
418}
419
420static void ql_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
421{
422	struct ql_adapter *qdev = netdev_priv(ndev);
423	unsigned short ssys_dev = qdev->pdev->subsystem_device;
424
425	/* WOL is only supported for mezz card. */
426	if (ssys_dev == QLGE_MEZZ_SSYS_ID_068 ||
427			ssys_dev == QLGE_MEZZ_SSYS_ID_180) {
428		wol->supported = WAKE_MAGIC;
429		wol->wolopts = qdev->wol;
430	}
431}
432
433static int ql_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
434{
435	struct ql_adapter *qdev = netdev_priv(ndev);
436	unsigned short ssys_dev = qdev->pdev->subsystem_device;
437
438	/* WOL is only supported for mezz card. */
439	if (ssys_dev != QLGE_MEZZ_SSYS_ID_068 &&
440			ssys_dev != QLGE_MEZZ_SSYS_ID_180) {
441		netif_info(qdev, drv, qdev->ndev,
442				"WOL is only supported for mezz card\n");
443		return -EOPNOTSUPP;
444	}
445	if (wol->wolopts & ~WAKE_MAGIC)
446		return -EINVAL;
447	qdev->wol = wol->wolopts;
448
449	netif_info(qdev, drv, qdev->ndev, "Set wol option 0x%x\n", qdev->wol);
450	return 0;
451}
452
453static int ql_set_phys_id(struct net_device *ndev,
454			  enum ethtool_phys_id_state state)
455
456{
457	struct ql_adapter *qdev = netdev_priv(ndev);
458
459	switch (state) {
460	case ETHTOOL_ID_ACTIVE:
461		/* Save the current LED settings */
462		if (ql_mb_get_led_cfg(qdev))
463			return -EIO;
464
465		/* Start blinking */
466		ql_mb_set_led_cfg(qdev, QL_LED_BLINK);
467		return 0;
468
469	case ETHTOOL_ID_INACTIVE:
470		/* Restore LED settings */
471		if (ql_mb_set_led_cfg(qdev, qdev->led_config))
472			return -EIO;
473		return 0;
474
475	default:
476		return -EINVAL;
477	}
478}
479
480static int ql_start_loopback(struct ql_adapter *qdev)
481{
482	if (netif_carrier_ok(qdev->ndev)) {
483		set_bit(QL_LB_LINK_UP, &qdev->flags);
484		netif_carrier_off(qdev->ndev);
485	} else
486		clear_bit(QL_LB_LINK_UP, &qdev->flags);
487	qdev->link_config |= CFG_LOOPBACK_PCS;
488	return ql_mb_set_port_cfg(qdev);
489}
490
491static void ql_stop_loopback(struct ql_adapter *qdev)
492{
493	qdev->link_config &= ~CFG_LOOPBACK_PCS;
494	ql_mb_set_port_cfg(qdev);
495	if (test_bit(QL_LB_LINK_UP, &qdev->flags)) {
496		netif_carrier_on(qdev->ndev);
497		clear_bit(QL_LB_LINK_UP, &qdev->flags);
498	}
499}
500
501static void ql_create_lb_frame(struct sk_buff *skb,
502					unsigned int frame_size)
503{
504	memset(skb->data, 0xFF, frame_size);
505	frame_size &= ~1;
506	memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
507	memset(&skb->data[frame_size / 2 + 10], 0xBE, 1);
508	memset(&skb->data[frame_size / 2 + 12], 0xAF, 1);
509}
510
511void ql_check_lb_frame(struct ql_adapter *qdev,
512					struct sk_buff *skb)
513{
514	unsigned int frame_size = skb->len;
515
516	if ((*(skb->data + 3) == 0xFF) &&
517		(*(skb->data + frame_size / 2 + 10) == 0xBE) &&
518		(*(skb->data + frame_size / 2 + 12) == 0xAF)) {
519			atomic_dec(&qdev->lb_count);
520			return;
521	}
522}
523
524static int ql_run_loopback_test(struct ql_adapter *qdev)
525{
526	int i;
527	netdev_tx_t rc;
528	struct sk_buff *skb;
529	unsigned int size = SMALL_BUF_MAP_SIZE;
530
531	for (i = 0; i < 64; i++) {
532		skb = netdev_alloc_skb(qdev->ndev, size);
533		if (!skb)
534			return -ENOMEM;
535
536		skb->queue_mapping = 0;
537		skb_put(skb, size);
538		ql_create_lb_frame(skb, size);
539		rc = ql_lb_send(skb, qdev->ndev);
540		if (rc != NETDEV_TX_OK)
541			return -EPIPE;
542		atomic_inc(&qdev->lb_count);
543	}
544	/* Give queue time to settle before testing results. */
545	msleep(2);
546	ql_clean_lb_rx_ring(&qdev->rx_ring[0], 128);
547	return atomic_read(&qdev->lb_count) ? -EIO : 0;
548}
549
550static int ql_loopback_test(struct ql_adapter *qdev, u64 *data)
551{
552	*data = ql_start_loopback(qdev);
553	if (*data)
554		goto out;
555	*data = ql_run_loopback_test(qdev);
556out:
557	ql_stop_loopback(qdev);
558	return *data;
559}
560
561static void ql_self_test(struct net_device *ndev,
562				struct ethtool_test *eth_test, u64 *data)
563{
564	struct ql_adapter *qdev = netdev_priv(ndev);
565
566	memset(data, 0, sizeof(u64) * QLGE_TEST_LEN);
567
568	if (netif_running(ndev)) {
569		set_bit(QL_SELFTEST, &qdev->flags);
570		if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
571			/* Offline tests */
572			if (ql_loopback_test(qdev, &data[0]))
573				eth_test->flags |= ETH_TEST_FL_FAILED;
574
575		} else {
576			/* Online tests */
577			data[0] = 0;
578		}
579		clear_bit(QL_SELFTEST, &qdev->flags);
580		/* Give link time to come up after
581		 * port configuration changes.
582		 */
583		msleep_interruptible(4 * 1000);
584	} else {
585		netif_err(qdev, drv, qdev->ndev,
586			  "is down, Loopback test will fail.\n");
587		eth_test->flags |= ETH_TEST_FL_FAILED;
588	}
589}
590
591static int ql_get_regs_len(struct net_device *ndev)
592{
593	struct ql_adapter *qdev = netdev_priv(ndev);
594
595	if (!test_bit(QL_FRC_COREDUMP, &qdev->flags))
596		return sizeof(struct ql_mpi_coredump);
597	else
598		return sizeof(struct ql_reg_dump);
599}
600
601static void ql_get_regs(struct net_device *ndev,
602			struct ethtool_regs *regs, void *p)
603{
604	struct ql_adapter *qdev = netdev_priv(ndev);
605
606	ql_get_dump(qdev, p);
607	qdev->core_is_dumped = 0;
608	if (!test_bit(QL_FRC_COREDUMP, &qdev->flags))
609		regs->len = sizeof(struct ql_mpi_coredump);
610	else
611		regs->len = sizeof(struct ql_reg_dump);
612}
613
614static int ql_get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
615{
616	struct ql_adapter *qdev = netdev_priv(dev);
617
618	c->rx_coalesce_usecs = qdev->rx_coalesce_usecs;
619	c->tx_coalesce_usecs = qdev->tx_coalesce_usecs;
620
621	/* This chip coalesces as follows:
622	 * If a packet arrives, hold off interrupts until
623	 * cqicb->int_delay expires, but if no other packets arrive don't
624	 * wait longer than cqicb->pkt_int_delay. But ethtool doesn't use a
625	 * timer to coalesce on a frame basis.  So, we have to take ethtool's
626	 * max_coalesced_frames value and convert it to a delay in microseconds.
627	 * We do this by using a basic thoughput of 1,000,000 frames per
628	 * second @ (1024 bytes).  This means one frame per usec. So it's a
629	 * simple one to one ratio.
630	 */
631	c->rx_max_coalesced_frames = qdev->rx_max_coalesced_frames;
632	c->tx_max_coalesced_frames = qdev->tx_max_coalesced_frames;
633
634	return 0;
635}
636
637static int ql_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *c)
638{
639	struct ql_adapter *qdev = netdev_priv(ndev);
640
641	/* Validate user parameters. */
642	if (c->rx_coalesce_usecs > qdev->rx_ring_size / 2)
643		return -EINVAL;
644       /* Don't wait more than 10 usec. */
645	if (c->rx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
646		return -EINVAL;
647	if (c->tx_coalesce_usecs > qdev->tx_ring_size / 2)
648		return -EINVAL;
649	if (c->tx_max_coalesced_frames > MAX_INTER_FRAME_WAIT)
650		return -EINVAL;
651
652	/* Verify a change took place before updating the hardware. */
653	if (qdev->rx_coalesce_usecs == c->rx_coalesce_usecs &&
654	    qdev->tx_coalesce_usecs == c->tx_coalesce_usecs &&
655	    qdev->rx_max_coalesced_frames == c->rx_max_coalesced_frames &&
656	    qdev->tx_max_coalesced_frames == c->tx_max_coalesced_frames)
657		return 0;
658
659	qdev->rx_coalesce_usecs = c->rx_coalesce_usecs;
660	qdev->tx_coalesce_usecs = c->tx_coalesce_usecs;
661	qdev->rx_max_coalesced_frames = c->rx_max_coalesced_frames;
662	qdev->tx_max_coalesced_frames = c->tx_max_coalesced_frames;
663
664	return ql_update_ring_coalescing(qdev);
665}
666
667static void ql_get_pauseparam(struct net_device *netdev,
668			struct ethtool_pauseparam *pause)
669{
670	struct ql_adapter *qdev = netdev_priv(netdev);
671
672	ql_mb_get_port_cfg(qdev);
673	if (qdev->link_config & CFG_PAUSE_STD) {
674		pause->rx_pause = 1;
675		pause->tx_pause = 1;
676	}
677}
678
679static int ql_set_pauseparam(struct net_device *netdev,
680			struct ethtool_pauseparam *pause)
681{
682	struct ql_adapter *qdev = netdev_priv(netdev);
683	int status = 0;
684
685	if ((pause->rx_pause) && (pause->tx_pause))
686		qdev->link_config |= CFG_PAUSE_STD;
687	else if (!pause->rx_pause && !pause->tx_pause)
688		qdev->link_config &= ~CFG_PAUSE_STD;
689	else
690		return -EINVAL;
691
692	status = ql_mb_set_port_cfg(qdev);
693	return status;
694}
695
696static u32 ql_get_msglevel(struct net_device *ndev)
697{
698	struct ql_adapter *qdev = netdev_priv(ndev);
699	return qdev->msg_enable;
700}
701
702static void ql_set_msglevel(struct net_device *ndev, u32 value)
703{
704	struct ql_adapter *qdev = netdev_priv(ndev);
705	qdev->msg_enable = value;
706}
707
708const struct ethtool_ops qlge_ethtool_ops = {
709	.get_settings = ql_get_settings,
710	.get_drvinfo = ql_get_drvinfo,
711	.get_wol = ql_get_wol,
712	.set_wol = ql_set_wol,
713	.get_regs_len	= ql_get_regs_len,
714	.get_regs = ql_get_regs,
715	.get_msglevel = ql_get_msglevel,
716	.set_msglevel = ql_set_msglevel,
717	.get_link = ethtool_op_get_link,
718	.set_phys_id		 = ql_set_phys_id,
719	.self_test		 = ql_self_test,
720	.get_pauseparam		 = ql_get_pauseparam,
721	.set_pauseparam		 = ql_set_pauseparam,
722	.get_coalesce = ql_get_coalesce,
723	.set_coalesce = ql_set_coalesce,
724	.get_sset_count = ql_get_sset_count,
725	.get_strings = ql_get_strings,
726	.get_ethtool_stats = ql_get_ethtool_stats,
727};
728