124 files changed, 2915 insertions, 1081 deletions

diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index c754d88e5ec9..179871d9e71f 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -633,7 +633,11 @@ struct vortex_private {
                 open:1,
                 medialock:1,
                 must_free_region:1,                             /* Flag: if zero, Cardbus owns the I/O region */
-                large_frames:1;                 /* accept large frames */
+                large_frames:1,                 /* accept large frames */
+                handling_irq:1;                 /* private in_irq indicator */
+        /* {get|set}_wol operations are already serialized by rtnl.
+         * no additional locking is required for the enable_wol and acpi_set_WOL()
+         */
         int drv_flags;
         u16 status_enable;
         u16 intr_enable;
@@ -646,7 +650,7 @@ struct vortex_private {
         u16 io_size;                                            /* Size of PCI region (for release_region) */
 
         /* Serialises access to hardware other than MII and variables below.
-         * The lock hierarchy is rtnl_lock > lock > mii_lock > window_lock. */
+         * The lock hierarchy is rtnl_lock > {lock, mii_lock} > window_lock. */
         spinlock_t lock;
 
         spinlock_t mii_lock;            /* Serialises access to MII */
@@ -1993,10 +1997,9 @@ vortex_error(struct net_device *dev, int status)
                 }
         }
 
-        if (status & RxEarly) {                         /* Rx early is unused. */
-                vortex_rx(dev);
+        if (status & RxEarly)                           /* Rx early is unused. */
                 iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
-        }
+
         if (status & StatsFull) {                       /* Empty statistics. */
                 static int DoneDidThat;
                 if (vortex_debug > 4)
@@ -2133,6 +2136,15 @@ boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
                            dev->name, vp->cur_tx);
         }
 
+        /*
+         * We can't allow a recursion from our interrupt handler back into the
+         * tx routine, as they take the same spin lock, and that causes
+         * deadlock.  Just return NETDEV_TX_BUSY and let the stack try again in
+         * a bit
+         */
+        if (vp->handling_irq)
+                return NETDEV_TX_BUSY;
+
         if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
                 if (vortex_debug > 0)
                         pr_warning("%s: BUG! Tx Ring full, refusing to send buffer.\n",
@@ -2288,7 +2300,12 @@ vortex_interrupt(int irq, void *dev_id)
                 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq)) {
                         if (status == 0xffff)
                                 break;
+                        if (status & RxEarly)
+                                vortex_rx(dev);
+                        spin_unlock(&vp->window_lock);
                         vortex_error(dev, status);
+                        spin_lock(&vp->window_lock);
+                        window_set(vp, 7);
                 }
 
                 if (--work_done < 0) {
@@ -2335,11 +2352,13 @@ boomerang_interrupt(int irq, void *dev_id)
 
         ioaddr = vp->ioaddr;
 
+
         /*
          * It seems dopey to put the spinlock this early, but we could race against vortex_tx_timeout
          * and boomerang_start_xmit
          */
         spin_lock(&vp->lock);
+        vp->handling_irq = 1;
 
         status = ioread16(ioaddr + EL3_STATUS);
 
@@ -2447,6 +2466,7 @@ boomerang_interrupt(int irq, void *dev_id)
                 pr_debug("%s: exiting interrupt, status %4.4x.\n",
                            dev->name, status);
 handler_exit:
+        vp->handling_irq = 0;
         spin_unlock(&vp->lock);
         return IRQ_HANDLED;
 }
@@ -2922,28 +2942,31 @@ static void vortex_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
         struct vortex_private *vp = netdev_priv(dev);
 
-        spin_lock_irq(&vp->lock);
+        if (!VORTEX_PCI(vp))
+                return;
+
         wol->supported = WAKE_MAGIC;
 
         wol->wolopts = 0;
         if (vp->enable_wol)
                 wol->wolopts |= WAKE_MAGIC;
-        spin_unlock_irq(&vp->lock);
 }
 
 static int vortex_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
         struct vortex_private *vp = netdev_priv(dev);
+
+        if (!VORTEX_PCI(vp))
+                return -EOPNOTSUPP;
+
         if (wol->wolopts & ~WAKE_MAGIC)
                 return -EINVAL;
 
-        spin_lock_irq(&vp->lock);
         if (wol->wolopts & WAKE_MAGIC)
                 vp->enable_wol = 1;
         else
                 vp->enable_wol = 0;
         acpi_set_WOL(dev);
-        spin_unlock_irq(&vp->lock);
 
         return 0;
 }
@@ -2971,7 +2994,6 @@ static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
         int err;
         struct vortex_private *vp = netdev_priv(dev);
-        unsigned long flags;
         pci_power_t state = 0;
 
         if(VORTEX_PCI(vp))
@@ -2981,9 +3003,7 @@ static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 
         if(state != 0)
                 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);
-        spin_lock_irqsave(&vp->lock, flags);
         err = generic_mii_ioctl(&vp->mii, if_mii(rq), cmd, NULL);
-        spin_unlock_irqrestore(&vp->lock, flags);
         if(state != 0)
                 pci_set_power_state(VORTEX_PCI(vp), state);
 
@@ -3188,6 +3208,9 @@ static void acpi_set_WOL(struct net_device *dev)
                         return;
                 }
 
+                if (VORTEX_PCI(vp)->current_state < PCI_D3hot)
+                        return;
+
                 /* Change the power state to D3; RxEnable doesn't take effect. */
                 pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot);
         }
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index ebe68395ecf8..2cc81a54cbf3 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -484,7 +484,7 @@ config XTENSA_XT2000_SONIC
 
 config MIPS_AU1X00_ENET
         tristate "MIPS AU1000 Ethernet support"
-        depends on SOC_AU1X00
+        depends on MIPS_ALCHEMY
         select PHYLIB
         select CRC32
         help
@@ -914,7 +914,7 @@ config SMC91X
         tristate "SMC 91C9x/91C1xxx support"
         select CRC32
         select MII
-        depends on ARM || REDWOOD_5 || REDWOOD_6 || M32R || SUPERH || \
+        depends on ARM || M32R || SUPERH || \
                 MIPS || BLACKFIN || MN10300 || COLDFIRE
         help
           This is a driver for SMC's 91x series of Ethernet chipsets,
@@ -928,6 +928,16 @@ config SMC91X
           The module will be called smc91x.  If you want to compile it as a
           module, say M here and read <file:Documentation/kbuild/modules.txt>.
 
+config PXA168_ETH
+        tristate "Marvell pxa168 ethernet support"
+        depends on CPU_PXA168
+        select PHYLIB
+        help
+          This driver supports the pxa168 Ethernet ports.
+
+          To compile this driver as a module, choose M here. The module
+          will be called pxa168_eth.
+
 config NET_NETX
         tristate "NetX Ethernet support"
         select MII
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 56e8c27f77ce..3e8f150c4b14 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -244,6 +244,7 @@ obj-$(CONFIG_MYRI10GE) += myri10ge/
 obj-$(CONFIG_SMC91X) += smc91x.o
 obj-$(CONFIG_SMC911X) += smc911x.o
 obj-$(CONFIG_SMSC911X) += smsc911x.o
+obj-$(CONFIG_PXA168_ETH) += pxa168_eth.o
 obj-$(CONFIG_BFIN_MAC) += bfin_mac.o
 obj-$(CONFIG_DM9000) += dm9000.o
 obj-$(CONFIG_PASEMI_MAC) += pasemi_mac_driver.o
diff --git a/drivers/net/arm/ixp4xx_eth.c b/drivers/net/arm/ixp4xx_eth.c
index 4f1cc7164ad9..6028226a7270 100644
--- a/drivers/net/arm/ixp4xx_eth.c
+++ b/drivers/net/arm/ixp4xx_eth.c
@@ -241,7 +241,7 @@ static inline void memcpy_swab32(u32 *dest, u32 *src, int cnt)
 
 static spinlock_t mdio_lock;
 static struct eth_regs __iomem *mdio_regs; /* mdio command and status only */
-struct mii_bus *mdio_bus;
+static struct mii_bus *mdio_bus;
 static int ports_open;
 static struct port *npe_port_tab[MAX_NPES];
 static struct dma_pool *dma_pool;
diff --git a/drivers/net/atlx/atl1.c b/drivers/net/atlx/atl1.c
index 63b9ba0cc67e..c73be2848319 100644
--- a/drivers/net/atlx/atl1.c
+++ b/drivers/net/atlx/atl1.c
@@ -1251,6 +1251,12 @@ static void atl1_free_ring_resources(struct atl1_adapter *adapter)
 
         rrd_ring->desc = NULL;
         rrd_ring->dma = 0;
+
+        adapter->cmb.dma = 0;
+        adapter->cmb.cmb = NULL;
+
+        adapter->smb.dma = 0;
+        adapter->smb.smb = NULL;
 }
 
 static void atl1_setup_mac_ctrl(struct atl1_adapter *adapter)
@@ -2847,10 +2853,11 @@ static int atl1_resume(struct pci_dev *pdev)
         pci_enable_wake(pdev, PCI_D3cold, 0);
 
         atl1_reset_hw(&adapter->hw);
-        adapter->cmb.cmb->int_stats = 0;
 
-        if (netif_running(netdev))
+        if (netif_running(netdev)) {
+                adapter->cmb.cmb->int_stats = 0;
                 atl1_up(adapter);
+        }
         netif_device_attach(netdev);
 
         return 0;
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index 386d4feec652..15ae6df2ff00 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -104,14 +104,6 @@ MODULE_VERSION(DRV_VERSION);
  * complete immediately.
  */
 
-/* These addresses are only used if yamon doesn't tell us what
- * the mac address is, and the mac address is not passed on the
- * command line.
- */
-static unsigned char au1000_mac_addr[6] __devinitdata = {
-        0x00, 0x50, 0xc2, 0x0c, 0x30, 0x00
-};
-
 struct au1000_private *au_macs[NUM_ETH_INTERFACES];
 
 /*
@@ -1002,7 +994,6 @@ static int __devinit au1000_probe(struct platform_device *pdev)
         db_dest_t *pDB, *pDBfree;
         int irq, i, err = 0;
         struct resource *base, *macen;
-        char ethaddr[6];
 
         base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!base) {
@@ -1079,24 +1070,13 @@ static int __devinit au1000_probe(struct platform_device *pdev)
         }
         aup->mac_id = pdev->id;
 
-        if (pdev->id == 0) {
-                if (prom_get_ethernet_addr(ethaddr) == 0)
-                        memcpy(au1000_mac_addr, ethaddr, sizeof(au1000_mac_addr));
-                else {
-                        netdev_info(dev, "No MAC address found\n");
-                                /* Use the hard coded MAC addresses */
-                }
-
+        if (pdev->id == 0)
                 au1000_setup_hw_rings(aup, MAC0_RX_DMA_ADDR, MAC0_TX_DMA_ADDR);
-        } else if (pdev->id == 1)
+        else if (pdev->id == 1)
                 au1000_setup_hw_rings(aup, MAC1_RX_DMA_ADDR, MAC1_TX_DMA_ADDR);
 
-        /*
-         * Assign to the Ethernet ports two consecutive MAC addresses
-         * to match those that are printed on their stickers
-         */
-        memcpy(dev->dev_addr, au1000_mac_addr, sizeof(au1000_mac_addr));
-        dev->dev_addr[5] += pdev->id;
+        /* set a random MAC now in case platform_data doesn't provide one */
+        random_ether_addr(dev->dev_addr);
 
         *aup->enable = 0;
         aup->mac_enabled = 0;
@@ -1106,6 +1086,9 @@ static int __devinit au1000_probe(struct platform_device *pdev)
                 dev_info(&pdev->dev, "no platform_data passed, PHY search on MAC0\n");
                 aup->phy1_search_mac0 = 1;
         } else {
+                if (is_valid_ether_addr(pd->mac))
+                        memcpy(dev->dev_addr, pd->mac, 6);
+
                 aup->phy_static_config = pd->phy_static_config;
                 aup->phy_search_highest_addr = pd->phy_search_highest_addr;
                 aup->phy1_search_mac0 = pd->phy1_search_mac0;
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 37617abc1647..1e620e287ae0 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -848,6 +848,15 @@ static int b44_poll(struct napi_struct *napi, int budget)
                 b44_tx(bp);
                 /* spin_unlock(&bp->tx_lock); */
         }
+        if (bp->istat & ISTAT_RFO) {    /* fast recovery, in ~20msec */
+                bp->istat &= ~ISTAT_RFO;
+                b44_disable_ints(bp);
+                ssb_device_enable(bp->sdev, 0); /* resets ISTAT_RFO */
+                b44_init_rings(bp);
+                b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
+                netif_wake_queue(bp->dev);
+        }
+
         spin_unlock_irqrestore(&bp->lock, flags);
 
         work_done = 0;
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 99197bd54da5..53306bf3f401 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -181,6 +181,7 @@ struct be_drvr_stats {
         u64 be_rx_bytes_prev;
         u64 be_rx_pkts;
         u32 be_rx_rate;
+        u32 be_rx_mcast_pkt;
         /* number of non ether type II frames dropped where
          * frame len > length field of Mac Hdr */
         u32 be_802_3_dropped_frames;
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 3d305494a606..34abcc9403d6 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -140,10 +140,8 @@ int be_process_mcc(struct be_adapter *adapter, int *status)
         while ((compl = be_mcc_compl_get(adapter))) {
                 if (compl->flags & CQE_FLAGS_ASYNC_MASK) {
                         /* Interpret flags as an async trailer */
-                        BUG_ON(!is_link_state_evt(compl->flags));
-
-                        /* Interpret compl as a async link evt */
-                        be_async_link_state_process(adapter,
+                        if (is_link_state_evt(compl->flags))
+                                be_async_link_state_process(adapter,
                                 (struct be_async_event_link_state *) compl);
                 } else if (compl->flags & CQE_FLAGS_COMPLETED_MASK) {
                                 *status = be_mcc_compl_process(adapter, compl);
@@ -207,7 +205,7 @@ static int be_mbox_db_ready_wait(struct be_adapter *adapter, void __iomem *db)
 
                 if (msecs > 4000) {
                         dev_err(&adapter->pdev->dev, "mbox poll timed out\n");
-                        be_dump_ue(adapter);
+                        be_detect_dump_ue(adapter);
                         return -1;
                 }
 
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index bdc10a28cfda..ad1e6fac60c5 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -992,5 +992,5 @@ extern int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num,
 extern int be_cmd_get_phy_info(struct be_adapter *adapter,
                 struct be_dma_mem *cmd);
 extern int be_cmd_set_qos(struct be_adapter *adapter, u32 bps, u32 domain);
-extern void be_dump_ue(struct be_adapter *adapter);
+extern void be_detect_dump_ue(struct be_adapter *adapter);
 
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index cd16243c7c36..13f0abbc5205 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -60,6 +60,7 @@ static const struct be_ethtool_stat et_stats[] = {
         {DRVSTAT_INFO(be_rx_events)},
         {DRVSTAT_INFO(be_tx_compl)},
         {DRVSTAT_INFO(be_rx_compl)},
+        {DRVSTAT_INFO(be_rx_mcast_pkt)},
         {DRVSTAT_INFO(be_ethrx_post_fail)},
         {DRVSTAT_INFO(be_802_3_dropped_frames)},
         {DRVSTAT_INFO(be_802_3_malformed_frames)},
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index 5d38046402b2..a2ec5df0d733 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -167,8 +167,11 @@
 #define FLASH_FCoE_BIOS_START_g3           (13631488)
 #define FLASH_REDBOOT_START_g3             (262144)
 
-
-
+/************* Rx Packet Type Encoding **************/
+#define BE_UNICAST_PACKET               0
+#define BE_MULTICAST_PACKET             1
+#define BE_BROADCAST_PACKET             2
+#define BE_RSVD_PACKET                  3
 
 /*
  * BE descriptors: host memory data structures whose formats
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 74e146f470c6..6eda7a022256 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -247,6 +247,7 @@ void netdev_stats_update(struct be_adapter *adapter)
         dev_stats->tx_packets = drvr_stats(adapter)->be_tx_pkts;
         dev_stats->rx_bytes = drvr_stats(adapter)->be_rx_bytes;
         dev_stats->tx_bytes = drvr_stats(adapter)->be_tx_bytes;
+        dev_stats->multicast = drvr_stats(adapter)->be_rx_mcast_pkt;
 
         /* bad pkts received */
         dev_stats->rx_errors = port_stats->rx_crc_errors +
@@ -294,7 +295,6 @@ void netdev_stats_update(struct be_adapter *adapter)
         /* no space available in linux */
         dev_stats->tx_dropped = 0;
 
-        dev_stats->multicast = port_stats->rx_multicast_frames;
         dev_stats->collisions = 0;
 
         /* detailed tx_errors */
@@ -848,7 +848,7 @@ static void be_rx_rate_update(struct be_adapter *adapter)
 }
 
 static void be_rx_stats_update(struct be_adapter *adapter,
-                u32 pktsize, u16 numfrags)
+                u32 pktsize, u16 numfrags, u8 pkt_type)
 {
         struct be_drvr_stats *stats = drvr_stats(adapter);
 
@@ -856,6 +856,9 @@ static void be_rx_stats_update(struct be_adapter *adapter,
         stats->be_rx_frags += numfrags;
         stats->be_rx_bytes += pktsize;
         stats->be_rx_pkts++;
+
+        if (pkt_type == BE_MULTICAST_PACKET)
+                stats->be_rx_mcast_pkt++;
 }
 
 static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso)
@@ -925,9 +928,11 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
         u16 rxq_idx, i, j;
         u32 pktsize, hdr_len, curr_frag_len, size;
         u8 *start;
+        u8 pkt_type;
 
         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
         pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
+        pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
 
         page_info = get_rx_page_info(adapter, rxq_idx);
 
@@ -993,7 +998,7 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
         BUG_ON(j > MAX_SKB_FRAGS);
 
 done:
-        be_rx_stats_update(adapter, pktsize, num_rcvd);
+        be_rx_stats_update(adapter, pktsize, num_rcvd, pkt_type);
 }
 
 /* Process the RX completion indicated by rxcp when GRO is disabled */
@@ -1060,6 +1065,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
         u16 i, rxq_idx = 0, vid, j;
         u8 vtm;
+        u8 pkt_type;
 
         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
         /* Is it a flush compl that has no data */
@@ -1070,6 +1076,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
         vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
+        pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
 
         /* vlanf could be wrongly set in some cards.
          * ignore if vtm is not set */
@@ -1125,7 +1132,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
                 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, vid);
         }
 
-        be_rx_stats_update(adapter, pkt_size, num_rcvd);
+        be_rx_stats_update(adapter, pkt_size, num_rcvd, pkt_type);
 }
 
 static struct be_eth_rx_compl *be_rx_compl_get(struct be_adapter *adapter)
@@ -1743,26 +1750,7 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
         return 1;
 }
 
-static inline bool be_detect_ue(struct be_adapter *adapter)
-{
-        u32 online0 = 0, online1 = 0;
-
-        pci_read_config_dword(adapter->pdev, PCICFG_ONLINE0, &online0);
-
-        pci_read_config_dword(adapter->pdev, PCICFG_ONLINE1, &online1);
-
-        if (!online0 || !online1) {
-                adapter->ue_detected = true;
-                dev_err(&adapter->pdev->dev,
-                        "UE Detected!! online0=%d online1=%d\n",
-                        online0, online1);
-                return true;
-        }
-
-        return false;
-}
-
-void be_dump_ue(struct be_adapter *adapter)
+void be_detect_dump_ue(struct be_adapter *adapter)
 {
         u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
         u32 i;
@@ -1779,6 +1767,11 @@ void be_dump_ue(struct be_adapter *adapter)
         ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
         ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));
 
+        if (ue_status_lo || ue_status_hi) {
+                adapter->ue_detected = true;
+                dev_err(&adapter->pdev->dev, "UE Detected!!\n");
+        }
+
         if (ue_status_lo) {
                 for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
                         if (ue_status_lo & 1)
@@ -1814,10 +1807,8 @@ static void be_worker(struct work_struct *work)
                 adapter->rx_post_starved = false;
                 be_post_rx_frags(adapter);
         }
-        if (!adapter->ue_detected) {
-                if (be_detect_ue(adapter))
-                        be_dump_ue(adapter);
-        }
+        if (!adapter->ue_detected)
+                be_detect_dump_ue(adapter);
 
         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
 }
diff --git a/drivers/net/bnx2x/bnx2x.h b/drivers/net/bnx2x/bnx2x.h
index 53af9c93e75c..0c2d96ed561c 100644
--- a/drivers/net/bnx2x/bnx2x.h
+++ b/drivers/net/bnx2x/bnx2x.h
@@ -20,8 +20,8 @@
  * (you will need to reboot afterwards) */
 /* #define BNX2X_STOP_ON_ERROR */
 
-#define DRV_MODULE_VERSION      "1.52.53-3"
-#define DRV_MODULE_RELDATE      "2010/18/04"
+#define DRV_MODULE_VERSION      "1.52.53-4"
+#define DRV_MODULE_RELDATE      "2010/16/08"
 #define BNX2X_BC_VER            0x040200
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index b4ec2b02a465..f8c3f08e4ce7 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -4328,10 +4328,12 @@ static int bnx2x_init_port(struct bnx2x *bp)
                 val |= aeu_gpio_mask;
                 REG_WR(bp, offset, val);
                 }
+                bp->port.need_hw_lock = 1;
                 break;
 
-        case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727:
+                bp->port.need_hw_lock = 1;
+        case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
                 /* add SPIO 5 to group 0 */
                 {
                 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
@@ -4341,7 +4343,10 @@ static int bnx2x_init_port(struct bnx2x *bp)
                 REG_WR(bp, reg_addr, val);
                 }
                 break;
-
+        case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
+        case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
+                bp->port.need_hw_lock = 1;
+                break;
         default:
                 break;
         }
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index 822f586d72af..0ddf4c66afe2 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -2466,6 +2466,9 @@ int bond_3ad_lacpdu_recv(struct sk_buff *skb, struct net_device *dev, struct pac
         if (!(dev->flags & IFF_MASTER))
                 goto out;
 
+        if (!pskb_may_pull(skb, sizeof(struct lacpdu)))
+                goto out;
+
         read_lock(&bond->lock);
         slave = bond_get_slave_by_dev((struct bonding *)netdev_priv(dev),
                                         orig_dev);
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index c746b331771d..26bb118c4533 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -362,6 +362,9 @@ static int rlb_arp_recv(struct sk_buff *skb, struct net_device *bond_dev, struct
                 goto out;
         }
 
+        if (!pskb_may_pull(skb, arp_hdr_len(bond_dev)))
+                goto out;
+
         if (skb->len < sizeof(struct arp_pkt)) {
                 pr_debug("Packet is too small to be an ARP\n");
                 goto out;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 2cc4cfc31892..3b16f62d5606 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -2797,9 +2797,15 @@ void bond_loadbalance_arp_mon(struct work_struct *work)
          *       so it can wait
          */
         bond_for_each_slave(bond, slave, i) {
+                unsigned long trans_start = dev_trans_start(slave->dev);
+
                 if (slave->link != BOND_LINK_UP) {
-                        if (time_before_eq(jiffies, dev_trans_start(slave->dev) + delta_in_ticks) &&
-                            time_before_eq(jiffies, slave->dev->last_rx + delta_in_ticks)) {
+                        if (time_in_range(jiffies,
+                                trans_start - delta_in_ticks,
+                                trans_start + delta_in_ticks) &&
+                            time_in_range(jiffies,
+                                slave->dev->last_rx - delta_in_ticks,
+                                slave->dev->last_rx + delta_in_ticks)) {
 
                                 slave->link  = BOND_LINK_UP;
                                 slave->state = BOND_STATE_ACTIVE;
@@ -2827,8 +2833,12 @@ void bond_loadbalance_arp_mon(struct work_struct *work)
                          * when the source ip is 0, so don't take the link down
                          * if we don't know our ip yet
                          */
-                        if (time_after_eq(jiffies, dev_trans_start(slave->dev) + 2*delta_in_ticks) ||
-                            (time_after_eq(jiffies, slave->dev->last_rx + 2*delta_in_ticks))) {
+                        if (!time_in_range(jiffies,
+                                trans_start - delta_in_ticks,
+                                trans_start + 2 * delta_in_ticks) ||
+                            !time_in_range(jiffies,
+                                slave->dev->last_rx - delta_in_ticks,
+                                slave->dev->last_rx + 2 * delta_in_ticks)) {
 
                                 slave->link  = BOND_LINK_DOWN;
                                 slave->state = BOND_STATE_BACKUP;
@@ -2883,13 +2893,16 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
 {
         struct slave *slave;
         int i, commit = 0;
+        unsigned long trans_start;
 
         bond_for_each_slave(bond, slave, i) {
                 slave->new_link = BOND_LINK_NOCHANGE;
 
                 if (slave->link != BOND_LINK_UP) {
-                        if (time_before_eq(jiffies, slave_last_rx(bond, slave) +
-                                           delta_in_ticks)) {
+                        if (time_in_range(jiffies,
+                                slave_last_rx(bond, slave) - delta_in_ticks,
+                                slave_last_rx(bond, slave) + delta_in_ticks)) {
+
                                 slave->new_link = BOND_LINK_UP;
                                 commit++;
                         }
@@ -2902,8 +2915,9 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  * active.  This avoids bouncing, as the last receive
                  * times need a full ARP monitor cycle to be updated.
                  */
-                if (!time_after_eq(jiffies, slave->jiffies +
-                                   2 * delta_in_ticks))
+                if (time_in_range(jiffies,
+                                  slave->jiffies - delta_in_ticks,
+                                  slave->jiffies + 2 * delta_in_ticks))
                         continue;
 
                 /*
@@ -2921,8 +2935,10 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  */
                 if (slave->state == BOND_STATE_BACKUP &&
                     !bond->current_arp_slave &&
-                    time_after(jiffies, slave_last_rx(bond, slave) +
-                               3 * delta_in_ticks)) {
+                    !time_in_range(jiffies,
+                        slave_last_rx(bond, slave) - delta_in_ticks,
+                        slave_last_rx(bond, slave) + 3 * delta_in_ticks)) {
+
                         slave->new_link = BOND_LINK_DOWN;
                         commit++;
                 }
@@ -2933,11 +2949,15 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  * - (more than 2*delta since receive AND
                  *    the bond has an IP address)
                  */
+                trans_start = dev_trans_start(slave->dev);
                 if ((slave->state == BOND_STATE_ACTIVE) &&
-                    (time_after_eq(jiffies, dev_trans_start(slave->dev) +
-                                    2 * delta_in_ticks) ||
-                      (time_after_eq(jiffies, slave_last_rx(bond, slave)
-                                     + 2 * delta_in_ticks)))) {
+                    (!time_in_range(jiffies,
+                        trans_start - delta_in_ticks,
+                        trans_start + 2 * delta_in_ticks) ||
+                     !time_in_range(jiffies,
+                        slave_last_rx(bond, slave) - delta_in_ticks,
+                        slave_last_rx(bond, slave) + 2 * delta_in_ticks))) {
+
                         slave->new_link = BOND_LINK_DOWN;
                         commit++;
                 }
@@ -2956,6 +2976,7 @@ static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
 {
         struct slave *slave;
         int i;
+        unsigned long trans_start;
 
         bond_for_each_slave(bond, slave, i) {
                 switch (slave->new_link) {
@@ -2963,10 +2984,11 @@ static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
                         continue;
 
                 case BOND_LINK_UP:
+                        trans_start = dev_trans_start(slave->dev);
                         if ((!bond->curr_active_slave &&
-                             time_before_eq(jiffies,
-                                            dev_trans_start(slave->dev) +
-                                            delta_in_ticks)) ||
+                             time_in_range(jiffies,
+                                           trans_start - delta_in_ticks,
+                                           trans_start + delta_in_ticks)) ||
                             bond->curr_active_slave != slave) {
                                 slave->link = BOND_LINK_UP;
                                 bond->current_arp_slave = NULL;
diff --git a/drivers/net/caif/Kconfig b/drivers/net/caif/Kconfig
index 631a6242b011..75bfc3a9d95f 100644
--- a/drivers/net/caif/Kconfig
+++ b/drivers/net/caif/Kconfig
@@ -15,7 +15,7 @@ config CAIF_TTY
 
 config CAIF_SPI_SLAVE
         tristate "CAIF SPI transport driver for slave interface"
-        depends on CAIF
+        depends on CAIF && HAS_DMA
         default n
         ---help---
         The CAIF Link layer SPI Protocol driver for Slave SPI interface.
diff --git a/drivers/net/caif/caif_spi_slave.c b/drivers/net/caif/caif_spi_slave.c
index 077ccf840edf..2111dbfea6fe 100644
--- a/drivers/net/caif/caif_spi_slave.c
+++ b/drivers/net/caif/caif_spi_slave.c
@@ -22,13 +22,13 @@
 #include <net/caif/caif_spi.h>
 
 #ifndef CONFIG_CAIF_SPI_SYNC
-#define SPI_DATA_POS SPI_CMD_SZ
+#define SPI_DATA_POS 0
 static inline int forward_to_spi_cmd(struct cfspi *cfspi)
 {
         return cfspi->rx_cpck_len;
 }
 #else
-#define SPI_DATA_POS 0
+#define SPI_DATA_POS SPI_CMD_SZ
 static inline int forward_to_spi_cmd(struct cfspi *cfspi)
 {
         return 0;
diff --git a/drivers/net/can/mscan/mpc5xxx_can.c b/drivers/net/can/mscan/mpc5xxx_can.c
index af753936e835..b1bdc909090f 100644
--- a/drivers/net/can/mscan/mpc5xxx_can.c
+++ b/drivers/net/can/mscan/mpc5xxx_can.c
@@ -38,7 +38,7 @@
 
 struct mpc5xxx_can_data {
         unsigned int type;
-        u32 (*get_clock)(struct of_device *ofdev, const char *clock_name,
+        u32 (*get_clock)(struct platform_device *ofdev, const char *clock_name,
                          int *mscan_clksrc);
 };
 
@@ -48,7 +48,7 @@ static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = {
         {}
 };
 
-static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -101,7 +101,7 @@ static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
         return freq;
 }
 #else /* !CONFIG_PPC_MPC52xx */
-static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -129,7 +129,7 @@ static struct of_device_id __devinitdata mpc512x_clock_ids[] = {
         {}
 };
 
-static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -239,7 +239,7 @@ exit_unmap:
         return freq;
 }
 #else /* !CONFIG_PPC_MPC512x */
-static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -247,7 +247,7 @@ static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
 }
 #endif /* CONFIG_PPC_MPC512x */
 
-static int __devinit mpc5xxx_can_probe(struct of_device *ofdev,
+static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev,
                                        const struct of_device_id *id)
 {
         struct mpc5xxx_can_data *data = (struct mpc5xxx_can_data *)id->data;
@@ -317,7 +317,7 @@ exit_unmap_mem:
         return err;
 }
 
-static int __devexit mpc5xxx_can_remove(struct of_device *ofdev)
+static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
@@ -334,7 +334,7 @@ static int __devexit mpc5xxx_can_remove(struct of_device *ofdev)
 
 #ifdef CONFIG_PM
 static struct mscan_regs saved_regs;
-static int mpc5xxx_can_suspend(struct of_device *ofdev, pm_message_t state)
+static int mpc5xxx_can_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
@@ -345,7 +345,7 @@ static int mpc5xxx_can_suspend(struct of_device *ofdev, pm_message_t state)
         return 0;
 }
 
-static int mpc5xxx_can_resume(struct of_device *ofdev)
+static int mpc5xxx_can_resume(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
diff --git a/drivers/net/can/sja1000/sja1000_of_platform.c b/drivers/net/can/sja1000/sja1000_of_platform.c
index ac1a83d7c204..5bfccfdf3bbb 100644
--- a/drivers/net/can/sja1000/sja1000_of_platform.c
+++ b/drivers/net/can/sja1000/sja1000_of_platform.c
@@ -67,7 +67,7 @@ static void sja1000_ofp_write_reg(const struct sja1000_priv *priv,
         out_8(priv->reg_base + reg, val);
 }
 
-static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
+static int __devexit sja1000_ofp_remove(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct sja1000_priv *priv = netdev_priv(dev);
@@ -87,7 +87,7 @@ static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
         return 0;
 }
 
-static int __devinit sja1000_ofp_probe(struct of_device *ofdev,
+static int __devinit sja1000_ofp_probe(struct platform_device *ofdev,
                                        const struct of_device_id *id)
 {
         struct device_node *np = ofdev->dev.of_node;
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index ad19585d960b..f208712c0b90 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -2296,6 +2296,8 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr)
         case CHELSIO_GET_QSET_NUM:{
                 struct ch_reg edata;
 
+                memset(&edata, 0, sizeof(struct ch_reg));
+
                 edata.cmd = CHELSIO_GET_QSET_NUM;
                 edata.val = pi->nqsets;
                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index a4a0d2b6eb1c..d3d4a57e2450 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -936,12 +936,14 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
         ew32(IMC, 0xffffffff);
         icr = er32(ICR);
 
-        /* Install any alternate MAC address into RAR0 */
-        ret_val = e1000_check_alt_mac_addr_generic(hw);
-        if (ret_val)
-                return ret_val;
+        if (hw->mac.type == e1000_82571) {
+                /* Install any alternate MAC address into RAR0 */
+                ret_val = e1000_check_alt_mac_addr_generic(hw);
+                if (ret_val)
+                        return ret_val;
 
-        e1000e_set_laa_state_82571(hw, true);
+                e1000e_set_laa_state_82571(hw, true);
+        }
 
         /* Reinitialize the 82571 serdes link state machine */
         if (hw->phy.media_type == e1000_media_type_internal_serdes)
@@ -1618,14 +1620,16 @@ static s32 e1000_read_mac_addr_82571(struct e1000_hw *hw)
 {
         s32 ret_val = 0;
 
-        /*
-         * If there's an alternate MAC address place it in RAR0
-         * so that it will override the Si installed default perm
-         * address.
-         */
-        ret_val = e1000_check_alt_mac_addr_generic(hw);
-        if (ret_val)
-                goto out;
+        if (hw->mac.type == e1000_82571) {
+                /*
+                 * If there's an alternate MAC address place it in RAR0
+                 * so that it will override the Si installed default perm
+                 * address.
+                 */
+                ret_val = e1000_check_alt_mac_addr_generic(hw);
+                if (ret_val)
+                        goto out;
+        }
 
         ret_val = e1000_read_mac_addr_generic(hw);
 
@@ -1833,6 +1837,7 @@ struct e1000_info e1000_82573_info = {
                                   | FLAG_HAS_SMART_POWER_DOWN
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_SWSM_ON_LOAD,
+        .flags2                 = FLAG2_DISABLE_ASPM_L1,
         .pba                    = 20,
         .max_hw_frame_size      = ETH_FRAME_LEN + ETH_FCS_LEN,
         .get_variants           = e1000_get_variants_82571,
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index 307a72f483ee..93b3bedae8d2 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -621,6 +621,7 @@
 #define E1000_FLASH_UPDATES  2000
 
 /* NVM Word Offsets */
+#define NVM_COMPAT                 0x0003
 #define NVM_ID_LED_SETTINGS        0x0004
 #define NVM_INIT_CONTROL2_REG      0x000F
 #define NVM_INIT_CONTROL3_PORT_B   0x0014
@@ -643,6 +644,9 @@
 /* Mask bits for fields in Word 0x1a of the NVM */
 #define NVM_WORD1A_ASPM_MASK  0x000C
 
+/* Mask bits for fields in Word 0x03 of the EEPROM */
+#define NVM_COMPAT_LOM    0x0800
+
 /* For checksumming, the sum of all words in the NVM should equal 0xBABA. */
 #define NVM_SUM                    0xBABA
 
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index 66ed08f726fb..ba302a5c2c30 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -57,6 +57,7 @@ enum e1e_registers {
         E1000_SCTL     = 0x00024, /* SerDes Control - RW */
         E1000_FCAL     = 0x00028, /* Flow Control Address Low - RW */
         E1000_FCAH     = 0x0002C, /* Flow Control Address High -RW */
+        E1000_FEXTNVM4 = 0x00024, /* Future Extended NVM 4 - RW */
         E1000_FEXTNVM  = 0x00028, /* Future Extended NVM - RW */
         E1000_FCT      = 0x00030, /* Flow Control Type - RW */
         E1000_VET      = 0x00038, /* VLAN Ether Type - RW */
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 63930d12711c..57b5435599ab 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -105,6 +105,10 @@
 #define E1000_FEXTNVM_SW_CONFIG         1
 #define E1000_FEXTNVM_SW_CONFIG_ICH8M (1 << 27) /* Bit redefined for ICH8M :/ */
 
+#define E1000_FEXTNVM4_BEACON_DURATION_MASK    0x7
+#define E1000_FEXTNVM4_BEACON_DURATION_8USEC   0x7
+#define E1000_FEXTNVM4_BEACON_DURATION_16USEC  0x3
+
 #define PCIE_ICH8_SNOOP_ALL             PCIE_NO_SNOOP_ALL
 
 #define E1000_ICH_RAR_ENTRIES           7
@@ -125,6 +129,7 @@
 
 /* SMBus Address Phy Register */
 #define HV_SMB_ADDR            PHY_REG(768, 26)
+#define HV_SMB_ADDR_MASK       0x007F
 #define HV_SMB_ADDR_PEC_EN     0x0200
 #define HV_SMB_ADDR_VALID      0x0080
 
@@ -237,6 +242,8 @@ static s32  e1000_k1_gig_workaround_hv(struct e1000_hw *hw, bool link);
 static s32 e1000_set_mdio_slow_mode_hv(struct e1000_hw *hw);
 static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw);
 static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw);
+static s32 e1000_k1_workaround_lv(struct e1000_hw *hw);
+static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate);
 
 static inline u16 __er16flash(struct e1000_hw *hw, unsigned long reg)
 {
@@ -272,7 +279,7 @@ static inline void __ew32flash(struct e1000_hw *hw, unsigned long reg, u32 val)
 static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
 {
         struct e1000_phy_info *phy = &hw->phy;
-        u32 ctrl;
+        u32 ctrl, fwsm;
         s32 ret_val = 0;
 
         phy->addr                     = 1;
@@ -294,7 +301,8 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
          * disabled, then toggle the LANPHYPC Value bit to force
          * the interconnect to PCIe mode.
          */
-        if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
+        fwsm = er32(FWSM);
+        if (!(fwsm & E1000_ICH_FWSM_FW_VALID)) {
                 ctrl = er32(CTRL);
                 ctrl |=  E1000_CTRL_LANPHYPC_OVERRIDE;
                 ctrl &= ~E1000_CTRL_LANPHYPC_VALUE;
@@ -303,6 +311,13 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
                 ctrl &= ~E1000_CTRL_LANPHYPC_OVERRIDE;
                 ew32(CTRL, ctrl);
                 msleep(50);
+
+                /*
+                 * Gate automatic PHY configuration by hardware on
+                 * non-managed 82579
+                 */
+                if (hw->mac.type == e1000_pch2lan)
+                        e1000_gate_hw_phy_config_ich8lan(hw, true);
         }
 
         /*
@@ -315,6 +330,13 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
         if (ret_val)
                 goto out;
 
+        /* Ungate automatic PHY configuration on non-managed 82579 */
+        if ((hw->mac.type == e1000_pch2lan)  &&
+            !(fwsm & E1000_ICH_FWSM_FW_VALID)) {
+                msleep(10);
+                e1000_gate_hw_phy_config_ich8lan(hw, false);
+        }
+
         phy->id = e1000_phy_unknown;
         ret_val = e1000e_get_phy_id(hw);
         if (ret_val)
@@ -561,13 +583,10 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_adapter *adapter)
         if (mac->type == e1000_ich8lan)
                 e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw, true);
 
-        /* Disable PHY configuration by hardware, config by software */
-        if (mac->type == e1000_pch2lan) {
-                u32 extcnf_ctrl = er32(EXTCNF_CTRL);
-
-                extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG;
-                ew32(EXTCNF_CTRL, extcnf_ctrl);
-        }
+        /* Gate automatic PHY configuration by hardware on managed 82579 */
+        if ((mac->type == e1000_pch2lan) &&
+            (er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
+                e1000_gate_hw_phy_config_ich8lan(hw, true);
 
         return 0;
 }
@@ -652,6 +671,12 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
                         goto out;
         }
 
+        if (hw->mac.type == e1000_pch2lan) {
+                ret_val = e1000_k1_workaround_lv(hw);
+                if (ret_val)
+                        goto out;
+        }
+
         /*
          * Check if there was DownShift, must be checked
          * immediately after link-up
@@ -895,6 +920,34 @@ static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw)
 }
 
 /**
+ *  e1000_write_smbus_addr - Write SMBus address to PHY needed during Sx states
+ *  @hw: pointer to the HW structure
+ *
+ *  Assumes semaphore already acquired.
+ *
+ **/
+static s32 e1000_write_smbus_addr(struct e1000_hw *hw)
+{
+        u16 phy_data;
+        u32 strap = er32(STRAP);
+        s32 ret_val = 0;
+
+        strap &= E1000_STRAP_SMBUS_ADDRESS_MASK;
+
+        ret_val = e1000_read_phy_reg_hv_locked(hw, HV_SMB_ADDR, &phy_data);
+        if (ret_val)
+                goto out;
+
+        phy_data &= ~HV_SMB_ADDR_MASK;
+        phy_data |= (strap >> E1000_STRAP_SMBUS_ADDRESS_SHIFT);
+        phy_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID;
+        ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR, phy_data);
+
+out:
+        return ret_val;
+}
+
+/**
  *  e1000_sw_lcd_config_ich8lan - SW-based LCD Configuration
  *  @hw:   pointer to the HW structure
  *
@@ -903,7 +956,6 @@ static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw)
  **/
 static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw)
 {
-        struct e1000_adapter *adapter = hw->adapter;
         struct e1000_phy_info *phy = &hw->phy;
         u32 i, data, cnf_size, cnf_base_addr, sw_cfg_mask;
         s32 ret_val = 0;
@@ -921,7 +973,8 @@ static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw)
                 if (phy->type != e1000_phy_igp_3)
                         return ret_val;
 
-                if (adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) {
+                if ((hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) ||
+                    (hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_C)) {
                         sw_cfg_mask = E1000_FEXTNVM_SW_CONFIG;
                         break;
                 }
@@ -961,21 +1014,16 @@ static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw)
         cnf_base_addr = data & E1000_EXTCNF_CTRL_EXT_CNF_POINTER_MASK;
         cnf_base_addr >>= E1000_EXTCNF_CTRL_EXT_CNF_POINTER_SHIFT;
 
-        if (!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) &&
-            ((hw->mac.type == e1000_pchlan) ||
-             (hw->mac.type == e1000_pch2lan))) {
+        if ((!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) &&
+            (hw->mac.type == e1000_pchlan)) ||
+             (hw->mac.type == e1000_pch2lan)) {
                 /*
                  * HW configures the SMBus address and LEDs when the
                  * OEM and LCD Write Enable bits are set in the NVM.
                  * When both NVM bits are cleared, SW will configure
                  * them instead.
                  */
-                data = er32(STRAP);
-                data &= E1000_STRAP_SMBUS_ADDRESS_MASK;
-                reg_data = data >> E1000_STRAP_SMBUS_ADDRESS_SHIFT;
-                reg_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID;
-                ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR,
-                                                        reg_data);
+                ret_val = e1000_write_smbus_addr(hw);
                 if (ret_val)
                         goto out;
 
@@ -1440,10 +1488,6 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                         goto out;
 
                 /* Enable jumbo frame workaround in the PHY */
-                e1e_rphy(hw, PHY_REG(769, 20), &data);
-                ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14));
-                if (ret_val)
-                        goto out;
                 e1e_rphy(hw, PHY_REG(769, 23), &data);
                 data &= ~(0x7F << 5);
                 data |= (0x37 << 5);
@@ -1452,7 +1496,6 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                         goto out;
                 e1e_rphy(hw, PHY_REG(769, 16), &data);
                 data &= ~(1 << 13);
-                data |= (1 << 12);
                 ret_val = e1e_wphy(hw, PHY_REG(769, 16), data);
                 if (ret_val)
                         goto out;
@@ -1477,7 +1520,7 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
 
                 mac_reg = er32(RCTL);
                 mac_reg &= ~E1000_RCTL_SECRC;
-                ew32(FFLT_DBG, mac_reg);
+                ew32(RCTL, mac_reg);
 
                 ret_val = e1000e_read_kmrn_reg(hw,
                                                 E1000_KMRNCTRLSTA_CTRL_OFFSET,
@@ -1503,17 +1546,12 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                         goto out;
 
                 /* Write PHY register values back to h/w defaults */
-                e1e_rphy(hw, PHY_REG(769, 20), &data);
-                ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14));
-                if (ret_val)
-                        goto out;
                 e1e_rphy(hw, PHY_REG(769, 23), &data);
                 data &= ~(0x7F << 5);
                 ret_val = e1e_wphy(hw, PHY_REG(769, 23), data);
                 if (ret_val)
                         goto out;
                 e1e_rphy(hw, PHY_REG(769, 16), &data);
-                data &= ~(1 << 12);
                 data |= (1 << 13);
                 ret_val = e1e_wphy(hw, PHY_REG(769, 16), data);
                 if (ret_val)
@@ -1559,6 +1597,69 @@ out:
 }
 
 /**
+ *  e1000_k1_gig_workaround_lv - K1 Si workaround
+ *  @hw:   pointer to the HW structure
+ *
+ *  Workaround to set the K1 beacon duration for 82579 parts
+ **/
+static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
+{
+        s32 ret_val = 0;
+        u16 status_reg = 0;
+        u32 mac_reg;
+
+        if (hw->mac.type != e1000_pch2lan)
+                goto out;
+
+        /* Set K1 beacon duration based on 1Gbps speed or otherwise */
+        ret_val = e1e_rphy(hw, HV_M_STATUS, &status_reg);
+        if (ret_val)
+                goto out;
+
+        if ((status_reg & (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE))
+            == (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE)) {
+                mac_reg = er32(FEXTNVM4);
+                mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
+
+                if (status_reg & HV_M_STATUS_SPEED_1000)
+                        mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
+                else
+                        mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC;
+
+                ew32(FEXTNVM4, mac_reg);
+        }
+
+out:
+        return ret_val;
+}
+
+/**
+ *  e1000_gate_hw_phy_config_ich8lan - disable PHY config via hardware
+ *  @hw:   pointer to the HW structure
+ *  @gate: boolean set to true to gate, false to ungate
+ *
+ *  Gate/ungate the automatic PHY configuration via hardware; perform
+ *  the configuration via software instead.
+ **/
+static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate)
+{
+        u32 extcnf_ctrl;
+
+        if (hw->mac.type != e1000_pch2lan)
+                return;
+
+        extcnf_ctrl = er32(EXTCNF_CTRL);
+
+        if (gate)
+                extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG;
+        else
+                extcnf_ctrl &= ~E1000_EXTCNF_CTRL_GATE_PHY_CFG;
+
+        ew32(EXTCNF_CTRL, extcnf_ctrl);
+        return;
+}
+
+/**
  *  e1000_lan_init_done_ich8lan - Check for PHY config completion
  *  @hw: pointer to the HW structure
  *
@@ -1602,6 +1703,9 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw)
         if (e1000_check_reset_block(hw))
                 goto out;
 
+        /* Allow time for h/w to get to quiescent state after reset */
+        msleep(10);
+
         /* Perform any necessary post-reset workarounds */
         switch (hw->mac.type) {
         case e1000_pchlan:
@@ -1630,6 +1734,13 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw)
         /* Configure the LCD with the OEM bits in NVM */
         ret_val = e1000_oem_bits_config_ich8lan(hw, true);
 
+        /* Ungate automatic PHY configuration on non-managed 82579 */
+        if ((hw->mac.type == e1000_pch2lan) &&
+            !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
+                msleep(10);
+                e1000_gate_hw_phy_config_ich8lan(hw, false);
+        }
+
 out:
         return ret_val;
 }
@@ -1646,6 +1757,11 @@ static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw)
 {
         s32 ret_val = 0;
 
+        /* Gate automatic PHY configuration by hardware on non-managed 82579 */
+        if ((hw->mac.type == e1000_pch2lan) &&
+            !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
+                e1000_gate_hw_phy_config_ich8lan(hw, true);
+
         ret_val = e1000e_phy_hw_reset_generic(hw);
         if (ret_val)
                 goto out;
@@ -2910,6 +3026,14 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
                  * external PHY is reset.
                  */
                 ctrl |= E1000_CTRL_PHY_RST;
+
+                /*
+                 * Gate automatic PHY configuration by hardware on
+                 * non-managed 82579
+                 */
+                if ((hw->mac.type == e1000_pch2lan) &&
+                    !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
+                        e1000_gate_hw_phy_config_ich8lan(hw, true);
         }
         ret_val = e1000_acquire_swflag_ich8lan(hw);
         e_dbg("Issuing a global reset to ich8lan\n");
@@ -3460,13 +3584,20 @@ void e1000e_gig_downshift_workaround_ich8lan(struct e1000_hw *hw)
 void e1000e_disable_gig_wol_ich8lan(struct e1000_hw *hw)
 {
         u32 phy_ctrl;
+        s32 ret_val;
 
         phy_ctrl = er32(PHY_CTRL);
         phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU | E1000_PHY_CTRL_GBE_DISABLE;
         ew32(PHY_CTRL, phy_ctrl);
 
-        if (hw->mac.type >= e1000_pchlan)
-                e1000_phy_hw_reset_ich8lan(hw);
+        if (hw->mac.type >= e1000_pchlan) {
+                e1000_oem_bits_config_ich8lan(hw, true);
+                ret_val = hw->phy.ops.acquire(hw);
+                if (ret_val)
+                        return;
+                e1000_write_smbus_addr(hw);
+                hw->phy.ops.release(hw);
+        }
 }
 
 /**
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index df4a27922931..0fd4eb5ac5fb 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -183,6 +183,16 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
         u16 offset, nvm_alt_mac_addr_offset, nvm_data;
         u8 alt_mac_addr[ETH_ALEN];
 
+        ret_val = e1000_read_nvm(hw, NVM_COMPAT, 1, &nvm_data);
+        if (ret_val)
+                goto out;
+
+        /* Check for LOM (vs. NIC) or one of two valid mezzanine cards */
+        if (!((nvm_data & NVM_COMPAT_LOM) ||
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_DUAL) ||
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD)))
+                goto out;
+
         ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
                                  &nvm_alt_mac_addr_offset);
         if (ret_val) {
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index c3dd590d87b2..e561d15c3eb1 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -2704,6 +2704,16 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         u32 psrctl = 0;
         u32 pages = 0;
 
+        /* Workaround Si errata on 82579 - configure jumbo frame flow */
+        if (hw->mac.type == e1000_pch2lan) {
+                s32 ret_val;
+
+                if (adapter->netdev->mtu > ETH_DATA_LEN)
+                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
+                else
+                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
+        }
+
         /* Program MC offset vector base */
         rctl = er32(RCTL);
         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
@@ -2744,16 +2754,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
                 e1e_wphy(hw, 22, phy_data);
         }
 
-        /* Workaround Si errata on 82579 - configure jumbo frame flow */
-        if (hw->mac.type == e1000_pch2lan) {
-                s32 ret_val;
-
-                if (rctl & E1000_RCTL_LPE)
-                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
-                else
-                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
-        }
-
         /* Setup buffer sizes */
         rctl &= ~E1000_RCTL_SZ_4096;
         rctl |= E1000_RCTL_BSEX;
@@ -4833,6 +4833,15 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
                 return -EINVAL;
         }
 
+        /* Jumbo frame workaround on 82579 requires CRC be stripped */
+        if ((adapter->hw.mac.type == e1000_pch2lan) &&
+            !(adapter->flags2 & FLAG2_CRC_STRIPPING) &&
+            (new_mtu > ETH_DATA_LEN)) {
+                e_err("Jumbo Frames not supported on 82579 when CRC "
+                      "stripping is disabled.\n");
+                return -EINVAL;
+        }
+
         /* 82573 Errata 17 */
         if (((adapter->hw.mac.type == e1000_82573) ||
              (adapter->hw.mac.type == e1000_82574)) &&
@@ -5829,11 +5838,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
 
         e1000_print_device_info(adapter);
 
-        if (pci_dev_run_wake(pdev)) {
-                pm_runtime_set_active(&pdev->dev);
-                pm_runtime_enable(&pdev->dev);
-        }
-        pm_schedule_suspend(&pdev->dev, MSEC_PER_SEC);
+        if (pci_dev_run_wake(pdev))
+                pm_runtime_put_noidle(&pdev->dev);
 
         return 0;
 
@@ -5879,8 +5885,6 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         bool down = test_bit(__E1000_DOWN, &adapter->state);
 
-        pm_runtime_get_sync(&pdev->dev);
-
         /*
          * flush_scheduled work may reschedule our watchdog task, so
          * explicitly disable watchdog tasks from being rescheduled
@@ -5905,11 +5909,8 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
                 clear_bit(__E1000_DOWN, &adapter->state);
         unregister_netdev(netdev);
 
-        if (pci_dev_run_wake(pdev)) {
-                pm_runtime_disable(&pdev->dev);
-                pm_runtime_set_suspended(&pdev->dev);
-        }
-        pm_runtime_put_noidle(&pdev->dev);
+        if (pci_dev_run_wake(pdev))
+                pm_runtime_get_noresume(&pdev->dev);
 
         /*
          * Release control of h/w to f/w.  If f/w is AMT enabled, this
diff --git a/drivers/net/ehea/ehea.h b/drivers/net/ehea/ehea.h
index 0060e422f171..1846623c6ae6 100644
--- a/drivers/net/ehea/ehea.h
+++ b/drivers/net/ehea/ehea.h
@@ -40,7 +40,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "ehea"
-#define DRV_VERSION     "EHEA_0105"
+#define DRV_VERSION     "EHEA_0106"
 
 /* eHEA capability flags */
 #define DLPAR_PORT_ADD_REM 1
@@ -400,6 +400,7 @@ struct ehea_port_res {
         u32 poll_counter;
         struct net_lro_mgr lro_mgr;
         struct net_lro_desc lro_desc[MAX_LRO_DESCRIPTORS];
+        int sq_restart_flag;
 };
 
 
@@ -413,7 +414,7 @@ struct ehea_port_res {
 
 struct ehea_adapter {
         u64 handle;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         struct ehea_port *port[EHEA_MAX_PORTS];
         struct ehea_eq *neq;       /* notification event queue */
         struct tasklet_struct neq_tasklet;
@@ -465,7 +466,7 @@ struct ehea_port {
         struct net_device *netdev;
         struct net_device_stats stats;
         struct ehea_port_res port_res[EHEA_MAX_PORT_RES];
-        struct of_device  ofdev; /* Open Firmware Device */
+        struct platform_device  ofdev; /* Open Firmware Device */
         struct ehea_mc_list *mc_list;    /* Multicast MAC addresses */
         struct vlan_group *vgrp;
         struct ehea_eq *qp_eq;
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index 3beba70b7dea..a333b42111b8 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -107,10 +107,10 @@ struct ehea_fw_handle_array ehea_fw_handles;
 struct ehea_bcmc_reg_array ehea_bcmc_regs;
 
 
-static int __devinit ehea_probe_adapter(struct of_device *dev,
+static int __devinit ehea_probe_adapter(struct platform_device *dev,
                                         const struct of_device_id *id);
 
-static int __devexit ehea_remove(struct of_device *dev);
+static int __devexit ehea_remove(struct platform_device *dev);
 
 static struct of_device_id ehea_device_table[] = {
         {
@@ -776,6 +776,53 @@ static int ehea_proc_rwqes(struct net_device *dev,
         return processed;
 }
 
+#define SWQE_RESTART_CHECK 0xdeadbeaff00d0000ull
+
+static void reset_sq_restart_flag(struct ehea_port *port)
+{
+        int i;
+
+        for (i = 0; i < port->num_def_qps + port->num_add_tx_qps; i++) {
+                struct ehea_port_res *pr = &port->port_res[i];
+                pr->sq_restart_flag = 0;
+        }
+}
+
+static void check_sqs(struct ehea_port *port)
+{
+        struct ehea_swqe *swqe;
+        int swqe_index;
+        int i, k;
+
+        for (i = 0; i < port->num_def_qps + port->num_add_tx_qps; i++) {
+                struct ehea_port_res *pr = &port->port_res[i];
+                k = 0;
+                swqe = ehea_get_swqe(pr->qp, &swqe_index);
+                memset(swqe, 0, SWQE_HEADER_SIZE);
+                atomic_dec(&pr->swqe_avail);
+
+                swqe->tx_control |= EHEA_SWQE_PURGE;
+                swqe->wr_id = SWQE_RESTART_CHECK;
+                swqe->tx_control |= EHEA_SWQE_SIGNALLED_COMPLETION;
+                swqe->tx_control |= EHEA_SWQE_IMM_DATA_PRESENT;
+                swqe->immediate_data_length = 80;
+
+                ehea_post_swqe(pr->qp, swqe);
+
+                while (pr->sq_restart_flag == 0) {
+                        msleep(5);
+                        if (++k == 100) {
+                                ehea_error("HW/SW queues out of sync");
+                                ehea_schedule_port_reset(pr->port);
+                                return;
+                        }
+                }
+        }
+
+        return;
+}
+
+
 static struct ehea_cqe *ehea_proc_cqes(struct ehea_port_res *pr, int my_quota)
 {
         struct sk_buff *skb;
@@ -793,6 +840,13 @@ static struct ehea_cqe *ehea_proc_cqes(struct ehea_port_res *pr, int my_quota)
 
                 cqe_counter++;
                 rmb();
+
+                if (cqe->wr_id == SWQE_RESTART_CHECK) {
+                        pr->sq_restart_flag = 1;
+                        swqe_av++;
+                        break;
+                }
+
                 if (cqe->status & EHEA_CQE_STAT_ERR_MASK) {
                         ehea_error("Bad send completion status=0x%04X",
                                    cqe->status);
@@ -2675,8 +2729,10 @@ static void ehea_flush_sq(struct ehea_port *port)
                 int k = 0;
                 while (atomic_read(&pr->swqe_avail) < swqe_max) {
                         msleep(5);
-                        if (++k == 20)
+                        if (++k == 20) {
+                                ehea_error("WARNING: sq not flushed completely");
                                 break;
+                        }
                 }
         }
 }
@@ -2917,6 +2973,7 @@ static void ehea_rereg_mrs(struct work_struct *work)
                                         port_napi_disable(port);
                                         mutex_unlock(&port->port_lock);
                                 }
+                                reset_sq_restart_flag(port);
                         }
 
                         /* Unregister old memory region */
@@ -2951,6 +3008,7 @@ static void ehea_rereg_mrs(struct work_struct *work)
                                                 mutex_lock(&port->port_lock);
                                                 port_napi_enable(port);
                                                 ret = ehea_restart_qps(dev);
+                                                check_sqs(port);
                                                 if (!ret)
                                                         netif_wake_queue(dev);
                                                 mutex_unlock(&port->port_lock);
@@ -3376,7 +3434,7 @@ static ssize_t ehea_remove_port(struct device *dev,
 static DEVICE_ATTR(probe_port, S_IWUSR, NULL, ehea_probe_port);
 static DEVICE_ATTR(remove_port, S_IWUSR, NULL, ehea_remove_port);
 
-int ehea_create_device_sysfs(struct of_device *dev)
+int ehea_create_device_sysfs(struct platform_device *dev)
 {
         int ret = device_create_file(&dev->dev, &dev_attr_probe_port);
         if (ret)
@@ -3387,13 +3445,13 @@ out:
         return ret;
 }
 
-void ehea_remove_device_sysfs(struct of_device *dev)
+void ehea_remove_device_sysfs(struct platform_device *dev)
 {
         device_remove_file(&dev->dev, &dev_attr_probe_port);
         device_remove_file(&dev->dev, &dev_attr_remove_port);
 }
 
-static int __devinit ehea_probe_adapter(struct of_device *dev,
+static int __devinit ehea_probe_adapter(struct platform_device *dev,
                                         const struct of_device_id *id)
 {
         struct ehea_adapter *adapter;
@@ -3492,7 +3550,7 @@ out:
         return ret;
 }
 
-static int __devexit ehea_remove(struct of_device *dev)
+static int __devexit ehea_remove(struct platform_device *dev)
 {
         struct ehea_adapter *adapter = dev_get_drvdata(&dev->dev);
         int i;
diff --git a/drivers/net/eql.c b/drivers/net/eql.c
index dda2c7944da9..0cb1cf9cf4b0 100644
--- a/drivers/net/eql.c
+++ b/drivers/net/eql.c
@@ -555,6 +555,8 @@ static int eql_g_master_cfg(struct net_device *dev, master_config_t __user *mcp)
         equalizer_t *eql;
         master_config_t mc;
 
+        memset(&mc, 0, sizeof(master_config_t));
+
         if (eql_is_master(dev)) {
                 eql = netdev_priv(dev);
                 mc.max_slaves = eql->max_slaves;
diff --git a/drivers/net/fec_mpc52xx.c b/drivers/net/fec_mpc52xx.c
index d1a5b17b2a95..e3e10b4add9c 100644
--- a/drivers/net/fec_mpc52xx.c
+++ b/drivers/net/fec_mpc52xx.c
@@ -850,7 +850,7 @@ static const struct net_device_ops mpc52xx_fec_netdev_ops = {
 /* ======================================================================== */
 
 static int __devinit
-mpc52xx_fec_probe(struct of_device *op, const struct of_device_id *match)
+mpc52xx_fec_probe(struct platform_device *op, const struct of_device_id *match)
 {
         int rv;
         struct net_device *ndev;
@@ -995,7 +995,7 @@ err_netdev:
 }
 
 static int
-mpc52xx_fec_remove(struct of_device *op)
+mpc52xx_fec_remove(struct platform_device *op)
 {
         struct net_device *ndev;
         struct mpc52xx_fec_priv *priv;
@@ -1025,7 +1025,7 @@ mpc52xx_fec_remove(struct of_device *op)
 }
 
 #ifdef CONFIG_PM
-static int mpc52xx_fec_of_suspend(struct of_device *op, pm_message_t state)
+static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
@@ -1035,7 +1035,7 @@ static int mpc52xx_fec_of_suspend(struct of_device *op, pm_message_t state)
         return 0;
 }
 
-static int mpc52xx_fec_of_resume(struct of_device *op)
+static int mpc52xx_fec_of_resume(struct platform_device *op)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/net/fec_mpc52xx_phy.c b/drivers/net/fec_mpc52xx_phy.c
index dbaf72cbb233..0b4cb6f15984 100644
--- a/drivers/net/fec_mpc52xx_phy.c
+++ b/drivers/net/fec_mpc52xx_phy.c
@@ -61,7 +61,7 @@ static int mpc52xx_fec_mdio_write(struct mii_bus *bus, int phy_id, int reg,
                 data | FEC_MII_WRITE_FRAME);
 }
 
-static int mpc52xx_fec_mdio_probe(struct of_device *of,
+static int mpc52xx_fec_mdio_probe(struct platform_device *of,
                 const struct of_device_id *match)
 {
         struct device *dev = &of->dev;
@@ -122,7 +122,7 @@ static int mpc52xx_fec_mdio_probe(struct of_device *of,
         return err;
 }
 
-static int mpc52xx_fec_mdio_remove(struct of_device *of)
+static int mpc52xx_fec_mdio_remove(struct platform_device *of)
 {
         struct device *dev = &of->dev;
         struct mii_bus *bus = dev_get_drvdata(dev);
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index f08cff9020bd..d6e3111959ab 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -997,7 +997,7 @@ static const struct net_device_ops fs_enet_netdev_ops = {
 #endif
 };
 
-static int __devinit fs_enet_probe(struct of_device *ofdev,
+static int __devinit fs_enet_probe(struct platform_device *ofdev,
                                    const struct of_device_id *match)
 {
         struct net_device *ndev;
@@ -1105,7 +1105,7 @@ out_free_fpi:
         return ret;
 }
 
-static int fs_enet_remove(struct of_device *ofdev)
+static int fs_enet_remove(struct platform_device *ofdev)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct fs_enet_private *fep = netdev_priv(ndev);
diff --git a/drivers/net/fs_enet/mac-fcc.c b/drivers/net/fs_enet/mac-fcc.c
index 48e91b6242ce..7a84e45487e8 100644
--- a/drivers/net/fs_enet/mac-fcc.c
+++ b/drivers/net/fs_enet/mac-fcc.c
@@ -84,7 +84,7 @@ static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 op)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
         struct fs_platform_info *fpi = fep->fpi;
         int ret = -EINVAL;
 
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
index 7ca1642276d0..61035fc5599b 100644
--- a/drivers/net/fs_enet/mac-fec.c
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -96,7 +96,7 @@ static int whack_reset(struct fec __iomem *fecp)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
 
         fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index a3c44544846d..22a02a767069 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -96,7 +96,7 @@ static inline int scc_cr_cmd(struct fs_enet_private *fep, u32 op)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
 
         fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
diff --git a/drivers/net/fs_enet/mii-bitbang.c b/drivers/net/fs_enet/mii-bitbang.c
index 3607340f3da7..3cda2b515471 100644
--- a/drivers/net/fs_enet/mii-bitbang.c
+++ b/drivers/net/fs_enet/mii-bitbang.c
@@ -150,7 +150,7 @@ static int __devinit fs_mii_bitbang_init(struct mii_bus *bus,
         return 0;
 }
 
-static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+static int __devinit fs_enet_mdio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct mii_bus *new_bus;
@@ -200,7 +200,7 @@ out:
         return ret;
 }
 
-static int fs_enet_mdio_remove(struct of_device *ofdev)
+static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
         struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
         struct bb_info *bitbang = bus->priv;
diff --git a/drivers/net/fs_enet/mii-fec.c b/drivers/net/fs_enet/mii-fec.c
index bddffd169b93..dbb9c48623df 100644
--- a/drivers/net/fs_enet/mii-fec.c
+++ b/drivers/net/fs_enet/mii-fec.c
@@ -101,7 +101,7 @@ static int fs_enet_fec_mii_reset(struct mii_bus *bus)
         return 0;
 }
 
-static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+static int __devinit fs_enet_mdio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct resource res;
@@ -192,7 +192,7 @@ out:
         return ret;
 }
 
-static int fs_enet_mdio_remove(struct of_device *ofdev)
+static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
         struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
         struct fec_info *fec = bus->priv;
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index b4c41d72c423..d4bf91aac25f 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -35,6 +35,7 @@
 #include <linux/mii.h>
 #include <linux/phy.h>
 #include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/of_mdio.h>
 #include <linux/of_platform.h>
 
@@ -264,7 +265,7 @@ static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id)
 #endif
 
 
-static int fsl_pq_mdio_probe(struct of_device *ofdev,
+static int fsl_pq_mdio_probe(struct platform_device *ofdev,
                 const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -424,7 +425,7 @@ err_free_priv:
 }
 
 
-static int fsl_pq_mdio_remove(struct of_device *ofdev)
+static int fsl_pq_mdio_remove(struct platform_device *ofdev)
 {
         struct device *device = &ofdev->dev;
         struct mii_bus *bus = dev_get_drvdata(device);
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index a1b6301bc674..4f7c3f3ca234 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -122,9 +122,9 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id);
 static void adjust_link(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int init_phy(struct net_device *dev);
-static int gfar_probe(struct of_device *ofdev,
+static int gfar_probe(struct platform_device *ofdev,
                 const struct of_device_id *match);
-static int gfar_remove(struct of_device *ofdev);
+static int gfar_remove(struct platform_device *ofdev);
 static void free_skb_resources(struct gfar_private *priv);
 static void gfar_set_multi(struct net_device *dev);
 static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr);
@@ -605,7 +605,7 @@ static int gfar_parse_group(struct device_node *np,
         return 0;
 }
 
-static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
+static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
 {
         const char *model;
         const char *ctype;
@@ -959,7 +959,7 @@ static void gfar_detect_errata(struct gfar_private *priv)
 
 /* Set up the ethernet device structure, private data,
  * and anything else we need before we start */
-static int gfar_probe(struct of_device *ofdev,
+static int gfar_probe(struct platform_device *ofdev,
                 const struct of_device_id *match)
 {
         u32 tempval;
@@ -1238,7 +1238,7 @@ register_fail:
         return err;
 }
 
-static int gfar_remove(struct of_device *ofdev)
+static int gfar_remove(struct platform_device *ofdev)
 {
         struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 710810e2adb4..68984eb88ae0 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -1054,7 +1054,7 @@ struct gfar_private {
 
         struct device_node *node;
         struct net_device *ndev;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         enum gfar_errata errata;
 
         struct gfar_priv_grp gfargrp[MAXGROUPS];
diff --git a/drivers/net/greth.c b/drivers/net/greth.c
index 4d09eab3548e..f15c64f1cd38 100644
--- a/drivers/net/greth.c
+++ b/drivers/net/greth.c
@@ -1373,7 +1373,7 @@ error:
 }
 
 /* Initialize the GRETH MAC */
-static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_device_id *match)
+static int __devinit greth_of_probe(struct platform_device *ofdev, const struct of_device_id *match)
 {
         struct net_device *dev;
         struct greth_private *greth;
@@ -1412,7 +1412,7 @@ static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_dev
         }
 
         regs = (struct greth_regs *) greth->regs;
-        greth->irq = ofdev->irqs[0];
+        greth->irq = ofdev->archdata.irqs[0];
 
         dev_set_drvdata(greth->dev, dev);
         SET_NETDEV_DEV(dev, greth->dev);
@@ -1572,7 +1572,7 @@ error1:
         return err;
 }
 
-static int __devexit greth_of_remove(struct of_device *of_dev)
+static int __devexit greth_of_remove(struct platform_device *of_dev)
 {
         struct net_device *ndev = dev_get_drvdata(&of_dev->dev);
         struct greth_private *greth = netdev_priv(ndev);
diff --git a/drivers/net/greth.h b/drivers/net/greth.h
index 973388d6abca..03ad903cd676 100644
--- a/drivers/net/greth.h
+++ b/drivers/net/greth.h
@@ -118,7 +118,7 @@ struct greth_private {
 
         int irq;
 
-        struct device *dev;             /* Pointer to of_device->dev */
+        struct device *dev;             /* Pointer to platform_device->dev */
         struct net_device *netdev;
         struct napi_struct napi;
         spinlock_t devlock;
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index 0f1d4e96cf89..519e19e23955 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -2245,7 +2245,7 @@ static int emac_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
 struct emac_depentry {
         u32                     phandle;
         struct device_node      *node;
-        struct of_device        *ofdev;
+        struct platform_device  *ofdev;
         void                    *drvdata;
 };
 
@@ -2339,11 +2339,11 @@ static int __devinit emac_wait_deps(struct emac_instance *dev)
                 deps[EMAC_DEP_MDIO_IDX].phandle = dev->mdio_ph;
         if (dev->blist && dev->blist > emac_boot_list)
                 deps[EMAC_DEP_PREV_IDX].phandle = 0xffffffffu;
-        bus_register_notifier(&of_platform_bus_type, &emac_of_bus_notifier);
+        bus_register_notifier(&platform_bus_type, &emac_of_bus_notifier);
         wait_event_timeout(emac_probe_wait,
                            emac_check_deps(dev, deps),
                            EMAC_PROBE_DEP_TIMEOUT);
-        bus_unregister_notifier(&of_platform_bus_type, &emac_of_bus_notifier);
+        bus_unregister_notifier(&platform_bus_type, &emac_of_bus_notifier);
         err = emac_check_deps(dev, deps) ? 0 : -ENODEV;
         for (i = 0; i < EMAC_DEP_COUNT; i++) {
                 if (deps[i].node)
@@ -2719,7 +2719,7 @@ static const struct net_device_ops emac_gige_netdev_ops = {
         .ndo_change_mtu         = emac_change_mtu,
 };
 
-static int __devinit emac_probe(struct of_device *ofdev,
+static int __devinit emac_probe(struct platform_device *ofdev,
                                 const struct of_device_id *match)
 {
         struct net_device *ndev;
@@ -2928,7 +2928,7 @@ static int __devinit emac_probe(struct of_device *ofdev,
         if (dev->emac_irq != NO_IRQ)
                 irq_dispose_mapping(dev->emac_irq);
  err_free:
-        kfree(ndev);
+        free_netdev(ndev);
  err_gone:
         /* if we were on the bootlist, remove us as we won't show up and
          * wake up all waiters to notify them in case they were waiting
@@ -2941,7 +2941,7 @@ static int __devinit emac_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit emac_remove(struct of_device *ofdev)
+static int __devexit emac_remove(struct platform_device *ofdev)
 {
         struct emac_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -2971,7 +2971,7 @@ static int __devexit emac_remove(struct of_device *ofdev)
         if (dev->emac_irq != NO_IRQ)
                 irq_dispose_mapping(dev->emac_irq);
 
-        kfree(dev->ndev);
+        free_netdev(dev->ndev);
 
         return 0;
 }
diff --git a/drivers/net/ibm_newemac/core.h b/drivers/net/ibm_newemac/core.h
index b1cbe6fdfc7a..9e37e3d9c51d 100644
--- a/drivers/net/ibm_newemac/core.h
+++ b/drivers/net/ibm_newemac/core.h
@@ -170,12 +170,12 @@ struct emac_instance {
         struct net_device               *ndev;
         struct resource                 rsrc_regs;
         struct emac_regs                __iomem *emacp;
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
         struct device_node              **blist; /* bootlist entry */
 
         /* MAL linkage */
         u32                             mal_ph;
-        struct of_device                *mal_dev;
+        struct platform_device          *mal_dev;
         u32                             mal_rx_chan;
         u32                             mal_tx_chan;
         struct mal_instance             *mal;
@@ -196,24 +196,24 @@ struct emac_instance {
 
         /* Shared MDIO if any */
         u32                             mdio_ph;
-        struct of_device                *mdio_dev;
+        struct platform_device          *mdio_dev;
         struct emac_instance            *mdio_instance;
         struct mutex                    mdio_lock;
 
         /* ZMII infos if any */
         u32                             zmii_ph;
         u32                             zmii_port;
-        struct of_device                *zmii_dev;
+        struct platform_device          *zmii_dev;
 
         /* RGMII infos if any */
         u32                             rgmii_ph;
         u32                             rgmii_port;
-        struct of_device                *rgmii_dev;
+        struct platform_device          *rgmii_dev;
 
         /* TAH infos if any */
         u32                             tah_ph;
         u32                             tah_port;
-        struct of_device                *tah_dev;
+        struct platform_device          *tah_dev;
 
         /* IRQs */
         int                             wol_irq;
diff --git a/drivers/net/ibm_newemac/debug.c b/drivers/net/ibm_newemac/debug.c
index 3995fafc1e08..8c6c1e2a8750 100644
--- a/drivers/net/ibm_newemac/debug.c
+++ b/drivers/net/ibm_newemac/debug.c
@@ -238,7 +238,7 @@ void emac_dbg_dump_all(void)
 }
 
 #if defined(CONFIG_MAGIC_SYSRQ)
-static void emac_sysrq_handler(int key, struct tty_struct *tty)
+static void emac_sysrq_handler(int key)
 {
         emac_dbg_dump_all();
 }
diff --git a/drivers/net/ibm_newemac/mal.c b/drivers/net/ibm_newemac/mal.c
index fcff9e0bd382..d5717e2123e1 100644
--- a/drivers/net/ibm_newemac/mal.c
+++ b/drivers/net/ibm_newemac/mal.c
@@ -517,7 +517,7 @@ void *mal_dump_regs(struct mal_instance *mal, void *buf)
         return regs + 1;
 }
 
-static int __devinit mal_probe(struct of_device *ofdev,
+static int __devinit mal_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         struct mal_instance *mal;
@@ -730,7 +730,7 @@ static int __devinit mal_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit mal_remove(struct of_device *ofdev)
+static int __devexit mal_remove(struct platform_device *ofdev)
 {
         struct mal_instance *mal = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/mal.h b/drivers/net/ibm_newemac/mal.h
index 9ededfbf0726..66084214bf45 100644
--- a/drivers/net/ibm_newemac/mal.h
+++ b/drivers/net/ibm_newemac/mal.h
@@ -210,7 +210,7 @@ struct mal_instance {
         dma_addr_t              bd_dma;
         struct mal_descriptor   *bd_virt;
 
-        struct of_device        *ofdev;
+        struct platform_device  *ofdev;
         int                     index;
         spinlock_t              lock;
 
diff --git a/drivers/net/ibm_newemac/rgmii.c b/drivers/net/ibm_newemac/rgmii.c
index 108919bcdf13..dd61798897ac 100644
--- a/drivers/net/ibm_newemac/rgmii.c
+++ b/drivers/net/ibm_newemac/rgmii.c
@@ -93,7 +93,7 @@ static inline u32 rgmii_mode_mask(int mode, int input)
         }
 }
 
-int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
+int __devinit rgmii_attach(struct platform_device *ofdev, int input, int mode)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -122,7 +122,7 @@ int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
         return 0;
 }
 
-void rgmii_set_speed(struct of_device *ofdev, int input, int speed)
+void rgmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -144,7 +144,7 @@ void rgmii_set_speed(struct of_device *ofdev, int input, int speed)
         mutex_unlock(&dev->lock);
 }
 
-void rgmii_get_mdio(struct of_device *ofdev, int input)
+void rgmii_get_mdio(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -165,7 +165,7 @@ void rgmii_get_mdio(struct of_device *ofdev, int input)
         DBG2(dev, " fer = 0x%08x\n", fer);
 }
 
-void rgmii_put_mdio(struct of_device *ofdev, int input)
+void rgmii_put_mdio(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -186,7 +186,7 @@ void rgmii_put_mdio(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-void rgmii_detach(struct of_device *ofdev, int input)
+void rgmii_detach(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p;
@@ -206,13 +206,13 @@ void rgmii_detach(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-int rgmii_get_regs_len(struct of_device *ofdev)
+int rgmii_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct rgmii_regs);
 }
 
-void *rgmii_dump_regs(struct of_device *ofdev, void *buf)
+void *rgmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -228,7 +228,7 @@ void *rgmii_dump_regs(struct of_device *ofdev, void *buf)
 }
 
 
-static int __devinit rgmii_probe(struct of_device *ofdev,
+static int __devinit rgmii_probe(struct platform_device *ofdev,
                                  const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -293,7 +293,7 @@ static int __devinit rgmii_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit rgmii_remove(struct of_device *ofdev)
+static int __devexit rgmii_remove(struct platform_device *ofdev)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/rgmii.h b/drivers/net/ibm_newemac/rgmii.h
index c4a4b358a270..d69799049865 100644
--- a/drivers/net/ibm_newemac/rgmii.h
+++ b/drivers/net/ibm_newemac/rgmii.h
@@ -51,20 +51,20 @@ struct rgmii_instance {
         int                             users;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 #ifdef CONFIG_IBM_NEW_EMAC_RGMII
 
 extern int rgmii_init(void);
 extern void rgmii_exit(void);
-extern int rgmii_attach(struct of_device *ofdev, int input, int mode);
-extern void rgmii_detach(struct of_device *ofdev, int input);
-extern void rgmii_get_mdio(struct of_device *ofdev, int input);
-extern void rgmii_put_mdio(struct of_device *ofdev, int input);
-extern void rgmii_set_speed(struct of_device *ofdev, int input, int speed);
-extern int rgmii_get_regs_len(struct of_device *ofdev);
-extern void *rgmii_dump_regs(struct of_device *ofdev, void *buf);
+extern int rgmii_attach(struct platform_device *ofdev, int input, int mode);
+extern void rgmii_detach(struct platform_device *ofdev, int input);
+extern void rgmii_get_mdio(struct platform_device *ofdev, int input);
+extern void rgmii_put_mdio(struct platform_device *ofdev, int input);
+extern void rgmii_set_speed(struct platform_device *ofdev, int input, int speed);
+extern int rgmii_get_regs_len(struct platform_device *ofdev);
+extern void *rgmii_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 
diff --git a/drivers/net/ibm_newemac/tah.c b/drivers/net/ibm_newemac/tah.c
index 044637144c43..299aa49490c0 100644
--- a/drivers/net/ibm_newemac/tah.c
+++ b/drivers/net/ibm_newemac/tah.c
@@ -23,7 +23,7 @@
 #include "emac.h"
 #include "core.h"
 
-int __devinit tah_attach(struct of_device *ofdev, int channel)
+int __devinit tah_attach(struct platform_device *ofdev, int channel)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -35,7 +35,7 @@ int __devinit tah_attach(struct of_device *ofdev, int channel)
         return 0;
 }
 
-void tah_detach(struct of_device *ofdev, int channel)
+void tah_detach(struct platform_device *ofdev, int channel)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -44,7 +44,7 @@ void tah_detach(struct of_device *ofdev, int channel)
         mutex_unlock(&dev->lock);
 }
 
-void tah_reset(struct of_device *ofdev)
+void tah_reset(struct platform_device *ofdev)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct tah_regs __iomem *p = dev->base;
@@ -66,13 +66,13 @@ void tah_reset(struct of_device *ofdev)
                  TAH_MR_DIG);
 }
 
-int tah_get_regs_len(struct of_device *ofdev)
+int tah_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct tah_regs);
 }
 
-void *tah_dump_regs(struct of_device *ofdev, void *buf)
+void *tah_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -87,7 +87,7 @@ void *tah_dump_regs(struct of_device *ofdev, void *buf)
         return regs + 1;
 }
 
-static int __devinit tah_probe(struct of_device *ofdev,
+static int __devinit tah_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -139,7 +139,7 @@ static int __devinit tah_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit tah_remove(struct of_device *ofdev)
+static int __devexit tah_remove(struct platform_device *ofdev)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/tah.h b/drivers/net/ibm_newemac/tah.h
index a068b5658dad..61dbeca006d1 100644
--- a/drivers/net/ibm_newemac/tah.h
+++ b/drivers/net/ibm_newemac/tah.h
@@ -48,7 +48,7 @@ struct tah_instance {
         int                             users;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 
@@ -74,11 +74,11 @@ struct tah_instance {
 
 extern int tah_init(void);
 extern void tah_exit(void);
-extern int tah_attach(struct of_device *ofdev, int channel);
-extern void tah_detach(struct of_device *ofdev, int channel);
-extern void tah_reset(struct of_device *ofdev);
-extern int tah_get_regs_len(struct of_device *ofdev);
-extern void *tah_dump_regs(struct of_device *ofdev, void *buf);
+extern int tah_attach(struct platform_device *ofdev, int channel);
+extern void tah_detach(struct platform_device *ofdev, int channel);
+extern void tah_reset(struct platform_device *ofdev);
+extern int tah_get_regs_len(struct platform_device *ofdev);
+extern void *tah_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 
diff --git a/drivers/net/ibm_newemac/zmii.c b/drivers/net/ibm_newemac/zmii.c
index 046dcd069c45..34ed6ee8ca8a 100644
--- a/drivers/net/ibm_newemac/zmii.c
+++ b/drivers/net/ibm_newemac/zmii.c
@@ -82,7 +82,7 @@ static inline u32 zmii_mode_mask(int mode, int input)
         }
 }
 
-int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode)
+int __devinit zmii_attach(struct platform_device *ofdev, int input, int *mode)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct zmii_regs __iomem *p = dev->base;
@@ -148,7 +148,7 @@ int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode)
         return 0;
 }
 
-void zmii_get_mdio(struct of_device *ofdev, int input)
+void zmii_get_mdio(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         u32 fer;
@@ -161,7 +161,7 @@ void zmii_get_mdio(struct of_device *ofdev, int input)
         out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input));
 }
 
-void zmii_put_mdio(struct of_device *ofdev, int input)
+void zmii_put_mdio(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -170,7 +170,7 @@ void zmii_put_mdio(struct of_device *ofdev, int input)
 }
 
 
-void zmii_set_speed(struct of_device *ofdev, int input, int speed)
+void zmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         u32 ssr;
@@ -191,7 +191,7 @@ void zmii_set_speed(struct of_device *ofdev, int input, int speed)
         mutex_unlock(&dev->lock);
 }
 
-void zmii_detach(struct of_device *ofdev, int input)
+void zmii_detach(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -210,13 +210,13 @@ void zmii_detach(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-int zmii_get_regs_len(struct of_device *ofdev)
+int zmii_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct zmii_regs);
 }
 
-void *zmii_dump_regs(struct of_device *ofdev, void *buf)
+void *zmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -231,7 +231,7 @@ void *zmii_dump_regs(struct of_device *ofdev, void *buf)
         return regs + 1;
 }
 
-static int __devinit zmii_probe(struct of_device *ofdev,
+static int __devinit zmii_probe(struct platform_device *ofdev,
                                 const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -286,7 +286,7 @@ static int __devinit zmii_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit zmii_remove(struct of_device *ofdev)
+static int __devexit zmii_remove(struct platform_device *ofdev)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/zmii.h b/drivers/net/ibm_newemac/zmii.h
index 6c9beba0c4b6..1333fa2b2781 100644
--- a/drivers/net/ibm_newemac/zmii.h
+++ b/drivers/net/ibm_newemac/zmii.h
@@ -48,20 +48,20 @@ struct zmii_instance {
         u32                             fer_save;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 #ifdef CONFIG_IBM_NEW_EMAC_ZMII
 
 extern int zmii_init(void);
 extern void zmii_exit(void);
-extern int zmii_attach(struct of_device *ofdev, int input, int *mode);
-extern void zmii_detach(struct of_device *ofdev, int input);
-extern void zmii_get_mdio(struct of_device *ofdev, int input);
-extern void zmii_put_mdio(struct of_device *ofdev, int input);
-extern void zmii_set_speed(struct of_device *ofdev, int input, int speed);
-extern int zmii_get_regs_len(struct of_device *ocpdev);
-extern void *zmii_dump_regs(struct of_device *ofdev, void *buf);
+extern int zmii_attach(struct platform_device *ofdev, int input, int *mode);
+extern void zmii_detach(struct platform_device *ofdev, int input);
+extern void zmii_get_mdio(struct platform_device *ofdev, int input);
+extern void zmii_put_mdio(struct platform_device *ofdev, int input);
+extern void zmii_set_speed(struct platform_device *ofdev, int input, int speed);
+extern int zmii_get_regs_len(struct platform_device *ocpdev);
+extern void *zmii_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 # define zmii_init()            0
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index 2602852cc55a..4734c939ad03 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -1113,7 +1113,8 @@ static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
         struct ibmveth_adapter *adapter = netdev_priv(dev);
         struct vio_dev *viodev = adapter->vdev;
         int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
-        int i;
+        int i, rc;
+        int need_restart = 0;
 
         if (new_mtu < IBMVETH_MAX_MTU)
                 return -EINVAL;
@@ -1127,35 +1128,32 @@ static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
 
         /* Deactivate all the buffer pools so that the next loop can activate
            only the buffer pools necessary to hold the new MTU */
-        for (i = 0; i < IbmVethNumBufferPools; i++)
-                if (adapter->rx_buff_pool[i].active) {
-                        ibmveth_free_buffer_pool(adapter,
-                                                 &adapter->rx_buff_pool[i]);
-                        adapter->rx_buff_pool[i].active = 0;
-                }
+        if (netif_running(adapter->netdev)) {
+                need_restart = 1;
+                adapter->pool_config = 1;
+                ibmveth_close(adapter->netdev);
+                adapter->pool_config = 0;
+        }
 
         /* Look for an active buffer pool that can hold the new MTU */
         for(i = 0; i<IbmVethNumBufferPools; i++) {
                 adapter->rx_buff_pool[i].active = 1;
 
                 if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) {
-                        if (netif_running(adapter->netdev)) {
-                                adapter->pool_config = 1;
-                                ibmveth_close(adapter->netdev);
-                                adapter->pool_config = 0;
-                                dev->mtu = new_mtu;
-                                vio_cmo_set_dev_desired(viodev,
-                                                ibmveth_get_desired_dma
-                                                (viodev));
-                                return ibmveth_open(adapter->netdev);
-                        }
                         dev->mtu = new_mtu;
                         vio_cmo_set_dev_desired(viodev,
                                                 ibmveth_get_desired_dma
                                                 (viodev));
+                        if (need_restart) {
+                                return ibmveth_open(adapter->netdev);
+                        }
                         return 0;
                 }
         }
+
+        if (need_restart && (rc = ibmveth_open(adapter->netdev)))
+                return rc;
+
         return -EINVAL;
 }
 
diff --git a/drivers/net/irda/sh_irda.c b/drivers/net/irda/sh_irda.c
index edd5666f0ffb..9e3f4f54281d 100644
--- a/drivers/net/irda/sh_irda.c
+++ b/drivers/net/irda/sh_irda.c
@@ -748,7 +748,6 @@ static int __devinit sh_irda_probe(struct platform_device *pdev)
         struct net_device *ndev;
         struct sh_irda_self *self;
         struct resource *res;
-        char clk_name[8];
         int irq;
         int err = -ENOMEM;
 
@@ -775,10 +774,9 @@ static int __devinit sh_irda_probe(struct platform_device *pdev)
         if (err)
                 goto err_mem_2;
 
-        snprintf(clk_name, sizeof(clk_name), "irda%d", pdev->id);
-        self->clk = clk_get(&pdev->dev, clk_name);
+        self->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(self->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
+                dev_err(&pdev->dev, "cannot get irda clock\n");
                 goto err_mem_3;
         }
 
diff --git a/drivers/net/ks8851.c b/drivers/net/ks8851.c
index b4fb07a6f13f..51919fcd50c2 100644
--- a/drivers/net/ks8851.c
+++ b/drivers/net/ks8851.c
@@ -503,30 +503,33 @@ static void ks8851_rx_pkts(struct ks8851_net *ks)
                 ks8851_wrreg16(ks, KS_RXQCR,
                                ks->rc_rxqcr | RXQCR_SDA | RXQCR_ADRFE);
 
-                if (rxlen > 0) {
-                        skb = netdev_alloc_skb(ks->netdev, rxlen + 2 + 8);
-                        if (!skb) {
-                                /* todo - dump frame and move on */
-                        }
+                if (rxlen > 4) {
+                        unsigned int rxalign;
+
+                        rxlen -= 4;
+                        rxalign = ALIGN(rxlen, 4);
+                        skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);
+                        if (skb) {
 
-                        /* two bytes to ensure ip is aligned, and four bytes
-                         * for the status header and 4 bytes of garbage */
-                        skb_reserve(skb, 2 + 4 + 4);
+                                /* 4 bytes of status header + 4 bytes of
+                                 * garbage: we put them before ethernet
+                                 * header, so that they are copied,
+                                 * but ignored.
+                                 */
 
-                        rxpkt = skb_put(skb, rxlen - 4) - 8;
+                                rxpkt = skb_put(skb, rxlen) - 8;
 
-                        /* align the packet length to 4 bytes, and add 4 bytes
-                         * as we're getting the rx status header as well */
-                        ks8851_rdfifo(ks, rxpkt, ALIGN(rxlen, 4) + 8);
+                                ks8851_rdfifo(ks, rxpkt, rxalign + 8);
 
-                        if (netif_msg_pktdata(ks))
-                                ks8851_dbg_dumpkkt(ks, rxpkt);
+                                if (netif_msg_pktdata(ks))
+                                        ks8851_dbg_dumpkkt(ks, rxpkt);
 
-                        skb->protocol = eth_type_trans(skb, ks->netdev);
-                        netif_rx(skb);
+                                skb->protocol = eth_type_trans(skb, ks->netdev);
+                                netif_rx(skb);
 
-                        ks->netdev->stats.rx_packets++;
-                        ks->netdev->stats.rx_bytes += rxlen - 4;
+                                ks->netdev->stats.rx_packets++;
+                                ks->netdev->stats.rx_bytes += rxlen;
+                        }
                 }
 
                 ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 4eea3f70c5cf..bdf2149e5296 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -159,7 +159,7 @@ static void temac_dma_dcr_out(struct temac_local *lp, int reg, u32 value)
  * temac_dcr_setup - If the DMA is DCR based, then setup the address and
  * I/O  functions
  */
-static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
+static int temac_dcr_setup(struct temac_local *lp, struct platform_device *op,
                                 struct device_node *np)
 {
         unsigned int dcrs;
@@ -184,7 +184,7 @@ static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
  * temac_dcr_setup - This is a stub for when DCR is not supported,
  * such as with MicroBlaze
  */
-static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
+static int temac_dcr_setup(struct temac_local *lp, struct platform_device *op,
                                 struct device_node *np)
 {
         return -1;
@@ -902,8 +902,8 @@ temac_poll_controller(struct net_device *ndev)
         disable_irq(lp->tx_irq);
         disable_irq(lp->rx_irq);
 
-        ll_temac_rx_irq(lp->tx_irq, lp);
-        ll_temac_tx_irq(lp->rx_irq, lp);
+        ll_temac_rx_irq(lp->tx_irq, ndev);
+        ll_temac_tx_irq(lp->rx_irq, ndev);
 
         enable_irq(lp->tx_irq);
         enable_irq(lp->rx_irq);
@@ -952,7 +952,7 @@ static const struct attribute_group temac_attr_group = {
 };
 
 static int __init
-temac_of_probe(struct of_device *op, const struct of_device_id *match)
+temac_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *np;
         struct temac_local *lp;
@@ -1094,7 +1094,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         return rc;
 }
 
-static int __devexit temac_of_remove(struct of_device *op)
+static int __devexit temac_of_remove(struct platform_device *op)
 {
         struct net_device *ndev = dev_get_drvdata(&op->dev);
         struct temac_local *lp = netdev_priv(ndev);
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index d771d1650d60..fb2c0927d3cc 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -239,6 +239,7 @@ struct myri10ge_priv {
         int watchdog_resets;
         int watchdog_pause;
         int pause;
+        bool fw_name_allocated;
         char *fw_name;
         char eeprom_strings[MYRI10GE_EEPROM_STRINGS_SIZE];
         char *product_code_string;
@@ -271,6 +272,7 @@ MODULE_FIRMWARE("myri10ge_eth_z8e.dat");
 MODULE_FIRMWARE("myri10ge_rss_ethp_z8e.dat");
 MODULE_FIRMWARE("myri10ge_rss_eth_z8e.dat");
 
+/* Careful: must be accessed under kparam_block_sysfs_write */
 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");
@@ -376,6 +378,14 @@ static inline void put_be32(__be32 val, __be32 __iomem * p)
 
 static struct net_device_stats *myri10ge_get_stats(struct net_device *dev);
 
+static void set_fw_name(struct myri10ge_priv *mgp, char *name, bool allocated)
+{
+        if (mgp->fw_name_allocated)
+                kfree(mgp->fw_name);
+        mgp->fw_name = name;
+        mgp->fw_name_allocated = allocated;
+}
+
 static int
 myri10ge_send_cmd(struct myri10ge_priv *mgp, u32 cmd,
                   struct myri10ge_cmd *data, int atomic)
@@ -747,7 +757,7 @@ static int myri10ge_load_firmware(struct myri10ge_priv *mgp, int adopt)
                         dev_warn(&mgp->pdev->dev, "via hotplug\n");
                 }
 
-                mgp->fw_name = "adopted";
+                set_fw_name(mgp, "adopted", false);
                 mgp->tx_boundary = 2048;
                 myri10ge_dummy_rdma(mgp, 1);
                 status = myri10ge_get_firmware_capabilities(mgp);
@@ -3233,7 +3243,7 @@ static void myri10ge_firmware_probe(struct myri10ge_priv *mgp)
          * load the optimized firmware (which assumes aligned PCIe
          * completions) in order to see if it works on this host.
          */
-        mgp->fw_name = myri10ge_fw_aligned;
+        set_fw_name(mgp, myri10ge_fw_aligned, false);
         status = myri10ge_load_firmware(mgp, 1);
         if (status != 0) {
                 goto abort;
@@ -3261,7 +3271,7 @@ static void myri10ge_firmware_probe(struct myri10ge_priv *mgp)
 abort:
         /* fall back to using the unaligned firmware */
         mgp->tx_boundary = 2048;
-        mgp->fw_name = myri10ge_fw_unaligned;
+        set_fw_name(mgp, myri10ge_fw_unaligned, false);
 
 }
 
@@ -3284,7 +3294,7 @@ static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
                         dev_info(&mgp->pdev->dev, "PCIE x%d Link\n",
                                  link_width);
                         mgp->tx_boundary = 4096;
-                        mgp->fw_name = myri10ge_fw_aligned;
+                        set_fw_name(mgp, myri10ge_fw_aligned, false);
                 } else {
                         myri10ge_firmware_probe(mgp);
                 }
@@ -3293,22 +3303,29 @@ static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
                         dev_info(&mgp->pdev->dev,
                                  "Assuming aligned completions (forced)\n");
                         mgp->tx_boundary = 4096;
-                        mgp->fw_name = myri10ge_fw_aligned;
+                        set_fw_name(mgp, myri10ge_fw_aligned, false);
                 } else {
                         dev_info(&mgp->pdev->dev,
                                  "Assuming unaligned completions (forced)\n");
                         mgp->tx_boundary = 2048;
-                        mgp->fw_name = myri10ge_fw_unaligned;
+                        set_fw_name(mgp, myri10ge_fw_unaligned, false);
                 }
         }
+
+        kparam_block_sysfs_write(myri10ge_fw_name);
         if (myri10ge_fw_name != NULL) {
-                overridden = 1;
-                mgp->fw_name = myri10ge_fw_name;
+                char *fw_name = kstrdup(myri10ge_fw_name, GFP_KERNEL);
+                if (fw_name) {
+                        overridden = 1;
+                        set_fw_name(mgp, fw_name, true);
+                }
         }
+        kparam_unblock_sysfs_write(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];
+                set_fw_name(mgp, myri10ge_fw_names[mgp->board_number], false);
                 overridden = 1;
         }
         if (overridden)
@@ -3660,6 +3677,7 @@ static void myri10ge_probe_slices(struct myri10ge_priv *mgp)
         struct myri10ge_cmd cmd;
         struct pci_dev *pdev = mgp->pdev;
         char *old_fw;
+        bool old_allocated;
         int i, status, ncpus, msix_cap;
 
         mgp->num_slices = 1;
@@ -3672,17 +3690,23 @@ static void myri10ge_probe_slices(struct myri10ge_priv *mgp)
 
         /* try to load the slice aware rss firmware */
         old_fw = mgp->fw_name;
+        old_allocated = mgp->fw_name_allocated;
+        /* don't free old_fw if we override it. */
+        mgp->fw_name_allocated = false;
+
         if (myri10ge_fw_name != NULL) {
                 dev_info(&mgp->pdev->dev, "overriding rss firmware to %s\n",
                          myri10ge_fw_name);
-                mgp->fw_name = myri10ge_fw_name;
+                set_fw_name(mgp, myri10ge_fw_name, false);
         } else if (old_fw == myri10ge_fw_aligned)
-                mgp->fw_name = myri10ge_fw_rss_aligned;
+                set_fw_name(mgp, myri10ge_fw_rss_aligned, false);
         else
-                mgp->fw_name = myri10ge_fw_rss_unaligned;
+                set_fw_name(mgp, myri10ge_fw_rss_unaligned, false);
         status = myri10ge_load_firmware(mgp, 0);
         if (status != 0) {
                 dev_info(&pdev->dev, "Rss firmware not found\n");
+                if (old_allocated)
+                        kfree(old_fw);
                 return;
         }
 
@@ -3747,6 +3771,8 @@ static void myri10ge_probe_slices(struct myri10ge_priv *mgp)
                                          mgp->num_slices);
                 if (status == 0) {
                         pci_disable_msix(pdev);
+                        if (old_allocated)
+                                kfree(old_fw);
                         return;
                 }
                 if (status > 0)
@@ -3763,7 +3789,7 @@ disable_msix:
 
 abort_with_fw:
         mgp->num_slices = 1;
-        mgp->fw_name = old_fw;
+        set_fw_name(mgp, old_fw, old_allocated);
         myri10ge_load_firmware(mgp, 0);
 }
 
@@ -3993,6 +4019,7 @@ abort_with_enabled:
         pci_disable_device(pdev);
 
 abort_with_netdev:
+        set_fw_name(mgp, NULL, false);
         free_netdev(netdev);
         return status;
 }
@@ -4037,6 +4064,7 @@ static void myri10ge_remove(struct pci_dev *pdev)
         dma_free_coherent(&pdev->dev, sizeof(*mgp->cmd),
                           mgp->cmd, mgp->cmd_bus);
 
+        set_fw_name(mgp, NULL, false);
         free_netdev(netdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index 1a57c3da1f49..617f898ba5f0 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -926,7 +926,7 @@ static const struct net_device_ops myri_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit myri_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit myri_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
@@ -1079,7 +1079,7 @@ static int __devinit myri_sbus_probe(struct of_device *op, const struct of_devic
 
         mp->dev = dev;
         dev->watchdog_timeo = 5*HZ;
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
         dev->netdev_ops = &myri_ops;
 
         /* Register interrupt handler now. */
@@ -1124,7 +1124,7 @@ err:
         return -ENODEV;
 }
 
-static int __devexit myri_sbus_remove(struct of_device *op)
+static int __devexit myri_sbus_remove(struct platform_device *op)
 {
         struct myri_eth *mp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = mp->dev;
@@ -1172,12 +1172,12 @@ static struct of_platform_driver myri_sbus_driver = {
 
 static int __init myri_sbus_init(void)
 {
-        return of_register_driver(&myri_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&myri_sbus_driver);
 }
 
 static void __exit myri_sbus_exit(void)
 {
-        of_unregister_driver(&myri_sbus_driver);
+        of_unregister_platform_driver(&myri_sbus_driver);
 }
 
 module_init(myri_sbus_init);
diff --git a/drivers/net/myri_sbus.h b/drivers/net/myri_sbus.h
index ff363e95d9cf..80a2fa5cf757 100644
--- a/drivers/net/myri_sbus.h
+++ b/drivers/net/myri_sbus.h
@@ -288,7 +288,7 @@ struct myri_eth {
         struct myri_eeprom              eeprom;         /* Local copy of EEPROM.      */
         unsigned int                    reg_size;       /* Size of register space.    */
         unsigned int                    shmem_base;     /* Offset to shared ram.      */
-        struct of_device                *myri_op;       /* Our OF device struct.    */
+        struct platform_device          *myri_op;       /* Our OF device struct.    */
 };
 
 /* We use this to acquire receive skb's that we can DMA directly into. */
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index ffa1b9ce1cc5..6dca3574e355 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -53,8 +53,8 @@
 
 #define _NETXEN_NIC_LINUX_MAJOR 4
 #define _NETXEN_NIC_LINUX_MINOR 0
-#define _NETXEN_NIC_LINUX_SUBVERSION 73
-#define NETXEN_NIC_LINUX_VERSIONID  "4.0.73"
+#define _NETXEN_NIC_LINUX_SUBVERSION 74
+#define NETXEN_NIC_LINUX_VERSIONID  "4.0.74"
 
 #define NETXEN_VERSION_CODE(a, b, c)    (((a) << 24) + ((b) << 16) + (c))
 #define _major(v)       (((v) >> 24) & 0xff)
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index c865dda2adf1..b075a35b85d4 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -1540,7 +1540,6 @@ netxen_process_rcv(struct netxen_adapter *adapter,
         if (pkt_offset)
                 skb_pull(skb, pkt_offset);
 
-        skb->truesize = skb->len + sizeof(struct sk_buff);
         skb->protocol = eth_type_trans(skb, netdev);
 
         napi_gro_receive(&sds_ring->napi, skb);
@@ -1602,8 +1601,6 @@ netxen_process_lro(struct netxen_adapter *adapter,
 
         skb_put(skb, lro_length + data_offset);
 
-        skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb);
-
         skb_pull(skb, l2_hdr_offset);
         skb->protocol = eth_type_trans(skb, netdev);
 
@@ -1805,8 +1802,6 @@ netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
         netxen_ctx_msg msg = 0;
         struct list_head *head;
 
-        spin_lock(&rds_ring->lock);
-
         producer = rds_ring->producer;
 
         head = &rds_ring->free_list;
@@ -1853,8 +1848,6 @@ netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
                                         NETXEN_RCV_PRODUCER_OFFSET), msg);
                 }
         }
-
-        spin_unlock(&rds_ring->lock);
 }
 
 static void
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index fd86e18604e6..73d314592230 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -2032,8 +2032,6 @@ struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
         struct netxen_adapter *adapter = netdev_priv(netdev);
         struct net_device_stats *stats = &netdev->stats;
 
-        memset(stats, 0, sizeof(*stats));
-
         stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
         stats->tx_packets = adapter->stats.xmitfinished;
         stats->rx_bytes = adapter->stats.rxbytes;
@@ -2133,9 +2131,16 @@ static int netxen_nic_poll(struct napi_struct *napi, int budget)
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void netxen_nic_poll_controller(struct net_device *netdev)
 {
+        int ring;
+        struct nx_host_sds_ring *sds_ring;
         struct netxen_adapter *adapter = netdev_priv(netdev);
+        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
+
         disable_irq(adapter->irq);
-        netxen_intr(adapter->irq, adapter);
+        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
+                sds_ring = &recv_ctx->sds_rings[ring];
+                netxen_intr(adapter->irq, sds_ring);
+        }
         enable_irq(adapter->irq);
 }
 #endif
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index b9b950845b0e..fe6983af6918 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -28,10 +28,7 @@
 #include <linux/slab.h>
 
 #include <linux/io.h>
-
-#ifdef CONFIG_SPARC64
 #include <linux/of_device.h>
-#endif
 
 #include "niu.h"
 
@@ -7272,32 +7269,28 @@ static int niu_get_ethtool_tcam_all(struct niu *np,
         struct niu_parent *parent = np->parent;
         struct niu_tcam_entry *tp;
         int i, idx, cnt;
-        u16 n_entries;
         unsigned long flags;
-
+        int ret = 0;
 
         /* put the tcam size here */
         nfc->data = tcam_get_size(np);
 
         niu_lock_parent(np, flags);
-        n_entries = nfc->rule_cnt;
         for (cnt = 0, i = 0; i < nfc->data; i++) {
                 idx = tcam_get_index(np, i);
                 tp = &parent->tcam[idx];
                 if (!tp->valid)
                         continue;
+                if (cnt == nfc->rule_cnt) {
+                        ret = -EMSGSIZE;
+                        break;
+                }
                 rule_locs[cnt] = i;
                 cnt++;
         }
         niu_unlock_parent(np, flags);
 
-        if (n_entries != cnt) {
-                /* print warning, this should not happen */
-                netdev_info(np->dev, "niu%d: In %s(): n_entries[%d] != cnt[%d]!!!\n",
-                            np->parent->index, __func__, n_entries, cnt);
-        }
-
-        return 0;
+        return ret;
 }
 
 static int niu_get_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
@@ -9106,7 +9099,7 @@ retry:
 static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
 {
 #ifdef CONFIG_SPARC64
-        struct of_device *op = np->op;
+        struct platform_device *op = np->op;
         const u32 *int_prop;
         int i;
 
@@ -9114,12 +9107,12 @@ static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
         if (!int_prop)
                 return -ENODEV;
 
-        for (i = 0; i < op->num_irqs; i++) {
+        for (i = 0; i < op->archdata.num_irqs; i++) {
                 ldg_num_map[i] = int_prop[i];
-                np->ldg[i].irq = op->irqs[i];
+                np->ldg[i].irq = op->archdata.irqs[i];
         }
 
-        np->num_ldg = op->num_irqs;
+        np->num_ldg = op->archdata.num_irqs;
 
         return 0;
 #else
@@ -9691,7 +9684,7 @@ static void __devinit niu_driver_version(void)
 
 static struct net_device * __devinit niu_alloc_and_init(
         struct device *gen_dev, struct pci_dev *pdev,
-        struct of_device *op, const struct niu_ops *ops,
+        struct platform_device *op, const struct niu_ops *ops,
         u8 port)
 {
         struct net_device *dev;
@@ -10067,7 +10060,7 @@ static const struct niu_ops niu_phys_ops = {
         .unmap_single   = niu_phys_unmap_single,
 };
 
-static int __devinit niu_of_probe(struct of_device *op,
+static int __devinit niu_of_probe(struct platform_device *op,
                                   const struct of_device_id *match)
 {
         union niu_parent_id parent_id;
@@ -10182,7 +10175,7 @@ err_out:
         return err;
 }
 
-static int __devexit niu_of_remove(struct of_device *op)
+static int __devexit niu_of_remove(struct platform_device *op)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
@@ -10249,14 +10242,14 @@ static int __init niu_init(void)
         niu_debug = netif_msg_init(debug, NIU_MSG_DEFAULT);
 
 #ifdef CONFIG_SPARC64
-        err = of_register_driver(&niu_of_driver, &of_bus_type);
+        err = of_register_platform_driver(&niu_of_driver);
 #endif
 
         if (!err) {
                 err = pci_register_driver(&niu_pci_driver);
 #ifdef CONFIG_SPARC64
                 if (err)
-                        of_unregister_driver(&niu_of_driver);
+                        of_unregister_platform_driver(&niu_of_driver);
 #endif
         }
 
@@ -10267,7 +10260,7 @@ static void __exit niu_exit(void)
 {
         pci_unregister_driver(&niu_pci_driver);
 #ifdef CONFIG_SPARC64
-        of_unregister_driver(&niu_of_driver);
+        of_unregister_platform_driver(&niu_of_driver);
 #endif
 }
 
diff --git a/drivers/net/niu.h b/drivers/net/niu.h
index d6715465f35d..a41fa8ebe05f 100644
--- a/drivers/net/niu.h
+++ b/drivers/net/niu.h
@@ -3236,7 +3236,7 @@ struct niu_phy_ops {
         int (*link_status)(struct niu *np, int *);
 };
 
-struct of_device;
+struct platform_device;
 struct niu {
         void __iomem                    *regs;
         struct net_device               *dev;
@@ -3297,7 +3297,7 @@ struct niu {
         struct niu_vpd                  vpd;
         u32                             eeprom_len;
 
-        struct of_device                *op;
+        struct platform_device          *op;
         void __iomem                    *vir_regs_1;
         void __iomem                    *vir_regs_2;
 };
diff --git a/drivers/net/pcmcia/3c574_cs.c b/drivers/net/pcmcia/3c574_cs.c
index 10ee106a1617..c683f77c6f42 100644
--- a/drivers/net/pcmcia/3c574_cs.c
+++ b/drivers/net/pcmcia/3c574_cs.c
@@ -87,7 +87,6 @@ earlier 3Com products.
 #include <linux/bitops.h>
 #include <linux/mii.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -279,8 +278,8 @@ static int tc574_probe(struct pcmcia_device *link)
         lp->p_dev = link;
 
         spin_lock_init(&lp->window_lock);
-        link->io.NumPorts1 = 32;
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
+        link->resource[0]->end = 32;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
         link->conf.ConfigIndex = 1;
@@ -338,10 +337,11 @@ static int tc574_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "3c574_config()\n");
 
-        link->io.IOAddrLines = 16;
+        link->io_lines = 16;
+
         for (i = j = 0; j < 0x400; j += 0x20) {
-                link->io.BasePort1 = j ^ 0x300;
-                i = pcmcia_request_io(link, &link->io);
+                link->resource[0]->start = j ^ 0x300;
+                i = pcmcia_request_io(link);
                 if (i == 0)
                         break;
         }
@@ -357,7 +357,7 @@ static int tc574_config(struct pcmcia_device *link)
                 goto failed;
 
         dev->irq = link->irq;
-        dev->base_addr = link->io.BasePort1;
+        dev->base_addr = link->resource[0]->start;
 
         ioaddr = dev->base_addr;
 
diff --git a/drivers/net/pcmcia/3c589_cs.c b/drivers/net/pcmcia/3c589_cs.c
index ce63c3773b4c..61f9cf2100ff 100644
--- a/drivers/net/pcmcia/3c589_cs.c
+++ b/drivers/net/pcmcia/3c589_cs.c
@@ -41,7 +41,6 @@
 #include <linux/bitops.h>
 #include <linux/jiffies.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -214,8 +213,8 @@ static int tc589_probe(struct pcmcia_device *link)
     lp->p_dev = link;
 
     spin_lock_init(&lp->lock);
-    link->io.NumPorts1 = 16;
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
+    link->resource[0]->end = 16;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 
     link->conf.Attributes = CONF_ENABLE_IRQ;
     link->conf.IntType = INT_MEMORY_AND_IO;
@@ -278,12 +277,13 @@ static int tc589_config(struct pcmcia_device *link)
                    "3Com card??\n");
     multi = (link->card_id == PRODID_3COM_3C562);
 
+    link->io_lines = 16;
+
     /* For the 3c562, the base address must be xx00-xx7f */
-    link->io.IOAddrLines = 16;
     for (i = j = 0; j < 0x400; j += 0x10) {
         if (multi && (j & 0x80)) continue;
-        link->io.BasePort1 = j ^ 0x300;
-        i = pcmcia_request_io(link, &link->io);
+        link->resource[0]->start = j ^ 0x300;
+        i = pcmcia_request_io(link);
         if (i == 0)
                 break;
     }
@@ -299,7 +299,7 @@ static int tc589_config(struct pcmcia_device *link)
             goto failed;
 
     dev->irq = link->irq;
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
     ioaddr = dev->base_addr;
     EL3WINDOW(0);
 
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index 33525bf2a3d3..5f05ffb240cc 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -39,7 +39,6 @@
 #include <linux/mii.h>
 #include "../8390.h"
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
@@ -260,28 +259,30 @@ static int get_prom(struct pcmcia_device *link)
 static int try_io_port(struct pcmcia_device *link)
 {
     int j, ret;
-    if (link->io.NumPorts1 == 32) {
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
+    link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+    link->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+    if (link->resource[0]->end == 32) {
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
         /* for master/slave multifunction cards */
-        if (link->io.NumPorts2 > 0)
-            link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
+        if (link->resource[1]->end > 0)
+            link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
     } else {
         /* This should be two 16-port windows */
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-        link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
     }
-    if (link->io.BasePort1 == 0) {
-        link->io.IOAddrLines = 16;
+    if (link->resource[0]->start == 0) {
         for (j = 0; j < 0x400; j += 0x20) {
-            link->io.BasePort1 = j ^ 0x300;
-            link->io.BasePort2 = (j ^ 0x300) + 0x10;
-            ret = pcmcia_request_io(link, &link->io);
+            link->resource[0]->start = j ^ 0x300;
+            link->resource[1]->start = (j ^ 0x300) + 0x10;
+            link->io_lines = 16;
+            ret = pcmcia_request_io(link);
             if (ret == 0)
                     return ret;
         }
         return ret;
     } else {
-        return pcmcia_request_io(link, &link->io);
+        return pcmcia_request_io(link);
     }
 }
 
@@ -302,15 +303,15 @@ static int axnet_configcheck(struct pcmcia_device *p_dev,
            network function with window 0, and serial with window 1 */
         if (io->nwin > 1) {
                 i = (io->win[1].len > io->win[0].len);
-                p_dev->io.BasePort2 = io->win[1-i].base;
-                p_dev->io.NumPorts2 = io->win[1-i].len;
+                p_dev->resource[1]->start = io->win[1-i].base;
+                p_dev->resource[1]->end = io->win[1-i].len;
         } else {
-                i = p_dev->io.NumPorts2 = 0;
+                i = p_dev->resource[1]->end = 0;
         }
-        p_dev->io.BasePort1 = io->win[i].base;
-        p_dev->io.NumPorts1 = io->win[i].len;
-        p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
-        if (p_dev->io.NumPorts1 + p_dev->io.NumPorts2 >= 32)
+        p_dev->resource[0]->start = io->win[i].base;
+        p_dev->resource[0]->end = io->win[i].len;
+        p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+        if (p_dev->resource[0]->end + p_dev->resource[1]->end >= 32)
                 return try_io_port(p_dev);
 
         return -ENODEV;
@@ -333,7 +334,7 @@ static int axnet_config(struct pcmcia_device *link)
     if (!link->irq)
             goto failed;
     
-    if (link->io.NumPorts2 == 8) {
+    if (resource_size(link->resource[1]) == 8) {
         link->conf.Attributes |= CONF_ENABLE_SPKR;
         link->conf.Status = CCSR_AUDIO_ENA;
     }
@@ -343,7 +344,7 @@ static int axnet_config(struct pcmcia_device *link)
             goto failed;
 
     dev->irq = link->irq;
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
 
     if (!get_prom(link)) {
         printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
@@ -379,8 +380,7 @@ static int axnet_config(struct pcmcia_device *link)
     /* Maybe PHY is in power down mode. (PPD_SET = 1) 
        Bit 2 of CCSR is active low. */ 
     if (i == 32) {
-        conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 };
-        pcmcia_access_configuration_register(link, &reg);
+        pcmcia_write_config_byte(link, CISREG_CCSR, 0x04);
         for (i = 0; i < 32; i++) {
             j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
             j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
diff --git a/drivers/net/pcmcia/com20020_cs.c b/drivers/net/pcmcia/com20020_cs.c
index 5643f94541bc..3c400cfa82ae 100644
--- a/drivers/net/pcmcia/com20020_cs.c
+++ b/drivers/net/pcmcia/com20020_cs.c
@@ -43,7 +43,6 @@
 #include <linux/arcdevice.h>
 #include <linux/com20020.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
@@ -159,9 +158,8 @@ static int com20020_probe(struct pcmcia_device *p_dev)
     /* fill in our module parameters as defaults */
     dev->dev_addr[0] = node;
 
-    p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-    p_dev->io.NumPorts1 = 16;
-    p_dev->io.IOAddrLines = 16;
+    p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+    p_dev->resource[0]->end = 16;
     p_dev->conf.Attributes = CONF_ENABLE_IRQ;
     p_dev->conf.IntType = INT_MEMORY_AND_IO;
 
@@ -246,20 +244,24 @@ static int com20020_config(struct pcmcia_device *link)
 
     dev_dbg(&link->dev, "com20020_config\n");
 
-    dev_dbg(&link->dev, "baseport1 is %Xh\n", link->io.BasePort1);
+    dev_dbg(&link->dev, "baseport1 is %Xh\n",
+            (unsigned int) link->resource[0]->start);
+
     i = -ENODEV;
-    if (!link->io.BasePort1)
+    link->io_lines = 16;
+
+    if (!link->resource[0]->start)
     {
         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
         {
-            link->io.BasePort1 = ioaddr;
-            i = pcmcia_request_io(link, &link->io);
+            link->resource[0]->start = ioaddr;
+            i = pcmcia_request_io(link);
             if (i == 0)
                 break;
         }
     }
     else
-        i = pcmcia_request_io(link, &link->io);
+        i = pcmcia_request_io(link);
     
     if (i != 0)
     {
@@ -267,7 +269,7 @@ static int com20020_config(struct pcmcia_device *link)
         goto failed;
     }
         
-    ioaddr = dev->base_addr = link->io.BasePort1;
+    ioaddr = dev->base_addr = link->resource[0]->start;
     dev_dbg(&link->dev, "got ioaddr %Xh\n", ioaddr);
 
     dev_dbg(&link->dev, "request IRQ %d\n",
diff --git a/drivers/net/pcmcia/fmvj18x_cs.c b/drivers/net/pcmcia/fmvj18x_cs.c
index 7c27c50211a5..98fffb03ecd7 100644
--- a/drivers/net/pcmcia/fmvj18x_cs.c
+++ b/drivers/net/pcmcia/fmvj18x_cs.c
@@ -49,7 +49,6 @@
 #include <linux/ioport.h>
 #include <linux/crc32.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
@@ -249,9 +248,8 @@ static int fmvj18x_probe(struct pcmcia_device *link)
     lp->base = NULL;
 
     /* The io structure describes IO port mapping */
-    link->io.NumPorts1 = 32;
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-    link->io.IOAddrLines = 5;
+    link->resource[0]->end = 32;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
     /* General socket configuration */
     link->conf.Attributes = CONF_ENABLE_IRQ;
@@ -289,13 +287,13 @@ static int mfc_try_io_port(struct pcmcia_device *link)
         { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 
     for (i = 0; i < 5; i++) {
-        link->io.BasePort2 = serial_base[i];
-        link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
-        if (link->io.BasePort2 == 0) {
-            link->io.NumPorts2 = 0;
+        link->resource[1]->start = serial_base[i];
+        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+        if (link->resource[1]->start == 0) {
+            link->resource[1]->end = 0;
             printk(KERN_NOTICE "fmvj18x_cs: out of resource for serial\n");
         }
-        ret = pcmcia_request_io(link, &link->io);
+        ret = pcmcia_request_io(link);
         if (ret == 0)
                 return ret;
     }
@@ -311,12 +309,12 @@ static int ungermann_try_io_port(struct pcmcia_device *link)
         0x380,0x3c0 only for ioport.
     */
     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
-        link->io.BasePort1 = ioaddr;
-        ret = pcmcia_request_io(link, &link->io);
+        link->resource[0]->start = ioaddr;
+        ret = pcmcia_request_io(link);
         if (ret == 0) {
             /* calculate ConfigIndex value */
             link->conf.ConfigIndex = 
-                ((link->io.BasePort1 & 0x0f0) >> 3) | 0x22;
+                ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
             return ret;
         }
     }
@@ -346,6 +344,8 @@ static int fmvj18x_config(struct pcmcia_device *link)
 
     dev_dbg(&link->dev, "fmvj18x_config\n");
 
+    link->io_lines = 5;
+
     len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
     kfree(buf);
 
@@ -364,20 +364,20 @@ static int fmvj18x_config(struct pcmcia_device *link)
                 /* MultiFunction Card */
                 link->conf.ConfigBase = 0x800;
                 link->conf.ConfigIndex = 0x47;
-                link->io.NumPorts2 = 8;
+                link->resource[1]->end = 8;
             }
             break;
         case MANFID_NEC:
             cardtype = NEC; /* MultiFunction Card */
             link->conf.ConfigBase = 0x800;
             link->conf.ConfigIndex = 0x47;
-            link->io.NumPorts2 = 8;
+            link->resource[1]->end = 8;
             break;
         case MANFID_KME:
             cardtype = KME; /* MultiFunction Card */
             link->conf.ConfigBase = 0x800;
             link->conf.ConfigIndex = 0x47;
-            link->io.NumPorts2 = 8;
+            link->resource[1]->end = 8;
             break;
         case MANFID_CONTEC:
             cardtype = CONTEC;
@@ -418,14 +418,14 @@ static int fmvj18x_config(struct pcmcia_device *link)
         }
     }
 
-    if (link->io.NumPorts2 != 0) {
+    if (link->resource[1]->end != 0) {
         ret = mfc_try_io_port(link);
         if (ret != 0) goto failed;
     } else if (cardtype == UNGERMANN) {
         ret = ungermann_try_io_port(link);
         if (ret != 0) goto failed;
     } else { 
-            ret = pcmcia_request_io(link, &link->io);
+            ret = pcmcia_request_io(link);
             if (ret)
                     goto failed;
     }
@@ -437,9 +437,9 @@ static int fmvj18x_config(struct pcmcia_device *link)
             goto failed;
 
     dev->irq = link->irq;
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
 
-    if (link->io.BasePort2 != 0) {
+    if (resource_size(link->resource[1]) != 0) {
         ret = fmvj18x_setup_mfc(link);
         if (ret != 0) goto failed;
     }
@@ -545,7 +545,6 @@ failed:
 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 {
     win_req_t req;
-    memreq_t mem;
     u_char __iomem *base;
     int i, j;
 
@@ -558,9 +557,7 @@ static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
         return -1;
 
     base = ioremap(req.Base, req.Size);
-    mem.Page = 0;
-    mem.CardOffset = 0;
-    pcmcia_map_mem_page(link, link->win, &mem);
+    pcmcia_map_mem_page(link, link->win, 0);
 
     /*
      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
@@ -594,7 +591,6 @@ static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
 {
     win_req_t req;
-    memreq_t mem;
     int i;
     struct net_device *dev = link->priv;
     unsigned int ioaddr;
@@ -614,9 +610,7 @@ static int fmvj18x_setup_mfc(struct pcmcia_device *link)
         return -1;
     }
 
-    mem.Page = 0;
-    mem.CardOffset = 0;
-    i = pcmcia_map_mem_page(link, link->win, &mem);
+    i = pcmcia_map_mem_page(link, link->win, 0);
     if (i != 0) {
         iounmap(lp->base);
         lp->base = NULL;
diff --git a/drivers/net/pcmcia/ibmtr_cs.c b/drivers/net/pcmcia/ibmtr_cs.c
index 67ee9851a8ed..b0d06a3d962f 100644
--- a/drivers/net/pcmcia/ibmtr_cs.c
+++ b/drivers/net/pcmcia/ibmtr_cs.c
@@ -57,7 +57,6 @@
 #include <linux/trdevice.h>
 #include <linux/ibmtr.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
@@ -152,9 +151,8 @@ static int __devinit ibmtr_attach(struct pcmcia_device *link)
     link->priv = info;
     info->ti = netdev_priv(dev);
 
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-    link->io.NumPorts1 = 4;
-    link->io.IOAddrLines = 16;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+    link->resource[0]->end = 4;
     link->conf.Attributes = CONF_ENABLE_IRQ;
     link->conf.IntType = INT_MEMORY_AND_IO;
     link->conf.Present = PRESENT_OPTION;
@@ -213,26 +211,26 @@ static int __devinit ibmtr_config(struct pcmcia_device *link)
     struct net_device *dev = info->dev;
     struct tok_info *ti = netdev_priv(dev);
     win_req_t req;
-    memreq_t mem;
     int i, ret;
 
     dev_dbg(&link->dev, "ibmtr_config\n");
 
     link->conf.ConfigIndex = 0x61;
+    link->io_lines = 16;
 
     /* Determine if this is PRIMARY or ALTERNATE. */
 
     /* Try PRIMARY card at 0xA20-0xA23 */
-    link->io.BasePort1 = 0xA20;
-    i = pcmcia_request_io(link, &link->io);
+    link->resource[0]->start = 0xA20;
+    i = pcmcia_request_io(link);
     if (i != 0) {
         /* Couldn't get 0xA20-0xA23.  Try ALTERNATE at 0xA24-0xA27. */
-        link->io.BasePort1 = 0xA24;
-        ret = pcmcia_request_io(link, &link->io);
+        link->resource[0]->start = 0xA24;
+        ret = pcmcia_request_io(link);
         if (ret)
                 goto failed;
     }
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
 
     ret = pcmcia_request_exclusive_irq(link, ibmtr_interrupt);
     if (ret)
@@ -251,9 +249,7 @@ static int __devinit ibmtr_config(struct pcmcia_device *link)
     if (ret)
             goto failed;
 
-    mem.CardOffset = mmiobase;
-    mem.Page = 0;
-    ret = pcmcia_map_mem_page(link, link->win, &mem);
+    ret = pcmcia_map_mem_page(link, link->win, mmiobase);
     if (ret)
             goto failed;
     ti->mmio = ioremap(req.Base, req.Size);
@@ -268,13 +264,11 @@ static int __devinit ibmtr_config(struct pcmcia_device *link)
     if (ret)
             goto failed;
 
-    mem.CardOffset = srambase;
-    mem.Page = 0;
-    ret = pcmcia_map_mem_page(link, info->sram_win_handle, &mem);
+    ret = pcmcia_map_mem_page(link, info->sram_win_handle, srambase);
     if (ret)
             goto failed;
 
-    ti->sram_base = mem.CardOffset >> 12;
+    ti->sram_base = srambase >> 12;
     ti->sram_virt = ioremap(req.Base, req.Size);
     ti->sram_phys = req.Base;
 
@@ -325,7 +319,6 @@ static void ibmtr_release(struct pcmcia_device *link)
         if (link->win) {
                 struct tok_info *ti = netdev_priv(dev);
                 iounmap(ti->mmio);
-                pcmcia_release_window(link, info->sram_win_handle);
         }
         pcmcia_disable_device(link);
 }
diff --git a/drivers/net/pcmcia/nmclan_cs.c b/drivers/net/pcmcia/nmclan_cs.c
index 9b63dec549cb..68f2deeb3ade 100644
--- a/drivers/net/pcmcia/nmclan_cs.c
+++ b/drivers/net/pcmcia/nmclan_cs.c
@@ -146,7 +146,6 @@ Include Files
 #include <linux/ioport.h>
 #include <linux/bitops.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/cistpl.h>
@@ -459,9 +458,8 @@ static int nmclan_probe(struct pcmcia_device *link)
     link->priv = dev;
     
     spin_lock_init(&lp->bank_lock);
-    link->io.NumPorts1 = 32;
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-    link->io.IOAddrLines = 5;
+    link->resource[0]->end = 32;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
     link->conf.Attributes = CONF_ENABLE_IRQ;
     link->conf.IntType = INT_MEMORY_AND_IO;
     link->conf.ConfigIndex = 1;
@@ -645,7 +643,8 @@ static int nmclan_config(struct pcmcia_device *link)
 
   dev_dbg(&link->dev, "nmclan_config\n");
 
-  ret = pcmcia_request_io(link, &link->io);
+  link->io_lines = 5;
+  ret = pcmcia_request_io(link);
   if (ret)
           goto failed;
   ret = pcmcia_request_exclusive_irq(link, mace_interrupt);
@@ -656,7 +655,7 @@ static int nmclan_config(struct pcmcia_device *link)
           goto failed;
 
   dev->irq = link->irq;
-  dev->base_addr = link->io.BasePort1;
+  dev->base_addr = link->resource[0]->start;
 
   ioaddr = dev->base_addr;
 
@@ -758,29 +757,20 @@ static void nmclan_reset(struct net_device *dev)
 
 #if RESET_XILINX
   struct pcmcia_device *link = &lp->link;
-  conf_reg_t reg;
-  u_long OrigCorValue; 
+  u8 OrigCorValue;
 
   /* Save original COR value */
-  reg.Function = 0;
-  reg.Action = CS_READ;
-  reg.Offset = CISREG_COR;
-  reg.Value = 0;
-  pcmcia_access_configuration_register(link, &reg);
-  OrigCorValue = reg.Value;
+  pcmcia_read_config_byte(link, CISREG_COR, &OrigCorValue);
 
   /* Reset Xilinx */
-  reg.Action = CS_WRITE;
-  reg.Offset = CISREG_COR;
-  dev_dbg(&link->dev, "nmclan_reset: OrigCorValue=0x%lX, resetting...\n",
+  dev_dbg(&link->dev, "nmclan_reset: OrigCorValue=0x%x, resetting...\n",
         OrigCorValue);
-  reg.Value = COR_SOFT_RESET;
-  pcmcia_access_configuration_register(link, &reg);
+  pcmcia_write_config_byte(link, CISREG_COR, COR_SOFT_RESET);
   /* Need to wait for 20 ms for PCMCIA to finish reset. */
 
   /* Restore original COR configuration index */
-  reg.Value = COR_LEVEL_REQ | (OrigCorValue & COR_CONFIG_MASK);
-  pcmcia_access_configuration_register(link, &reg);
+  pcmcia_write_config_byte(link, CISREG_COR,
+                          (COR_LEVEL_REQ | (OrigCorValue & COR_CONFIG_MASK)));
   /* Xilinx is now completely reset along with the MACE chip. */
   lp->tx_free_frames=AM2150_MAX_TX_FRAMES;
 
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index bfdef72c5d5e..49279b0ee526 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -42,7 +42,6 @@
 #include <linux/mii.h>
 #include "../8390.h"
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
@@ -113,8 +112,6 @@ static int setup_dma_config(struct pcmcia_device *link, int start_pg,
 
 static void pcnet_detach(struct pcmcia_device *p_dev);
 
-static dev_info_t dev_info = "pcnet_cs";
-
 /*====================================================================*/
 
 typedef struct hw_info_t {
@@ -304,7 +301,6 @@ static hw_info_t *get_hwinfo(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     win_req_t req;
-    memreq_t mem;
     u_char __iomem *base, *virt;
     int i, j;
 
@@ -317,10 +313,8 @@ static hw_info_t *get_hwinfo(struct pcmcia_device *link)
         return NULL;
 
     virt = ioremap(req.Base, req.Size);
-    mem.Page = 0;
     for (i = 0; i < NR_INFO; i++) {
-        mem.CardOffset = hw_info[i].offset & ~(req.Size-1);
-        pcmcia_map_mem_page(link, link->win, &mem);
+        pcmcia_map_mem_page(link, link->win, hw_info[i].offset & ~(req.Size-1));
         base = &virt[hw_info[i].offset & (req.Size-1)];
         if ((readb(base+0) == hw_info[i].a0) &&
             (readb(base+2) == hw_info[i].a1) &&
@@ -480,29 +474,31 @@ static hw_info_t *get_hwired(struct pcmcia_device *link)
 static int try_io_port(struct pcmcia_device *link)
 {
     int j, ret;
-    if (link->io.NumPorts1 == 32) {
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-        if (link->io.NumPorts2 > 0) {
+    link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+    link->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+    if (link->resource[0]->end == 32) {
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        if (link->resource[1]->end > 0) {
             /* for master/slave multifunction cards */
-            link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
+            link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
         }
     } else {
         /* This should be two 16-port windows */
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-        link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
     }
-    if (link->io.BasePort1 == 0) {
-        link->io.IOAddrLines = 16;
+    if (link->resource[0]->start == 0) {
         for (j = 0; j < 0x400; j += 0x20) {
-            link->io.BasePort1 = j ^ 0x300;
-            link->io.BasePort2 = (j ^ 0x300) + 0x10;
-            ret = pcmcia_request_io(link, &link->io);
+            link->resource[0]->start = j ^ 0x300;
+            link->resource[1]->start = (j ^ 0x300) + 0x10;
+            link->io_lines = 16;
+            ret = pcmcia_request_io(link);
             if (ret == 0)
                     return ret;
         }
         return ret;
     } else {
-        return pcmcia_request_io(link, &link->io);
+        return pcmcia_request_io(link);
     }
 }
 
@@ -523,18 +519,18 @@ static int pcnet_confcheck(struct pcmcia_device *p_dev,
            network function with window 0, and serial with window 1 */
         if (io->nwin > 1) {
                 i = (io->win[1].len > io->win[0].len);
-                p_dev->io.BasePort2 = io->win[1-i].base;
-                p_dev->io.NumPorts2 = io->win[1-i].len;
+                p_dev->resource[1]->start = io->win[1-i].base;
+                p_dev->resource[1]->end = io->win[1-i].len;
         } else {
-                i = p_dev->io.NumPorts2 = 0;
+                i = p_dev->resource[1]->end = 0;
         }
 
         *has_shmem = ((cfg->mem.nwin == 1) &&
                       (cfg->mem.win[0].len >= 0x4000));
-        p_dev->io.BasePort1 = io->win[i].base;
-        p_dev->io.NumPorts1 = io->win[i].len;
-        p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
-        if (p_dev->io.NumPorts1 + p_dev->io.NumPorts2 >= 32)
+        p_dev->resource[0]->start = io->win[i].base;
+        p_dev->resource[0]->end = io->win[i].len;
+        p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+        if (p_dev->resource[0]->end + p_dev->resource[1]->end >= 32)
                 return try_io_port(p_dev);
 
         return 0;
@@ -557,7 +553,7 @@ static int pcnet_config(struct pcmcia_device *link)
     if (!link->irq)
             goto failed;
 
-    if (link->io.NumPorts2 == 8) {
+    if (resource_size(link->resource[1]) == 8) {
         link->conf.Attributes |= CONF_ENABLE_SPKR;
         link->conf.Status = CCSR_AUDIO_ENA;
     }
@@ -569,7 +565,7 @@ static int pcnet_config(struct pcmcia_device *link)
     if (ret)
             goto failed;
     dev->irq = link->irq;
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
     if (info->flags & HAS_MISC_REG) {
         if ((if_port == 1) || (if_port == 2))
             dev->if_port = if_port;
@@ -956,7 +952,7 @@ static int pcnet_open(struct net_device *dev)
     set_misc_reg(dev);
 
     outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
-    ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, dev_info, dev);
+    ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, dev->name, dev);
     if (ret)
             return ret;
 
@@ -1464,7 +1460,6 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
     struct net_device *dev = link->priv;
     pcnet_dev_t *info = PRIV(dev);
     win_req_t req;
-    memreq_t mem;
     int i, window_size, offset, ret;
 
     window_size = (stop_pg - start_pg) << 8;
@@ -1483,11 +1478,9 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
     if (ret)
             goto failed;
 
-    mem.CardOffset = (start_pg << 8) + cm_offset;
-    offset = mem.CardOffset % window_size;
-    mem.CardOffset -= offset;
-    mem.Page = 0;
-    ret = pcmcia_map_mem_page(link, link->win, &mem);
+    offset = (start_pg << 8) + cm_offset;
+    offset -= offset % window_size;
+    ret = pcmcia_map_mem_page(link, link->win, offset);
     if (ret)
             goto failed;
 
@@ -1644,6 +1637,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCETTX", 0x547e66dc, 0x6fc5459b),
         PCMCIA_DEVICE_PROD_ID12("iPort", "10/100 Ethernet Card", 0x56c538d2, 0x11b0ffc0),
         PCMCIA_DEVICE_PROD_ID12("KANSAI ELECTRIC CO.,LTD", "KLA-PCM/T", 0xb18dc3b4, 0xcc51a956),
+        PCMCIA_DEVICE_PROD_ID12("KENTRONICS", "KEP-230", 0xaf8144c9, 0x868f6616),
         PCMCIA_DEVICE_PROD_ID12("KCI", "PE520 PCMCIA Ethernet Adapter", 0xa89b87d3, 0x1eb88e64),
         PCMCIA_DEVICE_PROD_ID12("KINGMAX", "EN10T2T", 0x7bcb459a, 0xa5c81fa5),
         PCMCIA_DEVICE_PROD_ID12("Kingston", "KNE-PC2", 0x1128e633, 0xce2a89b3),
diff --git a/drivers/net/pcmcia/smc91c92_cs.c b/drivers/net/pcmcia/smc91c92_cs.c
index 307cd1721e91..377367d03b41 100644
--- a/drivers/net/pcmcia/smc91c92_cs.c
+++ b/drivers/net/pcmcia/smc91c92_cs.c
@@ -44,7 +44,6 @@
 #include <linux/jiffies.h>
 #include <linux/firmware.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -325,9 +324,8 @@ static int smc91c92_probe(struct pcmcia_device *link)
     link->priv = dev;
 
     spin_lock_init(&smc->lock);
-    link->io.NumPorts1 = 16;
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-    link->io.IOAddrLines = 4;
+    link->resource[0]->end = 16;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
     link->conf.Attributes = CONF_ENABLE_IRQ;
     link->conf.IntType = INT_MEMORY_AND_IO;
 
@@ -428,12 +426,13 @@ static int mhz_mfc_config_check(struct pcmcia_device *p_dev,
                                 void *priv_data)
 {
         int k;
-        p_dev->io.BasePort2 = cf->io.win[0].base;
+        p_dev->resource[1]->start = cf->io.win[0].base;
         for (k = 0; k < 0x400; k += 0x10) {
                 if (k & 0x80)
                         continue;
-                p_dev->io.BasePort1 = k ^ 0x300;
-                if (!pcmcia_request_io(p_dev, &p_dev->io))
+                p_dev->resource[0]->start = k ^ 0x300;
+                p_dev->io_lines = 16;
+                if (!pcmcia_request_io(p_dev))
                         return 0;
         }
         return -ENODEV;
@@ -444,21 +443,20 @@ static int mhz_mfc_config(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     struct smc_private *smc = netdev_priv(dev);
     win_req_t req;
-    memreq_t mem;
+    unsigned int offset;
     int i;
 
     link->conf.Attributes |= CONF_ENABLE_SPKR;
     link->conf.Status = CCSR_AUDIO_ENA;
-    link->io.IOAddrLines = 16;
-    link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
-    link->io.NumPorts2 = 8;
+    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+    link->resource[1]->end = 8;
 
     /* The Megahertz combo cards have modem-like CIS entries, so
        we have to explicitly try a bunch of port combinations. */
     if (pcmcia_loop_config(link, mhz_mfc_config_check, NULL))
             return -ENODEV;
 
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
 
     /* Allocate a memory window, for accessing the ISR */
     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
@@ -469,11 +467,8 @@ static int mhz_mfc_config(struct pcmcia_device *link)
             return -ENODEV;
 
     smc->base = ioremap(req.Base, req.Size);
-    mem.CardOffset = mem.Page = 0;
-    if (smc->manfid == MANFID_MOTOROLA)
-        mem.CardOffset = link->conf.ConfigBase;
-    i = pcmcia_map_mem_page(link, link->win, &mem);
-
+    offset = (smc->manfid == MANFID_MOTOROLA) ? link->conf.ConfigBase : 0;
+    i = pcmcia_map_mem_page(link, link->win, offset);
     if ((i == 0) &&
         (smc->manfid == MANFID_MEGAHERTZ) &&
         (smc->cardid == PRODID_MEGAHERTZ_EM3288))
@@ -546,7 +541,7 @@ static void mot_config(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     struct smc_private *smc = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
-    unsigned int iouart = link->io.BasePort2;
+    unsigned int iouart = link->resource[1]->start;
 
     /* Set UART base address and force map with COR bit 1 */
     writeb(iouart & 0xff,        smc->base + MOT_UART + CISREG_IOBASE_0);
@@ -602,9 +597,9 @@ static int smc_configcheck(struct pcmcia_device *p_dev,
                            unsigned int vcc,
                            void *priv_data)
 {
-        p_dev->io.BasePort1 = cf->io.win[0].base;
-        p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
-        return pcmcia_request_io(p_dev, &p_dev->io);
+        p_dev->resource[0]->start = cf->io.win[0].base;
+        p_dev->io_lines = cf->io.flags & CISTPL_IO_LINES_MASK;
+        return pcmcia_request_io(p_dev);
 }
 
 static int smc_config(struct pcmcia_device *link)
@@ -612,10 +607,10 @@ static int smc_config(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     int i;
 
-    link->io.NumPorts1 = 16;
+    link->resource[0]->end = 16;
     i = pcmcia_loop_config(link, smc_configcheck, NULL);
     if (!i)
-            dev->base_addr = link->io.BasePort1;
+            dev->base_addr = link->resource[0]->start;
 
     return i;
 }
@@ -647,27 +642,27 @@ static int osi_config(struct pcmcia_device *link)
 
     link->conf.Attributes |= CONF_ENABLE_SPKR;
     link->conf.Status = CCSR_AUDIO_ENA;
-    link->io.NumPorts1 = 64;
-    link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
-    link->io.NumPorts2 = 8;
-    link->io.IOAddrLines = 16;
+    link->resource[0]->end = 64;
+    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+    link->resource[1]->end = 8;
 
     /* Enable Hard Decode, LAN, Modem */
     link->conf.ConfigIndex = 0x23;
+    link->io_lines = 16;
 
     for (i = j = 0; j < 4; j++) {
-        link->io.BasePort2 = com[j];
-        i = pcmcia_request_io(link, &link->io);
+        link->resource[1]->start = com[j];
+        i = pcmcia_request_io(link);
         if (i == 0)
                 break;
     }
     if (i != 0) {
         /* Fallback: turn off hard decode */
         link->conf.ConfigIndex = 0x03;
-        link->io.NumPorts2 = 0;
-        i = pcmcia_request_io(link, &link->io);
+        link->resource[1]->end = 0;
+        i = pcmcia_request_io(link);
     }
-    dev->base_addr = link->io.BasePort1 + 0x10;
+    dev->base_addr = link->resource[0]->start + 0x10;
     return i;
 }
 
@@ -684,7 +679,7 @@ static int osi_load_firmware(struct pcmcia_device *link)
 
         /* Download the Seven of Diamonds firmware */
         for (i = 0; i < fw->size; i++) {
-            outb(fw->data[i], link->io.BasePort1 + 2);
+            outb(fw->data[i], link->resource[0]->start + 2);
             udelay(50);
         }
         release_firmware(fw);
@@ -726,12 +721,12 @@ static int osi_setup(struct pcmcia_device *link, u_short manfid, u_short cardid)
                 return rc;
     } else if (manfid == MANFID_OSITECH) {
         /* Make sure both functions are powered up */
-        set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
+        set_bits(0x300, link->resource[0]->start + OSITECH_AUI_PWR);
         /* Now, turn on the interrupt for both card functions */
-        set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
+        set_bits(0x300, link->resource[0]->start + OSITECH_RESET_ISR);
         dev_dbg(&link->dev, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
-              inw(link->io.BasePort1 + OSITECH_AUI_PWR),
-              inw(link->io.BasePort1 + OSITECH_RESET_ISR));
+              inw(link->resource[0]->start + OSITECH_AUI_PWR),
+              inw(link->resource[0]->start + OSITECH_RESET_ISR));
     }
     return 0;
 }
@@ -804,7 +799,7 @@ static int check_sig(struct pcmcia_device *link)
     }
 
     /* Try setting bus width */
-    width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
+    width = (link->resource[0]->flags == IO_DATA_PATH_WIDTH_AUTO);
     s = inb(ioaddr + CONFIG);
     if (width)
         s |= CFG_16BIT;
diff --git a/drivers/net/pcmcia/xirc2ps_cs.c b/drivers/net/pcmcia/xirc2ps_cs.c
index b6c3644888cd..f5819526b5ee 100644
--- a/drivers/net/pcmcia/xirc2ps_cs.c
+++ b/drivers/net/pcmcia/xirc2ps_cs.c
@@ -82,7 +82,6 @@
 #include <linux/bitops.h>
 #include <linux/mii.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -678,9 +677,9 @@ xirc2ps_config_modem(struct pcmcia_device *p_dev,
 
         if (cf->io.nwin > 0  &&  (cf->io.win[0].base & 0xf) == 8) {
                 for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
-                        p_dev->io.BasePort2 = cf->io.win[0].base;
-                        p_dev->io.BasePort1 = ioaddr;
-                        if (!pcmcia_request_io(p_dev, &p_dev->io))
+                        p_dev->resource[1]->start = cf->io.win[0].base;
+                        p_dev->resource[0]->start = ioaddr;
+                        if (!pcmcia_request_io(p_dev))
                                 return 0;
                 }
         }
@@ -697,11 +696,11 @@ xirc2ps_config_check(struct pcmcia_device *p_dev,
         int *pass = priv_data;
 
         if (cf->io.nwin > 0 && (cf->io.win[0].base & 0xf) == 8) {
-                p_dev->io.BasePort2 = cf->io.win[0].base;
-                p_dev->io.BasePort1 = p_dev->io.BasePort2
+                p_dev->resource[1]->start = cf->io.win[0].base;
+                p_dev->resource[0]->start = p_dev->resource[1]->start
                         + (*pass ? (cf->index & 0x20 ? -24:8)
                            : (cf->index & 0x20 ?   8:-24));
-                if (!pcmcia_request_io(p_dev, &p_dev->io))
+                if (!pcmcia_request_io(p_dev))
                         return 0;
         }
         return -ENODEV;
@@ -808,8 +807,8 @@ xirc2ps_config(struct pcmcia_device * link)
         goto failure;
     }
 
-    link->io.IOAddrLines =10;
-    link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
+    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
+    link->io_lines = 10;
     if (local->modem) {
         int pass;
 
@@ -817,16 +816,16 @@ xirc2ps_config(struct pcmcia_device * link)
             link->conf.Attributes |= CONF_ENABLE_SPKR;
             link->conf.Status |= CCSR_AUDIO_ENA;
         }
-        link->io.NumPorts2 = 8;
-        link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
+        link->resource[1]->end = 8;
+        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
         if (local->dingo) {
             /* Take the Modem IO port from the CIS and scan for a free
              * Ethernet port */
-            link->io.NumPorts1 = 16; /* no Mako stuff anymore */
+            link->resource[0]->end = 16; /* no Mako stuff anymore */
             if (!pcmcia_loop_config(link, xirc2ps_config_modem, NULL))
                     goto port_found;
         } else {
-            link->io.NumPorts1 = 18;
+            link->resource[0]->end = 18;
             /* We do 2 passes here: The first one uses the regular mapping and
              * the second tries again, thereby considering that the 32 ports are
              * mirrored every 32 bytes. Actually we use a mirrored port for
@@ -841,14 +840,14 @@ xirc2ps_config(struct pcmcia_device * link)
         }
         printk(KNOT_XIRC "no ports available\n");
     } else {
-        link->io.NumPorts1 = 16;
+        link->resource[0]->end = 16;
         for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
-            link->io.BasePort1 = ioaddr;
-            if (!(err=pcmcia_request_io(link, &link->io)))
+            link->resource[0]->start = ioaddr;
+            if (!(err = pcmcia_request_io(link)))
                 goto port_found;
         }
-        link->io.BasePort1 = 0; /* let CS decide */
-        if ((err=pcmcia_request_io(link, &link->io)))
+        link->resource[0]->start = 0; /* let CS decide */
+        if ((err = pcmcia_request_io(link)))
             goto config_error;
     }
   port_found:
@@ -870,24 +869,21 @@ xirc2ps_config(struct pcmcia_device * link)
         goto config_error;
 
     if (local->dingo) {
-        conf_reg_t reg;
         win_req_t req;
-        memreq_t mem;
 
         /* Reset the modem's BAR to the correct value
          * This is necessary because in the RequestConfiguration call,
          * the base address of the ethernet port (BasePort1) is written
          * to the BAR registers of the modem.
          */
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_IOBASE_0;
-        reg.Value = link->io.BasePort2 & 0xff;
-        if ((err = pcmcia_access_configuration_register(link, &reg)))
+        err = pcmcia_write_config_byte(link, CISREG_IOBASE_0, (u8)
+                                link->resource[1]->start & 0xff);
+        if (err)
             goto config_error;
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_IOBASE_1;
-        reg.Value = (link->io.BasePort2 >> 8) & 0xff;
-        if ((err = pcmcia_access_configuration_register(link, &reg)))
+
+        err = pcmcia_write_config_byte(link, CISREG_IOBASE_1,
+                                (link->resource[1]->start >> 8) & 0xff);
+        if (err)
             goto config_error;
 
         /* There is no config entry for the Ethernet part which
@@ -901,16 +897,14 @@ xirc2ps_config(struct pcmcia_device * link)
             goto config_error;
 
         local->dingo_ccr = ioremap(req.Base,0x1000) + 0x0800;
-        mem.CardOffset = 0x0;
-        mem.Page = 0;
-        if ((err = pcmcia_map_mem_page(link, link->win, &mem)))
+        if ((err = pcmcia_map_mem_page(link, link->win, 0)))
             goto config_error;
 
         /* Setup the CCRs; there are no infos in the CIS about the Ethernet
          * part.
          */
         writeb(0x47, local->dingo_ccr + CISREG_COR);
-        ioaddr = link->io.BasePort1;
+        ioaddr = link->resource[0]->start;
         writeb(ioaddr & 0xff      , local->dingo_ccr + CISREG_IOBASE_0);
         writeb((ioaddr >> 8)&0xff , local->dingo_ccr + CISREG_IOBASE_1);
 
@@ -957,7 +951,7 @@ xirc2ps_config(struct pcmcia_device * link)
 
     /* we can now register the device with the net subsystem */
     dev->irq = link->irq;
-    dev->base_addr = link->io.BasePort1;
+    dev->base_addr = link->resource[0]->start;
 
     if (local->dingo)
         do_reset(dev, 1); /* a kludge to make the cem56 work */
diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig
index a527e37728cd..eb799b36c86a 100644
--- a/drivers/net/phy/Kconfig
+++ b/drivers/net/phy/Kconfig
@@ -5,7 +5,7 @@
 menuconfig PHYLIB
         tristate "PHY Device support and infrastructure"
         depends on !S390
-        depends on NET_ETHERNET
+        depends on NETDEVICES
         help
           Ethernet controllers are usually attached to PHY
           devices.  This option provides infrastructure for
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index fc5fef2a8175..f62c7b717bc8 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -188,7 +188,7 @@ static int __devexit mdio_gpio_remove(struct platform_device *pdev)
 
 #ifdef CONFIG_OF_GPIO
 
-static int __devinit mdio_ofgpio_probe(struct of_device *ofdev,
+static int __devinit mdio_ofgpio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct mdio_gpio_platform_data *pdata;
@@ -224,7 +224,7 @@ out_free:
         return -ENODEV;
 }
 
-static int __devexit mdio_ofgpio_remove(struct of_device *ofdev)
+static int __devexit mdio_ofgpio_remove(struct platform_device *ofdev)
 {
         mdio_gpio_bus_destroy(&ofdev->dev);
         kfree(ofdev->dev.platform_data);
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 6a6b8199a0d6..6c58da2b882c 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -308,7 +308,7 @@ static int mdio_bus_suspend(struct device *dev)
          * may call phy routines that try to grab the same lock, and that may
          * lead to a deadlock.
          */
-        if (phydev->attached_dev)
+        if (phydev->attached_dev && phydev->adjust_link)
                 phy_stop_machine(phydev);
 
         if (!mdio_bus_phy_may_suspend(phydev))
@@ -331,7 +331,7 @@ static int mdio_bus_resume(struct device *dev)
                 return ret;
 
 no_resume:
-        if (phydev->attached_dev)
+        if (phydev->attached_dev && phydev->adjust_link)
                 phy_start_machine(phydev, NULL);
 
         return 0;
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 5130db8f5c4e..1bb16cb79433 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -301,7 +301,7 @@ EXPORT_SYMBOL(phy_ethtool_gset);
 /**
  * phy_mii_ioctl - generic PHY MII ioctl interface
  * @phydev: the phy_device struct
- * @mii_data: MII ioctl data
+ * @ifr: &struct ifreq for socket ioctl's
  * @cmd: ioctl cmd to execute
  *
  * Note that this function is currently incompatible with the
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index c0761197c07e..16ddc77313cb 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -466,6 +466,8 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
 
         phydev->interface = interface;
 
+        phydev->state = PHY_READY;
+
         /* Do initial configuration here, now that
          * we have certain key parameters
          * (dev_flags and interface) */
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 6695a51e09e9..736b91703b3e 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -1314,8 +1314,13 @@ static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb)
         hdrlen = (ppp->flags & SC_MP_XSHORTSEQ)? MPHDRLEN_SSN: MPHDRLEN;
         i = 0;
         list_for_each_entry(pch, &ppp->channels, clist) {
-                navail += pch->avail = (pch->chan != NULL);
-                pch->speed = pch->chan->speed;
+                if (pch->chan) {
+                        pch->avail = 1;
+                        navail++;
+                        pch->speed = pch->chan->speed;
+                } else {
+                        pch->avail = 0;
+                }
                 if (pch->avail) {
                         if (skb_queue_empty(&pch->file.xq) ||
                                 !pch->had_frag) {
diff --git a/drivers/net/pxa168_eth.c b/drivers/net/pxa168_eth.c
new file mode 100644
index 000000000000..85eddda276bd
--- /dev/null
+++ b/drivers/net/pxa168_eth.c
@@ -0,0 +1,1666 @@
+/*
+ * PXA168 ethernet driver.
+ * Most of the code is derived from mv643xx ethernet driver.
+ *
+ * Copyright (C) 2010 Marvell International Ltd.
+ *              Sachin Sanap <ssanap@marvell.com>
+ *              Philip Rakity <prakity@marvell.com>
+ *              Mark Brown <markb@marvell.com>
+ *
+ * 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/init.h>
+#include <linux/dma-mapping.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/etherdevice.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/ethtool.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/workqueue.h>
+#include <linux/clk.h>
+#include <linux/phy.h>
+#include <linux/io.h>
+#include <linux/types.h>
+#include <asm/pgtable.h>
+#include <asm/system.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <asm/cacheflush.h>
+#include <linux/pxa168_eth.h>
+
+#define DRIVER_NAME     "pxa168-eth"
+#define DRIVER_VERSION  "0.3"
+
+/*
+ * Registers
+ */
+
+#define PHY_ADDRESS             0x0000
+#define SMI                     0x0010
+#define PORT_CONFIG             0x0400
+#define PORT_CONFIG_EXT         0x0408
+#define PORT_COMMAND            0x0410
+#define PORT_STATUS             0x0418
+#define HTPR                    0x0428
+#define SDMA_CONFIG             0x0440
+#define SDMA_CMD                0x0448
+#define INT_CAUSE               0x0450
+#define INT_W_CLEAR             0x0454
+#define INT_MASK                0x0458
+#define ETH_F_RX_DESC_0         0x0480
+#define ETH_C_RX_DESC_0         0x04A0
+#define ETH_C_TX_DESC_1         0x04E4
+
+/* smi register */
+#define SMI_BUSY                (1 << 28)       /* 0 - Write, 1 - Read  */
+#define SMI_R_VALID             (1 << 27)       /* 0 - Write, 1 - Read  */
+#define SMI_OP_W                (0 << 26)       /* Write operation      */
+#define SMI_OP_R                (1 << 26)       /* Read operation */
+
+#define PHY_WAIT_ITERATIONS     10
+
+#define PXA168_ETH_PHY_ADDR_DEFAULT     0
+/* RX & TX descriptor command */
+#define BUF_OWNED_BY_DMA        (1 << 31)
+
+/* RX descriptor status */
+#define RX_EN_INT               (1 << 23)
+#define RX_FIRST_DESC           (1 << 17)
+#define RX_LAST_DESC            (1 << 16)
+#define RX_ERROR                (1 << 15)
+
+/* TX descriptor command */
+#define TX_EN_INT               (1 << 23)
+#define TX_GEN_CRC              (1 << 22)
+#define TX_ZERO_PADDING         (1 << 18)
+#define TX_FIRST_DESC           (1 << 17)
+#define TX_LAST_DESC            (1 << 16)
+#define TX_ERROR                (1 << 15)
+
+/* SDMA_CMD */
+#define SDMA_CMD_AT             (1 << 31)
+#define SDMA_CMD_TXDL           (1 << 24)
+#define SDMA_CMD_TXDH           (1 << 23)
+#define SDMA_CMD_AR             (1 << 15)
+#define SDMA_CMD_ERD            (1 << 7)
+
+/* Bit definitions of the Port Config Reg */
+#define PCR_HS                  (1 << 12)
+#define PCR_EN                  (1 << 7)
+#define PCR_PM                  (1 << 0)
+
+/* Bit definitions of the Port Config Extend Reg */
+#define PCXR_2BSM               (1 << 28)
+#define PCXR_DSCP_EN            (1 << 21)
+#define PCXR_MFL_1518           (0 << 14)
+#define PCXR_MFL_1536           (1 << 14)
+#define PCXR_MFL_2048           (2 << 14)
+#define PCXR_MFL_64K            (3 << 14)
+#define PCXR_FLP                (1 << 11)
+#define PCXR_PRIO_TX_OFF        3
+#define PCXR_TX_HIGH_PRI        (7 << PCXR_PRIO_TX_OFF)
+
+/* Bit definitions of the SDMA Config Reg */
+#define SDCR_BSZ_OFF            12
+#define SDCR_BSZ8               (3 << SDCR_BSZ_OFF)
+#define SDCR_BSZ4               (2 << SDCR_BSZ_OFF)
+#define SDCR_BSZ2               (1 << SDCR_BSZ_OFF)
+#define SDCR_BSZ1               (0 << SDCR_BSZ_OFF)
+#define SDCR_BLMR               (1 << 6)
+#define SDCR_BLMT               (1 << 7)
+#define SDCR_RIFB               (1 << 9)
+#define SDCR_RC_OFF             2
+#define SDCR_RC_MAX_RETRANS     (0xf << SDCR_RC_OFF)
+
+/*
+ * Bit definitions of the Interrupt Cause Reg
+ * and Interrupt MASK Reg is the same
+ */
+#define ICR_RXBUF               (1 << 0)
+#define ICR_TXBUF_H             (1 << 2)
+#define ICR_TXBUF_L             (1 << 3)
+#define ICR_TXEND_H             (1 << 6)
+#define ICR_TXEND_L             (1 << 7)
+#define ICR_RXERR               (1 << 8)
+#define ICR_TXERR_H             (1 << 10)
+#define ICR_TXERR_L             (1 << 11)
+#define ICR_TX_UDR              (1 << 13)
+#define ICR_MII_CH              (1 << 28)
+
+#define ALL_INTS (ICR_TXBUF_H  | ICR_TXBUF_L  | ICR_TX_UDR |\
+                                ICR_TXERR_H  | ICR_TXERR_L |\
+                                ICR_TXEND_H  | ICR_TXEND_L |\
+                                ICR_RXBUF | ICR_RXERR  | ICR_MII_CH)
+
+#define ETH_HW_IP_ALIGN         2       /* hw aligns IP header */
+
+#define NUM_RX_DESCS            64
+#define NUM_TX_DESCS            64
+
+#define HASH_ADD                0
+#define HASH_DELETE             1
+#define HASH_ADDR_TABLE_SIZE    0x4000  /* 16K (1/2K address - PCR_HS == 1) */
+#define HOP_NUMBER              12
+
+/* Bit definitions for Port status */
+#define PORT_SPEED_100          (1 << 0)
+#define FULL_DUPLEX             (1 << 1)
+#define FLOW_CONTROL_ENABLED    (1 << 2)
+#define LINK_UP                 (1 << 3)
+
+/* Bit definitions for work to be done */
+#define WORK_LINK               (1 << 0)
+#define WORK_TX_DONE            (1 << 1)
+
+/*
+ * Misc definitions.
+ */
+#define SKB_DMA_REALIGN         ((PAGE_SIZE - NET_SKB_PAD) % SMP_CACHE_BYTES)
+
+struct rx_desc {
+        u32 cmd_sts;            /* Descriptor command status            */
+        u16 byte_cnt;           /* Descriptor buffer byte count         */
+        u16 buf_size;           /* Buffer size                          */
+        u32 buf_ptr;            /* Descriptor buffer pointer            */
+        u32 next_desc_ptr;      /* Next descriptor pointer              */
+};
+
+struct tx_desc {
+        u32 cmd_sts;            /* Command/status field                 */
+        u16 reserved;
+        u16 byte_cnt;           /* buffer byte count                    */
+        u32 buf_ptr;            /* pointer to buffer for this descriptor */
+        u32 next_desc_ptr;      /* Pointer to next descriptor           */
+};
+
+struct pxa168_eth_private {
+        int port_num;           /* User Ethernet port number    */
+
+        int rx_resource_err;    /* Rx ring resource error flag */
+
+        /* Next available and first returning Rx resource */
+        int rx_curr_desc_q, rx_used_desc_q;
+
+        /* Next available and first returning Tx resource */
+        int tx_curr_desc_q, tx_used_desc_q;
+
+        struct rx_desc *p_rx_desc_area;
+        dma_addr_t rx_desc_dma;
+        int rx_desc_area_size;
+        struct sk_buff **rx_skb;
+
+        struct tx_desc *p_tx_desc_area;
+        dma_addr_t tx_desc_dma;
+        int tx_desc_area_size;
+        struct sk_buff **tx_skb;
+
+        struct work_struct tx_timeout_task;
+
+        struct net_device *dev;
+        struct napi_struct napi;
+        u8 work_todo;
+        int skb_size;
+
+        struct net_device_stats stats;
+        /* Size of Tx Ring per queue */
+        int tx_ring_size;
+        /* Number of tx descriptors in use */
+        int tx_desc_count;
+        /* Size of Rx Ring per queue */
+        int rx_ring_size;
+        /* Number of rx descriptors in use */
+        int rx_desc_count;
+
+        /*
+         * Used in case RX Ring is empty, which can occur when
+         * system does not have resources (skb's)
+         */
+        struct timer_list timeout;
+        struct mii_bus *smi_bus;
+        struct phy_device *phy;
+
+        /* clock */
+        struct clk *clk;
+        struct pxa168_eth_platform_data *pd;
+        /*
+         * Ethernet controller base address.
+         */
+        void __iomem *base;
+
+        /* Pointer to the hardware address filter table */
+        void *htpr;
+        dma_addr_t htpr_dma;
+};
+
+struct addr_table_entry {
+        __le32 lo;
+        __le32 hi;
+};
+
+/* Bit fields of a Hash Table Entry */
+enum hash_table_entry {
+        HASH_ENTRY_VALID = 1,
+        SKIP = 2,
+        HASH_ENTRY_RECEIVE_DISCARD = 4,
+        HASH_ENTRY_RECEIVE_DISCARD_BIT = 2
+};
+
+static int pxa168_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
+static int pxa168_set_settings(struct net_device *dev, struct ethtool_cmd *cmd);
+static int pxa168_init_hw(struct pxa168_eth_private *pep);
+static void eth_port_reset(struct net_device *dev);
+static void eth_port_start(struct net_device *dev);
+static int pxa168_eth_open(struct net_device *dev);
+static int pxa168_eth_stop(struct net_device *dev);
+static int ethernet_phy_setup(struct net_device *dev);
+
+static inline u32 rdl(struct pxa168_eth_private *pep, int offset)
+{
+        return readl(pep->base + offset);
+}
+
+static inline void wrl(struct pxa168_eth_private *pep, int offset, u32 data)
+{
+        writel(data, pep->base + offset);
+}
+
+static void abort_dma(struct pxa168_eth_private *pep)
+{
+        int delay;
+        int max_retries = 40;
+
+        do {
+                wrl(pep, SDMA_CMD, SDMA_CMD_AR | SDMA_CMD_AT);
+                udelay(100);
+
+                delay = 10;
+                while ((rdl(pep, SDMA_CMD) & (SDMA_CMD_AR | SDMA_CMD_AT))
+                       && delay-- > 0) {
+                        udelay(10);
+                }
+        } while (max_retries-- > 0 && delay <= 0);
+
+        if (max_retries <= 0)
+                printk(KERN_ERR "%s : DMA Stuck\n", __func__);
+}
+
+static int ethernet_phy_get(struct pxa168_eth_private *pep)
+{
+        unsigned int reg_data;
+
+        reg_data = rdl(pep, PHY_ADDRESS);
+
+        return (reg_data >> (5 * pep->port_num)) & 0x1f;
+}
+
+static void ethernet_phy_set_addr(struct pxa168_eth_private *pep, int phy_addr)
+{
+        u32 reg_data;
+        int addr_shift = 5 * pep->port_num;
+
+        reg_data = rdl(pep, PHY_ADDRESS);
+        reg_data &= ~(0x1f << addr_shift);
+        reg_data |= (phy_addr & 0x1f) << addr_shift;
+        wrl(pep, PHY_ADDRESS, reg_data);
+}
+
+static void ethernet_phy_reset(struct pxa168_eth_private *pep)
+{
+        int data;
+
+        data = phy_read(pep->phy, MII_BMCR);
+        if (data < 0)
+                return;
+
+        data |= BMCR_RESET;
+        if (phy_write(pep->phy, MII_BMCR, data) < 0)
+                return;
+
+        do {
+                data = phy_read(pep->phy, MII_BMCR);
+        } while (data >= 0 && data & BMCR_RESET);
+}
+
+static void rxq_refill(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct sk_buff *skb;
+        struct rx_desc *p_used_rx_desc;
+        int used_rx_desc;
+
+        while (pep->rx_desc_count < pep->rx_ring_size) {
+                int size;
+
+                skb = dev_alloc_skb(pep->skb_size);
+                if (!skb)
+                        break;
+                if (SKB_DMA_REALIGN)
+                        skb_reserve(skb, SKB_DMA_REALIGN);
+                pep->rx_desc_count++;
+                /* Get 'used' Rx descriptor */
+                used_rx_desc = pep->rx_used_desc_q;
+                p_used_rx_desc = &pep->p_rx_desc_area[used_rx_desc];
+                size = skb->end - skb->data;
+                p_used_rx_desc->buf_ptr = dma_map_single(NULL,
+                                                         skb->data,
+                                                         size,
+                                                         DMA_FROM_DEVICE);
+                p_used_rx_desc->buf_size = size;
+                pep->rx_skb[used_rx_desc] = skb;
+
+                /* Return the descriptor to DMA ownership */
+                wmb();
+                p_used_rx_desc->cmd_sts = BUF_OWNED_BY_DMA | RX_EN_INT;
+                wmb();
+
+                /* Move the used descriptor pointer to the next descriptor */
+                pep->rx_used_desc_q = (used_rx_desc + 1) % pep->rx_ring_size;
+
+                /* Any Rx return cancels the Rx resource error status */
+                pep->rx_resource_err = 0;
+
+                skb_reserve(skb, ETH_HW_IP_ALIGN);
+        }
+
+        /*
+         * If RX ring is empty of SKB, set a timer to try allocating
+         * again at a later time.
+         */
+        if (pep->rx_desc_count == 0) {
+                pep->timeout.expires = jiffies + (HZ / 10);
+                add_timer(&pep->timeout);
+        }
+}
+
+static inline void rxq_refill_timer_wrapper(unsigned long data)
+{
+        struct pxa168_eth_private *pep = (void *)data;
+        napi_schedule(&pep->napi);
+}
+
+static inline u8 flip_8_bits(u8 x)
+{
+        return (((x) & 0x01) << 3) | (((x) & 0x02) << 1)
+            | (((x) & 0x04) >> 1) | (((x) & 0x08) >> 3)
+            | (((x) & 0x10) << 3) | (((x) & 0x20) << 1)
+            | (((x) & 0x40) >> 1) | (((x) & 0x80) >> 3);
+}
+
+static void nibble_swap_every_byte(unsigned char *mac_addr)
+{
+        int i;
+        for (i = 0; i < ETH_ALEN; i++) {
+                mac_addr[i] = ((mac_addr[i] & 0x0f) << 4) |
+                                ((mac_addr[i] & 0xf0) >> 4);
+        }
+}
+
+static void inverse_every_nibble(unsigned char *mac_addr)
+{
+        int i;
+        for (i = 0; i < ETH_ALEN; i++)
+                mac_addr[i] = flip_8_bits(mac_addr[i]);
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * This function will calculate the hash function of the address.
+ * Inputs
+ * mac_addr_orig    - MAC address.
+ * Outputs
+ * return the calculated entry.
+ */
+static u32 hash_function(unsigned char *mac_addr_orig)
+{
+        u32 hash_result;
+        u32 addr0;
+        u32 addr1;
+        u32 addr2;
+        u32 addr3;
+        unsigned char mac_addr[ETH_ALEN];
+
+        /* Make a copy of MAC address since we are going to performe bit
+         * operations on it
+         */
+        memcpy(mac_addr, mac_addr_orig, ETH_ALEN);
+
+        nibble_swap_every_byte(mac_addr);
+        inverse_every_nibble(mac_addr);
+
+        addr0 = (mac_addr[5] >> 2) & 0x3f;
+        addr1 = (mac_addr[5] & 0x03) | (((mac_addr[4] & 0x7f)) << 2);
+        addr2 = ((mac_addr[4] & 0x80) >> 7) | mac_addr[3] << 1;
+        addr3 = (mac_addr[2] & 0xff) | ((mac_addr[1] & 1) << 8);
+
+        hash_result = (addr0 << 9) | (addr1 ^ addr2 ^ addr3);
+        hash_result = hash_result & 0x07ff;
+        return hash_result;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * This function will add/del an entry to the address table.
+ * Inputs
+ * pep - ETHERNET .
+ * mac_addr - MAC address.
+ * skip - if 1, skip this address.Used in case of deleting an entry which is a
+ *        part of chain in the hash table.We cant just delete the entry since
+ *        that will break the chain.We need to defragment the tables time to
+ *        time.
+ * rd   - 0 Discard packet upon match.
+ *      - 1 Receive packet upon match.
+ * Outputs
+ * address table entry is added/deleted.
+ * 0 if success.
+ * -ENOSPC if table full
+ */
+static int add_del_hash_entry(struct pxa168_eth_private *pep,
+                              unsigned char *mac_addr,
+                              u32 rd, u32 skip, int del)
+{
+        struct addr_table_entry *entry, *start;
+        u32 new_high;
+        u32 new_low;
+        u32 i;
+
+        new_low = (((mac_addr[1] >> 4) & 0xf) << 15)
+            | (((mac_addr[1] >> 0) & 0xf) << 11)
+            | (((mac_addr[0] >> 4) & 0xf) << 7)
+            | (((mac_addr[0] >> 0) & 0xf) << 3)
+            | (((mac_addr[3] >> 4) & 0x1) << 31)
+            | (((mac_addr[3] >> 0) & 0xf) << 27)
+            | (((mac_addr[2] >> 4) & 0xf) << 23)
+            | (((mac_addr[2] >> 0) & 0xf) << 19)
+            | (skip << SKIP) | (rd << HASH_ENTRY_RECEIVE_DISCARD_BIT)
+            | HASH_ENTRY_VALID;
+
+        new_high = (((mac_addr[5] >> 4) & 0xf) << 15)
+            | (((mac_addr[5] >> 0) & 0xf) << 11)
+            | (((mac_addr[4] >> 4) & 0xf) << 7)
+            | (((mac_addr[4] >> 0) & 0xf) << 3)
+            | (((mac_addr[3] >> 5) & 0x7) << 0);
+
+        /*
+         * Pick the appropriate table, start scanning for free/reusable
+         * entries at the index obtained by hashing the specified MAC address
+         */
+        start = (struct addr_table_entry *)(pep->htpr);
+        entry = start + hash_function(mac_addr);
+        for (i = 0; i < HOP_NUMBER; i++) {
+                if (!(le32_to_cpu(entry->lo) & HASH_ENTRY_VALID)) {
+                        break;
+                } else {
+                        /* if same address put in same position */
+                        if (((le32_to_cpu(entry->lo) & 0xfffffff8) ==
+                                (new_low & 0xfffffff8)) &&
+                                (le32_to_cpu(entry->hi) == new_high)) {
+                                break;
+                        }
+                }
+                if (entry == start + 0x7ff)
+                        entry = start;
+                else
+                        entry++;
+        }
+
+        if (((le32_to_cpu(entry->lo) & 0xfffffff8) != (new_low & 0xfffffff8)) &&
+            (le32_to_cpu(entry->hi) != new_high) && del)
+                return 0;
+
+        if (i == HOP_NUMBER) {
+                if (!del) {
+                        printk(KERN_INFO "%s: table section is full, need to "
+                                        "move to 16kB implementation?\n",
+                                         __FILE__);
+                        return -ENOSPC;
+                } else
+                        return 0;
+        }
+
+        /*
+         * Update the selected entry
+         */
+        if (del) {
+                entry->hi = 0;
+                entry->lo = 0;
+        } else {
+                entry->hi = cpu_to_le32(new_high);
+                entry->lo = cpu_to_le32(new_low);
+        }
+
+        return 0;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *  Create an addressTable entry from MAC address info
+ *  found in the specifed net_device struct
+ *
+ *  Input : pointer to ethernet interface network device structure
+ *  Output : N/A
+ */
+static void update_hash_table_mac_address(struct pxa168_eth_private *pep,
+                                          unsigned char *oaddr,
+                                          unsigned char *addr)
+{
+        /* Delete old entry */
+        if (oaddr)
+                add_del_hash_entry(pep, oaddr, 1, 0, HASH_DELETE);
+        /* Add new entry */
+        add_del_hash_entry(pep, addr, 1, 0, HASH_ADD);
+}
+
+static int init_hash_table(struct pxa168_eth_private *pep)
+{
+        /*
+         * Hardware expects CPU to build a hash table based on a predefined
+         * hash function and populate it based on hardware address. The
+         * location of the hash table is identified by 32-bit pointer stored
+         * in HTPR internal register. Two possible sizes exists for the hash
+         * table 8kB (256kB of DRAM required (4 x 64 kB banks)) and 1/2kB
+         * (16kB of DRAM required (4 x 4 kB banks)).We currently only support
+         * 1/2kB.
+         */
+        /* TODO: Add support for 8kB hash table and alternative hash
+         * function.Driver can dynamically switch to them if the 1/2kB hash
+         * table is full.
+         */
+        if (pep->htpr == NULL) {
+                pep->htpr = dma_alloc_coherent(pep->dev->dev.parent,
+                                              HASH_ADDR_TABLE_SIZE,
+                                              &pep->htpr_dma, GFP_KERNEL);
+                if (pep->htpr == NULL)
+                        return -ENOMEM;
+        }
+        memset(pep->htpr, 0, HASH_ADDR_TABLE_SIZE);
+        wrl(pep, HTPR, pep->htpr_dma);
+        return 0;
+}
+
+static void pxa168_eth_set_rx_mode(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct netdev_hw_addr *ha;
+        u32 val;
+
+        val = rdl(pep, PORT_CONFIG);
+        if (dev->flags & IFF_PROMISC)
+                val |= PCR_PM;
+        else
+                val &= ~PCR_PM;
+        wrl(pep, PORT_CONFIG, val);
+
+        /*
+         * Remove the old list of MAC address and add dev->addr
+         * and multicast address.
+         */
+        memset(pep->htpr, 0, HASH_ADDR_TABLE_SIZE);
+        update_hash_table_mac_address(pep, NULL, dev->dev_addr);
+
+        netdev_for_each_mc_addr(ha, dev)
+                update_hash_table_mac_address(pep, NULL, ha->addr);
+}
+
+static int pxa168_eth_set_mac_address(struct net_device *dev, void *addr)
+{
+        struct sockaddr *sa = addr;
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        unsigned char oldMac[ETH_ALEN];
+
+        if (!is_valid_ether_addr(sa->sa_data))
+                return -EINVAL;
+        memcpy(oldMac, dev->dev_addr, ETH_ALEN);
+        memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN);
+        netif_addr_lock_bh(dev);
+        update_hash_table_mac_address(pep, oldMac, dev->dev_addr);
+        netif_addr_unlock_bh(dev);
+        return 0;
+}
+
+static void eth_port_start(struct net_device *dev)
+{
+        unsigned int val = 0;
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        int tx_curr_desc, rx_curr_desc;
+
+        /* Perform PHY reset, if there is a PHY. */
+        if (pep->phy != NULL) {
+                struct ethtool_cmd cmd;
+
+                pxa168_get_settings(pep->dev, &cmd);
+                ethernet_phy_reset(pep);
+                pxa168_set_settings(pep->dev, &cmd);
+        }
+
+        /* Assignment of Tx CTRP of given queue */
+        tx_curr_desc = pep->tx_curr_desc_q;
+        wrl(pep, ETH_C_TX_DESC_1,
+            (u32) (pep->tx_desc_dma + tx_curr_desc * sizeof(struct tx_desc)));
+
+        /* Assignment of Rx CRDP of given queue */
+        rx_curr_desc = pep->rx_curr_desc_q;
+        wrl(pep, ETH_C_RX_DESC_0,
+            (u32) (pep->rx_desc_dma + rx_curr_desc * sizeof(struct rx_desc)));
+
+        wrl(pep, ETH_F_RX_DESC_0,
+            (u32) (pep->rx_desc_dma + rx_curr_desc * sizeof(struct rx_desc)));
+
+        /* Clear all interrupts */
+        wrl(pep, INT_CAUSE, 0);
+
+        /* Enable all interrupts for receive, transmit and error. */
+        wrl(pep, INT_MASK, ALL_INTS);
+
+        val = rdl(pep, PORT_CONFIG);
+        val |= PCR_EN;
+        wrl(pep, PORT_CONFIG, val);
+
+        /* Start RX DMA engine */
+        val = rdl(pep, SDMA_CMD);
+        val |= SDMA_CMD_ERD;
+        wrl(pep, SDMA_CMD, val);
+}
+
+static void eth_port_reset(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        unsigned int val = 0;
+
+        /* Stop all interrupts for receive, transmit and error. */
+        wrl(pep, INT_MASK, 0);
+
+        /* Clear all interrupts */
+        wrl(pep, INT_CAUSE, 0);
+
+        /* Stop RX DMA */
+        val = rdl(pep, SDMA_CMD);
+        val &= ~SDMA_CMD_ERD;   /* abort dma command */
+
+        /* Abort any transmit and receive operations and put DMA
+         * in idle state.
+         */
+        abort_dma(pep);
+
+        /* Disable port */
+        val = rdl(pep, PORT_CONFIG);
+        val &= ~PCR_EN;
+        wrl(pep, PORT_CONFIG, val);
+}
+
+/*
+ * txq_reclaim - Free the tx desc data for completed descriptors
+ * If force is non-zero, frees uncompleted descriptors as well
+ */
+static int txq_reclaim(struct net_device *dev, int force)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct tx_desc *desc;
+        u32 cmd_sts;
+        struct sk_buff *skb;
+        int tx_index;
+        dma_addr_t addr;
+        int count;
+        int released = 0;
+
+        netif_tx_lock(dev);
+
+        pep->work_todo &= ~WORK_TX_DONE;
+        while (pep->tx_desc_count > 0) {
+                tx_index = pep->tx_used_desc_q;
+                desc = &pep->p_tx_desc_area[tx_index];
+                cmd_sts = desc->cmd_sts;
+                if (!force && (cmd_sts & BUF_OWNED_BY_DMA)) {
+                        if (released > 0) {
+                                goto txq_reclaim_end;
+                        } else {
+                                released = -1;
+                                goto txq_reclaim_end;
+                        }
+                }
+                pep->tx_used_desc_q = (tx_index + 1) % pep->tx_ring_size;
+                pep->tx_desc_count--;
+                addr = desc->buf_ptr;
+                count = desc->byte_cnt;
+                skb = pep->tx_skb[tx_index];
+                if (skb)
+                        pep->tx_skb[tx_index] = NULL;
+
+                if (cmd_sts & TX_ERROR) {
+                        if (net_ratelimit())
+                                printk(KERN_ERR "%s: Error in TX\n", dev->name);
+                        dev->stats.tx_errors++;
+                }
+                dma_unmap_single(NULL, addr, count, DMA_TO_DEVICE);
+                if (skb)
+                        dev_kfree_skb_irq(skb);
+                released++;
+        }
+txq_reclaim_end:
+        netif_tx_unlock(dev);
+        return released;
+}
+
+static void pxa168_eth_tx_timeout(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        printk(KERN_INFO "%s: TX timeout  desc_count %d\n",
+               dev->name, pep->tx_desc_count);
+
+        schedule_work(&pep->tx_timeout_task);
+}
+
+static void pxa168_eth_tx_timeout_task(struct work_struct *work)
+{
+        struct pxa168_eth_private *pep = container_of(work,
+                                                 struct pxa168_eth_private,
+                                                 tx_timeout_task);
+        struct net_device *dev = pep->dev;
+        pxa168_eth_stop(dev);
+        pxa168_eth_open(dev);
+}
+
+static int rxq_process(struct net_device *dev, int budget)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct net_device_stats *stats = &dev->stats;
+        unsigned int received_packets = 0;
+        struct sk_buff *skb;
+
+        while (budget-- > 0) {
+                int rx_next_curr_desc, rx_curr_desc, rx_used_desc;
+                struct rx_desc *rx_desc;
+                unsigned int cmd_sts;
+
+                /* Do not process Rx ring in case of Rx ring resource error */
+                if (pep->rx_resource_err)
+                        break;
+                rx_curr_desc = pep->rx_curr_desc_q;
+                rx_used_desc = pep->rx_used_desc_q;
+                rx_desc = &pep->p_rx_desc_area[rx_curr_desc];
+                cmd_sts = rx_desc->cmd_sts;
+                rmb();
+                if (cmd_sts & (BUF_OWNED_BY_DMA))
+                        break;
+                skb = pep->rx_skb[rx_curr_desc];
+                pep->rx_skb[rx_curr_desc] = NULL;
+
+                rx_next_curr_desc = (rx_curr_desc + 1) % pep->rx_ring_size;
+                pep->rx_curr_desc_q = rx_next_curr_desc;
+
+                /* Rx descriptors exhausted. */
+                /* Set the Rx ring resource error flag */
+                if (rx_next_curr_desc == rx_used_desc)
+                        pep->rx_resource_err = 1;
+                pep->rx_desc_count--;
+                dma_unmap_single(NULL, rx_desc->buf_ptr,
+                                 rx_desc->buf_size,
+                                 DMA_FROM_DEVICE);
+                received_packets++;
+                /*
+                 * Update statistics.
+                 * Note byte count includes 4 byte CRC count
+                 */
+                stats->rx_packets++;
+                stats->rx_bytes += rx_desc->byte_cnt;
+                /*
+                 * In case received a packet without first / last bits on OR
+                 * the error summary bit is on, the packets needs to be droped.
+                 */
+                if (((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC)) !=
+                     (RX_FIRST_DESC | RX_LAST_DESC))
+                    || (cmd_sts & RX_ERROR)) {
+
+                        stats->rx_dropped++;
+                        if ((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC)) !=
+                            (RX_FIRST_DESC | RX_LAST_DESC)) {
+                                if (net_ratelimit())
+                                        printk(KERN_ERR
+                                               "%s: Rx pkt on multiple desc\n",
+                                               dev->name);
+                        }
+                        if (cmd_sts & RX_ERROR)
+                                stats->rx_errors++;
+                        dev_kfree_skb_irq(skb);
+                } else {
+                        /*
+                         * The -4 is for the CRC in the trailer of the
+                         * received packet
+                         */
+                        skb_put(skb, rx_desc->byte_cnt - 4);
+                        skb->protocol = eth_type_trans(skb, dev);
+                        netif_receive_skb(skb);
+                }
+                dev->last_rx = jiffies;
+        }
+        /* Fill RX ring with skb's */
+        rxq_refill(dev);
+        return received_packets;
+}
+
+static int pxa168_eth_collect_events(struct pxa168_eth_private *pep,
+                                     struct net_device *dev)
+{
+        u32 icr;
+        int ret = 0;
+
+        icr = rdl(pep, INT_CAUSE);
+        if (icr == 0)
+                return IRQ_NONE;
+
+        wrl(pep, INT_CAUSE, ~icr);
+        if (icr & (ICR_TXBUF_H | ICR_TXBUF_L)) {
+                pep->work_todo |= WORK_TX_DONE;
+                ret = 1;
+        }
+        if (icr & ICR_RXBUF)
+                ret = 1;
+        if (icr & ICR_MII_CH) {
+                pep->work_todo |= WORK_LINK;
+                ret = 1;
+        }
+        return ret;
+}
+
+static void handle_link_event(struct pxa168_eth_private *pep)
+{
+        struct net_device *dev = pep->dev;
+        u32 port_status;
+        int speed;
+        int duplex;
+        int fc;
+
+        port_status = rdl(pep, PORT_STATUS);
+        if (!(port_status & LINK_UP)) {
+                if (netif_carrier_ok(dev)) {
+                        printk(KERN_INFO "%s: link down\n", dev->name);
+                        netif_carrier_off(dev);
+                        txq_reclaim(dev, 1);
+                }
+                return;
+        }
+        if (port_status & PORT_SPEED_100)
+                speed = 100;
+        else
+                speed = 10;
+
+        duplex = (port_status & FULL_DUPLEX) ? 1 : 0;
+        fc = (port_status & FLOW_CONTROL_ENABLED) ? 1 : 0;
+        printk(KERN_INFO "%s: link up, %d Mb/s, %s duplex, "
+               "flow control %sabled\n", dev->name,
+               speed, duplex ? "full" : "half", fc ? "en" : "dis");
+        if (!netif_carrier_ok(dev))
+                netif_carrier_on(dev);
+}
+
+static irqreturn_t pxa168_eth_int_handler(int irq, void *dev_id)
+{
+        struct net_device *dev = (struct net_device *)dev_id;
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        if (unlikely(!pxa168_eth_collect_events(pep, dev)))
+                return IRQ_NONE;
+        /* Disable interrupts */
+        wrl(pep, INT_MASK, 0);
+        napi_schedule(&pep->napi);
+        return IRQ_HANDLED;
+}
+
+static void pxa168_eth_recalc_skb_size(struct pxa168_eth_private *pep)
+{
+        int skb_size;
+
+        /*
+         * Reserve 2+14 bytes for an ethernet header (the hardware
+         * automatically prepends 2 bytes of dummy data to each
+         * received packet), 16 bytes for up to four VLAN tags, and
+         * 4 bytes for the trailing FCS -- 36 bytes total.
+         */
+        skb_size = pep->dev->mtu + 36;
+
+        /*
+         * Make sure that the skb size is a multiple of 8 bytes, as
+         * the lower three bits of the receive descriptor's buffer
+         * size field are ignored by the hardware.
+         */
+        pep->skb_size = (skb_size + 7) & ~7;
+
+        /*
+         * If NET_SKB_PAD is smaller than a cache line,
+         * netdev_alloc_skb() will cause skb->data to be misaligned
+         * to a cache line boundary.  If this is the case, include
+         * some extra space to allow re-aligning the data area.
+         */
+        pep->skb_size += SKB_DMA_REALIGN;
+
+}
+
+static int set_port_config_ext(struct pxa168_eth_private *pep)
+{
+        int skb_size;
+
+        pxa168_eth_recalc_skb_size(pep);
+        if  (pep->skb_size <= 1518)
+                skb_size = PCXR_MFL_1518;
+        else if (pep->skb_size <= 1536)
+                skb_size = PCXR_MFL_1536;
+        else if (pep->skb_size <= 2048)
+                skb_size = PCXR_MFL_2048;
+        else
+                skb_size = PCXR_MFL_64K;
+
+        /* Extended Port Configuration */
+        wrl(pep,
+            PORT_CONFIG_EXT, PCXR_2BSM | /* Two byte prefix aligns IP hdr */
+            PCXR_DSCP_EN |               /* Enable DSCP in IP */
+            skb_size | PCXR_FLP |        /* do not force link pass */
+            PCXR_TX_HIGH_PRI);           /* Transmit - high priority queue */
+
+        return 0;
+}
+
+static int pxa168_init_hw(struct pxa168_eth_private *pep)
+{
+        int err = 0;
+
+        /* Disable interrupts */
+        wrl(pep, INT_MASK, 0);
+        wrl(pep, INT_CAUSE, 0);
+        /* Write to ICR to clear interrupts. */
+        wrl(pep, INT_W_CLEAR, 0);
+        /* Abort any transmit and receive operations and put DMA
+         * in idle state.
+         */
+        abort_dma(pep);
+        /* Initialize address hash table */
+        err = init_hash_table(pep);
+        if (err)
+                return err;
+        /* SDMA configuration */
+        wrl(pep, SDMA_CONFIG, SDCR_BSZ8 |       /* Burst size = 32 bytes */
+            SDCR_RIFB |                         /* Rx interrupt on frame */
+            SDCR_BLMT |                         /* Little endian transmit */
+            SDCR_BLMR |                         /* Little endian receive */
+            SDCR_RC_MAX_RETRANS);               /* Max retransmit count */
+        /* Port Configuration */
+        wrl(pep, PORT_CONFIG, PCR_HS);          /* Hash size is 1/2kb */
+        set_port_config_ext(pep);
+
+        return err;
+}
+
+static int rxq_init(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct rx_desc *p_rx_desc;
+        int size = 0, i = 0;
+        int rx_desc_num = pep->rx_ring_size;
+
+        /* Allocate RX skb rings */
+        pep->rx_skb = kmalloc(sizeof(*pep->rx_skb) * pep->rx_ring_size,
+                             GFP_KERNEL);
+        if (!pep->rx_skb) {
+                printk(KERN_ERR "%s: Cannot alloc RX skb ring\n", dev->name);
+                return -ENOMEM;
+        }
+        /* Allocate RX ring */
+        pep->rx_desc_count = 0;
+        size = pep->rx_ring_size * sizeof(struct rx_desc);
+        pep->rx_desc_area_size = size;
+        pep->p_rx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                &pep->rx_desc_dma, GFP_KERNEL);
+        if (!pep->p_rx_desc_area) {
+                printk(KERN_ERR "%s: Cannot alloc RX ring (size %d bytes)\n",
+                       dev->name, size);
+                goto out;
+        }
+        memset((void *)pep->p_rx_desc_area, 0, size);
+        /* initialize the next_desc_ptr links in the Rx descriptors ring */
+        p_rx_desc = (struct rx_desc *)pep->p_rx_desc_area;
+        for (i = 0; i < rx_desc_num; i++) {
+                p_rx_desc[i].next_desc_ptr = pep->rx_desc_dma +
+                    ((i + 1) % rx_desc_num) * sizeof(struct rx_desc);
+        }
+        /* Save Rx desc pointer to driver struct. */
+        pep->rx_curr_desc_q = 0;
+        pep->rx_used_desc_q = 0;
+        pep->rx_desc_area_size = rx_desc_num * sizeof(struct rx_desc);
+        return 0;
+out:
+        kfree(pep->rx_skb);
+        return -ENOMEM;
+}
+
+static void rxq_deinit(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        int curr;
+
+        /* Free preallocated skb's on RX rings */
+        for (curr = 0; pep->rx_desc_count && curr < pep->rx_ring_size; curr++) {
+                if (pep->rx_skb[curr]) {
+                        dev_kfree_skb(pep->rx_skb[curr]);
+                        pep->rx_desc_count--;
+                }
+        }
+        if (pep->rx_desc_count)
+                printk(KERN_ERR
+                       "Error in freeing Rx Ring. %d skb's still\n",
+                       pep->rx_desc_count);
+        /* Free RX ring */
+        if (pep->p_rx_desc_area)
+                dma_free_coherent(pep->dev->dev.parent, pep->rx_desc_area_size,
+                                  pep->p_rx_desc_area, pep->rx_desc_dma);
+        kfree(pep->rx_skb);
+}
+
+static int txq_init(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct tx_desc *p_tx_desc;
+        int size = 0, i = 0;
+        int tx_desc_num = pep->tx_ring_size;
+
+        pep->tx_skb = kmalloc(sizeof(*pep->tx_skb) * pep->tx_ring_size,
+                             GFP_KERNEL);
+        if (!pep->tx_skb) {
+                printk(KERN_ERR "%s: Cannot alloc TX skb ring\n", dev->name);
+                return -ENOMEM;
+        }
+        /* Allocate TX ring */
+        pep->tx_desc_count = 0;
+        size = pep->tx_ring_size * sizeof(struct tx_desc);
+        pep->tx_desc_area_size = size;
+        pep->p_tx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                &pep->tx_desc_dma, GFP_KERNEL);
+        if (!pep->p_tx_desc_area) {
+                printk(KERN_ERR "%s: Cannot allocate Tx Ring (size %d bytes)\n",
+                       dev->name, size);
+                goto out;
+        }
+        memset((void *)pep->p_tx_desc_area, 0, pep->tx_desc_area_size);
+        /* Initialize the next_desc_ptr links in the Tx descriptors ring */
+        p_tx_desc = (struct tx_desc *)pep->p_tx_desc_area;
+        for (i = 0; i < tx_desc_num; i++) {
+                p_tx_desc[i].next_desc_ptr = pep->tx_desc_dma +
+                    ((i + 1) % tx_desc_num) * sizeof(struct tx_desc);
+        }
+        pep->tx_curr_desc_q = 0;
+        pep->tx_used_desc_q = 0;
+        pep->tx_desc_area_size = tx_desc_num * sizeof(struct tx_desc);
+        return 0;
+out:
+        kfree(pep->tx_skb);
+        return -ENOMEM;
+}
+
+static void txq_deinit(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        /* Free outstanding skb's on TX ring */
+        txq_reclaim(dev, 1);
+        BUG_ON(pep->tx_used_desc_q != pep->tx_curr_desc_q);
+        /* Free TX ring */
+        if (pep->p_tx_desc_area)
+                dma_free_coherent(pep->dev->dev.parent, pep->tx_desc_area_size,
+                                  pep->p_tx_desc_area, pep->tx_desc_dma);
+        kfree(pep->tx_skb);
+}
+
+static int pxa168_eth_open(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        int err;
+
+        err = request_irq(dev->irq, pxa168_eth_int_handler,
+                          IRQF_DISABLED, dev->name, dev);
+        if (err) {
+                dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
+                return -EAGAIN;
+        }
+        pep->rx_resource_err = 0;
+        err = rxq_init(dev);
+        if (err != 0)
+                goto out_free_irq;
+        err = txq_init(dev);
+        if (err != 0)
+                goto out_free_rx_skb;
+        pep->rx_used_desc_q = 0;
+        pep->rx_curr_desc_q = 0;
+
+        /* Fill RX ring with skb's */
+        rxq_refill(dev);
+        pep->rx_used_desc_q = 0;
+        pep->rx_curr_desc_q = 0;
+        netif_carrier_off(dev);
+        eth_port_start(dev);
+        napi_enable(&pep->napi);
+        return 0;
+out_free_rx_skb:
+        rxq_deinit(dev);
+out_free_irq:
+        free_irq(dev->irq, dev);
+        return err;
+}
+
+static int pxa168_eth_stop(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        eth_port_reset(dev);
+
+        /* Disable interrupts */
+        wrl(pep, INT_MASK, 0);
+        wrl(pep, INT_CAUSE, 0);
+        /* Write to ICR to clear interrupts. */
+        wrl(pep, INT_W_CLEAR, 0);
+        napi_disable(&pep->napi);
+        del_timer_sync(&pep->timeout);
+        netif_carrier_off(dev);
+        free_irq(dev->irq, dev);
+        rxq_deinit(dev);
+        txq_deinit(dev);
+
+        return 0;
+}
+
+static int pxa168_eth_change_mtu(struct net_device *dev, int mtu)
+{
+        int retval;
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        if ((mtu > 9500) || (mtu < 68))
+                return -EINVAL;
+
+        dev->mtu = mtu;
+        retval = set_port_config_ext(pep);
+
+        if (!netif_running(dev))
+                return 0;
+
+        /*
+         * Stop and then re-open the interface. This will allocate RX
+         * skbs of the new MTU.
+         * There is a possible danger that the open will not succeed,
+         * due to memory being full.
+         */
+        pxa168_eth_stop(dev);
+        if (pxa168_eth_open(dev)) {
+                dev_printk(KERN_ERR, &dev->dev,
+                           "fatal error on re-opening device after "
+                           "MTU change\n");
+        }
+
+        return 0;
+}
+
+static int eth_alloc_tx_desc_index(struct pxa168_eth_private *pep)
+{
+        int tx_desc_curr;
+
+        tx_desc_curr = pep->tx_curr_desc_q;
+        pep->tx_curr_desc_q = (tx_desc_curr + 1) % pep->tx_ring_size;
+        BUG_ON(pep->tx_curr_desc_q == pep->tx_used_desc_q);
+        pep->tx_desc_count++;
+
+        return tx_desc_curr;
+}
+
+static int pxa168_rx_poll(struct napi_struct *napi, int budget)
+{
+        struct pxa168_eth_private *pep =
+            container_of(napi, struct pxa168_eth_private, napi);
+        struct net_device *dev = pep->dev;
+        int work_done = 0;
+
+        if (unlikely(pep->work_todo & WORK_LINK)) {
+                pep->work_todo &= ~(WORK_LINK);
+                handle_link_event(pep);
+        }
+        /*
+         * We call txq_reclaim every time since in NAPI interupts are disabled
+         * and due to this we miss the TX_DONE interrupt,which is not updated in
+         * interrupt status register.
+         */
+        txq_reclaim(dev, 0);
+        if (netif_queue_stopped(dev)
+            && pep->tx_ring_size - pep->tx_desc_count > 1) {
+                netif_wake_queue(dev);
+        }
+        work_done = rxq_process(dev, budget);
+        if (work_done < budget) {
+                napi_complete(napi);
+                wrl(pep, INT_MASK, ALL_INTS);
+        }
+
+        return work_done;
+}
+
+static int pxa168_eth_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        struct net_device_stats *stats = &dev->stats;
+        struct tx_desc *desc;
+        int tx_index;
+        int length;
+
+        tx_index = eth_alloc_tx_desc_index(pep);
+        desc = &pep->p_tx_desc_area[tx_index];
+        length = skb->len;
+        pep->tx_skb[tx_index] = skb;
+        desc->byte_cnt = length;
+        desc->buf_ptr = dma_map_single(NULL, skb->data, length, DMA_TO_DEVICE);
+        wmb();
+        desc->cmd_sts = BUF_OWNED_BY_DMA | TX_GEN_CRC | TX_FIRST_DESC |
+                        TX_ZERO_PADDING | TX_LAST_DESC | TX_EN_INT;
+        wmb();
+        wrl(pep, SDMA_CMD, SDMA_CMD_TXDH | SDMA_CMD_ERD);
+
+        stats->tx_bytes += skb->len;
+        stats->tx_packets++;
+        dev->trans_start = jiffies;
+        if (pep->tx_ring_size - pep->tx_desc_count <= 1) {
+                /* We handled the current skb, but now we are out of space.*/
+                netif_stop_queue(dev);
+        }
+
+        return NETDEV_TX_OK;
+}
+
+static int smi_wait_ready(struct pxa168_eth_private *pep)
+{
+        int i = 0;
+
+        /* wait for the SMI register to become available */
+        for (i = 0; rdl(pep, SMI) & SMI_BUSY; i++) {
+                if (i == PHY_WAIT_ITERATIONS)
+                        return -ETIMEDOUT;
+                msleep(10);
+        }
+
+        return 0;
+}
+
+static int pxa168_smi_read(struct mii_bus *bus, int phy_addr, int regnum)
+{
+        struct pxa168_eth_private *pep = bus->priv;
+        int i = 0;
+        int val;
+
+        if (smi_wait_ready(pep)) {
+                printk(KERN_WARNING "pxa168_eth: SMI bus busy timeout\n");
+                return -ETIMEDOUT;
+        }
+        wrl(pep, SMI, (phy_addr << 16) | (regnum << 21) | SMI_OP_R);
+        /* now wait for the data to be valid */
+        for (i = 0; !((val = rdl(pep, SMI)) & SMI_R_VALID); i++) {
+                if (i == PHY_WAIT_ITERATIONS) {
+                        printk(KERN_WARNING
+                                "pxa168_eth: SMI bus read not valid\n");
+                        return -ENODEV;
+                }
+                msleep(10);
+        }
+
+        return val & 0xffff;
+}
+
+static int pxa168_smi_write(struct mii_bus *bus, int phy_addr, int regnum,
+                            u16 value)
+{
+        struct pxa168_eth_private *pep = bus->priv;
+
+        if (smi_wait_ready(pep)) {
+                printk(KERN_WARNING "pxa168_eth: SMI bus busy timeout\n");
+                return -ETIMEDOUT;
+        }
+
+        wrl(pep, SMI, (phy_addr << 16) | (regnum << 21) |
+            SMI_OP_W | (value & 0xffff));
+
+        if (smi_wait_ready(pep)) {
+                printk(KERN_ERR "pxa168_eth: SMI bus busy timeout\n");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static int pxa168_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr,
+                               int cmd)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        if (pep->phy != NULL)
+                return phy_mii_ioctl(pep->phy, ifr, cmd);
+
+        return -EOPNOTSUPP;
+}
+
+static struct phy_device *phy_scan(struct pxa168_eth_private *pep, int phy_addr)
+{
+        struct mii_bus *bus = pep->smi_bus;
+        struct phy_device *phydev;
+        int start;
+        int num;
+        int i;
+
+        if (phy_addr == PXA168_ETH_PHY_ADDR_DEFAULT) {
+                /* Scan entire range */
+                start = ethernet_phy_get(pep);
+                num = 32;
+        } else {
+                /* Use phy addr specific to platform */
+                start = phy_addr & 0x1f;
+                num = 1;
+        }
+        phydev = NULL;
+        for (i = 0; i < num; i++) {
+                int addr = (start + i) & 0x1f;
+                if (bus->phy_map[addr] == NULL)
+                        mdiobus_scan(bus, addr);
+
+                if (phydev == NULL) {
+                        phydev = bus->phy_map[addr];
+                        if (phydev != NULL)
+                                ethernet_phy_set_addr(pep, addr);
+                }
+        }
+
+        return phydev;
+}
+
+static void phy_init(struct pxa168_eth_private *pep, int speed, int duplex)
+{
+        struct phy_device *phy = pep->phy;
+        ethernet_phy_reset(pep);
+
+        phy_attach(pep->dev, dev_name(&phy->dev), 0, PHY_INTERFACE_MODE_MII);
+
+        if (speed == 0) {
+                phy->autoneg = AUTONEG_ENABLE;
+                phy->speed = 0;
+                phy->duplex = 0;
+                phy->supported &= PHY_BASIC_FEATURES;
+                phy->advertising = phy->supported | ADVERTISED_Autoneg;
+        } else {
+                phy->autoneg = AUTONEG_DISABLE;
+                phy->advertising = 0;
+                phy->speed = speed;
+                phy->duplex = duplex;
+        }
+        phy_start_aneg(phy);
+}
+
+static int ethernet_phy_setup(struct net_device *dev)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        if (pep->pd->init)
+                pep->pd->init();
+        pep->phy = phy_scan(pep, pep->pd->phy_addr & 0x1f);
+        if (pep->phy != NULL)
+                phy_init(pep, pep->pd->speed, pep->pd->duplex);
+        update_hash_table_mac_address(pep, NULL, dev->dev_addr);
+
+        return 0;
+}
+
+static int pxa168_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+        int err;
+
+        err = phy_read_status(pep->phy);
+        if (err == 0)
+                err = phy_ethtool_gset(pep->phy, cmd);
+
+        return err;
+}
+
+static int pxa168_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        return phy_ethtool_sset(pep->phy, cmd);
+}
+
+static void pxa168_get_drvinfo(struct net_device *dev,
+                               struct ethtool_drvinfo *info)
+{
+        strncpy(info->driver, DRIVER_NAME, 32);
+        strncpy(info->version, DRIVER_VERSION, 32);
+        strncpy(info->fw_version, "N/A", 32);
+        strncpy(info->bus_info, "N/A", 32);
+}
+
+static u32 pxa168_get_link(struct net_device *dev)
+{
+        return !!netif_carrier_ok(dev);
+}
+
+static const struct ethtool_ops pxa168_ethtool_ops = {
+        .get_settings = pxa168_get_settings,
+        .set_settings = pxa168_set_settings,
+        .get_drvinfo = pxa168_get_drvinfo,
+        .get_link = pxa168_get_link,
+};
+
+static const struct net_device_ops pxa168_eth_netdev_ops = {
+        .ndo_open = pxa168_eth_open,
+        .ndo_stop = pxa168_eth_stop,
+        .ndo_start_xmit = pxa168_eth_start_xmit,
+        .ndo_set_rx_mode = pxa168_eth_set_rx_mode,
+        .ndo_set_mac_address = pxa168_eth_set_mac_address,
+        .ndo_validate_addr = eth_validate_addr,
+        .ndo_do_ioctl = pxa168_eth_do_ioctl,
+        .ndo_change_mtu = pxa168_eth_change_mtu,
+        .ndo_tx_timeout = pxa168_eth_tx_timeout,
+};
+
+static int pxa168_eth_probe(struct platform_device *pdev)
+{
+        struct pxa168_eth_private *pep = NULL;
+        struct net_device *dev = NULL;
+        struct resource *res;
+        struct clk *clk;
+        int err;
+
+        printk(KERN_NOTICE "PXA168 10/100 Ethernet Driver\n");
+
+        clk = clk_get(&pdev->dev, "MFUCLK");
+        if (IS_ERR(clk)) {
+                printk(KERN_ERR "%s: Fast Ethernet failed to get clock\n",
+                        DRIVER_NAME);
+                return -ENODEV;
+        }
+        clk_enable(clk);
+
+        dev = alloc_etherdev(sizeof(struct pxa168_eth_private));
+        if (!dev) {
+                err = -ENOMEM;
+                goto err_clk;
+        }
+
+        platform_set_drvdata(pdev, dev);
+        pep = netdev_priv(dev);
+        pep->dev = dev;
+        pep->clk = clk;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                err = -ENODEV;
+                goto err_netdev;
+        }
+        pep->base = ioremap(res->start, res->end - res->start + 1);
+        if (pep->base == NULL) {
+                err = -ENOMEM;
+                goto err_netdev;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        BUG_ON(!res);
+        dev->irq = res->start;
+        dev->netdev_ops = &pxa168_eth_netdev_ops;
+        dev->watchdog_timeo = 2 * HZ;
+        dev->base_addr = 0;
+        SET_ETHTOOL_OPS(dev, &pxa168_ethtool_ops);
+
+        INIT_WORK(&pep->tx_timeout_task, pxa168_eth_tx_timeout_task);
+
+        printk(KERN_INFO "%s:Using random mac address\n", DRIVER_NAME);
+        random_ether_addr(dev->dev_addr);
+
+        pep->pd = pdev->dev.platform_data;
+        pep->rx_ring_size = NUM_RX_DESCS;
+        if (pep->pd->rx_queue_size)
+                pep->rx_ring_size = pep->pd->rx_queue_size;
+
+        pep->tx_ring_size = NUM_TX_DESCS;
+        if (pep->pd->tx_queue_size)
+                pep->tx_ring_size = pep->pd->tx_queue_size;
+
+        pep->port_num = pep->pd->port_number;
+        /* Hardware supports only 3 ports */
+        BUG_ON(pep->port_num > 2);
+        netif_napi_add(dev, &pep->napi, pxa168_rx_poll, pep->rx_ring_size);
+
+        memset(&pep->timeout, 0, sizeof(struct timer_list));
+        init_timer(&pep->timeout);
+        pep->timeout.function = rxq_refill_timer_wrapper;
+        pep->timeout.data = (unsigned long)pep;
+
+        pep->smi_bus = mdiobus_alloc();
+        if (pep->smi_bus == NULL) {
+                err = -ENOMEM;
+                goto err_base;
+        }
+        pep->smi_bus->priv = pep;
+        pep->smi_bus->name = "pxa168_eth smi";
+        pep->smi_bus->read = pxa168_smi_read;
+        pep->smi_bus->write = pxa168_smi_write;
+        snprintf(pep->smi_bus->id, MII_BUS_ID_SIZE, "%d", pdev->id);
+        pep->smi_bus->parent = &pdev->dev;
+        pep->smi_bus->phy_mask = 0xffffffff;
+        err = mdiobus_register(pep->smi_bus);
+        if (err)
+                goto err_free_mdio;
+
+        pxa168_init_hw(pep);
+        err = ethernet_phy_setup(dev);
+        if (err)
+                goto err_mdiobus;
+        SET_NETDEV_DEV(dev, &pdev->dev);
+        err = register_netdev(dev);
+        if (err)
+                goto err_mdiobus;
+        return 0;
+
+err_mdiobus:
+        mdiobus_unregister(pep->smi_bus);
+err_free_mdio:
+        mdiobus_free(pep->smi_bus);
+err_base:
+        iounmap(pep->base);
+err_netdev:
+        free_netdev(dev);
+err_clk:
+        clk_disable(clk);
+        clk_put(clk);
+        return err;
+}
+
+static int pxa168_eth_remove(struct platform_device *pdev)
+{
+        struct net_device *dev = platform_get_drvdata(pdev);
+        struct pxa168_eth_private *pep = netdev_priv(dev);
+
+        if (pep->htpr) {
+                dma_free_coherent(pep->dev->dev.parent, HASH_ADDR_TABLE_SIZE,
+                                  pep->htpr, pep->htpr_dma);
+                pep->htpr = NULL;
+        }
+        if (pep->clk) {
+                clk_disable(pep->clk);
+                clk_put(pep->clk);
+                pep->clk = NULL;
+        }
+        if (pep->phy != NULL)
+                phy_detach(pep->phy);
+
+        iounmap(pep->base);
+        pep->base = NULL;
+        mdiobus_unregister(pep->smi_bus);
+        mdiobus_free(pep->smi_bus);
+        unregister_netdev(dev);
+        flush_scheduled_work();
+        free_netdev(dev);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static void pxa168_eth_shutdown(struct platform_device *pdev)
+{
+        struct net_device *dev = platform_get_drvdata(pdev);
+        eth_port_reset(dev);
+}
+
+#ifdef CONFIG_PM
+static int pxa168_eth_resume(struct platform_device *pdev)
+{
+        return -ENOSYS;
+}
+
+static int pxa168_eth_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        return -ENOSYS;
+}
+
+#else
+#define pxa168_eth_resume NULL
+#define pxa168_eth_suspend NULL
+#endif
+
+static struct platform_driver pxa168_eth_driver = {
+        .probe = pxa168_eth_probe,
+        .remove = pxa168_eth_remove,
+        .shutdown = pxa168_eth_shutdown,
+        .resume = pxa168_eth_resume,
+        .suspend = pxa168_eth_suspend,
+        .driver = {
+                   .name = DRIVER_NAME,
+                   },
+};
+
+static int __init pxa168_init_module(void)
+{
+        return platform_driver_register(&pxa168_eth_driver);
+}
+
+static void __exit pxa168_cleanup_module(void)
+{
+        platform_driver_unregister(&pxa168_eth_driver);
+}
+
+module_init(pxa168_init_module);
+module_exit(pxa168_cleanup_module);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Ethernet driver for Marvell PXA168");
+MODULE_ALIAS("platform:pxa168_eth");
diff --git a/drivers/net/qlcnic/qlcnic_init.c b/drivers/net/qlcnic/qlcnic_init.c
index 75ba744b173c..2c7cf0b64811 100644
--- a/drivers/net/qlcnic/qlcnic_init.c
+++ b/drivers/net/qlcnic/qlcnic_init.c
@@ -1316,7 +1316,7 @@ qlcnic_alloc_rx_skb(struct qlcnic_adapter *adapter,
                 return -ENOMEM;
         }
 
-        skb_reserve(skb, 2);
+        skb_reserve(skb, NET_IP_ALIGN);
 
         dma = pci_map_single(pdev, skb->data,
                         rds_ring->dma_size, PCI_DMA_FROMDEVICE);
@@ -1404,7 +1404,6 @@ qlcnic_process_rcv(struct qlcnic_adapter *adapter,
         if (pkt_offset)
                 skb_pull(skb, pkt_offset);
 
-        skb->truesize = skb->len + sizeof(struct sk_buff);
         skb->protocol = eth_type_trans(skb, netdev);
 
         napi_gro_receive(&sds_ring->napi, skb);
@@ -1466,8 +1465,6 @@ qlcnic_process_lro(struct qlcnic_adapter *adapter,
 
         skb_put(skb, lro_length + data_offset);
 
-        skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb);
-
         skb_pull(skb, l2_hdr_offset);
         skb->protocol = eth_type_trans(skb, netdev);
 
@@ -1700,8 +1697,6 @@ qlcnic_process_rcv_diag(struct qlcnic_adapter *adapter,
         if (pkt_offset)
                 skb_pull(skb, pkt_offset);
 
-        skb->truesize = skb->len + sizeof(struct sk_buff);
-
         if (!qlcnic_check_loopback_buff(skb->data))
                 adapter->diag_cnt++;
 
diff --git a/drivers/net/qlcnic/qlcnic_main.c b/drivers/net/qlcnic/qlcnic_main.c
index b9615bd745ea..66eea5972020 100644
--- a/drivers/net/qlcnic/qlcnic_main.c
+++ b/drivers/net/qlcnic/qlcnic_main.c
@@ -473,48 +473,58 @@ qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 static int
 qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 {
-        struct qlcnic_pci_info pci_info[QLCNIC_MAX_PCI_FUNC];
+        struct qlcnic_pci_info *pci_info;
         int i, ret = 0, err;
         u8 pfn;
 
-        if (!adapter->npars)
-                adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
-                                QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
-        if (!adapter->npars)
+        pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
+        if (!pci_info)
                 return -ENOMEM;
 
-        if (!adapter->eswitch)
-                adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
+        adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
+                                QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
+        if (!adapter->npars) {
+                err = -ENOMEM;
+                goto err_pci_info;
+        }
+
+        adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
                                 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
         if (!adapter->eswitch) {
                 err = -ENOMEM;
-                goto err_eswitch;
+                goto err_npars;
         }
 
         ret = qlcnic_get_pci_info(adapter, pci_info);
-        if (!ret) {
-                for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
-                        pfn = pci_info[i].id;
-                        if (pfn > QLCNIC_MAX_PCI_FUNC)
-                                return QL_STATUS_INVALID_PARAM;
-                        adapter->npars[pfn].active = pci_info[i].active;
-                        adapter->npars[pfn].type = pci_info[i].type;
-                        adapter->npars[pfn].phy_port = pci_info[i].default_port;
-                        adapter->npars[pfn].mac_learning = DEFAULT_MAC_LEARN;
-                        adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
-                        adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
-                }
-
-                for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
-                        adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
+        if (ret)
+                goto err_eswitch;
 
-                return ret;
+        for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
+                pfn = pci_info[i].id;
+                if (pfn > QLCNIC_MAX_PCI_FUNC)
+                        return QL_STATUS_INVALID_PARAM;
+                adapter->npars[pfn].active = pci_info[i].active;
+                adapter->npars[pfn].type = pci_info[i].type;
+                adapter->npars[pfn].phy_port = pci_info[i].default_port;
+                adapter->npars[pfn].mac_learning = DEFAULT_MAC_LEARN;
+                adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
+                adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
         }
 
+        for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
+                adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
+
+        kfree(pci_info);
+        return 0;
+
+err_eswitch:
         kfree(adapter->eswitch);
         adapter->eswitch = NULL;
-err_eswitch:
+err_npars:
         kfree(adapter->npars);
+        adapter->npars = NULL;
+err_pci_info:
+        kfree(pci_info);
 
         return ret;
 }
@@ -1973,8 +1983,6 @@ static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
         struct net_device_stats *stats = &netdev->stats;
 
-        memset(stats, 0, sizeof(*stats));
-
         stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
         stats->tx_packets = adapter->stats.xmitfinished;
         stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
@@ -2180,9 +2188,16 @@ static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void qlcnic_poll_controller(struct net_device *netdev)
 {
+        int ring;
+        struct qlcnic_host_sds_ring *sds_ring;
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
+        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+
         disable_irq(adapter->irq);
-        qlcnic_intr(adapter->irq, adapter);
+        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
+                sds_ring = &recv_ctx->sds_rings[ring];
+                qlcnic_intr(adapter->irq, sds_ring);
+        }
         enable_irq(adapter->irq);
 }
 #endif
@@ -3361,15 +3376,21 @@ qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
         struct device *dev = container_of(kobj, struct device, kobj);
         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
         struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
-        struct qlcnic_pci_info  pci_info[QLCNIC_MAX_PCI_FUNC];
+        struct qlcnic_pci_info *pci_info;
         int i, ret;
 
         if (size != sizeof(pci_cfg))
                 return QL_STATUS_INVALID_PARAM;
 
+        pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
+        if (!pci_info)
+                return -ENOMEM;
+
         ret = qlcnic_get_pci_info(adapter, pci_info);
-        if (ret)
+        if (ret) {
+                kfree(pci_info);
                 return ret;
+        }
 
         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
                 pci_cfg[i].pci_func = pci_info[i].id;
@@ -3380,8 +3401,8 @@ qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
                 memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
         }
         memcpy(buf, &pci_cfg, size);
+        kfree(pci_info);
         return size;
-
 }
 static struct bin_attribute bin_attr_npar_config = {
         .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 8d63f69b27d9..5f89e83501f4 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -3919,12 +3919,12 @@ static int ql_adapter_down(struct ql_adapter *qdev)
         for (i = 0; i < qdev->rss_ring_count; i++)
                 netif_napi_del(&qdev->rx_ring[i].napi);
 
-        ql_free_rx_buffers(qdev);
-
         status = ql_adapter_reset(qdev);
         if (status)
                 netif_err(qdev, ifdown, qdev->ndev, "reset(func #%d) FAILED!\n",
                           qdev->func);
+        ql_free_rx_buffers(qdev);
+
         return status;
 }
 
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 35540411990d..a0da4a17b025 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -2934,7 +2934,7 @@ static const struct rtl_cfg_info {
                 .hw_start       = rtl_hw_start_8168,
                 .region         = 2,
                 .align          = 8,
-                .intr_event     = SYSErr | LinkChg | RxOverflow |
+                .intr_event     = SYSErr | RxFIFOOver | LinkChg | RxOverflow |
                                   TxErr | TxOK | RxOK | RxErr,
                 .napi_event     = TxErr | TxOK | RxOK | RxOverflow,
                 .features       = RTL_FEATURE_GMII | RTL_FEATURE_MSI,
@@ -3219,11 +3219,8 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         device_set_wakeup_enable(&pdev->dev, tp->features & RTL_FEATURE_WOL);
 
-        if (pci_dev_run_wake(pdev)) {
-                pm_runtime_set_active(&pdev->dev);
-                pm_runtime_enable(&pdev->dev);
-        }
-        pm_runtime_idle(&pdev->dev);
+        if (pci_dev_run_wake(pdev))
+                pm_runtime_put_noidle(&pdev->dev);
 
 out:
         return rc;
@@ -3246,17 +3243,12 @@ static void __devexit rtl8169_remove_one(struct pci_dev *pdev)
         struct net_device *dev = pci_get_drvdata(pdev);
         struct rtl8169_private *tp = netdev_priv(dev);
 
-        pm_runtime_get_sync(&pdev->dev);
-
         flush_scheduled_work();
 
         unregister_netdev(dev);
 
-        if (pci_dev_run_wake(pdev)) {
-                pm_runtime_disable(&pdev->dev);
-                pm_runtime_set_suspended(&pdev->dev);
-        }
-        pm_runtime_put_noidle(&pdev->dev);
+        if (pci_dev_run_wake(pdev))
+                pm_runtime_get_noresume(&pdev->dev);
 
         /* restore original MAC address */
         rtl_rar_set(tp, dev->perm_addr);
@@ -4633,8 +4625,7 @@ static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance)
                 }
 
                 /* Work around for rx fifo overflow */
-                if (unlikely(status & RxFIFOOver) &&
-                (tp->mac_version == RTL_GIGA_MAC_VER_11)) {
+                if (unlikely(status & RxFIFOOver)) {
                         netif_stop_queue(dev);
                         rtl8169_tx_timeout(dev);
                         break;
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index 07eb884ff982..44150f2f7bfd 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -384,7 +384,7 @@ static void rionet_remove(struct rio_dev *rdev)
         free_pages((unsigned long)rionet_active, rdev->net->hport->sys_size ?
                                         __ilog2(sizeof(void *)) + 4 : 0);
         unregister_netdev(ndev);
-        kfree(ndev);
+        free_netdev(ndev);
 
         list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
                 list_del(&peer->node);
diff --git a/drivers/net/sgiseeq.c b/drivers/net/sgiseeq.c
index cc4bd8c65f8b..9265315baa0b 100644
--- a/drivers/net/sgiseeq.c
+++ b/drivers/net/sgiseeq.c
@@ -804,7 +804,7 @@ static int __devinit sgiseeq_probe(struct platform_device *pdev)
 err_out_free_page:
         free_page((unsigned long) sp->srings);
 err_out_free_dev:
-        kfree(dev);
+        free_netdev(dev);
 
 err_out:
         return err;
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index f5a9eb1df593..79fd02bc69fd 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -1437,7 +1437,7 @@ static const struct net_device_ops sh_eth_netdev_ops = {
 
 static int sh_eth_drv_probe(struct platform_device *pdev)
 {
-        int ret, i, devno = 0;
+        int ret, devno = 0;
         struct resource *res;
         struct net_device *ndev = NULL;
         struct sh_eth_private *mdp;
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index 8d2772cc42f2..ee747919a766 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -83,43 +83,6 @@ static inline void SMC_outw(u16 val, void __iomem *ioaddr, int reg)
         }
 }
 
-#elif defined(CONFIG_REDWOOD_5) || defined(CONFIG_REDWOOD_6)
-
-/* We can only do 16-bit reads and writes in the static memory space. */
-#define SMC_CAN_USE_8BIT        0
-#define SMC_CAN_USE_16BIT       1
-#define SMC_CAN_USE_32BIT       0
-#define SMC_NOWAIT              1
-
-#define SMC_IO_SHIFT            0
-
-#define SMC_inw(a, r)           in_be16((volatile u16 *)((a) + (r)))
-#define SMC_outw(v, a, r)       out_be16((volatile u16 *)((a) + (r)), v)
-#define SMC_insw(a, r, p, l)                                            \
-        do {                                                            \
-                unsigned long __port = (a) + (r);                       \
-                u16 *__p = (u16 *)(p);                                  \
-                int __l = (l);                                          \
-                insw(__port, __p, __l);                                 \
-                while (__l > 0) {                                       \
-                        *__p = swab16(*__p);                            \
-                        __p++;                                          \
-                        __l--;                                          \
-                }                                                       \
-        } while (0)
-#define SMC_outsw(a, r, p, l)                                           \
-        do {                                                            \
-                unsigned long __port = (a) + (r);                       \
-                u16 *__p = (u16 *)(p);                                  \
-                int __l = (l);                                          \
-                while (__l > 0) {                                       \
-                        /* Believe it or not, the swab isn't needed. */ \
-                        outw( /* swab16 */ (*__p++), __port);           \
-                        __l--;                                          \
-                }                                                       \
-        } while (0)
-#define SMC_IRQ_FLAGS           (0)
-
 #elif defined(CONFIG_SA1100_PLEB)
 /* We can only do 16-bit reads and writes in the static memory space. */
 #define SMC_CAN_USE_8BIT        1
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index 0909ae934ad0..8150ba154116 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -58,6 +58,7 @@
 
 MODULE_LICENSE("GPL");
 MODULE_VERSION(SMSC_DRV_VERSION);
+MODULE_ALIAS("platform:smsc911x");
 
 #if USE_DEBUG > 0
 static int debug = 16;
diff --git a/drivers/net/stmmac/stmmac_main.c b/drivers/net/stmmac/stmmac_main.c
index bbb7951b9c4c..ea0461eb2dbe 100644
--- a/drivers/net/stmmac/stmmac_main.c
+++ b/drivers/net/stmmac/stmmac_main.c
@@ -1865,15 +1865,15 @@ static int stmmac_resume(struct platform_device *pdev)
         if (!netif_running(dev))
                 return 0;
 
-        spin_lock(&priv->lock);
-
         if (priv->shutdown) {
                 /* Re-open the interface and re-init the MAC/DMA
-                   and the rings. */
+                   and the rings (i.e. on hibernation stage) */
                 stmmac_open(dev);
-                goto out_resume;
+                return 0;
         }
 
+        spin_lock(&priv->lock);
+
         /* Power Down bit, into the PM register, is cleared
          * automatically as soon as a magic packet or a Wake-up frame
          * is received. Anyway, it's better to manually clear
@@ -1901,7 +1901,6 @@ static int stmmac_resume(struct platform_device *pdev)
 
         netif_start_queue(dev);
 
-out_resume:
         spin_unlock(&priv->lock);
         return 0;
 }
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index 367e96f317d4..618643e3ca3e 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -97,7 +97,7 @@ static int qec_global_reset(void __iomem *gregs)
 
 static void qec_init(struct bigmac *bp)
 {
-        struct of_device *qec_op = bp->qec_op;
+        struct platform_device *qec_op = bp->qec_op;
         void __iomem *gregs = bp->gregs;
         u8 bsizes = bp->bigmac_bursts;
         u32 regval;
@@ -1083,8 +1083,8 @@ static const struct net_device_ops bigmac_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit bigmac_ether_init(struct of_device *op,
-                                       struct of_device *qec_op)
+static int __devinit bigmac_ether_init(struct platform_device *op,
+                                       struct platform_device *qec_op)
 {
         static int version_printed;
         struct net_device *dev;
@@ -1201,7 +1201,7 @@ static int __devinit bigmac_ether_init(struct of_device *op,
         dev->watchdog_timeo = 5*HZ;
 
         /* Finish net device registration. */
-        dev->irq = bp->bigmac_op->irqs[0];
+        dev->irq = bp->bigmac_op->archdata.irqs[0];
         dev->dma = 0;
 
         if (register_netdev(dev)) {
@@ -1242,25 +1242,25 @@ fail_and_cleanup:
 /* QEC can be the parent of either QuadEthernet or a BigMAC.  We want
  * the latter.
  */
-static int __devinit bigmac_sbus_probe(struct of_device *op,
+static int __devinit bigmac_sbus_probe(struct platform_device *op,
                                        const struct of_device_id *match)
 {
         struct device *parent = op->dev.parent;
-        struct of_device *qec_op;
+        struct platform_device *qec_op;
 
-        qec_op = to_of_device(parent);
+        qec_op = to_platform_device(parent);
 
         return bigmac_ether_init(op, qec_op);
 }
 
-static int __devexit bigmac_sbus_remove(struct of_device *op)
+static int __devexit bigmac_sbus_remove(struct platform_device *op)
 {
         struct bigmac *bp = dev_get_drvdata(&op->dev);
         struct device *parent = op->dev.parent;
         struct net_device *net_dev = bp->dev;
-        struct of_device *qec_op;
+        struct platform_device *qec_op;
 
-        qec_op = to_of_device(parent);
+        qec_op = to_platform_device(parent);
 
         unregister_netdev(net_dev);
 
@@ -1301,12 +1301,12 @@ static struct of_platform_driver bigmac_sbus_driver = {
 
 static int __init bigmac_init(void)
 {
-        return of_register_driver(&bigmac_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&bigmac_sbus_driver);
 }
 
 static void __exit bigmac_exit(void)
 {
-        of_unregister_driver(&bigmac_sbus_driver);
+        of_unregister_platform_driver(&bigmac_sbus_driver);
 }
 
 module_init(bigmac_init);
diff --git a/drivers/net/sunbmac.h b/drivers/net/sunbmac.h
index 8840bc0b840b..8db88945b889 100644
--- a/drivers/net/sunbmac.h
+++ b/drivers/net/sunbmac.h
@@ -329,8 +329,8 @@ struct bigmac {
         unsigned int            timer_ticks;
 
         struct net_device_stats enet_stats;
-        struct of_device        *qec_op;
-        struct of_device        *bigmac_op;
+        struct platform_device  *qec_op;
+        struct platform_device  *bigmac_op;
         struct net_device       *dev;
 };
 
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index 3d9650b8d38f..bd0df1c14955 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -1591,7 +1591,7 @@ static int happy_meal_init(struct happy_meal *hp)
                  */
 #ifdef CONFIG_SBUS
                 if ((hp->happy_flags & HFLAG_PCI) == 0) {
-                        struct of_device *op = hp->happy_dev;
+                        struct platform_device *op = hp->happy_dev;
                         if (sbus_can_dma_64bit()) {
                                 sbus_set_sbus64(&op->dev,
                                                 hp->happy_bursts);
@@ -2480,7 +2480,7 @@ static void hme_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
 #ifdef CONFIG_SBUS
         else {
                 const struct linux_prom_registers *regs;
-                struct of_device *op = hp->happy_dev;
+                struct platform_device *op = hp->happy_dev;
                 regs = of_get_property(op->dev.of_node, "regs", NULL);
                 if (regs)
                         sprintf(info->bus_info, "SBUS:%d",
@@ -2515,13 +2515,13 @@ static int hme_version_printed;
  *
  * Return NULL on failure.
  */
-static struct quattro * __devinit quattro_sbus_find(struct of_device *child)
+static struct quattro * __devinit quattro_sbus_find(struct platform_device *child)
 {
         struct device *parent = child->dev.parent;
-        struct of_device *op;
+        struct platform_device *op;
         struct quattro *qp;
 
-        op = to_of_device(parent);
+        op = to_platform_device(parent);
         qp = dev_get_drvdata(&op->dev);
         if (qp)
                 return qp;
@@ -2551,7 +2551,7 @@ static int __init quattro_sbus_register_irqs(void)
         struct quattro *qp;
 
         for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
-                struct of_device *op = qp->quattro_dev;
+                struct platform_device *op = qp->quattro_dev;
                 int err, qfe_slot, skip = 0;
 
                 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++) {
@@ -2561,7 +2561,7 @@ static int __init quattro_sbus_register_irqs(void)
                 if (skip)
                         continue;
 
-                err = request_irq(op->irqs[0],
+                err = request_irq(op->archdata.irqs[0],
                                   quattro_sbus_interrupt,
                                   IRQF_SHARED, "Quattro",
                                   qp);
@@ -2580,7 +2580,7 @@ static void quattro_sbus_free_irqs(void)
         struct quattro *qp;
 
         for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
-                struct of_device *op = qp->quattro_dev;
+                struct platform_device *op = qp->quattro_dev;
                 int qfe_slot, skip = 0;
 
                 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++) {
@@ -2590,7 +2590,7 @@ static void quattro_sbus_free_irqs(void)
                 if (skip)
                         continue;
 
-                free_irq(op->irqs[0], qp);
+                free_irq(op->archdata.irqs[0], qp);
         }
 }
 #endif /* CONFIG_SBUS */
@@ -2639,7 +2639,7 @@ static const struct net_device_ops hme_netdev_ops = {
 };
 
 #ifdef CONFIG_SBUS
-static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
+static int __devinit happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
 {
         struct device_node *dp = op->dev.of_node, *sbus_dp;
         struct quattro *qp = NULL;
@@ -2648,7 +2648,7 @@ static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
         int i, qfe_slot = -1;
         int err = -ENODEV;
 
-        sbus_dp = to_of_device(op->dev.parent)->dev.of_node;
+        sbus_dp = op->dev.parent->of_node;
 
         /* We can match PCI devices too, do not accept those here. */
         if (strcmp(sbus_dp->name, "sbus"))
@@ -2790,7 +2790,7 @@ static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
         /* Happy Meal can do it all... */
         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
 
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
 
 #if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
         /* Hook up SBUS register/descriptor accessors. */
@@ -3235,7 +3235,7 @@ static void happy_meal_pci_exit(void)
 #endif
 
 #ifdef CONFIG_SBUS
-static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit hme_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         const char *model = of_get_property(dp, "model", NULL);
@@ -3247,7 +3247,7 @@ static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device
         return happy_meal_sbus_probe_one(op, is_qfe);
 }
 
-static int __devexit hme_sbus_remove(struct of_device *op)
+static int __devexit hme_sbus_remove(struct platform_device *op)
 {
         struct happy_meal *hp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = hp->dev;
@@ -3304,7 +3304,7 @@ static int __init happy_meal_sbus_init(void)
 {
         int err;
 
-        err = of_register_driver(&hme_sbus_driver, &of_bus_type);
+        err = of_register_platform_driver(&hme_sbus_driver);
         if (!err)
                 err = quattro_sbus_register_irqs();
 
@@ -3313,7 +3313,7 @@ static int __init happy_meal_sbus_init(void)
 
 static void happy_meal_sbus_exit(void)
 {
-        of_unregister_driver(&hme_sbus_driver);
+        of_unregister_platform_driver(&hme_sbus_driver);
         quattro_sbus_free_irqs();
 
         while (qfe_sbus_list) {
diff --git a/drivers/net/sunhme.h b/drivers/net/sunhme.h
index efd2ca0fcad3..756b5bf3aa89 100644
--- a/drivers/net/sunhme.h
+++ b/drivers/net/sunhme.h
@@ -407,7 +407,7 @@ struct happy_meal {
         void (*write_rxd)(struct happy_meal_rxd *, u32, u32);
 #endif
 
-        /* This is either an of_device or a pci_dev. */
+        /* This is either an platform_device or a pci_dev. */
         void                      *happy_dev;
         struct device             *dma_dev;
 
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 7d9c33dd9d1a..8dcb858f2168 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -250,7 +250,7 @@ struct lance_private {
         int             rx_new, tx_new;
         int             rx_old, tx_old;
 
-        struct of_device *ledma;        /* If set this points to ledma  */
+        struct platform_device *ledma;  /* If set this points to ledma  */
         char            tpe;            /* cable-selection is TPE       */
         char            auto_select;    /* cable-selection by carrier   */
         char            burst_sizes;    /* ledma SBus burst sizes       */
@@ -265,8 +265,8 @@ struct lance_private {
         char                   *name;
         dma_addr_t              init_block_dvma;
         struct net_device      *dev;              /* Backpointer        */
-        struct of_device       *op;
-        struct of_device       *lebuffer;
+        struct platform_device       *op;
+        struct platform_device       *lebuffer;
         struct timer_list       multicast_timer;
 };
 
@@ -1272,7 +1272,7 @@ static void lance_free_hwresources(struct lance_private *lp)
         if (lp->lregs)
                 of_iounmap(&lp->op->resource[0], lp->lregs, LANCE_REG_SIZE);
         if (lp->dregs) {
-                struct of_device *ledma = lp->ledma;
+                struct platform_device *ledma = lp->ledma;
 
                 of_iounmap(&ledma->resource[0], lp->dregs,
                            resource_size(&ledma->resource[0]));
@@ -1319,9 +1319,9 @@ static const struct net_device_ops sparc_lance_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit sparc_lance_probe_one(struct of_device *op,
-                                           struct of_device *ledma,
-                                           struct of_device *lebuffer)
+static int __devinit sparc_lance_probe_one(struct platform_device *op,
+                                           struct platform_device *ledma,
+                                           struct platform_device *lebuffer)
 {
         struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
@@ -1474,7 +1474,7 @@ no_link_test:
         dev->ethtool_ops = &sparc_lance_ethtool_ops;
         dev->netdev_ops = &sparc_lance_ops;
 
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
 
         /* We cannot sleep if the chip is busy during a
          * multicast list update event, because such events
@@ -1503,9 +1503,9 @@ fail:
         return -ENODEV;
 }
 
-static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit sunlance_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
-        struct of_device *parent = to_of_device(op->dev.parent);
+        struct platform_device *parent = to_platform_device(op->dev.parent);
         struct device_node *parent_dp = parent->dev.of_node;
         int err;
 
@@ -1519,7 +1519,7 @@ static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_d
         return err;
 }
 
-static int __devexit sunlance_sbus_remove(struct of_device *op)
+static int __devexit sunlance_sbus_remove(struct platform_device *op)
 {
         struct lance_private *lp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = lp->dev;
@@ -1558,12 +1558,12 @@ static struct of_platform_driver sunlance_sbus_driver = {
 /* Find all the lance cards on the system and initialize them */
 static int __init sparc_lance_init(void)
 {
-        return of_register_driver(&sunlance_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&sunlance_sbus_driver);
 }
 
 static void __exit sparc_lance_exit(void)
 {
-        of_unregister_driver(&sunlance_sbus_driver);
+        of_unregister_platform_driver(&sunlance_sbus_driver);
 }
 
 module_init(sparc_lance_init);
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index 72b579c8d812..72e65d4666ef 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -689,7 +689,7 @@ static void qe_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         const struct linux_prom_registers *regs;
         struct sunqe *qep = netdev_priv(dev);
-        struct of_device *op;
+        struct platform_device *op;
 
         strcpy(info->driver, "sunqe");
         strcpy(info->version, "3.0");
@@ -720,7 +720,7 @@ static const struct ethtool_ops qe_ethtool_ops = {
 };
 
 /* This is only called once at boot time for each card probed. */
-static void qec_init_once(struct sunqec *qecp, struct of_device *op)
+static void qec_init_once(struct sunqec *qecp, struct platform_device *op)
 {
         u8 bsizes = qecp->qec_bursts;
 
@@ -770,9 +770,9 @@ static u8 __devinit qec_get_burst(struct device_node *dp)
         return bsizes;
 }
 
-static struct sunqec * __devinit get_qec(struct of_device *child)
+static struct sunqec * __devinit get_qec(struct platform_device *child)
 {
-        struct of_device *op = to_of_device(child->dev.parent);
+        struct platform_device *op = to_platform_device(child->dev.parent);
         struct sunqec *qecp;
 
         qecp = dev_get_drvdata(&op->dev);
@@ -803,7 +803,7 @@ static struct sunqec * __devinit get_qec(struct of_device *child)
 
                         qec_init_once(qecp, op);
 
-                        if (request_irq(op->irqs[0], qec_interrupt,
+                        if (request_irq(op->archdata.irqs[0], qec_interrupt,
                                         IRQF_SHARED, "qec", (void *) qecp)) {
                                 printk(KERN_ERR "qec: Can't register irq.\n");
                                 goto fail;
@@ -836,7 +836,7 @@ static const struct net_device_ops qec_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit qec_ether_init(struct of_device *op)
+static int __devinit qec_ether_init(struct platform_device *op)
 {
         static unsigned version_printed;
         struct net_device *dev;
@@ -901,7 +901,7 @@ static int __devinit qec_ether_init(struct of_device *op)
         SET_NETDEV_DEV(dev, &op->dev);
 
         dev->watchdog_timeo = 5*HZ;
-        dev->irq = op->irqs[0];
+        dev->irq = op->archdata.irqs[0];
         dev->dma = 0;
         dev->ethtool_ops = &qe_ethtool_ops;
         dev->netdev_ops = &qec_ops;
@@ -941,12 +941,12 @@ fail:
         return res;
 }
 
-static int __devinit qec_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit qec_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         return qec_ether_init(op);
 }
 
-static int __devexit qec_sbus_remove(struct of_device *op)
+static int __devexit qec_sbus_remove(struct platform_device *op)
 {
         struct sunqe *qp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = qp->dev;
@@ -988,18 +988,18 @@ static struct of_platform_driver qec_sbus_driver = {
 
 static int __init qec_init(void)
 {
-        return of_register_driver(&qec_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&qec_sbus_driver);
 }
 
 static void __exit qec_exit(void)
 {
-        of_unregister_driver(&qec_sbus_driver);
+        of_unregister_platform_driver(&qec_sbus_driver);
 
         while (root_qec_dev) {
                 struct sunqec *next = root_qec_dev->next_module;
-                struct of_device *op = root_qec_dev->op;
+                struct platform_device *op = root_qec_dev->op;
 
-                free_irq(op->irqs[0], (void *) root_qec_dev);
+                free_irq(op->archdata.irqs[0], (void *) root_qec_dev);
                 of_iounmap(&op->resource[0], root_qec_dev->gregs,
                            GLOB_REG_SIZE);
                 kfree(root_qec_dev);
diff --git a/drivers/net/sunqe.h b/drivers/net/sunqe.h
index 5813a7b2faa5..581781b6b2fa 100644
--- a/drivers/net/sunqe.h
+++ b/drivers/net/sunqe.h
@@ -314,7 +314,7 @@ struct sunqec {
         void __iomem            *gregs;         /* QEC Global Registers         */
         struct sunqe            *qes[4];        /* Each child MACE              */
         unsigned int            qec_bursts;     /* Support burst sizes          */
-        struct of_device        *op;            /* QEC's OF device              */
+        struct platform_device  *op;            /* QEC's OF device              */
         struct sunqec           *next_module;   /* List of all QECs in system   */
 };
 
@@ -342,7 +342,7 @@ struct sunqe {
         __u32                           buffers_dvma;   /* DVMA visible address.       */
         struct sunqec                   *parent;
         u8                              mconfig;        /* Base MACE mconfig value     */
-        struct of_device                *op;            /* QE's OF device struct       */
+        struct platform_device          *op;            /* QE's OF device struct       */
         struct net_device               *dev;           /* QE's netdevice struct       */
         int                             channel;        /* Who am I?                   */
 };
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index 5efa57757a2c..6888e3d41462 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -243,6 +243,7 @@ enum {
         NWayState               = (1 << 14) | (1 << 13) | (1 << 12),
         NWayRestart             = (1 << 12),
         NonselPortActive        = (1 << 9),
+        SelPortActive           = (1 << 8),
         LinkFailStatus          = (1 << 2),
         NetCxnErr               = (1 << 1),
 };
@@ -363,7 +364,9 @@ static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
 
 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
-static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
+static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
+/* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */
+static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
 
 
@@ -1064,6 +1067,9 @@ static void de21041_media_timer (unsigned long data)
         unsigned int carrier;
         unsigned long flags;
 
+        /* clear port active bits */
+        dw32(SIAStatus, NonselPortActive | SelPortActive);
+
         carrier = (status & NetCxnErr) ? 0 : 1;
 
         if (carrier) {
@@ -1158,14 +1164,29 @@ no_link_yet:
 static void de_media_interrupt (struct de_private *de, u32 status)
 {
         if (status & LinkPass) {
+                /* Ignore if current media is AUI or BNC and we can't use TP */
+                if ((de->media_type == DE_MEDIA_AUI ||
+                     de->media_type == DE_MEDIA_BNC) &&
+                    (de->media_lock ||
+                     !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)))
+                        return;
+                /* If current media is not TP, change it to TP */
+                if ((de->media_type == DE_MEDIA_AUI ||
+                     de->media_type == DE_MEDIA_BNC)) {
+                        de->media_type = DE_MEDIA_TP_AUTO;
+                        de_stop_rxtx(de);
+                        de_set_media(de);
+                        de_start_rxtx(de);
+                }
                 de_link_up(de);
                 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
                 return;
         }
 
         BUG_ON(!(status & LinkFail));
-
-        if (netif_carrier_ok(de->dev)) {
+        /* Mark the link as down only if current media is TP */
+        if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI &&
+            de->media_type != DE_MEDIA_BNC) {
                 de_link_down(de);
                 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
         }
@@ -1229,6 +1250,7 @@ static void de_adapter_sleep (struct de_private *de)
         if (de->de21040)
                 return;
 
+        dw32(CSR13, 0); /* Reset phy */
         pci_read_config_dword(de->pdev, PCIPM, &pmctl);
         pmctl |= PM_Sleep;
         pci_write_config_dword(de->pdev, PCIPM, pmctl);
@@ -1574,12 +1596,15 @@ static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
                 return 0; /* nothing to change */
 
         de_link_down(de);
+        mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
         de_stop_rxtx(de);
 
         de->media_type = new_media;
         de->media_lock = media_lock;
         de->media_advertise = ecmd->advertising;
         de_set_media(de);
+        if (netif_running(de->dev))
+                de_start_rxtx(de);
 
         return 0;
 }
@@ -1911,8 +1936,14 @@ fill_defaults:
         for (i = 0; i < DE_MAX_MEDIA; i++) {
                 if (de->media[i].csr13 == 0xffff)
                         de->media[i].csr13 = t21041_csr13[i];
-                if (de->media[i].csr14 == 0xffff)
-                        de->media[i].csr14 = t21041_csr14[i];
+                if (de->media[i].csr14 == 0xffff) {
+                        /* autonegotiation is broken at least on some chip
+                           revisions - rev. 0x21 works, 0x11 does not */
+                        if (de->pdev->revision < 0x20)
+                                de->media[i].csr14 = t21041_csr14_brk[i];
+                        else
+                                de->media[i].csr14 = t21041_csr14[i];
+                }
                 if (de->media[i].csr15 == 0xffff)
                         de->media[i].csr15 = t21041_csr15[i];
         }
@@ -2158,6 +2189,8 @@ static int de_resume (struct pci_dev *pdev)
                 dev_err(&dev->dev, "pci_enable_device failed in resume\n");
                 goto out;
         }
+        pci_set_master(pdev);
+        de_init_rings(de);
         de_init_hw(de);
 out_attach:
         netif_device_attach(dev);
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 8d532f9b50d0..a4c3f5708246 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3601,7 +3601,7 @@ static void ucc_geth_timeout(struct net_device *dev)
 
 #ifdef CONFIG_PM
 
-static int ucc_geth_suspend(struct of_device *ofdev, pm_message_t state)
+static int ucc_geth_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct ucc_geth_private *ugeth = netdev_priv(ndev);
@@ -3629,7 +3629,7 @@ static int ucc_geth_suspend(struct of_device *ofdev, pm_message_t state)
         return 0;
 }
 
-static int ucc_geth_resume(struct of_device *ofdev)
+static int ucc_geth_resume(struct platform_device *ofdev)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct ucc_geth_private *ugeth = netdev_priv(ndev);
@@ -3732,7 +3732,7 @@ static const struct net_device_ops ucc_geth_netdev_ops = {
 #endif
 };
 
-static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *match)
+static int ucc_geth_probe(struct platform_device* ofdev, const struct of_device_id *match)
 {
         struct device *device = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
@@ -3954,7 +3954,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
         return 0;
 }
 
-static int ucc_geth_remove(struct of_device* ofdev)
+static int ucc_geth_remove(struct platform_device* ofdev)
 {
         struct device *device = &ofdev->dev;
         struct net_device *dev = dev_get_drvdata(device);
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 6efca66b8766..1cd752f9a6e1 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -1652,6 +1652,8 @@ static int hso_get_count(struct hso_serial *serial,
         struct uart_icount cnow;
         struct hso_tiocmget  *tiocmget = serial->tiocmget;
 
+        memset(&icount, 0, sizeof(struct serial_icounter_struct));
+
         if (!tiocmget)
                  return -ENOENT;
         spin_lock_irq(&serial->serial_lock);
diff --git a/drivers/net/usb/ipheth.c b/drivers/net/usb/ipheth.c
index 08e7b6abacdd..b2bcf99e6f08 100644
--- a/drivers/net/usb/ipheth.c
+++ b/drivers/net/usb/ipheth.c
@@ -58,6 +58,7 @@
 #define USB_PRODUCT_IPHONE      0x1290
 #define USB_PRODUCT_IPHONE_3G   0x1292
 #define USB_PRODUCT_IPHONE_3GS  0x1294
+#define USB_PRODUCT_IPHONE_4    0x1297
 
 #define IPHETH_USBINTF_CLASS    255
 #define IPHETH_USBINTF_SUBCLASS 253
@@ -92,6 +93,10 @@ static struct usb_device_id ipheth_table[] = {
                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3GS,
                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
                 IPHETH_USBINTF_PROTO) },
+        { USB_DEVICE_AND_INTERFACE_INFO(
+                USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4,
+                IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
+                IPHETH_USBINTF_PROTO) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, ipheth_table);
@@ -424,10 +429,6 @@ static const struct net_device_ops ipheth_netdev_ops = {
         .ndo_get_stats = &ipheth_stats,
 };
 
-static struct device_type ipheth_type = {
-        .name   = "wwan",
-};
-
 static int ipheth_probe(struct usb_interface *intf,
                         const struct usb_device_id *id)
 {
@@ -445,7 +446,7 @@ static int ipheth_probe(struct usb_interface *intf,
 
         netdev->netdev_ops = &ipheth_netdev_ops;
         netdev->watchdog_timeo = IPHETH_TX_TIMEOUT;
-        strcpy(netdev->name, "wwan%d");
+        strcpy(netdev->name, "eth%d");
 
         dev = netdev_priv(netdev);
         dev->udev = udev;
@@ -495,7 +496,6 @@ static int ipheth_probe(struct usb_interface *intf,
 
         SET_NETDEV_DEV(netdev, &intf->dev);
         SET_ETHTOOL_OPS(netdev, &ops);
-        SET_NETDEV_DEVTYPE(netdev, &ipheth_type);
 
         retval = register_netdev(netdev);
         if (retval) {
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 7f62e2dea28f..ca7fc9df1ccf 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -315,7 +315,7 @@ EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
 
 static void rx_complete (struct urb *urb);
 
-static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
+static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
 {
         struct sk_buff          *skb;
         struct skb_data         *entry;
@@ -327,7 +327,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                 netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
                 usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
                 usb_free_urb (urb);
-                return;
+                return -ENOMEM;
         }
         skb_reserve (skb, NET_IP_ALIGN);
 
@@ -357,6 +357,9 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
                         netif_device_detach (dev->net);
                         break;
+                case -EHOSTUNREACH:
+                        retval = -ENOLINK;
+                        break;
                 default:
                         netif_dbg(dev, rx_err, dev->net,
                                   "rx submit, %d\n", retval);
@@ -374,6 +377,7 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
                 dev_kfree_skb_any (skb);
                 usb_free_urb (urb);
         }
+        return retval;
 }
 
 
@@ -912,6 +916,7 @@ fail_halt:
         /* tasklet could resubmit itself forever if memory is tight */
         if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
                 struct urb      *urb = NULL;
+                int resched = 1;
 
                 if (netif_running (dev->net))
                         urb = usb_alloc_urb (0, GFP_KERNEL);
@@ -922,10 +927,12 @@ fail_halt:
                         status = usb_autopm_get_interface(dev->intf);
                         if (status < 0)
                                 goto fail_lowmem;
-                        rx_submit (dev, urb, GFP_KERNEL);
+                        if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
+                                resched = 0;
                         usb_autopm_put_interface(dev->intf);
 fail_lowmem:
-                        tasklet_schedule (&dev->bh);
+                        if (resched)
+                                tasklet_schedule (&dev->bh);
                 }
         }
 
@@ -1175,8 +1182,11 @@ static void usbnet_bh (unsigned long param)
                         // don't refill the queue all at once
                         for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
                                 urb = usb_alloc_urb (0, GFP_ATOMIC);
-                                if (urb != NULL)
-                                        rx_submit (dev, urb, GFP_ATOMIC);
+                                if (urb != NULL) {
+                                        if (rx_submit (dev, urb, GFP_ATOMIC) ==
+                                            -ENOLINK)
+                                                return;
+                                }
                         }
                         if (temp != dev->rxq.qlen)
                                 netif_dbg(dev, link, dev->net,
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index fd69095ef6e3..f53412368ce1 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -2824,7 +2824,7 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
         netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
 
         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
-                NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM | NETIF_F_SG;
+                NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM;
 
         ret = register_netdev(dev);
         if (ret < 0)
diff --git a/drivers/net/wan/farsync.c b/drivers/net/wan/farsync.c
index ad7719fe6d0a..e050bd65e037 100644
--- a/drivers/net/wan/farsync.c
+++ b/drivers/net/wan/farsync.c
@@ -885,20 +885,21 @@ fst_rx_dma_complete(struct fst_card_info *card, struct fst_port_info *port,
  *      Receive a frame through the DMA
  */
 static inline void
-fst_rx_dma(struct fst_card_info *card, unsigned char *skb,
-           unsigned char *mem, int len)
+fst_rx_dma(struct fst_card_info *card, dma_addr_t skb,
+           dma_addr_t mem, int len)
 {
         /*
          * This routine will setup the DMA and start it
          */
 
-        dbg(DBG_RX, "In fst_rx_dma %p %p %d\n", skb, mem, len);
+        dbg(DBG_RX, "In fst_rx_dma %lx %lx %d\n",
+            (unsigned long) skb, (unsigned long) mem, len);
         if (card->dmarx_in_progress) {
                 dbg(DBG_ASS, "In fst_rx_dma while dma in progress\n");
         }
 
-        outl((unsigned long) skb, card->pci_conf + DMAPADR0);   /* Copy to here */
-        outl((unsigned long) mem, card->pci_conf + DMALADR0);   /* from here */
+        outl(skb, card->pci_conf + DMAPADR0);   /* Copy to here */
+        outl(mem, card->pci_conf + DMALADR0);   /* from here */
         outl(len, card->pci_conf + DMASIZ0);    /* for this length */
         outl(0x00000000c, card->pci_conf + DMADPR0);    /* In this direction */
 
@@ -1309,8 +1310,8 @@ fst_intr_rx(struct fst_card_info *card, struct fst_port_info *port)
                 card->dma_port_rx = port;
                 card->dma_len_rx = len;
                 card->dma_rxpos = rxp;
-                fst_rx_dma(card, (char *) card->rx_dma_handle_card,
-                           (char *) BUF_OFFSET(rxBuffer[pi][rxp][0]), len);
+                fst_rx_dma(card, card->rx_dma_handle_card,
+                           BUF_OFFSET(rxBuffer[pi][rxp][0]), len);
         }
         if (rxp != port->rxpos) {
                 dbg(DBG_ASS, "About to increment rxpos by more than 1\n");
diff --git a/drivers/net/wan/ixp4xx_hss.c b/drivers/net/wan/ixp4xx_hss.c
index 88e363033e23..6c571e198835 100644
--- a/drivers/net/wan/ixp4xx_hss.c
+++ b/drivers/net/wan/ixp4xx_hss.c
@@ -396,7 +396,7 @@ static void hss_config(struct port *port)
         msg.cmd = PORT_CONFIG_WRITE;
         msg.hss_port = port->id;
         msg.index = HSS_CONFIG_TX_PCR;
-        msg.data32 = PCR_FRM_SYNC_OUTPUT_RISING | PCR_MSB_ENDIAN |
+        msg.data32 = PCR_FRM_PULSE_DISABLED | PCR_MSB_ENDIAN |
                 PCR_TX_DATA_ENABLE | PCR_SOF_NO_FBIT;
         if (port->clock_type == CLOCK_INT)
                 msg.data32 |= PCR_SYNC_CLK_DIR_OUTPUT;
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index 33bdc6a84e81..9a121a5b787c 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -32,7 +32,6 @@
 #include <linux/timer.h>
 #include <linux/netdevice.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -155,8 +154,6 @@ static int airo_cs_config_check(struct pcmcia_device *p_dev,
                                 unsigned int vcc,
                                 void *priv_data)
 {
-        win_req_t *req = priv_data;
-
         if (cfg->index == 0)
                 return -ENODEV;
 
@@ -176,52 +173,25 @@ static int airo_cs_config_check(struct pcmcia_device *p_dev,
         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 
         /* IO window settings */
-        p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-                if (!(io->flags & CISTPL_IO_8BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
-                if (!(io->flags & CISTPL_IO_16BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-                p_dev->io.BasePort1 = io->win[0].base;
-                p_dev->io.NumPorts1 = io->win[0].len;
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                                        pcmcia_io_cfg_data_width(io->flags);
+                p_dev->resource[0]->start = io->win[0].base;
+                p_dev->resource[0]->end = io->win[0].len;
                 if (io->nwin > 1) {
-                        p_dev->io.Attributes2 = p_dev->io.Attributes1;
-                        p_dev->io.BasePort2 = io->win[1].base;
-                        p_dev->io.NumPorts2 = io->win[1].len;
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1].base;
+                        p_dev->resource[1]->end = io->win[1].len;
                 }
         }
 
         /* This reserves IO space but doesn't actually enable it */
-        if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
+        if (pcmcia_request_io(p_dev) != 0)
                 return -ENODEV;
 
-        /*
-          Now set up a common memory window, if needed.  There is room
-          in the struct pcmcia_device structure for one memory window handle,
-          but if the base addresses need to be saved, or if multiple
-          windows are needed, the info should go in the private data
-          structure for this device.
-
-          Note that the memory window base is a physical address, and
-          needs to be mapped to virtual space with ioremap() before it
-          is used.
-        */
-        if ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) {
-                cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
-                memreq_t map;
-                req->Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
-                req->Base = mem->win[0].host_addr;
-                req->Size = mem->win[0].len;
-                req->AccessSpeed = 0;
-                if (pcmcia_request_window(p_dev, req, &p_dev->win) != 0)
-                        return -ENODEV;
-                map.Page = 0;
-                map.CardOffset = mem->win[0].card_addr;
-                if (pcmcia_map_mem_page(p_dev, p_dev->win, &map) != 0)
-                        return -ENODEV;
-        }
         /* If we got this far, we're cool! */
         return 0;
 }
@@ -230,17 +200,12 @@ static int airo_cs_config_check(struct pcmcia_device *p_dev,
 static int airo_config(struct pcmcia_device *link)
 {
         local_info_t *dev;
-        win_req_t *req;
         int ret;
 
         dev = link->priv;
 
         dev_dbg(&link->dev, "airo_config\n");
 
-        req = kzalloc(sizeof(win_req_t), GFP_KERNEL);
-        if (!req)
-                return -ENOMEM;
-
         /*
          * In this loop, we scan the CIS for configuration table
          * entries, each of which describes a valid card
@@ -255,7 +220,7 @@ static int airo_config(struct pcmcia_device *link)
          * and most client drivers will only use the CIS to fill in
          * implementation-defined details.
          */
-        ret = pcmcia_loop_config(link, airo_cs_config_check, req);
+        ret = pcmcia_loop_config(link, airo_cs_config_check, NULL);
         if (ret)
                 goto failed;
 
@@ -272,7 +237,7 @@ static int airo_config(struct pcmcia_device *link)
                 goto failed;
         ((local_info_t *)link->priv)->eth_dev =
                 init_airo_card(link->irq,
-                               link->io.BasePort1, 1, &link->dev);
+                               link->resource[0]->start, 1, &link->dev);
         if (!((local_info_t *)link->priv)->eth_dev)
                 goto failed;
 
@@ -282,22 +247,15 @@ static int airo_config(struct pcmcia_device *link)
         if (link->conf.Vpp)
                 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
         printk(", irq %d", link->irq);
-        if (link->io.NumPorts1)
-                printk(", io 0x%04x-0x%04x", link->io.BasePort1,
-                       link->io.BasePort1+link->io.NumPorts1-1);
-        if (link->io.NumPorts2)
-                printk(" & 0x%04x-0x%04x", link->io.BasePort2,
-                       link->io.BasePort2+link->io.NumPorts2-1);
-        if (link->win)
-                printk(", mem 0x%06lx-0x%06lx", req->Base,
-                       req->Base+req->Size-1);
+        if (link->resource[0])
+                printk(" & %pR", link->resource[0]);
+        if (link->resource[1])
+                printk(" & %pR", link->resource[1]);
         printk("\n");
-        kfree(req);
         return 0;
 
  failed:
         airo_release(link);
-        kfree(req);
         return -ENODEV;
 } /* airo_config */
 
diff --git a/drivers/net/wireless/atmel_cs.c b/drivers/net/wireless/atmel_cs.c
index c2746fc7f2be..3b632161c106 100644
--- a/drivers/net/wireless/atmel_cs.c
+++ b/drivers/net/wireless/atmel_cs.c
@@ -42,7 +42,6 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -191,25 +190,23 @@ static int atmel_config_check(struct pcmcia_device *p_dev,
         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 
         /* IO window settings */
-        p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-                if (!(io->flags & CISTPL_IO_8BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
-                if (!(io->flags & CISTPL_IO_16BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-                p_dev->io.BasePort1 = io->win[0].base;
-                p_dev->io.NumPorts1 = io->win[0].len;
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                                        pcmcia_io_cfg_data_width(io->flags);
+                p_dev->resource[0]->start = io->win[0].base;
+                p_dev->resource[0]->end = io->win[0].len;
                 if (io->nwin > 1) {
-                        p_dev->io.Attributes2 = p_dev->io.Attributes1;
-                        p_dev->io.BasePort2 = io->win[1].base;
-                        p_dev->io.NumPorts2 = io->win[1].len;
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1].base;
+                        p_dev->resource[1]->end = io->win[1].len;
                 }
         }
 
         /* This reserves IO space but doesn't actually enable it */
-        return pcmcia_request_io(p_dev, &p_dev->io);
+        return pcmcia_request_io(p_dev);
 }
 
 static int atmel_config(struct pcmcia_device *link)
@@ -254,7 +251,7 @@ static int atmel_config(struct pcmcia_device *link)
 
         ((local_info_t*)link->priv)->eth_dev =
                 init_atmel_card(link->irq,
-                                link->io.BasePort1,
+                                link->resource[0]->start,
                                 did ? did->driver_info : ATMEL_FW_TYPE_NONE,
                                 &link->dev,
                                 card_present,
diff --git a/drivers/net/wireless/b43/pcmcia.c b/drivers/net/wireless/b43/pcmcia.c
index 0e99b634267c..dfbc41d431ff 100644
--- a/drivers/net/wireless/b43/pcmcia.c
+++ b/drivers/net/wireless/b43/pcmcia.c
@@ -26,7 +26,6 @@
 #include <linux/ssb/ssb.h>
 #include <linux/slab.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
@@ -65,7 +64,6 @@ static int __devinit b43_pcmcia_probe(struct pcmcia_device *dev)
 {
         struct ssb_bus *ssb;
         win_req_t win;
-        memreq_t mem;
         int err = -ENOMEM;
         int res = 0;
 
@@ -78,12 +76,7 @@ static int __devinit b43_pcmcia_probe(struct pcmcia_device *dev)
         dev->conf.Attributes = CONF_ENABLE_IRQ;
         dev->conf.IntType = INT_MEMORY_AND_IO;
 
-        dev->io.BasePort2 = 0;
-        dev->io.NumPorts2 = 0;
-        dev->io.Attributes2 = 0;
-
-        win.Attributes = WIN_ADDR_SPACE_MEM | WIN_MEMORY_TYPE_CM |
-                         WIN_ENABLE | WIN_DATA_WIDTH_16 |
+        win.Attributes =  WIN_ENABLE | WIN_DATA_WIDTH_16 |
                          WIN_USE_WAIT;
         win.Base = 0;
         win.Size = SSB_CORE_SIZE;
@@ -92,9 +85,7 @@ static int __devinit b43_pcmcia_probe(struct pcmcia_device *dev)
         if (res != 0)
                 goto err_kfree_ssb;
 
-        mem.CardOffset = 0;
-        mem.Page = 0;
-        res = pcmcia_map_mem_page(dev, dev->win, &mem);
+        res = pcmcia_map_mem_page(dev, dev->win, 0);
         if (res != 0)
                 goto err_disable;
 
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index 29b31a694b59..ba54d1b04d22 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -12,7 +12,6 @@
 #include <linux/wireless.h>
 #include <net/iw_handler.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -23,7 +22,7 @@
 #include "hostap_wlan.h"
 
 
-static dev_info_t dev_info = "hostap_cs";
+static char *dev_info = "hostap_cs";
 
 MODULE_AUTHOR("Jouni Malinen");
 MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "
@@ -225,27 +224,18 @@ static int prism2_pccard_card_present(local_info_t *local)
 static void sandisk_set_iobase(local_info_t *local)
 {
         int res;
-        conf_reg_t reg;
         struct hostap_cs_priv *hw_priv = local->hw_priv;
 
-        reg.Function = 0;
-        reg.Action = CS_WRITE;
-        reg.Offset = 0x10; /* 0x3f0 IO base 1 */
-        reg.Value = hw_priv->link->io.BasePort1 & 0x00ff;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, 0x10,
+                                hw_priv->link->resource[0]->start & 0x00ff);
         if (res != 0) {
                 printk(KERN_DEBUG "Prism3 SanDisk - failed to set I/O base 0 -"
                        " res=%d\n", res);
         }
         udelay(10);
 
-        reg.Function = 0;
-        reg.Action = CS_WRITE;
-        reg.Offset = 0x12; /* 0x3f2 IO base 2 */
-        reg.Value = (hw_priv->link->io.BasePort1 & 0xff00) >> 8;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, 0x12,
+                                (hw_priv->link->resource[0]->start >> 8) & 0x00ff);
         if (res != 0) {
                 printk(KERN_DEBUG "Prism3 SanDisk - failed to set I/O base 1 -"
                        " res=%d\n", res);
@@ -271,12 +261,11 @@ static void sandisk_write_hcr(local_info_t *local, int hcr)
 static int sandisk_enable_wireless(struct net_device *dev)
 {
         int res, ret = 0;
-        conf_reg_t reg;
         struct hostap_interface *iface = netdev_priv(dev);
         local_info_t *local = iface->local;
         struct hostap_cs_priv *hw_priv = local->hw_priv;
 
-        if (hw_priv->link->io.NumPorts1 < 0x42) {
+        if (resource_size(hw_priv->link->resource[0]) < 0x42) {
                 /* Not enough ports to be SanDisk multi-function card */
                 ret = -ENODEV;
                 goto done;
@@ -298,12 +287,8 @@ static int sandisk_enable_wireless(struct net_device *dev)
                " - using vendor-specific initialization\n", dev->name);
         hw_priv->sandisk_connectplus = 1;
 
-        reg.Function = 0;
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_COR;
-        reg.Value = COR_SOFT_RESET;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR,
+                                COR_SOFT_RESET);
         if (res != 0) {
                 printk(KERN_DEBUG "%s: SanDisk - COR sreset failed (%d)\n",
                        dev->name, res);
@@ -311,16 +296,13 @@ static int sandisk_enable_wireless(struct net_device *dev)
         }
         mdelay(5);
 
-        reg.Function = 0;
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_COR;
         /*
          * Do not enable interrupts here to avoid some bogus events. Interrupts
          * will be enabled during the first cor_sreset call.
          */
-        reg.Value = COR_LEVEL_REQ | 0x8 | COR_ADDR_DECODE | COR_FUNC_ENA;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR,
+                                (COR_LEVEL_REQ | 0x8 | COR_ADDR_DECODE |
+                                        COR_FUNC_ENA));
         if (res != 0) {
                 printk(KERN_DEBUG "%s: SanDisk - COR sreset failed (%d)\n",
                        dev->name, res);
@@ -343,30 +325,23 @@ done:
 static void prism2_pccard_cor_sreset(local_info_t *local)
 {
         int res;
-        conf_reg_t reg;
+        u8 val;
         struct hostap_cs_priv *hw_priv = local->hw_priv;
 
         if (!prism2_pccard_card_present(local))
                return;
 
-        reg.Function = 0;
-        reg.Action = CS_READ;
-        reg.Offset = CISREG_COR;
-        reg.Value = 0;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_read_config_byte(hw_priv->link, CISREG_COR, &val);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 1 (%d)\n",
                        res);
                 return;
         }
         printk(KERN_DEBUG "prism2_pccard_cor_sreset: original COR %02x\n",
-               reg.Value);
+                val);
 
-        reg.Action = CS_WRITE;
-        reg.Value |= COR_SOFT_RESET;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        val |= COR_SOFT_RESET;
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR, val);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 2 (%d)\n",
                        res);
@@ -375,11 +350,10 @@ static void prism2_pccard_cor_sreset(local_info_t *local)
 
         mdelay(hw_priv->sandisk_connectplus ? 5 : 2);
 
-        reg.Value &= ~COR_SOFT_RESET;
+        val &= ~COR_SOFT_RESET;
         if (hw_priv->sandisk_connectplus)
-                reg.Value |= COR_IREQ_ENA;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+                val |= COR_IREQ_ENA;
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR, val);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 3 (%d)\n",
                        res);
@@ -396,8 +370,7 @@ static void prism2_pccard_cor_sreset(local_info_t *local)
 static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
 {
         int res;
-        conf_reg_t reg;
-        int old_cor;
+        u8 old_cor;
         struct hostap_cs_priv *hw_priv = local->hw_priv;
 
         if (!prism2_pccard_card_present(local))
@@ -408,25 +381,17 @@ static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
                 return;
         }
 
-        reg.Function = 0;
-        reg.Action = CS_READ;
-        reg.Offset = CISREG_COR;
-        reg.Value = 0;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_read_config_byte(hw_priv->link, CISREG_COR, &old_cor);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 1 "
                        "(%d)\n", res);
                 return;
         }
         printk(KERN_DEBUG "prism2_pccard_genesis_sreset: original COR %02x\n",
-               reg.Value);
-        old_cor = reg.Value;
+                old_cor);
 
-        reg.Action = CS_WRITE;
-        reg.Value |= COR_SOFT_RESET;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR,
+                                old_cor | COR_SOFT_RESET);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 2 "
                        "(%d)\n", res);
@@ -436,11 +401,7 @@ static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
         mdelay(10);
 
         /* Setup Genesis mode */
-        reg.Action = CS_WRITE;
-        reg.Value = hcr;
-        reg.Offset = CISREG_CCSR;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_CCSR, hcr);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 3 "
                        "(%d)\n", res);
@@ -448,11 +409,8 @@ static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
         }
         mdelay(10);
 
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_COR;
-        reg.Value = old_cor & ~COR_SOFT_RESET;
-        res = pcmcia_access_configuration_register(hw_priv->link,
-                                                   &reg);
+        res = pcmcia_write_config_byte(hw_priv->link, CISREG_COR,
+                                old_cor & ~COR_SOFT_RESET);
         if (res != 0) {
                 printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 4 "
                        "(%d)\n", res);
@@ -561,30 +519,24 @@ static int prism2_config_check(struct pcmcia_device *p_dev,
         PDEBUG(DEBUG_EXTRA, "IO window settings: cfg->io.nwin=%d "
                "dflt->io.nwin=%d\n",
                cfg->io.nwin, dflt->io.nwin);
-        p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-                PDEBUG(DEBUG_EXTRA, "io->flags = 0x%04X, "
-                       "io.base=0x%04x, len=%d\n", io->flags,
-                       io->win[0].base, io->win[0].len);
-                if (!(io->flags & CISTPL_IO_8BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
-                if (!(io->flags & CISTPL_IO_16BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-                p_dev->io.IOAddrLines = io->flags &
-                        CISTPL_IO_LINES_MASK;
-                p_dev->io.BasePort1 = io->win[0].base;
-                p_dev->io.NumPorts1 = io->win[0].len;
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                                        pcmcia_io_cfg_data_width(io->flags);
+                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+                p_dev->resource[0]->start = io->win[0].base;
+                p_dev->resource[0]->end = io->win[0].len;
                 if (io->nwin > 1) {
-                        p_dev->io.Attributes2 = p_dev->io.Attributes1;
-                        p_dev->io.BasePort2 = io->win[1].base;
-                        p_dev->io.NumPorts2 = io->win[1].len;
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1].base;
+                        p_dev->resource[1]->end = io->win[1].len;
                 }
         }
 
         /* This reserves IO space but doesn't actually enable it */
-        return pcmcia_request_io(p_dev, &p_dev->io);
+        return pcmcia_request_io(p_dev);
 }
 
 static int prism2_config(struct pcmcia_device *link)
@@ -646,7 +598,7 @@ static int prism2_config(struct pcmcia_device *link)
                 goto failed_unlock;
 
         dev->irq = link->irq;
-        dev->base_addr = link->io.BasePort1;
+        dev->base_addr = link->resource[0]->start;
 
         spin_unlock_irqrestore(&local->irq_init_lock, flags);
 
@@ -658,12 +610,10 @@ static int prism2_config(struct pcmcia_device *link)
                        link->conf.Vpp % 10);
         if (link->conf.Attributes & CONF_ENABLE_IRQ)
                 printk(", irq %d", link->irq);
-        if (link->io.NumPorts1)
-                printk(", io 0x%04x-0x%04x", link->io.BasePort1,
-                       link->io.BasePort1+link->io.NumPorts1-1);
-        if (link->io.NumPorts2)
-                printk(" & 0x%04x-0x%04x", link->io.BasePort2,
-                       link->io.BasePort2+link->io.NumPorts2-1);
+        if (link->resource[0])
+                printk(" & %pR", link->resource[0]);
+        if (link->resource[1])
+                printk(" & %pR", link->resource[1]);
         printk("\n");
 
         local->shutdown = 0;
diff --git a/drivers/net/wireless/libertas/cfg.c b/drivers/net/wireless/libertas/cfg.c
index 51a96f5a342d..3e82f1627209 100644
--- a/drivers/net/wireless/libertas/cfg.c
+++ b/drivers/net/wireless/libertas/cfg.c
@@ -6,6 +6,8 @@
  *
  */
 
+#include <linux/sched.h>
+#include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/ieee80211.h>
diff --git a/drivers/net/wireless/libertas/if_cs.c b/drivers/net/wireless/libertas/if_cs.c
index 08e4e3908003..9c298396be50 100644
--- a/drivers/net/wireless/libertas/if_cs.c
+++ b/drivers/net/wireless/libertas/if_cs.c
@@ -28,7 +28,6 @@
 #include <linux/firmware.h>
 #include <linux/netdevice.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
@@ -802,9 +801,9 @@ static int if_cs_ioprobe(struct pcmcia_device *p_dev,
                          unsigned int vcc,
                          void *priv_data)
 {
-        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-        p_dev->io.BasePort1 = cfg->io.win[0].base;
-        p_dev->io.NumPorts1 = cfg->io.win[0].len;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        p_dev->resource[0]->start = cfg->io.win[0].base;
+        p_dev->resource[0]->end = cfg->io.win[0].len;
 
         /* Do we need to allocate an interrupt? */
         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
@@ -816,7 +815,7 @@ static int if_cs_ioprobe(struct pcmcia_device *p_dev,
         }
 
         /* This reserves IO space but doesn't actually enable it */
-        return pcmcia_request_io(p_dev, &p_dev->io);
+        return pcmcia_request_io(p_dev);
 }
 
 static int if_cs_probe(struct pcmcia_device *p_dev)
@@ -854,7 +853,8 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
                 goto out1;
 
         /* Initialize io access */
-        card->iobase = ioport_map(p_dev->io.BasePort1, p_dev->io.NumPorts1);
+        card->iobase = ioport_map(p_dev->resource[0]->start,
+                                resource_size(p_dev->resource[0]));
         if (!card->iobase) {
                 lbs_pr_err("error in ioport_map\n");
                 ret = -EIO;
@@ -873,9 +873,7 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
         }
 
         /* Finally, report what we've done */
-        lbs_deb_cs("irq %d, io 0x%04x-0x%04x\n",
-               p_dev->irq, p_dev->io.BasePort1,
-               p_dev->io.BasePort1 + p_dev->io.NumPorts1 - 1);
+        lbs_deb_cs("irq %d, io %pR", p_dev->irq, p_dev->resource[0]);
 
         /*
          * Most of the libertas cards can do unaligned register access, but some
diff --git a/drivers/net/wireless/libertas/if_sdio.c b/drivers/net/wireless/libertas/if_sdio.c
index 382f2371a1ab..87b634978b35 100644
--- a/drivers/net/wireless/libertas/if_sdio.c
+++ b/drivers/net/wireless/libertas/if_sdio.c
@@ -125,6 +125,8 @@ struct if_sdio_card {
 
         const char              *helper;
         const char              *firmware;
+        bool                    helper_allocated;
+        bool                    firmware_allocated;
 
         u8                      buffer[65536] __attribute__((aligned(4)));
 
@@ -984,16 +986,34 @@ static int if_sdio_probe(struct sdio_func *func,
         card->helper = if_sdio_models[i].helper;
         card->firmware = if_sdio_models[i].firmware;
 
+        kparam_block_sysfs_write(helper_name);
         if (lbs_helper_name) {
+                char *helper = kstrdup(lbs_helper_name, GFP_KERNEL);
+                if (!helper) {
+                        kparam_unblock_sysfs_write(helper_name);
+                        ret = -ENOMEM;
+                        goto free;
+                }
                 lbs_deb_sdio("overriding helper firmware: %s\n",
                         lbs_helper_name);
-                card->helper = lbs_helper_name;
+                card->helper = helper;
+                card->helper_allocated = true;
         }
+        kparam_unblock_sysfs_write(helper_name);
 
+        kparam_block_sysfs_write(fw_name);
         if (lbs_fw_name) {
+                char *fw_name = kstrdup(lbs_fw_name, GFP_KERNEL);
+                if (!fw_name) {
+                        kparam_unblock_sysfs_write(fw_name);
+                        ret = -ENOMEM;
+                        goto free;
+                }
                 lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
-                card->firmware = lbs_fw_name;
+                card->firmware = fw_name;
+                card->firmware_allocated = true;
         }
+        kparam_unblock_sysfs_write(fw_name);
 
         sdio_claim_host(func);
 
@@ -1127,6 +1147,10 @@ free:
                 kfree(packet);
         }
 
+        if (card->helper_allocated)
+                kfree(card->helper);
+        if (card->firmware_allocated)
+                kfree(card->firmware);
         kfree(card);
 
         goto out;
@@ -1177,6 +1201,10 @@ static void if_sdio_remove(struct sdio_func *func)
                 kfree(packet);
         }
 
+        if (card->helper_allocated)
+                kfree(card->helper);
+        if (card->firmware_allocated)
+                kfree(card->firmware);
         kfree(card);
 
         lbs_deb_leave(LBS_DEB_SDIO);
diff --git a/drivers/net/wireless/libertas/if_usb.c b/drivers/net/wireless/libertas/if_usb.c
index 07ece9d26c63..3ff61063671a 100644
--- a/drivers/net/wireless/libertas/if_usb.c
+++ b/drivers/net/wireless/libertas/if_usb.c
@@ -289,10 +289,13 @@ static int if_usb_probe(struct usb_interface *intf,
         }
 
         /* Upload firmware */
+        kparam_block_sysfs_write(fw_name);
         if (__if_usb_prog_firmware(cardp, lbs_fw_name, BOOT_CMD_FW_BY_USB)) {
+                kparam_unblock_sysfs_write(fw_name);
                 lbs_deb_usbd(&udev->dev, "FW upload failed\n");
                 goto err_prog_firmware;
         }
+        kparam_unblock_sysfs_write(fw_name);
 
         if (!(priv = lbs_add_card(cardp, &udev->dev)))
                 goto err_prog_firmware;
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c
index b172f5d87a3b..41a4f214ade1 100644
--- a/drivers/net/wireless/libertas_tf/if_usb.c
+++ b/drivers/net/wireless/libertas_tf/if_usb.c
@@ -811,12 +811,15 @@ static int if_usb_prog_firmware(struct if_usb_card *cardp)
 
         lbtf_deb_enter(LBTF_DEB_USB);
 
+        kparam_block_sysfs_write(fw_name);
         ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev);
         if (ret < 0) {
                 pr_err("request_firmware() failed with %#x\n", ret);
                 pr_err("firmware %s not found\n", lbtf_fw_name);
+                kparam_unblock_sysfs_write(fw_name);
                 goto done;
         }
+        kparam_unblock_sysfs_write(fw_name);
 
         if (check_fwfile_format(cardp->fw->data, cardp->fw->size))
                 goto release_fw;
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index b16d5db52a4d..ef46a2d88539 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -17,7 +17,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -192,25 +191,23 @@ static int orinoco_cs_config_check(struct pcmcia_device *p_dev,
         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 
         /* IO window settings */
-        p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-                if (!(io->flags & CISTPL_IO_8BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
-                if (!(io->flags & CISTPL_IO_16BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-                p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->io.BasePort1 = io->win[0].base;
-                p_dev->io.NumPorts1 = io->win[0].len;
+                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                        pcmcia_io_cfg_data_width(io->flags);
+                p_dev->resource[0]->start = io->win[0].base;
+                p_dev->resource[0]->end = io->win[0].len;
                 if (io->nwin > 1) {
-                        p_dev->io.Attributes2 = p_dev->io.Attributes1;
-                        p_dev->io.BasePort2 = io->win[1].base;
-                        p_dev->io.NumPorts2 = io->win[1].len;
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1].base;
+                        p_dev->resource[1]->end = io->win[1].len;
                 }
 
                 /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
+                if (pcmcia_request_io(p_dev) != 0)
                         goto next_entry;
         }
         return 0;
@@ -258,7 +255,8 @@ orinoco_cs_config(struct pcmcia_device *link)
         /* We initialize the hermes structure before completing PCMCIA
          * configuration just in case the interrupt handler gets
          * called. */
-        mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
+        mem = ioport_map(link->resource[0]->start,
+                        resource_size(link->resource[0]));
         if (!mem)
                 goto failed;
 
@@ -280,7 +278,7 @@ orinoco_cs_config(struct pcmcia_device *link)
         }
 
         /* Register an interface with the stack */
-        if (orinoco_if_add(priv, link->io.BasePort1,
+        if (orinoco_if_add(priv, link->resource[0]->start,
                            link->irq, NULL) != 0) {
                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
                 goto failed;
diff --git a/drivers/net/wireless/orinoco/spectrum_cs.c b/drivers/net/wireless/orinoco/spectrum_cs.c
index b51a9adc80f6..873877e17e1b 100644
--- a/drivers/net/wireless/orinoco/spectrum_cs.c
+++ b/drivers/net/wireless/orinoco/spectrum_cs.c
@@ -25,7 +25,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -80,35 +79,27 @@ static int
 spectrum_reset(struct pcmcia_device *link, int idle)
 {
         int ret;
-        conf_reg_t reg;
-        u_int save_cor;
+        u8 save_cor;
+        u8 ccsr;
 
         /* Doing it if hardware is gone is guaranteed crash */
         if (!pcmcia_dev_present(link))
                 return -ENODEV;
 
         /* Save original COR value */
-        reg.Function = 0;
-        reg.Action = CS_READ;
-        reg.Offset = CISREG_COR;
-        ret = pcmcia_access_configuration_register(link, &reg);
+        ret = pcmcia_read_config_byte(link, CISREG_COR, &save_cor);
         if (ret)
                 goto failed;
-        save_cor = reg.Value;
 
         /* Soft-Reset card */
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_COR;
-        reg.Value = (save_cor | COR_SOFT_RESET);
-        ret = pcmcia_access_configuration_register(link, &reg);
+        ret = pcmcia_write_config_byte(link, CISREG_COR,
+                                (save_cor | COR_SOFT_RESET));
         if (ret)
                 goto failed;
         udelay(1000);
 
         /* Read CCSR */
-        reg.Action = CS_READ;
-        reg.Offset = CISREG_CCSR;
-        ret = pcmcia_access_configuration_register(link, &reg);
+        ret = pcmcia_read_config_byte(link, CISREG_CCSR, &ccsr);
         if (ret)
                 goto failed;
 
@@ -116,19 +107,15 @@ spectrum_reset(struct pcmcia_device *link, int idle)
          * Start or stop the firmware.  Memory width bit should be
          * preserved from the value we've just read.
          */
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_CCSR;
-        reg.Value = (idle ? HCR_IDLE : HCR_RUN) | (reg.Value & HCR_MEM16);
-        ret = pcmcia_access_configuration_register(link, &reg);
+        ccsr = (idle ? HCR_IDLE : HCR_RUN) | (ccsr & HCR_MEM16);
+        ret = pcmcia_write_config_byte(link, CISREG_CCSR, ccsr);
         if (ret)
                 goto failed;
         udelay(1000);
 
         /* Restore original COR configuration index */
-        reg.Action = CS_WRITE;
-        reg.Offset = CISREG_COR;
-        reg.Value = (save_cor & ~COR_SOFT_RESET);
-        ret = pcmcia_access_configuration_register(link, &reg);
+        ret = pcmcia_write_config_byte(link, CISREG_COR,
+                                (save_cor & ~COR_SOFT_RESET));
         if (ret)
                 goto failed;
         udelay(1000);
@@ -266,25 +253,23 @@ static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 
         /* IO window settings */
-        p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-                if (!(io->flags & CISTPL_IO_8BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
-                if (!(io->flags & CISTPL_IO_16BIT))
-                        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-                p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->io.BasePort1 = io->win[0].base;
-                p_dev->io.NumPorts1 = io->win[0].len;
+                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                        pcmcia_io_cfg_data_width(io->flags);
+                p_dev->resource[0]->start = io->win[0].base;
+                p_dev->resource[0]->end = io->win[0].len;
                 if (io->nwin > 1) {
-                        p_dev->io.Attributes2 = p_dev->io.Attributes1;
-                        p_dev->io.BasePort2 = io->win[1].base;
-                        p_dev->io.NumPorts2 = io->win[1].len;
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1].base;
+                        p_dev->resource[1]->end = io->win[1].len;
                 }
 
                 /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
+                if (pcmcia_request_io(p_dev) != 0)
                         goto next_entry;
         }
         return 0;
@@ -332,7 +317,8 @@ spectrum_cs_config(struct pcmcia_device *link)
         /* We initialize the hermes structure before completing PCMCIA
          * configuration just in case the interrupt handler gets
          * called. */
-        mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
+        mem = ioport_map(link->resource[0]->start,
+                        resource_size(link->resource[0]));
         if (!mem)
                 goto failed;
 
@@ -359,7 +345,7 @@ spectrum_cs_config(struct pcmcia_device *link)
         }
 
         /* Register an interface with the stack */
-        if (orinoco_if_add(priv, link->io.BasePort1,
+        if (orinoco_if_add(priv, link->resource[0]->start,
                            link->irq, NULL) != 0) {
                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
                 goto failed;
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index 9c38fc331dca..88560d0ae50a 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -46,7 +46,6 @@
 #include <linux/ethtool.h>
 #include <linux/ieee80211.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -315,9 +314,8 @@ static int ray_probe(struct pcmcia_device *p_dev)
         local->finder = p_dev;
 
         /* The io structure describes IO port mapping. None used here */
-        p_dev->io.NumPorts1 = 0;
-        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-        p_dev->io.IOAddrLines = 5;
+        p_dev->resource[0]->end = 0;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 
         /* General socket configuration */
         p_dev->conf.Attributes = CONF_ENABLE_IRQ;
@@ -394,7 +392,6 @@ static int ray_config(struct pcmcia_device *link)
         int ret = 0;
         int i;
         win_req_t req;
-        memreq_t mem;
         struct net_device *dev = (struct net_device *)link->priv;
         ray_dev_t *local = netdev_priv(dev);
 
@@ -431,9 +428,7 @@ static int ray_config(struct pcmcia_device *link)
         ret = pcmcia_request_window(link, &req, &link->win);
         if (ret)
                 goto failed;
-        mem.CardOffset = 0x0000;
-        mem.Page = 0;
-        ret = pcmcia_map_mem_page(link, link->win, &mem);
+        ret = pcmcia_map_mem_page(link, link->win, 0);
         if (ret)
                 goto failed;
         local->sram = ioremap(req.Base, req.Size);
@@ -447,9 +442,7 @@ static int ray_config(struct pcmcia_device *link)
         ret = pcmcia_request_window(link, &req, &local->rmem_handle);
         if (ret)
                 goto failed;
-        mem.CardOffset = 0x8000;
-        mem.Page = 0;
-        ret = pcmcia_map_mem_page(link, local->rmem_handle, &mem);
+        ret = pcmcia_map_mem_page(link, local->rmem_handle, 0x8000);
         if (ret)
                 goto failed;
         local->rmem = ioremap(req.Base, req.Size);
@@ -463,9 +456,7 @@ static int ray_config(struct pcmcia_device *link)
         ret = pcmcia_request_window(link, &req, &local->amem_handle);
         if (ret)
                 goto failed;
-        mem.CardOffset = 0x0000;
-        mem.Page = 0;
-        ret = pcmcia_map_mem_page(link, local->amem_handle, &mem);
+        ret = pcmcia_map_mem_page(link, local->amem_handle, 0);
         if (ret)
                 goto failed;
         local->amem = ioremap(req.Base, req.Size);
@@ -793,7 +784,6 @@ static void ray_release(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
         ray_dev_t *local = netdev_priv(dev);
-        int i;
 
         dev_dbg(&link->dev, "ray_release\n");
 
@@ -802,13 +792,6 @@ static void ray_release(struct pcmcia_device *link)
         iounmap(local->sram);
         iounmap(local->rmem);
         iounmap(local->amem);
-        /* Do bother checking to see if these succeed or not */
-        i = pcmcia_release_window(link, local->amem_handle);
-        if (i != 0)
-                dev_dbg(&link->dev, "ReleaseWindow(local->amem) ret = %x\n", i);
-        i = pcmcia_release_window(link, local->rmem_handle);
-        if (i != 0)
-                dev_dbg(&link->dev, "ReleaseWindow(local->rmem) ret = %x\n", i);
         pcmcia_disable_device(link);
 
         dev_dbg(&link->dev, "ray_release ending\n");
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index 376c6b964a9c..a1cc2d498a1c 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -48,7 +48,6 @@
 
 #include <net/iw_handler.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
@@ -89,13 +88,6 @@
 static int wl3501_config(struct pcmcia_device *link);
 static void wl3501_release(struct pcmcia_device *link);
 
-/*
- * The dev_info variable is the "key" that is used to match up this
- * device driver with appropriate cards, through the card configuration
- * database.
- */
-static dev_info_t wl3501_dev_info = "wl3501_cs";
-
 static const struct {
         int reg_domain;
         int min, max, deflt;
@@ -1421,7 +1413,7 @@ static struct iw_statistics *wl3501_get_wireless_stats(struct net_device *dev)
 
 static void wl3501_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
-        strlcpy(info->driver, wl3501_dev_info, sizeof(info->driver));
+        strlcpy(info->driver, "wl3501_cs", sizeof(info->driver));
 }
 
 static const struct ethtool_ops ops = {
@@ -1892,9 +1884,8 @@ static int wl3501_probe(struct pcmcia_device *p_dev)
         struct wl3501_card *this;
 
         /* The io structure describes IO port mapping */
-        p_dev->io.NumPorts1     = 16;
-        p_dev->io.Attributes1   = IO_DATA_PATH_WIDTH_8;
-        p_dev->io.IOAddrLines   = 5;
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[0]->flags       = IO_DATA_PATH_WIDTH_8;
 
         /* General socket configuration */
         p_dev->conf.Attributes  = CONF_ENABLE_IRQ;
@@ -1940,13 +1931,14 @@ static int wl3501_config(struct pcmcia_device *link)
         /* Try allocating IO ports.  This tries a few fixed addresses.  If you
          * want, you can also read the card's config table to pick addresses --
          * see the serial driver for an example. */
+        link->io_lines = 5;
 
         for (j = 0x280; j < 0x400; j += 0x20) {
                 /* The '^0x300' is so that we probe 0x300-0x3ff first, then
                  * 0x200-0x2ff, and so on, because this seems safer */
-                link->io.BasePort1 = j;
-                link->io.BasePort2 = link->io.BasePort1 + 0x10;
-                i = pcmcia_request_io(link, &link->io);
+                link->resource[0]->start = j;
+                link->resource[1]->start = link->resource[0]->start + 0x10;
+                i = pcmcia_request_io(link);
                 if (i == 0)
                         break;
         }
@@ -1968,7 +1960,7 @@ static int wl3501_config(struct pcmcia_device *link)
                 goto failed;
 
         dev->irq = link->irq;
-        dev->base_addr = link->io.BasePort1;
+        dev->base_addr = link->resource[0]->start;
         SET_NETDEV_DEV(dev, &link->dev);
         if (register_netdev(dev)) {
                 printk(KERN_NOTICE "wl3501_cs: register_netdev() failed\n");
diff --git a/drivers/net/xilinx_emaclite.c b/drivers/net/xilinx_emaclite.c
index d04c5b262050..ecbbb688eba0 100644
--- a/drivers/net/xilinx_emaclite.c
+++ b/drivers/net/xilinx_emaclite.c
@@ -20,7 +20,7 @@
 #include <linux/skbuff.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-
+#include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
 #include <linux/of_mdio.h>
@@ -1086,7 +1086,7 @@ static void xemaclite_remove_ndev(struct net_device *ndev)
  *
  * Return:      Value of the parameter if the parameter is found, or 0 otherwise
  */
-static bool get_bool(struct of_device *ofdev, const char *s)
+static bool get_bool(struct platform_device *ofdev, const char *s)
 {
         u32 *p = (u32 *)of_get_property(ofdev->dev.of_node, s, NULL);
 
@@ -1115,7 +1115,7 @@ static struct net_device_ops xemaclite_netdev_ops;
  * Return:      0, if the driver is bound to the Emaclite device, or
  *              a negative error if there is failure.
  */
-static int __devinit xemaclite_of_probe(struct of_device *ofdev,
+static int __devinit xemaclite_of_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct resource r_irq; /* Interrupt resources */
@@ -1240,7 +1240,7 @@ error2:
  *
  * Return:      0, always.
  */
-static int __devexit xemaclite_of_remove(struct of_device *of_dev)
+static int __devexit xemaclite_of_remove(struct platform_device *of_dev)
 {
         struct device *dev = &of_dev->dev;
         struct net_device *ndev = dev_get_drvdata(dev);