Merge branch 'origin' into devel-stable

Conflicts:
	arch/arm/mach-mx2/devices.c
	arch/arm/mach-mx2/devices.h
	sound/soc/pxa/pxa-ssp.c

1 files changed, 98 insertions, 120 deletions

diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 379a3dc0016..d0058e5bb6a 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -23,6 +23,8 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -46,7 +48,6 @@
 
 #define DRV_NAME                "skge"
 #define DRV_VERSION             "1.13"
-#define PFX                     DRV_NAME " "
 
 #define DEFAULT_TX_RING_SIZE    128
 #define DEFAULT_RX_RING_SIZE    512
@@ -70,15 +71,15 @@ MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-static const u32 default_msg
-        = NETIF_MSG_DRV| NETIF_MSG_PROBE| NETIF_MSG_LINK
-          | NETIF_MSG_IFUP| NETIF_MSG_IFDOWN;
+static const u32 default_msg = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
+                                NETIF_MSG_LINK | NETIF_MSG_IFUP |
+                                NETIF_MSG_IFDOWN);
 
 static int debug = -1;  /* defaults above */
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
-static const struct pci_device_id skge_id_table[] = {
+static DEFINE_PCI_DEVICE_TABLE(skge_id_table) = {
         { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940) },
         { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940B) },
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE) },
@@ -187,8 +188,8 @@ static void skge_wol_init(struct skge_port *skge)
 
         /* Force to 10/100 skge_reset will re-enable on resume   */
         gm_phy_write(hw, port, PHY_MARV_AUNE_ADV,
-                     PHY_AN_100FULL | PHY_AN_100HALF |
-                     PHY_AN_10FULL | PHY_AN_10HALF| PHY_AN_CSMA);
+                     (PHY_AN_100FULL | PHY_AN_100HALF |
+                      PHY_AN_10FULL | PHY_AN_10HALF | PHY_AN_CSMA));
         /* no 1000 HD/FD */
         gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, 0);
         gm_phy_write(hw, port, PHY_MARV_CTRL,
@@ -257,25 +258,28 @@ static u32 skge_supported_modes(const struct skge_hw *hw)
         u32 supported;
 
         if (hw->copper) {
-                supported = SUPPORTED_10baseT_Half
-                        | SUPPORTED_10baseT_Full
-                        | SUPPORTED_100baseT_Half
-                        | SUPPORTED_100baseT_Full
-                        | SUPPORTED_1000baseT_Half
-                        | SUPPORTED_1000baseT_Full
-                        | SUPPORTED_Autoneg| SUPPORTED_TP;
+                supported = (SUPPORTED_10baseT_Half |
+                             SUPPORTED_10baseT_Full |
+                             SUPPORTED_100baseT_Half |
+                             SUPPORTED_100baseT_Full |
+                             SUPPORTED_1000baseT_Half |
+                             SUPPORTED_1000baseT_Full |
+                             SUPPORTED_Autoneg |
+                             SUPPORTED_TP);
 
                 if (hw->chip_id == CHIP_ID_GENESIS)
-                        supported &= ~(SUPPORTED_10baseT_Half
-                                             | SUPPORTED_10baseT_Full
-                                             | SUPPORTED_100baseT_Half
-                                             | SUPPORTED_100baseT_Full);
+                        supported &= ~(SUPPORTED_10baseT_Half |
+                                       SUPPORTED_10baseT_Full |
+                                       SUPPORTED_100baseT_Half |
+                                       SUPPORTED_100baseT_Full);
 
                 else if (hw->chip_id == CHIP_ID_YUKON)
                         supported &= ~SUPPORTED_1000baseT_Half;
         } else
-                supported = SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half
-                        | SUPPORTED_FIBRE | SUPPORTED_Autoneg;
+                supported = (SUPPORTED_1000baseT_Full |
+                             SUPPORTED_1000baseT_Half |
+                             SUPPORTED_FIBRE |
+                             SUPPORTED_Autoneg);
 
         return supported;
 }
@@ -365,7 +369,7 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                 }
         }
 
-        return (0);
+        return 0;
 }
 
 static void skge_get_drvinfo(struct net_device *dev,
@@ -812,7 +816,7 @@ static int skge_get_eeprom_len(struct net_device *dev)
         u32 reg2;
 
         pci_read_config_dword(skge->hw->pdev, PCI_DEV_REG2, &reg2);
-        return 1 << ( ((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
+        return 1 << (((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
 }
 
 static u32 skge_vpd_read(struct pci_dev *pdev, int cap, u16 offset)
@@ -1043,7 +1047,7 @@ static int skge_rx_fill(struct net_device *dev)
 
                 skb_reserve(skb, NET_IP_ALIGN);
                 skge_rx_setup(skge, e, skb, skge->rx_buf_size);
-        } while ( (e = e->next) != ring->start);
+        } while ((e = e->next) != ring->start);
 
         ring->to_clean = ring->start;
         return 0;
@@ -1051,7 +1055,7 @@ static int skge_rx_fill(struct net_device *dev)
 
 static const char *skge_pause(enum pause_status status)
 {
-        switch(status) {
+        switch (status) {
         case FLOW_STAT_NONE:
                 return "none";
         case FLOW_STAT_REM_SEND:
@@ -1074,13 +1078,11 @@ static void skge_link_up(struct skge_port *skge)
         netif_carrier_on(skge->netdev);
         netif_wake_queue(skge->netdev);
 
-        if (netif_msg_link(skge)) {
-                printk(KERN_INFO PFX
-                       "%s: Link is up at %d Mbps, %s duplex, flow control %s\n",
-                       skge->netdev->name, skge->speed,
-                       skge->duplex == DUPLEX_FULL ? "full" : "half",
-                       skge_pause(skge->flow_status));
-        }
+        netif_info(skge, link, skge->netdev,
+                   "Link is up at %d Mbps, %s duplex, flow control %s\n",
+                   skge->speed,
+                   skge->duplex == DUPLEX_FULL ? "full" : "half",
+                   skge_pause(skge->flow_status));
 }
 
 static void skge_link_down(struct skge_port *skge)
@@ -1089,8 +1091,7 @@ static void skge_link_down(struct skge_port *skge)
         netif_carrier_off(skge->netdev);
         netif_stop_queue(skge->netdev);
 
-        if (netif_msg_link(skge))
-                printk(KERN_INFO PFX "%s: Link is down.\n", skge->netdev->name);
+        netif_info(skge, link, skge->netdev, "Link is down\n");
 }
 
 
@@ -1132,8 +1133,7 @@ static u16 xm_phy_read(struct skge_hw *hw, int port, u16 reg)
 {
         u16 v = 0;
         if (__xm_phy_read(hw, port, reg, &v))
-                printk(KERN_WARNING PFX "%s: phy read timed out\n",
-                       hw->dev[port]->name);
+                pr_warning("%s: phy read timed out\n", hw->dev[port]->name);
         return v;
 }
 
@@ -1255,8 +1255,7 @@ static void bcom_check_link(struct skge_hw *hw, int port)
 
                 lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
                 if (lpa & PHY_B_AN_RF) {
-                        printk(KERN_NOTICE PFX "%s: remote fault\n",
-                               dev->name);
+                        netdev_notice(dev, "remote fault\n");
                         return;
                 }
 
@@ -1271,8 +1270,7 @@ static void bcom_check_link(struct skge_hw *hw, int port)
                         skge->duplex = DUPLEX_HALF;
                         break;
                 default:
-                        printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
-                               dev->name);
+                        netdev_notice(dev, "duplex mismatch\n");
                         return;
                 }
 
@@ -1327,7 +1325,7 @@ static void bcom_phy_init(struct skge_port *skge)
         /* Optimize MDIO transfer by suppressing preamble. */
         r = xm_read16(hw, port, XM_MMU_CMD);
         r |=  XM_MMU_NO_PRE;
-        xm_write16(hw, port, XM_MMU_CMD,r);
+        xm_write16(hw, port, XM_MMU_CMD, r);
 
         switch (id1) {
         case PHY_BCOM_ID1_C0:
@@ -1464,8 +1462,7 @@ static int xm_check_link(struct net_device *dev)
 
                 lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
                 if (lpa & PHY_B_AN_RF) {
-                        printk(KERN_NOTICE PFX "%s: remote fault\n",
-                               dev->name);
+                        netdev_notice(dev, "remote fault\n");
                         return 0;
                 }
 
@@ -1480,8 +1477,7 @@ static int xm_check_link(struct net_device *dev)
                         skge->duplex = DUPLEX_HALF;
                         break;
                 default:
-                        printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
-                               dev->name);
+                        netdev_notice(dev, "duplex mismatch\n");
                         return 0;
                 }
 
@@ -1519,7 +1515,7 @@ static void xm_link_timer(unsigned long arg)
 {
         struct skge_port *skge = (struct skge_port *) arg;
         struct net_device *dev = skge->netdev;
-        struct skge_hw *hw = skge->hw;
+        struct skge_hw *hw = skge->hw;
         int port = skge->port;
         int i;
         unsigned long flags;
@@ -1538,7 +1534,7 @@ static void xm_link_timer(unsigned long arg)
                         goto link_down;
         }
 
-        /* Re-enable interrupt to detect link down */
+        /* Re-enable interrupt to detect link down */
         if (xm_check_link(dev)) {
                 u16 msk = xm_read16(hw, port, XM_IMSK);
                 msk &= ~XM_IS_INP_ASS;
@@ -1569,7 +1565,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
                 udelay(1);
         }
 
-        printk(KERN_WARNING PFX "%s: genesis reset failed\n", dev->name);
+        netdev_warn(dev, "genesis reset failed\n");
 
  reset_ok:
         /* Unreset the XMAC. */
@@ -1595,7 +1591,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
         }
 
 
-        switch(hw->phy_type) {
+        switch (hw->phy_type) {
         case SK_PHY_XMAC:
                 xm_phy_init(skge);
                 break;
@@ -1702,7 +1698,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
 
         if (jumbo) {
                 /* Enable frame flushing if jumbo frames used */
-                skge_write16(hw, SK_REG(port,RX_MFF_CTRL1), MFF_ENA_FLUSH);
+                skge_write16(hw, SK_REG(port, RX_MFF_CTRL1), MFF_ENA_FLUSH);
         } else {
                 /* enable timeout timers if normal frames */
                 skge_write16(hw, B3_PA_CTRL,
@@ -1717,7 +1713,7 @@ static void genesis_stop(struct skge_port *skge)
         unsigned retries = 1000;
         u16 cmd;
 
-        /* Disable Tx and Rx */
+        /* Disable Tx and Rx */
         cmd = xm_read16(hw, port, XM_MMU_CMD);
         cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
         xm_write16(hw, port, XM_MMU_CMD, cmd);
@@ -1792,12 +1788,11 @@ static void genesis_mac_intr(struct skge_hw *hw, int port)
         struct skge_port *skge = netdev_priv(dev);
         u16 status = xm_read16(hw, port, XM_ISRC);
 
-        if (netif_msg_intr(skge))
-                printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
-                       dev->name, status);
+        netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                     "mac interrupt status 0x%x\n", status);
 
         if (hw->phy_type == SK_PHY_XMAC && (status & XM_IS_INP_ASS)) {
-                xm_link_down(hw, port);
+                xm_link_down(hw, port);
                 mod_timer(&skge->link_timer, jiffies + 1);
         }
 
@@ -1831,7 +1826,7 @@ static void genesis_link_up(struct skge_port *skge)
         xm_write16(hw, port, XM_MMU_CMD, cmd);
 
         mode = xm_read32(hw, port, XM_MODE);
-        if (skge->flow_status== FLOW_STAT_SYMMETRIC ||
+        if (skge->flow_status == FLOW_STAT_SYMMETRIC ||
             skge->flow_status == FLOW_STAT_LOC_SEND) {
                 /*
                  * Configure Pause Frame Generation
@@ -1898,12 +1893,11 @@ static inline void bcom_phy_intr(struct skge_port *skge)
         u16 isrc;
 
         isrc = xm_phy_read(hw, port, PHY_BCOM_INT_STAT);
-        if (netif_msg_intr(skge))
-                printk(KERN_DEBUG PFX "%s: phy interrupt status 0x%x\n",
-                       skge->netdev->name, isrc);
+        netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                     "phy interrupt status 0x%x\n", isrc);
 
         if (isrc & PHY_B_IS_PSE)
-                printk(KERN_ERR PFX "%s: uncorrectable pair swap error\n",
+                pr_err("%s: uncorrectable pair swap error\n",
                        hw->dev[port]->name);
 
         /* Workaround BCom Errata:
@@ -1936,8 +1930,7 @@ static int gm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val)
                         return 0;
         }
 
-        printk(KERN_WARNING PFX "%s: phy write timeout\n",
-               hw->dev[port]->name);
+        pr_warning("%s: phy write timeout\n", hw->dev[port]->name);
         return -EIO;
 }
 
@@ -1965,8 +1958,7 @@ static u16 gm_phy_read(struct skge_hw *hw, int port, u16 reg)
 {
         u16 v = 0;
         if (__gm_phy_read(hw, port, reg, &v))
-                printk(KERN_WARNING PFX "%s: phy read timeout\n",
-               hw->dev[port]->name);
+                pr_warning("%s: phy read timeout\n", hw->dev[port]->name);
         return v;
 }
 
@@ -2298,9 +2290,8 @@ static void yukon_mac_intr(struct skge_hw *hw, int port)
         struct skge_port *skge = netdev_priv(dev);
         u8 status = skge_read8(hw, SK_REG(port, GMAC_IRQ_SRC));
 
-        if (netif_msg_intr(skge))
-                printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
-                       dev->name, status);
+        netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                     "mac interrupt status 0x%x\n", status);
 
         if (status & GM_IS_RX_FF_OR) {
                 ++dev->stats.rx_fifo_errors;
@@ -2379,9 +2370,8 @@ static void yukon_phy_intr(struct skge_port *skge)
         istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT);
         phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT);
 
-        if (netif_msg_intr(skge))
-                printk(KERN_DEBUG PFX "%s: phy interrupt status 0x%x 0x%x\n",
-                       skge->netdev->name, istatus, phystat);
+        netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
+                     "phy interrupt status 0x%x 0x%x\n", istatus, phystat);
 
         if (istatus & PHY_M_IS_AN_COMPL) {
                 if (gm_phy_read(hw, port, PHY_MARV_AUNE_LP)
@@ -2441,8 +2431,7 @@ static void yukon_phy_intr(struct skge_port *skge)
         }
         return;
  failed:
-        printk(KERN_ERR PFX "%s: autonegotiation failed (%s)\n",
-               skge->netdev->name, reason);
+        pr_err("%s: autonegotiation failed (%s)\n", skge->netdev->name, reason);
 
         /* XXX restart autonegotiation? */
 }
@@ -2480,7 +2469,7 @@ static int skge_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
         if (!netif_running(dev))
                 return -ENODEV; /* Phy still in reset */
 
-        switch(cmd) {
+        switch (cmd) {
         case SIOCGMIIPHY:
                 data->phy_id = hw->phy_addr;
 
@@ -2571,8 +2560,7 @@ static int skge_up(struct net_device *dev)
         if (!is_valid_ether_addr(dev->dev_addr))
                 return -EINVAL;
 
-        if (netif_msg_ifup(skge))
-                printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
+        netif_info(skge, ifup, skge->netdev, "enabling interface\n");
 
         if (dev->mtu > RX_BUF_SIZE)
                 skge->rx_buf_size = dev->mtu + ETH_HLEN;
@@ -2670,8 +2658,7 @@ static int skge_down(struct net_device *dev)
         if (skge->mem == NULL)
                 return 0;
 
-        if (netif_msg_ifdown(skge))
-                printk(KERN_INFO PFX "%s: disabling interface\n", dev->name);
+        netif_info(skge, ifdown, skge->netdev, "disabling interface\n");
 
         netif_tx_disable(dev);
 
@@ -2781,7 +2768,7 @@ static netdev_tx_t skge_xmit_frame(struct sk_buff *skb,
                  * does.  Looks like hardware is wrong?
                  */
                 if (ipip_hdr(skb)->protocol == IPPROTO_UDP &&
-                    hw->chip_rev == 0 && hw->chip_id == CHIP_ID_YUKON)
+                    hw->chip_rev == 0 && hw->chip_id == CHIP_ID_YUKON)
                         control = BMU_TCP_CHECK;
                 else
                         control = BMU_UDP_CHECK;
@@ -2793,7 +2780,7 @@ static netdev_tx_t skge_xmit_frame(struct sk_buff *skb,
                 control = BMU_CHECK;
 
         if (!skb_shinfo(skb)->nr_frags) /* single buffer i.e. no fragments */
-                control |= BMU_EOF| BMU_IRQ_EOF;
+                control |= BMU_EOF | BMU_IRQ_EOF;
         else {
                 struct skge_tx_desc *tf = td;
 
@@ -2825,15 +2812,15 @@ static netdev_tx_t skge_xmit_frame(struct sk_buff *skb,
 
         skge_write8(hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_START);
 
-        if (unlikely(netif_msg_tx_queued(skge)))
-                printk(KERN_DEBUG "%s: tx queued, slot %td, len %d\n",
-                       dev->name, e - skge->tx_ring.start, skb->len);
+        netif_printk(skge, tx_queued, KERN_DEBUG, skge->netdev,
+                     "tx queued, slot %td, len %d\n",
+                     e - skge->tx_ring.start, skb->len);
 
         skge->tx_ring.to_use = e->next;
         smp_wmb();
 
         if (skge_avail(&skge->tx_ring) <= TX_LOW_WATER) {
-                pr_debug("%s: transmit queue full\n", dev->name);
+                netdev_dbg(dev, "transmit queue full\n");
                 netif_stop_queue(dev);
         }
 
@@ -2858,9 +2845,8 @@ static void skge_tx_free(struct skge_port *skge, struct skge_element *e,
                                PCI_DMA_TODEVICE);
 
         if (control & BMU_EOF) {
-                if (unlikely(netif_msg_tx_done(skge)))
-                        printk(KERN_DEBUG PFX "%s: tx done slot %td\n",
-                               skge->netdev->name, e - skge->tx_ring.start);
+                netif_printk(skge, tx_done, KERN_DEBUG, skge->netdev,
+                             "tx done slot %td\n", e - skge->tx_ring.start);
 
                 dev_kfree_skb(e->skb);
         }
@@ -2885,8 +2871,7 @@ static void skge_tx_timeout(struct net_device *dev)
 {
         struct skge_port *skge = netdev_priv(dev);
 
-        if (netif_msg_timer(skge))
-                printk(KERN_DEBUG PFX "%s: tx timeout\n", dev->name);
+        netif_printk(skge, timer, KERN_DEBUG, skge->netdev, "tx timeout\n");
 
         skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_STOP);
         skge_tx_clean(dev);
@@ -2932,8 +2917,7 @@ static void genesis_set_multicast(struct net_device *dev)
         struct skge_port *skge = netdev_priv(dev);
         struct skge_hw *hw = skge->hw;
         int port = skge->port;
-        int i, count = dev->mc_count;
-        struct dev_mc_list *list = dev->mc_list;
+        struct dev_mc_list *list;
         u32 mode;
         u8 filter[8];
 
@@ -2953,7 +2937,7 @@ static void genesis_set_multicast(struct net_device *dev)
                     skge->flow_status == FLOW_STAT_SYMMETRIC)
                         genesis_add_filter(filter, pause_mc_addr);
 
-                for (i = 0; list && i < count; i++, list = list->next)
+                netdev_for_each_mc_addr(list, dev)
                         genesis_add_filter(filter, list->dmi_addr);
         }
 
@@ -2972,7 +2956,7 @@ static void yukon_set_multicast(struct net_device *dev)
         struct skge_port *skge = netdev_priv(dev);
         struct skge_hw *hw = skge->hw;
         int port = skge->port;
-        struct dev_mc_list *list = dev->mc_list;
+        struct dev_mc_list *list;
         int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND ||
                         skge->flow_status == FLOW_STAT_SYMMETRIC);
         u16 reg;
@@ -2987,16 +2971,15 @@ static void yukon_set_multicast(struct net_device *dev)
                 reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
         else if (dev->flags & IFF_ALLMULTI)     /* all multicast */
                 memset(filter, 0xff, sizeof(filter));
-        else if (dev->mc_count == 0 && !rx_pause)/* no multicast */
+        else if (netdev_mc_empty(dev) && !rx_pause)/* no multicast */
                 reg &= ~GM_RXCR_MCF_ENA;
         else {
-                int i;
                 reg |= GM_RXCR_MCF_ENA;
 
                 if (rx_pause)
                         yukon_add_filter(filter, pause_mc_addr);
 
-                for (i = 0; list && i < dev->mc_count; i++, list = list->next)
+                netdev_for_each_mc_addr(list, dev)
                         yukon_add_filter(filter, list->dmi_addr);
         }
 
@@ -3054,10 +3037,9 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
         struct sk_buff *skb;
         u16 len = control & BMU_BBC;
 
-        if (unlikely(netif_msg_rx_status(skge)))
-                printk(KERN_DEBUG PFX "%s: rx slot %td status 0x%x len %d\n",
-                       dev->name, e - skge->rx_ring.start,
-                       status, len);
+        netif_printk(skge, rx_status, KERN_DEBUG, skge->netdev,
+                     "rx slot %td status 0x%x len %d\n",
+                     e - skge->rx_ring.start, status, len);
 
         if (len > skge->rx_buf_size)
                 goto error;
@@ -3096,7 +3078,7 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
                                  pci_unmap_len(e, maplen),
                                  PCI_DMA_FROMDEVICE);
                 skb = e->skb;
-                prefetch(skb->data);
+                prefetch(skb->data);
                 skge_rx_setup(skge, e, nskb, skge->rx_buf_size);
         }
 
@@ -3111,10 +3093,9 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
         return skb;
 error:
 
-        if (netif_msg_rx_err(skge))
-                printk(KERN_DEBUG PFX "%s: rx err, slot %td control 0x%x status 0x%x\n",
-                       dev->name, e - skge->rx_ring.start,
-                       control, status);
+        netif_printk(skge, rx_err, KERN_DEBUG, skge->netdev,
+                     "rx err, slot %td control 0x%x status 0x%x\n",
+                     e - skge->rx_ring.start, control, status);
 
         if (skge->hw->chip_id == CHIP_ID_GENESIS) {
                 if (status & (XMR_FS_RUNT|XMR_FS_LNG_ERR))
@@ -3574,8 +3555,7 @@ static int skge_reset(struct skge_hw *hw)
                         hw->ram_offset = 0x80000;
                 } else
                         hw->ram_size = t8 * 512;
-        }
-        else if (t8 == 0)
+        } else if (t8 == 0)
                 hw->ram_size = 0x20000;
         else
                 hw->ram_size = t8 * 4096;
@@ -3729,7 +3709,7 @@ static int skge_device_event(struct notifier_block *unused,
                 goto done;
 
         skge = netdev_priv(dev);
-        switch(event) {
+        switch (event) {
         case NETDEV_CHANGENAME:
                 if (skge->debugfs) {
                         d = debugfs_rename(skge_debug, skge->debugfs,
@@ -3737,7 +3717,7 @@ static int skge_device_event(struct notifier_block *unused,
                         if (d)
                                 skge->debugfs = d;
                         else {
-                                pr_info(PFX "%s: rename failed\n", dev->name);
+                                netdev_info(dev, "rename failed\n");
                                 debugfs_remove(skge->debugfs);
                         }
                 }
@@ -3755,8 +3735,7 @@ static int skge_device_event(struct notifier_block *unused,
                                         skge_debug, dev,
                                         &skge_debug_fops);
                 if (!d || IS_ERR(d))
-                        pr_info(PFX "%s: debugfs create failed\n",
-                               dev->name);
+                        netdev_info(dev, "debugfs create failed\n");
                 else
                         skge->debugfs = d;
                 break;
@@ -3777,7 +3756,7 @@ static __init void skge_debug_init(void)
 
         ent = debugfs_create_dir("skge", NULL);
         if (!ent || IS_ERR(ent)) {
-                pr_info(PFX "debugfs create directory failed\n");
+                pr_info("debugfs create directory failed\n");
                 return;
         }
 
@@ -3885,9 +3864,7 @@ static void __devinit skge_show_addr(struct net_device *dev)
 {
         const struct skge_port *skge = netdev_priv(dev);
 
-        if (netif_msg_probe(skge))
-                printk(KERN_INFO PFX "%s: addr %pM\n",
-                       dev->name, dev->dev_addr);
+        netif_info(skge, probe, skge->netdev, "addr %pM\n", dev->dev_addr);
 }
 
 static int __devinit skge_probe(struct pci_dev *pdev,
@@ -3937,7 +3914,7 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 
         err = -ENOMEM;
         /* space for skge@pci:0000:04:00.0 */
-        hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:" )
+        hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:")
                      + strlen(pci_name(pdev)) + 1, GFP_KERNEL);
         if (!hw) {
                 dev_err(&pdev->dev, "cannot allocate hardware struct\n");
@@ -3960,9 +3937,10 @@ static int __devinit skge_probe(struct pci_dev *pdev,
         if (err)
                 goto err_out_iounmap;
 
-        printk(KERN_INFO PFX DRV_VERSION " addr 0x%llx irq %d chip %s rev %d\n",
-               (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
-               skge_board_name(hw), hw->chip_rev);
+        pr_info("%s addr 0x%llx irq %d chip %s rev %d\n",
+                DRV_VERSION,
+                (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
+                skge_board_name(hw), hw->chip_rev);
 
         dev = skge_devinit(hw, 0, using_dac);
         if (!dev)
@@ -4032,7 +4010,8 @@ static void __devexit skge_remove(struct pci_dev *pdev)
 
         flush_scheduled_work();
 
-        if ((dev1 = hw->dev[1]))
+        dev1 = hw->dev[1];
+        if (dev1)
                 unregister_netdev(dev1);
         dev0 = hw->dev[0];
         unregister_netdev(dev0);
@@ -4119,8 +4098,7 @@ static int skge_resume(struct pci_dev *pdev)
                         err = skge_up(dev);
 
                         if (err) {
-                                printk(KERN_ERR PFX "%s: could not up: %d\n",
-                                       dev->name, err);
+                                netdev_err(dev, "could not up: %d\n", err);
                                 dev_close(dev);
                                 goto out;
                         }