1 files changed, 95 insertions, 62 deletions

diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index d6577084ce70..39996bf3b247 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -1917,8 +1917,10 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
                         netif_printk(sky2, tx_done, KERN_DEBUG, dev,
                                      "tx done %u\n", idx);
 
-                        dev->stats.tx_packets++;
-                        dev->stats.tx_bytes += skb->len;
+                        u64_stats_update_begin(&sky2->tx_stats.syncp);
+                        ++sky2->tx_stats.packets;
+                        sky2->tx_stats.bytes += skb->len;
+                        u64_stats_update_end(&sky2->tx_stats.syncp);
 
                         re->skb = NULL;
                         dev_kfree_skb_any(skb);
@@ -2460,7 +2462,7 @@ static struct sk_buff *sky2_receive(struct net_device *dev,
 
         /* if length reported by DMA does not match PHY, packet was truncated */
         if (length != count)
-                goto len_error;
+                goto error;
 
 okay:
         if (length < copybreak)
@@ -2475,34 +2477,13 @@ resubmit:
 
         return skb;
 
-len_error:
-        /* Truncation of overlength packets
-           causes PHY length to not match MAC length */
-        ++dev->stats.rx_length_errors;
-        if (net_ratelimit())
-                netif_info(sky2, rx_err, dev,
-                           "rx length error: status %#x length %d\n",
-                           status, length);
-        goto resubmit;
-
 error:
         ++dev->stats.rx_errors;
-        if (status & GMR_FS_RX_FF_OV) {
-                dev->stats.rx_over_errors++;
-                goto resubmit;
-        }
 
         if (net_ratelimit())
                 netif_info(sky2, rx_err, dev,
                            "rx error, status 0x%x length %d\n", status, length);
 
-        if (status & (GMR_FS_LONG_ERR | GMR_FS_UN_SIZE))
-                dev->stats.rx_length_errors++;
-        if (status & GMR_FS_FRAGMENT)
-                dev->stats.rx_frame_errors++;
-        if (status & GMR_FS_CRC_ERR)
-                dev->stats.rx_crc_errors++;
-
         goto resubmit;
 }
 
@@ -2543,14 +2524,19 @@ static inline void sky2_skb_rx(const struct sky2_port *sky2,
 static inline void sky2_rx_done(struct sky2_hw *hw, unsigned port,
                                 unsigned packets, unsigned bytes)
 {
-        if (packets) {
-                struct net_device *dev = hw->dev[port];
+        struct net_device *dev = hw->dev[port];
+        struct sky2_port *sky2 = netdev_priv(dev);
 
-                dev->stats.rx_packets += packets;
-                dev->stats.rx_bytes += bytes;
-                dev->last_rx = jiffies;
-                sky2_rx_update(netdev_priv(dev), rxqaddr[port]);
-        }
+        if (packets == 0)
+                return;
+
+        u64_stats_update_begin(&sky2->rx_stats.syncp);
+        sky2->rx_stats.packets += packets;
+        sky2->rx_stats.bytes += bytes;
+        u64_stats_update_end(&sky2->rx_stats.syncp);
+
+        dev->last_rx = jiffies;
+        sky2_rx_update(netdev_priv(dev), rxqaddr[port]);
 }
 
 static void sky2_rx_checksum(struct sky2_port *sky2, u32 status)
@@ -3398,12 +3384,24 @@ static int sky2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
         struct sky2_port *sky2 = netdev_priv(dev);
         struct sky2_hw *hw = sky2->hw;
+        bool enable_wakeup = false;
+        int i;
 
         if ((wol->wolopts & ~sky2_wol_supported(sky2->hw)) ||
             !device_can_wakeup(&hw->pdev->dev))
                 return -EOPNOTSUPP;
 
         sky2->wol = wol->wolopts;
+
+        for (i = 0; i < hw->ports; i++) {
+                struct net_device *dev = hw->dev[i];
+                struct sky2_port *sky2 = netdev_priv(dev);
+
+                if (sky2->wol)
+                        enable_wakeup = true;
+        }
+        device_set_wakeup_enable(&hw->pdev->dev, enable_wakeup);
+
         return 0;
 }
 
@@ -3614,13 +3612,11 @@ static void sky2_phy_stats(struct sky2_port *sky2, u64 * data, unsigned count)
         unsigned port = sky2->port;
         int i;
 
-        data[0] = (u64) gma_read32(hw, port, GM_TXO_OK_HI) << 32
-            | (u64) gma_read32(hw, port, GM_TXO_OK_LO);
-        data[1] = (u64) gma_read32(hw, port, GM_RXO_OK_HI) << 32
-            | (u64) gma_read32(hw, port, GM_RXO_OK_LO);
+        data[0] = get_stats64(hw, port, GM_TXO_OK_LO);
+        data[1] = get_stats64(hw, port, GM_RXO_OK_LO);
 
         for (i = 2; i < count; i++)
-                data[i] = (u64) gma_read32(hw, port, sky2_stats[i].offset);
+                data[i] = get_stats32(hw, port, sky2_stats[i].offset);
 }
 
 static void sky2_set_msglevel(struct net_device *netdev, u32 value)
@@ -3738,6 +3734,51 @@ static void sky2_set_multicast(struct net_device *dev)
         gma_write16(hw, port, GM_RX_CTRL, reg);
 }
 
+static struct rtnl_link_stats64 *sky2_get_stats(struct net_device *dev,
+                                                struct rtnl_link_stats64 *stats)
+{
+        struct sky2_port *sky2 = netdev_priv(dev);
+        struct sky2_hw *hw = sky2->hw;
+        unsigned port = sky2->port;
+        unsigned int start;
+        u64 _bytes, _packets;
+
+        do {
+                start = u64_stats_fetch_begin_bh(&sky2->rx_stats.syncp);
+                _bytes = sky2->rx_stats.bytes;
+                _packets = sky2->rx_stats.packets;
+        } while (u64_stats_fetch_retry_bh(&sky2->rx_stats.syncp, start));
+
+        stats->rx_packets = _packets;
+        stats->rx_bytes = _bytes;
+
+        do {
+                start = u64_stats_fetch_begin_bh(&sky2->tx_stats.syncp);
+                _bytes = sky2->tx_stats.bytes;
+                _packets = sky2->tx_stats.packets;
+        } while (u64_stats_fetch_retry_bh(&sky2->tx_stats.syncp, start));
+
+        stats->tx_packets = _packets;
+        stats->tx_bytes = _bytes;
+
+        stats->multicast = get_stats32(hw, port, GM_RXF_MC_OK)
+                + get_stats32(hw, port, GM_RXF_BC_OK);
+
+        stats->collisions = get_stats32(hw, port, GM_TXF_COL);
+
+        stats->rx_length_errors = get_stats32(hw, port, GM_RXF_LNG_ERR);
+        stats->rx_crc_errors = get_stats32(hw, port, GM_RXF_FCS_ERR);
+        stats->rx_frame_errors = get_stats32(hw, port, GM_RXF_SHT)
+                + get_stats32(hw, port, GM_RXE_FRAG);
+        stats->rx_over_errors = get_stats32(hw, port, GM_RXE_FIFO_OV);
+
+        stats->rx_dropped = dev->stats.rx_dropped;
+        stats->rx_fifo_errors = dev->stats.rx_fifo_errors;
+        stats->tx_fifo_errors = dev->stats.tx_fifo_errors;
+
+        return stats;
+}
+
 /* Can have one global because blinking is controlled by
  * ethtool and that is always under RTNL mutex
  */
@@ -4512,6 +4553,7 @@ static const struct net_device_ops sky2_netdev_ops[2] = {
         .ndo_set_multicast_list = sky2_set_multicast,
         .ndo_change_mtu         = sky2_change_mtu,
         .ndo_tx_timeout         = sky2_tx_timeout,
+        .ndo_get_stats64        = sky2_get_stats,
 #ifdef SKY2_VLAN_TAG_USED
         .ndo_vlan_rx_register   = sky2_vlan_rx_register,
 #endif
@@ -4529,6 +4571,7 @@ static const struct net_device_ops sky2_netdev_ops[2] = {
         .ndo_set_multicast_list = sky2_set_multicast,
         .ndo_change_mtu         = sky2_change_mtu,
         .ndo_tx_timeout         = sky2_tx_timeout,
+        .ndo_get_stats64        = sky2_get_stats,
 #ifdef SKY2_VLAN_TAG_USED
         .ndo_vlan_rx_register   = sky2_vlan_rx_register,
 #endif
@@ -4920,10 +4963,11 @@ static void __devexit sky2_remove(struct pci_dev *pdev)
         pci_set_drvdata(pdev, NULL);
 }
 
-static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
+static int sky2_suspend(struct device *dev)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         struct sky2_hw *hw = pci_get_drvdata(pdev);
-        int i, wol = 0;
+        int i;
 
         if (!hw)
                 return 0;
@@ -4940,41 +4984,24 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
 
                 if (sky2->wol)
                         sky2_wol_init(sky2);
-
-                wol |= sky2->wol;
         }
 
-        device_set_wakeup_enable(&pdev->dev, wol != 0);
-
         sky2_power_aux(hw);
         rtnl_unlock();
 
-        pci_save_state(pdev);
-        pci_enable_wake(pdev, pci_choose_state(pdev, state), wol);
-        pci_set_power_state(pdev, pci_choose_state(pdev, state));
-
         return 0;
 }
 
 #ifdef CONFIG_PM
-static int sky2_resume(struct pci_dev *pdev)
+static int sky2_resume(struct device *dev)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         struct sky2_hw *hw = pci_get_drvdata(pdev);
         int err;
 
         if (!hw)
                 return 0;
 
-        err = pci_set_power_state(pdev, PCI_D0);
-        if (err)
-                goto out;
-
-        err = pci_restore_state(pdev);
-        if (err)
-                goto out;
-
-        pci_enable_wake(pdev, PCI_D0, 0);
-
         /* Re-enable all clocks */
         err = pci_write_config_dword(pdev, PCI_DEV_REG3, 0);
         if (err) {
@@ -4994,11 +5021,20 @@ out:
         pci_disable_device(pdev);
         return err;
 }
+
+static SIMPLE_DEV_PM_OPS(sky2_pm_ops, sky2_suspend, sky2_resume);
+#define SKY2_PM_OPS (&sky2_pm_ops)
+
+#else
+
+#define SKY2_PM_OPS NULL
 #endif
 
 static void sky2_shutdown(struct pci_dev *pdev)
 {
-        sky2_suspend(pdev, PMSG_SUSPEND);
+        sky2_suspend(&pdev->dev);
+        pci_wake_from_d3(pdev, device_may_wakeup(&pdev->dev));
+        pci_set_power_state(pdev, PCI_D3hot);
 }
 
 static struct pci_driver sky2_driver = {
@@ -5006,11 +5042,8 @@ static struct pci_driver sky2_driver = {
         .id_table = sky2_id_table,
         .probe = sky2_probe,
         .remove = __devexit_p(sky2_remove),
-#ifdef CONFIG_PM
-        .suspend = sky2_suspend,
-        .resume = sky2_resume,
-#endif
         .shutdown = sky2_shutdown,
+        .driver.pm = SKY2_PM_OPS,
 };
 
 static int __init sky2_init_module(void)