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_hw.h"
44 #include "netxen_nic.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_port *)0)->m), \
54 offsetof(struct netxen_port, 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 {"uphappy", NETXEN_NIC_STAT(stats.uphappy)},
68 {"updropped", NETXEN_NIC_STAT(stats.updropped)},
69 {"uplcong", NETXEN_NIC_STAT(stats.uplcong)},
70 {"uphcong", NETXEN_NIC_STAT(stats.uphcong)},
71 {"upmcong", NETXEN_NIC_STAT(stats.upmcong)},
72 {"updunno", NETXEN_NIC_STAT(stats.updunno)},
73 {"skb_freed", NETXEN_NIC_STAT(stats.skbfreed)},
74 {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
75 {"tx_null_skb", NETXEN_NIC_STAT(stats.txnullskb)},
76 {"csummed", NETXEN_NIC_STAT(stats.csummed)},
77 {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
78 {"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
79 {"tx_bytes", NETXEN_NIC_STAT(stats.txbytes)},
82 #define NETXEN_NIC_STATS_LEN ARRAY_SIZE(netxen_nic_gstrings_stats)
84 static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
85 "Register_Test_on_offline",
86 "Link_Test_on_offline"
89 #define NETXEN_NIC_TEST_LEN sizeof(netxen_nic_gstrings_test) / ETH_GSTRING_LEN
91 #define NETXEN_NIC_REGS_COUNT 42
92 #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
93 #define NETXEN_MAX_EEPROM_LEN 1024
95 static int netxen_nic_get_eeprom_len(struct net_device *dev)
97 return FLASH_TOTAL_SIZE;
101 netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
103 struct netxen_port *port = netdev_priv(dev);
104 struct netxen_adapter *adapter = port->adapter;
109 strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
110 strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
111 fw_major = readl(NETXEN_CRB_NORMALIZE(adapter,
112 NETXEN_FW_VERSION_MAJOR));
113 fw_minor = readl(NETXEN_CRB_NORMALIZE(adapter,
114 NETXEN_FW_VERSION_MINOR));
115 fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
116 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
118 strncpy(drvinfo->bus_info, pci_name(port->pdev), 32);
119 drvinfo->n_stats = NETXEN_NIC_STATS_LEN;
120 drvinfo->testinfo_len = NETXEN_NIC_TEST_LEN;
121 drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
122 drvinfo->eedump_len = netxen_nic_get_eeprom_len(dev);
126 netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
128 struct netxen_port *port = netdev_priv(dev);
129 struct netxen_adapter *adapter = port->adapter;
130 struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
132 /* read which mode */
133 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
134 ecmd->supported = (SUPPORTED_10baseT_Half |
135 SUPPORTED_10baseT_Full |
136 SUPPORTED_100baseT_Half |
137 SUPPORTED_100baseT_Full |
138 SUPPORTED_1000baseT_Half |
139 SUPPORTED_1000baseT_Full);
141 ecmd->advertising = (ADVERTISED_100baseT_Half |
142 ADVERTISED_100baseT_Full |
143 ADVERTISED_1000baseT_Half |
144 ADVERTISED_1000baseT_Full);
146 ecmd->port = PORT_TP;
148 if (netif_running(dev)) {
149 ecmd->speed = port->link_speed;
150 ecmd->duplex = port->link_duplex;
152 return -EIO; /* link absent */
153 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
154 ecmd->supported = (SUPPORTED_TP |
155 SUPPORTED_1000baseT_Full |
156 SUPPORTED_10000baseT_Full);
157 ecmd->advertising = (ADVERTISED_TP |
158 ADVERTISED_1000baseT_Full |
159 ADVERTISED_10000baseT_Full);
160 ecmd->port = PORT_TP;
162 ecmd->speed = SPEED_10000;
163 ecmd->duplex = DUPLEX_FULL;
164 ecmd->autoneg = AUTONEG_DISABLE;
168 ecmd->phy_address = port->portnum;
169 ecmd->transceiver = XCVR_EXTERNAL;
171 switch ((netxen_brdtype_t) boardinfo->board_type) {
172 case NETXEN_BRDTYPE_P2_SB35_4G:
173 case NETXEN_BRDTYPE_P2_SB31_2G:
174 ecmd->supported |= SUPPORTED_Autoneg;
175 ecmd->advertising |= ADVERTISED_Autoneg;
176 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
177 ecmd->supported |= SUPPORTED_TP;
178 ecmd->advertising |= ADVERTISED_TP;
179 ecmd->port = PORT_TP;
180 ecmd->autoneg = (boardinfo->board_type ==
181 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
182 (AUTONEG_DISABLE) : (port->link_autoneg);
184 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
185 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
186 ecmd->supported |= SUPPORTED_MII;
187 ecmd->advertising |= ADVERTISED_MII;
188 ecmd->port = PORT_FIBRE;
189 ecmd->autoneg = AUTONEG_DISABLE;
191 case NETXEN_BRDTYPE_P2_SB31_10G:
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_port *port = netdev_priv(dev);
210 struct netxen_adapter *adapter = port->adapter;
213 /* read which mode */
214 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
215 /* autonegotiation */
216 if (adapter->phy_write
217 && adapter->phy_write(adapter, port->portnum,
218 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
222 port->link_autoneg = ecmd->autoneg;
224 if (adapter->phy_read
225 && adapter->phy_read(adapter, port->portnum,
226 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
231 switch (ecmd->speed) {
233 netxen_set_phy_speed(status, 0);
236 netxen_set_phy_speed(status, 1);
239 netxen_set_phy_speed(status, 2);
242 /* set duplex mode */
243 if (ecmd->duplex == DUPLEX_HALF)
244 netxen_clear_phy_duplex(status);
245 if (ecmd->duplex == DUPLEX_FULL)
246 netxen_set_phy_duplex(status);
247 if (adapter->phy_write
248 && adapter->phy_write(adapter, port->portnum,
249 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
250 *((int *)&status)) != 0)
253 port->link_speed = ecmd->speed;
254 port->link_duplex = ecmd->duplex;
259 if (netif_running(dev)) {
266 static int netxen_nic_get_regs_len(struct net_device *dev)
268 return NETXEN_NIC_REGS_LEN;
271 struct netxen_niu_regs {
272 __u32 reg[NETXEN_NIC_REGS_COUNT];
275 static struct netxen_niu_regs niu_registers[] = {
279 NETXEN_NIU_GB_SERDES_RESET,
280 NETXEN_NIU_GB0_MII_MODE,
281 NETXEN_NIU_GB1_MII_MODE,
282 NETXEN_NIU_GB2_MII_MODE,
283 NETXEN_NIU_GB3_MII_MODE,
284 NETXEN_NIU_GB0_GMII_MODE,
285 NETXEN_NIU_GB1_GMII_MODE,
286 NETXEN_NIU_GB2_GMII_MODE,
287 NETXEN_NIU_GB3_GMII_MODE,
288 NETXEN_NIU_REMOTE_LOOPBACK,
289 NETXEN_NIU_GB0_HALF_DUPLEX,
290 NETXEN_NIU_GB1_HALF_DUPLEX,
291 NETXEN_NIU_RESET_SYS_FIFOS,
292 NETXEN_NIU_GB_CRC_DROP,
293 NETXEN_NIU_GB_DROP_WRONGADDR,
294 NETXEN_NIU_TEST_MUX_CTL,
296 NETXEN_NIU_GB_MAC_CONFIG_0(0),
297 NETXEN_NIU_GB_MAC_CONFIG_1(0),
298 NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
299 NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
300 NETXEN_NIU_GB_TEST_REG(0),
301 NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
302 NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
303 NETXEN_NIU_GB_MII_MGMT_ADDR(0),
304 NETXEN_NIU_GB_MII_MGMT_CTRL(0),
305 NETXEN_NIU_GB_MII_MGMT_STATUS(0),
306 NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
307 NETXEN_NIU_GB_INTERFACE_CTRL(0),
308 NETXEN_NIU_GB_INTERFACE_STATUS(0),
309 NETXEN_NIU_GB_STATION_ADDR_0(0),
310 NETXEN_NIU_GB_STATION_ADDR_1(0),
317 NETXEN_NIU_XG_SINGLE_TERM,
318 NETXEN_NIU_XG_DRIVE_HI,
319 NETXEN_NIU_XG_DRIVE_LO,
322 NETXEN_NIU_XG_WORD_ALIGN,
324 NETXEN_NIU_XG_POWER_DOWN,
325 NETXEN_NIU_XG_RESET_PLL,
326 NETXEN_NIU_XG_SERDES_LOOPBACK,
327 NETXEN_NIU_XG_DO_BYTE_ALIGN,
328 NETXEN_NIU_XG_TX_ENABLE,
329 NETXEN_NIU_XG_RX_ENABLE,
330 NETXEN_NIU_XG_STATUS,
331 NETXEN_NIU_XG_PAUSE_THRESHOLD,
332 NETXEN_NIU_XGE_CONFIG_0,
333 NETXEN_NIU_XGE_CONFIG_1,
335 NETXEN_NIU_XGE_STATION_ADDR_0_HI,
336 NETXEN_NIU_XGE_STATION_ADDR_0_1,
337 NETXEN_NIU_XGE_STATION_ADDR_1_LO,
338 NETXEN_NIU_XGE_STATUS,
339 NETXEN_NIU_XGE_MAX_FRAME_SIZE,
340 NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
341 NETXEN_NIU_XGE_TX_BYTE_CNT,
342 NETXEN_NIU_XGE_TX_FRAME_CNT,
343 NETXEN_NIU_XGE_RX_BYTE_CNT,
344 NETXEN_NIU_XGE_RX_FRAME_CNT,
345 NETXEN_NIU_XGE_AGGR_ERROR_CNT,
346 NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
347 NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
348 NETXEN_NIU_XGE_CRC_ERROR_CNT,
349 NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
350 NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
351 NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
352 NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
353 NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
354 NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
361 netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
363 struct netxen_port *port = netdev_priv(dev);
364 struct netxen_adapter *adapter = port->adapter;
365 __u32 mode, *regs_buff = p;
369 memset(p, 0, NETXEN_NIC_REGS_LEN);
370 regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
371 (port->pdev)->device;
373 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, ®s_buff[0]);
376 /* Common registers to all the modes */
377 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER,
380 mode = (mode / 2) - 1;
383 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
384 /* GB: port specific registers */
385 if (mode == 0 && i >= 19)
386 window = port->portnum * NETXEN_NIC_PORT_WINDOW;
388 NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
396 static u32 netxen_nic_test_link(struct net_device *dev)
398 struct netxen_port *port = netdev_priv(dev);
399 struct netxen_adapter *adapter = port->adapter;
403 /* read which mode */
404 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
405 if (adapter->phy_read
406 && adapter->phy_read(adapter, port->portnum,
407 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
411 val = netxen_get_phy_link(status);
414 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
415 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
416 return (val == XG_LINK_UP) ? 0 : 1;
422 netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
425 struct netxen_port *port = netdev_priv(dev);
426 struct netxen_adapter *adapter = port->adapter;
430 if (eeprom->len == 0)
433 eeprom->magic = (port->pdev)->vendor | ((port->pdev)->device << 16);
434 offset = eeprom->offset;
436 ret = netxen_rom_fast_read_words(adapter, offset, bytes,
445 netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
448 struct netxen_port *port = netdev_priv(dev);
449 struct netxen_adapter *adapter = port->adapter;
450 int offset = eeprom->offset;
451 static int flash_start;
452 static int ready_to_flash;
455 if (flash_start == 0) {
456 netxen_halt_pegs(adapter);
457 ret = netxen_flash_unlock(adapter);
459 printk(KERN_ERR "%s: Flash unlock failed.\n",
460 netxen_nic_driver_name);
463 printk(KERN_INFO "%s: flash unlocked. \n",
464 netxen_nic_driver_name);
465 ret = netxen_flash_erase_secondary(adapter);
466 if (ret != FLASH_SUCCESS) {
467 printk(KERN_ERR "%s: Flash erase failed.\n",
468 netxen_nic_driver_name);
471 printk(KERN_INFO "%s: secondary flash erased successfully.\n",
472 netxen_nic_driver_name);
477 if (offset == BOOTLD_START) {
478 ret = netxen_flash_erase_primary(adapter);
479 if (ret != FLASH_SUCCESS) {
480 printk(KERN_ERR "%s: Flash erase failed.\n",
481 netxen_nic_driver_name);
485 ret = netxen_rom_se(adapter, USER_START);
486 if (ret != FLASH_SUCCESS)
488 ret = netxen_rom_se(adapter, FIXED_START);
489 if (ret != FLASH_SUCCESS)
492 printk(KERN_INFO "%s: primary flash erased successfully\n",
493 netxen_nic_driver_name);
495 ret = netxen_backup_crbinit(adapter);
496 if (ret != FLASH_SUCCESS) {
497 printk(KERN_ERR "%s: CRBinit backup failed.\n",
498 netxen_nic_driver_name);
501 printk(KERN_INFO "%s: CRBinit backup done.\n",
502 netxen_nic_driver_name);
506 if (!ready_to_flash) {
507 printk(KERN_ERR "%s: Invalid write sequence, returning...\n",
508 netxen_nic_driver_name);
512 return netxen_rom_fast_write_words(adapter, offset, bytes, eeprom->len);
516 netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
518 struct netxen_port *port = netdev_priv(dev);
519 struct netxen_adapter *adapter = port->adapter;
522 ring->rx_pending = 0;
523 ring->rx_jumbo_pending = 0;
524 for (i = 0; i < MAX_RCV_CTX; ++i) {
525 ring->rx_pending += adapter->recv_ctx[i].
526 rcv_desc[RCV_DESC_NORMAL_CTXID].rcv_pending;
527 ring->rx_jumbo_pending += adapter->recv_ctx[i].
528 rcv_desc[RCV_DESC_JUMBO_CTXID].rcv_pending;
531 ring->rx_max_pending = adapter->max_rx_desc_count;
532 ring->tx_max_pending = adapter->max_tx_desc_count;
533 ring->rx_jumbo_max_pending = adapter->max_jumbo_rx_desc_count;
534 ring->rx_mini_max_pending = 0;
535 ring->rx_mini_pending = 0;
536 ring->rx_jumbo_pending = 0;
540 netxen_nic_get_pauseparam(struct net_device *dev,
541 struct ethtool_pauseparam *pause)
543 struct netxen_port *port = netdev_priv(dev);
544 struct netxen_adapter *adapter = port->adapter;
547 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
548 /* get flow control settings */
549 netxen_nic_read_w0(adapter,
550 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
552 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
553 pause->tx_pause = netxen_gb_get_tx_flowctl(val);
554 /* get autoneg settings */
555 pause->autoneg = port->link_autoneg;
560 netxen_nic_set_pauseparam(struct net_device *dev,
561 struct ethtool_pauseparam *pause)
563 struct netxen_port *port = netdev_priv(dev);
564 struct netxen_adapter *adapter = port->adapter;
566 unsigned int autoneg;
569 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
570 /* set flow control */
571 netxen_nic_read_w0(adapter,
572 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
575 netxen_gb_tx_flowctl(val);
577 netxen_gb_unset_tx_flowctl(val);
579 netxen_gb_rx_flowctl(val);
581 netxen_gb_unset_rx_flowctl(val);
583 netxen_nic_write_w0(adapter,
584 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
587 autoneg = pause->autoneg;
588 if (adapter->phy_write
589 && adapter->phy_write(adapter, port->portnum,
590 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
594 port->link_autoneg = pause->autoneg;
601 static int netxen_nic_reg_test(struct net_device *dev)
603 struct netxen_adapter *adapter = netdev_priv(dev);
604 u32 data_read, data_written;
606 netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
607 if ((data_read & 0xffff) != PHAN_VENDOR_ID)
610 data_written = (u32)0xa5a5a5a5;
612 netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
613 data_read = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_SCRATCHPAD_TEST));
614 if (data_written != data_read)
620 static int netxen_nic_diag_test_count(struct net_device *dev)
622 return NETXEN_NIC_TEST_LEN;
626 netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
629 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { /* offline tests */
631 if ((data[1] = (u64) netxen_nic_test_link(dev)))
632 eth_test->flags |= ETH_TEST_FL_FAILED;
635 if ((data[0] = netxen_nic_reg_test(dev)))
636 eth_test->flags |= ETH_TEST_FL_FAILED;
637 } else { /* online tests */
639 if((data[0] = netxen_nic_reg_test(dev)))
640 eth_test->flags |= ETH_TEST_FL_FAILED;
643 if ((data[1] = (u64) netxen_nic_test_link(dev)))
644 eth_test->flags |= ETH_TEST_FL_FAILED;
649 netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
655 memcpy(data, *netxen_nic_gstrings_test,
656 NETXEN_NIC_TEST_LEN * ETH_GSTRING_LEN);
659 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
660 memcpy(data + index * ETH_GSTRING_LEN,
661 netxen_nic_gstrings_stats[index].stat_string,
668 static int netxen_nic_get_stats_count(struct net_device *dev)
670 return NETXEN_NIC_STATS_LEN;
674 netxen_nic_get_ethtool_stats(struct net_device *dev,
675 struct ethtool_stats *stats, u64 * data)
677 struct netxen_port *port = netdev_priv(dev);
680 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
682 (char *)port + netxen_nic_gstrings_stats[index].stat_offset;
684 (netxen_nic_gstrings_stats[index].sizeof_stat ==
685 sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
689 struct ethtool_ops netxen_nic_ethtool_ops = {
690 .get_settings = netxen_nic_get_settings,
691 .set_settings = netxen_nic_set_settings,
692 .get_drvinfo = netxen_nic_get_drvinfo,
693 .get_regs_len = netxen_nic_get_regs_len,
694 .get_regs = netxen_nic_get_regs,
695 .get_link = ethtool_op_get_link,
696 .get_eeprom_len = netxen_nic_get_eeprom_len,
697 .get_eeprom = netxen_nic_get_eeprom,
698 .set_eeprom = netxen_nic_set_eeprom,
699 .get_ringparam = netxen_nic_get_ringparam,
700 .get_pauseparam = netxen_nic_get_pauseparam,
701 .set_pauseparam = netxen_nic_set_pauseparam,
702 .get_tx_csum = ethtool_op_get_tx_csum,
703 .set_tx_csum = ethtool_op_set_tx_csum,
704 .get_sg = ethtool_op_get_sg,
705 .set_sg = ethtool_op_set_sg,
706 .get_tso = ethtool_op_get_tso,
707 .set_tso = ethtool_op_set_tso,
708 .self_test_count = netxen_nic_diag_test_count,
709 .self_test = netxen_nic_diag_test,
710 .get_strings = netxen_nic_get_strings,
711 .get_stats_count = netxen_nic_get_stats_count,
712 .get_ethtool_stats = netxen_nic_get_ethtool_stats,
713 .get_perm_addr = ethtool_op_get_perm_addr,