usbnet: fix skb traversing races during unlink(v2)
[linux-2.6.git] / drivers / net / sungem.c
index e567d0a..ade35dd 100644 (file)
  * NAPI and NETPOLL support
  * (C) 2004 by Eric Lemoine (eric.lemoine@gmail.com)
  *
- * TODO:
- *  - Now that the driver was significantly simplified, I need to rework
- *    the locking. I'm sure we don't need _2_ spinlocks, and we probably
- *    can avoid taking most of them for so long period of time (and schedule
- *    instead). The main issues at this point are caused by the netdev layer
- *    though:
- *
- *    gem_change_mtu() and gem_set_multicast() are called with a read_lock()
- *    help by net/core/dev.c, thus they can't schedule. That means they can't
- *    call netif_poll_disable() neither, thus force gem_poll() to keep a spinlock
- *    where it could have been dropped. change_mtu especially would love also to
- *    be able to msleep instead of horrid locked delays when resetting the HW,
- *    but that read_lock() makes it impossible, unless I defer it's action to
- *    the reset task, which means it'll be asynchronous (won't take effect until
- *    the system schedules a bit).
- *
- *    Also, it would probably be possible to also remove most of the long-life
- *    locking in open/resume code path (gem_reinit_chip) by beeing more careful
- *    about when we can start taking interrupts or get xmit() called...
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -38,7 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/ioport.h>
 #include <linux/in.h>
-#include <linux/slab.h>
+#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/delay.h>
 #include <linux/init.h>
@@ -55,7 +38,8 @@
 #include <linux/workqueue.h>
 #include <linux/if_vlan.h>
 #include <linux/bitops.h>
-#include <linux/mutex.h>
+#include <linux/mm.h>
+#include <linux/gfp.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
 
-#ifdef __sparc__
+#ifdef CONFIG_SPARC
 #include <asm/idprom.h>
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-#include <asm/pbm.h>
+#include <asm/prom.h>
 #endif
 
 #ifdef CONFIG_PPC_PMAC
 
 #define ADVERTISE_MASK (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \
                         SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \
-                        SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full)
+                        SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full | \
+                        SUPPORTED_Pause | SUPPORTED_Autoneg)
 
 #define DRV_NAME       "sungem"
-#define DRV_VERSION    "0.98"
-#define DRV_RELDATE    "8/24/03"
-#define DRV_AUTHOR     "David S. Miller (davem@redhat.com)"
+#define DRV_VERSION    "1.0"
+#define DRV_AUTHOR     "David S. Miller <davem@redhat.com>"
 
 static char version[] __devinitdata =
-        DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " " DRV_AUTHOR "\n";
+        DRV_NAME ".c:v" DRV_VERSION " " DRV_AUTHOR "\n";
 
 MODULE_AUTHOR(DRV_AUTHOR);
 MODULE_DESCRIPTION("Sun GEM Gbit ethernet driver");
 MODULE_LICENSE("GPL");
 
 #define GEM_MODULE_NAME        "gem"
-#define PFX GEM_MODULE_NAME ": "
 
-static struct pci_device_id gem_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(gem_pci_tbl) = {
        { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_GEM,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 
@@ -148,7 +129,7 @@ static u16 __phy_read(struct gem *gp, int phy_addr, int reg)
        cmd |= (MIF_FRAME_TAMSB);
        writel(cmd, gp->regs + MIF_FRAME);
 
-       while (limit--) {
+       while (--limit) {
                cmd = readl(gp->regs + MIF_FRAME);
                if (cmd & MIF_FRAME_TALSB)
                        break;
@@ -164,7 +145,7 @@ static u16 __phy_read(struct gem *gp, int phy_addr, int reg)
 
 static inline int _phy_read(struct net_device *dev, int mii_id, int reg)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        return __phy_read(gp, mii_id, reg);
 }
 
@@ -197,7 +178,7 @@ static void __phy_write(struct gem *gp, int phy_addr, int reg, u16 val)
 
 static inline void _phy_write(struct net_device *dev, int mii_id, int reg, int val)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        __phy_write(gp, mii_id, reg, val & 0xffff);
 }
 
@@ -216,6 +197,7 @@ static inline void gem_disable_ints(struct gem *gp)
 {
        /* Disable all interrupts, including TXDONE */
        writel(GREG_STAT_NAPI | GREG_STAT_TXDONE, gp->regs + GREG_IMASK);
+       (void)readl(gp->regs + GREG_IMASK); /* write posting */
 }
 
 static void gem_get_cell(struct gem *gp)
@@ -245,6 +227,29 @@ static void gem_put_cell(struct gem *gp)
 #endif /* CONFIG_PPC_PMAC */
 }
 
+static inline void gem_netif_stop(struct gem *gp)
+{
+       gp->dev->trans_start = jiffies; /* prevent tx timeout */
+       napi_disable(&gp->napi);
+       netif_tx_disable(gp->dev);
+}
+
+static inline void gem_netif_start(struct gem *gp)
+{
+       /* NOTE: unconditional netif_wake_queue is only
+        * appropriate so long as all callers are assured to
+        * have free tx slots.
+        */
+       netif_wake_queue(gp->dev);
+       napi_enable(&gp->napi);
+}
+
+static void gem_schedule_reset(struct gem *gp)
+{
+       gp->reset_task_pending = 1;
+       schedule_work(&gp->reset_task);
+}
+
 static void gem_handle_mif_event(struct gem *gp, u32 reg_val, u32 changed_bits)
 {
        if (netif_msg_intr(gp))
@@ -261,8 +266,7 @@ static int gem_pcs_interrupt(struct net_device *dev, struct gem *gp, u32 gem_sta
                        gp->dev->name, pcs_istat);
 
        if (!(pcs_istat & PCS_ISTAT_LSC)) {
-               printk(KERN_ERR "%s: PCS irq but no link status change???\n",
-                      dev->name);
+               netdev_err(dev, "PCS irq but no link status change???\n");
                return 0;
        }
 
@@ -281,20 +285,16 @@ static int gem_pcs_interrupt(struct net_device *dev, struct gem *gp, u32 gem_sta
                 * when autoneg has completed.
                 */
                if (pcs_miistat & PCS_MIISTAT_RF)
-                       printk(KERN_INFO "%s: PCS AutoNEG complete, "
-                              "RemoteFault\n", dev->name);
+                       netdev_info(dev, "PCS AutoNEG complete, RemoteFault\n");
                else
-                       printk(KERN_INFO "%s: PCS AutoNEG complete.\n",
-                              dev->name);
+                       netdev_info(dev, "PCS AutoNEG complete\n");
        }
 
        if (pcs_miistat & PCS_MIISTAT_LS) {
-               printk(KERN_INFO "%s: PCS link is now up.\n",
-                      dev->name);
+               netdev_info(dev, "PCS link is now up\n");
                netif_carrier_on(gp->dev);
        } else {
-               printk(KERN_INFO "%s: PCS link is now down.\n",
-                      dev->name);
+               netdev_info(dev, "PCS link is now down\n");
                netif_carrier_off(gp->dev);
                /* If this happens and the link timer is not running,
                 * reset so we re-negotiate.
@@ -322,31 +322,29 @@ static int gem_txmac_interrupt(struct net_device *dev, struct gem *gp, u32 gem_s
                return 0;
 
        if (txmac_stat & MAC_TXSTAT_URUN) {
-               printk(KERN_ERR "%s: TX MAC xmit underrun.\n",
-                      dev->name);
-               gp->net_stats.tx_fifo_errors++;
+               netdev_err(dev, "TX MAC xmit underrun\n");
+               dev->stats.tx_fifo_errors++;
        }
 
        if (txmac_stat & MAC_TXSTAT_MPE) {
-               printk(KERN_ERR "%s: TX MAC max packet size error.\n",
-                      dev->name);
-               gp->net_stats.tx_errors++;
+               netdev_err(dev, "TX MAC max packet size error\n");
+               dev->stats.tx_errors++;
        }
 
        /* The rest are all cases of one of the 16-bit TX
         * counters expiring.
         */
        if (txmac_stat & MAC_TXSTAT_NCE)
-               gp->net_stats.collisions += 0x10000;
+               dev->stats.collisions += 0x10000;
 
        if (txmac_stat & MAC_TXSTAT_ECE) {
-               gp->net_stats.tx_aborted_errors += 0x10000;
-               gp->net_stats.collisions += 0x10000;
+               dev->stats.tx_aborted_errors += 0x10000;
+               dev->stats.collisions += 0x10000;
        }
 
        if (txmac_stat & MAC_TXSTAT_LCE) {
-               gp->net_stats.tx_aborted_errors += 0x10000;
-               gp->net_stats.collisions += 0x10000;
+               dev->stats.tx_aborted_errors += 0x10000;
+               dev->stats.collisions += 0x10000;
        }
 
        /* We do not keep track of MAC_TXSTAT_FCE and
@@ -376,8 +374,7 @@ static int gem_rxmac_reset(struct gem *gp)
                udelay(10);
        }
        if (limit == 5000) {
-               printk(KERN_ERR "%s: RX MAC will not reset, resetting whole "
-                       "chip.\n", dev->name);
+               netdev_err(dev, "RX MAC will not reset, resetting whole chip\n");
                return 1;
        }
 
@@ -389,8 +386,7 @@ static int gem_rxmac_reset(struct gem *gp)
                udelay(10);
        }
        if (limit == 5000) {
-               printk(KERN_ERR "%s: RX MAC will not disable, resetting whole "
-                      "chip.\n", dev->name);
+               netdev_err(dev, "RX MAC will not disable, resetting whole chip\n");
                return 1;
        }
 
@@ -402,8 +398,7 @@ static int gem_rxmac_reset(struct gem *gp)
                udelay(10);
        }
        if (limit == 5000) {
-               printk(KERN_ERR "%s: RX DMA will not disable, resetting whole "
-                      "chip.\n", dev->name);
+               netdev_err(dev, "RX DMA will not disable, resetting whole chip\n");
                return 1;
        }
 
@@ -418,8 +413,7 @@ static int gem_rxmac_reset(struct gem *gp)
                udelay(10);
        }
        if (limit == 5000) {
-               printk(KERN_ERR "%s: RX reset command will not execute, resetting "
-                      "whole chip.\n", dev->name);
+               netdev_err(dev, "RX reset command will not execute, resetting whole chip\n");
                return 1;
        }
 
@@ -428,8 +422,7 @@ static int gem_rxmac_reset(struct gem *gp)
                struct gem_rxd *rxd = &gp->init_block->rxd[i];
 
                if (gp->rx_skbs[i] == NULL) {
-                       printk(KERN_ERR "%s: Parts of RX ring empty, resetting "
-                              "whole chip.\n", dev->name);
+                       netdev_err(dev, "Parts of RX ring empty, resetting whole chip\n");
                        return 1;
                }
 
@@ -478,22 +471,21 @@ static int gem_rxmac_interrupt(struct net_device *dev, struct gem *gp, u32 gem_s
        if (rxmac_stat & MAC_RXSTAT_OFLW) {
                u32 smac = readl(gp->regs + MAC_SMACHINE);
 
-               printk(KERN_ERR "%s: RX MAC fifo overflow smac[%08x].\n",
-                               dev->name, smac);
-               gp->net_stats.rx_over_errors++;
-               gp->net_stats.rx_fifo_errors++;
+               netdev_err(dev, "RX MAC fifo overflow smac[%08x]\n", smac);
+               dev->stats.rx_over_errors++;
+               dev->stats.rx_fifo_errors++;
 
                ret = gem_rxmac_reset(gp);
        }
 
        if (rxmac_stat & MAC_RXSTAT_ACE)
-               gp->net_stats.rx_frame_errors += 0x10000;
+               dev->stats.rx_frame_errors += 0x10000;
 
        if (rxmac_stat & MAC_RXSTAT_CCE)
-               gp->net_stats.rx_crc_errors += 0x10000;
+               dev->stats.rx_crc_errors += 0x10000;
 
        if (rxmac_stat & MAC_RXSTAT_LCE)
-               gp->net_stats.rx_length_errors += 0x10000;
+               dev->stats.rx_length_errors += 0x10000;
 
        /* We do not track MAC_RXSTAT_FCE and MAC_RXSTAT_VCE
         * events.
@@ -541,19 +533,18 @@ static int gem_pci_interrupt(struct net_device *dev, struct gem *gp, u32 gem_sta
 
        if (gp->pdev->vendor == PCI_VENDOR_ID_SUN &&
            gp->pdev->device == PCI_DEVICE_ID_SUN_GEM) {
-               printk(KERN_ERR "%s: PCI error [%04x] ",
-                      dev->name, pci_estat);
+               netdev_err(dev, "PCI error [%04x]", pci_estat);
 
                if (pci_estat & GREG_PCIESTAT_BADACK)
-                       printk("<No ACK64# during ABS64 cycle> ");
+                       pr_cont(" <No ACK64# during ABS64 cycle>");
                if (pci_estat & GREG_PCIESTAT_DTRTO)
-                       printk("<Delayed transaction timeout> ");
+                       pr_cont(" <Delayed transaction timeout>");
                if (pci_estat & GREG_PCIESTAT_OTHER)
-                       printk("<other>");
-               printk("\n");
+                       pr_cont(" <other>");
+               pr_cont("\n");
        } else {
                pci_estat |= GREG_PCIESTAT_OTHER;
-               printk(KERN_ERR "%s: PCI error\n", dev->name);
+               netdev_err(dev, "PCI error\n");
        }
 
        if (pci_estat & GREG_PCIESTAT_OTHER) {
@@ -564,26 +555,20 @@ static int gem_pci_interrupt(struct net_device *dev, struct gem *gp, u32 gem_sta
                 */
                pci_read_config_word(gp->pdev, PCI_STATUS,
                                     &pci_cfg_stat);
-               printk(KERN_ERR "%s: Read PCI cfg space status [%04x]\n",
-                      dev->name, pci_cfg_stat);
+               netdev_err(dev, "Read PCI cfg space status [%04x]\n",
+                          pci_cfg_stat);
                if (pci_cfg_stat & PCI_STATUS_PARITY)
-                       printk(KERN_ERR "%s: PCI parity error detected.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI parity error detected\n");
                if (pci_cfg_stat & PCI_STATUS_SIG_TARGET_ABORT)
-                       printk(KERN_ERR "%s: PCI target abort.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI target abort\n");
                if (pci_cfg_stat & PCI_STATUS_REC_TARGET_ABORT)
-                       printk(KERN_ERR "%s: PCI master acks target abort.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI master acks target abort\n");
                if (pci_cfg_stat & PCI_STATUS_REC_MASTER_ABORT)
-                       printk(KERN_ERR "%s: PCI master abort.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI master abort\n");
                if (pci_cfg_stat & PCI_STATUS_SIG_SYSTEM_ERROR)
-                       printk(KERN_ERR "%s: PCI system error SERR#.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI system error SERR#\n");
                if (pci_cfg_stat & PCI_STATUS_DETECTED_PARITY)
-                       printk(KERN_ERR "%s: PCI parity error.\n",
-                              dev->name);
+                       netdev_err(dev, "PCI parity error\n");
 
                /* Write the error bits back to clear them. */
                pci_cfg_stat &= (PCI_STATUS_PARITY |
@@ -612,7 +597,7 @@ static int gem_abnormal_irq(struct net_device *dev, struct gem *gp, u32 gem_stat
                if (netif_msg_rx_err(gp))
                        printk(KERN_DEBUG "%s: no buffer for rx frame\n",
                                gp->dev->name);
-               gp->net_stats.rx_dropped++;
+               dev->stats.rx_dropped++;
        }
 
        if (gem_status & GREG_STAT_RXTAGERR) {
@@ -620,58 +605,48 @@ static int gem_abnormal_irq(struct net_device *dev, struct gem *gp, u32 gem_stat
                if (netif_msg_rx_err(gp))
                        printk(KERN_DEBUG "%s: corrupt rx tag framing\n",
                                gp->dev->name);
-               gp->net_stats.rx_errors++;
+               dev->stats.rx_errors++;
 
-               goto do_reset;
+               return 1;
        }
 
        if (gem_status & GREG_STAT_PCS) {
                if (gem_pcs_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        if (gem_status & GREG_STAT_TXMAC) {
                if (gem_txmac_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        if (gem_status & GREG_STAT_RXMAC) {
                if (gem_rxmac_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        if (gem_status & GREG_STAT_MAC) {
                if (gem_mac_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        if (gem_status & GREG_STAT_MIF) {
                if (gem_mif_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        if (gem_status & GREG_STAT_PCIERR) {
                if (gem_pci_interrupt(dev, gp, gem_status))
-                       goto do_reset;
+                       return 1;
        }
 
        return 0;
-
-do_reset:
-       gp->reset_task_pending = 1;
-       schedule_work(&gp->reset_task);
-
-       return 1;
 }
 
 static __inline__ void gem_tx(struct net_device *dev, struct gem *gp, u32 gem_status)
 {
        int entry, limit;
 
-       if (netif_msg_intr(gp))
-               printk(KERN_DEBUG "%s: tx interrupt, gem_status: 0x%x\n",
-                       gp->dev->name, gem_status);
-
        entry = gp->tx_old;
        limit = ((gem_status & GREG_STAT_TXNR) >> GREG_STAT_TXNR_SHIFT);
        while (entry != limit) {
@@ -702,7 +677,7 @@ static __inline__ void gem_tx(struct net_device *dev, struct gem *gp, u32 gem_st
                                break;
                }
                gp->tx_skbs[entry] = NULL;
-               gp->net_stats.tx_bytes += skb->len;
+               dev->stats.tx_bytes += skb->len;
 
                for (frag = 0; frag <= skb_shinfo(skb)->nr_frags; frag++) {
                        txd = &gp->init_block->txd[entry];
@@ -714,14 +689,28 @@ static __inline__ void gem_tx(struct net_device *dev, struct gem *gp, u32 gem_st
                        entry = NEXT_TX(entry);
                }
 
-               gp->net_stats.tx_packets++;
-               dev_kfree_skb_irq(skb);
+               dev->stats.tx_packets++;
+               dev_kfree_skb(skb);
        }
        gp->tx_old = entry;
 
-       if (netif_queue_stopped(dev) &&
-           TX_BUFFS_AVAIL(gp) > (MAX_SKB_FRAGS + 1))
-               netif_wake_queue(dev);
+       /* Need to make the tx_old update visible to gem_start_xmit()
+        * before checking for netif_queue_stopped().  Without the
+        * memory barrier, there is a small possibility that gem_start_xmit()
+        * will miss it and cause the queue to be stopped forever.
+        */
+       smp_mb();
+
+       if (unlikely(netif_queue_stopped(dev) &&
+                    TX_BUFFS_AVAIL(gp) > (MAX_SKB_FRAGS + 1))) {
+               struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
+
+               __netif_tx_lock(txq, smp_processor_id());
+               if (netif_queue_stopped(dev) &&
+                   TX_BUFFS_AVAIL(gp) > (MAX_SKB_FRAGS + 1))
+                       netif_wake_queue(dev);
+               __netif_tx_unlock(txq);
+       }
 }
 
 static __inline__ void gem_post_rxds(struct gem *gp, int limit)
@@ -754,10 +743,27 @@ static __inline__ void gem_post_rxds(struct gem *gp, int limit)
        }
 }
 
+#define ALIGNED_RX_SKB_ADDR(addr) \
+        ((((unsigned long)(addr) + (64UL - 1UL)) & ~(64UL - 1UL)) - (unsigned long)(addr))
+static __inline__ struct sk_buff *gem_alloc_skb(struct net_device *dev, int size,
+                                               gfp_t gfp_flags)
+{
+       struct sk_buff *skb = alloc_skb(size + 64, gfp_flags);
+
+       if (likely(skb)) {
+               unsigned long offset = ALIGNED_RX_SKB_ADDR(skb->data);
+               skb_reserve(skb, offset);
+               skb->dev = dev;
+       }
+       return skb;
+}
+
 static int gem_rx(struct gem *gp, int work_to_do)
 {
+       struct net_device *dev = gp->dev;
        int entry, drops, work_done = 0;
        u32 done;
+       __sum16 csum;
 
        if (netif_msg_rx_status(gp))
                printk(KERN_DEBUG "%s: rx interrupt, done: %d, rx_new: %d\n",
@@ -769,7 +775,7 @@ static int gem_rx(struct gem *gp, int work_to_do)
        for (;;) {
                struct gem_rxd *rxd = &gp->init_block->rxd[entry];
                struct sk_buff *skb;
-               u64 status = cpu_to_le64(rxd->status_word);
+               u64 status = le64_to_cpu(rxd->status_word);
                dma_addr_t dma_addr;
                int len;
 
@@ -780,7 +786,7 @@ static int gem_rx(struct gem *gp, int work_to_do)
                        break;
 
                /* When writing back RX descriptor, GEM writes status
-                * then buffer address, possibly in seperate transactions.
+                * then buffer address, possibly in separate transactions.
                 * If we don't wait for the chip to write both, we could
                 * post a new buffer to this descriptor then have GEM spam
                 * on the buffer address.  We sync on the RX completion
@@ -799,23 +805,23 @@ static int gem_rx(struct gem *gp, int work_to_do)
 
                len = (status & RXDCTRL_BUFSZ) >> 16;
                if ((len < ETH_ZLEN) || (status & RXDCTRL_BAD)) {
-                       gp->net_stats.rx_errors++;
+                       dev->stats.rx_errors++;
                        if (len < ETH_ZLEN)
-                               gp->net_stats.rx_length_errors++;
+                               dev->stats.rx_length_errors++;
                        if (len & RXDCTRL_BAD)
-                               gp->net_stats.rx_crc_errors++;
+                               dev->stats.rx_crc_errors++;
 
                        /* We'll just return it to GEM. */
                drop_it:
-                       gp->net_stats.rx_dropped++;
+                       dev->stats.rx_dropped++;
                        goto next;
                }
 
-               dma_addr = cpu_to_le64(rxd->buffer);
+               dma_addr = le64_to_cpu(rxd->buffer);
                if (len > RX_COPY_THRESHOLD) {
                        struct sk_buff *new_skb;
 
-                       new_skb = gem_alloc_skb(RX_BUF_ALLOC_SIZE(gp), GFP_ATOMIC);
+                       new_skb = gem_alloc_skb(dev, RX_BUF_ALLOC_SIZE(gp), GFP_ATOMIC);
                        if (new_skb == NULL) {
                                drops++;
                                goto drop_it;
@@ -824,7 +830,6 @@ static int gem_rx(struct gem *gp, int work_to_do)
                                       RX_BUF_ALLOC_SIZE(gp),
                                       PCI_DMA_FROMDEVICE);
                        gp->rx_skbs[entry] = new_skb;
-                       new_skb->dev = gp->dev;
                        skb_put(new_skb, (gp->rx_buf_sz + RX_OFFSET));
                        rxd->buffer = cpu_to_le64(pci_map_page(gp->pdev,
                                                               virt_to_page(new_skb->data),
@@ -836,33 +841,32 @@ static int gem_rx(struct gem *gp, int work_to_do)
                        /* Trim the original skb for the netif. */
                        skb_trim(skb, len);
                } else {
-                       struct sk_buff *copy_skb = dev_alloc_skb(len + 2);
+                       struct sk_buff *copy_skb = netdev_alloc_skb(dev, len + 2);
 
                        if (copy_skb == NULL) {
                                drops++;
                                goto drop_it;
                        }
 
-                       copy_skb->dev = gp->dev;
                        skb_reserve(copy_skb, 2);
                        skb_put(copy_skb, len);
                        pci_dma_sync_single_for_cpu(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
-                       memcpy(copy_skb->data, skb->data, len);
+                       skb_copy_from_linear_data(skb, copy_skb->data, len);
                        pci_dma_sync_single_for_device(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
 
                        /* We'll reuse the original ring buffer. */
                        skb = copy_skb;
                }
 
-               skb->csum = ntohs((status & RXDCTRL_TCPCSUM) ^ 0xffff);
-               skb->ip_summed = CHECKSUM_HW;
+               csum = (__force __sum16)htons((status & RXDCTRL_TCPCSUM) ^ 0xffff);
+               skb->csum = csum_unfold(csum);
+               skb->ip_summed = CHECKSUM_COMPLETE;
                skb->protocol = eth_type_trans(skb, gp->dev);
 
-               netif_receive_skb(skb);
+               napi_gro_receive(&gp->napi, skb);
 
-               gp->net_stats.rx_packets++;
-               gp->net_stats.rx_bytes += len;
-               gp->dev->last_rx = jiffies;
+               dev->stats.rx_packets++;
+               dev->stats.rx_bytes += len;
 
        next:
                entry = NEXT_RX(entry);
@@ -873,95 +877,82 @@ static int gem_rx(struct gem *gp, int work_to_do)
        gp->rx_new = entry;
 
        if (drops)
-               printk(KERN_INFO "%s: Memory squeeze, deferring packet.\n",
-                      gp->dev->name);
+               netdev_info(gp->dev, "Memory squeeze, deferring packet\n");
 
        return work_done;
 }
 
-static int gem_poll(struct net_device *dev, int *budget)
+static int gem_poll(struct napi_struct *napi, int budget)
 {
-       struct gem *gp = dev->priv;
-       unsigned long flags;
-
-       /*
-        * NAPI locking nightmare: See comment at head of driver
-        */
-       spin_lock_irqsave(&gp->lock, flags);
+       struct gem *gp = container_of(napi, struct gem, napi);
+       struct net_device *dev = gp->dev;
+       int work_done;
 
+       work_done = 0;
        do {
-               int work_to_do, work_done;
-
                /* Handle anomalies */
-               if (gp->status & GREG_STAT_ABNORMAL) {
-                       if (gem_abnormal_irq(dev, gp, gp->status))
-                               break;
+               if (unlikely(gp->status & GREG_STAT_ABNORMAL)) {
+                       struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
+                       int reset;
+
+                       /* We run the abnormal interrupt handling code with
+                        * the Tx lock. It only resets the Rx portion of the
+                        * chip, but we need to guard it against DMA being
+                        * restarted by the link poll timer
+                        */
+                       __netif_tx_lock(txq, smp_processor_id());
+                       reset = gem_abnormal_irq(dev, gp, gp->status);
+                       __netif_tx_unlock(txq);
+                       if (reset) {
+                               gem_schedule_reset(gp);
+                               napi_complete(napi);
+                               return work_done;
+                       }
                }
 
                /* Run TX completion thread */
-               spin_lock(&gp->tx_lock);
                gem_tx(dev, gp, gp->status);
-               spin_unlock(&gp->tx_lock);
-
-               spin_unlock_irqrestore(&gp->lock, flags);
 
                /* Run RX thread. We don't use any locking here,
                 * code willing to do bad things - like cleaning the
-                * rx ring - must call netif_poll_disable(), which
+                * rx ring - must call napi_disable(), which
                 * schedule_timeout()'s if polling is already disabled.
                 */
-               work_to_do = min(*budget, dev->quota);
-
-               work_done = gem_rx(gp, work_to_do);
-
-               *budget -= work_done;
-               dev->quota -= work_done;
+               work_done += gem_rx(gp, budget - work_done);
 
-               if (work_done >= work_to_do)
-                       return 1;
-
-               spin_lock_irqsave(&gp->lock, flags);
+               if (work_done >= budget)
+                       return work_done;
 
                gp->status = readl(gp->regs + GREG_STAT);
        } while (gp->status & GREG_STAT_NAPI);
 
-       __netif_rx_complete(dev);
+       napi_complete(napi);
        gem_enable_ints(gp);
 
-       spin_unlock_irqrestore(&gp->lock, flags);
-       return 0;
+       return work_done;
 }
 
-static irqreturn_t gem_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t gem_interrupt(int irq, void *dev_id)
 {
        struct net_device *dev = dev_id;
-       struct gem *gp = dev->priv;
-       unsigned long flags;
-
-       /* Swallow interrupts when shutting the chip down, though
-        * that shouldn't happen, we should have done free_irq() at
-        * this point...
-        */
-       if (!gp->running)
-               return IRQ_HANDLED;
+       struct gem *gp = netdev_priv(dev);
 
-       spin_lock_irqsave(&gp->lock, flags);
-
-       if (netif_rx_schedule_prep(dev)) {
+       if (napi_schedule_prep(&gp->napi)) {
                u32 gem_status = readl(gp->regs + GREG_STAT);
 
-               if (gem_status == 0) {
-                       netif_poll_enable(dev);
-                       spin_unlock_irqrestore(&gp->lock, flags);
+               if (unlikely(gem_status == 0)) {
+                       napi_enable(&gp->napi);
                        return IRQ_NONE;
                }
+               if (netif_msg_intr(gp))
+                       printk(KERN_DEBUG "%s: gem_interrupt() gem_status: 0x%x\n",
+                              gp->dev->name, gem_status);
+
                gp->status = gem_status;
                gem_disable_ints(gp);
-               __netif_rx_schedule(dev);
+               __napi_schedule(&gp->napi);
        }
 
-       spin_unlock_irqrestore(&gp->lock, flags);
-
        /* If polling was disabled at the time we received that
         * interrupt, we may return IRQ_HANDLED here while we
         * should return IRQ_NONE. No big deal...
@@ -972,41 +963,30 @@ static irqreturn_t gem_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void gem_poll_controller(struct net_device *dev)
 {
-       /* gem_interrupt is safe to reentrance so no need
-        * to disable_irq here.
-        */
-       gem_interrupt(dev->irq, dev, NULL);
+       struct gem *gp = netdev_priv(dev);
+
+       disable_irq(gp->pdev->irq);
+       gem_interrupt(gp->pdev->irq, dev);
+       enable_irq(gp->pdev->irq);
 }
 #endif
 
 static void gem_tx_timeout(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
-
-       printk(KERN_ERR "%s: transmit timed out, resetting\n", dev->name);
-       if (!gp->running) {
-               printk("%s: hrm.. hw not running !\n", dev->name);
-               return;
-       }
-       printk(KERN_ERR "%s: TX_STATE[%08x:%08x:%08x]\n",
-              dev->name,
-              readl(gp->regs + TXDMA_CFG),
-              readl(gp->regs + MAC_TXSTAT),
-              readl(gp->regs + MAC_TXCFG));
-       printk(KERN_ERR "%s: RX_STATE[%08x:%08x:%08x]\n",
-              dev->name,
-              readl(gp->regs + RXDMA_CFG),
-              readl(gp->regs + MAC_RXSTAT),
-              readl(gp->regs + MAC_RXCFG));
+       struct gem *gp = netdev_priv(dev);
 
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
+       netdev_err(dev, "transmit timed out, resetting\n");
 
-       gp->reset_task_pending = 1;
-       schedule_work(&gp->reset_task);
+       netdev_err(dev, "TX_STATE[%08x:%08x:%08x]\n",
+                  readl(gp->regs + TXDMA_CFG),
+                  readl(gp->regs + MAC_TXSTAT),
+                  readl(gp->regs + MAC_TXCFG));
+       netdev_err(dev, "RX_STATE[%08x:%08x:%08x]\n",
+                  readl(gp->regs + RXDMA_CFG),
+                  readl(gp->regs + MAC_RXSTAT),
+                  readl(gp->regs + MAC_RXCFG));
 
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
+       gem_schedule_reset(gp);
 }
 
 static __inline__ int gem_intme(int entry)
@@ -1018,43 +998,29 @@ static __inline__ int gem_intme(int entry)
        return 0;
 }
 
-static int gem_start_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t gem_start_xmit(struct sk_buff *skb,
+                                 struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        int entry;
        u64 ctrl;
-       unsigned long flags;
 
        ctrl = 0;
-       if (skb->ip_summed == CHECKSUM_HW) {
-               u64 csum_start_off, csum_stuff_off;
-
-               csum_start_off = (u64) (skb->h.raw - skb->data);
-               csum_stuff_off = (u64) ((skb->h.raw + skb->csum) - skb->data);
+       if (skb->ip_summed == CHECKSUM_PARTIAL) {
+               const u64 csum_start_off = skb_checksum_start_offset(skb);
+               const u64 csum_stuff_off = csum_start_off + skb->csum_offset;
 
                ctrl = (TXDCTRL_CENAB |
                        (csum_start_off << 15) |
                        (csum_stuff_off << 21));
        }
 
-       local_irq_save(flags);
-       if (!spin_trylock(&gp->tx_lock)) {
-               /* Tell upper layer to requeue */
-               local_irq_restore(flags);
-               return NETDEV_TX_LOCKED;
-       }
-       /* We raced with gem_do_stop() */
-       if (!gp->running) {
-               spin_unlock_irqrestore(&gp->tx_lock, flags);
-               return NETDEV_TX_BUSY;
-       }
-
-       /* This is a hard error, log it. */
-       if (TX_BUFFS_AVAIL(gp) <= (skb_shinfo(skb)->nr_frags + 1)) {
-               netif_stop_queue(dev);
-               spin_unlock_irqrestore(&gp->tx_lock, flags);
-               printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
-                      dev->name);
+       if (unlikely(TX_BUFFS_AVAIL(gp) <= (skb_shinfo(skb)->nr_frags + 1))) {
+               /* This is a hard error, log it. */
+               if (!netif_queue_stopped(dev)) {
+                       netif_stop_queue(dev);
+                       netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
+               }
                return NETDEV_TX_BUSY;
        }
 
@@ -1131,24 +1097,92 @@ static int gem_start_xmit(struct sk_buff *skb, struct net_device *dev)
        }
 
        gp->tx_new = entry;
-       if (TX_BUFFS_AVAIL(gp) <= (MAX_SKB_FRAGS + 1))
+       if (unlikely(TX_BUFFS_AVAIL(gp) <= (MAX_SKB_FRAGS + 1))) {
                netif_stop_queue(dev);
 
+               /* netif_stop_queue() must be done before checking
+                * checking tx index in TX_BUFFS_AVAIL() below, because
+                * in gem_tx(), we update tx_old before checking for
+                * netif_queue_stopped().
+                */
+               smp_mb();
+               if (TX_BUFFS_AVAIL(gp) > (MAX_SKB_FRAGS + 1))
+                       netif_wake_queue(dev);
+       }
        if (netif_msg_tx_queued(gp))
                printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
                       dev->name, entry, skb->len);
        mb();
        writel(gp->tx_new, gp->regs + TXDMA_KICK);
-       spin_unlock_irqrestore(&gp->tx_lock, flags);
-
-       dev->trans_start = jiffies;
 
        return NETDEV_TX_OK;
 }
 
+static void gem_pcs_reset(struct gem *gp)
+{
+       int limit;
+       u32 val;
+
+       /* Reset PCS unit. */
+       val = readl(gp->regs + PCS_MIICTRL);
+       val |= PCS_MIICTRL_RST;
+       writel(val, gp->regs + PCS_MIICTRL);
+
+       limit = 32;
+       while (readl(gp->regs + PCS_MIICTRL) & PCS_MIICTRL_RST) {
+               udelay(100);
+               if (limit-- <= 0)
+                       break;
+       }
+       if (limit < 0)
+               netdev_warn(gp->dev, "PCS reset bit would not clear\n");
+}
+
+static void gem_pcs_reinit_adv(struct gem *gp)
+{
+       u32 val;
+
+       /* Make sure PCS is disabled while changing advertisement
+        * configuration.
+        */
+       val = readl(gp->regs + PCS_CFG);
+       val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
+       writel(val, gp->regs + PCS_CFG);
+
+       /* Advertise all capabilities except asymmetric
+        * pause.
+        */
+       val = readl(gp->regs + PCS_MIIADV);
+       val |= (PCS_MIIADV_FD | PCS_MIIADV_HD |
+               PCS_MIIADV_SP | PCS_MIIADV_AP);
+       writel(val, gp->regs + PCS_MIIADV);
+
+       /* Enable and restart auto-negotiation, disable wrapback/loopback,
+        * and re-enable PCS.
+        */
+       val = readl(gp->regs + PCS_MIICTRL);
+       val |= (PCS_MIICTRL_RAN | PCS_MIICTRL_ANE);
+       val &= ~PCS_MIICTRL_WB;
+       writel(val, gp->regs + PCS_MIICTRL);
+
+       val = readl(gp->regs + PCS_CFG);
+       val |= PCS_CFG_ENABLE;
+       writel(val, gp->regs + PCS_CFG);
+
+       /* Make sure serialink loopback is off.  The meaning
+        * of this bit is logically inverted based upon whether
+        * you are in Serialink or SERDES mode.
+        */
+       val = readl(gp->regs + PCS_SCTRL);
+       if (gp->phy_type == phy_serialink)
+               val &= ~PCS_SCTRL_LOOP;
+       else
+               val |= PCS_SCTRL_LOOP;
+       writel(val, gp->regs + PCS_SCTRL);
+}
+
 #define STOP_TRIES 32
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_reset(struct gem *gp)
 {
        int limit;
@@ -1170,11 +1204,13 @@ static void gem_reset(struct gem *gp)
                        break;
        } while (val & (GREG_SWRST_TXRST | GREG_SWRST_RXRST));
 
-       if (limit <= 0)
-               printk(KERN_ERR "%s: SW reset is ghetto.\n", gp->dev->name);
+       if (limit < 0)
+               netdev_err(gp->dev, "SW reset is ghetto\n");
+
+       if (gp->phy_type == phy_serialink || gp->phy_type == phy_serdes)
+               gem_pcs_reinit_adv(gp);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_start_dma(struct gem *gp)
 {
        u32 val;
@@ -1197,8 +1233,7 @@ static void gem_start_dma(struct gem *gp)
        writel(RX_RING_SIZE - 4, gp->regs + RXDMA_KICK);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. DMA won't be
- * actually stopped before about 4ms tho ...
+/* DMA won't be actually stopped before about 4ms tho ...
  */
 static void gem_stop_dma(struct gem *gp)
 {
@@ -1220,7 +1255,6 @@ static void gem_stop_dma(struct gem *gp)
 }
 
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 // XXX dbl check what that function should do when called on PCS PHY
 static void gem_begin_auto_negotiation(struct gem *gp, struct ethtool_cmd *ep)
 {
@@ -1255,7 +1289,7 @@ static void gem_begin_auto_negotiation(struct gem *gp, struct ethtool_cmd *ep)
                autoneg = 1;
        } else {
                autoneg = 0;
-               speed = ep->speed;
+               speed = ethtool_cmd_speed(ep);
                duplex = ep->duplex;
        }
 
@@ -1280,7 +1314,7 @@ start_aneg:
        /* If we are asleep, we don't try to actually setup the PHY, we
         * just store the settings
         */
-       if (gp->asleep) {
+       if (!netif_device_present(gp->dev)) {
                gp->phy_mii.autoneg = gp->want_autoneg = autoneg;
                gp->phy_mii.speed = speed;
                gp->phy_mii.duplex = duplex;
@@ -1306,13 +1340,12 @@ non_mii:
 
 /* A link-up condition has occurred, initialize and enable the
  * rest of the chip.
- *
- * Must be invoked under gp->lock and gp->tx_lock.
  */
 static int gem_set_link_modes(struct gem *gp)
 {
-       u32 val;
+       struct netdev_queue *txq = netdev_get_tx_queue(gp->dev, 0);
        int full_duplex, speed, pause;
+       u32 val;
 
        full_duplex = 0;
        speed = SPEED_10;
@@ -1328,17 +1361,19 @@ static int gem_set_link_modes(struct gem *gp)
                   gp->phy_type == phy_serdes) {
                u32 pcs_lpa = readl(gp->regs + PCS_MIILP);
 
-               if (pcs_lpa & PCS_MIIADV_FD)
+               if ((pcs_lpa & PCS_MIIADV_FD) || gp->phy_type == phy_serdes)
                        full_duplex = 1;
                speed = SPEED_1000;
        }
 
-       if (netif_msg_link(gp))
-               printk(KERN_INFO "%s: Link is up at %d Mbps, %s-duplex.\n",
-                       gp->dev->name, speed, (full_duplex ? "full" : "half"));
+       netif_info(gp, link, gp->dev, "Link is up at %d Mbps, %s-duplex\n",
+                  speed, (full_duplex ? "full" : "half"));
 
-       if (!gp->running)
-               return 0;
+
+       /* We take the tx queue lock to avoid collisions between
+        * this code, the tx path and the NAPI-driven error path
+        */
+       __netif_tx_lock(txq, smp_processor_id());
 
        val = (MAC_TXCFG_EIPG0 | MAC_TXCFG_NGU);
        if (full_duplex) {
@@ -1387,20 +1422,6 @@ static int gem_set_link_modes(struct gem *gp)
                        pause = 1;
        }
 
-       if (netif_msg_link(gp)) {
-               if (pause) {
-                       printk(KERN_INFO "%s: Pause is enabled "
-                              "(rxfifo: %d off: %d on: %d)\n",
-                              gp->dev->name,
-                              gp->rx_fifo_sz,
-                              gp->rx_pause_off,
-                              gp->rx_pause_on);
-               } else {
-                       printk(KERN_INFO "%s: Pause is disabled\n",
-                              gp->dev->name);
-               }
-       }
-
        if (!full_duplex)
                writel(512, gp->regs + MAC_STIME);
        else
@@ -1414,17 +1435,29 @@ static int gem_set_link_modes(struct gem *gp)
 
        gem_start_dma(gp);
 
+       __netif_tx_unlock(txq);
+
+       if (netif_msg_link(gp)) {
+               if (pause) {
+                       netdev_info(gp->dev,
+                                   "Pause is enabled (rxfifo: %d off: %d on: %d)\n",
+                                   gp->rx_fifo_sz,
+                                   gp->rx_pause_off,
+                                   gp->rx_pause_on);
+               } else {
+                       netdev_info(gp->dev, "Pause is disabled\n");
+               }
+       }
+
        return 0;
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static int gem_mdio_link_not_up(struct gem *gp)
 {
        switch (gp->lstate) {
        case link_force_ret:
-               if (netif_msg_link(gp))
-                       printk(KERN_INFO "%s: Autoneg failed again, keeping"
-                               " forced mode\n", gp->dev->name);
+               netif_info(gp, link, gp->dev,
+                          "Autoneg failed again, keeping forced mode\n");
                gp->phy_mii.def->ops->setup_forced(&gp->phy_mii,
                        gp->last_forced_speed, DUPLEX_HALF);
                gp->timer_ticks = 5;
@@ -1437,9 +1470,7 @@ static int gem_mdio_link_not_up(struct gem *gp)
                 */
                if (gp->phy_mii.def->magic_aneg)
                        return 1;
-               if (netif_msg_link(gp))
-                       printk(KERN_INFO "%s: switching to forced 100bt\n",
-                               gp->dev->name);
+               netif_info(gp, link, gp->dev, "switching to forced 100bt\n");
                /* Try forced modes. */
                gp->phy_mii.def->ops->setup_forced(&gp->phy_mii, SPEED_100,
                        DUPLEX_HALF);
@@ -1455,9 +1486,8 @@ static int gem_mdio_link_not_up(struct gem *gp)
                        gp->phy_mii.def->ops->setup_forced(&gp->phy_mii, SPEED_10,
                                DUPLEX_HALF);
                        gp->timer_ticks = 5;
-                       if (netif_msg_link(gp))
-                               printk(KERN_INFO "%s: switching to forced 10bt\n",
-                                       gp->dev->name);
+                       netif_info(gp, link, gp->dev,
+                                  "switching to forced 10bt\n");
                        return 0;
                } else
                        return 1;
@@ -1469,20 +1499,12 @@ static int gem_mdio_link_not_up(struct gem *gp)
 static void gem_link_timer(unsigned long data)
 {
        struct gem *gp = (struct gem *) data;
+       struct net_device *dev = gp->dev;
        int restart_aneg = 0;
 
-       if (gp->asleep)
-               return;
-
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
-       gem_get_cell(gp);
-
-       /* If the reset task is still pending, we just
-        * reschedule the link timer
-        */
+       /* There's no point doing anything if we're going to be reset */
        if (gp->reset_task_pending)
-               goto restart;
+               return;
 
        if (gp->phy_type == phy_serialink ||
            gp->phy_type == phy_serdes) {
@@ -1492,8 +1514,11 @@ static void gem_link_timer(unsigned long data)
                        val = readl(gp->regs + PCS_MIISTAT);
 
                if ((val & PCS_MIISTAT_LS) != 0) {
+                       if (gp->lstate == link_up)
+                               goto restart;
+
                        gp->lstate = link_up;
-                       netif_carrier_on(gp->dev);
+                       netif_carrier_on(dev);
                        (void)gem_set_link_modes(gp);
                }
                goto restart;
@@ -1509,12 +1534,12 @@ static void gem_link_timer(unsigned long data)
                        gp->last_forced_speed = gp->phy_mii.speed;
                        gp->timer_ticks = 5;
                        if (netif_msg_link(gp))
-                               printk(KERN_INFO "%s: Got link after fallback, retrying"
-                                       " autoneg once...\n", gp->dev->name);
+                               netdev_info(dev,
+                                           "Got link after fallback, retrying autoneg once...\n");
                        gp->phy_mii.def->ops->setup_aneg(&gp->phy_mii, gp->phy_mii.advertising);
                } else if (gp->lstate != link_up) {
                        gp->lstate = link_up;
-                       netif_carrier_on(gp->dev);
+                       netif_carrier_on(dev);
                        if (gem_set_link_modes(gp))
                                restart_aneg = 1;
                }
@@ -1524,13 +1549,11 @@ static void gem_link_timer(unsigned long data)
                 */
                if (gp->lstate == link_up) {
                        gp->lstate = link_down;
-                       if (netif_msg_link(gp))
-                               printk(KERN_INFO "%s: Link down\n",
-                                       gp->dev->name);
-                       netif_carrier_off(gp->dev);
-                       gp->reset_task_pending = 1;
-                       schedule_work(&gp->reset_task);
-                       restart_aneg = 1;
+                       netif_info(gp, link, dev, "Link down\n");
+                       netif_carrier_off(dev);
+                       gem_schedule_reset(gp);
+                       /* The reset task will restart the timer */
+                       return;
                } else if (++gp->timer_ticks > 10) {
                        if (found_mii_phy(gp))
                                restart_aneg = gem_mdio_link_not_up(gp);
@@ -1540,17 +1563,12 @@ static void gem_link_timer(unsigned long data)
        }
        if (restart_aneg) {
                gem_begin_auto_negotiation(gp, NULL);
-               goto out_unlock;
+               return;
        }
 restart:
        mod_timer(&gp->link_timer, jiffies + ((12 * HZ) / 10));
-out_unlock:
-       gem_put_cell(gp);
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_clean_rings(struct gem *gp)
 {
        struct gem_init_block *gb = gp->init_block;
@@ -1601,7 +1619,6 @@ static void gem_clean_rings(struct gem *gp)
        }
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_init_rings(struct gem *gp)
 {
        struct gem_init_block *gb = gp->init_block;
@@ -1620,7 +1637,7 @@ static void gem_init_rings(struct gem *gp)
                struct sk_buff *skb;
                struct gem_rxd *rxd = &gb->rxd[i];
 
-               skb = gem_alloc_skb(RX_BUF_ALLOC_SIZE(gp), GFP_ATOMIC);
+               skb = gem_alloc_skb(dev, RX_BUF_ALLOC_SIZE(gp), GFP_KERNEL);
                if (!skb) {
                        rxd->buffer = 0;
                        rxd->status_word = 0;
@@ -1628,7 +1645,6 @@ static void gem_init_rings(struct gem *gp)
                }
 
                gp->rx_skbs[i] = skb;
-               skb->dev = dev;
                skb_put(skb, (gp->rx_buf_sz + RX_OFFSET));
                dma_addr = pci_map_page(gp->pdev,
                                        virt_to_page(skb->data),
@@ -1681,8 +1697,7 @@ static void gem_init_phy(struct gem *gp)
                        if (phy_read(gp, MII_BMCR) != 0xffff)
                                break;
                        if (i == 2)
-                               printk(KERN_WARNING "%s: GMAC PHY not responding !\n",
-                                      gp->dev->name);
+                               netdev_warn(gp->dev, "GMAC PHY not responding !\n");
                }
        }
 
@@ -1705,68 +1720,15 @@ static void gem_init_phy(struct gem *gp)
 
        if (gp->phy_type == phy_mii_mdio0 ||
            gp->phy_type == phy_mii_mdio1) {
-               // XXX check for errors
+               /* Reset and detect MII PHY */
                mii_phy_probe(&gp->phy_mii, gp->mii_phy_addr);
 
                /* Init PHY */
                if (gp->phy_mii.def && gp->phy_mii.def->ops->init)
                        gp->phy_mii.def->ops->init(&gp->phy_mii);
        } else {
-               u32 val;
-               int limit;
-
-               /* Reset PCS unit. */
-               val = readl(gp->regs + PCS_MIICTRL);
-               val |= PCS_MIICTRL_RST;
-               writeb(val, gp->regs + PCS_MIICTRL);
-
-               limit = 32;
-               while (readl(gp->regs + PCS_MIICTRL) & PCS_MIICTRL_RST) {
-                       udelay(100);
-                       if (limit-- <= 0)
-                               break;
-               }
-               if (limit <= 0)
-                       printk(KERN_WARNING "%s: PCS reset bit would not clear.\n",
-                              gp->dev->name);
-
-               /* Make sure PCS is disabled while changing advertisement
-                * configuration.
-                */
-               val = readl(gp->regs + PCS_CFG);
-               val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
-               writel(val, gp->regs + PCS_CFG);
-
-               /* Advertise all capabilities except assymetric
-                * pause.
-                */
-               val = readl(gp->regs + PCS_MIIADV);
-               val |= (PCS_MIIADV_FD | PCS_MIIADV_HD |
-                       PCS_MIIADV_SP | PCS_MIIADV_AP);
-               writel(val, gp->regs + PCS_MIIADV);
-
-               /* Enable and restart auto-negotiation, disable wrapback/loopback,
-                * and re-enable PCS.
-                */
-               val = readl(gp->regs + PCS_MIICTRL);
-               val |= (PCS_MIICTRL_RAN | PCS_MIICTRL_ANE);
-               val &= ~PCS_MIICTRL_WB;
-               writel(val, gp->regs + PCS_MIICTRL);
-
-               val = readl(gp->regs + PCS_CFG);
-               val |= PCS_CFG_ENABLE;
-               writel(val, gp->regs + PCS_CFG);
-
-               /* Make sure serialink loopback is off.  The meaning
-                * of this bit is logically inverted based upon whether
-                * you are in Serialink or SERDES mode.
-                */
-               val = readl(gp->regs + PCS_SCTRL);
-               if (gp->phy_type == phy_serialink)
-                       val &= ~PCS_SCTRL_LOOP;
-               else
-                       val |= PCS_SCTRL_LOOP;
-               writel(val, gp->regs + PCS_SCTRL);
+               gem_pcs_reset(gp);
+               gem_pcs_reinit_adv(gp);
        }
 
        /* Default aneg parameters */
@@ -1774,13 +1736,15 @@ static void gem_init_phy(struct gem *gp)
        gp->lstate = link_down;
        netif_carrier_off(gp->dev);
 
-       /* Can I advertise gigabit here ? I'd need BCM PHY docs... */
-       spin_lock_irq(&gp->lock);
+       /* Print things out */
+       if (gp->phy_type == phy_mii_mdio0 ||
+           gp->phy_type == phy_mii_mdio1)
+               netdev_info(gp->dev, "Found %s PHY\n",
+                           gp->phy_mii.def ? gp->phy_mii.def->name : "no");
+
        gem_begin_auto_negotiation(gp, NULL);
-       spin_unlock_irq(&gp->lock);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_init_dma(struct gem *gp)
 {
        u64 desc_dma = (u64) gp->gblock_dvma;
@@ -1818,14 +1782,13 @@ static void gem_init_dma(struct gem *gp)
                       gp->regs + RXDMA_BLANK);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static u32 gem_setup_multicast(struct gem *gp)
 {
        u32 rxcfg = 0;
        int i;
 
        if ((gp->dev->flags & IFF_ALLMULTI) ||
-           (gp->dev->mc_count > 256)) {
+           (netdev_mc_count(gp->dev) > 256)) {
                for (i=0; i<16; i++)
                        writel(0xffff, gp->regs + MAC_HASH0 + (i << 2));
                rxcfg |= MAC_RXCFG_HFE;
@@ -1834,21 +1797,12 @@ static u32 gem_setup_multicast(struct gem *gp)
        } else {
                u16 hash_table[16];
                u32 crc;
-               struct dev_mc_list *dmi = gp->dev->mc_list;
+               struct netdev_hw_addr *ha;
                int i;
 
-               for (i = 0; i < 16; i++)
-                       hash_table[i] = 0;
-
-               for (i = 0; i < gp->dev->mc_count; i++) {
-                       char *addrs = dmi->dmi_addr;
-
-                       dmi = dmi->next;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+               memset(hash_table, 0, sizeof(hash_table));
+               netdev_for_each_mc_addr(ha, gp->dev) {
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 24;
                        hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf));
                }
@@ -1860,7 +1814,6 @@ static u32 gem_setup_multicast(struct gem *gp)
        return rxcfg;
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_init_mac(struct gem *gp)
 {
        unsigned char *e = &gp->dev->dev_addr[0];
@@ -1943,7 +1896,6 @@ static void gem_init_mac(struct gem *gp)
                writel(0, gp->regs + WOL_WAKECSR);
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_init_pause_thresholds(struct gem *gp)
 {
                u32 cfg;
@@ -2030,7 +1982,7 @@ static int gem_check_invariants(struct gem *gp)
                 * as this chip has no gigabit PHY.
                 */
                if ((mif_cfg & (MIF_CFG_MDI0 | MIF_CFG_MDI1)) == 0) {
-                       printk(KERN_ERR PFX "RIO GEM lacks MII phy, mif_cfg[%08x]\n",
+                       pr_err("RIO GEM lacks MII phy, mif_cfg[%08x]\n",
                               mif_cfg);
                        return -1;
                }
@@ -2049,7 +2001,15 @@ static int gem_check_invariants(struct gem *gp)
                mif_cfg &= ~MIF_CFG_PSELECT;
                writel(mif_cfg, gp->regs + MIF_CFG);
        } else {
-               gp->phy_type = phy_serialink;
+#ifdef CONFIG_SPARC
+               const char *p;
+
+               p = of_get_property(gp->of_node, "shared-pins", NULL);
+               if (p && !strcmp(p, "serdes"))
+                       gp->phy_type = phy_serdes;
+               else
+#endif
+                       gp->phy_type = phy_serialink;
        }
        if (gp->phy_type == phy_mii_mdio1 ||
            gp->phy_type == phy_mii_mdio0) {
@@ -2062,7 +2022,7 @@ static int gem_check_invariants(struct gem *gp)
                }
                if (i == 32) {
                        if (pdev->device != PCI_DEVICE_ID_SUN_GEM) {
-                               printk(KERN_ERR PFX "RIO MII phy will not respond.\n");
+                               pr_err("RIO MII phy will not respond\n");
                                return -1;
                        }
                        gp->phy_type = phy_serdes;
@@ -2077,7 +2037,7 @@ static int gem_check_invariants(struct gem *gp)
                if (pdev->device == PCI_DEVICE_ID_SUN_GEM) {
                        if (gp->tx_fifo_sz != (9 * 1024) ||
                            gp->rx_fifo_sz != (20 * 1024)) {
-                               printk(KERN_ERR PFX "GEM has bogus fifo sizes tx(%d) rx(%d)\n",
+                               pr_err("GEM has bogus fifo sizes tx(%d) rx(%d)\n",
                                       gp->tx_fifo_sz, gp->rx_fifo_sz);
                                return -1;
                        }
@@ -2085,7 +2045,7 @@ static int gem_check_invariants(struct gem *gp)
                } else {
                        if (gp->tx_fifo_sz != (2 * 1024) ||
                            gp->rx_fifo_sz != (2 * 1024)) {
-                               printk(KERN_ERR PFX "RIO GEM has bogus fifo sizes tx(%d) rx(%d)\n",
+                               pr_err("RIO GEM has bogus fifo sizes tx(%d) rx(%d)\n",
                                       gp->tx_fifo_sz, gp->rx_fifo_sz);
                                return -1;
                        }
@@ -2096,7 +2056,6 @@ static int gem_check_invariants(struct gem *gp)
        return 0;
 }
 
-/* Must be invoked under gp->lock and gp->tx_lock. */
 static void gem_reinit_chip(struct gem *gp)
 {
        /* Reset the chip */
@@ -2117,11 +2076,9 @@ static void gem_reinit_chip(struct gem *gp)
 }
 
 
-/* Must be invoked with no lock held. */
 static void gem_stop_phy(struct gem *gp, int wol)
 {
        u32 mifcfg;
-       unsigned long flags;
 
        /* Let the chip settle down a bit, it seems that helps
         * for sleep mode on some models
@@ -2167,15 +2124,9 @@ static void gem_stop_phy(struct gem *gp, int wol)
        writel(0, gp->regs + RXDMA_CFG);
 
        if (!wol) {
-               spin_lock_irqsave(&gp->lock, flags);
-               spin_lock(&gp->tx_lock);
                gem_reset(gp);
                writel(MAC_TXRST_CMD, gp->regs + MAC_TXRST);
                writel(MAC_RXRST_CMD, gp->regs + MAC_RXRST);
-               spin_unlock(&gp->tx_lock);
-               spin_unlock_irqrestore(&gp->lock, flags);
-
-               /* No need to take the lock here */
 
                if (found_mii_phy(gp) && gp->phy_mii.def->ops->suspend)
                        gp->phy_mii.def->ops->suspend(&gp->phy_mii);
@@ -2192,73 +2143,86 @@ static void gem_stop_phy(struct gem *gp, int wol)
        }
 }
 
-
 static int gem_do_start(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
-       unsigned long flags;
-
-       spin_lock_irqsave(&gp->lock, flags);
-       spin_lock(&gp->tx_lock);
+       struct gem *gp = netdev_priv(dev);
+       int rc;
 
        /* Enable the cell */
        gem_get_cell(gp);
 
-       /* Init & setup chip hardware */
-       gem_reinit_chip(gp);
-
-       gp->running = 1;
+       /* Make sure PCI access and bus master are enabled */
+       rc = pci_enable_device(gp->pdev);
+       if (rc) {
+               netdev_err(dev, "Failed to enable chip on PCI bus !\n");
 
-       if (gp->lstate == link_up) {
-               netif_carrier_on(gp->dev);
-               gem_set_link_modes(gp);
+               /* Put cell and forget it for now, it will be considered as
+                * still asleep, a new sleep cycle may bring it back
+                */
+               gem_put_cell(gp);
+               return -ENXIO;
        }
+       pci_set_master(gp->pdev);
 
-       netif_wake_queue(gp->dev);
-
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irqrestore(&gp->lock, flags);
-
-       if (request_irq(gp->pdev->irq, gem_interrupt,
-                                  IRQF_SHARED, dev->name, (void *)dev)) {
-               printk(KERN_ERR "%s: failed to request irq !\n", gp->dev->name);
+       /* Init & setup chip hardware */
+       gem_reinit_chip(gp);
 
-               spin_lock_irqsave(&gp->lock, flags);
-               spin_lock(&gp->tx_lock);
+       /* An interrupt might come in handy */
+       rc = request_irq(gp->pdev->irq, gem_interrupt,
+                        IRQF_SHARED, dev->name, (void *)dev);
+       if (rc) {
+               netdev_err(dev, "failed to request irq !\n");
 
-               gp->running =  0;
                gem_reset(gp);
                gem_clean_rings(gp);
                gem_put_cell(gp);
+               return rc;
+       }
 
-               spin_unlock(&gp->tx_lock);
-               spin_unlock_irqrestore(&gp->lock, flags);
+       /* Mark us as attached again if we come from resume(), this has
+        * no effect if we weren't detatched and needs to be done now.
+        */
+       netif_device_attach(dev);
 
-               return -EAGAIN;
-       }
+       /* Restart NAPI & queues */
+       gem_netif_start(gp);
+
+       /* Detect & init PHY, start autoneg etc... this will
+        * eventually result in starting DMA operations when
+        * the link is up
+        */
+       gem_init_phy(gp);
 
        return 0;
 }
 
 static void gem_do_stop(struct net_device *dev, int wol)
 {
-       struct gem *gp = dev->priv;
-       unsigned long flags;
+       struct gem *gp = netdev_priv(dev);
 
-       spin_lock_irqsave(&gp->lock, flags);
-       spin_lock(&gp->tx_lock);
+       /* Stop NAPI and stop tx queue */
+       gem_netif_stop(gp);
 
-       gp->running = 0;
-
-       /* Stop netif queue */
-       netif_stop_queue(dev);
-
-       /* Make sure ints are disabled */
+       /* Make sure ints are disabled. We don't care about
+        * synchronizing as NAPI is disabled, thus a stray
+        * interrupt will do nothing bad (our irq handler
+        * just schedules NAPI)
+        */
        gem_disable_ints(gp);
 
-       /* We can drop the lock now */
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irqrestore(&gp->lock, flags);
+       /* Stop the link timer */
+       del_timer_sync(&gp->link_timer);
+
+       /* We cannot cancel the reset task while holding the
+        * rtnl lock, we'd get an A->B / B->A deadlock stituation
+        * if we did. This is not an issue however as the reset
+        * task is synchronized vs. us (rtnl_lock) and will do
+        * nothing if the device is down or suspended. We do
+        * still clear reset_task_pending to avoid a spurrious
+        * reset later on in case we do resume before it gets
+        * scheduled.
+        */
+       gp->reset_task_pending = 0;
 
        /* If we are going to sleep with WOL */
        gem_stop_dma(gp);
@@ -2273,82 +2237,79 @@ static void gem_do_stop(struct net_device *dev, int wol)
        /* No irq needed anymore */
        free_irq(gp->pdev->irq, (void *) dev);
 
+       /* Shut the PHY down eventually and setup WOL */
+       gem_stop_phy(gp, wol);
+
+       /* Make sure bus master is disabled */
+       pci_disable_device(gp->pdev);
+
        /* Cell not needed neither if no WOL */
-       if (!wol) {
-               spin_lock_irqsave(&gp->lock, flags);
+       if (!wol)
                gem_put_cell(gp);
-               spin_unlock_irqrestore(&gp->lock, flags);
-       }
 }
 
-static void gem_reset_task(void *data)
+static void gem_reset_task(struct work_struct *work)
 {
-       struct gem *gp = (struct gem *) data;
+       struct gem *gp = container_of(work, struct gem, reset_task);
+
+       /* Lock out the network stack (essentially shield ourselves
+        * against a racing open, close, control call, or suspend
+        */
+       rtnl_lock();
 
-       mutex_lock(&gp->pm_mutex);
+       /* Skip the reset task if suspended or closed, or if it's
+        * been cancelled by gem_do_stop (see comment there)
+        */
+       if (!netif_device_present(gp->dev) ||
+           !netif_running(gp->dev) ||
+           !gp->reset_task_pending) {
+               rtnl_unlock();
+               return;
+       }
 
-       netif_poll_disable(gp->dev);
+       /* Stop the link timer */
+       del_timer_sync(&gp->link_timer);
 
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
+       /* Stop NAPI and tx */
+       gem_netif_stop(gp);
 
-       if (gp->running == 0)
-               goto not_running;
+       /* Reset the chip & rings */
+       gem_reinit_chip(gp);
+       if (gp->lstate == link_up)
+               gem_set_link_modes(gp);
 
-       if (gp->running) {
-               netif_stop_queue(gp->dev);
+       /* Restart NAPI and Tx */
+       gem_netif_start(gp);
 
-               /* Reset the chip & rings */
-               gem_reinit_chip(gp);
-               if (gp->lstate == link_up)
-                       gem_set_link_modes(gp);
-               netif_wake_queue(gp->dev);
-       }
- not_running:
+       /* We are back ! */
        gp->reset_task_pending = 0;
 
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
-
-       netif_poll_enable(gp->dev);
+       /* If the link is not up, restart autoneg, else restart the
+        * polling timer
+        */
+       if (gp->lstate != link_up)
+               gem_begin_auto_negotiation(gp, NULL);
+       else
+               mod_timer(&gp->link_timer, jiffies + ((12 * HZ) / 10));
 
-       mutex_unlock(&gp->pm_mutex);
+       rtnl_unlock();
 }
 
-
 static int gem_open(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
-       int rc = 0;
-
-       mutex_lock(&gp->pm_mutex);
-
-       /* We need the cell enabled */
-       if (!gp->asleep)
-               rc = gem_do_start(dev);
-       gp->opened = (rc == 0);
-
-       mutex_unlock(&gp->pm_mutex);
-
-       return rc;
+       /* We allow open while suspended, we just do nothing,
+        * the chip will be initialized in resume()
+        */
+       if (netif_device_present(dev))
+               return gem_do_start(dev);
+       return 0;
 }
 
 static int gem_close(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
-
-       /* Note: we don't need to call netif_poll_disable() here because
-        * our caller (dev_close) already did it for us
-        */
-
-       mutex_lock(&gp->pm_mutex);
-
-       gp->opened = 0;
-       if (!gp->asleep)
+       if (netif_device_present(dev))
                gem_do_stop(dev, 0);
 
-       mutex_unlock(&gp->pm_mutex);
-
        return 0;
 }
 
@@ -2356,63 +2317,36 @@ static int gem_close(struct net_device *dev)
 static int gem_suspend(struct pci_dev *pdev, pm_message_t state)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
-       struct gem *gp = dev->priv;
-       unsigned long flags;
-
-       mutex_lock(&gp->pm_mutex);
-
-       netif_poll_disable(dev);
+       struct gem *gp = netdev_priv(dev);
 
-       printk(KERN_INFO "%s: suspending, WakeOnLan %s\n",
-              dev->name,
-              (gp->wake_on_lan && gp->opened) ? "enabled" : "disabled");
-
-       /* Keep the cell enabled during the entire operation */
-       spin_lock_irqsave(&gp->lock, flags);
-       spin_lock(&gp->tx_lock);
-       gem_get_cell(gp);
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irqrestore(&gp->lock, flags);
+       /* Lock the network stack first to avoid racing with open/close,
+        * reset task and setting calls
+        */
+       rtnl_lock();
 
-       /* If the driver is opened, we stop the MAC */
-       if (gp->opened) {
-               /* Stop traffic, mark us closed */
+       /* Not running, mark ourselves non-present, no need for
+        * a lock here
+        */
+       if (!netif_running(dev)) {
                netif_device_detach(dev);
+               rtnl_unlock();
+               return 0;
+       }
+       netdev_info(dev, "suspending, WakeOnLan %s\n",
+                   (gp->wake_on_lan && netif_running(dev)) ?
+                   "enabled" : "disabled");
 
-               /* Switch off MAC, remember WOL setting */
-               gp->asleep_wol = gp->wake_on_lan;
-               gem_do_stop(dev, gp->asleep_wol);
-       } else
-               gp->asleep_wol = 0;
-
-       /* Mark us asleep */
-       gp->asleep = 1;
-       wmb();
-
-       /* Stop the link timer */
-       del_timer_sync(&gp->link_timer);
-
-       /* Now we release the mutex to not block the reset task who
-        * can take it too. We are marked asleep, so there will be no
-        * conflict here
+       /* Tell the network stack we're gone. gem_do_stop() below will
+        * synchronize with TX, stop NAPI etc...
         */
-       mutex_unlock(&gp->pm_mutex);
+       netif_device_detach(dev);
 
-       /* Wait for a pending reset task to complete */
-       while (gp->reset_task_pending)
-               yield();
-       flush_scheduled_work();
+       /* Switch off chip, remember WOL setting */
+       gp->asleep_wol = gp->wake_on_lan;
+       gem_do_stop(dev, gp->asleep_wol);
 
-       /* Shut the PHY down eventually and setup WOL */
-       gem_stop_phy(gp, gp->asleep_wol);
-
-       /* Make sure bus master is disabled */
-       pci_disable_device(gp->pdev);
-
-       /* Release the cell, no need to take a lock at this point since
-        * nothing else can happen now
-        */
-       gem_put_cell(gp);
+       /* Unlock the network stack */
+       rtnl_unlock();
 
        return 0;
 }
@@ -2420,56 +2354,24 @@ static int gem_suspend(struct pci_dev *pdev, pm_message_t state)
 static int gem_resume(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
-       struct gem *gp = dev->priv;
-       unsigned long flags;
-
-       printk(KERN_INFO "%s: resuming\n", dev->name);
+       struct gem *gp = netdev_priv(dev);
 
-       mutex_lock(&gp->pm_mutex);
+       /* See locking comment in gem_suspend */
+       rtnl_lock();
 
-       /* Keep the cell enabled during the entire operation, no need to
-        * take a lock here tho since nothing else can happen while we are
-        * marked asleep
+       /* Not running, mark ourselves present, no need for
+        * a lock here
         */
-       gem_get_cell(gp);
-
-       /* Make sure PCI access and bus master are enabled */
-       if (pci_enable_device(gp->pdev)) {
-               printk(KERN_ERR "%s: Can't re-enable chip !\n",
-                      dev->name);
-               /* Put cell and forget it for now, it will be considered as
-                * still asleep, a new sleep cycle may bring it back
-                */
-               gem_put_cell(gp);
-               mutex_unlock(&gp->pm_mutex);
+       if (!netif_running(dev)) {
+               netif_device_attach(dev);
+               rtnl_unlock();
                return 0;
        }
-       pci_set_master(gp->pdev);
-
-       /* Reset everything */
-       gem_reset(gp);
-
-       /* Mark us woken up */
-       gp->asleep = 0;
-       wmb();
 
-       /* Bring the PHY back. Again, lock is useless at this point as
-        * nothing can be happening until we restart the whole thing
+       /* Restart chip. If that fails there isn't much we can do, we
+        * leave things stopped.
         */
-       gem_init_phy(gp);
-
-       /* If we were opened, bring everything back */
-       if (gp->opened) {
-               /* Restart MAC */
-               gem_do_start(dev);
-
-               /* Re-attach net device */
-               netif_device_attach(dev);
-
-       }
-
-       spin_lock_irqsave(&gp->lock, flags);
-       spin_lock(&gp->tx_lock);
+       gem_do_start(dev);
 
        /* If we had WOL enabled, the cell clock was never turned off during
         * sleep, so we end up beeing unbalanced. Fix that here
@@ -2477,17 +2379,8 @@ static int gem_resume(struct pci_dev *pdev)
        if (gp->asleep_wol)
                gem_put_cell(gp);
 
-       /* This function doesn't need to hold the cell, it will be held if the
-        * driver is open by gem_do_start().
-        */
-       gem_put_cell(gp);
-
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irqrestore(&gp->lock, flags);
-
-       netif_poll_enable(dev);
-
-       mutex_unlock(&gp->pm_mutex);
+       /* Unlock the network stack */
+       rtnl_unlock();
 
        return 0;
 }
@@ -2495,53 +2388,78 @@ static int gem_resume(struct pci_dev *pdev)
 
 static struct net_device_stats *gem_get_stats(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
-       struct net_device_stats *stats = &gp->net_stats;
-
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
+       struct gem *gp = netdev_priv(dev);
 
        /* I have seen this being called while the PM was in progress,
-        * so we shield against this
+        * so we shield against this. Let's also not poke at registers
+        * while the reset task is going on.
+        *
+        * TODO: Move stats collection elsewhere (link timer ?) and
+        * make this a nop to avoid all those synchro issues
         */
-       if (gp->running) {
-               stats->rx_crc_errors += readl(gp->regs + MAC_FCSERR);
-               writel(0, gp->regs + MAC_FCSERR);
+       if (!netif_device_present(dev) || !netif_running(dev))
+               goto bail;
 
-               stats->rx_frame_errors += readl(gp->regs + MAC_AERR);
-               writel(0, gp->regs + MAC_AERR);
+       /* Better safe than sorry... */
+       if (WARN_ON(!gp->cell_enabled))
+               goto bail;
 
-               stats->rx_length_errors += readl(gp->regs + MAC_LERR);
-               writel(0, gp->regs + MAC_LERR);
+       dev->stats.rx_crc_errors += readl(gp->regs + MAC_FCSERR);
+       writel(0, gp->regs + MAC_FCSERR);
 
-               stats->tx_aborted_errors += readl(gp->regs + MAC_ECOLL);
-               stats->collisions +=
-                       (readl(gp->regs + MAC_ECOLL) +
-                        readl(gp->regs + MAC_LCOLL));
-               writel(0, gp->regs + MAC_ECOLL);
-               writel(0, gp->regs + MAC_LCOLL);
-       }
+       dev->stats.rx_frame_errors += readl(gp->regs + MAC_AERR);
+       writel(0, gp->regs + MAC_AERR);
 
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
+       dev->stats.rx_length_errors += readl(gp->regs + MAC_LERR);
+       writel(0, gp->regs + MAC_LERR);
 
-       return &gp->net_stats;
+       dev->stats.tx_aborted_errors += readl(gp->regs + MAC_ECOLL);
+       dev->stats.collisions +=
+               (readl(gp->regs + MAC_ECOLL) + readl(gp->regs + MAC_LCOLL));
+       writel(0, gp->regs + MAC_ECOLL);
+       writel(0, gp->regs + MAC_LCOLL);
+ bail:
+       return &dev->stats;
+}
+
+static int gem_set_mac_address(struct net_device *dev, void *addr)
+{
+       struct sockaddr *macaddr = (struct sockaddr *) addr;
+       struct gem *gp = netdev_priv(dev);
+       unsigned char *e = &dev->dev_addr[0];
+
+       if (!is_valid_ether_addr(macaddr->sa_data))
+               return -EADDRNOTAVAIL;
+
+       memcpy(dev->dev_addr, macaddr->sa_data, dev->addr_len);
+
+       /* We'll just catch it later when the device is up'd or resumed */
+       if (!netif_running(dev) || !netif_device_present(dev))
+               return 0;
+
+       /* Better safe than sorry... */
+       if (WARN_ON(!gp->cell_enabled))
+               return 0;
+
+       writel((e[4] << 8) | e[5], gp->regs + MAC_ADDR0);
+       writel((e[2] << 8) | e[3], gp->regs + MAC_ADDR1);
+       writel((e[0] << 8) | e[1], gp->regs + MAC_ADDR2);
+
+       return 0;
 }
 
 static void gem_set_multicast(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        u32 rxcfg, rxcfg_new;
        int limit = 10000;
 
+       if (!netif_running(dev) || !netif_device_present(dev))
+               return;
 
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
-
-       if (!gp->running)
-               goto bail;
-
-       netif_stop_queue(dev);
+       /* Better safe than sorry... */
+       if (gp->reset_task_pending || WARN_ON(!gp->cell_enabled))
+               return;
 
        rxcfg = readl(gp->regs + MAC_RXCFG);
        rxcfg_new = gem_setup_multicast(gp);
@@ -2561,12 +2479,6 @@ static void gem_set_multicast(struct net_device *dev)
        rxcfg |= rxcfg_new;
 
        writel(rxcfg, gp->regs + MAC_RXCFG);
-
-       netif_wake_queue(dev);
-
- bail:
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
 }
 
 /* Jumbo-grams don't seem to work :-( */
@@ -2579,38 +2491,33 @@ static void gem_set_multicast(struct net_device *dev)
 
 static int gem_change_mtu(struct net_device *dev, int new_mtu)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        if (new_mtu < GEM_MIN_MTU || new_mtu > GEM_MAX_MTU)
                return -EINVAL;
 
-       if (!netif_running(dev) || !netif_device_present(dev)) {
-               /* We'll just catch it later when the
-                * device is up'd or resumed.
-                */
-               dev->mtu = new_mtu;
+       dev->mtu = new_mtu;
+
+       /* We'll just catch it later when the device is up'd or resumed */
+       if (!netif_running(dev) || !netif_device_present(dev))
                return 0;
-       }
 
-       mutex_lock(&gp->pm_mutex);
-       spin_lock_irq(&gp->lock);
-       spin_lock(&gp->tx_lock);
-       dev->mtu = new_mtu;
-       if (gp->running) {
-               gem_reinit_chip(gp);
-               if (gp->lstate == link_up)
-                       gem_set_link_modes(gp);
-       }
-       spin_unlock(&gp->tx_lock);
-       spin_unlock_irq(&gp->lock);
-       mutex_unlock(&gp->pm_mutex);
+       /* Better safe than sorry... */
+       if (WARN_ON(!gp->cell_enabled))
+               return 0;
+
+       gem_netif_stop(gp);
+       gem_reinit_chip(gp);
+       if (gp->lstate == link_up)
+               gem_set_link_modes(gp);
+       gem_netif_start(gp);
 
        return 0;
 }
 
 static void gem_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        strcpy(info->driver, DRV_NAME);
        strcpy(info->version, DRV_VERSION);
@@ -2619,7 +2526,7 @@ static void gem_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
 
 static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        if (gp->phy_type == phy_mii_mdio0 ||
            gp->phy_type == phy_mii_mdio1) {
@@ -2635,9 +2542,8 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                cmd->phy_address = 0; /* XXX fixed PHYAD */
 
                /* Return current PHY settings */
-               spin_lock_irq(&gp->lock);
                cmd->autoneg = gp->want_autoneg;
-               cmd->speed = gp->phy_mii.speed;
+               ethtool_cmd_speed_set(cmd, gp->phy_mii.speed);
                cmd->duplex = gp->phy_mii.duplex;
                cmd->advertising = gp->phy_mii.advertising;
 
@@ -2647,16 +2553,30 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 */
                if (cmd->advertising == 0)
                        cmd->advertising = cmd->supported;
-               spin_unlock_irq(&gp->lock);
        } else { // XXX PCS ?
                cmd->supported =
                        (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
                         SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
                         SUPPORTED_Autoneg);
                cmd->advertising = cmd->supported;
-               cmd->speed = 0;
+               ethtool_cmd_speed_set(cmd, 0);
                cmd->duplex = cmd->port = cmd->phy_address =
                        cmd->transceiver = cmd->autoneg = 0;
+
+               /* serdes means usually a Fibre connector, with most fixed */
+               if (gp->phy_type == phy_serdes) {
+                       cmd->port = PORT_FIBRE;
+                       cmd->supported = (SUPPORTED_1000baseT_Half |
+                               SUPPORTED_1000baseT_Full |
+                               SUPPORTED_FIBRE | SUPPORTED_Autoneg |
+                               SUPPORTED_Pause | SUPPORTED_Asym_Pause);
+                       cmd->advertising = cmd->supported;
+                       cmd->transceiver = XCVR_INTERNAL;
+                       if (gp->lstate == link_up)
+                               ethtool_cmd_speed_set(cmd, SPEED_1000);
+                       cmd->duplex = DUPLEX_FULL;
+                       cmd->autoneg = 1;
+               }
        }
        cmd->maxtxpkt = cmd->maxrxpkt = 0;
 
@@ -2665,7 +2585,8 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
 static int gem_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
+       u32 speed = ethtool_cmd_speed(cmd);
 
        /* Verify the settings we care about. */
        if (cmd->autoneg != AUTONEG_ENABLE &&
@@ -2677,49 +2598,47 @@ static int gem_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                return -EINVAL;
 
        if (cmd->autoneg == AUTONEG_DISABLE &&
-           ((cmd->speed != SPEED_1000 &&
-             cmd->speed != SPEED_100 &&
-             cmd->speed != SPEED_10) ||
+           ((speed != SPEED_1000 &&
+             speed != SPEED_100 &&
+             speed != SPEED_10) ||
             (cmd->duplex != DUPLEX_HALF &&
              cmd->duplex != DUPLEX_FULL)))
                return -EINVAL;
 
        /* Apply settings and restart link process. */
-       spin_lock_irq(&gp->lock);
-       gem_get_cell(gp);
-       gem_begin_auto_negotiation(gp, cmd);
-       gem_put_cell(gp);
-       spin_unlock_irq(&gp->lock);
+       if (netif_device_present(gp->dev)) {
+               del_timer_sync(&gp->link_timer);
+               gem_begin_auto_negotiation(gp, cmd);
+       }
 
        return 0;
 }
 
 static int gem_nway_reset(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        if (!gp->want_autoneg)
                return -EINVAL;
 
-       /* Restart link process. */
-       spin_lock_irq(&gp->lock);
-       gem_get_cell(gp);
-       gem_begin_auto_negotiation(gp, NULL);
-       gem_put_cell(gp);
-       spin_unlock_irq(&gp->lock);
+       /* Restart link process  */
+       if (netif_device_present(gp->dev)) {
+               del_timer_sync(&gp->link_timer);
+               gem_begin_auto_negotiation(gp, NULL);
+       }
 
        return 0;
 }
 
 static u32 gem_get_msglevel(struct net_device *dev)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        return gp->msg_enable;
 }
 
 static void gem_set_msglevel(struct net_device *dev, u32 value)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        gp->msg_enable = value;
 }
 
@@ -2731,7 +2650,7 @@ static void gem_set_msglevel(struct net_device *dev, u32 value)
 
 static void gem_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        /* Add more when I understand how to program the chip */
        if (gp->has_wol) {
@@ -2745,7 +2664,7 @@ static void gem_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 
 static int gem_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
 
        if (!gp->has_wol)
                return -EOPNOTSUPP;
@@ -2767,19 +2686,14 @@ static const struct ethtool_ops gem_ethtool_ops = {
 
 static int gem_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
-       struct gem *gp = dev->priv;
+       struct gem *gp = netdev_priv(dev);
        struct mii_ioctl_data *data = if_mii(ifr);
        int rc = -EOPNOTSUPP;
-       unsigned long flags;
 
-       /* Hold the PM mutex while doing ioctl's or we may collide
-        * with power management.
+       /* For SIOCGMIIREG and SIOCSMIIREG the core checks for us that
+        * netif_device_present() is true and holds rtnl_lock for us
+        * so we have nothing to worry about
         */
-       mutex_lock(&gp->pm_mutex);
-
-       spin_lock_irqsave(&gp->lock, flags);
-       gem_get_cell(gp);
-       spin_unlock_irqrestore(&gp->lock, flags);
 
        switch (cmd) {
        case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
@@ -2787,38 +2701,21 @@ static int gem_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
                /* Fallthrough... */
 
        case SIOCGMIIREG:               /* Read MII PHY register. */
-               if (!gp->running)
-                       rc = -EAGAIN;
-               else {
-                       data->val_out = __phy_read(gp, data->phy_id & 0x1f,
-                                                  data->reg_num & 0x1f);
-                       rc = 0;
-               }
+               data->val_out = __phy_read(gp, data->phy_id & 0x1f,
+                                          data->reg_num & 0x1f);
+               rc = 0;
                break;
 
        case SIOCSMIIREG:               /* Write MII PHY register. */
-               if (!capable(CAP_NET_ADMIN))
-                       rc = -EPERM;
-               else if (!gp->running)
-                       rc = -EAGAIN;
-               else {
-                       __phy_write(gp, data->phy_id & 0x1f, data->reg_num & 0x1f,
-                                   data->val_in);
-                       rc = 0;
-               }
+               __phy_write(gp, data->phy_id & 0x1f, data->reg_num & 0x1f,
+                           data->val_in);
+               rc = 0;
                break;
-       };
-
-       spin_lock_irqsave(&gp->lock, flags);
-       gem_put_cell(gp);
-       spin_unlock_irqrestore(&gp->lock, flags);
-
-       mutex_unlock(&gp->pm_mutex);
-
+       }
        return rc;
 }
 
-#if (!defined(__sparc__) && !defined(CONFIG_PPC_PMAC))
+#if (!defined(CONFIG_SPARC) && !defined(CONFIG_PPC_PMAC))
 /* Fetch MAC address from vital product data of PCI ROM. */
 static int find_eth_addr_in_vpd(void __iomem *rom_base, int len, unsigned char *dev_addr)
 {
@@ -2867,42 +2764,24 @@ static void get_gem_mac_nonobp(struct pci_dev *pdev, unsigned char *dev_addr)
        dev_addr[1] = 0x00;
        dev_addr[2] = 0x20;
        get_random_bytes(dev_addr + 3, 3);
-       return;
 }
 #endif /* not Sparc and not PPC */
 
 static int __devinit gem_get_device_address(struct gem *gp)
 {
-#if defined(__sparc__) || defined(CONFIG_PPC_PMAC)
+#if defined(CONFIG_SPARC) || defined(CONFIG_PPC_PMAC)
        struct net_device *dev = gp->dev;
-#endif
-
-#if defined(__sparc__)
-       struct pci_dev *pdev = gp->pdev;
-       struct pcidev_cookie *pcp = pdev->sysdata;
-       int use_idprom = 1;
+       const unsigned char *addr;
 
-       if (pcp != NULL) {
-               unsigned char *addr;
-               int len;
-
-               addr = of_get_property(pcp->prom_node, "local-mac-address",
-                                      &len);
-               if (addr && len == 6) {
-                       use_idprom = 0;
-                       memcpy(dev->dev_addr, addr, 6);
-               }
-       }
-       if (use_idprom)
-               memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
-#elif defined(CONFIG_PPC_PMAC)
-       unsigned char *addr;
-
-       addr = get_property(gp->of_node, "local-mac-address", NULL);
+       addr = of_get_property(gp->of_node, "local-mac-address", NULL);
        if (addr == NULL) {
+#ifdef CONFIG_SPARC
+               addr = idprom->id_ethaddr;
+#else
                printk("\n");
-               printk(KERN_ERR "%s: can't get mac-address\n", dev->name);
+               pr_err("%s: can't get mac-address\n", dev->name);
                return -1;
+#endif
        }
        memcpy(dev->dev_addr, addr, 6);
 #else
@@ -2916,28 +2795,12 @@ static void gem_remove_one(struct pci_dev *pdev)
        struct net_device *dev = pci_get_drvdata(pdev);
 
        if (dev) {
-               struct gem *gp = dev->priv;
+               struct gem *gp = netdev_priv(dev);
 
                unregister_netdev(dev);
 
-               /* Stop the link timer */
-               del_timer_sync(&gp->link_timer);
-
-               /* We shouldn't need any locking here */
-               gem_get_cell(gp);
-
-               /* Wait for a pending reset task to complete */
-               while (gp->reset_task_pending)
-                       yield();
-               flush_scheduled_work();
-
-               /* Shut the PHY down */
-               gem_stop_phy(gp, 0);
-
-               gem_put_cell(gp);
-
-               /* Make sure bus master is disabled */
-               pci_disable_device(gp->pdev);
+               /* Ensure reset task is truely gone */
+               cancel_work_sync(&gp->reset_task);
 
                /* Free resources */
                pci_free_consistent(pdev,
@@ -2952,17 +2815,31 @@ static void gem_remove_one(struct pci_dev *pdev)
        }
 }
 
+static const struct net_device_ops gem_netdev_ops = {
+       .ndo_open               = gem_open,
+       .ndo_stop               = gem_close,
+       .ndo_start_xmit         = gem_start_xmit,
+       .ndo_get_stats          = gem_get_stats,
+       .ndo_set_multicast_list = gem_set_multicast,
+       .ndo_do_ioctl           = gem_ioctl,
+       .ndo_tx_timeout         = gem_tx_timeout,
+       .ndo_change_mtu         = gem_change_mtu,
+       .ndo_validate_addr      = eth_validate_addr,
+       .ndo_set_mac_address    = gem_set_mac_address,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       .ndo_poll_controller    = gem_poll_controller,
+#endif
+};
+
 static int __devinit gem_init_one(struct pci_dev *pdev,
                                  const struct pci_device_id *ent)
 {
-       static int gem_version_printed = 0;
        unsigned long gemreg_base, gemreg_len;
        struct net_device *dev;
        struct gem *gp;
-       int i, err, pci_using_dac;
+       int err, pci_using_dac;
 
-       if (gem_version_printed++ == 0)
-               printk(KERN_INFO "%s", version);
+       printk_once(KERN_INFO "%s", version);
 
        /* Apple gmac note: during probe, the chip is powered up by
         * the arch code to allow the code below to work (and to let
@@ -2972,8 +2849,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
         */
        err = pci_enable_device(pdev);
        if (err) {
-               printk(KERN_ERR PFX "Cannot enable MMIO operation, "
-                      "aborting.\n");
+               pr_err("Cannot enable MMIO operation, aborting\n");
                return err;
        }
        pci_set_master(pdev);
@@ -2989,13 +2865,12 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
         */
        if (pdev->vendor == PCI_VENDOR_ID_SUN &&
            pdev->device == PCI_DEVICE_ID_SUN_GEM &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
-                       printk(KERN_ERR PFX "No usable DMA configuration, "
-                              "aborting.\n");
+                       pr_err("No usable DMA configuration, aborting\n");
                        goto err_disable_device;
                }
                pci_using_dac = 0;
@@ -3005,27 +2880,24 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
        gemreg_len = pci_resource_len(pdev, 0);
 
        if ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) != 0) {
-               printk(KERN_ERR PFX "Cannot find proper PCI device "
-                      "base address, aborting.\n");
+               pr_err("Cannot find proper PCI device base address, aborting\n");
                err = -ENODEV;
                goto err_disable_device;
        }
 
        dev = alloc_etherdev(sizeof(*gp));
        if (!dev) {
-               printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
+               pr_err("Etherdev alloc failed, aborting\n");
                err = -ENOMEM;
                goto err_disable_device;
        }
-       SET_MODULE_OWNER(dev);
        SET_NETDEV_DEV(dev, &pdev->dev);
 
-       gp = dev->priv;
+       gp = netdev_priv(dev);
 
        err = pci_request_regions(pdev, DRV_NAME);
        if (err) {
-               printk(KERN_ERR PFX "Cannot obtain PCI resources, "
-                      "aborting.\n");
+               pr_err("Cannot obtain PCI resources, aborting\n");
                goto err_out_free_netdev;
        }
 
@@ -3035,24 +2907,19 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
 
        gp->msg_enable = DEFAULT_MSG;
 
-       spin_lock_init(&gp->lock);
-       spin_lock_init(&gp->tx_lock);
-       mutex_init(&gp->pm_mutex);
-
        init_timer(&gp->link_timer);
        gp->link_timer.function = gem_link_timer;
        gp->link_timer.data = (unsigned long) gp;
 
-       INIT_WORK(&gp->reset_task, gem_reset_task, gp);
+       INIT_WORK(&gp->reset_task, gem_reset_task);
 
        gp->lstate = link_down;
        gp->timer_ticks = 0;
        netif_carrier_off(dev);
 
        gp->regs = ioremap(gemreg_base, gemreg_len);
-       if (gp->regs == 0UL) {
-               printk(KERN_ERR PFX "Cannot map device registers, "
-                      "aborting.\n");
+       if (!gp->regs) {
+               pr_err("Cannot map device registers, aborting\n");
                err = -EIO;
                goto err_out_free_res;
        }
@@ -3060,7 +2927,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
        /* On Apple, we want a reference to the Open Firmware device-tree
         * node. We use it for clock control.
         */
-#ifdef CONFIG_PPC_PMAC
+#if defined(CONFIG_PPC_PMAC) || defined(CONFIG_SPARC)
        gp->of_node = pci_device_to_OF_node(pdev);
 #endif
 
@@ -3097,8 +2964,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
                pci_alloc_consistent(pdev, sizeof(struct gem_init_block),
                                     &gp->gblock_dvma);
        if (!gp->init_block) {
-               printk(KERN_ERR PFX "Cannot allocate init block, "
-                      "aborting.\n");
+               pr_err("Cannot allocate init block, aborting\n");
                err = -ENOMEM;
                goto err_out_iounmap;
        }
@@ -3106,61 +2972,38 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
        if (gem_get_device_address(gp))
                goto err_out_free_consistent;
 
-       dev->open = gem_open;
-       dev->stop = gem_close;
-       dev->hard_start_xmit = gem_start_xmit;
-       dev->get_stats = gem_get_stats;
-       dev->set_multicast_list = gem_set_multicast;
-       dev->do_ioctl = gem_ioctl;
-       dev->poll = gem_poll;
-       dev->weight = 64;
+       dev->netdev_ops = &gem_netdev_ops;
+       netif_napi_add(dev, &gp->napi, gem_poll, 64);
        dev->ethtool_ops = &gem_ethtool_ops;
-       dev->tx_timeout = gem_tx_timeout;
        dev->watchdog_timeo = 5 * HZ;
-       dev->change_mtu = gem_change_mtu;
        dev->irq = pdev->irq;
        dev->dma = 0;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-       dev->poll_controller = gem_poll_controller;
-#endif
 
        /* Set that now, in case PM kicks in now */
        pci_set_drvdata(pdev, dev);
 
-       /* Detect & init PHY, start autoneg, we release the cell now
-        * too, it will be managed by whoever needs it
-        */
-       gem_init_phy(gp);
-
-       spin_lock_irq(&gp->lock);
-       gem_put_cell(gp);
-       spin_unlock_irq(&gp->lock);
+       /* We can do scatter/gather and HW checksum */
+       dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM;
+       dev->features |= dev->hw_features | NETIF_F_RXCSUM;
+       if (pci_using_dac)
+               dev->features |= NETIF_F_HIGHDMA;
 
        /* Register with kernel */
        if (register_netdev(dev)) {
-               printk(KERN_ERR PFX "Cannot register net device, "
-                      "aborting.\n");
+               pr_err("Cannot register net device, aborting\n");
                err = -ENOMEM;
                goto err_out_free_consistent;
        }
 
-       printk(KERN_INFO "%s: Sun GEM (PCI) 10/100/1000BaseT Ethernet ",
-              dev->name);
-       for (i = 0; i < 6; i++)
-               printk("%2.2x%c", dev->dev_addr[i],
-                      i == 5 ? ' ' : ':');
-       printk("\n");
-
-       if (gp->phy_type == phy_mii_mdio0 ||
-           gp->phy_type == phy_mii_mdio1)
-               printk(KERN_INFO "%s: Found %s PHY\n", dev->name,
-                       gp->phy_mii.def ? gp->phy_mii.def->name : "no");
-
-       /* GEM can do it all... */
-       dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_LLTX;
-       if (pci_using_dac)
-               dev->features |= NETIF_F_HIGHDMA;
+       /* Undo the get_cell with appropriate locking (we could use
+        * ndo_init/uninit but that would be even more clumsy imho)
+        */
+       rtnl_lock();
+       gem_put_cell(gp);
+       rtnl_unlock();
 
+       netdev_info(dev, "Sun GEM (PCI) 10/100/1000BaseT Ethernet %pM\n",
+                   dev->dev_addr);
        return 0;
 
 err_out_free_consistent: