diff -Naru linux-2.6.16_orig/drivers/net/netxen/netxen_nic_ethtool.c
linux-2.6.16/drivers/net/netxen/netxen_nic_ethtool.c
--- linux-2.6.16_orig/drivers/net/netxen/netxen_nic_ethtool.c 1969-12-31
16:00:00.000000000 -0800
+++ linux-2.6.16/drivers/net/netxen/netxen_nic_ethtool.c 2006-03-24
14:13:57.000000000 -0800
@@ -0,0 +1,861 @@
+/*
+ * Copyright (C) 2003 - 2006 NetXen Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.
+ *
+ * Contact Information:
+ * [EMAIL PROTECTED]
+ * NetXen, 3965 Freedom Circle, Fourth Floor,
+ * Santa Clara, CA 95054
+ */
+/* ethtool support for netxen nic */
+
+#include <linux/types.h>
+#include <asm/uaccess.h>
+#include <linux/pci.h>
+#include <asm/io.h>
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/version.h>
+
+#include "netxen_nic_hw.h"
+#include "netxen_nic.h"
+#include "nic_phan_reg.h"
+#include "netxen_nic_ioctl.h"
+#include "nic_cmn.h"
+
+extern char * netxen_nic_driver_string;
+extern void netxen_update_stats(struct netxen_port *port);
+extern void netxen_change_ringparam(struct netxen_adapter_s *adapter);
+extern int rom_fast_read(struct netxen_adapter_s *adapter, int addr);
+
+#define MIN_RX_DESC_COUNT 4096
+#define MIN_TX_DESC_COUNT 4096
+#define MAX_RX_DESC_COUNT MAX_RCV_DESCRIPTORS
+#define MAX_TX_DESC_COUNT MAX_CMD_DESCRIPTORS
+
+// This will be needed for efficiency reasons !!
+#define RX_DESC_MULTIPLE 8
+#define TX_DESC_MULTIPLE 8
+
+#define NetXen_ROUNDUP(i, size) ((i) = (((i) + (size) - 1) & ~((size) - 1)))
+
+struct netxen_nic_stats {
+ char stat_string[ETH_GSTRING_LEN];
+ int sizeof_stat;
+ int stat_offset;
+};
+
+#define NetXen_NIC_STAT(m) sizeof(((struct netxen_port *)0)->m), \
+ offsetof(struct netxen_port, m)
+
+static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
+ { "rcvd bad skb", NetXen_NIC_STAT(stats.rcvdbadskb) },
+ { "xmit called", NetXen_NIC_STAT(stats.xmitcalled) },
+ { "xmited frames", NetXen_NIC_STAT(stats.xmitedframes) },
+ { "xmit finished", NetXen_NIC_STAT(stats.xmitfinished) },
+ { "bad skb len", NetXen_NIC_STAT(stats.badskblen) },
+ { "no cmd desc", NetXen_NIC_STAT(stats.nocmddescriptor) },
+ { "polled", NetXen_NIC_STAT(stats.polled) },
+ { "uphappy", NetXen_NIC_STAT(stats.uphappy) },
+ { "updropped", NetXen_NIC_STAT(stats.updropped) },
+ { "uplcong", NetXen_NIC_STAT(stats.uplcong) },
+ { "uphcong", NetXen_NIC_STAT(stats.uphcong) },
+ { "upmcong", NetXen_NIC_STAT(stats.upmcong) },
+ { "updunno", NetXen_NIC_STAT(stats.updunno) },
+ { "skb freed", NetXen_NIC_STAT(stats.skbfreed) },
+ { "tx dropped", NetXen_NIC_STAT(stats.txdropped) },
+ { "tx null skb", NetXen_NIC_STAT(stats.txnullskb) },
+ { "csummed", NetXen_NIC_STAT(stats.csummed) },
+ { "no rcv", NetXen_NIC_STAT(stats.no_rcv) },
+ { "rx bytes", NetXen_NIC_STAT(stats.rxbytes) },
+ { "tx bytes", NetXen_NIC_STAT(stats.txbytes) },
+};
+
+#define NetXen_NIC_STATS_LEN \
+ sizeof(netxen_nic_gstrings_stats) / sizeof(struct netxen_nic_stats)
+
+static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
+ "Register test (offline)", "Eeprom test (offline)",
+ "Interrupt test (offline)", "Loopback test (offline)",
+ "Link test (on/offline)"
+};
+#define NetXen_NIC_TEST_LEN sizeof(netxen_nic_gstrings_test) / ETH_GSTRING_LEN
+
+#define NetXen_NIC_REGS_COUNT 42
+#define NetXen_NIC_REGS_LEN (NetXen_NIC_REGS_COUNT * sizeof(netxen_crbword_t))
+
+static int
+netxen_nic_get_eeprom_len(struct net_device *netdev)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ int n = rom_fast_read(adapter,0);
+ if(n & 0x80000000) { // verify the rom address
+ n &= ~0x80000000;
+ if(n < 1024) return (n);
+ }
+ return 0;
+}
+
+static void
+netxen_nic_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo
*drvinfo)
+{
+ struct netxen_port *port = netdev->priv;
+
+ strncpy(drvinfo->driver, "NetXen NIC Driver", 32);
+ strncpy(drvinfo->version, "N/A", 32);
+ strncpy(drvinfo->fw_version, "N/A", 32);
+ strncpy(drvinfo->bus_info, pci_name(port->pdev), 32);
+ drvinfo->n_stats = NetXen_NIC_STATS_LEN;
+ drvinfo->testinfo_len = NetXen_NIC_TEST_LEN;
+ drvinfo->regdump_len = NetXen_NIC_REGS_LEN;
+ drvinfo->eedump_len = netxen_nic_get_eeprom_len(netdev);
+}
+
+static int
+netxen_nic_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+
+ // read which mode
+ if(adapter->ahw.board_type == NetXen_NIC_GBE) {
+ ecmd->supported = (SUPPORTED_10baseT_Half|
+ SUPPORTED_10baseT_Full|
+ SUPPORTED_100baseT_Half|
+ SUPPORTED_100baseT_Full|
+ SUPPORTED_1000baseT_Half|
+ SUPPORTED_1000baseT_Full|
+ SUPPORTED_TP|
+ SUPPORTED_MII|
+ SUPPORTED_Autoneg);
+
+ ecmd->advertising = (ADVERTISED_100baseT_Half|
+ ADVERTISED_100baseT_Full|
+ ADVERTISED_1000baseT_Half|
+ ADVERTISED_1000baseT_Full|
+ ADVERTISED_TP|
+ ADVERTISED_MII|
+ ADVERTISED_Autoneg);
+
+ ecmd->port = PORT_TP;
+
+// if(netif_carrier_ok(netdev)) { // cant use this method to determine
+// link status as driver has not taken care of carrier state (ON/OFF).
+// Instead I'll use cached value in netxen_port to find link status !!
+ if(port->state) {
+ ecmd->speed = port->link_speed;
+ ecmd->duplex = port->link_duplex;
+ } else
+ return -EIO; // link absent
+
+ ecmd->phy_address = port->portnum;
+ ecmd->transceiver = XCVR_EXTERNAL;
+
+ // get autoneg settings
+ ecmd->autoneg = port->link_autoneg;
+ return 0;
+ }
+
+ if (adapter->ahw.board_type == NetXen_NIC_XGBE) {
+ ecmd->supported = (SUPPORTED_FIBRE |
+ SUPPORTED_Autoneg);
+ ecmd->advertising = (ADVERTISED_10000baseT_Full|
+ ADVERTISED_FIBRE |
+ ADVERTISED_Autoneg);
+ ecmd->port = PORT_FIBRE;
+ ecmd->speed = SPEED_10000;
+ ecmd->duplex = DUPLEX_FULL;
+ ecmd->phy_address = port->portnum;
+ ecmd->transceiver = XCVR_EXTERNAL;
+ ecmd->autoneg = 0;
+ return 0;
+ }
+
+ return -EIO;
+}
+
+static int
+netxen_nic_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ netxen_niu_phy_status_t status;
+
+ // read which mode
+ if(adapter->ahw.board_type == NetXen_NIC_GBE) {
+ // autonegotiation
+ if (netxen_nic_phy_write(port->adapter,port->portnum,
+ NetXen_NIU_GB_MII_MGMT_ADDR_AUTONEG,
+ (netxen_crbword_t)ecmd->autoneg)!= 0)
+ return -EIO;
+ else
+ port->link_autoneg = ecmd->autoneg;
+
+ if (netxen_nic_phy_read(port->adapter, port->portnum,
+ NetXen_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
+ (netxen_crbword_t *)&status) != 0)
+ return -EIO;
+
+ // speed
+ switch(ecmd->speed) {
+ case SPEED_10:
+ status.speed = 0;
+ break;
+ case SPEED_100:
+ status.speed = 1;
+ break;
+ case SPEED_1000:
+ status.speed = 2;
+ break;
+ }
+ // set duplex mode
+ if(ecmd->duplex == DUPLEX_HALF)
+ status.duplex = 0;
+ if(ecmd->duplex == DUPLEX_FULL)
+ status.duplex = 1;
+
+ if (netxen_nic_phy_write(port->adapter,port->portnum,
+ NetXen_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
+ *((int*)&status)) != 0)
+ return -EIO;
+ else {
+ port->link_speed = ecmd->speed;
+ port->link_duplex = ecmd->duplex;
+ }
+ }
+ if(netif_running(netdev)) {
+ netdev->stop(netdev);
+ netdev->open(netdev);
+ }
+ return 0;
+}
+
+static int
+netxen_nic_get_regs_len(struct net_device *netdev)
+{
+ return NetXen_NIC_REGS_LEN;
+}
+
+static void
+netxen_nic_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void
*p)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ netxen_crbword_t mode, *regs_buff = p;
+ unsigned long flags;
+ void *addr;
+
+ memset(p, 0, NetXen_NIC_REGS_LEN);
+ regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
+ adapter->ahw.device_id;
+ write_lock_irqsave(&adapter->adapter_lock, flags);
+ // which mode
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_MODE, ®s_buff[0]);
+ mode = regs_buff[0];
+
+ // Common registers to all the modes
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_STRAP_VALUE_SAVE_HIGHER,
®s_buff[2]);
+ switch(mode) {
+ case 4: {//XGB Mode
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_SINGLE_TERM,
®s_buff[3]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_DRIVE_HI,
®s_buff[4]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_DRIVE_LO,
®s_buff[5]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_DTX, ®s_buff[6]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_DEQ, ®s_buff[7]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_WORD_ALIGN,
®s_buff[8]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_RESET, ®s_buff[9]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_POWER_DOWN,
®s_buff[10]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_RESET_PLL,
®s_buff[11]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_SERDES_LOOPBACK,
+ ®s_buff[12]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_DO_BYTE_ALIGN,
+ ®s_buff[13]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_TX_ENABLE,
®s_buff[14]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_RX_ENABLE,
®s_buff[15]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_STATUS,
®s_buff[16]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XG_PAUSE_THRESHOLD,
+ ®s_buff[17]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_CONFIG_0,
®s_buff[18]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_CONFIG_1,
®s_buff[19]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_IPG, ®s_buff[20]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_STATION_ADDR_0_HI,
+ ®s_buff[21]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_STATION_ADDR_0_1,
+ ®s_buff[22]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_STATION_ADDR_1_LO,
+ ®s_buff[23]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_STATUS,
®s_buff[24]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_MAX_FRAME_SIZE,
+ ®s_buff[25]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_PAUSE_FRAME_VALUE,
+ ®s_buff[26]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_TX_BYTE_CNT,
+ ®s_buff[27]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_TX_FRAME_CNT,
+ ®s_buff[28]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_RX_BYTE_CNT,
+ ®s_buff[29]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_RX_FRAME_CNT,
+ ®s_buff[30]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_AGGR_ERROR_CNT,
+ ®s_buff[31]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_MULTICAST_FRAME_CNT,
+ ®s_buff[32]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_UNICAST_FRAME_CNT,
+ ®s_buff[33]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_CRC_ERROR_CNT,
+ ®s_buff[34]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_OVERSIZE_FRAME_ERR,
+ ®s_buff[35]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_UNDERSIZE_FRAME_ERR,
+ ®s_buff[36]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_LOCAL_ERROR_CNT,
+ ®s_buff[37]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_REMOTE_ERROR_CNT,
+ ®s_buff[38]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_CONTROL_CHAR_CNT,
+ ®s_buff[39]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_XGE_PAUSE_FRAME_CNT,
+ ®s_buff[40]);
+ break;
+ }
+
+ case 2: { // GB Mode
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_SERDES_RESET,
®s_buff[3]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB0_MII_MODE,
®s_buff[4]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB1_MII_MODE,
®s_buff[5]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB2_MII_MODE,
®s_buff[6]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB3_MII_MODE,
®s_buff[7]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB0_GMII_MODE,
®s_buff[8]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB1_GMII_MODE,
®s_buff[9]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB2_GMII_MODE,
®s_buff[10]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB3_GMII_MODE,
®s_buff[11]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_REMOTE_LOOPBACK,
+ ®s_buff[12]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB0_HALF_DUPLEX,
+ ®s_buff[13]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB1_HALF_DUPLEX,
+ ®s_buff[14]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_RESET_SYS_FIFOS,
+ ®s_buff[15]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_CRC_DROP,
+ ®s_buff[16]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_DROP_WRONGADDR,
+ ®s_buff[17]);
+ NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_TEST_MUX_CTL,
®s_buff[18]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MAC_CONFIG_0(port->portnum),
+ ®s_buff[19]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MAC_CONFIG_1(port->portnum),
+ ®s_buff[20]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_HALF_DUPLEX_CTRL(port->portnum),
+ ®s_buff[21]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MAX_FRAME_SIZE(port->portnum),
+ ®s_buff[22]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_TEST_REG(port->portnum),
+ ®s_buff[23]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_CONFIG(port->portnum),
+ ®s_buff[24]);
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_COMMAND(port->portnum),
+ ®s_buff[25]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_ADDR(port->portnum),
+ ®s_buff[26]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_CTRL(port->portnum),
+ ®s_buff[27]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_STATUS(port->portnum),
+ ®s_buff[28]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_MII_MGMT_INDICATE(port->portnum),
+ ®s_buff[29]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_INTERFACE_CTRL(port->portnum),
+ ®s_buff[30]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_INTERFACE_STATUS(port->portnum),
+ ®s_buff[31]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_STATION_ADDR_0(port->portnum),
+ ®s_buff[32]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_GB_STATION_ADDR_1(port->portnum),
+ ®s_buff[33]);
+ break;
+ }
+
+ case 1: { // FC Mode
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_RX_STATUS(port->portnum),
+ ®s_buff[3]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_RX_COMMA_DETECT(port->portnum),
+ ®s_buff[4]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_LASER_UNSAFE(port->portnum),
+ ®s_buff[5]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_TX_CONTROL(port->portnum),
+ ®s_buff[6]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_ON_OFFLINE_CTL(port->portnum),
+ ®s_buff[7]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_PORT_ACTIVE_STAT(port->portnum),
+ ®s_buff[8]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_PORT_INACTIVE_STAT(port->portnum),
+ ®s_buff[9]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_LINK_FAILURE_CNT(port->portnum),
+ ®s_buff[10]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_LOSS_SYNC_CNT(port->portnum),
+ ®s_buff[11]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_LOSS_SIGNAL_CNT(port->portnum),
+ ®s_buff[12]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_PRIM_SEQ_ERR_CNT(port->portnum),
+ ®s_buff[13]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_INVLD_TX_WORD_CNT(port->portnum),
+ ®s_buff[14]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_INVLD_CRC_CNT(port->portnum),
+ ®s_buff[15]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_RX_CELL_CNT(port->portnum),
+ ®s_buff[16]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_TX_CELL_CNT(port->portnum),
+ ®s_buff[17]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_B2B_CREDIT(port->portnum),
+ ®s_buff[18]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_LOGIN_DONE(port->portnum),
+ ®s_buff[19]);
+
+
NetXen_NIC_LOCKED_READ_REG(NetXen_NIU_FC_OPERATING_SPEED(port->portnum),
+ ®s_buff[20]);
+ break;
+ }
+ }
+ write_unlock_irqrestore(&adapter->adapter_lock, flags);
+}
+
+static void
+netxen_nic_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
+{
+ wol->supported = WAKE_UCAST | WAKE_MCAST |
+ WAKE_BCAST | WAKE_MAGIC;
+ // Phantom II will have WOL support !! abeyant till then.
+ wol->wolopts = 0; // options can be added depending upon the mode
+}
+
+static int
+netxen_nic_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
+{
+ // can't implement as WOL register is not known !!
+ return 0;
+}
+
+static uint32_t
+netxen_nic_get_msglevel(struct net_device *netdev)
+{
+ /* Presently netxen_nic_debug=0 and is not being used to display
+ * debug msgs. But comment says that it will be used in future
+ * releases to display debug msgs(which is exactly the way it
+ * should be) Keeping this thing in mind !!
+ */
+ return netxen_nic_debug;
+}
+
+static void
+netxen_nic_set_msglevel(struct net_device *netdev, uint32_t data)
+{
+ netxen_nic_debug = data;
+}
+
+/* Restart Link Process */
+static int
+netxen_nic_nway_reset(struct net_device *netdev)
+{
+ if(netif_running(netdev)) {
+ netdev->stop(netdev); // verify
+ netdev->open(netdev);
+ }
+ return 0;
+}
+
+static uint32_t
+netxen_nic_get_link(struct net_device *netdev)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ netxen_niu_phy_status_t status;
+ // read which mode
+ if(adapter->ahw.board_type == NetXen_NIC_GBE) {
+ if (netxen_nic_phy_read(port->adapter, port->portnum,
+ NetXen_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
+ (netxen_crbword_t *)&status) != 0)
+ return -EIO;
+ else
+ return status.link;
+ }
+ return -EIO;
+}
+
+static int
+netxen_nic_get_eeprom(struct net_device *netdev,
+ struct ethtool_eeprom *eeprom, uint8_t *bytes)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ int i;
+
+ if(eeprom->len == 0) return -EINVAL;
+
+ eeprom->magic = adapter->ahw.vendor_id |
+ (adapter->ahw.device_id << 16);
+ for(i=0; i<eeprom->len; i++)
+ rom_fast_read(adapter,(8*i)+8);
+ return 0;
+}
+
+static void
+netxen_nic_get_ringparam(struct net_device *netdev,
+ struct ethtool_ringparam *ring)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ int i, j;
+
+ ring->rx_pending = 0;
+ for (i = 0; i < MAX_RCV_CTX; ++i) {
+ for (j = 0; j < NUM_RCV_DESC_RINGS; j++) {
+ ring->rx_pending +=
+ adapter->recv_ctx[i].rcv_desc[j].rcv_pending;
+ }
+ }
+
+ ring->tx_pending = adapter->pendingCmdCount;
+ ring->rx_max_pending = adapter->MaxRxDescCount;
+ ring->tx_max_pending = adapter->MaxTxDescCount;
+ ring->rx_mini_max_pending = 0;
+ ring->rx_mini_pending = 0;
+ ring->rx_jumbo_max_pending = 0;
+ ring->rx_jumbo_pending = 0;
+}
+
+// Note: This change will be reflected in all the four ports as there is
+// only one common adapter.
+static int
+netxen_nic_set_ringparam(struct net_device *netdev,
+ struct ethtool_ringparam *ring)
+{
+ return 0;
+}
+
+static void
+netxen_nic_get_pauseparam(struct net_device *netdev,
+ struct ethtool_pauseparam *pause)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ netxen_niu_gb_mac_config_0_t val;
+
+ if(adapter->ahw.board_type == NetXen_NIC_GBE) {
+ // get flow control settings
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_MAC_CONFIG_0(port->portnum),
+ (uint32_t *)&val);
+ pause->rx_pause = val.rx_flowctl;
+ pause->tx_pause = val.tx_flowctl;
+ // get autoneg settings
+ pause->autoneg = port->link_autoneg;
+ }
+}
+
+static int
+netxen_nic_set_pauseparam(struct net_device *netdev,
+ struct ethtool_pauseparam *pause)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ netxen_niu_gb_mac_config_0_t val;
+ unsigned int autoneg;
+
+ // read mode
+ if(adapter->ahw.board_type == NetXen_NIC_GBE) {
+ // set flow control
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_MAC_CONFIG_0(port->portnum),
+ (uint32_t *)&val);
+ val.rx_flowctl = pause->rx_pause;
+ val.tx_flowctl = pause->tx_pause;
+ netxen_nic_write_w0(adapter,
NetXen_NIU_GB_MAC_CONFIG_0(port->portnum), *(__uint32_t *)(&val));
+ // set autoneg
+ autoneg = pause->autoneg;
+ if (netxen_nic_phy_write(port->adapter,port->portnum,
+ NetXen_NIU_GB_MII_MGMT_ADDR_AUTONEG,
+ (netxen_crbword_t)autoneg)!= 0)
+ return -EIO;
+ else{
+ port->link_autoneg = pause->autoneg;
+ return 0;
+ }
+ } else
+ return -EIO;
+}
+
+static uint32_t
+netxen_nic_get_rx_csum(struct net_device *netdev)
+{
+ return (netdev->features & NETIF_F_HW_CSUM);
+}
+
+static int
+netxen_nic_set_rx_csum(struct net_device *netdev, uint32_t data)
+{
+ if(data)
+ netdev->features |= NETIF_F_HW_CSUM;
+ else
+ netdev->features &= (~NETIF_F_HW_CSUM);
+
+ if(netif_running(netdev)) {
+ netdev->stop(netdev); // verify
+ netdev->open(netdev);
+ }
+ return 0;
+}
+
+static int
+netxen_nic_reg_test(struct net_device *netdev)
+{
+ struct netxen_port *port = netdev->priv;
+ struct netxen_adapter_s *adapter = port->adapter;
+ int data_read, data_written, save;
+ netxen_niu_control_t mode;
+
+ // first test the "Read Only" registers by writing
+ // which mode
+ netxen_nic_read_w0(adapter, NetXen_NIU_MODE, (uint32_t *)&mode);
+ if(mode.enable_ge) { // GB Mode
+ // netxen_niu_gb_mii_mgmt_status_t is read only
+ netxen_nic_read_w0(adapter,
+
NetXen_NIU_GB_MII_MGMT_STATUS(port->portnum),&data_read);
+
+ save = data_read;
+ if(data_read)
+ data_written = data_read & 0xDEADBEEF;
+ else
+ data_written = 0xDEADBEEF;
+ netxen_nic_write_w0(adapter,
NetXen_NIU_GB_MII_MGMT_STATUS(port->portnum), data_written);
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_MII_MGMT_STATUS(port->portnum),
+ &data_read);
+
+ if(data_written == data_read) {
+ netxen_nic_write_w0(
+ adapter,
+ NetXen_NIU_GB_MII_MGMT_STATUS(port->portnum),
+ save);
+
+ return 0;
+ }
+
+ // netxen_niu_gb_mii_mgmt_indicators_t is read only
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_MII_MGMT_INDICATE(port->portnum),
+ &data_read);
+
+ save = data_read;
+ if(data_read)
+ data_written = data_read & 0xDEADBEEF;
+ else
+ data_written = 0xDEADBEEF;
+ netxen_nic_write_w0(
+ adapter,
NetXen_NIU_GB_MII_MGMT_INDICATE(port->portnum),
+ data_written);
+
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_MII_MGMT_INDICATE(port->portnum),
+ &data_read);
+
+ if(data_written == data_read) {
+ netxen_nic_write_w0(adapter,
NetXen_NIU_GB_MII_MGMT_INDICATE(port->portnum), save);
+ return 0;
+ }
+
+ // netxen_niu_gb_interface_status_t is read only
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_INTERFACE_STATUS(port->portnum),
+ &data_read);
+
+ save = data_read;
+ if(data_read)
+ data_written = data_read & 0xDEADBEEF;
+ else
+ data_written = 0xDEADBEEF;
+ netxen_nic_write_w0(
+ adapter, NetXen_NIU_GB_INTERFACE_STATUS(port->portnum),
+ data_written);
+
+ netxen_nic_read_w0(adapter,
+ NetXen_NIU_GB_INTERFACE_STATUS(port->portnum),
+ &data_read);
+
+ if(data_written == data_read) {
+ netxen_nic_write_w0(
+ adapter, NetXen_NIU_GB_INTERFACE_STATUS(port->portnum),
+ save);
+
+ return 0;
+ }
+ } // GB Mode
+ return 1;
+}
+
+static int
+netxen_nic_diag_test_count(struct net_device *netdev)
+{
+ return NetXen_NIC_TEST_LEN;
+}
+
+static void
+netxen_nic_diag_test(struct net_device *netdev,
+ struct ethtool_test *eth_test, uint64_t *data)
+{
+ if(eth_test->flags == ETH_TEST_FL_OFFLINE) { // offline tests
+ // link test
+ if(!(data[4] = (uint64_t)netxen_nic_get_link(netdev)))
+ eth_test->flags |= ETH_TEST_FL_FAILED;
+
+ if(netif_running(netdev))
+ netdev->stop(netdev);
+
+ // register tests
+ if(!(data[0] = netxen_nic_reg_test(netdev)))
+ eth_test->flags |= ETH_TEST_FL_FAILED;
+ // other tests pass as of now
+ data[1] = data[2] = data[3] = 1;
+ if(netif_running(netdev))
+ netdev->open(netdev);
+ } else { // online tests
+ // link test
+ if(!(data[4] = (uint64_t)netxen_nic_get_link(netdev)))
+ eth_test->flags |= ETH_TEST_FL_FAILED;
+
+ // other tests pass by default
+ data[0] = data[1] = data[2] = data[3] = 1;
+ }
+}
+
+static void
+netxen_nic_get_strings(struct net_device *netdev, uint32_t stringset,
+ uint8_t *data)
+{
+ int i;
+
+ switch(stringset) {
+ case ETH_SS_TEST:
+ memcpy(data, *netxen_nic_gstrings_test,
+ NetXen_NIC_TEST_LEN*ETH_GSTRING_LEN);
+ break;
+ case ETH_SS_STATS:
+ for (i=0; i < NetXen_NIC_STATS_LEN; i++) {
+ memcpy(data + i * ETH_GSTRING_LEN,
+ netxen_nic_gstrings_stats[i].stat_string,
+ ETH_GSTRING_LEN);
+ }
+ break;
+ }
+}
+
+static int
+netxen_nic_get_stats_count(struct net_device *netdev)
+{
+ return NetXen_NIC_STATS_LEN;
+}
+
+/*
+ * NOTE: I have displayed only port's stats
+ * TBD: netxen_nic_stats(struct netxen_port * port) doesn't update stats
+ * as of now !! So this function may produce unexpected results !!
+ */
+static void
+netxen_nic_get_ethtool_stats(struct net_device *netdev,
+ struct ethtool_stats *stats, uint64_t *data)
+{
+ struct netxen_port *port = netdev->priv;
+ int i;
+
+ netxen_update_stats(port);
+
+ for(i = 0; i < NetXen_NIC_STATS_LEN; i++) {
+ char *p = (char
*)port+netxen_nic_gstrings_stats[i].stat_offset;
+ data[i] = (netxen_nic_gstrings_stats[i].sizeof_stat ==
+ sizeof(uint64_t)) ? *(uint64_t *)p : *(uint32_t *)p;
+ }
+
+}
+
+static struct ethtool_ops netxen_nic_ethtool_ops = {
+ .get_settings = netxen_nic_get_settings,
+ .set_settings = netxen_nic_set_settings,
+ .get_drvinfo = netxen_nic_get_drvinfo,
+ .get_regs_len = netxen_nic_get_regs_len,
+ .get_regs = netxen_nic_get_regs,
+ .get_wol = netxen_nic_get_wol,
+ .set_wol = netxen_nic_set_wol,
+ .get_msglevel = netxen_nic_get_msglevel,
+ .set_msglevel = netxen_nic_set_msglevel,
+ .nway_reset = netxen_nic_nway_reset,
+ .get_link = netxen_nic_get_link,
+ .get_eeprom_len = netxen_nic_get_eeprom_len,
+ .get_eeprom = netxen_nic_get_eeprom,
+ .get_ringparam = netxen_nic_get_ringparam,
+ .set_ringparam = netxen_nic_set_ringparam,
+ .get_pauseparam = netxen_nic_get_pauseparam,
+ .set_pauseparam = netxen_nic_set_pauseparam,
+ .get_rx_csum = netxen_nic_get_rx_csum,
+ .set_rx_csum = netxen_nic_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,
+#ifdef NETIF_F_TSO
+ .get_tso = ethtool_op_get_tso,
+ .set_tso = ethtool_op_set_tso,
+#endif
+ .self_test_count = netxen_nic_diag_test_count,
+ .self_test = netxen_nic_diag_test,
+ .get_strings = netxen_nic_get_strings,
+ .get_stats_count = netxen_nic_get_stats_count,
+ .get_ethtool_stats = netxen_nic_get_ethtool_stats,
+};
+
+void set_ethtool_ops(struct net_device *netdev)
+{
+ netdev->ethtool_ops = &netxen_nic_ethtool_ops;
+}
-
To unsubscribe from this list: send the line "unsubscribe netdev" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
