Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / net / skge.c
index f73ee79..f4be5c7 100644 (file)
@@ -23,6 +23,8 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/crc32.h>
 #include <linux/dma-mapping.h>
 #include <linux/debugfs.h>
+#include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/mii.h>
+#include <linux/slab.h>
+#include <linux/dmi.h>
+#include <linux/prefetch.h>
 #include <asm/irq.h>
 
 #include "skge.h"
 
 #define DRV_NAME               "skge"
 #define DRV_VERSION            "1.13"
-#define PFX                    DRV_NAME " "
 
 #define DEFAULT_TX_RING_SIZE   128
 #define DEFAULT_RX_RING_SIZE   512
@@ -69,15 +74,15 @@ MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-static const u32 default_msg
-       = NETIF_MSG_DRV| NETIF_MSG_PROBE| NETIF_MSG_LINK
-         | NETIF_MSG_IFUP| NETIF_MSG_IFDOWN;
+static const u32 default_msg = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
+                               NETIF_MSG_LINK | NETIF_MSG_IFUP |
+                               NETIF_MSG_IFDOWN);
 
 static int debug = -1; /* defaults above */
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
-static const struct pci_device_id skge_id_table[] = {
+static DEFINE_PCI_DEVICE_TABLE(skge_id_table) = {
        { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940) },
        { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940B) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE) },
@@ -186,8 +191,8 @@ static void skge_wol_init(struct skge_port *skge)
 
        /* Force to 10/100 skge_reset will re-enable on resume   */
        gm_phy_write(hw, port, PHY_MARV_AUNE_ADV,
-                    PHY_AN_100FULL | PHY_AN_100HALF |
-                    PHY_AN_10FULL | PHY_AN_10HALF| PHY_AN_CSMA);
+                    (PHY_AN_100FULL | PHY_AN_100HALF |
+                     PHY_AN_10FULL | PHY_AN_10HALF | PHY_AN_CSMA));
        /* no 1000 HD/FD */
        gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, 0);
        gm_phy_write(hw, port, PHY_MARV_CTRL,
@@ -215,7 +220,7 @@ static void skge_wol_init(struct skge_port *skge)
        if (skge->wol & WAKE_MAGIC)
                ctrl |= WOL_CTL_ENA_PME_ON_MAGIC_PKT|WOL_CTL_ENA_MAGIC_PKT_UNIT;
        else
-               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;;
+               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;
 
        ctrl |= WOL_CTL_DIS_PME_ON_PATTERN|WOL_CTL_DIS_PATTERN_UNIT;
        skge_write16(hw, WOL_REGS(port, WOL_CTRL_STAT), ctrl);
@@ -237,8 +242,8 @@ static int skge_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
        struct skge_port *skge = netdev_priv(dev);
        struct skge_hw *hw = skge->hw;
 
-       if ((wol->wolopts & ~wol_supported(hw))
-           || !device_can_wakeup(&hw->pdev->dev))
+       if ((wol->wolopts & ~wol_supported(hw)) ||
+           !device_can_wakeup(&hw->pdev->dev))
                return -EOPNOTSUPP;
 
        skge->wol = wol->wolopts;
@@ -256,25 +261,28 @@ static u32 skge_supported_modes(const struct skge_hw *hw)
        u32 supported;
 
        if (hw->copper) {
-               supported = SUPPORTED_10baseT_Half
-                       | SUPPORTED_10baseT_Full
-                       | SUPPORTED_100baseT_Half
-                       | SUPPORTED_100baseT_Full
-                       | SUPPORTED_1000baseT_Half
-                       | SUPPORTED_1000baseT_Full
-                       | SUPPORTED_Autoneg| SUPPORTED_TP;
+               supported = (SUPPORTED_10baseT_Half |
+                            SUPPORTED_10baseT_Full |
+                            SUPPORTED_100baseT_Half |
+                            SUPPORTED_100baseT_Full |
+                            SUPPORTED_1000baseT_Half |
+                            SUPPORTED_1000baseT_Full |
+                            SUPPORTED_Autoneg |
+                            SUPPORTED_TP);
 
                if (hw->chip_id == CHIP_ID_GENESIS)
-                       supported &= ~(SUPPORTED_10baseT_Half
-                                            | SUPPORTED_10baseT_Full
-                                            | SUPPORTED_100baseT_Half
-                                            | SUPPORTED_100baseT_Full);
+                       supported &= ~(SUPPORTED_10baseT_Half |
+                                      SUPPORTED_10baseT_Full |
+                                      SUPPORTED_100baseT_Half |
+                                      SUPPORTED_100baseT_Full);
 
                else if (hw->chip_id == CHIP_ID_YUKON)
                        supported &= ~SUPPORTED_1000baseT_Half;
        } else
-               supported = SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half
-                       | SUPPORTED_FIBRE | SUPPORTED_Autoneg;
+               supported = (SUPPORTED_1000baseT_Full |
+                            SUPPORTED_1000baseT_Half |
+                            SUPPORTED_FIBRE |
+                            SUPPORTED_Autoneg);
 
        return supported;
 }
@@ -296,7 +304,7 @@ static int skge_get_settings(struct net_device *dev,
 
        ecmd->advertising = skge->advertising;
        ecmd->autoneg = skge->autoneg;
-       ecmd->speed = skge->speed;
+       ethtool_cmd_speed_set(ecmd, skge->speed);
        ecmd->duplex = skge->duplex;
        return 0;
 }
@@ -314,8 +322,9 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                skge->speed = -1;
        } else {
                u32 setting;
+               u32 speed = ethtool_cmd_speed(ecmd);
 
-               switch (ecmd->speed) {
+               switch (speed) {
                case SPEED_1000:
                        if (ecmd->duplex == DUPLEX_FULL)
                                setting = SUPPORTED_1000baseT_Full;
@@ -348,7 +357,7 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                if ((setting & supported) == 0)
                        return -EINVAL;
 
-               skge->speed = ecmd->speed;
+               skge->speed = speed;
                skge->duplex = ecmd->duplex;
        }
 
@@ -364,7 +373,7 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                }
        }
 
-       return (0);
+       return 0;
 }
 
 static void skge_get_drvinfo(struct net_device *dev,
@@ -530,54 +539,15 @@ static int skge_nway_reset(struct net_device *dev)
        return 0;
 }
 
-static int skge_set_sg(struct net_device *dev, u32 data)
-{
-       struct skge_port *skge = netdev_priv(dev);
-       struct skge_hw *hw = skge->hw;
-
-       if (hw->chip_id == CHIP_ID_GENESIS && data)
-               return -EOPNOTSUPP;
-       return ethtool_op_set_sg(dev, data);
-}
-
-static int skge_set_tx_csum(struct net_device *dev, u32 data)
-{
-       struct skge_port *skge = netdev_priv(dev);
-       struct skge_hw *hw = skge->hw;
-
-       if (hw->chip_id == CHIP_ID_GENESIS && data)
-               return -EOPNOTSUPP;
-
-       return ethtool_op_set_tx_csum(dev, data);
-}
-
-static u32 skge_get_rx_csum(struct net_device *dev)
-{
-       struct skge_port *skge = netdev_priv(dev);
-
-       return skge->rx_csum;
-}
-
-/* Only Yukon supports checksum offload. */
-static int skge_set_rx_csum(struct net_device *dev, u32 data)
-{
-       struct skge_port *skge = netdev_priv(dev);
-
-       if (skge->hw->chip_id == CHIP_ID_GENESIS && data)
-               return -EOPNOTSUPP;
-
-       skge->rx_csum = data;
-       return 0;
-}
-
 static void skge_get_pauseparam(struct net_device *dev,
                                struct ethtool_pauseparam *ecmd)
 {
        struct skge_port *skge = netdev_priv(dev);
 
-       ecmd->rx_pause = (skge->flow_control == FLOW_MODE_SYMMETRIC)
-               || (skge->flow_control == FLOW_MODE_SYM_OR_REM);
-       ecmd->tx_pause = ecmd->rx_pause || (skge->flow_control == FLOW_MODE_LOC_SEND);
+       ecmd->rx_pause = ((skge->flow_control == FLOW_MODE_SYMMETRIC) ||
+                         (skge->flow_control == FLOW_MODE_SYM_OR_REM));
+       ecmd->tx_pause = (ecmd->rx_pause ||
+                         (skge->flow_control == FLOW_MODE_LOC_SEND));
 
        ecmd->autoneg = ecmd->rx_pause || ecmd->tx_pause;
 }
@@ -778,28 +748,27 @@ static void skge_led(struct skge_port *skge, enum led_mode mode)
 }
 
 /* blink LED's for finding board */
-static int skge_phys_id(struct net_device *dev, u32 data)
+static int skge_set_phys_id(struct net_device *dev,
+                           enum ethtool_phys_id_state state)
 {
        struct skge_port *skge = netdev_priv(dev);
-       unsigned long ms;
-       enum led_mode mode = LED_MODE_TST;
 
-       if (!data || data > (u32)(MAX_SCHEDULE_TIMEOUT / HZ))
-               ms = jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT / HZ) * 1000;
-       else
-               ms = data * 1000;
+       switch (state) {
+       case ETHTOOL_ID_ACTIVE:
+               return 2;       /* cycle on/off twice per second */
 
-       while (ms > 0) {
-               skge_led(skge, mode);
-               mode ^= LED_MODE_TST;
+       case ETHTOOL_ID_ON:
+               skge_led(skge, LED_MODE_TST);
+               break;
 
-               if (msleep_interruptible(BLINK_MS))
-                       break;
-               ms -= BLINK_MS;
-       }
+       case ETHTOOL_ID_OFF:
+               skge_led(skge, LED_MODE_OFF);
+               break;
 
-       /* back to regular LED state */
-       skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
+       case ETHTOOL_ID_INACTIVE:
+               /* back to regular LED state */
+               skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
+       }
 
        return 0;
 }
@@ -810,7 +779,7 @@ static int skge_get_eeprom_len(struct net_device *dev)
        u32 reg2;
 
        pci_read_config_dword(skge->hw->pdev, PCI_DEV_REG2, &reg2);
-       return 1 << ( ((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
+       return 1 << (((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
 }
 
 static u32 skge_vpd_read(struct pci_dev *pdev, int cap, u16 offset)
@@ -917,12 +886,8 @@ static const struct ethtool_ops skge_ethtool_ops = {
        .set_pauseparam = skge_set_pauseparam,
        .get_coalesce   = skge_get_coalesce,
        .set_coalesce   = skge_set_coalesce,
-       .set_sg         = skge_set_sg,
-       .set_tx_csum    = skge_set_tx_csum,
-       .get_rx_csum    = skge_get_rx_csum,
-       .set_rx_csum    = skge_set_rx_csum,
        .get_strings    = skge_get_strings,
-       .phys_id        = skge_phys_id,
+       .set_phys_id    = skge_set_phys_id,
        .get_sset_count = skge_get_sset_count,
        .get_ethtool_stats = skge_get_ethtool_stats,
 };
@@ -977,8 +942,8 @@ static void skge_rx_setup(struct skge_port *skge, struct skge_element *e,
        wmb();
 
        rd->control = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | bufsize;
-       pci_unmap_addr_set(e, mapaddr, map);
-       pci_unmap_len_set(e, maplen, bufsize);
+       dma_unmap_addr_set(e, mapaddr, map);
+       dma_unmap_len_set(e, maplen, bufsize);
 }
 
 /* Resume receiving using existing skb,
@@ -1011,8 +976,8 @@ static void skge_rx_clean(struct skge_port *skge)
                rd->control = 0;
                if (e->skb) {
                        pci_unmap_single(hw->pdev,
-                                        pci_unmap_addr(e, mapaddr),
-                                        pci_unmap_len(e, maplen),
+                                        dma_unmap_addr(e, mapaddr),
+                                        dma_unmap_len(e, maplen),
                                         PCI_DMA_FROMDEVICE);
                        dev_kfree_skb(e->skb);
                        e->skb = NULL;
@@ -1041,7 +1006,7 @@ static int skge_rx_fill(struct net_device *dev)
 
                skb_reserve(skb, NET_IP_ALIGN);
                skge_rx_setup(skge, e, skb, skge->rx_buf_size);
-       } while ( (e = e->next) != ring->start);
+       } while ((e = e->next) != ring->start);
 
        ring->to_clean = ring->start;
        return 0;
@@ -1049,7 +1014,7 @@ static int skge_rx_fill(struct net_device *dev)
 
 static const char *skge_pause(enum pause_status status)
 {
-       switch(status) {
+       switch (status) {
        case FLOW_STAT_NONE:
                return "none";
        case FLOW_STAT_REM_SEND:
@@ -1072,13 +1037,11 @@ static void skge_link_up(struct skge_port *skge)
        netif_carrier_on(skge->netdev);
        netif_wake_queue(skge->netdev);
 
-       if (netif_msg_link(skge)) {
-               printk(KERN_INFO PFX
-                      "%s: Link is up at %d Mbps, %s duplex, flow control %s\n",
-                      skge->netdev->name, skge->speed,
-                      skge->duplex == DUPLEX_FULL ? "full" : "half",
-                      skge_pause(skge->flow_status));
-       }
+       netif_info(skge, link, skge->netdev,
+                  "Link is up at %d Mbps, %s duplex, flow control %s\n",
+                  skge->speed,
+                  skge->duplex == DUPLEX_FULL ? "full" : "half",
+                  skge_pause(skge->flow_status));
 }
 
 static void skge_link_down(struct skge_port *skge)
@@ -1087,8 +1050,7 @@ static void skge_link_down(struct skge_port *skge)
        netif_carrier_off(skge->netdev);
        netif_stop_queue(skge->netdev);
 
-       if (netif_msg_link(skge))
-               printk(KERN_INFO PFX "%s: Link is down.\n", skge->netdev->name);
+       netif_info(skge, link, skge->netdev, "Link is down\n");
 }
 
 
@@ -1130,8 +1092,7 @@ static u16 xm_phy_read(struct skge_hw *hw, int port, u16 reg)
 {
        u16 v = 0;
        if (__xm_phy_read(hw, port, reg, &v))
-               printk(KERN_WARNING PFX "%s: phy read timed out\n",
-                      hw->dev[port]->name);
+               pr_warning("%s: phy read timed out\n", hw->dev[port]->name);
        return v;
 }
 
@@ -1187,7 +1148,7 @@ static void genesis_init(struct skge_hw *hw)
 
 static void genesis_reset(struct skge_hw *hw, int port)
 {
-       const u8 zero[8]  = { 0 };
+       static const u8 zero[8]  = { 0 };
        u32 reg;
 
        skge_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0);
@@ -1253,8 +1214,7 @@ static void bcom_check_link(struct skge_hw *hw, int port)
 
                lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
                if (lpa & PHY_B_AN_RF) {
-                       printk(KERN_NOTICE PFX "%s: remote fault\n",
-                              dev->name);
+                       netdev_notice(dev, "remote fault\n");
                        return;
                }
 
@@ -1269,8 +1229,7 @@ static void bcom_check_link(struct skge_hw *hw, int port)
                        skge->duplex = DUPLEX_HALF;
                        break;
                default:
-                       printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
-                              dev->name);
+                       netdev_notice(dev, "duplex mismatch\n");
                        return;
                }
 
@@ -1325,7 +1284,7 @@ static void bcom_phy_init(struct skge_port *skge)
        /* Optimize MDIO transfer by suppressing preamble. */
        r = xm_read16(hw, port, XM_MMU_CMD);
        r |=  XM_MMU_NO_PRE;
-       xm_write16(hw, port, XM_MMU_CMD,r);
+       xm_write16(hw, port, XM_MMU_CMD, r);
 
        switch (id1) {
        case PHY_BCOM_ID1_C0:
@@ -1462,8 +1421,7 @@ static int xm_check_link(struct net_device *dev)
 
                lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
                if (lpa & PHY_B_AN_RF) {
-                       printk(KERN_NOTICE PFX "%s: remote fault\n",
-                              dev->name);
+                       netdev_notice(dev, "remote fault\n");
                        return 0;
                }
 
@@ -1478,8 +1436,7 @@ static int xm_check_link(struct net_device *dev)
                        skge->duplex = DUPLEX_HALF;
                        break;
                default:
-                       printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
-                              dev->name);
+                       netdev_notice(dev, "duplex mismatch\n");
                        return 0;
                }
 
@@ -1517,7 +1474,7 @@ static void xm_link_timer(unsigned long arg)
 {
        struct skge_port *skge = (struct skge_port *) arg;
        struct net_device *dev = skge->netdev;
-       struct skge_hw *hw = skge->hw;
+       struct skge_hw *hw = skge->hw;
        int port = skge->port;
        int i;
        unsigned long flags;
@@ -1536,7 +1493,7 @@ static void xm_link_timer(unsigned long arg)
                        goto link_down;
        }
 
-        /* Re-enable interrupt to detect link down */
+       /* Re-enable interrupt to detect link down */
        if (xm_check_link(dev)) {
                u16 msk = xm_read16(hw, port, XM_IMSK);
                msk &= ~XM_IS_INP_ASS;
@@ -1557,7 +1514,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
        int jumbo = hw->dev[port]->mtu > ETH_DATA_LEN;
        int i;
        u32 r;
-       const u8 zero[6]  = { 0 };
+       static const u8 zero[6]  = { 0 };
 
        for (i = 0; i < 10; i++) {
                skge_write16(hw, SK_REG(port, TX_MFF_CTRL1),
@@ -1567,7 +1524,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
                udelay(1);
        }
 
-       printk(KERN_WARNING PFX "%s: genesis reset failed\n", dev->name);
+       netdev_warn(dev, "genesis reset failed\n");
 
  reset_ok:
        /* Unreset the XMAC. */
@@ -1593,7 +1550,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
        }
 
 
-       switch(hw->phy_type) {
+       switch (hw->phy_type) {
        case SK_PHY_XMAC:
                xm_phy_init(skge);
                break;
@@ -1700,7 +1657,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
 
        if (jumbo) {
                /* Enable frame flushing if jumbo frames used */
-               skge_write16(hw, SK_REG(port,RX_MFF_CTRL1), MFF_ENA_FLUSH);
+               skge_write16(hw, SK_REG(port, RX_MFF_CTRL1), MFF_ENA_FLUSH);
        } else {
                /* enable timeout timers if normal frames */
                skge_write16(hw, B3_PA_CTRL,
@@ -1715,7 +1672,7 @@ static void genesis_stop(struct skge_port *skge)
        unsigned retries = 1000;
        u16 cmd;
 
-       /* Disable Tx and Rx */
+       /* Disable Tx and Rx */
        cmd = xm_read16(hw, port, XM_MMU_CMD);
        cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
        xm_write16(hw, port, XM_MMU_CMD, cmd);
@@ -1790,12 +1747,11 @@ static void genesis_mac_intr(struct skge_hw *hw, int port)
        struct skge_port *skge = netdev_priv(dev);
        u16 status = xm_read16(hw, port, XM_ISRC);
 
-       if (netif_msg_intr(skge))
-               printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
-                      dev->name, status);
+       netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                    "mac interrupt status 0x%x\n", status);
 
        if (hw->phy_type == SK_PHY_XMAC && (status & XM_IS_INP_ASS)) {
-               xm_link_down(hw, port);
+               xm_link_down(hw, port);
                mod_timer(&skge->link_timer, jiffies + 1);
        }
 
@@ -1829,7 +1785,7 @@ static void genesis_link_up(struct skge_port *skge)
        xm_write16(hw, port, XM_MMU_CMD, cmd);
 
        mode = xm_read32(hw, port, XM_MODE);
-       if (skge->flow_status== FLOW_STAT_SYMMETRIC ||
+       if (skge->flow_status == FLOW_STAT_SYMMETRIC ||
            skge->flow_status == FLOW_STAT_LOC_SEND) {
                /*
                 * Configure Pause Frame Generation
@@ -1896,12 +1852,11 @@ static inline void bcom_phy_intr(struct skge_port *skge)
        u16 isrc;
 
        isrc = xm_phy_read(hw, port, PHY_BCOM_INT_STAT);
-       if (netif_msg_intr(skge))
-               printk(KERN_DEBUG PFX "%s: phy interrupt status 0x%x\n",
-                      skge->netdev->name, isrc);
+       netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                    "phy interrupt status 0x%x\n", isrc);
 
        if (isrc & PHY_B_IS_PSE)
-               printk(KERN_ERR PFX "%s: uncorrectable pair swap error\n",
+               pr_err("%s: uncorrectable pair swap error\n",
                       hw->dev[port]->name);
 
        /* Workaround BCom Errata:
@@ -1934,8 +1889,7 @@ static int gm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val)
                        return 0;
        }
 
-       printk(KERN_WARNING PFX "%s: phy write timeout\n",
-              hw->dev[port]->name);
+       pr_warning("%s: phy write timeout\n", hw->dev[port]->name);
        return -EIO;
 }
 
@@ -1963,8 +1917,7 @@ static u16 gm_phy_read(struct skge_hw *hw, int port, u16 reg)
 {
        u16 v = 0;
        if (__gm_phy_read(hw, port, reg, &v))
-               printk(KERN_WARNING PFX "%s: phy read timeout\n",
-              hw->dev[port]->name);
+               pr_warning("%s: phy read timeout\n", hw->dev[port]->name);
        return v;
 }
 
@@ -2296,9 +2249,8 @@ static void yukon_mac_intr(struct skge_hw *hw, int port)
        struct skge_port *skge = netdev_priv(dev);
        u8 status = skge_read8(hw, SK_REG(port, GMAC_IRQ_SRC));
 
-       if (netif_msg_intr(skge))
-               printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
-                      dev->name, status);
+       netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                    "mac interrupt status 0x%x\n", status);
 
        if (status & GM_IS_RX_FF_OR) {
                ++dev->stats.rx_fifo_errors;
@@ -2377,9 +2329,8 @@ static void yukon_phy_intr(struct skge_port *skge)
        istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT);
        phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT);
 
-       if (netif_msg_intr(skge))
-               printk(KERN_DEBUG PFX "%s: phy interrupt status 0x%x 0x%x\n",
-                      skge->netdev->name, istatus, phystat);
+       netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                    "phy interrupt status 0x%x 0x%x\n", istatus, phystat);
 
        if (istatus & PHY_M_IS_AN_COMPL) {
                if (gm_phy_read(hw, port, PHY_MARV_AUNE_LP)
@@ -2439,8 +2390,7 @@ static void yukon_phy_intr(struct skge_port *skge)
        }
        return;
  failed:
-       printk(KERN_ERR PFX "%s: autonegotiation failed (%s)\n",
-              skge->netdev->name, reason);
+       pr_err("%s: autonegotiation failed (%s)\n", skge->netdev->name, reason);
 
        /* XXX restart autonegotiation? */
 }
@@ -2478,7 +2428,7 @@ static int skge_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
        if (!netif_running(dev))
                return -ENODEV; /* Phy still in reset */
 
-       switch(cmd) {
+       switch (cmd) {
        case SIOCGMIIPHY:
                data->phy_id = hw->phy_addr;
 
@@ -2496,9 +2446,6 @@ static int skge_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
        }
 
        case SIOCSMIIREG:
-               if (!capable(CAP_NET_ADMIN))
-                       return -EPERM;
-
                spin_lock_bh(&hw->phy_lock);
                if (hw->chip_id == CHIP_ID_GENESIS)
                        err = xm_phy_write(hw, skge->port, data->reg_num & 0x1f,
@@ -2572,8 +2519,7 @@ static int skge_up(struct net_device *dev)
        if (!is_valid_ether_addr(dev->dev_addr))
                return -EINVAL;
 
-       if (netif_msg_ifup(skge))
-               printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
+       netif_info(skge, ifup, skge->netdev, "enabling interface\n");
 
        if (dev->mtu > RX_BUF_SIZE)
                skge->rx_buf_size = dev->mtu + ETH_HLEN;
@@ -2671,10 +2617,9 @@ static int skge_down(struct net_device *dev)
        if (skge->mem == NULL)
                return 0;
 
-       if (netif_msg_ifdown(skge))
-               printk(KERN_INFO PFX "%s: disabling interface\n", dev->name);
+       netif_info(skge, ifdown, skge->netdev, "disabling interface\n");
 
-       netif_stop_queue(dev);
+       netif_tx_disable(dev);
 
        if (hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC)
                del_timer_sync(&skge->link_timer);
@@ -2746,7 +2691,8 @@ static inline int skge_avail(const struct skge_ring *ring)
                + (ring->to_clean - ring->to_use) - 1;
 }
 
-static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t skge_xmit_frame(struct sk_buff *skb,
+                                  struct net_device *dev)
 {
        struct skge_port *skge = netdev_priv(dev);
        struct skge_hw *hw = skge->hw;
@@ -2768,20 +2714,20 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
        e->skb = skb;
        len = skb_headlen(skb);
        map = pci_map_single(hw->pdev, skb->data, len, PCI_DMA_TODEVICE);
-       pci_unmap_addr_set(e, mapaddr, map);
-       pci_unmap_len_set(e, maplen, len);
+       dma_unmap_addr_set(e, mapaddr, map);
+       dma_unmap_len_set(e, maplen, len);
 
        td->dma_lo = map;
        td->dma_hi = map >> 32;
 
        if (skb->ip_summed == CHECKSUM_PARTIAL) {
-               const int offset = skb_transport_offset(skb);
+               const int offset = skb_checksum_start_offset(skb);
 
                /* This seems backwards, but it is what the sk98lin
                 * does.  Looks like hardware is wrong?
                 */
-               if (ipip_hdr(skb)->protocol == IPPROTO_UDP
-                   && hw->chip_rev == 0 && hw->chip_id == CHIP_ID_YUKON)
+               if (ipip_hdr(skb)->protocol == IPPROTO_UDP &&
+                   hw->chip_rev == 0 && hw->chip_id == CHIP_ID_YUKON)
                        control = BMU_TCP_CHECK;
                else
                        control = BMU_UDP_CHECK;
@@ -2793,7 +2739,7 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
                control = BMU_CHECK;
 
        if (!skb_shinfo(skb)->nr_frags) /* single buffer i.e. no fragments */
-               control |= BMU_EOF| BMU_IRQ_EOF;
+               control |= BMU_EOF | BMU_IRQ_EOF;
        else {
                struct skge_tx_desc *tf = td;
 
@@ -2811,8 +2757,8 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 
                        tf->dma_lo = map;
                        tf->dma_hi = (u64) map >> 32;
-                       pci_unmap_addr_set(e, mapaddr, map);
-                       pci_unmap_len_set(e, maplen, frag->size);
+                       dma_unmap_addr_set(e, mapaddr, map);
+                       dma_unmap_len_set(e, maplen, frag->size);
 
                        tf->control = BMU_OWN | BMU_SW | control | frag->size;
                }
@@ -2825,20 +2771,18 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 
        skge_write8(hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_START);
 
-       if (unlikely(netif_msg_tx_queued(skge)))
-               printk(KERN_DEBUG "%s: tx queued, slot %td, len %d\n",
-                      dev->name, e - skge->tx_ring.start, skb->len);
+       netif_printk(skge, tx_queued, KERN_DEBUG, skge->netdev,
+                    "tx queued, slot %td, len %d\n",
+                    e - skge->tx_ring.start, skb->len);
 
        skge->tx_ring.to_use = e->next;
        smp_wmb();
 
        if (skge_avail(&skge->tx_ring) <= TX_LOW_WATER) {
-               pr_debug("%s: transmit queue full\n", dev->name);
+               netdev_dbg(dev, "transmit queue full\n");
                netif_stop_queue(dev);
        }
 
-       dev->trans_start = jiffies;
-
        return NETDEV_TX_OK;
 }
 
@@ -2851,18 +2795,17 @@ static void skge_tx_free(struct skge_port *skge, struct skge_element *e,
 
        /* skb header vs. fragment */
        if (control & BMU_STF)
-               pci_unmap_single(pdev, pci_unmap_addr(e, mapaddr),
-                                pci_unmap_len(e, maplen),
+               pci_unmap_single(pdev, dma_unmap_addr(e, mapaddr),
+                                dma_unmap_len(e, maplen),
                                 PCI_DMA_TODEVICE);
        else
-               pci_unmap_page(pdev, pci_unmap_addr(e, mapaddr),
-                              pci_unmap_len(e, maplen),
+               pci_unmap_page(pdev, dma_unmap_addr(e, mapaddr),
+                              dma_unmap_len(e, maplen),
                               PCI_DMA_TODEVICE);
 
        if (control & BMU_EOF) {
-               if (unlikely(netif_msg_tx_done(skge)))
-                       printk(KERN_DEBUG PFX "%s: tx done slot %td\n",
-                              skge->netdev->name, e - skge->tx_ring.start);
+               netif_printk(skge, tx_done, KERN_DEBUG, skge->netdev,
+                            "tx done slot %td\n", e - skge->tx_ring.start);
 
                dev_kfree_skb(e->skb);
        }
@@ -2881,18 +2824,17 @@ static void skge_tx_clean(struct net_device *dev)
        }
 
        skge->tx_ring.to_clean = e;
-       netif_wake_queue(dev);
 }
 
 static void skge_tx_timeout(struct net_device *dev)
 {
        struct skge_port *skge = netdev_priv(dev);
 
-       if (netif_msg_timer(skge))
-               printk(KERN_DEBUG PFX "%s: tx timeout\n", dev->name);
+       netif_printk(skge, timer, KERN_DEBUG, skge->netdev, "tx timeout\n");
 
        skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_STOP);
        skge_tx_clean(dev);
+       netif_wake_queue(dev);
 }
 
 static int skge_change_mtu(struct net_device *dev, int new_mtu)
@@ -2934,8 +2876,7 @@ static void genesis_set_multicast(struct net_device *dev)
        struct skge_port *skge = netdev_priv(dev);
        struct skge_hw *hw = skge->hw;
        int port = skge->port;
-       int i, count = dev->mc_count;
-       struct dev_mc_list *list = dev->mc_list;
+       struct netdev_hw_addr *ha;
        u32 mode;
        u8 filter[8];
 
@@ -2951,12 +2892,12 @@ static void genesis_set_multicast(struct net_device *dev)
        else {
                memset(filter, 0, sizeof(filter));
 
-               if (skge->flow_status == FLOW_STAT_REM_SEND
-                   || skge->flow_status == FLOW_STAT_SYMMETRIC)
+               if (skge->flow_status == FLOW_STAT_REM_SEND ||
+                   skge->flow_status == FLOW_STAT_SYMMETRIC)
                        genesis_add_filter(filter, pause_mc_addr);
 
-               for (i = 0; list && i < count; i++, list = list->next)
-                       genesis_add_filter(filter, list->dmi_addr);
+               netdev_for_each_mc_addr(ha, dev)
+                       genesis_add_filter(filter, ha->addr);
        }
 
        xm_write32(hw, port, XM_MODE, mode);
@@ -2974,9 +2915,9 @@ static void yukon_set_multicast(struct net_device *dev)
        struct skge_port *skge = netdev_priv(dev);
        struct skge_hw *hw = skge->hw;
        int port = skge->port;
-       struct dev_mc_list *list = dev->mc_list;
-       int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND
-                       || skge->flow_status == FLOW_STAT_SYMMETRIC);
+       struct netdev_hw_addr *ha;
+       int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND ||
+                       skge->flow_status == FLOW_STAT_SYMMETRIC);
        u16 reg;
        u8 filter[8];
 
@@ -2989,17 +2930,16 @@ static void yukon_set_multicast(struct net_device *dev)
                reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
        else if (dev->flags & IFF_ALLMULTI)     /* all multicast */
                memset(filter, 0xff, sizeof(filter));
-       else if (dev->mc_count == 0 && !rx_pause)/* no multicast */
+       else if (netdev_mc_empty(dev) && !rx_pause)/* no multicast */
                reg &= ~GM_RXCR_MCF_ENA;
        else {
-               int i;
                reg |= GM_RXCR_MCF_ENA;
 
                if (rx_pause)
                        yukon_add_filter(filter, pause_mc_addr);
 
-               for (i = 0; list && i < dev->mc_count; i++, list = list->next)
-                       yukon_add_filter(filter, list->dmi_addr);
+               netdev_for_each_mc_addr(ha, dev)
+                       yukon_add_filter(filter, ha->addr);
        }
 
 
@@ -3056,10 +2996,9 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
        struct sk_buff *skb;
        u16 len = control & BMU_BBC;
 
-       if (unlikely(netif_msg_rx_status(skge)))
-               printk(KERN_DEBUG PFX "%s: rx slot %td status 0x%x len %d\n",
-                      dev->name, e - skge->rx_ring.start,
-                      status, len);
+       netif_printk(skge, rx_status, KERN_DEBUG, skge->netdev,
+                    "rx slot %td status 0x%x len %d\n",
+                    e - skge->rx_ring.start, status, len);
 
        if (len > skge->rx_buf_size)
                goto error;
@@ -3074,37 +3013,37 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
                goto error;
 
        if (len < RX_COPY_THRESHOLD) {
-               skb = netdev_alloc_skb(dev, len + 2);
+               skb = netdev_alloc_skb_ip_align(dev, len);
                if (!skb)
                        goto resubmit;
 
-               skb_reserve(skb, 2);
                pci_dma_sync_single_for_cpu(skge->hw->pdev,
-                                           pci_unmap_addr(e, mapaddr),
+                                           dma_unmap_addr(e, mapaddr),
                                            len, PCI_DMA_FROMDEVICE);
                skb_copy_from_linear_data(e->skb, skb->data, len);
                pci_dma_sync_single_for_device(skge->hw->pdev,
-                                              pci_unmap_addr(e, mapaddr),
+                                              dma_unmap_addr(e, mapaddr),
                                               len, PCI_DMA_FROMDEVICE);
                skge_rx_reuse(e, skge->rx_buf_size);
        } else {
                struct sk_buff *nskb;
-               nskb = netdev_alloc_skb(dev, skge->rx_buf_size + NET_IP_ALIGN);
+
+               nskb = netdev_alloc_skb_ip_align(dev, skge->rx_buf_size);
                if (!nskb)
                        goto resubmit;
 
-               skb_reserve(nskb, NET_IP_ALIGN);
                pci_unmap_single(skge->hw->pdev,
-                                pci_unmap_addr(e, mapaddr),
-                                pci_unmap_len(e, maplen),
+                                dma_unmap_addr(e, mapaddr),
+                                dma_unmap_len(e, maplen),
                                 PCI_DMA_FROMDEVICE);
                skb = e->skb;
-               prefetch(skb->data);
+               prefetch(skb->data);
                skge_rx_setup(skge, e, nskb, skge->rx_buf_size);
        }
 
        skb_put(skb, len);
-       if (skge->rx_csum) {
+
+       if (dev->features & NETIF_F_RXCSUM) {
                skb->csum = csum;
                skb->ip_summed = CHECKSUM_COMPLETE;
        }
@@ -3114,10 +3053,9 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
        return skb;
 error:
 
-       if (netif_msg_rx_err(skge))
-               printk(KERN_DEBUG PFX "%s: rx err, slot %td control 0x%x status 0x%x\n",
-                      dev->name, e - skge->rx_ring.start,
-                      control, status);
+       netif_printk(skge, rx_err, KERN_DEBUG, skge->netdev,
+                    "rx err, slot %td control 0x%x status 0x%x\n",
+                    e - skge->rx_ring.start, control, status);
 
        if (skge->hw->chip_id == CHIP_ID_GENESIS) {
                if (status & (XMR_FS_RUNT|XMR_FS_LNG_ERR))
@@ -3199,8 +3137,7 @@ static int skge_poll(struct napi_struct *napi, int to_do)
 
                skb = skge_rx_get(dev, e, control, rd->status, rd->csum2);
                if (likely(skb)) {
-                       netif_receive_skb(skb);
-
+                       napi_gro_receive(napi, skb);
                        ++work_done;
                }
        }
@@ -3213,8 +3150,9 @@ static int skge_poll(struct napi_struct *napi, int to_do)
        if (work_done < to_do) {
                unsigned long flags;
 
+               napi_gro_flush(napi);
                spin_lock_irqsave(&hw->hw_lock, flags);
-               __netif_rx_complete(dev, napi);
+               __napi_complete(napi);
                hw->intr_mask |= napimask[skge->port];
                skge_write32(hw, B0_IMSK, hw->intr_mask);
                skge_read32(hw, B0_IMSK);
@@ -3377,7 +3315,7 @@ static irqreturn_t skge_intr(int irq, void *dev_id)
        if (status & (IS_XA1_F|IS_R1_F)) {
                struct skge_port *skge = netdev_priv(hw->dev[0]);
                hw->intr_mask &= ~(IS_XA1_F|IS_R1_F);
-               netif_rx_schedule(hw->dev[0], &skge->napi);
+               napi_schedule(&skge->napi);
        }
 
        if (status & IS_PA_TO_TX1)
@@ -3397,7 +3335,7 @@ static irqreturn_t skge_intr(int irq, void *dev_id)
 
                if (status & (IS_XA2_F|IS_R2_F)) {
                        hw->intr_mask &= ~(IS_XA2_F|IS_R2_F);
-                       netif_rx_schedule(hw->dev[1], &skge->napi);
+                       napi_schedule(&skge->napi);
                }
 
                if (status & IS_PA_TO_RX2) {
@@ -3577,8 +3515,7 @@ static int skge_reset(struct skge_hw *hw)
                        hw->ram_offset = 0x80000;
                } else
                        hw->ram_size = t8 * 512;
-       }
-       else if (t8 == 0)
+       } else if (t8 == 0)
                hw->ram_size = 0x20000;
        else
                hw->ram_size = t8 * 4096;
@@ -3689,7 +3626,7 @@ static int skge_debug_show(struct seq_file *seq, void *v)
                           t->csum_offs, t->csum_write, t->csum_start);
        }
 
-       seq_printf(seq, "\nRx Ring: \n");
+       seq_printf(seq, "\nRx Ring:\n");
        for (e = skge->rx_ring.to_clean; ; e = e->next) {
                const struct skge_rx_desc *r = e->desc;
 
@@ -3732,7 +3669,7 @@ static int skge_device_event(struct notifier_block *unused,
                goto done;
 
        skge = netdev_priv(dev);
-       switch(event) {
+       switch (event) {
        case NETDEV_CHANGENAME:
                if (skge->debugfs) {
                        d = debugfs_rename(skge_debug, skge->debugfs,
@@ -3740,7 +3677,7 @@ static int skge_device_event(struct notifier_block *unused,
                        if (d)
                                skge->debugfs = d;
                        else {
-                               pr_info(PFX "%s: rename failed\n", dev->name);
+                               netdev_info(dev, "rename failed\n");
                                debugfs_remove(skge->debugfs);
                        }
                }
@@ -3758,8 +3695,7 @@ static int skge_device_event(struct notifier_block *unused,
                                        skge_debug, dev,
                                        &skge_debug_fops);
                if (!d || IS_ERR(d))
-                       pr_info(PFX "%s: debugfs create failed\n",
-                              dev->name);
+                       netdev_info(dev, "debugfs create failed\n");
                else
                        skge->debugfs = d;
                break;
@@ -3780,7 +3716,7 @@ static __init void skge_debug_init(void)
 
        ent = debugfs_create_dir("skge", NULL);
        if (!ent || IS_ERR(ent)) {
-               pr_info(PFX "debugfs create directory failed\n");
+               pr_info("debugfs create directory failed\n");
                return;
        }
 
@@ -3856,8 +3792,10 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
        skge->speed = -1;
        skge->advertising = skge_supported_modes(hw);
 
-       if (device_may_wakeup(&hw->pdev->dev))
+       if (device_can_wakeup(&hw->pdev->dev)) {
                skge->wol = wol_supported(hw) & WAKE_MAGIC;
+               device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
+       }
 
        hw->dev[port] = dev;
 
@@ -3867,18 +3805,15 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
        setup_timer(&skge->link_timer, xm_link_timer, (unsigned long) skge);
 
        if (hw->chip_id != CHIP_ID_GENESIS) {
-               dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
-               skge->rx_csum = 1;
+               dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+                                  NETIF_F_RXCSUM;
+               dev->features |= dev->hw_features;
        }
 
        /* read the mac address */
        memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port*8, ETH_ALEN);
        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
-       /* device is off until link detection */
-       netif_carrier_off(dev);
-       netif_stop_queue(dev);
-
        return dev;
 }
 
@@ -3886,11 +3821,11 @@ static void __devinit skge_show_addr(struct net_device *dev)
 {
        const struct skge_port *skge = netdev_priv(dev);
 
-       if (netif_msg_probe(skge))
-               printk(KERN_INFO PFX "%s: addr %pM\n",
-                      dev->name, dev->dev_addr);
+       netif_info(skge, probe, skge->netdev, "addr %pM\n", dev->dev_addr);
 }
 
+static int only_32bit_dma;
+
 static int __devinit skge_probe(struct pci_dev *pdev,
                                const struct pci_device_id *ent)
 {
@@ -3912,12 +3847,12 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!only_32bit_dma && !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
-       } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+       } else if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                using_dac = 0;
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        }
 
        if (err) {
@@ -3937,16 +3872,19 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 #endif
 
        err = -ENOMEM;
-       hw = kzalloc(sizeof(*hw), GFP_KERNEL);
+       /* space for skge@pci:0000:04:00.0 */
+       hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:")
+                    + strlen(pci_name(pdev)) + 1, GFP_KERNEL);
        if (!hw) {
                dev_err(&pdev->dev, "cannot allocate hardware struct\n");
                goto err_out_free_regions;
        }
+       sprintf(hw->irq_name, DRV_NAME "@pci:%s", pci_name(pdev));
 
        hw->pdev = pdev;
        spin_lock_init(&hw->hw_lock);
        spin_lock_init(&hw->phy_lock);
-       tasklet_init(&hw->phy_task, &skge_extirq, (unsigned long) hw);
+       tasklet_init(&hw->phy_task, skge_extirq, (unsigned long) hw);
 
        hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000);
        if (!hw->regs) {
@@ -3958,9 +3896,10 @@ static int __devinit skge_probe(struct pci_dev *pdev,
        if (err)
                goto err_out_iounmap;
 
-       printk(KERN_INFO PFX DRV_VERSION " addr 0x%llx irq %d chip %s rev %d\n",
-              (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
-              skge_board_name(hw), hw->chip_rev);
+       pr_info("%s addr 0x%llx irq %d chip %s rev %d\n",
+               DRV_VERSION,
+               (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
+               skge_board_name(hw), hw->chip_rev);
 
        dev = skge_devinit(hw, 0, using_dac);
        if (!dev)
@@ -3976,7 +3915,7 @@ static int __devinit skge_probe(struct pci_dev *pdev,
                goto err_out_free_netdev;
        }
 
-       err = request_irq(pdev->irq, skge_intr, IRQF_SHARED, dev->name, hw);
+       err = request_irq(pdev->irq, skge_intr, IRQF_SHARED, hw->irq_name, hw);
        if (err) {
                dev_err(&pdev->dev, "%s: cannot assign irq %d\n",
                       dev->name, pdev->irq);
@@ -3984,14 +3923,17 @@ static int __devinit skge_probe(struct pci_dev *pdev,
        }
        skge_show_addr(dev);
 
-       if (hw->ports > 1 && (dev1 = skge_devinit(hw, 1, using_dac))) {
-               if (register_netdev(dev1) == 0)
+       if (hw->ports > 1) {
+               dev1 = skge_devinit(hw, 1, using_dac);
+               if (dev1 && register_netdev(dev1) == 0)
                        skge_show_addr(dev1);
                else {
                        /* Failure to register second port need not be fatal */
                        dev_warn(&pdev->dev, "register of second port failed\n");
                        hw->dev[1] = NULL;
-                       free_netdev(dev1);
+                       hw->ports = 1;
+                       if (dev1)
+                               free_netdev(dev1);
                }
        }
        pci_set_drvdata(pdev, hw);
@@ -4025,9 +3967,8 @@ static void __devexit skge_remove(struct pci_dev *pdev)
        if (!hw)
                return;
 
-       flush_scheduled_work();
-
-       if ((dev1 = hw->dev[1]))
+       dev1 = hw->dev[1];
+       if (dev1)
                unregister_netdev(dev1);
        dev0 = hw->dev[0];
        unregister_netdev(dev0);
@@ -4056,53 +3997,40 @@ static void __devexit skge_remove(struct pci_dev *pdev)
 }
 
 #ifdef CONFIG_PM
-static int skge_suspend(struct pci_dev *pdev, pm_message_t state)
+static int skge_suspend(struct device *dev)
 {
+       struct pci_dev *pdev = to_pci_dev(dev);
        struct skge_hw *hw  = pci_get_drvdata(pdev);
-       int i, err, wol = 0;
+       int i;
 
        if (!hw)
                return 0;
 
-       err = pci_save_state(pdev);
-       if (err)
-               return err;
-
        for (i = 0; i < hw->ports; i++) {
                struct net_device *dev = hw->dev[i];
                struct skge_port *skge = netdev_priv(dev);
 
                if (netif_running(dev))
                        skge_down(dev);
+
                if (skge->wol)
                        skge_wol_init(skge);
-
-               wol |= skge->wol;
        }
 
        skge_write32(hw, B0_IMSK, 0);
 
-       pci_prepare_to_sleep(pdev);
-
        return 0;
 }
 
-static int skge_resume(struct pci_dev *pdev)
+static int skge_resume(struct device *dev)
 {
+       struct pci_dev *pdev = to_pci_dev(dev);
        struct skge_hw *hw  = pci_get_drvdata(pdev);
        int i, err;
 
        if (!hw)
                return 0;
 
-       err = pci_back_from_sleep(pdev);
-       if (err)
-               goto out;
-
-       err = pci_restore_state(pdev);
-       if (err)
-               goto out;
-
        err = skge_reset(hw);
        if (err)
                goto out;
@@ -4114,8 +4042,7 @@ static int skge_resume(struct pci_dev *pdev)
                        err = skge_up(dev);
 
                        if (err) {
-                               printk(KERN_ERR PFX "%s: could not up: %d\n",
-                                      dev->name, err);
+                               netdev_err(dev, "could not up: %d\n", err);
                                dev_close(dev);
                                goto out;
                        }
@@ -4124,12 +4051,19 @@ static int skge_resume(struct pci_dev *pdev)
 out:
        return err;
 }
+
+static SIMPLE_DEV_PM_OPS(skge_pm_ops, skge_suspend, skge_resume);
+#define SKGE_PM_OPS (&skge_pm_ops)
+
+#else
+
+#define SKGE_PM_OPS NULL
 #endif
 
 static void skge_shutdown(struct pci_dev *pdev)
 {
        struct skge_hw *hw  = pci_get_drvdata(pdev);
-       int i, wol = 0;
+       int i;
 
        if (!hw)
                return;
@@ -4140,15 +4074,10 @@ static void skge_shutdown(struct pci_dev *pdev)
 
                if (skge->wol)
                        skge_wol_init(skge);
-               wol |= skge->wol;
        }
 
-       if (pci_enable_wake(pdev, PCI_D3cold, wol))
-               pci_enable_wake(pdev, PCI_D3hot, wol);
-
-       pci_disable_device(pdev);
+       pci_wake_from_d3(pdev, device_may_wakeup(&pdev->dev));
        pci_set_power_state(pdev, PCI_D3hot);
-
 }
 
 static struct pci_driver skge_driver = {
@@ -4156,15 +4085,25 @@ static struct pci_driver skge_driver = {
        .id_table =     skge_id_table,
        .probe =        skge_probe,
        .remove =       __devexit_p(skge_remove),
-#ifdef CONFIG_PM
-       .suspend =      skge_suspend,
-       .resume =       skge_resume,
-#endif
        .shutdown =     skge_shutdown,
+       .driver.pm =    SKGE_PM_OPS,
+};
+
+static struct dmi_system_id skge_32bit_dma_boards[] = {
+       {
+               .ident = "Gigabyte nForce boards",
+               .matches = {
+                       DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co"),
+                       DMI_MATCH(DMI_BOARD_NAME, "nForce"),
+               },
+       },
+       {}
 };
 
 static int __init skge_init_module(void)
 {
+       if (dmi_check_system(skge_32bit_dma_boards))
+               only_32bit_dma = 1;
        skge_debug_init();
        return pci_register_driver(&skge_driver);
 }