Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / net / skge.c
index b680cb0..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.12"
-#define PFX                    DRV_NAME " "
+#define DRV_VERSION            "1.13"
 
 #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) },
@@ -104,6 +109,7 @@ static void yukon_get_stats(struct skge_port *skge, u64 *data);
 static void yukon_init(struct skge_hw *hw, int port);
 static void genesis_mac_init(struct skge_hw *hw, int port);
 static void genesis_link_up(struct skge_port *skge);
+static void skge_set_multicast(struct net_device *dev);
 
 /* Avoid conditionals by using array */
 static const int txqaddr[] = { Q_XA1, Q_XA2 };
@@ -149,24 +155,6 @@ static u32 wol_supported(const struct skge_hw *hw)
        return WAKE_MAGIC | WAKE_PHY;
 }
 
-static u32 pci_wake_enabled(struct pci_dev *dev)
-{
-       int pm = pci_find_capability(dev, PCI_CAP_ID_PM);
-       u16 value;
-
-       /* If device doesn't support PM Capabilities, but request is to disable
-        * wake events, it's a nop; otherwise fail */
-       if (!pm)
-               return 0;
-
-       pci_read_config_word(dev, pm + PCI_PM_PMC, &value);
-
-       value &= PCI_PM_CAP_PME_MASK;
-       value >>= ffs(PCI_PM_CAP_PME_MASK) - 1;   /* First bit of mask */
-
-       return value != 0;
-}
-
 static void skge_wol_init(struct skge_port *skge)
 {
        struct skge_hw *hw = skge->hw;
@@ -203,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,
@@ -232,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);
@@ -254,10 +242,14 @@ 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))
+       if ((wol->wolopts & ~wol_supported(hw)) ||
+           !device_can_wakeup(&hw->pdev->dev))
                return -EOPNOTSUPP;
 
        skge->wol = wol->wolopts;
+
+       device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
+
        return 0;
 }
 
@@ -269,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;
 }
@@ -309,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;
 }
@@ -319,6 +314,7 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
        struct skge_port *skge = netdev_priv(dev);
        const struct skge_hw *hw = skge->hw;
        u32 supported = skge_supported_modes(hw);
+       int err = 0;
 
        if (ecmd->autoneg == AUTONEG_ENABLE) {
                ecmd->advertising = supported;
@@ -326,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;
@@ -360,17 +357,23 @@ 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;
        }
 
        skge->autoneg = ecmd->autoneg;
        skge->advertising = ecmd->advertising;
 
-       if (netif_running(dev))
-               skge_phy_reset(skge);
+       if (netif_running(dev)) {
+               skge_down(dev);
+               err = skge_up(dev);
+               if (err) {
+                       dev_close(dev);
+                       return err;
+               }
+       }
 
-       return (0);
+       return 0;
 }
 
 static void skge_get_drvinfo(struct net_device *dev,
@@ -494,7 +497,7 @@ static int skge_set_ring_param(struct net_device *dev,
                               struct ethtool_ringparam *p)
 {
        struct skge_port *skge = netdev_priv(dev);
-       int err;
+       int err = 0;
 
        if (p->rx_pending == 0 || p->rx_pending > MAX_RX_RING_SIZE ||
            p->tx_pending < TX_LOW_WATER || p->tx_pending > MAX_TX_RING_SIZE)
@@ -510,7 +513,7 @@ static int skge_set_ring_param(struct net_device *dev,
                        dev_close(dev);
        }
 
-       return 0;
+       return err;
 }
 
 static u32 skge_get_msglevel(struct net_device *netdev)
@@ -536,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;
 }
@@ -593,6 +557,7 @@ static int skge_set_pauseparam(struct net_device *dev,
 {
        struct skge_port *skge = netdev_priv(dev);
        struct ethtool_pauseparam old;
+       int err = 0;
 
        skge_get_pauseparam(dev, &old);
 
@@ -609,8 +574,14 @@ static int skge_set_pauseparam(struct net_device *dev,
                        skge->flow_control = FLOW_MODE_NONE;
        }
 
-       if (netif_running(dev))
-               skge_phy_reset(skge);
+       if (netif_running(dev)) {
+               skge_down(dev);
+               err = skge_up(dev);
+               if (err) {
+                       dev_close(dev);
+                       return err;
+               }
+       }
 
        return 0;
 }
@@ -777,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;
 }
@@ -809,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)
@@ -916,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,
 };
@@ -976,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,
@@ -1010,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;
@@ -1040,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;
@@ -1048,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:
@@ -1071,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)
@@ -1086,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");
 }
 
 
@@ -1095,16 +1058,9 @@ static void xm_link_down(struct skge_hw *hw, int port)
 {
        struct net_device *dev = hw->dev[port];
        struct skge_port *skge = netdev_priv(dev);
-       u16 cmd = xm_read16(hw, port, XM_MMU_CMD);
 
        xm_write16(hw, port, XM_IMSK, XM_IMSK_DISABLE);
 
-       cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
-       xm_write16(hw, port, XM_MMU_CMD, cmd);
-
-       /* dummy read to ensure writing */
-       xm_read16(hw, port, XM_MMU_CMD);
-
        if (netif_carrier_ok(dev))
                skge_link_down(skge);
 }
@@ -1136,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;
 }
 
@@ -1193,7 +1148,8 @@ 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);
 
@@ -1209,6 +1165,11 @@ static void genesis_reset(struct skge_hw *hw, int port)
                xm_write16(hw, port, PHY_BCOM_INT_MASK, 0xffff);
 
        xm_outhash(hw, port, XM_HSM, zero);
+
+       /* Flush TX and RX fifo */
+       reg = xm_read32(hw, port, XM_MODE);
+       xm_write32(hw, port, XM_MODE, reg | XM_MD_FTF);
+       xm_write32(hw, port, XM_MODE, reg | XM_MD_FRF);
 }
 
 
@@ -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;
@@ -1634,15 +1591,14 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
        }
        xm_write16(hw, port, XM_RX_CMD, r);
 
-
        /* We want short frames padded to 60 bytes. */
        xm_write16(hw, port, XM_TX_CMD, XM_TX_AUTO_PAD);
 
-       /*
-        * Bump up the transmit threshold. This helps hold off transmit
-        * underruns when we're blasting traffic from both ports at once.
-        */
-       xm_write16(hw, port, XM_TX_THR, 512);
+       /* Increase threshold for jumbo frames on dual port */
+       if (hw->ports > 1 && jumbo)
+               xm_write16(hw, port, XM_TX_THR, 1020);
+       else
+               xm_write16(hw, port, XM_TX_THR, 512);
 
        /*
         * Enable the reception of all error frames. This is is
@@ -1701,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,
@@ -1714,6 +1670,12 @@ static void genesis_stop(struct skge_port *skge)
        struct skge_hw *hw = skge->hw;
        int port = skge->port;
        unsigned retries = 1000;
+       u16 cmd;
+
+       /* 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);
 
        genesis_reset(hw, port);
 
@@ -1785,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);
        }
 
@@ -1824,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
@@ -1891,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:
@@ -1929,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;
 }
 
@@ -1958,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;
 }
 
@@ -2186,9 +2144,12 @@ static void yukon_mac_init(struct skge_hw *hw, int port)
                         TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) |
                         TX_IPG_JAM_DATA(TX_IPG_JAM_DEF));
 
-       /* serial mode register */
-       reg = GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
-       if (hw->dev[port]->mtu > 1500)
+       /* configure the Serial Mode Register */
+       reg = DATA_BLIND_VAL(DATA_BLIND_DEF)
+               | GM_SMOD_VLAN_ENA
+               | IPG_DATA_VAL(IPG_DATA_DEF);
+
+       if (hw->dev[port]->mtu > ETH_DATA_LEN)
                reg |= GM_SMOD_JUMBO_ENA;
 
        gma_write16(hw, port, GM_SERIAL_MODE, reg);
@@ -2288,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;
@@ -2369,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)
@@ -2431,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? */
 }
@@ -2456,7 +2414,7 @@ static void skge_phy_reset(struct skge_port *skge)
        }
        spin_unlock_bh(&hw->phy_lock);
 
-       dev->set_multicast_list(dev);
+       skge_set_multicast(dev);
 }
 
 /* Basic MII support */
@@ -2470,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;
 
@@ -2488,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,
@@ -2564,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;
@@ -2663,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);
@@ -2738,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;
@@ -2760,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;
@@ -2785,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;
 
@@ -2803,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;
                }
@@ -2817,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;
 }
 
@@ -2843,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);
        }
@@ -2873,27 +2824,22 @@ 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)
 {
-       struct skge_port *skge = netdev_priv(dev);
-       struct skge_hw *hw = skge->hw;
-       int port = skge->port;
        int err;
-       u16 ctl, reg;
 
        if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU)
                return -EINVAL;
@@ -2903,40 +2849,13 @@ static int skge_change_mtu(struct net_device *dev, int new_mtu)
                return 0;
        }
 
-       skge_write32(hw, B0_IMSK, 0);
-       dev->trans_start = jiffies;     /* prevent tx timeout */
-       netif_stop_queue(dev);
-       napi_disable(&skge->napi);
-
-       ctl = gma_read16(hw, port, GM_GP_CTRL);
-       gma_write16(hw, port, GM_GP_CTRL, ctl & ~GM_GPCR_RX_ENA);
-
-       skge_rx_clean(skge);
-       skge_rx_stop(hw, port);
+       skge_down(dev);
 
        dev->mtu = new_mtu;
 
-       reg = GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
-       if (new_mtu > 1500)
-               reg |= GM_SMOD_JUMBO_ENA;
-       gma_write16(hw, port, GM_SERIAL_MODE, reg);
-
-       skge_write8(hw, RB_ADDR(rxqaddr[port], RB_CTRL), RB_ENA_OP_MD);
-
-       err = skge_rx_fill(dev);
-       wmb();
-       if (!err)
-               skge_write8(hw, Q_ADDR(rxqaddr[port], Q_CSR), CSR_START | CSR_IRQ_CL_F);
-       skge_write32(hw, B0_IMSK, hw->intr_mask);
-
+       err = skge_up(dev);
        if (err)
                dev_close(dev);
-       else {
-               gma_write16(hw, port, GM_GP_CTRL, ctl);
-
-               napi_enable(&skge->napi);
-               netif_wake_queue(dev);
-       }
 
        return err;
 }
@@ -2957,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];
 
@@ -2974,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);
@@ -2997,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];
 
@@ -3012,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);
        }
 
 
@@ -3055,6 +2972,18 @@ static inline int bad_phy_status(const struct skge_hw *hw, u32 status)
                        (status & GMR_FS_RX_OK) == 0;
 }
 
+static void skge_set_multicast(struct net_device *dev)
+{
+       struct skge_port *skge = netdev_priv(dev);
+       struct skge_hw *hw = skge->hw;
+
+       if (hw->chip_id == CHIP_ID_GENESIS)
+               genesis_set_multicast(dev);
+       else
+               yukon_set_multicast(dev);
+
+}
+
 
 /* Get receive buffer from descriptor.
  * Handles copy of small buffers and reallocation failures
@@ -3067,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;
@@ -3085,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;
        }
@@ -3125,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))
@@ -3210,9 +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)) {
-                       dev->last_rx = jiffies;
-                       netif_receive_skb(skb);
-
+                       napi_gro_receive(napi, skb);
                        ++work_done;
                }
        }
@@ -3223,12 +3148,15 @@ static int skge_poll(struct napi_struct *napi, int to_do)
        skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_START);
 
        if (work_done < to_do) {
-               spin_lock_irq(&hw->hw_lock);
-               __netif_rx_complete(dev, napi);
+               unsigned long flags;
+
+               napi_gro_flush(napi);
+               spin_lock_irqsave(&hw->hw_lock, flags);
+               __napi_complete(napi);
                hw->intr_mask |= napimask[skge->port];
                skge_write32(hw, B0_IMSK, hw->intr_mask);
                skge_read32(hw, B0_IMSK);
-               spin_unlock_irq(&hw->hw_lock);
+               spin_unlock_irqrestore(&hw->hw_lock, flags);
        }
 
        return work_done;
@@ -3387,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)
@@ -3407,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) {
@@ -3587,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;
@@ -3699,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;
 
@@ -3738,11 +3665,11 @@ static int skge_device_event(struct notifier_block *unused,
        struct skge_port *skge;
        struct dentry *d;
 
-       if (dev->open != &skge_up || !skge_debug)
+       if (dev->netdev_ops->ndo_open != &skge_up || !skge_debug)
                goto done;
 
        skge = netdev_priv(dev);
-       switch(event) {
+       switch (event) {
        case NETDEV_CHANGENAME:
                if (skge->debugfs) {
                        d = debugfs_rename(skge_debug, skge->debugfs,
@@ -3750,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);
                        }
                }
@@ -3768,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;
@@ -3790,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;
        }
 
@@ -3812,6 +3738,23 @@ static __exit void skge_debug_cleanup(void)
 #define skge_debug_cleanup()
 #endif
 
+static const struct net_device_ops skge_netdev_ops = {
+       .ndo_open               = skge_up,
+       .ndo_stop               = skge_down,
+       .ndo_start_xmit         = skge_xmit_frame,
+       .ndo_do_ioctl           = skge_ioctl,
+       .ndo_get_stats          = skge_get_stats,
+       .ndo_tx_timeout         = skge_tx_timeout,
+       .ndo_change_mtu         = skge_change_mtu,
+       .ndo_validate_addr      = eth_validate_addr,
+       .ndo_set_multicast_list = skge_set_multicast,
+       .ndo_set_mac_address    = skge_set_mac_address,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       .ndo_poll_controller    = skge_netpoll,
+#endif
+};
+
+
 /* Initialize network device */
 static struct net_device *skge_devinit(struct skge_hw *hw, int port,
                                       int highmem)
@@ -3825,24 +3768,9 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
        }
 
        SET_NETDEV_DEV(dev, &hw->pdev->dev);
-       dev->open = skge_up;
-       dev->stop = skge_down;
-       dev->do_ioctl = skge_ioctl;
-       dev->hard_start_xmit = skge_xmit_frame;
-       dev->get_stats = skge_get_stats;
-       if (hw->chip_id == CHIP_ID_GENESIS)
-               dev->set_multicast_list = genesis_set_multicast;
-       else
-               dev->set_multicast_list = yukon_set_multicast;
-
-       dev->set_mac_address = skge_set_mac_address;
-       dev->change_mtu = skge_change_mtu;
-       SET_ETHTOOL_OPS(dev, &skge_ethtool_ops);
-       dev->tx_timeout = skge_tx_timeout;
+       dev->netdev_ops = &skge_netdev_ops;
+       dev->ethtool_ops = &skge_ethtool_ops;
        dev->watchdog_timeo = TX_WATCHDOG;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-       dev->poll_controller = skge_netpoll;
-#endif
        dev->irq = hw->pdev->irq;
 
        if (highmem)
@@ -3864,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 (pci_wake_enabled(hw->pdev))
+       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;
 
@@ -3875,31 +3805,27 @@ 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;
 }
 
 static void __devinit skge_show_addr(struct net_device *dev)
 {
        const struct skge_port *skge = netdev_priv(dev);
-       DECLARE_MAC_BUF(mac);
 
-       if (netif_msg_probe(skge))
-               printk(KERN_INFO PFX "%s: addr %s\n",
-                      dev->name, print_mac(mac, 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)
 {
@@ -3921,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) {
@@ -3946,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) {
@@ -3967,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)
@@ -3985,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);
@@ -3993,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);
@@ -4034,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);
@@ -4065,55 +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_enable_wake(pdev, pci_choose_state(pdev, state), wol);
-       pci_set_power_state(pdev, pci_choose_state(pdev, state));
 
        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_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);
-
        err = skge_reset(hw);
        if (err)
                goto out;
@@ -4125,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;
                        }
@@ -4135,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;
@@ -4151,15 +4074,10 @@ static void skge_shutdown(struct pci_dev *pdev)
 
                if (skge->wol)
                        skge_wol_init(skge);
-               wol |= skge->wol;
        }
 
-       pci_enable_wake(pdev, PCI_D3hot, wol);
-       pci_enable_wake(pdev, PCI_D3cold, 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 = {
@@ -4167,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);
 }