net: convert multicast list to list_head
[linux-2.6.git] / drivers / net / r8169.c
index fa49356..64cd250 100644 (file)
@@ -23,6 +23,7 @@
 #include <linux/tcp.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
+#include <linux/pm_runtime.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
@@ -168,7 +169,7 @@ static void rtl_hw_start_8169(struct net_device *);
 static void rtl_hw_start_8168(struct net_device *);
 static void rtl_hw_start_8101(struct net_device *);
 
-static struct pci_device_id rtl8169_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(rtl8169_pci_tbl) = {
        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8129), 0, 0, RTL_CFG_0 },
        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8136), 0, 0, RTL_CFG_2 },
        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8167), 0, 0, RTL_CFG_0 },
@@ -187,7 +188,7 @@ static struct pci_device_id rtl8169_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl);
 
 static int rx_copybreak = 200;
-static int use_dac;
+static int use_dac = -1;
 static struct {
        u32 msg_enable;
 } debug = { -1 };
@@ -504,6 +505,7 @@ struct rtl8169_private {
 
        struct mii_if_info mii;
        struct rtl8169_counters counters;
+       u32 saved_wolopts;
 };
 
 MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>");
@@ -511,7 +513,8 @@ MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver");
 module_param(rx_copybreak, int, 0);
 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
 module_param(use_dac, int, 0);
-MODULE_PARM_DESC(use_dac, "Enable PCI DAC. Unsafe on 32 bit PCI slot.");
+MODULE_PARM_DESC(use_dac, "Enable PCI DAC. -1 defaults on for PCI Express only."
+" Unsafe on 32 bit PCI slot.");
 module_param_named(debug, debug.msg_enable, int, 0);
 MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)");
 MODULE_LICENSE("GPL");
@@ -743,58 +746,64 @@ static void rtl8169_check_link_status(struct net_device *dev,
 
        spin_lock_irqsave(&tp->lock, flags);
        if (tp->link_ok(ioaddr)) {
+               /* This is to cancel a scheduled suspend if there's one. */
+               pm_request_resume(&tp->pci_dev->dev);
                netif_carrier_on(dev);
-               if (netif_msg_ifup(tp))
-                       printk(KERN_INFO PFX "%s: link up\n", dev->name);
+               netif_info(tp, ifup, dev, "link up\n");
        } else {
-               if (netif_msg_ifdown(tp))
-                       printk(KERN_INFO PFX "%s: link down\n", dev->name);
                netif_carrier_off(dev);
+               netif_info(tp, ifdown, dev, "link down\n");
+               pm_schedule_suspend(&tp->pci_dev->dev, 100);
        }
        spin_unlock_irqrestore(&tp->lock, flags);
 }
 
-static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+#define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST)
+
+static u32 __rtl8169_get_wol(struct rtl8169_private *tp)
 {
-       struct rtl8169_private *tp = netdev_priv(dev);
        void __iomem *ioaddr = tp->mmio_addr;
        u8 options;
-
-       wol->wolopts = 0;
-
-#define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST)
-       wol->supported = WAKE_ANY;
-
-       spin_lock_irq(&tp->lock);
+       u32 wolopts = 0;
 
        options = RTL_R8(Config1);
        if (!(options & PMEnable))
-               goto out_unlock;
+               return 0;
 
        options = RTL_R8(Config3);
        if (options & LinkUp)
-               wol->wolopts |= WAKE_PHY;
+               wolopts |= WAKE_PHY;
        if (options & MagicPacket)
-               wol->wolopts |= WAKE_MAGIC;
+               wolopts |= WAKE_MAGIC;
 
        options = RTL_R8(Config5);
        if (options & UWF)
-               wol->wolopts |= WAKE_UCAST;
+               wolopts |= WAKE_UCAST;
        if (options & BWF)
-               wol->wolopts |= WAKE_BCAST;
+               wolopts |= WAKE_BCAST;
        if (options & MWF)
-               wol->wolopts |= WAKE_MCAST;
+               wolopts |= WAKE_MCAST;
 
-out_unlock:
-       spin_unlock_irq(&tp->lock);
+       return wolopts;
 }
 
-static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
        struct rtl8169_private *tp = netdev_priv(dev);
+
+       spin_lock_irq(&tp->lock);
+
+       wol->supported = WAKE_ANY;
+       wol->wolopts = __rtl8169_get_wol(tp);
+
+       spin_unlock_irq(&tp->lock);
+}
+
+static void __rtl8169_set_wol(struct rtl8169_private *tp, u32 wolopts)
+{
        void __iomem *ioaddr = tp->mmio_addr;
        unsigned int i;
-       static struct {
+       static const struct {
                u32 opt;
                u16 reg;
                u8  mask;
@@ -808,23 +817,29 @@ static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
                { WAKE_ANY,   Config5, LanWake }
        };
 
-       spin_lock_irq(&tp->lock);
-
        RTL_W8(Cfg9346, Cfg9346_Unlock);
 
        for (i = 0; i < ARRAY_SIZE(cfg); i++) {
                u8 options = RTL_R8(cfg[i].reg) & ~cfg[i].mask;
-               if (wol->wolopts & cfg[i].opt)
+               if (wolopts & cfg[i].opt)
                        options |= cfg[i].mask;
                RTL_W8(cfg[i].reg, options);
        }
 
        RTL_W8(Cfg9346, Cfg9346_Lock);
+}
+
+static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+{
+       struct rtl8169_private *tp = netdev_priv(dev);
+
+       spin_lock_irq(&tp->lock);
 
        if (wol->wolopts)
                tp->features |= RTL_FEATURE_WOL;
        else
                tp->features &= ~RTL_FEATURE_WOL;
+       __rtl8169_set_wol(tp, wol->wolopts);
        device_set_wakeup_enable(&tp->pci_dev->dev, wol->wolopts);
 
        spin_unlock_irq(&tp->lock);
@@ -862,11 +877,8 @@ static int rtl8169_set_speed_tbi(struct net_device *dev,
        } else if (autoneg == AUTONEG_ENABLE)
                RTL_W32(TBICSR, reg | TBINwEnable | TBINwRestart);
        else {
-               if (netif_msg_link(tp)) {
-                       printk(KERN_WARNING "%s: "
-                              "incorrect speed setting refused in TBI mode\n",
-                              dev->name);
-               }
+               netif_warn(tp, link, dev,
+                          "incorrect speed setting refused in TBI mode\n");
                ret = -EOPNOTSUPP;
        }
 
@@ -901,9 +913,9 @@ static int rtl8169_set_speed_xmii(struct net_device *dev,
                    (tp->mac_version != RTL_GIGA_MAC_VER_15) &&
                    (tp->mac_version != RTL_GIGA_MAC_VER_16)) {
                        giga_ctrl |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
-               } else if (netif_msg_link(tp)) {
-                       printk(KERN_INFO "%s: PHY does not support 1000Mbps.\n",
-                              dev->name);
+               } else {
+                       netif_info(tp, link, dev,
+                                  "PHY does not support 1000Mbps\n");
                }
 
                bmcr = BMCR_ANENABLE | BMCR_ANRESTART;
@@ -1042,14 +1054,14 @@ static void rtl8169_vlan_rx_register(struct net_device *dev,
 }
 
 static int rtl8169_rx_vlan_skb(struct rtl8169_private *tp, struct RxDesc *desc,
-                              struct sk_buff *skb)
+                              struct sk_buff *skb, int polling)
 {
        u32 opts2 = le32_to_cpu(desc->opts2);
        struct vlan_group *vlgrp = tp->vlgrp;
        int ret;
 
        if (vlgrp && (opts2 & RxVlanTag)) {
-               vlan_hwaccel_receive_skb(skb, vlgrp, swab16(opts2 & 0xffff));
+               __vlan_hwaccel_rx(skb, vlgrp, swab16(opts2 & 0xffff), polling);
                ret = 0;
        } else
                ret = -1;
@@ -1066,7 +1078,7 @@ static inline u32 rtl8169_tx_vlan_tag(struct rtl8169_private *tp,
 }
 
 static int rtl8169_rx_vlan_skb(struct rtl8169_private *tp, struct RxDesc *desc,
-                              struct sk_buff *skb)
+                              struct sk_buff *skb, int polling)
 {
        return -1;
 }
@@ -1277,7 +1289,7 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
         *
         * (RTL_R32(TxConfig) & 0x700000) == 0x200000 ? 8101Eb : 8101Ec
         */
-       const struct {
+       static const struct {
                u32 mask;
                u32 val;
                int mac_version;
@@ -1351,7 +1363,7 @@ struct phy_reg {
        u16 val;
 };
 
-static void rtl_phy_write(void __iomem *ioaddr, struct phy_reg *regs, int len)
+static void rtl_phy_write(void __iomem *ioaddr, const struct phy_reg *regs, int len)
 {
        while (len-- > 0) {
                mdio_write(ioaddr, regs->reg, regs->val);
@@ -1361,7 +1373,7 @@ static void rtl_phy_write(void __iomem *ioaddr, struct phy_reg *regs, int len)
 
 static void rtl8169s_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x06, 0x006e },
                { 0x08, 0x0708 },
@@ -1428,7 +1440,7 @@ static void rtl8169s_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8169sb_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0002 },
                { 0x01, 0x90d0 },
                { 0x1f, 0x0000 }
@@ -1457,7 +1469,7 @@ static void rtl8169scd_hw_phy_config_quirk(struct rtl8169_private *tp,
 static void rtl8169scd_hw_phy_config(struct rtl8169_private *tp,
                                     void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x04, 0x0000 },
                { 0x03, 0x00a1 },
@@ -1504,7 +1516,7 @@ static void rtl8169scd_hw_phy_config(struct rtl8169_private *tp,
 
 static void rtl8169sce_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x04, 0x0000 },
                { 0x03, 0x00a1 },
@@ -1557,7 +1569,7 @@ static void rtl8169sce_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168bb_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x10, 0xf41b },
                { 0x1f, 0x0000 }
        };
@@ -1570,7 +1582,7 @@ static void rtl8168bb_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168bef_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x10, 0xf41b },
                { 0x1f, 0x0000 }
@@ -1581,7 +1593,7 @@ static void rtl8168bef_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168cp_1_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0000 },
                { 0x1d, 0x0f00 },
                { 0x1f, 0x0002 },
@@ -1594,7 +1606,7 @@ static void rtl8168cp_1_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168cp_2_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x1d, 0x3d98 },
                { 0x1f, 0x0000 }
@@ -1609,7 +1621,7 @@ static void rtl8168cp_2_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168c_1_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x12, 0x2300 },
                { 0x1f, 0x0002 },
@@ -1638,7 +1650,7 @@ static void rtl8168c_1_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168c_2_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x12, 0x2300 },
                { 0x03, 0x802f },
@@ -1666,7 +1678,7 @@ static void rtl8168c_2_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168c_3_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0001 },
                { 0x12, 0x2300 },
                { 0x1d, 0x3d98 },
@@ -1693,7 +1705,7 @@ static void rtl8168c_4_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
 {
-       static struct phy_reg phy_reg_init_0[] = {
+       static const struct phy_reg phy_reg_init_0[] = {
                { 0x1f, 0x0001 },
                { 0x06, 0x4064 },
                { 0x07, 0x2863 },
@@ -1712,14 +1724,14 @@ static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
                { 0x1a, 0x05ad },
                { 0x14, 0x94c0 }
        };
-       static struct phy_reg phy_reg_init_1[] = {
+       static const struct phy_reg phy_reg_init_1[] = {
                { 0x1f, 0x0002 },
                { 0x06, 0x5561 },
                { 0x1f, 0x0005 },
                { 0x05, 0x8332 },
                { 0x06, 0x5561 }
        };
-       static struct phy_reg phy_reg_init_2[] = {
+       static const struct phy_reg phy_reg_init_2[] = {
                { 0x1f, 0x0005 },
                { 0x05, 0xffc2 },
                { 0x1f, 0x0005 },
@@ -2084,7 +2096,7 @@ static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
        rtl_phy_write(ioaddr, phy_reg_init_1, ARRAY_SIZE(phy_reg_init_1));
 
        if (rtl8168d_efuse_read(ioaddr, 0x01) == 0xb1) {
-               struct phy_reg phy_reg_init[] = {
+               static const struct phy_reg phy_reg_init[] = {
                        { 0x1f, 0x0002 },
                        { 0x05, 0x669a },
                        { 0x1f, 0x0005 },
@@ -2099,7 +2111,7 @@ static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
                val = mdio_read(ioaddr, 0x0d);
 
                if ((val & 0x00ff) != 0x006c) {
-                       u32 set[] = {
+                       static const u32 set[] = {
                                0x0065, 0x0066, 0x0067, 0x0068,
                                0x0069, 0x006a, 0x006b, 0x006c
                        };
@@ -2112,7 +2124,7 @@ static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
                                mdio_write(ioaddr, 0x0d, val | set[i]);
                }
        } else {
-               struct phy_reg phy_reg_init[] = {
+               static const struct phy_reg phy_reg_init[] = {
                        { 0x1f, 0x0002 },
                        { 0x05, 0x6662 },
                        { 0x1f, 0x0005 },
@@ -2136,7 +2148,7 @@ static void rtl8168d_1_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168d_2_hw_phy_config(void __iomem *ioaddr)
 {
-       static struct phy_reg phy_reg_init_0[] = {
+       static const struct phy_reg phy_reg_init_0[] = {
                { 0x1f, 0x0001 },
                { 0x06, 0x4064 },
                { 0x07, 0x2863 },
@@ -2161,7 +2173,7 @@ static void rtl8168d_2_hw_phy_config(void __iomem *ioaddr)
                { 0x05, 0x8332 },
                { 0x06, 0x5561 }
        };
-       static struct phy_reg phy_reg_init_1[] = {
+       static const struct phy_reg phy_reg_init_1[] = {
                { 0x1f, 0x0005 },
                { 0x05, 0xffc2 },
                { 0x1f, 0x0005 },
@@ -2477,7 +2489,7 @@ static void rtl8168d_2_hw_phy_config(void __iomem *ioaddr)
        rtl_phy_write(ioaddr, phy_reg_init_0, ARRAY_SIZE(phy_reg_init_0));
 
        if (rtl8168d_efuse_read(ioaddr, 0x01) == 0xb1) {
-               struct phy_reg phy_reg_init[] = {
+               static const struct phy_reg phy_reg_init[] = {
                        { 0x1f, 0x0002 },
                        { 0x05, 0x669a },
                        { 0x1f, 0x0005 },
@@ -2505,7 +2517,7 @@ static void rtl8168d_2_hw_phy_config(void __iomem *ioaddr)
                                mdio_write(ioaddr, 0x0d, val | set[i]);
                }
        } else {
-               struct phy_reg phy_reg_init[] = {
+               static const struct phy_reg phy_reg_init[] = {
                        { 0x1f, 0x0002 },
                        { 0x05, 0x2642 },
                        { 0x1f, 0x0005 },
@@ -2531,7 +2543,7 @@ static void rtl8168d_2_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8168d_3_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0002 },
                { 0x10, 0x0008 },
                { 0x0d, 0x006c },
@@ -2592,7 +2604,7 @@ static void rtl8168d_3_hw_phy_config(void __iomem *ioaddr)
 
 static void rtl8102e_hw_phy_config(void __iomem *ioaddr)
 {
-       struct phy_reg phy_reg_init[] = {
+       static const struct phy_reg phy_reg_init[] = {
                { 0x1f, 0x0003 },
                { 0x08, 0x441d },
                { 0x01, 0x9100 },
@@ -2705,8 +2717,7 @@ static void rtl8169_phy_timer(unsigned long __opaque)
        if (tp->link_ok(ioaddr))
                goto out_unlock;
 
-       if (netif_msg_link(tp))
-               printk(KERN_WARNING "%s: PHY reset until link up\n", dev->name);
+       netif_warn(tp, link, dev, "PHY reset until link up\n");
 
        tp->phy_reset_enable(ioaddr);
 
@@ -2776,8 +2787,7 @@ static void rtl8169_phy_reset(struct net_device *dev,
                        return;
                msleep(1);
        }
-       if (netif_msg_link(tp))
-               printk(KERN_ERR "%s: PHY reset failed.\n", dev->name);
+       netif_err(tp, link, dev, "PHY reset failed\n");
 }
 
 static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp)
@@ -2811,8 +2821,8 @@ static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp)
         */
        rtl8169_set_speed(dev, AUTONEG_ENABLE, SPEED_1000, DUPLEX_FULL);
 
-       if ((RTL_R8(PHYstatus) & TBI_Enable) && netif_msg_link(tp))
-               printk(KERN_INFO PFX "%s: TBI auto-negotiating\n", dev->name);
+       if (RTL_R8(PHYstatus) & TBI_Enable)
+               netif_info(tp, link, dev, "TBI auto-negotiating\n");
 }
 
 static void rtl_rar_set(struct rtl8169_private *tp, u8 *addr)
@@ -2980,6 +2990,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        void __iomem *ioaddr;
        unsigned int i;
        int rc;
+       int this_use_dac = use_dac;
 
        if (netif_msg_drv(&debug)) {
                printk(KERN_INFO "%s Gigabit Ethernet driver %s loaded\n",
@@ -3012,8 +3023,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        /* enable device (incl. PCI PM wakeup and hotplug setup) */
        rc = pci_enable_device(pdev);
        if (rc < 0) {
-               if (netif_msg_probe(tp))
-                       dev_err(&pdev->dev, "enable failure\n");
+               netif_err(tp, probe, dev, "enable failure\n");
                goto err_out_free_dev_1;
        }
 
@@ -3023,45 +3033,46 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        /* make sure PCI base addr 1 is MMIO */
        if (!(pci_resource_flags(pdev, region) & IORESOURCE_MEM)) {
-               if (netif_msg_probe(tp)) {
-                       dev_err(&pdev->dev,
-                               "region #%d not an MMIO resource, aborting\n",
-                               region);
-               }
+               netif_err(tp, probe, dev,
+                         "region #%d not an MMIO resource, aborting\n",
+                         region);
                rc = -ENODEV;
                goto err_out_mwi_3;
        }
 
        /* check for weird/broken PCI region reporting */
        if (pci_resource_len(pdev, region) < R8169_REGS_SIZE) {
-               if (netif_msg_probe(tp)) {
-                       dev_err(&pdev->dev,
-                               "Invalid PCI region size(s), aborting\n");
-               }
+               netif_err(tp, probe, dev,
+                         "Invalid PCI region size(s), aborting\n");
                rc = -ENODEV;
                goto err_out_mwi_3;
        }
 
        rc = pci_request_regions(pdev, MODULENAME);
        if (rc < 0) {
-               if (netif_msg_probe(tp))
-                       dev_err(&pdev->dev, "could not request regions.\n");
+               netif_err(tp, probe, dev, "could not request regions\n");
                goto err_out_mwi_3;
        }
 
        tp->cp_cmd = PCIMulRW | RxChkSum;
 
+       tp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
+       if (!tp->pcie_cap)
+               netif_info(tp, probe, dev, "no PCI Express capability\n");
+
+       if (this_use_dac < 0)
+               this_use_dac = tp->pcie_cap != 0;
+
        if ((sizeof(dma_addr_t) > 4) &&
-           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) && use_dac) {
+           this_use_dac &&
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               netif_info(tp, probe, dev, "using 64-bit DMA\n");
                tp->cp_cmd |= PCIDAC;
                dev->features |= NETIF_F_HIGHDMA;
        } else {
                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc < 0) {
-                       if (netif_msg_probe(tp)) {
-                               dev_err(&pdev->dev,
-                                       "DMA configuration failed.\n");
-                       }
+                       netif_err(tp, probe, dev, "DMA configuration failed\n");
                        goto err_out_free_res_4;
                }
        }
@@ -3069,16 +3080,11 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        /* ioremap MMIO region */
        ioaddr = ioremap(pci_resource_start(pdev, region), R8169_REGS_SIZE);
        if (!ioaddr) {
-               if (netif_msg_probe(tp))
-                       dev_err(&pdev->dev, "cannot remap MMIO, aborting\n");
+               netif_err(tp, probe, dev, "cannot remap MMIO, aborting\n");
                rc = -EIO;
                goto err_out_free_res_4;
        }
 
-       tp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
-       if (!tp->pcie_cap && netif_msg_probe(tp))
-               dev_info(&pdev->dev, "no PCI Express capability\n");
-
        RTL_W16(IntrMask, 0x0000);
 
        /* Soft reset the chip. */
@@ -3100,10 +3106,8 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        /* Use appropriate default if unknown */
        if (tp->mac_version == RTL_GIGA_MAC_NONE) {
-               if (netif_msg_probe(tp)) {
-                       dev_notice(&pdev->dev,
-                                  "unknown MAC, using family default\n");
-               }
+               netif_notice(tp, probe, dev,
+                            "unknown MAC, using family default\n");
                tp->mac_version = cfg->default_ver;
        }
 
@@ -3185,19 +3189,10 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        pci_set_drvdata(pdev, dev);
 
-       if (netif_msg_probe(tp)) {
-               u32 xid = RTL_R32(TxConfig) & 0x9cf0f8ff;
-
-               printk(KERN_INFO "%s: %s at 0x%lx, "
-                      "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
-                      "XID %08x IRQ %d\n",
-                      dev->name,
-                      rtl_chip_info[tp->chipset].name,
-                      dev->base_addr,
-                      dev->dev_addr[0], dev->dev_addr[1],
-                      dev->dev_addr[2], dev->dev_addr[3],
-                      dev->dev_addr[4], dev->dev_addr[5], xid, dev->irq);
-       }
+       netif_info(tp, probe, dev, "%s at 0x%lx, %pM, XID %08x IRQ %d\n",
+                  rtl_chip_info[tp->chipset].name,
+                  dev->base_addr, dev->dev_addr,
+                  (u32)(RTL_R32(TxConfig) & 0x9cf0f8ff), dev->irq);
 
        rtl8169_init_phy(dev, tp);
 
@@ -3210,6 +3205,12 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        device_set_wakeup_enable(&pdev->dev, tp->features & RTL_FEATURE_WOL);
 
+       if (pci_dev_run_wake(pdev)) {
+               pm_runtime_set_active(&pdev->dev);
+               pm_runtime_enable(&pdev->dev);
+       }
+       pm_runtime_idle(&pdev->dev);
+
 out:
        return rc;
 
@@ -3232,9 +3233,21 @@ static void __devexit rtl8169_remove_one(struct pci_dev *pdev)
        struct net_device *dev = pci_get_drvdata(pdev);
        struct rtl8169_private *tp = netdev_priv(dev);
 
+       pm_runtime_get_sync(&pdev->dev);
+
        flush_scheduled_work();
 
        unregister_netdev(dev);
+
+       if (pci_dev_run_wake(pdev)) {
+               pm_runtime_disable(&pdev->dev);
+               pm_runtime_set_suspended(&pdev->dev);
+       }
+       pm_runtime_put_noidle(&pdev->dev);
+
+       /* restore original MAC address */
+       rtl_rar_set(tp, dev->perm_addr);
+
        rtl_disable_msi(pdev, tp);
        rtl8169_release_board(pdev, dev, tp->mmio_addr);
        pci_set_drvdata(pdev, NULL);
@@ -3243,9 +3256,9 @@ static void __devexit rtl8169_remove_one(struct pci_dev *pdev)
 static void rtl8169_set_rxbufsize(struct rtl8169_private *tp,
                                  struct net_device *dev)
 {
-       unsigned int mtu = dev->mtu;
+       unsigned int max_frame = dev->mtu + VLAN_ETH_HLEN + ETH_FCS_LEN;
 
-       tp->rx_buf_sz = (mtu > RX_BUF_SIZE) ? mtu + ETH_HLEN + 8 : RX_BUF_SIZE;
+       tp->rx_buf_sz = (max_frame > RX_BUF_SIZE) ? max_frame : RX_BUF_SIZE;
 }
 
 static int rtl8169_open(struct net_device *dev)
@@ -3254,6 +3267,7 @@ static int rtl8169_open(struct net_device *dev)
        struct pci_dev *pdev = tp->pci_dev;
        int retval = -ENOMEM;
 
+       pm_runtime_get_sync(&pdev->dev);
 
        rtl8169_set_rxbufsize(tp, dev);
 
@@ -3264,7 +3278,7 @@ static int rtl8169_open(struct net_device *dev)
        tp->TxDescArray = pci_alloc_consistent(pdev, R8169_TX_RING_BYTES,
                                               &tp->TxPhyAddr);
        if (!tp->TxDescArray)
-               goto out;
+               goto err_pm_runtime_put;
 
        tp->RxDescArray = pci_alloc_consistent(pdev, R8169_RX_RING_BYTES,
                                               &tp->RxPhyAddr);
@@ -3291,6 +3305,9 @@ static int rtl8169_open(struct net_device *dev)
 
        rtl8169_request_timer(dev);
 
+       tp->saved_wolopts = 0;
+       pm_runtime_put_noidle(&pdev->dev);
+
        rtl8169_check_link_status(dev, tp, tp->mmio_addr);
 out:
        return retval;
@@ -3300,9 +3317,13 @@ err_release_ring_2:
 err_free_rx_1:
        pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray,
                            tp->RxPhyAddr);
+       tp->RxDescArray = NULL;
 err_free_tx_0:
        pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray,
                            tp->TxPhyAddr);
+       tp->TxDescArray = NULL;
+err_pm_runtime_put:
+       pm_runtime_put_noidle(&pdev->dev);
        goto out;
 }
 
@@ -3384,7 +3405,7 @@ static void rtl_set_rx_max_size(void __iomem *ioaddr, unsigned int rx_buf_sz)
 
 static void rtl8169_set_magic_reg(void __iomem *ioaddr, unsigned mac_version)
 {
-       struct {
+       static const struct {
                u32 mac_version;
                u32 clk;
                u32 val;
@@ -3508,7 +3529,7 @@ struct ephy_info {
        u16 bits;
 };
 
-static void rtl_ephy_init(void __iomem *ioaddr, struct ephy_info *e, int len)
+static void rtl_ephy_init(void __iomem *ioaddr, const struct ephy_info *e, int len)
 {
        u16 w;
 
@@ -3579,7 +3600,7 @@ static void __rtl_hw_start_8168cp(void __iomem *ioaddr, struct pci_dev *pdev)
 
 static void rtl_hw_start_8168cp_1(void __iomem *ioaddr, struct pci_dev *pdev)
 {
-       static struct ephy_info e_info_8168cp[] = {
+       static const struct ephy_info e_info_8168cp[] = {
                { 0x01, 0,      0x0001 },
                { 0x02, 0x0800, 0x1000 },
                { 0x03, 0,      0x0042 },
@@ -3623,7 +3644,7 @@ static void rtl_hw_start_8168cp_3(void __iomem *ioaddr, struct pci_dev *pdev)
 
 static void rtl_hw_start_8168c_1(void __iomem *ioaddr, struct pci_dev *pdev)
 {
-       static struct ephy_info e_info_8168c_1[] = {
+       static const struct ephy_info e_info_8168c_1[] = {
                { 0x02, 0x0800, 0x1000 },
                { 0x03, 0,      0x0002 },
                { 0x06, 0x0080, 0x0000 }
@@ -3640,7 +3661,7 @@ static void rtl_hw_start_8168c_1(void __iomem *ioaddr, struct pci_dev *pdev)
 
 static void rtl_hw_start_8168c_2(void __iomem *ioaddr, struct pci_dev *pdev)
 {
-       static struct ephy_info e_info_8168c_2[] = {
+       static const struct ephy_info e_info_8168c_2[] = {
                { 0x01, 0,      0x0001 },
                { 0x03, 0x0400, 0x0220 }
        };
@@ -3783,7 +3804,7 @@ static void rtl_hw_start_8168(struct net_device *dev)
 
 static void rtl_hw_start_8102e_1(void __iomem *ioaddr, struct pci_dev *pdev)
 {
-       static struct ephy_info e_info_8102e_1[] = {
+       static const struct ephy_info e_info_8102e_1[] = {
                { 0x01, 0, 0x6e65 },
                { 0x02, 0, 0x091f },
                { 0x03, 0, 0xc2f9 },
@@ -4132,10 +4153,10 @@ static void rtl8169_reinit_task(struct work_struct *work)
 
        ret = rtl8169_open(dev);
        if (unlikely(ret < 0)) {
-               if (net_ratelimit() && netif_msg_drv(tp)) {
-                       printk(KERN_ERR PFX "%s: reinit failure (status = %d)."
-                              " Rescheduling.\n", dev->name, ret);
-               }
+               if (net_ratelimit())
+                       netif_err(tp, drv, dev,
+                                 "reinit failure (status = %d). Rescheduling\n",
+                                 ret);
                rtl8169_schedule_work(dev, rtl8169_reinit_task);
        }
 
@@ -4165,10 +4186,8 @@ static void rtl8169_reset_task(struct work_struct *work)
                netif_wake_queue(dev);
                rtl8169_check_link_status(dev, tp, tp->mmio_addr);
        } else {
-               if (net_ratelimit() && netif_msg_intr(tp)) {
-                       printk(KERN_EMERG PFX "%s: Rx buffers shortage\n",
-                              dev->name);
-               }
+               if (net_ratelimit())
+                       netif_emerg(tp, intr, dev, "Rx buffers shortage\n");
                rtl8169_schedule_work(dev, rtl8169_reset_task);
        }
 
@@ -4256,11 +4275,7 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
        u32 opts1;
 
        if (unlikely(TX_BUFFS_AVAIL(tp) < skb_shinfo(skb)->nr_frags)) {
-               if (netif_msg_drv(tp)) {
-                       printk(KERN_ERR
-                              "%s: BUG! Tx Ring full when queue awake!\n",
-                              dev->name);
-               }
+               netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n");
                goto err_stop;
        }
 
@@ -4293,7 +4308,7 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
 
        tp->cur_tx += frags + 1;
 
-       smp_wmb();
+       wmb();
 
        RTL_W8(TxPoll, NPQ);    /* set polling bit */
 
@@ -4322,11 +4337,8 @@ static void rtl8169_pcierr_interrupt(struct net_device *dev)
        pci_read_config_word(pdev, PCI_COMMAND, &pci_cmd);
        pci_read_config_word(pdev, PCI_STATUS, &pci_status);
 
-       if (netif_msg_intr(tp)) {
-               printk(KERN_ERR
-                      "%s: PCI error (cmd = 0x%04x, status = 0x%04x).\n",
-                      dev->name, pci_cmd, pci_status);
-       }
+       netif_err(tp, intr, dev, "PCI error (cmd = 0x%04x, status = 0x%04x)\n",
+                 pci_cmd, pci_status);
 
        /*
         * The recovery sequence below admits a very elaborated explanation:
@@ -4350,8 +4362,7 @@ static void rtl8169_pcierr_interrupt(struct net_device *dev)
 
        /* The infamous DAC f*ckup only happens at boot time */
        if ((tp->cp_cmd & PCIDAC) && !tp->dirty_rx && !tp->cur_rx) {
-               if (netif_msg_intr(tp))
-                       printk(KERN_INFO "%s: disabling PCI DAC.\n", dev->name);
+               netif_info(tp, intr, dev, "disabling PCI DAC\n");
                tp->cp_cmd &= ~PCIDAC;
                RTL_W16(CPlusCmd, tp->cp_cmd);
                dev->features &= ~NETIF_F_HIGHDMA;
@@ -4443,13 +4454,12 @@ static inline bool rtl8169_try_rx_copy(struct sk_buff **sk_buff,
        if (pkt_size >= rx_copybreak)
                goto out;
 
-       skb = netdev_alloc_skb(tp->dev, pkt_size + NET_IP_ALIGN);
+       skb = netdev_alloc_skb_ip_align(tp->dev, pkt_size);
        if (!skb)
                goto out;
 
        pci_dma_sync_single_for_cpu(tp->pci_dev, addr, pkt_size,
                                    PCI_DMA_FROMDEVICE);
-       skb_reserve(skb, NET_IP_ALIGN);
        skb_copy_from_linear_data(*sk_buff, skb->data, pkt_size);
        *sk_buff = skb;
        done = true;
@@ -4457,12 +4467,20 @@ out:
        return done;
 }
 
+/*
+ * Warning : rtl8169_rx_interrupt() might be called :
+ * 1) from NAPI (softirq) context
+ *     (polling = 1 : we should call netif_receive_skb())
+ * 2) from process context (rtl8169_reset_task())
+ *     (polling = 0 : we must call netif_rx() instead)
+ */
 static int rtl8169_rx_interrupt(struct net_device *dev,
                                struct rtl8169_private *tp,
                                void __iomem *ioaddr, u32 budget)
 {
        unsigned int cur_rx, rx_left;
        unsigned int delta, count;
+       int polling = (budget != ~(u32)0) ? 1 : 0;
 
        cur_rx = tp->cur_rx;
        rx_left = NUM_RX_DESC + tp->dirty_rx - cur_rx;
@@ -4479,11 +4497,8 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
                if (status & DescOwn)
                        break;
                if (unlikely(status & RxRES)) {
-                       if (netif_msg_rx_err(tp)) {
-                               printk(KERN_INFO
-                                      "%s: Rx ERROR. status = %08x\n",
-                                      dev->name, status);
-                       }
+                       netif_info(tp, rx_err, dev, "Rx ERROR. status = %08x\n",
+                                  status);
                        dev->stats.rx_errors++;
                        if (status & (RxRWT | RxRUNT))
                                dev->stats.rx_length_errors++;
@@ -4527,8 +4542,12 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
                        skb_put(skb, pkt_size);
                        skb->protocol = eth_type_trans(skb, dev);
 
-                       if (rtl8169_rx_vlan_skb(tp, desc, skb) < 0)
-                               netif_receive_skb(skb);
+                       if (rtl8169_rx_vlan_skb(tp, desc, skb, polling) < 0) {
+                               if (likely(polling))
+                                       netif_receive_skb(skb);
+                               else
+                                       netif_rx(skb);
+                       }
 
                        dev->stats.rx_bytes += pkt_size;
                        dev->stats.rx_packets++;
@@ -4546,8 +4565,8 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
        tp->cur_rx = cur_rx;
 
        delta = rtl8169_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx);
-       if (!delta && count && netif_msg_intr(tp))
-               printk(KERN_INFO "%s: no Rx buffer allocated\n", dev->name);
+       if (!delta && count)
+               netif_info(tp, intr, dev, "no Rx buffer allocated\n");
        tp->dirty_rx += delta;
 
        /*
@@ -4557,8 +4576,8 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
         *   after refill ?
         * - how do others driver handle this condition (Uh oh...).
         */
-       if ((tp->dirty_rx + NUM_RX_DESC == tp->cur_rx) && netif_msg_intr(tp))
-               printk(KERN_EMERG "%s: Rx buffers exhausted\n", dev->name);
+       if (tp->dirty_rx + NUM_RX_DESC == tp->cur_rx)
+               netif_emerg(tp, intr, dev, "Rx buffers exhausted\n");
 
        return count;
 }
@@ -4613,10 +4632,9 @@ static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance)
 
                        if (likely(napi_schedule_prep(&tp->napi)))
                                __napi_schedule(&tp->napi);
-                       else if (netif_msg_intr(tp)) {
-                               printk(KERN_INFO "%s: interrupt %04x in poll\n",
-                               dev->name, status);
-                       }
+                       else
+                               netif_info(tp, intr, dev,
+                                          "interrupt %04x in poll\n", status);
                }
 
                /* We only get a new MSI interrupt when all active irq
@@ -4653,7 +4671,7 @@ static int rtl8169_poll(struct napi_struct *napi, int budget)
                 * until it does.
                 */
                tp->intr_mask = 0xffff;
-               smp_wmb();
+               wmb();
                RTL_W16(IntrMask, tp->intr_event);
        }
 
@@ -4724,6 +4742,8 @@ static int rtl8169_close(struct net_device *dev)
        struct rtl8169_private *tp = netdev_priv(dev);
        struct pci_dev *pdev = tp->pci_dev;
 
+       pm_runtime_get_sync(&pdev->dev);
+
        /* update counters before going down */
        rtl8169_update_counters(dev);
 
@@ -4738,6 +4758,8 @@ static int rtl8169_close(struct net_device *dev)
        tp->TxDescArray = NULL;
        tp->RxDescArray = NULL;
 
+       pm_runtime_put_sync(&pdev->dev);
+
        return 0;
 }
 
@@ -4752,28 +4774,23 @@ static void rtl_set_rx_mode(struct net_device *dev)
 
        if (dev->flags & IFF_PROMISC) {
                /* Unconditionally log net taps. */
-               if (netif_msg_link(tp)) {
-                       printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n",
-                              dev->name);
-               }
+               netif_notice(tp, link, dev, "Promiscuous mode enabled\n");
                rx_mode =
                    AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
                    AcceptAllPhys;
                mc_filter[1] = mc_filter[0] = 0xffffffff;
-       } else if ((dev->mc_count > multicast_filter_limit)
-                  || (dev->flags & IFF_ALLMULTI)) {
+       } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
+                  (dev->flags & IFF_ALLMULTI)) {
                /* Too many to filter perfectly -- accept all multicasts. */
                rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
                mc_filter[1] = mc_filter[0] = 0xffffffff;
        } else {
-               struct dev_mc_list *mclist;
-               unsigned int i;
+               struct netdev_hw_addr *ha;
 
                rx_mode = AcceptBroadcast | AcceptMyPhys;
                mc_filter[1] = mc_filter[0] = 0;
-               for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
-                    i++, mclist = mclist->next) {
-                       int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
+               netdev_for_each_mc_addr(ha, dev) {
+                       int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
                        mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
                        rx_mode |= AcceptMulticast;
                }
@@ -4841,28 +4858,84 @@ static int rtl8169_suspend(struct device *device)
        return 0;
 }
 
+static void __rtl8169_resume(struct net_device *dev)
+{
+       netif_device_attach(dev);
+       rtl8169_schedule_work(dev, rtl8169_reset_task);
+}
+
 static int rtl8169_resume(struct device *device)
 {
        struct pci_dev *pdev = to_pci_dev(device);
        struct net_device *dev = pci_get_drvdata(pdev);
 
-       if (!netif_running(dev))
-               goto out;
+       if (netif_running(dev))
+               __rtl8169_resume(dev);
 
-       netif_device_attach(dev);
+       return 0;
+}
+
+static int rtl8169_runtime_suspend(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct rtl8169_private *tp = netdev_priv(dev);
+
+       if (!tp->TxDescArray)
+               return 0;
+
+       spin_lock_irq(&tp->lock);
+       tp->saved_wolopts = __rtl8169_get_wol(tp);
+       __rtl8169_set_wol(tp, WAKE_ANY);
+       spin_unlock_irq(&tp->lock);
+
+       rtl8169_net_suspend(dev);
 
-       rtl8169_schedule_work(dev, rtl8169_reset_task);
-out:
        return 0;
 }
 
-static struct dev_pm_ops rtl8169_pm_ops = {
+static int rtl8169_runtime_resume(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct rtl8169_private *tp = netdev_priv(dev);
+
+       if (!tp->TxDescArray)
+               return 0;
+
+       spin_lock_irq(&tp->lock);
+       __rtl8169_set_wol(tp, tp->saved_wolopts);
+       tp->saved_wolopts = 0;
+       spin_unlock_irq(&tp->lock);
+
+       __rtl8169_resume(dev);
+
+       return 0;
+}
+
+static int rtl8169_runtime_idle(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct net_device *dev = pci_get_drvdata(pdev);
+       struct rtl8169_private *tp = netdev_priv(dev);
+
+       if (!tp->TxDescArray)
+               return 0;
+
+       rtl8169_check_link_status(dev, tp, tp->mmio_addr);
+       return -EBUSY;
+}
+
+static const struct dev_pm_ops rtl8169_pm_ops = {
        .suspend = rtl8169_suspend,
        .resume = rtl8169_resume,
        .freeze = rtl8169_suspend,
        .thaw = rtl8169_resume,
        .poweroff = rtl8169_suspend,
        .restore = rtl8169_resume,
+       .runtime_suspend = rtl8169_runtime_suspend,
+       .runtime_resume = rtl8169_runtime_resume,
+       .runtime_idle = rtl8169_runtime_idle,
 };
 
 #define RTL8169_PM_OPS (&rtl8169_pm_ops)
@@ -4881,6 +4954,9 @@ static void rtl_shutdown(struct pci_dev *pdev)
 
        rtl8169_net_suspend(dev);
 
+       /* restore original MAC address */
+       rtl_rar_set(tp, dev->perm_addr);
+
        spin_lock_irq(&tp->lock);
 
        rtl8169_asic_down(ioaddr);