126 files changed, 3549 insertions, 2632 deletions

diff --git a/Documentation/isdn/00-INDEX b/Documentation/isdn/00-INDEX
index 9fee5f2e5c62..33543ac7d81f 100644
--- a/Documentation/isdn/00-INDEX
+++ b/Documentation/isdn/00-INDEX
@@ -2,28 +2,20 @@
         - this file (info on ISDN implementation for Linux)
 CREDITS
         - list of the kind folks that brought you this stuff.
+HiSax.cert
+        - information about the ITU approval certification of the HiSax driver.
 INTERFACE
-        - description of Linklevel and Hardwarelevel ISDN interface.
+        - description of isdn4linux Link Level and Hardware Level interfaces.
+INTERFACE.fax
+        - description of the fax subinterface of isdn4linux.
 README
         - general info on what you need and what to do for Linux ISDN.
 README.FAQ
         - general info for FAQ.
-README.audio
-        - info for running audio over ISDN.
-README.fax
-        - info for using Fax over ISDN.
-README.icn
-        - info on the ICN-ISDN-card and its driver.
 README.HiSax
         - info on the HiSax driver which replaces the old teles.
-README.hfc-pci
-        - info on hfc-pci based cards.
-README.pcbit
-        - info on the PCBIT-D ISDN adapter and driver.
-README.syncppp
-        - info on running Sync PPP over ISDN.
-syncPPP.FAQ
-        - frequently asked questions about running PPP over ISDN.
+README.audio
+        - info for running audio over ISDN.
 README.avmb1
         - info on driver for AVM-B1 ISDN card.
 README.act2000
@@ -34,10 +26,25 @@ README.concap
         - info on "CONCAP" encapsulation protocol interface used for X.25.
 README.diversion
         - info on module for isdn diversion services.
+README.fax
+        - info for using Fax over ISDN.
+README.gigaset
+        - info on the drivers for Siemens Gigaset ISDN adapters
+README.hfc-pci
+        - info on hfc-pci based cards.
+README.hysdn
+        - info on driver for Hypercope active HYSDN cards
+README.icn
+        - info on the ICN-ISDN-card and its driver.
+README.mISDN
+        - info on the Modular ISDN subsystem (mISDN)
+README.pcbit
+        - info on the PCBIT-D ISDN adapter and driver.
 README.sc
         - info on driver for Spellcaster cards.
+README.syncppp
+        - info on running Sync PPP over ISDN.
 README.x25
-    _ info for running X.25 over ISDN.
-README.hysdn
-        - info on driver for Hypercope active HYSDN cards
- 
+        - info on running X.25 over ISDN.
+syncPPP.FAQ
+        - frequently asked questions about running PPP over ISDN.
diff --git a/MAINTAINERS b/MAINTAINERS
index 36ea627dabc1..2dc197c362b3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4607,7 +4607,7 @@ F:	drivers/net/r6040.c
 RDS - RELIABLE DATAGRAM SOCKETS
 P:      Andy Grover
 M:      andy.grover@oracle.com
-L:      rds-devel@oss.oracle.com
+L:      rds-devel@oss.oracle.com (moderated for non-subscribers)
 S:      Supported
 F:      net/rds/
 
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index 1fc45431a620..d90177509bf6 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -2292,11 +2292,11 @@ static int rtl8139_close (struct net_device *dev)
    other threads or interrupts aren't messing with the 8139.  */
 static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        void __iomem *ioaddr = np->mmio_addr;
+        struct rtl8139_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
 
-        spin_lock_irq(&np->lock);
-        if (rtl_chip_info[np->chipset].flags & HasLWake) {
+        spin_lock_irq(&tp->lock);
+        if (rtl_chip_info[tp->chipset].flags & HasLWake) {
                 u8 cfg3 = RTL_R8 (Config3);
                 u8 cfg5 = RTL_R8 (Config5);
 
@@ -2317,7 +2317,7 @@ static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
                 if (cfg5 & Cfg5_BWF)
                         wol->wolopts |= WAKE_BCAST;
         }
-        spin_unlock_irq(&np->lock);
+        spin_unlock_irq(&tp->lock);
 }
 
 
@@ -2326,19 +2326,19 @@ static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
    aren't messing with the 8139.  */
 static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        void __iomem *ioaddr = np->mmio_addr;
+        struct rtl8139_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
         u32 support;
         u8 cfg3, cfg5;
 
-        support = ((rtl_chip_info[np->chipset].flags & HasLWake)
+        support = ((rtl_chip_info[tp->chipset].flags & HasLWake)
                    ? (WAKE_PHY | WAKE_MAGIC
                       | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
                    : 0);
         if (wol->wolopts & ~support)
                 return -EINVAL;
 
-        spin_lock_irq(&np->lock);
+        spin_lock_irq(&tp->lock);
         cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
         if (wol->wolopts & WAKE_PHY)
                 cfg3 |= Cfg3_LinkUp;
@@ -2359,87 +2359,87 @@ static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & WAKE_BCAST)
                 cfg5 |= Cfg5_BWF;
         RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
-        spin_unlock_irq(&np->lock);
+        spin_unlock_irq(&tp->lock);
 
         return 0;
 }
 
 static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
+        struct rtl8139_private *tp = netdev_priv(dev);
         strcpy(info->driver, DRV_NAME);
         strcpy(info->version, DRV_VERSION);
-        strcpy(info->bus_info, pci_name(np->pci_dev));
-        info->regdump_len = np->regs_len;
+        strcpy(info->bus_info, pci_name(tp->pci_dev));
+        info->regdump_len = tp->regs_len;
 }
 
 static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        spin_lock_irq(&np->lock);
-        mii_ethtool_gset(&np->mii, cmd);
-        spin_unlock_irq(&np->lock);
+        struct rtl8139_private *tp = netdev_priv(dev);
+        spin_lock_irq(&tp->lock);
+        mii_ethtool_gset(&tp->mii, cmd);
+        spin_unlock_irq(&tp->lock);
         return 0;
 }
 
 static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
+        struct rtl8139_private *tp = netdev_priv(dev);
         int rc;
-        spin_lock_irq(&np->lock);
-        rc = mii_ethtool_sset(&np->mii, cmd);
-        spin_unlock_irq(&np->lock);
+        spin_lock_irq(&tp->lock);
+        rc = mii_ethtool_sset(&tp->mii, cmd);
+        spin_unlock_irq(&tp->lock);
         return rc;
 }
 
 static int rtl8139_nway_reset(struct net_device *dev)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        return mii_nway_restart(&np->mii);
+        struct rtl8139_private *tp = netdev_priv(dev);
+        return mii_nway_restart(&tp->mii);
 }
 
 static u32 rtl8139_get_link(struct net_device *dev)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        return mii_link_ok(&np->mii);
+        struct rtl8139_private *tp = netdev_priv(dev);
+        return mii_link_ok(&tp->mii);
 }
 
 static u32 rtl8139_get_msglevel(struct net_device *dev)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        return np->msg_enable;
+        struct rtl8139_private *tp = netdev_priv(dev);
+        return tp->msg_enable;
 }
 
 static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
-        np->msg_enable = datum;
+        struct rtl8139_private *tp = netdev_priv(dev);
+        tp->msg_enable = datum;
 }
 
 static int rtl8139_get_regs_len(struct net_device *dev)
 {
-        struct rtl8139_private *np;
+        struct rtl8139_private *tp;
         /* TODO: we are too slack to do reg dumping for pio, for now */
         if (use_io)
                 return 0;
-        np = netdev_priv(dev);
-        return np->regs_len;
+        tp = netdev_priv(dev);
+        return tp->regs_len;
 }
 
 static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
 {
-        struct rtl8139_private *np;
+        struct rtl8139_private *tp;
 
         /* TODO: we are too slack to do reg dumping for pio, for now */
         if (use_io)
                 return;
-        np = netdev_priv(dev);
+        tp = netdev_priv(dev);
 
         regs->version = RTL_REGS_VER;
 
-        spin_lock_irq(&np->lock);
-        memcpy_fromio(regbuf, np->mmio_addr, regs->len);
-        spin_unlock_irq(&np->lock);
+        spin_lock_irq(&tp->lock);
+        memcpy_fromio(regbuf, tp->mmio_addr, regs->len);
+        spin_unlock_irq(&tp->lock);
 }
 
 static int rtl8139_get_sset_count(struct net_device *dev, int sset)
@@ -2454,12 +2454,12 @@ static int rtl8139_get_sset_count(struct net_device *dev, int sset)
 
 static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
+        struct rtl8139_private *tp = netdev_priv(dev);
 
-        data[0] = np->xstats.early_rx;
-        data[1] = np->xstats.tx_buf_mapped;
-        data[2] = np->xstats.tx_timeouts;
-        data[3] = np->xstats.rx_lost_in_ring;
+        data[0] = tp->xstats.early_rx;
+        data[1] = tp->xstats.tx_buf_mapped;
+        data[2] = tp->xstats.tx_timeouts;
+        data[3] = tp->xstats.rx_lost_in_ring;
 }
 
 static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
@@ -2486,15 +2486,15 @@ static const struct ethtool_ops rtl8139_ethtool_ops = {
 
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-        struct rtl8139_private *np = netdev_priv(dev);
+        struct rtl8139_private *tp = netdev_priv(dev);
         int rc;
 
         if (!netif_running(dev))
                 return -EINVAL;
 
-        spin_lock_irq(&np->lock);
-        rc = generic_mii_ioctl(&np->mii, if_mii(rq), cmd, NULL);
-        spin_unlock_irq(&np->lock);
+        spin_lock_irq(&tp->lock);
+        rc = generic_mii_ioctl(&tp->mii, if_mii(rq), cmd, NULL);
+        spin_unlock_irq(&tp->lock);
 
         return rc;
 }
diff --git a/drivers/net/8390.c b/drivers/net/8390.c
index ec3e22e6306f..21153dea8ebe 100644
--- a/drivers/net/8390.c
+++ b/drivers/net/8390.c
@@ -74,14 +74,8 @@ EXPORT_SYMBOL(ei_netdev_ops);
 struct net_device *__alloc_ei_netdev(int size)
 {
         struct net_device *dev = ____alloc_ei_netdev(size);
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        if (dev) {
-                dev->hard_start_xmit = ei_start_xmit;
-                dev->get_stats  = ei_get_stats;
-                dev->set_multicast_list = ei_set_multicast_list;
-                dev->tx_timeout = ei_tx_timeout;
-        }
-#endif
+        if (dev)
+                dev->netdev_ops = &ei_netdev_ops;
         return dev;
 }
 EXPORT_SYMBOL(__alloc_ei_netdev);
diff --git a/drivers/net/8390p.c b/drivers/net/8390p.c
index da863c91d1d0..cacdd86a27d0 100644
--- a/drivers/net/8390p.c
+++ b/drivers/net/8390p.c
@@ -79,14 +79,8 @@ EXPORT_SYMBOL(eip_netdev_ops);
 struct net_device *__alloc_eip_netdev(int size)
 {
         struct net_device *dev = ____alloc_ei_netdev(size);
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        if (dev) {
-                dev->hard_start_xmit = eip_start_xmit;
-                dev->get_stats  = eip_get_stats;
-                dev->set_multicast_list = eip_set_multicast_list;
-                dev->tx_timeout = eip_tx_timeout;
-        }
-#endif
+        if (dev)
+                dev->netdev_ops = &eip_netdev_ops;
         return dev;
 }
 EXPORT_SYMBOL(__alloc_eip_netdev);
@@ -97,16 +91,15 @@ void NS8390p_init(struct net_device *dev, int startp)
 }
 EXPORT_SYMBOL(NS8390p_init);
 
-#if defined(MODULE)
-
-int init_module(void)
+static int __init 8390p_init_module(void)
 {
         return 0;
 }
 
-void cleanup_module(void)
+static void __exit 8390p_cleanup_module(void)
 {
 }
 
-#endif /* MODULE */
+module_init(8390p_init_module);
+module_exit(8390p_cleanup_module);
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/atl1e/atl1e_main.c b/drivers/net/atl1e/atl1e_main.c
index fb57b750866b..adac06195c8f 100644
--- a/drivers/net/atl1e/atl1e_main.c
+++ b/drivers/net/atl1e/atl1e_main.c
@@ -1794,8 +1794,7 @@ static void atl1e_tx_map(struct atl1e_adapter *adapter,
                         memcpy(use_tpd, tpd, sizeof(struct atl1e_tpd_desc));
 
                         tx_buffer = atl1e_get_tx_buffer(adapter, use_tpd);
-                        if (tx_buffer->skb)
-                                BUG();
+                        BUG_ON(tx_buffer->skb);
 
                         tx_buffer->skb = NULL;
                         tx_buffer->length =
diff --git a/drivers/net/atlx/atl1.c b/drivers/net/atlx/atl1.c
index 0ab22540bf59..13f0bdc32449 100644
--- a/drivers/net/atlx/atl1.c
+++ b/drivers/net/atlx/atl1.c
@@ -2207,8 +2207,7 @@ static void atl1_tx_map(struct atl1_adapter *adapter, struct sk_buff *skb,
         nr_frags = skb_shinfo(skb)->nr_frags;
         next_to_use = atomic_read(&tpd_ring->next_to_use);
         buffer_info = &tpd_ring->buffer_info[next_to_use];
-        if (unlikely(buffer_info->skb))
-                BUG();
+        BUG_ON(buffer_info->skb);
         /* put skb in last TPD */
         buffer_info->skb = NULL;
 
@@ -2274,8 +2273,8 @@ static void atl1_tx_map(struct atl1_adapter *adapter, struct sk_buff *skb,
                         ATL1_MAX_TX_BUF_LEN;
                 for (i = 0; i < nseg; i++) {
                         buffer_info = &tpd_ring->buffer_info[next_to_use];
-                        if (unlikely(buffer_info->skb))
-                                BUG();
+                        BUG_ON(buffer_info->skb);
+
                         buffer_info->skb = NULL;
                         buffer_info->length = (buf_len > ATL1_MAX_TX_BUF_LEN) ?
                                 ATL1_MAX_TX_BUF_LEN : buf_len;
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 9b75aa630062..8994b03d80ac 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -637,6 +637,22 @@ static void be_rx_stats_update(struct be_adapter *adapter,
         stats->be_rx_bytes += pktsize;
 }
 
+static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso)
+{
+        u8 l4_cksm, ip_version, ipcksm, tcpf = 0, udpf = 0, ipv6_chk;
+
+        l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp);
+        ipcksm = AMAP_GET_BITS(struct amap_eth_rx_compl, ipcksm, rxcp);
+        ip_version = AMAP_GET_BITS(struct amap_eth_rx_compl, ip_version, rxcp);
+        if (ip_version) {
+                tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
+                udpf = AMAP_GET_BITS(struct amap_eth_rx_compl, udpf, rxcp);
+        }
+        ipv6_chk = (ip_version && (tcpf || udpf));
+
+        return ((l4_cksm && ipv6_chk && ipcksm) && cso) ? false : true;
+}
+
 static struct be_rx_page_info *
 get_rx_page_info(struct be_adapter *adapter, u16 frag_idx)
 {
@@ -752,9 +768,7 @@ static void be_rx_compl_process(struct be_adapter *adapter,
 {
         struct sk_buff *skb;
         u32 vtp, vid;
-        int l4_cksm;
 
-        l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp);
         vtp = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
 
         skb = netdev_alloc_skb(adapter->netdev, BE_HDR_LEN + NET_IP_ALIGN);
@@ -769,10 +783,10 @@ static void be_rx_compl_process(struct be_adapter *adapter,
 
         skb_fill_rx_data(adapter, skb, rxcp);
 
-        if (l4_cksm && adapter->rx_csum)
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        else
+        if (do_pkt_csum(rxcp, adapter->rx_csum))
                 skb->ip_summed = CHECKSUM_NONE;
+        else
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
 
         skb->truesize = skb->len + sizeof(struct sk_buff);
         skb->protocol = eth_type_trans(skb, adapter->netdev);
@@ -1626,10 +1640,12 @@ static void be_netdev_init(struct net_device *netdev)
 
         netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
                 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM |
-                NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
+                NETIF_F_IPV6_CSUM;
 
         netdev->flags |= IFF_MULTICAST;
 
+        adapter->rx_csum = true;
+
         BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
 
         SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 44d015f70d1c..9578a3dfac01 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1247,6 +1247,16 @@ static const struct ethtool_ops bmac_ethtool_ops = {
         .get_link               = ethtool_op_get_link,
 };
 
+static const struct net_device_ops bmac_netdev_ops = {
+        .ndo_open               = bmac_open,
+        .ndo_stop               = bmac_close,
+        .ndo_start_xmit         = bmac_output,
+        .ndo_set_multicast_list = bmac_set_multicast,
+        .ndo_set_mac_address    = bmac_set_address,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static int __devinit bmac_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         int j, rev, ret;
@@ -1308,12 +1318,8 @@ static int __devinit bmac_probe(struct macio_dev *mdev, const struct of_device_i
         bmac_enable_and_reset_chip(dev);
         bmwrite(dev, INTDISABLE, DisableAll);
 
-        dev->open = bmac_open;
-        dev->stop = bmac_close;
+        dev->netdev_ops = &bmac_netdev_ops;
         dev->ethtool_ops = &bmac_ethtool_ops;
-        dev->hard_start_xmit = bmac_output;
-        dev->set_multicast_list = bmac_set_multicast;
-        dev->set_mac_address = bmac_set_address;
 
         bmac_get_station_address(dev, addr);
         if (bmac_verify_checksum(dev) != 0)
diff --git a/drivers/net/chelsio/sge.c b/drivers/net/chelsio/sge.c
index 58f6fc055f6a..5e97a1a71d88 100644
--- a/drivers/net/chelsio/sge.c
+++ b/drivers/net/chelsio/sge.c
@@ -1149,8 +1149,8 @@ static inline void write_tx_desc(struct cmdQ_e *e, dma_addr_t mapping,
                                  unsigned int len, unsigned int gen,
                                  unsigned int eop)
 {
-        if (unlikely(len > SGE_TX_DESC_MAX_PLEN))
-                BUG();
+        BUG_ON(len > SGE_TX_DESC_MAX_PLEN);
+
         e->addr_lo = (u32)mapping;
         e->addr_hi = (u64)mapping >> 32;
         e->len_gen = V_CMD_LEN(len) | V_CMD_GEN1(gen);
diff --git a/drivers/net/cpmac.c b/drivers/net/cpmac.c
index 3f476c7c0736..af305c0b34d1 100644
--- a/drivers/net/cpmac.c
+++ b/drivers/net/cpmac.c
@@ -1093,6 +1093,19 @@ static int cpmac_stop(struct net_device *dev)
         return 0;
 }
 
+static const struct net_device_ops cpmac_netdev_ops = {
+        .ndo_open               = cpmac_open,
+        .ndo_stop               = cpmac_stop,
+        .ndo_start_xmit         = cpmac_start_xmit,
+        .ndo_tx_timeout         = cpmac_tx_timeout,
+        .ndo_set_multicast_list = cpmac_set_multicast_list,
+        .ndo_so_ioctl           = cpmac_ioctl,
+        .ndo_set_config         = cpmac_config,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int external_switch;
 
 static int __devinit cpmac_probe(struct platform_device *pdev)
@@ -1143,14 +1156,8 @@ static int __devinit cpmac_probe(struct platform_device *pdev)
 
         dev->irq = platform_get_irq_byname(pdev, "irq");
 
-        dev->open               = cpmac_open;
-        dev->stop               = cpmac_stop;
-        dev->set_config         = cpmac_config;
-        dev->hard_start_xmit    = cpmac_start_xmit;
-        dev->do_ioctl           = cpmac_ioctl;
-        dev->set_multicast_list = cpmac_set_multicast_list;
-        dev->tx_timeout         = cpmac_tx_timeout;
-        dev->ethtool_ops        = &cpmac_ethtool_ops;
+        dev->netdev_ops = &cpmac_netdev_ops;
+        dev->ethtool_ops = &cpmac_ethtool_ops;
 
         netif_napi_add(dev, &priv->napi, cpmac_poll, 64);
 
diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h
index 714df2b675e6..322434ac42fc 100644
--- a/drivers/net/cxgb3/adapter.h
+++ b/drivers/net/cxgb3/adapter.h
@@ -195,7 +195,7 @@ struct sge_qset {		/* an SGE queue set */
         struct sge_rspq rspq;
         struct sge_fl fl[SGE_RXQ_PER_SET];
         struct sge_txq txq[SGE_TXQ_PER_SET];
-        struct napi_gro_fraginfo lro_frag_tbl;
+        int nomem;
         int lro_enabled;
         void *lro_va;
         struct net_device *netdev;
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index 26d3587f3399..73d569e758ec 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -654,7 +654,8 @@ static void t3_reset_qset(struct sge_qset *q)
         q->txq_stopped = 0;
         q->tx_reclaim_timer.function = NULL; /* for t3_stop_sge_timers() */
         q->rx_reclaim_timer.function = NULL;
-        q->lro_frag_tbl.nr_frags = q->lro_frag_tbl.len = 0;
+        q->nomem = 0;
+        napi_free_frags(&q->napi);
 }
 
 
@@ -2074,20 +2075,19 @@ static void lro_add_page(struct adapter *adap, struct sge_qset *qs,
                          struct sge_fl *fl, int len, int complete)
 {
         struct rx_sw_desc *sd = &fl->sdesc[fl->cidx];
+        struct sk_buff *skb = NULL;
         struct cpl_rx_pkt *cpl;
-        struct skb_frag_struct *rx_frag = qs->lro_frag_tbl.frags;
-        int nr_frags = qs->lro_frag_tbl.nr_frags;
-        int frag_len = qs->lro_frag_tbl.len;
+        struct skb_frag_struct *rx_frag;
+        int nr_frags;
         int offset = 0;
 
-        if (!nr_frags) {
-                offset = 2 + sizeof(struct cpl_rx_pkt);
-                qs->lro_va = cpl = sd->pg_chunk.va + 2;
+        if (!qs->nomem) {
+                skb = napi_get_frags(&qs->napi);
+                qs->nomem = !skb;
         }
 
         fl->credits--;
 
-        len -= offset;
         pci_dma_sync_single_for_cpu(adap->pdev,
                                     pci_unmap_addr(sd, dma_addr),
                                     fl->buf_size - SGE_PG_RSVD,
@@ -2100,21 +2100,38 @@ static void lro_add_page(struct adapter *adap, struct sge_qset *qs,
                                fl->alloc_size,
                                PCI_DMA_FROMDEVICE);
 
+        if (!skb) {
+                put_page(sd->pg_chunk.page);
+                if (complete)
+                        qs->nomem = 0;
+                return;
+        }
+
+        rx_frag = skb_shinfo(skb)->frags;
+        nr_frags = skb_shinfo(skb)->nr_frags;
+
+        if (!nr_frags) {
+                offset = 2 + sizeof(struct cpl_rx_pkt);
+                qs->lro_va = sd->pg_chunk.va + 2;
+        }
+        len -= offset;
+
         prefetch(qs->lro_va);
 
         rx_frag += nr_frags;
         rx_frag->page = sd->pg_chunk.page;
         rx_frag->page_offset = sd->pg_chunk.offset + offset;
         rx_frag->size = len;
-        frag_len += len;
-        qs->lro_frag_tbl.nr_frags++;
-        qs->lro_frag_tbl.len = frag_len;
 
+        skb->len += len;
+        skb->data_len += len;
+        skb->truesize += len;
+        skb_shinfo(skb)->nr_frags++;
 
         if (!complete)
                 return;
 
-        qs->lro_frag_tbl.ip_summed = CHECKSUM_UNNECESSARY;
+        skb->ip_summed = CHECKSUM_UNNECESSARY;
         cpl = qs->lro_va;
 
         if (unlikely(cpl->vlan_valid)) {
@@ -2123,15 +2140,11 @@ static void lro_add_page(struct adapter *adap, struct sge_qset *qs,
                 struct vlan_group *grp = pi->vlan_grp;
 
                 if (likely(grp != NULL)) {
-                        vlan_gro_frags(&qs->napi, grp, ntohs(cpl->vlan),
-                                       &qs->lro_frag_tbl);
-                        goto out;
+                        vlan_gro_frags(&qs->napi, grp, ntohs(cpl->vlan));
+                        return;
                 }
         }
-        napi_gro_frags(&qs->napi, &qs->lro_frag_tbl);
-
-out:
-        qs->lro_frag_tbl.nr_frags = qs->lro_frag_tbl.len = 0;
+        napi_gro_frags(&qs->napi);
 }
 
 /**
@@ -2300,8 +2313,6 @@ no_mem:
                         if (fl->use_pages) {
                                 void *addr = fl->sdesc[fl->cidx].pg_chunk.va;
 
-                                prefetch(&qs->lro_frag_tbl);
-
                                 prefetch(addr);
 #if L1_CACHE_BYTES < 128
                                 prefetch(addr + L1_CACHE_BYTES);
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index d8350860c0f8..e402e91bf188 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -1170,6 +1170,21 @@ dm9000_stop(struct net_device *ndev)
         return 0;
 }
 
+static const struct net_device_ops dm9000_netdev_ops = {
+        .ndo_open               = dm9000_open,
+        .ndo_stop               = dm9000_stop,
+        .ndo_start_xmit         = dm9000_start_xmit,
+        .ndo_tx_timeout         = dm9000_timeout,
+        .ndo_set_multicast_list = dm9000_hash_table,
+        .ndo_do_ioctl           = dm9000_ioctl,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = dm9000_poll_controller,
+#endif
+};
+
 #define res_size(_r) (((_r)->end - (_r)->start) + 1)
 
 /*
@@ -1339,18 +1354,9 @@ dm9000_probe(struct platform_device *pdev)
         /* driver system function */
         ether_setup(ndev);
 
-        ndev->open               = &dm9000_open;
-        ndev->hard_start_xmit    = &dm9000_start_xmit;
-        ndev->tx_timeout         = &dm9000_timeout;
-        ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
-        ndev->stop               = &dm9000_stop;
-        ndev->set_multicast_list = &dm9000_hash_table;
-        ndev->ethtool_ops        = &dm9000_ethtool_ops;
-        ndev->do_ioctl           = &dm9000_ioctl;
-
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        ndev->poll_controller    = &dm9000_poll_controller;
-#endif
+        ndev->netdev_ops        = &dm9000_netdev_ops;
+        ndev->watchdog_timeo    = msecs_to_jiffies(watchdog);
+        ndev->ethtool_ops       = &dm9000_ethtool_ops;
 
         db->msg_enable       = NETIF_MSG_LINK;
         db->mii.phy_id_mask  = 0x1f;
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 6a46ceed9436..71d4fe15976a 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -498,6 +498,8 @@ int e1000_up(struct e1000_adapter *adapter)
 
         e1000_irq_enable(adapter);
 
+        netif_wake_queue(adapter->netdev);
+
         /* fire a link change interrupt to start the watchdog */
         ew32(ICS, E1000_ICS_LSC);
         return 0;
@@ -1234,15 +1236,14 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
             !e1000_check_mng_mode(hw))
                 e1000_get_hw_control(adapter);
 
-        /* tell the stack to leave us alone until e1000_open() is called */
-        netif_carrier_off(netdev);
-        netif_stop_queue(netdev);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
                 goto err_register;
 
+        /* carrier off reporting is important to ethtool even BEFORE open */
+        netif_carrier_off(netdev);
+
         DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
 
         cards_found++;
@@ -1441,6 +1442,8 @@ static int e1000_open(struct net_device *netdev)
         if (test_bit(__E1000_TESTING, &adapter->flags))
                 return -EBUSY;
 
+        netif_carrier_off(netdev);
+
         /* allocate transmit descriptors */
         err = e1000_setup_all_tx_resources(adapter);
         if (err)
@@ -2590,7 +2593,6 @@ static void e1000_watchdog(unsigned long data)
                         ew32(TCTL, tctl);
 
                         netif_carrier_on(netdev);
-                        netif_wake_queue(netdev);
                         mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
                         adapter->smartspeed = 0;
                 } else {
@@ -2607,7 +2609,6 @@ static void e1000_watchdog(unsigned long data)
                         printk(KERN_INFO "e1000: %s NIC Link is Down\n",
                                netdev->name);
                         netif_carrier_off(netdev);
-                        netif_stop_queue(netdev);
                         mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
 
                         /* 80003ES2LAN workaround--
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index ca82f19a7ed1..da6b37e05bea 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -2826,6 +2826,8 @@ int e1000e_up(struct e1000_adapter *adapter)
                 e1000_configure_msix(adapter);
         e1000_irq_enable(adapter);
 
+        netif_wake_queue(adapter->netdev);
+
         /* fire a link change interrupt to start the watchdog */
         ew32(ICS, E1000_ICS_LSC);
         return 0;
@@ -2848,7 +2850,7 @@ void e1000e_down(struct e1000_adapter *adapter)
         ew32(RCTL, rctl & ~E1000_RCTL_EN);
         /* flush and sleep below */
 
-        netif_tx_stop_all_queues(netdev);
+        netif_stop_queue(netdev);
 
         /* disable transmits in the hardware */
         tctl = er32(TCTL);
@@ -3072,6 +3074,8 @@ static int e1000_open(struct net_device *netdev)
         if (test_bit(__E1000_TESTING, &adapter->state))
                 return -EBUSY;
 
+        netif_carrier_off(netdev);
+
         /* allocate transmit descriptors */
         err = e1000e_setup_tx_resources(adapter);
         if (err)
@@ -3128,7 +3132,7 @@ static int e1000_open(struct net_device *netdev)
 
         e1000_irq_enable(adapter);
 
-        netif_tx_start_all_queues(netdev);
+        netif_start_queue(netdev);
 
         /* fire a link status change interrupt to start the watchdog */
         ew32(ICS, E1000_ICS_LSC);
@@ -3598,7 +3602,6 @@ static void e1000_watchdog_task(struct work_struct *work)
                                 phy->ops.cfg_on_link_up(hw);
 
                         netif_carrier_on(netdev);
-                        netif_tx_wake_all_queues(netdev);
 
                         if (!test_bit(__E1000_DOWN, &adapter->state))
                                 mod_timer(&adapter->phy_info_timer,
@@ -3612,7 +3615,6 @@ static void e1000_watchdog_task(struct work_struct *work)
                         printk(KERN_INFO "e1000e: %s NIC Link is Down\n",
                                adapter->netdev->name);
                         netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
                         if (!test_bit(__E1000_DOWN, &adapter->state))
                                 mod_timer(&adapter->phy_info_timer,
                                           round_jiffies(jiffies + 2 * HZ));
@@ -5037,15 +5039,14 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         if (!(adapter->flags & FLAG_HAS_AMT))
                 e1000_get_hw_control(adapter);
 
-        /* tell the stack to leave us alone until e1000_open() is called */
-        netif_carrier_off(netdev);
-        netif_tx_stop_all_queues(netdev);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
                 goto err_register;
 
+        /* carrier off reporting is important to ethtool even BEFORE open */
+        netif_carrier_off(netdev);
+
         e1000_print_device_info(adapter);
 
         return 0;
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 682e7f0b5581..28db6919c526 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -86,8 +86,7 @@ static unsigned char	fec_mac_default[] = {
 #endif
 #endif /* CONFIG_M5272 */
 
-/* Forward declarations of some structures to support different PHYs
-*/
+/* Forward declarations of some structures to support different PHYs */
 
 typedef struct {
         uint mii_data;
@@ -123,8 +122,7 @@ typedef struct {
 #error "FEC: descriptor ring size constants too large"
 #endif
 
-/* Interrupt events/masks.
-*/
+/* Interrupt events/masks. */
 #define FEC_ENET_HBERR  ((uint)0x80000000)      /* Heartbeat error */
 #define FEC_ENET_BABR   ((uint)0x40000000)      /* Babbling receiver */
 #define FEC_ENET_BABT   ((uint)0x20000000)      /* Babbling transmitter */
@@ -165,7 +163,7 @@ typedef struct {
  */
 struct fec_enet_private {
         /* Hardware registers of the FEC device */
-        volatile fec_t  *hwp;
+        void __iomem *hwp;
 
         struct net_device *netdev;
 
@@ -174,16 +172,20 @@ struct fec_enet_private {
         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
         unsigned char *tx_bounce[TX_RING_SIZE];
         struct  sk_buff* tx_skbuff[TX_RING_SIZE];
+        struct  sk_buff* rx_skbuff[RX_RING_SIZE];
         ushort  skb_cur;
         ushort  skb_dirty;
 
-        /* CPM dual port RAM relative addresses.
-        */
+        /* CPM dual port RAM relative addresses */
         dma_addr_t      bd_dma;
-        cbd_t   *rx_bd_base;            /* Address of Rx and Tx buffers. */
-        cbd_t   *tx_bd_base;
-        cbd_t   *cur_rx, *cur_tx;               /* The next free ring entry */
-        cbd_t   *dirty_tx;      /* The ring entries to be free()ed. */
+        /* Address of Rx and Tx buffers */
+        struct bufdesc  *rx_bd_base;
+        struct bufdesc  *tx_bd_base;
+        /* The next free ring entry */
+        struct bufdesc  *cur_rx, *cur_tx; 
+        /* The ring entries to be free()ed */
+        struct bufdesc  *dirty_tx;
+
         uint    tx_full;
         /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
         spinlock_t hw_lock;
@@ -209,17 +211,13 @@ struct fec_enet_private {
         int     full_duplex;
 };
 
-static int fec_enet_open(struct net_device *dev);
-static int fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static void fec_enet_mii(struct net_device *dev);
 static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
 static void fec_enet_tx(struct net_device *dev);
 static void fec_enet_rx(struct net_device *dev);
 static int fec_enet_close(struct net_device *dev);
-static void set_multicast_list(struct net_device *dev);
 static void fec_restart(struct net_device *dev, int duplex);
 static void fec_stop(struct net_device *dev);
-static void fec_set_mac_address(struct net_device *dev);
 
 
 /* MII processing.  We keep this as simple as possible.  Requests are
@@ -241,19 +239,16 @@ static mii_list_t	*mii_tail;
 static int      mii_queue(struct net_device *dev, int request,
                                 void (*func)(uint, struct net_device *));
 
-/* Make MII read/write commands for the FEC.
-*/
+/* Make MII read/write commands for the FEC */
 #define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
 #define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | \
                                                 (VAL & 0xffff))
 #define mk_mii_end      0
 
-/* Transmitter timeout.
-*/
-#define TX_TIMEOUT (2*HZ)
+/* Transmitter timeout */
+#define TX_TIMEOUT (2 * HZ)
 
-/* Register definitions for the PHY.
-*/
+/* Register definitions for the PHY */
 
 #define MII_REG_CR          0  /* Control Register                         */
 #define MII_REG_SR          1  /* Status Register                          */
@@ -288,15 +283,11 @@ static int	mii_queue(struct net_device *dev, int request,
 static int
 fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct fec_enet_private *fep;
-        volatile fec_t  *fecp;
-        volatile cbd_t  *bdp;
+        struct fec_enet_private *fep = netdev_priv(dev);
+        struct bufdesc *bdp;
         unsigned short  status;
         unsigned long flags;
 
-        fep = netdev_priv(dev);
-        fecp = (volatile fec_t*)dev->base_addr;
-
         if (!fep->link) {
                 /* Link is down or autonegotiation is in progress. */
                 return 1;
@@ -307,7 +298,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         bdp = fep->cur_tx;
 
         status = bdp->cbd_sc;
-#ifndef final_version
+
         if (status & BD_ENET_TX_READY) {
                 /* Ooops.  All transmit buffers are full.  Bail out.
                  * This should not happen, since dev->tbusy should be set.
@@ -316,21 +307,18 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 spin_unlock_irqrestore(&fep->hw_lock, flags);
                 return 1;
         }
-#endif
 
-        /* Clear all of the status flags.
-         */
+        /* Clear all of the status flags */
         status &= ~BD_ENET_TX_STATS;
 
-        /* Set buffer length and buffer pointer.
-        */
+        /* Set buffer length and buffer pointer */
         bdp->cbd_bufaddr = __pa(skb->data);
         bdp->cbd_datlen = skb->len;
 
         /*
-         *      On some FEC implementations data must be aligned on
-         *      4-byte boundaries. Use bounce buffers to copy data
-         *      and get it aligned. Ugh.
+         * On some FEC implementations data must be aligned on
+         * 4-byte boundaries. Use bounce buffers to copy data
+         * and get it aligned. Ugh.
          */
         if (bdp->cbd_bufaddr & FEC_ALIGNMENT) {
                 unsigned int index;
@@ -339,8 +327,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
         }
 
-        /* Save skb pointer.
-        */
+        /* Save skb pointer */
         fep->tx_skbuff[fep->skb_cur] = skb;
 
         dev->stats.tx_bytes += skb->len;
@@ -349,13 +336,12 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         /* Push the data cache so the CPM does not get stale memory
          * data.
          */
-        dma_sync_single(NULL, bdp->cbd_bufaddr,
-                        bdp->cbd_datlen, DMA_TO_DEVICE);
+        bdp->cbd_bufaddr = dma_map_single(&dev->dev, skb->data,
+                        FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
 
         /* Send it on its way.  Tell FEC it's ready, interrupt when done,
          * it's the last BD of the frame, and to put the CRC on the end.
          */
-
         status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
                         | BD_ENET_TX_LAST | BD_ENET_TX_TC);
         bdp->cbd_sc = status;
@@ -363,22 +349,20 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         dev->trans_start = jiffies;
 
         /* Trigger transmission start */
-        fecp->fec_x_des_active = 0;
+        writel(0, fep->hwp + FEC_X_DES_ACTIVE);
 
-        /* If this was the last BD in the ring, start at the beginning again.
-        */
-        if (status & BD_ENET_TX_WRAP) {
+        /* If this was the last BD in the ring, start at the beginning again. */
+        if (status & BD_ENET_TX_WRAP)
                 bdp = fep->tx_bd_base;
-        } else {
+        else
                 bdp++;
-        }
 
         if (bdp == fep->dirty_tx) {
                 fep->tx_full = 1;
                 netif_stop_queue(dev);
         }
 
-        fep->cur_tx = (cbd_t *)bdp;
+        fep->cur_tx = bdp;
 
         spin_unlock_irqrestore(&fep->hw_lock, flags);
 
@@ -390,75 +374,33 @@ fec_timeout(struct net_device *dev)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
 
-        printk("%s: transmit timed out.\n", dev->name);
         dev->stats.tx_errors++;
-#ifndef final_version
-        {
-        int     i;
-        cbd_t   *bdp;
-
-        printk("Ring data dump: cur_tx %lx%s, dirty_tx %lx cur_rx: %lx\n",
-               (unsigned long)fep->cur_tx, fep->tx_full ? " (full)" : "",
-               (unsigned long)fep->dirty_tx,
-               (unsigned long)fep->cur_rx);
-
-        bdp = fep->tx_bd_base;
-        printk(" tx: %u buffers\n",  TX_RING_SIZE);
-        for (i = 0 ; i < TX_RING_SIZE; i++) {
-                printk("  %08x: %04x %04x %08x\n",
-                       (uint) bdp,
-                       bdp->cbd_sc,
-                       bdp->cbd_datlen,
-                       (int) bdp->cbd_bufaddr);
-                bdp++;
-        }
 
-        bdp = fep->rx_bd_base;
-        printk(" rx: %lu buffers\n",  (unsigned long) RX_RING_SIZE);
-        for (i = 0 ; i < RX_RING_SIZE; i++) {
-                printk("  %08x: %04x %04x %08x\n",
-                       (uint) bdp,
-                       bdp->cbd_sc,
-                       bdp->cbd_datlen,
-                       (int) bdp->cbd_bufaddr);
-                bdp++;
-        }
-        }
-#endif
         fec_restart(dev, fep->full_duplex);
         netif_wake_queue(dev);
 }
 
-/* The interrupt handler.
- * This is called from the MPC core interrupt.
- */
 static irqreturn_t
 fec_enet_interrupt(int irq, void * dev_id)
 {
         struct  net_device *dev = dev_id;
-        volatile fec_t  *fecp;
+        struct fec_enet_private *fep = netdev_priv(dev);
         uint    int_events;
         irqreturn_t ret = IRQ_NONE;
 
-        fecp = (volatile fec_t*)dev->base_addr;
-
-        /* Get the interrupt events that caused us to be here.
-        */
         do {
-                int_events = fecp->fec_ievent;
-                fecp->fec_ievent = int_events;
+                int_events = readl(fep->hwp + FEC_IEVENT);
+                writel(int_events, fep->hwp + FEC_IEVENT);
 
-                /* Handle receive event in its own function.
-                 */
                 if (int_events & FEC_ENET_RXF) {
                         ret = IRQ_HANDLED;
                         fec_enet_rx(dev);
                 }
 
                 /* Transmit OK, or non-fatal error. Update the buffer
-                   descriptors. FEC handles all errors, we just discover
-                   them as part of the transmit process.
-                */
+                 * descriptors. FEC handles all errors, we just discover
+                 * them as part of the transmit process.
+                 */
                 if (int_events & FEC_ENET_TXF) {
                         ret = IRQ_HANDLED;
                         fec_enet_tx(dev);
@@ -479,7 +421,7 @@ static void
 fec_enet_tx(struct net_device *dev)
 {
         struct  fec_enet_private *fep;
-        volatile cbd_t  *bdp;
+        struct bufdesc *bdp;
         unsigned short status;
         struct  sk_buff *skb;
 
@@ -488,7 +430,11 @@ fec_enet_tx(struct net_device *dev)
         bdp = fep->dirty_tx;
 
         while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
-                if (bdp == fep->cur_tx && fep->tx_full == 0) break;
+                if (bdp == fep->cur_tx && fep->tx_full == 0)
+                        break;
+
+                dma_unmap_single(&dev->dev, bdp->cbd_bufaddr, FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
+                bdp->cbd_bufaddr = 0;
 
                 skb = fep->tx_skbuff[fep->skb_dirty];
                 /* Check for errors. */
@@ -510,31 +456,27 @@ fec_enet_tx(struct net_device *dev)
                         dev->stats.tx_packets++;
                 }
 
-#ifndef final_version
                 if (status & BD_ENET_TX_READY)
                         printk("HEY! Enet xmit interrupt and TX_READY.\n");
-#endif
+
                 /* Deferred means some collisions occurred during transmit,
                  * but we eventually sent the packet OK.
                  */
                 if (status & BD_ENET_TX_DEF)
                         dev->stats.collisions++;
 
-                /* Free the sk buffer associated with this last transmit.
-                 */
+                /* Free the sk buffer associated with this last transmit */
                 dev_kfree_skb_any(skb);
                 fep->tx_skbuff[fep->skb_dirty] = NULL;
                 fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
 
-                /* Update pointer to next buffer descriptor to be transmitted.
-                 */
+                /* Update pointer to next buffer descriptor to be transmitted */
                 if (status & BD_ENET_TX_WRAP)
                         bdp = fep->tx_bd_base;
                 else
                         bdp++;
 
-                /* Since we have freed up a buffer, the ring is no longer
-                 * full.
+                /* Since we have freed up a buffer, the ring is no longer full
                  */
                 if (fep->tx_full) {
                         fep->tx_full = 0;
@@ -542,7 +484,7 @@ fec_enet_tx(struct net_device *dev)
                                 netif_wake_queue(dev);
                 }
         }
-        fep->dirty_tx = (cbd_t *)bdp;
+        fep->dirty_tx = bdp;
         spin_unlock_irq(&fep->hw_lock);
 }
 
@@ -555,9 +497,8 @@ fec_enet_tx(struct net_device *dev)
 static void
 fec_enet_rx(struct net_device *dev)
 {
-        struct  fec_enet_private *fep;
-        volatile fec_t  *fecp;
-        volatile cbd_t *bdp;
+        struct  fec_enet_private *fep = netdev_priv(dev);
+        struct bufdesc *bdp;
         unsigned short status;
         struct  sk_buff *skb;
         ushort  pkt_len;
@@ -567,9 +508,6 @@ fec_enet_rx(struct net_device *dev)
         flush_cache_all();
 #endif
 
-        fep = netdev_priv(dev);
-        fecp = (volatile fec_t*)dev->base_addr;
-
         spin_lock_irq(&fep->hw_lock);
 
         /* First, grab all of the stats for the incoming packet.
@@ -577,143 +515,121 @@ fec_enet_rx(struct net_device *dev)
          */
         bdp = fep->cur_rx;
 
-while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
+        while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
 
-#ifndef final_version
-        /* Since we have allocated space to hold a complete frame,
-         * the last indicator should be set.
-         */
-        if ((status & BD_ENET_RX_LAST) == 0)
-                printk("FEC ENET: rcv is not +last\n");
-#endif
+                /* Since we have allocated space to hold a complete frame,
+                 * the last indicator should be set.
+                 */
+                if ((status & BD_ENET_RX_LAST) == 0)
+                        printk("FEC ENET: rcv is not +last\n");
 
-        if (!fep->opened)
-                goto rx_processing_done;
+                if (!fep->opened)
+                        goto rx_processing_done;
 
-        /* Check for errors. */
-        if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
+                /* Check for errors. */
+                if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
                            BD_ENET_RX_CR | BD_ENET_RX_OV)) {
-                dev->stats.rx_errors++;
-                if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
-                /* Frame too long or too short. */
-                        dev->stats.rx_length_errors++;
+                        dev->stats.rx_errors++;
+                        if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
+                                /* Frame too long or too short. */
+                                dev->stats.rx_length_errors++;
+                        }
+                        if (status & BD_ENET_RX_NO)     /* Frame alignment */
+                                dev->stats.rx_frame_errors++;
+                        if (status & BD_ENET_RX_CR)     /* CRC Error */
+                                dev->stats.rx_crc_errors++;
+                        if (status & BD_ENET_RX_OV)     /* FIFO overrun */
+                                dev->stats.rx_fifo_errors++;
                 }
-                if (status & BD_ENET_RX_NO)     /* Frame alignment */
+
+                /* Report late collisions as a frame error.
+                 * On this error, the BD is closed, but we don't know what we
+                 * have in the buffer.  So, just drop this frame on the floor.
+                 */
+                if (status & BD_ENET_RX_CL) {
+                        dev->stats.rx_errors++;
                         dev->stats.rx_frame_errors++;
-                if (status & BD_ENET_RX_CR)     /* CRC Error */
-                        dev->stats.rx_crc_errors++;
-                if (status & BD_ENET_RX_OV)     /* FIFO overrun */
-                        dev->stats.rx_fifo_errors++;
-        }
+                        goto rx_processing_done;
+                }
 
-        /* Report late collisions as a frame error.
-         * On this error, the BD is closed, but we don't know what we
-         * have in the buffer.  So, just drop this frame on the floor.
-         */
-        if (status & BD_ENET_RX_CL) {
-                dev->stats.rx_errors++;
-                dev->stats.rx_frame_errors++;
-                goto rx_processing_done;
-        }
+                /* Process the incoming frame. */
+                dev->stats.rx_packets++;
+                pkt_len = bdp->cbd_datlen;
+                dev->stats.rx_bytes += pkt_len;
+                data = (__u8*)__va(bdp->cbd_bufaddr);
 
-        /* Process the incoming frame.
-         */
-        dev->stats.rx_packets++;
-        pkt_len = bdp->cbd_datlen;
-        dev->stats.rx_bytes += pkt_len;
-        data = (__u8*)__va(bdp->cbd_bufaddr);
-
-        dma_sync_single(NULL, (unsigned long)__pa(data),
-                        pkt_len - 4, DMA_FROM_DEVICE);
-
-        /* This does 16 byte alignment, exactly what we need.
-         * The packet length includes FCS, but we don't want to
-         * include that when passing upstream as it messes up
-         * bridging applications.
-         */
-        skb = dev_alloc_skb(pkt_len-4);
+                dma_unmap_single(NULL, bdp->cbd_bufaddr, bdp->cbd_datlen,
+                                DMA_FROM_DEVICE);
 
-        if (skb == NULL) {
-                printk("%s: Memory squeeze, dropping packet.\n", dev->name);
-                dev->stats.rx_dropped++;
-        } else {
-                skb_put(skb,pkt_len-4); /* Make room */
-                skb_copy_to_linear_data(skb, data, pkt_len-4);
-                skb->protocol=eth_type_trans(skb,dev);
-                netif_rx(skb);
-        }
-  rx_processing_done:
+                /* This does 16 byte alignment, exactly what we need.
+                 * The packet length includes FCS, but we don't want to
+                 * include that when passing upstream as it messes up
+                 * bridging applications.
+                 */
+                skb = dev_alloc_skb(pkt_len - 4 + NET_IP_ALIGN);
 
-        /* Clear the status flags for this buffer.
-        */
-        status &= ~BD_ENET_RX_STATS;
+                if (unlikely(!skb)) {
+                        printk("%s: Memory squeeze, dropping packet.\n",
+                                        dev->name);
+                        dev->stats.rx_dropped++;
+                } else {
+                        skb_reserve(skb, NET_IP_ALIGN);
+                        skb_put(skb, pkt_len - 4);      /* Make room */
+                        skb_copy_to_linear_data(skb, data, pkt_len - 4);
+                        skb->protocol = eth_type_trans(skb, dev);
+                        netif_rx(skb);
+                }
 
-        /* Mark the buffer empty.
-        */
-        status |= BD_ENET_RX_EMPTY;
-        bdp->cbd_sc = status;
+                bdp->cbd_bufaddr = dma_map_single(NULL, data, bdp->cbd_datlen,
+                        DMA_FROM_DEVICE);
+rx_processing_done:
+                /* Clear the status flags for this buffer */
+                status &= ~BD_ENET_RX_STATS;
 
-        /* Update BD pointer to next entry.
-        */
-        if (status & BD_ENET_RX_WRAP)
-                bdp = fep->rx_bd_base;
-        else
-                bdp++;
+                /* Mark the buffer empty */
+                status |= BD_ENET_RX_EMPTY;
+                bdp->cbd_sc = status;
 
-#if 1
-        /* Doing this here will keep the FEC running while we process
-         * incoming frames.  On a heavily loaded network, we should be
-         * able to keep up at the expense of system resources.
-         */
-        fecp->fec_r_des_active = 0;
-#endif
-   } /* while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) */
-        fep->cur_rx = (cbd_t *)bdp;
-
-#if 0
-        /* Doing this here will allow us to process all frames in the
-         * ring before the FEC is allowed to put more there.  On a heavily
-         * loaded network, some frames may be lost.  Unfortunately, this
-         * increases the interrupt overhead since we can potentially work
-         * our way back to the interrupt return only to come right back
-         * here.
-         */
-        fecp->fec_r_des_active = 0;
-#endif
+                /* Update BD pointer to next entry */
+                if (status & BD_ENET_RX_WRAP)
+                        bdp = fep->rx_bd_base;
+                else
+                        bdp++;
+                /* Doing this here will keep the FEC running while we process
+                 * incoming frames.  On a heavily loaded network, we should be
+                 * able to keep up at the expense of system resources.
+                 */
+                writel(0, fep->hwp + FEC_R_DES_ACTIVE);
+        }
+        fep->cur_rx = bdp;
 
         spin_unlock_irq(&fep->hw_lock);
 }
 
-
 /* called from interrupt context */
 static void
 fec_enet_mii(struct net_device *dev)
 {
         struct  fec_enet_private *fep;
-        volatile fec_t  *ep;
         mii_list_t      *mip;
-        uint            mii_reg;
 
         fep = netdev_priv(dev);
         spin_lock_irq(&fep->mii_lock);
 
-        ep = fep->hwp;
-        mii_reg = ep->fec_mii_data;
-
         if ((mip = mii_head) == NULL) {
                 printk("MII and no head!\n");
                 goto unlock;
         }
 
         if (mip->mii_func != NULL)
-                (*(mip->mii_func))(mii_reg, dev);
+                (*(mip->mii_func))(readl(fep->hwp + FEC_MII_DATA), dev);
 
         mii_head = mip->mii_next;
         mip->mii_next = mii_free;
         mii_free = mip;
 
         if ((mip = mii_head) != NULL)
-                ep->fec_mii_data = mip->mii_regval;
+                writel(mip->mii_regval, fep->hwp + FEC_MII_DATA);
 
 unlock:
         spin_unlock_irq(&fep->mii_lock);
@@ -727,8 +643,7 @@ mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_devi
         mii_list_t      *mip;
         int             retval;
 
-        /* Add PHY address to register command.
-        */
+        /* Add PHY address to register command */
         fep = netdev_priv(dev);
         spin_lock_irqsave(&fep->mii_lock, flags);
 
@@ -745,7 +660,7 @@ mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_devi
                         mii_tail = mip;
                 } else {
                         mii_head = mii_tail = mip;
-                        fep->hwp->fec_mii_data = regval;
+                        writel(regval, fep->hwp + FEC_MII_DATA);
                 }
         } else {
                 retval = 1;
@@ -1246,11 +1161,8 @@ static void __inline__ fec_phy_ack_intr(void)
 static void __inline__ fec_get_mac(struct net_device *dev)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
-        volatile fec_t *fecp;
         unsigned char *iap, tmpaddr[ETH_ALEN];
 
-        fecp = fep->hwp;
-
         if (FEC_FLASHMAC) {
                 /*
                  * Get MAC address from FLASH.
@@ -1264,8 +1176,8 @@ static void __inline__ fec_get_mac(struct net_device *dev)
                     (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
                         iap = fec_mac_default;
         } else {
-                *((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
-                *((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
+                *((unsigned long *) &tmpaddr[0]) = readl(fep->hwp + FEC_ADDR_LOW);
+                *((unsigned short *) &tmpaddr[4]) = (readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
                 iap = &tmpaddr[0];
         }
 
@@ -1375,11 +1287,6 @@ static void mii_relink(struct work_struct *work)
                 fec_restart(dev, duplex);
         } else
                 fec_stop(dev);
-
-#if 0
-        enable_irq(fep->mii_irq);
-#endif
-
 }
 
 /* mii_queue_relink is called in interrupt context from mii_link_interrupt */
@@ -1388,12 +1295,12 @@ static void mii_queue_relink(uint mii_reg, struct net_device *dev)
         struct fec_enet_private *fep = netdev_priv(dev);
 
         /*
-        ** We cannot queue phy_task twice in the workqueue.  It
-        ** would cause an endless loop in the workqueue.
-        ** Fortunately, if the last mii_relink entry has not yet been
-        ** executed now, it will do the job for the current interrupt,
-        ** which is just what we want.
-        */
+         * We cannot queue phy_task twice in the workqueue.  It
+         * would cause an endless loop in the workqueue.
+         * Fortunately, if the last mii_relink entry has not yet been
+         * executed now, it will do the job for the current interrupt,
+         * which is just what we want.
+         */
         if (fep->mii_phy_task_queued)
                 return;
 
@@ -1424,8 +1331,7 @@ phy_cmd_t const phy_cmd_config[] = {
         { mk_mii_end, }
         };
 
-/* Read remainder of PHY ID.
-*/
+/* Read remainder of PHY ID. */
 static void
 mii_discover_phy3(uint mii_reg, struct net_device *dev)
 {
@@ -1457,17 +1363,14 @@ static void
 mii_discover_phy(uint mii_reg, struct net_device *dev)
 {
         struct fec_enet_private *fep;
-        volatile fec_t *fecp;
         uint phytype;
 
         fep = netdev_priv(dev);
-        fecp = fep->hwp;
 
         if (fep->phy_addr < 32) {
                 if ((phytype = (mii_reg & 0xffff)) != 0xffff && phytype != 0) {
 
-                        /* Got first part of ID, now get remainder.
-                        */
+                        /* Got first part of ID, now get remainder */
                         fep->phy_id = phytype << 16;
                         mii_queue(dev, mk_mii_read(MII_REG_PHYIR2),
                                                         mii_discover_phy3);
@@ -1479,15 +1382,15 @@ mii_discover_phy(uint mii_reg, struct net_device *dev)
         } else {
                 printk("FEC: No PHY device found.\n");
                 /* Disable external MII interface */
-                fecp->fec_mii_speed = fep->phy_speed = 0;
+                writel(0, fep->hwp + FEC_MII_SPEED);
+                fep->phy_speed = 0;
 #ifdef HAVE_mii_link_interrupt
                 fec_disable_phy_intr();
 #endif
         }
 }
 
-/* This interrupt occurs when the PHY detects a link change.
-*/
+/* This interrupt occurs when the PHY detects a link change */
 #ifdef HAVE_mii_link_interrupt
 static irqreturn_t
 mii_link_interrupt(int irq, void * dev_id)
@@ -1497,10 +1400,6 @@ mii_link_interrupt(int irq, void * dev_id)
 
         fec_phy_ack_intr();
 
-#if 0
-        disable_irq(fep->mii_irq);  /* disable now, enable later */
-#endif
-
         mii_do_cmd(dev, fep->phy->ack_int);
         mii_do_cmd(dev, phy_cmd_relink);  /* restart and display status */
 
@@ -1508,19 +1407,91 @@ mii_link_interrupt(int irq, void * dev_id)
 }
 #endif
 
+static void fec_enet_free_buffers(struct net_device *dev)
+{
+        struct fec_enet_private *fep = netdev_priv(dev);
+        int i;
+        struct sk_buff *skb;
+        struct bufdesc  *bdp;
+
+        bdp = fep->rx_bd_base;
+        for (i = 0; i < RX_RING_SIZE; i++) {
+                skb = fep->rx_skbuff[i];
+
+                if (bdp->cbd_bufaddr)
+                        dma_unmap_single(&dev->dev, bdp->cbd_bufaddr,
+                                        FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
+                if (skb)
+                        dev_kfree_skb(skb);
+                bdp++;
+        }
+
+        bdp = fep->tx_bd_base;
+        for (i = 0; i < TX_RING_SIZE; i++)
+                kfree(fep->tx_bounce[i]);
+}
+
+static int fec_enet_alloc_buffers(struct net_device *dev)
+{
+        struct fec_enet_private *fep = netdev_priv(dev);
+        int i;
+        struct sk_buff *skb;
+        struct bufdesc  *bdp;
+
+        bdp = fep->rx_bd_base;
+        for (i = 0; i < RX_RING_SIZE; i++) {
+                skb = dev_alloc_skb(FEC_ENET_RX_FRSIZE);
+                if (!skb) {
+                        fec_enet_free_buffers(dev);
+                        return -ENOMEM;
+                }
+                fep->rx_skbuff[i] = skb;
+
+                bdp->cbd_bufaddr = dma_map_single(&dev->dev, skb->data,
+                                FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
+                bdp->cbd_sc = BD_ENET_RX_EMPTY;
+                bdp++;
+        }
+
+        /* Set the last buffer to wrap. */
+        bdp--;
+        bdp->cbd_sc |= BD_SC_WRAP;
+
+        bdp = fep->tx_bd_base;
+        for (i = 0; i < TX_RING_SIZE; i++) {
+                fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
+
+                bdp->cbd_sc = 0;
+                bdp->cbd_bufaddr = 0;
+                bdp++;
+        }
+
+        /* Set the last buffer to wrap. */
+        bdp--;
+        bdp->cbd_sc |= BD_SC_WRAP;
+
+        return 0;
+}
+
 static int
 fec_enet_open(struct net_device *dev)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
+        int ret;
 
         /* I should reset the ring buffers here, but I don't yet know
          * a simple way to do that.
          */
-        fec_set_mac_address(dev);
+
+        ret = fec_enet_alloc_buffers(dev);
+        if (ret)
+                return ret;
 
         fep->sequence_done = 0;
         fep->link = 0;
 
+        fec_restart(dev, 1);
+
         if (fep->phy) {
                 mii_do_cmd(dev, fep->phy->ack_int);
                 mii_do_cmd(dev, fep->phy->config);
@@ -1537,21 +1508,17 @@ fec_enet_open(struct net_device *dev)
                         schedule();
 
                 mii_do_cmd(dev, fep->phy->startup);
-
-                /* Set the initial link state to true. A lot of hardware
-                 * based on this device does not implement a PHY interrupt,
-                 * so we are never notified of link change.
-                 */
-                fep->link = 1;
-        } else {
-                fep->link = 1; /* lets just try it and see */
-                /* no phy,  go full duplex,  it's most likely a hub chip */
-                fec_restart(dev, 1);
         }
 
+        /* Set the initial link state to true. A lot of hardware
+         * based on this device does not implement a PHY interrupt,
+         * so we are never notified of link change.
+         */
+        fep->link = 1;
+
         netif_start_queue(dev);
         fep->opened = 1;
-        return 0;               /* Success */
+        return 0;
 }
 
 static int
@@ -1559,12 +1526,13 @@ fec_enet_close(struct net_device *dev)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
 
-        /* Don't know what to do yet.
-        */
+        /* Don't know what to do yet. */
         fep->opened = 0;
         netif_stop_queue(dev);
         fec_stop(dev);
 
+        fec_enet_free_buffers(dev);
+
         return 0;
 }
 
@@ -1583,87 +1551,102 @@ fec_enet_close(struct net_device *dev)
 
 static void set_multicast_list(struct net_device *dev)
 {
-        struct fec_enet_private *fep;
-        volatile fec_t *ep;
+        struct fec_enet_private *fep = netdev_priv(dev);
         struct dev_mc_list *dmi;
-        unsigned int i, j, bit, data, crc;
+        unsigned int i, j, bit, data, crc, tmp;
         unsigned char hash;
 
-        fep = netdev_priv(dev);
-        ep = fep->hwp;
+        if (dev->flags & IFF_PROMISC) {
+                tmp = readl(fep->hwp + FEC_R_CNTRL);
+                tmp |= 0x8;
+                writel(tmp, fep->hwp + FEC_R_CNTRL);
+                return;
+        }
 
-        if (dev->flags&IFF_PROMISC) {
-                ep->fec_r_cntrl |= 0x0008;
-        } else {
+        tmp = readl(fep->hwp + FEC_R_CNTRL);
+        tmp &= ~0x8;
+        writel(tmp, fep->hwp + FEC_R_CNTRL);
+
+        if (dev->flags & IFF_ALLMULTI) {
+                /* Catch all multicast addresses, so set the
+                 * filter to all 1's
+                 */
+                writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+                writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
 
-                ep->fec_r_cntrl &= ~0x0008;
+                return;
+        }
 
-                if (dev->flags & IFF_ALLMULTI) {
-                        /* Catch all multicast addresses, so set the
-                         * filter to all 1's.
-                         */
-                        ep->fec_grp_hash_table_high = 0xffffffff;
-                        ep->fec_grp_hash_table_low = 0xffffffff;
-                } else {
-                        /* Clear filter and add the addresses in hash register.
-                        */
-                        ep->fec_grp_hash_table_high = 0;
-                        ep->fec_grp_hash_table_low = 0;
-
-                        dmi = dev->mc_list;
-
-                        for (j = 0; j < dev->mc_count; j++, dmi = dmi->next)
-                        {
-                                /* Only support group multicast for now.
-                                */
-                                if (!(dmi->dmi_addr[0] & 1))
-                                        continue;
-
-                                /* calculate crc32 value of mac address
-                                */
-                                crc = 0xffffffff;
-
-                                for (i = 0; i < dmi->dmi_addrlen; i++)
-                                {
-                                        data = dmi->dmi_addr[i];
-                                        for (bit = 0; bit < 8; bit++, data >>= 1)
-                                        {
-                                                crc = (crc >> 1) ^
-                                                (((crc ^ data) & 1) ? CRC32_POLY : 0);
-                                        }
-                                }
-
-                                /* only upper 6 bits (HASH_BITS) are used
-                                   which point to specific bit in he hash registers
-                                */
-                                hash = (crc >> (32 - HASH_BITS)) & 0x3f;
-
-                                if (hash > 31)
-                                        ep->fec_grp_hash_table_high |= 1 << (hash - 32);
-                                else
-                                        ep->fec_grp_hash_table_low |= 1 << hash;
+        /* Clear filter and add the addresses in hash register
+         */
+        writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+        writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+
+        dmi = dev->mc_list;
+
+        for (j = 0; j < dev->mc_count; j++, dmi = dmi->next) {
+                /* Only support group multicast for now */
+                if (!(dmi->dmi_addr[0] & 1))
+                        continue;
+
+                /* calculate crc32 value of mac address */
+                crc = 0xffffffff;
+
+                for (i = 0; i < dmi->dmi_addrlen; i++) {
+                        data = dmi->dmi_addr[i];
+                        for (bit = 0; bit < 8; bit++, data >>= 1) {
+                                crc = (crc >> 1) ^
+                                (((crc ^ data) & 1) ? CRC32_POLY : 0);
                         }
                 }
+
+                /* only upper 6 bits (HASH_BITS) are used
+                 * which point to specific bit in he hash registers
+                 */
+                hash = (crc >> (32 - HASH_BITS)) & 0x3f;
+
+                if (hash > 31) {
+                        tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+                        tmp |= 1 << (hash - 32);
+                        writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+                } else {
+                        tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+                        tmp |= 1 << hash;
+                        writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+                }
         }
 }
 
-/* Set a MAC change in hardware.
- */
-static void
-fec_set_mac_address(struct net_device *dev)
+/* Set a MAC change in hardware. */
+static int
+fec_set_mac_address(struct net_device *dev, void *p)
 {
-        volatile fec_t *fecp;
+        struct fec_enet_private *fep = netdev_priv(dev);
+        struct sockaddr *addr = p;
 
-        fecp = ((struct fec_enet_private *)netdev_priv(dev))->hwp;
+        if (!is_valid_ether_addr(addr->sa_data))
+                return -EADDRNOTAVAIL;
 
-        /* Set station address. */
-        fecp->fec_addr_low = dev->dev_addr[3] | (dev->dev_addr[2] << 8) |
-                (dev->dev_addr[1] << 16) | (dev->dev_addr[0] << 24);
-        fecp->fec_addr_high = (dev->dev_addr[5] << 16) |
-                (dev->dev_addr[4] << 24);
+        memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 
+        writel(dev->dev_addr[3] | (dev->dev_addr[2] << 8) |
+                (dev->dev_addr[1] << 16) | (dev->dev_addr[0] << 24),
+                fep->hwp + FEC_ADDR_LOW);
+        writel((dev->dev_addr[5] << 16) | (dev->dev_addr[4] << 24),
+                fep + FEC_ADDR_HIGH);
+        return 0;
 }
 
+static const struct net_device_ops fec_netdev_ops = {
+        .ndo_open               = fec_enet_open,
+        .ndo_stop               = fec_enet_close,
+        .ndo_start_xmit         = fec_enet_start_xmit,
+        .ndo_set_multicast_list = set_multicast_list,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_tx_timeout         = fec_timeout,
+        .ndo_set_mac_address    = fec_set_mac_address,
+};
+
  /*
   * XXX:  We need to clean up on failure exits here.
   *
@@ -1672,17 +1655,13 @@ fec_set_mac_address(struct net_device *dev)
 int __init fec_enet_init(struct net_device *dev, int index)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
-        unsigned long   mem_addr;
-        volatile cbd_t  *bdp;
-        cbd_t           *cbd_base;
-        volatile fec_t  *fecp;
-        int             i, j;
+        struct bufdesc *cbd_base;
+        int i;
 
-        /* Allocate memory for buffer descriptors.
-        */
-        mem_addr = (unsigned long)dma_alloc_coherent(NULL, PAGE_SIZE,
-                        &fep->bd_dma, GFP_KERNEL);
-        if (mem_addr == 0) {
+        /* Allocate memory for buffer descriptors. */
+        cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
+                        GFP_KERNEL);
+        if (!cbd_base) {
                 printk("FEC: allocate descriptor memory failed?\n");
                 return -ENOMEM;
         }
@@ -1690,146 +1669,47 @@ int __init fec_enet_init(struct net_device *dev, int index)
         spin_lock_init(&fep->hw_lock);
         spin_lock_init(&fep->mii_lock);
 
-        /* Create an Ethernet device instance.
-        */
-        fecp = (volatile fec_t *)dev->base_addr;
-
         fep->index = index;
-        fep->hwp = fecp;
+        fep->hwp = (void __iomem *)dev->base_addr;
         fep->netdev = dev;
 
-        /* Whack a reset.  We should wait for this.
-        */
-        fecp->fec_ecntrl = 1;
-        udelay(10);
-
         /* Set the Ethernet address */
 #ifdef CONFIG_M5272
         fec_get_mac(dev);
 #else
         {
                 unsigned long l;
-                l = fecp->fec_addr_low;
+                l = readl(fep->hwp + FEC_ADDR_LOW);
                 dev->dev_addr[0] = (unsigned char)((l & 0xFF000000) >> 24);
                 dev->dev_addr[1] = (unsigned char)((l & 0x00FF0000) >> 16);
                 dev->dev_addr[2] = (unsigned char)((l & 0x0000FF00) >> 8);
                 dev->dev_addr[3] = (unsigned char)((l & 0x000000FF) >> 0);
-                l = fecp->fec_addr_high;
+                l = readl(fep->hwp + FEC_ADDR_HIGH);
                 dev->dev_addr[4] = (unsigned char)((l & 0xFF000000) >> 24);
                 dev->dev_addr[5] = (unsigned char)((l & 0x00FF0000) >> 16);
         }
 #endif
 
-        cbd_base = (cbd_t *)mem_addr;
-
-        /* Set receive and transmit descriptor base.
-        */
+        /* Set receive and transmit descriptor base. */
         fep->rx_bd_base = cbd_base;
         fep->tx_bd_base = cbd_base + RX_RING_SIZE;
 
-        fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
-        fep->cur_rx = fep->rx_bd_base;
-
-        fep->skb_cur = fep->skb_dirty = 0;
-
-        /* Initialize the receive buffer descriptors.
-        */
-        bdp = fep->rx_bd_base;
-        for (i=0; i<FEC_ENET_RX_PAGES; i++) {
-
-                /* Allocate a page.
-                */
-                mem_addr = __get_free_page(GFP_KERNEL);
-                /* XXX: missing check for allocation failure */
-
-                /* Initialize the BD for every fragment in the page.
-                */
-                for (j=0; j<FEC_ENET_RX_FRPPG; j++) {
-                        bdp->cbd_sc = BD_ENET_RX_EMPTY;
-                        bdp->cbd_bufaddr = __pa(mem_addr);
-                        mem_addr += FEC_ENET_RX_FRSIZE;
-                        bdp++;
-                }
-        }
-
-        /* Set the last buffer to wrap.
-        */
-        bdp--;
-        bdp->cbd_sc |= BD_SC_WRAP;
-
-        /* ...and the same for transmmit.
-        */
-        bdp = fep->tx_bd_base;
-        for (i=0, j=FEC_ENET_TX_FRPPG; i<TX_RING_SIZE; i++) {
-                if (j >= FEC_ENET_TX_FRPPG) {
-                        mem_addr = __get_free_page(GFP_KERNEL);
-                        j = 1;
-                } else {
-                        mem_addr += FEC_ENET_TX_FRSIZE;
-                        j++;
-                }
-                fep->tx_bounce[i] = (unsigned char *) mem_addr;
-
-                /* Initialize the BD for every fragment in the page.
-                */
-                bdp->cbd_sc = 0;
-                bdp->cbd_bufaddr = 0;
-                bdp++;
-        }
-
-        /* Set the last buffer to wrap.
-        */
-        bdp--;
-        bdp->cbd_sc |= BD_SC_WRAP;
-
-        /* Set receive and transmit descriptor base.
-        */
-        fecp->fec_r_des_start = fep->bd_dma;
-        fecp->fec_x_des_start = (unsigned long)fep->bd_dma + sizeof(cbd_t)
-                                * RX_RING_SIZE;
-
 #ifdef HAVE_mii_link_interrupt
         fec_request_mii_intr(dev);
 #endif
-
-        fecp->fec_grp_hash_table_high = 0;
-        fecp->fec_grp_hash_table_low = 0;
-        fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
-        fecp->fec_ecntrl = 2;
-        fecp->fec_r_des_active = 0;
-#ifndef CONFIG_M5272
-        fecp->fec_hash_table_high = 0;
-        fecp->fec_hash_table_low = 0;
-#endif
-
-        /* The FEC Ethernet specific entries in the device structure. */
-        dev->open = fec_enet_open;
-        dev->hard_start_xmit = fec_enet_start_xmit;
-        dev->tx_timeout = fec_timeout;
+        /* The FEC Ethernet specific entries in the device structure */
         dev->watchdog_timeo = TX_TIMEOUT;
-        dev->stop = fec_enet_close;
-        dev->set_multicast_list = set_multicast_list;
+        dev->netdev_ops = &fec_netdev_ops;
 
         for (i=0; i<NMII-1; i++)
                 mii_cmds[i].mii_next = &mii_cmds[i+1];
         mii_free = mii_cmds;
 
-        /* setup MII interface */
-        fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
-        fecp->fec_x_cntrl = 0x00;
-
-        /*
-         * Set MII speed to 2.5 MHz
-         */
+        /* Set MII speed to 2.5 MHz */
         fep->phy_speed = ((((clk_get_rate(fep->clk) / 2 + 4999999)
                                         / 2500000) / 2) & 0x3F) << 1;
-        fecp->fec_mii_speed = fep->phy_speed;
         fec_restart(dev, 0);
 
-        /* Clear and enable interrupts */
-        fecp->fec_ievent = 0xffc00000;
-        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
-
         /* Queue up command to detect the PHY and initialize the
          * remainder of the interface.
          */
@@ -1847,145 +1727,118 @@ int __init fec_enet_init(struct net_device *dev, int index)
 static void
 fec_restart(struct net_device *dev, int duplex)
 {
-        struct fec_enet_private *fep;
-        volatile cbd_t *bdp;
-        volatile fec_t *fecp;
+        struct fec_enet_private *fep = netdev_priv(dev);
+        struct bufdesc *bdp;
         int i;
 
-        fep = netdev_priv(dev);
-        fecp = fep->hwp;
-
-        /* Whack a reset.  We should wait for this.
-        */
-        fecp->fec_ecntrl = 1;
+        /* Whack a reset.  We should wait for this. */
+        writel(1, fep->hwp + FEC_ECNTRL);
         udelay(10);
 
-        /* Clear any outstanding interrupt.
-        */
-        fecp->fec_ievent = 0xffc00000;
+        /* Clear any outstanding interrupt. */
+        writel(0xffc00000, fep->hwp + FEC_IEVENT);
 
-        /* Set station address.
-        */
-        fec_set_mac_address(dev);
+        /* Reset all multicast. */
+        writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+        writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+#ifndef CONFIG_M5272
+        writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
+        writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
+#endif
 
-        /* Reset all multicast.
-        */
-        fecp->fec_grp_hash_table_high = 0;
-        fecp->fec_grp_hash_table_low = 0;
+        /* Set maximum receive buffer size. */
+        writel(PKT_MAXBLR_SIZE, fep->hwp + FEC_R_BUFF_SIZE);
 
-        /* Set maximum receive buffer size.
-        */
-        fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
-
-        /* Set receive and transmit descriptor base.
-        */
-        fecp->fec_r_des_start = fep->bd_dma;
-        fecp->fec_x_des_start = (unsigned long)fep->bd_dma + sizeof(cbd_t)
-                                * RX_RING_SIZE;
+        /* Set receive and transmit descriptor base. */
+        writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
+        writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc) * RX_RING_SIZE,
+                        fep->hwp + FEC_X_DES_START);
 
         fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
         fep->cur_rx = fep->rx_bd_base;
 
-        /* Reset SKB transmit buffers.
-        */
+        /* Reset SKB transmit buffers. */
         fep->skb_cur = fep->skb_dirty = 0;
-        for (i=0; i<=TX_RING_MOD_MASK; i++) {
-                if (fep->tx_skbuff[i] != NULL) {
+        for (i = 0; i <= TX_RING_MOD_MASK; i++) {
+                if (fep->tx_skbuff[i]) {
                         dev_kfree_skb_any(fep->tx_skbuff[i]);
                         fep->tx_skbuff[i] = NULL;
                 }
         }
 
-        /* Initialize the receive buffer descriptors.
-        */
+        /* Initialize the receive buffer descriptors. */
         bdp = fep->rx_bd_base;
-        for (i=0; i<RX_RING_SIZE; i++) {
+        for (i = 0; i < RX_RING_SIZE; i++) {
 
-                /* Initialize the BD for every fragment in the page.
-                */
+                /* Initialize the BD for every fragment in the page. */
                 bdp->cbd_sc = BD_ENET_RX_EMPTY;
                 bdp++;
         }
 
-        /* Set the last buffer to wrap.
-        */
+        /* Set the last buffer to wrap */
         bdp--;
         bdp->cbd_sc |= BD_SC_WRAP;
 
-        /* ...and the same for transmmit.
-        */
+        /* ...and the same for transmit */
         bdp = fep->tx_bd_base;
-        for (i=0; i<TX_RING_SIZE; i++) {
+        for (i = 0; i < TX_RING_SIZE; i++) {
 
-                /* Initialize the BD for every fragment in the page.
-                */
+                /* Initialize the BD for every fragment in the page. */
                 bdp->cbd_sc = 0;
                 bdp->cbd_bufaddr = 0;
                 bdp++;
         }
 
-        /* Set the last buffer to wrap.
-        */
+        /* Set the last buffer to wrap */
         bdp--;
         bdp->cbd_sc |= BD_SC_WRAP;
 
-        /* Enable MII mode.
-        */
+        /* Enable MII mode */
         if (duplex) {
-                fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;/* MII enable */
-                fecp->fec_x_cntrl = 0x04;                 /* FD enable */
+                /* MII enable / FD enable */
+                writel(OPT_FRAME_SIZE | 0x04, fep->hwp + FEC_R_CNTRL);
+                writel(0x04, fep->hwp + FEC_X_CNTRL);
         } else {
-                /* MII enable|No Rcv on Xmit */
-                fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x06;
-                fecp->fec_x_cntrl = 0x00;
+                /* MII enable / No Rcv on Xmit */
+                writel(OPT_FRAME_SIZE | 0x06, fep->hwp + FEC_R_CNTRL);
+                writel(0x0, fep->hwp + FEC_X_CNTRL);
         }
         fep->full_duplex = duplex;
 
-        /* Set MII speed.
-        */
-        fecp->fec_mii_speed = fep->phy_speed;
+        /* Set MII speed */
+        writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 
-        /* And last, enable the transmit and receive processing.
-        */
-        fecp->fec_ecntrl = 2;
-        fecp->fec_r_des_active = 0;
+        /* And last, enable the transmit and receive processing */
+        writel(2, fep->hwp + FEC_ECNTRL);
+        writel(0, fep->hwp + FEC_R_DES_ACTIVE);
 
-        /* Enable interrupts we wish to service.
-        */
-        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
+        /* Enable interrupts we wish to service */
+        writel(FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII,
+                        fep->hwp + FEC_IMASK);
 }
 
 static void
 fec_stop(struct net_device *dev)
 {
-        volatile fec_t *fecp;
-        struct fec_enet_private *fep;
-
-        fep = netdev_priv(dev);
-        fecp = fep->hwp;
+        struct fec_enet_private *fep = netdev_priv(dev);
 
-        /*
-        ** We cannot expect a graceful transmit stop without link !!!
-        */
-        if (fep->link)
-                {
-                fecp->fec_x_cntrl = 0x01;       /* Graceful transmit stop */
+        /* We cannot expect a graceful transmit stop without link !!! */
+        if (fep->link) {
+                writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
                 udelay(10);
-                if (!(fecp->fec_ievent & FEC_ENET_GRA))
+                if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
                         printk("fec_stop : Graceful transmit stop did not complete !\n");
-                }
+        }
 
-        /* Whack a reset.  We should wait for this.
-        */
-        fecp->fec_ecntrl = 1;
+        /* Whack a reset.  We should wait for this. */
+        writel(1, fep->hwp + FEC_ECNTRL);
         udelay(10);
 
-        /* Clear outstanding MII command interrupts.
-        */
-        fecp->fec_ievent = FEC_ENET_MII;
+        /* Clear outstanding MII command interrupts. */
+        writel(FEC_ENET_MII, fep->hwp + FEC_IEVENT);
 
-        fecp->fec_imask = FEC_ENET_MII;
-        fecp->fec_mii_speed = fep->phy_speed;
+        writel(FEC_ENET_MII, fep->hwp + FEC_IMASK);
+        writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 }
 
 static int __devinit
diff --git a/drivers/net/fec.h b/drivers/net/fec.h
index 76c64c92e190..30b7dd671336 100644
--- a/drivers/net/fec.h
+++ b/drivers/net/fec.h
@@ -20,82 +20,55 @@
  *      registers in the same peripheral device on different models
  *      of the ColdFire!
  */
-typedef struct fec {
-        unsigned long   fec_reserved0;
-        unsigned long   fec_ievent;             /* Interrupt event reg */
-        unsigned long   fec_imask;              /* Interrupt mask reg */
-        unsigned long   fec_reserved1;
-        unsigned long   fec_r_des_active;       /* Receive descriptor reg */
-        unsigned long   fec_x_des_active;       /* Transmit descriptor reg */
-        unsigned long   fec_reserved2[3];
-        unsigned long   fec_ecntrl;             /* Ethernet control reg */
-        unsigned long   fec_reserved3[6];
-        unsigned long   fec_mii_data;           /* MII manage frame reg */
-        unsigned long   fec_mii_speed;          /* MII speed control reg */
-        unsigned long   fec_reserved4[7];
-        unsigned long   fec_mib_ctrlstat;       /* MIB control/status reg */
-        unsigned long   fec_reserved5[7];
-        unsigned long   fec_r_cntrl;            /* Receive control reg */
-        unsigned long   fec_reserved6[15];
-        unsigned long   fec_x_cntrl;            /* Transmit Control reg */
-        unsigned long   fec_reserved7[7];
-        unsigned long   fec_addr_low;           /* Low 32bits MAC address */
-        unsigned long   fec_addr_high;          /* High 16bits MAC address */
-        unsigned long   fec_opd;                /* Opcode + Pause duration */
-        unsigned long   fec_reserved8[10];
-        unsigned long   fec_hash_table_high;    /* High 32bits hash table */
-        unsigned long   fec_hash_table_low;     /* Low 32bits hash table */
-        unsigned long   fec_grp_hash_table_high;/* High 32bits hash table */
-        unsigned long   fec_grp_hash_table_low; /* Low 32bits hash table */
-        unsigned long   fec_reserved9[7];
-        unsigned long   fec_x_wmrk;             /* FIFO transmit water mark */
-        unsigned long   fec_reserved10;
-        unsigned long   fec_r_bound;            /* FIFO receive bound reg */
-        unsigned long   fec_r_fstart;           /* FIFO receive start reg */
-        unsigned long   fec_reserved11[11];
-        unsigned long   fec_r_des_start;        /* Receive descriptor ring */
-        unsigned long   fec_x_des_start;        /* Transmit descriptor ring */
-        unsigned long   fec_r_buff_size;        /* Maximum receive buff size */
-} fec_t;
+#define FEC_IEVENT              0x004 /* Interrupt event reg */
+#define FEC_IMASK               0x008 /* Interrupt mask reg */
+#define FEC_R_DES_ACTIVE        0x010 /* Receive descriptor reg */
+#define FEC_X_DES_ACTIVE        0x014 /* Transmit descriptor reg */
+#define FEC_ECNTRL              0x024 /* Ethernet control reg */
+#define FEC_MII_DATA            0x040 /* MII manage frame reg */
+#define FEC_MII_SPEED           0x044 /* MII speed control reg */
+#define FEC_MIB_CTRLSTAT        0x064 /* MIB control/status reg */
+#define FEC_R_CNTRL             0x084 /* Receive control reg */
+#define FEC_X_CNTRL             0x0c4 /* Transmit Control reg */
+#define FEC_ADDR_LOW            0x0e4 /* Low 32bits MAC address */
+#define FEC_ADDR_HIGH           0x0e8 /* High 16bits MAC address */
+#define FEC_OPD                 0x0ec /* Opcode + Pause duration */
+#define FEC_HASH_TABLE_HIGH     0x118 /* High 32bits hash table */
+#define FEC_HASH_TABLE_LOW      0x11c /* Low 32bits hash table */
+#define FEC_GRP_HASH_TABLE_HIGH 0x120 /* High 32bits hash table */
+#define FEC_GRP_HASH_TABLE_LOW  0x124 /* Low 32bits hash table */
+#define FEC_X_WMRK              0x144 /* FIFO transmit water mark */
+#define FEC_R_BOUND             0x14c /* FIFO receive bound reg */
+#define FEC_R_FSTART            0x150 /* FIFO receive start reg */
+#define FEC_R_DES_START         0x180 /* Receive descriptor ring */
+#define FEC_X_DES_START         0x184 /* Transmit descriptor ring */
+#define FEC_R_BUFF_SIZE         0x188 /* Maximum receive buff size */
 
 #else
 
-/*
- *      Define device register set address map.
- */
-typedef struct fec {
-        unsigned long   fec_ecntrl;             /* Ethernet control reg */
-        unsigned long   fec_ievent;             /* Interrupt even reg */
-        unsigned long   fec_imask;              /* Interrupt mask reg */
-        unsigned long   fec_ivec;               /* Interrupt vec status reg */
-        unsigned long   fec_r_des_active;       /* Receive descriptor reg */
-        unsigned long   fec_x_des_active;       /* Transmit descriptor reg */
-        unsigned long   fec_reserved1[10];
-        unsigned long   fec_mii_data;           /* MII manage frame reg */
-        unsigned long   fec_mii_speed;          /* MII speed control reg */
-        unsigned long   fec_reserved2[17];
-        unsigned long   fec_r_bound;            /* FIFO receive bound reg */
-        unsigned long   fec_r_fstart;           /* FIFO receive start reg */
-        unsigned long   fec_reserved3[4];
-        unsigned long   fec_x_wmrk;             /* FIFO transmit water mark */
-        unsigned long   fec_reserved4;
-        unsigned long   fec_x_fstart;           /* FIFO transmit start reg */
-        unsigned long   fec_reserved5[21];
-        unsigned long   fec_r_cntrl;            /* Receive control reg */
-        unsigned long   fec_max_frm_len;        /* Maximum frame length reg */
-        unsigned long   fec_reserved6[14];
-        unsigned long   fec_x_cntrl;            /* Transmit Control reg */
-        unsigned long   fec_reserved7[158];
-        unsigned long   fec_addr_low;           /* Low 32bits MAC address */
-        unsigned long   fec_addr_high;          /* High 16bits MAC address */
-        unsigned long   fec_grp_hash_table_high;/* High 32bits hash table */
-        unsigned long   fec_grp_hash_table_low; /* Low 32bits hash table */
-        unsigned long   fec_r_des_start;        /* Receive descriptor ring */
-        unsigned long   fec_x_des_start;        /* Transmit descriptor ring */
-        unsigned long   fec_r_buff_size;        /* Maximum receive buff size */
-        unsigned long   reserved8[9];
-        unsigned long   fec_fifo_ram[112];      /* FIFO RAM buffer */
-} fec_t;
+#define FEC_ECNTRL;             0x000 /* Ethernet control reg */
+#define FEC_IEVENT;             0x004 /* Interrupt even reg */
+#define FEC_IMASK;              0x008 /* Interrupt mask reg */
+#define FEC_IVEC;               0x00c /* Interrupt vec status reg */
+#define FEC_R_DES_ACTIVE;       0x010 /* Receive descriptor reg */
+#define FEC_X_DES_ACTIVE;       0x01c /* Transmit descriptor reg */
+#define FEC_MII_DATA            0x040 /* MII manage frame reg */
+#define FEC_MII_SPEED           0x044 /* MII speed control reg */
+#define FEC_R_BOUND             0x08c /* FIFO receive bound reg */
+#define FEC_R_FSTART            0x090 /* FIFO receive start reg */
+#define FEC_X_WMRK              0x0a4 /* FIFO transmit water mark */
+#define FEC_X_FSTART            0x0ac /* FIFO transmit start reg */
+#define FEC_R_CNTRL             0x104 /* Receive control reg */
+#define FEC_MAX_FRM_LEN         0x108 /* Maximum frame length reg */
+#define FEC_X_CNTRL             0x144 /* Transmit Control reg */
+#define FEC_ADDR_LOW            0x3c0 /* Low 32bits MAC address */
+#define FEC_ADDR_HIGH           0x3c4 /* High 16bits MAC address */
+#define FEC_GRP_HASH_TABLE_HIGH 0x3c8 /* High 32bits hash table */
+#define FEC_GRP_HASH_TABLE_LOW  0x3cc /* Low 32bits hash table */
+#define FEC_R_DES_START         0x3d0 /* Receive descriptor ring */
+#define FEC_X_DES_START         0x3d4 /* Transmit descriptor ring */
+#define FEC_R_BUFF_SIZE         0x3d8 /* Maximum receive buff size */
+#define FEC_FIFO_RAM            0x400 /* FIFO RAM buffer */
 
 #endif /* CONFIG_M5272 */
 
@@ -104,17 +77,17 @@ typedef struct fec {
  *      Define the buffer descriptor structure.
  */
 #ifdef CONFIG_ARCH_MXC
-typedef struct bufdesc {
+struct bufdesc {
         unsigned short cbd_datlen;      /* Data length */
         unsigned short cbd_sc;  /* Control and status info */
         unsigned long cbd_bufaddr;      /* Buffer address */
-} cbd_t;
+};
 #else
-typedef struct bufdesc {
+struct bufdesc {
         unsigned short  cbd_sc;                 /* Control and status info */
         unsigned short  cbd_datlen;             /* Data length */
         unsigned long   cbd_bufaddr;            /* Buffer address */
-} cbd_t;
+};
 #endif
 
 /*
diff --git a/drivers/net/fs_enet/mii-fec.c b/drivers/net/fs_enet/mii-fec.c
index 28077cc1b949..61aaae444b40 100644
--- a/drivers/net/fs_enet/mii-fec.c
+++ b/drivers/net/fs_enet/mii-fec.c
@@ -54,8 +54,7 @@ static int fs_enet_fec_mii_read(struct mii_bus *bus , int phy_id, int location)
         fec_t __iomem *fecp = fec->fecp;
         int i, ret = -1;
 
-        if ((in_be32(&fecp->fec_r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
-                BUG();
+        BUG_ON((in_be32(&fecp->fec_r_cntrl) & FEC_RCNTRL_MII_MODE) == 0);
 
         /* Add PHY address to register command.  */
         out_be32(&fecp->fec_mii_data, (phy_id << 23) | mk_mii_read(location));
@@ -79,8 +78,7 @@ static int fs_enet_fec_mii_write(struct mii_bus *bus, int phy_id, int location,
         int i;
 
         /* this must never happen */
-        if ((in_be32(&fecp->fec_r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
-                BUG();
+        BUG_ON((in_be32(&fecp->fec_r_cntrl) & FEC_RCNTRL_MII_MODE) == 0);
 
         /* Add PHY address to register command.  */
         out_be32(&fecp->fec_mii_data, (phy_id << 23) | mk_mii_write(location, val));
diff --git a/drivers/net/hplance.c b/drivers/net/hplance.c
index 2e802634d366..3e3528ade259 100644
--- a/drivers/net/hplance.c
+++ b/drivers/net/hplance.c
@@ -71,6 +71,19 @@ static struct dio_driver hplance_driver = {
         .remove    = __devexit_p(hplance_remove_one),
 };
 
+static const struct net_device_ops hplance_netdev_ops = {
+        .ndo_open               = hplance_open,
+        .ndo_stop               = hplance_close,
+        .ndo_start_xmit         = lance_start_xmit,
+        .ndo_set_multicast_list = lance_set_multicast,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = lance_poll,
+#endif
+};
+
 /* Find all the HP Lance boards and initialise them... */
 static int __devinit hplance_init_one(struct dio_dev *d,
                                 const struct dio_device_id *ent)
@@ -135,13 +148,7 @@ static void __init hplance_init(struct net_device *dev, struct dio_dev *d)
 
         /* Fill the dev fields */
         dev->base_addr = va;
-        dev->open = &hplance_open;
-        dev->stop = &hplance_close;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = lance_poll;
-#endif
-        dev->hard_start_xmit = &lance_start_xmit;
-        dev->set_multicast_list = &lance_set_multicast;
+        dev->netdev_ops = &hplance_netdev_ops;
         dev->dma = 0;
 
         for (i=0; i<6; i++) {
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index 5c6315df86b9..0a51b0bd1e49 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -1203,6 +1203,20 @@ static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
         return ret;
 }
 
+static const struct net_device_ops ibmveth_netdev_ops = {
+        .ndo_open               = ibmveth_open,
+        .ndo_stop               = ibmveth_close,
+        .ndo_start_xmit         = ibmveth_start_xmit,
+        .ndo_set_multicast_list = ibmveth_set_multicast_list,
+        .ndo_do_ioctl           = ibmveth_ioctl,
+        .ndo_change_mtu         = ibmveth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = ibmveth_poll_controller,
+#endif
+};
+
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
         int rc, i;
@@ -1265,17 +1279,9 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
         memcpy(&adapter->mac_addr, mac_addr_p, 6);
 
         netdev->irq = dev->irq;
-        netdev->open               = ibmveth_open;
-        netdev->stop               = ibmveth_close;
-        netdev->hard_start_xmit    = ibmveth_start_xmit;
-        netdev->set_multicast_list = ibmveth_set_multicast_list;
-        netdev->do_ioctl           = ibmveth_ioctl;
-        netdev->ethtool_ops           = &netdev_ethtool_ops;
-        netdev->change_mtu         = ibmveth_change_mtu;
+        netdev->netdev_ops = &ibmveth_netdev_ops;
+        netdev->ethtool_ops = &netdev_ethtool_ops;
         SET_NETDEV_DEV(netdev, &dev->dev);
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        netdev->poll_controller = ibmveth_poll_controller;
-#endif
         netdev->features |= NETIF_F_LLTX;
         spin_lock_init(&adapter->stats_lock);
 
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 08c801490c72..183235d46aee 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -942,6 +942,8 @@ int igb_up(struct igb_adapter *adapter)
         rd32(E1000_ICR);
         igb_irq_enable(adapter);
 
+        netif_tx_start_all_queues(adapter->netdev);
+
         /* Fire a link change interrupt to start the watchdog. */
         wr32(E1000_ICS, E1000_ICS_LSC);
         return 0;
@@ -1442,15 +1444,14 @@ static int __devinit igb_probe(struct pci_dev *pdev,
          * driver. */
         igb_get_hw_control(adapter);
 
-        /* tell the stack to leave us alone until igb_open() is called */
-        netif_carrier_off(netdev);
-        netif_tx_stop_all_queues(netdev);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
                 goto err_register;
 
+        /* carrier off reporting is important to ethtool even BEFORE open */
+        netif_carrier_off(netdev);
+
 #ifdef CONFIG_IGB_DCA
         if (dca_add_requester(&pdev->dev) == 0) {
                 adapter->flags |= IGB_FLAG_DCA_ENABLED;
@@ -1699,6 +1700,8 @@ static int igb_open(struct net_device *netdev)
         if (test_bit(__IGB_TESTING, &adapter->state))
                 return -EBUSY;
 
+        netif_carrier_off(netdev);
+
         /* allocate transmit descriptors */
         err = igb_setup_all_tx_resources(adapter);
         if (err)
@@ -2663,7 +2666,6 @@ static void igb_watchdog_task(struct work_struct *work)
                         }
 
                         netif_carrier_on(netdev);
-                        netif_tx_wake_all_queues(netdev);
 
                         igb_ping_all_vfs(adapter);
 
@@ -2680,7 +2682,6 @@ static void igb_watchdog_task(struct work_struct *work)
                         printk(KERN_INFO "igb: %s NIC Link is Down\n",
                                netdev->name);
                         netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
 
                         igb_ping_all_vfs(adapter);
 
diff --git a/drivers/net/irda/au1k_ir.c b/drivers/net/irda/au1k_ir.c
index 941164076a2b..269153eedd26 100644
--- a/drivers/net/irda/au1k_ir.c
+++ b/drivers/net/irda/au1k_ir.c
@@ -23,6 +23,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
+#include <linux/etherdevice.h>
 #include <linux/slab.h>
 #include <linux/rtnetlink.h>
 #include <linux/interrupt.h>
@@ -198,6 +199,17 @@ static int au1k_irda_init_iobuf(iobuff_t *io, int size)
         return io->head ? 0 : -ENOMEM;
 }
 
+static const struct net_device_ops au1k_irda_netdev_ops = {
+        .ndo_open               = au1k_irda_start,
+        .ndo_stop               = au1k_irda_stop,
+        .ndo_start_xmit         = au1k_irda_hard_xmit,
+        .ndo_tx_timeout         = au1k_tx_timeout,
+        .ndo_do_ioctl           = au1k_irda_ioctl,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int au1k_irda_net_init(struct net_device *dev)
 {
         struct au1k_private *aup = netdev_priv(dev);
@@ -209,11 +221,7 @@ static int au1k_irda_net_init(struct net_device *dev)
         if (err)
                 goto out1;
 
-        dev->open = au1k_irda_start;
-        dev->hard_start_xmit = au1k_irda_hard_xmit;
-        dev->stop = au1k_irda_stop;
-        dev->do_ioctl = au1k_irda_ioctl;
-        dev->tx_timeout = au1k_tx_timeout;
+        dev->netdev_ops = &au1k_irda_netdev_ops;
 
         irda_init_max_qos_capabilies(&aup->qos);
 
diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
index e775338b525f..3376a4f39e0a 100644
--- a/drivers/net/irda/pxaficp_ir.c
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -14,6 +14,7 @@
  */
 #include <linux/module.h>
 #include <linux/netdevice.h>
+#include <linux/etherdevice.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 
@@ -797,6 +798,16 @@ static int pxa_irda_init_iobuf(iobuff_t *io, int size)
         return io->head ? 0 : -ENOMEM;
 }
 
+static const struct net_device_ops pxa_irda_netdev_ops = {
+        .ndo_open               = pxa_irda_start,
+        .ndo_stop               = pxa_irda_stop,
+        .ndo_start_xmit         = pxa_irda_hard_xmit,
+        .ndo_do_ioctl           = pxa_irda_ioctl,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int pxa_irda_probe(struct platform_device *pdev)
 {
         struct net_device *dev;
@@ -845,10 +856,7 @@ static int pxa_irda_probe(struct platform_device *pdev)
         if (err)
                 goto err_startup;
 
-        dev->hard_start_xmit    = pxa_irda_hard_xmit;
-        dev->open               = pxa_irda_start;
-        dev->stop               = pxa_irda_stop;
-        dev->do_ioctl           = pxa_irda_ioctl;
+        dev->netdev_ops = &pxa_irda_netdev_ops;
 
         irda_init_max_qos_capabilies(&si->qos);
 
diff --git a/drivers/net/irda/sa1100_ir.c b/drivers/net/irda/sa1100_ir.c
index 7a2b003954ca..2aeb2e6aec1b 100644
--- a/drivers/net/irda/sa1100_ir.c
+++ b/drivers/net/irda/sa1100_ir.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
+#include <linux/etherdevice.h>
 #include <linux/slab.h>
 #include <linux/rtnetlink.h>
 #include <linux/interrupt.h>
@@ -875,6 +876,16 @@ static int sa1100_irda_init_iobuf(iobuff_t *io, int size)
         return io->head ? 0 : -ENOMEM;
 }
 
+static const struct net_device_ops sa1100_irda_netdev_ops = {
+        .ndo_open               = sa1100_irda_start,
+        .ndo_stop               = sa1100_irda_stop,
+        .ndo_start_xmit         = sa1100_irda_hard_xmit,
+        .ndo_do_ioctl           = sa1100_irda_ioctl,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int sa1100_irda_probe(struct platform_device *pdev)
 {
         struct net_device *dev;
@@ -913,11 +924,8 @@ static int sa1100_irda_probe(struct platform_device *pdev)
         if (err)
                 goto err_mem_5;
 
-        dev->hard_start_xmit    = sa1100_irda_hard_xmit;
-        dev->open               = sa1100_irda_start;
-        dev->stop               = sa1100_irda_stop;
-        dev->do_ioctl           = sa1100_irda_ioctl;
-        dev->irq                = IRQ_Ser2ICP;
+        dev->netdev_ops = &sa1100_irda_netdev_ops;
+        dev->irq        = IRQ_Ser2ICP;
 
         irda_init_max_qos_capabilies(&si->qos);
 
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index cb793c2bade2..e44215cb1882 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -1021,6 +1021,16 @@ static const struct ethtool_ops ops = {
         .get_link = veth_get_link,
 };
 
+static const struct net_device_ops veth_netdev_ops = {
+        .ndo_open               = veth_open,
+        .ndo_stop               = veth_close,
+        .ndo_start_xmit         = veth_start_xmit,
+        .ndo_change_mtu         = veth_change_mtu,
+        .ndo_set_multicast_list = veth_set_multicast_list,
+        .ndo_set_mac_address    = NULL,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static struct net_device *veth_probe_one(int vlan,
                 struct vio_dev *vio_dev)
 {
@@ -1067,12 +1077,7 @@ static struct net_device *veth_probe_one(int vlan,
 
         memcpy(&port->mac_addr, mac_addr, ETH_ALEN);
 
-        dev->open = veth_open;
-        dev->hard_start_xmit = veth_start_xmit;
-        dev->stop = veth_close;
-        dev->change_mtu = veth_change_mtu;
-        dev->set_mac_address = NULL;
-        dev->set_multicast_list = veth_set_multicast_list;
+        dev->netdev_ops = &veth_netdev_ops;
         SET_ETHTOOL_OPS(dev, &ops);
 
         SET_NETDEV_DEV(dev, vdev);
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index 4a0826b8f6f2..cb9ecc48f6d0 100644
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -266,6 +266,8 @@ ixgb_up(struct ixgb_adapter *adapter)
         napi_enable(&adapter->napi);
         ixgb_irq_enable(adapter);
 
+        netif_wake_queue(netdev);
+
         mod_timer(&adapter->watchdog_timer, jiffies);
 
         return 0;
@@ -471,10 +473,8 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (err)
                 goto err_register;
 
-        /* we're going to reset, so assume we have no link for now */
-
+        /* carrier off reporting is important to ethtool even BEFORE open */
         netif_carrier_off(netdev);
-        netif_stop_queue(netdev);
 
         DPRINTK(PROBE, INFO, "Intel(R) PRO/10GbE Network Connection\n");
         ixgb_check_options(adapter);
@@ -592,6 +592,8 @@ ixgb_open(struct net_device *netdev)
         if (err)
                 goto err_setup_tx;
 
+        netif_carrier_off(netdev);
+
         /* allocate receive descriptors */
 
         err = ixgb_setup_rx_resources(adapter);
@@ -602,6 +604,8 @@ ixgb_open(struct net_device *netdev)
         if (err)
                 goto err_up;
 
+        netif_start_queue(netdev);
+
         return 0;
 
 err_up:
@@ -1116,7 +1120,6 @@ ixgb_watchdog(unsigned long data)
                         adapter->link_speed = 10000;
                         adapter->link_duplex = FULL_DUPLEX;
                         netif_carrier_on(netdev);
-                        netif_wake_queue(netdev);
                 }
         } else {
                 if (netif_carrier_ok(netdev)) {
@@ -1125,8 +1128,6 @@ ixgb_watchdog(unsigned long data)
                         printk(KERN_INFO "ixgb: %s NIC Link is Down\n",
                                netdev->name);
                         netif_carrier_off(netdev);
-                        netif_stop_queue(netdev);
-
                 }
         }
 
diff --git a/drivers/net/ixgb/ixgb_osdep.h b/drivers/net/ixgb/ixgb_osdep.h
index d92e72bd627a..371a6be4d965 100644
--- a/drivers/net/ixgb/ixgb_osdep.h
+++ b/drivers/net/ixgb/ixgb_osdep.h
@@ -40,7 +40,7 @@
 #include <linux/sched.h>
 
 #undef ASSERT
-#define ASSERT(x)       if (!(x)) BUG()
+#define ASSERT(x)       BUG_ON(!(x))
 #define MSGOUT(S, A, B) printk(KERN_DEBUG S "\n", A, B)
 
 #ifdef DBG
diff --git a/drivers/net/ixgbe/ixgbe_82598.c b/drivers/net/ixgbe/ixgbe_82598.c
index 4791238c3f6e..03eb54f4f1cc 100644
--- a/drivers/net/ixgbe/ixgbe_82598.c
+++ b/drivers/net/ixgbe/ixgbe_82598.c
@@ -75,18 +75,49 @@ static u16 ixgbe_get_pcie_msix_count_82598(struct ixgbe_hw *hw)
 static s32 ixgbe_get_invariants_82598(struct ixgbe_hw *hw)
 {
         struct ixgbe_mac_info *mac = &hw->mac;
+
+        /* Call PHY identify routine to get the phy type */
+        ixgbe_identify_phy_generic(hw);
+
+        mac->mcft_size = IXGBE_82598_MC_TBL_SIZE;
+        mac->vft_size = IXGBE_82598_VFT_TBL_SIZE;
+        mac->num_rar_entries = IXGBE_82598_RAR_ENTRIES;
+        mac->max_rx_queues = IXGBE_82598_MAX_RX_QUEUES;
+        mac->max_tx_queues = IXGBE_82598_MAX_TX_QUEUES;
+        mac->max_msix_vectors = ixgbe_get_pcie_msix_count_82598(hw);
+
+        return 0;
+}
+
+/**
+ *  ixgbe_init_phy_ops_82598 - PHY/SFP specific init
+ *  @hw: pointer to hardware structure
+ *
+ *  Initialize any function pointers that were not able to be
+ *  set during get_invariants because the PHY/SFP type was
+ *  not known.  Perform the SFP init if necessary.
+ *
+ **/
+s32 ixgbe_init_phy_ops_82598(struct ixgbe_hw *hw)
+{
+        struct ixgbe_mac_info *mac = &hw->mac;
         struct ixgbe_phy_info *phy = &hw->phy;
         s32 ret_val = 0;
         u16 list_offset, data_offset;
 
-        /* Set the bus information prior to PHY identification */
-        mac->ops.get_bus_info(hw);
+        /* Identify the PHY */
+        phy->ops.identify(hw);
 
-        /* Call PHY identify routine to get the phy type */
-        ixgbe_identify_phy_generic(hw);
+        /* Overwrite the link function pointers if copper PHY */
+        if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
+                mac->ops.setup_link = &ixgbe_setup_copper_link_82598;
+                mac->ops.setup_link_speed =
+                                     &ixgbe_setup_copper_link_speed_82598;
+                mac->ops.get_link_capabilities =
+                                  &ixgbe_get_copper_link_capabilities_82598;
+        }
 
-        /* PHY Init */
-        switch (phy->type) {
+        switch (hw->phy.type) {
         case ixgbe_phy_tn:
                 phy->ops.check_link = &ixgbe_check_phy_link_tnx;
                 phy->ops.get_firmware_version =
@@ -106,8 +137,8 @@ static s32 ixgbe_get_invariants_82598(struct ixgbe_hw *hw)
 
                 /* Check to see if SFP+ module is supported */
                 ret_val = ixgbe_get_sfp_init_sequence_offsets(hw,
-                                                              &list_offset,
-                                                              &data_offset);
+                                                            &list_offset,
+                                                            &data_offset);
                 if (ret_val != 0) {
                         ret_val = IXGBE_ERR_SFP_NOT_SUPPORTED;
                         goto out;
@@ -117,21 +148,6 @@ static s32 ixgbe_get_invariants_82598(struct ixgbe_hw *hw)
                 break;
         }
 
-        if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
-                mac->ops.setup_link = &ixgbe_setup_copper_link_82598;
-                mac->ops.setup_link_speed =
-                                     &ixgbe_setup_copper_link_speed_82598;
-                mac->ops.get_link_capabilities =
-                                     &ixgbe_get_copper_link_capabilities_82598;
-        }
-
-        mac->mcft_size = IXGBE_82598_MC_TBL_SIZE;
-        mac->vft_size = IXGBE_82598_VFT_TBL_SIZE;
-        mac->num_rar_entries = IXGBE_82598_RAR_ENTRIES;
-        mac->max_rx_queues = IXGBE_82598_MAX_RX_QUEUES;
-        mac->max_tx_queues = IXGBE_82598_MAX_TX_QUEUES;
-        mac->max_msix_vectors = ixgbe_get_pcie_msix_count_82598(hw);
-
 out:
         return ret_val;
 }
@@ -149,12 +165,19 @@ static s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
                                              bool *autoneg)
 {
         s32 status = 0;
+        u32 autoc = 0;
 
         /*
          * Determine link capabilities based on the stored value of AUTOC,
-         * which represents EEPROM defaults.
+         * which represents EEPROM defaults.  If AUTOC value has not been
+         * stored, use the current register value.
          */
-        switch (hw->mac.orig_autoc & IXGBE_AUTOC_LMS_MASK) {
+        if (hw->mac.orig_link_settings_stored)
+                autoc = hw->mac.orig_autoc;
+        else
+                autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
+
+        switch (autoc & IXGBE_AUTOC_LMS_MASK) {
         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
                 *autoneg = false;
@@ -173,9 +196,9 @@ static s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
         case IXGBE_AUTOC_LMS_KX4_AN:
         case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX4_SUPP)
+                if (autoc & IXGBE_AUTOC_KX4_SUPP)
                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX_SUPP)
+                if (autoc & IXGBE_AUTOC_KX_SUPP)
                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
                 *autoneg = true;
                 break;
@@ -322,6 +345,7 @@ static s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
         }
 
         /* Enable 802.3x based flow control settings. */
+        fctrl_reg |= IXGBE_FCTRL_DPF;
         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl_reg);
         IXGBE_WRITE_REG(hw, IXGBE_RMCS, rmcs_reg);
 
@@ -380,9 +404,11 @@ static s32 ixgbe_setup_fc_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
          * because it causes the controller to just blast out fc packets.
          */
         if (!hw->fc.low_water || !hw->fc.high_water || !hw->fc.pause_time) {
-                hw_dbg(hw, "Invalid water mark configuration\n");
-                ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
-                goto out;
+                if (hw->fc.requested_mode != ixgbe_fc_none) {
+                        hw_dbg(hw, "Invalid water mark configuration\n");
+                        ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
+                        goto out;
+                }
         }
 
         /*
@@ -716,14 +742,23 @@ static s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw)
         }
 
         /* Reset PHY */
-        if (hw->phy.reset_disable == false)
+        if (hw->phy.reset_disable == false) {
+                /* PHY ops must be identified and initialized prior to reset */
+
+                /* Init PHY and function pointers, perform SFP setup */
+                status = hw->phy.ops.init(hw);
+                if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
+                        goto reset_hw_out;
+
                 hw->phy.ops.reset(hw);
+        }
 
         /*
          * Prevent the PCI-E bus from from hanging by disabling PCI-E master
          * access and verify no pending requests before reset
          */
-        if (ixgbe_disable_pcie_master(hw) != 0) {
+        status = ixgbe_disable_pcie_master(hw);
+        if (status != 0) {
                 status = IXGBE_ERR_MASTER_REQUESTS_PENDING;
                 hw_dbg(hw, "PCI-E Master disable polling has failed.\n");
         }
@@ -770,6 +805,7 @@ static s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw)
         /* Store the permanent mac address */
         hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
 
+reset_hw_out:
         return status;
 }
 
@@ -998,35 +1034,56 @@ out:
 static u32 ixgbe_get_supported_physical_layer_82598(struct ixgbe_hw *hw)
 {
         u32 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
+        u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
+        u32 pma_pmd_10g = autoc & IXGBE_AUTOC_10G_PMA_PMD_MASK;
+        u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
+        u16 ext_ability = 0;
+
+        hw->phy.ops.identify(hw);
+
+        /* Copper PHY must be checked before AUTOC LMS to determine correct
+         * physical layer because 10GBase-T PHYs use LMS = KX4/KX */
+        if (hw->phy.type == ixgbe_phy_tn ||
+            hw->phy.type == ixgbe_phy_cu_unknown) {
+                hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
+                IXGBE_MDIO_PMA_PMD_DEV_TYPE, &ext_ability);
+                if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
+                if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
+                if (ext_ability & IXGBE_MDIO_PHY_100BASETX_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_100BASE_TX;
+                goto out;
+        }
 
-        switch (hw->device_id) {
-        case IXGBE_DEV_ID_82598:
-                /* Default device ID is mezzanine card KX/KX4 */
-                physical_layer = (IXGBE_PHYSICAL_LAYER_10GBASE_KX4 |
-                                  IXGBE_PHYSICAL_LAYER_1000BASE_KX);
-                break;
-        case IXGBE_DEV_ID_82598_BX:
-                physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_BX;
-        case IXGBE_DEV_ID_82598EB_CX4:
-        case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
-                physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
-                break;
-        case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
-                physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
+        switch (autoc & IXGBE_AUTOC_LMS_MASK) {
+        case IXGBE_AUTOC_LMS_1G_AN:
+        case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
+                if (pma_pmd_1g == IXGBE_AUTOC_1G_KX)
+                        physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_KX;
+                else
+                        physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_BX;
                 break;
-        case IXGBE_DEV_ID_82598AF_DUAL_PORT:
-        case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
-        case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
-                physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
+        case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
+                if (pma_pmd_10g == IXGBE_AUTOC_10G_CX4)
+                        physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
+                else if (pma_pmd_10g == IXGBE_AUTOC_10G_KX4)
+                        physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
+                else /* XAUI */
+                        physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
                 break;
-        case IXGBE_DEV_ID_82598EB_XF_LR:
-                physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
+        case IXGBE_AUTOC_LMS_KX4_AN:
+        case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
+                if (autoc & IXGBE_AUTOC_KX_SUPP)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_KX;
+                if (autoc & IXGBE_AUTOC_KX4_SUPP)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
                 break;
-        case IXGBE_DEV_ID_82598AT:
-                physical_layer = (IXGBE_PHYSICAL_LAYER_10GBASE_T |
-                                  IXGBE_PHYSICAL_LAYER_1000BASE_T);
+        default:
                 break;
-        case IXGBE_DEV_ID_82598EB_SFP_LOM:
+        }
+
+        if (hw->phy.type == ixgbe_phy_nl) {
                 hw->phy.ops.identify_sfp(hw);
 
                 switch (hw->phy.sfp_type) {
@@ -1043,13 +1100,25 @@ static u32 ixgbe_get_supported_physical_layer_82598(struct ixgbe_hw *hw)
                         physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
                         break;
                 }
-                break;
+        }
 
+        switch (hw->device_id) {
+        case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
+                physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
+                break;
+        case IXGBE_DEV_ID_82598AF_DUAL_PORT:
+        case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
+        case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
+                physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
+                break;
+        case IXGBE_DEV_ID_82598EB_XF_LR:
+                physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
+                break;
         default:
-                physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
                 break;
         }
 
+out:
         return physical_layer;
 }
 
@@ -1099,6 +1168,7 @@ static struct ixgbe_eeprom_operations eeprom_ops_82598 = {
 static struct ixgbe_phy_operations phy_ops_82598 = {
         .identify               = &ixgbe_identify_phy_generic,
         .identify_sfp           = &ixgbe_identify_sfp_module_generic,
+        .init                   = &ixgbe_init_phy_ops_82598,
         .reset                  = &ixgbe_reset_phy_generic,
         .read_reg               = &ixgbe_read_phy_reg_generic,
         .write_reg              = &ixgbe_write_phy_reg_generic,
diff --git a/drivers/net/ixgbe/ixgbe_82599.c b/drivers/net/ixgbe/ixgbe_82599.c
index 29771fbaa42d..9e824b450416 100644
--- a/drivers/net/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ixgbe/ixgbe_82599.c
@@ -100,6 +100,9 @@ s32 ixgbe_setup_sfp_modules_82599(struct ixgbe_hw *hw)
 
         if (hw->phy.sfp_type != ixgbe_sfp_type_unknown) {
                 ixgbe_init_mac_link_ops_82599(hw);
+
+                hw->phy.ops.reset = NULL;
+
                 ret_val = ixgbe_get_sfp_init_sequence_offsets(hw, &list_offset,
                                                               &data_offset);
 
@@ -146,51 +149,60 @@ u32 ixgbe_get_pcie_msix_count_82599(struct ixgbe_hw *hw)
 static s32 ixgbe_get_invariants_82599(struct ixgbe_hw *hw)
 {
         struct ixgbe_mac_info *mac = &hw->mac;
-        struct ixgbe_phy_info *phy = &hw->phy;
-        s32 ret_val;
 
-        /* Set the bus information prior to PHY identification */
-        mac->ops.get_bus_info(hw);
+        ixgbe_init_mac_link_ops_82599(hw);
 
-        /* Call PHY identify routine to get the Cu or SFI phy type */
-        ret_val = phy->ops.identify(hw);
+        mac->mcft_size = IXGBE_82599_MC_TBL_SIZE;
+        mac->vft_size = IXGBE_82599_VFT_TBL_SIZE;
+        mac->num_rar_entries = IXGBE_82599_RAR_ENTRIES;
+        mac->max_rx_queues = IXGBE_82599_MAX_RX_QUEUES;
+        mac->max_tx_queues = IXGBE_82599_MAX_TX_QUEUES;
+        mac->max_msix_vectors = ixgbe_get_pcie_msix_count_82599(hw);
 
-        if (ret_val == IXGBE_ERR_SFP_NOT_SUPPORTED)
-                goto get_invariants_out;
+        return 0;
+}
 
-        ixgbe_init_mac_link_ops_82599(hw);
+/**
+ *  ixgbe_init_phy_ops_82599 - PHY/SFP specific init
+ *  @hw: pointer to hardware structure
+ *
+ *  Initialize any function pointers that were not able to be
+ *  set during get_invariants because the PHY/SFP type was
+ *  not known.  Perform the SFP init if necessary.
+ *
+ **/
+s32 ixgbe_init_phy_ops_82599(struct ixgbe_hw *hw)
+{
+        struct ixgbe_mac_info *mac = &hw->mac;
+        struct ixgbe_phy_info *phy = &hw->phy;
+        s32 ret_val = 0;
 
-        /* Setup SFP module if there is one present. */
-        ret_val = mac->ops.setup_sfp(hw);
+        /* Identify the PHY or SFP module */
+        ret_val = phy->ops.identify(hw);
+
+        /* Setup function pointers based on detected SFP module and speeds */
+        ixgbe_init_mac_link_ops_82599(hw);
 
         /* If copper media, overwrite with copper function pointers */
         if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
                 mac->ops.setup_link = &ixgbe_setup_copper_link_82599;
                 mac->ops.setup_link_speed =
-                                  &ixgbe_setup_copper_link_speed_82599;
+                                     &ixgbe_setup_copper_link_speed_82599;
                 mac->ops.get_link_capabilities =
                                   &ixgbe_get_copper_link_capabilities_82599;
         }
 
-        /* PHY Init */
+        /* Set necessary function pointers based on phy type */
         switch (hw->phy.type) {
         case ixgbe_phy_tn:
                 phy->ops.check_link = &ixgbe_check_phy_link_tnx;
                 phy->ops.get_firmware_version =
-                                  &ixgbe_get_phy_firmware_version_tnx;
+                             &ixgbe_get_phy_firmware_version_tnx;
                 break;
         default:
                 break;
         }
 
-        mac->mcft_size = IXGBE_82599_MC_TBL_SIZE;
-        mac->vft_size = IXGBE_82599_VFT_TBL_SIZE;
-        mac->num_rar_entries = IXGBE_82599_RAR_ENTRIES;
-        mac->max_rx_queues = IXGBE_82599_MAX_RX_QUEUES;
-        mac->max_tx_queues = IXGBE_82599_MAX_TX_QUEUES;
-        mac->max_msix_vectors = ixgbe_get_pcie_msix_count_82599(hw);
-
-get_invariants_out:
         return ret_val;
 }
 
@@ -207,8 +219,19 @@ s32 ixgbe_get_link_capabilities_82599(struct ixgbe_hw *hw,
                                       bool *negotiation)
 {
         s32 status = 0;
+        u32 autoc = 0;
+
+        /*
+         * Determine link capabilities based on the stored value of AUTOC,
+         * which represents EEPROM defaults.  If AUTOC value has not been
+         * stored, use the current register value.
+         */
+        if (hw->mac.orig_link_settings_stored)
+                autoc = hw->mac.orig_autoc;
+        else
+                autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 
-        switch (hw->mac.orig_autoc & IXGBE_AUTOC_LMS_MASK) {
+        switch (autoc & IXGBE_AUTOC_LMS_MASK) {
         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
                 *negotiation = false;
@@ -232,22 +255,22 @@ s32 ixgbe_get_link_capabilities_82599(struct ixgbe_hw *hw,
         case IXGBE_AUTOC_LMS_KX4_KX_KR:
         case IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN:
                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KR_SUPP)
+                if (autoc & IXGBE_AUTOC_KR_SUPP)
                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX4_SUPP)
+                if (autoc & IXGBE_AUTOC_KX4_SUPP)
                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX_SUPP)
+                if (autoc & IXGBE_AUTOC_KX_SUPP)
                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
                 *negotiation = true;
                 break;
 
         case IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII:
                 *speed = IXGBE_LINK_SPEED_100_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KR_SUPP)
+                if (autoc & IXGBE_AUTOC_KR_SUPP)
                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX4_SUPP)
+                if (autoc & IXGBE_AUTOC_KX4_SUPP)
                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
-                if (hw->mac.orig_autoc & IXGBE_AUTOC_KX_SUPP)
+                if (autoc & IXGBE_AUTOC_KX_SUPP)
                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
                 *negotiation = true;
                 break;
@@ -558,6 +581,7 @@ s32 ixgbe_setup_mac_link_speed_82599(struct ixgbe_hw *hw,
         s32 status = 0;
         u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
         u32 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
+        u32 orig_autoc = 0;
         u32 link_mode = autoc & IXGBE_AUTOC_LMS_MASK;
         u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
         u32 pma_pmd_10g_serial = autoc2 & IXGBE_AUTOC2_10G_SERIAL_PMA_PMD_MASK;
@@ -569,6 +593,13 @@ s32 ixgbe_setup_mac_link_speed_82599(struct ixgbe_hw *hw,
         hw->mac.ops.get_link_capabilities(hw, &link_capabilities, &autoneg);
         speed &= link_capabilities;
 
+        /* Use stored value (EEPROM defaults) of AUTOC to find KR/KX4 support*/
+        if (hw->mac.orig_link_settings_stored)
+                orig_autoc = hw->mac.orig_autoc;
+        else
+                orig_autoc = autoc;
+
+
         if (speed == IXGBE_LINK_SPEED_UNKNOWN) {
                 status = IXGBE_ERR_LINK_SETUP;
         } else if (link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR ||
@@ -577,9 +608,9 @@ s32 ixgbe_setup_mac_link_speed_82599(struct ixgbe_hw *hw,
                 /* Set KX4/KX/KR support according to speed requested */
                 autoc &= ~(IXGBE_AUTOC_KX4_KX_SUPP_MASK | IXGBE_AUTOC_KR_SUPP);
                 if (speed & IXGBE_LINK_SPEED_10GB_FULL)
-                        if (hw->mac.orig_autoc & IXGBE_AUTOC_KX4_SUPP)
+                        if (orig_autoc & IXGBE_AUTOC_KX4_SUPP)
                                 autoc |= IXGBE_AUTOC_KX4_SUPP;
-                        if (hw->mac.orig_autoc & IXGBE_AUTOC_KR_SUPP)
+                        if (orig_autoc & IXGBE_AUTOC_KR_SUPP)
                                 autoc |= IXGBE_AUTOC_KR_SUPP;
                 if (speed & IXGBE_LINK_SPEED_1GB_FULL)
                         autoc |= IXGBE_AUTOC_KX_SUPP;
@@ -705,14 +736,30 @@ s32 ixgbe_reset_hw_82599(struct ixgbe_hw *hw)
         /* Call adapter stop to disable tx/rx and clear interrupts */
         hw->mac.ops.stop_adapter(hw);
 
+        /* PHY ops must be identified and initialized prior to reset */
+
+        /* Init PHY and function pointers, perform SFP setup */
+        status = hw->phy.ops.init(hw);
+
+        if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
+                goto reset_hw_out;
+
+        /* Setup SFP module if there is one present. */
+        if (hw->phy.sfp_setup_needed) {
+                status = hw->mac.ops.setup_sfp(hw);
+                hw->phy.sfp_setup_needed = false;
+        }
+
         /* Reset PHY */
-        hw->phy.ops.reset(hw);
+        if (hw->phy.reset_disable == false && hw->phy.ops.reset != NULL)
+                hw->phy.ops.reset(hw);
 
         /*
          * Prevent the PCI-E bus from from hanging by disabling PCI-E master
          * access and verify no pending requests before reset
          */
-        if (ixgbe_disable_pcie_master(hw) != 0) {
+        status = ixgbe_disable_pcie_master(hw);
+        if (status != 0) {
                 status = IXGBE_ERR_MASTER_REQUESTS_PENDING;
                 hw_dbg(hw, "PCI-E Master disable polling has failed.\n");
         }
@@ -773,6 +820,7 @@ s32 ixgbe_reset_hw_82599(struct ixgbe_hw *hw)
         /* Store the permanent mac address */
         hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
 
+reset_hw_out:
         return status;
 }
 
@@ -1093,53 +1141,98 @@ s32 ixgbe_identify_phy_82599(struct ixgbe_hw *hw)
 u32 ixgbe_get_supported_physical_layer_82599(struct ixgbe_hw *hw)
 {
         u32 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
+        u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
+        u32 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
+        u32 pma_pmd_10g_serial = autoc2 & IXGBE_AUTOC2_10G_SERIAL_PMA_PMD_MASK;
+        u32 pma_pmd_10g_parallel = autoc & IXGBE_AUTOC_10G_PMA_PMD_MASK;
+        u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
+        u16 ext_ability = 0;
         u8 comp_codes_10g = 0;
 
-        switch (hw->device_id) {
-        case IXGBE_DEV_ID_82599:
-        case IXGBE_DEV_ID_82599_KX4:
-                /* Default device ID is mezzanine card KX/KX4 */
-                physical_layer = (IXGBE_PHYSICAL_LAYER_10GBASE_KX4 |
-                                  IXGBE_PHYSICAL_LAYER_1000BASE_KX);
+        hw->phy.ops.identify(hw);
+
+        if (hw->phy.type == ixgbe_phy_tn ||
+            hw->phy.type == ixgbe_phy_cu_unknown) {
+                hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
+                IXGBE_MDIO_PMA_PMD_DEV_TYPE, &ext_ability);
+                if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
+                if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
+                if (ext_ability & IXGBE_MDIO_PHY_100BASETX_ABILITY)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_100BASE_TX;
+                goto out;
+        }
+
+        switch (autoc & IXGBE_AUTOC_LMS_MASK) {
+        case IXGBE_AUTOC_LMS_1G_AN:
+        case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
+                if (pma_pmd_1g == IXGBE_AUTOC_1G_KX_BX) {
+                        physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_KX |
+                            IXGBE_PHYSICAL_LAYER_1000BASE_BX;
+                        goto out;
+                } else
+                        /* SFI mode so read SFP module */
+                        goto sfp_check;
                 break;
-        case IXGBE_DEV_ID_82599_SFP:
-                hw->phy.ops.identify_sfp(hw);
+        case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
+                if (pma_pmd_10g_parallel == IXGBE_AUTOC_10G_CX4)
+                        physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
+                else if (pma_pmd_10g_parallel == IXGBE_AUTOC_10G_KX4)
+                        physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
+                goto out;
+                break;
+        case IXGBE_AUTOC_LMS_10G_SERIAL:
+                if (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_KR) {
+                        physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KR;
+                        goto out;
+                } else if (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI)
+                        goto sfp_check;
+                break;
+        case IXGBE_AUTOC_LMS_KX4_KX_KR:
+        case IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN:
+                if (autoc & IXGBE_AUTOC_KX_SUPP)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_KX;
+                if (autoc & IXGBE_AUTOC_KX4_SUPP)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
+                if (autoc & IXGBE_AUTOC_KR_SUPP)
+                        physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KR;
+                goto out;
+                break;
+        default:
+                goto out;
+                break;
+        }
 
-                switch (hw->phy.sfp_type) {
-                case ixgbe_sfp_type_da_cu:
-                case ixgbe_sfp_type_da_cu_core0:
-                case ixgbe_sfp_type_da_cu_core1:
-                        physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
-                        break;
-                case ixgbe_sfp_type_sr:
+sfp_check:
+        /* SFP check must be done last since DA modules are sometimes used to
+         * test KR mode -  we need to id KR mode correctly before SFP module.
+         * Call identify_sfp because the pluggable module may have changed */
+        hw->phy.ops.identify_sfp(hw);
+        if (hw->phy.sfp_type == ixgbe_sfp_type_not_present)
+                goto out;
+
+        switch (hw->phy.type) {
+        case ixgbe_phy_tw_tyco:
+        case ixgbe_phy_tw_unknown:
+                physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
+                break;
+        case ixgbe_phy_sfp_avago:
+        case ixgbe_phy_sfp_ftl:
+        case ixgbe_phy_sfp_intel:
+        case ixgbe_phy_sfp_unknown:
+                hw->phy.ops.read_i2c_eeprom(hw,
+                      IXGBE_SFF_10GBE_COMP_CODES, &comp_codes_10g);
+                if (comp_codes_10g & IXGBE_SFF_10GBASESR_CAPABLE)
                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
-                        break;
-                case ixgbe_sfp_type_lr:
+                else if (comp_codes_10g & IXGBE_SFF_10GBASELR_CAPABLE)
                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
-                        break;
-                case ixgbe_sfp_type_srlr_core0:
-                case ixgbe_sfp_type_srlr_core1:
-                        hw->phy.ops.read_i2c_eeprom(hw,
-                                                    IXGBE_SFF_10GBE_COMP_CODES,
-                                                    &comp_codes_10g);
-                        if (comp_codes_10g & IXGBE_SFF_10GBASESR_CAPABLE)
-                                physical_layer =
-                                                IXGBE_PHYSICAL_LAYER_10GBASE_SR;
-                        else if (comp_codes_10g & IXGBE_SFF_10GBASELR_CAPABLE)
-                                physical_layer =
-                                                IXGBE_PHYSICAL_LAYER_10GBASE_LR;
-                        else
-                                physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
-                default:
-                        physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
-                        break;
-                }
                 break;
         default:
-                physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
                 break;
         }
 
+out:
         return physical_layer;
 }
 
@@ -1187,6 +1280,22 @@ s32 ixgbe_enable_rx_dma_82599(struct ixgbe_hw *hw, u32 regval)
         return 0;
 }
 
+/**
+ *  ixgbe_get_device_caps_82599 - Get additional device capabilities
+ *  @hw: pointer to hardware structure
+ *  @device_caps: the EEPROM word with the extra device capabilities
+ *
+ *  This function will read the EEPROM location for the device capabilities,
+ *  and return the word through device_caps.
+ **/
+s32 ixgbe_get_device_caps_82599(struct ixgbe_hw *hw, u16 *device_caps)
+{
+        hw->eeprom.ops.read(hw, IXGBE_DEVICE_CAPS, device_caps);
+
+        return 0;
+}
+
+
 static struct ixgbe_mac_operations mac_ops_82599 = {
         .init_hw                = &ixgbe_init_hw_generic,
         .reset_hw               = &ixgbe_reset_hw_82599,
@@ -1196,6 +1305,7 @@ static struct ixgbe_mac_operations mac_ops_82599 = {
         .get_supported_physical_layer = &ixgbe_get_supported_physical_layer_82599,
         .enable_rx_dma          = &ixgbe_enable_rx_dma_82599,
         .get_mac_addr           = &ixgbe_get_mac_addr_generic,
+        .get_device_caps        = &ixgbe_get_device_caps_82599,
         .stop_adapter           = &ixgbe_stop_adapter_generic,
         .get_bus_info           = &ixgbe_get_bus_info_generic,
         .set_lan_id             = &ixgbe_set_lan_id_multi_port_pcie,
@@ -1236,6 +1346,7 @@ static struct ixgbe_eeprom_operations eeprom_ops_82599 = {
 static struct ixgbe_phy_operations phy_ops_82599 = {
         .identify               = &ixgbe_identify_phy_82599,
         .identify_sfp           = &ixgbe_identify_sfp_module_generic,
+        .init                   = &ixgbe_init_phy_ops_82599,
         .reset                  = &ixgbe_reset_phy_generic,
         .read_reg               = &ixgbe_read_phy_reg_generic,
         .write_reg              = &ixgbe_write_phy_reg_generic,
diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c
index 5567519676d5..5f2ee34e9d1d 100644
--- a/drivers/net/ixgbe/ixgbe_common.c
+++ b/drivers/net/ixgbe/ixgbe_common.c
@@ -1700,6 +1700,7 @@ s32 ixgbe_fc_enable(struct ixgbe_hw *hw, s32 packetbuf_num)
         }
 
         /* Enable 802.3x based flow control settings. */
+        mflcn_reg |= IXGBE_MFLCN_DPF;
         IXGBE_WRITE_REG(hw, IXGBE_MFLCN, mflcn_reg);
         IXGBE_WRITE_REG(hw, IXGBE_FCCFG, fccfg_reg);
 
@@ -1906,9 +1907,11 @@ s32 ixgbe_setup_fc_generic(struct ixgbe_hw *hw, s32 packetbuf_num)
          * because it causes the controller to just blast out fc packets.
          */
         if (!hw->fc.low_water || !hw->fc.high_water || !hw->fc.pause_time) {
-                hw_dbg(hw, "Invalid water mark configuration\n");
-                ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
-                goto out;
+                if (hw->fc.requested_mode != ixgbe_fc_none) {
+                        hw_dbg(hw, "Invalid water mark configuration\n");
+                        ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
+                        goto out;
+                }
         }
 
         /*
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 01884256f4c9..c45e4e7999ea 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -47,7 +47,7 @@ char ixgbe_driver_name[] = "ixgbe";
 static const char ixgbe_driver_string[] =
                               "Intel(R) 10 Gigabit PCI Express Network Driver";
 
-#define DRV_VERSION "2.0.8-k2"
+#define DRV_VERSION "2.0.16-k2"
 const char ixgbe_driver_version[] = DRV_VERSION;
 static char ixgbe_copyright[] = "Copyright (c) 1999-2009 Intel Corporation.";
 
@@ -3503,6 +3503,8 @@ static int ixgbe_open(struct net_device *netdev)
         if (test_bit(__IXGBE_TESTING, &adapter->state))
                 return -EBUSY;
 
+        netif_carrier_off(netdev);
+
         /* allocate transmit descriptors */
         err = ixgbe_setup_all_tx_resources(adapter);
         if (err)
@@ -4703,7 +4705,11 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
 
         /* reset_hw fills in the perm_addr as well */
         err = hw->mac.ops.reset_hw(hw);
-        if (err) {
+        if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
+                dev_err(&adapter->pdev->dev, "failed to load because an "
+                        "unsupported SFP+ module type was detected.\n");
+                goto err_sw_init;
+        } else if (err) {
                 dev_err(&adapter->pdev->dev, "HW Init failed: %d\n", err);
                 goto err_sw_init;
         }
@@ -4776,6 +4782,9 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         device_init_wakeup(&adapter->pdev->dev, true);
         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
+        /* pick up the PCI bus settings for reporting later */
+        hw->mac.ops.get_bus_info(hw);
+
         /* print bus type/speed/width info */
         dev_info(&pdev->dev, "(PCI Express:%s:%s) %pM\n",
                 ((hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0Gb/s":
@@ -4809,13 +4818,14 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         /* reset the hardware with the new settings */
         hw->mac.ops.start_hw(hw);
 
-        netif_carrier_off(netdev);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
                 goto err_register;
 
+        /* carrier off reporting is important to ethtool even BEFORE open */
+        netif_carrier_off(netdev);
+
 #ifdef CONFIG_IXGBE_DCA
         if (dca_add_requester(&pdev->dev) == 0) {
                 adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
diff --git a/drivers/net/ixgbe/ixgbe_phy.c b/drivers/net/ixgbe/ixgbe_phy.c
index 14e9606aa3b3..f3258ec901fe 100644
--- a/drivers/net/ixgbe/ixgbe_phy.c
+++ b/drivers/net/ixgbe/ixgbe_phy.c
@@ -552,6 +552,7 @@ s32 ixgbe_identify_sfp_module_generic(struct ixgbe_hw *hw)
 {
         s32 status = IXGBE_ERR_PHY_ADDR_INVALID;
         u32 vendor_oui = 0;
+        enum ixgbe_sfp_type stored_sfp_type = hw->phy.sfp_type;
         u8 identifier = 0;
         u8 comp_codes_1g = 0;
         u8 comp_codes_10g = 0;
@@ -620,8 +621,18 @@ s32 ixgbe_identify_sfp_module_generic(struct ixgbe_hw *hw)
                                 hw->phy.sfp_type = ixgbe_sfp_type_unknown;
                 }
 
+                if (hw->phy.sfp_type != stored_sfp_type)
+                        hw->phy.sfp_setup_needed = true;
+
+                /* Determine if the SFP+ PHY is dual speed or not. */
+                if (((comp_codes_1g & IXGBE_SFF_1GBASESX_CAPABLE) &&
+                   (comp_codes_10g & IXGBE_SFF_10GBASESR_CAPABLE)) ||
+                   ((comp_codes_1g & IXGBE_SFF_1GBASELX_CAPABLE) &&
+                   (comp_codes_10g & IXGBE_SFF_10GBASELR_CAPABLE)))
+                        hw->phy.multispeed_fiber = true;
+
                 /* Determine PHY vendor */
-                if (hw->phy.type == ixgbe_phy_unknown) {
+                if (hw->phy.type != ixgbe_phy_nl) {
                         hw->phy.id = identifier;
                         hw->phy.ops.read_i2c_eeprom(hw,
                                                     IXGBE_SFF_VENDOR_OUI_BYTE0,
@@ -671,9 +682,9 @@ s32 ixgbe_identify_sfp_module_generic(struct ixgbe_hw *hw)
                         goto out;
                 }
 
-                hw->eeprom.ops.read(hw, IXGBE_PHY_ENFORCE_INTEL_SFP_OFFSET,
-                                    &enforce_sfp);
-                if (!(enforce_sfp & IXGBE_PHY_ALLOW_ANY_SFP)) {
+                /* This is guaranteed to be 82599, no need to check for NULL */
+                hw->mac.ops.get_device_caps(hw, &enforce_sfp);
+                if (!(enforce_sfp & IXGBE_DEVICE_CAPS_ALLOW_ANY_SFP)) {
                         /* Make sure we're a supported PHY type */
                         if (hw->phy.type == ixgbe_phy_sfp_intel) {
                                 status = 0;
diff --git a/drivers/net/ixgbe/ixgbe_phy.h b/drivers/net/ixgbe/ixgbe_phy.h
index cc5f1b3287e1..c9964b7ce1b9 100644
--- a/drivers/net/ixgbe/ixgbe_phy.h
+++ b/drivers/net/ixgbe/ixgbe_phy.h
@@ -44,6 +44,7 @@
 /* Bitmasks */
 #define IXGBE_SFF_TWIN_AX_CAPABLE            0x80
 #define IXGBE_SFF_1GBASESX_CAPABLE           0x1
+#define IXGBE_SFF_1GBASELX_CAPABLE           0x2
 #define IXGBE_SFF_10GBASESR_CAPABLE          0x10
 #define IXGBE_SFF_10GBASELR_CAPABLE          0x20
 #define IXGBE_I2C_EEPROM_READ_MASK           0x100
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h
index 030ff0a9ea67..a3317d8fbf6a 100644
--- a/drivers/net/ixgbe/ixgbe_type.h
+++ b/drivers/net/ixgbe/ixgbe_type.h
@@ -862,6 +862,7 @@
 #define IXGBE_MDIO_PHY_EXT_ABILITY        0xB /* Ext Ability Reg */
 #define IXGBE_MDIO_PHY_10GBASET_ABILITY   0x0004 /* 10GBaseT capable */
 #define IXGBE_MDIO_PHY_1000BASET_ABILITY  0x0020 /* 1000BaseT capable */
+#define IXGBE_MDIO_PHY_100BASETX_ABILITY  0x0080 /* 100BaseTX capable */
 
 #define IXGBE_MDIO_PMA_PMD_SDA_SCL_ADDR     0xC30A /* PHY_XS SDA/SCL Addr Reg */
 #define IXGBE_MDIO_PMA_PMD_SDA_SCL_DATA     0xC30B /* PHY_XS SDA/SCL Data Reg */
@@ -898,8 +899,6 @@
 #define IXGBE_CONTROL_NL         0x000F
 #define IXGBE_CONTROL_EOL_NL     0x0FFF
 #define IXGBE_CONTROL_SOL_NL     0x0000
-#define IXGBE_PHY_ENFORCE_INTEL_SFP_OFFSET 0x002C
-#define IXGBE_PHY_ALLOW_ANY_SFP            0x1
 
 /* General purpose Interrupt Enable */
 #define IXGBE_SDP0_GPIEN         0x00000001 /* SDP0 */
@@ -958,6 +957,8 @@
 #define IXGBE_VT_CTL_DIS_DEFPL  0x20000000 /* disable default pool */
 #define IXGBE_VT_CTL_REPLEN     0x40000000 /* replication enabled */
 #define IXGBE_VT_CTL_VT_ENABLE  0x00000001  /* Enable VT Mode */
+#define IXGBE_VT_CTL_POOL_SHIFT 7
+#define IXGBE_VT_CTL_POOL_MASK  (0x3F << IXGBE_VT_CTL_POOL_SHIFT)
 
 /* VMOLR bitmasks */
 #define IXGBE_VMOLR_AUPE        0x01000000 /* accept untagged packets */
@@ -1148,6 +1149,7 @@
 
 /* Interrupt Vector Allocation Registers */
 #define IXGBE_IVAR_REG_NUM      25
+#define IXGBE_IVAR_REG_NUM_82599       64
 #define IXGBE_IVAR_TXRX_ENTRY   96
 #define IXGBE_IVAR_RX_ENTRY     64
 #define IXGBE_IVAR_RX_QUEUE(_i)    (0 + (_i))
@@ -1382,6 +1384,7 @@
 #define IXGBE_FW_PTR            0x0F
 #define IXGBE_PBANUM0_PTR       0x15
 #define IXGBE_PBANUM1_PTR       0x16
+#define IXGBE_DEVICE_CAPS       0x2C
 #define IXGBE_PCIE_MSIX_82599_CAPS  0x72
 #define IXGBE_PCIE_MSIX_82598_CAPS  0x62
 
@@ -1425,6 +1428,8 @@
 #define IXGBE_EERD_ATTEMPTS 100000
 #endif
 
+#define IXGBE_DEVICE_CAPS_ALLOW_ANY_SFP  0x1
+
 /* PCI Bus Info */
 #define IXGBE_PCI_LINK_STATUS     0xB2
 #define IXGBE_PCI_LINK_WIDTH      0x3F0
@@ -1553,7 +1558,8 @@
 #define IXGBE_MTQC_RT_ENA       0x1 /* DCB Enable */
 #define IXGBE_MTQC_VT_ENA       0x2 /* VMDQ2 Enable */
 #define IXGBE_MTQC_64Q_1PB      0x0 /* 64 queues 1 pack buffer */
-#define IXGBE_MTQC_64VF         0x8 /* 2 TX Queues per pool w/64VF's */
+#define IXGBE_MTQC_32VF         0x8 /* 4 TX Queues per pool w/32VF's */
+#define IXGBE_MTQC_64VF         0x4 /* 2 TX Queues per pool w/64VF's */
 #define IXGBE_MTQC_8TC_8TQ      0xC /* 8 TC if RT_ENA or 8 TQ if VT_ENA */
 
 /* Receive Descriptor bit definitions */
@@ -1861,7 +1867,7 @@ typedef u32 ixgbe_physical_layer;
 #define IXGBE_PHYSICAL_LAYER_UNKNOWN      0
 #define IXGBE_PHYSICAL_LAYER_10GBASE_T    0x0001
 #define IXGBE_PHYSICAL_LAYER_1000BASE_T   0x0002
-#define IXGBE_PHYSICAL_LAYER_100BASE_T    0x0004
+#define IXGBE_PHYSICAL_LAYER_100BASE_TX   0x0004
 #define IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU  0x0008
 #define IXGBE_PHYSICAL_LAYER_10GBASE_LR   0x0010
 #define IXGBE_PHYSICAL_LAYER_10GBASE_LRM  0x0020
@@ -1870,6 +1876,7 @@ typedef u32 ixgbe_physical_layer;
 #define IXGBE_PHYSICAL_LAYER_10GBASE_CX4  0x0100
 #define IXGBE_PHYSICAL_LAYER_1000BASE_KX  0x0200
 #define IXGBE_PHYSICAL_LAYER_1000BASE_BX  0x0400
+#define IXGBE_PHYSICAL_LAYER_10GBASE_KR   0x0800
 
 enum ixgbe_eeprom_type {
         ixgbe_eeprom_uninitialized = 0,
@@ -2101,6 +2108,7 @@ struct ixgbe_mac_operations {
         enum ixgbe_media_type (*get_media_type)(struct ixgbe_hw *);
         u32 (*get_supported_physical_layer)(struct ixgbe_hw *);
         s32 (*get_mac_addr)(struct ixgbe_hw *, u8 *);
+        s32 (*get_device_caps)(struct ixgbe_hw *, u16 *);
         s32 (*stop_adapter)(struct ixgbe_hw *);
         s32 (*get_bus_info)(struct ixgbe_hw *);
         void (*set_lan_id)(struct ixgbe_hw *);
@@ -2146,6 +2154,7 @@ struct ixgbe_mac_operations {
 struct ixgbe_phy_operations {
         s32 (*identify)(struct ixgbe_hw *);
         s32 (*identify_sfp)(struct ixgbe_hw *);
+        s32 (*init)(struct ixgbe_hw *);
         s32 (*reset)(struct ixgbe_hw *);
         s32 (*read_reg)(struct ixgbe_hw *, u32, u32, u16 *);
         s32 (*write_reg)(struct ixgbe_hw *, u32, u32, u16);
@@ -2193,6 +2202,7 @@ struct ixgbe_phy_info {
         u32                             addr;
         u32                             id;
         enum ixgbe_sfp_type             sfp_type;
+        bool                            sfp_setup_needed;
         u32                             revision;
         enum ixgbe_media_type           media_type;
         bool                            reset_disable;
diff --git a/drivers/net/ixp2000/ixpdev.c b/drivers/net/ixp2000/ixpdev.c
index d3bf2f017cc2..2a0174b62e96 100644
--- a/drivers/net/ixp2000/ixpdev.c
+++ b/drivers/net/ixp2000/ixpdev.c
@@ -270,6 +270,18 @@ static int ixpdev_close(struct net_device *dev)
         return 0;
 }
 
+static const struct net_device_ops ixpdev_netdev_ops = {
+        .ndo_open               = ixpdev_open,
+        .ndo_stop               = ixpdev_close,
+        .ndo_start_xmit         = ixpdev_xmit,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = ixpdev_poll_controller,
+#endif
+};
+
 struct net_device *ixpdev_alloc(int channel, int sizeof_priv)
 {
         struct net_device *dev;
@@ -279,12 +291,7 @@ struct net_device *ixpdev_alloc(int channel, int sizeof_priv)
         if (dev == NULL)
                 return NULL;
 
-        dev->hard_start_xmit = ixpdev_xmit;
-        dev->open = ixpdev_open;
-        dev->stop = ixpdev_close;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = ixpdev_poll_controller;
-#endif
+        dev->netdev_ops = &ixpdev_netdev_ops;
 
         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
 
diff --git a/drivers/net/jazzsonic.c b/drivers/net/jazzsonic.c
index 14248cfc3dfd..d12106b47bf2 100644
--- a/drivers/net/jazzsonic.c
+++ b/drivers/net/jazzsonic.c
@@ -96,6 +96,18 @@ static int jazzsonic_close(struct net_device* dev)
         return err;
 }
 
+static const struct net_device_ops sonic_netdev_ops = {
+        .ndo_open               = jazzsonic_open,
+        .ndo_stop               = jazzsonic_close,
+        .ndo_start_xmit         = sonic_send_packet,
+        .ndo_get_stats          = sonic_get_stats,
+        .ndo_set_multicast_list = sonic_multicast_list,
+        .ndo_tx_timeout         = sonic_tx_timeout,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int __init sonic_probe1(struct net_device *dev)
 {
         static unsigned version_printed;
@@ -179,12 +191,7 @@ static int __init sonic_probe1(struct net_device *dev)
         lp->rra_laddr = lp->rda_laddr + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
                              * SONIC_BUS_SCALE(lp->dma_bitmode));
 
-        dev->open = jazzsonic_open;
-        dev->stop = jazzsonic_close;
-        dev->hard_start_xmit = sonic_send_packet;
-        dev->get_stats = sonic_get_stats;
-        dev->set_multicast_list = &sonic_multicast_list;
-        dev->tx_timeout = sonic_tx_timeout;
+        dev->netdev_ops = &sonic_netdev_ops;
         dev->watchdog_timeo = TX_TIMEOUT;
 
         /*
diff --git a/drivers/net/korina.c b/drivers/net/korina.c
index 38d6649a29c4..dc238567cae1 100644
--- a/drivers/net/korina.c
+++ b/drivers/net/korina.c
@@ -1081,6 +1081,21 @@ static int korina_close(struct net_device *dev)
         return 0;
 }
 
+static const struct net_device_ops korina_netdev_ops = {
+        .ndo_open               = korina_open,
+        .ndo_stop               = korina_close,
+        .ndo_start_xmit         = korina_send_packet,
+        .ndo_set_multicast_list = korina_multicast_list,
+        .ndo_tx_timeout         = korina_tx_timeout,
+        .ndo_do_ioctl           = korina_ioctl,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = korina_poll_controller,
+#endif
+};
+
 static int korina_probe(struct platform_device *pdev)
 {
         struct korina_device *bif = platform_get_drvdata(pdev);
@@ -1149,17 +1164,9 @@ static int korina_probe(struct platform_device *pdev)
         dev->irq = lp->rx_irq;
         lp->dev = dev;
 
-        dev->open = korina_open;
-        dev->stop = korina_close;
-        dev->hard_start_xmit = korina_send_packet;
-        dev->set_multicast_list = &korina_multicast_list;
+        dev->netdev_ops = &korina_netdev_ops;
         dev->ethtool_ops = &netdev_ethtool_ops;
-        dev->tx_timeout = korina_tx_timeout;
         dev->watchdog_timeo = TX_TIMEOUT;
-        dev->do_ioctl = &korina_ioctl;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = korina_poll_controller;
-#endif
         netif_napi_add(dev, &lp->napi, korina_poll, 64);
 
         lp->phy_addr = (((lp->rx_irq == 0x2c? 1:0) << 8) | 0x05);
diff --git a/drivers/net/lib82596.c b/drivers/net/lib82596.c
index 7415f517491d..070fa4500871 100644
--- a/drivers/net/lib82596.c
+++ b/drivers/net/lib82596.c
@@ -1036,6 +1036,19 @@ static void print_eth(unsigned char *add, char *str)
         printk(KERN_DEBUG "i596 0x%p, %pM --> %pM %02X%02X, %s\n",
                add, add + 6, add, add[12], add[13], str);
 }
+static const struct net_device_ops i596_netdev_ops = {
+        .ndo_open               = i596_open,
+        .ndo_stop               = i596_close,
+        .ndo_start_xmit         = i596_start_xmit,
+        .ndo_set_multicast_list = set_multicast_list,
+        .ndo_tx_timeout         = i596_tx_timeout,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = i596_poll_controller,
+#endif
+};
 
 static int __devinit i82596_probe(struct net_device *dev)
 {
@@ -1062,16 +1075,8 @@ static int __devinit i82596_probe(struct net_device *dev)
                 return -ENOMEM;
         }
 
-        /* The 82596-specific entries in the device structure. */
-        dev->open = i596_open;
-        dev->stop = i596_close;
-        dev->hard_start_xmit = i596_start_xmit;
-        dev->set_multicast_list = set_multicast_list;
-        dev->tx_timeout = i596_tx_timeout;
+        dev->netdev_ops = &i596_netdev_ops;
         dev->watchdog_timeo = TX_TIMEOUT;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = i596_poll_controller;
-#endif
 
         memset(dma, 0, sizeof(struct i596_dma));
         lp->dma = dma;
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index b7d438a367f3..6f71157bea8e 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -62,6 +62,7 @@
 struct pcpu_lstats {
         unsigned long packets;
         unsigned long bytes;
+        unsigned long drops;
 };
 
 /*
@@ -71,18 +72,22 @@ struct pcpu_lstats {
 static int loopback_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct pcpu_lstats *pcpu_lstats, *lb_stats;
+        int len;
 
         skb_orphan(skb);
 
-        skb->protocol = eth_type_trans(skb,dev);
+        skb->protocol = eth_type_trans(skb, dev);
 
         /* it's OK to use per_cpu_ptr() because BHs are off */
         pcpu_lstats = dev->ml_priv;
         lb_stats = per_cpu_ptr(pcpu_lstats, smp_processor_id());
-        lb_stats->bytes += skb->len;
-        lb_stats->packets++;
 
-        netif_rx(skb);
+        len = skb->len;
+        if (likely(netif_rx(skb) == NET_RX_SUCCESS)) {
+                lb_stats->bytes += len;
+                lb_stats->packets++;
+        } else
+                lb_stats->drops++;
 
         return 0;
 }
@@ -93,6 +98,7 @@ static struct net_device_stats *loopback_get_stats(struct net_device *dev)
         struct net_device_stats *stats = &dev->stats;
         unsigned long bytes = 0;
         unsigned long packets = 0;
+        unsigned long drops = 0;
         int i;
 
         pcpu_lstats = dev->ml_priv;
@@ -102,11 +108,14 @@ static struct net_device_stats *loopback_get_stats(struct net_device *dev)
                 lb_stats = per_cpu_ptr(pcpu_lstats, i);
                 bytes   += lb_stats->bytes;
                 packets += lb_stats->packets;
+                drops   += lb_stats->drops;
         }
         stats->rx_packets = packets;
         stats->tx_packets = packets;
-        stats->rx_bytes = bytes;
-        stats->tx_bytes = bytes;
+        stats->rx_dropped = drops;
+        stats->rx_errors  = drops;
+        stats->rx_bytes   = bytes;
+        stats->tx_bytes   = bytes;
         return stats;
 }
 
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index feebbd92aff2..1ad740bc8878 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -94,6 +94,16 @@ static void __mace_set_address(struct net_device *dev, void *addr);
  */
 static unsigned char *dummy_buf;
 
+static const struct net_device_ops mace_netdev_ops = {
+        .ndo_open               = mace_open,
+        .ndo_stop               = mace_close,
+        .ndo_start_xmit         = mace_xmit_start,
+        .ndo_set_multicast_list = mace_set_multicast,
+        .ndo_set_mac_address    = mace_set_address,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static int __devinit mace_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct device_node *mace = macio_get_of_node(mdev);
@@ -207,11 +217,7 @@ static int __devinit mace_probe(struct macio_dev *mdev, const struct of_device_i
                 }
         }
 
-        dev->open = mace_open;
-        dev->stop = mace_close;
-        dev->hard_start_xmit = mace_xmit_start;
-        dev->set_multicast_list = mace_set_multicast;
-        dev->set_mac_address = mace_set_address;
+        dev->netdev_ops = &mace_netdev_ops;
 
         /*
          * Most of what is below could be moved to mace_open()
diff --git a/drivers/net/macmace.c b/drivers/net/macmace.c
index 274e99bb63ac..44f3c2896f20 100644
--- a/drivers/net/macmace.c
+++ b/drivers/net/macmace.c
@@ -180,6 +180,17 @@ static void mace_dma_off(struct net_device *dev)
         psc_write_word(PSC_ENETWR_CMD + PSC_SET1, 0x1100);
 }
 
+static const struct net_device_ops mace_netdev_ops = {
+        .ndo_open               = mace_open,
+        .ndo_stop               = mace_close,
+        .ndo_start_xmit         = mace_xmit_start,
+        .ndo_tx_timeout         = mace_tx_timeout,
+        .ndo_set_multicast_list = mace_set_multicast,
+        .ndo_set_mac_address    = mace_set_address,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 /*
  * Not really much of a probe. The hardware table tells us if this
  * model of Macintrash has a MACE (AV macintoshes)
@@ -240,13 +251,8 @@ static int __devinit mace_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        dev->open               = mace_open;
-        dev->stop               = mace_close;
-        dev->hard_start_xmit    = mace_xmit_start;
-        dev->tx_timeout         = mace_tx_timeout;
+        dev->netdev_ops         = &mace_netdev_ops;
         dev->watchdog_timeo     = TX_TIMEOUT;
-        dev->set_multicast_list = mace_set_multicast;
-        dev->set_mac_address    = mace_set_address;
 
         printk(KERN_INFO "%s: 68K MACE, hardware address %pM\n",
                dev->name, dev->dev_addr);
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index 214a8cf2b708..329cd50d0e29 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -374,36 +374,20 @@ static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
 static u32 macvlan_ethtool_get_rx_csum(struct net_device *dev)
 {
         const struct macvlan_dev *vlan = netdev_priv(dev);
-        struct net_device *lowerdev = vlan->lowerdev;
-
-        if (lowerdev->ethtool_ops == NULL ||
-            lowerdev->ethtool_ops->get_rx_csum == NULL)
-                return 0;
-        return lowerdev->ethtool_ops->get_rx_csum(lowerdev);
+        return dev_ethtool_get_rx_csum(vlan->lowerdev);
 }
 
 static int macvlan_ethtool_get_settings(struct net_device *dev,
                                         struct ethtool_cmd *cmd)
 {
         const struct macvlan_dev *vlan = netdev_priv(dev);
-        struct net_device *lowerdev = vlan->lowerdev;
-
-        if (!lowerdev->ethtool_ops ||
-            !lowerdev->ethtool_ops->get_settings)
-                return -EOPNOTSUPP;
-
-        return lowerdev->ethtool_ops->get_settings(lowerdev, cmd);
+        return dev_ethtool_get_settings(vlan->lowerdev, cmd);
 }
 
 static u32 macvlan_ethtool_get_flags(struct net_device *dev)
 {
         const struct macvlan_dev *vlan = netdev_priv(dev);
-        struct net_device *lowerdev = vlan->lowerdev;
-
-        if (!lowerdev->ethtool_ops ||
-            !lowerdev->ethtool_ops->get_flags)
-                return 0;
-        return lowerdev->ethtool_ops->get_flags(lowerdev);
+        return dev_ethtool_get_flags(vlan->lowerdev);
 }
 
 static const struct ethtool_ops macvlan_ethtool_ops = {
diff --git a/drivers/net/meth.c b/drivers/net/meth.c
index aa08987f6e81..46ffdb464ac4 100644
--- a/drivers/net/meth.c
+++ b/drivers/net/meth.c
@@ -769,9 +769,17 @@ static int meth_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         }
 }
 
-/*
- * Return statistics to the caller
- */
+static const struct net_device_ops meth_netdev_ops = {
+        .ndo_open               = meth_open,
+        .ndo_stop               = meth_release,
+        .ndo_start_xmit         = meth_tx,
+        .ndo_do_ioctl           = meth_ioctl,
+        .ndo_tx_timeout         = meth_tx_timeout,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 /*
  * The init function.
  */
@@ -785,16 +793,10 @@ static int __init meth_probe(struct platform_device *pdev)
         if (!dev)
                 return -ENOMEM;
 
-        dev->open            = meth_open;
-        dev->stop            = meth_release;
-        dev->hard_start_xmit = meth_tx;
-        dev->do_ioctl        = meth_ioctl;
-#ifdef HAVE_TX_TIMEOUT
-        dev->tx_timeout      = meth_tx_timeout;
-        dev->watchdog_timeo  = timeout;
-#endif
-        dev->irq             = MACE_ETHERNET_IRQ;
-        dev->base_addr       = (unsigned long)&mace->eth;
+        dev->netdev_ops         = &meth_netdev_ops;
+        dev->watchdog_timeo     = timeout;
+        dev->irq                = MACE_ETHERNET_IRQ;
+        dev->base_addr          = (unsigned long)&mace->eth;
         memcpy(dev->dev_addr, o2meth_eaddr, 6);
 
         priv = netdev_priv(dev);
diff --git a/drivers/net/mipsnet.c b/drivers/net/mipsnet.c
index 664835b822fb..b3b9a147d09a 100644
--- a/drivers/net/mipsnet.c
+++ b/drivers/net/mipsnet.c
@@ -237,6 +237,16 @@ static void mipsnet_set_mclist(struct net_device *dev)
 {
 }
 
+static const struct net_device_ops mipsnet_netdev_ops = {
+        .ndo_open               = mipsnet_open,
+        .ndo_stop               = mipsnet_close,
+        .ndo_start_xmit         = mipsnet_xmit,
+        .ndo_set_multicast_list = mipsnet_set_mclist,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int __init mipsnet_probe(struct platform_device *dev)
 {
         struct net_device *netdev;
@@ -250,10 +260,7 @@ static int __init mipsnet_probe(struct platform_device *dev)
 
         platform_set_drvdata(dev, netdev);
 
-        netdev->open                    = mipsnet_open;
-        netdev->stop                    = mipsnet_close;
-        netdev->hard_start_xmit         = mipsnet_xmit;
-        netdev->set_multicast_list      = mipsnet_set_mclist;
+        netdev->netdev_ops = &mipsnet_netdev_ops;
 
         /*
          * TODO: probe for these or load them from PARAM
diff --git a/drivers/net/mvme147.c b/drivers/net/mvme147.c
index 435e5a847c43..93c709d63e2f 100644
--- a/drivers/net/mvme147.c
+++ b/drivers/net/mvme147.c
@@ -57,6 +57,17 @@ typedef void (*writerap_t)(void *, unsigned short);
 typedef void (*writerdp_t)(void *, unsigned short);
 typedef unsigned short (*readrdp_t)(void *);
 
+static const struct net_device_ops lance_netdev_ops = {
+        .ndo_open               = m147lance_open,
+        .ndo_stop               = m147lance_close,
+        .ndo_start_xmit         = lance_start_xmit,
+        .ndo_set_multicast_list = lance_set_multicast,
+        .ndo_tx_timeout         = lance_tx_timeout,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 /* Initialise the one and only on-board 7990 */
 struct net_device * __init mvme147lance_probe(int unit)
 {
@@ -81,11 +92,7 @@ struct net_device * __init mvme147lance_probe(int unit)
 
         /* Fill the dev fields */
         dev->base_addr = (unsigned long)MVME147_LANCE_BASE;
-        dev->open = &m147lance_open;
-        dev->stop = &m147lance_close;
-        dev->hard_start_xmit = &lance_start_xmit;
-        dev->set_multicast_list = &lance_set_multicast;
-        dev->tx_timeout = &lance_tx_timeout;
+        dev->netdev_ops = &lance_netdev_ops;
         dev->dma = 0;
 
         addr=(u_long *)ETHERNET_ADDRESS;
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index f2c4a665e93f..140794a8d56a 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -75,7 +75,7 @@
 #include "myri10ge_mcp.h"
 #include "myri10ge_mcp_gen_header.h"
 
-#define MYRI10GE_VERSION_STR "1.4.4-1.401"
+#define MYRI10GE_VERSION_STR "1.4.4-1.412"
 
 MODULE_DESCRIPTION("Myricom 10G driver (10GbE)");
 MODULE_AUTHOR("Maintainer: help@myri.com");
@@ -255,6 +255,7 @@ struct myri10ge_priv {
         u32 read_write_dma;
         u32 link_changes;
         u32 msg_enable;
+        unsigned int board_number;
 };
 
 static char *myri10ge_fw_unaligned = "myri10ge_ethp_z8e.dat";
@@ -266,6 +267,13 @@ static char *myri10ge_fw_name = NULL;
 module_param(myri10ge_fw_name, charp, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(myri10ge_fw_name, "Firmware image name");
 
+#define MYRI10GE_MAX_BOARDS 8
+static char *myri10ge_fw_names[MYRI10GE_MAX_BOARDS] =
+    {[0 ... (MYRI10GE_MAX_BOARDS - 1)] = NULL };
+module_param_array_named(myri10ge_fw_names, myri10ge_fw_names, charp, NULL,
+                         0444);
+MODULE_PARM_DESC(myri10ge_fw_name, "Firmware image names per board");
+
 static int myri10ge_ecrc_enable = 1;
 module_param(myri10ge_ecrc_enable, int, S_IRUGO);
 MODULE_PARM_DESC(myri10ge_ecrc_enable, "Enable Extended CRC on PCI-E");
@@ -361,6 +369,8 @@ static inline void put_be32(__be32 val, __be32 __iomem * p)
         __raw_writel((__force __u32) val, (__force void __iomem *)p);
 }
 
+static struct net_device_stats *myri10ge_get_stats(struct net_device *dev);
+
 static int
 myri10ge_send_cmd(struct myri10ge_priv *mgp, u32 cmd,
                   struct myri10ge_cmd *data, int atomic)
@@ -1686,7 +1696,7 @@ myri10ge_get_ringparam(struct net_device *netdev,
         ring->rx_mini_max_pending = mgp->ss[0].rx_small.mask + 1;
         ring->rx_max_pending = mgp->ss[0].rx_big.mask + 1;
         ring->rx_jumbo_max_pending = 0;
-        ring->tx_max_pending = mgp->ss[0].rx_small.mask + 1;
+        ring->tx_max_pending = mgp->ss[0].tx.mask + 1;
         ring->rx_mini_pending = ring->rx_mini_max_pending;
         ring->rx_pending = ring->rx_max_pending;
         ring->rx_jumbo_pending = ring->rx_jumbo_max_pending;
@@ -1803,6 +1813,8 @@ myri10ge_get_ethtool_stats(struct net_device *netdev,
         int slice;
         int i;
 
+        /* force stats update */
+        (void)myri10ge_get_stats(netdev);
         for (i = 0; i < MYRI10GE_NET_STATS_LEN; i++)
                 data[i] = ((unsigned long *)&mgp->stats)[i];
 
@@ -2969,6 +2981,7 @@ static struct net_device_stats *myri10ge_get_stats(struct net_device *dev)
         struct net_device_stats *stats = &mgp->stats;
         int i;
 
+        spin_lock(&mgp->stats_lock);
         memset(stats, 0, sizeof(*stats));
         for (i = 0; i < mgp->num_slices; i++) {
                 slice_stats = &mgp->ss[i].stats;
@@ -2979,6 +2992,7 @@ static struct net_device_stats *myri10ge_get_stats(struct net_device *dev)
                 stats->rx_dropped += slice_stats->rx_dropped;
                 stats->tx_dropped += slice_stats->tx_dropped;
         }
+        spin_unlock(&mgp->stats_lock);
         return stats;
 }
 
@@ -3253,6 +3267,8 @@ abort:
 
 static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
 {
+        int overridden = 0;
+
         if (myri10ge_force_firmware == 0) {
                 int link_width, exp_cap;
                 u16 lnk;
@@ -3286,10 +3302,18 @@ static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
                 }
         }
         if (myri10ge_fw_name != NULL) {
-                dev_info(&mgp->pdev->dev, "overriding firmware to %s\n",
-                         myri10ge_fw_name);
+                overridden = 1;
                 mgp->fw_name = myri10ge_fw_name;
         }
+        if (mgp->board_number < MYRI10GE_MAX_BOARDS &&
+            myri10ge_fw_names[mgp->board_number] != NULL &&
+            strlen(myri10ge_fw_names[mgp->board_number])) {
+                mgp->fw_name = myri10ge_fw_names[mgp->board_number];
+                overridden = 1;
+        }
+        if (overridden)
+                dev_info(&mgp->pdev->dev, "overriding firmware to %s\n",
+                         mgp->fw_name);
 }
 
 #ifdef CONFIG_PM
@@ -3754,6 +3778,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         int status = -ENXIO;
         int dac_enabled;
         unsigned hdr_offset, ss_offset;
+        static int board_number;
 
         netdev = alloc_etherdev_mq(sizeof(*mgp), MYRI10GE_MAX_SLICES);
         if (netdev == NULL) {
@@ -3770,6 +3795,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         mgp->pause = myri10ge_flow_control;
         mgp->intr_coal_delay = myri10ge_intr_coal_delay;
         mgp->msg_enable = netif_msg_init(myri10ge_debug, MYRI10GE_MSG_DEFAULT);
+        mgp->board_number = board_number;
         init_waitqueue_head(&mgp->down_wq);
 
         if (pci_enable_device(pdev)) {
@@ -3902,6 +3928,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         setup_timer(&mgp->watchdog_timer, myri10ge_watchdog_timer,
                     (unsigned long)mgp);
 
+        spin_lock_init(&mgp->stats_lock);
         SET_ETHTOOL_OPS(netdev, &myri10ge_ethtool_ops);
         INIT_WORK(&mgp->watchdog_work, myri10ge_watchdog);
         status = register_netdev(netdev);
@@ -3919,6 +3946,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                          netdev->irq, mgp->tx_boundary, mgp->fw_name,
                          (mgp->wc_enabled ? "Enabled" : "Disabled"));
 
+        board_number++;
         return 0;
 
 abort_with_state:
@@ -4008,6 +4036,8 @@ static struct pci_device_id myri10ge_pci_tbl[] = {
         {0},
 };
 
+MODULE_DEVICE_TABLE(pci, myri10ge_pci_tbl);
+
 static struct pci_driver myri10ge_driver = {
         .name = "myri10ge",
         .probe = myri10ge_probe,
diff --git a/drivers/net/netx-eth.c b/drivers/net/netx-eth.c
index 1861d5bbd96b..946366dcc992 100644
--- a/drivers/net/netx-eth.c
+++ b/drivers/net/netx-eth.c
@@ -301,6 +301,17 @@ netx_eth_phy_write(struct net_device *ndev, int phy_id, int reg, int value)
         while (readl(NETX_MIIMU) & MIIMU_SNRDY);
 }
 
+static const struct net_device_ops netx_eth_netdev_ops = {
+        .ndo_open               = netx_eth_open,
+        .ndo_stop               = netx_eth_close,
+        .ndo_start_xmit         = netx_eth_hard_start_xmit,
+        .ndo_tx_timeout         = netx_eth_timeout,
+        .ndo_set_multicast_list = netx_eth_set_multicast_list,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int netx_eth_enable(struct net_device *ndev)
 {
         struct netx_eth_priv *priv = netdev_priv(ndev);
@@ -309,12 +320,8 @@ static int netx_eth_enable(struct net_device *ndev)
 
         ether_setup(ndev);
 
-        ndev->open = netx_eth_open;
-        ndev->stop = netx_eth_close;
-        ndev->hard_start_xmit = netx_eth_hard_start_xmit;
-        ndev->tx_timeout = netx_eth_timeout;
+        ndev->netdev_ops = &netx_eth_netdev_ops;
         ndev->watchdog_timeo = msecs_to_jiffies(5000);
-        ndev->set_multicast_list = netx_eth_set_multicast_list;
 
         priv->msg_enable       = NETIF_MSG_LINK;
         priv->mii.phy_id_mask  = 0x1f;
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index c40815169f35..ebd6c2edc343 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -34,10 +34,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
-#include <linux/compiler.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
 #include <linux/netdevice.h>
@@ -49,18 +45,12 @@
 
 #include <linux/ethtool.h>
 #include <linux/mii.h>
-#include <linux/interrupt.h>
 #include <linux/timer.h>
 
-#include <linux/mm.h>
-#include <linux/mman.h>
 #include <linux/vmalloc.h>
 
-#include <asm/system.h>
 #include <asm/io.h>
 #include <asm/byteorder.h>
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
 
 #include "netxen_nic_hw.h"
 
@@ -84,10 +74,10 @@
         (sizeof(struct netxen_rx_buffer) * rds_ring->num_desc)
 #define STATUS_DESC_RINGSIZE(sds_ring)  \
         (sizeof(struct status_desc) * (sds_ring)->num_desc)
-#define TX_BUFF_RINGSIZE(adapter)       \
-        (sizeof(struct netxen_cmd_buffer) * adapter->num_txd)
-#define TX_DESC_RINGSIZE(adapter)       \
-        (sizeof(struct cmd_desc_type0) * adapter->num_txd)
+#define TX_BUFF_RINGSIZE(tx_ring)       \
+        (sizeof(struct netxen_cmd_buffer) * tx_ring->num_desc)
+#define TX_DESC_RINGSIZE(tx_ring)       \
+        (sizeof(struct cmd_desc_type0) * tx_ring->num_desc)
 
 #define find_diff_among(a,b,range) ((a)<(b)?((b)-(a)):((b)+(range)-(a)))
 
@@ -118,6 +108,7 @@
 #define NX_P3_A2                0x30
 #define NX_P3_B0                0x40
 #define NX_P3_B1                0x41
+#define NX_P3_B2                0x42
 
 #define NX_IS_REVISION_P2(REVISION)     (REVISION <= NX_P2_C1)
 #define NX_IS_REVISION_P3(REVISION)     (REVISION >= NX_P3_A0)
@@ -203,18 +194,10 @@
 #define MAX_RCV_DESCRIPTORS_10G         4096
 #define MAX_JUMBO_RCV_DESCRIPTORS       1024
 #define MAX_LRO_RCV_DESCRIPTORS         8
-#define MAX_RCVSTATUS_DESCRIPTORS       MAX_RCV_DESCRIPTORS
-#define MAX_JUMBO_RCV_DESC      MAX_JUMBO_RCV_DESCRIPTORS
-#define MAX_RCV_DESC            MAX_RCV_DESCRIPTORS
-#define MAX_RCVSTATUS_DESC      MAX_RCV_DESCRIPTORS
-#define MAX_EPG_DESCRIPTORS     (MAX_CMD_DESCRIPTORS * 8)
-#define NUM_RCV_DESC            (MAX_RCV_DESC + MAX_JUMBO_RCV_DESCRIPTORS + \
-                                 MAX_LRO_RCV_DESCRIPTORS)
-#define MIN_TX_COUNT    4096
-#define MIN_RX_COUNT    4096
 #define NETXEN_CTX_SIGNATURE    0xdee0
+#define NETXEN_CTX_SIGNATURE_V2 0x0002dee0
+#define NETXEN_CTX_RESET        0xbad0
 #define NETXEN_RCV_PRODUCER(ringid)     (ringid)
-#define MAX_FRAME_SIZE  0x10000 /* 64K MAX size for LSO */
 
 #define PHAN_PEG_RCV_INITIALIZED        0xff01
 #define PHAN_PEG_RCV_START_INITIALIZE   0xff00
@@ -253,12 +236,19 @@ typedef u32 netxen_ctx_msg;
 #define netxen_set_msg_opcode(config_word, val) \
         ((config_word) &= ~(0xf<<28), (config_word) |= (val & 0xf) << 28)
 
-struct netxen_rcv_context {
-        __le64 rcv_ring_addr;
-        __le32 rcv_ring_size;
+struct netxen_rcv_ring {
+        __le64 addr;
+        __le32 size;
         __le32 rsrvd;
 };
 
+struct netxen_sts_ring {
+        __le64 addr;
+        __le32 size;
+        __le16 msi_index;
+        __le16 rsvd;
+} ;
+
 struct netxen_ring_ctx {
 
         /* one command ring */
@@ -268,13 +258,18 @@ struct netxen_ring_ctx {
         __le32 rsrvd;
 
         /* three receive rings */
-        struct netxen_rcv_context rcv_ctx[3];
+        struct netxen_rcv_ring rcv_rings[NUM_RCV_DESC_RINGS];
 
-        /* one status ring */
         __le64 sts_ring_addr;
         __le32 sts_ring_size;
 
         __le32 ctx_id;
+
+        __le64 rsrvd_2[3];
+        __le32 sts_ring_count;
+        __le32 rsrvd_3;
+        struct netxen_sts_ring sts_rings[NUM_STS_DESC_RINGS];
+
 } __attribute__ ((aligned(64)));
 
 /*
@@ -373,6 +368,7 @@ struct rcv_desc {
 /* opcode field in status_desc */
 #define NETXEN_NIC_RXPKT_DESC  0x04
 #define NETXEN_OLD_RXPKT_DESC  0x3f
+#define NETXEN_NIC_RESPONSE_DESC 0x05
 
 /* for status field in status_desc */
 #define STATUS_NEED_CKSUM       (1)
@@ -382,13 +378,11 @@ struct rcv_desc {
 #define STATUS_OWNER_HOST       (0x1ULL << 56)
 #define STATUS_OWNER_PHANTOM    (0x2ULL << 56)
 
-/* Note: sizeof(status_desc) should always be a mutliple of 2 */
-
-#define netxen_get_sts_desc_lro_cnt(status_desc)        \
-        ((status_desc)->lro & 0x7F)
-#define netxen_get_sts_desc_lro_last_frag(status_desc)  \
-        (((status_desc)->lro & 0x80) >> 7)
-
+/* Status descriptor:
+   0-3 port, 4-7 status, 8-11 type, 12-27 total_length
+   28-43 reference_handle, 44-47 protocol, 48-52 pkt_offset
+   53-55 desc_cnt, 56-57 owner, 58-63 opcode
+ */
 #define netxen_get_sts_port(sts_data)   \
         ((sts_data) & 0x0F)
 #define netxen_get_sts_status(sts_data) \
@@ -403,41 +397,15 @@ struct rcv_desc {
         (((sts_data) >> 44) & 0x0F)
 #define netxen_get_sts_pkt_offset(sts_data)     \
         (((sts_data) >> 48) & 0x1F)
+#define netxen_get_sts_desc_cnt(sts_data)       \
+        (((sts_data) >> 53) & 0x7)
 #define netxen_get_sts_opcode(sts_data) \
         (((sts_data) >> 58) & 0x03F)
 
 struct status_desc {
-        /* Bit pattern: 0-3 port, 4-7 status, 8-11 type, 12-27 total_length
-           28-43 reference_handle, 44-47 protocol, 48-52 pkt_offset
-           53-55 desc_cnt, 56-57 owner, 58-63 opcode
-         */
-        __le64 status_desc_data;
-        union {
-                struct {
-                        __le32 hash_value;
-                        u8 hash_type;
-                        u8 msg_type;
-                        u8 unused;
-                        union {
-                                /* Bit pattern: 0-6 lro_count indicates frag
-                                 * sequence, 7 last_frag indicates last frag
-                                 */
-                                u8 lro;
-
-                                /* chained buffers */
-                                u8 nr_frags;
-                        };
-                };
-                struct {
-                        __le16 frag_handles[4];
-                };
-        };
+        __le64 status_desc_data[2];
 } __attribute__ ((aligned(16)));
 
-enum {
-        NETXEN_RCV_PEG_0 = 0,
-        NETXEN_RCV_PEG_1
-};
 /* The version of the main data structure */
 #define NETXEN_BDINFO_VERSION 1
 
@@ -447,85 +415,35 @@ enum {
 /* Max number of Gig ports on a Phantom board */
 #define NETXEN_MAX_PORTS 4
 
-typedef enum {
-        NETXEN_BRDTYPE_P1_BD = 0x0000,
-        NETXEN_BRDTYPE_P1_SB = 0x0001,
-        NETXEN_BRDTYPE_P1_SMAX = 0x0002,
-        NETXEN_BRDTYPE_P1_SOCK = 0x0003,
-
-        NETXEN_BRDTYPE_P2_SOCK_31 = 0x0008,
-        NETXEN_BRDTYPE_P2_SOCK_35 = 0x0009,
-        NETXEN_BRDTYPE_P2_SB35_4G = 0x000a,
-        NETXEN_BRDTYPE_P2_SB31_10G = 0x000b,
-        NETXEN_BRDTYPE_P2_SB31_2G = 0x000c,
-
-        NETXEN_BRDTYPE_P2_SB31_10G_IMEZ = 0x000d,
-        NETXEN_BRDTYPE_P2_SB31_10G_HMEZ = 0x000e,
-        NETXEN_BRDTYPE_P2_SB31_10G_CX4 = 0x000f,
-
-        NETXEN_BRDTYPE_P3_REF_QG = 0x0021,
-        NETXEN_BRDTYPE_P3_HMEZ = 0x0022,
-        NETXEN_BRDTYPE_P3_10G_CX4_LP = 0x0023,
-        NETXEN_BRDTYPE_P3_4_GB = 0x0024,
-        NETXEN_BRDTYPE_P3_IMEZ = 0x0025,
-        NETXEN_BRDTYPE_P3_10G_SFP_PLUS = 0x0026,
-        NETXEN_BRDTYPE_P3_10000_BASE_T = 0x0027,
-        NETXEN_BRDTYPE_P3_XG_LOM = 0x0028,
-        NETXEN_BRDTYPE_P3_4_GB_MM = 0x0029,
-        NETXEN_BRDTYPE_P3_10G_SFP_CT = 0x002a,
-        NETXEN_BRDTYPE_P3_10G_SFP_QT = 0x002b,
-        NETXEN_BRDTYPE_P3_10G_CX4 = 0x0031,
-        NETXEN_BRDTYPE_P3_10G_XFP = 0x0032,
-        NETXEN_BRDTYPE_P3_10G_TP = 0x0080
-
-} netxen_brdtype_t;
-
-typedef enum {
-        NETXEN_BRDMFG_INVENTEC = 1
-} netxen_brdmfg;
-
-typedef enum {
-        MEM_ORG_128Mbx4 = 0x0,  /* DDR1 only */
-        MEM_ORG_128Mbx8 = 0x1,  /* DDR1 only */
-        MEM_ORG_128Mbx16 = 0x2, /* DDR1 only */
-        MEM_ORG_256Mbx4 = 0x3,
-        MEM_ORG_256Mbx8 = 0x4,
-        MEM_ORG_256Mbx16 = 0x5,
-        MEM_ORG_512Mbx4 = 0x6,
-        MEM_ORG_512Mbx8 = 0x7,
-        MEM_ORG_512Mbx16 = 0x8,
-        MEM_ORG_1Gbx4 = 0x9,
-        MEM_ORG_1Gbx8 = 0xa,
-        MEM_ORG_1Gbx16 = 0xb,
-        MEM_ORG_2Gbx4 = 0xc,
-        MEM_ORG_2Gbx8 = 0xd,
-        MEM_ORG_2Gbx16 = 0xe,
-        MEM_ORG_128Mbx32 = 0x10002,     /* GDDR only */
-        MEM_ORG_256Mbx32 = 0x10005      /* GDDR only */
-} netxen_mn_mem_org_t;
-
-typedef enum {
-        MEM_ORG_512Kx36 = 0x0,
-        MEM_ORG_1Mx36 = 0x1,
-        MEM_ORG_2Mx36 = 0x2
-} netxen_sn_mem_org_t;
-
-typedef enum {
-        MEM_DEPTH_4MB = 0x1,
-        MEM_DEPTH_8MB = 0x2,
-        MEM_DEPTH_16MB = 0x3,
-        MEM_DEPTH_32MB = 0x4,
-        MEM_DEPTH_64MB = 0x5,
-        MEM_DEPTH_128MB = 0x6,
-        MEM_DEPTH_256MB = 0x7,
-        MEM_DEPTH_512MB = 0x8,
-        MEM_DEPTH_1GB = 0x9,
-        MEM_DEPTH_2GB = 0xa,
-        MEM_DEPTH_4GB = 0xb,
-        MEM_DEPTH_8GB = 0xc,
-        MEM_DEPTH_16GB = 0xd,
-        MEM_DEPTH_32GB = 0xe
-} netxen_mem_depth_t;
+#define NETXEN_BRDTYPE_P1_BD            0x0000
+#define NETXEN_BRDTYPE_P1_SB            0x0001
+#define NETXEN_BRDTYPE_P1_SMAX          0x0002
+#define NETXEN_BRDTYPE_P1_SOCK          0x0003
+
+#define NETXEN_BRDTYPE_P2_SOCK_31       0x0008
+#define NETXEN_BRDTYPE_P2_SOCK_35       0x0009
+#define NETXEN_BRDTYPE_P2_SB35_4G       0x000a
+#define NETXEN_BRDTYPE_P2_SB31_10G      0x000b
+#define NETXEN_BRDTYPE_P2_SB31_2G       0x000c
+
+#define NETXEN_BRDTYPE_P2_SB31_10G_IMEZ         0x000d
+#define NETXEN_BRDTYPE_P2_SB31_10G_HMEZ         0x000e
+#define NETXEN_BRDTYPE_P2_SB31_10G_CX4          0x000f
+
+#define NETXEN_BRDTYPE_P3_REF_QG        0x0021
+#define NETXEN_BRDTYPE_P3_HMEZ          0x0022
+#define NETXEN_BRDTYPE_P3_10G_CX4_LP    0x0023
+#define NETXEN_BRDTYPE_P3_4_GB          0x0024
+#define NETXEN_BRDTYPE_P3_IMEZ          0x0025
+#define NETXEN_BRDTYPE_P3_10G_SFP_PLUS  0x0026
+#define NETXEN_BRDTYPE_P3_10000_BASE_T  0x0027
+#define NETXEN_BRDTYPE_P3_XG_LOM        0x0028
+#define NETXEN_BRDTYPE_P3_4_GB_MM       0x0029
+#define NETXEN_BRDTYPE_P3_10G_SFP_CT    0x002a
+#define NETXEN_BRDTYPE_P3_10G_SFP_QT    0x002b
+#define NETXEN_BRDTYPE_P3_10G_CX4       0x0031
+#define NETXEN_BRDTYPE_P3_10G_XFP       0x0032
+#define NETXEN_BRDTYPE_P3_10G_TP        0x0080
 
 struct netxen_board_info {
         u32 header_version;
@@ -676,17 +594,15 @@ struct netxen_new_user_info {
 #define PRIMARY_IMAGE_BAD       0xffffffff
 
 /* Flash memory map */
-typedef enum {
-        NETXEN_CRBINIT_START = 0,       /* Crbinit section */
-        NETXEN_BRDCFG_START = 0x4000,   /* board config */
-        NETXEN_INITCODE_START = 0x6000, /* pegtune code */
-        NETXEN_BOOTLD_START = 0x10000,  /* bootld */
-        NETXEN_IMAGE_START = 0x43000,   /* compressed image */
-        NETXEN_SECONDARY_START = 0x200000,      /* backup images */
-        NETXEN_PXE_START = 0x3E0000,    /* user defined region */
-        NETXEN_USER_START = 0x3E8000,   /* User defined region for new boards */
-        NETXEN_FIXED_START = 0x3F0000   /* backup of crbinit */
-} netxen_flash_map_t;
+#define NETXEN_CRBINIT_START    0       /* crbinit section */
+#define NETXEN_BRDCFG_START     0x4000  /* board config */
+#define NETXEN_INITCODE_START   0x6000  /* pegtune code */
+#define NETXEN_BOOTLD_START     0x10000 /* bootld */
+#define NETXEN_IMAGE_START      0x43000 /* compressed image */
+#define NETXEN_SECONDARY_START  0x200000        /* backup images */
+#define NETXEN_PXE_START        0x3E0000        /* PXE boot rom */
+#define NETXEN_USER_START       0x3E8000        /* Firmare info */
+#define NETXEN_FIXED_START      0x3F0000        /* backup of crbinit */
 
 #define NX_FW_VERSION_OFFSET    (NETXEN_USER_START+0x408)
 #define NX_FW_SIZE_OFFSET       (NETXEN_USER_START+0x40c)
@@ -708,21 +624,8 @@ typedef enum {
 #define NETXEN_FLASH_SECONDARY_SIZE     (NETXEN_USER_START-NETXEN_SECONDARY_START)
 #define NETXEN_NUM_PRIMARY_SECTORS      (0x20)
 #define NETXEN_NUM_CONFIG_SECTORS       (1)
-#define PFX "NetXen: "
 extern char netxen_nic_driver_name[];
 
-/* Note: Make sure to not call this before adapter->port is valid */
-#if !defined(NETXEN_DEBUG)
-#define DPRINTK(klevel, fmt, args...)   do { \
-        } while (0)
-#else
-#define DPRINTK(klevel, fmt, args...)   do { \
-        printk(KERN_##klevel PFX "%s: %s: " fmt, __func__,\
-                (adapter != NULL && adapter->netdev != NULL) ? \
-                adapter->netdev->name : NULL, \
-                ## args); } while(0)
-#endif
-
 /* Number of status descriptors to handle per interrupt */
 #define MAX_STATUS_HANDLE       (64)
 
@@ -732,7 +635,7 @@ extern char netxen_nic_driver_name[];
  */
 struct netxen_skb_frag {
         u64 dma;
-        ulong length;
+        u64 length;
 };
 
 #define _netxen_set_bits(config_word, start, bits, val) {\
@@ -793,34 +696,24 @@ struct netxen_hardware_context {
 
         u8 cut_through;
         u8 revision_id;
+        u8 pci_func;
+        u8 linkup;
         u16 port_type;
-        int board_type;
-        u32 linkup;
-        /* Address of cmd ring in Phantom */
-        struct cmd_desc_type0 *cmd_desc_head;
-        dma_addr_t cmd_desc_phys_addr;
-        struct netxen_adapter *adapter;
-        int pci_func;
+        u16 board_type;
 };
 
 #define MINIMUM_ETHERNET_FRAME_SIZE     64      /* With FCS */
 #define ETHERNET_FCS_SIZE               4
 
 struct netxen_adapter_stats {
-        u64  rcvdbadskb;
         u64  xmitcalled;
-        u64  xmitedframes;
         u64  xmitfinished;
-        u64  badskblen;
-        u64  nocmddescriptor;
-        u64  polled;
         u64  rxdropped;
         u64  txdropped;
         u64  csummed;
         u64  no_rcv;
         u64  rxbytes;
         u64  txbytes;
-        u64  ints;
 };
 
 /*
@@ -852,14 +745,25 @@ struct nx_host_sds_ring {
         struct napi_struct napi;
         struct list_head free_list[NUM_RCV_DESC_RINGS];
 
-        u16 clean_tx;
-        u16 post_rxd;
         int irq;
 
         dma_addr_t phys_addr;
         char name[IFNAMSIZ+4];
 };
 
+struct nx_host_tx_ring {
+        u32 producer;
+        __le32 *hw_consumer;
+        u32 sw_consumer;
+        u32 crb_cmd_producer;
+        u32 crb_cmd_consumer;
+        u32 num_desc;
+
+        struct netxen_cmd_buffer *cmd_buf_arr;
+        struct cmd_desc_type0 *desc_head;
+        dma_addr_t phys_addr;
+};
+
 /*
  * Receive context. There is one such structure per instance of the
  * receive processing. Any state information that is relevant to
@@ -872,7 +776,7 @@ struct netxen_recv_context {
         u16 virt_port;
 
         struct nx_host_rds_ring rds_rings[NUM_RCV_DESC_RINGS];
-        struct nx_host_sds_ring sds_rings[NUM_STS_DESC_RINGS];
+        struct nx_host_sds_ring *sds_rings;
 };
 
 /* New HW context creation */
@@ -1154,31 +1058,118 @@ typedef struct {
 
 #define NX_MAC_EVENT            0x1
 
-enum {
-        NX_NIC_H2C_OPCODE_START = 0,
-        NX_NIC_H2C_OPCODE_CONFIG_RSS,
-        NX_NIC_H2C_OPCODE_CONFIG_RSS_TBL,
-        NX_NIC_H2C_OPCODE_CONFIG_INTR_COALESCE,
-        NX_NIC_H2C_OPCODE_CONFIG_LED,
-        NX_NIC_H2C_OPCODE_CONFIG_PROMISCUOUS,
-        NX_NIC_H2C_OPCODE_CONFIG_L2_MAC,
-        NX_NIC_H2C_OPCODE_LRO_REQUEST,
-        NX_NIC_H2C_OPCODE_GET_SNMP_STATS,
-        NX_NIC_H2C_OPCODE_PROXY_START_REQUEST,
-        NX_NIC_H2C_OPCODE_PROXY_STOP_REQUEST,
-        NX_NIC_H2C_OPCODE_PROXY_SET_MTU,
-        NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE,
-        NX_H2P_OPCODE_GET_FINGER_PRINT_REQUEST,
-        NX_H2P_OPCODE_INSTALL_LICENSE_REQUEST,
-        NX_H2P_OPCODE_GET_LICENSE_CAPABILITY_REQUEST,
-        NX_NIC_H2C_OPCODE_GET_NET_STATS,
-        NX_NIC_H2C_OPCODE_LAST
-};
+/*
+ * Driver --> Firmware
+ */
+#define NX_NIC_H2C_OPCODE_START                         0
+#define NX_NIC_H2C_OPCODE_CONFIG_RSS                    1
+#define NX_NIC_H2C_OPCODE_CONFIG_RSS_TBL                2
+#define NX_NIC_H2C_OPCODE_CONFIG_INTR_COALESCE          3
+#define NX_NIC_H2C_OPCODE_CONFIG_LED                    4
+#define NX_NIC_H2C_OPCODE_CONFIG_PROMISCUOUS            5
+#define NX_NIC_H2C_OPCODE_CONFIG_L2_MAC                 6
+#define NX_NIC_H2C_OPCODE_LRO_REQUEST                   7
+#define NX_NIC_H2C_OPCODE_GET_SNMP_STATS                8
+#define NX_NIC_H2C_OPCODE_PROXY_START_REQUEST           9
+#define NX_NIC_H2C_OPCODE_PROXY_STOP_REQUEST            10
+#define NX_NIC_H2C_OPCODE_PROXY_SET_MTU                 11
+#define NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE     12
+#define NX_NIC_H2C_OPCODE_GET_FINGER_PRINT_REQUEST      13
+#define NX_NIC_H2C_OPCODE_INSTALL_LICENSE_REQUEST       14
+#define NX_NIC_H2C_OPCODE_GET_LICENSE_CAPABILITY_REQUEST        15
+#define NX_NIC_H2C_OPCODE_GET_NET_STATS                 16
+#define NX_NIC_H2C_OPCODE_PROXY_UPDATE_P2V              17
+#define NX_NIC_H2C_OPCODE_CONFIG_IPADDR                 18
+#define NX_NIC_H2C_OPCODE_CONFIG_LOOPBACK               19
+#define NX_NIC_H2C_OPCODE_PROXY_STOP_DONE               20
+#define NX_NIC_H2C_OPCODE_GET_LINKEVENT                 21
+#define NX_NIC_C2C_OPCODE                               22
+#define NX_NIC_H2C_OPCODE_LAST                          23
+
+/*
+ * Firmware --> Driver
+ */
+
+#define NX_NIC_C2H_OPCODE_START                         128
+#define NX_NIC_C2H_OPCODE_CONFIG_RSS_RESPONSE           129
+#define NX_NIC_C2H_OPCODE_CONFIG_RSS_TBL_RESPONSE       130
+#define NX_NIC_C2H_OPCODE_CONFIG_MAC_RESPONSE           131
+#define NX_NIC_C2H_OPCODE_CONFIG_PROMISCUOUS_RESPONSE   132
+#define NX_NIC_C2H_OPCODE_CONFIG_L2_MAC_RESPONSE        133
+#define NX_NIC_C2H_OPCODE_LRO_DELETE_RESPONSE           134
+#define NX_NIC_C2H_OPCODE_LRO_ADD_FAILURE_RESPONSE      135
+#define NX_NIC_C2H_OPCODE_GET_SNMP_STATS                136
+#define NX_NIC_C2H_OPCODE_GET_FINGER_PRINT_REPLY        137
+#define NX_NIC_C2H_OPCODE_INSTALL_LICENSE_REPLY         138
+#define NX_NIC_C2H_OPCODE_GET_LICENSE_CAPABILITIES_REPLY 139
+#define NX_NIC_C2H_OPCODE_GET_NET_STATS_RESPONSE        140
+#define NX_NIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE        141
+#define NX_NIC_C2H_OPCODE_LAST                          142
 
 #define VPORT_MISS_MODE_DROP            0 /* drop all unmatched */
 #define VPORT_MISS_MODE_ACCEPT_ALL      1 /* accept all packets */
 #define VPORT_MISS_MODE_ACCEPT_MULTI    2 /* accept unmatched multicast */
 
+#define NX_FW_CAPABILITY_LINK_NOTIFICATION      (1 << 5)
+#define NX_FW_CAPABILITY_SWITCHING              (1 << 6)
+
+/* module types */
+#define LINKEVENT_MODULE_NOT_PRESENT                    1
+#define LINKEVENT_MODULE_OPTICAL_UNKNOWN                2
+#define LINKEVENT_MODULE_OPTICAL_SRLR                   3
+#define LINKEVENT_MODULE_OPTICAL_LRM                    4
+#define LINKEVENT_MODULE_OPTICAL_SFP_1G                 5
+#define LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE       6
+#define LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN    7
+#define LINKEVENT_MODULE_TWINAX                         8
+
+#define LINKSPEED_10GBPS        10000
+#define LINKSPEED_1GBPS         1000
+#define LINKSPEED_100MBPS       100
+#define LINKSPEED_10MBPS        10
+
+#define LINKSPEED_ENCODED_10MBPS        0
+#define LINKSPEED_ENCODED_100MBPS       1
+#define LINKSPEED_ENCODED_1GBPS         2
+
+#define LINKEVENT_AUTONEG_DISABLED      0
+#define LINKEVENT_AUTONEG_ENABLED       1
+
+#define LINKEVENT_HALF_DUPLEX           0
+#define LINKEVENT_FULL_DUPLEX           1
+
+#define LINKEVENT_LINKSPEED_MBPS        0
+#define LINKEVENT_LINKSPEED_ENCODED     1
+
+/* firmware response header:
+ *      63:58 - message type
+ *      57:56 - owner
+ *      55:53 - desc count
+ *      52:48 - reserved
+ *      47:40 - completion id
+ *      39:32 - opcode
+ *      31:16 - error code
+ *      15:00 - reserved
+ */
+#define netxen_get_nic_msgtype(msg_hdr) \
+        ((msg_hdr >> 58) & 0x3F)
+#define netxen_get_nic_msg_compid(msg_hdr)      \
+        ((msg_hdr >> 40) & 0xFF)
+#define netxen_get_nic_msg_opcode(msg_hdr)      \
+        ((msg_hdr >> 32) & 0xFF)
+#define netxen_get_nic_msg_errcode(msg_hdr)     \
+        ((msg_hdr >> 16) & 0xFFFF)
+
+typedef struct {
+        union {
+                struct {
+                        u64 hdr;
+                        u64 body[7];
+                };
+                u64 words[8];
+        };
+} nx_fw_msg_t;
+
 typedef struct {
         __le64 qhdr;
         __le64 req_hdr;
@@ -1218,78 +1209,60 @@ struct netxen_adapter {
 
         struct net_device *netdev;
         struct pci_dev *pdev;
-        int pci_using_dac;
-        struct net_device_stats net_stats;
-        int mtu;
-        int portnum;
-        u8 physical_port;
-        u16 tx_context_id;
-
-        uint8_t         mc_enabled;
-        uint8_t         max_mc_count;
         nx_mac_list_t   *mac_list;
 
-        struct netxen_legacy_intr_set legacy_intr;
-
-        struct work_struct watchdog_task;
-        struct timer_list watchdog_timer;
-        struct work_struct  tx_timeout_task;
-
         u32 curr_window;
         u32 crb_win;
         rwlock_t adapter_lock;
 
-        u32 cmd_producer;
-        __le32 *cmd_consumer;
-        u32 last_cmd_consumer;
-        u32 crb_addr_cmd_producer;
-        u32 crb_addr_cmd_consumer;
         spinlock_t tx_clean_lock;
 
-        u32 num_txd;
-        u32 num_rxd;
-        u32 num_jumbo_rxd;
-        u32 num_lro_rxd;
+        u16 num_txd;
+        u16 num_rxd;
+        u16 num_jumbo_rxd;
+        u16 num_lro_rxd;
+
+        u8 max_rds_rings;
+        u8 max_sds_rings;
+        u8 driver_mismatch;
+        u8 msix_supported;
+        u8 rx_csum;
+        u8 pci_using_dac;
+        u8 portnum;
+        u8 physical_port;
+
+        u8 mc_enabled;
+        u8 max_mc_count;
+        u8 rss_supported;
+        u8 resv2;
+        u32 resv3;
 
-        int max_rds_rings;
-        int max_sds_rings;
+        u8 has_link_events;
+        u8 resv1;
+        u16 tx_context_id;
+        u16 mtu;
+        u16 is_up;
+
+        u16 link_speed;
+        u16 link_duplex;
+        u16 link_autoneg;
+        u16 module_type;
 
+        u32 capabilities;
         u32 flags;
         u32 irq;
-        int driver_mismatch;
         u32 temp;
-
         u32 fw_major;
         u32 fw_version;
 
-        int msix_supported;
-        struct msix_entry msix_entries[MSIX_ENTRIES_PER_ADAPTER];
-
         struct netxen_adapter_stats stats;
 
-        u16 link_speed;
-        u16 link_duplex;
-        u16 state;
-        u16 link_autoneg;
-        int rx_csum;
-
-        struct netxen_cmd_buffer *cmd_buf_arr;  /* Command buffers for xmit */
-
-        /*
-         * Receive instances. These can be either one per port,
-         * or one per peg, etc.
-         */
         struct netxen_recv_context recv_ctx;
-
-        int is_up;
-        struct netxen_dummy_dma dummy_dma;
-        nx_nic_intr_coalesce_t coal;
+        struct nx_host_tx_ring tx_ring;
 
         /* Context interface shared between card and host */
         struct netxen_ring_ctx *ctx_desc;
         dma_addr_t ctx_desc_phys_addr;
-        int intr_scheme;
-        int msi_mode;
         int (*enable_phy_interrupts) (struct netxen_adapter *);
         int (*disable_phy_interrupts) (struct netxen_adapter *);
         int (*macaddr_set) (struct netxen_adapter *, netxen_ethernet_macaddr_t);
@@ -1300,17 +1273,29 @@ struct netxen_adapter {
         int (*init_port) (struct netxen_adapter *, int);
         int (*stop_port) (struct netxen_adapter *);
 
-        int (*hw_read_wx)(struct netxen_adapter *, ulong, void *, int);
-        int (*hw_write_wx)(struct netxen_adapter *, ulong, void *, int);
+        u32 (*hw_read_wx)(struct netxen_adapter *, ulong);
+        int (*hw_write_wx)(struct netxen_adapter *, ulong, u32);
         int (*pci_mem_read)(struct netxen_adapter *, u64, void *, int);
         int (*pci_mem_write)(struct netxen_adapter *, u64, void *, int);
         int (*pci_write_immediate)(struct netxen_adapter *, u64, u32);
         u32 (*pci_read_immediate)(struct netxen_adapter *, u64);
-        void (*pci_write_normalize)(struct netxen_adapter *, u64, u32);
-        u32 (*pci_read_normalize)(struct netxen_adapter *, u64);
         unsigned long (*pci_set_window)(struct netxen_adapter *,
                         unsigned long long);
-};                              /* netxen_adapter structure */
+
+        struct netxen_legacy_intr_set legacy_intr;
+
+        struct msix_entry msix_entries[MSIX_ENTRIES_PER_ADAPTER];
+
+        struct netxen_dummy_dma dummy_dma;
+
+        struct work_struct watchdog_task;
+        struct timer_list watchdog_timer;
+        struct work_struct  tx_timeout_task;
+
+        struct net_device_stats net_stats;
+
+        nx_nic_intr_coalesce_t coal;
+};
 
 /*
  * NetXen dma watchdog control structure
@@ -1330,46 +1315,6 @@ struct netxen_adapter {
 #define netxen_get_dma_watchdog_disabled(config_word) \
         (((config_word) >> 1) & 0x1)
 
-/* Max number of xmit producer threads that can run simultaneously */
-#define MAX_XMIT_PRODUCERS              16
-
-#define PCI_OFFSET_FIRST_RANGE(adapter, off)    \
-        ((adapter)->ahw.pci_base0 + (off))
-#define PCI_OFFSET_SECOND_RANGE(adapter, off)   \
-        ((adapter)->ahw.pci_base1 + (off) - SECOND_PAGE_GROUP_START)
-#define PCI_OFFSET_THIRD_RANGE(adapter, off)    \
-        ((adapter)->ahw.pci_base2 + (off) - THIRD_PAGE_GROUP_START)
-
-static inline void __iomem *pci_base_offset(struct netxen_adapter *adapter,
-                                            unsigned long off)
-{
-        if ((off < FIRST_PAGE_GROUP_END) && (off >= FIRST_PAGE_GROUP_START)) {
-                return (adapter->ahw.pci_base0 + off);
-        } else if ((off < SECOND_PAGE_GROUP_END) &&
-                   (off >= SECOND_PAGE_GROUP_START)) {
-                return (adapter->ahw.pci_base1 + off - SECOND_PAGE_GROUP_START);
-        } else if ((off < THIRD_PAGE_GROUP_END) &&
-                   (off >= THIRD_PAGE_GROUP_START)) {
-                return (adapter->ahw.pci_base2 + off - THIRD_PAGE_GROUP_START);
-        }
-        return NULL;
-}
-
-static inline void __iomem *pci_base(struct netxen_adapter *adapter,
-                                     unsigned long off)
-{
-        if ((off < FIRST_PAGE_GROUP_END) && (off >= FIRST_PAGE_GROUP_START)) {
-                return adapter->ahw.pci_base0;
-        } else if ((off < SECOND_PAGE_GROUP_END) &&
-                   (off >= SECOND_PAGE_GROUP_START)) {
-                return adapter->ahw.pci_base1;
-        } else if ((off < THIRD_PAGE_GROUP_END) &&
-                   (off >= THIRD_PAGE_GROUP_START)) {
-                return adapter->ahw.pci_base2;
-        }
-        return NULL;
-}
-
 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter);
 int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter);
 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter);
@@ -1382,21 +1327,19 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
 /* Functions available from netxen_nic_hw.c */
 int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu);
 int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu);
-void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val);
-int netxen_nic_reg_read(struct netxen_adapter *adapter, u64 off);
-void netxen_nic_write_w0(struct netxen_adapter *adapter, u32 index, u32 value);
-void netxen_nic_read_w0(struct netxen_adapter *adapter, u32 index, u32 *value);
-void netxen_nic_write_w1(struct netxen_adapter *adapter, u32 index, u32 value);
-void netxen_nic_read_w1(struct netxen_adapter *adapter, u32 index, u32 *value);
+
+#define NXRD32(adapter, off) \
+        (adapter->hw_read_wx(adapter, off))
+#define NXWR32(adapter, off, val) \
+        (adapter->hw_write_wx(adapter, off, val))
 
 int netxen_nic_get_board_info(struct netxen_adapter *adapter);
 void netxen_nic_get_firmware_info(struct netxen_adapter *adapter);
 int netxen_nic_wol_supported(struct netxen_adapter *adapter);
 
-int netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len);
+u32 netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off);
 int netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len);
+                ulong off, u32 data);
 int netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter,
                 u64 off, void *data, int size);
 int netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter,
@@ -1412,16 +1355,13 @@ unsigned long netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter,
 void netxen_nic_pci_change_crbwindow_128M(struct netxen_adapter *adapter,
                 u32 wndw);
 
-int netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len);
+u32 netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off);
 int netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len);
+                ulong off, u32 data);
 int netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
                 u64 off, void *data, int size);
 int netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
                 u64 off, void *data, int size);
-void netxen_crb_writelit_adapter(struct netxen_adapter *adapter,
-                                 unsigned long off, int data);
 int netxen_nic_pci_write_immediate_2M(struct netxen_adapter *adapter,
                 u64 off, u32 data);
 u32 netxen_nic_pci_read_immediate_2M(struct netxen_adapter *adapter, u64 off);
@@ -1435,7 +1375,6 @@ unsigned long netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
 void netxen_free_adapter_offload(struct netxen_adapter *adapter);
 int netxen_initialize_adapter_offload(struct netxen_adapter *adapter);
 int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val);
-int netxen_receive_peg_ready(struct netxen_adapter *adapter);
 int netxen_load_firmware(struct netxen_adapter *adapter);
 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose);
 
@@ -1475,6 +1414,8 @@ void netxen_p3_free_mac_list(struct netxen_adapter *adapter);
 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32);
 int netxen_config_intr_coalesce(struct netxen_adapter *adapter);
 int netxen_config_rss(struct netxen_adapter *adapter, int enable);
+int netxen_linkevent_request(struct netxen_adapter *adapter, int enable);
+void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup);
 
 int nx_fw_cmd_set_mtu(struct netxen_adapter *adapter, int mtu);
 int netxen_nic_change_mtu(struct net_device *netdev, int new_mtu);
@@ -1483,7 +1424,7 @@ int netxen_nic_set_mac(struct net_device *netdev, void *p);
 struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev);
 
 void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
-                uint32_t crb_producer);
+                struct nx_host_tx_ring *tx_ring, uint32_t crb_producer);
 
 /*
  * NetXen Board information
@@ -1491,7 +1432,7 @@ void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
 
 #define NETXEN_MAX_SHORT_NAME 32
 struct netxen_brdinfo {
-        netxen_brdtype_t brdtype;       /* type of board */
+        int brdtype;    /* type of board */
         long ports;             /* max no of physical ports */
         char short_name[NETXEN_MAX_SHORT_NAME];
 };
@@ -1541,17 +1482,15 @@ dma_watchdog_shutdown_request(struct netxen_adapter *adapter)
         u32 ctrl;
 
         /* check if already inactive */
-        if (adapter->hw_read_wx(adapter,
-            NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
-                printk(KERN_ERR "failed to read dma watchdog status\n");
+        ctrl = adapter->hw_read_wx(adapter,
+                        NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL));
 
         if (netxen_get_dma_watchdog_enabled(ctrl) == 0)
                 return 1;
 
         /* Send the disable request */
         netxen_set_dma_watchdog_disable_req(ctrl);
-        netxen_crb_writelit_adapter(adapter,
-                NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
+        NXWR32(adapter, NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
 
         return 0;
 }
@@ -1561,9 +1500,8 @@ dma_watchdog_shutdown_poll_result(struct netxen_adapter *adapter)
 {
         u32 ctrl;
 
-        if (adapter->hw_read_wx(adapter,
-            NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
-                printk(KERN_ERR "failed to read dma watchdog status\n");
+        ctrl = adapter->hw_read_wx(adapter,
+                        NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL));
 
         return (netxen_get_dma_watchdog_enabled(ctrl) == 0);
 }
@@ -1573,9 +1511,8 @@ dma_watchdog_wakeup(struct netxen_adapter *adapter)
 {
         u32 ctrl;
 
-        if (adapter->hw_read_wx(adapter,
-                NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
-                printk(KERN_ERR "failed to read dma watchdog status\n");
+        ctrl = adapter->hw_read_wx(adapter,
+                        NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL));
 
         if (netxen_get_dma_watchdog_enabled(ctrl))
                 return 1;
@@ -1583,8 +1520,7 @@ dma_watchdog_wakeup(struct netxen_adapter *adapter)
         /* send the wakeup request */
         netxen_set_dma_watchdog_enable_req(ctrl);
 
-        netxen_crb_writelit_adapter(adapter,
-                NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
+        NXWR32(adapter, NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
 
         return 0;
 }
diff --git a/drivers/net/netxen/netxen_nic_ctx.c b/drivers/net/netxen/netxen_nic_ctx.c
index 9234473bc08a..fd82adf4f876 100644
--- a/drivers/net/netxen/netxen_nic_ctx.c
+++ b/drivers/net/netxen/netxen_nic_ctx.c
@@ -41,8 +41,7 @@ netxen_api_lock(struct netxen_adapter *adapter)
 
         for (;;) {
                 /* Acquire PCIE HW semaphore5 */
-                netxen_nic_read_w0(adapter,
-                        NETXEN_PCIE_REG(PCIE_SEM5_LOCK), &done);
+                done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM5_LOCK));
 
                 if (done == 1)
                         break;
@@ -56,7 +55,7 @@ netxen_api_lock(struct netxen_adapter *adapter)
         }
 
 #if 0
-        netxen_nic_write_w1(adapter,
+        NXWR32(adapter,
                 NETXEN_API_LOCK_ID, NX_OS_API_LOCK_DRIVER);
 #endif
         return 0;
@@ -65,11 +64,8 @@ netxen_api_lock(struct netxen_adapter *adapter)
 static int
 netxen_api_unlock(struct netxen_adapter *adapter)
 {
-        u32 val;
-
         /* Release PCIE HW semaphore5 */
-        netxen_nic_read_w0(adapter,
-                NETXEN_PCIE_REG(PCIE_SEM5_UNLOCK), &val);
+        NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM5_UNLOCK));
         return 0;
 }
 
@@ -86,7 +82,7 @@ netxen_poll_rsp(struct netxen_adapter *adapter)
                 if (++timeout > NX_OS_CRB_RETRY_COUNT)
                         return NX_CDRP_RSP_TIMEOUT;
 
-                netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET, &rsp);
+                rsp = NXRD32(adapter, NX_CDRP_CRB_OFFSET);
         } while (!NX_CDRP_IS_RSP(rsp));
 
         return rsp;
@@ -106,16 +102,15 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
         if (netxen_api_lock(adapter))
                 return NX_RCODE_TIMEOUT;
 
-        netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET, signature);
+        NXWR32(adapter, NX_SIGN_CRB_OFFSET, signature);
 
-        netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET, arg1);
+        NXWR32(adapter, NX_ARG1_CRB_OFFSET, arg1);
 
-        netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET, arg2);
+        NXWR32(adapter, NX_ARG2_CRB_OFFSET, arg2);
 
-        netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET, arg3);
+        NXWR32(adapter, NX_ARG3_CRB_OFFSET, arg3);
 
-        netxen_nic_write_w1(adapter, NX_CDRP_CRB_OFFSET,
-                        NX_CDRP_FORM_CMD(cmd));
+        NXWR32(adapter, NX_CDRP_CRB_OFFSET, NX_CDRP_FORM_CMD(cmd));
 
         rsp = netxen_poll_rsp(adapter);
 
@@ -125,7 +120,7 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
 
                 rcode = NX_RCODE_TIMEOUT;
         } else if (rsp == NX_CDRP_RSP_FAIL) {
-                netxen_nic_read_w1(adapter, NX_ARG1_CRB_OFFSET, &rcode);
+                rcode = NXRD32(adapter, NX_ARG1_CRB_OFFSET);
 
                 printk(KERN_ERR "%s: failed card response code:0x%x\n",
                                 netxen_nic_driver_name, rcode);
@@ -328,6 +323,7 @@ nx_fw_cmd_create_tx_ctx(struct netxen_adapter *adapter)
         int     err = 0;
         u64     offset, phys_addr;
         dma_addr_t      rq_phys_addr, rsp_phys_addr;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
 
         rq_size = SIZEOF_HOSTRQ_TX(nx_hostrq_tx_ctx_t);
         rq_addr = pci_alloc_consistent(adapter->pdev,
@@ -367,10 +363,8 @@ nx_fw_cmd_create_tx_ctx(struct netxen_adapter *adapter)
 
         prq_cds = &prq->cds_ring;
 
-        prq_cds->host_phys_addr =
-                cpu_to_le64(adapter->ahw.cmd_desc_phys_addr);
-
-        prq_cds->ring_size = cpu_to_le32(adapter->num_txd);
+        prq_cds->host_phys_addr = cpu_to_le64(tx_ring->phys_addr);
+        prq_cds->ring_size = cpu_to_le32(tx_ring->num_desc);
 
         phys_addr = rq_phys_addr;
         err = netxen_issue_cmd(adapter,
@@ -383,8 +377,7 @@ nx_fw_cmd_create_tx_ctx(struct netxen_adapter *adapter)
 
         if (err == NX_RCODE_SUCCESS) {
                 temp = le32_to_cpu(prsp->cds_ring.host_producer_crb);
-                adapter->crb_addr_cmd_producer =
-                        NETXEN_NIC_REG(temp - 0x200);
+                tx_ring->crb_cmd_producer = NETXEN_NIC_REG(temp - 0x200);
 #if 0
                 adapter->tx_state =
                         le32_to_cpu(prsp->host_ctx_state);
@@ -448,7 +441,19 @@ static struct netxen_recv_crb recv_crb_registers[] = {
                         NETXEN_NIC_REG(0x120)
                 },
                 /* crb_sts_consumer: */
-                NETXEN_NIC_REG(0x138),
+                {
+                        NETXEN_NIC_REG(0x138),
+                        NETXEN_NIC_REG_2(0x000),
+                        NETXEN_NIC_REG_2(0x004),
+                        NETXEN_NIC_REG_2(0x008),
+                },
+                /* sw_int_mask */
+                {
+                        CRB_SW_INT_MASK_0,
+                        NETXEN_NIC_REG_2(0x044),
+                        NETXEN_NIC_REG_2(0x048),
+                        NETXEN_NIC_REG_2(0x04c),
+                },
         },
         /* Instance 1 */
         {
@@ -461,7 +466,19 @@ static struct netxen_recv_crb recv_crb_registers[] = {
                         NETXEN_NIC_REG(0x164)
                 },
                 /* crb_sts_consumer: */
-                NETXEN_NIC_REG(0x17c),
+                {
+                        NETXEN_NIC_REG(0x17c),
+                        NETXEN_NIC_REG_2(0x020),
+                        NETXEN_NIC_REG_2(0x024),
+                        NETXEN_NIC_REG_2(0x028),
+                },
+                /* sw_int_mask */
+                {
+                        CRB_SW_INT_MASK_1,
+                        NETXEN_NIC_REG_2(0x064),
+                        NETXEN_NIC_REG_2(0x068),
+                        NETXEN_NIC_REG_2(0x06c),
+                },
         },
         /* Instance 2 */
         {
@@ -474,7 +491,19 @@ static struct netxen_recv_crb recv_crb_registers[] = {
                         NETXEN_NIC_REG(0x208)
                 },
                 /* crb_sts_consumer: */
-                NETXEN_NIC_REG(0x220),
+                {
+                        NETXEN_NIC_REG(0x220),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                },
+                /* sw_int_mask */
+                {
+                        CRB_SW_INT_MASK_2,
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                },
         },
         /* Instance 3 */
         {
@@ -487,7 +516,19 @@ static struct netxen_recv_crb recv_crb_registers[] = {
                         NETXEN_NIC_REG(0x24c)
                 },
                 /* crb_sts_consumer: */
-                NETXEN_NIC_REG(0x264),
+                {
+                        NETXEN_NIC_REG(0x264),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                },
+                /* sw_int_mask */
+                {
+                        CRB_SW_INT_MASK_3,
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                        NETXEN_NIC_REG_2(0x03c),
+                },
         },
 };
 
@@ -497,62 +538,65 @@ netxen_init_old_ctx(struct netxen_adapter *adapter)
         struct netxen_recv_context *recv_ctx;
         struct nx_host_rds_ring *rds_ring;
         struct nx_host_sds_ring *sds_ring;
+        struct nx_host_tx_ring *tx_ring;
         int ring;
-        int func_id = adapter->portnum;
+        int port = adapter->portnum;
+        struct netxen_ring_ctx *hwctx = adapter->ctx_desc;
+        u32 signature;
 
-        adapter->ctx_desc->cmd_ring_addr =
-                cpu_to_le64(adapter->ahw.cmd_desc_phys_addr);
-        adapter->ctx_desc->cmd_ring_size =
-                cpu_to_le32(adapter->num_txd);
+        tx_ring = &adapter->tx_ring;
+        hwctx->cmd_ring_addr = cpu_to_le64(tx_ring->phys_addr);
+        hwctx->cmd_ring_size = cpu_to_le32(tx_ring->num_desc);
 
         recv_ctx = &adapter->recv_ctx;
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                 rds_ring = &recv_ctx->rds_rings[ring];
 
-                adapter->ctx_desc->rcv_ctx[ring].rcv_ring_addr =
+                hwctx->rcv_rings[ring].addr =
                         cpu_to_le64(rds_ring->phys_addr);
-                adapter->ctx_desc->rcv_ctx[ring].rcv_ring_size =
+                hwctx->rcv_rings[ring].size =
                         cpu_to_le32(rds_ring->num_desc);
         }
-        sds_ring = &recv_ctx->sds_rings[0];
-        adapter->ctx_desc->sts_ring_addr = cpu_to_le64(sds_ring->phys_addr);
-        adapter->ctx_desc->sts_ring_size = cpu_to_le32(sds_ring->num_desc);
 
-        adapter->pci_write_normalize(adapter, CRB_CTX_ADDR_REG_LO(func_id),
+        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
+                sds_ring = &recv_ctx->sds_rings[ring];
+
+                if (ring == 0) {
+                        hwctx->sts_ring_addr = cpu_to_le64(sds_ring->phys_addr);
+                        hwctx->sts_ring_size = cpu_to_le32(sds_ring->num_desc);
+                }
+                hwctx->sts_rings[ring].addr = cpu_to_le64(sds_ring->phys_addr);
+                hwctx->sts_rings[ring].size = cpu_to_le32(sds_ring->num_desc);
+                hwctx->sts_rings[ring].msi_index = cpu_to_le16(ring);
+        }
+        hwctx->sts_ring_count = cpu_to_le32(adapter->max_sds_rings);
+
+        signature = (adapter->max_sds_rings > 1) ?
+                NETXEN_CTX_SIGNATURE_V2 : NETXEN_CTX_SIGNATURE;
+
+        NXWR32(adapter, CRB_CTX_ADDR_REG_LO(port),
                         lower32(adapter->ctx_desc_phys_addr));
-        adapter->pci_write_normalize(adapter, CRB_CTX_ADDR_REG_HI(func_id),
+        NXWR32(adapter, CRB_CTX_ADDR_REG_HI(port),
                         upper32(adapter->ctx_desc_phys_addr));
-        adapter->pci_write_normalize(adapter, CRB_CTX_SIGNATURE_REG(func_id),
-                        NETXEN_CTX_SIGNATURE | func_id);
+        NXWR32(adapter, CRB_CTX_SIGNATURE_REG(port),
+                        signature | port);
         return 0;
 }
 
-static uint32_t sw_int_mask[4] = {
-        CRB_SW_INT_MASK_0, CRB_SW_INT_MASK_1,
-        CRB_SW_INT_MASK_2, CRB_SW_INT_MASK_3
-};
-
 int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
 {
-        struct netxen_hardware_context *hw = &adapter->ahw;
-        u32 state = 0;
         void *addr;
         int err = 0;
         int ring;
         struct netxen_recv_context *recv_ctx;
         struct nx_host_rds_ring *rds_ring;
         struct nx_host_sds_ring *sds_ring;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
 
         struct pci_dev *pdev = adapter->pdev;
         struct net_device *netdev = adapter->netdev;
-
-        err = netxen_receive_peg_ready(adapter);
-        if (err) {
-                printk(KERN_ERR "Rcv Peg initialization not complete:%x.\n",
-                                state);
-                return err;
-        }
+        int port = adapter->portnum;
 
         addr = pci_alloc_consistent(pdev,
                         sizeof(struct netxen_ring_ctx) + sizeof(uint32_t),
@@ -564,17 +608,16 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
         }
         memset(addr, 0, sizeof(struct netxen_ring_ctx));
         adapter->ctx_desc = (struct netxen_ring_ctx *)addr;
-        adapter->ctx_desc->ctx_id = cpu_to_le32(adapter->portnum);
+        adapter->ctx_desc->ctx_id = cpu_to_le32(port);
         adapter->ctx_desc->cmd_consumer_offset =
                 cpu_to_le64(adapter->ctx_desc_phys_addr +
                         sizeof(struct netxen_ring_ctx));
-        adapter->cmd_consumer =
+        tx_ring->hw_consumer =
                 (__le32 *)(((char *)addr) + sizeof(struct netxen_ring_ctx));
 
         /* cmd desc ring */
-        addr = pci_alloc_consistent(pdev,
-                        TX_DESC_RINGSIZE(adapter),
-                        &hw->cmd_desc_phys_addr);
+        addr = pci_alloc_consistent(pdev, TX_DESC_RINGSIZE(tx_ring),
+                        &tx_ring->phys_addr);
 
         if (addr == NULL) {
                 dev_err(&pdev->dev, "%s: failed to allocate tx desc ring\n",
@@ -582,7 +625,7 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
                 return -ENOMEM;
         }
 
-        hw->cmd_desc_head = (struct cmd_desc_type0 *)addr;
+        tx_ring->desc_head = (struct cmd_desc_type0 *)addr;
 
         recv_ctx = &adapter->recv_ctx;
 
@@ -602,8 +645,7 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
 
                 if (adapter->fw_major < 4)
                         rds_ring->crb_rcv_producer =
-                                recv_crb_registers[adapter->portnum].
-                                crb_rcv_producer[ring];
+                                recv_crb_registers[port].crb_rcv_producer[ring];
         }
 
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
@@ -620,13 +662,16 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
                         goto err_out_free;
                 }
                 sds_ring->desc_head = (struct status_desc *)addr;
+
+                sds_ring->crb_sts_consumer =
+                        recv_crb_registers[port].crb_sts_consumer[ring];
+
+                sds_ring->crb_intr_mask =
+                        recv_crb_registers[port].sw_int_mask[ring];
         }
 
 
         if (adapter->fw_major >= 4) {
-                adapter->intr_scheme = INTR_SCHEME_PERPORT;
-                adapter->msi_mode = MSI_MODE_MULTIFUNC;
-
                 err = nx_fw_cmd_create_rx_ctx(adapter);
                 if (err)
                         goto err_out_free;
@@ -634,23 +679,11 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
                 if (err)
                         goto err_out_free;
         } else {
-                sds_ring = &recv_ctx->sds_rings[0];
-                sds_ring->crb_sts_consumer =
-                        recv_crb_registers[adapter->portnum].crb_sts_consumer;
-
-                adapter->intr_scheme = adapter->pci_read_normalize(adapter,
-                                CRB_NIC_CAPABILITIES_FW);
-                adapter->msi_mode = adapter->pci_read_normalize(adapter,
-                                CRB_NIC_MSI_MODE_FW);
-                recv_ctx->sds_rings[0].crb_intr_mask =
-                                sw_int_mask[adapter->portnum];
-
                 err = netxen_init_old_ctx(adapter);
                 if (err) {
                         netxen_free_hw_resources(adapter);
                         return err;
                 }
-
         }
 
         return 0;
@@ -665,11 +698,19 @@ void netxen_free_hw_resources(struct netxen_adapter *adapter)
         struct netxen_recv_context *recv_ctx;
         struct nx_host_rds_ring *rds_ring;
         struct nx_host_sds_ring *sds_ring;
+        struct nx_host_tx_ring *tx_ring;
         int ring;
 
+        int port = adapter->portnum;
+
         if (adapter->fw_major >= 4) {
                 nx_fw_cmd_destroy_tx_ctx(adapter);
                 nx_fw_cmd_destroy_rx_ctx(adapter);
+        } else {
+                netxen_api_lock(adapter);
+                NXWR32(adapter, CRB_CTX_SIGNATURE_REG(port),
+                                NETXEN_CTX_RESET | port);
+                netxen_api_unlock(adapter);
         }
 
         if (adapter->ctx_desc != NULL) {
@@ -681,13 +722,12 @@ void netxen_free_hw_resources(struct netxen_adapter *adapter)
                 adapter->ctx_desc = NULL;
         }
 
-        if (adapter->ahw.cmd_desc_head != NULL) {
+        tx_ring = &adapter->tx_ring;
+        if (tx_ring->desc_head != NULL) {
                 pci_free_consistent(adapter->pdev,
-                                sizeof(struct cmd_desc_type0) *
-                                adapter->num_txd,
-                                adapter->ahw.cmd_desc_head,
-                                adapter->ahw.cmd_desc_phys_addr);
-                adapter->ahw.cmd_desc_head = NULL;
+                                TX_DESC_RINGSIZE(tx_ring),
+                                tx_ring->desc_head, tx_ring->phys_addr);
+                tx_ring->desc_head = NULL;
         }
 
         recv_ctx = &adapter->recv_ctx;
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index a677ff895184..a452b2facb77 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -30,7 +30,6 @@
 
 #include <linux/types.h>
 #include <linux/delay.h>
-#include <asm/uaccess.h>
 #include <linux/pci.h>
 #include <asm/io.h>
 #include <linux/netdevice.h>
@@ -53,13 +52,9 @@ struct netxen_nic_stats {
 #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
 
 static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
-        {"rcvd_bad_skb", NETXEN_NIC_STAT(stats.rcvdbadskb)},
         {"xmit_called", NETXEN_NIC_STAT(stats.xmitcalled)},
-        {"xmited_frames", NETXEN_NIC_STAT(stats.xmitedframes)},
         {"xmit_finished", NETXEN_NIC_STAT(stats.xmitfinished)},
-        {"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
-        {"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
-        {"polled", NETXEN_NIC_STAT(stats.polled)},
+        {"rx_dropped", NETXEN_NIC_STAT(stats.rxdropped)},
         {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
         {"csummed", NETXEN_NIC_STAT(stats.csummed)},
         {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
@@ -97,12 +92,9 @@ netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
         strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
         strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
         write_lock_irqsave(&adapter->adapter_lock, flags);
-        fw_major = adapter->pci_read_normalize(adapter,
-                                        NETXEN_FW_VERSION_MAJOR);
-        fw_minor = adapter->pci_read_normalize(adapter,
-                                        NETXEN_FW_VERSION_MINOR);
-        fw_build = adapter->pci_read_normalize(adapter,
-                                        NETXEN_FW_VERSION_SUB);
+        fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
+        fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
+        fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
         write_unlock_irqrestore(&adapter->adapter_lock, flags);
         sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
 
@@ -115,6 +107,7 @@ static int
 netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 {
         struct netxen_adapter *adapter = netdev_priv(dev);
+        int check_sfp_module = 0;
 
         /* read which mode */
         if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
@@ -139,7 +132,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
                 u32 val;
 
-                adapter->hw_read_wx(adapter, NETXEN_PORT_MODE_ADDR, &val, 4);
+                val = NXRD32(adapter, NETXEN_PORT_MODE_ADDR);
                 if (val == NETXEN_PORT_MODE_802_3_AP) {
                         ecmd->supported = SUPPORTED_1000baseT_Full;
                         ecmd->advertising = ADVERTISED_1000baseT_Full;
@@ -148,13 +141,19 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                         ecmd->advertising = ADVERTISED_10000baseT_Full;
                 }
 
+                if (netif_running(dev) && adapter->has_link_events) {
+                        ecmd->speed = adapter->link_speed;
+                        ecmd->autoneg = adapter->link_autoneg;
+                        ecmd->duplex = adapter->link_duplex;
+                        goto skip;
+                }
+
                 ecmd->port = PORT_TP;
 
                 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
                         u16 pcifn = adapter->ahw.pci_func;
 
-                        adapter->hw_read_wx(adapter,
-                                P3_LINK_SPEED_REG(pcifn), &val, 4);
+                        val = NXRD32(adapter, P3_LINK_SPEED_REG(pcifn));
                         ecmd->speed = P3_LINK_SPEED_MHZ *
                                         P3_LINK_SPEED_VAL(pcifn, val);
                 } else
@@ -165,10 +164,11 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         } else
                 return -EIO;
 
+skip:
         ecmd->phy_address = adapter->physical_port;
         ecmd->transceiver = XCVR_EXTERNAL;
 
-        switch ((netxen_brdtype_t)adapter->ahw.board_type) {
+        switch (adapter->ahw.board_type) {
         case NETXEN_BRDTYPE_P2_SB35_4G:
         case NETXEN_BRDTYPE_P2_SB31_2G:
         case NETXEN_BRDTYPE_P3_REF_QG:
@@ -195,7 +195,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         case NETXEN_BRDTYPE_P3_HMEZ:
                 ecmd->supported |= SUPPORTED_MII;
                 ecmd->advertising |= ADVERTISED_MII;
-                ecmd->port = PORT_FIBRE;
+                ecmd->port = PORT_MII;
                 ecmd->autoneg = AUTONEG_DISABLE;
                 break;
         case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
@@ -203,6 +203,8 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         case NETXEN_BRDTYPE_P3_10G_SFP_QT:
                 ecmd->advertising |= ADVERTISED_TP;
                 ecmd->supported |= SUPPORTED_TP;
+                check_sfp_module = netif_running(dev) &&
+                        adapter->has_link_events;
         case NETXEN_BRDTYPE_P2_SB31_10G:
         case NETXEN_BRDTYPE_P3_10G_XFP:
                 ecmd->supported |= SUPPORTED_FIBRE;
@@ -217,6 +219,8 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                         ecmd->advertising |=
                                 (ADVERTISED_FIBRE | ADVERTISED_TP);
                         ecmd->port = PORT_FIBRE;
+                        check_sfp_module = netif_running(dev) &&
+                                adapter->has_link_events;
                 } else {
                         ecmd->autoneg = AUTONEG_ENABLE;
                         ecmd->supported |= (SUPPORTED_TP |SUPPORTED_Autoneg);
@@ -227,10 +231,27 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                 break;
         default:
                 printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
-                       (netxen_brdtype_t)adapter->ahw.board_type);
+                                adapter->ahw.board_type);
                 return -EIO;
         }
 
+        if (check_sfp_module) {
+                switch (adapter->module_type) {
+                case LINKEVENT_MODULE_OPTICAL_UNKNOWN:
+                case LINKEVENT_MODULE_OPTICAL_SRLR:
+                case LINKEVENT_MODULE_OPTICAL_LRM:
+                case LINKEVENT_MODULE_OPTICAL_SFP_1G:
+                        ecmd->port = PORT_FIBRE;
+                        break;
+                case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE:
+                case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN:
+                case LINKEVENT_MODULE_TWINAX:
+                        ecmd->port = PORT_TP;
+                default:
+                        ecmd->port = -1;
+                }
+        }
+
         return 0;
 }
 
@@ -398,12 +419,11 @@ netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
         regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
             (adapter->pdev)->device;
         /* which mode */
-        adapter->hw_read_wx(adapter, NETXEN_NIU_MODE, &regs_buff[0], 4);
+        regs_buff[0] = NXRD32(adapter, NETXEN_NIU_MODE);
         mode = regs_buff[0];
 
         /* Common registers to all the modes */
-        adapter->hw_read_wx(adapter,
-                        NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER, &regs_buff[2], 4);
+        regs_buff[2] = NXRD32(adapter, NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER);
         /* GB/XGB Mode */
         mode = (mode / 2) - 1;
         window = 0;
@@ -414,9 +434,8 @@ netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
                                 window = adapter->physical_port *
                                         NETXEN_NIC_PORT_WINDOW;
 
-                        adapter->hw_read_wx(adapter,
-                                niu_registers[mode].reg[i - 3] + window,
-                                &regs_buff[i], 4);
+                        regs_buff[i] = NXRD32(adapter,
+                                niu_registers[mode].reg[i - 3] + window);
                 }
 
         }
@@ -440,7 +459,7 @@ static u32 netxen_nic_test_link(struct net_device *dev)
                         return !val;
                 }
         } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
-                val = adapter->pci_read_normalize(adapter, CRB_XG_STATE);
+                val = NXRD32(adapter, CRB_XG_STATE);
                 return (val == XG_LINK_UP) ? 0 : 1;
         }
         return -EIO;
@@ -504,10 +523,9 @@ netxen_nic_get_pauseparam(struct net_device *dev,
                 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                         return;
                 /* get flow control settings */
-                netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                &val);
+                val = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port));
                 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
-                netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
+                val = NXRD32(adapter, NETXEN_NIU_GB_PAUSE_CTL);
                 switch (port) {
                         case 0:
                                 pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
@@ -527,7 +545,7 @@ netxen_nic_get_pauseparam(struct net_device *dev,
                 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
                         return;
                 pause->rx_pause = 1;
-                netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
+                val = NXRD32(adapter, NETXEN_NIU_XG_PAUSE_CTL);
                 if (port == 0)
                         pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
                 else
@@ -550,18 +568,17 @@ netxen_nic_set_pauseparam(struct net_device *dev,
                 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                         return -EIO;
                 /* set flow control */
-                netxen_nic_read_w0(adapter,
-                                        NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
+                val = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port));
 
                 if (pause->rx_pause)
                         netxen_gb_rx_flowctl(val);
                 else
                         netxen_gb_unset_rx_flowctl(val);
 
-                netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
+                NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
                                 val);
                 /* set autoneg */
-                netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
+                val = NXRD32(adapter, NETXEN_NIU_GB_PAUSE_CTL);
                 switch (port) {
                         case 0:
                                 if (pause->tx_pause)
@@ -589,11 +606,11 @@ netxen_nic_set_pauseparam(struct net_device *dev,
                                         netxen_gb_set_gb3_mask(val);
                                 break;
                 }
-                netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
+                NXWR32(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
         } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
                 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
                         return -EIO;
-                netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
+                val = NXRD32(adapter, NETXEN_NIU_XG_PAUSE_CTL);
                 if (port == 0) {
                         if (pause->tx_pause)
                                 netxen_xg_unset_xg0_mask(val);
@@ -605,7 +622,7 @@ netxen_nic_set_pauseparam(struct net_device *dev,
                         else
                                 netxen_xg_set_xg1_mask(val);
                 }
-                netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
+                NXWR32(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
         } else {
                 printk(KERN_ERR "%s: Unknown board type: %x\n",
                                 netxen_nic_driver_name,
@@ -619,14 +636,14 @@ static int netxen_nic_reg_test(struct net_device *dev)
         struct netxen_adapter *adapter = netdev_priv(dev);
         u32 data_read, data_written;
 
-        netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
+        data_read = NXRD32(adapter, NETXEN_PCIX_PH_REG(0));
         if ((data_read & 0xffff) != PHAN_VENDOR_ID)
         return 1;
 
         data_written = (u32)0xa5a5a5a5;
 
-        netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
-        data_read = adapter->pci_read_normalize(adapter, CRB_SCRATCHPAD_TEST);
+        NXWR32(adapter, CRB_SCRATCHPAD_TEST, data_written);
+        data_read = NXRD32(adapter, CRB_SCRATCHPAD_TEST);
         if (data_written != data_read)
                 return 1;
 
@@ -743,11 +760,11 @@ netxen_nic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
                 return;
 
-        wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG_NV);
+        wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG_NV);
         if (wol_cfg & (1UL << adapter->portnum))
                 wol->supported |= WAKE_MAGIC;
 
-        wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG);
+        wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG);
         if (wol_cfg & (1UL << adapter->portnum))
                 wol->wolopts |= WAKE_MAGIC;
 }
@@ -764,16 +781,16 @@ netxen_nic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & ~WAKE_MAGIC)
                 return -EOPNOTSUPP;
 
-        wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG_NV);
+        wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG_NV);
         if (!(wol_cfg & (1 << adapter->portnum)))
                 return -EOPNOTSUPP;
 
-        wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG);
+        wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG);
         if (wol->wolopts & WAKE_MAGIC)
                 wol_cfg |= 1UL << adapter->portnum;
         else
                 wol_cfg &= ~(1UL << adapter->portnum);
-        netxen_nic_reg_write(adapter, NETXEN_WOL_CONFIG, wol_cfg);
+        NXWR32(adapter, NETXEN_WOL_CONFIG, wol_cfg);
 
         return 0;
 }
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 016c62129c76..7f0ddbfa7b28 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -31,16 +31,8 @@
 #ifndef __NETXEN_NIC_HDR_H_
 #define __NETXEN_NIC_HDR_H_
 
-#include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/spinlock.h>
-#include <asm/irq.h>
-#include <linux/init.h>
-#include <linux/errno.h>
-#include <linux/pci.h>
 #include <linux/types.h>
-#include <asm/uaccess.h>
-#include <asm/string.h>         /* for memset */
 
 /*
  * The basic unit of access when reading/writing control registers.
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index 5026811c04ce..3bb2b8c74d92 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -48,8 +48,49 @@
 #define CRB_HI(off)     ((crb_hub_agt[CRB_BLK(off)] << 20) | ((off) & 0xf0000))
 #define CRB_INDIRECT_2M (0x1e0000UL)
 
+#ifndef readq
+static inline u64 readq(void __iomem *addr)
+{
+        return readl(addr) | (((u64) readl(addr + 4)) << 32LL);
+}
+#endif
+
+#ifndef writeq
+static inline void writeq(u64 val, void __iomem *addr)
+{
+        writel(((u32) (val)), (addr));
+        writel(((u32) (val >> 32)), (addr + 4));
+}
+#endif
+
+#define ADDR_IN_RANGE(addr, low, high)  \
+        (((addr) < (high)) && ((addr) >= (low)))
+
+#define PCI_OFFSET_FIRST_RANGE(adapter, off)    \
+        ((adapter)->ahw.pci_base0 + (off))
+#define PCI_OFFSET_SECOND_RANGE(adapter, off)   \
+        ((adapter)->ahw.pci_base1 + (off) - SECOND_PAGE_GROUP_START)
+#define PCI_OFFSET_THIRD_RANGE(adapter, off)    \
+        ((adapter)->ahw.pci_base2 + (off) - THIRD_PAGE_GROUP_START)
+
+static void __iomem *pci_base_offset(struct netxen_adapter *adapter,
+                                            unsigned long off)
+{
+        if (ADDR_IN_RANGE(off, FIRST_PAGE_GROUP_START, FIRST_PAGE_GROUP_END))
+                return PCI_OFFSET_FIRST_RANGE(adapter, off);
+
+        if (ADDR_IN_RANGE(off, SECOND_PAGE_GROUP_START, SECOND_PAGE_GROUP_END))
+                return PCI_OFFSET_SECOND_RANGE(adapter, off);
+
+        if (ADDR_IN_RANGE(off, THIRD_PAGE_GROUP_START, THIRD_PAGE_GROUP_END))
+                return PCI_OFFSET_THIRD_RANGE(adapter, off);
+
+        return NULL;
+}
+
 #define CRB_WIN_LOCK_TIMEOUT 100000000
-static crb_128M_2M_block_map_t crb_128M_2M_map[64] = {
+static crb_128M_2M_block_map_t
+crb_128M_2M_map[64] __cacheline_aligned_in_smp = {
     {{{0, 0,         0,         0} } },         /* 0: PCI */
     {{{1, 0x0100000, 0x0102000, 0x120000},      /* 1: PCIE */
           {1, 0x0110000, 0x0120000, 0x130000},
@@ -279,18 +320,8 @@ static unsigned crb_hub_agt[64] =
 
 /*  PCI Windowing for DDR regions.  */
 
-#define ADDR_IN_RANGE(addr, low, high)  \
-        (((addr) <= (high)) && ((addr) >= (low)))
-
 #define NETXEN_WINDOW_ONE       0x2000000 /*CRB Window: bit 25 of CRB address */
 
-#define NETXEN_NIC_ZERO_PAUSE_ADDR     0ULL
-#define NETXEN_NIC_UNIT_PAUSE_ADDR     0x200ULL
-#define NETXEN_NIC_EPG_PAUSE_ADDR1     0x2200010000c28001ULL
-#define NETXEN_NIC_EPG_PAUSE_ADDR2     0x0100088866554433ULL
-
-#define NETXEN_NIC_WINDOW_MARGIN 0x100000
-
 int netxen_nic_set_mac(struct net_device *netdev, void *p)
 {
         struct netxen_adapter *adapter = netdev_priv(netdev);
@@ -331,22 +362,20 @@ netxen_nic_enable_mcast_filter(struct netxen_adapter *adapter)
         if (adapter->mc_enabled)
                 return 0;
 
-        adapter->hw_read_wx(adapter, NETXEN_MAC_ADDR_CNTL_REG, &val, 4);
+        val = NXRD32(adapter, NETXEN_MAC_ADDR_CNTL_REG);
         val |= (1UL << (28+port));
-        adapter->hw_write_wx(adapter, NETXEN_MAC_ADDR_CNTL_REG, &val, 4);
+        NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
 
         /* add broadcast addr to filter */
         val = 0xffffff;
-        netxen_crb_writelit_adapter(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_UNICAST_ADDR(port, 0)+4, val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0)+4, val);
 
         /* add station addr to filter */
         val = MAC_HI(addr);
-        netxen_crb_writelit_adapter(adapter, NETXEN_UNICAST_ADDR(port, 1), val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1), val);
         val = MAC_LO(addr);
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_UNICAST_ADDR(port, 1)+4, val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1)+4, val);
 
         adapter->mc_enabled = 1;
         return 0;
@@ -362,18 +391,17 @@ netxen_nic_disable_mcast_filter(struct netxen_adapter *adapter)
         if (!adapter->mc_enabled)
                 return 0;
 
-        adapter->hw_read_wx(adapter, NETXEN_MAC_ADDR_CNTL_REG, &val, 4);
+        val = NXRD32(adapter, NETXEN_MAC_ADDR_CNTL_REG);
         val &= ~(1UL << (28+port));
-        adapter->hw_write_wx(adapter, NETXEN_MAC_ADDR_CNTL_REG, &val, 4);
+        NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
 
         val = MAC_HI(addr);
-        netxen_crb_writelit_adapter(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0), val);
         val = MAC_LO(addr);
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_UNICAST_ADDR(port, 0)+4, val);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 0)+4, val);
 
-        netxen_crb_writelit_adapter(adapter, NETXEN_UNICAST_ADDR(port, 1), 0);
-        netxen_crb_writelit_adapter(adapter, NETXEN_UNICAST_ADDR(port, 1)+4, 0);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1), 0);
+        NXWR32(adapter, NETXEN_UNICAST_ADDR(port, 1)+4, 0);
 
         adapter->mc_enabled = 0;
         return 0;
@@ -389,10 +417,8 @@ netxen_nic_set_mcast_addr(struct netxen_adapter *adapter,
         lo = MAC_LO(addr);
         hi = MAC_HI(addr);
 
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_MCAST_ADDR(port, index), hi);
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_MCAST_ADDR(port, index)+4, lo);
+        NXWR32(adapter, NETXEN_MCAST_ADDR(port, index), hi);
+        NXWR32(adapter, NETXEN_MCAST_ADDR(port, index)+4, lo);
 
         return 0;
 }
@@ -486,45 +512,44 @@ static int nx_p3_nic_add_mac(struct netxen_adapter *adapter,
 
 static int
 netxen_send_cmd_descs(struct netxen_adapter *adapter,
-                struct cmd_desc_type0 *cmd_desc_arr, int nr_elements)
+                struct cmd_desc_type0 *cmd_desc_arr, int nr_desc)
 {
-        uint32_t i, producer;
+        u32 i, producer, consumer;
         struct netxen_cmd_buffer *pbuf;
         struct cmd_desc_type0 *cmd_desc;
-
-        if (nr_elements > MAX_PENDING_DESC_BLOCK_SIZE || nr_elements == 0) {
-                printk(KERN_WARNING "%s: Too many command descriptors in a "
-                              "request\n", __func__);
-                return -EINVAL;
-        }
+        struct nx_host_tx_ring *tx_ring;
 
         i = 0;
 
+        tx_ring = &adapter->tx_ring;
         netif_tx_lock_bh(adapter->netdev);
 
-        producer = adapter->cmd_producer;
+        producer = tx_ring->producer;
+        consumer = tx_ring->sw_consumer;
+
+        if (nr_desc > find_diff_among(producer, consumer, tx_ring->num_desc)) {
+                netif_tx_unlock_bh(adapter->netdev);
+                return -EBUSY;
+        }
+
         do {
                 cmd_desc = &cmd_desc_arr[i];
 
-                pbuf = &adapter->cmd_buf_arr[producer];
+                pbuf = &tx_ring->cmd_buf_arr[producer];
                 pbuf->skb = NULL;
                 pbuf->frag_count = 0;
 
-                /* adapter->ahw.cmd_desc_head[producer] = *cmd_desc; */
-                memcpy(&adapter->ahw.cmd_desc_head[producer],
+                memcpy(&tx_ring->desc_head[producer],
                         &cmd_desc_arr[i], sizeof(struct cmd_desc_type0));
 
-                producer = get_next_index(producer,
-                                adapter->num_txd);
+                producer = get_next_index(producer, tx_ring->num_desc);
                 i++;
 
-        } while (i != nr_elements);
+        } while (i != nr_desc);
 
-        adapter->cmd_producer = producer;
+        tx_ring->producer = producer;
 
-        /* write producer index to start the xmit */
-
-        netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
+        netxen_nic_update_cmd_producer(adapter, tx_ring, producer);
 
         netif_tx_unlock_bh(adapter->netdev);
 
@@ -717,6 +742,28 @@ int netxen_config_rss(struct netxen_adapter *adapter, int enable)
         return rv;
 }
 
+int netxen_linkevent_request(struct netxen_adapter *adapter, int enable)
+{
+        nx_nic_req_t req;
+        u64 word;
+        int rv;
+
+        memset(&req, 0, sizeof(nx_nic_req_t));
+        req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
+
+        word = NX_NIC_H2C_OPCODE_GET_LINKEVENT | ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
+        req.words[0] = cpu_to_le64(enable);
+
+        rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
+        if (rv != 0) {
+                printk(KERN_ERR "%s: could not configure link notification\n",
+                                adapter->netdev->name);
+        }
+
+        return rv;
+}
+
 /*
  * netxen_nic_change_mtu - Change the Maximum Transfer Unit
  * @returns 0 on success, negative on failure
@@ -812,8 +859,8 @@ int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
         crbaddr = CRB_MAC_BLOCK_START +
                 (4 * ((pci_func/2) * 3)) + (4 * (pci_func & 1));
 
-        adapter->hw_read_wx(adapter, crbaddr, &mac_lo, 4);
-        adapter->hw_read_wx(adapter, crbaddr+4, &mac_hi, 4);
+        mac_lo = NXRD32(adapter, crbaddr);
+        mac_hi = NXRD32(adapter, crbaddr+4);
 
         if (pci_func & 1)
                 *mac = le64_to_cpu((mac_lo >> 16) | ((u64)mac_hi << 16));
@@ -831,8 +878,7 @@ static int crb_win_lock(struct netxen_adapter *adapter)
 
         while (!done) {
                 /* acquire semaphore3 from PCI HW block */
-                adapter->hw_read_wx(adapter,
-                                NETXEN_PCIE_REG(PCIE_SEM7_LOCK), &done, 4);
+                done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM7_LOCK));
                 if (done == 1)
                         break;
                 if (timeout >= CRB_WIN_LOCK_TIMEOUT)
@@ -840,8 +886,7 @@ static int crb_win_lock(struct netxen_adapter *adapter)
                 timeout++;
                 udelay(1);
         }
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_CRB_WIN_LOCK_ID, adapter->portnum);
+        NXWR32(adapter, NETXEN_CRB_WIN_LOCK_ID, adapter->portnum);
         return 0;
 }
 
@@ -849,8 +894,7 @@ static void crb_win_unlock(struct netxen_adapter *adapter)
 {
         int val;
 
-        adapter->hw_read_wx(adapter,
-                        NETXEN_PCIE_REG(PCIE_SEM7_UNLOCK), &val, 4);
+        val = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM7_UNLOCK));
 }
 
 /*
@@ -986,8 +1030,7 @@ netxen_do_load_firmware(struct netxen_adapter *adapter, const char *fwname,
                 dev_info(&pdev->dev, "loading firmware from flash\n");
 
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
-                adapter->pci_write_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_CAS_RST, 1);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 1);
 
         if (fw) {
                 __le64 data;
@@ -1039,13 +1082,10 @@ netxen_do_load_firmware(struct netxen_adapter *adapter, const char *fwname,
         msleep(1);
 
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
-                adapter->pci_write_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_SW_RESET, 0x80001d);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0x80001d);
         else {
-                adapter->pci_write_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL, 0x3fff);
-                adapter->pci_write_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_CAS_RST, 0);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL, 0x3fff);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 0);
         }
 
         return 0;
@@ -1103,8 +1143,7 @@ netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname,
         if (NETXEN_VERSION_CODE(major, minor, build) > ver)
                 return -EINVAL;
 
-        netxen_nic_reg_write(adapter, NETXEN_CAM_RAM(0x1fc),
-                        NETXEN_BDINFO_MAGIC);
+        NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
         return 0;
 }
 
@@ -1132,8 +1171,7 @@ request_mn:
         netxen_rom_fast_read(adapter,
                         NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
         if (flashed_ver >= NETXEN_VERSION_CODE(4, 0, 220)) {
-                adapter->hw_read_wx(adapter,
-                                NX_PEG_TUNE_CAPABILITY, &capability, 4);
+                capability = NXRD32(adapter, NX_PEG_TUNE_CAPABILITY);
                 if (capability & NX_PEG_TUNE_MN_PRESENT) {
                         fw_type = NX_P3_MN_ROMIMAGE;
                         goto request_fw;
@@ -1173,13 +1211,10 @@ load_fw:
 }
 
 int
-netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len)
+netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter, ulong off, u32 data)
 {
         void __iomem *addr;
 
-        BUG_ON(len != 4);
-
         if (ADDR_IN_WINDOW1(off)) {
                 addr = NETXEN_CRB_NORMALIZE(adapter, off);
         } else {                /* Window 0 */
@@ -1192,7 +1227,7 @@ netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter,
                 return 1;
         }
 
-        writel(*(u32 *) data, addr);
+        writel(data, addr);
 
         if (!ADDR_IN_WINDOW1(off))
                 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
@@ -1200,13 +1235,11 @@ netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter,
         return 0;
 }
 
-int
-netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len)
+u32
+netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off)
 {
         void __iomem *addr;
-
-        BUG_ON(len != 4);
+        u32 data;
 
         if (ADDR_IN_WINDOW1(off)) {     /* Window 1 */
                 addr = NETXEN_CRB_NORMALIZE(adapter, off);
@@ -1220,24 +1253,21 @@ netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter,
                 return 1;
         }
 
-        *(u32 *)data = readl(addr);
+        data = readl(addr);
 
         if (!ADDR_IN_WINDOW1(off))
                 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
 
-        return 0;
+        return data;
 }
 
 int
-netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len)
+netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter, ulong off, u32 data)
 {
         unsigned long flags = 0;
         int rv;
 
-        BUG_ON(len != 4);
-
-        rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off, len);
+        rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off, 4);
 
         if (rv == -1) {
                 printk(KERN_ERR "%s: invalid offset: 0x%016lx\n",
@@ -1250,26 +1280,24 @@ netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter,
                 write_lock_irqsave(&adapter->adapter_lock, flags);
                 crb_win_lock(adapter);
                 netxen_nic_pci_set_crbwindow_2M(adapter, &off);
-                writel(*(uint32_t *)data, (void __iomem *)off);
+                writel(data, (void __iomem *)off);
                 crb_win_unlock(adapter);
                 write_unlock_irqrestore(&adapter->adapter_lock, flags);
         } else
-                writel(*(uint32_t *)data, (void __iomem *)off);
+                writel(data, (void __iomem *)off);
 
 
         return 0;
 }
 
-int
-netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter,
-                ulong off, void *data, int len)
+u32
+netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off)
 {
         unsigned long flags = 0;
         int rv;
+        u32 data;
 
-        BUG_ON(len != 4);
-
-        rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off, len);
+        rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off, 4);
 
         if (rv == -1) {
                 printk(KERN_ERR "%s: invalid offset: 0x%016lx\n",
@@ -1282,47 +1310,13 @@ netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter,
                 write_lock_irqsave(&adapter->adapter_lock, flags);
                 crb_win_lock(adapter);
                 netxen_nic_pci_set_crbwindow_2M(adapter, &off);
-                *(uint32_t *)data = readl((void __iomem *)off);
+                data = readl((void __iomem *)off);
                 crb_win_unlock(adapter);
                 write_unlock_irqrestore(&adapter->adapter_lock, flags);
         } else
-                *(uint32_t *)data = readl((void __iomem *)off);
-
-        return 0;
-}
+                data = readl((void __iomem *)off);
 
-void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val)
-{
-        adapter->hw_write_wx(adapter, off, &val, 4);
-}
-
-int netxen_nic_reg_read(struct netxen_adapter *adapter, u64 off)
-{
-        int val;
-        adapter->hw_read_wx(adapter, off, &val, 4);
-        return val;
-}
-
-/* Change the window to 0, write and change back to window 1. */
-void netxen_nic_write_w0(struct netxen_adapter *adapter, u32 index, u32 value)
-{
-        adapter->hw_write_wx(adapter, index, &value, 4);
-}
-
-/* Change the window to 0, read and change back to window 1. */
-void netxen_nic_read_w0(struct netxen_adapter *adapter, u32 index, u32 *value)
-{
-        adapter->hw_read_wx(adapter, index, value, 4);
-}
-
-void netxen_nic_write_w1(struct netxen_adapter *adapter, u32 index, u32 value)
-{
-        adapter->hw_write_wx(adapter, index, &value, 4);
-}
-
-void netxen_nic_read_w1(struct netxen_adapter *adapter, u32 index, u32 *value)
-{
-        adapter->hw_read_wx(adapter, index, value, 4);
+        return data;
 }
 
 /*
@@ -1425,17 +1419,6 @@ u32 netxen_nic_pci_read_immediate_128M(struct netxen_adapter *adapter, u64 off)
         return readl((void __iomem *)(pci_base_offset(adapter, off)));
 }
 
-void netxen_nic_pci_write_normalize_128M(struct netxen_adapter *adapter,
-                u64 off, u32 data)
-{
-        writel(data, NETXEN_CRB_NORMALIZE(adapter, off));
-}
-
-u32 netxen_nic_pci_read_normalize_128M(struct netxen_adapter *adapter, u64 off)
-{
-        return readl(NETXEN_CRB_NORMALIZE(adapter, off));
-}
-
 unsigned long
 netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
                 unsigned long long addr)
@@ -1447,12 +1430,10 @@ netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
                 /* DDR network side */
                 window = MN_WIN(addr);
                 adapter->ahw.ddr_mn_window = window;
-                adapter->hw_write_wx(adapter,
-                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
-                                &window, 4);
-                adapter->hw_read_wx(adapter,
-                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
-                                &win_read, 4);
+                NXWR32(adapter, adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
+                                window);
+                win_read = NXRD32(adapter,
+                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE);
                 if ((win_read << 17) != window) {
                         printk(KERN_INFO "Written MNwin (0x%x) != "
                                 "Read MNwin (0x%x)\n", window, win_read);
@@ -1467,12 +1448,10 @@ netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
 
                 window = OCM_WIN(addr);
                 adapter->ahw.ddr_mn_window = window;
-                adapter->hw_write_wx(adapter,
-                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
-                                &window, 4);
-                adapter->hw_read_wx(adapter,
-                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
-                                &win_read, 4);
+                NXWR32(adapter, adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE,
+                                window);
+                win_read = NXRD32(adapter,
+                                adapter->ahw.mn_win_crb | NETXEN_PCI_CRBSPACE);
                 if ((win_read >> 7) != window) {
                         printk(KERN_INFO "%s: Written OCMwin (0x%x) != "
                                         "Read OCMwin (0x%x)\n",
@@ -1485,12 +1464,10 @@ netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
                 /* QDR network side */
                 window = MS_WIN(addr);
                 adapter->ahw.qdr_sn_window = window;
-                adapter->hw_write_wx(adapter,
-                                adapter->ahw.ms_win_crb | NETXEN_PCI_CRBSPACE,
-                                &window, 4);
-                adapter->hw_read_wx(adapter,
-                                adapter->ahw.ms_win_crb | NETXEN_PCI_CRBSPACE,
-                                &win_read, 4);
+                NXWR32(adapter, adapter->ahw.ms_win_crb | NETXEN_PCI_CRBSPACE,
+                                window);
+                win_read = NXRD32(adapter,
+                                adapter->ahw.ms_win_crb | NETXEN_PCI_CRBSPACE);
                 if (win_read != window) {
                         printk(KERN_INFO "%s: Written MSwin (0x%x) != "
                                         "Read MSwin (0x%x)\n",
@@ -1936,27 +1913,20 @@ netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
 
         for (i = 0; i < loop; i++) {
                 temp = off8 + (i << 3);
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_ADDR_LO, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
                 temp = 0;
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_ADDR_HI, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_ADDR_HI, temp);
                 temp = word[i] & 0xffffffff;
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_WRDATA_LO, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_WRDATA_LO, temp);
                 temp = (word[i] >> 32) & 0xffffffff;
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_WRDATA_HI, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_WRDATA_HI, temp);
                 temp = MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_CTRL, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_CTRL, temp);
                 temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
-                adapter->hw_write_wx(adapter,
-                                mem_crb+MIU_TEST_AGT_CTRL, &temp, 4);
+                NXWR32(adapter, mem_crb+MIU_TEST_AGT_CTRL, temp);
 
                 for (j = 0; j < MAX_CTL_CHECK; j++) {
-                        adapter->hw_read_wx(adapter,
-                                        mem_crb + MIU_TEST_AGT_CTRL, &temp, 4);
+                        temp = NXRD32(adapter, mem_crb + MIU_TEST_AGT_CTRL);
                         if ((temp & MIU_TA_CTL_BUSY) == 0)
                                 break;
                 }
@@ -2013,21 +1983,16 @@ netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
 
         for (i = 0; i < loop; i++) {
                 temp = off8 + (i << 3);
-                adapter->hw_write_wx(adapter,
-                                mem_crb + MIU_TEST_AGT_ADDR_LO, &temp, 4);
+                NXWR32(adapter, mem_crb + MIU_TEST_AGT_ADDR_LO, temp);
                 temp = 0;
-                adapter->hw_write_wx(adapter,
-                                mem_crb + MIU_TEST_AGT_ADDR_HI, &temp, 4);
+                NXWR32(adapter, mem_crb + MIU_TEST_AGT_ADDR_HI, temp);
                 temp = MIU_TA_CTL_ENABLE;
-                adapter->hw_write_wx(adapter,
-                                mem_crb + MIU_TEST_AGT_CTRL, &temp, 4);
+                NXWR32(adapter, mem_crb + MIU_TEST_AGT_CTRL, temp);
                 temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE;
-                adapter->hw_write_wx(adapter,
-                                mem_crb + MIU_TEST_AGT_CTRL, &temp, 4);
+                NXWR32(adapter, mem_crb + MIU_TEST_AGT_CTRL, temp);
 
                 for (j = 0; j < MAX_CTL_CHECK; j++) {
-                        adapter->hw_read_wx(adapter,
-                                        mem_crb + MIU_TEST_AGT_CTRL, &temp, 4);
+                        temp = NXRD32(adapter, mem_crb + MIU_TEST_AGT_CTRL);
                         if ((temp & MIU_TA_CTL_BUSY) == 0)
                                 break;
                 }
@@ -2042,8 +2007,8 @@ netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
                 start = off0[i] >> 2;
                 end   = (off0[i] + sz[i] - 1) >> 2;
                 for (k = start; k <= end; k++) {
-                        adapter->hw_read_wx(adapter,
-                                mem_crb + MIU_TEST_AGT_RDDATA(k), &temp, 4);
+                        temp = NXRD32(adapter,
+                                mem_crb + MIU_TEST_AGT_RDDATA(k));
                         word[i] |= ((uint64_t)temp << (32 * k));
                 }
         }
@@ -2086,29 +2051,14 @@ netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
 int netxen_nic_pci_write_immediate_2M(struct netxen_adapter *adapter,
                 u64 off, u32 data)
 {
-        adapter->hw_write_wx(adapter, off, &data, 4);
+        NXWR32(adapter, off, data);
 
         return 0;
 }
 
 u32 netxen_nic_pci_read_immediate_2M(struct netxen_adapter *adapter, u64 off)
 {
-        u32 temp;
-        adapter->hw_read_wx(adapter, off, &temp, 4);
-        return temp;
-}
-
-void netxen_nic_pci_write_normalize_2M(struct netxen_adapter *adapter,
-                u64 off, u32 data)
-{
-        adapter->hw_write_wx(adapter, off, &data, 4);
-}
-
-u32 netxen_nic_pci_read_normalize_2M(struct netxen_adapter *adapter, u64 off)
-{
-        u32 temp;
-        adapter->hw_read_wx(adapter, off, &temp, 4);
-        return temp;
+        return NXRD32(adapter, off);
 }
 
 int netxen_nic_get_board_info(struct netxen_adapter *adapter)
@@ -2142,13 +2092,12 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
         adapter->ahw.board_type = board_type;
 
         if (board_type == NETXEN_BRDTYPE_P3_4_GB_MM) {
-                u32 gpio = netxen_nic_reg_read(adapter,
-                                NETXEN_ROMUSB_GLB_PAD_GPIO_I);
+                u32 gpio = NXRD32(adapter, NETXEN_ROMUSB_GLB_PAD_GPIO_I);
                 if ((gpio & 0x8000) == 0)
                         board_type = NETXEN_BRDTYPE_P3_10G_TP;
         }
 
-        switch ((netxen_brdtype_t)board_type) {
+        switch (board_type) {
         case NETXEN_BRDTYPE_P2_SB35_4G:
                 adapter->ahw.port_type = NETXEN_NIC_GBE;
                 break;
@@ -2195,8 +2144,7 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
 int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu)
 {
         new_mtu += MTU_FUDGE_FACTOR;
-        netxen_nic_write_w0(adapter,
-                NETXEN_NIU_GB_MAX_FRAME_SIZE(adapter->physical_port),
+        NXWR32(adapter, NETXEN_NIU_GB_MAX_FRAME_SIZE(adapter->physical_port),
                 new_mtu);
         return 0;
 }
@@ -2205,21 +2153,12 @@ int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu)
 {
         new_mtu += MTU_FUDGE_FACTOR;
         if (adapter->physical_port == 0)
-                netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE,
-                                new_mtu);
+                NXWR32(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, new_mtu);
         else
-                netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE,
-                                new_mtu);
+                NXWR32(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE, new_mtu);
         return 0;
 }
 
-void
-netxen_crb_writelit_adapter(struct netxen_adapter *adapter,
-                unsigned long off, int data)
-{
-        adapter->hw_write_wx(adapter, off, &data, 4);
-}
-
 void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
 {
         __u32 status;
@@ -2234,8 +2173,7 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
         }
 
         if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
-                adapter->hw_read_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &port_mode, 4);
+                port_mode = NXRD32(adapter, NETXEN_PORT_MODE_ADDR);
                 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
                         adapter->link_speed   = SPEED_1000;
                         adapter->link_duplex  = DUPLEX_FULL;
@@ -2312,9 +2250,9 @@ void netxen_nic_get_firmware_info(struct netxen_adapter *adapter)
                 addr += sizeof(u32);
         }
 
-        adapter->hw_read_wx(adapter, NETXEN_FW_VERSION_MAJOR, &fw_major, 4);
-        adapter->hw_read_wx(adapter, NETXEN_FW_VERSION_MINOR, &fw_minor, 4);
-        adapter->hw_read_wx(adapter, NETXEN_FW_VERSION_SUB, &fw_build, 4);
+        fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
+        fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
+        fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
 
         adapter->fw_major = fw_major;
         adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
@@ -2337,8 +2275,7 @@ void netxen_nic_get_firmware_info(struct netxen_adapter *adapter)
                         fw_major, fw_minor, fw_build);
 
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
-                adapter->hw_read_wx(adapter,
-                                NETXEN_MIU_MN_CONTROL, &i, 4);
+                i = NXRD32(adapter, NETXEN_MIU_MN_CONTROL);
                 adapter->ahw.cut_through = (i & 0x4) ? 1 : 0;
                 dev_info(&pdev->dev, "firmware running in %s mode\n",
                 adapter->ahw.cut_through ? "cut-through" : "legacy");
@@ -2353,9 +2290,9 @@ netxen_nic_wol_supported(struct netxen_adapter *adapter)
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
                 return 0;
 
-        wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG_NV);
+        wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG_NV);
         if (wol_cfg & (1UL << adapter->portnum)) {
-                wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG);
+                wol_cfg = NXRD32(adapter, NETXEN_WOL_CONFIG);
                 if (wol_cfg & (1 << adapter->portnum))
                         return 1;
         }
diff --git a/drivers/net/netxen/netxen_nic_hw.h b/drivers/net/netxen/netxen_nic_hw.h
index 04b47a7993cd..f20c96591a87 100644
--- a/drivers/net/netxen/netxen_nic_hw.h
+++ b/drivers/net/netxen/netxen_nic_hw.h
@@ -36,35 +36,15 @@
 /* Hardware memory size of 128 meg */
 #define NETXEN_MEMADDR_MAX (128 * 1024 * 1024)
 
-#ifndef readq
-static inline u64 readq(void __iomem * addr)
-{
-        return readl(addr) | (((u64) readl(addr + 4)) << 32LL);
-}
-#endif
-
-#ifndef writeq
-static inline void writeq(u64 val, void __iomem * addr)
-{
-        writel(((u32) (val)), (addr));
-        writel(((u32) (val >> 32)), (addr + 4));
-}
-#endif
-
 struct netxen_adapter;
 
 #define NETXEN_PCI_MAPSIZE_BYTES  (NETXEN_PCI_MAPSIZE << 20)
 
-struct netxen_port;
 void netxen_nic_set_link_parameters(struct netxen_adapter *adapter);
 
 typedef u8 netxen_ethernet_macaddr_t[6];
 
 /* Nibble or Byte mode for phy interface (GbE mode only) */
-typedef enum {
-        NETXEN_NIU_10_100_MB = 0,
-        NETXEN_NIU_1000_MB
-} netxen_niu_gbe_ifmode_t;
 
 #define _netxen_crb_get_bit(var, bit)  ((var >> bit) & 0x1)
 
@@ -222,30 +202,28 @@ typedef enum {
 /*
  * PHY-Specific MII control/status registers.
  */
-typedef enum {
-        NETXEN_NIU_GB_MII_MGMT_ADDR_CONTROL = 0,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_STATUS = 1,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_ID_0 = 2,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_ID_1 = 3,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG = 4,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_LNKPART = 5,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG_MORE = 6,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_NEXTPAGE_XMIT = 7,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_LNKPART_NEXTPAGE = 8,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_1000BT_CONTROL = 9,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_1000BT_STATUS = 10,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_EXTENDED_STATUS = 15,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL = 16,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS = 17,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE = 18,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS = 19,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL_MORE = 20,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_RECV_ERROR_COUNT = 21,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_LED_CONTROL = 24,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_LED_OVERRIDE = 25,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL_MORE_YET = 26,
-        NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS_MORE = 27
-} netxen_niu_phy_register_t;
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_CONTROL             0
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_STATUS              1
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_ID_0            2
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_ID_1            3
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG             4
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_LNKPART             5
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG_MORE        6
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_NEXTPAGE_XMIT       7
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_LNKPART_NEXTPAGE    8
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_1000BT_CONTROL      9
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_1000BT_STATUS       10
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_EXTENDED_STATUS     15
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL         16
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS          17
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE          18
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS          19
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL_MORE    20
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_RECV_ERROR_COUNT    21
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_LED_CONTROL         24
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_LED_OVERRIDE        25
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_CONTROL_MORE_YET        26
+#define NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS_MORE     27
 
 /*
  * PHY-Specific Status Register (reg 17).
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 0759c35f16ac..8893a973399a 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -108,42 +108,6 @@ static void crb_addr_transform_setup(void)
         crb_addr_transform(I2C0);
 }
 
-int netxen_init_firmware(struct netxen_adapter *adapter)
-{
-        u32 state = 0, loops = 0, err = 0;
-
-        /* Window 1 call */
-        state = adapter->pci_read_normalize(adapter, CRB_CMDPEG_STATE);
-
-        if (state == PHAN_INITIALIZE_ACK)
-                return 0;
-
-        while (state != PHAN_INITIALIZE_COMPLETE && loops < 2000) {
-                msleep(1);
-                /* Window 1 call */
-                state = adapter->pci_read_normalize(adapter, CRB_CMDPEG_STATE);
-
-                loops++;
-        }
-        if (loops >= 2000) {
-                printk(KERN_ERR "Cmd Peg initialization not complete:%x.\n",
-                       state);
-                err = -EIO;
-                return err;
-        }
-        /* Window 1 call */
-        adapter->pci_write_normalize(adapter,
-                        CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
-        adapter->pci_write_normalize(adapter,
-                        CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
-        adapter->pci_write_normalize(adapter,
-                        CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
-        adapter->pci_write_normalize(adapter,
-                        CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
-
-        return err;
-}
-
 void netxen_release_rx_buffers(struct netxen_adapter *adapter)
 {
         struct netxen_recv_context *recv_ctx;
@@ -173,9 +137,10 @@ void netxen_release_tx_buffers(struct netxen_adapter *adapter)
         struct netxen_cmd_buffer *cmd_buf;
         struct netxen_skb_frag *buffrag;
         int i, j;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
 
-        cmd_buf = adapter->cmd_buf_arr;
-        for (i = 0; i < adapter->num_txd; i++) {
+        cmd_buf = tx_ring->cmd_buf_arr;
+        for (i = 0; i < tx_ring->num_desc; i++) {
                 buffrag = cmd_buf->frag_array;
                 if (buffrag->dma) {
                         pci_unmap_single(adapter->pdev, buffrag->dma,
@@ -203,6 +168,7 @@ void netxen_free_sw_resources(struct netxen_adapter *adapter)
 {
         struct netxen_recv_context *recv_ctx;
         struct nx_host_rds_ring *rds_ring;
+        struct nx_host_tx_ring *tx_ring;
         int ring;
 
         recv_ctx = &adapter->recv_ctx;
@@ -214,8 +180,9 @@ void netxen_free_sw_resources(struct netxen_adapter *adapter)
                 }
         }
 
-        if (adapter->cmd_buf_arr)
-                vfree(adapter->cmd_buf_arr);
+        tx_ring = &adapter->tx_ring;
+        if (tx_ring->cmd_buf_arr)
+                vfree(tx_ring->cmd_buf_arr);
         return;
 }
 
@@ -224,21 +191,24 @@ int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
         struct netxen_recv_context *recv_ctx;
         struct nx_host_rds_ring *rds_ring;
         struct nx_host_sds_ring *sds_ring;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
         struct netxen_rx_buffer *rx_buf;
         int ring, i, num_rx_bufs;
 
         struct netxen_cmd_buffer *cmd_buf_arr;
         struct net_device *netdev = adapter->netdev;
+        struct pci_dev *pdev = adapter->pdev;
 
+        tx_ring->num_desc = adapter->num_txd;
         cmd_buf_arr =
-                (struct netxen_cmd_buffer *)vmalloc(TX_BUFF_RINGSIZE(adapter));
+                (struct netxen_cmd_buffer *)vmalloc(TX_BUFF_RINGSIZE(tx_ring));
         if (cmd_buf_arr == NULL) {
-                printk(KERN_ERR "%s: Failed to allocate cmd buffer ring\n",
+                dev_err(&pdev->dev, "%s: failed to allocate cmd buffer ring\n",
                        netdev->name);
                 return -ENOMEM;
         }
-        memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(adapter));
-        adapter->cmd_buf_arr = cmd_buf_arr;
+        memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
+        tx_ring->cmd_buf_arr = cmd_buf_arr;
 
         recv_ctx = &adapter->recv_ctx;
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
@@ -307,8 +277,6 @@ int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
                 sds_ring->irq = adapter->msix_entries[ring].vector;
-                sds_ring->clean_tx = (ring == 0);
-                sds_ring->post_rxd = (ring == 0);
                 sds_ring->adapter = adapter;
                 sds_ring->num_desc = adapter->num_rxd;
 
@@ -400,8 +368,7 @@ static int rom_lock(struct netxen_adapter *adapter)
 
         while (!done) {
                 /* acquire semaphore2 from PCI HW block */
-                netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK),
-                                   &done);
+                done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK));
                 if (done == 1)
                         break;
                 if (timeout >= rom_lock_timeout)
@@ -418,7 +385,7 @@ static int rom_lock(struct netxen_adapter *adapter)
                                 cpu_relax();    /*This a nop instr on i386 */
                 }
         }
-        netxen_nic_reg_write(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
+        NXWR32(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
         return 0;
 }
 
@@ -430,7 +397,7 @@ static int netxen_wait_rom_done(struct netxen_adapter *adapter)
         cond_resched();
 
         while (done == 0) {
-                done = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_GLB_STATUS);
+                done = NXRD32(adapter, NETXEN_ROMUSB_GLB_STATUS);
                 done &= 2;
                 timeout++;
                 if (timeout >= rom_max_timeout) {
@@ -443,30 +410,28 @@ static int netxen_wait_rom_done(struct netxen_adapter *adapter)
 
 static void netxen_rom_unlock(struct netxen_adapter *adapter)
 {
-        u32 val;
-
         /* release semaphore2 */
-        netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK), &val);
+        NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK));
 
 }
 
 static int do_rom_fast_read(struct netxen_adapter *adapter,
                             int addr, int *valp)
 {
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
         if (netxen_wait_rom_done(adapter)) {
                 printk("Error waiting for rom done\n");
                 return -EIO;
         }
         /* reset abyte_cnt and dummy_byte_cnt */
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
         udelay(10);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
+        NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 
-        *valp = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_ROM_RDATA);
+        *valp = NXRD32(adapter, NETXEN_ROMUSB_ROM_RDATA);
         return 0;
 }
 
@@ -530,8 +495,7 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 
         /* resetall */
         rom_lock(adapter);
-        netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
-                                    0xffffffff);
+        NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0xffffffff);
         netxen_rom_unlock(adapter);
 
         if (verbose) {
@@ -655,7 +619,7 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                         }
                 }
 
-                adapter->hw_write_wx(adapter, off, &buf[i].data, 4);
+                NXWR32(adapter, off, buf[i].data);
 
                 msleep(init_delay);
         }
@@ -665,33 +629,31 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 
         /* unreset_net_cache */
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
-                adapter->hw_read_wx(adapter,
-                                NETXEN_ROMUSB_GLB_SW_RESET, &val, 4);
-                netxen_crb_writelit_adapter(adapter,
-                                NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
+                val = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
         }
 
         /* p2dn replyCount */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
         /* disable_peg_cache 0 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
         /* disable_peg_cache 1 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
 
         /* peg_clr_all */
 
         /* peg_clr 0 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
         /* peg_clr 1 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
         /* peg_clr 2 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
         /* peg_clr 3 */
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
-        netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
+        NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
         return 0;
 }
 
@@ -715,12 +677,12 @@ int netxen_initialize_adapter_offload(struct netxen_adapter *adapter)
         hi = (addr >> 32) & 0xffffffff;
         lo = addr & 0xffffffff;
 
-        adapter->pci_write_normalize(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
-        adapter->pci_write_normalize(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
+        NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
+        NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
 
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
                 uint32_t temp = 0;
-                adapter->hw_write_wx(adapter, CRB_HOST_DUMMY_BUF, &temp, 4);
+                NXWR32(adapter, CRB_HOST_DUMMY_BUF, temp);
         }
 
         return 0;
@@ -762,8 +724,7 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
 
         if (!pegtune_val) {
                 do {
-                        val = adapter->pci_read_normalize(adapter,
-                                        CRB_CMDPEG_STATE);
+                        val = NXRD32(adapter, CRB_CMDPEG_STATE);
 
                         if (val == PHAN_INITIALIZE_COMPLETE ||
                                 val == PHAN_INITIALIZE_ACK)
@@ -774,7 +735,7 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
                 } while (--retries);
 
                 if (!retries) {
-                        pegtune_val = adapter->pci_read_normalize(adapter,
+                        pegtune_val = NXRD32(adapter,
                                         NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
                         printk(KERN_WARNING "netxen_phantom_init: init failed, "
                                         "pegtune_val=%x\n", pegtune_val);
@@ -785,13 +746,14 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
         return 0;
 }
 
-int netxen_receive_peg_ready(struct netxen_adapter *adapter)
+static int
+netxen_receive_peg_ready(struct netxen_adapter *adapter)
 {
         u32 val = 0;
         int retries = 2000;
 
         do {
-                val = adapter->pci_read_normalize(adapter, CRB_RCVPEG_STATE);
+                val = NXRD32(adapter, CRB_RCVPEG_STATE);
 
                 if (val == PHAN_PEG_RCV_INITIALIZED)
                         return 0;
@@ -809,6 +771,93 @@ int netxen_receive_peg_ready(struct netxen_adapter *adapter)
         return 0;
 }
 
+int netxen_init_firmware(struct netxen_adapter *adapter)
+{
+        int err;
+
+        err = netxen_receive_peg_ready(adapter);
+        if (err)
+                return err;
+
+        NXWR32(adapter, CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
+        NXWR32(adapter, CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
+        NXWR32(adapter, CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
+        NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
+
+        if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222)) {
+                adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
+        }
+
+        return err;
+}
+
+static void
+netxen_handle_linkevent(struct netxen_adapter *adapter, nx_fw_msg_t *msg)
+{
+        u32 cable_OUI;
+        u16 cable_len;
+        u16 link_speed;
+        u8  link_status, module, duplex, autoneg;
+        struct net_device *netdev = adapter->netdev;
+
+        adapter->has_link_events = 1;
+
+        cable_OUI = msg->body[1] & 0xffffffff;
+        cable_len = (msg->body[1] >> 32) & 0xffff;
+        link_speed = (msg->body[1] >> 48) & 0xffff;
+
+        link_status = msg->body[2] & 0xff;
+        duplex = (msg->body[2] >> 16) & 0xff;
+        autoneg = (msg->body[2] >> 24) & 0xff;
+
+        module = (msg->body[2] >> 8) & 0xff;
+        if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE) {
+                printk(KERN_INFO "%s: unsupported cable: OUI 0x%x, length %d\n",
+                                netdev->name, cable_OUI, cable_len);
+        } else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN) {
+                printk(KERN_INFO "%s: unsupported cable length %d\n",
+                                netdev->name, cable_len);
+        }
+
+        netxen_advert_link_change(adapter, link_status);
+
+        /* update link parameters */
+        if (duplex == LINKEVENT_FULL_DUPLEX)
+                adapter->link_duplex = DUPLEX_FULL;
+        else
+                adapter->link_duplex = DUPLEX_HALF;
+        adapter->module_type = module;
+        adapter->link_autoneg = autoneg;
+        adapter->link_speed = link_speed;
+}
+
+static void
+netxen_handle_fw_message(int desc_cnt, int index,
+                struct nx_host_sds_ring *sds_ring)
+{
+        nx_fw_msg_t msg;
+        struct status_desc *desc;
+        int i = 0, opcode;
+
+        while (desc_cnt > 0 && i < 8) {
+                desc = &sds_ring->desc_head[index];
+                msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
+                msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
+
+                index = get_next_index(index, sds_ring->num_desc);
+                desc_cnt--;
+        }
+
+        opcode = netxen_get_nic_msg_opcode(msg.body[0]);
+        switch (opcode) {
+        case NX_NIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
+                netxen_handle_linkevent(sds_ring->adapter, &msg);
+                break;
+        default:
+                break;
+        }
+}
+
 static int
 netxen_alloc_rx_skb(struct netxen_adapter *adapter,
                 struct nx_host_rds_ring *rds_ring,
@@ -874,7 +923,8 @@ no_skb:
 
 static struct netxen_rx_buffer *
 netxen_process_rcv(struct netxen_adapter *adapter,
-                int ring, int index, int length, int cksum, int pkt_offset)
+                int ring, int index, int length, int cksum, int pkt_offset,
+                struct nx_host_sds_ring *sds_ring)
 {
         struct net_device *netdev = adapter->netdev;
         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
@@ -902,7 +952,7 @@ netxen_process_rcv(struct netxen_adapter *adapter,
 
         skb->protocol = eth_type_trans(skb, netdev);
 
-        netif_receive_skb(skb);
+        napi_gro_receive(&sds_ring->napi, skb);
 
         adapter->stats.no_rcv++;
         adapter->stats.rxbytes += length;
@@ -927,35 +977,53 @@ netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
 
         int count = 0;
         u64 sts_data;
-        int opcode, ring, index, length, cksum, pkt_offset;
+        int opcode, ring, index, length, cksum, pkt_offset, desc_cnt;
 
         while (count < max) {
                 desc = &sds_ring->desc_head[consumer];
-                sts_data = le64_to_cpu(desc->status_desc_data);
+                sts_data = le64_to_cpu(desc->status_desc_data[0]);
 
                 if (!(sts_data & STATUS_OWNER_HOST))
                         break;
 
+                desc_cnt = netxen_get_sts_desc_cnt(sts_data);
                 ring   = netxen_get_sts_type(sts_data);
+
                 if (ring > RCV_RING_JUMBO)
-                        continue;
+                        goto skip;
 
                 opcode = netxen_get_sts_opcode(sts_data);
 
+                switch (opcode) {
+                case NETXEN_NIC_RXPKT_DESC:
+                case NETXEN_OLD_RXPKT_DESC:
+                        break;
+                case NETXEN_NIC_RESPONSE_DESC:
+                        netxen_handle_fw_message(desc_cnt, consumer, sds_ring);
+                default:
+                        goto skip;
+                }
+
+                WARN_ON(desc_cnt > 1);
+
                 index  = netxen_get_sts_refhandle(sts_data);
                 length = netxen_get_sts_totallength(sts_data);
                 cksum  = netxen_get_sts_status(sts_data);
                 pkt_offset = netxen_get_sts_pkt_offset(sts_data);
 
                 rxbuf = netxen_process_rcv(adapter, ring, index,
-                                length, cksum, pkt_offset);
+                                length, cksum, pkt_offset, sds_ring);
 
                 if (rxbuf)
                         list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
 
-                desc->status_desc_data = cpu_to_le64(STATUS_OWNER_PHANTOM);
-
-                consumer = get_next_index(consumer, sds_ring->num_desc);
+skip:
+                for (; desc_cnt > 0; desc_cnt--) {
+                        desc = &sds_ring->desc_head[consumer];
+                        desc->status_desc_data[0] =
+                                cpu_to_le64(STATUS_OWNER_PHANTOM);
+                        consumer = get_next_index(consumer, sds_ring->num_desc);
+                }
                 count++;
         }
 
@@ -980,8 +1048,7 @@ netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
 
         if (count) {
                 sds_ring->consumer = consumer;
-                adapter->pci_write_normalize(adapter,
-                                sds_ring->crb_sts_consumer, consumer);
+                NXWR32(adapter, sds_ring->crb_sts_consumer, consumer);
         }
 
         return count;
@@ -990,23 +1057,24 @@ netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
 /* Process Command status ring */
 int netxen_process_cmd_ring(struct netxen_adapter *adapter)
 {
-        u32 last_consumer, consumer;
+        u32 sw_consumer, hw_consumer;
         int count = 0, i;
         struct netxen_cmd_buffer *buffer;
         struct pci_dev *pdev = adapter->pdev;
         struct net_device *netdev = adapter->netdev;
         struct netxen_skb_frag *frag;
         int done = 0;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
 
         if (!spin_trylock(&adapter->tx_clean_lock))
                 return 1;
 
-        last_consumer = adapter->last_cmd_consumer;
-        barrier(); /* cmd_consumer can change underneath */
-        consumer = le32_to_cpu(*(adapter->cmd_consumer));
+        sw_consumer = tx_ring->sw_consumer;
+        barrier(); /* hw_consumer can change underneath */
+        hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
 
-        while (last_consumer != consumer) {
-                buffer = &adapter->cmd_buf_arr[last_consumer];
+        while (sw_consumer != hw_consumer) {
+                buffer = &tx_ring->cmd_buf_arr[sw_consumer];
                 if (buffer->skb) {
                         frag = &buffer->frag_array[0];
                         pci_unmap_single(pdev, frag->dma, frag->length,
@@ -1024,14 +1092,13 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter)
                         buffer->skb = NULL;
                 }
 
-                last_consumer = get_next_index(last_consumer,
-                                               adapter->num_txd);
+                sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
                 if (++count >= MAX_STATUS_HANDLE)
                         break;
         }
 
         if (count) {
-                adapter->last_cmd_consumer = last_consumer;
+                tx_ring->sw_consumer = sw_consumer;
                 smp_mb();
                 if (netif_queue_stopped(netdev) && netif_running(netdev)) {
                         netif_tx_lock(netdev);
@@ -1053,9 +1120,9 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter)
          * There is still a possible race condition and the host could miss an
          * interrupt. The card has to take care of this.
          */
-        barrier(); /* cmd_consumer can change underneath */
-        consumer = le32_to_cpu(*(adapter->cmd_consumer));
-        done = (last_consumer == consumer);
+        barrier(); /* hw_consumer can change underneath */
+        hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
+        done = (sw_consumer == hw_consumer);
         spin_unlock(&adapter->tx_clean_lock);
 
         return (done);
@@ -1099,8 +1166,7 @@ netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
 
         if (count) {
                 rds_ring->producer = producer;
-                adapter->pci_write_normalize(adapter,
-                                rds_ring->crb_rcv_producer,
+                NXWR32(adapter, rds_ring->crb_rcv_producer,
                                 (producer-1) & (rds_ring->num_desc-1));
 
                 if (adapter->fw_major < 4) {
@@ -1160,8 +1226,7 @@ netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
 
         if (count) {
                 rds_ring->producer = producer;
-                adapter->pci_write_normalize(adapter,
-                        rds_ring->crb_rcv_producer,
+                NXWR32(adapter, rds_ring->crb_rcv_producer,
                                 (producer - 1) & (rds_ring->num_desc - 1));
                         wmb();
         }
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index aef77289bd34..e877eefdfeb0 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -29,7 +29,7 @@
  */
 
 #include <linux/vmalloc.h>
-#include <linux/highmem.h>
+#include <linux/interrupt.h>
 #include "netxen_nic_hw.h"
 
 #include "netxen_nic.h"
@@ -107,10 +107,9 @@ static uint32_t crb_cmd_producer[4] = {
 
 void
 netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
-                uint32_t crb_producer)
+                struct nx_host_tx_ring *tx_ring, u32 producer)
 {
-        adapter->pci_write_normalize(adapter,
-                        adapter->crb_addr_cmd_producer, crb_producer);
+        NXWR32(adapter, tx_ring->crb_cmd_producer, producer);
 }
 
 static uint32_t crb_cmd_consumer[4] = {
@@ -120,10 +119,9 @@ static uint32_t crb_cmd_consumer[4] = {
 
 static inline void
 netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
-                u32 crb_consumer)
+                struct nx_host_tx_ring *tx_ring, u32 consumer)
 {
-        adapter->pci_write_normalize(adapter,
-                        adapter->crb_addr_cmd_consumer, crb_consumer);
+        NXWR32(adapter, tx_ring->crb_cmd_consumer, consumer);
 }
 
 static uint32_t msi_tgt_status[8] = {
@@ -139,37 +137,60 @@ static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
 {
         struct netxen_adapter *adapter = sds_ring->adapter;
 
-        adapter->pci_write_normalize(adapter, sds_ring->crb_intr_mask, 0);
+        NXWR32(adapter, sds_ring->crb_intr_mask, 0);
 }
 
 static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
 {
         struct netxen_adapter *adapter = sds_ring->adapter;
 
-        adapter->pci_write_normalize(adapter, sds_ring->crb_intr_mask, 0x1);
+        NXWR32(adapter, sds_ring->crb_intr_mask, 0x1);
 
         if (!NETXEN_IS_MSI_FAMILY(adapter))
                 adapter->pci_write_immediate(adapter,
                                 adapter->legacy_intr.tgt_mask_reg, 0xfbff);
 }
 
+static int
+netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
+{
+        int size = sizeof(struct nx_host_sds_ring) * count;
+
+        recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
+
+        return (recv_ctx->sds_rings == NULL);
+}
+
 static void
+netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
+{
+        if (recv_ctx->sds_rings != NULL)
+                kfree(recv_ctx->sds_rings);
+}
+
+static int
 netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
 {
         int ring;
         struct nx_host_sds_ring *sds_ring;
         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
-        if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
+        if ((adapter->flags & NETXEN_NIC_MSIX_ENABLED) &&
+                        adapter->rss_supported)
                 adapter->max_sds_rings = (num_online_cpus() >= 4) ? 4 : 2;
         else
                 adapter->max_sds_rings = 1;
 
+        if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
+                return 1;
+
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
                 netif_napi_add(netdev, &sds_ring->napi,
                                 netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
         }
+
+        return 0;
 }
 
 static void
@@ -240,7 +261,7 @@ nx_update_dma_mask(struct netxen_adapter *adapter)
 
         change = 0;
 
-        shift = netxen_nic_reg_read(adapter, CRB_DMA_SHIFT);
+        shift = NXRD32(adapter, CRB_DMA_SHIFT);
         if (shift >= 32)
                 return 0;
 
@@ -268,10 +289,22 @@ static void netxen_check_options(struct netxen_adapter *adapter)
         else if (adapter->ahw.port_type == NETXEN_NIC_GBE)
                 adapter->num_rxd = MAX_RCV_DESCRIPTORS_1G;
 
-        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
+        adapter->msix_supported = 0;
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
                 adapter->msix_supported = !!use_msi_x;
-        else
-                adapter->msix_supported = 0;
+                adapter->rss_supported = !!use_msi_x;
+        } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
+                switch (adapter->ahw.board_type) {
+                case NETXEN_BRDTYPE_P2_SB31_10G:
+                case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
+                case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
+                        adapter->msix_supported = !!use_msi_x;
+                        adapter->rss_supported = !!use_msi_x;
+                        break;
+                default:
+                        break;
+                }
+        }
 
         adapter->num_txd = MAX_CMD_DESCRIPTORS_HOST;
         adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS;
@@ -287,43 +320,34 @@ netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
 
         if (first_boot == 0x55555555) {
                 /* This is the first boot after power up */
-                adapter->pci_write_normalize(adapter,
-                        NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
+                NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
 
                 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
                         return 0;
 
                 /* PCI bus master workaround */
-                adapter->hw_read_wx(adapter,
-                        NETXEN_PCIE_REG(0x4), &first_boot, 4);
+                first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
                 if (!(first_boot & 0x4)) {
                         first_boot |= 0x4;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PCIE_REG(0x4), &first_boot, 4);
-                        adapter->hw_read_wx(adapter,
-                                NETXEN_PCIE_REG(0x4), &first_boot, 4);
+                        NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
+                        first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
                 }
 
                 /* This is the first boot after power up */
-                adapter->hw_read_wx(adapter,
-                        NETXEN_ROMUSB_GLB_SW_RESET, &first_boot, 4);
+                first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
                 if (first_boot != 0x80000f) {
                         /* clear the register for future unloads/loads */
-                        adapter->pci_write_normalize(adapter,
-                                        NETXEN_CAM_RAM(0x1fc), 0);
+                        NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
                         return -EIO;
                 }
 
                 /* Start P2 boot loader */
-                val = adapter->pci_read_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
-                adapter->pci_write_normalize(adapter,
-                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
+                val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
+                NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
                 timeout = 0;
                 do {
                         msleep(1);
-                        val = adapter->pci_read_normalize(adapter,
-                                        NETXEN_CAM_RAM(0x1fc));
+                        val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
 
                         if (++timeout > 5000)
                                 return -EIO;
@@ -342,24 +366,19 @@ static void netxen_set_port_mode(struct netxen_adapter *adapter)
                 (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
                 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
                         data = NETXEN_PORT_MODE_802_3_AP;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &data, 4);
+                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
                 } else if (port_mode == NETXEN_PORT_MODE_XG) {
                         data = NETXEN_PORT_MODE_XG;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &data, 4);
+                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
                 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
                         data = NETXEN_PORT_MODE_AUTO_NEG_1G;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &data, 4);
+                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
                 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
                         data = NETXEN_PORT_MODE_AUTO_NEG_XG;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &data, 4);
+                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
                 } else {
                         data = NETXEN_PORT_MODE_AUTO_NEG;
-                        adapter->hw_write_wx(adapter,
-                                NETXEN_PORT_MODE_ADDR, &data, 4);
+                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
                 }
 
                 if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
@@ -368,8 +387,7 @@ static void netxen_set_port_mode(struct netxen_adapter *adapter)
                         (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
                         wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
                 }
-                adapter->hw_write_wx(adapter, NETXEN_WOL_PORT_MODE,
-                        &wol_port_mode, 4);
+                NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
         }
 }
 
@@ -462,8 +480,6 @@ netxen_setup_intr(struct netxen_adapter *adapter)
         struct pci_dev *pdev = adapter->pdev;
 
         adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
-        adapter->intr_scheme = -1;
-        adapter->msi_mode = -1;
 
         if (adapter->ahw.revision_id >= NX_P3_B0)
                 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
@@ -552,8 +568,6 @@ netxen_setup_pci_map(struct netxen_adapter *adapter)
         adapter->hw_read_wx = netxen_nic_hw_read_wx_128M;
         adapter->pci_read_immediate = netxen_nic_pci_read_immediate_128M;
         adapter->pci_write_immediate = netxen_nic_pci_write_immediate_128M;
-        adapter->pci_read_normalize = netxen_nic_pci_read_normalize_128M;
-        adapter->pci_write_normalize = netxen_nic_pci_write_normalize_128M;
         adapter->pci_set_window = netxen_nic_pci_set_window_128M;
         adapter->pci_mem_read = netxen_nic_pci_mem_read_128M;
         adapter->pci_mem_write = netxen_nic_pci_mem_write_128M;
@@ -575,9 +589,6 @@ netxen_setup_pci_map(struct netxen_adapter *adapter)
                 adapter->pci_read_immediate = netxen_nic_pci_read_immediate_2M;
                 adapter->pci_write_immediate =
                         netxen_nic_pci_write_immediate_2M;
-                adapter->pci_read_normalize = netxen_nic_pci_read_normalize_2M;
-                adapter->pci_write_normalize =
-                        netxen_nic_pci_write_normalize_2M;
                 adapter->pci_set_window = netxen_nic_pci_set_window_2M;
                 adapter->pci_mem_read = netxen_nic_pci_mem_read_2M;
                 adapter->pci_mem_write = netxen_nic_pci_mem_write_2M;
@@ -660,8 +671,7 @@ netxen_start_firmware(struct netxen_adapter *adapter)
         if (!first_driver)
                 return 0;
 
-        first_boot = adapter->pci_read_normalize(adapter,
-                        NETXEN_CAM_RAM(0x1fc));
+        first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
 
         err = netxen_check_hw_init(adapter, first_boot);
         if (err) {
@@ -670,13 +680,12 @@ netxen_start_firmware(struct netxen_adapter *adapter)
         }
 
         if (first_boot != 0x55555555) {
-                adapter->pci_write_normalize(adapter,
-                                        CRB_CMDPEG_STATE, 0);
+                NXWR32(adapter, CRB_CMDPEG_STATE, 0);
                 netxen_pinit_from_rom(adapter, 0);
                 msleep(1);
         }
 
-        netxen_nic_reg_write(adapter, CRB_DMA_SHIFT, 0x55555555);
+        NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
                 netxen_set_port_mode(adapter);
 
@@ -688,8 +697,7 @@ netxen_start_firmware(struct netxen_adapter *adapter)
                 val = 0x7654;
                 if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
                         val |= 0x0f000000;
-                netxen_crb_writelit_adapter(adapter,
-                                NETXEN_MAC_ADDR_CNTL_REG, val);
+                NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
 
         }
 
@@ -703,7 +711,7 @@ netxen_start_firmware(struct netxen_adapter *adapter)
         val = (_NETXEN_NIC_LINUX_MAJOR << 16)
                 | ((_NETXEN_NIC_LINUX_MINOR << 8))
                 | (_NETXEN_NIC_LINUX_SUBVERSION);
-        adapter->pci_write_normalize(adapter, CRB_DRIVER_VERSION, val);
+        NXWR32(adapter, CRB_DRIVER_VERSION, val);
 
         /* Handshake with the card before we register the devices. */
         err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
@@ -726,15 +734,6 @@ netxen_nic_request_irq(struct netxen_adapter *adapter)
         struct net_device *netdev = adapter->netdev;
         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
-        if ((adapter->msi_mode != MSI_MODE_MULTIFUNC) ||
-                (adapter->intr_scheme != INTR_SCHEME_PERPORT)) {
-                printk(KERN_ERR "%s: Firmware interrupt scheme is "
-                                "incompatible with driver\n",
-                                netdev->name);
-                adapter->driver_mismatch = 1;
-                return -EINVAL;
-        }
-
         if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
                 handler = netxen_msix_intr;
         else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
@@ -798,6 +797,9 @@ netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
         if (adapter->max_sds_rings > 1)
                 netxen_config_rss(adapter, 1);
 
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
+                netxen_linkevent_request(adapter, 1);
+
         return 0;
 }
 
@@ -825,6 +827,7 @@ netxen_nic_attach(struct netxen_adapter *adapter)
         struct pci_dev *pdev = adapter->pdev;
         int err, ring;
         struct nx_host_rds_ring *rds_ring;
+        struct nx_host_tx_ring *tx_ring;
 
         err = netxen_init_firmware(adapter);
         if (err != 0) {
@@ -854,13 +857,12 @@ netxen_nic_attach(struct netxen_adapter *adapter)
         }
 
         if (adapter->fw_major < 4) {
-                adapter->crb_addr_cmd_producer =
-                        crb_cmd_producer[adapter->portnum];
-                adapter->crb_addr_cmd_consumer =
-                        crb_cmd_consumer[adapter->portnum];
+                tx_ring = &adapter->tx_ring;
+                tx_ring->crb_cmd_producer = crb_cmd_producer[adapter->portnum];
+                tx_ring->crb_cmd_consumer = crb_cmd_consumer[adapter->portnum];
 
-                netxen_nic_update_cmd_producer(adapter, 0);
-                netxen_nic_update_cmd_consumer(adapter, 0);
+                netxen_nic_update_cmd_producer(adapter, tx_ring, 0);
+                netxen_nic_update_cmd_consumer(adapter, tx_ring, 0);
         }
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
@@ -979,6 +981,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
 
         netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+        netdev->features |= (NETIF_F_GRO);
         netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
 
         if (NX_IS_REVISION_P3(revision_id)) {
@@ -1024,8 +1027,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         adapter->physical_port = adapter->portnum;
         if (adapter->fw_major < 4) {
-                i = adapter->pci_read_normalize(adapter,
-                                CRB_V2P(adapter->portnum));
+                i = NXRD32(adapter, CRB_V2P(adapter->portnum));
                 if (i != 0x55555555)
                         adapter->physical_port = i;
         }
@@ -1036,10 +1038,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         netdev->irq = adapter->msix_entries[0].vector;
 
-        netxen_napi_add(adapter, netdev);
-
-        err = netxen_receive_peg_ready(adapter);
-        if (err)
+        if (netxen_napi_add(adapter, netdev))
                 goto err_out_disable_msi;
 
         init_timer(&adapter->watchdog_timer);
@@ -1122,6 +1121,7 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
                 netxen_free_adapter_offload(adapter);
 
         netxen_teardown_intr(adapter);
+        netxen_free_sds_rings(&adapter->recv_ctx);
 
         netxen_cleanup_pci_map(adapter);
 
@@ -1315,7 +1315,7 @@ static int
 netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 {
         struct netxen_adapter *adapter = netdev_priv(netdev);
-        struct netxen_hardware_context *hw = &adapter->ahw;
+        struct nx_host_tx_ring *tx_ring = &adapter->tx_ring;
         unsigned int first_seg_len = skb->len - skb->data_len;
         struct netxen_cmd_buffer *pbuf;
         struct netxen_skb_frag *buffrag;
@@ -1326,28 +1326,26 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 
         u32 producer, consumer;
         int frag_count, no_of_desc;
-        u32 num_txd = adapter->num_txd;
+        u32 num_txd = tx_ring->num_desc;
         bool is_tso = false;
 
         frag_count = skb_shinfo(skb)->nr_frags + 1;
 
-        /* There 4 fragments per descriptor */
+        /* 4 fragments per cmd des */
         no_of_desc = (frag_count + 3) >> 2;
 
-        producer = adapter->cmd_producer;
+        producer = tx_ring->producer;
         smp_mb();
-        consumer = adapter->last_cmd_consumer;
+        consumer = tx_ring->sw_consumer;
         if ((no_of_desc+2) > find_diff_among(producer, consumer, num_txd)) {
                 netif_stop_queue(netdev);
                 smp_mb();
                 return NETDEV_TX_BUSY;
         }
 
-        /* Copy the descriptors into the hardware    */
-        hwdesc = &hw->cmd_desc_head[producer];
+        hwdesc = &tx_ring->desc_head[producer];
         netxen_clear_cmddesc((u64 *)hwdesc);
-        /* Take skb->data itself */
-        pbuf = &adapter->cmd_buf_arr[producer];
+        pbuf = &tx_ring->cmd_buf_arr[producer];
 
         is_tso = netxen_tso_check(netdev, hwdesc, skb);
 
@@ -1376,9 +1374,9 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 if ((i & 0x3) == 0) {
                         k = 0;
                         producer = get_next_index(producer, num_txd);
-                        hwdesc = &hw->cmd_desc_head[producer];
+                        hwdesc = &tx_ring->desc_head[producer];
                         netxen_clear_cmddesc((u64 *)hwdesc);
-                        pbuf = &adapter->cmd_buf_arr[producer];
+                        pbuf = &tx_ring->cmd_buf_arr[producer];
                         pbuf->skb = NULL;
                 }
                 frag = &skb_shinfo(skb)->frags[i - 1];
@@ -1430,8 +1428,8 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                         more_hdr = 0;
                 }
                 /* copy the MAC/IP/TCP headers to the cmd descriptor list */
-                hwdesc = &hw->cmd_desc_head[producer];
-                pbuf = &adapter->cmd_buf_arr[producer];
+                hwdesc = &tx_ring->desc_head[producer];
+                pbuf = &tx_ring->cmd_buf_arr[producer];
                 pbuf->skb = NULL;
 
                 /* copy the first 64 bytes */
@@ -1440,8 +1438,8 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 producer = get_next_index(producer, num_txd);
 
                 if (more_hdr) {
-                        hwdesc = &hw->cmd_desc_head[producer];
-                        pbuf = &adapter->cmd_buf_arr[producer];
+                        hwdesc = &tx_ring->desc_head[producer];
+                        pbuf = &tx_ring->cmd_buf_arr[producer];
                         pbuf->skb = NULL;
                         /* copy the next 64 bytes - should be enough except
                          * for pathological case
@@ -1454,10 +1452,10 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 }
         }
 
-        adapter->cmd_producer = producer;
+        tx_ring->producer = producer;
         adapter->stats.txbytes += skb->len;
 
-        netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
+        netxen_nic_update_cmd_producer(adapter, tx_ring, producer);
 
         adapter->stats.xmitcalled++;
         netdev->trans_start = jiffies;
@@ -1476,7 +1474,7 @@ static int netxen_nic_check_temp(struct netxen_adapter *adapter)
         uint32_t temp, temp_state, temp_val;
         int rv = 0;
 
-        temp = adapter->pci_read_normalize(adapter, CRB_TEMP_STATE);
+        temp = NXRD32(adapter, CRB_TEMP_STATE);
 
         temp_state = nx_get_temp_state(temp);
         temp_val = nx_get_temp_val(temp);
@@ -1510,26 +1508,9 @@ static int netxen_nic_check_temp(struct netxen_adapter *adapter)
         return rv;
 }
 
-static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
+void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
 {
         struct net_device *netdev = adapter->netdev;
-        u32 val, port, linkup;
-
-        port = adapter->physical_port;
-
-        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
-                val = adapter->pci_read_normalize(adapter, CRB_XG_STATE_P3);
-                val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
-                linkup = (val == XG_LINK_UP_P3);
-        } else {
-                val = adapter->pci_read_normalize(adapter, CRB_XG_STATE);
-                if (adapter->ahw.port_type == NETXEN_NIC_GBE)
-                        linkup = (val >> port) & 1;
-                else {
-                        val = (val >> port*8) & 0xff;
-                        linkup = (val == XG_LINK_UP);
-                }
-        }
 
         if (adapter->ahw.linkup && !linkup) {
                 printk(KERN_INFO "%s: %s NIC Link is down\n",
@@ -1540,7 +1521,9 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                         netif_stop_queue(netdev);
                 }
 
-                netxen_nic_set_link_parameters(adapter);
+                if (!adapter->has_link_events)
+                        netxen_nic_set_link_parameters(adapter);
+
         } else if (!adapter->ahw.linkup && linkup) {
                 printk(KERN_INFO "%s: %s NIC Link is up\n",
                        netxen_nic_driver_name, netdev->name);
@@ -1550,10 +1533,34 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                         netif_wake_queue(netdev);
                 }
 
-                netxen_nic_set_link_parameters(adapter);
+                if (!adapter->has_link_events)
+                        netxen_nic_set_link_parameters(adapter);
         }
 }
 
+static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
+{
+        u32 val, port, linkup;
+
+        port = adapter->physical_port;
+
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
+                val = NXRD32(adapter, CRB_XG_STATE_P3);
+                val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
+                linkup = (val == XG_LINK_UP_P3);
+        } else {
+                val = NXRD32(adapter, CRB_XG_STATE);
+                if (adapter->ahw.port_type == NETXEN_NIC_GBE)
+                        linkup = (val >> port) & 1;
+                else {
+                        val = (val >> port*8) & 0xff;
+                        linkup = (val == XG_LINK_UP);
+                }
+        }
+
+        netxen_advert_link_change(adapter, linkup);
+}
+
 static void netxen_watchdog(unsigned long v)
 {
         struct netxen_adapter *adapter = (struct netxen_adapter *)v;
@@ -1569,7 +1576,8 @@ void netxen_watchdog_task(struct work_struct *work)
         if ((adapter->portnum  == 0) && netxen_nic_check_temp(adapter))
                 return;
 
-        netxen_nic_handle_phy_intr(adapter);
+        if (!adapter->has_link_events)
+                netxen_nic_handle_phy_intr(adapter);
 
         if (netif_running(adapter->netdev))
                 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
@@ -1598,10 +1606,6 @@ static void netxen_tx_timeout_task(struct work_struct *work)
         netif_wake_queue(adapter->netdev);
 }
 
-/*
- * netxen_nic_get_stats - Get System Network Statistics
- * @netdev: network interface device structure
- */
 struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
 {
         struct netxen_adapter *adapter = netdev_priv(netdev);
@@ -1609,22 +1613,11 @@ struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
 
         memset(stats, 0, sizeof(*stats));
 
-        /* total packets received   */
         stats->rx_packets = adapter->stats.no_rcv;
-        /* total packets transmitted    */
-        stats->tx_packets = adapter->stats.xmitedframes +
-                adapter->stats.xmitfinished;
-        /* total bytes received     */
+        stats->tx_packets = adapter->stats.xmitfinished;
         stats->rx_bytes = adapter->stats.rxbytes;
-        /* total bytes transmitted  */
         stats->tx_bytes = adapter->stats.txbytes;
-        /* bad packets received     */
-        stats->rx_errors = adapter->stats.rcvdbadskb;
-        /* packet transmit problems */
-        stats->tx_errors = adapter->stats.nocmddescriptor;
-        /* no space in linux buffers    */
         stats->rx_dropped = adapter->stats.rxdropped;
-        /* no space available in linux  */
         stats->tx_dropped = adapter->stats.txdropped;
 
         return stats;
@@ -1651,15 +1644,14 @@ static irqreturn_t netxen_intr(int irq, void *data)
         } else {
                 unsigned long our_int = 0;
 
-                our_int = adapter->pci_read_normalize(adapter, CRB_INT_VECTOR);
+                our_int = NXRD32(adapter, CRB_INT_VECTOR);
 
                 /* not our interrupt */
                 if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
                         return IRQ_NONE;
 
                 /* claim interrupt */
-                adapter->pci_write_normalize(adapter,
-                                CRB_INT_VECTOR, (our_int & 0xffffffff));
+                NXWR32(adapter, CRB_INT_VECTOR, (our_int & 0xffffffff));
         }
 
         /* clear interrupt */
diff --git a/drivers/net/netxen/netxen_nic_niu.c b/drivers/net/netxen/netxen_nic_niu.c
index d85203203d4d..5e2698bf575a 100644
--- a/drivers/net/netxen/netxen_nic_niu.c
+++ b/drivers/net/netxen/netxen_nic_niu.c
@@ -43,8 +43,7 @@ static int phy_lock(struct netxen_adapter *adapter)
         int done = 0, timeout = 0;
 
         while (!done) {
-                done = netxen_nic_reg_read(adapter,
-                                NETXEN_PCIE_REG(PCIE_SEM3_LOCK));
+                done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM3_LOCK));
                 if (done == 1)
                         break;
                 if (timeout >= phy_lock_timeout) {
@@ -59,8 +58,7 @@ static int phy_lock(struct netxen_adapter *adapter)
                 }
         }
 
-        netxen_crb_writelit_adapter(adapter,
-                        NETXEN_PHY_LOCK_ID, PHY_LOCK_DRIVER);
+        NXWR32(adapter, NETXEN_PHY_LOCK_ID, PHY_LOCK_DRIVER);
         return 0;
 }
 
@@ -105,9 +103,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
          * so it cannot be in reset
          */
 
-        if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                  &mac_cfg0, 4))
-                return -EIO;
+        mac_cfg0 = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0));
         if (netxen_gb_get_soft_reset(mac_cfg0)) {
                 __u32 temp;
                 temp = 0;
@@ -115,9 +111,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
                 netxen_gb_rx_reset_pb(temp);
                 netxen_gb_tx_reset_mac(temp);
                 netxen_gb_rx_reset_mac(temp);
-                if (adapter->hw_write_wx(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                           &temp, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), temp))
                         return -EIO;
                 restore = 1;
         }
@@ -125,43 +119,32 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
         address = 0;
         netxen_gb_mii_mgmt_reg_addr(address, reg);
         netxen_gb_mii_mgmt_phy_addr(address, phy);
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
-                                   &address, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0), address))
                 return -EIO;
         command = 0;            /* turn off any prior activity */
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                   &command, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                 return -EIO;
         /* send read command */
         netxen_gb_mii_mgmt_set_read_cycle(command);
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                   &command, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                 return -EIO;
 
         status = 0;
         do {
-                if (adapter->hw_read_wx(adapter,
-                                          NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
-                                          &status, 4))
-                        return -EIO;
+                status = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_INDICATE(0));
                 timeout++;
         } while ((netxen_get_gb_mii_mgmt_busy(status)
                   || netxen_get_gb_mii_mgmt_notvalid(status))
                  && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
 
         if (timeout < NETXEN_NIU_PHY_WAITMAX) {
-                if (adapter->hw_read_wx(adapter,
-                                          NETXEN_NIU_GB_MII_MGMT_STATUS(0),
-                                          readval, 4))
-                        return -EIO;
+                *readval = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_STATUS(0));
                 result = 0;
         } else
                 result = -1;
 
         if (restore)
-                if (adapter->hw_write_wx(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                           &mac_cfg0, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), mac_cfg0))
                         return -EIO;
         phy_unlock(adapter);
         return result;
@@ -197,9 +180,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
          * cannot be in reset
          */
 
-        if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                  &mac_cfg0, 4))
-                return -EIO;
+        mac_cfg0 = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0));
         if (netxen_gb_get_soft_reset(mac_cfg0)) {
                 __u32 temp;
                 temp = 0;
@@ -208,35 +189,27 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
                 netxen_gb_tx_reset_mac(temp);
                 netxen_gb_rx_reset_mac(temp);
 
-                if (adapter->hw_write_wx(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                           &temp, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), temp))
                         return -EIO;
                 restore = 1;
         }
 
         command = 0;            /* turn off any prior activity */
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                   &command, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                 return -EIO;
 
         address = 0;
         netxen_gb_mii_mgmt_reg_addr(address, reg);
         netxen_gb_mii_mgmt_phy_addr(address, phy);
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
-                                   &address, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0), address))
                 return -EIO;
 
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0),
-                                   &val, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0), val))
                 return -EIO;
 
         status = 0;
         do {
-                if (adapter->hw_read_wx(adapter,
-                                          NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
-                                          &status, 4))
-                        return -EIO;
+                status = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_INDICATE(0));
                 timeout++;
         } while ((netxen_get_gb_mii_mgmt_busy(status))
                  && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
@@ -248,9 +221,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
 
         /* restore the state of port 0 MAC in case we tampered with it */
         if (restore)
-                if (adapter->hw_write_wx(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                           &mac_cfg0, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), mac_cfg0))
                         return -EIO;
 
         return result;
@@ -258,7 +229,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
 
 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter)
 {
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x3f);
+        NXWR32(adapter, NETXEN_NIU_INT_MASK, 0x3f);
         return 0;
 }
 
@@ -281,7 +252,7 @@ int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter)
 
 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter)
 {
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x7f);
+        NXWR32(adapter, NETXEN_NIU_INT_MASK, 0x7f);
         return 0;
 }
 
@@ -315,36 +286,27 @@ static int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
 static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
                                         int port, long enable)
 {
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                    0x80000000);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                    0x0000f0025);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
-                                    0xf1ff);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
-        netxen_crb_writelit_adapter(adapter,
-                                    (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
+        NXWR32(adapter, NETXEN_NIU_MODE, 0x2);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x80000000);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x0000f0025);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port), 0xf1ff);
+        NXWR32(adapter, NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
+        NXWR32(adapter, NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
+        NXWR32(adapter, (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
+        NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
 
         if (enable) {
                 /*
                  * Do NOT enable flow control until a suitable solution for
                  *  shutting down pause frames is found.
                  */
-                netxen_crb_writelit_adapter(adapter,
-                                            NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                            0x5);
+                NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x5);
         }
 
         if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-                printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
+                printk(KERN_ERR "ERROR enabling PHY interrupts\n");
         if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
+                printk(KERN_ERR "ERROR clearing PHY interrupts\n");
 }
 
 /*
@@ -353,36 +315,27 @@ static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
 static void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
                                          int port, long enable)
 {
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                    0x80000000);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                    0x0000f0025);
-        netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
-                                    0xf2ff);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
-        netxen_crb_writelit_adapter(adapter,
-                                    (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
-        netxen_crb_writelit_adapter(adapter,
-                                    NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
+        NXWR32(adapter, NETXEN_NIU_MODE, 0x2);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x80000000);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x0000f0025);
+        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port), 0xf2ff);
+        NXWR32(adapter, NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
+        NXWR32(adapter, NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
+        NXWR32(adapter, (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
+        NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
 
         if (enable) {
                 /*
                  * Do NOT enable flow control until a suitable solution for
                  *  shutting down pause frames is found.
                  */
-                netxen_crb_writelit_adapter(adapter,
-                                            NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                            0x5);
+                NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x5);
         }
 
         if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-                printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
+                printk(KERN_ERR "ERROR enabling PHY interrupts\n");
         if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
+                printk(KERN_ERR "ERROR clearing PHY interrupts\n");
 }
 
 int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
@@ -416,25 +369,20 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
                          * plugged in.
                          */
 
-                        netxen_crb_writelit_adapter(adapter,
-                                                    NETXEN_NIU_GB_MAC_CONFIG_0
-                                                    (port),
+                        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
                                                     NETXEN_GB_MAC_SOFT_RESET);
-                        netxen_crb_writelit_adapter(adapter,
-                                                    NETXEN_NIU_GB_MAC_CONFIG_0
-                                                    (port),
-                                                    NETXEN_GB_MAC_RESET_PROT_BLK
-                                                    | NETXEN_GB_MAC_ENABLE_TX_RX
-                                                    |
-                                                    NETXEN_GB_MAC_PAUSED_FRMS);
+                        NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
+                                            NETXEN_GB_MAC_RESET_PROT_BLK |
+                                            NETXEN_GB_MAC_ENABLE_TX_RX |
+                                            NETXEN_GB_MAC_PAUSED_FRMS);
                         if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                                printk(KERN_ERR PFX
+                                printk(KERN_ERR
                                        "ERROR clearing PHY interrupts\n");
                         if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-                                printk(KERN_ERR PFX
+                                printk(KERN_ERR
                                        "ERROR enabling PHY interrupts\n");
                         if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                                printk(KERN_ERR PFX
+                                printk(KERN_ERR
                                        "ERROR clearing PHY interrupts\n");
                         result = -1;
                 }
@@ -447,10 +395,8 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
 {
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
-                netxen_crb_writelit_adapter(adapter,
-                        NETXEN_NIU_XGE_CONFIG_1+(0x10000*port), 0x1447);
-                netxen_crb_writelit_adapter(adapter,
-                        NETXEN_NIU_XGE_CONFIG_0+(0x10000*port), 0x5);
+                NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1+(0x10000*port), 0x1447);
+                NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_0+(0x10000*port), 0x5);
         }
 
         return 0;
@@ -473,12 +419,8 @@ static int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
         if ((phy < 0) || (phy > 3))
                 return -EINVAL;
 
-        if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy),
-                                  &stationhigh, 4))
-                return -EIO;
-        if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy),
-                                  &stationlow, 4))
-                return -EIO;
+        stationhigh = NXRD32(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy));
+        stationlow = NXRD32(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy));
         ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
         ((__le32 *)val)[0] = cpu_to_le32(stationlow);
 
@@ -507,14 +449,12 @@ int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
                 temp[0] = temp[1] = 0;
                 memcpy(temp + 2, addr, 2);
                 val = le32_to_cpu(*(__le32 *)temp);
-                if (adapter->hw_write_wx(adapter,
-                                NETXEN_NIU_GB_STATION_ADDR_1(phy), &val, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy), val))
                         return -EIO;
 
                 memcpy(temp, ((u8 *) addr) + 2, sizeof(__le32));
                 val = le32_to_cpu(*(__le32 *)temp);
-                if (adapter->hw_write_wx(adapter,
-                                NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
+                if (NXWR32(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), val))
                         return -2;
 
                 netxen_niu_macaddr_get(adapter,
@@ -545,8 +485,7 @@ int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
                 return -EINVAL;
         mac_cfg0 = 0;
         netxen_gb_soft_reset(mac_cfg0);
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                   &mac_cfg0, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), mac_cfg0))
                 return -EIO;
         return 0;
 }
@@ -564,8 +503,8 @@ int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
                 return -EINVAL;
 
         mac_cfg = 0;
-        if (adapter->hw_write_wx(adapter,
-                NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), &mac_cfg, 4))
+        if (NXWR32(adapter,
+                        NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), mac_cfg))
                 return -EIO;
         return 0;
 }
@@ -581,9 +520,7 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
                 return -EINVAL;
 
         /* save previous contents */
-        if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
-                                  &reg, 4))
-                return -EIO;
+        reg = NXRD32(adapter, NETXEN_NIU_GB_DROP_WRONGADDR);
         if (mode == NETXEN_NIU_PROMISC_MODE) {
                 switch (port) {
                 case 0:
@@ -619,8 +556,7 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
                         return -EIO;
                 }
         }
-        if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
-                                   &reg, 4))
+        if (NXWR32(adapter, NETXEN_NIU_GB_DROP_WRONGADDR, reg))
                 return -EIO;
         return 0;
 }
@@ -647,28 +583,24 @@ int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
         case 0:
             memcpy(temp + 2, addr, 2);
             val = le32_to_cpu(*(__le32 *)temp);
-            if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
-                                &val, 4))
+            if (NXWR32(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1, val))
                 return -EIO;
 
             memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
             val = le32_to_cpu(*(__le32 *)temp);
-            if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
-                                &val, 4))
+            if (NXWR32(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI, val))
                 return -EIO;
             break;
 
         case 1:
             memcpy(temp + 2, addr, 2);
             val = le32_to_cpu(*(__le32 *)temp);
-            if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1,
-                                &val, 4))
+            if (NXWR32(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1, val))
                 return -EIO;
 
             memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
             val = le32_to_cpu(*(__le32 *)temp);
-            if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI,
-                                &val, 4))
+            if (NXWR32(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI, val))
                 return -EIO;
             break;
 
@@ -689,9 +621,7 @@ int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
         if (port > NETXEN_NIU_MAX_XG_PORTS)
                 return -EINVAL;
 
-        if (adapter->hw_read_wx(adapter,
-                NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), &reg, 4))
-                        return -EIO;
+        reg = NXRD32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port));
         if (mode == NETXEN_NIU_PROMISC_MODE)
                 reg = (reg | 0x2000UL);
         else
@@ -702,8 +632,7 @@ int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
         else
                 reg = (reg & ~0x1000UL);
 
-        netxen_crb_writelit_adapter(adapter,
-                NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
+        NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
 
         return 0;
 }
diff --git a/drivers/net/netxen/netxen_nic_phan_reg.h b/drivers/net/netxen/netxen_nic_phan_reg.h
index 50183335e43a..845dcf436cf6 100644
--- a/drivers/net/netxen/netxen_nic_phan_reg.h
+++ b/drivers/net/netxen/netxen_nic_phan_reg.h
@@ -36,23 +36,25 @@
  */
 #define NIC_CRB_BASE               NETXEN_CAM_RAM(0x200)
 #define NETXEN_NIC_REG(X)             (NIC_CRB_BASE+(X))
+#define NIC_CRB_BASE_2             NETXEN_CAM_RAM(0x700)
+#define NETXEN_NIC_REG_2(X)         (NIC_CRB_BASE_2+(X))
 
 #define CRB_PHAN_CNTRL_LO_OFFSET    NETXEN_NIC_REG(0x00)
 #define CRB_PHAN_CNTRL_HI_OFFSET    NETXEN_NIC_REG(0x04)
 #define CRB_CMD_PRODUCER_OFFSET     NETXEN_NIC_REG(0x08)
 #define CRB_CMD_CONSUMER_OFFSET     NETXEN_NIC_REG(0x0c)
-#define CRB_PAUSE_ADDR_LO           NETXEN_NIC_REG(0x10)        /* C0 EPG BUG  */
+#define CRB_PAUSE_ADDR_LO           NETXEN_NIC_REG(0x10)
 #define CRB_PAUSE_ADDR_HI           NETXEN_NIC_REG(0x14)
 #define NX_CDRP_CRB_OFFSET          NETXEN_NIC_REG(0x18)
 #define NX_ARG1_CRB_OFFSET          NETXEN_NIC_REG(0x1c)
 #define NX_ARG2_CRB_OFFSET          NETXEN_NIC_REG(0x20)
 #define NX_ARG3_CRB_OFFSET          NETXEN_NIC_REG(0x24)
 #define NX_SIGN_CRB_OFFSET          NETXEN_NIC_REG(0x28)
-#define CRB_CMD_INTR_LOOP           NETXEN_NIC_REG(0x20)        /* 4 regs for perf */
+#define CRB_CMD_INTR_LOOP           NETXEN_NIC_REG(0x20)
 #define CRB_CMD_DMA_LOOP            NETXEN_NIC_REG(0x24)
 #define CRB_RCV_INTR_LOOP           NETXEN_NIC_REG(0x28)
 #define CRB_RCV_DMA_LOOP            NETXEN_NIC_REG(0x2c)
-#define CRB_ENABLE_TX_INTR          NETXEN_NIC_REG(0x30)        /* phantom init status */
+#define CRB_ENABLE_TX_INTR          NETXEN_NIC_REG(0x30)
 #define CRB_MMAP_ADDR_3             NETXEN_NIC_REG(0x34)
 #define CRB_CMDPEG_CMDRING          NETXEN_NIC_REG(0x38)
 #define CRB_HOST_DUMMY_BUF_ADDR_HI  NETXEN_NIC_REG(0x3c)
@@ -65,7 +67,7 @@
 #define CRB_MMAP_SIZE_1             NETXEN_NIC_REG(0x58)
 #define CRB_MMAP_SIZE_2             NETXEN_NIC_REG(0x5c)
 #define CRB_MMAP_SIZE_3             NETXEN_NIC_REG(0x60)
-#define CRB_GLOBAL_INT_COAL         NETXEN_NIC_REG(0x64)        /* interrupt coalescing */
+#define CRB_GLOBAL_INT_COAL         NETXEN_NIC_REG(0x64)
 #define CRB_INT_COAL_MODE           NETXEN_NIC_REG(0x68)
 #define CRB_MAX_RCV_BUFS            NETXEN_NIC_REG(0x6c)
 #define CRB_TX_INT_THRESHOLD        NETXEN_NIC_REG(0x70)
@@ -83,13 +85,13 @@
 #define CRB_AGENT_TX_TYPE           NETXEN_NIC_REG(0xa0)
 #define CRB_AGENT_TX_ADDR           NETXEN_NIC_REG(0xa4)
 #define CRB_AGENT_TX_MSS            NETXEN_NIC_REG(0xa8)
-#define CRB_TX_STATE                NETXEN_NIC_REG(0xac)        /* Debug -performance */
+#define CRB_TX_STATE                NETXEN_NIC_REG(0xac)
 #define CRB_TX_COUNT                NETXEN_NIC_REG(0xb0)
 #define CRB_RX_STATE                NETXEN_NIC_REG(0xb4)
 #define CRB_RX_PERF_DEBUG_1         NETXEN_NIC_REG(0xb8)
-#define CRB_RX_LRO_CONTROL          NETXEN_NIC_REG(0xbc)        /* LRO On/OFF */
+#define CRB_RX_LRO_CONTROL          NETXEN_NIC_REG(0xbc)
 #define CRB_RX_LRO_START_NUM        NETXEN_NIC_REG(0xc0)
-#define CRB_MPORT_MODE              NETXEN_NIC_REG(0xc4)        /* Multiport Mode */
+#define CRB_MPORT_MODE              NETXEN_NIC_REG(0xc4)
 #define CRB_CMD_RING_SIZE           NETXEN_NIC_REG(0xc8)
 #define CRB_DMA_SHIFT               NETXEN_NIC_REG(0xcc)
 #define CRB_INT_VECTOR              NETXEN_NIC_REG(0xd4)
@@ -109,8 +111,6 @@
 #define CRB_CMD_CONSUMER_OFFSET_1   NETXEN_NIC_REG(0x1b0)
 #define CRB_CMD_PRODUCER_OFFSET_2   NETXEN_NIC_REG(0x1b8)
 #define CRB_CMD_CONSUMER_OFFSET_2   NETXEN_NIC_REG(0x1bc)
-
-// 1c0 to 1cc used for signature reg
 #define CRB_CMD_PRODUCER_OFFSET_3   NETXEN_NIC_REG(0x1d0)
 #define CRB_CMD_CONSUMER_OFFSET_3   NETXEN_NIC_REG(0x1d4)
 #define CRB_TEMP_STATE              NETXEN_NIC_REG(0x1b4)
@@ -120,8 +120,7 @@
 #define CRB_V2P_2                   NETXEN_NIC_REG(0x298)
 #define CRB_V2P_3                   NETXEN_NIC_REG(0x29c)
 #define CRB_V2P(port)               (CRB_V2P_0+((port)*4))
-#define CRB_DRIVER_VERSION          NETXEN_NIC_REG(0x2a0)
-/* sw int status/mask registers */
+#define CRB_DRIVER_VERSION         NETXEN_NIC_REG(0x2a0)
 #define CRB_SW_INT_MASK_0          NETXEN_NIC_REG(0x1d8)
 #define CRB_SW_INT_MASK_1          NETXEN_NIC_REG(0x1e0)
 #define CRB_SW_INT_MASK_2          NETXEN_NIC_REG(0x1e4)
@@ -136,7 +135,8 @@
 #define CRB_NIC_CAPABILITIES_HOST       NETXEN_NIC_REG(0x1a8)
 #define CRB_NIC_CAPABILITIES_FW         NETXEN_NIC_REG(0x1dc)
 #define CRB_NIC_MSI_MODE_HOST           NETXEN_NIC_REG(0x270)
-#define CRB_NIC_MSI_MODE_FW                     NETXEN_NIC_REG(0x274)
+#define CRB_NIC_MSI_MODE_FW             NETXEN_NIC_REG(0x274)
+#define CRB_FW_CAPABILITIES_1           NETXEN_NIC_REG(0x128)
 
 #define INTR_SCHEME_PERPORT             0x1
 #define MSI_MODE_MULTIFUNC              0x1
@@ -162,7 +162,8 @@
 
 struct netxen_recv_crb {
         u32 crb_rcv_producer[NUM_RCV_DESC_RINGS];
-        u32 crb_sts_consumer;
+        u32 crb_sts_consumer[NUM_STS_DESC_RINGS];
+        u32 sw_int_mask[NUM_STS_DESC_RINGS];
 };
 
 /*
diff --git a/drivers/net/pasemi_mac.c b/drivers/net/pasemi_mac.c
index 5eeb5a87b738..067caba43656 100644
--- a/drivers/net/pasemi_mac.c
+++ b/drivers/net/pasemi_mac.c
@@ -1735,6 +1735,19 @@ out:
         return ret;
 }
 
+static const struct net_device_ops pasemi_netdev_ops = {
+        .ndo_open               = pasemi_mac_open,
+        .ndo_stop               = pasemi_mac_close,
+        .ndo_start_xmit         = pasemi_mac_start_tx,
+        .ndo_set_multicast_list = pasemi_mac_set_rx_mode,
+        .ndo_set_mac_address    = pasemi_mac_set_mac_addr,
+        .ndo_change_mtu         = pasemi_mac_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = pasemi_mac_netpoll,
+#endif
+};
+
 static int __devinit
 pasemi_mac_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
@@ -1817,19 +1830,11 @@ pasemi_mac_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto out;
         }
 
-        dev->open = pasemi_mac_open;
-        dev->stop = pasemi_mac_close;
-        dev->hard_start_xmit = pasemi_mac_start_tx;
-        dev->set_multicast_list = pasemi_mac_set_rx_mode;
-        dev->set_mac_address = pasemi_mac_set_mac_addr;
+        dev->netdev_ops = &pasemi_netdev_ops;
         dev->mtu = PE_DEF_MTU;
         /* 1500 MTU + ETH_HLEN + VLAN_HLEN + 2 64B cachelines */
         mac->bufsz = dev->mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = pasemi_mac_netpoll;
-#endif
 
-        dev->change_mtu = pasemi_mac_change_mtu;
         dev->ethtool_ops = &pasemi_mac_ethtool_ops;
 
         if (err)
diff --git a/drivers/net/pci-skeleton.c b/drivers/net/pci-skeleton.c
index c95fd72c3bb9..8c1f6988f398 100644
--- a/drivers/net/pci-skeleton.c
+++ b/drivers/net/pci-skeleton.c
@@ -728,6 +728,17 @@ err_out:
         return rc;
 }
 
+static const struct net_device_ops netdrv_netdev_ops = {
+        .ndo_open               = netdrv_open,
+        .ndo_stop               = netdrv_close,
+        .ndo_start_xmit         = netdrv_start_xmit,
+        .ndo_set_multicast_list = netdrv_set_rx_mode,
+        .ndo_do_ioctl           = netdrv_ioctl,
+        .ndo_tx_timeout         = netdrv_tx_timeout,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
 
 static int __devinit netdrv_init_one (struct pci_dev *pdev,
                                        const struct pci_device_id *ent)
@@ -769,13 +780,7 @@ static int __devinit netdrv_init_one (struct pci_dev *pdev,
                 ((u16 *) (dev->dev_addr))[i] =
                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
 
-        /* The Rtl8139-specific entries in the device structure. */
-        dev->open = netdrv_open;
-        dev->hard_start_xmit = netdrv_start_xmit;
-        dev->stop = netdrv_close;
-        dev->set_multicast_list = netdrv_set_rx_mode;
-        dev->do_ioctl = netdrv_ioctl;
-        dev->tx_timeout = netdrv_tx_timeout;
+        dev->netdev_ops = &netdrv_netdev_ops;
         dev->watchdog_timeo = TX_TIMEOUT;
 
         dev->irq = pdev->irq;
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c
index 5b07dd8e5c04..5981debcde5e 100644
--- a/drivers/net/pppol2tp.c
+++ b/drivers/net/pppol2tp.c
@@ -1238,8 +1238,7 @@ static void pppol2tp_tunnel_closeall(struct pppol2tp_tunnel *tunnel)
         struct pppol2tp_session *session;
         struct sock *sk;
 
-        if (tunnel == NULL)
-                BUG();
+        BUG_ON(tunnel == NULL);
 
         PRINTK(tunnel->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
                "%s: closing all sessions...\n", tunnel->name);
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 0b6e8c896835..c812e16b7ab4 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -3791,16 +3791,13 @@ static struct net_device_stats *rtl8169_get_stats(struct net_device *dev)
         return &dev->stats;
 }
 
-#ifdef CONFIG_PM
-
-static int rtl8169_suspend(struct pci_dev *pdev, pm_message_t state)
+static void rtl8169_net_suspend(struct net_device *dev)
 {
-        struct net_device *dev = pci_get_drvdata(pdev);
         struct rtl8169_private *tp = netdev_priv(dev);
         void __iomem *ioaddr = tp->mmio_addr;
 
         if (!netif_running(dev))
-                goto out_pci_suspend;
+                return;
 
         netif_device_detach(dev);
         netif_stop_queue(dev);
@@ -3812,24 +3809,25 @@ static int rtl8169_suspend(struct pci_dev *pdev, pm_message_t state)
         rtl8169_rx_missed(dev, ioaddr);
 
         spin_unlock_irq(&tp->lock);
+}
+
+#ifdef CONFIG_PM
+
+static int rtl8169_suspend(struct device *device)
+{
+        struct pci_dev *pdev = to_pci_dev(device);
+        struct net_device *dev = pci_get_drvdata(pdev);
 
-out_pci_suspend:
-        pci_save_state(pdev);
-        pci_enable_wake(pdev, pci_choose_state(pdev, state),
-                (tp->features & RTL_FEATURE_WOL) ? 1 : 0);
-        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+        rtl8169_net_suspend(dev);
 
         return 0;
 }
 
-static int rtl8169_resume(struct pci_dev *pdev)
+static int rtl8169_resume(struct device *device)
 {
+        struct pci_dev *pdev = to_pci_dev(device);
         struct net_device *dev = pci_get_drvdata(pdev);
 
-        pci_set_power_state(pdev, PCI_D0);
-        pci_restore_state(pdev);
-        pci_enable_wake(pdev, PCI_D0, 0);
-
         if (!netif_running(dev))
                 goto out;
 
@@ -3840,23 +3838,42 @@ out:
         return 0;
 }
 
+static struct dev_pm_ops rtl8169_pm_ops = {
+        .suspend = rtl8169_suspend,
+        .resume = rtl8169_resume,
+        .freeze = rtl8169_suspend,
+        .thaw = rtl8169_resume,
+        .poweroff = rtl8169_suspend,
+        .restore = rtl8169_resume,
+};
+
+#define RTL8169_PM_OPS  (&rtl8169_pm_ops)
+
+#else /* !CONFIG_PM */
+
+#define RTL8169_PM_OPS  NULL
+
+#endif /* !CONFIG_PM */
+
 static void rtl_shutdown(struct pci_dev *pdev)
 {
-        rtl8169_suspend(pdev, PMSG_SUSPEND);
-}
+        struct net_device *dev = pci_get_drvdata(pdev);
+
+        rtl8169_net_suspend(dev);
 
-#endif /* CONFIG_PM */
+        if (system_state == SYSTEM_POWER_OFF) {
+                pci_wake_from_d3(pdev, true);
+                pci_set_power_state(pdev, PCI_D3hot);
+        }
+}
 
 static struct pci_driver rtl8169_pci_driver = {
         .name           = MODULENAME,
         .id_table       = rtl8169_pci_tbl,
         .probe          = rtl8169_init_one,
         .remove         = __devexit_p(rtl8169_remove_one),
-#ifdef CONFIG_PM
-        .suspend        = rtl8169_suspend,
-        .resume         = rtl8169_resume,
         .shutdown       = rtl_shutdown,
-#endif
+        .driver.pm      = RTL8169_PM_OPS,
 };
 
 static int __init rtl8169_init_module(void)
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index ec59e29807a6..8702e7acdee6 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -428,6 +428,15 @@ static const struct ethtool_ops rionet_ethtool_ops = {
         .get_link = ethtool_op_get_link,
 };
 
+static const struct net_device_ops rionet_netdev_ops = {
+        .ndo_open               = rionet_open,
+        .ndo_stop               = rionet_close,
+        .ndo_start_xmit         = rionet_start_xmit,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+};
+
 static int rionet_setup_netdev(struct rio_mport *mport)
 {
         int rc = 0;
@@ -466,10 +475,7 @@ static int rionet_setup_netdev(struct rio_mport *mport)
         ndev->dev_addr[4] = device_id >> 8;
         ndev->dev_addr[5] = device_id & 0xff;
 
-        /* Fill in the driver function table */
-        ndev->open = &rionet_open;
-        ndev->hard_start_xmit = &rionet_start_xmit;
-        ndev->stop = &rionet_close;
+        ndev->netdev_ops = &rionet_netdev_ops;
         ndev->mtu = RIO_MAX_MSG_SIZE - 14;
         ndev->features = NETIF_F_LLTX;
         SET_ETHTOOL_OPS(ndev, &rionet_ethtool_ops);
diff --git a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c
index ce7551e17ba7..aaeebf57a9a4 100644
--- a/drivers/net/sb1250-mac.c
+++ b/drivers/net/sb1250-mac.c
@@ -2271,6 +2271,21 @@ static int sb1250_change_mtu(struct net_device *_dev, int new_mtu)
         return 0;
 }
 
+static const struct net_device_ops sbmac_netdev_ops = {
+        .ndo_open               = sbmac_open,
+        .ndo_stop               = sbmac_close,
+        .ndo_start_xmit         = sbmac_start_tx,
+        .ndo_set_multicast_list = sbmac_set_rx_mode,
+        .ndo_tx_timeout         = sbmac_tx_timeout,
+        .ndo_do_ioctl           = sbmac_mii_ioctl,
+        .ndo_change_mtu         = sb1250_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = sbmac_netpoll,
+#endif
+};
+
 /**********************************************************************
  *  SBMAC_INIT(dev)
  *
@@ -2327,21 +2342,11 @@ static int sbmac_init(struct platform_device *pldev, long long base)
 
         spin_lock_init(&(sc->sbm_lock));
 
-        dev->open               = sbmac_open;
-        dev->hard_start_xmit    = sbmac_start_tx;
-        dev->stop               = sbmac_close;
-        dev->set_multicast_list = sbmac_set_rx_mode;
-        dev->do_ioctl           = sbmac_mii_ioctl;
-        dev->tx_timeout         = sbmac_tx_timeout;
-        dev->watchdog_timeo     = TX_TIMEOUT;
+        dev->netdev_ops = &sbmac_netdev_ops;
+        dev->watchdog_timeo = TX_TIMEOUT;
 
         netif_napi_add(dev, &sc->napi, sbmac_poll, 16);
 
-        dev->change_mtu         = sb1250_change_mtu;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = sbmac_netpoll;
-#endif
-
         dev->irq                = UNIT_INT(idx);
 
         /* This is needed for PASS2 for Rx H/W checksum feature */
diff --git a/drivers/net/sfc/boards.c b/drivers/net/sfc/boards.c
index 5182ac5a1034..4a4c74c891b7 100644
--- a/drivers/net/sfc/boards.c
+++ b/drivers/net/sfc/boards.c
@@ -172,7 +172,6 @@ static const u8 sfe4002_lm87_regs[] = {
 static struct i2c_board_info sfe4002_hwmon_info = {
         I2C_BOARD_INFO("lm87", 0x2e),
         .platform_data  = &sfe4002_lm87_channel,
-        .irq            = -1,
 };
 
 /****************************************************************************/
@@ -247,7 +246,6 @@ static const u8 sfn4112f_lm87_regs[] = {
 static struct i2c_board_info sfn4112f_hwmon_info = {
         I2C_BOARD_INFO("lm87", 0x2e),
         .platform_data  = &sfn4112f_lm87_channel,
-        .irq            = -1,
 };
 
 #define SFN4112F_ACT_LED        0
diff --git a/drivers/net/sfc/rx.c b/drivers/net/sfc/rx.c
index 66d7fe3db3e6..01f9432c31ef 100644
--- a/drivers/net/sfc/rx.c
+++ b/drivers/net/sfc/rx.c
@@ -450,17 +450,27 @@ static void efx_rx_packet_lro(struct efx_channel *channel,
 
         /* Pass the skb/page into the LRO engine */
         if (rx_buf->page) {
-                struct napi_gro_fraginfo info;
+                struct sk_buff *skb = napi_get_frags(napi);
 
-                info.frags[0].page = rx_buf->page;
-                info.frags[0].page_offset = efx_rx_buf_offset(rx_buf);
-                info.frags[0].size = rx_buf->len;
-                info.nr_frags = 1;
-                info.ip_summed = CHECKSUM_UNNECESSARY;
-                info.len = rx_buf->len;
+                if (!skb) {
+                        put_page(rx_buf->page);
+                        goto out;
+                }
+
+                skb_shinfo(skb)->frags[0].page = rx_buf->page;
+                skb_shinfo(skb)->frags[0].page_offset =
+                        efx_rx_buf_offset(rx_buf);
+                skb_shinfo(skb)->frags[0].size = rx_buf->len;
+                skb_shinfo(skb)->nr_frags = 1;
+
+                skb->len = rx_buf->len;
+                skb->data_len = rx_buf->len;
+                skb->truesize += rx_buf->len;
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-                napi_gro_frags(napi, &info);
+                napi_gro_frags(napi);
 
+out:
                 EFX_BUG_ON_PARANOID(rx_buf->skb);
                 rx_buf->page = NULL;
         } else {
diff --git a/drivers/net/sfc/sfe4001.c b/drivers/net/sfc/sfe4001.c
index 4eac5da81e5a..cee00ad49b57 100644
--- a/drivers/net/sfc/sfe4001.c
+++ b/drivers/net/sfc/sfe4001.c
@@ -296,7 +296,6 @@ static int sfe4001_check_hw(struct efx_nic *efx)
 
 static struct i2c_board_info sfe4001_hwmon_info = {
         I2C_BOARD_INFO("max6647", 0x4e),
-        .irq            = -1,
 };
 
 /* This board uses an I2C expander to provider power to the PHY, which needs to
@@ -389,12 +388,10 @@ static void sfn4111t_fini(struct efx_nic *efx)
 
 static struct i2c_board_info sfn4111t_a0_hwmon_info = {
         I2C_BOARD_INFO("max6647", 0x4e),
-        .irq            = -1,
 };
 
 static struct i2c_board_info sfn4111t_r5_hwmon_info = {
         I2C_BOARD_INFO("max6646", 0x4d),
-        .irq            = -1,
 };
 
 int sfn4111t_init(struct efx_nic *efx)
diff --git a/drivers/net/sgiseeq.c b/drivers/net/sgiseeq.c
index 97d68560067d..5fb88ca6dd7f 100644
--- a/drivers/net/sgiseeq.c
+++ b/drivers/net/sgiseeq.c
@@ -709,6 +709,17 @@ static inline void setup_rx_ring(struct net_device *dev,
         dma_sync_desc_dev(dev, &buf[i]);
 }
 
+static const struct net_device_ops sgiseeq_netdev_ops = {
+        .ndo_open               = sgiseeq_open,
+        .ndo_stop               = sgiseeq_close,
+        .ndo_start_xmit         = sgiseeq_start_xmit,
+        .ndo_tx_timeout         = timeout,
+        .ndo_set_multicast_list = sgiseeq_set_multicast,
+        .ndo_set_mac_address    = sgiseeq_set_mac_address,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static int __init sgiseeq_probe(struct platform_device *pdev)
 {
         struct sgiseeq_platform_data *pd = pdev->dev.platform_data;
@@ -775,13 +786,8 @@ static int __init sgiseeq_probe(struct platform_device *pdev)
                               SEEQ_CTRL_SFLAG | SEEQ_CTRL_ESHORT |
                               SEEQ_CTRL_ENCARR;
 
-        dev->open               = sgiseeq_open;
-        dev->stop               = sgiseeq_close;
-        dev->hard_start_xmit    = sgiseeq_start_xmit;
-        dev->tx_timeout         = timeout;
+        dev->netdev_ops         = &sgiseeq_netdev_ops;
         dev->watchdog_timeo     = (200 * HZ) / 1000;
-        dev->set_multicast_list = sgiseeq_set_multicast;
-        dev->set_mac_address    = sgiseeq_set_mac_address;
         dev->irq                = irq;
 
         if (register_netdev(dev)) {
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index 293610334a77..bc4976ac8712 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -1774,6 +1774,20 @@ static int __devinit smc911x_findirq(struct net_device *dev)
         return probe_irq_off(cookie);
 }
 
+static const struct net_device_ops smc911x_netdev_ops = {
+        .ndo_open               = smc911x_open,
+        .ndo_stop               = smc911x_close,
+        .ndo_start_xmit         = smc911x_hard_start_xmit,
+        .ndo_tx_timeout         = smc911x_timeout,
+        .ndo_set_multicast_list = smc911x_set_multicast_list,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = smc911x_poll_controller,
+#endif
+};
+
 /*
  * Function: smc911x_probe(unsigned long ioaddr)
  *
@@ -1940,16 +1954,9 @@ static int __devinit smc911x_probe(struct net_device *dev)
         /* Fill in the fields of the device structure with ethernet values. */
         ether_setup(dev);
 
-        dev->open = smc911x_open;
-        dev->stop = smc911x_close;
-        dev->hard_start_xmit = smc911x_hard_start_xmit;
-        dev->tx_timeout = smc911x_timeout;
+        dev->netdev_ops = &smc911x_netdev_ops;
         dev->watchdog_timeo = msecs_to_jiffies(watchdog);
-        dev->set_multicast_list = smc911x_set_multicast_list;
         dev->ethtool_ops = &smc911x_ethtool_ops;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = smc911x_poll_controller;
-#endif
 
         INIT_WORK(&lp->phy_configure, smc911x_phy_configure);
         lp->mii.phy_id_mask = 0x1f;
diff --git a/drivers/net/sun3lance.c b/drivers/net/sun3lance.c
index e5beb299cbd0..9bd9dadb8534 100644
--- a/drivers/net/sun3lance.c
+++ b/drivers/net/sun3lance.c
@@ -294,6 +294,16 @@ out:
         return ERR_PTR(err);
 }
 
+static const struct net_device_ops lance_netdev_ops = {
+        .ndo_open               = lance_open,
+        .ndo_stop               = lance_close,
+        .ndo_start_xmit         = lance_start_xmit,
+        .ndo_set_multicast_list = set_multicast_list,
+        .ndo_set_mac_address    = NULL,
+        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static int __init lance_probe( struct net_device *dev)
 {
         unsigned long ioaddr;
@@ -397,12 +407,7 @@ static int __init lance_probe( struct net_device *dev)
         if (did_version++ == 0)
                 printk( version );
 
-        /* The LANCE-specific entries in the device structure. */
-        dev->open = &lance_open;
-        dev->hard_start_xmit = &lance_start_xmit;
-        dev->stop = &lance_close;
-        dev->set_multicast_list = &set_multicast_list;
-        dev->set_mac_address = NULL;
+        dev->netdev_ops = &lance_netdev_ops;
 //      KLUDGE -- REMOVE ME
         set_bit(__LINK_STATE_PRESENT, &dev->state);
 
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 201be425643a..eb65e25989f3 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -68,8 +68,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.98"
-#define DRV_MODULE_RELDATE      "February 25, 2009"
+#define DRV_MODULE_VERSION      "3.99"
+#define DRV_MODULE_RELDATE      "April 20, 2009"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -1950,7 +1950,8 @@ static void tg3_frob_aux_power(struct tg3 *tp)
                                      GRC_LCLCTRL_GPIO_OUTPUT0 |
                                      GRC_LCLCTRL_GPIO_OUTPUT1),
                                     100);
-                } else if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761) {
+                } else if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761 ||
+                           tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S) {
                         /* The 5761 non-e device swaps GPIO 0 and GPIO 2. */
                         u32 grc_local_ctrl = GRC_LCLCTRL_GPIO_OE0 |
                                              GRC_LCLCTRL_GPIO_OE1 |
@@ -2455,8 +2456,6 @@ static int tg3_set_power_state(struct tg3 *tp, pci_power_t state)
                 }
         }
 
-        __tg3_set_mac_addr(tp, 0);
-
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
                 u32 val;
 
@@ -4656,6 +4655,7 @@ static int tg3_poll(struct napi_struct *napi, int budget)
                          * so we must read it before checking for more work.
                          */
                         tp->last_tag = sblk->status_tag;
+                        tp->last_irq_tag = tp->last_tag;
                         rmb();
                 } else
                         sblk->status &= ~SD_STATUS_UPDATED;
@@ -4811,7 +4811,7 @@ static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
          * Reading the PCI State register will confirm whether the
          * interrupt is ours and will flush the status block.
          */
-        if (unlikely(sblk->status_tag == tp->last_tag)) {
+        if (unlikely(sblk->status_tag == tp->last_irq_tag)) {
                 if ((tp->tg3_flags & TG3_FLAG_CHIP_RESETTING) ||
                     (tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
                         handled = 0;
@@ -4831,18 +4831,22 @@ static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
          * excessive spurious interrupts can be worse in some cases.
          */
         tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
+
+        /*
+         * In a shared interrupt configuration, sometimes other devices'
+         * interrupts will scream.  We record the current status tag here
+         * so that the above check can report that the screaming interrupts
+         * are unhandled.  Eventually they will be silenced.
+         */
+        tp->last_irq_tag = sblk->status_tag;
+
         if (tg3_irq_sync(tp))
                 goto out;
-        if (napi_schedule_prep(&tp->napi)) {
-                prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
-                /* Update last_tag to mark that this status has been
-                 * seen. Because interrupt may be shared, we may be
-                 * racing with tg3_poll(), so only update last_tag
-                 * if tg3_poll() is not scheduled.
-                 */
-                tp->last_tag = sblk->status_tag;
-                __napi_schedule(&tp->napi);
-        }
+
+        prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
+
+        napi_schedule(&tp->napi);
+
 out:
         return IRQ_RETVAL(handled);
 }
@@ -6156,6 +6160,7 @@ static int tg3_chip_reset(struct tg3 *tp)
                 tp->hw_status->status_tag = 0;
         }
         tp->last_tag = 0;
+        tp->last_irq_tag = 0;
         smp_mb();
         synchronize_irq(tp->pdev->irq);
 
@@ -6350,6 +6355,8 @@ static int tg3_halt(struct tg3 *tp, int kind, int silent)
         tg3_abort_hw(tp, silent);
         err = tg3_chip_reset(tp);
 
+        __tg3_set_mac_addr(tp, 0);
+
         tg3_write_sig_legacy(tp, kind);
         tg3_write_sig_post_reset(tp, kind);
 
@@ -6711,6 +6718,13 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                 tw32(TG3_CPMU_HST_ACC, val);
         }
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780) {
+                val = tr32(PCIE_PWR_MGMT_THRESH) & ~PCIE_PWR_MGMT_L1_THRESH_MSK;
+                val |= PCIE_PWR_MGMT_EXT_ASPM_TMR_EN |
+                       PCIE_PWR_MGMT_L1_THRESH_4MS;
+                tw32(PCIE_PWR_MGMT_THRESH, val);
+        }
+
         /* This works around an issue with Athlon chipsets on
          * B3 tigon3 silicon.  This bit has no effect on any
          * other revision.  But do not set this on PCI Express
@@ -7138,7 +7152,6 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         udelay(100);
 
         tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0);
-        tp->last_tag = 0;
 
         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
                 tw32_f(DMAC_MODE, DMAC_MODE_ENABLE);
@@ -8539,6 +8552,9 @@ static int tg3_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
         u32 i, offset, len, b_offset, b_count;
         __be32 val;
 
+        if (tp->tg3_flags3 & TG3_FLG3_NO_NVRAM)
+                return -EINVAL;
+
         if (tp->link_config.phy_is_low_power)
                 return -EAGAIN;
 
@@ -8604,7 +8620,8 @@ static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
         if (tp->link_config.phy_is_low_power)
                 return -EAGAIN;
 
-        if (eeprom->magic != TG3_EEPROM_MAGIC)
+        if ((tp->tg3_flags3 & TG3_FLG3_NO_NVRAM) ||
+            eeprom->magic != TG3_EEPROM_MAGIC)
                 return -EINVAL;
 
         offset = eeprom->offset;
@@ -9201,6 +9218,9 @@ static int tg3_test_nvram(struct tg3 *tp)
         __be32 *buf;
         int i, j, k, err = 0, size;
 
+        if (tp->tg3_flags3 & TG3_FLG3_NO_NVRAM)
+                return 0;
+
         if (tg3_nvram_read(tp, 0, &magic) != 0)
                 return -EIO;
 
@@ -10183,7 +10203,8 @@ static void __devinit tg3_get_nvram_size(struct tg3 *tp)
 {
         u32 val;
 
-        if (tg3_nvram_read(tp, 0, &val) != 0)
+        if ((tp->tg3_flags3 & TG3_FLG3_NO_NVRAM) ||
+            tg3_nvram_read(tp, 0, &val) != 0)
                 return;
 
         /* Selfboot format */
@@ -10565,6 +10586,7 @@ static void __devinit tg3_get_57780_nvram_info(struct tg3 *tp)
                 }
                 break;
         default:
+                tp->tg3_flags3 |= TG3_FLG3_NO_NVRAM;
                 return;
         }
 
@@ -11365,7 +11387,8 @@ static void __devinit tg3_read_partno(struct tg3 *tp)
         unsigned int i;
         u32 magic;
 
-        if (tg3_nvram_read(tp, 0x0, &magic))
+        if ((tp->tg3_flags3 & TG3_FLG3_NO_NVRAM) ||
+            tg3_nvram_read(tp, 0x0, &magic))
                 goto out_not_found;
 
         if (magic == TG3_EEPROM_MAGIC) {
@@ -11457,6 +11480,15 @@ static void __devinit tg3_read_partno(struct tg3 *tp)
 out_not_found:
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
                 strcpy(tp->board_part_number, "BCM95906");
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 &&
+                 tp->pdev->device == TG3PCI_DEVICE_TIGON3_57780)
+                strcpy(tp->board_part_number, "BCM57780");
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 &&
+                 tp->pdev->device == TG3PCI_DEVICE_TIGON3_57760)
+                strcpy(tp->board_part_number, "BCM57760");
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 &&
+                 tp->pdev->device == TG3PCI_DEVICE_TIGON3_57790)
+                strcpy(tp->board_part_number, "BCM57790");
         else
                 strcpy(tp->board_part_number, "none");
 }
@@ -11667,6 +11699,14 @@ static void __devinit tg3_read_fw_ver(struct tg3 *tp)
 {
         u32 val;
 
+        if (tp->tg3_flags3 & TG3_FLG3_NO_NVRAM) {
+                tp->fw_ver[0] = 's';
+                tp->fw_ver[1] = 'b';
+                tp->fw_ver[2] = '\0';
+
+                return;
+        }
+
         if (tg3_nvram_read(tp, 0, &val))
                 return;
 
@@ -11952,7 +11992,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                                 tp->tg3_flags2 &= ~TG3_FLG2_HW_TSO_2;
                         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
                             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
-                            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780)
+                            tp->pci_chip_rev_id == CHIPREV_ID_57780_A0 ||
+                            tp->pci_chip_rev_id == CHIPREV_ID_57780_A1)
                                 tp->tg3_flags3 |= TG3_FLG3_CLKREQ_BUG;
                 }
         } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785) {
@@ -12144,7 +12185,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780)
                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
 
-        if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761) {
+        if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761 ||
+            tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S) {
                 /* Turn off the debug UART. */
                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
                 if (tp->tg3_flags2 & TG3_FLG2_IS_NIC)
@@ -12454,7 +12496,8 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
         }
         if (!addr_ok) {
                 /* Next, try NVRAM. */
-                if (!tg3_nvram_read_be32(tp, mac_offset + 0, &hi) &&
+                if (!(tp->tg3_flags3 & TG3_FLG3_NO_NVRAM) &&
+                    !tg3_nvram_read_be32(tp, mac_offset + 0, &hi) &&
                     !tg3_nvram_read_be32(tp, mac_offset + 4, &lo)) {
                         memcpy(&dev->dev_addr[0], ((char *)&hi) + 2, 2);
                         memcpy(&dev->dev_addr[2], (char *)&lo, sizeof(lo));
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index cb4c62abdd21..b3347c41a1a3 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -95,6 +95,8 @@
 #define  CHIPREV_ID_5752_A1              0x6001
 #define  CHIPREV_ID_5714_A2              0x9002
 #define  CHIPREV_ID_5906_A1              0xc001
+#define  CHIPREV_ID_57780_A0             0x57780000
+#define  CHIPREV_ID_57780_A1             0x57780001
 #define  GET_ASIC_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 12)
 #define   ASIC_REV_5700                  0x07
 #define   ASIC_REV_5701                  0x00
@@ -1697,6 +1699,8 @@
 
 #define PCIE_PWR_MGMT_THRESH            0x00007d28
 #define PCIE_PWR_MGMT_L1_THRESH_MSK      0x0000ff00
+#define PCIE_PWR_MGMT_L1_THRESH_4MS      0x0000ff00
+#define PCIE_PWR_MGMT_EXT_ASPM_TMR_EN    0x01000000
 
 
 /* OTP bit definitions */
@@ -2501,6 +2505,7 @@ struct tg3 {
         struct tg3_hw_status            *hw_status;
         dma_addr_t                      status_mapping;
         u32                             last_tag;
+        u32                             last_irq_tag;
 
         u32                             msg_enable;
 
@@ -2635,6 +2640,7 @@ struct tg3 {
 #define TG3_FLG3_CLKREQ_BUG             0x00000800
 #define TG3_FLG3_PHY_ENABLE_APD         0x00001000
 #define TG3_FLG3_5755_PLUS              0x00002000
+#define TG3_FLG3_NO_NVRAM               0x00004000
 
         struct timer_list               timer;
         u16                             timer_counter;
diff --git a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c
index 264e61404f34..842b1a2c40d4 100644
--- a/drivers/net/tulip/winbond-840.c
+++ b/drivers/net/tulip/winbond-840.c
@@ -1601,8 +1601,7 @@ static int w840_suspend (struct pci_dev *pdev, pm_message_t state)
 
                 /* no more hardware accesses behind this line. */
 
-                BUG_ON(np->csr6);
-                if (ioread32(ioaddr + IntrEnable)) BUG();
+                BUG_ON(np->csr6 || ioread32(ioaddr + IntrEnable));
 
                 /* pci_power_off(pdev, -1); */
 
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 735bf41c654a..589f0ca668d6 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -540,31 +540,34 @@ static inline struct sk_buff *tun_alloc_skb(struct tun_struct *tun,
 
 /* Get packet from user space buffer */
 static __inline__ ssize_t tun_get_user(struct tun_struct *tun,
-                                       struct iovec *iv, size_t count,
+                                       const struct iovec *iv, size_t count,
                                        int noblock)
 {
         struct tun_pi pi = { 0, cpu_to_be16(ETH_P_IP) };
         struct sk_buff *skb;
         size_t len = count, align = 0;
         struct virtio_net_hdr gso = { 0 };
+        int offset = 0;
 
         if (!(tun->flags & TUN_NO_PI)) {
                 if ((len -= sizeof(pi)) > count)
                         return -EINVAL;
 
-                if(memcpy_fromiovec((void *)&pi, iv, sizeof(pi)))
+                if (memcpy_fromiovecend((void *)&pi, iv, 0, sizeof(pi)))
                         return -EFAULT;
+                offset += sizeof(pi);
         }
 
         if (tun->flags & TUN_VNET_HDR) {
                 if ((len -= sizeof(gso)) > count)
                         return -EINVAL;
 
-                if (memcpy_fromiovec((void *)&gso, iv, sizeof(gso)))
+                if (memcpy_fromiovecend((void *)&gso, iv, offset, sizeof(gso)))
                         return -EFAULT;
 
                 if (gso.hdr_len > len)
                         return -EINVAL;
+                offset += sizeof(pi);
         }
 
         if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) {
@@ -581,7 +584,7 @@ static __inline__ ssize_t tun_get_user(struct tun_struct *tun,
                 return PTR_ERR(skb);
         }
 
-        if (skb_copy_datagram_from_iovec(skb, 0, iv, len)) {
+        if (skb_copy_datagram_from_iovec(skb, 0, iv, offset, len)) {
                 tun->dev->stats.rx_dropped++;
                 kfree_skb(skb);
                 return -EFAULT;
@@ -673,7 +676,7 @@ static ssize_t tun_chr_aio_write(struct kiocb *iocb, const struct iovec *iv,
 
         DBG(KERN_INFO "%s: tun_chr_write %ld\n", tun->dev->name, count);
 
-        result = tun_get_user(tun, (struct iovec *)iv, iov_length(iv, count),
+        result = tun_get_user(tun, iv, iov_length(iv, count),
                               file->f_flags & O_NONBLOCK);
 
         tun_put(tun);
@@ -683,7 +686,7 @@ static ssize_t tun_chr_aio_write(struct kiocb *iocb, const struct iovec *iv,
 /* Put packet to the user space buffer */
 static __inline__ ssize_t tun_put_user(struct tun_struct *tun,
                                        struct sk_buff *skb,
-                                       struct iovec *iv, int len)
+                                       const struct iovec *iv, int len)
 {
         struct tun_pi pi = { 0, skb->protocol };
         ssize_t total = 0;
@@ -697,7 +700,7 @@ static __inline__ ssize_t tun_put_user(struct tun_struct *tun,
                         pi.flags |= TUN_PKT_STRIP;
                 }
 
-                if (memcpy_toiovec(iv, (void *) &pi, sizeof(pi)))
+                if (memcpy_toiovecend(iv, (void *) &pi, 0, sizeof(pi)))
                         return -EFAULT;
                 total += sizeof(pi);
         }
@@ -730,14 +733,15 @@ static __inline__ ssize_t tun_put_user(struct tun_struct *tun,
                         gso.csum_offset = skb->csum_offset;
                 } /* else everything is zero */
 
-                if (unlikely(memcpy_toiovec(iv, (void *)&gso, sizeof(gso))))
+                if (unlikely(memcpy_toiovecend(iv, (void *)&gso, total,
+                                               sizeof(gso))))
                         return -EFAULT;
                 total += sizeof(gso);
         }
 
         len = min_t(int, skb->len, len);
 
-        skb_copy_datagram_iovec(skb, 0, iv, len);
+        skb_copy_datagram_const_iovec(skb, 0, iv, total, len);
         total += len;
 
         tun->dev->stats.tx_packets++;
@@ -792,7 +796,7 @@ static ssize_t tun_chr_aio_read(struct kiocb *iocb, const struct iovec *iv,
                 }
                 netif_wake_queue(tun->dev);
 
-                ret = tun_put_user(tun, skb, (struct iovec *) iv, len);
+                ret = tun_put_user(tun, skb, iv, len);
                 kfree_skb(skb);
                 break;
         }
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 44f8392da117..811f97cb0a29 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3217,7 +3217,7 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
                 dev->stats.tx_packets++;
 
                 /* Free the sk buffer associated with this TxBD */
-                dev_kfree_skb_irq(ugeth->
+                dev_kfree_skb(ugeth->
                                   tx_skbuff[txQ][ugeth->skb_dirtytx[txQ]]);
                 ugeth->tx_skbuff[txQ][ugeth->skb_dirtytx[txQ]] = NULL;
                 ugeth->skb_dirtytx[txQ] =
@@ -3251,9 +3251,15 @@ static int ucc_geth_poll(struct napi_struct *napi, int budget)
         for (i = 0; i < ug_info->numQueuesRx; i++)
                 howmany += ucc_geth_rx(ugeth, i, budget - howmany);
 
+        /* Tx event processing */
+        spin_lock(&ugeth->lock);
+        for (i = 0; i < ug_info->numQueuesTx; i++)
+                ucc_geth_tx(ugeth->ndev, i);
+        spin_unlock(&ugeth->lock);
+
         if (howmany < budget) {
                 napi_complete(napi);
-                setbits32(ugeth->uccf->p_uccm, UCCE_RX_EVENTS);
+                setbits32(ugeth->uccf->p_uccm, UCCE_RX_EVENTS | UCCE_TX_EVENTS);
         }
 
         return howmany;
@@ -3267,8 +3273,6 @@ static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
         struct ucc_geth_info *ug_info;
         register u32 ucce;
         register u32 uccm;
-        register u32 tx_mask;
-        u8 i;
 
         ugeth_vdbg("%s: IN", __func__);
 
@@ -3282,27 +3286,14 @@ static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
         out_be32(uccf->p_ucce, ucce);
 
         /* check for receive events that require processing */
-        if (ucce & UCCE_RX_EVENTS) {
+        if (ucce & (UCCE_RX_EVENTS | UCCE_TX_EVENTS)) {
                 if (napi_schedule_prep(&ugeth->napi)) {
-                        uccm &= ~UCCE_RX_EVENTS;
+                        uccm &= ~(UCCE_RX_EVENTS | UCCE_TX_EVENTS);
                         out_be32(uccf->p_uccm, uccm);
                         __napi_schedule(&ugeth->napi);
                 }
         }
 
-        /* Tx event processing */
-        if (ucce & UCCE_TX_EVENTS) {
-                spin_lock(&ugeth->lock);
-                tx_mask = UCC_GETH_UCCE_TXB0;
-                for (i = 0; i < ug_info->numQueuesTx; i++) {
-                        if (ucce & tx_mask)
-                                ucc_geth_tx(dev, i);
-                        ucce &= ~tx_mask;
-                        tx_mask <<= 1;
-                }
-                spin_unlock(&ugeth->lock);
-        }
-
         /* Errors and other events */
         if (ucce & UCCE_OTHER) {
                 if (ucce & UCC_GETH_UCCE_BSY)
@@ -3735,7 +3726,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
         dev->netdev_ops = &ucc_geth_netdev_ops;
         dev->watchdog_timeo = TX_TIMEOUT;
         INIT_WORK(&ugeth->timeout_work, ucc_geth_timeout_work);
-        netif_napi_add(dev, &ugeth->napi, ucc_geth_poll, UCC_GETH_DEV_WEIGHT);
+        netif_napi_add(dev, &ugeth->napi, ucc_geth_poll, 64);
         dev->mtu = 1500;
 
         ugeth->msg_enable = netif_msg_init(debug.msg_enable, UGETH_MSG_DEFAULT);
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index 2f8ee7c87efe..602764799df0 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -852,7 +852,6 @@ struct ucc_geth_hardware_statistics {
 /* Driver definitions */
 #define TX_BD_RING_LEN                          0x10
 #define RX_BD_RING_LEN                          0x10
-#define UCC_GETH_DEV_WEIGHT                     TX_BD_RING_LEN
 
 #define TX_RING_MOD_MASK(size)                  (size-1)
 #define RX_RING_MOD_MASK(size)                  (size-1)
diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index 8ee21030e9ac..e00b5b1f6743 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -345,4 +345,12 @@ config USB_HSO
           To compile this driver as a module, choose M here: the
           module will be called hso.
 
+config USB_NET_INT51X1
+        tristate "Intellon PLC based usb adapter"
+        depends on USB_USBNET
+        help
+          Choose this option if you're using a 14Mb USB-based PLC
+          (Powerline Communications) solution with an Intellon
+          INT51x1/INT5200 chip, like the "devolo dLan duo".
+
 endmenu
diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile
index 88a87eeb376a..f4402a06e52c 100644
--- a/drivers/net/usb/Makefile
+++ b/drivers/net/usb/Makefile
@@ -19,4 +19,5 @@ obj-$(CONFIG_USB_NET_CDC_SUBSET)	+= cdc_subset.o
 obj-$(CONFIG_USB_NET_ZAURUS)    += zaurus.o
 obj-$(CONFIG_USB_NET_MCS7830)   += mcs7830.o
 obj-$(CONFIG_USB_USBNET)        += usbnet.o
+obj-$(CONFIG_USB_NET_INT51X1)   += int51x1.o
 
diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
index 55e8ecc3a9e5..01fd528306ec 100644
--- a/drivers/net/usb/cdc_ether.c
+++ b/drivers/net/usb/cdc_ether.c
@@ -25,7 +25,6 @@
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
-#include <linux/ctype.h>
 #include <linux/ethtool.h>
 #include <linux/workqueue.h>
 #include <linux/mii.h>
@@ -389,36 +388,6 @@ static void cdc_status(struct usbnet *dev, struct urb *urb)
         }
 }
 
-static u8 nibble(unsigned char c)
-{
-        if (likely(isdigit(c)))
-                return c - '0';
-        c = toupper(c);
-        if (likely(isxdigit(c)))
-                return 10 + c - 'A';
-        return 0;
-}
-
-static inline int
-get_ethernet_addr(struct usbnet *dev, struct usb_cdc_ether_desc *e)
-{
-        int             tmp, i;
-        unsigned char   buf [13];
-
-        tmp = usb_string(dev->udev, e->iMACAddress, buf, sizeof buf);
-        if (tmp != 12) {
-                dev_dbg(&dev->udev->dev,
-                        "bad MAC string %d fetch, %d\n", e->iMACAddress, tmp);
-                if (tmp >= 0)
-                        tmp = -EINVAL;
-                return tmp;
-        }
-        for (i = tmp = 0; i < 6; i++, tmp += 2)
-                dev->net->dev_addr [i] =
-                        (nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
-        return 0;
-}
-
 static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
 {
         int                             status;
@@ -428,7 +397,7 @@ static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
         if (status < 0)
                 return status;
 
-        status = get_ethernet_addr(dev, info->ether);
+        status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
         if (status < 0) {
                 usb_set_intfdata(info->data, NULL);
                 usb_driver_release_interface(driver_of(intf), info->data);
diff --git a/drivers/net/usb/int51x1.c b/drivers/net/usb/int51x1.c
new file mode 100644
index 000000000000..55cf7081de10
--- /dev/null
+++ b/drivers/net/usb/int51x1.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2009 Peter Holik
+ *
+ * Intellon usb PLC (Powerline Communications) usb net driver
+ *
+ * http://www.tandel.be/downloads/INT51X1_Datasheet.pdf
+ *
+ * Based on the work of Jan 'RedBully' Seiffert
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or.
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/ctype.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/usb/usbnet.h>
+
+#define INT51X1_VENDOR_ID       0x09e1
+#define INT51X1_PRODUCT_ID      0x5121
+
+#define INT51X1_HEADER_SIZE     2       /* 2 byte header */
+
+#define PACKET_TYPE_PROMISCUOUS         (1 << 0)
+#define PACKET_TYPE_ALL_MULTICAST       (1 << 1) /* no filter */
+#define PACKET_TYPE_DIRECTED            (1 << 2)
+#define PACKET_TYPE_BROADCAST           (1 << 3)
+#define PACKET_TYPE_MULTICAST           (1 << 4) /* filtered */
+
+#define SET_ETHERNET_PACKET_FILTER      0x43
+
+static int int51x1_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        int len;
+
+        if (!(pskb_may_pull(skb, INT51X1_HEADER_SIZE))) {
+                deverr(dev, "unexpected tiny rx frame");
+                return 0;
+        }
+
+        len = le16_to_cpu(*(__le16 *)&skb->data[skb->len - 2]);
+
+        skb_trim(skb, len);
+
+        return 1;
+}
+
+static struct sk_buff *int51x1_tx_fixup(struct usbnet *dev,
+                struct sk_buff *skb, gfp_t flags)
+{
+        int pack_len = skb->len;
+        int pack_with_header_len = pack_len + INT51X1_HEADER_SIZE;
+        int headroom = skb_headroom(skb);
+        int tailroom = skb_tailroom(skb);
+        int need_tail = 0;
+        __le16 *len;
+
+        /* if packet and our header is smaler than 64 pad to 64 (+ ZLP) */
+        if ((pack_with_header_len) < dev->maxpacket)
+                need_tail = dev->maxpacket - pack_with_header_len + 1;
+        /*
+         * usbnet would send a ZLP if packetlength mod urbsize == 0 for us,
+         * but we need to know ourself, because this would add to the length
+         * we send down to the device...
+         */
+        else if (!(pack_with_header_len % dev->maxpacket))
+                need_tail = 1;
+
+        if (!skb_cloned(skb) &&
+                        (headroom + tailroom >= need_tail + INT51X1_HEADER_SIZE)) {
+                if (headroom < INT51X1_HEADER_SIZE || tailroom < need_tail) {
+                        skb->data = memmove(skb->head + INT51X1_HEADER_SIZE,
+                                        skb->data, skb->len);
+                        skb_set_tail_pointer(skb, skb->len);
+                }
+        } else {
+                struct sk_buff *skb2;
+
+                skb2 = skb_copy_expand(skb,
+                                INT51X1_HEADER_SIZE,
+                                need_tail,
+                                flags);
+                dev_kfree_skb_any(skb);
+                if (!skb2)
+                        return NULL;
+                skb = skb2;
+        }
+
+        pack_len += need_tail;
+        pack_len &= 0x07ff;
+
+        len = (__le16 *) __skb_push(skb, INT51X1_HEADER_SIZE);
+        *len = cpu_to_le16(pack_len);
+
+        if(need_tail)
+                memset(__skb_put(skb, need_tail), 0, need_tail);
+
+        return skb;
+}
+
+static void int51x1_async_cmd_callback(struct urb *urb)
+{
+        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
+        int status = urb->status;
+
+        if (status < 0)
+                dev_warn(&urb->dev->dev, "async callback failed with %d\n", status);
+
+        kfree(req);
+        usb_free_urb(urb);
+}
+
+static void int51x1_set_multicast(struct net_device *netdev)
+{
+        struct usb_ctrlrequest *req;
+        int status;
+        struct urb *urb;
+        struct usbnet *dev = netdev_priv(netdev);
+        u16 filter = PACKET_TYPE_DIRECTED | PACKET_TYPE_BROADCAST;
+
+        if (netdev->flags & IFF_PROMISC) {
+                /* do not expect to see traffic of other PLCs */
+                filter |= PACKET_TYPE_PROMISCUOUS;
+                devinfo(dev, "promiscuous mode enabled");
+        } else if (netdev->mc_count ||
+                  (netdev->flags & IFF_ALLMULTI)) {
+                filter |= PACKET_TYPE_ALL_MULTICAST;
+                devdbg(dev, "receive all multicast enabled");
+        } else {
+                /* ~PROMISCUOUS, ~MULTICAST */
+                devdbg(dev, "receive own packets only");
+        }
+
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+        if (!urb) {
+                devwarn(dev, "Error allocating URB");
+                return;
+        }
+
+        req = kmalloc(sizeof(*req), GFP_ATOMIC);
+        if (!req) {
+                devwarn(dev, "Error allocating control msg");
+                goto out;
+        }
+
+        req->bRequestType = USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
+        req->bRequest = SET_ETHERNET_PACKET_FILTER;
+        req->wValue = cpu_to_le16(filter);
+        req->wIndex = 0;
+        req->wLength = 0;
+
+        usb_fill_control_urb(urb, dev->udev, usb_sndctrlpipe(dev->udev, 0),
+                (void *)req, NULL, 0,
+                int51x1_async_cmd_callback,
+                (void *)req);
+
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status < 0) {
+                devwarn(dev, "Error submitting control msg, sts=%d", status);
+                goto out1;
+        }
+        return;
+out1:
+        kfree(req);
+out:
+        usb_free_urb(urb);
+}
+
+static const struct net_device_ops int51x1_netdev_ops = {
+        .ndo_open               = usbnet_open,
+        .ndo_stop               = usbnet_stop,
+        .ndo_start_xmit         = usbnet_start_xmit,
+        .ndo_tx_timeout         = usbnet_tx_timeout,
+        .ndo_change_mtu         = usbnet_change_mtu,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_multicast_list = int51x1_set_multicast,
+};
+
+static int int51x1_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int status = usbnet_get_ethernet_addr(dev, 3);
+
+        if (status)
+                return status;
+
+        dev->net->hard_header_len += INT51X1_HEADER_SIZE;
+        dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
+        dev->net->netdev_ops = &int51x1_netdev_ops;
+
+        return usbnet_get_endpoints(dev, intf);
+}
+
+static const struct driver_info int51x1_info = {
+        .description = "Intellon usb powerline adapter",
+        .bind        = int51x1_bind,
+        .rx_fixup    = int51x1_rx_fixup,
+        .tx_fixup    = int51x1_tx_fixup,
+        .in          = 1,
+        .out         = 2,
+        .flags       = FLAG_ETHER,
+};
+
+static const struct usb_device_id products[] = {
+        {
+        USB_DEVICE(INT51X1_VENDOR_ID, INT51X1_PRODUCT_ID),
+                .driver_info = (unsigned long) &int51x1_info,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver int51x1_driver = {
+        .name       = "int51x1",
+        .id_table   = products,
+        .probe      = usbnet_probe,
+        .disconnect = usbnet_disconnect,
+        .suspend    = usbnet_suspend,
+        .resume     = usbnet_resume,
+};
+
+static int __init int51x1_init(void)
+{
+        return usb_register(&int51x1_driver);
+}
+module_init(int51x1_init);
+
+static void __exit int51x1_exit(void)
+{
+        usb_deregister(&int51x1_driver);
+}
+module_exit(int51x1_exit);
+
+MODULE_AUTHOR("Peter Holik");
+MODULE_DESCRIPTION("Intellon usb powerline adapter");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/usb/kaweth.c b/drivers/net/usb/kaweth.c
index 3d0d0b0b37c5..e01314789718 100644
--- a/drivers/net/usb/kaweth.c
+++ b/drivers/net/usb/kaweth.c
@@ -31,7 +31,6 @@
  ****************************************************************/
 
 /* TODO:
- * Fix in_interrupt() problem
  * Develop test procedures for USB net interfaces
  * Run test procedures
  * Fix bugs from previous two steps
@@ -606,14 +605,30 @@ static void kaweth_usb_receive(struct urb *urb)
 
         struct sk_buff *skb;
 
-        if(unlikely(status == -ECONNRESET || status == -ESHUTDOWN))
-        /* we are killed - set a flag and wake the disconnect handler */
-        {
+        if (unlikely(status == -EPIPE)) {
+                kaweth->stats.rx_errors++;
                 kaweth->end = 1;
                 wake_up(&kaweth->term_wait);
+                dbg("Status was -EPIPE.");
                 return;
         }
-
+        if (unlikely(status == -ECONNRESET || status == -ESHUTDOWN)) {
+                /* we are killed - set a flag and wake the disconnect handler */
+                kaweth->end = 1;
+                wake_up(&kaweth->term_wait);
+                dbg("Status was -ECONNRESET or -ESHUTDOWN.");
+                return;
+        }
+        if (unlikely(status == -EPROTO || status == -ETIME ||
+                     status == -EILSEQ)) {
+                kaweth->stats.rx_errors++;
+                dbg("Status was -EPROTO, -ETIME, or -EILSEQ.");
+                return;
+        }
+        if (unlikely(status == -EOVERFLOW)) {
+                kaweth->stats.rx_errors++;
+                dbg("Status was -EOVERFLOW.");
+        }
         spin_lock(&kaweth->device_lock);
         if (IS_BLOCKED(kaweth->status)) {
                 spin_unlock(&kaweth->device_lock);
@@ -883,13 +898,16 @@ static void kaweth_set_rx_mode(struct net_device *net)
  ****************************************************************/
 static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
 {
+        int result;
         __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
+
         kaweth->packet_filter_bitmap = 0;
         if (packet_filter_bitmap == 0)
                 return;
 
-        {
-        int result;
+        if (in_interrupt())
+                return;
+
         result = kaweth_control(kaweth,
                                 usb_sndctrlpipe(kaweth->dev, 0),
                                 KAWETH_COMMAND_SET_PACKET_FILTER,
@@ -906,7 +924,6 @@ static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
         else {
                 dbg("Set Rx mode to %d", packet_filter_bitmap);
         }
-        }
 }
 
 /****************************************************************
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index f3a2fce6166c..c94de6243140 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -37,6 +37,7 @@
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/ctype.h>
 #include <linux/ethtool.h>
 #include <linux/workqueue.h>
 #include <linux/mii.h>
@@ -156,6 +157,36 @@ int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
 }
 EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
 
+static u8 nibble(unsigned char c)
+{
+        if (likely(isdigit(c)))
+                return c - '0';
+        c = toupper(c);
+        if (likely(isxdigit(c)))
+                return 10 + c - 'A';
+        return 0;
+}
+
+int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
+{
+        int             tmp, i;
+        unsigned char   buf [13];
+
+        tmp = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
+        if (tmp != 12) {
+                dev_dbg(&dev->udev->dev,
+                        "bad MAC string %d fetch, %d\n", iMACAddress, tmp);
+                if (tmp >= 0)
+                        tmp = -EINVAL;
+                return tmp;
+        }
+        for (i = tmp = 0; i < 6; i++, tmp += 2)
+                dev->net->dev_addr [i] =
+                        (nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
+
 static void intr_complete (struct urb *urb);
 
 static int init_status (struct usbnet *dev, struct usb_interface *intf)
@@ -1185,12 +1216,6 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 #endif
 
         net->netdev_ops = &usbnet_netdev_ops;
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        net->hard_start_xmit = usbnet_start_xmit;
-        net->open = usbnet_open;
-        net->stop = usbnet_stop;
-        net->tx_timeout = usbnet_tx_timeout;
-#endif
         net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
         net->ethtool_ops = &usbnet_ethtool_ops;
 
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 9c82a39497e5..071855871524 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -621,12 +621,9 @@ static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
         virtio_net_ctrl_ack status = ~0;
         unsigned int tmp;
 
-        if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ)) {
-                BUG();  /* Caller should know better */
-                return false;
-        }
-
-        BUG_ON(out + in > VIRTNET_SEND_COMMAND_SG_MAX);
+        /* Caller should know better */
+        BUG_ON(!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ) ||
+                (out + in > VIRTNET_SEND_COMMAND_SG_MAX));
 
         out++; /* Add header */
         in++; /* Add return status */
@@ -640,8 +637,7 @@ static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
         memcpy(&sg[1], data, sizeof(struct scatterlist) * (out + in - 2));
         sg_set_buf(&sg[out + in - 1], &status, sizeof(status));
 
-        if (vi->cvq->vq_ops->add_buf(vi->cvq, sg, out, in, vi) != 0)
-                BUG();
+        BUG_ON(vi->cvq->vq_ops->add_buf(vi->cvq, sg, out, in, vi));
 
         vi->cvq->vq_ops->kick(vi->cvq);
 
diff --git a/drivers/net/wan/pc300_drv.c b/drivers/net/wan/pc300_drv.c
index c23fde0c0344..79dabc557bd3 100644
--- a/drivers/net/wan/pc300_drv.c
+++ b/drivers/net/wan/pc300_drv.c
@@ -225,6 +225,7 @@ static char rcsid[] =
 #include <linux/skbuff.h>
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
+#include <linux/etherdevice.h>
 #include <linux/spinlock.h>
 #include <linux/if.h>
 #include <net/arp.h>
@@ -3246,6 +3247,16 @@ static inline void show_version(void)
                 rcsvers, rcsdate, __DATE__, __TIME__);
 }                               /* show_version */
 
+static const struct net_device_ops cpc_netdev_ops = {
+        .ndo_open               = cpc_open,
+        .ndo_stop               = cpc_close,
+        .ndo_tx_timeout         = cpc_tx_timeout,
+        .ndo_set_mac_address    = NULL,
+        .ndo_change_mtu         = cpc_change_mtu,
+        .ndo_do_ioctl           = cpc_ioctl,
+        .ndo_validate_addr      = eth_validate_addr,
+};
+
 static void cpc_init_card(pc300_t * card)
 {
         int i, devcount = 0;
@@ -3357,18 +3368,11 @@ static void cpc_init_card(pc300_t * card)
                 dev->mem_start = card->hw.ramphys;
                 dev->mem_end = card->hw.ramphys + card->hw.ramsize - 1;
                 dev->irq = card->hw.irq;
-                dev->init = NULL;
                 dev->tx_queue_len = PC300_TX_QUEUE_LEN;
                 dev->mtu = PC300_DEF_MTU;
 
-                dev->open = cpc_open;
-                dev->stop = cpc_close;
-                dev->tx_timeout = cpc_tx_timeout;
+                dev->netdev_ops = &cpc_netdev_ops;
                 dev->watchdog_timeo = PC300_TX_TIMEOUT;
-                dev->set_multicast_list = NULL;
-                dev->set_mac_address = NULL;
-                dev->change_mtu = cpc_change_mtu;
-                dev->do_ioctl = cpc_ioctl;
 
                 if (register_hdlc_device(dev) == 0) {
                         printk("%s: Cyclades-PC300/", dev->name);
diff --git a/drivers/net/wireless/at76c50x-usb.c b/drivers/net/wireless/at76c50x-usb.c
index 744f4f4dd3d1..69248ded5102 100644
--- a/drivers/net/wireless/at76c50x-usb.c
+++ b/drivers/net/wireless/at76c50x-usb.c
@@ -2311,8 +2311,7 @@ static void at76_delete_device(struct at76_priv *priv)
 
         del_timer_sync(&ledtrig_tx_timer);
 
-        if (priv->rx_skb)
-                kfree_skb(priv->rx_skb);
+        kfree_skb(priv->rx_skb);
 
         usb_put_dev(priv->udev);
 
diff --git a/drivers/net/wireless/ath5k/reset.c b/drivers/net/wireless/ath5k/reset.c
index 7a17d31b2fd9..cb5e15f97095 100644
--- a/drivers/net/wireless/ath5k/reset.c
+++ b/drivers/net/wireless/ath5k/reset.c
@@ -54,9 +54,8 @@ static inline int ath5k_hw_write_ofdm_timings(struct ath5k_hw *ah,
         u32 coef_scaled, coef_exp, coef_man,
                 ds_coef_exp, ds_coef_man, clock;
 
-        if (!(ah->ah_version == AR5K_AR5212) ||
-                !(channel->hw_value & CHANNEL_OFDM))
-                BUG();
+        BUG_ON(!(ah->ah_version == AR5K_AR5212) ||
+                !(channel->hw_value & CHANNEL_OFDM));
 
         /* Get coefficient
          * ALGO: coef = (5 * clock * carrier_freq) / 2)
diff --git a/drivers/net/wireless/ath9k/ath9k.h b/drivers/net/wireless/ath9k/ath9k.h
index 2689a08a2844..7b1b40aaf09d 100644
--- a/drivers/net/wireless/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath9k/ath9k.h
@@ -53,11 +53,7 @@ struct ath_node;
 
 #define A_MAX(a, b) ((a) > (b) ? (a) : (b))
 
-#define ASSERT(exp) do {                        \
-                if (unlikely(!(exp))) {         \
-                        BUG();                  \
-                }                               \
-        } while (0)
+#define ASSERT(exp) BUG_ON(!(exp))
 
 #define TSF_TO_TU(_h,_l) \
         ((((u32)(_h)) << 22) | (((u32)(_l)) >> 10))
diff --git a/drivers/net/wireless/ipw2x00/ipw2200.c b/drivers/net/wireless/ipw2x00/ipw2200.c
index bd4dbcfe1bbe..9a123fbcc359 100644
--- a/drivers/net/wireless/ipw2x00/ipw2200.c
+++ b/drivers/net/wireless/ipw2x00/ipw2200.c
@@ -3176,11 +3176,8 @@ static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
         /* Start the Dma */
         rc = ipw_fw_dma_enable(priv);
 
-        if (priv->sram_desc.last_cb_index > 0) {
-                /* the DMA is already ready this would be a bug. */
-                BUG();
-                goto out;
-        }
+        /* the DMA is already ready this would be a bug. */
+        BUG_ON(priv->sram_desc.last_cb_index > 0);
 
         do {
                 chunk = (struct fw_chunk *)(data + offset);
diff --git a/drivers/net/wireless/ipw2x00/libipw_module.c b/drivers/net/wireless/ipw2x00/libipw_module.c
index 92a26922e792..8ce6e961c5da 100644
--- a/drivers/net/wireless/ipw2x00/libipw_module.c
+++ b/drivers/net/wireless/ipw2x00/libipw_module.c
@@ -154,10 +154,6 @@ struct net_device *alloc_ieee80211(int sizeof_priv)
                 goto failed;
         }
         ieee = netdev_priv(dev);
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        dev->hard_start_xmit = ieee80211_xmit;
-        dev->change_mtu = ieee80211_change_mtu;
-#endif
 
         ieee->dev = dev;
 
diff --git a/drivers/net/wireless/libertas/if_usb.c b/drivers/net/wireless/libertas/if_usb.c
index ea3dc038be76..d649caebf08a 100644
--- a/drivers/net/wireless/libertas/if_usb.c
+++ b/drivers/net/wireless/libertas/if_usb.c
@@ -686,8 +686,7 @@ static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
                 return;
         }
 
-        if (!in_interrupt())
-                BUG();
+        BUG_ON(!in_interrupt());
 
         spin_lock(&priv->driver_lock);
 
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c
index 59634c33b1f9..392337b37b1d 100644
--- a/drivers/net/wireless/libertas_tf/if_usb.c
+++ b/drivers/net/wireless/libertas_tf/if_usb.c
@@ -461,8 +461,7 @@ static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
                 return;
         }
 
-        if (!in_interrupt())
-                BUG();
+        BUG_ON(!in_interrupt());
 
         spin_lock(&priv->driver_lock);
         memcpy(priv->cmd_resp_buff, recvbuff + MESSAGE_HEADER_LEN,
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index e1ff5b14310e..7ff9af1d0f05 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -118,8 +118,7 @@ extern int vlan_hwaccel_do_receive(struct sk_buff *skb);
 extern int vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
                             unsigned int vlan_tci, struct sk_buff *skb);
 extern int vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-                          unsigned int vlan_tci,
-                          struct napi_gro_fraginfo *info);
+                          unsigned int vlan_tci);
 
 #else
 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
@@ -154,8 +153,7 @@ static inline int vlan_gro_receive(struct napi_struct *napi,
 }
 
 static inline int vlan_gro_frags(struct napi_struct *napi,
-                                 struct vlan_group *grp, unsigned int vlan_tci,
-                                 struct napi_gro_fraginfo *info)
+                                 struct vlan_group *grp, unsigned int vlan_tci)
 {
         return NET_RX_DROP;
 }
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 2e7783f4a755..31167451d08d 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -42,6 +42,7 @@
 #include <linux/dmaengine.h>
 #include <linux/workqueue.h>
 
+#include <linux/ethtool.h>
 #include <net/net_namespace.h>
 #include <net/dsa.h>
 #ifdef CONFIG_DCB
@@ -49,7 +50,6 @@
 #endif
 
 struct vlan_group;
-struct ethtool_ops;
 struct netpoll_info;
 /* 802.11 specific */
 struct wireless_dev;
@@ -1047,14 +1047,6 @@ struct packet_type {
         struct list_head        list;
 };
 
-struct napi_gro_fraginfo {
-        skb_frag_t frags[MAX_SKB_FRAGS];
-        unsigned int nr_frags;
-        unsigned int ip_summed;
-        unsigned int len;
-        __wsum csum;
-};
-
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 
@@ -1442,12 +1434,18 @@ extern int		napi_gro_receive(struct napi_struct *napi,
                                          struct sk_buff *skb);
 extern void             napi_reuse_skb(struct napi_struct *napi,
                                        struct sk_buff *skb);
-extern struct sk_buff * napi_fraginfo_skb(struct napi_struct *napi,
-                                          struct napi_gro_fraginfo *info);
+extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
 extern int              napi_frags_finish(struct napi_struct *napi,
                                           struct sk_buff *skb, int ret);
-extern int              napi_gro_frags(struct napi_struct *napi,
-                                       struct napi_gro_fraginfo *info);
+extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
+extern int              napi_gro_frags(struct napi_struct *napi);
+
+static inline void napi_free_frags(struct napi_struct *napi)
+{
+        kfree_skb(napi->skb);
+        napi->skb = NULL;
+}
+
 extern void             netif_nit_deliver(struct sk_buff *skb);
 extern int              dev_valid_name(const char *name);
 extern int              dev_ioctl(struct net *net, unsigned int cmd, void __user *);
@@ -1908,6 +1906,28 @@ static inline int skb_bond_should_drop(struct sk_buff *skb)
 }
 
 extern struct pernet_operations __net_initdata loopback_net_ops;
+
+static inline int dev_ethtool_get_settings(struct net_device *dev,
+                                           struct ethtool_cmd *cmd)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
+                return -EOPNOTSUPP;
+        return dev->ethtool_ops->get_settings(dev, cmd);
+}
+
+static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
+                return 0;
+        return dev->ethtool_ops->get_rx_csum(dev);
+}
+
+static inline u32 dev_ethtool_get_flags(struct net_device *dev)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
+                return 0;
+        return dev->ethtool_ops->get_flags(dev);
+}
 #endif /* __KERNEL__ */
 
 #endif  /* _LINUX_DEV_H */
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 5fd389162f01..1b5c3d298f43 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1715,8 +1715,14 @@ extern int	       skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
                                                         struct iovec *iov);
 extern int             skb_copy_datagram_from_iovec(struct sk_buff *skb,
                                                     int offset,
-                                                    struct iovec *from,
+                                                    const struct iovec *from,
+                                                    int from_offset,
                                                     int len);
+extern int             skb_copy_datagram_const_iovec(const struct sk_buff *from,
+                                                     int offset,
+                                                     const struct iovec *to,
+                                                     int to_offset,
+                                                     int size);
 extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
 extern int             skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
                                          unsigned int flags);
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 421afb4d29b0..d2310cb45d2f 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -303,14 +303,15 @@ struct ucred {
 #define SOL_BLUETOOTH   274
 #define SOL_PNPIPE      275
 #define SOL_RDS         276
+#define SOL_IUCV        277
 
 /* IPX options */
 #define IPX_TYPE        1
 
 #ifdef __KERNEL__
 extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
-extern int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov, 
-                                int offset, int len);
+extern int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
+                               int offset, int len);
 extern int csum_partial_copy_fromiovecend(unsigned char *kdata, 
                                           struct iovec *iov, 
                                           int offset, 
@@ -318,6 +319,8 @@ extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
 
 extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
 extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
+extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
+                             int offset, int len);
 extern int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, int __user *ulen);
 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 9d5078bd23a3..8afac76cd748 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -377,7 +377,7 @@ struct tcp_sock {
         unsigned int            keepalive_time;   /* time before keep alive takes place */
         unsigned int            keepalive_intvl;  /* time interval between keep alive probes */
 
-        unsigned long last_synq_overflow; 
+        int                     linger2;
 
 /* Receiver side RTT estimation */
         struct {
@@ -406,8 +406,6 @@ struct tcp_sock {
 /* TCP MD5 Signagure Option information */
         struct tcp_md5sig_info  *md5sig_info;
 #endif
-
-        int                     linger2;
 };
 
 static inline struct tcp_sock *tcp_sk(const struct sock *sk)
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index 36fabb95c7d3..5d44059f6d63 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -183,6 +183,7 @@ extern void usbnet_tx_timeout (struct net_device *net);
 extern int usbnet_change_mtu (struct net_device *net, int new_mtu);
 
 extern int usbnet_get_endpoints(struct usbnet *, struct usb_interface *);
+extern int usbnet_get_ethernet_addr(struct usbnet *, int);
 extern void usbnet_defer_kevent (struct usbnet *, int);
 extern void usbnet_skb_return (struct usbnet *, struct sk_buff *);
 extern void usbnet_unlink_rx_urbs(struct usbnet *);
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index 85f80eadfa35..21ee49ffcbaf 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -73,8 +73,17 @@ struct iucv_sock {
         struct sk_buff_head     backlog_skb_q;
         struct sock_msg_q       message_q;
         unsigned int            send_tag;
+        u8                      flags;
+        u16                     msglimit;
 };
 
+/* iucv socket options (SOL_IUCV) */
+#define SO_IPRMDATA_MSG 0x0080          /* send/recv IPRM_DATA msgs */
+#define SO_MSGLIMIT     0x1000          /* get/set IUCV MSGLIMIT */
+
+/* iucv related control messages (scm) */
+#define SCM_IUCV_TRGCLS 0x0001          /* target class control message */
+
 struct iucv_sock_list {
         struct hlist_head head;
         rwlock_t          lock;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 1b94b9bfe2dc..b55b4891029e 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -265,6 +265,19 @@ static inline int tcp_too_many_orphans(struct sock *sk, int num)
                  atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2]);
 }
 
+/* syncookies: remember time of last synqueue overflow */
+static inline void tcp_synq_overflow(struct sock *sk)
+{
+        tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
+}
+
+/* syncookies: no recent synqueue overflow on this listening socket? */
+static inline int tcp_synq_no_recent_overflow(const struct sock *sk)
+{
+        unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
+        return time_after(jiffies, last_overflow + TCP_TIMEOUT_INIT);
+}
+
 extern struct proto tcp_prot;
 
 #define TCP_INC_STATS(net, field)       SNMP_INC_STATS((net)->mib.tcp_statistics, field)
diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c
index c67fe6f75653..7f7de1a04de6 100644
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@ -114,9 +114,9 @@ int vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 EXPORT_SYMBOL(vlan_gro_receive);
 
 int vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-                   unsigned int vlan_tci, struct napi_gro_fraginfo *info)
+                   unsigned int vlan_tci)
 {
-        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
+        struct sk_buff *skb = napi_frags_skb(napi);
 
         if (!skb)
                 return NET_RX_DROP;
diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 6b0921364014..04dc8c8a6854 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -666,13 +666,7 @@ static int vlan_ethtool_get_settings(struct net_device *dev,
                                      struct ethtool_cmd *cmd)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (!real_dev->ethtool_ops ||
-            !real_dev->ethtool_ops->get_settings)
-                return -EOPNOTSUPP;
-
-        return real_dev->ethtool_ops->get_settings(real_dev, cmd);
+        return dev_ethtool_get_settings(vlan->real_dev, cmd);
 }
 
 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
@@ -686,24 +680,13 @@ static void vlan_ethtool_get_drvinfo(struct net_device *dev,
 static u32 vlan_ethtool_get_rx_csum(struct net_device *dev)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (real_dev->ethtool_ops == NULL ||
-            real_dev->ethtool_ops->get_rx_csum == NULL)
-                return 0;
-        return real_dev->ethtool_ops->get_rx_csum(real_dev);
+        return dev_ethtool_get_rx_csum(vlan->real_dev);
 }
 
 static u32 vlan_ethtool_get_flags(struct net_device *dev)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (!(real_dev->features & NETIF_F_HW_VLAN_RX) ||
-            real_dev->ethtool_ops == NULL ||
-            real_dev->ethtool_ops->get_flags == NULL)
-                return 0;
-        return real_dev->ethtool_ops->get_flags(real_dev);
+        return dev_ethtool_get_flags(vlan->real_dev);
 }
 
 static const struct ethtool_ops vlan_ethtool_ops = {
diff --git a/net/core/datagram.c b/net/core/datagram.c
index d0de644b378d..914d5fa773b4 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -339,17 +339,111 @@ fault:
 }
 
 /**
+ *      skb_copy_datagram_const_iovec - Copy a datagram to an iovec.
+ *      @skb: buffer to copy
+ *      @offset: offset in the buffer to start copying from
+ *      @to: io vector to copy to
+ *      @to_offset: offset in the io vector to start copying to
+ *      @len: amount of data to copy from buffer to iovec
+ *
+ *      Returns 0 or -EFAULT.
+ *      Note: the iovec is not modified during the copy.
+ */
+int skb_copy_datagram_const_iovec(const struct sk_buff *skb, int offset,
+                                  const struct iovec *to, int to_offset,
+                                  int len)
+{
+        int start = skb_headlen(skb);
+        int i, copy = start - offset;
+
+        /* Copy header. */
+        if (copy > 0) {
+                if (copy > len)
+                        copy = len;
+                if (memcpy_toiovecend(to, skb->data + offset, to_offset, copy))
+                        goto fault;
+                if ((len -= copy) == 0)
+                        return 0;
+                offset += copy;
+                to_offset += copy;
+        }
+
+        /* Copy paged appendix. Hmm... why does this look so complicated? */
+        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + skb_shinfo(skb)->frags[i].size;
+                if ((copy = end - offset) > 0) {
+                        int err;
+                        u8  *vaddr;
+                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                        struct page *page = frag->page;
+
+                        if (copy > len)
+                                copy = len;
+                        vaddr = kmap(page);
+                        err = memcpy_toiovecend(to, vaddr + frag->page_offset +
+                                                offset - start, to_offset, copy);
+                        kunmap(page);
+                        if (err)
+                                goto fault;
+                        if (!(len -= copy))
+                                return 0;
+                        offset += copy;
+                        to_offset += copy;
+                }
+                start = end;
+        }
+
+        if (skb_shinfo(skb)->frag_list) {
+                struct sk_buff *list = skb_shinfo(skb)->frag_list;
+
+                for (; list; list = list->next) {
+                        int end;
+
+                        WARN_ON(start > offset + len);
+
+                        end = start + list->len;
+                        if ((copy = end - offset) > 0) {
+                                if (copy > len)
+                                        copy = len;
+                                if (skb_copy_datagram_const_iovec(list,
+                                                            offset - start,
+                                                            to, to_offset,
+                                                            copy))
+                                        goto fault;
+                                if ((len -= copy) == 0)
+                                        return 0;
+                                offset += copy;
+                                to_offset += copy;
+                        }
+                        start = end;
+                }
+        }
+        if (!len)
+                return 0;
+
+fault:
+        return -EFAULT;
+}
+EXPORT_SYMBOL(skb_copy_datagram_const_iovec);
+
+/**
  *      skb_copy_datagram_from_iovec - Copy a datagram from an iovec.
  *      @skb: buffer to copy
  *      @offset: offset in the buffer to start copying to
  *      @from: io vector to copy to
+ *      @from_offset: offset in the io vector to start copying from
  *      @len: amount of data to copy to buffer from iovec
  *
  *      Returns 0 or -EFAULT.
- *      Note: the iovec is modified during the copy.
+ *      Note: the iovec is not modified during the copy.
  */
 int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
-                                 struct iovec *from, int len)
+                                 const struct iovec *from, int from_offset,
+                                 int len)
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
@@ -358,11 +452,12 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
         if (copy > 0) {
                 if (copy > len)
                         copy = len;
-                if (memcpy_fromiovec(skb->data + offset, from, copy))
+                if (memcpy_fromiovecend(skb->data + offset, from, 0, copy))
                         goto fault;
                 if ((len -= copy) == 0)
                         return 0;
                 offset += copy;
+                from_offset += copy;
         }
 
         /* Copy paged appendix. Hmm... why does this look so complicated? */
@@ -381,8 +476,9 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
                         if (copy > len)
                                 copy = len;
                         vaddr = kmap(page);
-                        err = memcpy_fromiovec(vaddr + frag->page_offset +
-                                               offset - start, from, copy);
+                        err = memcpy_fromiovecend(vaddr + frag->page_offset +
+                                                  offset - start,
+                                                  from, from_offset, copy);
                         kunmap(page);
                         if (err)
                                 goto fault;
@@ -390,6 +486,7 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
                         if (!(len -= copy))
                                 return 0;
                         offset += copy;
+                        from_offset += copy;
                 }
                 start = end;
         }
@@ -408,11 +505,14 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
                                         copy = len;
                                 if (skb_copy_datagram_from_iovec(list,
                                                                  offset - start,
-                                                                 from, copy))
+                                                                 from,
+                                                                 from_offset,
+                                                                 copy))
                                         goto fault;
                                 if ((len -= copy) == 0)
                                         return 0;
                                 offset += copy;
+                                from_offset += copy;
                         }
                         start = end;
                 }
diff --git a/net/core/dev.c b/net/core/dev.c
index 308a7d0c277f..e48c08af76ad 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2525,16 +2525,10 @@ void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(napi_reuse_skb);
 
-struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
-                                  struct napi_gro_fraginfo *info)
+struct sk_buff *napi_get_frags(struct napi_struct *napi)
 {
         struct net_device *dev = napi->dev;
         struct sk_buff *skb = napi->skb;
-        struct ethhdr *eth;
-        skb_frag_t *frag;
-        int i;
-
-        napi->skb = NULL;
 
         if (!skb) {
                 skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
@@ -2542,47 +2536,14 @@ struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
                         goto out;
 
                 skb_reserve(skb, NET_IP_ALIGN);
-        }
-
-        BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
-        frag = info->frags;
 
-        for (i = 0; i < info->nr_frags; i++) {
-                skb_fill_page_desc(skb, i, frag->page, frag->page_offset,
-                                   frag->size);
-                frag++;
+                napi->skb = skb;
         }
-        skb_shinfo(skb)->nr_frags = info->nr_frags;
-
-        skb->data_len = info->len;
-        skb->len += info->len;
-        skb->truesize += info->len;
-
-        skb_reset_mac_header(skb);
-        skb_gro_reset_offset(skb);
-
-        eth = skb_gro_header(skb, sizeof(*eth));
-        if (!eth) {
-                napi_reuse_skb(napi, skb);
-                skb = NULL;
-                goto out;
-        }
-
-        skb_gro_pull(skb, sizeof(*eth));
-
-        /*
-         * This works because the only protocols we care about don't require
-         * special handling.  We'll fix it up properly at the end.
-         */
-        skb->protocol = eth->h_proto;
-
-        skb->ip_summed = info->ip_summed;
-        skb->csum = info->csum;
 
 out:
         return skb;
 }
-EXPORT_SYMBOL(napi_fraginfo_skb);
+EXPORT_SYMBOL(napi_get_frags);
 
 int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
 {
@@ -2612,9 +2573,39 @@ int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
 }
 EXPORT_SYMBOL(napi_frags_finish);
 
-int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
+struct sk_buff *napi_frags_skb(struct napi_struct *napi)
+{
+        struct sk_buff *skb = napi->skb;
+        struct ethhdr *eth;
+
+        napi->skb = NULL;
+
+        skb_reset_mac_header(skb);
+        skb_gro_reset_offset(skb);
+
+        eth = skb_gro_header(skb, sizeof(*eth));
+        if (!eth) {
+                napi_reuse_skb(napi, skb);
+                skb = NULL;
+                goto out;
+        }
+
+        skb_gro_pull(skb, sizeof(*eth));
+
+        /*
+         * This works because the only protocols we care about don't require
+         * special handling.  We'll fix it up properly at the end.
+         */
+        skb->protocol = eth->h_proto;
+
+out:
+        return skb;
+}
+EXPORT_SYMBOL(napi_frags_skb);
+
+int napi_gro_frags(struct napi_struct *napi)
 {
-        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
+        struct sk_buff *skb = napi_frags_skb(napi);
 
         if (!skb)
                 return NET_RX_DROP;
@@ -2718,7 +2709,7 @@ void netif_napi_del(struct napi_struct *napi)
         struct sk_buff *skb, *next;
 
         list_del_init(&napi->dev_list);
-        kfree_skb(napi->skb);
+        napi_free_frags(napi);
 
         for (skb = napi->gro_list; skb; skb = next) {
                 next = skb->next;
diff --git a/net/core/iovec.c b/net/core/iovec.c
index 4c9c0121c9da..40a76ce19d9f 100644
--- a/net/core/iovec.c
+++ b/net/core/iovec.c
@@ -98,6 +98,31 @@ int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
 }
 
 /*
+ *      Copy kernel to iovec. Returns -EFAULT on error.
+ */
+
+int memcpy_toiovecend(const struct iovec *iov, unsigned char *kdata,
+                      int offset, int len)
+{
+        int copy;
+        for (; len > 0; ++iov) {
+                /* Skip over the finished iovecs */
+                if (unlikely(offset >= iov->iov_len)) {
+                        offset -= iov->iov_len;
+                        continue;
+                }
+                copy = min_t(unsigned int, iov->iov_len - offset, len);
+                offset = 0;
+                if (copy_to_user(iov->iov_base, kdata, copy))
+                        return -EFAULT;
+                kdata += copy;
+                len -= copy;
+        }
+
+        return 0;
+}
+
+/*
  *      Copy iovec to kernel. Returns -EFAULT on error.
  *
  *      Note: this modifies the original iovec.
@@ -122,10 +147,11 @@ int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len)
 }
 
 /*
- *      For use with ip_build_xmit
+ *      Copy iovec from kernel. Returns -EFAULT on error.
  */
-int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov, int offset,
-                        int len)
+
+int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
+                        int offset, int len)
 {
         /* Skip over the finished iovecs */
         while (offset >= iov->iov_len) {
@@ -236,3 +262,4 @@ EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
 EXPORT_SYMBOL(memcpy_fromiovec);
 EXPORT_SYMBOL(memcpy_fromiovecend);
 EXPORT_SYMBOL(memcpy_toiovec);
+EXPORT_SYMBOL(memcpy_toiovecend);
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 7f03373b8c07..170689681aa2 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1003,8 +1003,6 @@ void inet_register_protosw(struct inet_protosw *p)
 out:
         spin_unlock_bh(&inetsw_lock);
 
-        synchronize_net();
-
         return;
 
 out_permanent:
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index b35a950d2e06..cd2b97f1b6e1 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -161,13 +161,12 @@ static __u16 const msstab[] = {
  */
 __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mssp)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
         const struct iphdr *iph = ip_hdr(skb);
         const struct tcphdr *th = tcp_hdr(skb);
         int mssind;
         const __u16 mss = *mssp;
 
-        tp->last_synq_overflow = jiffies;
+        tcp_synq_overflow(sk);
 
         /* XXX sort msstab[] by probability?  Binary search? */
         for (mssind = 0; mss > msstab[mssind + 1]; mssind++)
@@ -268,7 +267,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         if (!sysctl_tcp_syncookies || !th->ack)
                 goto out;
 
-        if (time_after(jiffies, tp->last_synq_overflow + TCP_TIMEOUT_INIT) ||
+        if (tcp_synq_no_recent_overflow(sk) ||
             (mss = cookie_check(skb, cookie)) == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c
index 711175e0571f..8c2513982b61 100644
--- a/net/ipv6/syncookies.c
+++ b/net/ipv6/syncookies.c
@@ -131,7 +131,7 @@ __u32 cookie_v6_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mssp)
         int mssind;
         const __u16 mss = *mssp;
 
-        tcp_sk(sk)->last_synq_overflow = jiffies;
+        tcp_synq_overflow(sk);
 
         for (mssind = 0; mss > msstab[mssind + 1]; mssind++)
                 ;
@@ -175,7 +175,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
         if (!sysctl_tcp_syncookies || !th->ack)
                 goto out;
 
-        if (time_after(jiffies, tp->last_synq_overflow + TCP_TIMEOUT_INIT) ||
+        if (tcp_synq_no_recent_overflow(sk) ||
                 (mss = cookie_check(skb, cookie)) == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index b51c9187c347..0fc00087ea8b 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -29,10 +29,7 @@
 #include <net/iucv/iucv.h>
 #include <net/iucv/af_iucv.h>
 
-#define CONFIG_IUCV_SOCK_DEBUG 1
-
-#define IPRMDATA 0x80
-#define VERSION "1.0"
+#define VERSION "1.1"
 
 static char iucv_userid[80];
 
@@ -44,6 +41,19 @@ static struct proto iucv_proto = {
         .obj_size       = sizeof(struct iucv_sock),
 };
 
+/* special AF_IUCV IPRM messages */
+static const u8 iprm_shutdown[8] =
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
+
+#define TRGCLS_SIZE     (sizeof(((struct iucv_message *)0)->class))
+
+/* macros to set/get socket control buffer at correct offset */
+#define CB_TAG(skb)     ((skb)->cb)             /* iucv message tag */
+#define CB_TAG_LEN      (sizeof(((struct iucv_message *) 0)->tag))
+#define CB_TRGCLS(skb)  ((skb)->cb + CB_TAG_LEN) /* iucv msg target class */
+#define CB_TRGCLS_LEN   (TRGCLS_SIZE)
+
+
 static void iucv_sock_kill(struct sock *sk);
 static void iucv_sock_close(struct sock *sk);
 
@@ -54,6 +64,7 @@ static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
 static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8],
                                  u8 ipuser[16]);
 static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
+static void iucv_callback_shutdown(struct iucv_path *, u8 ipuser[16]);
 
 static struct iucv_sock_list iucv_sk_list = {
         .lock = __RW_LOCK_UNLOCKED(iucv_sk_list.lock),
@@ -65,7 +76,8 @@ static struct iucv_handler af_iucv_handler = {
         .path_complete    = iucv_callback_connack,
         .path_severed     = iucv_callback_connrej,
         .message_pending  = iucv_callback_rx,
-        .message_complete = iucv_callback_txdone
+        .message_complete = iucv_callback_txdone,
+        .path_quiesced    = iucv_callback_shutdown,
 };
 
 static inline void high_nmcpy(unsigned char *dst, char *src)
@@ -78,6 +90,37 @@ static inline void low_nmcpy(unsigned char *dst, char *src)
        memcpy(&dst[8], src, 8);
 }
 
+/**
+ * iucv_msg_length() - Returns the length of an iucv message.
+ * @msg:        Pointer to struct iucv_message, MUST NOT be NULL
+ *
+ * The function returns the length of the specified iucv message @msg of data
+ * stored in a buffer and of data stored in the parameter list (PRMDATA).
+ *
+ * For IUCV_IPRMDATA, AF_IUCV uses the following convention to transport socket
+ * data:
+ *      PRMDATA[0..6]   socket data (max 7 bytes);
+ *      PRMDATA[7]      socket data length value (len is 0xff - PRMDATA[7])
+ *
+ * The socket data length is computed by substracting the socket data length
+ * value from 0xFF.
+ * If the socket data len is greater 7, then PRMDATA can be used for special
+ * notifications (see iucv_sock_shutdown); and further,
+ * if the socket data len is > 7, the function returns 8.
+ *
+ * Use this function to allocate socket buffers to store iucv message data.
+ */
+static inline size_t iucv_msg_length(struct iucv_message *msg)
+{
+        size_t datalen;
+
+        if (msg->flags & IUCV_IPRMDATA) {
+                datalen = 0xff - msg->rmmsg[7];
+                return (datalen < 8) ? datalen : 8;
+        }
+        return msg->length;
+}
+
 /* Timers */
 static void iucv_sock_timeout(unsigned long arg)
 {
@@ -225,6 +268,8 @@ static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio)
         spin_lock_init(&iucv_sk(sk)->message_q.lock);
         skb_queue_head_init(&iucv_sk(sk)->backlog_skb_q);
         iucv_sk(sk)->send_tag = 0;
+        iucv_sk(sk)->flags = 0;
+        iucv_sk(sk)->msglimit = IUCV_QUEUELEN_DEFAULT;
         iucv_sk(sk)->path = NULL;
         memset(&iucv_sk(sk)->src_user_id , 0, 32);
 
@@ -248,11 +293,22 @@ static int iucv_sock_create(struct net *net, struct socket *sock, int protocol)
 {
         struct sock *sk;
 
-        if (sock->type != SOCK_STREAM)
-                return -ESOCKTNOSUPPORT;
+        if (protocol && protocol != PF_IUCV)
+                return -EPROTONOSUPPORT;
 
         sock->state = SS_UNCONNECTED;
-        sock->ops = &iucv_sock_ops;
+
+        switch (sock->type) {
+        case SOCK_STREAM:
+                sock->ops = &iucv_sock_ops;
+                break;
+        case SOCK_SEQPACKET:
+                /* currently, proto ops can handle both sk types */
+                sock->ops = &iucv_sock_ops;
+                break;
+        default:
+                return -ESOCKTNOSUPPORT;
+        }
 
         sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
         if (!sk)
@@ -463,11 +519,9 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
         if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
                 return -EBADFD;
 
-        if (sk->sk_type != SOCK_STREAM)
+        if (sk->sk_type != SOCK_STREAM && sk->sk_type != SOCK_SEQPACKET)
                 return -EINVAL;
 
-        iucv = iucv_sk(sk);
-
         if (sk->sk_state == IUCV_OPEN) {
                 err = iucv_sock_autobind(sk);
                 if (unlikely(err))
@@ -486,8 +540,8 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
 
         iucv = iucv_sk(sk);
         /* Create path. */
-        iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT,
-                                     IPRMDATA, GFP_KERNEL);
+        iucv->path = iucv_path_alloc(iucv->msglimit,
+                                     IUCV_IPRMDATA, GFP_KERNEL);
         if (!iucv->path) {
                 err = -ENOMEM;
                 goto done;
@@ -521,8 +575,7 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
         }
 
         if (sk->sk_state == IUCV_DISCONN) {
-                release_sock(sk);
-                return -ECONNREFUSED;
+                err = -ECONNREFUSED;
         }
 
         if (err) {
@@ -545,7 +598,10 @@ static int iucv_sock_listen(struct socket *sock, int backlog)
         lock_sock(sk);
 
         err = -EINVAL;
-        if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM)
+        if (sk->sk_state != IUCV_BOUND)
+                goto done;
+
+        if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
                 goto done;
 
         sk->sk_max_ack_backlog = backlog;
@@ -636,6 +692,30 @@ static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
         return 0;
 }
 
+/**
+ * iucv_send_iprm() - Send socket data in parameter list of an iucv message.
+ * @path:       IUCV path
+ * @msg:        Pointer to a struct iucv_message
+ * @skb:        The socket data to send, skb->len MUST BE <= 7
+ *
+ * Send the socket data in the parameter list in the iucv message
+ * (IUCV_IPRMDATA). The socket data is stored at index 0 to 6 in the parameter
+ * list and the socket data len at index 7 (last byte).
+ * See also iucv_msg_length().
+ *
+ * Returns the error code from the iucv_message_send() call.
+ */
+static int iucv_send_iprm(struct iucv_path *path, struct iucv_message *msg,
+                          struct sk_buff *skb)
+{
+        u8 prmdata[8];
+
+        memcpy(prmdata, (void *) skb->data, skb->len);
+        prmdata[7] = 0xff - (u8) skb->len;
+        return iucv_message_send(path, msg, IUCV_IPRMDATA, 0,
+                                 (void *) prmdata, 8);
+}
+
 static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
                              struct msghdr *msg, size_t len)
 {
@@ -643,6 +723,8 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         struct iucv_sock *iucv = iucv_sk(sk);
         struct sk_buff *skb;
         struct iucv_message txmsg;
+        struct cmsghdr *cmsg;
+        int cmsg_done;
         char user_id[9];
         char appl_id[9];
         int err;
@@ -654,6 +736,10 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         if (msg->msg_flags & MSG_OOB)
                 return -EOPNOTSUPP;
 
+        /* SOCK_SEQPACKET: we do not support segmented records */
+        if (sk->sk_type == SOCK_SEQPACKET && !(msg->msg_flags & MSG_EOR))
+                return -EOPNOTSUPP;
+
         lock_sock(sk);
 
         if (sk->sk_shutdown & SEND_SHUTDOWN) {
@@ -662,6 +748,52 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         }
 
         if (sk->sk_state == IUCV_CONNECTED) {
+                /* initialize defaults */
+                cmsg_done   = 0;        /* check for duplicate headers */
+                txmsg.class = 0;
+
+                /* iterate over control messages */
+                for (cmsg = CMSG_FIRSTHDR(msg); cmsg;
+                     cmsg = CMSG_NXTHDR(msg, cmsg)) {
+
+                        if (!CMSG_OK(msg, cmsg)) {
+                                err = -EINVAL;
+                                goto out;
+                        }
+
+                        if (cmsg->cmsg_level != SOL_IUCV)
+                                continue;
+
+                        if (cmsg->cmsg_type & cmsg_done) {
+                                err = -EINVAL;
+                                goto out;
+                        }
+                        cmsg_done |= cmsg->cmsg_type;
+
+                        switch (cmsg->cmsg_type) {
+                        case SCM_IUCV_TRGCLS:
+                                if (cmsg->cmsg_len != CMSG_LEN(TRGCLS_SIZE)) {
+                                        err = -EINVAL;
+                                        goto out;
+                                }
+
+                                /* set iucv message target class */
+                                memcpy(&txmsg.class,
+                                        (void *) CMSG_DATA(cmsg), TRGCLS_SIZE);
+
+                                break;
+
+                        default:
+                                err = -EINVAL;
+                                goto out;
+                                break;
+                        }
+                }
+
+                /* allocate one skb for each iucv message:
+                 * this is fine for SOCK_SEQPACKET (unless we want to support
+                 * segmented records using the MSG_EOR flag), but
+                 * for SOCK_STREAM we might want to improve it in future */
                 if (!(skb = sock_alloc_send_skb(sk, len,
                                                 msg->msg_flags & MSG_DONTWAIT,
                                                 &err)))
@@ -672,13 +804,33 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
                         goto fail;
                 }
 
-                txmsg.class = 0;
-                memcpy(&txmsg.class, skb->data, skb->len >= 4 ? 4 : skb->len);
+                /* increment and save iucv message tag for msg_completion cbk */
                 txmsg.tag = iucv->send_tag++;
-                memcpy(skb->cb, &txmsg.tag, 4);
+                memcpy(CB_TAG(skb), &txmsg.tag, CB_TAG_LEN);
                 skb_queue_tail(&iucv->send_skb_q, skb);
-                err = iucv_message_send(iucv->path, &txmsg, 0, 0,
-                                        (void *) skb->data, skb->len);
+
+                if (((iucv->path->flags & IUCV_IPRMDATA) & iucv->flags)
+                    && skb->len <= 7) {
+                        err = iucv_send_iprm(iucv->path, &txmsg, skb);
+
+                        /* on success: there is no message_complete callback
+                         * for an IPRMDATA msg; remove skb from send queue */
+                        if (err == 0) {
+                                skb_unlink(skb, &iucv->send_skb_q);
+                                kfree_skb(skb);
+                        }
+
+                        /* this error should never happen since the
+                         * IUCV_IPRMDATA path flag is set... sever path */
+                        if (err == 0x15) {
+                                iucv_path_sever(iucv->path, NULL);
+                                skb_unlink(skb, &iucv->send_skb_q);
+                                err = -EPIPE;
+                                goto fail;
+                        }
+                } else
+                        err = iucv_message_send(iucv->path, &txmsg, 0, 0,
+                                                (void *) skb->data, skb->len);
                 if (err) {
                         if (err == 3) {
                                 user_id[8] = 0;
@@ -725,6 +877,10 @@ static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len)
                 if (!nskb)
                         return -ENOMEM;
 
+                /* copy target class to control buffer of new skb */
+                memcpy(CB_TRGCLS(nskb), CB_TRGCLS(skb), CB_TRGCLS_LEN);
+
+                /* copy data fragment */
                 memcpy(nskb->data, skb->data + copied, size);
                 copied += size;
                 dataleft -= size;
@@ -744,19 +900,33 @@ static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
                                  struct iucv_message *msg)
 {
         int rc;
+        unsigned int len;
+
+        len = iucv_msg_length(msg);
+
+        /* store msg target class in the second 4 bytes of skb ctrl buffer */
+        /* Note: the first 4 bytes are reserved for msg tag */
+        memcpy(CB_TRGCLS(skb), &msg->class, CB_TRGCLS_LEN);
 
-        if (msg->flags & IPRMDATA) {
-                skb->data = NULL;
-                skb->len = 0;
+        /* check for special IPRM messages (e.g. iucv_sock_shutdown) */
+        if ((msg->flags & IUCV_IPRMDATA) && len > 7) {
+                if (memcmp(msg->rmmsg, iprm_shutdown, 8) == 0) {
+                        skb->data = NULL;
+                        skb->len = 0;
+                }
         } else {
-                rc = iucv_message_receive(path, msg, 0, skb->data,
-                                          msg->length, NULL);
+                rc = iucv_message_receive(path, msg, msg->flags & IUCV_IPRMDATA,
+                                          skb->data, len, NULL);
                 if (rc) {
                         kfree_skb(skb);
                         return;
                 }
-                if (skb->truesize >= sk->sk_rcvbuf / 4) {
-                        rc = iucv_fragment_skb(sk, skb, msg->length);
+                /* we need to fragment iucv messages for SOCK_STREAM only;
+                 * for SOCK_SEQPACKET, it is only relevant if we support
+                 * record segmentation using MSG_EOR (see also recvmsg()) */
+                if (sk->sk_type == SOCK_STREAM &&
+                    skb->truesize >= sk->sk_rcvbuf / 4) {
+                        rc = iucv_fragment_skb(sk, skb, len);
                         kfree_skb(skb);
                         skb = NULL;
                         if (rc) {
@@ -767,7 +937,7 @@ static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
                 } else {
                         skb_reset_transport_header(skb);
                         skb_reset_network_header(skb);
-                        skb->len = msg->length;
+                        skb->len = len;
                 }
         }
 
@@ -782,7 +952,7 @@ static void iucv_process_message_q(struct sock *sk)
         struct sock_msg_q *p, *n;
 
         list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
-                skb = alloc_skb(p->msg.length, GFP_ATOMIC | GFP_DMA);
+                skb = alloc_skb(iucv_msg_length(&p->msg), GFP_ATOMIC | GFP_DMA);
                 if (!skb)
                         break;
                 iucv_process_message(sk, skb, p->path, &p->msg);
@@ -799,7 +969,7 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
         int noblock = flags & MSG_DONTWAIT;
         struct sock *sk = sock->sk;
         struct iucv_sock *iucv = iucv_sk(sk);
-        int target, copied = 0;
+        unsigned int copied, rlen;
         struct sk_buff *skb, *rskb, *cskb;
         int err = 0;
 
@@ -823,25 +993,45 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
                 return err;
         }
 
-        copied = min_t(unsigned int, skb->len, len);
+        rlen   = skb->len;              /* real length of skb */
+        copied = min_t(unsigned int, rlen, len);
 
         cskb = skb;
         if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
-                skb_queue_head(&sk->sk_receive_queue, skb);
-                if (copied == 0)
-                        return -EFAULT;
-                goto done;
+                if (!(flags & MSG_PEEK))
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                return -EFAULT;
         }
 
-        len -= copied;
+        /* SOCK_SEQPACKET: set MSG_TRUNC if recv buf size is too small */
+        if (sk->sk_type == SOCK_SEQPACKET) {
+                if (copied < rlen)
+                        msg->msg_flags |= MSG_TRUNC;
+                /* each iucv message contains a complete record */
+                msg->msg_flags |= MSG_EOR;
+        }
+
+        /* create control message to store iucv msg target class:
+         * get the trgcls from the control buffer of the skb due to
+         * fragmentation of original iucv message. */
+        err = put_cmsg(msg, SOL_IUCV, SCM_IUCV_TRGCLS,
+                        CB_TRGCLS_LEN, CB_TRGCLS(skb));
+        if (err) {
+                if (!(flags & MSG_PEEK))
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                return err;
+        }
 
         /* Mark read part of skb as used */
         if (!(flags & MSG_PEEK)) {
-                skb_pull(skb, copied);
 
-                if (skb->len) {
-                        skb_queue_head(&sk->sk_receive_queue, skb);
-                        goto done;
+                /* SOCK_STREAM: re-queue skb if it contains unreceived data */
+                if (sk->sk_type == SOCK_STREAM) {
+                        skb_pull(skb, copied);
+                        if (skb->len) {
+                                skb_queue_head(&sk->sk_receive_queue, skb);
+                                goto done;
+                        }
                 }
 
                 kfree_skb(skb);
@@ -866,7 +1056,11 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
         }
 
 done:
-        return err ? : copied;
+        /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
+        if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
+                copied = rlen;
+
+        return copied;
 }
 
 static inline unsigned int iucv_accept_poll(struct sock *parent)
@@ -928,7 +1122,6 @@ static int iucv_sock_shutdown(struct socket *sock, int how)
         struct iucv_sock *iucv = iucv_sk(sk);
         struct iucv_message txmsg;
         int err = 0;
-        u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 
         how++;
 
@@ -953,7 +1146,7 @@ static int iucv_sock_shutdown(struct socket *sock, int how)
                 txmsg.class = 0;
                 txmsg.tag = 0;
                 err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0,
-                                        (void *) prmmsg, 8);
+                                        (void *) iprm_shutdown, 8);
                 if (err) {
                         switch (err) {
                         case 1:
@@ -1007,6 +1200,98 @@ static int iucv_sock_release(struct socket *sock)
         return err;
 }
 
+/* getsockopt and setsockopt */
+static int iucv_sock_setsockopt(struct socket *sock, int level, int optname,
+                                char __user *optval, int optlen)
+{
+        struct sock *sk = sock->sk;
+        struct iucv_sock *iucv = iucv_sk(sk);
+        int val;
+        int rc;
+
+        if (level != SOL_IUCV)
+                return -ENOPROTOOPT;
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+
+        if (get_user(val, (int __user *) optval))
+                return -EFAULT;
+
+        rc = 0;
+
+        lock_sock(sk);
+        switch (optname) {
+        case SO_IPRMDATA_MSG:
+                if (val)
+                        iucv->flags |= IUCV_IPRMDATA;
+                else
+                        iucv->flags &= ~IUCV_IPRMDATA;
+                break;
+        case SO_MSGLIMIT:
+                switch (sk->sk_state) {
+                case IUCV_OPEN:
+                case IUCV_BOUND:
+                        if (val < 1 || val > (u16)(~0))
+                                rc = -EINVAL;
+                        else
+                                iucv->msglimit = val;
+                        break;
+                default:
+                        rc = -EINVAL;
+                        break;
+                }
+                break;
+        default:
+                rc = -ENOPROTOOPT;
+                break;
+        }
+        release_sock(sk);
+
+        return rc;
+}
+
+static int iucv_sock_getsockopt(struct socket *sock, int level, int optname,
+                                char __user *optval, int __user *optlen)
+{
+        struct sock *sk = sock->sk;
+        struct iucv_sock *iucv = iucv_sk(sk);
+        int val, len;
+
+        if (level != SOL_IUCV)
+                return -ENOPROTOOPT;
+
+        if (get_user(len, optlen))
+                return -EFAULT;
+
+        if (len < 0)
+                return -EINVAL;
+
+        len = min_t(unsigned int, len, sizeof(int));
+
+        switch (optname) {
+        case SO_IPRMDATA_MSG:
+                val = (iucv->flags & IUCV_IPRMDATA) ? 1 : 0;
+                break;
+        case SO_MSGLIMIT:
+                lock_sock(sk);
+                val = (iucv->path != NULL) ? iucv->path->msglim /* connected */
+                                           : iucv->msglimit;    /* default */
+                release_sock(sk);
+                break;
+        default:
+                return -ENOPROTOOPT;
+        }
+
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+
 /* Callback wrappers - called from iucv base support */
 static int iucv_callback_connreq(struct iucv_path *path,
                                  u8 ipvmid[8], u8 ipuser[16])
@@ -1060,7 +1345,7 @@ static int iucv_callback_connreq(struct iucv_path *path,
         }
 
         /* Create the new socket */
-        nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC);
+        nsk = iucv_sock_alloc(NULL, sk->sk_type, GFP_ATOMIC);
         if (!nsk) {
                 err = iucv_path_sever(path, user_data);
                 iucv_path_free(path);
@@ -1083,7 +1368,9 @@ static int iucv_callback_connreq(struct iucv_path *path,
         memcpy(nuser_data + 8, niucv->src_name, 8);
         ASCEBC(nuser_data + 8, 8);
 
-        path->msglim = IUCV_QUEUELEN_DEFAULT;
+        /* set message limit for path based on msglimit of accepting socket */
+        niucv->msglimit = iucv->msglimit;
+        path->msglim = iucv->msglimit;
         err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk);
         if (err) {
                 err = iucv_path_sever(path, user_data);
@@ -1131,11 +1418,11 @@ static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
                 goto save_message;
 
         len = atomic_read(&sk->sk_rmem_alloc);
-        len += msg->length + sizeof(struct sk_buff);
+        len += iucv_msg_length(msg) + sizeof(struct sk_buff);
         if (len > sk->sk_rcvbuf)
                 goto save_message;
 
-        skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA);
+        skb = alloc_skb(iucv_msg_length(msg), GFP_ATOMIC | GFP_DMA);
         if (!skb)
                 goto save_message;
 
@@ -1170,7 +1457,7 @@ static void iucv_callback_txdone(struct iucv_path *path,
                 spin_lock_irqsave(&list->lock, flags);
 
                 while (list_skb != (struct sk_buff *)list) {
-                        if (!memcmp(&msg->tag, list_skb->cb, 4)) {
+                        if (!memcmp(&msg->tag, CB_TAG(list_skb), CB_TAG_LEN)) {
                                 this = list_skb;
                                 break;
                         }
@@ -1206,6 +1493,21 @@ static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
         sk->sk_state_change(sk);
 }
 
+/* called if the other communication side shuts down its RECV direction;
+ * in turn, the callback sets SEND_SHUTDOWN to disable sending of data.
+ */
+static void iucv_callback_shutdown(struct iucv_path *path, u8 ipuser[16])
+{
+        struct sock *sk = path->private;
+
+        bh_lock_sock(sk);
+        if (sk->sk_state != IUCV_CLOSED) {
+                sk->sk_shutdown |= SEND_SHUTDOWN;
+                sk->sk_state_change(sk);
+        }
+        bh_unlock_sock(sk);
+}
+
 static struct proto_ops iucv_sock_ops = {
         .family         = PF_IUCV,
         .owner          = THIS_MODULE,
@@ -1222,8 +1524,8 @@ static struct proto_ops iucv_sock_ops = {
         .mmap           = sock_no_mmap,
         .socketpair     = sock_no_socketpair,
         .shutdown       = iucv_sock_shutdown,
-        .setsockopt     = sock_no_setsockopt,
-        .getsockopt     = sock_no_getsockopt
+        .setsockopt     = iucv_sock_setsockopt,
+        .getsockopt     = iucv_sock_getsockopt,
 };
 
 static struct net_proto_family iucv_sock_family_ops = {
diff --git a/net/iucv/iucv.c b/net/iucv/iucv.c
index a35240f61ec3..61e8038a55ee 100644
--- a/net/iucv/iucv.c
+++ b/net/iucv/iucv.c
@@ -280,6 +280,7 @@ union iucv_param {
  * Anchor for per-cpu IUCV command parameter block.
  */
 static union iucv_param *iucv_param[NR_CPUS];
+static union iucv_param *iucv_param_irq[NR_CPUS];
 
 /**
  * iucv_call_b2f0
@@ -358,7 +359,7 @@ static void iucv_allow_cpu(void *data)
          *      0x10 - Flag to allow priority message completion interrupts
          *      0x08 - Flag to allow IUCV control interrupts
          */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         parm->set_mask.ipmask = 0xf8;
         iucv_call_b2f0(IUCV_SETMASK, parm);
@@ -379,7 +380,7 @@ static void iucv_block_cpu(void *data)
         union iucv_param *parm;
 
         /* Disable all iucv interrupts. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         iucv_call_b2f0(IUCV_SETMASK, parm);
 
@@ -403,7 +404,7 @@ static void iucv_declare_cpu(void *data)
                 return;
 
         /* Declare interrupt buffer. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
         rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
@@ -460,7 +461,7 @@ static void iucv_retrieve_cpu(void *data)
         iucv_block_cpu(NULL);
 
         /* Retrieve interrupt buffer. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
 
         /* Clear indication that an iucv buffer exists for this cpu. */
@@ -574,11 +575,22 @@ static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
                         iucv_irq_data[cpu] = NULL;
                         return NOTIFY_BAD;
                 }
+                iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                        GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param_irq[cpu]) {
+                        kfree(iucv_param[cpu]);
+                        iucv_param[cpu] = NULL;
+                        kfree(iucv_irq_data[cpu]);
+                        iucv_irq_data[cpu] = NULL;
+                        return NOTIFY_BAD;
+                }
                 break;
         case CPU_UP_CANCELED:
         case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
@@ -625,7 +637,7 @@ static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
 {
         union iucv_param *parm;
 
-        parm = iucv_param[smp_processor_id()];
+        parm = iucv_param_irq[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
@@ -918,10 +930,8 @@ int iucv_path_sever(struct iucv_path *path, u8 userdata[16])
         if (iucv_active_cpu != smp_processor_id())
                 spin_lock_bh(&iucv_table_lock);
         rc = iucv_sever_pathid(path->pathid, userdata);
-        if (!rc) {
-                iucv_path_table[path->pathid] = NULL;
-                list_del_init(&path->list);
-        }
+        iucv_path_table[path->pathid] = NULL;
+        list_del_init(&path->list);
         if (iucv_active_cpu != smp_processor_id())
                 spin_unlock_bh(&iucv_table_lock);
         preempt_enable();
@@ -1378,6 +1388,8 @@ static void iucv_path_complete(struct iucv_irq_data *data)
         struct iucv_path_complete *ipc = (void *) data;
         struct iucv_path *path = iucv_path_table[ipc->ippathid];
 
+        if (path)
+                path->flags = ipc->ipflags1;
         if (path && path->handler && path->handler->path_complete)
                 path->handler->path_complete(path, ipc->ipuser);
 }
@@ -1413,7 +1425,7 @@ static void iucv_path_severed(struct iucv_irq_data *data)
         else {
                 iucv_sever_pathid(path->pathid, NULL);
                 iucv_path_table[path->pathid] = NULL;
-                list_del_init(&path->list);
+                list_del(&path->list);
                 iucv_path_free(path);
         }
 }
@@ -1717,6 +1729,13 @@ static int __init iucv_init(void)
                         rc = -ENOMEM;
                         goto out_free;
                 }
+                iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                  GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param_irq[cpu]) {
+                        rc = -ENOMEM;
+                        goto out_free;
+                }
+
         }
         rc = register_hotcpu_notifier(&iucv_cpu_notifier);
         if (rc)
@@ -1734,6 +1753,8 @@ out_cpu:
         unregister_hotcpu_notifier(&iucv_cpu_notifier);
 out_free:
         for_each_possible_cpu(cpu) {
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
@@ -1764,6 +1785,8 @@ static void __exit iucv_exit(void)
         spin_unlock_irq(&iucv_queue_lock);
         unregister_hotcpu_notifier(&iucv_cpu_notifier);
         for_each_possible_cpu(cpu) {
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index 20cf16fc572f..b11e7e527864 100644
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -35,7 +35,6 @@
 #include <linux/kernel.h>
 #include <linux/in.h>
 #include <linux/poll.h>
-#include <linux/version.h>
 #include <net/sock.h>
 
 #include "rds.h"
diff --git a/net/rds/connection.c b/net/rds/connection.c
index 273f064930a8..d14445c48304 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -148,14 +148,12 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
         if (conn)
                 goto out;
 
-        conn = kmem_cache_alloc(rds_conn_slab, gfp);
+        conn = kmem_cache_zalloc(rds_conn_slab, gfp);
         if (conn == NULL) {
                 conn = ERR_PTR(-ENOMEM);
                 goto out;
         }
 
-        memset(conn, 0, sizeof(*conn));
-
         INIT_HLIST_NODE(&conn->c_hash_node);
         conn->c_version = RDS_PROTOCOL_3_0;
         conn->c_laddr = laddr;
diff --git a/net/rds/ib.c b/net/rds/ib.c
index 4933b380985e..b9bcd32431e1 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -224,8 +224,8 @@ static int rds_ib_laddr_check(__be32 addr)
          * IB and iWARP capable NICs.
          */
         cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
-        if (!cm_id)
-                return -EADDRNOTAVAIL;
+        if (IS_ERR(cm_id))
+                return PTR_ERR(cm_id);
 
         memset(&sin, 0, sizeof(sin));
         sin.sin_family = AF_INET;
diff --git a/net/rds/ib.h b/net/rds/ib.h
index 069206cae733..455ae73047fe 100644
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -333,7 +333,7 @@ int rds_ib_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op);
 void rds_ib_send_add_credits(struct rds_connection *conn, unsigned int credits);
 void rds_ib_advertise_credits(struct rds_connection *conn, unsigned int posted);
 int rds_ib_send_grab_credits(struct rds_ib_connection *ic, u32 wanted,
-                             u32 *adv_credits, int need_posted);
+                             u32 *adv_credits, int need_posted, int max_posted);
 
 /* ib_stats.c */
 DECLARE_PER_CPU(struct rds_ib_statistics, rds_ib_stats);
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 36d931573ff4..5709bad28329 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -524,7 +524,7 @@ void rds_ib_attempt_ack(struct rds_ib_connection *ic)
         }
 
         /* Can we get a send credit? */
-        if (!rds_ib_send_grab_credits(ic, 1, &adv_credits, 0)) {
+        if (!rds_ib_send_grab_credits(ic, 1, &adv_credits, 0, RDS_MAX_ADV_CREDIT)) {
                 rds_ib_stats_inc(s_ib_tx_throttle);
                 clear_bit(IB_ACK_IN_FLIGHT, &ic->i_ack_flags);
                 return;
diff --git a/net/rds/ib_ring.c b/net/rds/ib_ring.c
index 99a6ccae964c..ff97e8eda858 100644
--- a/net/rds/ib_ring.c
+++ b/net/rds/ib_ring.c
@@ -137,7 +137,7 @@ int rds_ib_ring_empty(struct rds_ib_work_ring *ring)
 
 int rds_ib_ring_low(struct rds_ib_work_ring *ring)
 {
-        return __rds_ib_ring_used(ring) <= (ring->w_nr >> 2);
+        return __rds_ib_ring_used(ring) <= (ring->w_nr >> 1);
 }
 
 /*
diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c
index cb6c52cb1c4c..23bf830db2d5 100644
--- a/net/rds/ib_send.c
+++ b/net/rds/ib_send.c
@@ -311,7 +311,7 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context)
  * and using atomic_cmpxchg when updating the two counters.
  */
 int rds_ib_send_grab_credits(struct rds_ib_connection *ic,
-                             u32 wanted, u32 *adv_credits, int need_posted)
+                             u32 wanted, u32 *adv_credits, int need_posted, int max_posted)
 {
         unsigned int avail, posted, got = 0, advertise;
         long oldval, newval;
@@ -351,7 +351,7 @@ try_again:
          * available.
          */
         if (posted && (got || need_posted)) {
-                advertise = min_t(unsigned int, posted, RDS_MAX_ADV_CREDIT);
+                advertise = min_t(unsigned int, posted, max_posted);
                 newval -= IB_SET_POST_CREDITS(advertise);
         }
 
@@ -498,7 +498,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
 
         credit_alloc = work_alloc;
         if (ic->i_flowctl) {
-                credit_alloc = rds_ib_send_grab_credits(ic, work_alloc, &posted, 0);
+                credit_alloc = rds_ib_send_grab_credits(ic, work_alloc, &posted, 0, RDS_MAX_ADV_CREDIT);
                 adv_credits += posted;
                 if (credit_alloc < work_alloc) {
                         rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc - credit_alloc);
@@ -506,7 +506,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
                         flow_controlled++;
                 }
                 if (work_alloc == 0) {
-                        rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc);
+                        set_bit(RDS_LL_SEND_FULL, &conn->c_flags);
                         rds_ib_stats_inc(s_ib_tx_throttle);
                         ret = -ENOMEM;
                         goto out;
@@ -571,7 +571,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
                 /*
                  * Update adv_credits since we reset the ACK_REQUIRED bit.
                  */
-                rds_ib_send_grab_credits(ic, 0, &posted, 1);
+                rds_ib_send_grab_credits(ic, 0, &posted, 1, RDS_MAX_ADV_CREDIT - adv_credits);
                 adv_credits += posted;
                 BUG_ON(adv_credits > 255);
         } else if (ic->i_rm != rm)
diff --git a/net/rds/info.c b/net/rds/info.c
index 1d885535214d..62aeef37aefe 100644
--- a/net/rds/info.c
+++ b/net/rds/info.c
@@ -188,10 +188,7 @@ int rds_info_getsockopt(struct socket *sock, int optname, char __user *optval,
                 ret = -ENOMEM;
                 goto out;
         }
-        down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, start, nr_pages, 1, 0,
-                             pages, NULL);
-        up_read(&current->mm->mmap_sem);
+        ret = get_user_pages_fast(start, nr_pages, 1, pages);
         if (ret != nr_pages) {
                 if (ret > 0)
                         nr_pages = ret;
diff --git a/net/rds/iw.c b/net/rds/iw.c
index b732efb5b634..d16e1cbc8e83 100644
--- a/net/rds/iw.c
+++ b/net/rds/iw.c
@@ -233,8 +233,8 @@ static int rds_iw_laddr_check(__be32 addr)
          * IB and iWARP capable NICs.
          */
         cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
-        if (!cm_id)
-                return -EADDRNOTAVAIL;
+        if (IS_ERR(cm_id))
+                return PTR_ERR(cm_id);
 
         memset(&sin, 0, sizeof(sin));
         sin.sin_family = AF_INET;
diff --git a/net/rds/iw.h b/net/rds/iw.h
index b4fb27252895..0715dde323e7 100644
--- a/net/rds/iw.h
+++ b/net/rds/iw.h
@@ -361,7 +361,7 @@ int rds_iw_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op);
 void rds_iw_send_add_credits(struct rds_connection *conn, unsigned int credits);
 void rds_iw_advertise_credits(struct rds_connection *conn, unsigned int posted);
 int rds_iw_send_grab_credits(struct rds_iw_connection *ic, u32 wanted,
-                             u32 *adv_credits, int need_posted);
+                             u32 *adv_credits, int need_posted, int max_posted);
 
 /* ib_stats.c */
 DECLARE_PER_CPU(struct rds_iw_statistics, rds_iw_stats);
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index fde470fa50d5..8683f5f66c4b 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -524,7 +524,7 @@ void rds_iw_attempt_ack(struct rds_iw_connection *ic)
         }
 
         /* Can we get a send credit? */
-        if (!rds_iw_send_grab_credits(ic, 1, &adv_credits, 0)) {
+        if (!rds_iw_send_grab_credits(ic, 1, &adv_credits, 0, RDS_MAX_ADV_CREDIT)) {
                 rds_iw_stats_inc(s_iw_tx_throttle);
                 clear_bit(IB_ACK_IN_FLIGHT, &ic->i_ack_flags);
                 return;
diff --git a/net/rds/iw_ring.c b/net/rds/iw_ring.c
index d422d4b5deef..da8e3b63f663 100644
--- a/net/rds/iw_ring.c
+++ b/net/rds/iw_ring.c
@@ -137,7 +137,7 @@ int rds_iw_ring_empty(struct rds_iw_work_ring *ring)
 
 int rds_iw_ring_low(struct rds_iw_work_ring *ring)
 {
-        return __rds_iw_ring_used(ring) <= (ring->w_nr >> 2);
+        return __rds_iw_ring_used(ring) <= (ring->w_nr >> 1);
 }
 
 
diff --git a/net/rds/iw_send.c b/net/rds/iw_send.c
index 22dd38ffd608..44a6a0551f28 100644
--- a/net/rds/iw_send.c
+++ b/net/rds/iw_send.c
@@ -347,7 +347,7 @@ void rds_iw_send_cq_comp_handler(struct ib_cq *cq, void *context)
  * and using atomic_cmpxchg when updating the two counters.
  */
 int rds_iw_send_grab_credits(struct rds_iw_connection *ic,
-                             u32 wanted, u32 *adv_credits, int need_posted)
+                             u32 wanted, u32 *adv_credits, int need_posted, int max_posted)
 {
         unsigned int avail, posted, got = 0, advertise;
         long oldval, newval;
@@ -387,7 +387,7 @@ try_again:
          * available.
          */
         if (posted && (got || need_posted)) {
-                advertise = min_t(unsigned int, posted, RDS_MAX_ADV_CREDIT);
+                advertise = min_t(unsigned int, posted, max_posted);
                 newval -= IB_SET_POST_CREDITS(advertise);
         }
 
@@ -541,7 +541,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
 
         credit_alloc = work_alloc;
         if (ic->i_flowctl) {
-                credit_alloc = rds_iw_send_grab_credits(ic, work_alloc, &posted, 0);
+                credit_alloc = rds_iw_send_grab_credits(ic, work_alloc, &posted, 0, RDS_MAX_ADV_CREDIT);
                 adv_credits += posted;
                 if (credit_alloc < work_alloc) {
                         rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc - credit_alloc);
@@ -549,7 +549,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
                         flow_controlled++;
                 }
                 if (work_alloc == 0) {
-                        rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc);
+                        set_bit(RDS_LL_SEND_FULL, &conn->c_flags);
                         rds_iw_stats_inc(s_iw_tx_throttle);
                         ret = -ENOMEM;
                         goto out;
@@ -614,7 +614,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
                 /*
                  * Update adv_credits since we reset the ACK_REQUIRED bit.
                  */
-                rds_iw_send_grab_credits(ic, 0, &posted, 1);
+                rds_iw_send_grab_credits(ic, 0, &posted, 1, RDS_MAX_ADV_CREDIT - adv_credits);
                 adv_credits += posted;
                 BUG_ON(adv_credits > 255);
         } else if (ic->i_rm != rm)
diff --git a/net/rds/rdma.c b/net/rds/rdma.c
index eaeeb91e1119..8dc83d2caa58 100644
--- a/net/rds/rdma.c
+++ b/net/rds/rdma.c
@@ -150,12 +150,9 @@ static int rds_pin_pages(unsigned long user_addr, unsigned int nr_pages,
 {
         int ret;
 
-        down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, user_addr,
-                             nr_pages, write, 0, pages, NULL);
-        up_read(&current->mm->mmap_sem);
+        ret = get_user_pages_fast(user_addr, nr_pages, write, pages);
 
-        if (0 <= ret && (unsigned) ret < nr_pages) {
+        if (ret >= 0 && ret < nr_pages) {
                 while (ret--)
                         put_page(pages[ret]);
                 ret = -EFAULT;
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index 7b19024f9706..7d0f901c93d5 100644
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -34,7 +34,7 @@
 
 #include "rdma_transport.h"
 
-static struct rdma_cm_id *rds_iw_listen_id;
+static struct rdma_cm_id *rds_rdma_listen_id;
 
 int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
                               struct rdma_cm_event *event)
@@ -161,7 +161,7 @@ static int __init rds_rdma_listen_init(void)
 
         rdsdebug("cm %p listening on port %u\n", cm_id, RDS_PORT);
 
-        rds_iw_listen_id = cm_id;
+        rds_rdma_listen_id = cm_id;
         cm_id = NULL;
 out:
         if (cm_id)
@@ -171,10 +171,10 @@ out:
 
 static void rds_rdma_listen_stop(void)
 {
-        if (rds_iw_listen_id) {
-                rdsdebug("cm %p\n", rds_iw_listen_id);
-                rdma_destroy_id(rds_iw_listen_id);
-                rds_iw_listen_id = NULL;
+        if (rds_rdma_listen_id) {
+                rdsdebug("cm %p\n", rds_rdma_listen_id);
+                rdma_destroy_id(rds_rdma_listen_id);
+                rds_rdma_listen_id = NULL;
         }
 }
 
diff --git a/net/rds/rds.h b/net/rds/rds.h
index 619f0a30a4e5..1f82ec0d2066 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -132,7 +132,7 @@ struct rds_connection {
 #define RDS_FLAG_CONG_BITMAP    0x01
 #define RDS_FLAG_ACK_REQUIRED   0x02
 #define RDS_FLAG_RETRANSMITTED  0x04
-#define RDS_MAX_ADV_CREDIT      127
+#define RDS_MAX_ADV_CREDIT      255
 
 /*
  * Maximum space available for extension headers.
diff --git a/net/rds/send.c b/net/rds/send.c
index 104fe033203d..a4a7f428cd76 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -854,11 +854,6 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 
         rm->m_daddr = daddr;
 
-        /* Parse any control messages the user may have included. */
-        ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
-        if (ret)
-                goto out;
-
         /* rds_conn_create has a spinlock that runs with IRQ off.
          * Caching the conn in the socket helps a lot. */
         if (rs->rs_conn && rs->rs_conn->c_faddr == daddr)
@@ -874,6 +869,11 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                 rs->rs_conn = conn;
         }
 
+        /* Parse any control messages the user may have included. */
+        ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
+        if (ret)
+                goto out;
+
         if ((rm->m_rdma_cookie || rm->m_rdma_op)
          && conn->c_trans->xmit_rdma == NULL) {
                 if (printk_ratelimit())