1 files changed, 89 insertions, 35 deletions

diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 65df1de447e4..d83512d3e02f 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -6145,6 +6145,10 @@ bnx2_enable_msix(struct bnx2 *bp, int msix_vecs)
         REG_WR(bp, BNX2_PCI_MSIX_TBL_OFF_BIR, BNX2_PCI_GRC_WINDOW2_BASE);
         REG_WR(bp, BNX2_PCI_MSIX_PBA_OFF_BIT, BNX2_PCI_GRC_WINDOW3_BASE);
 
+        /*  Need to flush the previous three writes to ensure MSI-X
+         *  is setup properly */
+        REG_RD(bp, BNX2_PCI_MSIX_CONTROL);
+
         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
                 msix_ent[i].entry = i;
                 msix_ent[i].vector = 0;
@@ -6227,6 +6231,8 @@ bnx2_open(struct net_device *dev)
 
         atomic_set(&bp->intr_sem, 0);
 
+        memset(bp->temp_stats_blk, 0, sizeof(struct statistics_block));
+
         bnx2_enable_int(bp);
 
         if (bp->flags & BNX2_FLAG_USING_MSI) {
@@ -6538,92 +6544,121 @@ bnx2_close(struct net_device *dev)
         return 0;
 }
 
-#define GET_NET_STATS64(ctr)                                    \
+static void
+bnx2_save_stats(struct bnx2 *bp)
+{
+        u32 *hw_stats = (u32 *) bp->stats_blk;
+        u32 *temp_stats = (u32 *) bp->temp_stats_blk;
+        int i;
+
+        /* The 1st 10 counters are 64-bit counters */
+        for (i = 0; i < 20; i += 2) {
+                u32 hi;
+                u64 lo;
+
+                hi = *(temp_stats + i) + *(hw_stats + i);
+                lo = *(temp_stats + i + 1) + *(hw_stats + i + 1);
+                if (lo > 0xffffffff)
+                        hi++;
+                *(temp_stats + i) = hi;
+                *(temp_stats + i + 1) = lo & 0xffffffff;
+        }
+
+        for ( ; i < sizeof(struct statistics_block) / 4; i++)
+                *(temp_stats + i) = *(temp_stats + i) + *(hw_stats + i);
+}
+
+#define GET_64BIT_NET_STATS64(ctr)                              \
         (unsigned long) ((unsigned long) (ctr##_hi) << 32) +    \
         (unsigned long) (ctr##_lo)
 
-#define GET_NET_STATS32(ctr)            \
+#define GET_64BIT_NET_STATS32(ctr)                              \
         (ctr##_lo)
 
 #if (BITS_PER_LONG == 64)
-#define GET_NET_STATS   GET_NET_STATS64
+#define GET_64BIT_NET_STATS(ctr)                                \
+        GET_64BIT_NET_STATS64(bp->stats_blk->ctr) +             \
+        GET_64BIT_NET_STATS64(bp->temp_stats_blk->ctr)
 #else
-#define GET_NET_STATS   GET_NET_STATS32
+#define GET_64BIT_NET_STATS(ctr)                                \
+        GET_64BIT_NET_STATS32(bp->stats_blk->ctr) +             \
+        GET_64BIT_NET_STATS32(bp->temp_stats_blk->ctr)
 #endif
 
+#define GET_32BIT_NET_STATS(ctr)                                \
+        (unsigned long) (bp->stats_blk->ctr +                   \
+                         bp->temp_stats_blk->ctr)
+
 static struct net_device_stats *
 bnx2_get_stats(struct net_device *dev)
 {
         struct bnx2 *bp = netdev_priv(dev);
-        struct statistics_block *stats_blk = bp->stats_blk;
         struct net_device_stats *net_stats = &dev->stats;
 
         if (bp->stats_blk == NULL) {
                 return net_stats;
         }
         net_stats->rx_packets =
-                GET_NET_STATS(stats_blk->stat_IfHCInUcastPkts) +
-                GET_NET_STATS(stats_blk->stat_IfHCInMulticastPkts) +
-                GET_NET_STATS(stats_blk->stat_IfHCInBroadcastPkts);
+                GET_64BIT_NET_STATS(stat_IfHCInUcastPkts) +
+                GET_64BIT_NET_STATS(stat_IfHCInMulticastPkts) +
+                GET_64BIT_NET_STATS(stat_IfHCInBroadcastPkts);
 
         net_stats->tx_packets =
-                GET_NET_STATS(stats_blk->stat_IfHCOutUcastPkts) +
-                GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts) +
-                GET_NET_STATS(stats_blk->stat_IfHCOutBroadcastPkts);
+                GET_64BIT_NET_STATS(stat_IfHCOutUcastPkts) +
+                GET_64BIT_NET_STATS(stat_IfHCOutMulticastPkts) +
+                GET_64BIT_NET_STATS(stat_IfHCOutBroadcastPkts);
 
         net_stats->rx_bytes =
-                GET_NET_STATS(stats_blk->stat_IfHCInOctets);
+                GET_64BIT_NET_STATS(stat_IfHCInOctets);
 
         net_stats->tx_bytes =
-                GET_NET_STATS(stats_blk->stat_IfHCOutOctets);
+                GET_64BIT_NET_STATS(stat_IfHCOutOctets);
 
         net_stats->multicast =
-                GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts);
+                GET_64BIT_NET_STATS(stat_IfHCOutMulticastPkts);
 
         net_stats->collisions =
-                (unsigned long) stats_blk->stat_EtherStatsCollisions;
+                GET_32BIT_NET_STATS(stat_EtherStatsCollisions);
 
         net_stats->rx_length_errors =
-                (unsigned long) (stats_blk->stat_EtherStatsUndersizePkts +
-                stats_blk->stat_EtherStatsOverrsizePkts);
+                GET_32BIT_NET_STATS(stat_EtherStatsUndersizePkts) +
+                GET_32BIT_NET_STATS(stat_EtherStatsOverrsizePkts);
 
         net_stats->rx_over_errors =
-                (unsigned long) (stats_blk->stat_IfInFTQDiscards +
-                stats_blk->stat_IfInMBUFDiscards);
+                GET_32BIT_NET_STATS(stat_IfInFTQDiscards) +
+                GET_32BIT_NET_STATS(stat_IfInMBUFDiscards);
 
         net_stats->rx_frame_errors =
-                (unsigned long) stats_blk->stat_Dot3StatsAlignmentErrors;
+                GET_32BIT_NET_STATS(stat_Dot3StatsAlignmentErrors);
 
         net_stats->rx_crc_errors =
-                (unsigned long) stats_blk->stat_Dot3StatsFCSErrors;
+                GET_32BIT_NET_STATS(stat_Dot3StatsFCSErrors);
 
         net_stats->rx_errors = net_stats->rx_length_errors +
                 net_stats->rx_over_errors + net_stats->rx_frame_errors +
                 net_stats->rx_crc_errors;
 
         net_stats->tx_aborted_errors =
-                (unsigned long) (stats_blk->stat_Dot3StatsExcessiveCollisions +
-                stats_blk->stat_Dot3StatsLateCollisions);
+                GET_32BIT_NET_STATS(stat_Dot3StatsExcessiveCollisions) +
+                GET_32BIT_NET_STATS(stat_Dot3StatsLateCollisions);
 
         if ((CHIP_NUM(bp) == CHIP_NUM_5706) ||
             (CHIP_ID(bp) == CHIP_ID_5708_A0))
                 net_stats->tx_carrier_errors = 0;
         else {
                 net_stats->tx_carrier_errors =
-                        (unsigned long)
-                        stats_blk->stat_Dot3StatsCarrierSenseErrors;
+                        GET_32BIT_NET_STATS(stat_Dot3StatsCarrierSenseErrors);
         }
 
         net_stats->tx_errors =
-                (unsigned long)
-                stats_blk->stat_emac_tx_stat_dot3statsinternalmactransmiterrors
-                +
+                GET_32BIT_NET_STATS(stat_emac_tx_stat_dot3statsinternalmactransmiterrors) +
                 net_stats->tx_aborted_errors +
                 net_stats->tx_carrier_errors;
 
         net_stats->rx_missed_errors =
-                (unsigned long) (stats_blk->stat_IfInFTQDiscards +
-                stats_blk->stat_IfInMBUFDiscards + stats_blk->stat_FwRxDrop);
+                GET_32BIT_NET_STATS(stat_IfInFTQDiscards) +
+                GET_32BIT_NET_STATS(stat_IfInMBUFDiscards) +
+                GET_32BIT_NET_STATS(stat_FwRxDrop);
 
         return net_stats;
 }
@@ -7083,6 +7118,9 @@ static int
 bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx)
 {
         if (netif_running(bp->dev)) {
+                /* Reset will erase chipset stats; save them */
+                bnx2_save_stats(bp);
+
                 bnx2_netif_stop(bp);
                 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
                 bnx2_free_skbs(bp);
@@ -7427,6 +7465,7 @@ bnx2_get_ethtool_stats(struct net_device *dev,
         struct bnx2 *bp = netdev_priv(dev);
         int i;
         u32 *hw_stats = (u32 *) bp->stats_blk;
+        u32 *temp_stats = (u32 *) bp->temp_stats_blk;
         u8 *stats_len_arr = NULL;
 
         if (hw_stats == NULL) {
@@ -7443,21 +7482,26 @@ bnx2_get_ethtool_stats(struct net_device *dev,
                 stats_len_arr = bnx2_5708_stats_len_arr;
 
         for (i = 0; i < BNX2_NUM_STATS; i++) {
+                unsigned long offset;
+
                 if (stats_len_arr[i] == 0) {
                         /* skip this counter */
                         buf[i] = 0;
                         continue;
                 }
+
+                offset = bnx2_stats_offset_arr[i];
                 if (stats_len_arr[i] == 4) {
                         /* 4-byte counter */
-                        buf[i] = (u64)
-                                *(hw_stats + bnx2_stats_offset_arr[i]);
+                        buf[i] = (u64) *(hw_stats + offset) +
+                                 *(temp_stats + offset);
                         continue;
                 }
                 /* 8-byte counter */
-                buf[i] = (((u64) *(hw_stats +
-                                        bnx2_stats_offset_arr[i])) << 32) +
-                                *(hw_stats + bnx2_stats_offset_arr[i] + 1);
+                buf[i] = (((u64) *(hw_stats + offset)) << 32) +
+                         *(hw_stats + offset + 1) +
+                         (((u64) *(temp_stats + offset)) << 32) +
+                         *(temp_stats + offset + 1);
         }
 }
 
@@ -7825,6 +7869,14 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         bp->flags = 0;
         bp->phy_flags = 0;
 
+        bp->temp_stats_blk =
+                kzalloc(sizeof(struct statistics_block), GFP_KERNEL);
+
+        if (bp->temp_stats_blk == NULL) {
+                rc = -ENOMEM;
+                goto err_out;
+        }
+
         /* enable device (incl. PCI PM wakeup), and bus-mastering */
         rc = pci_enable_device(pdev);
         if (rc) {
@@ -8346,6 +8398,8 @@ bnx2_remove_one(struct pci_dev *pdev)
         if (bp->regview)
                 iounmap(bp->regview);
 
+        kfree(bp->temp_stats_blk);
+
         free_netdev(dev);
         pci_release_regions(pdev);
         pci_disable_device(pdev);