Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 128 insertions, 175 deletions

diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index 434f9d735333..ab5930099267 100644
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -31,6 +31,8 @@
  *    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>
@@ -105,7 +107,6 @@ MODULE_DESCRIPTION("Sun GEM Gbit ethernet driver");
 MODULE_LICENSE("GPL");
 
 #define GEM_MODULE_NAME "gem"
-#define PFX GEM_MODULE_NAME ": "
 
 static DEFINE_PCI_DEVICE_TABLE(gem_pci_tbl) = {
         { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_GEM,
@@ -262,8 +263,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;
         }
 
@@ -282,20 +282,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.
@@ -323,31 +319,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
@@ -377,8 +371,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;
         }
 
@@ -390,8 +383,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;
         }
 
@@ -403,8 +395,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;
         }
 
@@ -419,8 +410,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;
         }
 
@@ -429,8 +419,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;
                 }
 
@@ -479,22 +468,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.
@@ -542,19 +530,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) {
@@ -565,26 +552,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 |
@@ -613,7 +594,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) {
@@ -621,7 +602,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: corrupt rx tag framing\n",
                                 gp->dev->name);
-                gp->net_stats.rx_errors++;
+                dev->stats.rx_errors++;
 
                 goto do_reset;
         }
@@ -703,7 +684,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];
@@ -715,7 +696,7 @@ 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->stats.tx_packets++;
                 dev_kfree_skb_irq(skb);
         }
         gp->tx_old = entry;
@@ -757,6 +738,7 @@ static __inline__ void gem_post_rxds(struct gem *gp, int limit)
 
 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;
@@ -801,15 +783,15 @@ 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;
                 }
 
@@ -862,8 +844,8 @@ static int gem_rx(struct gem *gp, int work_to_do)
 
                 netif_receive_skb(skb);
 
-                gp->net_stats.rx_packets++;
-                gp->net_stats.rx_bytes += len;
+                dev->stats.rx_packets++;
+                dev->stats.rx_bytes += len;
 
         next:
                 entry = NEXT_RX(entry);
@@ -874,8 +856,7 @@ 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;
 }
@@ -981,21 +962,19 @@ static void gem_tx_timeout(struct net_device *dev)
 {
         struct gem *gp = netdev_priv(dev);
 
-        printk(KERN_ERR "%s: transmit timed out, resetting\n", dev->name);
+        netdev_err(dev, "transmit timed out, resetting\n");
         if (!gp->running) {
-                printk("%s: hrm.. hw not running !\n", dev->name);
+                netdev_err(dev, "hrm.. hw not running !\n");
                 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));
+        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_lock_irq(&gp->lock);
         spin_lock(&gp->tx_lock);
@@ -1026,7 +1005,7 @@ static netdev_tx_t gem_start_xmit(struct sk_buff *skb,
 
         ctrl = 0;
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                const u64 csum_start_off = skb_transport_offset(skb);
+                const u64 csum_start_off = skb_checksum_start_offset(skb);
                 const u64 csum_stuff_off = csum_start_off + skb->csum_offset;
 
                 ctrl = (TXDCTRL_CENAB |
@@ -1048,8 +1027,7 @@ static netdev_tx_t gem_start_xmit(struct sk_buff *skb,
         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);
+                netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
                 return NETDEV_TX_BUSY;
         }
 
@@ -1158,8 +1136,7 @@ static void gem_pcs_reset(struct gem *gp)
                         break;
         }
         if (limit < 0)
-                printk(KERN_WARNING "%s: PCS reset bit would not clear.\n",
-                       gp->dev->name);
+                netdev_warn(gp->dev, "PCS reset bit would not clear\n");
 }
 
 static void gem_pcs_reinit_adv(struct gem *gp)
@@ -1173,7 +1150,7 @@ static void gem_pcs_reinit_adv(struct gem *gp)
         val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
         writel(val, gp->regs + PCS_CFG);
 
-        /* Advertise all capabilities except assymetric
+        /* Advertise all capabilities except asymmetric
          * pause.
          */
         val = readl(gp->regs + PCS_MIIADV);
@@ -1230,7 +1207,7 @@ static void gem_reset(struct gem *gp)
         } while (val & (GREG_SWRST_TXRST | GREG_SWRST_RXRST));
 
         if (limit < 0)
-                printk(KERN_ERR "%s: SW reset is ghetto.\n", gp->dev->name);
+                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);
@@ -1317,7 +1294,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;
         }
 
@@ -1395,9 +1372,8 @@ static int gem_set_link_modes(struct gem *gp)
                 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;
@@ -1451,15 +1427,13 @@ static int gem_set_link_modes(struct gem *gp)
 
         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);
+                        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 {
-                        printk(KERN_INFO "%s: Pause is disabled\n",
-                               gp->dev->name);
+                        netdev_info(gp->dev, "Pause is disabled\n");
                 }
         }
 
@@ -1484,9 +1458,8 @@ 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;
@@ -1499,9 +1472,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);
@@ -1517,9 +1488,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;
@@ -1574,8 +1544,8 @@ 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(gp->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;
@@ -1589,9 +1559,7 @@ 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_info(gp, link, gp->dev, "Link down\n");
                         netif_carrier_off(gp->dev);
                         gp->reset_task_pending = 1;
                         schedule_work(&gp->reset_task);
@@ -1746,8 +1714,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");
                 }
         }
 
@@ -2038,7 +2005,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;
                 }
@@ -2078,7 +2045,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;
@@ -2093,7 +2060,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;
                         }
@@ -2101,7 +2068,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;
                         }
@@ -2239,7 +2206,7 @@ static int gem_do_start(struct net_device *dev)
 
         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);
+                netdev_err(dev, "failed to request irq !\n");
 
                 spin_lock_irqsave(&gp->lock, flags);
                 spin_lock(&gp->tx_lock);
@@ -2378,9 +2345,8 @@ static int gem_suspend(struct pci_dev *pdev, pm_message_t state)
 
         mutex_lock(&gp->pm_mutex);
 
-        printk(KERN_INFO "%s: suspending, WakeOnLan %s\n",
-               dev->name,
-               (gp->wake_on_lan && gp->opened) ? "enabled" : "disabled");
+        netdev_info(dev, "suspending, WakeOnLan %s\n",
+                    (gp->wake_on_lan && gp->opened) ? "enabled" : "disabled");
 
         /* Keep the cell enabled during the entire operation */
         spin_lock_irqsave(&gp->lock, flags);
@@ -2415,10 +2381,8 @@ static int gem_suspend(struct pci_dev *pdev, pm_message_t state)
          */
         mutex_unlock(&gp->pm_mutex);
 
-        /* Wait for a pending reset task to complete */
-        while (gp->reset_task_pending)
-                yield();
-        flush_scheduled_work();
+        /* Wait for the pending reset task to complete */
+        flush_work_sync(&gp->reset_task);
 
         /* Shut the PHY down eventually and setup WOL */
         gem_stop_phy(gp, gp->asleep_wol);
@@ -2440,7 +2404,7 @@ static int gem_resume(struct pci_dev *pdev)
         struct gem *gp = netdev_priv(dev);
         unsigned long flags;
 
-        printk(KERN_INFO "%s: resuming\n", dev->name);
+        netdev_info(dev, "resuming\n");
 
         mutex_lock(&gp->pm_mutex);
 
@@ -2452,8 +2416,7 @@ static int gem_resume(struct pci_dev *pdev)
 
         /* 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);
+                netdev_err(dev, "Can't re-enable chip !\n");
                 /* Put cell and forget it for now, it will be considered as
                  * still asleep, a new sleep cycle may bring it back
                  */
@@ -2510,7 +2473,6 @@ static int gem_resume(struct pci_dev *pdev)
 static struct net_device_stats *gem_get_stats(struct net_device *dev)
 {
         struct gem *gp = netdev_priv(dev);
-        struct net_device_stats *stats = &gp->net_stats;
 
         spin_lock_irq(&gp->lock);
         spin_lock(&gp->tx_lock);
@@ -2519,17 +2481,17 @@ static struct net_device_stats *gem_get_stats(struct net_device *dev)
          * so we shield against this
          */
         if (gp->running) {
-                stats->rx_crc_errors += readl(gp->regs + MAC_FCSERR);
+                dev->stats.rx_crc_errors += readl(gp->regs + MAC_FCSERR);
                 writel(0, gp->regs + MAC_FCSERR);
 
-                stats->rx_frame_errors += readl(gp->regs + MAC_AERR);
+                dev->stats.rx_frame_errors += readl(gp->regs + MAC_AERR);
                 writel(0, gp->regs + MAC_AERR);
 
-                stats->rx_length_errors += readl(gp->regs + MAC_LERR);
+                dev->stats.rx_length_errors += readl(gp->regs + MAC_LERR);
                 writel(0, gp->regs + MAC_LERR);
 
-                stats->tx_aborted_errors += readl(gp->regs + MAC_ECOLL);
-                stats->collisions +=
+                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);
@@ -2539,7 +2501,7 @@ static struct net_device_stats *gem_get_stats(struct net_device *dev)
         spin_unlock(&gp->tx_lock);
         spin_unlock_irq(&gp->lock);
 
-        return &gp->net_stats;
+        return &dev->stats;
 }
 
 static int gem_set_mac_address(struct net_device *dev, void *addr)
@@ -2680,7 +2642,7 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 /* 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;
 
@@ -2697,7 +2659,7 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                          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;
 
@@ -2711,7 +2673,7 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                         cmd->advertising = cmd->supported;
                         cmd->transceiver = XCVR_INTERNAL;
                         if (gp->lstate == link_up)
-                                cmd->speed = SPEED_1000;
+                                ethtool_cmd_speed_set(cmd, SPEED_1000);
                         cmd->duplex = DUPLEX_FULL;
                         cmd->autoneg = 1;
                 }
@@ -2724,6 +2686,7 @@ 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 = netdev_priv(dev);
+        u32 speed = ethtool_cmd_speed(cmd);
 
         /* Verify the settings we care about. */
         if (cmd->autoneg != AUTONEG_ENABLE &&
@@ -2735,9 +2698,9 @@ 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;
@@ -2938,7 +2901,7 @@ static int __devinit gem_get_device_address(struct gem *gp)
                 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
         }
@@ -2964,10 +2927,8 @@ static void gem_remove_one(struct pci_dev *pdev)
                 /* 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();
+                /* Cancel reset task */
+                cancel_work_sync(&gp->reset_task);
 
                 /* Shut the PHY down */
                 gem_stop_phy(gp, 0);
@@ -3009,14 +2970,12 @@ static const struct net_device_ops gem_netdev_ops = {
 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 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
@@ -3026,8 +2985,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);
@@ -3048,8 +3006,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
         } else {
                 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;
@@ -3059,15 +3016,14 @@ 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;
         }
@@ -3077,8 +3033,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
 
         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;
         }
 
@@ -3104,8 +3059,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
 
         gp->regs = ioremap(gemreg_base, gemreg_len);
         if (!gp->regs) {
-                printk(KERN_ERR PFX "Cannot map device registers, "
-                       "aborting.\n");
+                pr_err("Cannot map device registers, aborting\n");
                 err = -EIO;
                 goto err_out_free_res;
         }
@@ -3150,8 +3104,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;
         }
@@ -3180,22 +3133,22 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
 
         /* 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 %pM\n",
-               dev->name, dev->dev_addr);
+        netdev_info(dev, "Sun GEM (PCI) 10/100/1000BaseT Ethernet %pM\n",
+                    dev->dev_addr);
 
         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");
+                netdev_info(dev, "Found %s PHY\n",
+                            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;
+        dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->features |= dev->hw_features | NETIF_F_RXCSUM | NETIF_F_LLTX;
         if (pci_using_dac)
                 dev->features |= NETIF_F_HIGHDMA;