[PATCH] forcedeth config: statistics

This patch exposes hardware statistic counters through ethtool support.

Signed-Off-By: Ayaz Abdulla <aabdulla@nvidia.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>

diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index eaf6de9a9dfa8ffad887e2aa674839d53639ad08..2b8fbebd44ac2b24874bffd495e86b87ac44c53d 100644 (file)
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -165,6 +165,7 @@
 #define DEV_HAS_MSI_X           0x0080  /* device supports MSI-X */
 #define DEV_HAS_POWER_CNTRL     0x0100  /* device supports power savings */
 #define DEV_HAS_PAUSEFRAME_TX   0x0200  /* device supports tx pause frames */
+#define DEV_HAS_STATISTICS      0x0400  /* device supports hw statistics */
 
 enum {
        NvRegIrqStatus = 0x000,
@@ -333,6 +334,33 @@ enum {
 #define NVREG_POWERSTATE_D1            0x0001
 #define NVREG_POWERSTATE_D2            0x0002
 #define NVREG_POWERSTATE_D3            0x0003
+       NvRegTxCnt = 0x280,
+       NvRegTxZeroReXmt = 0x284,
+       NvRegTxOneReXmt = 0x288,
+       NvRegTxManyReXmt = 0x28c,
+       NvRegTxLateCol = 0x290,
+       NvRegTxUnderflow = 0x294,
+       NvRegTxLossCarrier = 0x298,
+       NvRegTxExcessDef = 0x29c,
+       NvRegTxRetryErr = 0x2a0,
+       NvRegRxFrameErr = 0x2a4,
+       NvRegRxExtraByte = 0x2a8,
+       NvRegRxLateCol = 0x2ac,
+       NvRegRxRunt = 0x2b0,
+       NvRegRxFrameTooLong = 0x2b4,
+       NvRegRxOverflow = 0x2b8,
+       NvRegRxFCSErr = 0x2bc,
+       NvRegRxFrameAlignErr = 0x2c0,
+       NvRegRxLenErr = 0x2c4,
+       NvRegRxUnicast = 0x2c8,
+       NvRegRxMulticast = 0x2cc,
+       NvRegRxBroadcast = 0x2d0,
+       NvRegTxDef = 0x2d4,
+       NvRegTxFrame = 0x2d8,
+       NvRegRxCnt = 0x2dc,
+       NvRegTxPause = 0x2e0,
+       NvRegRxPause = 0x2e4,
+       NvRegRxDropFrame = 0x2e8,
        NvRegVlanControl = 0x300,
 #define NVREG_VLANCONTROL_ENABLE       0x2000
        NvRegMSIXMap0 = 0x3e0,
@@ -481,6 +509,7 @@ typedef union _ring_type {
 #define OOM_REFILL     (1+HZ/20)
 #define POLL_WAIT      (1+HZ/100)
 #define LINK_TIMEOUT   (3*HZ)
+#define STATS_INTERVAL (10*HZ)
 
 /*
  * desc_ver values:
@@ -536,6 +565,75 @@ typedef union _ring_type {
 #define NV_MSI_X_VECTOR_TX    0x1
 #define NV_MSI_X_VECTOR_OTHER 0x2
 
+/* statistics */
+struct nv_ethtool_str {
+       char name[ETH_GSTRING_LEN];
+};
+
+static const struct nv_ethtool_str nv_estats_str[] = {
+       { "tx_bytes" },
+       { "tx_zero_rexmt" },
+       { "tx_one_rexmt" },
+       { "tx_many_rexmt" },
+       { "tx_late_collision" },
+       { "tx_fifo_errors" },
+       { "tx_carrier_errors" },
+       { "tx_excess_deferral" },
+       { "tx_retry_error" },
+       { "tx_deferral" },
+       { "tx_packets" },
+       { "tx_pause" },
+       { "rx_frame_error" },
+       { "rx_extra_byte" },
+       { "rx_late_collision" },
+       { "rx_runt" },
+       { "rx_frame_too_long" },
+       { "rx_over_errors" },
+       { "rx_crc_errors" },
+       { "rx_frame_align_error" },
+       { "rx_length_error" },
+       { "rx_unicast" },
+       { "rx_multicast" },
+       { "rx_broadcast" },
+       { "rx_bytes" },
+       { "rx_pause" },
+       { "rx_drop_frame" },
+       { "rx_packets" },
+       { "rx_errors_total" }
+};
+
+struct nv_ethtool_stats {
+       u64 tx_bytes;
+       u64 tx_zero_rexmt;
+       u64 tx_one_rexmt;
+       u64 tx_many_rexmt;
+       u64 tx_late_collision;
+       u64 tx_fifo_errors;
+       u64 tx_carrier_errors;
+       u64 tx_excess_deferral;
+       u64 tx_retry_error;
+       u64 tx_deferral;
+       u64 tx_packets;
+       u64 tx_pause;
+       u64 rx_frame_error;
+       u64 rx_extra_byte;
+       u64 rx_late_collision;
+       u64 rx_runt;
+       u64 rx_frame_too_long;
+       u64 rx_over_errors;
+       u64 rx_crc_errors;
+       u64 rx_frame_align_error;
+       u64 rx_length_error;
+       u64 rx_unicast;
+       u64 rx_multicast;
+       u64 rx_broadcast;
+       u64 rx_bytes;
+       u64 rx_pause;
+       u64 rx_drop_frame;
+       u64 rx_packets;
+       u64 rx_errors_total;
+};
+
 /*
  * SMP locking:
  * All hardware access under dev->priv->lock, except the performance
@@ -554,6 +652,7 @@ struct fe_priv {
        /* General data:
         * Locking: spin_lock(&np->lock); */
        struct net_device_stats stats;
+       struct nv_ethtool_stats estats;
        int in_shutdown;
        u32 linkspeed;
        int duplex;
@@ -588,6 +687,7 @@ struct fe_priv {
        unsigned int pkt_limit;
        struct timer_list oom_kick;
        struct timer_list nic_poll;
+       struct timer_list stats_poll;
        u32 nic_poll_irq;
        int rx_ring_size;
 
@@ -2471,6 +2571,56 @@ static void nv_poll_controller(struct net_device *dev)
 }
 #endif
 
+static void nv_do_stats_poll(unsigned long data)
+{
+       struct net_device *dev = (struct net_device *) data;
+       struct fe_priv *np = netdev_priv(dev);
+       u8 __iomem *base = get_hwbase(dev);
+
+       np->estats.tx_bytes += readl(base + NvRegTxCnt);
+       np->estats.tx_zero_rexmt += readl(base + NvRegTxZeroReXmt);
+       np->estats.tx_one_rexmt += readl(base + NvRegTxOneReXmt);
+       np->estats.tx_many_rexmt += readl(base + NvRegTxManyReXmt);
+       np->estats.tx_late_collision += readl(base + NvRegTxLateCol);
+       np->estats.tx_fifo_errors += readl(base + NvRegTxUnderflow);
+       np->estats.tx_carrier_errors += readl(base + NvRegTxLossCarrier);
+       np->estats.tx_excess_deferral += readl(base + NvRegTxExcessDef);
+       np->estats.tx_retry_error += readl(base + NvRegTxRetryErr);
+       np->estats.tx_deferral += readl(base + NvRegTxDef);
+       np->estats.tx_packets += readl(base + NvRegTxFrame);
+       np->estats.tx_pause += readl(base + NvRegTxPause);
+       np->estats.rx_frame_error += readl(base + NvRegRxFrameErr);
+       np->estats.rx_extra_byte += readl(base + NvRegRxExtraByte);
+       np->estats.rx_late_collision += readl(base + NvRegRxLateCol);
+       np->estats.rx_runt += readl(base + NvRegRxRunt);
+       np->estats.rx_frame_too_long += readl(base + NvRegRxFrameTooLong);
+       np->estats.rx_over_errors += readl(base + NvRegRxOverflow);
+       np->estats.rx_crc_errors += readl(base + NvRegRxFCSErr);
+       np->estats.rx_frame_align_error += readl(base + NvRegRxFrameAlignErr);
+       np->estats.rx_length_error += readl(base + NvRegRxLenErr);
+       np->estats.rx_unicast += readl(base + NvRegRxUnicast);
+       np->estats.rx_multicast += readl(base + NvRegRxMulticast);
+       np->estats.rx_broadcast += readl(base + NvRegRxBroadcast);
+       np->estats.rx_bytes += readl(base + NvRegRxCnt);
+       np->estats.rx_pause += readl(base + NvRegRxPause);
+       np->estats.rx_drop_frame += readl(base + NvRegRxDropFrame);
+       np->estats.rx_packets =
+               np->estats.rx_unicast +
+               np->estats.rx_multicast +
+               np->estats.rx_broadcast;
+       np->estats.rx_errors_total =
+               np->estats.rx_crc_errors +
+               np->estats.rx_over_errors +
+               np->estats.rx_frame_error +
+               (np->estats.rx_frame_align_error - np->estats.rx_extra_byte) +
+               np->estats.rx_late_collision +
+               np->estats.rx_runt +
+               np->estats.rx_frame_too_long;
+
+       if (!np->in_shutdown)
+               mod_timer(&np->stats_poll, jiffies + STATS_INTERVAL);
+}
+
 static void nv_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        struct fe_priv *np = netdev_priv(dev);
@@ -3084,6 +3234,35 @@ static int nv_set_sg(struct net_device *dev, u32 data)
                return -EOPNOTSUPP;
 }
 
+static int nv_get_stats_count(struct net_device *dev)
+{
+       struct fe_priv *np = netdev_priv(dev);
+
+       if (np->driver_data & DEV_HAS_STATISTICS)
+               return (sizeof(struct nv_ethtool_stats)/sizeof(u64));
+       else
+               return 0;
+}
+
+static void nv_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *buffer)
+{
+       struct fe_priv *np = netdev_priv(dev);
+
+       /* update stats */
+       nv_do_stats_poll((unsigned long)dev);
+
+       memcpy(buffer, &np->estats, nv_get_stats_count(dev)*sizeof(u64));
+}
+
+static void nv_get_strings(struct net_device *dev, u32 stringset, u8 *buffer)
+{
+       switch (stringset) {
+       case ETH_SS_STATS:
+               memcpy(buffer, &nv_estats_str, nv_get_stats_count(dev)*sizeof(struct nv_ethtool_str));
+               break;
+       }
+}
+
 static struct ethtool_ops ops = {
        .get_drvinfo = nv_get_drvinfo,
        .get_link = ethtool_op_get_link,
@@ -3107,6 +3286,9 @@ static struct ethtool_ops ops = {
        .set_tx_csum = nv_set_tx_csum,
        .get_sg = ethtool_op_get_sg,
        .set_sg = nv_set_sg,
+       .get_strings = nv_get_strings,
+       .get_stats_count = nv_get_stats_count,
+       .get_ethtool_stats = nv_get_ethtool_stats,
 };
 
 static void nv_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
@@ -3409,6 +3591,11 @@ static int nv_open(struct net_device *dev)
        }
        if (oom)
                mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
+
+       /* start statistics timer */
+       if (np->driver_data & DEV_HAS_STATISTICS)
+               mod_timer(&np->stats_poll, jiffies + STATS_INTERVAL);
+
        spin_unlock_irq(&np->lock);
 
        return 0;
@@ -3429,6 +3616,7 @@ static int nv_close(struct net_device *dev)
 
        del_timer_sync(&np->oom_kick);
        del_timer_sync(&np->nic_poll);
+       del_timer_sync(&np->stats_poll);
 
        netif_stop_queue(dev);
        spin_lock_irq(&np->lock);
@@ -3488,6 +3676,9 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        init_timer(&np->nic_poll);
        np->nic_poll.data = (unsigned long) dev;
        np->nic_poll.function = &nv_do_nic_poll;        /* timer handler */
+       init_timer(&np->stats_poll);
+       np->stats_poll.data = (unsigned long) dev;
+       np->stats_poll.function = &nv_do_stats_poll;    /* timer handler */
 
        err = pci_enable_device(pci_dev);
        if (err) {
@@ -3502,7 +3693,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        if (err < 0)
                goto out_disable;
 
-       if (id->driver_data & (DEV_HAS_VLAN|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL))
+       if (id->driver_data & (DEV_HAS_VLAN|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_STATISTICS))
                np->register_size = NV_PCI_REGSZ_VER2;
        else
                np->register_size = NV_PCI_REGSZ_VER1;
@@ -3858,11 +4049,11 @@ static struct pci_device_id pci_tbl[] = {
        },
        {       /* MCP55 Ethernet Controller */
                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_14),
-               .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX,
+               .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS,
        },
        {       /* MCP55 Ethernet Controller */
                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_15),
-               .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX,
+               .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS,
        },
        {0,},
 };