2 * Copyright (C) 2003 - 2006 NetXen, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
23 * Contact Information:
26 * 3965 Freedom Circle, Fourth floor,
27 * Santa Clara, CA 95054
30 * ethtool support for netxen nic
34 #include <linux/types.h>
35 #include <linux/delay.h>
36 #include <asm/uaccess.h>
37 #include <linux/pci.h>
39 #include <linux/netdevice.h>
40 #include <linux/ethtool.h>
41 #include <linux/version.h>
43 #include "netxen_nic.h"
44 #include "netxen_nic_hw.h"
45 #include "netxen_nic_phan_reg.h"
47 struct netxen_nic_stats {
48 char stat_string[ETH_GSTRING_LEN];
53 #define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
54 offsetof(struct netxen_adapter, m)
56 #define NETXEN_NIC_PORT_WINDOW 0x10000
57 #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
59 static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
60 {"rcvd_bad_skb", NETXEN_NIC_STAT(stats.rcvdbadskb)},
61 {"xmit_called", NETXEN_NIC_STAT(stats.xmitcalled)},
62 {"xmited_frames", NETXEN_NIC_STAT(stats.xmitedframes)},
63 {"xmit_finished", NETXEN_NIC_STAT(stats.xmitfinished)},
64 {"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
65 {"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
66 {"polled", NETXEN_NIC_STAT(stats.polled)},
67 {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
68 {"csummed", NETXEN_NIC_STAT(stats.csummed)},
69 {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
70 {"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
71 {"tx_bytes", NETXEN_NIC_STAT(stats.txbytes)},
74 #define NETXEN_NIC_STATS_LEN ARRAY_SIZE(netxen_nic_gstrings_stats)
76 static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
77 "Register_Test_on_offline",
78 "Link_Test_on_offline"
81 #define NETXEN_NIC_TEST_LEN ARRAY_SIZE(netxen_nic_gstrings_test)
83 #define NETXEN_NIC_REGS_COUNT 42
84 #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
85 #define NETXEN_MAX_EEPROM_LEN 1024
87 static int netxen_nic_get_eeprom_len(struct net_device *dev)
89 return NETXEN_FLASH_TOTAL_SIZE;
93 netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
95 struct netxen_adapter *adapter = netdev_priv(dev);
100 strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
101 strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
102 fw_major = readl(NETXEN_CRB_NORMALIZE(adapter,
103 NETXEN_FW_VERSION_MAJOR));
104 fw_minor = readl(NETXEN_CRB_NORMALIZE(adapter,
105 NETXEN_FW_VERSION_MINOR));
106 fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
107 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
109 strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
110 drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
111 drvinfo->eedump_len = netxen_nic_get_eeprom_len(dev);
115 netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
117 struct netxen_adapter *adapter = netdev_priv(dev);
118 struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
120 /* read which mode */
121 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
122 ecmd->supported = (SUPPORTED_10baseT_Half |
123 SUPPORTED_10baseT_Full |
124 SUPPORTED_100baseT_Half |
125 SUPPORTED_100baseT_Full |
126 SUPPORTED_1000baseT_Half |
127 SUPPORTED_1000baseT_Full);
129 ecmd->advertising = (ADVERTISED_100baseT_Half |
130 ADVERTISED_100baseT_Full |
131 ADVERTISED_1000baseT_Half |
132 ADVERTISED_1000baseT_Full);
134 ecmd->port = PORT_TP;
136 if (netif_running(dev)) {
137 ecmd->speed = adapter->link_speed;
138 ecmd->duplex = adapter->link_duplex;
140 return -EIO; /* link absent */
141 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
142 ecmd->supported = (SUPPORTED_TP |
143 SUPPORTED_1000baseT_Full |
144 SUPPORTED_10000baseT_Full);
145 ecmd->advertising = (ADVERTISED_TP |
146 ADVERTISED_1000baseT_Full |
147 ADVERTISED_10000baseT_Full);
148 ecmd->port = PORT_TP;
150 ecmd->speed = SPEED_10000;
151 ecmd->duplex = DUPLEX_FULL;
152 ecmd->autoneg = AUTONEG_DISABLE;
156 ecmd->phy_address = adapter->portnum;
157 ecmd->transceiver = XCVR_EXTERNAL;
159 switch ((netxen_brdtype_t) boardinfo->board_type) {
160 case NETXEN_BRDTYPE_P2_SB35_4G:
161 case NETXEN_BRDTYPE_P2_SB31_2G:
162 case NETXEN_BRDTYPE_P3_REF_QG:
163 case NETXEN_BRDTYPE_P3_4_GB:
164 case NETXEN_BRDTYPE_P3_4_GB_MM:
165 case NETXEN_BRDTYPE_P3_10000_BASE_T:
167 ecmd->supported |= SUPPORTED_Autoneg;
168 ecmd->advertising |= ADVERTISED_Autoneg;
169 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
170 case NETXEN_BRDTYPE_P3_10G_CX4:
171 case NETXEN_BRDTYPE_P3_10G_CX4_LP:
172 ecmd->supported |= SUPPORTED_TP;
173 ecmd->advertising |= ADVERTISED_TP;
174 ecmd->port = PORT_TP;
175 ecmd->autoneg = (boardinfo->board_type ==
176 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
177 (AUTONEG_DISABLE) : (adapter->link_autoneg);
179 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
180 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
181 case NETXEN_BRDTYPE_P3_IMEZ:
182 case NETXEN_BRDTYPE_P3_XG_LOM:
183 case NETXEN_BRDTYPE_P3_HMEZ:
184 ecmd->supported |= SUPPORTED_MII;
185 ecmd->advertising |= ADVERTISED_MII;
186 ecmd->port = PORT_FIBRE;
187 ecmd->autoneg = AUTONEG_DISABLE;
189 case NETXEN_BRDTYPE_P2_SB31_10G:
190 case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
191 case NETXEN_BRDTYPE_P3_10G_XFP:
192 ecmd->supported |= SUPPORTED_FIBRE;
193 ecmd->advertising |= ADVERTISED_FIBRE;
194 ecmd->port = PORT_FIBRE;
195 ecmd->autoneg = AUTONEG_DISABLE;
198 printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
199 (netxen_brdtype_t) boardinfo->board_type);
207 netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
209 struct netxen_adapter *adapter = netdev_priv(dev);
212 /* read which mode */
213 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
214 /* autonegotiation */
215 if (adapter->phy_write
216 && adapter->phy_write(adapter,
217 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
221 adapter->link_autoneg = ecmd->autoneg;
223 if (adapter->phy_read
224 && adapter->phy_read(adapter,
225 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
230 switch (ecmd->speed) {
232 netxen_set_phy_speed(status, 0);
235 netxen_set_phy_speed(status, 1);
238 netxen_set_phy_speed(status, 2);
241 /* set duplex mode */
242 if (ecmd->duplex == DUPLEX_HALF)
243 netxen_clear_phy_duplex(status);
244 if (ecmd->duplex == DUPLEX_FULL)
245 netxen_set_phy_duplex(status);
246 if (adapter->phy_write
247 && adapter->phy_write(adapter,
248 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
249 *((int *)&status)) != 0)
252 adapter->link_speed = ecmd->speed;
253 adapter->link_duplex = ecmd->duplex;
258 if (netif_running(dev)) {
265 static int netxen_nic_get_regs_len(struct net_device *dev)
267 return NETXEN_NIC_REGS_LEN;
270 struct netxen_niu_regs {
271 __u32 reg[NETXEN_NIC_REGS_COUNT];
274 static struct netxen_niu_regs niu_registers[] = {
278 NETXEN_NIU_GB_SERDES_RESET,
279 NETXEN_NIU_GB0_MII_MODE,
280 NETXEN_NIU_GB1_MII_MODE,
281 NETXEN_NIU_GB2_MII_MODE,
282 NETXEN_NIU_GB3_MII_MODE,
283 NETXEN_NIU_GB0_GMII_MODE,
284 NETXEN_NIU_GB1_GMII_MODE,
285 NETXEN_NIU_GB2_GMII_MODE,
286 NETXEN_NIU_GB3_GMII_MODE,
287 NETXEN_NIU_REMOTE_LOOPBACK,
288 NETXEN_NIU_GB0_HALF_DUPLEX,
289 NETXEN_NIU_GB1_HALF_DUPLEX,
290 NETXEN_NIU_RESET_SYS_FIFOS,
291 NETXEN_NIU_GB_CRC_DROP,
292 NETXEN_NIU_GB_DROP_WRONGADDR,
293 NETXEN_NIU_TEST_MUX_CTL,
295 NETXEN_NIU_GB_MAC_CONFIG_0(0),
296 NETXEN_NIU_GB_MAC_CONFIG_1(0),
297 NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
298 NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
299 NETXEN_NIU_GB_TEST_REG(0),
300 NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
301 NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
302 NETXEN_NIU_GB_MII_MGMT_ADDR(0),
303 NETXEN_NIU_GB_MII_MGMT_CTRL(0),
304 NETXEN_NIU_GB_MII_MGMT_STATUS(0),
305 NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
306 NETXEN_NIU_GB_INTERFACE_CTRL(0),
307 NETXEN_NIU_GB_INTERFACE_STATUS(0),
308 NETXEN_NIU_GB_STATION_ADDR_0(0),
309 NETXEN_NIU_GB_STATION_ADDR_1(0),
316 NETXEN_NIU_XG_SINGLE_TERM,
317 NETXEN_NIU_XG_DRIVE_HI,
318 NETXEN_NIU_XG_DRIVE_LO,
321 NETXEN_NIU_XG_WORD_ALIGN,
323 NETXEN_NIU_XG_POWER_DOWN,
324 NETXEN_NIU_XG_RESET_PLL,
325 NETXEN_NIU_XG_SERDES_LOOPBACK,
326 NETXEN_NIU_XG_DO_BYTE_ALIGN,
327 NETXEN_NIU_XG_TX_ENABLE,
328 NETXEN_NIU_XG_RX_ENABLE,
329 NETXEN_NIU_XG_STATUS,
330 NETXEN_NIU_XG_PAUSE_THRESHOLD,
331 NETXEN_NIU_XGE_CONFIG_0,
332 NETXEN_NIU_XGE_CONFIG_1,
334 NETXEN_NIU_XGE_STATION_ADDR_0_HI,
335 NETXEN_NIU_XGE_STATION_ADDR_0_1,
336 NETXEN_NIU_XGE_STATION_ADDR_1_LO,
337 NETXEN_NIU_XGE_STATUS,
338 NETXEN_NIU_XGE_MAX_FRAME_SIZE,
339 NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
340 NETXEN_NIU_XGE_TX_BYTE_CNT,
341 NETXEN_NIU_XGE_TX_FRAME_CNT,
342 NETXEN_NIU_XGE_RX_BYTE_CNT,
343 NETXEN_NIU_XGE_RX_FRAME_CNT,
344 NETXEN_NIU_XGE_AGGR_ERROR_CNT,
345 NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
346 NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
347 NETXEN_NIU_XGE_CRC_ERROR_CNT,
348 NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
349 NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
350 NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
351 NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
352 NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
353 NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
360 netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
362 struct netxen_adapter *adapter = netdev_priv(dev);
363 __u32 mode, *regs_buff = p;
367 memset(p, 0, NETXEN_NIC_REGS_LEN);
368 regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
369 (adapter->pdev)->device;
371 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, ®s_buff[0]);
374 /* Common registers to all the modes */
375 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER,
378 mode = (mode / 2) - 1;
381 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
382 /* GB: port specific registers */
383 if (mode == 0 && i >= 19)
384 window = adapter->physical_port *
385 NETXEN_NIC_PORT_WINDOW;
387 NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
395 static u32 netxen_nic_test_link(struct net_device *dev)
397 struct netxen_adapter *adapter = netdev_priv(dev);
401 /* read which mode */
402 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
403 if (adapter->phy_read
404 && adapter->phy_read(adapter,
405 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
409 val = netxen_get_phy_link(status);
412 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
413 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
414 return (val == XG_LINK_UP) ? 0 : 1;
420 netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
423 struct netxen_adapter *adapter = netdev_priv(dev);
427 if (eeprom->len == 0)
430 eeprom->magic = (adapter->pdev)->vendor |
431 ((adapter->pdev)->device << 16);
432 offset = eeprom->offset;
434 ret = netxen_rom_fast_read_words(adapter, offset, bytes,
444 netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
447 struct netxen_adapter *adapter = netdev_priv(dev);
448 int offset = eeprom->offset;
449 static int flash_start;
450 static int ready_to_flash;
453 if (flash_start == 0) {
454 netxen_halt_pegs(adapter);
455 ret = netxen_flash_unlock(adapter);
457 printk(KERN_ERR "%s: Flash unlock failed.\n",
458 netxen_nic_driver_name);
461 printk(KERN_INFO "%s: flash unlocked. \n",
462 netxen_nic_driver_name);
463 ret = netxen_flash_erase_secondary(adapter);
464 if (ret != FLASH_SUCCESS) {
465 printk(KERN_ERR "%s: Flash erase failed.\n",
466 netxen_nic_driver_name);
469 printk(KERN_INFO "%s: secondary flash erased successfully.\n",
470 netxen_nic_driver_name);
475 if (offset == NETXEN_BOOTLD_START) {
476 ret = netxen_flash_erase_primary(adapter);
477 if (ret != FLASH_SUCCESS) {
478 printk(KERN_ERR "%s: Flash erase failed.\n",
479 netxen_nic_driver_name);
483 ret = netxen_rom_se(adapter, NETXEN_USER_START);
484 if (ret != FLASH_SUCCESS)
486 ret = netxen_rom_se(adapter, NETXEN_FIXED_START);
487 if (ret != FLASH_SUCCESS)
490 printk(KERN_INFO "%s: primary flash erased successfully\n",
491 netxen_nic_driver_name);
493 ret = netxen_backup_crbinit(adapter);
494 if (ret != FLASH_SUCCESS) {
495 printk(KERN_ERR "%s: CRBinit backup failed.\n",
496 netxen_nic_driver_name);
499 printk(KERN_INFO "%s: CRBinit backup done.\n",
500 netxen_nic_driver_name);
504 if (!ready_to_flash) {
505 printk(KERN_ERR "%s: Invalid write sequence, returning...\n",
506 netxen_nic_driver_name);
510 return netxen_rom_fast_write_words(adapter, offset, bytes, eeprom->len);
515 netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
517 struct netxen_adapter *adapter = netdev_priv(dev);
520 ring->rx_pending = 0;
521 ring->rx_jumbo_pending = 0;
522 for (i = 0; i < MAX_RCV_CTX; ++i) {
523 ring->rx_pending += adapter->recv_ctx[i].
524 rcv_desc[RCV_DESC_NORMAL_CTXID].max_rx_desc_count;
525 ring->rx_jumbo_pending += adapter->recv_ctx[i].
526 rcv_desc[RCV_DESC_JUMBO_CTXID].max_rx_desc_count;
528 ring->tx_pending = adapter->max_tx_desc_count;
530 ring->rx_max_pending = MAX_RCV_DESCRIPTORS;
531 ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
532 ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
533 ring->rx_mini_max_pending = 0;
534 ring->rx_mini_pending = 0;
538 netxen_nic_get_pauseparam(struct net_device *dev,
539 struct ethtool_pauseparam *pause)
541 struct netxen_adapter *adapter = netdev_priv(dev);
543 int port = adapter->physical_port;
545 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
546 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
548 /* get flow control settings */
549 netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
551 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
552 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
555 pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
558 pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
561 pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
565 pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
568 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
569 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
572 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
574 pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
576 pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
578 printk(KERN_ERR"%s: Unknown board type: %x\n",
579 netxen_nic_driver_name, adapter->ahw.board_type);
584 netxen_nic_set_pauseparam(struct net_device *dev,
585 struct ethtool_pauseparam *pause)
587 struct netxen_adapter *adapter = netdev_priv(dev);
589 int port = adapter->physical_port;
591 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
592 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
594 /* set flow control */
595 netxen_nic_read_w0(adapter,
596 NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
599 netxen_gb_rx_flowctl(val);
601 netxen_gb_unset_rx_flowctl(val);
603 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
606 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
610 netxen_gb_unset_gb0_mask(val);
612 netxen_gb_set_gb0_mask(val);
616 netxen_gb_unset_gb1_mask(val);
618 netxen_gb_set_gb1_mask(val);
622 netxen_gb_unset_gb2_mask(val);
624 netxen_gb_set_gb2_mask(val);
629 netxen_gb_unset_gb3_mask(val);
631 netxen_gb_set_gb3_mask(val);
634 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
635 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
636 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
638 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
641 netxen_xg_unset_xg0_mask(val);
643 netxen_xg_set_xg0_mask(val);
646 netxen_xg_unset_xg1_mask(val);
648 netxen_xg_set_xg1_mask(val);
650 netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
652 printk(KERN_ERR "%s: Unknown board type: %x\n",
653 netxen_nic_driver_name,
654 adapter->ahw.board_type);
659 static int netxen_nic_reg_test(struct net_device *dev)
661 struct netxen_adapter *adapter = netdev_priv(dev);
662 u32 data_read, data_written;
664 netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
665 if ((data_read & 0xffff) != PHAN_VENDOR_ID)
668 data_written = (u32)0xa5a5a5a5;
670 netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
671 data_read = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_SCRATCHPAD_TEST));
672 if (data_written != data_read)
678 static int netxen_get_sset_count(struct net_device *dev, int sset)
682 return NETXEN_NIC_TEST_LEN;
684 return NETXEN_NIC_STATS_LEN;
691 netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
694 memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
695 if ((data[0] = netxen_nic_reg_test(dev)))
696 eth_test->flags |= ETH_TEST_FL_FAILED;
698 if ((data[1] = (u64) netxen_nic_test_link(dev)))
699 eth_test->flags |= ETH_TEST_FL_FAILED;
703 netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
709 memcpy(data, *netxen_nic_gstrings_test,
710 NETXEN_NIC_TEST_LEN * ETH_GSTRING_LEN);
713 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
714 memcpy(data + index * ETH_GSTRING_LEN,
715 netxen_nic_gstrings_stats[index].stat_string,
723 netxen_nic_get_ethtool_stats(struct net_device *dev,
724 struct ethtool_stats *stats, u64 * data)
726 struct netxen_adapter *adapter = netdev_priv(dev);
729 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
732 netxen_nic_gstrings_stats[index].stat_offset;
734 (netxen_nic_gstrings_stats[index].sizeof_stat ==
735 sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
739 static u32 netxen_nic_get_rx_csum(struct net_device *dev)
741 struct netxen_adapter *adapter = netdev_priv(dev);
742 return adapter->rx_csum;
745 static int netxen_nic_set_rx_csum(struct net_device *dev, u32 data)
747 struct netxen_adapter *adapter = netdev_priv(dev);
748 adapter->rx_csum = !!data;
752 struct ethtool_ops netxen_nic_ethtool_ops = {
753 .get_settings = netxen_nic_get_settings,
754 .set_settings = netxen_nic_set_settings,
755 .get_drvinfo = netxen_nic_get_drvinfo,
756 .get_regs_len = netxen_nic_get_regs_len,
757 .get_regs = netxen_nic_get_regs,
758 .get_link = ethtool_op_get_link,
759 .get_eeprom_len = netxen_nic_get_eeprom_len,
760 .get_eeprom = netxen_nic_get_eeprom,
762 .set_eeprom = netxen_nic_set_eeprom,
764 .get_ringparam = netxen_nic_get_ringparam,
765 .get_pauseparam = netxen_nic_get_pauseparam,
766 .set_pauseparam = netxen_nic_set_pauseparam,
767 .set_tx_csum = ethtool_op_set_tx_csum,
768 .set_sg = ethtool_op_set_sg,
769 .set_tso = ethtool_op_set_tso,
770 .self_test = netxen_nic_diag_test,
771 .get_strings = netxen_nic_get_strings,
772 .get_ethtool_stats = netxen_nic_get_ethtool_stats,
773 .get_sset_count = netxen_get_sset_count,
774 .get_rx_csum = netxen_nic_get_rx_csum,
775 .set_rx_csum = netxen_nic_set_rx_csum,