Merge ../linux-2.6 by hand

192 files changed, 15509 insertions, 7204 deletions

diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index bc537440ca02..f822cd3025ff 100644
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -1027,8 +1027,7 @@ static void cp_reset_hw (struct cp_private *cp)
                 if (!(cpr8(Cmd) & CmdReset))
                         return;
 
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(10);
+                schedule_timeout_uninterruptible(10);
         }
 
         printk(KERN_ERR "%s: hardware reset timeout\n", cp->dev->name);
@@ -1575,6 +1574,7 @@ static struct ethtool_ops cp_ethtool_ops = {
         .set_wol                = cp_set_wol,
         .get_strings            = cp_get_strings,
         .get_ethtool_stats      = cp_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static int cp_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
@@ -1773,6 +1773,7 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         for (i = 0; i < 3; i++)
                 ((u16 *) (dev->dev_addr))[i] =
                     le16_to_cpu (read_eeprom (regs, i + 7, addr_len));
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         dev->open = cp_open;
         dev->stop = cp_close;
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index 4c2cf7bbd252..30bee11c48bd 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -552,7 +552,8 @@ const static struct {
 
         { "RTL-8100B/8139D",
           HW_REVID(1, 1, 1, 0, 1, 0, 1),
-          HasLWake,
+          HasHltClk /* XXX undocumented? */
+        | HasLWake,
         },
 
         { "RTL-8101",
@@ -970,6 +971,7 @@ static int __devinit rtl8139_init_one (struct pci_dev *pdev,
         for (i = 0; i < 3; i++)
                 ((u16 *) (dev->dev_addr))[i] =
                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         /* The Rtl8139-specific entries in the device structure. */
         dev->open = rtl8139_open;
@@ -2465,6 +2467,7 @@ static struct ethtool_ops rtl8139_ethtool_ops = {
         .get_strings            = rtl8139_get_strings,
         .get_stats_count        = rtl8139_get_stats_count,
         .get_ethtool_stats      = rtl8139_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index c748b0e16419..6d4f9ceb0a32 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -475,6 +475,14 @@ config SGI_IOC3_ETH_HW_TX_CSUM
           the moment only acceleration of IPv4 is supported.  This option
           enables offloading for checksums on transmit.  If unsure, say Y.
 
+config MIPS_SIM_NET
+        tristate "MIPS simulator Network device (EXPERIMENTAL)"
+        depends on NETDEVICES && MIPS_SIM && EXPERIMENTAL
+        help
+          The MIPSNET device is a simple Ethernet network device which is
+          emulated by the MIPS Simulator.
+          If you are not using a MIPSsim or are unsure, say N.
+
 config SGI_O2MACE_ETH
         tristate "SGI O2 MACE Fast Ethernet support"
         depends on NET_ETHERNET && SGI_IP32=y
@@ -1155,38 +1163,74 @@ config IBMVETH
           be called ibmveth.
 
 config IBM_EMAC
-        bool "IBM PPC4xx EMAC driver support"
+        tristate "PowerPC 4xx on-chip Ethernet support"
         depends on 4xx
-        select CRC32
-        ---help---
-          This driver supports the IBM PPC4xx EMAC family of on-chip
-          Ethernet controllers.
-
-config IBM_EMAC_ERRMSG
-        bool "Verbose error messages"
-        depends on IBM_EMAC && BROKEN
+        help
+          This driver supports the PowerPC 4xx EMAC family of on-chip
+          Ethernet controllers.
 
 config IBM_EMAC_RXB
         int "Number of receive buffers"
         depends on IBM_EMAC
-        default "128" if IBM_EMAC4
-        default "64"
+        default "128"
 
 config IBM_EMAC_TXB
         int "Number of transmit buffers"
         depends on IBM_EMAC
-        default "128" if IBM_EMAC4
-        default "8"
+        default "64"
+
+config IBM_EMAC_POLL_WEIGHT
+        int "MAL NAPI polling weight"
+        depends on IBM_EMAC
+        default "32"
 
-config IBM_EMAC_FGAP
-        int "Frame gap"
+config IBM_EMAC_RX_COPY_THRESHOLD
+        int "RX skb copy threshold (bytes)"
         depends on IBM_EMAC
-        default "8"
+        default "256"
 
-config IBM_EMAC_SKBRES
-        int "Skb reserve amount"
+config IBM_EMAC_RX_SKB_HEADROOM
+        int "Additional RX skb headroom (bytes)"
         depends on IBM_EMAC
         default "0"
+        help
+          Additional receive skb headroom. Note, that driver
+          will always reserve at least 2 bytes to make IP header
+          aligned, so usualy there is no need to add any additional
+          headroom.
+          
+          If unsure, set to 0.
+
+config IBM_EMAC_PHY_RX_CLK_FIX
+        bool "PHY Rx clock workaround"
+        depends on IBM_EMAC && (405EP || 440GX || 440EP)
+        help
+          Enable this if EMAC attached to a PHY which doesn't generate
+          RX clock if there is no link, if this is the case, you will 
+          see "TX disable timeout" or "RX disable timeout" in the system
+          log.
+          
+          If unsure, say N.
+
+config IBM_EMAC_DEBUG
+        bool "Debugging"
+        depends on IBM_EMAC
+        default n
+
+config IBM_EMAC_ZMII
+        bool
+        depends on IBM_EMAC && (NP405H || NP405L || 44x)
+        default y
+
+config IBM_EMAC_RGMII
+        bool
+        depends on IBM_EMAC && 440GX
+        default y
+                
+config IBM_EMAC_TAH
+        bool
+        depends on IBM_EMAC && 440GX
+        default y
 
 config NET_PCI
         bool "EISA, VLB, PCI and on board controllers"
@@ -1330,7 +1374,7 @@ config FORCEDETH
 
 config CS89x0
         tristate "CS89x0 support"
-        depends on (NET_PCI && (ISA || ARCH_IXDP2X01)) || ARCH_PNX0105
+        depends on (NET_PCI && (ISA || ARCH_IXDP2X01)) || ARCH_PNX0105 || MACH_MP1000
         ---help---
           Support for CS89x0 chipset based Ethernet cards. If you have a
           network (Ethernet) card of this type, say Y and read the
@@ -1767,6 +1811,7 @@ config NE_H8300
           controller on the Renesas H8/300 processor.
 
 source "drivers/net/fec_8xx/Kconfig"
+source "drivers/net/fs_enet/Kconfig"
 
 endmenu
 
@@ -2083,6 +2128,7 @@ config SPIDER_NET
 config GIANFAR
         tristate "Gianfar Ethernet"
         depends on 85xx || 83xx
+        select PHYLIB
         help
           This driver supports the Gigabit TSEC on the MPC85xx 
           family of chips, and the FEC on the 8540
@@ -2192,8 +2238,8 @@ config S2IO
         depends on PCI
         ---help---
           This driver supports the 10Gbe XFrame NIC of S2IO. 
-          For help regarding driver compilation, installation and 
-          tuning please look into ~/drivers/net/s2io/README.txt.
+          More specific information on configuring the driver is in 
+          <file:Documentation/networking/s2io.txt>.
 
 config S2IO_NAPI
         bool "Use Rx Polling (NAPI) (EXPERIMENTAL)"
@@ -2243,6 +2289,20 @@ config ISERIES_VETH
         tristate "iSeries Virtual Ethernet driver support"
         depends on PPC_ISERIES
 
+config RIONET
+        tristate "RapidIO Ethernet over messaging driver support"
+        depends on NETDEVICES && RAPIDIO
+
+config RIONET_TX_SIZE
+        int "Number of outbound queue entries"
+        depends on RIONET
+        default "128"
+
+config RIONET_RX_SIZE
+        int "Number of inbound queue entries"
+        depends on RIONET
+        default "128"
+
 config FDDI
         bool "FDDI driver support"
         depends on (PCI || EISA)
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 8aeec9f2495b..7c313cb341b8 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -13,7 +13,7 @@ obj-$(CONFIG_CHELSIO_T1) += chelsio/
 obj-$(CONFIG_BONDING) += bonding/
 obj-$(CONFIG_GIANFAR) += gianfar_driver.o
 
-gianfar_driver-objs := gianfar.o gianfar_ethtool.o gianfar_phy.o
+gianfar_driver-objs := gianfar.o gianfar_ethtool.o gianfar_mii.o
 
 #
 # link order important here
@@ -64,6 +64,7 @@ obj-$(CONFIG_SKFP) += skfp/
 obj-$(CONFIG_VIA_RHINE) += via-rhine.o
 obj-$(CONFIG_VIA_VELOCITY) += via-velocity.o
 obj-$(CONFIG_ADAPTEC_STARFIRE) += starfire.o
+obj-$(CONFIG_RIONET) += rionet.o
 
 #
 # end link order section
@@ -166,6 +167,7 @@ obj-$(CONFIG_EQUALIZER) += eql.o
 obj-$(CONFIG_MIPS_JAZZ_SONIC) += jazzsonic.o
 obj-$(CONFIG_MIPS_GT96100ETH) += gt96100eth.o
 obj-$(CONFIG_MIPS_AU1X00_ENET) += au1000_eth.o
+obj-$(CONFIG_MIPS_SIM_NET) += mipsnet.o
 obj-$(CONFIG_SGI_IOC3_ETH) += ioc3-eth.o
 obj-$(CONFIG_DECLANCE) += declance.o
 obj-$(CONFIG_ATARILANCE) += atarilance.o
@@ -201,3 +203,6 @@ obj-$(CONFIG_IRDA) += irda/
 obj-$(CONFIG_ETRAX_ETHERNET) += cris/
 
 obj-$(CONFIG_NETCONSOLE) += netconsole.o
+
+obj-$(CONFIG_FS_ENET) += fs_enet/
+
diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index dbecc6bf7851..b8953de5664a 100644
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -871,10 +871,8 @@ static void ace_init_cleanup(struct net_device *dev)
         if (ap->info)
                 pci_free_consistent(ap->pdev, sizeof(struct ace_info),
                                     ap->info, ap->info_dma);
-        if (ap->skb)
-                kfree(ap->skb);
-        if (ap->trace_buf)
-                kfree(ap->trace_buf);
+        kfree(ap->skb);
+        kfree(ap->trace_buf);
 
         if (dev->irq)
                 free_irq(dev->irq, dev);
diff --git a/drivers/net/amd8111e.c b/drivers/net/amd8111e.c
index d9ba8be72af8..d9ba8be72af8 100755..100644
--- a/drivers/net/amd8111e.c
+++ b/drivers/net/amd8111e.c
diff --git a/drivers/net/amd8111e.h b/drivers/net/amd8111e.h
index cfe3a4298822..cfe3a4298822 100755..100644
--- a/drivers/net/amd8111e.h
+++ b/drivers/net/amd8111e.h
diff --git a/drivers/net/arm/am79c961a.c b/drivers/net/arm/am79c961a.c
index c56d86d371a9..3d50e953faaa 100644
--- a/drivers/net/arm/am79c961a.c
+++ b/drivers/net/arm/am79c961a.c
@@ -29,6 +29,7 @@
 
 #include <asm/system.h>
 #include <asm/irq.h>
+#include <asm/hardware.h>
 #include <asm/io.h>
 
 #define TX_BUFFERS 15
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index c82b9cd1c924..332e9953c55c 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -151,13 +151,6 @@ struct au1000_private *au_macs[NUM_ETH_INTERFACES];
         SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \
         SUPPORTED_Autoneg
 
-static char *phy_link[] = 
-{       "unknown", 
-        "10Base2", "10BaseT", 
-        "AUI",
-        "100BaseT", "100BaseTX", "100BaseFX"
-};
-
 int bcm_5201_init(struct net_device *dev, int phy_addr)
 {
         s16 data;
@@ -785,6 +778,7 @@ static struct mii_chip_info {
         {"Broadcom BCM5201 10/100 BaseT PHY",0x0040,0x6212, &bcm_5201_ops,0},
         {"Broadcom BCM5221 10/100 BaseT PHY",0x0040,0x61e4, &bcm_5201_ops,0},
         {"Broadcom BCM5222 10/100 BaseT PHY",0x0040,0x6322, &bcm_5201_ops,1},
+        {"NS DP83847 PHY", 0x2000, 0x5c30, &bcm_5201_ops ,0},
         {"AMD 79C901 HomePNA PHY",0x0000,0x35c8, &am79c901_ops,0},
         {"AMD 79C874 10/100 BaseT PHY",0x0022,0x561b, &am79c874_ops,0},
         {"LSI 80227 10/100 BaseT PHY",0x0016,0xf840, &lsi_80227_ops,0},
@@ -1045,7 +1039,7 @@ found:
 #endif
 
         if (aup->mii->chip_info == NULL) {
-                printk(KERN_ERR "%s: Au1x No MII transceivers found!\n",
+                printk(KERN_ERR "%s: Au1x No known MII transceivers found!\n",
                                 dev->name);
                 return -1;
         }
@@ -1546,6 +1540,9 @@ au1000_probe(u32 ioaddr, int irq, int port_num)
                 printk(KERN_ERR "%s: out of memory\n", dev->name);
                 goto err_out;
         }
+        aup->mii->next = NULL;
+        aup->mii->chip_info = NULL;
+        aup->mii->status = 0;
         aup->mii->mii_control_reg = 0;
         aup->mii->mii_data_reg = 0;
 
@@ -1609,8 +1606,7 @@ err_out:
         /* here we should have a valid dev plus aup-> register addresses
          * so we can reset the mac properly.*/
         reset_mac(dev);
-        if (aup->mii)
-                kfree(aup->mii);
+        kfree(aup->mii);
         for (i = 0; i < NUM_RX_DMA; i++) {
                 if (aup->rx_db_inuse[i])
                         ReleaseDB(aup, aup->rx_db_inuse[i]);
@@ -1809,8 +1805,7 @@ static void __exit au1000_cleanup_module(void)
                 if (dev) {
                         aup = (struct au1000_private *) dev->priv;
                         unregister_netdev(dev);
-                        if (aup->mii)
-                                kfree(aup->mii);
+                        kfree(aup->mii);
                         for (j = 0; j < NUM_RX_DMA; j++) {
                                 if (aup->rx_db_inuse[j])
                                         ReleaseDB(aup, aup->rx_db_inuse[j]);
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 94939f570f78..0ee3e27969c6 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -19,6 +19,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/version.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -106,6 +107,29 @@ static int b44_poll(struct net_device *dev, int *budget);
 static void b44_poll_controller(struct net_device *dev);
 #endif
 
+static int dma_desc_align_mask;
+static int dma_desc_sync_size;
+
+static inline void b44_sync_dma_desc_for_device(struct pci_dev *pdev,
+                                                dma_addr_t dma_base,
+                                                unsigned long offset,
+                                                enum dma_data_direction dir)
+{
+        dma_sync_single_range_for_device(&pdev->dev, dma_base,
+                                         offset & dma_desc_align_mask,
+                                         dma_desc_sync_size, dir);
+}
+
+static inline void b44_sync_dma_desc_for_cpu(struct pci_dev *pdev,
+                                             dma_addr_t dma_base,
+                                             unsigned long offset,
+                                             enum dma_data_direction dir)
+{
+        dma_sync_single_range_for_cpu(&pdev->dev, dma_base,
+                                      offset & dma_desc_align_mask,
+                                      dma_desc_sync_size, dir);
+}
+
 static inline unsigned long br32(const struct b44 *bp, unsigned long reg)
 {
         return readl(bp->regs + reg);
@@ -668,6 +692,11 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
         dp->ctrl = cpu_to_le32(ctrl);
         dp->addr = cpu_to_le32((u32) mapping + bp->rx_offset + bp->dma_offset);
 
+        if (bp->flags & B44_FLAG_RX_RING_HACK)
+                b44_sync_dma_desc_for_device(bp->pdev, bp->rx_ring_dma,
+                                             dest_idx * sizeof(dp),
+                                             DMA_BIDIRECTIONAL);
+
         return RX_PKT_BUF_SZ;
 }
 
@@ -692,6 +721,11 @@ static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
         pci_unmap_addr_set(dest_map, mapping,
                            pci_unmap_addr(src_map, mapping));
 
+        if (bp->flags & B44_FLAG_RX_RING_HACK)
+                b44_sync_dma_desc_for_cpu(bp->pdev, bp->rx_ring_dma,
+                                          src_idx * sizeof(src_desc),
+                                          DMA_BIDIRECTIONAL);
+
         ctrl = src_desc->ctrl;
         if (dest_idx == (B44_RX_RING_SIZE - 1))
                 ctrl |= cpu_to_le32(DESC_CTRL_EOT);
@@ -700,8 +734,14 @@ static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
 
         dest_desc->ctrl = ctrl;
         dest_desc->addr = src_desc->addr;
+
         src_map->skb = NULL;
 
+        if (bp->flags & B44_FLAG_RX_RING_HACK)
+                b44_sync_dma_desc_for_device(bp->pdev, bp->rx_ring_dma,
+                                             dest_idx * sizeof(dest_desc),
+                                             DMA_BIDIRECTIONAL);
+
         pci_dma_sync_single_for_device(bp->pdev, src_desc->addr,
                                        RX_PKT_BUF_SZ,
                                        PCI_DMA_FROMDEVICE);
@@ -959,6 +999,11 @@ static int b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
         bp->tx_ring[entry].ctrl = cpu_to_le32(ctrl);
         bp->tx_ring[entry].addr = cpu_to_le32((u32) mapping+bp->dma_offset);
 
+        if (bp->flags & B44_FLAG_TX_RING_HACK)
+                b44_sync_dma_desc_for_device(bp->pdev, bp->tx_ring_dma,
+                                             entry * sizeof(bp->tx_ring[0]),
+                                             DMA_TO_DEVICE);
+
         entry = NEXT_TX(entry);
 
         bp->tx_prod = entry;
@@ -1064,6 +1109,16 @@ static void b44_init_rings(struct b44 *bp)
         memset(bp->rx_ring, 0, B44_RX_RING_BYTES);
         memset(bp->tx_ring, 0, B44_TX_RING_BYTES);
 
+        if (bp->flags & B44_FLAG_RX_RING_HACK)
+                dma_sync_single_for_device(&bp->pdev->dev, bp->rx_ring_dma,
+                                           DMA_TABLE_BYTES,
+                                           PCI_DMA_BIDIRECTIONAL);
+
+        if (bp->flags & B44_FLAG_TX_RING_HACK)
+                dma_sync_single_for_device(&bp->pdev->dev, bp->tx_ring_dma,
+                                           DMA_TABLE_BYTES,
+                                           PCI_DMA_TODEVICE);
+
         for (i = 0; i < bp->rx_pending; i++) {
                 if (b44_alloc_rx_skb(bp, -1, i) < 0)
                         break;
@@ -1076,23 +1131,33 @@ static void b44_init_rings(struct b44 *bp)
  */
 static void b44_free_consistent(struct b44 *bp)
 {
-        if (bp->rx_buffers) {
-                kfree(bp->rx_buffers);
-                bp->rx_buffers = NULL;
-        }
-        if (bp->tx_buffers) {
-                kfree(bp->tx_buffers);
-                bp->tx_buffers = NULL;
-        }
+        kfree(bp->rx_buffers);
+        bp->rx_buffers = NULL;
+        kfree(bp->tx_buffers);
+        bp->tx_buffers = NULL;
         if (bp->rx_ring) {
-                pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
-                                    bp->rx_ring, bp->rx_ring_dma);
+                if (bp->flags & B44_FLAG_RX_RING_HACK) {
+                        dma_unmap_single(&bp->pdev->dev, bp->rx_ring_dma,
+                                         DMA_TABLE_BYTES,
+                                         DMA_BIDIRECTIONAL);
+                        kfree(bp->rx_ring);
+                } else
+                        pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
+                                            bp->rx_ring, bp->rx_ring_dma);
                 bp->rx_ring = NULL;
+                bp->flags &= ~B44_FLAG_RX_RING_HACK;
         }
         if (bp->tx_ring) {
-                pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
-                                    bp->tx_ring, bp->tx_ring_dma);
+                if (bp->flags & B44_FLAG_TX_RING_HACK) {
+                        dma_unmap_single(&bp->pdev->dev, bp->tx_ring_dma,
+                                         DMA_TABLE_BYTES,
+                                         DMA_TO_DEVICE);
+                        kfree(bp->tx_ring);
+                } else
+                        pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
+                                            bp->tx_ring, bp->tx_ring_dma);
                 bp->tx_ring = NULL;
+                bp->flags &= ~B44_FLAG_TX_RING_HACK;
         }
 }
 
@@ -1118,12 +1183,56 @@ static int b44_alloc_consistent(struct b44 *bp)
 
         size = DMA_TABLE_BYTES;
         bp->rx_ring = pci_alloc_consistent(bp->pdev, size, &bp->rx_ring_dma);
-        if (!bp->rx_ring)
-                goto out_err;
+        if (!bp->rx_ring) {
+                /* Allocation may have failed due to pci_alloc_consistent
+                   insisting on use of GFP_DMA, which is more restrictive
+                   than necessary...  */
+                struct dma_desc *rx_ring;
+                dma_addr_t rx_ring_dma;
+
+                if (!(rx_ring = (struct dma_desc *)kmalloc(size, GFP_KERNEL)))
+                        goto out_err;
+
+                memset(rx_ring, 0, size);
+                rx_ring_dma = dma_map_single(&bp->pdev->dev, rx_ring,
+                                             DMA_TABLE_BYTES,
+                                             DMA_BIDIRECTIONAL);
+
+                if (rx_ring_dma + size > B44_DMA_MASK) {
+                        kfree(rx_ring);
+                        goto out_err;
+                }
+
+                bp->rx_ring = rx_ring;
+                bp->rx_ring_dma = rx_ring_dma;
+                bp->flags |= B44_FLAG_RX_RING_HACK;
+        }
 
         bp->tx_ring = pci_alloc_consistent(bp->pdev, size, &bp->tx_ring_dma);
-        if (!bp->tx_ring)
-                goto out_err;
+        if (!bp->tx_ring) {
+                /* Allocation may have failed due to pci_alloc_consistent
+                   insisting on use of GFP_DMA, which is more restrictive
+                   than necessary...  */
+                struct dma_desc *tx_ring;
+                dma_addr_t tx_ring_dma;
+
+                if (!(tx_ring = (struct dma_desc *)kmalloc(size, GFP_KERNEL)))
+                        goto out_err;
+
+                memset(tx_ring, 0, size);
+                tx_ring_dma = dma_map_single(&bp->pdev->dev, tx_ring,
+                                             DMA_TABLE_BYTES,
+                                             DMA_TO_DEVICE);
+
+                if (tx_ring_dma + size > B44_DMA_MASK) {
+                        kfree(tx_ring);
+                        goto out_err;
+                }
+
+                bp->tx_ring = tx_ring;
+                bp->tx_ring_dma = tx_ring_dma;
+                bp->flags |= B44_FLAG_TX_RING_HACK;
+        }
 
         return 0;
 
@@ -1507,14 +1616,14 @@ static int b44_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
         cmd->advertising = 0;
         if (bp->flags & B44_FLAG_ADV_10HALF)
-                cmd->advertising |= ADVERTISE_10HALF;
+                cmd->advertising |= ADVERTISED_10baseT_Half;
         if (bp->flags & B44_FLAG_ADV_10FULL)
-                cmd->advertising |= ADVERTISE_10FULL;
+                cmd->advertising |= ADVERTISED_10baseT_Full;
         if (bp->flags & B44_FLAG_ADV_100HALF)
-                cmd->advertising |= ADVERTISE_100HALF;
+                cmd->advertising |= ADVERTISED_100baseT_Half;
         if (bp->flags & B44_FLAG_ADV_100FULL)
-                cmd->advertising |= ADVERTISE_100FULL;
-        cmd->advertising |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
+                cmd->advertising |= ADVERTISED_100baseT_Full;
+        cmd->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
         cmd->speed = (bp->flags & B44_FLAG_100_BASE_T) ?
                 SPEED_100 : SPEED_10;
         cmd->duplex = (bp->flags & B44_FLAG_FULL_DUPLEX) ?
@@ -1676,6 +1785,7 @@ static struct ethtool_ops b44_ethtool_ops = {
         .set_pauseparam         = b44_set_pauseparam,
         .get_msglevel           = b44_get_msglevel,
         .set_msglevel           = b44_set_msglevel,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static int b44_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
@@ -1718,6 +1828,7 @@ static int __devinit b44_get_invariants(struct b44 *bp)
         bp->dev->dev_addr[3] = eeprom[80];
         bp->dev->dev_addr[4] = eeprom[83];
         bp->dev->dev_addr[5] = eeprom[82];
+        memcpy(bp->dev->perm_addr, bp->dev->dev_addr, bp->dev->addr_len);
 
         bp->phy_addr = eeprom[90] & 0x1f;
 
@@ -1930,6 +2041,8 @@ static int b44_suspend(struct pci_dev *pdev, pm_message_t state)
         b44_free_rings(bp);
 
         spin_unlock_irq(&bp->lock);
+
+        free_irq(dev->irq, dev);
         pci_disable_device(pdev);
         return 0;
 }
@@ -1946,6 +2059,9 @@ static int b44_resume(struct pci_dev *pdev)
         if (!netif_running(dev))
                 return 0;
 
+        if (request_irq(dev->irq, b44_interrupt, SA_SHIRQ, dev->name, dev))
+                printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
+
         spin_lock_irq(&bp->lock);
 
         b44_init_rings(bp);
@@ -1971,6 +2087,12 @@ static struct pci_driver b44_driver = {
 
 static int __init b44_init(void)
 {
+        unsigned int dma_desc_align_size = dma_get_cache_alignment();
+
+        /* Setup paramaters for syncing RX/TX DMA descriptors */
+        dma_desc_align_mask = ~(dma_desc_align_size - 1);
+        dma_desc_sync_size = max(dma_desc_align_size, sizeof(struct dma_desc));
+
         return pci_module_init(&b44_driver);
 }
 
diff --git a/drivers/net/b44.h b/drivers/net/b44.h
index 11c40a2e71c7..593cb0ad4100 100644
--- a/drivers/net/b44.h
+++ b/drivers/net/b44.h
@@ -400,6 +400,8 @@ struct b44 {
 #define B44_FLAG_ADV_100HALF    0x04000000
 #define B44_FLAG_ADV_100FULL    0x08000000
 #define B44_FLAG_INTERNAL_PHY   0x10000000
+#define B44_FLAG_RX_RING_HACK   0x20000000
+#define B44_FLAG_TX_RING_HACK   0x40000000
 
         u32                     rx_offset;
 
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 0ee28899fb8d..bbca8ae8018c 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1690,10 +1690,8 @@ static void __exit bmac_exit(void)
 {
         macio_unregister_driver(&bmac_driver);
 
-        if (bmac_emergency_rxbuf != NULL) {
-                kfree(bmac_emergency_rxbuf);
-                bmac_emergency_rxbuf = NULL;
-        }
+        kfree(bmac_emergency_rxbuf);
+        bmac_emergency_rxbuf = NULL;
 }
 
 MODULE_AUTHOR("Randy Gobbel/Paul Mackerras");
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 3a2ace01e444..11d252318221 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -314,20 +314,16 @@ bnx2_free_mem(struct bnx2 *bp)
                                     bp->tx_desc_ring, bp->tx_desc_mapping);
                 bp->tx_desc_ring = NULL;
         }
-        if (bp->tx_buf_ring) {
-                kfree(bp->tx_buf_ring);
-                bp->tx_buf_ring = NULL;
-        }
+        kfree(bp->tx_buf_ring);
+        bp->tx_buf_ring = NULL;
         if (bp->rx_desc_ring) {
                 pci_free_consistent(bp->pdev,
                                     sizeof(struct rx_bd) * RX_DESC_CNT,
                                     bp->rx_desc_ring, bp->rx_desc_mapping);
                 bp->rx_desc_ring = NULL;
         }
-        if (bp->rx_buf_ring) {
-                kfree(bp->rx_buf_ring);
-                bp->rx_buf_ring = NULL;
-        }
+        kfree(bp->rx_buf_ring);
+        bp->rx_buf_ring = NULL;
 }
 
 static int
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index f264ff162979..8032126fd589 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -4241,6 +4241,43 @@ out:
         return 0;
 }
 
+static void bond_activebackup_xmit_copy(struct sk_buff *skb,
+                                        struct bonding *bond,
+                                        struct slave *slave)
+{
+        struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
+        struct ethhdr *eth_data;
+        u8 *hwaddr;
+        int res;
+
+        if (!skb2) {
+                printk(KERN_ERR DRV_NAME ": Error: "
+                       "bond_activebackup_xmit_copy(): skb_copy() failed\n");
+                return;
+        }
+
+        skb2->mac.raw = (unsigned char *)skb2->data;
+        eth_data = eth_hdr(skb2);
+
+        /* Pick an appropriate source MAC address
+         *      -- use slave's perm MAC addr, unless used by bond
+         *      -- otherwise, borrow active slave's perm MAC addr
+         *         since that will not be used
+         */
+        hwaddr = slave->perm_hwaddr;
+        if (!memcmp(eth_data->h_source, hwaddr, ETH_ALEN))
+                hwaddr = bond->curr_active_slave->perm_hwaddr;
+
+        /* Set source MAC address appropriately */
+        memcpy(eth_data->h_source, hwaddr, ETH_ALEN);
+
+        res = bond_dev_queue_xmit(bond, skb2, slave->dev);
+        if (res)
+                dev_kfree_skb(skb2);
+
+        return;
+}
+
 /*
  * in active-backup mode, we know that bond->curr_active_slave is always valid if
  * the bond has a usable interface.
@@ -4257,10 +4294,26 @@ static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_d
                 goto out;
         }
 
-        if (bond->curr_active_slave) { /* one usable interface */
-                res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
+        if (!bond->curr_active_slave)
+                goto out;
+
+        /* Xmit IGMP frames on all slaves to ensure rapid fail-over
+           for multicast traffic on snooping switches */
+        if (skb->protocol == __constant_htons(ETH_P_IP) &&
+            skb->nh.iph->protocol == IPPROTO_IGMP) {
+                struct slave *slave, *active_slave;
+                int i;
+
+                active_slave = bond->curr_active_slave;
+                bond_for_each_slave_from_to(bond, slave, i, active_slave->next,
+                                            active_slave->prev)
+                        if (IS_UP(slave->dev) &&
+                            (slave->link == BOND_LINK_UP))
+                                bond_activebackup_xmit_copy(skb, bond, slave);
         }
 
+        res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
+
 out:
         if (res) {
                 /* no suitable interface, frame not sent */
diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 2e617424d3fb..50f43dbf31ae 100644
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -489,7 +489,7 @@ static int cas_page_free(struct cas *cp, cas_page_t *page)
 /* local page allocation routines for the receive buffers. jumbo pages
  * require at least 8K contiguous and 8K aligned buffers.
  */
-static cas_page_t *cas_page_alloc(struct cas *cp, const int flags)
+static cas_page_t *cas_page_alloc(struct cas *cp, const gfp_t flags)
 {
         cas_page_t *page;
 
@@ -561,7 +561,7 @@ static void cas_spare_free(struct cas *cp)
 }
 
 /* replenish spares if needed */
-static void cas_spare_recover(struct cas *cp, const int flags)
+static void cas_spare_recover(struct cas *cp, const gfp_t flags)
 {
         struct list_head list, *elem, *tmp;
         int needed, i;
diff --git a/drivers/net/cs89x0.c b/drivers/net/cs89x0.c
index a6078ad9b654..bfdae10036ed 100644
--- a/drivers/net/cs89x0.c
+++ b/drivers/net/cs89x0.c
@@ -182,6 +182,10 @@ static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
 #define CIRRUS_DEFAULT_IRQ      VH_INTC_INT_NUM_CASCADED_INTERRUPT_1 /* Event inputs bank 1 - ID 35/bit 3 */
 static unsigned int netcard_portlist[] __initdata = {CIRRUS_DEFAULT_BASE, 0};
 static unsigned int cs8900_irq_map[] = {CIRRUS_DEFAULT_IRQ, 0, 0, 0};
+#elif defined(CONFIG_MACH_MP1000)
+#include <asm/arch/mp1000-seprom.h>
+static unsigned int netcard_portlist[] __initdata = {MP1000_EIO_BASE+0x300, 0};
+static unsigned int cs8900_irq_map[] = {IRQ_EINT3,0,0,0};
 #else
 static unsigned int netcard_portlist[] __initdata =
    { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
@@ -590,6 +594,10 @@ cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
                         cnt -= j;
                 }
         } else
+#elif defined(CONFIG_MACH_MP1000)
+        if (1) {
+                memcpy(dev->dev_addr, get_eeprom_mac_address(), ETH_ALEN);
+        } else
 #endif
 
         if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) == 
@@ -649,6 +657,10 @@ cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
         if (1) {
                 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
         } else
+#elif defined(CONFIG_MACH_MP1000)
+        if (1) {
+                lp->force |= FORCE_RJ45;
+        } else
 #endif
         if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
                 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
@@ -1231,7 +1243,7 @@ net_open(struct net_device *dev)
         else
 #endif
         {
-#if !defined(CONFIG_ARCH_IXDP2X01) && !defined(CONFIG_ARCH_PNX0105)
+#if !defined(CONFIG_ARCH_IXDP2X01) && !defined(CONFIG_ARCH_PNX0105) && !defined(CONFIG_MACH_MP1000)
                 if (((1 << dev->irq) & lp->irq_map) == 0) {
                         printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
                                dev->name, dev->irq, lp->irq_map);
diff --git a/drivers/net/cs89x0.h b/drivers/net/cs89x0.h
index decea264f121..f19d1ebe0183 100644
--- a/drivers/net/cs89x0.h
+++ b/drivers/net/cs89x0.h
@@ -16,7 +16,7 @@
 
 #include <linux/config.h>
 
-#if defined(CONFIG_ARCH_IXDP2X01) || defined(CONFIG_ARCH_PNX0105)
+#if defined(CONFIG_ARCH_IXDP2X01) || defined(CONFIG_ARCH_PNX0105) || defined (CONFIG_MACH_MP1000)
 /* IXDP2401/IXDP2801 uses dword-aligned register addressing */
 #define CS89x0_PORT(reg) ((reg) * 2)
 #else
diff --git a/drivers/net/declance.c b/drivers/net/declance.c
index 521c83137bf6..f130bdab3fd3 100644
--- a/drivers/net/declance.c
+++ b/drivers/net/declance.c
@@ -5,7 +5,7 @@
  *
  *      adopted from sunlance.c by Richard van den Berg
  *
- *      Copyright (C) 2002, 2003  Maciej W. Rozycki
+ *      Copyright (C) 2002, 2003, 2005  Maciej W. Rozycki
  *
  *      additional sources:
  *      - PMAD-AA TURBOchannel Ethernet Module Functional Specification,
@@ -57,13 +57,15 @@
 #include <linux/string.h>
 
 #include <asm/addrspace.h>
+#include <asm/system.h>
+
 #include <asm/dec/interrupts.h>
 #include <asm/dec/ioasic.h>
 #include <asm/dec/ioasic_addrs.h>
 #include <asm/dec/kn01.h>
 #include <asm/dec/machtype.h>
+#include <asm/dec/system.h>
 #include <asm/dec/tc.h>
-#include <asm/system.h>
 
 static char version[] __devinitdata =
 "declance.c: v0.009 by Linux MIPS DECstation task force\n";
@@ -79,10 +81,6 @@ MODULE_LICENSE("GPL");
 #define PMAD_LANCE 2
 #define PMAX_LANCE 3
 
-#ifndef CONFIG_TC
-unsigned long system_base;
-unsigned long dmaptr;
-#endif
 
 #define LE_CSR0 0
 #define LE_CSR1 1
@@ -237,7 +235,7 @@ struct lance_init_block {
 /*
  * This works *only* for the ring descriptors
  */
-#define LANCE_ADDR(x) (PHYSADDR(x) >> 1)
+#define LANCE_ADDR(x) (CPHYSADDR(x) >> 1)
 
 struct lance_private {
         struct net_device *next;
@@ -697,12 +695,13 @@ out:
         spin_unlock(&lp->lock);
 }
 
-static void lance_dma_merr_int(const int irq, void *dev_id,
-                                struct pt_regs *regs)
+static irqreturn_t lance_dma_merr_int(const int irq, void *dev_id,
+                                      struct pt_regs *regs)
 {
         struct net_device *dev = (struct net_device *) dev_id;
 
         printk("%s: DMA error\n", dev->name);
+        return IRQ_HANDLED;
 }
 
 static irqreturn_t
@@ -1026,10 +1025,6 @@ static int __init dec_lance_init(const int type, const int slot)
         unsigned long esar_base;
         unsigned char *esar;
 
-#ifndef CONFIG_TC
-        system_base = KN01_LANCE_BASE;
-#endif
-
         if (dec_lance_debug && version_printed++ == 0)
                 printk(version);
 
@@ -1062,16 +1057,16 @@ static int __init dec_lance_init(const int type, const int slot)
         switch (type) {
 #ifdef CONFIG_TC
         case ASIC_LANCE:
-                dev->base_addr = system_base + IOASIC_LANCE;
+                dev->base_addr = CKSEG1ADDR(dec_kn_slot_base + IOASIC_LANCE);
 
                 /* buffer space for the on-board LANCE shared memory */
                 /*
                  * FIXME: ugly hack!
                  */
-                dev->mem_start = KSEG1ADDR(0x00020000);
+                dev->mem_start = CKSEG1ADDR(0x00020000);
                 dev->mem_end = dev->mem_start + 0x00020000;
                 dev->irq = dec_interrupt[DEC_IRQ_LANCE];
-                esar_base = system_base + IOASIC_ESAR;
+                esar_base = CKSEG1ADDR(dec_kn_slot_base + IOASIC_ESAR);
 
                 /* Workaround crash with booting KN04 2.1k from Disk */
                 memset((void *)dev->mem_start, 0,
@@ -1101,14 +1096,14 @@ static int __init dec_lance_init(const int type, const int slot)
                 /* Setup I/O ASIC LANCE DMA.  */
                 lp->dma_irq = dec_interrupt[DEC_IRQ_LANCE_MERR];
                 ioasic_write(IO_REG_LANCE_DMA_P,
-                             PHYSADDR(dev->mem_start) << 3);
+                             CPHYSADDR(dev->mem_start) << 3);
 
                 break;
 
         case PMAD_LANCE:
                 claim_tc_card(slot);
 
-                dev->mem_start = get_tc_base_addr(slot);
+                dev->mem_start = CKSEG1ADDR(get_tc_base_addr(slot));
                 dev->base_addr = dev->mem_start + 0x100000;
                 dev->irq = get_tc_irq_nr(slot);
                 esar_base = dev->mem_start + 0x1c0002;
@@ -1137,9 +1132,9 @@ static int __init dec_lance_init(const int type, const int slot)
 
         case PMAX_LANCE:
                 dev->irq = dec_interrupt[DEC_IRQ_LANCE];
-                dev->base_addr = KN01_LANCE_BASE;
-                dev->mem_start = KN01_LANCE_BASE + 0x01000000;
-                esar_base = KN01_RTC_BASE + 1;
+                dev->base_addr = CKSEG1ADDR(KN01_SLOT_BASE + KN01_LANCE);
+                dev->mem_start = CKSEG1ADDR(KN01_SLOT_BASE + KN01_LANCE_MEM);
+                esar_base = CKSEG1ADDR(KN01_SLOT_BASE + KN01_ESAR + 1);
                 lp->dma_irq = -1;
 
                 /*
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index e54fc10f6846..abce1f730d00 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -1140,11 +1140,11 @@ dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value)
 }
 
 static int
-dm9000_drv_suspend(struct device *dev, pm_message_t state, u32 level)
+dm9000_drv_suspend(struct device *dev, pm_message_t state)
 {
         struct net_device *ndev = dev_get_drvdata(dev);
 
-        if (ndev && level == SUSPEND_DISABLE) {
+        if (ndev) {
                 if (netif_running(ndev)) {
                         netif_device_detach(ndev);
                         dm9000_shutdown(ndev);
@@ -1154,12 +1154,12 @@ dm9000_drv_suspend(struct device *dev, pm_message_t state, u32 level)
 }
 
 static int
-dm9000_drv_resume(struct device *dev, u32 level)
+dm9000_drv_resume(struct device *dev)
 {
         struct net_device *ndev = dev_get_drvdata(dev);
         board_info_t *db = (board_info_t *) ndev->priv;
 
-        if (ndev && level == RESUME_ENABLE) {
+        if (ndev) {
 
                 if (netif_running(ndev)) {
                         dm9000_reset(db);
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 40887f09b681..eb169a8e8773 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2201,6 +2201,7 @@ static struct ethtool_ops e100_ethtool_ops = {
         .phys_id                = e100_phys_id,
         .get_stats_count        = e100_get_stats_count,
         .get_ethtool_stats      = e100_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static int e100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
@@ -2351,7 +2352,8 @@ static int __devinit e100_probe(struct pci_dev *pdev,
         e100_phy_init(nic);
 
         memcpy(netdev->dev_addr, nic->eeprom, ETH_ALEN);
-        if(!is_valid_ether_addr(netdev->dev_addr)) {
+        memcpy(netdev->perm_addr, nic->eeprom, ETH_ALEN);
+        if(!is_valid_ether_addr(netdev->perm_addr)) {
                 DPRINTK(PROBE, ERR, "Invalid MAC address from "
                         "EEPROM, aborting.\n");
                 err = -EAGAIN;
diff --git a/drivers/net/e1000/e1000.h b/drivers/net/e1000/e1000.h
index 092757bc721f..3f653a93e1bc 100644
--- a/drivers/net/e1000/e1000.h
+++ b/drivers/net/e1000/e1000.h
@@ -72,6 +72,10 @@
 #include <linux/mii.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
+#ifdef CONFIG_E1000_MQ
+#include <linux/cpu.h>
+#include <linux/smp.h>
+#endif
 
 #define BAR_0           0
 #define BAR_1           1
@@ -165,10 +169,33 @@ struct e1000_buffer {
         uint16_t next_to_watch;
 };
 
-struct e1000_ps_page { struct page *ps_page[MAX_PS_BUFFERS]; };
-struct e1000_ps_page_dma { uint64_t ps_page_dma[MAX_PS_BUFFERS]; };
+struct e1000_ps_page { struct page *ps_page[PS_PAGE_BUFFERS]; };
+struct e1000_ps_page_dma { uint64_t ps_page_dma[PS_PAGE_BUFFERS]; };
+
+struct e1000_tx_ring {
+        /* pointer to the descriptor ring memory */
+        void *desc;
+        /* physical address of the descriptor ring */
+        dma_addr_t dma;
+        /* length of descriptor ring in bytes */
+        unsigned int size;
+        /* number of descriptors in the ring */
+        unsigned int count;
+        /* next descriptor to associate a buffer with */
+        unsigned int next_to_use;
+        /* next descriptor to check for DD status bit */
+        unsigned int next_to_clean;
+        /* array of buffer information structs */
+        struct e1000_buffer *buffer_info;
+
+        struct e1000_buffer previous_buffer_info;
+        spinlock_t tx_lock;
+        uint16_t tdh;
+        uint16_t tdt;
+        uint64_t pkt;
+};
 
-struct e1000_desc_ring {
+struct e1000_rx_ring {
         /* pointer to the descriptor ring memory */
         void *desc;
         /* physical address of the descriptor ring */
@@ -186,6 +213,10 @@ struct e1000_desc_ring {
         /* arrays of page information for packet split */
         struct e1000_ps_page *ps_page;
         struct e1000_ps_page_dma *ps_page_dma;
+
+        uint16_t rdh;
+        uint16_t rdt;
+        uint64_t pkt;
 };
 
 #define E1000_DESC_UNUSED(R) \
@@ -227,9 +258,10 @@ struct e1000_adapter {
         unsigned long led_status;
 
         /* TX */
-        struct e1000_desc_ring tx_ring;
-        struct e1000_buffer previous_buffer_info;
-        spinlock_t tx_lock;
+        struct e1000_tx_ring *tx_ring;      /* One per active queue */
+#ifdef CONFIG_E1000_MQ
+        struct e1000_tx_ring **cpu_tx_ring; /* per-cpu */
+#endif
         uint32_t txd_cmd;
         uint32_t tx_int_delay;
         uint32_t tx_abs_int_delay;
@@ -246,19 +278,33 @@ struct e1000_adapter {
 
         /* RX */
 #ifdef CONFIG_E1000_NAPI
-        boolean_t (*clean_rx) (struct e1000_adapter *adapter, int *work_done,
-                          int work_to_do);
+        boolean_t (*clean_rx) (struct e1000_adapter *adapter,
+                               struct e1000_rx_ring *rx_ring,
+                               int *work_done, int work_to_do);
 #else
-        boolean_t (*clean_rx) (struct e1000_adapter *adapter);
+        boolean_t (*clean_rx) (struct e1000_adapter *adapter,
+                               struct e1000_rx_ring *rx_ring);
 #endif
-        void (*alloc_rx_buf) (struct e1000_adapter *adapter);
-        struct e1000_desc_ring rx_ring;
+        void (*alloc_rx_buf) (struct e1000_adapter *adapter,
+                              struct e1000_rx_ring *rx_ring);
+        struct e1000_rx_ring *rx_ring;      /* One per active queue */
+#ifdef CONFIG_E1000_NAPI
+        struct net_device *polling_netdev;  /* One per active queue */
+#endif
+#ifdef CONFIG_E1000_MQ
+        struct net_device **cpu_netdev;     /* per-cpu */
+        struct call_async_data_struct rx_sched_call_data;
+        int cpu_for_queue[4];
+#endif
+        int num_queues;
+
         uint64_t hw_csum_err;
         uint64_t hw_csum_good;
+        uint64_t rx_hdr_split;
         uint32_t rx_int_delay;
         uint32_t rx_abs_int_delay;
         boolean_t rx_csum;
-        boolean_t rx_ps;
+        unsigned int rx_ps_pages;
         uint32_t gorcl;
         uint64_t gorcl_old;
         uint16_t rx_ps_bsize0;
@@ -278,8 +324,8 @@ struct e1000_adapter {
         struct e1000_phy_stats phy_stats;
 
         uint32_t test_icr;
-        struct e1000_desc_ring test_tx_ring;
-        struct e1000_desc_ring test_rx_ring;
+        struct e1000_tx_ring test_tx_ring;
+        struct e1000_rx_ring test_rx_ring;
 
 
         int msg_enable;
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index f133ff0b0b94..9c7feaeaa6a4 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -39,10 +39,10 @@ extern int e1000_up(struct e1000_adapter *adapter);
 extern void e1000_down(struct e1000_adapter *adapter);
 extern void e1000_reset(struct e1000_adapter *adapter);
 extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
-extern int e1000_setup_rx_resources(struct e1000_adapter *adapter);
-extern int e1000_setup_tx_resources(struct e1000_adapter *adapter);
-extern void e1000_free_rx_resources(struct e1000_adapter *adapter);
-extern void e1000_free_tx_resources(struct e1000_adapter *adapter);
+extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
+extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
+extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
+extern void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
 extern void e1000_update_stats(struct e1000_adapter *adapter);
 
 struct e1000_stats {
@@ -91,7 +91,8 @@ static const struct e1000_stats e1000_gstrings_stats[] = {
         { "tx_flow_control_xoff", E1000_STAT(stats.xofftxc) },
         { "rx_long_byte_count", E1000_STAT(stats.gorcl) },
         { "rx_csum_offload_good", E1000_STAT(hw_csum_good) },
-        { "rx_csum_offload_errors", E1000_STAT(hw_csum_err) }
+        { "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },
+        { "rx_header_split", E1000_STAT(rx_hdr_split) },
 };
 #define E1000_STATS_LEN \
         sizeof(e1000_gstrings_stats) / sizeof(struct e1000_stats)
@@ -546,8 +547,10 @@ e1000_set_eeprom(struct net_device *netdev,
         ret_val = e1000_write_eeprom(hw, first_word,
                                      last_word - first_word + 1, eeprom_buff);
 
-        /* Update the checksum over the first part of the EEPROM if needed */
-        if((ret_val == 0) && first_word <= EEPROM_CHECKSUM_REG)
+        /* Update the checksum over the first part of the EEPROM if needed 
+         * and flush shadow RAM for 82573 conrollers */
+        if((ret_val == 0) && ((first_word <= EEPROM_CHECKSUM_REG) || 
+                                (hw->mac_type == e1000_82573)))
                 e1000_update_eeprom_checksum(hw);
 
         kfree(eeprom_buff);
@@ -576,8 +579,8 @@ e1000_get_ringparam(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         e1000_mac_type mac_type = adapter->hw.mac_type;
-        struct e1000_desc_ring *txdr = &adapter->tx_ring;
-        struct e1000_desc_ring *rxdr = &adapter->rx_ring;
+        struct e1000_tx_ring *txdr = adapter->tx_ring;
+        struct e1000_rx_ring *rxdr = adapter->rx_ring;
 
         ring->rx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_RXD :
                 E1000_MAX_82544_RXD;
@@ -597,20 +600,40 @@ e1000_set_ringparam(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         e1000_mac_type mac_type = adapter->hw.mac_type;
-        struct e1000_desc_ring *txdr = &adapter->tx_ring;
-        struct e1000_desc_ring *rxdr = &adapter->rx_ring;
-        struct e1000_desc_ring tx_old, tx_new, rx_old, rx_new;
-        int err;
+        struct e1000_tx_ring *txdr, *tx_old, *tx_new;
+        struct e1000_rx_ring *rxdr, *rx_old, *rx_new;
+        int i, err, tx_ring_size, rx_ring_size;
+
+        tx_ring_size = sizeof(struct e1000_tx_ring) * adapter->num_queues;
+        rx_ring_size = sizeof(struct e1000_rx_ring) * adapter->num_queues;
+
+        if (netif_running(adapter->netdev))
+                e1000_down(adapter);
 
         tx_old = adapter->tx_ring;
         rx_old = adapter->rx_ring;
 
+        adapter->tx_ring = kmalloc(tx_ring_size, GFP_KERNEL);
+        if (!adapter->tx_ring) {
+                err = -ENOMEM;
+                goto err_setup_rx;
+        }
+        memset(adapter->tx_ring, 0, tx_ring_size);
+
+        adapter->rx_ring = kmalloc(rx_ring_size, GFP_KERNEL);
+        if (!adapter->rx_ring) {
+                kfree(adapter->tx_ring);
+                err = -ENOMEM;
+                goto err_setup_rx;
+        }
+        memset(adapter->rx_ring, 0, rx_ring_size);
+
+        txdr = adapter->tx_ring;
+        rxdr = adapter->rx_ring;
+
         if((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
                 return -EINVAL;
 
-        if(netif_running(adapter->netdev))
-                e1000_down(adapter);
-
         rxdr->count = max(ring->rx_pending,(uint32_t)E1000_MIN_RXD);
         rxdr->count = min(rxdr->count,(uint32_t)(mac_type < e1000_82544 ?
                 E1000_MAX_RXD : E1000_MAX_82544_RXD));
@@ -621,11 +644,16 @@ e1000_set_ringparam(struct net_device *netdev,
                 E1000_MAX_TXD : E1000_MAX_82544_TXD));
         E1000_ROUNDUP(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE); 
 
+        for (i = 0; i < adapter->num_queues; i++) {
+                txdr[i].count = txdr->count;
+                rxdr[i].count = rxdr->count;
+        }
+
         if(netif_running(adapter->netdev)) {
                 /* Try to get new resources before deleting old */
-                if((err = e1000_setup_rx_resources(adapter)))
+                if ((err = e1000_setup_all_rx_resources(adapter)))
                         goto err_setup_rx;
-                if((err = e1000_setup_tx_resources(adapter)))
+                if ((err = e1000_setup_all_tx_resources(adapter)))
                         goto err_setup_tx;
 
                 /* save the new, restore the old in order to free it,
@@ -635,8 +663,10 @@ e1000_set_ringparam(struct net_device *netdev,
                 tx_new = adapter->tx_ring;
                 adapter->rx_ring = rx_old;
                 adapter->tx_ring = tx_old;
-                e1000_free_rx_resources(adapter);
-                e1000_free_tx_resources(adapter);
+                e1000_free_all_rx_resources(adapter);
+                e1000_free_all_tx_resources(adapter);
+                kfree(tx_old);
+                kfree(rx_old);
                 adapter->rx_ring = rx_new;
                 adapter->tx_ring = tx_new;
                 if((err = e1000_up(adapter)))
@@ -645,7 +675,7 @@ e1000_set_ringparam(struct net_device *netdev,
 
         return 0;
 err_setup_tx:
-        e1000_free_rx_resources(adapter);
+        e1000_free_all_rx_resources(adapter);
 err_setup_rx:
         adapter->rx_ring = rx_old;
         adapter->tx_ring = tx_old;
@@ -696,6 +726,11 @@ e1000_reg_test(struct e1000_adapter *adapter, uint64_t *data)
          * Some bits that get toggled are ignored.
          */
         switch (adapter->hw.mac_type) {
+        /* there are several bits on newer hardware that are r/w */
+        case e1000_82571:
+        case e1000_82572:
+                toggle = 0x7FFFF3FF;
+                break;
         case e1000_82573:
                 toggle = 0x7FFFF033;
                 break;
@@ -898,8 +933,8 @@ e1000_intr_test(struct e1000_adapter *adapter, uint64_t *data)
 static void
 e1000_free_desc_rings(struct e1000_adapter *adapter)
 {
-        struct e1000_desc_ring *txdr = &adapter->test_tx_ring;
-        struct e1000_desc_ring *rxdr = &adapter->test_rx_ring;
+        struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
+        struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
         struct pci_dev *pdev = adapter->pdev;
         int i;
 
@@ -930,19 +965,16 @@ e1000_free_desc_rings(struct e1000_adapter *adapter)
         if(rxdr->desc)
                 pci_free_consistent(pdev, rxdr->size, rxdr->desc, rxdr->dma);
 
-        if(txdr->buffer_info)
-                kfree(txdr->buffer_info);
-        if(rxdr->buffer_info)
-                kfree(rxdr->buffer_info);
-
+        kfree(txdr->buffer_info);
+        kfree(rxdr->buffer_info);
         return;
 }
 
 static int
 e1000_setup_desc_rings(struct e1000_adapter *adapter)
 {
-        struct e1000_desc_ring *txdr = &adapter->test_tx_ring;
-        struct e1000_desc_ring *rxdr = &adapter->test_rx_ring;
+        struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
+        struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
         struct pci_dev *pdev = adapter->pdev;
         uint32_t rctl;
         int size, i, ret_val;
@@ -1245,6 +1277,8 @@ e1000_set_phy_loopback(struct e1000_adapter *adapter)
         case e1000_82541_rev_2:
         case e1000_82547:
         case e1000_82547_rev_2:
+        case e1000_82571:
+        case e1000_82572:
         case e1000_82573:
                 return e1000_integrated_phy_loopback(adapter);
                 break;
@@ -1340,8 +1374,8 @@ e1000_check_lbtest_frame(struct sk_buff *skb, unsigned int frame_size)
 static int
 e1000_run_loopback_test(struct e1000_adapter *adapter)
 {
-        struct e1000_desc_ring *txdr = &adapter->test_tx_ring;
-        struct e1000_desc_ring *rxdr = &adapter->test_rx_ring;
+        struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
+        struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
         struct pci_dev *pdev = adapter->pdev;
         int i, j, k, l, lc, good_cnt, ret_val=0;
         unsigned long time;
@@ -1509,6 +1543,7 @@ e1000_diag_test(struct net_device *netdev,
                 data[2] = 0;
                 data[3] = 0;
         }
+        msleep_interruptible(4 * 1000);
 }
 
 static void
@@ -1625,7 +1660,7 @@ e1000_phys_id(struct net_device *netdev, uint32_t data)
         if(!data || data > (uint32_t)(MAX_SCHEDULE_TIMEOUT / HZ))
                 data = (uint32_t)(MAX_SCHEDULE_TIMEOUT / HZ);
 
-        if(adapter->hw.mac_type < e1000_82573) {
+        if(adapter->hw.mac_type < e1000_82571) {
                 if(!adapter->blink_timer.function) {
                         init_timer(&adapter->blink_timer);
                         adapter->blink_timer.function = e1000_led_blink_callback;
@@ -1739,6 +1774,7 @@ struct ethtool_ops e1000_ethtool_ops = {
         .phys_id                = e1000_phys_id,
         .get_stats_count        = e1000_get_stats_count,
         .get_ethtool_stats      = e1000_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 void e1000_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/e1000/e1000_hw.c b/drivers/net/e1000/e1000_hw.c
index 045f5426ab9a..8fc876da43b4 100644
--- a/drivers/net/e1000/e1000_hw.c
+++ b/drivers/net/e1000/e1000_hw.c
@@ -83,14 +83,14 @@ uint16_t e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] =
 
 static const
 uint16_t e1000_igp_2_cable_length_table[IGP02E1000_AGC_LENGTH_TABLE_SIZE] =
-    { 8, 13, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43,
-      22, 24, 27, 30, 32, 35, 37, 40, 42, 44, 47, 49, 51, 54, 56, 58,
-      32, 35, 38, 41, 44, 47, 50, 53, 55, 58, 61, 63, 66, 69, 71, 74,
-      43, 47, 51, 54, 58, 61, 64, 67, 71, 74, 77, 80, 82, 85, 88, 90,
-      57, 62, 66, 70, 74, 77, 81, 85, 88, 91, 94, 97, 100, 103, 106, 108,
-      73, 78, 82, 87, 91, 95, 98, 102, 105, 109, 112, 114, 117, 119, 122, 124,
-      91, 96, 101, 105, 109, 113, 116, 119, 122, 125, 127, 128, 128, 128, 128, 128,
-      108, 113, 117, 121, 124, 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128};
+    { 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21,
+      0, 0, 0, 3, 6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41,
+      6, 10, 14, 18, 22, 26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61,
+      21, 26, 31, 35, 40, 44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82,
+      40, 45, 51, 56, 61, 66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104,
+      60, 66, 72, 77, 82, 87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121,
+      83, 89, 95, 100, 105, 109, 113, 116, 119, 122, 124,
+      104, 109, 114, 118, 121, 124};
 
 
 /******************************************************************************
@@ -286,7 +286,6 @@ e1000_set_mac_type(struct e1000_hw *hw)
     case E1000_DEV_ID_82546GB_FIBER:
     case E1000_DEV_ID_82546GB_SERDES:
     case E1000_DEV_ID_82546GB_PCIE:
-    case E1000_DEV_ID_82546GB_QUAD_COPPER:
         hw->mac_type = e1000_82546_rev_3;
         break;
     case E1000_DEV_ID_82541EI:
@@ -305,8 +304,19 @@ e1000_set_mac_type(struct e1000_hw *hw)
     case E1000_DEV_ID_82547GI:
         hw->mac_type = e1000_82547_rev_2;
         break;
+    case E1000_DEV_ID_82571EB_COPPER:
+    case E1000_DEV_ID_82571EB_FIBER:
+    case E1000_DEV_ID_82571EB_SERDES:
+            hw->mac_type = e1000_82571;
+        break;
+    case E1000_DEV_ID_82572EI_COPPER:
+    case E1000_DEV_ID_82572EI_FIBER:
+    case E1000_DEV_ID_82572EI_SERDES:
+        hw->mac_type = e1000_82572;
+        break;
     case E1000_DEV_ID_82573E:
     case E1000_DEV_ID_82573E_IAMT:
+    case E1000_DEV_ID_82573L:
         hw->mac_type = e1000_82573;
         break;
     default:
@@ -315,6 +325,8 @@ e1000_set_mac_type(struct e1000_hw *hw)
     }
 
     switch(hw->mac_type) {
+    case e1000_82571:
+    case e1000_82572:
     case e1000_82573:
         hw->eeprom_semaphore_present = TRUE;
         /* fall through */
@@ -351,6 +363,8 @@ e1000_set_media_type(struct e1000_hw *hw)
     switch (hw->device_id) {
     case E1000_DEV_ID_82545GM_SERDES:
     case E1000_DEV_ID_82546GB_SERDES:
+    case E1000_DEV_ID_82571EB_SERDES:
+    case E1000_DEV_ID_82572EI_SERDES:
         hw->media_type = e1000_media_type_internal_serdes;
         break;
     default:
@@ -523,6 +537,8 @@ e1000_reset_hw(struct e1000_hw *hw)
             E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
             E1000_WRITE_FLUSH(hw);
             /* fall through */
+        case e1000_82571:
+        case e1000_82572:
             ret_val = e1000_get_auto_rd_done(hw);
             if(ret_val)
                 /* We don't want to continue accessing MAC registers. */
@@ -683,6 +699,9 @@ e1000_init_hw(struct e1000_hw *hw)
         switch (hw->mac_type) {
         default:
             break;
+        case e1000_82571:
+        case e1000_82572:
+            ctrl |= (1 << 22);
         case e1000_82573:
             ctrl |= E1000_TXDCTL_COUNT_DESC;
             break;
@@ -694,6 +713,26 @@ e1000_init_hw(struct e1000_hw *hw)
         e1000_enable_tx_pkt_filtering(hw); 
     }
 
+    switch (hw->mac_type) {
+    default:
+        break;
+    case e1000_82571:
+    case e1000_82572:
+        ctrl = E1000_READ_REG(hw, TXDCTL1);
+        ctrl &= ~E1000_TXDCTL_WTHRESH;
+        ctrl |= E1000_TXDCTL_COUNT_DESC | E1000_TXDCTL_FULL_TX_DESC_WB;
+        ctrl |= (1 << 22);
+        E1000_WRITE_REG(hw, TXDCTL1, ctrl);
+        break;
+    }
+
+
+
+    if (hw->mac_type == e1000_82573) {
+        uint32_t gcr = E1000_READ_REG(hw, GCR);
+        gcr |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
+        E1000_WRITE_REG(hw, GCR, gcr);
+    }
 
     /* Clear all of the statistics registers (clear on read).  It is
      * important that we do this after we have tried to establish link
@@ -878,6 +917,14 @@ e1000_setup_fiber_serdes_link(struct e1000_hw *hw)
 
     DEBUGFUNC("e1000_setup_fiber_serdes_link");
 
+    /* On 82571 and 82572 Fiber connections, SerDes loopback mode persists
+     * until explicitly turned off or a power cycle is performed.  A read to
+     * the register does not indicate its status.  Therefore, we ensure
+     * loopback mode is disabled during initialization.
+     */
+    if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572)
+        E1000_WRITE_REG(hw, SCTL, E1000_DISABLE_SERDES_LOOPBACK);
+
     /* On adapters with a MAC newer than 82544, SW Defineable pin 1 will be
      * set when the optics detect a signal. On older adapters, it will be
      * cleared when there is a signal.  This applies to fiber media only.
@@ -2943,6 +2990,8 @@ e1000_phy_reset(struct e1000_hw *hw)
 
     switch (hw->mac_type) {
     case e1000_82541_rev_2:
+    case e1000_82571:
+    case e1000_82572:
         ret_val = e1000_phy_hw_reset(hw);
         if(ret_val)
             return ret_val;
@@ -2981,6 +3030,16 @@ e1000_detect_gig_phy(struct e1000_hw *hw)
 
     DEBUGFUNC("e1000_detect_gig_phy");
 
+    /* The 82571 firmware may still be configuring the PHY.  In this
+     * case, we cannot access the PHY until the configuration is done.  So
+     * we explicitly set the PHY values. */
+    if(hw->mac_type == e1000_82571 ||
+       hw->mac_type == e1000_82572) {
+        hw->phy_id = IGP01E1000_I_PHY_ID;
+        hw->phy_type = e1000_phy_igp_2;
+        return E1000_SUCCESS;
+    }
+
     /* Read the PHY ID Registers to identify which PHY is onboard. */
     ret_val = e1000_read_phy_reg(hw, PHY_ID1, &phy_id_high);
     if(ret_val)
@@ -3334,6 +3393,21 @@ e1000_init_eeprom_params(struct e1000_hw *hw)
         eeprom->use_eerd = FALSE;
         eeprom->use_eewr = FALSE;
         break;
+    case e1000_82571:
+    case e1000_82572:
+        eeprom->type = e1000_eeprom_spi;
+        eeprom->opcode_bits = 8;
+        eeprom->delay_usec = 1;
+        if (eecd & E1000_EECD_ADDR_BITS) {
+            eeprom->page_size = 32;
+            eeprom->address_bits = 16;
+        } else {
+            eeprom->page_size = 8;
+            eeprom->address_bits = 8;
+        }
+        eeprom->use_eerd = FALSE;
+        eeprom->use_eewr = FALSE;
+        break;
     case e1000_82573:
         eeprom->type = e1000_eeprom_spi;
         eeprom->opcode_bits = 8;
@@ -3543,25 +3617,26 @@ e1000_acquire_eeprom(struct e1000_hw *hw)
     eecd = E1000_READ_REG(hw, EECD);
 
     if (hw->mac_type != e1000_82573) {
-    /* Request EEPROM Access */
-    if(hw->mac_type > e1000_82544) {
-        eecd |= E1000_EECD_REQ;
-        E1000_WRITE_REG(hw, EECD, eecd);
-        eecd = E1000_READ_REG(hw, EECD);
-        while((!(eecd & E1000_EECD_GNT)) &&
-              (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
-            i++;
-            udelay(5);
-            eecd = E1000_READ_REG(hw, EECD);
-        }
-        if(!(eecd & E1000_EECD_GNT)) {
-            eecd &= ~E1000_EECD_REQ;
+        /* Request EEPROM Access */
+        if(hw->mac_type > e1000_82544) {
+            eecd |= E1000_EECD_REQ;
             E1000_WRITE_REG(hw, EECD, eecd);
-            DEBUGOUT("Could not acquire EEPROM grant\n");
-            return -E1000_ERR_EEPROM;
+            eecd = E1000_READ_REG(hw, EECD);
+            while((!(eecd & E1000_EECD_GNT)) &&
+                  (i < E1000_EEPROM_GRANT_ATTEMPTS)) {
+                i++;
+                udelay(5);
+                eecd = E1000_READ_REG(hw, EECD);
+            }
+            if(!(eecd & E1000_EECD_GNT)) {
+                eecd &= ~E1000_EECD_REQ;
+                E1000_WRITE_REG(hw, EECD, eecd);
+                DEBUGOUT("Could not acquire EEPROM grant\n");
+                e1000_put_hw_eeprom_semaphore(hw);
+                return -E1000_ERR_EEPROM;
+            }
         }
     }
-    }
 
     /* Setup EEPROM for Read/Write */
 
@@ -4064,7 +4139,7 @@ e1000_write_eeprom(struct e1000_hw *hw,
         return -E1000_ERR_EEPROM;
     }
 
-    /* 82573 reads only through eerd */
+    /* 82573 writes only through eewr */
     if(eeprom->use_eewr == TRUE)
         return e1000_write_eeprom_eewr(hw, offset, words, data);
 
@@ -4353,9 +4428,16 @@ e1000_read_mac_addr(struct e1000_hw * hw)
         hw->perm_mac_addr[i] = (uint8_t) (eeprom_data & 0x00FF);
         hw->perm_mac_addr[i+1] = (uint8_t) (eeprom_data >> 8);
     }
-    if(((hw->mac_type == e1000_82546) || (hw->mac_type == e1000_82546_rev_3)) &&
-       (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1))
+    switch (hw->mac_type) {
+    default:
+        break;
+    case e1000_82546:
+    case e1000_82546_rev_3:
+    case e1000_82571:
+        if(E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1)
             hw->perm_mac_addr[5] ^= 0x01;
+        break;
+    }
 
     for(i = 0; i < NODE_ADDRESS_SIZE; i++)
         hw->mac_addr[i] = hw->perm_mac_addr[i];
@@ -4385,6 +4467,12 @@ e1000_init_rx_addrs(struct e1000_hw *hw)
     e1000_rar_set(hw, hw->mac_addr, 0);
 
     rar_num = E1000_RAR_ENTRIES;
+
+    /* Reserve a spot for the Locally Administered Address to work around
+     * an 82571 issue in which a reset on one port will reload the MAC on
+     * the other port. */
+    if ((hw->mac_type == e1000_82571) && (hw->laa_is_present == TRUE))
+        rar_num -= 1;
     /* Zero out the other 15 receive addresses. */
     DEBUGOUT("Clearing RAR[1-15]\n");
     for(i = 1; i < rar_num; i++) {
@@ -4427,6 +4515,12 @@ e1000_mc_addr_list_update(struct e1000_hw *hw,
     /* Clear RAR[1-15] */
     DEBUGOUT(" Clearing RAR[1-15]\n");
     num_rar_entry = E1000_RAR_ENTRIES;
+    /* Reserve a spot for the Locally Administered Address to work around
+     * an 82571 issue in which a reset on one port will reload the MAC on
+     * the other port. */
+    if ((hw->mac_type == e1000_82571) && (hw->laa_is_present == TRUE))
+        num_rar_entry -= 1;
+
     for(i = rar_used_count; i < num_rar_entry; i++) {
         E1000_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
         E1000_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
@@ -4984,7 +5078,6 @@ e1000_clear_hw_cntrs(struct e1000_hw *hw)
     temp = E1000_READ_REG(hw, ICTXQEC);
     temp = E1000_READ_REG(hw, ICTXQMTC);
     temp = E1000_READ_REG(hw, ICRXDMTC);
-
 }
 
 /******************************************************************************
@@ -5151,6 +5244,8 @@ e1000_get_bus_info(struct e1000_hw *hw)
         hw->bus_speed = e1000_bus_speed_unknown;
         hw->bus_width = e1000_bus_width_unknown;
         break;
+    case e1000_82571:
+    case e1000_82572:
     case e1000_82573:
         hw->bus_type = e1000_bus_type_pci_express;
         hw->bus_speed = e1000_bus_speed_2500;
@@ -5250,6 +5345,7 @@ e1000_get_cable_length(struct e1000_hw *hw,
     int32_t ret_val;
     uint16_t agc_value = 0;
     uint16_t cur_agc, min_agc = IGP01E1000_AGC_LENGTH_TABLE_SIZE;
+    uint16_t max_agc = 0;
     uint16_t i, phy_data;
     uint16_t cable_length;
 
@@ -5338,6 +5434,40 @@ e1000_get_cable_length(struct e1000_hw *hw,
                        IGP01E1000_AGC_RANGE) : 0;
         *max_length = e1000_igp_cable_length_table[agc_value] +
                       IGP01E1000_AGC_RANGE;
+    } else if (hw->phy_type == e1000_phy_igp_2) {
+        uint16_t agc_reg_array[IGP02E1000_PHY_CHANNEL_NUM] =
+                                                         {IGP02E1000_PHY_AGC_A,
+                                                          IGP02E1000_PHY_AGC_B,
+                                                          IGP02E1000_PHY_AGC_C,
+                                                          IGP02E1000_PHY_AGC_D};
+        /* Read the AGC registers for all channels */
+        for (i = 0; i < IGP02E1000_PHY_CHANNEL_NUM; i++) {
+            ret_val = e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
+            if (ret_val)
+                return ret_val;
+
+            /* Getting bits 15:9, which represent the combination of course and
+             * fine gain values.  The result is a number that can be put into
+             * the lookup table to obtain the approximate cable length. */
+            cur_agc = (phy_data >> IGP02E1000_AGC_LENGTH_SHIFT) &
+                      IGP02E1000_AGC_LENGTH_MASK;
+
+            /* Remove min & max AGC values from calculation. */
+            if (e1000_igp_2_cable_length_table[min_agc] > e1000_igp_2_cable_length_table[cur_agc])
+                min_agc = cur_agc;
+            if (e1000_igp_2_cable_length_table[max_agc] < e1000_igp_2_cable_length_table[cur_agc])
+                max_agc = cur_agc;
+
+            agc_value += e1000_igp_2_cable_length_table[cur_agc];
+        }
+
+        agc_value -= (e1000_igp_2_cable_length_table[min_agc] + e1000_igp_2_cable_length_table[max_agc]);
+        agc_value /= (IGP02E1000_PHY_CHANNEL_NUM - 2);
+
+        /* Calculate cable length with the error range of +/- 10 meters. */
+        *min_length = ((agc_value - IGP02E1000_AGC_RANGE) > 0) ?
+                       (agc_value - IGP02E1000_AGC_RANGE) : 0;
+        *max_length = agc_value + IGP02E1000_AGC_RANGE;
     }
 
     return E1000_SUCCESS;
@@ -6465,6 +6595,8 @@ e1000_get_auto_rd_done(struct e1000_hw *hw)
     default:
         msec_delay(5);
         break;
+    case e1000_82571:
+    case e1000_82572:
     case e1000_82573:
         while(timeout) {
             if (E1000_READ_REG(hw, EECD) & E1000_EECD_AUTO_RD) break;
@@ -6494,10 +6626,31 @@ e1000_get_auto_rd_done(struct e1000_hw *hw)
 int32_t
 e1000_get_phy_cfg_done(struct e1000_hw *hw)
 {
+    int32_t timeout = PHY_CFG_TIMEOUT;
+    uint32_t cfg_mask = E1000_EEPROM_CFG_DONE;
+
     DEBUGFUNC("e1000_get_phy_cfg_done");
 
-    /* Simply wait for 10ms */
-    msec_delay(10);
+    switch (hw->mac_type) {
+    default:
+        msec_delay(10);
+        break;
+    case e1000_82571:
+    case e1000_82572:
+        while (timeout) {
+            if (E1000_READ_REG(hw, EEMNGCTL) & cfg_mask)
+                break;
+            else
+                msec_delay(1);
+            timeout--;
+        }
+
+        if (!timeout) {
+            DEBUGOUT("MNG configuration cycle has not completed.\n");
+            return -E1000_ERR_RESET;
+        }
+        break;
+    }
 
     return E1000_SUCCESS;
 }
@@ -6569,8 +6722,7 @@ e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw)
         return;
 
     swsm = E1000_READ_REG(hw, SWSM);
-    /* Release both semaphores. */
-    swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
+        swsm &= ~(E1000_SWSM_SWESMBI);
     E1000_WRITE_REG(hw, SWSM, swsm);
 }
 
@@ -6606,6 +6758,8 @@ e1000_arc_subsystem_valid(struct e1000_hw *hw)
      * if this is the case.  We read FWSM to determine the manageability mode.
      */
     switch (hw->mac_type) {
+    case e1000_82571:
+    case e1000_82572:
     case e1000_82573:
         fwsm = E1000_READ_REG(hw, FWSM);
         if((fwsm & E1000_FWSM_MODE_MASK) != 0)
diff --git a/drivers/net/e1000/e1000_hw.h b/drivers/net/e1000/e1000_hw.h
index 51c2b3a18b6f..4f2c196dc314 100644
--- a/drivers/net/e1000/e1000_hw.h
+++ b/drivers/net/e1000/e1000_hw.h
@@ -57,6 +57,8 @@ typedef enum {
     e1000_82541_rev_2,
     e1000_82547,
     e1000_82547_rev_2,
+    e1000_82571,
+    e1000_82572,
     e1000_82573,
     e1000_num_macs
 } e1000_mac_type;
@@ -478,10 +480,16 @@ uint8_t e1000_arc_subsystem_valid(struct e1000_hw *hw);
 #define E1000_DEV_ID_82546GB_SERDES      0x107B
 #define E1000_DEV_ID_82546GB_PCIE        0x108A
 #define E1000_DEV_ID_82547EI             0x1019
+#define E1000_DEV_ID_82571EB_COPPER      0x105E
+#define E1000_DEV_ID_82571EB_FIBER       0x105F
+#define E1000_DEV_ID_82571EB_SERDES      0x1060
+#define E1000_DEV_ID_82572EI_COPPER      0x107D
+#define E1000_DEV_ID_82572EI_FIBER       0x107E
+#define E1000_DEV_ID_82572EI_SERDES      0x107F
 #define E1000_DEV_ID_82573E              0x108B
 #define E1000_DEV_ID_82573E_IAMT         0x108C
+#define E1000_DEV_ID_82573L              0x109A
 
-#define E1000_DEV_ID_82546GB_QUAD_COPPER 0x1099
 
 #define NODE_ADDRESS_SIZE 6
 #define ETH_LENGTH_OF_ADDRESS 6
@@ -833,6 +841,8 @@ struct e1000_ffvt_entry {
 #define E1000_FFMT_SIZE E1000_FLEXIBLE_FILTER_SIZE_MAX
 #define E1000_FFVT_SIZE E1000_FLEXIBLE_FILTER_SIZE_MAX
 
+#define E1000_DISABLE_SERDES_LOOPBACK   0x0400
+
 /* Register Set. (82543, 82544)
  *
  * Registers are defined to be 32 bits and  should be accessed as 32 bit values.
@@ -853,6 +863,7 @@ struct e1000_ffvt_entry {
 #define E1000_CTRL_EXT 0x00018  /* Extended Device Control - RW */
 #define E1000_FLA      0x0001C  /* Flash Access - RW */
 #define E1000_MDIC     0x00020  /* MDI Control - RW */
+#define E1000_SCTL     0x00024  /* SerDes Control - RW */
 #define E1000_FCAL     0x00028  /* Flow Control Address Low - RW */
 #define E1000_FCAH     0x0002C  /* Flow Control Address High -RW */
 #define E1000_FCT      0x00030  /* Flow Control Type - RW */
@@ -864,6 +875,12 @@ struct e1000_ffvt_entry {
 #define E1000_IMC      0x000D8  /* Interrupt Mask Clear - WO */
 #define E1000_IAM      0x000E0  /* Interrupt Acknowledge Auto Mask */
 #define E1000_RCTL     0x00100  /* RX Control - RW */
+#define E1000_RDTR1    0x02820  /* RX Delay Timer (1) - RW */
+#define E1000_RDBAL1   0x02900  /* RX Descriptor Base Address Low (1) - RW */
+#define E1000_RDBAH1   0x02904  /* RX Descriptor Base Address High (1) - RW */
+#define E1000_RDLEN1   0x02908  /* RX Descriptor Length (1) - RW */
+#define E1000_RDH1     0x02910  /* RX Descriptor Head (1) - RW */
+#define E1000_RDT1     0x02918  /* RX Descriptor Tail (1) - RW */
 #define E1000_FCTTV    0x00170  /* Flow Control Transmit Timer Value - RW */
 #define E1000_TXCW     0x00178  /* TX Configuration Word - RW */
 #define E1000_RXCW     0x00180  /* RX Configuration Word - RO */
@@ -895,6 +912,12 @@ struct e1000_ffvt_entry {
 #define E1000_RDH      0x02810  /* RX Descriptor Head - RW */
 #define E1000_RDT      0x02818  /* RX Descriptor Tail - RW */
 #define E1000_RDTR     0x02820  /* RX Delay Timer - RW */
+#define E1000_RDBAL0   E1000_RDBAL /* RX Desc Base Address Low (0) - RW */
+#define E1000_RDBAH0   E1000_RDBAH /* RX Desc Base Address High (0) - RW */
+#define E1000_RDLEN0   E1000_RDLEN /* RX Desc Length (0) - RW */
+#define E1000_RDH0     E1000_RDH   /* RX Desc Head (0) - RW */
+#define E1000_RDT0     E1000_RDT   /* RX Desc Tail (0) - RW */
+#define E1000_RDTR0    E1000_RDTR  /* RX Delay Timer (0) - RW */
 #define E1000_RXDCTL   0x02828  /* RX Descriptor Control - RW */
 #define E1000_RADV     0x0282C  /* RX Interrupt Absolute Delay Timer - RW */
 #define E1000_RSRPD    0x02C00  /* RX Small Packet Detect - RW */
@@ -980,15 +1003,15 @@ struct e1000_ffvt_entry {
 #define E1000_BPTC     0x040F4  /* Broadcast Packets TX Count - R/clr */
 #define E1000_TSCTC    0x040F8  /* TCP Segmentation Context TX - R/clr */
 #define E1000_TSCTFC   0x040FC  /* TCP Segmentation Context TX Fail - R/clr */
-#define E1000_IAC       0x4100  /* Interrupt Assertion Count */
-#define E1000_ICRXPTC   0x4104  /* Interrupt Cause Rx Packet Timer Expire Count */
-#define E1000_ICRXATC   0x4108  /* Interrupt Cause Rx Absolute Timer Expire Count */
-#define E1000_ICTXPTC   0x410C  /* Interrupt Cause Tx Packet Timer Expire Count */
-#define E1000_ICTXATC   0x4110  /* Interrupt Cause Tx Absolute Timer Expire Count */
-#define E1000_ICTXQEC   0x4118  /* Interrupt Cause Tx Queue Empty Count */
-#define E1000_ICTXQMTC  0x411C  /* Interrupt Cause Tx Queue Minimum Threshold Count */
-#define E1000_ICRXDMTC  0x4120  /* Interrupt Cause Rx Descriptor Minimum Threshold Count */
-#define E1000_ICRXOC    0x4124  /* Interrupt Cause Receiver Overrun Count */
+#define E1000_IAC      0x04100  /* Interrupt Assertion Count */
+#define E1000_ICRXPTC  0x04104  /* Interrupt Cause Rx Packet Timer Expire Count */
+#define E1000_ICRXATC  0x04108  /* Interrupt Cause Rx Absolute Timer Expire Count */
+#define E1000_ICTXPTC  0x0410C  /* Interrupt Cause Tx Packet Timer Expire Count */
+#define E1000_ICTXATC  0x04110  /* Interrupt Cause Tx Absolute Timer Expire Count */
+#define E1000_ICTXQEC  0x04118  /* Interrupt Cause Tx Queue Empty Count */
+#define E1000_ICTXQMTC 0x0411C  /* Interrupt Cause Tx Queue Minimum Threshold Count */
+#define E1000_ICRXDMTC 0x04120  /* Interrupt Cause Rx Descriptor Minimum Threshold Count */
+#define E1000_ICRXOC   0x04124  /* Interrupt Cause Receiver Overrun Count */
 #define E1000_RXCSUM   0x05000  /* RX Checksum Control - RW */
 #define E1000_RFCTL    0x05008  /* Receive Filter Control*/
 #define E1000_MTA      0x05200  /* Multicast Table Array - RW Array */
@@ -1018,6 +1041,14 @@ struct e1000_ffvt_entry {
 #define E1000_FWSM      0x05B54 /* FW Semaphore */
 #define E1000_FFLT_DBG  0x05F04 /* Debug Register */
 #define E1000_HICR      0x08F00 /* Host Inteface Control */
+
+/* RSS registers */
+#define E1000_CPUVEC    0x02C10 /* CPU Vector Register - RW */
+#define E1000_MRQC      0x05818 /* Multiple Receive Control - RW */
+#define E1000_RETA      0x05C00 /* Redirection Table - RW Array */
+#define E1000_RSSRK     0x05C80 /* RSS Random Key - RW Array */
+#define E1000_RSSIM     0x05864 /* RSS Interrupt Mask */
+#define E1000_RSSIR     0x05868 /* RSS Interrupt Request */
 /* Register Set (82542)
  *
  * Some of the 82542 registers are located at different offsets than they are
@@ -1032,6 +1063,7 @@ struct e1000_ffvt_entry {
 #define E1000_82542_CTRL_EXT E1000_CTRL_EXT
 #define E1000_82542_FLA      E1000_FLA
 #define E1000_82542_MDIC     E1000_MDIC
+#define E1000_82542_SCTL     E1000_SCTL
 #define E1000_82542_FCAL     E1000_FCAL
 #define E1000_82542_FCAH     E1000_FCAH
 #define E1000_82542_FCT      E1000_FCT
@@ -1049,6 +1081,18 @@ struct e1000_ffvt_entry {
 #define E1000_82542_RDLEN    0x00118
 #define E1000_82542_RDH      0x00120
 #define E1000_82542_RDT      0x00128
+#define E1000_82542_RDTR0    E1000_82542_RDTR
+#define E1000_82542_RDBAL0   E1000_82542_RDBAL
+#define E1000_82542_RDBAH0   E1000_82542_RDBAH
+#define E1000_82542_RDLEN0   E1000_82542_RDLEN
+#define E1000_82542_RDH0     E1000_82542_RDH
+#define E1000_82542_RDT0     E1000_82542_RDT
+#define E1000_82542_RDTR1    0x00130
+#define E1000_82542_RDBAL1   0x00138
+#define E1000_82542_RDBAH1   0x0013C
+#define E1000_82542_RDLEN1   0x00140
+#define E1000_82542_RDH1     0x00148
+#define E1000_82542_RDT1     0x00150
 #define E1000_82542_FCRTH    0x00160
 #define E1000_82542_FCRTL    0x00168
 #define E1000_82542_FCTTV    E1000_FCTTV
@@ -1197,6 +1241,13 @@ struct e1000_ffvt_entry {
 #define E1000_82542_ICRXOC      E1000_ICRXOC
 #define E1000_82542_HICR        E1000_HICR
 
+#define E1000_82542_CPUVEC      E1000_CPUVEC
+#define E1000_82542_MRQC        E1000_MRQC
+#define E1000_82542_RETA        E1000_RETA
+#define E1000_82542_RSSRK       E1000_RSSRK
+#define E1000_82542_RSSIM       E1000_RSSIM
+#define E1000_82542_RSSIR       E1000_RSSIR
+
 /* Statistics counters collected by the MAC */
 struct e1000_hw_stats {
     uint64_t crcerrs;
@@ -1336,6 +1387,7 @@ struct e1000_hw {
     boolean_t serdes_link_down;
     boolean_t tbi_compatibility_en;
     boolean_t tbi_compatibility_on;
+    boolean_t laa_is_present;
     boolean_t phy_reset_disable;
     boolean_t fc_send_xon;
     boolean_t fc_strict_ieee;
@@ -1374,6 +1426,7 @@ struct e1000_hw {
 #define E1000_CTRL_BEM32    0x00000400  /* Big Endian 32 mode */
 #define E1000_CTRL_FRCSPD   0x00000800  /* Force Speed */
 #define E1000_CTRL_FRCDPX   0x00001000  /* Force Duplex */
+#define E1000_CTRL_D_UD_EN  0x00002000  /* Dock/Undock enable */
 #define E1000_CTRL_D_UD_POLARITY 0x00004000 /* Defined polarity of Dock/Undock indication in SDP[0] */
 #define E1000_CTRL_SWDPIN0  0x00040000  /* SWDPIN 0 value */
 #define E1000_CTRL_SWDPIN1  0x00080000  /* SWDPIN 1 value */
@@ -1491,6 +1544,8 @@ struct e1000_hw {
 #define E1000_CTRL_EXT_WR_WMARK_320   0x01000000
 #define E1000_CTRL_EXT_WR_WMARK_384   0x02000000
 #define E1000_CTRL_EXT_WR_WMARK_448   0x03000000
+#define E1000_CTRL_EXT_CANC           0x04000000  /* Interrupt delay cancellation */
+#define E1000_CTRL_EXT_DRV_LOAD       0x10000000  /* Driver loaded bit for FW */
 #define E1000_CTRL_EXT_IAME           0x08000000  /* Interrupt acknowledge Auto-mask */
 #define E1000_CTRL_EXT_INT_TIMER_CLR  0x20000000  /* Clear Interrupt timers after IMS clear */
 
@@ -1524,6 +1579,7 @@ struct e1000_hw {
 #define E1000_LEDCTL_LED2_BLINK           0x00800000
 #define E1000_LEDCTL_LED3_MODE_MASK       0x0F000000
 #define E1000_LEDCTL_LED3_MODE_SHIFT      24
+#define E1000_LEDCTL_LED3_BLINK_RATE      0x20000000
 #define E1000_LEDCTL_LED3_IVRT            0x40000000
 #define E1000_LEDCTL_LED3_BLINK           0x80000000
 
@@ -1784,6 +1840,16 @@ struct e1000_hw {
 #define E1000_RXCSUM_IPPCSE    0x00001000   /* IP payload checksum enable */
 #define E1000_RXCSUM_PCSD      0x00002000   /* packet checksum disabled */
 
+/* Multiple Receive Queue Control */
+#define E1000_MRQC_ENABLE_MASK              0x00000003
+#define E1000_MRQC_ENABLE_RSS_2Q            0x00000001
+#define E1000_MRQC_ENABLE_RSS_INT           0x00000004
+#define E1000_MRQC_RSS_FIELD_MASK           0xFFFF0000
+#define E1000_MRQC_RSS_FIELD_IPV4_TCP       0x00010000
+#define E1000_MRQC_RSS_FIELD_IPV4           0x00020000
+#define E1000_MRQC_RSS_FIELD_IPV6_TCP       0x00040000
+#define E1000_MRQC_RSS_FIELD_IPV6_EX        0x00080000
+#define E1000_MRQC_RSS_FIELD_IPV6           0x00100000
 
 /* Definitions for power management and wakeup registers */
 /* Wake Up Control */
@@ -1928,6 +1994,7 @@ struct e1000_host_command_info {
 #define E1000_MDALIGN          4096
 
 #define E1000_GCR_BEM32                 0x00400000
+#define E1000_GCR_L1_ACT_WITHOUT_L0S_RX 0x08000000
 /* Function Active and Power State to MNG */
 #define E1000_FACTPS_FUNC0_POWER_STATE_MASK         0x00000003
 #define E1000_FACTPS_LAN0_VALID                     0x00000004
@@ -1980,6 +2047,7 @@ struct e1000_host_command_info {
 /* EEPROM Word Offsets */
 #define EEPROM_COMPAT                 0x0003
 #define EEPROM_ID_LED_SETTINGS        0x0004
+#define EEPROM_VERSION                0x0005
 #define EEPROM_SERDES_AMPLITUDE       0x0006 /* For SERDES output amplitude adjustment. */
 #define EEPROM_PHY_CLASS_WORD         0x0007
 #define EEPROM_INIT_CONTROL1_REG      0x000A
@@ -1990,6 +2058,8 @@ struct e1000_host_command_info {
 #define EEPROM_FLASH_VERSION          0x0032
 #define EEPROM_CHECKSUM_REG           0x003F
 
+#define E1000_EEPROM_CFG_DONE         0x00040000   /* MNG config cycle done */
+
 /* Word definitions for ID LED Settings */
 #define ID_LED_RESERVED_0000 0x0000
 #define ID_LED_RESERVED_FFFF 0xFFFF
@@ -2108,6 +2178,8 @@ struct e1000_host_command_info {
 #define E1000_PBA_22K 0x0016
 #define E1000_PBA_24K 0x0018
 #define E1000_PBA_30K 0x001E
+#define E1000_PBA_32K 0x0020
+#define E1000_PBA_38K 0x0026
 #define E1000_PBA_40K 0x0028
 #define E1000_PBA_48K 0x0030    /* 48KB, default RX allocation */
 
@@ -2592,11 +2664,11 @@ struct e1000_host_command_info {
 
 /* 7 bits (3 Coarse + 4 Fine) --> 128 optional values */
 #define IGP01E1000_AGC_LENGTH_TABLE_SIZE 128
-#define IGP02E1000_AGC_LENGTH_TABLE_SIZE 128
+#define IGP02E1000_AGC_LENGTH_TABLE_SIZE 113
 
 /* The precision error of the cable length is +/- 10 meters */
 #define IGP01E1000_AGC_RANGE    10
-#define IGP02E1000_AGC_RANGE    10
+#define IGP02E1000_AGC_RANGE    15
 
 /* IGP01E1000 PCS Initialization register */
 /* bits 3:6 in the PCS registers stores the channels polarity */
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index ee687c902a20..efbbda7cbcbf 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -43,7 +43,7 @@ char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
 #else
 #define DRIVERNAPI "-NAPI"
 #endif
-#define DRV_VERSION             "6.0.60-k2"DRIVERNAPI
+#define DRV_VERSION "6.1.16-k2"DRIVERNAPI
 char e1000_driver_version[] = DRV_VERSION;
 char e1000_copyright[] = "Copyright (c) 1999-2005 Intel Corporation.";
 
@@ -80,6 +80,9 @@ static struct pci_device_id e1000_pci_tbl[] = {
         INTEL_E1000_ETHERNET_DEVICE(0x1026),
         INTEL_E1000_ETHERNET_DEVICE(0x1027),
         INTEL_E1000_ETHERNET_DEVICE(0x1028),
+        INTEL_E1000_ETHERNET_DEVICE(0x105E),
+        INTEL_E1000_ETHERNET_DEVICE(0x105F),
+        INTEL_E1000_ETHERNET_DEVICE(0x1060),
         INTEL_E1000_ETHERNET_DEVICE(0x1075),
         INTEL_E1000_ETHERNET_DEVICE(0x1076),
         INTEL_E1000_ETHERNET_DEVICE(0x1077),
@@ -88,10 +91,13 @@ static struct pci_device_id e1000_pci_tbl[] = {
         INTEL_E1000_ETHERNET_DEVICE(0x107A),
         INTEL_E1000_ETHERNET_DEVICE(0x107B),
         INTEL_E1000_ETHERNET_DEVICE(0x107C),
+        INTEL_E1000_ETHERNET_DEVICE(0x107D),
+        INTEL_E1000_ETHERNET_DEVICE(0x107E),
+        INTEL_E1000_ETHERNET_DEVICE(0x107F),
         INTEL_E1000_ETHERNET_DEVICE(0x108A),
         INTEL_E1000_ETHERNET_DEVICE(0x108B),
         INTEL_E1000_ETHERNET_DEVICE(0x108C),
-        INTEL_E1000_ETHERNET_DEVICE(0x1099),
+        INTEL_E1000_ETHERNET_DEVICE(0x109A),
         /* required last entry */
         {0,}
 };
@@ -102,10 +108,18 @@ int e1000_up(struct e1000_adapter *adapter);
 void e1000_down(struct e1000_adapter *adapter);
 void e1000_reset(struct e1000_adapter *adapter);
 int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
-int e1000_setup_tx_resources(struct e1000_adapter *adapter);
-int e1000_setup_rx_resources(struct e1000_adapter *adapter);
-void e1000_free_tx_resources(struct e1000_adapter *adapter);
-void e1000_free_rx_resources(struct e1000_adapter *adapter);
+int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
+int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
+void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
+void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
+int e1000_setup_tx_resources(struct e1000_adapter *adapter,
+                             struct e1000_tx_ring *txdr);
+int e1000_setup_rx_resources(struct e1000_adapter *adapter,
+                             struct e1000_rx_ring *rxdr);
+void e1000_free_tx_resources(struct e1000_adapter *adapter,
+                             struct e1000_tx_ring *tx_ring);
+void e1000_free_rx_resources(struct e1000_adapter *adapter,
+                             struct e1000_rx_ring *rx_ring);
 void e1000_update_stats(struct e1000_adapter *adapter);
 
 /* Local Function Prototypes */
@@ -114,14 +128,22 @@ static int e1000_init_module(void);
 static void e1000_exit_module(void);
 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 static void __devexit e1000_remove(struct pci_dev *pdev);
+static int e1000_alloc_queues(struct e1000_adapter *adapter);
+#ifdef CONFIG_E1000_MQ
+static void e1000_setup_queue_mapping(struct e1000_adapter *adapter);
+#endif
 static int e1000_sw_init(struct e1000_adapter *adapter);
 static int e1000_open(struct net_device *netdev);
 static int e1000_close(struct net_device *netdev);
 static void e1000_configure_tx(struct e1000_adapter *adapter);
 static void e1000_configure_rx(struct e1000_adapter *adapter);
 static void e1000_setup_rctl(struct e1000_adapter *adapter);
-static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
-static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
+static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
+static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
+static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
+                                struct e1000_tx_ring *tx_ring);
+static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
+                                struct e1000_rx_ring *rx_ring);
 static void e1000_set_multi(struct net_device *netdev);
 static void e1000_update_phy_info(unsigned long data);
 static void e1000_watchdog(unsigned long data);
@@ -132,19 +154,26 @@ static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
 static int e1000_set_mac(struct net_device *netdev, void *p);
 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
-static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter);
+static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
+                                    struct e1000_tx_ring *tx_ring);
 #ifdef CONFIG_E1000_NAPI
-static int e1000_clean(struct net_device *netdev, int *budget);
+static int e1000_clean(struct net_device *poll_dev, int *budget);
 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
+                                    struct e1000_rx_ring *rx_ring,
                                     int *work_done, int work_to_do);
 static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
+                                       struct e1000_rx_ring *rx_ring,
                                        int *work_done, int work_to_do);
 #else
-static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter);
-static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter);
+static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
+                                    struct e1000_rx_ring *rx_ring);
+static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
+                                       struct e1000_rx_ring *rx_ring);
 #endif
-static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
-static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter);
+static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
+                                   struct e1000_rx_ring *rx_ring);
+static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
+                                      struct e1000_rx_ring *rx_ring);
 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
                            int cmd);
@@ -162,8 +191,8 @@ static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 
-static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 #ifdef CONFIG_PM
+static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 static int e1000_resume(struct pci_dev *pdev);
 #endif
 
@@ -172,6 +201,11 @@ static int e1000_resume(struct pci_dev *pdev);
 static void e1000_netpoll (struct net_device *netdev);
 #endif
 
+#ifdef CONFIG_E1000_MQ
+/* for multiple Rx queues */
+void e1000_rx_schedule(void *data);
+#endif
+
 /* Exported from other modules */
 
 extern void e1000_check_options(struct e1000_adapter *adapter);
@@ -289,7 +323,7 @@ int
 e1000_up(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
-        int err;
+        int i, err;
 
         /* hardware has been reset, we need to reload some things */
 
@@ -308,7 +342,8 @@ e1000_up(struct e1000_adapter *adapter)
         e1000_configure_tx(adapter);
         e1000_setup_rctl(adapter);
         e1000_configure_rx(adapter);
-        adapter->alloc_rx_buf(adapter);
+        for (i = 0; i < adapter->num_queues; i++)
+                adapter->alloc_rx_buf(adapter, &adapter->rx_ring[i]);
 
 #ifdef CONFIG_PCI_MSI
         if(adapter->hw.mac_type > e1000_82547_rev_2) {
@@ -344,6 +379,9 @@ e1000_down(struct e1000_adapter *adapter)
         struct net_device *netdev = adapter->netdev;
 
         e1000_irq_disable(adapter);
+#ifdef CONFIG_E1000_MQ
+        while (atomic_read(&adapter->rx_sched_call_data.count) != 0);
+#endif
         free_irq(adapter->pdev->irq, netdev);
 #ifdef CONFIG_PCI_MSI
         if(adapter->hw.mac_type > e1000_82547_rev_2 &&
@@ -363,11 +401,10 @@ e1000_down(struct e1000_adapter *adapter)
         netif_stop_queue(netdev);
 
         e1000_reset(adapter);
-        e1000_clean_tx_ring(adapter);
-        e1000_clean_rx_ring(adapter);
+        e1000_clean_all_tx_rings(adapter);
+        e1000_clean_all_rx_rings(adapter);
 
-        /* If WoL is not enabled
-         * and management mode is not IAMT
+        /* If WoL is not enabled and management mode is not IAMT
          * Power down the PHY so no link is implied when interface is down */
         if(!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
            adapter->hw.media_type == e1000_media_type_copper &&
@@ -398,6 +435,10 @@ e1000_reset(struct e1000_adapter *adapter)
         case e1000_82547_rev_2:
                 pba = E1000_PBA_30K;
                 break;
+        case e1000_82571:
+        case e1000_82572:
+                pba = E1000_PBA_38K;
+                break;
         case e1000_82573:
                 pba = E1000_PBA_12K;
                 break;
@@ -475,6 +516,7 @@ e1000_probe(struct pci_dev *pdev,
         struct net_device *netdev;
         struct e1000_adapter *adapter;
         unsigned long mmio_start, mmio_len;
+        uint32_t ctrl_ext;
         uint32_t swsm;
 
         static int cards_found = 0;
@@ -614,8 +656,9 @@ e1000_probe(struct pci_dev *pdev,
         if(e1000_read_mac_addr(&adapter->hw))
                 DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
         memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
+        memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
 
-        if(!is_valid_ether_addr(netdev->dev_addr)) {
+        if(!is_valid_ether_addr(netdev->perm_addr)) {
                 DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
                 err = -EIO;
                 goto err_eeprom;
@@ -687,6 +730,12 @@ e1000_probe(struct pci_dev *pdev,
 
         /* Let firmware know the driver has taken over */
         switch(adapter->hw.mac_type) {
+        case e1000_82571:
+        case e1000_82572:
+                ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
+                E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
+                                ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
+                break;
         case e1000_82573:
                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
                 E1000_WRITE_REG(&adapter->hw, SWSM,
@@ -731,7 +780,11 @@ e1000_remove(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct e1000_adapter *adapter = netdev_priv(netdev);
+        uint32_t ctrl_ext;
         uint32_t manc, swsm;
+#ifdef CONFIG_E1000_NAPI
+        int i;
+#endif
 
         flush_scheduled_work();
 
@@ -745,6 +798,12 @@ e1000_remove(struct pci_dev *pdev)
         }
 
         switch(adapter->hw.mac_type) {
+        case e1000_82571:
+        case e1000_82572:
+                ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
+                E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
+                                ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
+                break;
         case e1000_82573:
                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
                 E1000_WRITE_REG(&adapter->hw, SWSM,
@@ -756,13 +815,27 @@ e1000_remove(struct pci_dev *pdev)
         }
 
         unregister_netdev(netdev);
+#ifdef CONFIG_E1000_NAPI
+        for (i = 0; i < adapter->num_queues; i++)
+                __dev_put(&adapter->polling_netdev[i]);
+#endif
 
         if(!e1000_check_phy_reset_block(&adapter->hw))
                 e1000_phy_hw_reset(&adapter->hw);
 
+        kfree(adapter->tx_ring);
+        kfree(adapter->rx_ring);
+#ifdef CONFIG_E1000_NAPI
+        kfree(adapter->polling_netdev);
+#endif
+
         iounmap(adapter->hw.hw_addr);
         pci_release_regions(pdev);
 
+#ifdef CONFIG_E1000_MQ
+        free_percpu(adapter->cpu_netdev);
+        free_percpu(adapter->cpu_tx_ring);
+#endif
         free_netdev(netdev);
 
         pci_disable_device(pdev);
@@ -783,6 +856,9 @@ e1000_sw_init(struct e1000_adapter *adapter)
         struct e1000_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
+#ifdef CONFIG_E1000_NAPI
+        int i;
+#endif
 
         /* PCI config space info */
 
@@ -840,14 +916,123 @@ e1000_sw_init(struct e1000_adapter *adapter)
                 hw->master_slave = E1000_MASTER_SLAVE;
         }
 
+#ifdef CONFIG_E1000_MQ
+        /* Number of supported queues */
+        switch (hw->mac_type) {
+        case e1000_82571:
+        case e1000_82572:
+                adapter->num_queues = 2;
+                break;
+        default:
+                adapter->num_queues = 1;
+                break;
+        }
+        adapter->num_queues = min(adapter->num_queues, num_online_cpus());
+#else
+        adapter->num_queues = 1;
+#endif
+
+        if (e1000_alloc_queues(adapter)) {
+                DPRINTK(PROBE, ERR, "Unable to allocate memory for queues\n");
+                return -ENOMEM;
+        }
+
+#ifdef CONFIG_E1000_NAPI
+        for (i = 0; i < adapter->num_queues; i++) {
+                adapter->polling_netdev[i].priv = adapter;
+                adapter->polling_netdev[i].poll = &e1000_clean;
+                adapter->polling_netdev[i].weight = 64;
+                dev_hold(&adapter->polling_netdev[i]);
+                set_bit(__LINK_STATE_START, &adapter->polling_netdev[i].state);
+        }
+#endif
+
+#ifdef CONFIG_E1000_MQ
+        e1000_setup_queue_mapping(adapter);
+#endif
+
         atomic_set(&adapter->irq_sem, 1);
         spin_lock_init(&adapter->stats_lock);
-        spin_lock_init(&adapter->tx_lock);
 
         return 0;
 }
 
 /**
+ * e1000_alloc_queues - Allocate memory for all rings
+ * @adapter: board private structure to initialize
+ *
+ * We allocate one ring per queue at run-time since we don't know the
+ * number of queues at compile-time.  The polling_netdev array is
+ * intended for Multiqueue, but should work fine with a single queue.
+ **/
+
+static int __devinit
+e1000_alloc_queues(struct e1000_adapter *adapter)
+{
+        int size;
+
+        size = sizeof(struct e1000_tx_ring) * adapter->num_queues;
+        adapter->tx_ring = kmalloc(size, GFP_KERNEL);
+        if (!adapter->tx_ring)
+                return -ENOMEM;
+        memset(adapter->tx_ring, 0, size);
+
+        size = sizeof(struct e1000_rx_ring) * adapter->num_queues;
+        adapter->rx_ring = kmalloc(size, GFP_KERNEL);
+        if (!adapter->rx_ring) {
+                kfree(adapter->tx_ring);
+                return -ENOMEM;
+        }
+        memset(adapter->rx_ring, 0, size);
+
+#ifdef CONFIG_E1000_NAPI
+        size = sizeof(struct net_device) * adapter->num_queues;
+        adapter->polling_netdev = kmalloc(size, GFP_KERNEL);
+        if (!adapter->polling_netdev) {
+                kfree(adapter->tx_ring);
+                kfree(adapter->rx_ring);
+                return -ENOMEM;
+        }
+        memset(adapter->polling_netdev, 0, size);
+#endif
+
+        return E1000_SUCCESS;
+}
+
+#ifdef CONFIG_E1000_MQ
+static void __devinit
+e1000_setup_queue_mapping(struct e1000_adapter *adapter)
+{
+        int i, cpu;
+
+        adapter->rx_sched_call_data.func = e1000_rx_schedule;
+        adapter->rx_sched_call_data.info = adapter->netdev;
+        cpus_clear(adapter->rx_sched_call_data.cpumask);
+
+        adapter->cpu_netdev = alloc_percpu(struct net_device *);
+        adapter->cpu_tx_ring = alloc_percpu(struct e1000_tx_ring *);
+
+        lock_cpu_hotplug();
+        i = 0;
+        for_each_online_cpu(cpu) {
+                *per_cpu_ptr(adapter->cpu_tx_ring, cpu) = &adapter->tx_ring[i % adapter->num_queues];
+                /* This is incomplete because we'd like to assign separate
+                 * physical cpus to these netdev polling structures and
+                 * avoid saturating a subset of cpus.
+                 */
+                if (i < adapter->num_queues) {
+                        *per_cpu_ptr(adapter->cpu_netdev, cpu) = &adapter->polling_netdev[i];
+                        adapter->cpu_for_queue[i] = cpu;
+                } else
+                        *per_cpu_ptr(adapter->cpu_netdev, cpu) = NULL;
+
+                i++;
+        }
+        unlock_cpu_hotplug();
+}
+#endif
+
+/**
  * e1000_open - Called when a network interface is made active
  * @netdev: network interface device structure
  *
@@ -868,12 +1053,12 @@ e1000_open(struct net_device *netdev)
 
         /* allocate transmit descriptors */
 
-        if((err = e1000_setup_tx_resources(adapter)))
+        if ((err = e1000_setup_all_tx_resources(adapter)))
                 goto err_setup_tx;
 
         /* allocate receive descriptors */
 
-        if((err = e1000_setup_rx_resources(adapter)))
+        if ((err = e1000_setup_all_rx_resources(adapter)))
                 goto err_setup_rx;
 
         if((err = e1000_up(adapter)))
@@ -887,9 +1072,9 @@ e1000_open(struct net_device *netdev)
         return E1000_SUCCESS;
 
 err_up:
-        e1000_free_rx_resources(adapter);
+        e1000_free_all_rx_resources(adapter);
 err_setup_rx:
-        e1000_free_tx_resources(adapter);
+        e1000_free_all_tx_resources(adapter);
 err_setup_tx:
         e1000_reset(adapter);
 
@@ -915,8 +1100,8 @@ e1000_close(struct net_device *netdev)
 
         e1000_down(adapter);
 
-        e1000_free_tx_resources(adapter);
-        e1000_free_rx_resources(adapter);
+        e1000_free_all_tx_resources(adapter);
+        e1000_free_all_rx_resources(adapter);
 
         if((adapter->hw.mng_cookie.status &
                           E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
@@ -951,25 +1136,28 @@ e1000_check_64k_bound(struct e1000_adapter *adapter,
 /**
  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
  * @adapter: board private structure
+ * @txdr:    tx descriptor ring (for a specific queue) to setup
  *
  * Return 0 on success, negative on failure
  **/
 
 int
-e1000_setup_tx_resources(struct e1000_adapter *adapter)
+e1000_setup_tx_resources(struct e1000_adapter *adapter,
+                         struct e1000_tx_ring *txdr)
 {
-        struct e1000_desc_ring *txdr = &adapter->tx_ring;
         struct pci_dev *pdev = adapter->pdev;
         int size;
 
         size = sizeof(struct e1000_buffer) * txdr->count;
-        txdr->buffer_info = vmalloc(size);
+
+        txdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
         if(!txdr->buffer_info) {
                 DPRINTK(PROBE, ERR,
                 "Unable to allocate memory for the transmit descriptor ring\n");
                 return -ENOMEM;
         }
         memset(txdr->buffer_info, 0, size);
+        memset(&txdr->previous_buffer_info, 0, sizeof(struct e1000_buffer));
 
         /* round up to nearest 4K */
 
@@ -1018,11 +1206,41 @@ setup_tx_desc_die:
 
         txdr->next_to_use = 0;
         txdr->next_to_clean = 0;
+        spin_lock_init(&txdr->tx_lock);
 
         return 0;
 }
 
 /**
+ * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
+ *                                (Descriptors) for all queues
+ * @adapter: board private structure
+ *
+ * If this function returns with an error, then it's possible one or
+ * more of the rings is populated (while the rest are not).  It is the
+ * callers duty to clean those orphaned rings.
+ *
+ * Return 0 on success, negative on failure
+ **/
+
+int
+e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
+{
+        int i, err = 0;
+
+        for (i = 0; i < adapter->num_queues; i++) {
+                err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
+                if (err) {
+                        DPRINTK(PROBE, ERR,
+                                "Allocation for Tx Queue %u failed\n", i);
+                        break;
+                }
+        }
+
+        return err;
+}
+
+/**
  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
  * @adapter: board private structure
  *
@@ -1032,23 +1250,43 @@ setup_tx_desc_die:
 static void
 e1000_configure_tx(struct e1000_adapter *adapter)
 {
-        uint64_t tdba = adapter->tx_ring.dma;
-        uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
-        uint32_t tctl, tipg;
-
-        E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
-        E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
-
-        E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
+        uint64_t tdba;
+        struct e1000_hw *hw = &adapter->hw;
+        uint32_t tdlen, tctl, tipg, tarc;
 
         /* Setup the HW Tx Head and Tail descriptor pointers */
 
-        E1000_WRITE_REG(&adapter->hw, TDH, 0);
-        E1000_WRITE_REG(&adapter->hw, TDT, 0);
+        switch (adapter->num_queues) {
+        case 2:
+                tdba = adapter->tx_ring[1].dma;
+                tdlen = adapter->tx_ring[1].count *
+                        sizeof(struct e1000_tx_desc);
+                E1000_WRITE_REG(hw, TDBAL1, (tdba & 0x00000000ffffffffULL));
+                E1000_WRITE_REG(hw, TDBAH1, (tdba >> 32));
+                E1000_WRITE_REG(hw, TDLEN1, tdlen);
+                E1000_WRITE_REG(hw, TDH1, 0);
+                E1000_WRITE_REG(hw, TDT1, 0);
+                adapter->tx_ring[1].tdh = E1000_TDH1;
+                adapter->tx_ring[1].tdt = E1000_TDT1;
+                /* Fall Through */
+        case 1:
+        default:
+                tdba = adapter->tx_ring[0].dma;
+                tdlen = adapter->tx_ring[0].count *
+                        sizeof(struct e1000_tx_desc);
+                E1000_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
+                E1000_WRITE_REG(hw, TDBAH, (tdba >> 32));
+                E1000_WRITE_REG(hw, TDLEN, tdlen);
+                E1000_WRITE_REG(hw, TDH, 0);
+                E1000_WRITE_REG(hw, TDT, 0);
+                adapter->tx_ring[0].tdh = E1000_TDH;
+                adapter->tx_ring[0].tdt = E1000_TDT;
+                break;
+        }
 
         /* Set the default values for the Tx Inter Packet Gap timer */
 
-        switch (adapter->hw.mac_type) {
+        switch (hw->mac_type) {
         case e1000_82542_rev2_0:
         case e1000_82542_rev2_1:
                 tipg = DEFAULT_82542_TIPG_IPGT;
@@ -1056,67 +1294,81 @@ e1000_configure_tx(struct e1000_adapter *adapter)
                 tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
                 break;
         default:
-                if(adapter->hw.media_type == e1000_media_type_fiber ||
-                   adapter->hw.media_type == e1000_media_type_internal_serdes)
+                if (hw->media_type == e1000_media_type_fiber ||
+                    hw->media_type == e1000_media_type_internal_serdes)
                         tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
                 else
                         tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
                 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
                 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
         }
-        E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
+        E1000_WRITE_REG(hw, TIPG, tipg);
 
         /* Set the Tx Interrupt Delay register */
 
-        E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
-        if(adapter->hw.mac_type >= e1000_82540)
-                E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
+        E1000_WRITE_REG(hw, TIDV, adapter->tx_int_delay);
+        if (hw->mac_type >= e1000_82540)
+                E1000_WRITE_REG(hw, TADV, adapter->tx_abs_int_delay);
 
         /* Program the Transmit Control Register */
 
-        tctl = E1000_READ_REG(&adapter->hw, TCTL);
+        tctl = E1000_READ_REG(hw, TCTL);
 
         tctl &= ~E1000_TCTL_CT;
-        tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
+        tctl |= E1000_TCTL_EN | E1000_TCTL_PSP | E1000_TCTL_RTLC |
                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
 
-        E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
+        E1000_WRITE_REG(hw, TCTL, tctl);
+
+        if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
+                tarc = E1000_READ_REG(hw, TARC0);
+                tarc |= ((1 << 25) | (1 << 21));
+                E1000_WRITE_REG(hw, TARC0, tarc);
+                tarc = E1000_READ_REG(hw, TARC1);
+                tarc |= (1 << 25);
+                if (tctl & E1000_TCTL_MULR)
+                        tarc &= ~(1 << 28);
+                else
+                        tarc |= (1 << 28);
+                E1000_WRITE_REG(hw, TARC1, tarc);
+        }
 
-        e1000_config_collision_dist(&adapter->hw);
+        e1000_config_collision_dist(hw);
 
         /* Setup Transmit Descriptor Settings for eop descriptor */
         adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
                 E1000_TXD_CMD_IFCS;
 
-        if(adapter->hw.mac_type < e1000_82543)
+        if (hw->mac_type < e1000_82543)
                 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
         else
                 adapter->txd_cmd |= E1000_TXD_CMD_RS;
 
         /* Cache if we're 82544 running in PCI-X because we'll
          * need this to apply a workaround later in the send path. */
-        if(adapter->hw.mac_type == e1000_82544 &&
-           adapter->hw.bus_type == e1000_bus_type_pcix)
+        if (hw->mac_type == e1000_82544 &&
+            hw->bus_type == e1000_bus_type_pcix)
                 adapter->pcix_82544 = 1;
 }
 
 /**
  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
  * @adapter: board private structure
+ * @rxdr:    rx descriptor ring (for a specific queue) to setup
  *
  * Returns 0 on success, negative on failure
  **/
 
 int
-e1000_setup_rx_resources(struct e1000_adapter *adapter)
+e1000_setup_rx_resources(struct e1000_adapter *adapter,
+                         struct e1000_rx_ring *rxdr)
 {
-        struct e1000_desc_ring *rxdr = &adapter->rx_ring;
         struct pci_dev *pdev = adapter->pdev;
         int size, desc_len;
 
         size = sizeof(struct e1000_buffer) * rxdr->count;
-        rxdr->buffer_info = vmalloc(size);
-        if(!rxdr->buffer_info) {
+        rxdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
+        if (!rxdr->buffer_info) {
                 DPRINTK(PROBE, ERR,
                 "Unable to allocate memory for the receive descriptor ring\n");
                 return -ENOMEM;
@@ -1156,13 +1408,13 @@ e1000_setup_rx_resources(struct e1000_adapter *adapter)
 
         rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
 
-        if(!rxdr->desc) {
+        if (!rxdr->desc) {
+                DPRINTK(PROBE, ERR,
+                "Unable to allocate memory for the receive descriptor ring\n");
 setup_rx_desc_die:
                 vfree(rxdr->buffer_info);
                 kfree(rxdr->ps_page);
                 kfree(rxdr->ps_page_dma);
-                DPRINTK(PROBE, ERR,
-                "Unable to allocate memory for the receive descriptor ring\n");
                 return -ENOMEM;
         }
 
@@ -1174,9 +1426,12 @@ setup_rx_desc_die:
                                      "at %p\n", rxdr->size, rxdr->desc);
                 /* Try again, without freeing the previous */
                 rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
-                if(!rxdr->desc) {
                 /* Failed allocation, critical failure */
+                if (!rxdr->desc) {
                         pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
+                        DPRINTK(PROBE, ERR,
+                                "Unable to allocate memory "
+                                "for the receive descriptor ring\n");
                         goto setup_rx_desc_die;
                 }
 
@@ -1188,10 +1443,7 @@ setup_rx_desc_die:
                         DPRINTK(PROBE, ERR,
                                 "Unable to allocate aligned memory "
                                 "for the receive descriptor ring\n");
-                        vfree(rxdr->buffer_info);
-                        kfree(rxdr->ps_page);
-                        kfree(rxdr->ps_page_dma);
-                        return -ENOMEM;
+                        goto setup_rx_desc_die;
                 } else {
                         /* Free old allocation, new allocation was successful */
                         pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
@@ -1206,15 +1458,48 @@ setup_rx_desc_die:
 }
 
 /**
+ * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
+ *                                (Descriptors) for all queues
+ * @adapter: board private structure
+ *
+ * If this function returns with an error, then it's possible one or
+ * more of the rings is populated (while the rest are not).  It is the
+ * callers duty to clean those orphaned rings.
+ *
+ * Return 0 on success, negative on failure
+ **/
+
+int
+e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
+{
+        int i, err = 0;
+
+        for (i = 0; i < adapter->num_queues; i++) {
+                err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
+                if (err) {
+                        DPRINTK(PROBE, ERR,
+                                "Allocation for Rx Queue %u failed\n", i);
+                        break;
+                }
+        }
+
+        return err;
+}
+
+/**
  * e1000_setup_rctl - configure the receive control registers
  * @adapter: Board private structure
  **/
-
+#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
+                        (((S) & (PAGE_SIZE - 1)) ? 1 : 0))
 static void
 e1000_setup_rctl(struct e1000_adapter *adapter)
 {
         uint32_t rctl, rfctl;
         uint32_t psrctl = 0;
+#ifdef CONFIG_E1000_PACKET_SPLIT
+        uint32_t pages = 0;
+#endif
 
         rctl = E1000_READ_REG(&adapter->hw, RCTL);
 
@@ -1235,7 +1520,7 @@ e1000_setup_rctl(struct e1000_adapter *adapter)
                 rctl |= E1000_RCTL_LPE;
 
         /* Setup buffer sizes */
-        if(adapter->hw.mac_type == e1000_82573) {
+        if(adapter->hw.mac_type >= e1000_82571) {
                 /* We can now specify buffers in 1K increments.
                  * BSIZE and BSEX are ignored in this case. */
                 rctl |= adapter->rx_buffer_len << 0x11;
@@ -1268,11 +1553,14 @@ e1000_setup_rctl(struct e1000_adapter *adapter)
          * followed by the page buffers.  Therefore, skb->data is
          * sized to hold the largest protocol header.
          */
-        adapter->rx_ps = (adapter->hw.mac_type > e1000_82547_rev_2) 
-                          && (adapter->netdev->mtu 
-                              < ((3 * PAGE_SIZE) + adapter->rx_ps_bsize0));
+        pages = PAGE_USE_COUNT(adapter->netdev->mtu);
+        if ((adapter->hw.mac_type > e1000_82547_rev_2) && (pages <= 3) &&
+            PAGE_SIZE <= 16384)
+                adapter->rx_ps_pages = pages;
+        else
+                adapter->rx_ps_pages = 0;
 #endif
-        if(adapter->rx_ps) {
+        if (adapter->rx_ps_pages) {
                 /* Configure extra packet-split registers */
                 rfctl = E1000_READ_REG(&adapter->hw, RFCTL);
                 rfctl |= E1000_RFCTL_EXTEN;
@@ -1284,12 +1572,19 @@ e1000_setup_rctl(struct e1000_adapter *adapter)
                 
                 psrctl |= adapter->rx_ps_bsize0 >>
                         E1000_PSRCTL_BSIZE0_SHIFT;
-                psrctl |= PAGE_SIZE >>
-                        E1000_PSRCTL_BSIZE1_SHIFT;
-                psrctl |= PAGE_SIZE <<
-                        E1000_PSRCTL_BSIZE2_SHIFT;
-                psrctl |= PAGE_SIZE <<
-                        E1000_PSRCTL_BSIZE3_SHIFT;
+
+                switch (adapter->rx_ps_pages) {
+                case 3:
+                        psrctl |= PAGE_SIZE <<
+                                E1000_PSRCTL_BSIZE3_SHIFT;
+                case 2:
+                        psrctl |= PAGE_SIZE <<
+                                E1000_PSRCTL_BSIZE2_SHIFT;
+                case 1:
+                        psrctl |= PAGE_SIZE >>
+                                E1000_PSRCTL_BSIZE1_SHIFT;
+                        break;
+                }
 
                 E1000_WRITE_REG(&adapter->hw, PSRCTL, psrctl);
         }
@@ -1307,91 +1602,181 @@ e1000_setup_rctl(struct e1000_adapter *adapter)
 static void
 e1000_configure_rx(struct e1000_adapter *adapter)
 {
-        uint64_t rdba = adapter->rx_ring.dma;
-        uint32_t rdlen, rctl, rxcsum;
+        uint64_t rdba;
+        struct e1000_hw *hw = &adapter->hw;
+        uint32_t rdlen, rctl, rxcsum, ctrl_ext;
+#ifdef CONFIG_E1000_MQ
+        uint32_t reta, mrqc;
+        int i;
+#endif
 
-        if(adapter->rx_ps) {
-                rdlen = adapter->rx_ring.count *
+        if (adapter->rx_ps_pages) {
+                rdlen = adapter->rx_ring[0].count *
                         sizeof(union e1000_rx_desc_packet_split);
                 adapter->clean_rx = e1000_clean_rx_irq_ps;
                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers_ps;
         } else {
-                rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
+                rdlen = adapter->rx_ring[0].count *
+                        sizeof(struct e1000_rx_desc);
                 adapter->clean_rx = e1000_clean_rx_irq;
                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
         }
 
         /* disable receives while setting up the descriptors */
-        rctl = E1000_READ_REG(&adapter->hw, RCTL);
-        E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
+        rctl = E1000_READ_REG(hw, RCTL);
+        E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
 
         /* set the Receive Delay Timer Register */
-        E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
+        E1000_WRITE_REG(hw, RDTR, adapter->rx_int_delay);
 
-        if(adapter->hw.mac_type >= e1000_82540) {
-                E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
+        if (hw->mac_type >= e1000_82540) {
+                E1000_WRITE_REG(hw, RADV, adapter->rx_abs_int_delay);
                 if(adapter->itr > 1)
-                        E1000_WRITE_REG(&adapter->hw, ITR,
+                        E1000_WRITE_REG(hw, ITR,
                                 1000000000 / (adapter->itr * 256));
         }
 
-        /* Setup the Base and Length of the Rx Descriptor Ring */
-        E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
-        E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
+        if (hw->mac_type >= e1000_82571) {
+                /* Reset delay timers after every interrupt */
+                ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
+                ctrl_ext |= E1000_CTRL_EXT_CANC;
+                E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
+                E1000_WRITE_FLUSH(hw);
+        }
+
+        /* Setup the HW Rx Head and Tail Descriptor Pointers and
+         * the Base and Length of the Rx Descriptor Ring */
+        switch (adapter->num_queues) {
+#ifdef CONFIG_E1000_MQ
+        case 2:
+                rdba = adapter->rx_ring[1].dma;
+                E1000_WRITE_REG(hw, RDBAL1, (rdba & 0x00000000ffffffffULL));
+                E1000_WRITE_REG(hw, RDBAH1, (rdba >> 32));
+                E1000_WRITE_REG(hw, RDLEN1, rdlen);
+                E1000_WRITE_REG(hw, RDH1, 0);
+                E1000_WRITE_REG(hw, RDT1, 0);
+                adapter->rx_ring[1].rdh = E1000_RDH1;
+                adapter->rx_ring[1].rdt = E1000_RDT1;
+                /* Fall Through */
+#endif
+        case 1:
+        default:
+                rdba = adapter->rx_ring[0].dma;
+                E1000_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
+                E1000_WRITE_REG(hw, RDBAH, (rdba >> 32));
+                E1000_WRITE_REG(hw, RDLEN, rdlen);
+                E1000_WRITE_REG(hw, RDH, 0);
+                E1000_WRITE_REG(hw, RDT, 0);
+                adapter->rx_ring[0].rdh = E1000_RDH;
+                adapter->rx_ring[0].rdt = E1000_RDT;
+                break;
+        }
+
+#ifdef CONFIG_E1000_MQ
+        if (adapter->num_queues > 1) {
+                uint32_t random[10];
+
+                get_random_bytes(&random[0], 40);
 
-        E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
+                if (hw->mac_type <= e1000_82572) {
+                        E1000_WRITE_REG(hw, RSSIR, 0);
+                        E1000_WRITE_REG(hw, RSSIM, 0);
+                }
+
+                switch (adapter->num_queues) {
+                case 2:
+                default:
+                        reta = 0x00800080;
+                        mrqc = E1000_MRQC_ENABLE_RSS_2Q;
+                        break;
+                }
 
-        /* Setup the HW Rx Head and Tail Descriptor Pointers */
-        E1000_WRITE_REG(&adapter->hw, RDH, 0);
-        E1000_WRITE_REG(&adapter->hw, RDT, 0);
+                /* Fill out redirection table */
+                for (i = 0; i < 32; i++)
+                        E1000_WRITE_REG_ARRAY(hw, RETA, i, reta);
+                /* Fill out hash function seeds */
+                for (i = 0; i < 10; i++)
+                        E1000_WRITE_REG_ARRAY(hw, RSSRK, i, random[i]);
+
+                mrqc |= (E1000_MRQC_RSS_FIELD_IPV4 |
+                         E1000_MRQC_RSS_FIELD_IPV4_TCP);
+                E1000_WRITE_REG(hw, MRQC, mrqc);
+        }
+
+        /* Multiqueue and packet checksumming are mutually exclusive. */
+        if (hw->mac_type >= e1000_82571) {
+                rxcsum = E1000_READ_REG(hw, RXCSUM);
+                rxcsum |= E1000_RXCSUM_PCSD;
+                E1000_WRITE_REG(hw, RXCSUM, rxcsum);
+        }
+
+#else
 
         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
-        if(adapter->hw.mac_type >= e1000_82543) {
-                rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
+        if (hw->mac_type >= e1000_82543) {
+                rxcsum = E1000_READ_REG(hw, RXCSUM);
                 if(adapter->rx_csum == TRUE) {
                         rxcsum |= E1000_RXCSUM_TUOFL;
 
-                        /* Enable 82573 IPv4 payload checksum for UDP fragments
+                        /* Enable 82571 IPv4 payload checksum for UDP fragments
                          * Must be used in conjunction with packet-split. */
-                        if((adapter->hw.mac_type > e1000_82547_rev_2) && 
-                           (adapter->rx_ps)) {
+                        if ((hw->mac_type >= e1000_82571) && 
+                           (adapter->rx_ps_pages)) {
                                 rxcsum |= E1000_RXCSUM_IPPCSE;
                         }
                 } else {
                         rxcsum &= ~E1000_RXCSUM_TUOFL;
                         /* don't need to clear IPPCSE as it defaults to 0 */
                 }
-                E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
+                E1000_WRITE_REG(hw, RXCSUM, rxcsum);
         }
+#endif /* CONFIG_E1000_MQ */
 
-        if (adapter->hw.mac_type == e1000_82573)
-                E1000_WRITE_REG(&adapter->hw, ERT, 0x0100);
+        if (hw->mac_type == e1000_82573)
+                E1000_WRITE_REG(hw, ERT, 0x0100);
 
         /* Enable Receives */
-        E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
+        E1000_WRITE_REG(hw, RCTL, rctl);
 }
 
 /**
- * e1000_free_tx_resources - Free Tx Resources
+ * e1000_free_tx_resources - Free Tx Resources per Queue
  * @adapter: board private structure
+ * @tx_ring: Tx descriptor ring for a specific queue
  *
  * Free all transmit software resources
  **/
 
 void
-e1000_free_tx_resources(struct e1000_adapter *adapter)
+e1000_free_tx_resources(struct e1000_adapter *adapter,
+                        struct e1000_tx_ring *tx_ring)
 {
         struct pci_dev *pdev = adapter->pdev;
 
-        e1000_clean_tx_ring(adapter);
+        e1000_clean_tx_ring(adapter, tx_ring);
 
-        vfree(adapter->tx_ring.buffer_info);
-        adapter->tx_ring.buffer_info = NULL;
+        vfree(tx_ring->buffer_info);
+        tx_ring->buffer_info = NULL;
 
-        pci_free_consistent(pdev, adapter->tx_ring.size,
-                            adapter->tx_ring.desc, adapter->tx_ring.dma);
+        pci_free_consistent(pdev, tx_ring->size, tx_ring->desc, tx_ring->dma);
+
+        tx_ring->desc = NULL;
+}
+
+/**
+ * e1000_free_all_tx_resources - Free Tx Resources for All Queues
+ * @adapter: board private structure
+ *
+ * Free all transmit software resources
+ **/
+
+void
+e1000_free_all_tx_resources(struct e1000_adapter *adapter)
+{
+        int i;
 
-        adapter->tx_ring.desc = NULL;
+        for (i = 0; i < adapter->num_queues; i++)
+                e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
 }
 
 static inline void
@@ -1414,21 +1799,22 @@ e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
 /**
  * e1000_clean_tx_ring - Free Tx Buffers
  * @adapter: board private structure
+ * @tx_ring: ring to be cleaned
  **/
 
 static void
-e1000_clean_tx_ring(struct e1000_adapter *adapter)
+e1000_clean_tx_ring(struct e1000_adapter *adapter,
+                    struct e1000_tx_ring *tx_ring)
 {
-        struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
         struct e1000_buffer *buffer_info;
         unsigned long size;
         unsigned int i;
 
         /* Free all the Tx ring sk_buffs */
 
-        if (likely(adapter->previous_buffer_info.skb != NULL)) {
+        if (likely(tx_ring->previous_buffer_info.skb != NULL)) {
                 e1000_unmap_and_free_tx_resource(adapter,
-                                &adapter->previous_buffer_info);
+                                &tx_ring->previous_buffer_info);
         }
 
         for(i = 0; i < tx_ring->count; i++) {
@@ -1446,24 +1832,39 @@ e1000_clean_tx_ring(struct e1000_adapter *adapter)
         tx_ring->next_to_use = 0;
         tx_ring->next_to_clean = 0;
 
-        E1000_WRITE_REG(&adapter->hw, TDH, 0);
-        E1000_WRITE_REG(&adapter->hw, TDT, 0);
+        writel(0, adapter->hw.hw_addr + tx_ring->tdh);
+        writel(0, adapter->hw.hw_addr + tx_ring->tdt);
+}
+
+/**
+ * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
+ * @adapter: board private structure
+ **/
+
+static void
+e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
+{
+        int i;
+
+        for (i = 0; i < adapter->num_queues; i++)
+                e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
 }
 
 /**
  * e1000_free_rx_resources - Free Rx Resources
  * @adapter: board private structure
+ * @rx_ring: ring to clean the resources from
  *
  * Free all receive software resources
  **/
 
 void
-e1000_free_rx_resources(struct e1000_adapter *adapter)
+e1000_free_rx_resources(struct e1000_adapter *adapter,
+                        struct e1000_rx_ring *rx_ring)
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         struct pci_dev *pdev = adapter->pdev;
 
-        e1000_clean_rx_ring(adapter);
+        e1000_clean_rx_ring(adapter, rx_ring);
 
         vfree(rx_ring->buffer_info);
         rx_ring->buffer_info = NULL;
@@ -1478,14 +1879,31 @@ e1000_free_rx_resources(struct e1000_adapter *adapter)
 }
 
 /**
- * e1000_clean_rx_ring - Free Rx Buffers
+ * e1000_free_all_rx_resources - Free Rx Resources for All Queues
+ * @adapter: board private structure
+ *
+ * Free all receive software resources
+ **/
+
+void
+e1000_free_all_rx_resources(struct e1000_adapter *adapter)
+{
+        int i;
+
+        for (i = 0; i < adapter->num_queues; i++)
+                e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
+}
+
+/**
+ * e1000_clean_rx_ring - Free Rx Buffers per Queue
  * @adapter: board private structure
+ * @rx_ring: ring to free buffers from
  **/
 
 static void
-e1000_clean_rx_ring(struct e1000_adapter *adapter)
+e1000_clean_rx_ring(struct e1000_adapter *adapter,
+                    struct e1000_rx_ring *rx_ring)
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         struct e1000_buffer *buffer_info;
         struct e1000_ps_page *ps_page;
         struct e1000_ps_page_dma *ps_page_dma;
@@ -1508,7 +1926,7 @@ e1000_clean_rx_ring(struct e1000_adapter *adapter)
                         dev_kfree_skb(buffer_info->skb);
                         buffer_info->skb = NULL;
 
-                        for(j = 0; j < PS_PAGE_BUFFERS; j++) {
+                        for(j = 0; j < adapter->rx_ps_pages; j++) {
                                 if(!ps_page->ps_page[j]) break;
                                 pci_unmap_single(pdev,
                                                  ps_page_dma->ps_page_dma[j],
@@ -1534,8 +1952,22 @@ e1000_clean_rx_ring(struct e1000_adapter *adapter)
         rx_ring->next_to_clean = 0;
         rx_ring->next_to_use = 0;
 
-        E1000_WRITE_REG(&adapter->hw, RDH, 0);
-        E1000_WRITE_REG(&adapter->hw, RDT, 0);
+        writel(0, adapter->hw.hw_addr + rx_ring->rdh);
+        writel(0, adapter->hw.hw_addr + rx_ring->rdt);
+}
+
+/**
+ * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
+ * @adapter: board private structure
+ **/
+
+static void
+e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
+{
+        int i;
+
+        for (i = 0; i < adapter->num_queues; i++)
+                e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
 }
 
 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
@@ -1556,7 +1988,7 @@ e1000_enter_82542_rst(struct e1000_adapter *adapter)
         mdelay(5);
 
         if(netif_running(netdev))
-                e1000_clean_rx_ring(adapter);
+                e1000_clean_all_rx_rings(adapter);
 }
 
 static void
@@ -1576,7 +2008,7 @@ e1000_leave_82542_rst(struct e1000_adapter *adapter)
 
         if(netif_running(netdev)) {
                 e1000_configure_rx(adapter);
-                e1000_alloc_rx_buffers(adapter);
+                e1000_alloc_rx_buffers(adapter, &adapter->rx_ring[0]);
         }
 }
 
@@ -1607,6 +2039,22 @@ e1000_set_mac(struct net_device *netdev, void *p)
 
         e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
 
+        /* With 82571 controllers, LAA may be overwritten (with the default)
+         * due to controller reset from the other port. */
+        if (adapter->hw.mac_type == e1000_82571) {
+                /* activate the work around */
+                adapter->hw.laa_is_present = 1;
+
+                /* Hold a copy of the LAA in RAR[14] This is done so that 
+                 * between the time RAR[0] gets clobbered  and the time it 
+                 * gets fixed (in e1000_watchdog), the actual LAA is in one 
+                 * of the RARs and no incoming packets directed to this port
+                 * are dropped. Eventaully the LAA will be in RAR[0] and 
+                 * RAR[14] */
+                e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 
+                                        E1000_RAR_ENTRIES - 1);
+        }
+
         if(adapter->hw.mac_type == e1000_82542_rev2_0)
                 e1000_leave_82542_rst(adapter);
 
@@ -1629,12 +2077,13 @@ e1000_set_multi(struct net_device *netdev)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
         struct dev_mc_list *mc_ptr;
-        unsigned long flags;
         uint32_t rctl;
         uint32_t hash_value;
-        int i;
+        int i, rar_entries = E1000_RAR_ENTRIES;
 
-        spin_lock_irqsave(&adapter->tx_lock, flags);
+        /* reserve RAR[14] for LAA over-write work-around */
+        if (adapter->hw.mac_type == e1000_82571)
+                rar_entries--;
 
         /* Check for Promiscuous and All Multicast modes */
 
@@ -1659,11 +2108,12 @@ e1000_set_multi(struct net_device *netdev)
         /* load the first 14 multicast address into the exact filters 1-14
          * RAR 0 is used for the station MAC adddress
          * if there are not 14 addresses, go ahead and clear the filters
+         * -- with 82571 controllers only 0-13 entries are filled here
          */
         mc_ptr = netdev->mc_list;
 
-        for(i = 1; i < E1000_RAR_ENTRIES; i++) {
-                if(mc_ptr) {
+        for(i = 1; i < rar_entries; i++) {
+                if (mc_ptr) {
                         e1000_rar_set(hw, mc_ptr->dmi_addr, i);
                         mc_ptr = mc_ptr->next;
                 } else {
@@ -1686,8 +2136,6 @@ e1000_set_multi(struct net_device *netdev)
 
         if(hw->mac_type == e1000_82542_rev2_0)
                 e1000_leave_82542_rst(adapter);
-
-        spin_unlock_irqrestore(&adapter->tx_lock, flags);
 }
 
 /* Need to wait a few seconds after link up to get diagnostic information from
@@ -1759,7 +2207,7 @@ static void
 e1000_watchdog_task(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
-        struct e1000_desc_ring *txdr = &adapter->tx_ring;
+        struct e1000_tx_ring *txdr = &adapter->tx_ring[0];
         uint32_t link;
 
         e1000_check_for_link(&adapter->hw);
@@ -1818,8 +2266,8 @@ e1000_watchdog_task(struct e1000_adapter *adapter)
 
         e1000_update_adaptive(&adapter->hw);
 
-        if(!netif_carrier_ok(netdev)) {
-                if(E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
+        if (adapter->num_queues == 1 && !netif_carrier_ok(netdev)) {
+                if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
                         /* We've lost link, so the controller stops DMA,
                          * but we've got queued Tx work that's never going
                          * to get done, so reset controller to flush Tx.
@@ -1847,6 +2295,11 @@ e1000_watchdog_task(struct e1000_adapter *adapter)
         /* Force detection of hung controller every watchdog period */
         adapter->detect_tx_hung = TRUE;
 
+        /* With 82571 controllers, LAA may be overwritten due to controller 
+         * reset from the other port. Set the appropriate LAA in RAR[0] */
+        if (adapter->hw.mac_type == e1000_82571 && adapter->hw.laa_is_present)
+                e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
+
         /* Reset the timer */
         mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
 }
@@ -1859,7 +2312,8 @@ e1000_watchdog_task(struct e1000_adapter *adapter)
 #define E1000_TX_FLAGS_VLAN_SHIFT       16
 
 static inline int
-e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
+e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
+          struct sk_buff *skb)
 {
 #ifdef NETIF_F_TSO
         struct e1000_context_desc *context_desc;
@@ -1910,8 +2364,8 @@ e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
                 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
                                E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
 
-                i = adapter->tx_ring.next_to_use;
-                context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
+                i = tx_ring->next_to_use;
+                context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
 
                 context_desc->lower_setup.ip_fields.ipcss  = ipcss;
                 context_desc->lower_setup.ip_fields.ipcso  = ipcso;
@@ -1923,8 +2377,8 @@ e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
                 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
                 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
 
-                if(++i == adapter->tx_ring.count) i = 0;
-                adapter->tx_ring.next_to_use = i;
+                if (++i == tx_ring->count) i = 0;
+                tx_ring->next_to_use = i;
 
                 return 1;
         }
@@ -1934,7 +2388,8 @@ e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
 }
 
 static inline boolean_t
-e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
+e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
+              struct sk_buff *skb)
 {
         struct e1000_context_desc *context_desc;
         unsigned int i;
@@ -1943,8 +2398,8 @@ e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
         if(likely(skb->ip_summed == CHECKSUM_HW)) {
                 css = skb->h.raw - skb->data;
 
-                i = adapter->tx_ring.next_to_use;
-                context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
+                i = tx_ring->next_to_use;
+                context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
 
                 context_desc->upper_setup.tcp_fields.tucss = css;
                 context_desc->upper_setup.tcp_fields.tucso = css + skb->csum;
@@ -1952,8 +2407,8 @@ e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
                 context_desc->tcp_seg_setup.data = 0;
                 context_desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT);
 
-                if(unlikely(++i == adapter->tx_ring.count)) i = 0;
-                adapter->tx_ring.next_to_use = i;
+                if (unlikely(++i == tx_ring->count)) i = 0;
+                tx_ring->next_to_use = i;
 
                 return TRUE;
         }
@@ -1965,11 +2420,10 @@ e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
 #define E1000_MAX_DATA_PER_TXD  (1<<E1000_MAX_TXD_PWR)
 
 static inline int
-e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb,
-        unsigned int first, unsigned int max_per_txd,
-        unsigned int nr_frags, unsigned int mss)
+e1000_tx_map(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
+             struct sk_buff *skb, unsigned int first, unsigned int max_per_txd,
+             unsigned int nr_frags, unsigned int mss)
 {
-        struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
         struct e1000_buffer *buffer_info;
         unsigned int len = skb->len;
         unsigned int offset = 0, size, count = 0, i;
@@ -2065,9 +2519,9 @@ e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb,
 }
 
 static inline void
-e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
+e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
+               int tx_flags, int count)
 {
-        struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
         struct e1000_tx_desc *tx_desc = NULL;
         struct e1000_buffer *buffer_info;
         uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
@@ -2113,7 +2567,7 @@ e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
         wmb();
 
         tx_ring->next_to_use = i;
-        E1000_WRITE_REG(&adapter->hw, TDT, i);
+        writel(i, adapter->hw.hw_addr + tx_ring->tdt);
 }
 
 /**
@@ -2206,6 +2660,7 @@ static int
 e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
+        struct e1000_tx_ring *tx_ring;
         unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
         unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
         unsigned int tx_flags = 0;
@@ -2218,7 +2673,13 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         unsigned int f;
         len -= skb->data_len;
 
-        if(unlikely(skb->len <= 0)) {
+#ifdef CONFIG_E1000_MQ
+        tx_ring = *per_cpu_ptr(adapter->cpu_tx_ring, smp_processor_id());
+#else
+        tx_ring = adapter->tx_ring;
+#endif
+
+        if (unlikely(skb->len <= 0)) {
                 dev_kfree_skb_any(skb);
                 return NETDEV_TX_OK;
         }
@@ -2262,21 +2723,42 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         if(adapter->pcix_82544)
                 count += nr_frags;
 
-        local_irq_save(flags); 
-        if (!spin_trylock(&adapter->tx_lock)) { 
-                /* Collision - tell upper layer to requeue */ 
-                local_irq_restore(flags); 
-                return NETDEV_TX_LOCKED; 
-        } 
+#ifdef NETIF_F_TSO
+        /* TSO Workaround for 82571/2 Controllers -- if skb->data
+         * points to just header, pull a few bytes of payload from 
+         * frags into skb->data */
+        if (skb_shinfo(skb)->tso_size) {
+                uint8_t hdr_len;
+                hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
+                if (skb->data_len && (hdr_len < (skb->len - skb->data_len)) && 
+                        (adapter->hw.mac_type == e1000_82571 ||
+                        adapter->hw.mac_type == e1000_82572)) {
+                        unsigned int pull_size;
+                        pull_size = min((unsigned int)4, skb->data_len);
+                        if (!__pskb_pull_tail(skb, pull_size)) {
+                                printk(KERN_ERR "__pskb_pull_tail failed.\n");
+                                dev_kfree_skb_any(skb);
+                                return -EFAULT;
+                        }
+                }
+        }
+#endif
+
         if(adapter->hw.tx_pkt_filtering && (adapter->hw.mac_type == e1000_82573) )
                 e1000_transfer_dhcp_info(adapter, skb);
 
+        local_irq_save(flags);
+        if (!spin_trylock(&tx_ring->tx_lock)) {
+                /* Collision - tell upper layer to requeue */
+                local_irq_restore(flags);
+                return NETDEV_TX_LOCKED;
+        }
 
         /* need: count + 2 desc gap to keep tail from touching
          * head, otherwise try next time */
-        if(unlikely(E1000_DESC_UNUSED(&adapter->tx_ring) < count + 2)) {
+        if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) {
                 netif_stop_queue(netdev);
-                spin_unlock_irqrestore(&adapter->tx_lock, flags);
+                spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
                 return NETDEV_TX_BUSY;
         }
 
@@ -2284,7 +2766,7 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 if(unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
                         netif_stop_queue(netdev);
                         mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
-                        spin_unlock_irqrestore(&adapter->tx_lock, flags);
+                        spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
                         return NETDEV_TX_BUSY;
                 }
         }
@@ -2294,37 +2776,37 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
         }
 
-        first = adapter->tx_ring.next_to_use;
+        first = tx_ring->next_to_use;
         
-        tso = e1000_tso(adapter, skb);
+        tso = e1000_tso(adapter, tx_ring, skb);
         if (tso < 0) {
                 dev_kfree_skb_any(skb);
-                spin_unlock_irqrestore(&adapter->tx_lock, flags);
+                spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
                 return NETDEV_TX_OK;
         }
 
         if (likely(tso))
                 tx_flags |= E1000_TX_FLAGS_TSO;
-        else if(likely(e1000_tx_csum(adapter, skb)))
+        else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
                 tx_flags |= E1000_TX_FLAGS_CSUM;
 
         /* Old method was to assume IPv4 packet by default if TSO was enabled.
-         * 82573 hardware supports TSO capabilities for IPv6 as well...
+         * 82571 hardware supports TSO capabilities for IPv6 as well...
          * no longer assume, we must. */
-        if(likely(skb->protocol == ntohs(ETH_P_IP)))
+        if (likely(skb->protocol == ntohs(ETH_P_IP)))
                 tx_flags |= E1000_TX_FLAGS_IPV4;
 
-        e1000_tx_queue(adapter,
-                e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss),
-                tx_flags);
+        e1000_tx_queue(adapter, tx_ring, tx_flags,
+                       e1000_tx_map(adapter, tx_ring, skb, first,
+                                    max_per_txd, nr_frags, mss));
 
         netdev->trans_start = jiffies;
 
         /* Make sure there is space in the ring for the next send. */
-        if(unlikely(E1000_DESC_UNUSED(&adapter->tx_ring) < MAX_SKB_FRAGS + 2))
+        if (unlikely(E1000_DESC_UNUSED(tx_ring) < MAX_SKB_FRAGS + 2))
                 netif_stop_queue(netdev);
 
-        spin_unlock_irqrestore(&adapter->tx_lock, flags);
+        spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
         return NETDEV_TX_OK;
 }
 
@@ -2388,9 +2870,18 @@ e1000_change_mtu(struct net_device *netdev, int new_mtu)
                         return -EINVAL;
         }
 
-#define MAX_STD_JUMBO_FRAME_SIZE 9216
+#define MAX_STD_JUMBO_FRAME_SIZE 9234
         /* might want this to be bigger enum check... */
-        if (adapter->hw.mac_type == e1000_82573 &&
+        /* 82571 controllers limit jumbo frame size to 10500 bytes */
+        if ((adapter->hw.mac_type == e1000_82571 || 
+             adapter->hw.mac_type == e1000_82572) &&
+            max_frame > MAX_STD_JUMBO_FRAME_SIZE) {
+                DPRINTK(PROBE, ERR, "MTU > 9216 bytes not supported "
+                                    "on 82571 and 82572 controllers.\n");
+                return -EINVAL;
+        }
+
+        if(adapter->hw.mac_type == e1000_82573 &&
             max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
                 DPRINTK(PROBE, ERR, "Jumbo Frames not supported "
                                     "on 82573\n");
@@ -2578,6 +3069,29 @@ e1000_update_stats(struct e1000_adapter *adapter)
         spin_unlock_irqrestore(&adapter->stats_lock, flags);
 }
 
+#ifdef CONFIG_E1000_MQ
+void
+e1000_rx_schedule(void *data)
+{
+        struct net_device *poll_dev, *netdev = data;
+        struct e1000_adapter *adapter = netdev->priv;
+        int this_cpu = get_cpu();
+
+        poll_dev = *per_cpu_ptr(adapter->cpu_netdev, this_cpu);
+        if (poll_dev == NULL) {
+                put_cpu();
+                return;
+        }
+
+        if (likely(netif_rx_schedule_prep(poll_dev)))
+                __netif_rx_schedule(poll_dev);
+        else
+                e1000_irq_enable(adapter);
+
+        put_cpu();
+}
+#endif
+
 /**
  * e1000_intr - Interrupt Handler
  * @irq: interrupt number
@@ -2592,8 +3106,8 @@ e1000_intr(int irq, void *data, struct pt_regs *regs)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
         uint32_t icr = E1000_READ_REG(hw, ICR);
-#ifndef CONFIG_E1000_NAPI
-        unsigned int i;
+#if defined(CONFIG_E1000_NAPI) && defined(CONFIG_E1000_MQ) || !defined(CONFIG_E1000_NAPI)
+        int i;
 #endif
 
         if(unlikely(!icr))
@@ -2605,17 +3119,31 @@ e1000_intr(int irq, void *data, struct pt_regs *regs)
         }
 
 #ifdef CONFIG_E1000_NAPI
-        if(likely(netif_rx_schedule_prep(netdev))) {
-
-                /* Disable interrupts and register for poll. The flush 
-                  of the posted write is intentionally left out.
-                */
-
-                atomic_inc(&adapter->irq_sem);
-                E1000_WRITE_REG(hw, IMC, ~0);
-                __netif_rx_schedule(netdev);
+        atomic_inc(&adapter->irq_sem);
+        E1000_WRITE_REG(hw, IMC, ~0);
+        E1000_WRITE_FLUSH(hw);
+#ifdef CONFIG_E1000_MQ
+        if (atomic_read(&adapter->rx_sched_call_data.count) == 0) {
+                cpu_set(adapter->cpu_for_queue[0],
+                        adapter->rx_sched_call_data.cpumask);
+                for (i = 1; i < adapter->num_queues; i++) {
+                        cpu_set(adapter->cpu_for_queue[i],
+                                adapter->rx_sched_call_data.cpumask);
+                        atomic_inc(&adapter->irq_sem);
+                }
+                atomic_set(&adapter->rx_sched_call_data.count, i);
+                smp_call_async_mask(&adapter->rx_sched_call_data);
+        } else {
+                printk("call_data.count == %u\n", atomic_read(&adapter->rx_sched_call_data.count));
         }
-#else
+#else /* if !CONFIG_E1000_MQ */
+        if (likely(netif_rx_schedule_prep(&adapter->polling_netdev[0])))
+                __netif_rx_schedule(&adapter->polling_netdev[0]);
+        else
+                e1000_irq_enable(adapter);
+#endif /* CONFIG_E1000_MQ */
+
+#else /* if !CONFIG_E1000_NAPI */
         /* Writing IMC and IMS is needed for 82547.
            Due to Hub Link bus being occupied, an interrupt
            de-assertion message is not able to be sent.
@@ -2632,13 +3160,14 @@ e1000_intr(int irq, void *data, struct pt_regs *regs)
         }
 
         for(i = 0; i < E1000_MAX_INTR; i++)
-                if(unlikely(!adapter->clean_rx(adapter) &
-                   !e1000_clean_tx_irq(adapter)))
+                if(unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
+                   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
                         break;
 
         if(hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)
                 e1000_irq_enable(adapter);
-#endif
+
+#endif /* CONFIG_E1000_NAPI */
 
         return IRQ_HANDLED;
 }
@@ -2650,22 +3179,37 @@ e1000_intr(int irq, void *data, struct pt_regs *regs)
  **/
 
 static int
-e1000_clean(struct net_device *netdev, int *budget)
+e1000_clean(struct net_device *poll_dev, int *budget)
 {
-        struct e1000_adapter *adapter = netdev_priv(netdev);
-        int work_to_do = min(*budget, netdev->quota);
-        int tx_cleaned;
-        int work_done = 0;
+        struct e1000_adapter *adapter;
+        int work_to_do = min(*budget, poll_dev->quota);
+        int tx_cleaned, i = 0, work_done = 0;
+
+        /* Must NOT use netdev_priv macro here. */
+        adapter = poll_dev->priv;
 
-        tx_cleaned = e1000_clean_tx_irq(adapter);
-        adapter->clean_rx(adapter, &work_done, work_to_do);
+        /* Keep link state information with original netdev */
+        if (!netif_carrier_ok(adapter->netdev))
+                goto quit_polling;
+
+        while (poll_dev != &adapter->polling_netdev[i]) {
+                i++;
+                if (unlikely(i == adapter->num_queues))
+                        BUG();
+        }
+
+        tx_cleaned = e1000_clean_tx_irq(adapter, &adapter->tx_ring[i]);
+        adapter->clean_rx(adapter, &adapter->rx_ring[i],
+                          &work_done, work_to_do);
 
         *budget -= work_done;
-        netdev->quota -= work_done;
+        poll_dev->quota -= work_done;
         
-        if ((!tx_cleaned && (work_done == 0)) || !netif_running(netdev)) {
         /* If no Tx and not enough Rx work done, exit the polling mode */
-                netif_rx_complete(netdev);
+        if((!tx_cleaned && (work_done == 0)) ||
+           !netif_running(adapter->netdev)) {
+quit_polling:
+                netif_rx_complete(poll_dev);
                 e1000_irq_enable(adapter);
                 return 0;
         }
@@ -2680,9 +3224,9 @@ e1000_clean(struct net_device *netdev, int *budget)
  **/
 
 static boolean_t
-e1000_clean_tx_irq(struct e1000_adapter *adapter)
+e1000_clean_tx_irq(struct e1000_adapter *adapter,
+                   struct e1000_tx_ring *tx_ring)
 {
-        struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
         struct net_device *netdev = adapter->netdev;
         struct e1000_tx_desc *tx_desc, *eop_desc;
         struct e1000_buffer *buffer_info;
@@ -2693,12 +3237,12 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
         eop = tx_ring->buffer_info[i].next_to_watch;
         eop_desc = E1000_TX_DESC(*tx_ring, eop);
 
-        while(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
+        while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
                 /* Premature writeback of Tx descriptors clear (free buffers
                  * and unmap pci_mapping) previous_buffer_info */
-                if (likely(adapter->previous_buffer_info.skb != NULL)) {
+                if (likely(tx_ring->previous_buffer_info.skb != NULL)) {
                         e1000_unmap_and_free_tx_resource(adapter,
-                                        &adapter->previous_buffer_info);
+                                        &tx_ring->previous_buffer_info);
                 }
 
                 for(cleaned = FALSE; !cleaned; ) {
@@ -2714,7 +3258,7 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
 #ifdef NETIF_F_TSO
                         } else {
                                 if (cleaned) {
-                                        memcpy(&adapter->previous_buffer_info,
+                                        memcpy(&tx_ring->previous_buffer_info,
                                                buffer_info,
                                                sizeof(struct e1000_buffer));
                                         memset(buffer_info, 0,
@@ -2732,6 +3276,8 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
 
                         if(unlikely(++i == tx_ring->count)) i = 0;
                 }
+
+                tx_ring->pkt++;
                 
                 eop = tx_ring->buffer_info[i].next_to_watch;
                 eop_desc = E1000_TX_DESC(*tx_ring, eop);
@@ -2739,15 +3285,15 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
 
         tx_ring->next_to_clean = i;
 
-        spin_lock(&adapter->tx_lock);
+        spin_lock(&tx_ring->tx_lock);
 
         if(unlikely(cleaned && netif_queue_stopped(netdev) &&
                     netif_carrier_ok(netdev)))
                 netif_wake_queue(netdev);
 
-        spin_unlock(&adapter->tx_lock);
-        if(adapter->detect_tx_hung) {
+        spin_unlock(&tx_ring->tx_lock);
 
+        if (adapter->detect_tx_hung) {
                 /* Detect a transmit hang in hardware, this serializes the
                  * check with the clearing of time_stamp and movement of i */
                 adapter->detect_tx_hung = FALSE;
@@ -2771,8 +3317,8 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
                                         "  next_to_watch        <%x>\n"
                                         "  jiffies              <%lx>\n"
                                         "  next_to_watch.status <%x>\n",
-                                E1000_READ_REG(&adapter->hw, TDH),
-                                E1000_READ_REG(&adapter->hw, TDT),
+                                readl(adapter->hw.hw_addr + tx_ring->tdh),
+                                readl(adapter->hw.hw_addr + tx_ring->tdt),
                                 tx_ring->next_to_use,
                                 i,
                                 (unsigned long long)tx_ring->buffer_info[i].dma,
@@ -2784,12 +3330,10 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter)
                 }
         }
 #ifdef NETIF_F_TSO
-
-        if( unlikely(!(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
-            time_after(jiffies, adapter->previous_buffer_info.time_stamp + HZ)))
+        if (unlikely(!(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
+            time_after(jiffies, tx_ring->previous_buffer_info.time_stamp + HZ)))
                 e1000_unmap_and_free_tx_resource(
-                    adapter, &adapter->previous_buffer_info);
-
+                    adapter, &tx_ring->previous_buffer_info);
 #endif
         return cleaned;
 }
@@ -2852,13 +3396,14 @@ e1000_rx_checksum(struct e1000_adapter *adapter,
 
 static boolean_t
 #ifdef CONFIG_E1000_NAPI
-e1000_clean_rx_irq(struct e1000_adapter *adapter, int *work_done,
-                   int work_to_do)
+e1000_clean_rx_irq(struct e1000_adapter *adapter,
+                   struct e1000_rx_ring *rx_ring,
+                   int *work_done, int work_to_do)
 #else
-e1000_clean_rx_irq(struct e1000_adapter *adapter)
+e1000_clean_rx_irq(struct e1000_adapter *adapter,
+                   struct e1000_rx_ring *rx_ring)
 #endif
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
         struct e1000_rx_desc *rx_desc;
@@ -2944,6 +3489,7 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter)
                 }
 #endif /* CONFIG_E1000_NAPI */
                 netdev->last_rx = jiffies;
+                rx_ring->pkt++;
 
 next_desc:
                 rx_desc->status = 0;
@@ -2953,7 +3499,7 @@ next_desc:
                 rx_desc = E1000_RX_DESC(*rx_ring, i);
         }
         rx_ring->next_to_clean = i;
-        adapter->alloc_rx_buf(adapter);
+        adapter->alloc_rx_buf(adapter, rx_ring);
 
         return cleaned;
 }
@@ -2965,13 +3511,14 @@ next_desc:
 
 static boolean_t
 #ifdef CONFIG_E1000_NAPI
-e1000_clean_rx_irq_ps(struct e1000_adapter *adapter, int *work_done,
-                      int work_to_do)
+e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
+                      struct e1000_rx_ring *rx_ring,
+                      int *work_done, int work_to_do)
 #else
-e1000_clean_rx_irq_ps(struct e1000_adapter *adapter)
+e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
+                      struct e1000_rx_ring *rx_ring)
 #endif
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         union e1000_rx_desc_packet_split *rx_desc;
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
@@ -3027,7 +3574,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter)
                 /* Good Receive */
                 skb_put(skb, length);
 
-                for(j = 0; j < PS_PAGE_BUFFERS; j++) {
+                for(j = 0; j < adapter->rx_ps_pages; j++) {
                         if(!(length = le16_to_cpu(rx_desc->wb.upper.length[j])))
                                 break;
 
@@ -3048,11 +3595,13 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter)
                                   rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
                 skb->protocol = eth_type_trans(skb, netdev);
 
-#ifdef HAVE_RX_ZERO_COPY
                 if(likely(rx_desc->wb.upper.header_status &
-                          E1000_RXDPS_HDRSTAT_HDRSP))
+                          E1000_RXDPS_HDRSTAT_HDRSP)) {
+                        adapter->rx_hdr_split++;
+#ifdef HAVE_RX_ZERO_COPY
                         skb_shinfo(skb)->zero_copy = TRUE;
 #endif
+                }
 #ifdef CONFIG_E1000_NAPI
                 if(unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
                         vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
@@ -3071,6 +3620,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter)
                 }
 #endif /* CONFIG_E1000_NAPI */
                 netdev->last_rx = jiffies;
+                rx_ring->pkt++;
 
 next_desc:
                 rx_desc->wb.middle.status_error &= ~0xFF;
@@ -3081,7 +3631,7 @@ next_desc:
                 staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
         }
         rx_ring->next_to_clean = i;
-        adapter->alloc_rx_buf(adapter);
+        adapter->alloc_rx_buf(adapter, rx_ring);
 
         return cleaned;
 }
@@ -3092,9 +3642,9 @@ next_desc:
  **/
 
 static void
-e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
+e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
+                       struct e1000_rx_ring *rx_ring)
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
         struct e1000_rx_desc *rx_desc;
@@ -3178,7 +3728,7 @@ e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
                          * applicable for weak-ordered memory model archs,
                          * such as IA-64). */
                         wmb();
-                        E1000_WRITE_REG(&adapter->hw, RDT, i);
+                        writel(i, adapter->hw.hw_addr + rx_ring->rdt);
                 }
 
                 if(unlikely(++i == rx_ring->count)) i = 0;
@@ -3194,9 +3744,9 @@ e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
  **/
 
 static void
-e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter)
+e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
+                          struct e1000_rx_ring *rx_ring)
 {
-        struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
         union e1000_rx_desc_packet_split *rx_desc;
@@ -3215,22 +3765,26 @@ e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter)
                 rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
 
                 for(j = 0; j < PS_PAGE_BUFFERS; j++) {
-                        if(unlikely(!ps_page->ps_page[j])) {
-                                ps_page->ps_page[j] =
-                                        alloc_page(GFP_ATOMIC);
-                                if(unlikely(!ps_page->ps_page[j]))
-                                        goto no_buffers;
-                                ps_page_dma->ps_page_dma[j] =
-                                        pci_map_page(pdev,
-                                                     ps_page->ps_page[j],
-                                                     0, PAGE_SIZE,
-                                                     PCI_DMA_FROMDEVICE);
-                        }
-                        /* Refresh the desc even if buffer_addrs didn't
-                         * change because each write-back erases this info.
-                         */
-                        rx_desc->read.buffer_addr[j+1] =
-                                cpu_to_le64(ps_page_dma->ps_page_dma[j]);
+                        if (j < adapter->rx_ps_pages) {
+                                if (likely(!ps_page->ps_page[j])) {
+                                        ps_page->ps_page[j] =
+                                                alloc_page(GFP_ATOMIC);
+                                        if (unlikely(!ps_page->ps_page[j]))
+                                                goto no_buffers;
+                                        ps_page_dma->ps_page_dma[j] =
+                                                pci_map_page(pdev,
+                                                            ps_page->ps_page[j],
+                                                            0, PAGE_SIZE,
+                                                            PCI_DMA_FROMDEVICE);
+                                }
+                                /* Refresh the desc even if buffer_addrs didn't
+                                 * change because each write-back erases 
+                                 * this info.
+                                 */
+                                rx_desc->read.buffer_addr[j+1] =
+                                     cpu_to_le64(ps_page_dma->ps_page_dma[j]);
+                        } else
+                                rx_desc->read.buffer_addr[j+1] = ~0;
                 }
 
                 skb = dev_alloc_skb(adapter->rx_ps_bsize0 + NET_IP_ALIGN);
@@ -3264,7 +3818,7 @@ e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter)
                          * descriptors are 32 bytes...so we increment tail
                          * twice as much.
                          */
-                        E1000_WRITE_REG(&adapter->hw, RDT, i<<1);
+                        writel(i<<1, adapter->hw.hw_addr + rx_ring->rdt);
                 }
 
                 if(unlikely(++i == rx_ring->count)) i = 0;
@@ -3640,6 +4194,7 @@ e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
         return 0;
 }
 
+#ifdef CONFIG_PM
 static int
 e1000_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -3715,6 +4270,12 @@ e1000_suspend(struct pci_dev *pdev, pm_message_t state)
         }
 
         switch(adapter->hw.mac_type) {
+        case e1000_82571:
+        case e1000_82572:
+                ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
+                E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
+                                ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
+                break;
         case e1000_82573:
                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
                 E1000_WRITE_REG(&adapter->hw, SWSM,
@@ -3730,13 +4291,13 @@ e1000_suspend(struct pci_dev *pdev, pm_message_t state)
         return 0;
 }
 
-#ifdef CONFIG_PM
 static int
 e1000_resume(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct e1000_adapter *adapter = netdev_priv(netdev);
         uint32_t manc, ret_val, swsm;
+        uint32_t ctrl_ext;
 
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
@@ -3762,6 +4323,12 @@ e1000_resume(struct pci_dev *pdev)
         }
 
         switch(adapter->hw.mac_type) {
+        case e1000_82571:
+        case e1000_82572:
+                ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
+                E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
+                                ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
+                break;
         case e1000_82573:
                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
                 E1000_WRITE_REG(&adapter->hw, SWSM,
@@ -3786,7 +4353,7 @@ e1000_netpoll(struct net_device *netdev)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         disable_irq(adapter->pdev->irq);
         e1000_intr(adapter->pdev->irq, netdev, NULL);
-        e1000_clean_tx_irq(adapter);
+        e1000_clean_tx_irq(adapter, adapter->tx_ring);
         enable_irq(adapter->pdev->irq);
 }
 #endif
diff --git a/drivers/net/e1000/e1000_param.c b/drivers/net/e1000/e1000_param.c
index 676247f9f1cc..38695d5b4637 100644
--- a/drivers/net/e1000/e1000_param.c
+++ b/drivers/net/e1000/e1000_param.c
@@ -306,7 +306,8 @@ e1000_check_options(struct e1000_adapter *adapter)
                         .def  = E1000_DEFAULT_TXD,
                         .arg  = { .r = { .min = E1000_MIN_TXD }}
                 };
-                struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
+                struct e1000_tx_ring *tx_ring = adapter->tx_ring;
+                int i;
                 e1000_mac_type mac_type = adapter->hw.mac_type;
                 opt.arg.r.max = mac_type < e1000_82544 ?
                         E1000_MAX_TXD : E1000_MAX_82544_TXD;
@@ -319,6 +320,8 @@ e1000_check_options(struct e1000_adapter *adapter)
                 } else {
                         tx_ring->count = opt.def;
                 }
+                for (i = 0; i < adapter->num_queues; i++)
+                        tx_ring[i].count = tx_ring->count;
         }
         { /* Receive Descriptor Count */
                 struct e1000_option opt = {
@@ -329,7 +332,8 @@ e1000_check_options(struct e1000_adapter *adapter)
                         .def  = E1000_DEFAULT_RXD,
                         .arg  = { .r = { .min = E1000_MIN_RXD }}
                 };
-                struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
+                struct e1000_rx_ring *rx_ring = adapter->rx_ring;
+                int i;
                 e1000_mac_type mac_type = adapter->hw.mac_type;
                 opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD :
                         E1000_MAX_82544_RXD;
@@ -342,6 +346,8 @@ e1000_check_options(struct e1000_adapter *adapter)
                 } else {
                         rx_ring->count = opt.def;
                 }
+                for (i = 0; i < adapter->num_queues; i++)
+                        rx_ring[i].count = rx_ring->count;
         }
         { /* Checksum Offload Enable/Disable */
                 struct e1000_option opt = {
diff --git a/drivers/net/eepro.c b/drivers/net/eepro.c
index dcb3028bb60f..a806dfe54d23 100644
--- a/drivers/net/eepro.c
+++ b/drivers/net/eepro.c
@@ -552,8 +552,7 @@ static int __init do_eepro_probe(struct net_device *dev)
         {
                 unsigned short int WS[32]=WakeupSeq;
 
-                if (check_region(WakeupPort, 2)==0) {
-
+                if (request_region(WakeupPort, 2, "eepro wakeup")) {
                         if (net_debug>5)
                                 printk(KERN_DEBUG "Waking UP\n");
 
@@ -563,7 +562,10 @@ static int __init do_eepro_probe(struct net_device *dev)
                                 outb_p(WS[i],WakeupPort);
                                 if (net_debug>5) printk(KERN_DEBUG ": %#x ",WS[i]);
                         }
-                } else printk(KERN_WARNING "Checkregion Failed!\n");
+
+                        release_region(WakeupPort, 2);
+                } else
+                        printk(KERN_WARNING "PnP wakeup region busy!\n");
         }
 #endif
 
@@ -705,7 +707,7 @@ static void __init eepro_print_info (struct net_device *dev)
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595FX:
-                        printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,", 
+                        printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,",
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595TX:
@@ -713,7 +715,7 @@ static void __init eepro_print_info (struct net_device *dev)
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595:
-                        printk("%s: Intel 82595-based lan card at %#x,", 
+                        printk("%s: Intel 82595-based lan card at %#x,",
                                         dev->name, (unsigned)dev->base_addr);
         }
 
@@ -726,7 +728,7 @@ static void __init eepro_print_info (struct net_device *dev)
 
         if (dev->irq > 2)
                 printk(", IRQ %d, %s.\n", dev->irq, ifmap[dev->if_port]);
-        else 
+        else
                 printk(", %s.\n", ifmap[dev->if_port]);
 
         if (net_debug > 3) {
@@ -756,7 +758,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
         int err;
 
         /* Grab the region so we can find another board if autoIRQ fails. */
-        if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { 
+        if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) {
                 if (!autoprobe)
                         printk(KERN_WARNING "EEPRO: io-port 0x%04x in use \n",
                                 ioaddr);
@@ -838,15 +840,15 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                 /* Mask off INT number */
                 int count = lp->word[1] & 7;
                 unsigned irqMask = lp->word[7];
- 
+
                 while (count--)
                         irqMask &= irqMask - 1;
- 
+
                 count = ffs(irqMask);
- 
+
                 if (count)
                         dev->irq = count - 1;
- 
+
                 if (dev->irq < 2) {
                         printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n");
                         goto exit;
@@ -854,7 +856,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                         dev->irq = 9;
                 }
         }
- 
+
         dev->open               = eepro_open;
         dev->stop               = eepro_close;
         dev->hard_start_xmit    = eepro_send_packet;
@@ -863,7 +865,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
         dev->tx_timeout         = eepro_tx_timeout;
         dev->watchdog_timeo     = TX_TIMEOUT;
         dev->ethtool_ops        = &eepro_ethtool_ops;
- 
+
         /* print boot time info */
         eepro_print_info(dev);
 
@@ -1047,8 +1049,8 @@ static int eepro_open(struct net_device *dev)
 
 
         /* Initialize the RCV and XMT upper and lower limits */
-        outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG); 
-        outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG); 
+        outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG);
+        outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG);
         outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg);
         outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg);
 
@@ -1065,12 +1067,12 @@ static int eepro_open(struct net_device *dev)
         eepro_clear_int(ioaddr);
 
         /* Initialize RCV */
-        outw(lp->rcv_lower_limit, ioaddr + RCV_BAR); 
+        outw(lp->rcv_lower_limit, ioaddr + RCV_BAR);
         lp->rx_start = lp->rcv_lower_limit;
-        outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP); 
+        outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP);
 
         /* Initialize XMT */
-        outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar); 
+        outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar);
         lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
         lp->tx_last = 0;
 
@@ -1411,7 +1413,7 @@ set_multicast_list(struct net_device *dev)
                                 outb(0x08, ioaddr + STATUS_REG);
 
                                 if (i & 0x20) { /* command ABORTed */
-                                        printk(KERN_NOTICE "%s: multicast setup failed.\n", 
+                                        printk(KERN_NOTICE "%s: multicast setup failed.\n",
                                                 dev->name);
                                         break;
                                 } else if ((i & 0x0f) == 0x03)  { /* MC-Done */
@@ -1512,7 +1514,7 @@ hardware_send_packet(struct net_device *dev, void *buf, short length)
                 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
 
         if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */
-                if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {   
+                if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {
                                 /* Arrrr!!!, must keep the xmt header together,
                                 several days were lost to chase this one down. */
                         last = lp->xmt_lower_limit;
@@ -1643,7 +1645,7 @@ eepro_rx(struct net_device *dev)
                         else if (rcv_status & 0x0800)
                                 lp->stats.rx_crc_errors++;
 
-                        printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n", 
+                        printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
                                 dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
                 }
 
@@ -1674,10 +1676,10 @@ eepro_transmit_interrupt(struct net_device *dev)
 {
         struct eepro_local *lp = netdev_priv(dev);
         short ioaddr = dev->base_addr;
-        short boguscount = 25; 
+        short boguscount = 25;
         short xmt_status;
 
-        while ((lp->tx_start != lp->tx_end) && boguscount--) { 
+        while ((lp->tx_start != lp->tx_end) && boguscount--) {
 
                 outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
                 xmt_status = inw(ioaddr+IO_PORT);
@@ -1723,7 +1725,7 @@ static int eepro_ethtool_get_settings(struct net_device *dev,
 {
         struct eepro_local      *lp = (struct eepro_local *)dev->priv;
 
-        cmd->supported =        SUPPORTED_10baseT_Half | 
+        cmd->supported =        SUPPORTED_10baseT_Half |
                                 SUPPORTED_10baseT_Full |
                                 SUPPORTED_Autoneg;
         cmd->advertising =      ADVERTISED_10baseT_Half |
@@ -1797,10 +1799,9 @@ MODULE_AUTHOR("Pascal Dupuis and others");
 MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver");
 MODULE_LICENSE("GPL");
 
-static int num_params;
-module_param_array(io, int, &num_params, 0);
-module_param_array(irq, int, &num_params, 0);
-module_param_array(mem, int, &num_params, 0);
+module_param_array(io, int, NULL, 0);
+module_param_array(irq, int, NULL, 0);
+module_param_array(mem, int, NULL, 0);
 module_param(autodetect, int, 0);
 MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
 MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
diff --git a/drivers/net/epic100.c b/drivers/net/epic100.c
index 87f522738bfc..f119ec4e89ea 100644
--- a/drivers/net/epic100.c
+++ b/drivers/net/epic100.c
@@ -1334,7 +1334,7 @@ static void epic_rx_err(struct net_device *dev, struct epic_private *ep)
 static int epic_poll(struct net_device *dev, int *budget)
 {
         struct epic_private *ep = dev->priv;
-        int work_done, orig_budget;
+        int work_done = 0, orig_budget;
         long ioaddr = dev->base_addr;
 
         orig_budget = (*budget > dev->quota) ? dev->quota : *budget;
@@ -1343,7 +1343,7 @@ rx_action:
 
         epic_tx(dev, ep);
 
-        work_done = epic_rx(dev, *budget);
+        work_done += epic_rx(dev, *budget);
 
         epic_rx_err(dev, ep);
 
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index d6eefdb71c17..22aec6ed80f5 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -95,6 +95,8 @@
  *                         of nv_remove
  *      0.42: 06 Aug 2005: Fix lack of link speed initialization
  *                         in the second (and later) nv_open call
+ *      0.43: 10 Aug 2005: Add support for tx checksum.
+ *      0.44: 20 Aug 2005: Add support for scatter gather and segmentation.
  *
  * Known bugs:
  * We suspect that on some hardware no TX done interrupts are generated.
@@ -106,7 +108,7 @@
  * DEV_NEED_TIMERIRQ will not harm you on sane hardware, only generating a few
  * superfluous timer interrupts from the nic.
  */
-#define FORCEDETH_VERSION               "0.41"
+#define FORCEDETH_VERSION               "0.44"
 #define DRV_NAME                        "forcedeth"
 
 #include <linux/module.h>
@@ -145,6 +147,7 @@
 #define DEV_NEED_LINKTIMER      0x0002  /* poll link settings. Relies on the timer irq */
 #define DEV_HAS_LARGEDESC       0x0004  /* device supports jumbo frames and needs packet format 2 */
 #define DEV_HAS_HIGH_DMA        0x0008  /* device supports 64bit dma */
+#define DEV_HAS_CHECKSUM        0x0010  /* device supports tx and rx checksum offloads */
 
 enum {
         NvRegIrqStatus = 0x000,
@@ -241,6 +244,9 @@ enum {
 #define NVREG_TXRXCTL_IDLE      0x0008
 #define NVREG_TXRXCTL_RESET     0x0010
 #define NVREG_TXRXCTL_RXCHECK   0x0400
+#define NVREG_TXRXCTL_DESC_1    0
+#define NVREG_TXRXCTL_DESC_2    0x02100
+#define NVREG_TXRXCTL_DESC_3    0x02200
         NvRegMIIStatus = 0x180,
 #define NVREG_MIISTAT_ERROR             0x0001
 #define NVREG_MIISTAT_LINKCHANGE        0x0008
@@ -335,6 +341,10 @@ typedef union _ring_type {
 /* error and valid are the same for both */
 #define NV_TX2_ERROR            (1<<30)
 #define NV_TX2_VALID            (1<<31)
+#define NV_TX2_TSO              (1<<28)
+#define NV_TX2_TSO_SHIFT        14
+#define NV_TX2_CHECKSUM_L3      (1<<27)
+#define NV_TX2_CHECKSUM_L4      (1<<26)
 
 #define NV_RX_DESCRIPTORVALID   (1<<16)
 #define NV_RX_MISSEDFRAME       (1<<17)
@@ -417,14 +427,14 @@ typedef union _ring_type {
 
 /* 
  * desc_ver values:
- * This field has two purposes:
- * - Newer nics uses a different ring layout. The layout is selected by
- *   comparing np->desc_ver with DESC_VER_xy.
- * - It contains bits that are forced on when writing to NvRegTxRxControl.
+ * The nic supports three different descriptor types:
+ * - DESC_VER_1: Original
+ * - DESC_VER_2: support for jumbo frames.
+ * - DESC_VER_3: 64-bit format.
  */
-#define DESC_VER_1      0x0
-#define DESC_VER_2      (0x02100|NVREG_TXRXCTL_RXCHECK)
-#define DESC_VER_3      (0x02200|NVREG_TXRXCTL_RXCHECK)
+#define DESC_VER_1      1
+#define DESC_VER_2      2
+#define DESC_VER_3      3
 
 /* PHY defines */
 #define PHY_OUI_MARVELL 0x5043
@@ -491,6 +501,7 @@ struct fe_priv {
         u32 orig_mac[2];
         u32 irqmask;
         u32 desc_ver;
+        u32 txrxctl_bits;
 
         void __iomem *base;
 
@@ -534,7 +545,7 @@ static inline struct fe_priv *get_nvpriv(struct net_device *dev)
 
 static inline u8 __iomem *get_hwbase(struct net_device *dev)
 {
-        return get_nvpriv(dev)->base;
+        return ((struct fe_priv *)netdev_priv(dev))->base;
 }
 
 static inline void pci_push(u8 __iomem *base)
@@ -623,7 +634,7 @@ static int mii_rw(struct net_device *dev, int addr, int miireg, int value)
 
 static int phy_reset(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u32 miicontrol;
         unsigned int tries = 0;
 
@@ -726,7 +737,7 @@ static int phy_init(struct net_device *dev)
 
 static void nv_start_rx(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
 
         dprintk(KERN_DEBUG "%s: nv_start_rx\n", dev->name);
@@ -782,14 +793,14 @@ static void nv_stop_tx(struct net_device *dev)
 
 static void nv_txrx_reset(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
 
         dprintk(KERN_DEBUG "%s: nv_txrx_reset\n", dev->name);
-        writel(NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | np->desc_ver, base + NvRegTxRxControl);
+        writel(NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | np->txrxctl_bits, base + NvRegTxRxControl);
         pci_push(base);
         udelay(NV_TXRX_RESET_DELAY);
-        writel(NVREG_TXRXCTL_BIT2 | np->desc_ver, base + NvRegTxRxControl);
+        writel(NVREG_TXRXCTL_BIT2 | np->txrxctl_bits, base + NvRegTxRxControl);
         pci_push(base);
 }
 
@@ -801,7 +812,7 @@ static void nv_txrx_reset(struct net_device *dev)
  */
 static struct net_device_stats *nv_get_stats(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
 
         /* It seems that the nic always generates interrupts and doesn't
          * accumulate errors internally. Thus the current values in np->stats
@@ -817,7 +828,7 @@ static struct net_device_stats *nv_get_stats(struct net_device *dev)
  */
 static int nv_alloc_rx(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         unsigned int refill_rx = np->refill_rx;
         int nr;
 
@@ -861,7 +872,7 @@ static int nv_alloc_rx(struct net_device *dev)
 static void nv_do_rx_refill(unsigned long data)
 {
         struct net_device *dev = (struct net_device *) data;
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
 
         disable_irq(dev->irq);
         if (nv_alloc_rx(dev)) {
@@ -875,7 +886,7 @@ static void nv_do_rx_refill(unsigned long data)
 
 static void nv_init_rx(struct net_device *dev) 
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         int i;
 
         np->cur_rx = RX_RING;
@@ -889,15 +900,17 @@ static void nv_init_rx(struct net_device *dev)
 
 static void nv_init_tx(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         int i;
 
         np->next_tx = np->nic_tx = 0;
-        for (i = 0; i < TX_RING; i++)
+        for (i = 0; i < TX_RING; i++) {
                 if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
                         np->tx_ring.orig[i].FlagLen = 0;
                 else
                         np->tx_ring.ex[i].FlagLen = 0;
+                np->tx_skbuff[i] = NULL;
+        }
 }
 
 static int nv_init_ring(struct net_device *dev)
@@ -907,21 +920,44 @@ static int nv_init_ring(struct net_device *dev)
         return nv_alloc_rx(dev);
 }
 
+static void nv_release_txskb(struct net_device *dev, unsigned int skbnr)
+{
+        struct fe_priv *np = netdev_priv(dev);
+        struct sk_buff *skb = np->tx_skbuff[skbnr];
+        unsigned int j, entry, fragments;
+                        
+        dprintk(KERN_INFO "%s: nv_release_txskb for skbnr %d, skb %p\n",
+                dev->name, skbnr, np->tx_skbuff[skbnr]);
+        
+        entry = skbnr;
+        if ((fragments = skb_shinfo(skb)->nr_frags) != 0) {
+                for (j = fragments; j >= 1; j--) {
+                        skb_frag_t *frag = &skb_shinfo(skb)->frags[j-1];
+                        pci_unmap_page(np->pci_dev, np->tx_dma[entry],
+                                       frag->size,
+                                       PCI_DMA_TODEVICE);
+                        entry = (entry - 1) % TX_RING;
+                }
+        }
+        pci_unmap_single(np->pci_dev, np->tx_dma[entry],
+                         skb->len - skb->data_len,
+                         PCI_DMA_TODEVICE);
+        dev_kfree_skb_irq(skb);
+        np->tx_skbuff[skbnr] = NULL;
+}
+
 static void nv_drain_tx(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
-        int i;
+        struct fe_priv *np = netdev_priv(dev);
+        unsigned int i;
+        
         for (i = 0; i < TX_RING; i++) {
                 if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
                         np->tx_ring.orig[i].FlagLen = 0;
                 else
                         np->tx_ring.ex[i].FlagLen = 0;
                 if (np->tx_skbuff[i]) {
-                        pci_unmap_single(np->pci_dev, np->tx_dma[i],
-                                                np->tx_skbuff[i]->len,
-                                                PCI_DMA_TODEVICE);
-                        dev_kfree_skb(np->tx_skbuff[i]);
-                        np->tx_skbuff[i] = NULL;
+                        nv_release_txskb(dev, i);
                         np->stats.tx_dropped++;
                 }
         }
@@ -929,7 +965,7 @@ static void nv_drain_tx(struct net_device *dev)
 
 static void nv_drain_rx(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         int i;
         for (i = 0; i < RX_RING; i++) {
                 if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
@@ -959,28 +995,69 @@ static void drain_ring(struct net_device *dev)
  */
 static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
-        int nr = np->next_tx % TX_RING;
+        struct fe_priv *np = netdev_priv(dev);
+        u32 tx_flags_extra = (np->desc_ver == DESC_VER_1 ? NV_TX_LASTPACKET : NV_TX2_LASTPACKET);
+        unsigned int fragments = skb_shinfo(skb)->nr_frags;
+        unsigned int nr = (np->next_tx + fragments) % TX_RING;
+        unsigned int i;
+
+        spin_lock_irq(&np->lock);
+
+        if ((np->next_tx - np->nic_tx + fragments) > TX_LIMIT_STOP) {
+                spin_unlock_irq(&np->lock);
+                netif_stop_queue(dev);
+                return NETDEV_TX_BUSY;
+        }
 
         np->tx_skbuff[nr] = skb;
-        np->tx_dma[nr] = pci_map_single(np->pci_dev, skb->data,skb->len,
-                                        PCI_DMA_TODEVICE);
+        
+        if (fragments) {
+                dprintk(KERN_DEBUG "%s: nv_start_xmit: buffer contains %d fragments\n", dev->name, fragments);
+                /* setup descriptors in reverse order */
+                for (i = fragments; i >= 1; i--) {
+                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
+                        np->tx_dma[nr] = pci_map_page(np->pci_dev, frag->page, frag->page_offset, frag->size,
+                                                        PCI_DMA_TODEVICE);
 
-        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
+                        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) {
+                                np->tx_ring.orig[nr].PacketBuffer = cpu_to_le32(np->tx_dma[nr]);
+                                np->tx_ring.orig[nr].FlagLen = cpu_to_le32( (frag->size-1) | np->tx_flags | tx_flags_extra);
+                        } else {
+                                np->tx_ring.ex[nr].PacketBufferHigh = cpu_to_le64(np->tx_dma[nr]) >> 32;
+                                np->tx_ring.ex[nr].PacketBufferLow = cpu_to_le64(np->tx_dma[nr]) & 0x0FFFFFFFF;
+                                np->tx_ring.ex[nr].FlagLen = cpu_to_le32( (frag->size-1) | np->tx_flags | tx_flags_extra);
+                        }
+                        
+                        nr = (nr - 1) % TX_RING;
+
+                        if (np->desc_ver == DESC_VER_1)
+                                tx_flags_extra &= ~NV_TX_LASTPACKET;
+                        else
+                                tx_flags_extra &= ~NV_TX2_LASTPACKET;           
+                }
+        }
+
+#ifdef NETIF_F_TSO
+        if (skb_shinfo(skb)->tso_size)
+                tx_flags_extra |= NV_TX2_TSO | (skb_shinfo(skb)->tso_size << NV_TX2_TSO_SHIFT);
+        else
+#endif
+        tx_flags_extra |= (skb->ip_summed == CHECKSUM_HW ? (NV_TX2_CHECKSUM_L3|NV_TX2_CHECKSUM_L4) : 0);
+
+        np->tx_dma[nr] = pci_map_single(np->pci_dev, skb->data, skb->len-skb->data_len,
+                                        PCI_DMA_TODEVICE);
+        
+        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) {
                 np->tx_ring.orig[nr].PacketBuffer = cpu_to_le32(np->tx_dma[nr]);
-        else {
+                np->tx_ring.orig[nr].FlagLen = cpu_to_le32( (skb->len-skb->data_len-1) | np->tx_flags | tx_flags_extra);
+        } else {
                 np->tx_ring.ex[nr].PacketBufferHigh = cpu_to_le64(np->tx_dma[nr]) >> 32;
                 np->tx_ring.ex[nr].PacketBufferLow = cpu_to_le64(np->tx_dma[nr]) & 0x0FFFFFFFF;
-        }
+                np->tx_ring.ex[nr].FlagLen = cpu_to_le32( (skb->len-skb->data_len-1) | np->tx_flags | tx_flags_extra);
+        }       
 
-        spin_lock_irq(&np->lock);
-        wmb();
-        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
-                np->tx_ring.orig[nr].FlagLen = cpu_to_le32( (skb->len-1) | np->tx_flags );
-        else
-                np->tx_ring.ex[nr].FlagLen = cpu_to_le32( (skb->len-1) | np->tx_flags );
-        dprintk(KERN_DEBUG "%s: nv_start_xmit: packet packet %d queued for transmission.\n",
-                                dev->name, np->next_tx);
+        dprintk(KERN_DEBUG "%s: nv_start_xmit: packet packet %d queued for transmission. tx_flags_extra: %x\n",
+                                dev->name, np->next_tx, tx_flags_extra);
         {
                 int j;
                 for (j=0; j<64; j++) {
@@ -991,15 +1068,13 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 dprintk("\n");
         }
 
-        np->next_tx++;
+        np->next_tx += 1 + fragments;
 
         dev->trans_start = jiffies;
-        if (np->next_tx - np->nic_tx >= TX_LIMIT_STOP)
-                netif_stop_queue(dev);
         spin_unlock_irq(&np->lock);
-        writel(NVREG_TXRXCTL_KICK|np->desc_ver, get_hwbase(dev) + NvRegTxRxControl);
+        writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl);
         pci_push(get_hwbase(dev));
-        return 0;
+        return NETDEV_TX_OK;
 }
 
 /*
@@ -1009,9 +1084,10 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
  */
 static void nv_tx_done(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u32 Flags;
-        int i;
+        unsigned int i;
+        struct sk_buff *skb;
 
         while (np->nic_tx != np->next_tx) {
                 i = np->nic_tx % TX_RING;
@@ -1026,35 +1102,38 @@ static void nv_tx_done(struct net_device *dev)
                 if (Flags & NV_TX_VALID)
                         break;
                 if (np->desc_ver == DESC_VER_1) {
-                        if (Flags & (NV_TX_RETRYERROR|NV_TX_CARRIERLOST|NV_TX_LATECOLLISION|
-                                                        NV_TX_UNDERFLOW|NV_TX_ERROR)) {
-                                if (Flags & NV_TX_UNDERFLOW)
-                                        np->stats.tx_fifo_errors++;
-                                if (Flags & NV_TX_CARRIERLOST)
-                                        np->stats.tx_carrier_errors++;
-                                np->stats.tx_errors++;
-                        } else {
-                                np->stats.tx_packets++;
-                                np->stats.tx_bytes += np->tx_skbuff[i]->len;
+                        if (Flags & NV_TX_LASTPACKET) {
+                                skb = np->tx_skbuff[i];
+                                if (Flags & (NV_TX_RETRYERROR|NV_TX_CARRIERLOST|NV_TX_LATECOLLISION|
+                                             NV_TX_UNDERFLOW|NV_TX_ERROR)) {
+                                        if (Flags & NV_TX_UNDERFLOW)
+                                                np->stats.tx_fifo_errors++;
+                                        if (Flags & NV_TX_CARRIERLOST)
+                                                np->stats.tx_carrier_errors++;
+                                        np->stats.tx_errors++;
+                                } else {
+                                        np->stats.tx_packets++;
+                                        np->stats.tx_bytes += skb->len;
+                                }
+                                nv_release_txskb(dev, i);
                         }
                 } else {
-                        if (Flags & (NV_TX2_RETRYERROR|NV_TX2_CARRIERLOST|NV_TX2_LATECOLLISION|
-                                                        NV_TX2_UNDERFLOW|NV_TX2_ERROR)) {
-                                if (Flags & NV_TX2_UNDERFLOW)
-                                        np->stats.tx_fifo_errors++;
-                                if (Flags & NV_TX2_CARRIERLOST)
-                                        np->stats.tx_carrier_errors++;
-                                np->stats.tx_errors++;
-                        } else {
-                                np->stats.tx_packets++;
-                                np->stats.tx_bytes += np->tx_skbuff[i]->len;
+                        if (Flags & NV_TX2_LASTPACKET) {
+                                skb = np->tx_skbuff[i];
+                                if (Flags & (NV_TX2_RETRYERROR|NV_TX2_CARRIERLOST|NV_TX2_LATECOLLISION|
+                                             NV_TX2_UNDERFLOW|NV_TX2_ERROR)) {
+                                        if (Flags & NV_TX2_UNDERFLOW)
+                                                np->stats.tx_fifo_errors++;
+                                        if (Flags & NV_TX2_CARRIERLOST)
+                                                np->stats.tx_carrier_errors++;
+                                        np->stats.tx_errors++;
+                                } else {
+                                        np->stats.tx_packets++;
+                                        np->stats.tx_bytes += skb->len;
+                                }                               
+                                nv_release_txskb(dev, i);
                         }
                 }
-                pci_unmap_single(np->pci_dev, np->tx_dma[i],
-                                        np->tx_skbuff[i]->len,
-                                        PCI_DMA_TODEVICE);
-                dev_kfree_skb_irq(np->tx_skbuff[i]);
-                np->tx_skbuff[i] = NULL;
                 np->nic_tx++;
         }
         if (np->next_tx - np->nic_tx < TX_LIMIT_START)
@@ -1067,7 +1146,7 @@ static void nv_tx_done(struct net_device *dev)
  */
 static void nv_tx_timeout(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
 
         printk(KERN_INFO "%s: Got tx_timeout. irq: %08x\n", dev->name,
@@ -1200,7 +1279,7 @@ static int nv_getlen(struct net_device *dev, void *packet, int datalen)
 
 static void nv_rx_process(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u32 Flags;
 
         for (;;) {
@@ -1355,7 +1434,7 @@ static void set_bufsize(struct net_device *dev)
  */
 static int nv_change_mtu(struct net_device *dev, int new_mtu)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         int old_mtu;
 
         if (new_mtu < 64 || new_mtu > np->pkt_limit)
@@ -1408,7 +1487,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                 writel( ((RX_RING-1) << NVREG_RINGSZ_RXSHIFT) + ((TX_RING-1) << NVREG_RINGSZ_TXSHIFT),
                         base + NvRegRingSizes);
                 pci_push(base);
-                writel(NVREG_TXRXCTL_KICK|np->desc_ver, get_hwbase(dev) + NvRegTxRxControl);
+                writel(NVREG_TXRXCTL_KICK|np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl);
                 pci_push(base);
 
                 /* restart rx engine */
@@ -1440,7 +1519,7 @@ static void nv_copy_mac_to_hw(struct net_device *dev)
  */
 static int nv_set_mac_address(struct net_device *dev, void *addr)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         struct sockaddr *macaddr = (struct sockaddr*)addr;
 
         if(!is_valid_ether_addr(macaddr->sa_data))
@@ -1475,7 +1554,7 @@ static int nv_set_mac_address(struct net_device *dev, void *addr)
  */
 static void nv_set_multicast(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
         u32 addr[2];
         u32 mask[2];
@@ -1535,7 +1614,7 @@ static void nv_set_multicast(struct net_device *dev)
 
 static int nv_update_linkspeed(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
         int adv, lpa;
         int newls = np->linkspeed;
@@ -1705,7 +1784,7 @@ static void nv_link_irq(struct net_device *dev)
 static irqreturn_t nv_nic_irq(int foo, void *data, struct pt_regs *regs)
 {
         struct net_device *dev = (struct net_device *) data;
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
         u32 events;
         int i;
@@ -1777,7 +1856,7 @@ static irqreturn_t nv_nic_irq(int foo, void *data, struct pt_regs *regs)
 static void nv_do_nic_poll(unsigned long data)
 {
         struct net_device *dev = (struct net_device *) data;
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
 
         disable_irq(dev->irq);
@@ -1801,7 +1880,7 @@ static void nv_poll_controller(struct net_device *dev)
 
 static void nv_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         strcpy(info->driver, "forcedeth");
         strcpy(info->version, FORCEDETH_VERSION);
         strcpy(info->bus_info, pci_name(np->pci_dev));
@@ -1809,7 +1888,7 @@ static void nv_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 
 static void nv_get_wol(struct net_device *dev, struct ethtool_wolinfo *wolinfo)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         wolinfo->supported = WAKE_MAGIC;
 
         spin_lock_irq(&np->lock);
@@ -1820,7 +1899,7 @@ static void nv_get_wol(struct net_device *dev, struct ethtool_wolinfo *wolinfo)
 
 static int nv_set_wol(struct net_device *dev, struct ethtool_wolinfo *wolinfo)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
 
         spin_lock_irq(&np->lock);
@@ -2021,7 +2100,7 @@ static int nv_get_regs_len(struct net_device *dev)
 
 static void nv_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *buf)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
         u32 *rbuf = buf;
         int i;
@@ -2035,7 +2114,7 @@ static void nv_get_regs(struct net_device *dev, struct ethtool_regs *regs, void
 
 static int nv_nway_reset(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         int ret;
 
         spin_lock_irq(&np->lock);
@@ -2065,11 +2144,12 @@ static struct ethtool_ops ops = {
         .get_regs_len = nv_get_regs_len,
         .get_regs = nv_get_regs,
         .nway_reset = nv_nway_reset,
+        .get_perm_addr = ethtool_op_get_perm_addr,
 };
 
 static int nv_open(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
         int ret, oom, i;
 
@@ -2114,9 +2194,9 @@ static int nv_open(struct net_device *dev)
         /* 5) continue setup */
         writel(np->linkspeed, base + NvRegLinkSpeed);
         writel(NVREG_UNKSETUP3_VAL1, base + NvRegUnknownSetupReg3);
-        writel(np->desc_ver, base + NvRegTxRxControl);
+        writel(np->txrxctl_bits, base + NvRegTxRxControl);
         pci_push(base);
-        writel(NVREG_TXRXCTL_BIT1|np->desc_ver, base + NvRegTxRxControl);
+        writel(NVREG_TXRXCTL_BIT1|np->txrxctl_bits, base + NvRegTxRxControl);
         reg_delay(dev, NvRegUnknownSetupReg5, NVREG_UNKSETUP5_BIT31, NVREG_UNKSETUP5_BIT31,
                         NV_SETUP5_DELAY, NV_SETUP5_DELAYMAX,
                         KERN_INFO "open: SetupReg5, Bit 31 remained off\n");
@@ -2205,7 +2285,7 @@ out_drain:
 
 static int nv_close(struct net_device *dev)
 {
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base;
 
         spin_lock_irq(&np->lock);
@@ -2261,7 +2341,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         if (!dev)
                 goto out;
 
-        np = get_nvpriv(dev);
+        np = netdev_priv(dev);
         np->pci_dev = pci_dev;
         spin_lock_init(&np->lock);
         SET_MODULE_OWNER(dev);
@@ -2313,19 +2393,32 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                 if (pci_set_dma_mask(pci_dev, 0x0000007fffffffffULL)) {
                         printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n",
                                         pci_name(pci_dev));
+                } else {
+                        dev->features |= NETIF_F_HIGHDMA;
                 }
+                np->txrxctl_bits = NVREG_TXRXCTL_DESC_3;
         } else if (id->driver_data & DEV_HAS_LARGEDESC) {
                 /* packet format 2: supports jumbo frames */
                 np->desc_ver = DESC_VER_2;
+                np->txrxctl_bits = NVREG_TXRXCTL_DESC_2;
         } else {
                 /* original packet format */
                 np->desc_ver = DESC_VER_1;
+                np->txrxctl_bits = NVREG_TXRXCTL_DESC_1;
         }
 
         np->pkt_limit = NV_PKTLIMIT_1;
         if (id->driver_data & DEV_HAS_LARGEDESC)
                 np->pkt_limit = NV_PKTLIMIT_2;
 
+        if (id->driver_data & DEV_HAS_CHECKSUM) {
+                np->txrxctl_bits |= NVREG_TXRXCTL_RXCHECK;
+                dev->features |= NETIF_F_HW_CSUM | NETIF_F_SG;
+#ifdef NETIF_F_TSO
+                dev->features |= NETIF_F_TSO;
+#endif
+        }
+
         err = -ENOMEM;
         np->base = ioremap(addr, NV_PCI_REGSZ);
         if (!np->base)
@@ -2377,8 +2470,9 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         dev->dev_addr[3] = (np->orig_mac[0] >> 16) & 0xff;
         dev->dev_addr[4] = (np->orig_mac[0] >>  8) & 0xff;
         dev->dev_addr[5] = (np->orig_mac[0] >>  0) & 0xff;
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
-        if (!is_valid_ether_addr(dev->dev_addr)) {
+        if (!is_valid_ether_addr(dev->perm_addr)) {
                 /*
                  * Bad mac address. At least one bios sets the mac address
                  * to 01:23:45:67:89:ab
@@ -2403,9 +2497,9 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         np->wolenabled = 0;
 
         if (np->desc_ver == DESC_VER_1) {
-                np->tx_flags = NV_TX_LASTPACKET|NV_TX_VALID;
+                np->tx_flags = NV_TX_VALID;
         } else {
-                np->tx_flags = NV_TX2_LASTPACKET|NV_TX2_VALID;
+                np->tx_flags = NV_TX2_VALID;
         }
         np->irqmask = NVREG_IRQMASK_WANTED;
         if (id->driver_data & DEV_NEED_TIMERIRQ)
@@ -2494,7 +2588,7 @@ out:
 static void __devexit nv_remove(struct pci_dev *pci_dev)
 {
         struct net_device *dev = pci_get_drvdata(pci_dev);
-        struct fe_priv *np = get_nvpriv(dev);
+        struct fe_priv *np = netdev_priv(dev);
 
         unregister_netdev(dev);
 
@@ -2525,35 +2619,35 @@ static struct pci_device_id pci_tbl[] = {
         },
         {       /* nForce3 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_4),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM,
         },
         {       /* nForce3 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_5),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM,
         },
         {       /* nForce3 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_6),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM,
         },
         {       /* nForce3 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_7),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM,
         },
         {       /* CK804 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_8),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {       /* CK804 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_9),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {       /* MCP04 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_10),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {       /* MCP04 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_11),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {       /* MCP51 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_12),
@@ -2565,11 +2659,11 @@ static struct pci_device_id pci_tbl[] = {
         },
         {       /* MCP55 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_14),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {       /* MCP55 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_15),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
         },
         {0,},
 };
diff --git a/drivers/net/fs_enet/Kconfig b/drivers/net/fs_enet/Kconfig
new file mode 100644
index 000000000000..6aaee67dd4b7
--- /dev/null
+++ b/drivers/net/fs_enet/Kconfig
@@ -0,0 +1,20 @@
+config FS_ENET
+       tristate "Freescale Ethernet Driver"
+       depends on NET_ETHERNET && (CPM1 || CPM2)
+       select MII
+
+config FS_ENET_HAS_SCC
+        bool "Chip has an SCC usable for ethernet"
+        depends on FS_ENET && (CPM1 || CPM2)
+        default y
+
+config FS_ENET_HAS_FCC
+        bool "Chip has an FCC usable for ethernet"
+        depends on FS_ENET && CPM2
+        default y
+
+config FS_ENET_HAS_FEC
+        bool "Chip has an FEC usable for ethernet"
+        depends on FS_ENET && CPM1
+        default y
+
diff --git a/drivers/net/fs_enet/Makefile b/drivers/net/fs_enet/Makefile
new file mode 100644
index 000000000000..d6dd3f2fb43e
--- /dev/null
+++ b/drivers/net/fs_enet/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for the Freescale Ethernet controllers
+#
+
+obj-$(CONFIG_FS_ENET) += fs_enet.o
+
+obj-$(CONFIG_8xx) += mac-fec.o mac-scc.o
+obj-$(CONFIG_8260) += mac-fcc.o
+
+fs_enet-objs := fs_enet-main.o fs_enet-mii.o mii-bitbang.o mii-fixed.o
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
new file mode 100644
index 000000000000..44fac7373289
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -0,0 +1,1226 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
+ * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <linux/vmalloc.h>
+#include <asm/pgtable.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+static char version[] __devinitdata =
+    DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
+
+MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
+MODULE_DESCRIPTION("Freescale Ethernet Driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_MODULE_VERSION);
+
+MODULE_PARM(fs_enet_debug, "i");
+MODULE_PARM_DESC(fs_enet_debug,
+                 "Freescale bitmapped debugging message enable value");
+
+int fs_enet_debug = -1;         /* -1 == use FS_ENET_DEF_MSG_ENABLE as value */
+
+static void fs_set_multicast_list(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        (*fep->ops->set_multicast_list)(dev);
+}
+
+/* NAPI receive function */
+static int fs_enet_rx_napi(struct net_device *dev, int *budget)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        cbd_t *bdp;
+        struct sk_buff *skb, *skbn, *skbt;
+        int received = 0;
+        u16 pkt_len, sc;
+        int curidx;
+        int rx_work_limit = 0;  /* pacify gcc */
+
+        rx_work_limit = min(dev->quota, *budget);
+
+        if (!netif_running(dev))
+                return 0;
+
+        /*
+         * First, grab all of the stats for the incoming packet.
+         * These get messed up if we get called due to a busy condition.
+         */
+        bdp = fep->cur_rx;
+
+        /* clear RX status bits for napi*/
+        (*fep->ops->napi_clear_rx_event)(dev);
+
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
+
+                curidx = bdp - fep->rx_bd_base;
+
+                /*
+                 * Since we have allocated space to hold a complete frame,
+                 * the last indicator should be set.
+                 */
+                if ((sc & BD_ENET_RX_LAST) == 0)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s rcv is not +last\n",
+                               dev->name);
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
+                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
+                        fep->stats.rx_errors++;
+                        /* Frame too long or too short. */
+                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
+                                fep->stats.rx_length_errors++;
+                        /* Frame alignment */
+                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+                                fep->stats.rx_frame_errors++;
+                        /* CRC Error */
+                        if (sc & BD_ENET_RX_CR)
+                                fep->stats.rx_crc_errors++;
+                        /* FIFO overrun */
+                        if (sc & BD_ENET_RX_OV)
+                                fep->stats.rx_crc_errors++;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        skbn = skb;
+
+                } else {
+
+                        /* napi, got packet but no quota */
+                        if (--rx_work_limit < 0)
+                                break;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        /*
+                         * Process the incoming frame.
+                         */
+                        fep->stats.rx_packets++;
+                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
+                        fep->stats.rx_bytes += pkt_len + 4;
+
+                        if (pkt_len <= fpi->rx_copybreak) {
+                                /* +2 to make IP header L1 cache aligned */
+                                skbn = dev_alloc_skb(pkt_len + 2);
+                                if (skbn != NULL) {
+                                        skb_reserve(skbn, 2);   /* align IP header */
+                                        memcpy(skbn->data, skb->data, pkt_len);
+                                        /* swap */
+                                        skbt = skb;
+                                        skb = skbn;
+                                        skbn = skbt;
+                                }
+                        } else
+                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
+
+                        if (skbn != NULL) {
+                                skb->dev = dev;
+                                skb_put(skb, pkt_len);  /* Make room */
+                                skb->protocol = eth_type_trans(skb, dev);
+                                received++;
+                                netif_receive_skb(skb);
+                        } else {
+                                printk(KERN_WARNING DRV_MODULE_NAME
+                                       ": %s Memory squeeze, dropping packet.\n",
+                                       dev->name);
+                                fep->stats.rx_dropped++;
+                                skbn = skb;
+                        }
+                }
+
+                fep->rx_skbuff[curidx] = skbn;
+                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
+                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                             DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
+
+                /*
+                 * Update BD pointer to next entry. 
+                 */
+                if ((sc & BD_ENET_RX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->rx_bd_base;
+
+                (*fep->ops->rx_bd_done)(dev);
+        }
+
+        fep->cur_rx = bdp;
+
+        dev->quota -= received;
+        *budget -= received;
+
+        if (rx_work_limit < 0)
+                return 1;       /* not done */
+
+        /* done */
+        netif_rx_complete(dev);
+
+        (*fep->ops->napi_enable_rx)(dev);
+
+        return 0;
+}
+
+/* non NAPI receive function */
+static int fs_enet_rx_non_napi(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        cbd_t *bdp;
+        struct sk_buff *skb, *skbn, *skbt;
+        int received = 0;
+        u16 pkt_len, sc;
+        int curidx;
+        /*
+         * First, grab all of the stats for the incoming packet.
+         * These get messed up if we get called due to a busy condition.
+         */
+        bdp = fep->cur_rx;
+
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
+
+                curidx = bdp - fep->rx_bd_base;
+
+                /*
+                 * Since we have allocated space to hold a complete frame,
+                 * the last indicator should be set.
+                 */
+                if ((sc & BD_ENET_RX_LAST) == 0)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s rcv is not +last\n",
+                               dev->name);
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
+                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
+                        fep->stats.rx_errors++;
+                        /* Frame too long or too short. */
+                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
+                                fep->stats.rx_length_errors++;
+                        /* Frame alignment */
+                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+                                fep->stats.rx_frame_errors++;
+                        /* CRC Error */
+                        if (sc & BD_ENET_RX_CR)
+                                fep->stats.rx_crc_errors++;
+                        /* FIFO overrun */
+                        if (sc & BD_ENET_RX_OV)
+                                fep->stats.rx_crc_errors++;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        skbn = skb;
+
+                } else {
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        /*
+                         * Process the incoming frame.
+                         */
+                        fep->stats.rx_packets++;
+                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
+                        fep->stats.rx_bytes += pkt_len + 4;
+
+                        if (pkt_len <= fpi->rx_copybreak) {
+                                /* +2 to make IP header L1 cache aligned */
+                                skbn = dev_alloc_skb(pkt_len + 2);
+                                if (skbn != NULL) {
+                                        skb_reserve(skbn, 2);   /* align IP header */
+                                        memcpy(skbn->data, skb->data, pkt_len);
+                                        /* swap */
+                                        skbt = skb;
+                                        skb = skbn;
+                                        skbn = skbt;
+                                }
+                        } else
+                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
+
+                        if (skbn != NULL) {
+                                skb->dev = dev;
+                                skb_put(skb, pkt_len);  /* Make room */
+                                skb->protocol = eth_type_trans(skb, dev);
+                                received++;
+                                netif_rx(skb);
+                        } else {
+                                printk(KERN_WARNING DRV_MODULE_NAME
+                                       ": %s Memory squeeze, dropping packet.\n",
+                                       dev->name);
+                                fep->stats.rx_dropped++;
+                                skbn = skb;
+                        }
+                }
+
+                fep->rx_skbuff[curidx] = skbn;
+                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
+                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                             DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
+
+                /*
+                 * Update BD pointer to next entry. 
+                 */
+                if ((sc & BD_ENET_RX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->rx_bd_base;
+
+                (*fep->ops->rx_bd_done)(dev);
+        }
+
+        fep->cur_rx = bdp;
+
+        return 0;
+}
+
+static void fs_enet_tx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        struct sk_buff *skb;
+        int dirtyidx, do_wake, do_restart;
+        u16 sc;
+
+        spin_lock(&fep->lock);
+        bdp = fep->dirty_tx;
+
+        do_wake = do_restart = 0;
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
+
+                dirtyidx = bdp - fep->tx_bd_base;
+
+                if (fep->tx_free == fep->tx_ring)
+                        break;
+
+                skb = fep->tx_skbuff[dirtyidx];
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
+                          BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
+
+                        if (sc & BD_ENET_TX_HB) /* No heartbeat */
+                                fep->stats.tx_heartbeat_errors++;
+                        if (sc & BD_ENET_TX_LC) /* Late collision */
+                                fep->stats.tx_window_errors++;
+                        if (sc & BD_ENET_TX_RL) /* Retrans limit */
+                                fep->stats.tx_aborted_errors++;
+                        if (sc & BD_ENET_TX_UN) /* Underrun */
+                                fep->stats.tx_fifo_errors++;
+                        if (sc & BD_ENET_TX_CSL)        /* Carrier lost */
+                                fep->stats.tx_carrier_errors++;
+
+                        if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
+                                fep->stats.tx_errors++;
+                                do_restart = 1;
+                        }
+                } else
+                        fep->stats.tx_packets++;
+
+                if (sc & BD_ENET_TX_READY)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s HEY! Enet xmit interrupt and TX_READY.\n",
+                               dev->name);
+
+                /*
+                 * Deferred means some collisions occurred during transmit,
+                 * but we eventually sent the packet OK.
+                 */
+                if (sc & BD_ENET_TX_DEF)
+                        fep->stats.collisions++;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data, skb->len, DMA_TO_DEVICE);
+
+                /*
+                 * Free the sk buffer associated with this last transmit. 
+                 */
+                dev_kfree_skb_irq(skb);
+                fep->tx_skbuff[dirtyidx] = NULL;
+
+                /*
+                 * Update pointer to next buffer descriptor to be transmitted. 
+                 */
+                if ((sc & BD_ENET_TX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->tx_bd_base;
+
+                /*
+                 * Since we have freed up a buffer, the ring is no longer
+                 * full.
+                 */
+                if (!fep->tx_free++)
+                        do_wake = 1;
+        }
+
+        fep->dirty_tx = bdp;
+
+        if (do_restart)
+                (*fep->ops->tx_restart)(dev);
+
+        spin_unlock(&fep->lock);
+
+        if (do_wake)
+                netif_wake_queue(dev);
+}
+
+/*
+ * The interrupt handler.
+ * This is called from the MPC core interrupt.
+ */
+static irqreturn_t
+fs_enet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+        u32 int_events;
+        u32 int_clr_events;
+        int nr, napi_ok;
+        int handled;
+
+        fep = netdev_priv(dev);
+        fpi = fep->fpi;
+
+        nr = 0;
+        while ((int_events = (*fep->ops->get_int_events)(dev)) != 0) {
+
+                nr++;
+
+                int_clr_events = int_events;
+                if (fpi->use_napi)
+                        int_clr_events &= ~fep->ev_napi_rx;
+
+                (*fep->ops->clear_int_events)(dev, int_clr_events);
+
+                if (int_events & fep->ev_err)
+                        (*fep->ops->ev_error)(dev, int_events);
+
+                if (int_events & fep->ev_rx) {
+                        if (!fpi->use_napi)
+                                fs_enet_rx_non_napi(dev);
+                        else {
+                                napi_ok = netif_rx_schedule_prep(dev);
+
+                                (*fep->ops->napi_disable_rx)(dev);
+                                (*fep->ops->clear_int_events)(dev, fep->ev_napi_rx);
+
+                                /* NOTE: it is possible for FCCs in NAPI mode    */
+                                /* to submit a spurious interrupt while in poll  */
+                                if (napi_ok)
+                                        __netif_rx_schedule(dev);
+                        }
+                }
+
+                if (int_events & fep->ev_tx)
+                        fs_enet_tx(dev);
+        }
+
+        handled = nr > 0;
+        return IRQ_RETVAL(handled);
+}
+
+void fs_init_bds(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        struct sk_buff *skb;
+        int i;
+
+        fs_cleanup_bds(dev);
+
+        fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
+        fep->tx_free = fep->tx_ring;
+        fep->cur_rx = fep->rx_bd_base;
+
+        /*
+         * Initialize the receive buffer descriptors. 
+         */
+        for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
+                skb = dev_alloc_skb(ENET_RX_FRSIZE);
+                if (skb == NULL) {
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s Memory squeeze, unable to allocate skb\n",
+                               dev->name);
+                        break;
+                }
+                fep->rx_skbuff[i] = skb;
+                skb->dev = dev;
+                CBDW_BUFADDR(bdp,
+                        dma_map_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);    /* zero */
+                CBDW_SC(bdp, BD_ENET_RX_EMPTY |
+                        ((i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP));
+        }
+        /*
+         * if we failed, fillup remainder 
+         */
+        for (; i < fep->rx_ring; i++, bdp++) {
+                fep->rx_skbuff[i] = NULL;
+                CBDW_SC(bdp, (i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP);
+        }
+
+        /*
+         * ...and the same for transmit.  
+         */
+        for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
+                fep->tx_skbuff[i] = NULL;
+                CBDW_BUFADDR(bdp, 0);
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (i < fep->tx_ring - 1) ? 0 : BD_SC_WRAP);
+        }
+}
+
+void fs_cleanup_bds(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct sk_buff *skb;
+        int i;
+
+        /*
+         * Reset SKB transmit buffers.  
+         */
+        for (i = 0; i < fep->tx_ring; i++) {
+                if ((skb = fep->tx_skbuff[i]) == NULL)
+                        continue;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data, skb->len, DMA_TO_DEVICE);
+
+                fep->tx_skbuff[i] = NULL;
+                dev_kfree_skb(skb);
+        }
+
+        /*
+         * Reset SKB receive buffers 
+         */
+        for (i = 0; i < fep->rx_ring; i++) {
+                if ((skb = fep->rx_skbuff[i]) == NULL)
+                        continue;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data,
+                        L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                        DMA_FROM_DEVICE);
+
+                fep->rx_skbuff[i] = NULL;
+
+                dev_kfree_skb(skb);
+        }
+}
+
+/**********************************************************************************/
+
+static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        int curidx;
+        u16 sc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fep->tx_lock, flags);
+
+        /*
+         * Fill in a Tx ring entry 
+         */
+        bdp = fep->cur_tx;
+
+        if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
+                netif_stop_queue(dev);
+                spin_unlock_irqrestore(&fep->tx_lock, flags);
+
+                /*
+                 * Ooops.  All transmit buffers are full.  Bail out.
+                 * This should not happen, since the tx queue should be stopped.
+                 */
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s tx queue full!.\n", dev->name);
+                return NETDEV_TX_BUSY;
+        }
+
+        curidx = bdp - fep->tx_bd_base;
+        /*
+         * Clear all of the status flags. 
+         */
+        CBDC_SC(bdp, BD_ENET_TX_STATS);
+
+        /*
+         * Save skb pointer. 
+         */
+        fep->tx_skbuff[curidx] = skb;
+
+        fep->stats.tx_bytes += skb->len;
+
+        /*
+         * Push the data cache so the CPM does not get stale memory data. 
+         */
+        CBDW_BUFADDR(bdp, dma_map_single(fep->dev,
+                                skb->data, skb->len, DMA_TO_DEVICE));
+        CBDW_DATLEN(bdp, skb->len);
+
+        dev->trans_start = jiffies;
+
+        /*
+         * If this was the last BD in the ring, start at the beginning again. 
+         */
+        if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
+                fep->cur_tx++;
+        else
+                fep->cur_tx = fep->tx_bd_base;
+
+        if (!--fep->tx_free)
+                netif_stop_queue(dev);
+
+        /* Trigger transmission start */
+        sc = BD_ENET_TX_READY | BD_ENET_TX_INTR |
+             BD_ENET_TX_LAST | BD_ENET_TX_TC;
+
+        /* note that while FEC does not have this bit
+         * it marks it as available for software use
+         * yay for hw reuse :) */
+        if (skb->len <= 60)
+                sc |= BD_ENET_TX_PAD;
+        CBDS_SC(bdp, sc);
+
+        (*fep->ops->tx_kickstart)(dev);
+
+        spin_unlock_irqrestore(&fep->tx_lock, flags);
+
+        return NETDEV_TX_OK;
+}
+
+static int fs_request_irq(struct net_device *dev, int irq, const char *name,
+                irqreturn_t (*irqf)(int irq, void *dev_id, struct pt_regs *regs))
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        (*fep->ops->pre_request_irq)(dev, irq);
+        return request_irq(irq, irqf, SA_SHIRQ, name, dev);
+}
+
+static void fs_free_irq(struct net_device *dev, int irq)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        free_irq(irq, dev);
+        (*fep->ops->post_free_irq)(dev, irq);
+}
+
+/**********************************************************************************/
+
+/* This interrupt occurs when the PHY detects a link change. */
+static irqreturn_t
+fs_mii_link_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+
+        fep = netdev_priv(dev);
+        fpi = fep->fpi;
+
+        /*
+         * Acknowledge the interrupt if possible. If we have not
+         * found the PHY yet we can't process or acknowledge the
+         * interrupt now. Instead we ignore this interrupt for now,
+         * which we can do since it is edge triggered. It will be
+         * acknowledged later by fs_enet_open().
+         */
+        if (!fep->phy)
+                return IRQ_NONE;
+
+        fs_mii_ack_int(dev);
+        fs_mii_link_status_change_check(dev, 0);
+
+        return IRQ_HANDLED;
+}
+
+static void fs_timeout(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int wake = 0;
+
+        fep->stats.tx_errors++;
+
+        spin_lock_irqsave(&fep->lock, flags);
+
+        if (dev->flags & IFF_UP) {
+                (*fep->ops->stop)(dev);
+                (*fep->ops->restart)(dev);
+        }
+
+        wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        if (wake)
+                netif_wake_queue(dev);
+}
+
+static int fs_enet_open(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        int r;
+
+        /* Install our interrupt handler. */
+        r = fs_request_irq(dev, fep->interrupt, "fs_enet-mac", fs_enet_interrupt);
+        if (r != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s Could not allocate FEC IRQ!", dev->name);
+                return -EINVAL;
+        }
+
+        /* Install our phy interrupt handler */
+        if (fpi->phy_irq != -1) {
+
+                r = fs_request_irq(dev, fpi->phy_irq, "fs_enet-phy", fs_mii_link_interrupt);
+                if (r != 0) {
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s Could not allocate PHY IRQ!", dev->name);
+                        fs_free_irq(dev, fep->interrupt);
+                        return -EINVAL;
+                }
+        }
+
+        fs_mii_startup(dev);
+        netif_carrier_off(dev);
+        fs_mii_link_status_change_check(dev, 1);
+
+        return 0;
+}
+
+static int fs_enet_close(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        unsigned long flags;
+
+        netif_stop_queue(dev);
+        netif_carrier_off(dev);
+        fs_mii_shutdown(dev);
+
+        spin_lock_irqsave(&fep->lock, flags);
+        (*fep->ops->stop)(dev);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        /* release any irqs */
+        if (fpi->phy_irq != -1)
+                fs_free_irq(dev, fpi->phy_irq);
+        fs_free_irq(dev, fep->interrupt);
+
+        return 0;
+}
+
+static struct net_device_stats *fs_enet_get_stats(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return &fep->stats;
+}
+
+/*************************************************************************/
+
+static void fs_get_drvinfo(struct net_device *dev,
+                            struct ethtool_drvinfo *info)
+{
+        strcpy(info->driver, DRV_MODULE_NAME);
+        strcpy(info->version, DRV_MODULE_VERSION);
+}
+
+static int fs_get_regs_len(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        return (*fep->ops->get_regs_len)(dev);
+}
+
+static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
+                         void *p)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int r, len;
+
+        len = regs->len;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        r = (*fep->ops->get_regs)(dev, p, &len);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        if (r == 0)
+                regs->version = 0;
+}
+
+static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = mii_ethtool_gset(&fep->mii_if, cmd);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        return rc;
+}
+
+static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = mii_ethtool_sset(&fep->mii_if, cmd);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        return rc;
+}
+
+static int fs_nway_reset(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return mii_nway_restart(&fep->mii_if);
+}
+
+static u32 fs_get_msglevel(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return fep->msg_enable;
+}
+
+static void fs_set_msglevel(struct net_device *dev, u32 value)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fep->msg_enable = value;
+}
+
+static struct ethtool_ops fs_ethtool_ops = {
+        .get_drvinfo = fs_get_drvinfo,
+        .get_regs_len = fs_get_regs_len,
+        .get_settings = fs_get_settings,
+        .set_settings = fs_set_settings,
+        .nway_reset = fs_nway_reset,
+        .get_link = ethtool_op_get_link,
+        .get_msglevel = fs_get_msglevel,
+        .set_msglevel = fs_set_msglevel,
+        .get_tx_csum = ethtool_op_get_tx_csum,
+        .set_tx_csum = ethtool_op_set_tx_csum,  /* local! */
+        .get_sg = ethtool_op_get_sg,
+        .set_sg = ethtool_op_set_sg,
+        .get_regs = fs_get_regs,
+};
+
+static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
+        unsigned long flags;
+        int rc;
+
+        if (!netif_running(dev))
+                return -EINVAL;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = generic_mii_ioctl(&fep->mii_if, mii, cmd, NULL);
+        spin_unlock_irqrestore(&fep->lock, flags);
+        return rc;
+}
+
+extern int fs_mii_connect(struct net_device *dev);
+extern void fs_mii_disconnect(struct net_device *dev);
+
+static struct net_device *fs_init_instance(struct device *dev,
+                const struct fs_platform_info *fpi)
+{
+        struct net_device *ndev = NULL;
+        struct fs_enet_private *fep = NULL;
+        int privsize, i, r, err = 0, registered = 0;
+
+        /* guard */
+        if ((unsigned int)fpi->fs_no >= FS_MAX_INDEX)
+                return ERR_PTR(-EINVAL);
+
+        privsize = sizeof(*fep) + (sizeof(struct sk_buff **) *
+                            (fpi->rx_ring + fpi->tx_ring));
+
+        ndev = alloc_etherdev(privsize);
+        if (!ndev) {
+                err = -ENOMEM;
+                goto err;
+        }
+        SET_MODULE_OWNER(ndev);
+
+        fep = netdev_priv(ndev);
+        memset(fep, 0, privsize);       /* clear everything */
+
+        fep->dev = dev;
+        dev_set_drvdata(dev, ndev);
+        fep->fpi = fpi;
+        if (fpi->init_ioports)
+                fpi->init_ioports();
+
+#ifdef CONFIG_FS_ENET_HAS_FEC
+        if (fs_get_fec_index(fpi->fs_no) >= 0)
+                fep->ops = &fs_fec_ops;
+#endif
+
+#ifdef CONFIG_FS_ENET_HAS_SCC
+        if (fs_get_scc_index(fpi->fs_no) >=0 )
+                fep->ops = &fs_scc_ops;
+#endif
+
+#ifdef CONFIG_FS_ENET_HAS_FCC
+        if (fs_get_fcc_index(fpi->fs_no) >= 0)
+                fep->ops = &fs_fcc_ops;
+#endif
+
+        if (fep->ops == NULL) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s No matching ops found (%d).\n",
+                       ndev->name, fpi->fs_no);
+                err = -EINVAL;
+                goto err;
+        }
+
+        r = (*fep->ops->setup_data)(ndev);
+        if (r != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s setup_data failed\n",
+                        ndev->name);
+                err = r;
+                goto err;
+        }
+
+        /* point rx_skbuff, tx_skbuff */
+        fep->rx_skbuff = (struct sk_buff **)&fep[1];
+        fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
+
+        /* init locks */
+        spin_lock_init(&fep->lock);
+        spin_lock_init(&fep->tx_lock);
+
+        /*
+         * Set the Ethernet address. 
+         */
+        for (i = 0; i < 6; i++)
+                ndev->dev_addr[i] = fpi->macaddr[i];
+        
+        r = (*fep->ops->allocate_bd)(ndev);
+        
+        if (fep->ring_base == NULL) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s buffer descriptor alloc failed (%d).\n", ndev->name, r);
+                err = r;
+                goto err;
+        }
+
+        /*
+         * Set receive and transmit descriptor base.
+         */
+        fep->rx_bd_base = fep->ring_base;
+        fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
+
+        /* initialize ring size variables */
+        fep->tx_ring = fpi->tx_ring;
+        fep->rx_ring = fpi->rx_ring;
+
+        /*
+         * The FEC Ethernet specific entries in the device structure. 
+         */
+        ndev->open = fs_enet_open;
+        ndev->hard_start_xmit = fs_enet_start_xmit;
+        ndev->tx_timeout = fs_timeout;
+        ndev->watchdog_timeo = 2 * HZ;
+        ndev->stop = fs_enet_close;
+        ndev->get_stats = fs_enet_get_stats;
+        ndev->set_multicast_list = fs_set_multicast_list;
+        if (fpi->use_napi) {
+                ndev->poll = fs_enet_rx_napi;
+                ndev->weight = fpi->napi_weight;
+        }
+        ndev->ethtool_ops = &fs_ethtool_ops;
+        ndev->do_ioctl = fs_ioctl;
+
+        init_timer(&fep->phy_timer_list);
+
+        netif_carrier_off(ndev);
+
+        err = register_netdev(ndev);
+        if (err != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s register_netdev failed.\n", ndev->name);
+                goto err;
+        }
+        registered = 1;
+
+        err = fs_mii_connect(ndev);
+        if (err != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s fs_mii_connect failed.\n", ndev->name);
+                goto err;
+        }
+
+        return ndev;
+
+      err:
+        if (ndev != NULL) {
+
+                if (registered)
+                        unregister_netdev(ndev);
+
+                if (fep != NULL) {
+                        (*fep->ops->free_bd)(ndev);
+                        (*fep->ops->cleanup_data)(ndev);
+                }
+
+                free_netdev(ndev);
+        }
+
+        dev_set_drvdata(dev, NULL);
+
+        return ERR_PTR(err);
+}
+
+static int fs_cleanup_instance(struct net_device *ndev)
+{
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+        struct device *dev;
+
+        if (ndev == NULL)
+                return -EINVAL;
+
+        fep = netdev_priv(ndev);
+        if (fep == NULL)
+                return -EINVAL;
+
+        fpi = fep->fpi;
+
+        fs_mii_disconnect(ndev);
+
+        unregister_netdev(ndev);
+
+        dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
+                          fep->ring_base, fep->ring_mem_addr);
+
+        /* reset it */
+        (*fep->ops->cleanup_data)(ndev);
+
+        dev = fep->dev;
+        if (dev != NULL) {
+                dev_set_drvdata(dev, NULL);
+                fep->dev = NULL;
+        }
+
+        free_netdev(ndev);
+
+        return 0;
+}
+
+/**************************************************************************************/
+
+/* handy pointer to the immap */
+void *fs_enet_immap = NULL;
+
+static int setup_immap(void)
+{
+        phys_addr_t paddr = 0;
+        unsigned long size = 0;
+
+#ifdef CONFIG_CPM1
+        paddr = IMAP_ADDR;
+        size = 0x10000; /* map 64K */
+#endif
+
+#ifdef CONFIG_CPM2
+        paddr = CPM_MAP_ADDR;
+        size = 0x40000; /* map 256 K */
+#endif
+        fs_enet_immap = ioremap(paddr, size);
+        if (fs_enet_immap == NULL)
+                return -EBADF;  /* XXX ahem; maybe just BUG_ON? */
+
+        return 0;
+}
+
+static void cleanup_immap(void)
+{
+        if (fs_enet_immap != NULL) {
+                iounmap(fs_enet_immap);
+                fs_enet_immap = NULL;
+        }
+}
+
+/**************************************************************************************/
+
+static int __devinit fs_enet_probe(struct device *dev)
+{
+        struct net_device *ndev;
+
+        /* no fixup - no device */
+        if (dev->platform_data == NULL) {
+                printk(KERN_INFO "fs_enet: "
+                                "probe called with no platform data; "
+                                "remove unused devices\n");
+                return -ENODEV;
+        }
+
+        ndev = fs_init_instance(dev, dev->platform_data);
+        if (IS_ERR(ndev))
+                return PTR_ERR(ndev);
+        return 0;
+}
+
+static int fs_enet_remove(struct device *dev)
+{
+        return fs_cleanup_instance(dev_get_drvdata(dev));
+}
+
+static struct device_driver fs_enet_fec_driver = {
+        .name           = "fsl-cpm-fec",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static struct device_driver fs_enet_scc_driver = {
+        .name           = "fsl-cpm-scc",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static struct device_driver fs_enet_fcc_driver = {
+        .name           = "fsl-cpm-fcc",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static int __init fs_init(void)
+{
+        int r;
+
+        printk(KERN_INFO
+                        "%s", version);
+
+        r = setup_immap();
+        if (r != 0)
+                return r;
+        r = driver_register(&fs_enet_fec_driver);
+        if (r != 0)
+                goto err;
+
+        r = driver_register(&fs_enet_fcc_driver);
+        if (r != 0)
+                goto err;
+
+        r = driver_register(&fs_enet_scc_driver);
+        if (r != 0)
+                goto err;
+
+        return 0;
+err:
+        cleanup_immap();
+        return r;
+        
+}
+
+static void __exit fs_cleanup(void)
+{
+        driver_unregister(&fs_enet_fec_driver);
+        driver_unregister(&fs_enet_fcc_driver);
+        driver_unregister(&fs_enet_scc_driver);
+        cleanup_immap();
+}
+
+/**************************************************************************************/
+
+module_init(fs_init);
+module_exit(fs_cleanup);
diff --git a/drivers/net/fs_enet/fs_enet-mii.c b/drivers/net/fs_enet/fs_enet-mii.c
new file mode 100644
index 000000000000..c6770377ef87
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet-mii.c
@@ -0,0 +1,507 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
+ * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+/*
+ * Generic PHY support.
+ * Should work for all PHYs, but link change is detected by polling
+ */
+
+static void generic_timer_callback(unsigned long data)
+{
+        struct net_device *dev = (struct net_device *)data;
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->phy_timer_list.expires = jiffies + HZ / 2;
+
+        add_timer(&fep->phy_timer_list);
+
+        fs_mii_link_status_change_check(dev, 0);
+}
+
+static void generic_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->phy_timer_list.expires = jiffies + HZ / 2; /* every 500ms */
+        fep->phy_timer_list.data = (unsigned long)dev;
+        fep->phy_timer_list.function = generic_timer_callback;
+        add_timer(&fep->phy_timer_list);
+}
+
+static void generic_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        del_timer_sync(&fep->phy_timer_list);
+}
+
+/* ------------------------------------------------------------------------- */
+/* The Davicom DM9161 is used on the NETTA board                             */
+
+/* register definitions */
+
+#define MII_DM9161_ANAR         4       /* Aux. Config Register         */
+#define MII_DM9161_ACR          16      /* Aux. Config Register         */
+#define MII_DM9161_ACSR         17      /* Aux. Config/Status Register  */
+#define MII_DM9161_10TCSR       18      /* 10BaseT Config/Status Reg.   */
+#define MII_DM9161_INTR         21      /* Interrupt Register           */
+#define MII_DM9161_RECR         22      /* Receive Error Counter Reg.   */
+#define MII_DM9161_DISCR        23      /* Disconnect Counter Register  */
+
+static void dm9161_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0000);
+        /* Start autonegotiation */
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_BMCR, 0x1200);
+
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        schedule_timeout(HZ*8);
+}
+
+static void dm9161_ack_int(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_read(dev, fep->mii_if.phy_id, MII_DM9161_INTR);
+}
+
+static void dm9161_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0f00);
+}
+
+/**********************************************************************************/
+
+static const struct phy_info phy_info[] = {
+        {
+                .id = 0x00181b88,
+                .name = "DM9161",
+                .startup = dm9161_startup,
+                .ack_int = dm9161_ack_int,
+                .shutdown = dm9161_shutdown,
+        }, {
+                .id = 0,
+                .name = "GENERIC",
+                .startup = generic_startup,
+                .shutdown = generic_shutdown,
+        },
+};
+
+/**********************************************************************************/
+
+static int phy_id_detect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        int i, r, start, end, phytype, physubtype;
+        const struct phy_info *phy;
+        int phy_hwid, phy_id;
+
+        phy_hwid = -1;
+        fep->phy = NULL;
+
+        /* auto-detect? */
+        if (fpi->phy_addr == -1) {
+                start = 1;
+                end = 32;
+        } else {                /* direct */
+                start = fpi->phy_addr;
+                end = start + 1;
+        }
+
+        for (phy_id = start; phy_id < end; phy_id++) {
+                /* skip already used phy addresses on this bus */ 
+                if (bus->usage_map & (1 << phy_id))
+                        continue;
+                r = fs_mii_read(dev, phy_id, MII_PHYSID1);
+                if (r == -1 || (phytype = (r & 0xffff)) == 0xffff)
+                        continue;
+                r = fs_mii_read(dev, phy_id, MII_PHYSID2);
+                if (r == -1 || (physubtype = (r & 0xffff)) == 0xffff)
+                        continue;
+                phy_hwid = (phytype << 16) | physubtype;
+                if (phy_hwid != -1)
+                        break;
+        }
+
+        if (phy_hwid == -1) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s No PHY detected! range=0x%02x-0x%02x\n",
+                        dev->name, start, end);
+                return -1;
+        }
+
+        for (i = 0, phy = phy_info; i < ARRAY_SIZE(phy_info); i++, phy++)
+                if (phy->id == (phy_hwid >> 4) || phy->id == 0)
+                        break;
+
+        if (i >= ARRAY_SIZE(phy_info)) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s PHY id 0x%08x is not supported!\n",
+                       dev->name, phy_hwid);
+                return -1;
+        }
+
+        fep->phy = phy;
+
+        /* mark this address as used */
+        bus->usage_map |= (1 << phy_id);
+
+        printk(KERN_INFO DRV_MODULE_NAME
+               ": %s Phy @ 0x%x, type %s (0x%08x)%s\n",
+               dev->name, phy_id, fep->phy->name, phy_hwid,
+               fpi->phy_addr == -1 ? " (auto-detected)" : "");
+
+        return phy_id;
+}
+
+void fs_mii_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->startup)
+                (*fep->phy->startup) (dev);
+}
+
+void fs_mii_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->shutdown)
+                (*fep->phy->shutdown) (dev);
+}
+
+void fs_mii_ack_int(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->ack_int)
+                (*fep->phy->ack_int) (dev);
+}
+
+#define MII_LINK        0x0001
+#define MII_HALF        0x0002
+#define MII_FULL        0x0004
+#define MII_BASE4       0x0008
+#define MII_10M         0x0010
+#define MII_100M        0x0020
+#define MII_1G          0x0040
+#define MII_10G         0x0080
+
+/* return full mii info at one gulp, with a usable form */
+static unsigned int mii_full_status(struct mii_if_info *mii)
+{
+        unsigned int status;
+        int bmsr, adv, lpa, neg;
+        struct fs_enet_private* fep = netdev_priv(mii->dev);
+        
+        /* first, a dummy read, needed to latch some MII phys */
+        (void)mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+        bmsr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+
+        /* no link */
+        if ((bmsr & BMSR_LSTATUS) == 0)
+                return 0;
+
+        status = MII_LINK;
+        
+        /* Lets look what ANEG says if it's supported - otherwize we shall
+           take the right values from the platform info*/
+        if(!mii->force_media) {
+                /* autoneg not completed; don't bother */
+                if ((bmsr & BMSR_ANEGCOMPLETE) == 0)
+                        return 0;
+
+                adv = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_ADVERTISE);
+                lpa = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_LPA);
+
+                neg = lpa & adv;
+        } else {
+                neg = fep->fpi->bus_info->lpa;
+        }
+
+        if (neg & LPA_100FULL)
+                status |= MII_FULL | MII_100M;
+        else if (neg & LPA_100BASE4)
+                status |= MII_FULL | MII_BASE4 | MII_100M;
+        else if (neg & LPA_100HALF)
+                status |= MII_HALF | MII_100M;
+        else if (neg & LPA_10FULL)
+                status |= MII_FULL | MII_10M;
+        else
+                status |= MII_HALF | MII_10M;
+        
+        return status;
+}
+
+void fs_mii_link_status_change_check(struct net_device *dev, int init_media)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct mii_if_info *mii = &fep->mii_if;
+        unsigned int mii_status;
+        int ok_to_print, link, duplex, speed;
+        unsigned long flags;
+
+        ok_to_print = netif_msg_link(fep);
+
+        mii_status = mii_full_status(mii);
+
+        if (!init_media && mii_status == fep->last_mii_status)
+                return;
+
+        fep->last_mii_status = mii_status;
+
+        link = !!(mii_status & MII_LINK);
+        duplex = !!(mii_status & MII_FULL);
+        speed = (mii_status & MII_100M) ? 100 : 10;
+
+        if (link == 0) {
+                netif_carrier_off(mii->dev);
+                netif_stop_queue(dev);
+                if (!init_media) {
+                        spin_lock_irqsave(&fep->lock, flags);
+                        (*fep->ops->stop)(dev);
+                        spin_unlock_irqrestore(&fep->lock, flags);
+                }
+
+                if (ok_to_print)
+                        printk(KERN_INFO "%s: link down\n", mii->dev->name);
+
+        } else {
+
+                mii->full_duplex = duplex;
+
+                netif_carrier_on(mii->dev);
+
+                spin_lock_irqsave(&fep->lock, flags);
+                fep->duplex = duplex;
+                fep->speed = speed;
+                (*fep->ops->restart)(dev);
+                spin_unlock_irqrestore(&fep->lock, flags);
+
+                netif_start_queue(dev);
+
+                if (ok_to_print)
+                        printk(KERN_INFO "%s: link up, %dMbps, %s-duplex\n",
+                               dev->name, speed, duplex ? "full" : "half");
+        }
+}
+
+/**********************************************************************************/
+
+int fs_mii_read(struct net_device *dev, int phy_id, int location)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&bus->mii_lock, flags);
+        ret = (*bus->mii_read)(bus, phy_id, location);
+        spin_unlock_irqrestore(&bus->mii_lock, flags);
+
+        return ret;
+}
+
+void fs_mii_write(struct net_device *dev, int phy_id, int location, int value)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        unsigned long flags;
+
+        spin_lock_irqsave(&bus->mii_lock, flags);
+        (*bus->mii_write)(bus, phy_id, location, value);
+        spin_unlock_irqrestore(&bus->mii_lock, flags);
+}
+
+/*****************************************************************************/
+
+/* list of all registered mii buses */
+static LIST_HEAD(fs_mii_bus_list);
+
+static struct fs_enet_mii_bus *lookup_bus(int method, int id)
+{
+        struct list_head *ptr;
+        struct fs_enet_mii_bus *bus;
+
+        list_for_each(ptr, &fs_mii_bus_list) {
+                bus = list_entry(ptr, struct fs_enet_mii_bus, list);
+                if (bus->bus_info->method == method &&
+                        bus->bus_info->id == id)
+                        return bus;
+        }
+        return NULL;
+}
+
+static struct fs_enet_mii_bus *create_bus(const struct fs_mii_bus_info *bi)
+{
+        struct fs_enet_mii_bus *bus;
+        int ret = 0;
+
+        bus = kmalloc(sizeof(*bus), GFP_KERNEL);
+        if (bus == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        memset(bus, 0, sizeof(*bus));
+        spin_lock_init(&bus->mii_lock);
+        bus->bus_info = bi;
+        bus->refs = 0;
+        bus->usage_map = 0;
+
+        /* perform initialization */
+        switch (bi->method) {
+
+                case fsmii_fixed:
+                        ret = fs_mii_fixed_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+
+                case fsmii_bitbang:
+                        ret = fs_mii_bitbang_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+#ifdef CONFIG_FS_ENET_HAS_FEC
+                case fsmii_fec:
+                        ret = fs_mii_fec_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+#endif
+                default:
+                        ret = -EINVAL;
+                        goto err;
+        }
+
+        list_add(&bus->list, &fs_mii_bus_list);
+
+        return bus;
+
+err:
+        if (bus)
+                kfree(bus);
+        return ERR_PTR(ret);
+}
+
+static void destroy_bus(struct fs_enet_mii_bus *bus)
+{
+        /* remove from bus list */
+        list_del(&bus->list);
+
+        /* nothing more needed */
+        kfree(bus);
+}
+
+int fs_mii_connect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        struct fs_enet_mii_bus *bus = NULL;
+
+        /* check method validity */
+        switch (fpi->bus_info->method) {
+                case fsmii_fixed:
+                case fsmii_bitbang:
+                        break;
+#ifdef CONFIG_FS_ENET_HAS_FEC
+                case fsmii_fec:
+                        break;
+#endif
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s Unknown MII bus method (%d)!\n",
+                               dev->name, fpi->bus_info->method);
+                        return -EINVAL; 
+        }
+
+        bus = lookup_bus(fpi->bus_info->method, fpi->bus_info->id);
+
+        /* if not found create new bus */
+        if (bus == NULL) {
+                bus = create_bus(fpi->bus_info);
+                if (IS_ERR(bus)) {
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s MII bus creation failure!\n", dev->name);
+                        return PTR_ERR(bus);
+                }
+        }
+
+        bus->refs++;
+
+        fep->mii_bus = bus;
+
+        fep->mii_if.dev = dev;
+        fep->mii_if.phy_id_mask = 0x1f;
+        fep->mii_if.reg_num_mask = 0x1f;
+        fep->mii_if.mdio_read = fs_mii_read;
+        fep->mii_if.mdio_write = fs_mii_write;
+        fep->mii_if.force_media = fpi->bus_info->disable_aneg;
+        fep->mii_if.phy_id = phy_id_detect(dev);
+
+        return 0;
+}
+
+void fs_mii_disconnect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = NULL;
+
+        bus = fep->mii_bus;
+        fep->mii_bus = NULL;
+
+        if (--bus->refs <= 0)
+                destroy_bus(bus);
+}
diff --git a/drivers/net/fs_enet/fs_enet.h b/drivers/net/fs_enet/fs_enet.h
new file mode 100644
index 000000000000..1105543b9d88
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet.h
@@ -0,0 +1,245 @@
+#ifndef FS_ENET_H
+#define FS_ENET_H
+
+#include <linux/mii.h>
+#include <linux/netdevice.h>
+#include <linux/types.h>
+#include <linux/version.h>
+#include <linux/list.h>
+
+#include <linux/fs_enet_pd.h>
+
+#include <asm/dma-mapping.h>
+
+#ifdef CONFIG_CPM1
+#include <asm/commproc.h>
+#endif
+
+#ifdef CONFIG_CPM2
+#include <asm/cpm2.h>
+#endif
+
+/* hw driver ops */
+struct fs_ops {
+        int (*setup_data)(struct net_device *dev);
+        int (*allocate_bd)(struct net_device *dev);
+        void (*free_bd)(struct net_device *dev);
+        void (*cleanup_data)(struct net_device *dev);
+        void (*set_multicast_list)(struct net_device *dev);
+        void (*restart)(struct net_device *dev);
+        void (*stop)(struct net_device *dev);
+        void (*pre_request_irq)(struct net_device *dev, int irq);
+        void (*post_free_irq)(struct net_device *dev, int irq);
+        void (*napi_clear_rx_event)(struct net_device *dev);
+        void (*napi_enable_rx)(struct net_device *dev);
+        void (*napi_disable_rx)(struct net_device *dev);
+        void (*rx_bd_done)(struct net_device *dev);
+        void (*tx_kickstart)(struct net_device *dev);
+        u32 (*get_int_events)(struct net_device *dev);
+        void (*clear_int_events)(struct net_device *dev, u32 int_events);
+        void (*ev_error)(struct net_device *dev, u32 int_events);
+        int (*get_regs)(struct net_device *dev, void *p, int *sizep);
+        int (*get_regs_len)(struct net_device *dev);
+        void (*tx_restart)(struct net_device *dev);
+};
+
+struct phy_info {
+        unsigned int id;
+        const char *name;
+        void (*startup) (struct net_device * dev);
+        void (*shutdown) (struct net_device * dev);
+        void (*ack_int) (struct net_device * dev);
+};
+
+/* The FEC stores dest/src/type, data, and checksum for receive packets.
+ */
+#define MAX_MTU 1508            /* Allow fullsized pppoe packets over VLAN */
+#define MIN_MTU 46              /* this is data size */
+#define CRC_LEN 4
+
+#define PKT_MAXBUF_SIZE         (MAX_MTU+ETH_HLEN+CRC_LEN)
+#define PKT_MINBUF_SIZE         (MIN_MTU+ETH_HLEN+CRC_LEN)
+
+/* Must be a multiple of 32 (to cover both FEC & FCC) */
+#define PKT_MAXBLR_SIZE         ((PKT_MAXBUF_SIZE + 31) & ~31)
+/* This is needed so that invalidate_xxx wont invalidate too much */
+#define ENET_RX_FRSIZE          L1_CACHE_ALIGN(PKT_MAXBUF_SIZE)
+
+struct fs_enet_mii_bus {
+        struct list_head list;
+        spinlock_t mii_lock;
+        const struct fs_mii_bus_info *bus_info;
+        int refs;
+        u32 usage_map;
+
+        int (*mii_read)(struct fs_enet_mii_bus *bus,
+                        int phy_id, int location);
+
+        void (*mii_write)(struct fs_enet_mii_bus *bus,
+                        int phy_id, int location, int value);
+
+        union {
+                struct {
+                        unsigned int mii_speed;
+                        void *fecp;
+                } fec;
+
+                struct {
+                        /* note that the actual port size may */
+                        /* be different; cpm(s) handle it OK  */
+                        u8 mdio_msk;
+                        u8 *mdio_dir;
+                        u8 *mdio_dat;
+                        u8 mdc_msk;
+                        u8 *mdc_dir;
+                        u8 *mdc_dat;
+                } bitbang;
+
+                struct {
+                        u16 lpa;
+                } fixed;
+        };
+};
+
+int fs_mii_bitbang_init(struct fs_enet_mii_bus *bus);
+int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
+int fs_mii_fec_init(struct fs_enet_mii_bus *bus);
+
+struct fs_enet_private {
+        struct device *dev;     /* pointer back to the device (must be initialized first) */
+        spinlock_t lock;        /* during all ops except TX pckt processing */
+        spinlock_t tx_lock;     /* during fs_start_xmit and fs_tx         */
+        const struct fs_platform_info *fpi;
+        const struct fs_ops *ops;
+        int rx_ring, tx_ring;
+        dma_addr_t ring_mem_addr;
+        void *ring_base;
+        struct sk_buff **rx_skbuff;
+        struct sk_buff **tx_skbuff;
+        cbd_t *rx_bd_base;      /* Address of Rx and Tx buffers.    */
+        cbd_t *tx_bd_base;
+        cbd_t *dirty_tx;        /* ring entries to be free()ed.     */
+        cbd_t *cur_rx;
+        cbd_t *cur_tx;
+        int tx_free;
+        struct net_device_stats stats;
+        struct timer_list phy_timer_list;
+        const struct phy_info *phy;
+        u32 msg_enable;
+        struct mii_if_info mii_if;
+        unsigned int last_mii_status;
+        struct fs_enet_mii_bus *mii_bus;
+        int interrupt;
+
+        int duplex, speed;      /* current settings */
+
+        /* event masks */
+        u32 ev_napi_rx;         /* mask of NAPI rx events */
+        u32 ev_rx;              /* rx event mask          */
+        u32 ev_tx;              /* tx event mask          */
+        u32 ev_err;             /* error event mask       */
+
+        u16 bd_rx_empty;        /* mask of BD rx empty    */
+        u16 bd_rx_err;          /* mask of BD rx errors   */
+
+        union {
+                struct {
+                        int idx;                /* FEC1 = 0, FEC2 = 1  */
+                        void *fecp;             /* hw registers        */
+                        u32 hthi, htlo;         /* state for multicast */
+                } fec;
+
+                struct {
+                        int idx;                /* FCC1-3 = 0-2        */
+                        void *fccp;             /* hw registers        */
+                        void *ep;               /* parameter ram       */
+                        void *fcccp;            /* hw registers cont.  */
+                        void *mem;              /* FCC DPRAM */
+                        u32 gaddrh, gaddrl;     /* group address       */
+                } fcc;
+
+                struct {
+                        int idx;                /* FEC1 = 0, FEC2 = 1  */
+                        void *sccp;             /* hw registers        */
+                        void *ep;               /* parameter ram       */
+                        u32 hthi, htlo;         /* state for multicast */
+                } scc;
+
+        };
+};
+
+/***************************************************************************/
+
+int fs_mii_read(struct net_device *dev, int phy_id, int location);
+void fs_mii_write(struct net_device *dev, int phy_id, int location, int value);
+
+void fs_mii_startup(struct net_device *dev);
+void fs_mii_shutdown(struct net_device *dev);
+void fs_mii_ack_int(struct net_device *dev);
+
+void fs_mii_link_status_change_check(struct net_device *dev, int init_media);
+
+void fs_init_bds(struct net_device *dev);
+void fs_cleanup_bds(struct net_device *dev);
+
+/***************************************************************************/
+
+#define DRV_MODULE_NAME         "fs_enet"
+#define PFX DRV_MODULE_NAME     ": "
+#define DRV_MODULE_VERSION      "1.0"
+#define DRV_MODULE_RELDATE      "Aug 8, 2005"
+
+/***************************************************************************/
+
+int fs_enet_platform_init(void);
+void fs_enet_platform_cleanup(void);
+
+/***************************************************************************/
+
+/* buffer descriptor access macros */
+
+/* access macros */
+#if defined(CONFIG_CPM1)
+/* for a a CPM1 __raw_xxx's are sufficient */
+#define __cbd_out32(addr, x)    __raw_writel(x, addr)
+#define __cbd_out16(addr, x)    __raw_writew(x, addr)
+#define __cbd_in32(addr)        __raw_readl(addr)
+#define __cbd_in16(addr)        __raw_readw(addr)
+#else
+/* for others play it safe */
+#define __cbd_out32(addr, x)    out_be32(addr, x)
+#define __cbd_out16(addr, x)    out_be16(addr, x)
+#define __cbd_in32(addr)        in_be32(addr)
+#define __cbd_in16(addr)        in_be16(addr)
+#endif
+
+/* write */
+#define CBDW_SC(_cbd, _sc)              __cbd_out16(&(_cbd)->cbd_sc, (_sc))
+#define CBDW_DATLEN(_cbd, _datlen)      __cbd_out16(&(_cbd)->cbd_datlen, (_datlen))
+#define CBDW_BUFADDR(_cbd, _bufaddr)    __cbd_out32(&(_cbd)->cbd_bufaddr, (_bufaddr))
+
+/* read */
+#define CBDR_SC(_cbd)                   __cbd_in16(&(_cbd)->cbd_sc)
+#define CBDR_DATLEN(_cbd)               __cbd_in16(&(_cbd)->cbd_datlen)
+#define CBDR_BUFADDR(_cbd)              __cbd_in32(&(_cbd)->cbd_bufaddr)
+
+/* set bits */
+#define CBDS_SC(_cbd, _sc)              CBDW_SC(_cbd, CBDR_SC(_cbd) | (_sc))
+
+/* clear bits */
+#define CBDC_SC(_cbd, _sc)              CBDW_SC(_cbd, CBDR_SC(_cbd) & ~(_sc))
+
+/*******************************************************************/
+
+extern const struct fs_ops fs_fec_ops;
+extern const struct fs_ops fs_fcc_ops;
+extern const struct fs_ops fs_scc_ops;
+
+/*******************************************************************/
+
+/* handy pointer to the immap */
+extern void *fs_enet_immap;
+
+/*******************************************************************/
+
+#endif
diff --git a/drivers/net/fs_enet/mac-fcc.c b/drivers/net/fs_enet/mac-fcc.c
new file mode 100644
index 000000000000..a940b96433c7
--- /dev/null
+++ b/drivers/net/fs_enet/mac-fcc.c
@@ -0,0 +1,578 @@
+/*
+ * FCC driver for Motorola MPC82xx (PQ2).
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/immap_cpm2.h>
+#include <asm/mpc8260.h>
+#include <asm/cpm2.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+/* FCC access macros */
+
+#define __fcc_out32(addr, x)    out_be32((unsigned *)addr, x)
+#define __fcc_out16(addr, x)    out_be16((unsigned short *)addr, x)
+#define __fcc_out8(addr, x)     out_8((unsigned char *)addr, x)
+#define __fcc_in32(addr)        in_be32((unsigned *)addr)
+#define __fcc_in16(addr)        in_be16((unsigned short *)addr)
+#define __fcc_in8(addr)         in_8((unsigned char *)addr)
+
+/* parameter space */
+
+/* write, read, set bits, clear bits */
+#define W32(_p, _m, _v) __fcc_out32(&(_p)->_m, (_v))
+#define R32(_p, _m)     __fcc_in32(&(_p)->_m)
+#define S32(_p, _m, _v) W32(_p, _m, R32(_p, _m) | (_v))
+#define C32(_p, _m, _v) W32(_p, _m, R32(_p, _m) & ~(_v))
+
+#define W16(_p, _m, _v) __fcc_out16(&(_p)->_m, (_v))
+#define R16(_p, _m)     __fcc_in16(&(_p)->_m)
+#define S16(_p, _m, _v) W16(_p, _m, R16(_p, _m) | (_v))
+#define C16(_p, _m, _v) W16(_p, _m, R16(_p, _m) & ~(_v))
+
+#define W8(_p, _m, _v)  __fcc_out8(&(_p)->_m, (_v))
+#define R8(_p, _m)      __fcc_in8(&(_p)->_m)
+#define S8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) | (_v))
+#define C8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) & ~(_v))
+
+/*************************************************/
+
+#define FCC_MAX_MULTICAST_ADDRS 64
+
+#define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
+#define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | (VAL & 0xffff))
+#define mk_mii_end              0
+
+#define MAX_CR_CMD_LOOPS        10000
+
+static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 mcn, u32 op)
+{
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        cpm2_map_t *immap = fs_enet_immap;
+        cpm_cpm2_t *cpmp = &immap->im_cpm;
+        u32 v;
+        int i;
+
+        /* Currently I don't know what feature call will look like. But 
+           I guess there'd be something like do_cpm_cmd() which will require page & sblock */
+        v = mk_cr_cmd(fpi->cp_page, fpi->cp_block, mcn, op);
+        W32(cpmp, cp_cpcr, v | CPM_CR_FLG);
+        for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
+                if ((R32(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
+                        break;
+
+        if (i >= MAX_CR_CMD_LOOPS) {
+                printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+                       __FUNCTION__);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev);
+        struct resource *r;
+
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq(pdev, 0);
+
+        /* Attach the memory for the FCC Parameter RAM */
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fcc_pram");
+        fep->fcc.ep = (void *)r->start;
+
+        if (fep->fcc.ep == NULL)
+                return -EINVAL;
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fcc_regs");
+        fep->fcc.fccp = (void *)r->start;
+
+        if (fep->fcc.fccp == NULL)
+                return -EINVAL;
+
+        fep->fcc.fcccp = (void *)fep->fpi->fcc_regs_c;
+
+        if (fep->fcc.fcccp == NULL)
+                return -EINVAL;
+
+        return 0;
+}
+
+#define FCC_NAPI_RX_EVENT_MSK   (FCC_ENET_RXF | FCC_ENET_RXB)
+#define FCC_RX_EVENT            (FCC_ENET_RXF)
+#define FCC_TX_EVENT            (FCC_ENET_TXB)
+#define FCC_ERR_EVENT_MSK       (FCC_ENET_TXE | FCC_ENET_BSY)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->fcc.idx = fs_get_fcc_index(fpi->fs_no);
+        if ((unsigned int)fep->fcc.idx >= 3)    /* max 3 FCCs */
+                return -EINVAL;
+
+        fep->fcc.mem = (void *)fpi->mem_offset;
+
+        if (do_pd_setup(fep) != 0)
+                return -EINVAL;
+
+        fep->ev_napi_rx = FCC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = FCC_RX_EVENT;
+        fep->ev_tx = FCC_TX_EVENT;
+        fep->ev_err = FCC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->ring_base = dma_alloc_coherent(fep->dev,
+                                            (fpi->tx_ring + fpi->rx_ring) *
+                                            sizeof(cbd_t), &fep->ring_mem_addr,
+                                            GFP_KERNEL);
+        if (fep->ring_base == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        if (fep->ring_base)
+                dma_free_coherent(fep->dev,
+                        (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
+                        fep->ring_base, fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        S32(fccp, fcc_fpsmr, FCC_PSMR_PRO);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_enet_t *ep = fep->fcc.ep;
+
+        W32(ep, fen_gaddrh, 0);
+        W32(ep, fen_gaddrl, 0);
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 *mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_enet_t *ep = fep->fcc.ep;
+        u16 taddrh, taddrm, taddrl;
+
+        taddrh = ((u16)mac[5] << 8) | mac[4];
+        taddrm = ((u16)mac[3] << 8) | mac[2];
+        taddrl = ((u16)mac[1] << 8) | mac[0];
+
+        W16(ep, fen_taddrh, taddrh);
+        W16(ep, fen_taddrm, taddrm);
+        W16(ep, fen_taddrl, taddrl);
+        fcc_cr_cmd(fep, 0x0C, CPM_CR_SET_GADDR);
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+        fcc_enet_t *ep = fep->fcc.ep;
+
+        /* clear promiscuous always */
+        C32(fccp, fcc_fpsmr, FCC_PSMR_PRO);
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > FCC_MAX_MULTICAST_ADDRS) {
+
+                W32(ep, fen_gaddrh, 0xffffffff);
+                W32(ep, fen_gaddrl, 0xffffffff);
+        }
+
+        /* read back */
+        fep->fcc.gaddrh = R32(ep, fen_gaddrh);
+        fep->fcc.gaddrl = R32(ep, fen_gaddrl);
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+static void restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        fcc_t *fccp = fep->fcc.fccp;
+        fcc_c_t *fcccp = fep->fcc.fcccp;
+        fcc_enet_t *ep = fep->fcc.ep;
+        dma_addr_t rx_bd_base_phys, tx_bd_base_phys;
+        u16 paddrh, paddrm, paddrl;
+        u16 mem_addr;
+        const unsigned char *mac;
+        int i;
+
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+
+        /* clear everything (slow & steady does it) */
+        for (i = 0; i < sizeof(*ep); i++)
+                __fcc_out8((char *)ep + i, 0);
+
+        /* get physical address */
+        rx_bd_base_phys = fep->ring_mem_addr;
+        tx_bd_base_phys = rx_bd_base_phys + sizeof(cbd_t) * fpi->rx_ring;
+
+        /* point to bds */
+        W32(ep, fen_genfcc.fcc_rbase, rx_bd_base_phys);
+        W32(ep, fen_genfcc.fcc_tbase, tx_bd_base_phys);
+
+        /* Set maximum bytes per receive buffer.
+         * It must be a multiple of 32.
+         */
+        W16(ep, fen_genfcc.fcc_mrblr, PKT_MAXBLR_SIZE);
+
+        W32(ep, fen_genfcc.fcc_rstate, (CPMFCR_GBL | CPMFCR_EB) << 24);
+        W32(ep, fen_genfcc.fcc_tstate, (CPMFCR_GBL | CPMFCR_EB) << 24);
+
+        /* Allocate space in the reserved FCC area of DPRAM for the
+         * internal buffers.  No one uses this space (yet), so we
+         * can do this.  Later, we will add resource management for
+         * this area.
+         */
+
+        mem_addr = (u32) fep->fcc.mem;  /* de-fixup dpram offset */
+
+        W16(ep, fen_genfcc.fcc_riptr, (mem_addr & 0xffff));
+        W16(ep, fen_genfcc.fcc_tiptr, ((mem_addr + 32) & 0xffff));
+        W16(ep, fen_padptr, mem_addr + 64);
+
+        /* fill with special symbol...  */
+        memset(fep->fcc.mem + fpi->dpram_offset + 64, 0x88, 32);
+
+        W32(ep, fen_genfcc.fcc_rbptr, 0);
+        W32(ep, fen_genfcc.fcc_tbptr, 0);
+        W32(ep, fen_genfcc.fcc_rcrc, 0);
+        W32(ep, fen_genfcc.fcc_tcrc, 0);
+        W16(ep, fen_genfcc.fcc_res1, 0);
+        W32(ep, fen_genfcc.fcc_res2, 0);
+
+        /* no CAM */
+        W32(ep, fen_camptr, 0);
+
+        /* Set CRC preset and mask */
+        W32(ep, fen_cmask, 0xdebb20e3);
+        W32(ep, fen_cpres, 0xffffffff);
+
+        W32(ep, fen_crcec, 0);          /* CRC Error counter       */
+        W32(ep, fen_alec, 0);           /* alignment error counter */
+        W32(ep, fen_disfc, 0);          /* discard frame counter   */
+        W16(ep, fen_retlim, 15);        /* Retry limit threshold   */
+        W16(ep, fen_pper, 0);           /* Normal persistence      */
+
+        /* set group address */
+        W32(ep, fen_gaddrh, fep->fcc.gaddrh);
+        W32(ep, fen_gaddrl, fep->fcc.gaddrh);
+
+        /* Clear hash filter tables */
+        W32(ep, fen_iaddrh, 0);
+        W32(ep, fen_iaddrl, 0);
+
+        /* Clear the Out-of-sequence TxBD  */
+        W16(ep, fen_tfcstat, 0);
+        W16(ep, fen_tfclen, 0);
+        W32(ep, fen_tfcptr, 0);
+
+        W16(ep, fen_mflr, PKT_MAXBUF_SIZE);     /* maximum frame length register */
+        W16(ep, fen_minflr, PKT_MINBUF_SIZE);   /* minimum frame length register */
+
+        /* set address */
+        mac = dev->dev_addr;
+        paddrh = ((u16)mac[5] << 8) | mac[4];
+        paddrm = ((u16)mac[3] << 8) | mac[2];
+        paddrl = ((u16)mac[1] << 8) | mac[0];
+
+        W16(ep, fen_paddrh, paddrh);
+        W16(ep, fen_paddrm, paddrm);
+        W16(ep, fen_paddrl, paddrl);
+
+        W16(ep, fen_taddrh, 0);
+        W16(ep, fen_taddrm, 0);
+        W16(ep, fen_taddrl, 0);
+
+        W16(ep, fen_maxd1, 1520);       /* maximum DMA1 length */
+        W16(ep, fen_maxd2, 1520);       /* maximum DMA2 length */
+
+        /* Clear stat counters, in case we ever enable RMON */
+        W32(ep, fen_octc, 0);
+        W32(ep, fen_colc, 0);
+        W32(ep, fen_broc, 0);
+        W32(ep, fen_mulc, 0);
+        W32(ep, fen_uspc, 0);
+        W32(ep, fen_frgc, 0);
+        W32(ep, fen_ospc, 0);
+        W32(ep, fen_jbrc, 0);
+        W32(ep, fen_p64c, 0);
+        W32(ep, fen_p65c, 0);
+        W32(ep, fen_p128c, 0);
+        W32(ep, fen_p256c, 0);
+        W32(ep, fen_p512c, 0);
+        W32(ep, fen_p1024c, 0);
+
+        W16(ep, fen_rfthr, 0);  /* Suggested by manual */
+        W16(ep, fen_rfcnt, 0);
+        W16(ep, fen_cftype, 0);
+
+        fs_init_bds(dev);
+
+        /* adjust to speed (for RMII mode) */
+        if (fpi->use_rmii) {
+                if (fep->speed == 100)
+                        C8(fcccp, fcc_gfemr, 0x20);
+                else
+                        S8(fcccp, fcc_gfemr, 0x20);
+        }
+
+        fcc_cr_cmd(fep, 0x0c, CPM_CR_INIT_TRX);
+
+        /* clear events */
+        W16(fccp, fcc_fcce, 0xffff);
+
+        /* Enable interrupts we wish to service */
+        W16(fccp, fcc_fccm, FCC_ENET_TXE | FCC_ENET_RXF | FCC_ENET_TXB);
+
+        /* Set GFMR to enable Ethernet operating mode */
+        W32(fccp, fcc_gfmr, FCC_GFMR_TCI | FCC_GFMR_MODE_ENET);
+
+        /* set sync/delimiters */
+        W16(fccp, fcc_fdsr, 0xd555);
+
+        W32(fccp, fcc_fpsmr, FCC_PSMR_ENCRC);
+
+        if (fpi->use_rmii)
+                S32(fccp, fcc_fpsmr, FCC_PSMR_RMII);
+
+        /* adjust to duplex mode */
+        if (fep->duplex)
+                S32(fccp, fcc_fpsmr, FCC_PSMR_FDE | FCC_PSMR_LPB);
+        else
+                C32(fccp, fcc_fpsmr, FCC_PSMR_FDE | FCC_PSMR_LPB);
+
+        S32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+}
+
+static void stop(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        /* stop ethernet */
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+
+        /* clear events */
+        W16(fccp, fcc_fcce, 0xffff);
+
+        /* clear interrupt mask */
+        W16(fccp, fcc_fccm, 0);
+
+        fs_cleanup_bds(dev);
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        W16(fccp, fcc_fcce, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        S16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        C16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        return (u32)R16(fccp, fcc_fcce);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        W16(fccp, fcc_fcce, int_events & 0xffff);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s FS_ENET ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->fcc.fccp, sizeof(fcc_t));
+        p = (char *)p + sizeof(fcc_t);
+
+        memcpy_fromio(p, fep->fcc.fcccp, sizeof(fcc_c_t));
+        p = (char *)p + sizeof(fcc_c_t);
+
+        memcpy_fromio(p, fep->fcc.ep, sizeof(fcc_enet_t));
+
+        return 0;
+}
+
+int get_regs_len(struct net_device *dev)
+{
+        return sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t);
+}
+
+/* Some transmit errors cause the transmitter to shut
+ * down.  We now issue a restart transmit.  Since the
+ * errors close the BD and update the pointers, the restart
+ * _should_ pick up without having to reset any of our
+ * pointers either.  Also, To workaround 8260 device erratum 
+ * CPM37, we must disable and then re-enable the transmitter
+ * following a Late Collision, Underrun, or Retry Limit error.
+ */
+void tx_restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENT);
+        udelay(10);
+        S32(fccp, fcc_gfmr, FCC_GFMR_ENT);
+
+        fcc_cr_cmd(fep, 0x0C, CPM_CR_RESTART_TX);
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_fcc_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
new file mode 100644
index 000000000000..5ef4e845a387
--- /dev/null
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -0,0 +1,653 @@
+/*
+ * Freescale Ethernet controllers
+ *
+ * Copyright (c) 2005 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#ifdef CONFIG_8xx
+#include <asm/8xx_immap.h>
+#include <asm/pgtable.h>
+#include <asm/mpc8xx.h>
+#include <asm/commproc.h>
+#endif
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+#if defined(CONFIG_CPM1)
+/* for a CPM1 __raw_xxx's are sufficient */
+#define __fs_out32(addr, x)     __raw_writel(x, addr)
+#define __fs_out16(addr, x)     __raw_writew(x, addr)
+#define __fs_in32(addr) __raw_readl(addr)
+#define __fs_in16(addr) __raw_readw(addr)
+#else
+/* for others play it safe */
+#define __fs_out32(addr, x)     out_be32(addr, x)
+#define __fs_out16(addr, x)     out_be16(addr, x)
+#define __fs_in32(addr) in_be32(addr)
+#define __fs_in16(addr) in_be16(addr)
+#endif
+
+/* write */
+#define FW(_fecp, _reg, _v) __fs_out32(&(_fecp)->fec_ ## _reg, (_v))
+
+/* read */
+#define FR(_fecp, _reg) __fs_in32(&(_fecp)->fec_ ## _reg)
+
+/* set bits */
+#define FS(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) | (_v))
+
+/* clear bits */
+#define FC(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) & ~(_v))
+
+
+/* CRC polynomium used by the FEC for the multicast group filtering */
+#define FEC_CRC_POLY   0x04C11DB7
+
+#define FEC_MAX_MULTICAST_ADDRS 64
+
+/* Interrupt events/masks.
+*/
+#define FEC_ENET_HBERR  0x80000000U     /* Heartbeat error          */
+#define FEC_ENET_BABR   0x40000000U     /* Babbling receiver        */
+#define FEC_ENET_BABT   0x20000000U     /* Babbling transmitter     */
+#define FEC_ENET_GRA    0x10000000U     /* Graceful stop complete   */
+#define FEC_ENET_TXF    0x08000000U     /* Full frame transmitted   */
+#define FEC_ENET_TXB    0x04000000U     /* A buffer was transmitted */
+#define FEC_ENET_RXF    0x02000000U     /* Full frame received      */
+#define FEC_ENET_RXB    0x01000000U     /* A buffer was received    */
+#define FEC_ENET_MII    0x00800000U     /* MII interrupt            */
+#define FEC_ENET_EBERR  0x00400000U     /* SDMA bus error           */
+
+#define FEC_ECNTRL_PINMUX       0x00000004
+#define FEC_ECNTRL_ETHER_EN     0x00000002
+#define FEC_ECNTRL_RESET        0x00000001
+
+#define FEC_RCNTRL_BC_REJ       0x00000010
+#define FEC_RCNTRL_PROM         0x00000008
+#define FEC_RCNTRL_MII_MODE     0x00000004
+#define FEC_RCNTRL_DRT          0x00000002
+#define FEC_RCNTRL_LOOP         0x00000001
+
+#define FEC_TCNTRL_FDEN         0x00000004
+#define FEC_TCNTRL_HBC          0x00000002
+#define FEC_TCNTRL_GTS          0x00000001
+
+
+/* Make MII read/write commands for the FEC.
+*/
+#define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
+#define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | (VAL & 0xffff))
+#define mk_mii_end              0
+
+#define FEC_MII_LOOPS   10000
+
+/*
+ * Delay to wait for FEC reset command to complete (in us) 
+ */
+#define FEC_RESET_DELAY         50
+
+static int whack_reset(fec_t * fecp)
+{
+        int i;
+
+        FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
+        for (i = 0; i < FEC_RESET_DELAY; i++) {
+                if ((FR(fecp, ecntrl) & FEC_ECNTRL_RESET) == 0)
+                        return 0;       /* OK */
+                udelay(1);
+        }
+
+        return -1;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev); 
+        struct resource *r;
+        
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq_byname(pdev,"interrupt");
+        
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        fep->fec.fecp =(void*)r->start;
+
+        if(fep->fec.fecp == NULL)
+                return -EINVAL;
+
+        return 0;
+        
+}
+
+#define FEC_NAPI_RX_EVENT_MSK   (FEC_ENET_RXF | FEC_ENET_RXB)
+#define FEC_RX_EVENT            (FEC_ENET_RXF)
+#define FEC_TX_EVENT            (FEC_ENET_TXF)
+#define FEC_ERR_EVENT_MSK       (FEC_ENET_HBERR | FEC_ENET_BABR | \
+                                 FEC_ENET_BABT | FEC_ENET_EBERR)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (do_pd_setup(fep) != 0)
+                return -EINVAL;
+
+        fep->fec.hthi = 0;
+        fep->fec.htlo = 0;
+
+        fep->ev_napi_rx = FEC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = FEC_RX_EVENT;
+        fep->ev_tx = FEC_TX_EVENT;
+        fep->ev_err = FEC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        
+        fep->ring_base = dma_alloc_coherent(fep->dev,
+                                            (fpi->tx_ring + fpi->rx_ring) *
+                                            sizeof(cbd_t), &fep->ring_mem_addr,
+                                            GFP_KERNEL);
+        if (fep->ring_base == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        if(fep->ring_base)
+                dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring)
+                                        * sizeof(cbd_t),
+                                        fep->ring_base,
+                                        fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FS(fecp, r_cntrl, FEC_RCNTRL_PROM);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->fec.hthi = 0;
+        fep->fec.htlo = 0;
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 *mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        int temp, hash_index, i, j;
+        u32 crc, csrVal;
+        u8 byte, msb;
+
+        crc = 0xffffffff;
+        for (i = 0; i < 6; i++) {
+                byte = mac[i];
+                for (j = 0; j < 8; j++) {
+                        msb = crc >> 31;
+                        crc <<= 1;
+                        if (msb ^ (byte & 0x1))
+                                crc ^= FEC_CRC_POLY;
+                        byte >>= 1;
+                }
+        }
+
+        temp = (crc & 0x3f) >> 1;
+        hash_index = ((temp & 0x01) << 4) |
+                     ((temp & 0x02) << 2) |
+                     ((temp & 0x04)) |
+                     ((temp & 0x08) >> 2) |
+                     ((temp & 0x10) >> 4);
+        csrVal = 1 << hash_index;
+        if (crc & 1)
+                fep->fec.hthi |= csrVal;
+        else
+                fep->fec.htlo |= csrVal;
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > FEC_MAX_MULTICAST_ADDRS) {
+                fep->fec.hthi = 0xffffffffU;
+                fep->fec.htlo = 0xffffffffU;
+        }
+
+        FC(fecp, r_cntrl, FEC_RCNTRL_PROM);
+        FW(fecp, hash_table_high, fep->fec.hthi);
+        FW(fecp, hash_table_low, fep->fec.htlo);
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+static void restart(struct net_device *dev)
+{
+#ifdef CONFIG_DUET
+        immap_t *immap = fs_enet_immap;
+        u32 cptr;
+#endif
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+        const struct fs_platform_info *fpi = fep->fpi;
+        dma_addr_t rx_bd_base_phys, tx_bd_base_phys;
+        int r;
+        u32 addrhi, addrlo;
+
+        r = whack_reset(fep->fec.fecp);
+        if (r != 0)
+                printk(KERN_ERR DRV_MODULE_NAME
+                                ": %s FEC Reset FAILED!\n", dev->name);
+
+        /*
+         * Set station address. 
+         */
+        addrhi = ((u32) dev->dev_addr[0] << 24) |
+                 ((u32) dev->dev_addr[1] << 16) |
+                 ((u32) dev->dev_addr[2] <<  8) |
+                  (u32) dev->dev_addr[3];
+        addrlo = ((u32) dev->dev_addr[4] << 24) |
+                 ((u32) dev->dev_addr[5] << 16);
+        FW(fecp, addr_low, addrhi);
+        FW(fecp, addr_high, addrlo);
+
+        /*
+         * Reset all multicast. 
+         */
+        FW(fecp, hash_table_high, fep->fec.hthi);
+        FW(fecp, hash_table_low, fep->fec.htlo);
+
+        /*
+         * Set maximum receive buffer size. 
+         */
+        FW(fecp, r_buff_size, PKT_MAXBLR_SIZE);
+        FW(fecp, r_hash, PKT_MAXBUF_SIZE);
+
+        /* get physical address */
+        rx_bd_base_phys = fep->ring_mem_addr;
+        tx_bd_base_phys = rx_bd_base_phys + sizeof(cbd_t) * fpi->rx_ring;
+
+        /*
+         * Set receive and transmit descriptor base. 
+         */
+        FW(fecp, r_des_start, rx_bd_base_phys);
+        FW(fecp, x_des_start, tx_bd_base_phys);
+
+        fs_init_bds(dev);
+
+        /*
+         * Enable big endian and don't care about SDMA FC. 
+         */
+        FW(fecp, fun_code, 0x78000000);
+
+        /*
+         * Set MII speed. 
+         */
+        FW(fecp, mii_speed, fep->mii_bus->fec.mii_speed);
+
+        /*
+         * Clear any outstanding interrupt. 
+         */
+        FW(fecp, ievent, 0xffc0);
+        FW(fecp, ivec, (fep->interrupt / 2) << 29);
+        
+
+        /*
+         * adjust to speed (only for DUET & RMII) 
+         */
+#ifdef CONFIG_DUET
+        if (fpi->use_rmii) {
+                cptr = in_be32(&immap->im_cpm.cp_cptr);
+                switch (fs_get_fec_index(fpi->fs_no)) {
+                case 0:
+                        cptr |= 0x100;
+                        if (fep->speed == 10)
+                                cptr |= 0x0000010;
+                        else if (fep->speed == 100)
+                                cptr &= ~0x0000010;
+                        break;
+                case 1:
+                        cptr |= 0x80;
+                        if (fep->speed == 10)
+                                cptr |= 0x0000008;
+                        else if (fep->speed == 100)
+                                cptr &= ~0x0000008;
+                        break;
+                default:
+                        BUG();  /* should never happen */
+                        break;
+                }
+                out_be32(&immap->im_cpm.cp_cptr, cptr);
+        }
+#endif
+
+        FW(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+        /*
+         * adjust to duplex mode 
+         */
+        if (fep->duplex) {
+                FC(fecp, r_cntrl, FEC_RCNTRL_DRT);
+                FS(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD enable */
+        } else {
+                FS(fecp, r_cntrl, FEC_RCNTRL_DRT);
+                FC(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD disable */
+        }
+
+        /*
+         * Enable interrupts we wish to service. 
+         */
+        FW(fecp, imask, FEC_ENET_TXF | FEC_ENET_TXB |
+           FEC_ENET_RXF | FEC_ENET_RXB);
+
+        /*
+         * And last, enable the transmit and receive processing. 
+         */
+        FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+        FW(fecp, r_des_active, 0x01000000);
+}
+
+static void stop(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        int i;
+
+        if ((FR(fecp, ecntrl) & FEC_ECNTRL_ETHER_EN) == 0)
+                return;         /* already down */
+
+        FW(fecp, x_cntrl, 0x01);        /* Graceful transmit stop */
+        for (i = 0; ((FR(fecp, ievent) & 0x10000000) == 0) &&
+             i < FEC_RESET_DELAY; i++)
+                udelay(1);
+
+        if (i == FEC_RESET_DELAY)
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s FEC timeout on graceful transmit stop\n",
+                       dev->name);
+        /*
+         * Disable FEC. Let only MII interrupts. 
+         */
+        FW(fecp, imask, 0);
+        FC(fecp, ecntrl, FEC_ECNTRL_ETHER_EN);
+
+        fs_cleanup_bds(dev);
+
+        /* shut down FEC1? that's where the mii bus is */
+        if (fep->fec.idx == 0 && bus->refs > 1 && bi->method == fsmii_fec) {
+                FS(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+                FS(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+                FW(fecp, ievent, FEC_ENET_MII);
+                FW(fecp, mii_speed, bus->fec.mii_speed);
+        }
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        immap_t *immap = fs_enet_immap;
+        u32 siel;
+
+        /* SIU interrupt */
+        if (irq >= SIU_IRQ0 && irq < SIU_LEVEL7) {
+
+                siel = in_be32(&immap->im_siu_conf.sc_siel);
+                if ((irq & 1) == 0)
+                        siel |= (0x80000000 >> irq);
+                else
+                        siel &= ~(0x80000000 >> (irq & ~1));
+                out_be32(&immap->im_siu_conf.sc_siel, siel);
+        }
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, ievent, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FS(fecp, imask, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FC(fecp, imask, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, r_des_active, 0x01000000);
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, x_des_active, 0x01000000);
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        return FR(fecp, ievent) & FR(fecp, imask);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, ievent, int_events);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s FEC ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(fec_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->fec.fecp, sizeof(fec_t));
+
+        return 0;
+}
+
+int get_regs_len(struct net_device *dev)
+{
+        return sizeof(fec_t);
+}
+
+void tx_restart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_fec_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
+
+/***********************************************************************/
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        fec_t *fecp = bus->fec.fecp;
+        int i, ret = -1;
+
+        if ((FR(fecp, r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
+                BUG();
+
+        /* Add PHY address to register command.  */
+        FW(fecp, mii_data, (phy_id << 23) | mk_mii_read(location));
+
+        for (i = 0; i < FEC_MII_LOOPS; i++)
+                if ((FR(fecp, ievent) & FEC_ENET_MII) != 0)
+                        break;
+
+        if (i < FEC_MII_LOOPS) {
+                FW(fecp, ievent, FEC_ENET_MII);
+                ret = FR(fecp, mii_data) & 0xffff;
+        }
+
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int value)
+{
+        fec_t *fecp = bus->fec.fecp;
+        int i;
+
+        /* this must never happen */
+        if ((FR(fecp, r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
+                BUG();
+
+        /* Add PHY address to register command.  */
+        FW(fecp, mii_data, (phy_id << 23) | mk_mii_write(location, value));
+
+        for (i = 0; i < FEC_MII_LOOPS; i++)
+                if ((FR(fecp, ievent) & FEC_ENET_MII) != 0)
+                        break;
+
+        if (i < FEC_MII_LOOPS)
+                FW(fecp, ievent, FEC_ENET_MII);
+}
+
+int fs_mii_fec_init(struct fs_enet_mii_bus *bus)
+{
+        bd_t *bd = (bd_t *)__res;
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        fec_t *fecp;
+
+        if (bi->id != 0)
+                return -1;
+
+        bus->fec.fecp = &((immap_t *)fs_enet_immap)->im_cpm.cp_fec;
+        bus->fec.mii_speed = ((((bd->bi_intfreq + 4999999) / 2500000) / 2)
+                                & 0x3F) << 1;
+
+        fecp = bus->fec.fecp;
+
+        FS(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+        FS(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+        FW(fecp, ievent, FEC_ENET_MII);
+        FW(fecp, mii_speed, bus->fec.mii_speed);
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
new file mode 100644
index 000000000000..d8c6e9cadcf5
--- /dev/null
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -0,0 +1,524 @@
+/*
+ * Ethernet on Serial Communications Controller (SCC) driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#ifdef CONFIG_8xx
+#include <asm/8xx_immap.h>
+#include <asm/pgtable.h>
+#include <asm/mpc8xx.h>
+#include <asm/commproc.h>
+#endif
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+#if defined(CONFIG_CPM1)
+/* for a 8xx __raw_xxx's are sufficient */
+#define __fs_out32(addr, x)     __raw_writel(x, addr)
+#define __fs_out16(addr, x)     __raw_writew(x, addr)
+#define __fs_out8(addr, x)      __raw_writeb(x, addr)
+#define __fs_in32(addr) __raw_readl(addr)
+#define __fs_in16(addr) __raw_readw(addr)
+#define __fs_in8(addr)  __raw_readb(addr)
+#else
+/* for others play it safe */
+#define __fs_out32(addr, x)     out_be32(addr, x)
+#define __fs_out16(addr, x)     out_be16(addr, x)
+#define __fs_in32(addr) in_be32(addr)
+#define __fs_in16(addr) in_be16(addr)
+#endif
+
+/* write, read, set bits, clear bits */
+#define W32(_p, _m, _v) __fs_out32(&(_p)->_m, (_v))
+#define R32(_p, _m)     __fs_in32(&(_p)->_m)
+#define S32(_p, _m, _v) W32(_p, _m, R32(_p, _m) | (_v))
+#define C32(_p, _m, _v) W32(_p, _m, R32(_p, _m) & ~(_v))
+
+#define W16(_p, _m, _v) __fs_out16(&(_p)->_m, (_v))
+#define R16(_p, _m)     __fs_in16(&(_p)->_m)
+#define S16(_p, _m, _v) W16(_p, _m, R16(_p, _m) | (_v))
+#define C16(_p, _m, _v) W16(_p, _m, R16(_p, _m) & ~(_v))
+
+#define W8(_p, _m, _v)  __fs_out8(&(_p)->_m, (_v))
+#define R8(_p, _m)      __fs_in8(&(_p)->_m)
+#define S8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) | (_v))
+#define C8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) & ~(_v))
+
+#define SCC_MAX_MULTICAST_ADDRS 64
+
+/*
+ * Delay to wait for SCC reset command to complete (in us) 
+ */
+#define SCC_RESET_DELAY         50
+#define MAX_CR_CMD_LOOPS        10000
+
+static inline int scc_cr_cmd(struct fs_enet_private *fep, u32 op)
+{
+        cpm8xx_t *cpmp = &((immap_t *)fs_enet_immap)->im_cpm;
+        u32 v, ch;
+        int i = 0;
+
+        ch = fep->scc.idx << 2;
+        v = mk_cr_cmd(ch, op);
+        W16(cpmp, cp_cpcr, v | CPM_CR_FLG);
+        for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
+                if ((R16(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
+                        break;
+
+        if (i >= MAX_CR_CMD_LOOPS) {
+                printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+                        __FUNCTION__);
+                return 1;
+        }
+        return 0;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev);
+        struct resource *r;
+
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq_byname(pdev, "interrupt");
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        fep->scc.sccp = (void *)r->start;
+
+        if (fep->scc.sccp == NULL)
+                return -EINVAL;
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pram");
+        fep->scc.ep = (void *)r->start;
+
+        if (fep->scc.ep == NULL)
+                return -EINVAL;
+
+        return 0;
+}
+
+#define SCC_NAPI_RX_EVENT_MSK   (SCCE_ENET_RXF | SCCE_ENET_RXB)
+#define SCC_RX_EVENT            (SCCE_ENET_RXF)
+#define SCC_TX_EVENT            (SCCE_ENET_TXB)
+#define SCC_ERR_EVENT_MSK       (SCCE_ENET_TXE | SCCE_ENET_BSY)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->scc.idx = fs_get_scc_index(fpi->fs_no);
+        if ((unsigned int)fep->fcc.idx > 4)     /* max 4 SCCs */
+                return -EINVAL;
+
+        do_pd_setup(fep);
+
+        fep->scc.hthi = 0;
+        fep->scc.htlo = 0;
+
+        fep->ev_napi_rx = SCC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = SCC_RX_EVENT;
+        fep->ev_tx = SCC_TX_EVENT;
+        fep->ev_err = SCC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->ring_mem_addr = cpm_dpalloc((fpi->tx_ring + fpi->rx_ring) *
+                                         sizeof(cbd_t), 8);
+        if (IS_DPERR(fep->ring_mem_addr))
+                return -ENOMEM;
+
+        fep->ring_base = cpm_dpram_addr(fep->ring_mem_addr);
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->ring_base)
+                cpm_dpfree(fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{                               
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        S16(sccp, scc_psmr, SCC_PSMR_PRO);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_enet_t *ep = fep->scc.ep;
+
+        W16(ep, sen_gaddr1, 0);
+        W16(ep, sen_gaddr2, 0);
+        W16(ep, sen_gaddr3, 0);
+        W16(ep, sen_gaddr4, 0);
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 * mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_enet_t *ep = fep->scc.ep;
+        u16 taddrh, taddrm, taddrl;
+
+        taddrh = ((u16) mac[5] << 8) | mac[4];
+        taddrm = ((u16) mac[3] << 8) | mac[2];
+        taddrl = ((u16) mac[1] << 8) | mac[0];
+
+        W16(ep, sen_taddrh, taddrh);
+        W16(ep, sen_taddrm, taddrm);
+        W16(ep, sen_taddrl, taddrl);
+        scc_cr_cmd(fep, CPM_CR_SET_GADDR);
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        scc_enet_t *ep = fep->scc.ep;
+
+        /* clear promiscuous always */
+        C16(sccp, scc_psmr, SCC_PSMR_PRO);
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > SCC_MAX_MULTICAST_ADDRS) {
+
+                W16(ep, sen_gaddr1, 0xffff);
+                W16(ep, sen_gaddr2, 0xffff);
+                W16(ep, sen_gaddr3, 0xffff);
+                W16(ep, sen_gaddr4, 0xffff);
+        }
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+/*
+ * This function is called to start or restart the FEC during a link
+ * change.  This only happens when switching between half and full
+ * duplex.
+ */
+static void restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        scc_enet_t *ep = fep->scc.ep;
+        const struct fs_platform_info *fpi = fep->fpi;
+        u16 paddrh, paddrm, paddrl;
+        const unsigned char *mac;
+        int i;
+
+        C32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+
+        /* clear everything (slow & steady does it) */
+        for (i = 0; i < sizeof(*ep); i++)
+                __fs_out8((char *)ep + i, 0);
+
+        /* point to bds */
+        W16(ep, sen_genscc.scc_rbase, fep->ring_mem_addr);
+        W16(ep, sen_genscc.scc_tbase,
+            fep->ring_mem_addr + sizeof(cbd_t) * fpi->rx_ring);
+
+        /* Initialize function code registers for big-endian.
+         */
+        W8(ep, sen_genscc.scc_rfcr, SCC_EB);
+        W8(ep, sen_genscc.scc_tfcr, SCC_EB);
+
+        /* Set maximum bytes per receive buffer.
+         * This appears to be an Ethernet frame size, not the buffer
+         * fragment size.  It must be a multiple of four.
+         */
+        W16(ep, sen_genscc.scc_mrblr, 0x5f0);
+
+        /* Set CRC preset and mask.
+         */
+        W32(ep, sen_cpres, 0xffffffff);
+        W32(ep, sen_cmask, 0xdebb20e3);
+
+        W32(ep, sen_crcec, 0);  /* CRC Error counter */
+        W32(ep, sen_alec, 0);   /* alignment error counter */
+        W32(ep, sen_disfc, 0);  /* discard frame counter */
+
+        W16(ep, sen_pads, 0x8888);      /* Tx short frame pad character */
+        W16(ep, sen_retlim, 15);        /* Retry limit threshold */
+
+        W16(ep, sen_maxflr, 0x5ee);     /* maximum frame length register */
+
+        W16(ep, sen_minflr, PKT_MINBUF_SIZE);   /* minimum frame length register */
+
+        W16(ep, sen_maxd1, 0x000005f0); /* maximum DMA1 length */
+        W16(ep, sen_maxd2, 0x000005f0); /* maximum DMA2 length */
+
+        /* Clear hash tables.
+         */
+        W16(ep, sen_gaddr1, 0);
+        W16(ep, sen_gaddr2, 0);
+        W16(ep, sen_gaddr3, 0);
+        W16(ep, sen_gaddr4, 0);
+        W16(ep, sen_iaddr1, 0);
+        W16(ep, sen_iaddr2, 0);
+        W16(ep, sen_iaddr3, 0);
+        W16(ep, sen_iaddr4, 0);
+
+        /* set address 
+         */
+        mac = dev->dev_addr;
+        paddrh = ((u16) mac[5] << 8) | mac[4];
+        paddrm = ((u16) mac[3] << 8) | mac[2];
+        paddrl = ((u16) mac[1] << 8) | mac[0];
+
+        W16(ep, sen_paddrh, paddrh);
+        W16(ep, sen_paddrm, paddrm);
+        W16(ep, sen_paddrl, paddrl);
+
+        W16(ep, sen_pper, 0);
+        W16(ep, sen_taddrl, 0);
+        W16(ep, sen_taddrm, 0);
+        W16(ep, sen_taddrh, 0);
+
+        fs_init_bds(dev);
+
+        scc_cr_cmd(fep, CPM_CR_INIT_TRX);
+
+        W16(sccp, scc_scce, 0xffff);
+
+        /* Enable interrupts we wish to service. 
+         */
+        W16(sccp, scc_sccm, SCCE_ENET_TXE | SCCE_ENET_RXF | SCCE_ENET_TXB);
+
+        /* Set GSMR_H to enable all normal operating modes.
+         * Set GSMR_L to enable Ethernet to MC68160.
+         */
+        W32(sccp, scc_gsmrh, 0);
+        W32(sccp, scc_gsmrl,
+            SCC_GSMRL_TCI | SCC_GSMRL_TPL_48 | SCC_GSMRL_TPP_10 |
+            SCC_GSMRL_MODE_ENET);
+
+        /* Set sync/delimiters.
+         */
+        W16(sccp, scc_dsr, 0xd555);
+
+        /* Set processing mode.  Use Ethernet CRC, catch broadcast, and
+         * start frame search 22 bit times after RENA.
+         */
+        W16(sccp, scc_psmr, SCC_PSMR_ENCRC | SCC_PSMR_NIB22);
+
+        /* Set full duplex mode if needed */
+        if (fep->duplex)
+                S16(sccp, scc_psmr, SCC_PSMR_LPB | SCC_PSMR_FDE);
+
+        S32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+}
+
+static void stop(struct net_device *dev)        
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        int i;
+
+        for (i = 0; (R16(sccp, scc_sccm) == 0) && i < SCC_RESET_DELAY; i++)
+                udelay(1);
+
+        if (i == SCC_RESET_DELAY)
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s SCC timeout on graceful transmit stop\n",
+                       dev->name);
+
+        W16(sccp, scc_sccm, 0);
+        C32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+
+        fs_cleanup_bds(dev);
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        immap_t *immap = fs_enet_immap;
+        u32 siel;
+
+        /* SIU interrupt */
+        if (irq >= SIU_IRQ0 && irq < SIU_LEVEL7) {
+
+                siel = in_be32(&immap->im_siu_conf.sc_siel);
+                if ((irq & 1) == 0)
+                        siel |= (0x80000000 >> irq);
+                else
+                        siel &= ~(0x80000000 >> (irq & ~1));
+                out_be32(&immap->im_siu_conf.sc_siel, siel);
+        }
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        W16(sccp, scc_scce, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        S16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        C16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        return (u32) R16(sccp, scc_scce);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        W16(sccp, scc_scce, int_events & 0xffff);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s SCC ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+static int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(scc_t) + sizeof(scc_enet_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->scc.sccp, sizeof(scc_t));
+        p = (char *)p + sizeof(scc_t);
+
+        memcpy_fromio(p, fep->scc.ep, sizeof(scc_enet_t));
+
+        return 0;
+}
+
+static int get_regs_len(struct net_device *dev)
+{
+        return sizeof(scc_t) + sizeof(scc_enet_t);
+}
+
+static void tx_restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        scc_cr_cmd(fep, CPM_CR_RESTART_TX);
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_scc_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
diff --git a/drivers/net/fs_enet/mii-bitbang.c b/drivers/net/fs_enet/mii-bitbang.c
new file mode 100644
index 000000000000..24a5e2e23d18
--- /dev/null
+++ b/drivers/net/fs_enet/mii-bitbang.c
@@ -0,0 +1,405 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+#ifdef CONFIG_8xx
+static int bitbang_prep_bit(u8 **dirp, u8 **datp, u8 *mskp, int port, int bit)
+{
+        immap_t *im = (immap_t *)fs_enet_immap;
+        void *dir, *dat, *ppar;
+        int adv;
+        u8 msk;
+
+        switch (port) {
+                case fsiop_porta:
+                        dir = &im->im_ioport.iop_padir;
+                        dat = &im->im_ioport.iop_padat;
+                        ppar = &im->im_ioport.iop_papar;
+                        break;
+
+                case fsiop_portb:
+                        dir = &im->im_cpm.cp_pbdir;
+                        dat = &im->im_cpm.cp_pbdat;
+                        ppar = &im->im_cpm.cp_pbpar;
+                        break;
+
+                case fsiop_portc:
+                        dir = &im->im_ioport.iop_pcdir;
+                        dat = &im->im_ioport.iop_pcdat;
+                        ppar = &im->im_ioport.iop_pcpar;
+                        break;
+
+                case fsiop_portd:
+                        dir = &im->im_ioport.iop_pddir;
+                        dat = &im->im_ioport.iop_pddat;
+                        ppar = &im->im_ioport.iop_pdpar;
+                        break;
+
+                case fsiop_porte:
+                        dir = &im->im_cpm.cp_pedir;
+                        dat = &im->im_cpm.cp_pedat;
+                        ppar = &im->im_cpm.cp_pepar;
+                        break;
+
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               "Illegal port value %d!\n", port);
+                        return -EINVAL;
+        }
+
+        adv = bit >> 3;
+        dir = (char *)dir + adv;
+        dat = (char *)dat + adv;
+        ppar = (char *)ppar + adv;
+
+        msk = 1 << (7 - (bit & 7));
+        if ((in_8(ppar) & msk) != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       "pin %d on port %d is not general purpose!\n", bit, port);
+                return -EINVAL;
+        }
+
+        *dirp = dir;
+        *datp = dat;
+        *mskp = msk;
+
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_8260
+static int bitbang_prep_bit(u8 **dirp, u8 **datp, u8 *mskp, int port, int bit)
+{
+        iop_cpm2_t *io = &((cpm2_map_t *)fs_enet_immap)->im_ioport;
+        void *dir, *dat, *ppar;
+        int adv;
+        u8 msk;
+
+        switch (port) {
+                case fsiop_porta:
+                        dir = &io->iop_pdira;
+                        dat = &io->iop_pdata;
+                        ppar = &io->iop_ppara;
+                        break;
+
+                case fsiop_portb:
+                        dir = &io->iop_pdirb;
+                        dat = &io->iop_pdatb;
+                        ppar = &io->iop_pparb;
+                        break;
+
+                case fsiop_portc:
+                        dir = &io->iop_pdirc;
+                        dat = &io->iop_pdatc;
+                        ppar = &io->iop_pparc;
+                        break;
+
+                case fsiop_portd:
+                        dir = &io->iop_pdird;
+                        dat = &io->iop_pdatd;
+                        ppar = &io->iop_ppard;
+                        break;
+
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               "Illegal port value %d!\n", port);
+                        return -EINVAL;
+        }
+
+        adv = bit >> 3;
+        dir = (char *)dir + adv;
+        dat = (char *)dat + adv;
+        ppar = (char *)ppar + adv;
+
+        msk = 1 << (7 - (bit & 7));
+        if ((in_8(ppar) & msk) != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       "pin %d on port %d is not general purpose!\n", bit, port);
+                return -EINVAL;
+        }
+
+        *dirp = dir;
+        *datp = dat;
+        *mskp = msk;
+
+        return 0;
+}
+#endif
+
+static inline void bb_set(u8 *p, u8 m)
+{
+        out_8(p, in_8(p) | m);
+}
+
+static inline void bb_clr(u8 *p, u8 m)
+{
+        out_8(p, in_8(p) & ~m);
+}
+
+static inline int bb_read(u8 *p, u8 m)
+{
+        return (in_8(p) & m) != 0;
+}
+
+static inline void mdio_active(struct fs_enet_mii_bus *bus)
+{
+        bb_set(bus->bitbang.mdio_dir, bus->bitbang.mdio_msk);
+}
+
+static inline void mdio_tristate(struct fs_enet_mii_bus *bus)
+{
+        bb_clr(bus->bitbang.mdio_dir, bus->bitbang.mdio_msk);
+}
+
+static inline int mdio_read(struct fs_enet_mii_bus *bus)
+{
+        return bb_read(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+}
+
+static inline void mdio(struct fs_enet_mii_bus *bus, int what)
+{
+        if (what)
+                bb_set(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+        else
+                bb_clr(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+}
+
+static inline void mdc(struct fs_enet_mii_bus *bus, int what)
+{
+        if (what)
+                bb_set(bus->bitbang.mdc_dat, bus->bitbang.mdc_msk);
+        else
+                bb_clr(bus->bitbang.mdc_dat, bus->bitbang.mdc_msk);
+}
+
+static inline void mii_delay(struct fs_enet_mii_bus *bus)
+{
+        udelay(bus->bus_info->i.bitbang.delay);
+}
+
+/* Utility to send the preamble, address, and register (common to read and write). */
+static void bitbang_pre(struct fs_enet_mii_bus *bus, int read, u8 addr, u8 reg)
+{
+        int j;
+
+        /*
+         * Send a 32 bit preamble ('1's) with an extra '1' bit for good measure.
+         * The IEEE spec says this is a PHY optional requirement.  The AMD
+         * 79C874 requires one after power up and one after a MII communications
+         * error.  This means that we are doing more preambles than we need,
+         * but it is safer and will be much more robust.
+         */
+
+        mdio_active(bus);
+        mdio(bus, 1);
+        for (j = 0; j < 32; j++) {
+                mdc(bus, 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+        }
+
+        /* send the start bit (01) and the read opcode (10) or write (10) */
+        mdc(bus, 0);
+        mdio(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, read);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, !read);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* send the PHY address */
+        for (j = 0; j < 5; j++) {
+                mdc(bus, 0);
+                mdio(bus, (addr & 0x10) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                addr <<= 1;
+        }
+
+        /* send the register address */
+        for (j = 0; j < 5; j++) {
+                mdc(bus, 0);
+                mdio(bus, (reg & 0x10) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                reg <<= 1;
+        }
+}
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        u16 rdreg;
+        int ret, j;
+        u8 addr = phy_id & 0xff;
+        u8 reg = location & 0xff;
+
+        bitbang_pre(bus, 1, addr, reg);
+
+        /* tri-state our MDIO I/O pin so we can read */
+        mdc(bus, 0);
+        mdio_tristate(bus);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* check the turnaround bit: the PHY should be driving it to zero */
+        if (mdio_read(bus) != 0) {
+                /* PHY didn't drive TA low */
+                for (j = 0; j < 32; j++) {
+                        mdc(bus, 0);
+                        mii_delay(bus);
+                        mdc(bus, 1);
+                        mii_delay(bus);
+                }
+                ret = -1;
+                goto out;
+        }
+
+        mdc(bus, 0);
+        mii_delay(bus);
+
+        /* read 16 bits of register data, MSB first */
+        rdreg = 0;
+        for (j = 0; j < 16; j++) {
+                mdc(bus, 1);
+                mii_delay(bus);
+                rdreg <<= 1;
+                rdreg |= mdio_read(bus);
+                mdc(bus, 0);
+                mii_delay(bus);
+        }
+
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        ret = rdreg;
+out:
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int val)
+{
+        int j;
+        u8 addr = phy_id & 0xff;
+        u8 reg = location & 0xff;
+        u16 value = val & 0xffff;
+
+        bitbang_pre(bus, 0, addr, reg);
+
+        /* send the turnaround (10) */
+        mdc(bus, 0);
+        mdio(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* write 16 bits of register data, MSB first */
+        for (j = 0; j < 16; j++) {
+                mdc(bus, 0);
+                mdio(bus, (value & 0x8000) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                value <<= 1;
+        }
+
+        /*
+         * Tri-state the MDIO line.
+         */
+        mdio_tristate(bus);
+        mdc(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+}
+
+int fs_mii_bitbang_init(struct fs_enet_mii_bus *bus)
+{
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        int r;
+
+        r = bitbang_prep_bit(&bus->bitbang.mdio_dir,
+                         &bus->bitbang.mdio_dat,
+                         &bus->bitbang.mdio_msk,
+                         bi->i.bitbang.mdio_port,
+                         bi->i.bitbang.mdio_bit);
+        if (r != 0)
+                return r;
+
+        r = bitbang_prep_bit(&bus->bitbang.mdc_dir,
+                         &bus->bitbang.mdc_dat,
+                         &bus->bitbang.mdc_msk,
+                         bi->i.bitbang.mdc_port,
+                         bi->i.bitbang.mdc_bit);
+        if (r != 0)
+                return r;
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/fs_enet/mii-fixed.c b/drivers/net/fs_enet/mii-fixed.c
new file mode 100644
index 000000000000..b3e192d612e5
--- /dev/null
+++ b/drivers/net/fs_enet/mii-fixed.c
@@ -0,0 +1,92 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+static const u16 mii_regs[7] = {
+        0x3100,
+        0x786d,
+        0x0fff,
+        0x0fff,
+        0x01e1,
+        0x45e1,
+        0x0003,
+};
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        int ret = 0;
+
+        if ((unsigned int)location >= ARRAY_SIZE(mii_regs))
+                return -1;
+
+        if (location != 5)
+                ret = mii_regs[location];
+        else
+                ret = bus->fixed.lpa;
+
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int val)
+{
+        /* do nothing */
+}
+
+int fs_mii_fixed_init(struct fs_enet_mii_bus *bus)
+{
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+
+        bus->fixed.lpa = 0x45e1;        /* default 100Mb, full duplex */
+
+        /* if speed is fixed at 10Mb, remove 100Mb modes */
+        if (bi->i.fixed.speed == 10)
+                bus->fixed.lpa &= ~LPA_100;
+
+        /* if duplex is half, remove full duplex modes */
+        if (bi->i.fixed.duplex == 0)
+                bus->fixed.lpa &= ~LPA_DUPLEX;
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 6518334b9280..ae5a2ed3b264 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -29,12 +29,7 @@
  *  define the configuration needed by the board are defined in a
  *  board structure in arch/ppc/platforms (though I do not
  *  discount the possibility that other architectures could one
- *  day be supported.  One assumption the driver currently makes
- *  is that the PHY is configured in such a way to advertise all
- *  capabilities.  This is a sensible default, and on certain
- *  PHYs, changing this default encounters substantial errata
- *  issues.  Future versions may remove this requirement, but for
- *  now, it is best for the firmware to ensure this is the case.
+ *  day be supported.
  *
  *  The Gianfar Ethernet Controller uses a ring of buffer
  *  descriptors.  The beginning is indicated by a register
@@ -47,7 +42,7 @@
  *  corresponding bit in the IMASK register is also set (if
  *  interrupt coalescing is active, then the interrupt may not
  *  happen immediately, but will wait until either a set number
- *  of frames or amount of time have passed.).  In NAPI, the
+ *  of frames or amount of time have passed).  In NAPI, the
  *  interrupt handler will signal there is work to be done, and
  *  exit.  Without NAPI, the packet(s) will be handled
  *  immediately.  Both methods will start at the last known empty
@@ -75,6 +70,7 @@
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/errno.h>
+#include <linux/unistd.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -97,9 +93,11 @@
 #include <linux/version.h>
 #include <linux/dma-mapping.h>
 #include <linux/crc32.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
 
 #include "gianfar.h"
-#include "gianfar_phy.h"
+#include "gianfar_mii.h"
 
 #define TX_TIMEOUT      (1*HZ)
 #define SKB_ALLOC_TIMEOUT 1000000
@@ -113,9 +111,8 @@
 #endif
 
 const char gfar_driver_name[] = "Gianfar Ethernet";
-const char gfar_driver_version[] = "1.1";
+const char gfar_driver_version[] = "1.2";
 
-int startup_gfar(struct net_device *dev);
 static int gfar_enet_open(struct net_device *dev);
 static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static void gfar_timeout(struct net_device *dev);
@@ -126,17 +123,13 @@ static int gfar_set_mac_address(struct net_device *dev);
 static int gfar_change_mtu(struct net_device *dev, int new_mtu);
 static irqreturn_t gfar_error(int irq, void *dev_id, struct pt_regs *regs);
 static irqreturn_t gfar_transmit(int irq, void *dev_id, struct pt_regs *regs);
-static irqreturn_t gfar_receive(int irq, void *dev_id, struct pt_regs *regs);
 static irqreturn_t gfar_interrupt(int irq, void *dev_id, struct pt_regs *regs);
-static irqreturn_t phy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
-static void gfar_phy_change(void *data);
-static void gfar_phy_timer(unsigned long data);
 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 device *device);
 static int gfar_remove(struct device *device);
-void free_skb_resources(struct gfar_private *priv);
+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);
 #ifdef CONFIG_GFAR_NAPI
@@ -144,7 +137,6 @@ static int gfar_poll(struct net_device *dev, int *budget);
 #endif
 int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit);
 static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb, int length);
-static void gfar_phy_startup_timer(unsigned long data);
 static void gfar_vlan_rx_register(struct net_device *netdev,
                                 struct vlan_group *grp);
 static void gfar_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
@@ -162,6 +154,9 @@ int gfar_uses_fcb(struct gfar_private *priv)
         else
                 return 0;
 }
+
+/* Set up the ethernet device structure, private data,
+ * and anything else we need before we start */
 static int gfar_probe(struct device *device)
 {
         u32 tempval;
@@ -175,7 +170,7 @@ static int gfar_probe(struct device *device)
 
         einfo = (struct gianfar_platform_data *) pdev->dev.platform_data;
 
-        if (einfo == NULL) {
+        if (NULL == einfo) {
                 printk(KERN_ERR "gfar %d: Missing additional data!\n",
                        pdev->id);
 
@@ -185,7 +180,7 @@ static int gfar_probe(struct device *device)
         /* Create an ethernet device instance */
         dev = alloc_etherdev(sizeof (*priv));
 
-        if (dev == NULL)
+        if (NULL == dev)
                 return -ENOMEM;
 
         priv = netdev_priv(dev);
@@ -207,20 +202,11 @@ static int gfar_probe(struct device *device)
         priv->regs = (struct gfar *)
                 ioremap(r->start, sizeof (struct gfar));
 
-        if (priv->regs == NULL) {
+        if (NULL == priv->regs) {
                 err = -ENOMEM;
                 goto regs_fail;
         }
 
-        /* Set the PHY base address */
-        priv->phyregs = (struct gfar *)
-            ioremap(einfo->phy_reg_addr, sizeof (struct gfar));
-
-        if (priv->phyregs == NULL) {
-                err = -ENOMEM;
-                goto phy_regs_fail;
-        }
-
         spin_lock_init(&priv->lock);
 
         dev_set_drvdata(device, dev);
@@ -386,12 +372,10 @@ static int gfar_probe(struct device *device)
         return 0;
 
 register_fail:
-        iounmap((void *) priv->phyregs);
-phy_regs_fail:
         iounmap((void *) priv->regs);
 regs_fail:
         free_netdev(dev);
-        return -ENOMEM;
+        return err;
 }
 
 static int gfar_remove(struct device *device)
@@ -402,108 +386,41 @@ static int gfar_remove(struct device *device)
         dev_set_drvdata(device, NULL);
 
         iounmap((void *) priv->regs);
-        iounmap((void *) priv->phyregs);
         free_netdev(dev);
 
         return 0;
 }
 
 
-/* Configure the PHY for dev.
- * returns 0 if success.  -1 if failure
+/* Initializes driver's PHY state, and attaches to the PHY.
+ * Returns 0 on success.
  */
 static int init_phy(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct phy_info *curphy;
-        unsigned int timeout = PHY_INIT_TIMEOUT;
-        struct gfar *phyregs = priv->phyregs;
-        struct gfar_mii_info *mii_info;
-        int err;
+        uint gigabit_support =
+                priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
+                SUPPORTED_1000baseT_Full : 0;
+        struct phy_device *phydev;
 
         priv->oldlink = 0;
         priv->oldspeed = 0;
         priv->oldduplex = -1;
 
-        mii_info = kmalloc(sizeof(struct gfar_mii_info),
-                        GFP_KERNEL);
-
-        if(NULL == mii_info) {
-                if (netif_msg_ifup(priv))
-                        printk(KERN_ERR "%s: Could not allocate mii_info\n",
-                                        dev->name);
-                return -ENOMEM;
-        }
-
-        mii_info->speed = SPEED_1000;
-        mii_info->duplex = DUPLEX_FULL;
-        mii_info->pause = 0;
-        mii_info->link = 1;
-
-        mii_info->advertising = (ADVERTISED_10baseT_Half |
-                        ADVERTISED_10baseT_Full |
-                        ADVERTISED_100baseT_Half |
-                        ADVERTISED_100baseT_Full |
-                        ADVERTISED_1000baseT_Full);
-        mii_info->autoneg = 1;
+        phydev = phy_connect(dev, priv->einfo->bus_id, &adjust_link, 0);
 
-        spin_lock_init(&mii_info->mdio_lock);
-
-        mii_info->mii_id = priv->einfo->phyid;
-
-        mii_info->dev = dev;
-
-        mii_info->mdio_read = &read_phy_reg;
-        mii_info->mdio_write = &write_phy_reg;
-
-        priv->mii_info = mii_info;
-
-        /* Reset the management interface */
-        gfar_write(&phyregs->miimcfg, MIIMCFG_RESET);
-
-        /* Setup the MII Mgmt clock speed */
-        gfar_write(&phyregs->miimcfg, MIIMCFG_INIT_VALUE);
-
-        /* Wait until the bus is free */
-        while ((gfar_read(&phyregs->miimind) & MIIMIND_BUSY) &&
-                        timeout--)
-                cpu_relax();
-
-        if(timeout <= 0) {
-                printk(KERN_ERR "%s: The MII Bus is stuck!\n",
-                                dev->name);
-                err = -1;
-                goto bus_fail;
-        }
-
-        /* get info for this PHY */
-        curphy = get_phy_info(priv->mii_info);
-
-        if (curphy == NULL) {
-                if (netif_msg_ifup(priv))
-                        printk(KERN_ERR "%s: No PHY found\n", dev->name);
-                err = -1;
-                goto no_phy;
+        if (IS_ERR(phydev)) {
+                printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
+                return PTR_ERR(phydev);
         }
 
-        mii_info->phyinfo = curphy;
+        /* Remove any features not supported by the controller */
+        phydev->supported &= (GFAR_SUPPORTED | gigabit_support);
+        phydev->advertising = phydev->supported;
 
-        /* Run the commands which initialize the PHY */
-        if(curphy->init) {
-                err = curphy->init(priv->mii_info);
-
-                if (err)
-                        goto phy_init_fail;
-        }
+        priv->phydev = phydev;
 
         return 0;
-
-phy_init_fail:
-no_phy:
-bus_fail:
-        kfree(mii_info);
-
-        return err;
 }
 
 static void init_registers(struct net_device *dev)
@@ -603,24 +520,13 @@ void stop_gfar(struct net_device *dev)
         struct gfar *regs = priv->regs;
         unsigned long flags;
 
+        phy_stop(priv->phydev);
+
         /* Lock it down */
         spin_lock_irqsave(&priv->lock, flags);
 
-        /* Tell the kernel the link is down */
-        priv->mii_info->link = 0;
-        adjust_link(dev);
-
         gfar_halt(dev);
 
-        if (priv->einfo->board_flags & FSL_GIANFAR_BRD_HAS_PHY_INTR) {
-                /* Clear any pending interrupts */
-                mii_clear_phy_interrupt(priv->mii_info);
-
-                /* Disable PHY Interrupts */
-                mii_configure_phy_interrupt(priv->mii_info,
-                                MII_INTERRUPT_DISABLED);
-        }
-
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* Free the IRQs */
@@ -629,13 +535,7 @@ void stop_gfar(struct net_device *dev)
                 free_irq(priv->interruptTransmit, dev);
                 free_irq(priv->interruptReceive, dev);
         } else {
-                free_irq(priv->interruptTransmit, dev);
-        }
-
-        if (priv->einfo->board_flags & FSL_GIANFAR_BRD_HAS_PHY_INTR) {
-                free_irq(priv->einfo->interruptPHY, dev);
-        } else {
-                del_timer_sync(&priv->phy_info_timer);
+                free_irq(priv->interruptTransmit, dev);
         }
 
         free_skb_resources(priv);
@@ -649,7 +549,7 @@ void stop_gfar(struct net_device *dev)
 
 /* If there are any tx skbs or rx skbs still around, free them.
  * Then free tx_skbuff and rx_skbuff */
-void free_skb_resources(struct gfar_private *priv)
+static void free_skb_resources(struct gfar_private *priv)
 {
         struct rxbd8 *rxbdp;
         struct txbd8 *txbdp;
@@ -770,7 +670,7 @@ int startup_gfar(struct net_device *dev)
             (struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
                                         priv->tx_ring_size, GFP_KERNEL);
 
-        if (priv->tx_skbuff == NULL) {
+        if (NULL == priv->tx_skbuff) {
                 if (netif_msg_ifup(priv))
                         printk(KERN_ERR "%s: Could not allocate tx_skbuff\n",
                                         dev->name);
@@ -785,7 +685,7 @@ int startup_gfar(struct net_device *dev)
             (struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
                                         priv->rx_ring_size, GFP_KERNEL);
 
-        if (priv->rx_skbuff == NULL) {
+        if (NULL == priv->rx_skbuff) {
                 if (netif_msg_ifup(priv))
                         printk(KERN_ERR "%s: Could not allocate rx_skbuff\n",
                                         dev->name);
@@ -879,13 +779,7 @@ int startup_gfar(struct net_device *dev)
                 }
         }
 
-        /* Set up the PHY change work queue */
-        INIT_WORK(&priv->tq, gfar_phy_change, dev);
-
-        init_timer(&priv->phy_info_timer);
-        priv->phy_info_timer.function = &gfar_phy_startup_timer;
-        priv->phy_info_timer.data = (unsigned long) priv->mii_info;
-        mod_timer(&priv->phy_info_timer, jiffies + HZ);
+        phy_start(priv->phydev);
 
         /* Configure the coalescing support */
         if (priv->txcoalescing)
@@ -933,11 +827,6 @@ tx_skb_fail:
                         priv->tx_bd_base,
                         gfar_read(&regs->tbase0));
 
-        if (priv->mii_info->phyinfo->close)
-                priv->mii_info->phyinfo->close(priv->mii_info);
-
-        kfree(priv->mii_info);
-
         return err;
 }
 
@@ -1035,7 +924,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         txbdp->status &= TXBD_WRAP;
 
         /* Set up checksumming */
-        if ((dev->features & NETIF_F_IP_CSUM) 
+        if ((dev->features & NETIF_F_IP_CSUM)
                         && (CHECKSUM_HW == skb->ip_summed)) {
                 fcb = gfar_add_fcb(skb, txbdp);
                 gfar_tx_checksum(skb, fcb);
@@ -1103,11 +992,9 @@ static int gfar_close(struct net_device *dev)
         struct gfar_private *priv = netdev_priv(dev);
         stop_gfar(dev);
 
-        /* Shutdown the PHY */
-        if (priv->mii_info->phyinfo->close)
-                priv->mii_info->phyinfo->close(priv->mii_info);
-
-        kfree(priv->mii_info);
+        /* Disconnect from the PHY */
+        phy_disconnect(priv->phydev);
+        priv->phydev = NULL;
 
         netif_stop_queue(dev);
 
@@ -1343,7 +1230,7 @@ struct sk_buff * gfar_new_skb(struct net_device *dev, struct rxbd8 *bdp)
         while ((!skb) && timeout--)
                 skb = dev_alloc_skb(priv->rx_buffer_size + RXBUF_ALIGNMENT);
 
-        if (skb == NULL)
+        if (NULL == skb)
                 return NULL;
 
         /* We need the data buffer to be aligned properly.  We will reserve
@@ -1490,7 +1377,7 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         struct gfar_private *priv = netdev_priv(dev);
         struct rxfcb *fcb = NULL;
 
-        if (skb == NULL) {
+        if (NULL == skb) {
                 if (netif_msg_rx_err(priv))
                         printk(KERN_WARNING "%s: Missing skb!!.\n", dev->name);
                 priv->stats.rx_dropped++;
@@ -1718,131 +1605,9 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t phy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        struct net_device *dev = (struct net_device *) dev_id;
-        struct gfar_private *priv = netdev_priv(dev);
-
-        /* Clear the interrupt */
-        mii_clear_phy_interrupt(priv->mii_info);
-
-        /* Disable PHY interrupts */
-        mii_configure_phy_interrupt(priv->mii_info,
-                        MII_INTERRUPT_DISABLED);
-
-        /* Schedule the phy change */
-        schedule_work(&priv->tq);
-
-        return IRQ_HANDLED;
-}
-
-/* Scheduled by the phy_interrupt/timer to handle PHY changes */
-static void gfar_phy_change(void *data)
-{
-        struct net_device *dev = (struct net_device *) data;
-        struct gfar_private *priv = netdev_priv(dev);
-        int result = 0;
-
-        /* Delay to give the PHY a chance to change the
-         * register state */
-        msleep(1);
-
-        /* Update the link, speed, duplex */
-        result = priv->mii_info->phyinfo->read_status(priv->mii_info);
-
-        /* Adjust the known status as long as the link
-         * isn't still coming up */
-        if((0 == result) || (priv->mii_info->link == 0))
-                adjust_link(dev);
-
-        /* Reenable interrupts, if needed */
-        if (priv->einfo->board_flags & FSL_GIANFAR_BRD_HAS_PHY_INTR)
-                mii_configure_phy_interrupt(priv->mii_info,
-                                MII_INTERRUPT_ENABLED);
-}
-
-/* Called every so often on systems that don't interrupt
- * the core for PHY changes */
-static void gfar_phy_timer(unsigned long data)
-{
-        struct net_device *dev = (struct net_device *) data;
-        struct gfar_private *priv = netdev_priv(dev);
-
-        schedule_work(&priv->tq);
-
-        mod_timer(&priv->phy_info_timer, jiffies +
-                        GFAR_PHY_CHANGE_TIME * HZ);
-}
-
-/* Keep trying aneg for some time
- * If, after GFAR_AN_TIMEOUT seconds, it has not
- * finished, we switch to forced.
- * Either way, once the process has completed, we either
- * request the interrupt, or switch the timer over to
- * using gfar_phy_timer to check status */
-static void gfar_phy_startup_timer(unsigned long data)
-{
-        int result;
-        static int secondary = GFAR_AN_TIMEOUT;
-        struct gfar_mii_info *mii_info = (struct gfar_mii_info *)data;
-        struct gfar_private *priv = netdev_priv(mii_info->dev);
-
-        /* Configure the Auto-negotiation */
-        result = mii_info->phyinfo->config_aneg(mii_info);
-
-        /* If autonegotiation failed to start, and
-         * we haven't timed out, reset the timer, and return */
-        if (result && secondary--) {
-                mod_timer(&priv->phy_info_timer, jiffies + HZ);
-                return;
-        } else if (result) {
-                /* Couldn't start autonegotiation.
-                 * Try switching to forced */
-                mii_info->autoneg = 0;
-                result = mii_info->phyinfo->config_aneg(mii_info);
-
-                /* Forcing failed!  Give up */
-                if(result) {
-                        if (netif_msg_link(priv))
-                                printk(KERN_ERR "%s: Forcing failed!\n",
-                                                mii_info->dev->name);
-                        return;
-                }
-        }
-
-        /* Kill the timer so it can be restarted */
-        del_timer_sync(&priv->phy_info_timer);
-
-        /* Grab the PHY interrupt, if necessary/possible */
-        if (priv->einfo->board_flags & FSL_GIANFAR_BRD_HAS_PHY_INTR) {
-                if (request_irq(priv->einfo->interruptPHY,
-                                        phy_interrupt,
-                                        SA_SHIRQ,
-                                        "phy_interrupt",
-                                        mii_info->dev) < 0) {
-                        if (netif_msg_intr(priv))
-                                printk(KERN_ERR "%s: Can't get IRQ %d (PHY)\n",
-                                                mii_info->dev->name,
-                                        priv->einfo->interruptPHY);
-                } else {
-                        mii_configure_phy_interrupt(priv->mii_info,
-                                        MII_INTERRUPT_ENABLED);
-                        return;
-                }
-        }
-
-        /* Start the timer again, this time in order to
-         * handle a change in status */
-        init_timer(&priv->phy_info_timer);
-        priv->phy_info_timer.function = &gfar_phy_timer;
-        priv->phy_info_timer.data = (unsigned long) mii_info->dev;
-        mod_timer(&priv->phy_info_timer, jiffies +
-                        GFAR_PHY_CHANGE_TIME * HZ);
-}
-
 /* Called every time the controller might need to be made
  * aware of new link state.  The PHY code conveys this
- * information through variables in the priv structure, and this
+ * information through variables in the phydev structure, and this
  * function converts those variables into the appropriate
  * register values, and can bring down the device if needed.
  */
@@ -1850,84 +1615,68 @@ static void adjust_link(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
         struct gfar *regs = priv->regs;
-        u32 tempval;
-        struct gfar_mii_info *mii_info = priv->mii_info;
+        unsigned long flags;
+        struct phy_device *phydev = priv->phydev;
+        int new_state = 0;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (phydev->link) {
+                u32 tempval = gfar_read(&regs->maccfg2);
 
-        if (mii_info->link) {
                 /* Now we make sure that we can be in full duplex mode.
                  * If not, we operate in half-duplex mode. */
-                if (mii_info->duplex != priv->oldduplex) {
-                        if (!(mii_info->duplex)) {
-                                tempval = gfar_read(&regs->maccfg2);
+                if (phydev->duplex != priv->oldduplex) {
+                        new_state = 1;
+                        if (!(phydev->duplex))
                                 tempval &= ~(MACCFG2_FULL_DUPLEX);
-                                gfar_write(&regs->maccfg2, tempval);
-
-                                if (netif_msg_link(priv))
-                                        printk(KERN_INFO "%s: Half Duplex\n",
-                                                        dev->name);
-                        } else {
-                                tempval = gfar_read(&regs->maccfg2);
+                        else
                                 tempval |= MACCFG2_FULL_DUPLEX;
-                                gfar_write(&regs->maccfg2, tempval);
 
-                                if (netif_msg_link(priv))
-                                        printk(KERN_INFO "%s: Full Duplex\n",
-                                                        dev->name);
-                        }
-
-                        priv->oldduplex = mii_info->duplex;
+                        priv->oldduplex = phydev->duplex;
                 }
 
-                if (mii_info->speed != priv->oldspeed) {
-                        switch (mii_info->speed) {
+                if (phydev->speed != priv->oldspeed) {
+                        new_state = 1;
+                        switch (phydev->speed) {
                         case 1000:
-                                tempval = gfar_read(&regs->maccfg2);
                                 tempval =
                                     ((tempval & ~(MACCFG2_IF)) | MACCFG2_GMII);
-                                gfar_write(&regs->maccfg2, tempval);
                                 break;
                         case 100:
                         case 10:
-                                tempval = gfar_read(&regs->maccfg2);
                                 tempval =
                                     ((tempval & ~(MACCFG2_IF)) | MACCFG2_MII);
-                                gfar_write(&regs->maccfg2, tempval);
                                 break;
                         default:
                                 if (netif_msg_link(priv))
                                         printk(KERN_WARNING
-                                                        "%s: Ack!  Speed (%d) is not 10/100/1000!\n",
-                                                        dev->name, mii_info->speed);
+                                                "%s: Ack!  Speed (%d) is not 10/100/1000!\n",
+                                                dev->name, phydev->speed);
                                 break;
                         }
 
-                        if (netif_msg_link(priv))
-                                printk(KERN_INFO "%s: Speed %dBT\n", dev->name,
-                                                mii_info->speed);
-
-                        priv->oldspeed = mii_info->speed;
+                        priv->oldspeed = phydev->speed;
                 }
 
+                gfar_write(&regs->maccfg2, tempval);
+
                 if (!priv->oldlink) {
-                        if (netif_msg_link(priv))
-                                printk(KERN_INFO "%s: Link is up\n", dev->name);
+                        new_state = 1;
                         priv->oldlink = 1;
-                        netif_carrier_on(dev);
                         netif_schedule(dev);
                 }
-        } else {
-                if (priv->oldlink) {
-                        if (netif_msg_link(priv))
-                                printk(KERN_INFO "%s: Link is down\n",
-                                                dev->name);
-                        priv->oldlink = 0;
-                        priv->oldspeed = 0;
-                        priv->oldduplex = -1;
-                        netif_carrier_off(dev);
-                }
+        } else if (priv->oldlink) {
+                new_state = 1;
+                priv->oldlink = 0;
+                priv->oldspeed = 0;
+                priv->oldduplex = -1;
         }
-}
 
+        if (new_state && netif_msg_link(priv))
+                phy_print_status(phydev);
+
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
 
 /* Update the hash table based on the current list of multicast
  * addresses we subscribe to.  Also, change the promiscuity of
@@ -2122,12 +1871,23 @@ static struct device_driver gfar_driver = {
 
 static int __init gfar_init(void)
 {
-        return driver_register(&gfar_driver);
+        int err = gfar_mdio_init();
+
+        if (err)
+                return err;
+
+        err = driver_register(&gfar_driver);
+
+        if (err)
+                gfar_mdio_exit();
+        
+        return err;
 }
 
 static void __exit gfar_exit(void)
 {
         driver_unregister(&gfar_driver);
+        gfar_mdio_exit();
 }
 
 module_init(gfar_init);
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 28af087d9fbb..c77ca6c0d04a 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -17,7 +17,6 @@
  *
  *  Still left to do:
  *      -Add support for module parameters
- *      -Add support for ethtool -s
  *      -Add patch for ethtool phys id
  */
 #ifndef __GIANFAR_H
@@ -37,7 +36,8 @@
 #include <linux/skbuff.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
-#include <linux/fsl_devices.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -48,7 +48,8 @@
 #include <linux/workqueue.h>
 #include <linux/ethtool.h>
 #include <linux/netdevice.h>
-#include "gianfar_phy.h"
+#include <linux/fsl_devices.h>
+#include "gianfar_mii.h"
 
 /* The maximum number of packets to be handled in one call of gfar_poll */
 #define GFAR_DEV_WEIGHT 64
@@ -73,7 +74,7 @@
 #define PHY_INIT_TIMEOUT 100000
 #define GFAR_PHY_CHANGE_TIME 2
 
-#define DEVICE_NAME "%s: Gianfar Ethernet Controller Version 1.1, "
+#define DEVICE_NAME "%s: Gianfar Ethernet Controller Version 1.2, "
 #define DRV_NAME "gfar-enet"
 extern const char gfar_driver_name[];
 extern const char gfar_driver_version[];
@@ -578,12 +579,7 @@ struct gfar {
         u32     hafdup;         /* 0x.50c - Half Duplex Register */
         u32     maxfrm;         /* 0x.510 - Maximum Frame Length Register */
         u8      res18[12];
-        u32     miimcfg;        /* 0x.520 - MII Management Configuration Register */
-        u32     miimcom;        /* 0x.524 - MII Management Command Register */
-        u32     miimadd;        /* 0x.528 - MII Management Address Register */
-        u32     miimcon;        /* 0x.52c - MII Management Control Register */
-        u32     miimstat;       /* 0x.530 - MII Management Status Register */
-        u32     miimind;        /* 0x.534 - MII Management Indicator Register */
+        u8      gfar_mii_regs[24];      /* See gianfar_phy.h */
         u8      res19[4];
         u32     ifstat;         /* 0x.53c - Interface Status Register */
         u32     macstnaddr1;    /* 0x.540 - Station Address Part 1 Register */
@@ -688,9 +684,6 @@ struct gfar_private {
         struct gfar *regs;      /* Pointer to the GFAR memory mapped Registers */
         u32 *hash_regs[16];
         int hash_width;
-        struct gfar *phyregs;
-        struct work_struct tq;
-        struct timer_list phy_info_timer;
         struct net_device_stats stats; /* linux network statistics */
         struct gfar_extra_stats extra_stats;
         spinlock_t lock;
@@ -710,7 +703,8 @@ struct gfar_private {
         unsigned int interruptError;
         struct gianfar_platform_data *einfo;
 
-        struct gfar_mii_info *mii_info;
+        struct phy_device *phydev;
+        struct mii_bus *mii_bus;
         int oldspeed;
         int oldduplex;
         int oldlink;
@@ -732,4 +726,12 @@ extern inline void gfar_write(volatile unsigned *addr, u32 val)
 
 extern struct ethtool_ops *gfar_op_array[];
 
+extern irqreturn_t gfar_receive(int irq, void *dev_id, struct pt_regs *regs);
+extern int startup_gfar(struct net_device *dev);
+extern void stop_gfar(struct net_device *dev);
+extern void gfar_halt(struct net_device *dev);
+extern void gfar_phy_test(struct mii_bus *bus, struct phy_device *phydev,
+                int enable, u32 regnum, u32 read);
+void gfar_setup_stashing(struct net_device *dev);
+
 #endif /* __GIANFAR_H */
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index a451de629197..68e3578e7613 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -39,17 +39,18 @@
 #include <asm/types.h>
 #include <asm/uaccess.h>
 #include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
 
 #include "gianfar.h"
 
 #define is_power_of_2(x)        ((x) != 0 && (((x) & ((x) - 1)) == 0))
 
-extern int startup_gfar(struct net_device *dev);
-extern void stop_gfar(struct net_device *dev);
-extern void gfar_halt(struct net_device *dev);
 extern void gfar_start(struct net_device *dev);
 extern int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit);
 
+#define GFAR_MAX_COAL_USECS 0xffff
+#define GFAR_MAX_COAL_FRAMES 0xff
 static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
                      u64 * buf);
 static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf);
@@ -182,38 +183,32 @@ static void gfar_gdrvinfo(struct net_device *dev, struct
         drvinfo->eedump_len = 0;
 }
 
+
+static int gfar_ssettings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct gfar_private *priv = netdev_priv(dev);
+        struct phy_device *phydev = priv->phydev;
+
+        if (NULL == phydev)
+                return -ENODEV;
+
+        return phy_ethtool_sset(phydev, cmd);
+}
+
+
 /* Return the current settings in the ethtool_cmd structure */
 static int gfar_gsettings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        uint gigabit_support = 
-                priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
-                        SUPPORTED_1000baseT_Full : 0;
-        uint gigabit_advert = 
-                priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
-                        ADVERTISED_1000baseT_Full: 0;
-
-        cmd->supported = (SUPPORTED_10baseT_Half
-                          | SUPPORTED_100baseT_Half
-                          | SUPPORTED_100baseT_Full
-                          | gigabit_support | SUPPORTED_Autoneg);
-
-        /* For now, we always advertise everything */
-        cmd->advertising = (ADVERTISED_10baseT_Half
-                            | ADVERTISED_100baseT_Half
-                            | ADVERTISED_100baseT_Full
-                            | gigabit_advert | ADVERTISED_Autoneg);
-
-        cmd->speed = priv->mii_info->speed;
-        cmd->duplex = priv->mii_info->duplex;
-        cmd->port = PORT_MII;
-        cmd->phy_address = priv->mii_info->mii_id;
-        cmd->transceiver = XCVR_EXTERNAL;
-        cmd->autoneg = AUTONEG_ENABLE;
+        struct phy_device *phydev = priv->phydev;
+
+        if (NULL == phydev)
+                return -ENODEV;
+        
         cmd->maxtxpkt = priv->txcount;
         cmd->maxrxpkt = priv->rxcount;
 
-        return 0;
+        return phy_ethtool_gset(phydev, cmd);
 }
 
 /* Return the length of the register structure */
@@ -241,14 +236,14 @@ static unsigned int gfar_usecs2ticks(struct gfar_private *priv, unsigned int use
         unsigned int count;
 
         /* The timer is different, depending on the interface speed */
-        switch (priv->mii_info->speed) {
-        case 1000:
+        switch (priv->phydev->speed) {
+        case SPEED_1000:
                 count = GFAR_GBIT_TIME;
                 break;
-        case 100:
+        case SPEED_100:
                 count = GFAR_100_TIME;
                 break;
-        case 10:
+        case SPEED_10:
         default:
                 count = GFAR_10_TIME;
                 break;
@@ -265,14 +260,14 @@ static unsigned int gfar_ticks2usecs(struct gfar_private *priv, unsigned int tic
         unsigned int count;
 
         /* The timer is different, depending on the interface speed */
-        switch (priv->mii_info->speed) {
-        case 1000:
+        switch (priv->phydev->speed) {
+        case SPEED_1000:
                 count = GFAR_GBIT_TIME;
                 break;
-        case 100:
+        case SPEED_100:
                 count = GFAR_100_TIME;
                 break;
-        case 10:
+        case SPEED_10:
         default:
                 count = GFAR_10_TIME;
                 break;
@@ -292,6 +287,9 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
         if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                 return -EOPNOTSUPP;
 
+        if (NULL == priv->phydev)
+                return -ENODEV;
+
         cvals->rx_coalesce_usecs = gfar_ticks2usecs(priv, priv->rxtime);
         cvals->rx_max_coalesced_frames = priv->rxcount;
 
@@ -348,6 +346,22 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
         else
                 priv->rxcoalescing = 1;
 
+        if (NULL == priv->phydev)
+                return -ENODEV;
+
+        /* Check the bounds of the values */
+        if (cvals->rx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
+                pr_info("Coalescing is limited to %d microseconds\n",
+                                GFAR_MAX_COAL_USECS);
+                return -EINVAL;
+        }
+
+        if (cvals->rx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
+                pr_info("Coalescing is limited to %d frames\n",
+                                GFAR_MAX_COAL_FRAMES);
+                return -EINVAL;
+        }
+
         priv->rxtime = gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs);
         priv->rxcount = cvals->rx_max_coalesced_frames;
 
@@ -358,6 +372,19 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
         else
                 priv->txcoalescing = 1;
 
+        /* Check the bounds of the values */
+        if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
+                pr_info("Coalescing is limited to %d microseconds\n",
+                                GFAR_MAX_COAL_USECS);
+                return -EINVAL;
+        }
+
+        if (cvals->tx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
+                pr_info("Coalescing is limited to %d frames\n",
+                                GFAR_MAX_COAL_FRAMES);
+                return -EINVAL;
+        }
+
         priv->txtime = gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs);
         priv->txcount = cvals->tx_max_coalesced_frames;
 
@@ -536,6 +563,7 @@ static void gfar_set_msglevel(struct net_device *dev, uint32_t data)
 
 struct ethtool_ops gfar_ethtool_ops = {
         .get_settings = gfar_gsettings,
+        .set_settings = gfar_ssettings,
         .get_drvinfo = gfar_gdrvinfo,
         .get_regs_len = gfar_reglen,
         .get_regs = gfar_get_regs,
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
new file mode 100644
index 000000000000..1eca1dbca7f1
--- /dev/null
+++ b/drivers/net/gianfar_mii.c
@@ -0,0 +1,219 @@
+/* 
+ * drivers/net/gianfar_mii.c
+ *
+ * Gianfar Ethernet Driver -- MIIM bus implementation
+ * Provides Bus interface for MIIM regs
+ *
+ * Author: Andy Fleming
+ * Maintainer: Kumar Gala (kumar.gala@freescale.com)
+ *
+ * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <asm/ocp.h>
+#include <linux/crc32.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "gianfar.h"
+#include "gianfar_mii.h"
+
+/* Write value to the PHY at mii_id at register regnum,
+ * on the bus, waiting until the write is done before returning.
+ * All PHY configuration is done through the TSEC1 MIIM regs */
+int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
+{
+        struct gfar_mii *regs = bus->priv;
+
+        /* Set the PHY address and the register address we want to write */
+        gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
+
+        /* Write out the value we want */
+        gfar_write(&regs->miimcon, value);
+
+        /* Wait for the transaction to finish */
+        while (gfar_read(&regs->miimind) & MIIMIND_BUSY)
+                cpu_relax();
+
+        return 0;
+}
+
+/* Read the bus for PHY at addr mii_id, register regnum, and
+ * return the value.  Clears miimcom first.  All PHY
+ * configuration has to be done through the TSEC1 MIIM regs */
+int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+        struct gfar_mii *regs = bus->priv;
+        u16 value;
+
+        /* Set the PHY address and the register address we want to read */
+        gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
+
+        /* Clear miimcom, and then initiate a read */
+        gfar_write(&regs->miimcom, 0);
+        gfar_write(&regs->miimcom, MII_READ_COMMAND);
+
+        /* Wait for the transaction to finish */
+        while (gfar_read(&regs->miimind) & (MIIMIND_NOTVALID | MIIMIND_BUSY))
+                cpu_relax();
+
+        /* Grab the value of the register from miimstat */
+        value = gfar_read(&regs->miimstat);
+
+        return value;
+}
+
+
+/* Reset the MIIM registers, and wait for the bus to free */
+int gfar_mdio_reset(struct mii_bus *bus)
+{
+        struct gfar_mii *regs = bus->priv;
+        unsigned int timeout = PHY_INIT_TIMEOUT;
+
+        spin_lock_bh(&bus->mdio_lock);
+
+        /* Reset the management interface */
+        gfar_write(&regs->miimcfg, MIIMCFG_RESET);
+
+        /* Setup the MII Mgmt clock speed */
+        gfar_write(&regs->miimcfg, MIIMCFG_INIT_VALUE);
+
+        /* Wait until the bus is free */
+        while ((gfar_read(&regs->miimind) & MIIMIND_BUSY) &&
+                        timeout--)
+                cpu_relax();
+
+        spin_unlock_bh(&bus->mdio_lock);
+
+        if(timeout <= 0) {
+                printk(KERN_ERR "%s: The MII Bus is stuck!\n",
+                                bus->name);
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+
+int gfar_mdio_probe(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct gianfar_mdio_data *pdata;
+        struct gfar_mii *regs;
+        struct mii_bus *new_bus;
+        int err = 0;
+
+        if (NULL == dev)
+                return -EINVAL;
+
+        new_bus = kmalloc(sizeof(struct mii_bus), GFP_KERNEL);
+
+        if (NULL == new_bus)
+                return -ENOMEM;
+
+        new_bus->name = "Gianfar MII Bus",
+        new_bus->read = &gfar_mdio_read,
+        new_bus->write = &gfar_mdio_write,
+        new_bus->reset = &gfar_mdio_reset,
+        new_bus->id = pdev->id;
+
+        pdata = (struct gianfar_mdio_data *)pdev->dev.platform_data;
+
+        if (NULL == pdata) {
+                printk(KERN_ERR "gfar mdio %d: Missing platform data!\n", pdev->id);
+                return -ENODEV;
+        }
+
+        /* Set the PHY base address */
+        regs = (struct gfar_mii *) ioremap(pdata->paddr, 
+                        sizeof (struct gfar_mii));
+
+        if (NULL == regs) {
+                err = -ENOMEM;
+                goto reg_map_fail;
+        }
+
+        new_bus->priv = regs;
+
+        new_bus->irq = pdata->irq;
+
+        new_bus->dev = dev;
+        dev_set_drvdata(dev, new_bus);
+
+        err = mdiobus_register(new_bus);
+
+        if (0 != err) {
+                printk (KERN_ERR "%s: Cannot register as MDIO bus\n", 
+                                new_bus->name);
+                goto bus_register_fail;
+        }
+
+        return 0;
+
+bus_register_fail:
+        iounmap((void *) regs);
+reg_map_fail:
+        kfree(new_bus);
+
+        return err;
+}
+
+
+int gfar_mdio_remove(struct device *dev)
+{
+        struct mii_bus *bus = dev_get_drvdata(dev);
+
+        mdiobus_unregister(bus);
+
+        dev_set_drvdata(dev, NULL);
+
+        iounmap((void *) (&bus->priv));
+        bus->priv = NULL;
+        kfree(bus);
+
+        return 0;
+}
+
+static struct device_driver gianfar_mdio_driver = {
+        .name = "fsl-gianfar_mdio",
+        .bus = &platform_bus_type,
+        .probe = gfar_mdio_probe,
+        .remove = gfar_mdio_remove,
+};
+
+int __init gfar_mdio_init(void)
+{
+        return driver_register(&gianfar_mdio_driver);
+}
+
+void __exit gfar_mdio_exit(void)
+{
+        driver_unregister(&gianfar_mdio_driver);
+}
diff --git a/drivers/net/gianfar_mii.h b/drivers/net/gianfar_mii.h
new file mode 100644
index 000000000000..56e5665d5c9b
--- /dev/null
+++ b/drivers/net/gianfar_mii.h
@@ -0,0 +1,45 @@
+/* 
+ * drivers/net/gianfar_mii.h
+ *
+ * Gianfar Ethernet Driver -- MII Management Bus Implementation
+ * Driver for the MDIO bus controller in the Gianfar register space
+ *
+ * Author: Andy Fleming
+ * Maintainer: Kumar Gala (kumar.gala@freescale.com)
+ *
+ * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ *
+ */
+#ifndef __GIANFAR_MII_H
+#define __GIANFAR_MII_H
+
+#define MIIMIND_BUSY            0x00000001
+#define MIIMIND_NOTVALID        0x00000004
+
+#define MII_READ_COMMAND       0x00000001
+
+#define GFAR_SUPPORTED (SUPPORTED_10baseT_Half \
+                | SUPPORTED_100baseT_Half \
+                | SUPPORTED_100baseT_Full \
+                | SUPPORTED_Autoneg \
+                | SUPPORTED_MII)
+
+struct gfar_mii {
+        u32     miimcfg;        /* 0x.520 - MII Management Config Register */
+        u32     miimcom;        /* 0x.524 - MII Management Command Register */
+        u32     miimadd;        /* 0x.528 - MII Management Address Register */
+        u32     miimcon;        /* 0x.52c - MII Management Control Register */
+        u32     miimstat;       /* 0x.530 - MII Management Status Register */
+        u32     miimind;        /* 0x.534 - MII Management Indicator Register */
+};
+
+int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum);
+int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
+int __init gfar_mdio_init(void);
+void __exit gfar_mdio_exit(void);
+#endif /* GIANFAR_PHY_H */
diff --git a/drivers/net/gianfar_phy.c b/drivers/net/gianfar_phy.c
deleted file mode 100644
index 7c965f268a82..000000000000
--- a/drivers/net/gianfar_phy.c
+++ /dev/null
@@ -1,661 +0,0 @@
-/* 
- * drivers/net/gianfar_phy.c
- *
- * Gianfar Ethernet Driver -- PHY handling
- * Driver for FEC on MPC8540 and TSEC on MPC8540/MPC8560
- * Based on 8260_io/fcc_enet.c
- *
- * Author: Andy Fleming
- * Maintainer: Kumar Gala (kumar.gala@freescale.com)
- *
- * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
- *
- * 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.
- *
- */
-
-#include <linux/config.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/spinlock.h>
-#include <linux/mm.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/uaccess.h>
-#include <linux/module.h>
-#include <linux/version.h>
-#include <linux/crc32.h>
-#include <linux/mii.h>
-
-#include "gianfar.h"
-#include "gianfar_phy.h"
-
-static void config_genmii_advert(struct gfar_mii_info *mii_info);
-static void genmii_setup_forced(struct gfar_mii_info *mii_info);
-static void genmii_restart_aneg(struct gfar_mii_info *mii_info);
-static int gbit_config_aneg(struct gfar_mii_info *mii_info);
-static int genmii_config_aneg(struct gfar_mii_info *mii_info);
-static int genmii_update_link(struct gfar_mii_info *mii_info);
-static int genmii_read_status(struct gfar_mii_info *mii_info);
-u16 phy_read(struct gfar_mii_info *mii_info, u16 regnum);
-void phy_write(struct gfar_mii_info *mii_info, u16 regnum, u16 val);
-
-/* Write value to the PHY for this device to the register at regnum, */
-/* waiting until the write is done before it returns.  All PHY */
-/* configuration has to be done through the TSEC1 MIIM regs */
-void write_phy_reg(struct net_device *dev, int mii_id, int regnum, int value)
-{
-        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regbase = priv->phyregs;
-
-        /* Set the PHY address and the register address we want to write */
-        gfar_write(&regbase->miimadd, (mii_id << 8) | regnum);
-
-        /* Write out the value we want */
-        gfar_write(&regbase->miimcon, value);
-
-        /* Wait for the transaction to finish */
-        while (gfar_read(&regbase->miimind) & MIIMIND_BUSY)
-                cpu_relax();
-}
-
-/* Reads from register regnum in the PHY for device dev, */
-/* returning the value.  Clears miimcom first.  All PHY */
-/* configuration has to be done through the TSEC1 MIIM regs */
-int read_phy_reg(struct net_device *dev, int mii_id, int regnum)
-{
-        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regbase = priv->phyregs;
-        u16 value;
-
-        /* Set the PHY address and the register address we want to read */
-        gfar_write(&regbase->miimadd, (mii_id << 8) | regnum);
-
-        /* Clear miimcom, and then initiate a read */
-        gfar_write(&regbase->miimcom, 0);
-        gfar_write(&regbase->miimcom, MII_READ_COMMAND);
-
-        /* Wait for the transaction to finish */
-        while (gfar_read(&regbase->miimind) & (MIIMIND_NOTVALID | MIIMIND_BUSY))
-                cpu_relax();
-
-        /* Grab the value of the register from miimstat */
-        value = gfar_read(&regbase->miimstat);
-
-        return value;
-}
-
-void mii_clear_phy_interrupt(struct gfar_mii_info *mii_info)
-{
-        if(mii_info->phyinfo->ack_interrupt)
-                mii_info->phyinfo->ack_interrupt(mii_info);
-}
-
-
-void mii_configure_phy_interrupt(struct gfar_mii_info *mii_info, u32 interrupts)
-{
-        mii_info->interrupts = interrupts;
-        if(mii_info->phyinfo->config_intr)
-                mii_info->phyinfo->config_intr(mii_info);
-}
-
-
-/* Writes MII_ADVERTISE with the appropriate values, after
- * sanitizing advertise to make sure only supported features
- * are advertised 
- */
-static void config_genmii_advert(struct gfar_mii_info *mii_info)
-{
-        u32 advertise;
-        u16 adv;
-
-        /* Only allow advertising what this PHY supports */
-        mii_info->advertising &= mii_info->phyinfo->features;
-        advertise = mii_info->advertising;
-
-        /* Setup standard advertisement */
-        adv = phy_read(mii_info, MII_ADVERTISE);
-        adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
-        if (advertise & ADVERTISED_10baseT_Half)
-                adv |= ADVERTISE_10HALF;
-        if (advertise & ADVERTISED_10baseT_Full)
-                adv |= ADVERTISE_10FULL;
-        if (advertise & ADVERTISED_100baseT_Half)
-                adv |= ADVERTISE_100HALF;
-        if (advertise & ADVERTISED_100baseT_Full)
-                adv |= ADVERTISE_100FULL;
-        phy_write(mii_info, MII_ADVERTISE, adv);
-}
-
-static void genmii_setup_forced(struct gfar_mii_info *mii_info)
-{
-        u16 ctrl;
-        u32 features = mii_info->phyinfo->features;
-        
-        ctrl = phy_read(mii_info, MII_BMCR);
-
-        ctrl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_SPEED1000|BMCR_ANENABLE);
-        ctrl |= BMCR_RESET;
-
-        switch(mii_info->speed) {
-                case SPEED_1000:
-                        if(features & (SUPPORTED_1000baseT_Half
-                                                | SUPPORTED_1000baseT_Full)) {
-                                ctrl |= BMCR_SPEED1000;
-                                break;
-                        }
-                        mii_info->speed = SPEED_100;
-                case SPEED_100:
-                        if (features & (SUPPORTED_100baseT_Half
-                                                | SUPPORTED_100baseT_Full)) {
-                                ctrl |= BMCR_SPEED100;
-                                break;
-                        }
-                        mii_info->speed = SPEED_10;
-                case SPEED_10:
-                        if (features & (SUPPORTED_10baseT_Half
-                                                | SUPPORTED_10baseT_Full))
-                                break;
-                default: /* Unsupported speed! */
-                        printk(KERN_ERR "%s: Bad speed!\n", 
-                                        mii_info->dev->name);
-                        break;
-        }
-
-        phy_write(mii_info, MII_BMCR, ctrl);
-}
-
-
-/* Enable and Restart Autonegotiation */
-static void genmii_restart_aneg(struct gfar_mii_info *mii_info)
-{
-        u16 ctl;
-
-        ctl = phy_read(mii_info, MII_BMCR);
-        ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
-        phy_write(mii_info, MII_BMCR, ctl);
-}
-
-
-static int gbit_config_aneg(struct gfar_mii_info *mii_info)
-{
-        u16 adv;
-        u32 advertise;
-
-        if(mii_info->autoneg) {
-                /* Configure the ADVERTISE register */
-                config_genmii_advert(mii_info);
-                advertise = mii_info->advertising;
-
-                adv = phy_read(mii_info, MII_1000BASETCONTROL);
-                adv &= ~(MII_1000BASETCONTROL_FULLDUPLEXCAP |
-                                MII_1000BASETCONTROL_HALFDUPLEXCAP);
-                if (advertise & SUPPORTED_1000baseT_Half)
-                        adv |= MII_1000BASETCONTROL_HALFDUPLEXCAP;
-                if (advertise & SUPPORTED_1000baseT_Full)
-                        adv |= MII_1000BASETCONTROL_FULLDUPLEXCAP;
-                phy_write(mii_info, MII_1000BASETCONTROL, adv);
-
-                /* Start/Restart aneg */
-                genmii_restart_aneg(mii_info);
-        } else
-                genmii_setup_forced(mii_info);
-
-        return 0;
-}
-
-static int marvell_config_aneg(struct gfar_mii_info *mii_info)
-{
-        /* The Marvell PHY has an errata which requires
-         * that certain registers get written in order
-         * to restart autonegotiation */
-        phy_write(mii_info, MII_BMCR, BMCR_RESET);
-
-        phy_write(mii_info, 0x1d, 0x1f);
-        phy_write(mii_info, 0x1e, 0x200c);
-        phy_write(mii_info, 0x1d, 0x5);
-        phy_write(mii_info, 0x1e, 0);
-        phy_write(mii_info, 0x1e, 0x100);
-
-        gbit_config_aneg(mii_info);
-
-        return 0;
-}
-static int genmii_config_aneg(struct gfar_mii_info *mii_info)
-{
-        if (mii_info->autoneg) {
-                config_genmii_advert(mii_info);
-                genmii_restart_aneg(mii_info);
-        } else
-                genmii_setup_forced(mii_info);
-
-        return 0;
-}
-
-
-static int genmii_update_link(struct gfar_mii_info *mii_info)
-{
-        u16 status;
-
-        /* Do a fake read */
-        phy_read(mii_info, MII_BMSR);
-
-        /* Read link and autonegotiation status */
-        status = phy_read(mii_info, MII_BMSR);
-        if ((status & BMSR_LSTATUS) == 0)
-                mii_info->link = 0;
-        else
-                mii_info->link = 1;
-
-        /* If we are autonegotiating, and not done, 
-         * return an error */
-        if (mii_info->autoneg && !(status & BMSR_ANEGCOMPLETE))
-                return -EAGAIN;
-
-        return 0;
-}
-
-static int genmii_read_status(struct gfar_mii_info *mii_info)
-{
-        u16 status;
-        int err;
-
-        /* Update the link, but return if there
-         * was an error */
-        err = genmii_update_link(mii_info);
-        if (err)
-                return err;
-
-        if (mii_info->autoneg) {
-                status = phy_read(mii_info, MII_LPA);
-
-                if (status & (LPA_10FULL | LPA_100FULL))
-                        mii_info->duplex = DUPLEX_FULL;
-                else
-                        mii_info->duplex = DUPLEX_HALF;
-                if (status & (LPA_100FULL | LPA_100HALF))
-                        mii_info->speed = SPEED_100;
-                else
-                        mii_info->speed = SPEED_10;
-                mii_info->pause = 0;
-        }
-        /* On non-aneg, we assume what we put in BMCR is the speed,
-         * though magic-aneg shouldn't prevent this case from occurring
-         */
-
-        return 0;
-}
-static int marvell_read_status(struct gfar_mii_info *mii_info)
-{
-        u16 status;
-        int err;
-
-        /* Update the link, but return if there
-         * was an error */
-        err = genmii_update_link(mii_info);
-        if (err)
-                return err;
-
-        /* If the link is up, read the speed and duplex */
-        /* If we aren't autonegotiating, assume speeds 
-         * are as set */
-        if (mii_info->autoneg && mii_info->link) {
-                int speed;
-                status = phy_read(mii_info, MII_M1011_PHY_SPEC_STATUS);
-
-#if 0
-                /* If speed and duplex aren't resolved,
-                 * return an error.  Isn't this handled
-                 * by checking aneg?
-                 */
-                if ((status & MII_M1011_PHY_SPEC_STATUS_RESOLVED) == 0)
-                        return -EAGAIN;
-#endif
-
-                /* Get the duplexity */
-                if (status & MII_M1011_PHY_SPEC_STATUS_FULLDUPLEX)
-                        mii_info->duplex = DUPLEX_FULL;
-                else
-                        mii_info->duplex = DUPLEX_HALF;
-
-                /* Get the speed */
-                speed = status & MII_M1011_PHY_SPEC_STATUS_SPD_MASK;
-                switch(speed) {
-                        case MII_M1011_PHY_SPEC_STATUS_1000:
-                                mii_info->speed = SPEED_1000;
-                                break;
-                        case MII_M1011_PHY_SPEC_STATUS_100:
-                                mii_info->speed = SPEED_100;
-                                break;
-                        default:
-                                mii_info->speed = SPEED_10;
-                                break;
-                }
-                mii_info->pause = 0;
-        }
-
-        return 0;
-}
-
-
-static int cis820x_read_status(struct gfar_mii_info *mii_info)
-{
-        u16 status;
-        int err;
-
-        /* Update the link, but return if there
-         * was an error */
-        err = genmii_update_link(mii_info);
-        if (err)
-                return err;
-
-        /* If the link is up, read the speed and duplex */
-        /* If we aren't autonegotiating, assume speeds 
-         * are as set */
-        if (mii_info->autoneg && mii_info->link) {
-                int speed;
-
-                status = phy_read(mii_info, MII_CIS8201_AUX_CONSTAT);
-                if (status & MII_CIS8201_AUXCONSTAT_DUPLEX)
-                        mii_info->duplex = DUPLEX_FULL;
-                else
-                        mii_info->duplex = DUPLEX_HALF;
-
-                speed = status & MII_CIS8201_AUXCONSTAT_SPEED;
-
-                switch (speed) {
-                case MII_CIS8201_AUXCONSTAT_GBIT:
-                        mii_info->speed = SPEED_1000;
-                        break;
-                case MII_CIS8201_AUXCONSTAT_100:
-                        mii_info->speed = SPEED_100;
-                        break;
-                default:
-                        mii_info->speed = SPEED_10;
-                        break;
-                }
-        }
-
-        return 0;
-}
-
-static int marvell_ack_interrupt(struct gfar_mii_info *mii_info)
-{
-        /* Clear the interrupts by reading the reg */
-        phy_read(mii_info, MII_M1011_IEVENT);
-
-        return 0;
-}
-
-static int marvell_config_intr(struct gfar_mii_info *mii_info)
-{
-        if(mii_info->interrupts == MII_INTERRUPT_ENABLED)
-                phy_write(mii_info, MII_M1011_IMASK, MII_M1011_IMASK_INIT);
-        else
-                phy_write(mii_info, MII_M1011_IMASK, MII_M1011_IMASK_CLEAR);
-
-        return 0;
-}
-
-static int cis820x_init(struct gfar_mii_info *mii_info)
-{
-        phy_write(mii_info, MII_CIS8201_AUX_CONSTAT, 
-                        MII_CIS8201_AUXCONSTAT_INIT);
-        phy_write(mii_info, MII_CIS8201_EXT_CON1,
-                        MII_CIS8201_EXTCON1_INIT);
-
-        return 0;
-}
-
-static int cis820x_ack_interrupt(struct gfar_mii_info *mii_info)
-{
-        phy_read(mii_info, MII_CIS8201_ISTAT);
-
-        return 0;
-}
-
-static int cis820x_config_intr(struct gfar_mii_info *mii_info)
-{
-        if(mii_info->interrupts == MII_INTERRUPT_ENABLED)
-                phy_write(mii_info, MII_CIS8201_IMASK, MII_CIS8201_IMASK_MASK);
-        else
-                phy_write(mii_info, MII_CIS8201_IMASK, 0);
-
-        return 0;
-}
-
-#define DM9161_DELAY 10
-
-static int dm9161_read_status(struct gfar_mii_info *mii_info)
-{
-        u16 status;
-        int err;
-
-        /* Update the link, but return if there
-         * was an error */
-        err = genmii_update_link(mii_info);
-        if (err)
-                return err;
-
-        /* If the link is up, read the speed and duplex */
-        /* If we aren't autonegotiating, assume speeds 
-         * are as set */
-        if (mii_info->autoneg && mii_info->link) {
-                status = phy_read(mii_info, MII_DM9161_SCSR);
-                if (status & (MII_DM9161_SCSR_100F | MII_DM9161_SCSR_100H))
-                        mii_info->speed = SPEED_100;
-                else
-                        mii_info->speed = SPEED_10;
-
-                if (status & (MII_DM9161_SCSR_100F | MII_DM9161_SCSR_10F))
-                        mii_info->duplex = DUPLEX_FULL;
-                else
-                        mii_info->duplex = DUPLEX_HALF;
-        }
-
-        return 0;
-}
-
-
-static int dm9161_config_aneg(struct gfar_mii_info *mii_info)
-{
-        struct dm9161_private *priv = mii_info->priv;
-
-        if(0 == priv->resetdone)
-                return -EAGAIN;
-
-        return 0;
-}
-
-static void dm9161_timer(unsigned long data)
-{
-        struct gfar_mii_info *mii_info = (struct gfar_mii_info *)data;
-        struct dm9161_private *priv = mii_info->priv;
-        u16 status = phy_read(mii_info, MII_BMSR);
-
-        if (status & BMSR_ANEGCOMPLETE) {
-                priv->resetdone = 1;
-        } else
-                mod_timer(&priv->timer, jiffies + DM9161_DELAY * HZ);
-}
-
-static int dm9161_init(struct gfar_mii_info *mii_info)
-{
-        struct dm9161_private *priv;
-
-        /* Allocate the private data structure */
-        priv = kmalloc(sizeof(struct dm9161_private), GFP_KERNEL);
-
-        if (NULL == priv)
-                return -ENOMEM;
-
-        mii_info->priv = priv;
-
-        /* Reset is not done yet */
-        priv->resetdone = 0;
-
-        /* Isolate the PHY */
-        phy_write(mii_info, MII_BMCR, BMCR_ISOLATE);
-
-        /* Do not bypass the scrambler/descrambler */
-        phy_write(mii_info, MII_DM9161_SCR, MII_DM9161_SCR_INIT);
-
-        /* Clear 10BTCSR to default */
-        phy_write(mii_info, MII_DM9161_10BTCSR, MII_DM9161_10BTCSR_INIT);
-
-        /* Reconnect the PHY, and enable Autonegotiation */
-        phy_write(mii_info, MII_BMCR, BMCR_ANENABLE);
-
-        /* Start a timer for DM9161_DELAY seconds to wait
-         * for the PHY to be ready */
-        init_timer(&priv->timer);
-        priv->timer.function = &dm9161_timer;
-        priv->timer.data = (unsigned long) mii_info;
-        mod_timer(&priv->timer, jiffies + DM9161_DELAY * HZ);
-
-        return 0;
-}
-
-static void dm9161_close(struct gfar_mii_info *mii_info)
-{
-        struct dm9161_private *priv = mii_info->priv;
-
-        del_timer_sync(&priv->timer);
-        kfree(priv);
-}
-
-#if 0
-static int dm9161_ack_interrupt(struct gfar_mii_info *mii_info)
-{
-        phy_read(mii_info, MII_DM9161_INTR);
-
-        return 0;
-}
-#endif
-
-/* Cicada 820x */
-static struct phy_info phy_info_cis820x = {
-        0x000fc440,
-        "Cicada Cis8204",
-        0x000fffc0,
-        .features       = MII_GBIT_FEATURES,
-        .init           = &cis820x_init,
-        .config_aneg    = &gbit_config_aneg,
-        .read_status    = &cis820x_read_status,
-        .ack_interrupt  = &cis820x_ack_interrupt,
-        .config_intr    = &cis820x_config_intr,
-};
-
-static struct phy_info phy_info_dm9161 = {
-        .phy_id         = 0x0181b880,
-        .name           = "Davicom DM9161E",
-        .phy_id_mask    = 0x0ffffff0,
-        .init           = dm9161_init,
-        .config_aneg    = dm9161_config_aneg,
-        .read_status    = dm9161_read_status,
-        .close          = dm9161_close,
-};
-
-static struct phy_info phy_info_marvell = {
-        .phy_id         = 0x01410c00,
-        .phy_id_mask    = 0xffffff00,
-        .name           = "Marvell 88E1101/88E1111",
-        .features       = MII_GBIT_FEATURES,
-        .config_aneg    = &marvell_config_aneg,
-        .read_status    = &marvell_read_status,
-        .ack_interrupt  = &marvell_ack_interrupt,
-        .config_intr    = &marvell_config_intr,
-};
-
-static struct phy_info phy_info_genmii= {
-        .phy_id         = 0x00000000,
-        .phy_id_mask    = 0x00000000,
-        .name           = "Generic MII",
-        .features       = MII_BASIC_FEATURES,
-        .config_aneg    = genmii_config_aneg,
-        .read_status    = genmii_read_status,
-};
-
-static struct phy_info *phy_info[] = {
-        &phy_info_cis820x,
-        &phy_info_marvell,
-        &phy_info_dm9161,
-        &phy_info_genmii,
-        NULL
-};
-
-u16 phy_read(struct gfar_mii_info *mii_info, u16 regnum)
-{
-        u16 retval;
-        unsigned long flags;
-
-        spin_lock_irqsave(&mii_info->mdio_lock, flags);
-        retval = mii_info->mdio_read(mii_info->dev, mii_info->mii_id, regnum);
-        spin_unlock_irqrestore(&mii_info->mdio_lock, flags);
-
-        return retval;
-}
-
-void phy_write(struct gfar_mii_info *mii_info, u16 regnum, u16 val)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&mii_info->mdio_lock, flags);
-        mii_info->mdio_write(mii_info->dev, 
-                        mii_info->mii_id, 
-                        regnum, val);
-        spin_unlock_irqrestore(&mii_info->mdio_lock, flags);
-}
-
-/* Use the PHY ID registers to determine what type of PHY is attached
- * to device dev.  return a struct phy_info structure describing that PHY
- */
-struct phy_info * get_phy_info(struct gfar_mii_info *mii_info)
-{
-        u16 phy_reg;
-        u32 phy_ID;
-        int i;
-        struct phy_info *theInfo = NULL;
-        struct net_device *dev = mii_info->dev;
-
-        /* Grab the bits from PHYIR1, and put them in the upper half */
-        phy_reg = phy_read(mii_info, MII_PHYSID1);
-        phy_ID = (phy_reg & 0xffff) << 16;
-
-        /* Grab the bits from PHYIR2, and put them in the lower half */
-        phy_reg = phy_read(mii_info, MII_PHYSID2);
-        phy_ID |= (phy_reg & 0xffff);
-
-        /* loop through all the known PHY types, and find one that */
-        /* matches the ID we read from the PHY. */
-        for (i = 0; phy_info[i]; i++)
-                if (phy_info[i]->phy_id == 
-                                (phy_ID & phy_info[i]->phy_id_mask)) {
-                        theInfo = phy_info[i];
-                        break;
-                }
-
-        /* This shouldn't happen, as we have generic PHY support */
-        if (theInfo == NULL) {
-                printk("%s: PHY id %x is not supported!\n", dev->name, phy_ID);
-                return NULL;
-        } else {
-                printk("%s: PHY is %s (%x)\n", dev->name, theInfo->name,
-                       phy_ID);
-        }
-
-        return theInfo;
-}
diff --git a/drivers/net/gianfar_phy.h b/drivers/net/gianfar_phy.h
deleted file mode 100644
index 1e9b3abf1e6d..000000000000
--- a/drivers/net/gianfar_phy.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/* 
- * drivers/net/gianfar_phy.h
- *
- * Gianfar Ethernet Driver -- PHY handling
- * Driver for FEC on MPC8540 and TSEC on MPC8540/MPC8560
- * Based on 8260_io/fcc_enet.c
- *
- * Author: Andy Fleming
- * Maintainer: Kumar Gala (kumar.gala@freescale.com)
- *
- * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
- *
- * 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.
- *
- */
-#ifndef __GIANFAR_PHY_H
-#define __GIANFAR_PHY_H
-
-#define MII_end ((u32)-2)
-#define MII_read ((u32)-1)
-
-#define MIIMIND_BUSY            0x00000001
-#define MIIMIND_NOTVALID        0x00000004
-
-#define GFAR_AN_TIMEOUT         2000
-
-/* 1000BT control (Marvell & BCM54xx at least) */
-#define MII_1000BASETCONTROL                    0x09
-#define MII_1000BASETCONTROL_FULLDUPLEXCAP      0x0200
-#define MII_1000BASETCONTROL_HALFDUPLEXCAP      0x0100
-
-/* Cicada Extended Control Register 1 */
-#define MII_CIS8201_EXT_CON1           0x17
-#define MII_CIS8201_EXTCON1_INIT       0x0000
-
-/* Cicada Interrupt Mask Register */
-#define MII_CIS8201_IMASK               0x19
-#define MII_CIS8201_IMASK_IEN           0x8000
-#define MII_CIS8201_IMASK_SPEED 0x4000
-#define MII_CIS8201_IMASK_LINK          0x2000
-#define MII_CIS8201_IMASK_DUPLEX        0x1000
-#define MII_CIS8201_IMASK_MASK          0xf000
-
-/* Cicada Interrupt Status Register */
-#define MII_CIS8201_ISTAT               0x1a
-#define MII_CIS8201_ISTAT_STATUS        0x8000
-#define MII_CIS8201_ISTAT_SPEED 0x4000
-#define MII_CIS8201_ISTAT_LINK          0x2000
-#define MII_CIS8201_ISTAT_DUPLEX        0x1000
-
-/* Cicada Auxiliary Control/Status Register */
-#define MII_CIS8201_AUX_CONSTAT        0x1c
-#define MII_CIS8201_AUXCONSTAT_INIT    0x0004
-#define MII_CIS8201_AUXCONSTAT_DUPLEX  0x0020
-#define MII_CIS8201_AUXCONSTAT_SPEED   0x0018
-#define MII_CIS8201_AUXCONSTAT_GBIT    0x0010
-#define MII_CIS8201_AUXCONSTAT_100     0x0008
-                                                                                
-/* 88E1011 PHY Status Register */
-#define MII_M1011_PHY_SPEC_STATUS               0x11
-#define MII_M1011_PHY_SPEC_STATUS_1000          0x8000
-#define MII_M1011_PHY_SPEC_STATUS_100           0x4000
-#define MII_M1011_PHY_SPEC_STATUS_SPD_MASK      0xc000
-#define MII_M1011_PHY_SPEC_STATUS_FULLDUPLEX    0x2000
-#define MII_M1011_PHY_SPEC_STATUS_RESOLVED      0x0800
-#define MII_M1011_PHY_SPEC_STATUS_LINK          0x0400
-
-#define MII_M1011_IEVENT                0x13
-#define MII_M1011_IEVENT_CLEAR          0x0000
-
-#define MII_M1011_IMASK                 0x12
-#define MII_M1011_IMASK_INIT            0x6400
-#define MII_M1011_IMASK_CLEAR           0x0000
-
-#define MII_DM9161_SCR          0x10
-#define MII_DM9161_SCR_INIT     0x0610
-
-/* DM9161 Specified Configuration and Status Register */
-#define MII_DM9161_SCSR 0x11
-#define MII_DM9161_SCSR_100F    0x8000
-#define MII_DM9161_SCSR_100H    0x4000
-#define MII_DM9161_SCSR_10F     0x2000
-#define MII_DM9161_SCSR_10H     0x1000
-
-/* DM9161 Interrupt Register */
-#define MII_DM9161_INTR 0x15
-#define MII_DM9161_INTR_PEND            0x8000
-#define MII_DM9161_INTR_DPLX_MASK       0x0800
-#define MII_DM9161_INTR_SPD_MASK        0x0400
-#define MII_DM9161_INTR_LINK_MASK       0x0200
-#define MII_DM9161_INTR_MASK            0x0100
-#define MII_DM9161_INTR_DPLX_CHANGE     0x0010
-#define MII_DM9161_INTR_SPD_CHANGE      0x0008
-#define MII_DM9161_INTR_LINK_CHANGE     0x0004
-#define MII_DM9161_INTR_INIT            0x0000
-#define MII_DM9161_INTR_STOP    \
-(MII_DM9161_INTR_DPLX_MASK | MII_DM9161_INTR_SPD_MASK \
- | MII_DM9161_INTR_LINK_MASK | MII_DM9161_INTR_MASK)
-
-/* DM9161 10BT Configuration/Status */
-#define MII_DM9161_10BTCSR      0x12
-#define MII_DM9161_10BTCSR_INIT 0x7800
-
-#define MII_BASIC_FEATURES      (SUPPORTED_10baseT_Half | \
-                                 SUPPORTED_10baseT_Full | \
-                                 SUPPORTED_100baseT_Half | \
-                                 SUPPORTED_100baseT_Full | \
-                                 SUPPORTED_Autoneg | \
-                                 SUPPORTED_TP | \
-                                 SUPPORTED_MII)
-
-#define MII_GBIT_FEATURES       (MII_BASIC_FEATURES | \
-                                 SUPPORTED_1000baseT_Half | \
-                                 SUPPORTED_1000baseT_Full)
-
-#define MII_READ_COMMAND       0x00000001
-
-#define MII_INTERRUPT_DISABLED 0x0
-#define MII_INTERRUPT_ENABLED 0x1
-/* Taken from mii_if_info and sungem_phy.h */
-struct gfar_mii_info {
-        /* Information about the PHY type */
-        /* And management functions */
-        struct phy_info *phyinfo;
-
-        /* forced speed & duplex (no autoneg)
-         * partner speed & duplex & pause (autoneg)
-         */
-        int speed;
-        int duplex;
-        int pause;
-
-        /* The most recently read link state */
-        int link;
-
-        /* Enabled Interrupts */
-        u32 interrupts;
-
-        u32 advertising;
-        int autoneg;
-        int mii_id;
-
-        /* private data pointer */
-        /* For use by PHYs to maintain extra state */
-        void *priv;
-
-        /* Provided by host chip */
-        struct net_device *dev;
-
-        /* A lock to ensure that only one thing can read/write
-         * the MDIO bus at a time */
-        spinlock_t mdio_lock;
-
-        /* Provided by ethernet driver */
-        int (*mdio_read) (struct net_device *dev, int mii_id, int reg);
-        void (*mdio_write) (struct net_device *dev, int mii_id, int reg, int val);
-};
-
-/* struct phy_info: a structure which defines attributes for a PHY
- *
- * id will contain a number which represents the PHY.  During
- * startup, the driver will poll the PHY to find out what its
- * UID--as defined by registers 2 and 3--is.  The 32-bit result
- * gotten from the PHY will be ANDed with phy_id_mask to
- * discard any bits which may change based on revision numbers
- * unimportant to functionality
- *
- * There are 6 commands which take a gfar_mii_info structure.
- * Each PHY must declare config_aneg, and read_status.
- */
-struct phy_info {
-        u32 phy_id;
-        char *name;
-        unsigned int phy_id_mask;
-        u32 features;
-
-        /* Called to initialize the PHY */
-        int (*init)(struct gfar_mii_info *mii_info);
-
-        /* Called to suspend the PHY for power */
-        int (*suspend)(struct gfar_mii_info *mii_info);
-
-        /* Reconfigures autonegotiation (or disables it) */
-        int (*config_aneg)(struct gfar_mii_info *mii_info);
-
-        /* Determines the negotiated speed and duplex */
-        int (*read_status)(struct gfar_mii_info *mii_info);
-
-        /* Clears any pending interrupts */
-        int (*ack_interrupt)(struct gfar_mii_info *mii_info);
-
-        /* Enables or disables interrupts */
-        int (*config_intr)(struct gfar_mii_info *mii_info);
-
-        /* Clears up any memory if needed */
-        void (*close)(struct gfar_mii_info *mii_info);
-};
-
-struct phy_info *get_phy_info(struct gfar_mii_info *mii_info);
-int read_phy_reg(struct net_device *dev, int mii_id, int regnum);
-void write_phy_reg(struct net_device *dev, int mii_id, int regnum, int value);
-void mii_clear_phy_interrupt(struct gfar_mii_info *mii_info);
-void mii_configure_phy_interrupt(struct gfar_mii_info *mii_info, u32 interrupts);
-
-struct dm9161_private {
-        struct timer_list timer;
-        int resetdone;
-};
-
-#endif /* GIANFAR_PHY_H */
diff --git a/drivers/net/hamradio/Kconfig b/drivers/net/hamradio/Kconfig
index de087cd609d9..896aa02000d7 100644
--- a/drivers/net/hamradio/Kconfig
+++ b/drivers/net/hamradio/Kconfig
@@ -1,6 +1,7 @@
 config MKISS
         tristate "Serial port KISS driver"
         depends on AX25
+        select CRC16
         ---help---
           KISS is a protocol used for the exchange of data between a computer
           and a Terminal Node Controller (a small embedded system commonly
diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c
index 1756f0ed54cc..cb43a9d28774 100644
--- a/drivers/net/hamradio/bpqether.c
+++ b/drivers/net/hamradio/bpqether.c
@@ -144,7 +144,7 @@ static inline struct net_device *bpq_get_ax25_dev(struct net_device *dev)
 {
         struct bpqdev *bpq;
 
-        list_for_each_entry(bpq, &bpq_devices, bpq_list) {
+        list_for_each_entry_rcu(bpq, &bpq_devices, bpq_list) {
                 if (bpq->ethdev == dev)
                         return bpq->axdev;
         }
@@ -399,7 +399,7 @@ static void *bpq_seq_start(struct seq_file *seq, loff_t *pos)
         if (*pos == 0)
                 return SEQ_START_TOKEN;
         
-        list_for_each_entry(bpqdev, &bpq_devices, bpq_list) {
+        list_for_each_entry_rcu(bpqdev, &bpq_devices, bpq_list) {
                 if (i == *pos)
                         return bpqdev;
         }
@@ -418,7 +418,7 @@ static void *bpq_seq_next(struct seq_file *seq, void *v, loff_t *pos)
                 p = ((struct bpqdev *)v)->bpq_list.next;
 
         return (p == &bpq_devices) ? NULL 
-                : list_entry(p, struct bpqdev, bpq_list);
+                : rcu_dereference(list_entry(p, struct bpqdev, bpq_list));
 }
 
 static void bpq_seq_stop(struct seq_file *seq, void *v)
@@ -561,8 +561,6 @@ static int bpq_device_event(struct notifier_block *this,unsigned long event, voi
         if (!dev_is_ethdev(dev))
                 return NOTIFY_DONE;
 
-        rcu_read_lock();
-
         switch (event) {
         case NETDEV_UP:         /* new ethernet device -> new BPQ interface */
                 if (bpq_get_ax25_dev(dev) == NULL)
@@ -581,7 +579,6 @@ static int bpq_device_event(struct notifier_block *this,unsigned long event, voi
         default:
                 break;
         }
-        rcu_read_unlock();
 
         return NOTIFY_DONE;
 }
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index d9fe64b46f4b..3e9accf137e7 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -14,13 +14,14 @@
  *
  * Copyright (C) Hans Alblas PE1AYX <hans@esrac.ele.tue.nl>
  * Copyright (C) 2004, 05 Ralf Baechle DL5RB <ralf@linux-mips.org>
+ * Copyright (C) 2004, 05 Thomas Osterried DL9SAU <thomas@x-berg.in-berlin.de>
  */
-
 #include <linux/config.h>
 #include <linux/module.h>
 #include <asm/system.h>
 #include <linux/bitops.h>
 #include <asm/uaccess.h>
+#include <linux/crc16.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
@@ -39,11 +40,6 @@
 
 #include <net/ax25.h>
 
-#ifdef CONFIG_INET
-#include <linux/ip.h>
-#include <linux/tcp.h>
-#endif
-
 #define AX_MTU          236
 
 /* SLIP/KISS protocol characters. */
@@ -80,9 +76,13 @@ struct mkiss {
 
         int             mode;
         int             crcmode;        /* MW: for FlexNet, SMACK etc.  */
-#define CRC_MODE_NONE   0
-#define CRC_MODE_FLEX   1
-#define CRC_MODE_SMACK  2
+        int             crcauto;        /* CRC auto mode */
+
+#define CRC_MODE_NONE           0
+#define CRC_MODE_FLEX           1
+#define CRC_MODE_SMACK          2
+#define CRC_MODE_FLEX_TEST      3
+#define CRC_MODE_SMACK_TEST     4
 
         atomic_t                refcnt;
         struct semaphore        dead_sem;
@@ -151,6 +151,21 @@ static int check_crc_flex(unsigned char *cp, int size)
         return 0;
 }
 
+static int check_crc_16(unsigned char *cp, int size)
+{
+        unsigned short crc = 0x0000;
+
+        if (size < 3)
+                return -1;
+
+        crc = crc16(0, cp, size);
+
+        if (crc != 0x0000)
+                return -1;
+
+        return 0;
+}
+
 /*
  * Standard encapsulation
  */
@@ -237,19 +252,42 @@ static void ax_bump(struct mkiss *ax)
 
         spin_lock_bh(&ax->buflock);
         if (ax->rbuff[0] > 0x0f) {
-                if (ax->rbuff[0] & 0x20) {
-                        ax->crcmode = CRC_MODE_FLEX;
+                if (ax->rbuff[0] & 0x80) {
+                        if (check_crc_16(ax->rbuff, ax->rcount) < 0) {
+                                ax->stats.rx_errors++;
+                                spin_unlock_bh(&ax->buflock);
+
+                                return;
+                        }
+                        if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) {
+                                printk(KERN_INFO
+                                       "mkiss: %s: Switchting to crc-smack\n",
+                                       ax->dev->name);
+                                ax->crcmode = CRC_MODE_SMACK;
+                        }
+                        ax->rcount -= 2;
+                        *ax->rbuff &= ~0x80;
+                } else if (ax->rbuff[0] & 0x20)  {
                         if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
-                                ax->stats.rx_errors++;
+                                ax->stats.rx_errors++;
+                                spin_unlock_bh(&ax->buflock);
                                 return;
                         }
+                        if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
+                                printk(KERN_INFO
+                                       "mkiss: %s: Switchting to crc-flexnet\n",
+                                       ax->dev->name);
+                                ax->crcmode = CRC_MODE_FLEX;
+                        }
                         ax->rcount -= 2;
-                        /* dl9sau bugfix: the trailling two bytes flexnet crc
-                         * will not be passed to the kernel. thus we have
-                         * to correct the kissparm signature, because it
-                         * indicates a crc but there's none
+
+                        /*
+                         * dl9sau bugfix: the trailling two bytes flexnet crc
+                         * will not be passed to the kernel. thus we have to
+                         * correct the kissparm signature, because it indicates
+                         * a crc but there's none
                          */
-                        *ax->rbuff &= ~0x20;
+                        *ax->rbuff &= ~0x20;
                 }
         }
         spin_unlock_bh(&ax->buflock);
@@ -352,10 +390,8 @@ static void ax_changedmtu(struct mkiss *ax)
                        "MTU change cancelled.\n",
                        ax->dev->name);
                 dev->mtu = ax->mtu;
-                if (xbuff != NULL)
-                        kfree(xbuff);
-                if (rbuff != NULL)
-                        kfree(rbuff);
+                kfree(xbuff);
+                kfree(rbuff);
                 return;
         }
 
@@ -417,20 +453,69 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
         p = icp;
 
         spin_lock_bh(&ax->buflock);
-        switch (ax->crcmode) {
-                 unsigned short crc;
+        if ((*p & 0x0f) != 0) {
+                /* Configuration Command (kissparms(1).
+                 * Protocol spec says: never append CRC.
+                 * This fixes a very old bug in the linux
+                 * kiss driver. -- dl9sau */
+                switch (*p & 0xff) {
+                case 0x85:
+                        /* command from userspace especially for us,
+                         * not for delivery to the tnc */
+                        if (len > 1) {
+                                int cmd = (p[1] & 0xff);
+                                switch(cmd) {
+                                case 3:
+                                  ax->crcmode = CRC_MODE_SMACK;
+                                  break;
+                                case 2:
+                                  ax->crcmode = CRC_MODE_FLEX;
+                                  break;
+                                case 1:
+                                  ax->crcmode = CRC_MODE_NONE;
+                                  break;
+                                case 0:
+                                default:
+                                  ax->crcmode = CRC_MODE_SMACK_TEST;
+                                  cmd = 0;
+                                }
+                                ax->crcauto = (cmd ? 0 : 1);
+                                printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
+                        }
+                        spin_unlock_bh(&ax->buflock);
+                        netif_start_queue(dev);
 
-        case CRC_MODE_FLEX:
-                 *p |= 0x20;
-                 crc = calc_crc_flex(p, len);
-                 count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
-                 break;
+                        return;
+                default:
+                        count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
+                }
+        } else {
+                unsigned short crc;
+                switch (ax->crcmode) {
+                case CRC_MODE_SMACK_TEST:
+                        ax->crcmode  = CRC_MODE_FLEX_TEST;
+                        printk(KERN_INFO "mkiss: %s: Trying crc-smack\n", ax->dev->name);
+                        // fall through
+                case CRC_MODE_SMACK:
+                        *p |= 0x80;
+                        crc = swab16(crc16(0, p, len));
+                        count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
+                        break;
+                case CRC_MODE_FLEX_TEST:
+                        ax->crcmode = CRC_MODE_NONE;
+                        printk(KERN_INFO "mkiss: %s: Trying crc-flexnet\n", ax->dev->name);
+                        // fall through
+                case CRC_MODE_FLEX:
+                        *p |= 0x20;
+                        crc = calc_crc_flex(p, len);
+                        count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
+                        break;
+
+                default:
+                        count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
+                }
+        }
 
-        default:
-                 count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
-                 break;
-        }
-        
         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
         actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
         ax->stats.tx_packets++;
@@ -439,8 +524,6 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
         ax->dev->trans_start = jiffies;
         ax->xleft = count - actual;
         ax->xhead = ax->xbuff + actual;
-
-        spin_unlock_bh(&ax->buflock);
 }
 
 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
@@ -622,7 +705,7 @@ static void ax_setup(struct net_device *dev)
  * best way to fix this is to use a rwlock in the tty struct, but for now we
  * use a single global rwlock for all ttys in ppp line discipline.
  */
-static rwlock_t disc_data_lock = RW_LOCK_UNLOCKED;
+static DEFINE_RWLOCK(disc_data_lock);
 
 static struct mkiss *mkiss_get(struct tty_struct *tty)
 {
@@ -643,6 +726,8 @@ static void mkiss_put(struct mkiss *ax)
                 up(&ax->dead_sem);
 }
 
+static int crc_force = 0;       /* Can be overridden with insmod */
+
 static int mkiss_open(struct tty_struct *tty)
 {
         struct net_device *dev;
@@ -682,6 +767,33 @@ static int mkiss_open(struct tty_struct *tty)
         if (register_netdev(dev))
                 goto out_free_buffers;
 
+        /* after register_netdev() - because else printk smashes the kernel */
+        switch (crc_force) {
+        case 3:
+                ax->crcmode  = CRC_MODE_SMACK;
+                printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
+                       ax->dev->name);
+                break;
+        case 2:
+                ax->crcmode  = CRC_MODE_FLEX;
+                printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
+                       ax->dev->name);
+                break;
+        case 1:
+                ax->crcmode  = CRC_MODE_NONE;
+                printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
+                       ax->dev->name);
+                break;
+        case 0:
+                /* fall through */
+        default:
+                crc_force = 0;
+                printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
+                       ax->dev->name);
+                ax->crcmode  = CRC_MODE_SMACK_TEST;
+        }
+        ax->crcauto = (crc_force ? 0 : 1);
+
         netif_start_queue(dev);
 
         /* Done.  We have linked the TTY line to a channel. */
@@ -765,7 +877,6 @@ static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
 
         case SIOCSIFHWADDR: {
                 char addr[AX25_ADDR_LEN];
-printk(KERN_INFO "In SIOCSIFHWADDR");
 
                 if (copy_from_user(&addr,
                                    (void __user *) arg, AX25_ADDR_LEN)) {
@@ -864,6 +975,7 @@ out:
 }
 
 static struct tty_ldisc ax_ldisc = {
+        .owner          = THIS_MODULE,
         .magic          = TTY_LDISC_MAGIC,
         .name           = "mkiss",
         .open           = mkiss_open,
@@ -904,6 +1016,8 @@ static void __exit mkiss_exit_driver(void)
 
 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
+MODULE_PARM(crc_force, "i");
+MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_LDISC(N_AX25);
 
diff --git a/drivers/net/hamradio/mkiss.h b/drivers/net/hamradio/mkiss.h
deleted file mode 100644
index 4ab700478598..000000000000
--- a/drivers/net/hamradio/mkiss.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/****************************************************************************
- *      Defines for the Multi-KISS driver.
- ****************************************************************************/
-
-#define AX25_MAXDEV     16              /* MAX number of AX25 channels;
-                                           This can be overridden with
-                                           insmod -oax25_maxdev=nnn     */
-#define AX_MTU          236     
-
-/* SLIP/KISS protocol characters. */
-#define END             0300            /* indicates end of frame       */
-#define ESC             0333            /* indicates byte stuffing      */
-#define ESC_END         0334            /* ESC ESC_END means END 'data' */
-#define ESC_ESC         0335            /* ESC ESC_ESC means ESC 'data' */
-
-struct ax_disp {
-        int                magic;
-
-        /* Various fields. */
-        struct tty_struct  *tty;                /* ptr to TTY structure         */
-        struct net_device      *dev;            /* easy for intr handling       */
-
-        /* These are pointers to the malloc()ed frame buffers. */
-        unsigned char      *rbuff;              /* receiver buffer              */
-        int                rcount;              /* received chars counter       */
-        unsigned char      *xbuff;              /* transmitter buffer           */
-        unsigned char      *xhead;              /* pointer to next byte to XMIT */
-        int                xleft;               /* bytes left in XMIT queue     */
-
-        /* SLIP interface statistics. */
-        unsigned long      rx_packets;          /* inbound frames counter       */
-        unsigned long      tx_packets;          /* outbound frames counter      */
-        unsigned long      rx_bytes;            /* inbound bytes counter        */
-        unsigned long      tx_bytes;            /* outbound bytes counter       */
-        unsigned long      rx_errors;           /* Parity, etc. errors          */
-        unsigned long      tx_errors;           /* Planned stuff                */
-        unsigned long      rx_dropped;          /* No memory for skb            */
-        unsigned long      tx_dropped;          /* When MTU change              */
-        unsigned long      rx_over_errors;      /* Frame bigger then SLIP buf.  */
-
-        /* Detailed SLIP statistics. */
-        int                 mtu;                /* Our mtu (to spot changes!)   */
-        int                 buffsize;           /* Max buffers sizes            */
-
-
-        unsigned long   flags;          /* Flag values/ mode etc        */
-                                        /* long req'd: used by set_bit --RR */
-#define AXF_INUSE       0               /* Channel in use               */
-#define AXF_ESCAPE      1               /* ESC received                 */
-#define AXF_ERROR       2               /* Parity, etc. error           */
-#define AXF_KEEPTEST    3               /* Keepalive test flag          */
-#define AXF_OUTWAIT     4               /* is outpacket was flag        */
-
-        int                 mode;
-        int                 crcmode;    /* MW: for FlexNet, SMACK etc.  */ 
-#define CRC_MODE_NONE   0
-#define CRC_MODE_FLEX   1
-#define CRC_MODE_SMACK  2
-        spinlock_t          buflock;    /* lock for rbuf and xbuf */
-};
-
-#define AX25_MAGIC              0x5316
diff --git a/drivers/net/hp100.c b/drivers/net/hp100.c
index cf0ac6fda1a1..b71fab6e34f4 100644
--- a/drivers/net/hp100.c
+++ b/drivers/net/hp100.c
@@ -2517,10 +2517,8 @@ static int hp100_down_vg_link(struct net_device *dev)
         do {
                 if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
                         break;
-                if (!in_interrupt()) {
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        schedule_timeout(1);
-                }
+                if (!in_interrupt())
+                        schedule_timeout_interruptible(1);
         } while (time_after(time, jiffies));
 
         if (time_after_eq(jiffies, time))       /* no signal->no logout */
@@ -2536,10 +2534,8 @@ static int hp100_down_vg_link(struct net_device *dev)
         do {
                 if (!(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
                         break;
-                if (!in_interrupt()) {
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        schedule_timeout(1);
-                }
+                if (!in_interrupt())
+                        schedule_timeout_interruptible(1);
         } while (time_after(time, jiffies));
 
 #ifdef HP100_DEBUG
@@ -2577,10 +2573,8 @@ static int hp100_down_vg_link(struct net_device *dev)
                 do {
                         if (!(hp100_inb(MAC_CFG_4) & HP100_MAC_SEL_ST))
                                 break;
-                        if (!in_interrupt()) {
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                schedule_timeout(1);
-                        }
+                        if (!in_interrupt())
+                                schedule_timeout_interruptible(1);
                 } while (time_after(time, jiffies));
 
                 hp100_orb(HP100_AUTO_MODE, MAC_CFG_3);  /* Autosel back on */
@@ -2591,10 +2585,8 @@ static int hp100_down_vg_link(struct net_device *dev)
         do {
                 if ((hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST) == 0)
                         break;
-                if (!in_interrupt()) {
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        schedule_timeout(1);
-                }
+                if (!in_interrupt())
+                        schedule_timeout_interruptible(1);
         } while (time_after(time, jiffies));
 
         if (time_before_eq(time, jiffies)) {
@@ -2606,10 +2598,8 @@ static int hp100_down_vg_link(struct net_device *dev)
 
         time = jiffies + (2 * HZ);      /* This seems to take a while.... */
         do {
-                if (!in_interrupt()) {
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        schedule_timeout(1);
-                }
+                if (!in_interrupt())
+                        schedule_timeout_interruptible(1);
         } while (time_after(time, jiffies));
 
         return 0;
@@ -2659,10 +2649,8 @@ static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
                 do {
                         if (~(hp100_inb(VG_LAN_CFG_1) & HP100_LINK_UP_ST))
                                 break;
-                        if (!in_interrupt()) {
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                schedule_timeout(1);
-                        }
+                        if (!in_interrupt())
+                                schedule_timeout_interruptible(1);
                 } while (time_after(time, jiffies));
 
                 /* Start an addressed training and optionally request promiscuous port */
@@ -2697,10 +2685,8 @@ static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
                 do {
                         if (hp100_inb(VG_LAN_CFG_1) & HP100_LINK_CABLE_ST)
                                 break;
-                        if (!in_interrupt()) {
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                schedule_timeout(1);
-                        }
+                        if (!in_interrupt())
+                                schedule_timeout_interruptible(1);
                 } while (time_before(jiffies, time));
 
                 if (time_after_eq(jiffies, time)) {
@@ -2723,10 +2709,8 @@ static int hp100_login_to_vg_hub(struct net_device *dev, u_short force_relogin)
 #endif
                                         break;
                                 }
-                                if (!in_interrupt()) {
-                                        set_current_state(TASK_INTERRUPTIBLE);
-                                        schedule_timeout(1);
-                                }
+                                if (!in_interrupt())
+                                        schedule_timeout_interruptible(1);
                         } while (time_after(time, jiffies));
                 }
 
diff --git a/drivers/net/ibm_emac/Makefile b/drivers/net/ibm_emac/Makefile
index 7f583a333c24..f98ddf0e807a 100644
--- a/drivers/net/ibm_emac/Makefile
+++ b/drivers/net/ibm_emac/Makefile
@@ -1,12 +1,11 @@
 #
-# Makefile for the IBM PPC4xx EMAC controllers
+# Makefile for the PowerPC 4xx on-chip ethernet driver
 #
 
 obj-$(CONFIG_IBM_EMAC) += ibm_emac.o
 
-ibm_emac-objs := ibm_emac_mal.o ibm_emac_core.o ibm_emac_phy.o
-
-# Only need this if you want to see additional debug messages
-ifeq ($(CONFIG_IBM_EMAC_ERRMSG), y)
-ibm_emac-objs += ibm_emac_debug.o
-endif
+ibm_emac-objs := ibm_emac_mal.o ibm_emac_core.o ibm_emac_phy.o 
+ibm_emac-$(CONFIG_IBM_EMAC_ZMII) += ibm_emac_zmii.o
+ibm_emac-$(CONFIG_IBM_EMAC_RGMII) += ibm_emac_rgmii.o
+ibm_emac-$(CONFIG_IBM_EMAC_TAH) += ibm_emac_tah.o
+ibm_emac-$(CONFIG_IBM_EMAC_DEBUG) += ibm_emac_debug.o
diff --git a/drivers/net/ibm_emac/ibm_emac.h b/drivers/net/ibm_emac/ibm_emac.h
index 15d5a0e82862..28c476f28c20 100644
--- a/drivers/net/ibm_emac/ibm_emac.h
+++ b/drivers/net/ibm_emac/ibm_emac.h
@@ -1,110 +1,142 @@
 /*
- * ibm_emac.h
+ * drivers/net/ibm_emac/ibm_emac.h
  *
+ * Register definitions for PowerPC 4xx on-chip ethernet contoller
  *
- *      Armin Kuster akuster@mvista.com
- *      June, 2002
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2002 MontaVista Softare Inc.
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002-2004 MontaVista Software Inc.
  *
  * 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.
+ *
  */
+#ifndef __IBM_EMAC_H_
+#define __IBM_EMAC_H_
+
+#include <linux/config.h>
+#include <linux/types.h>
+
+/* This is a simple check to prevent use of this driver on non-tested SoCs */
+#if !defined(CONFIG_405GP) && !defined(CONFIG_405GPR) && !defined(CONFIG_405EP) && \
+    !defined(CONFIG_440GP) && !defined(CONFIG_440GX) && !defined(CONFIG_440SP) && \
+    !defined(CONFIG_440EP) && !defined(CONFIG_NP405H)
+#error  "Unknown SoC. Please, check chip user manual and make sure EMAC defines are OK"
+#endif
+
+/* EMAC registers               Write Access rules */
+struct emac_regs {
+        u32 mr0;                /* special      */
+        u32 mr1;                /* Reset        */
+        u32 tmr0;               /* special      */
+        u32 tmr1;               /* special      */
+        u32 rmr;                /* Reset        */
+        u32 isr;                /* Always       */
+        u32 iser;               /* Reset        */
+        u32 iahr;               /* Reset, R, T  */
+        u32 ialr;               /* Reset, R, T  */
+        u32 vtpid;              /* Reset, R, T  */
+        u32 vtci;               /* Reset, R, T  */
+        u32 ptr;                /* Reset,    T  */
+        u32 iaht1;              /* Reset, R     */
+        u32 iaht2;              /* Reset, R     */
+        u32 iaht3;              /* Reset, R     */
+        u32 iaht4;              /* Reset, R     */
+        u32 gaht1;              /* Reset, R     */
+        u32 gaht2;              /* Reset, R     */
+        u32 gaht3;              /* Reset, R     */
+        u32 gaht4;              /* Reset, R     */
+        u32 lsah;
+        u32 lsal;
+        u32 ipgvr;              /* Reset,    T  */
+        u32 stacr;              /* special      */
+        u32 trtr;               /* special      */
+        u32 rwmr;               /* Reset        */
+        u32 octx;
+        u32 ocrx;
+        u32 ipcr;
+};
+
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_ETHTOOL_REGS_VER           0
+#define EMAC_ETHTOOL_REGS_SIZE          (sizeof(struct emac_regs) - sizeof(u32))
+#else
+#define EMAC_ETHTOOL_REGS_VER           1
+#define EMAC_ETHTOOL_REGS_SIZE          sizeof(struct emac_regs)
+#endif
 
-#ifndef _IBM_EMAC_H_
-#define _IBM_EMAC_H_
-/* General defines needed for the driver */
+/* EMACx_MR0 */
+#define EMAC_MR0_RXI                    0x80000000
+#define EMAC_MR0_TXI                    0x40000000
+#define EMAC_MR0_SRST                   0x20000000
+#define EMAC_MR0_TXE                    0x10000000
+#define EMAC_MR0_RXE                    0x08000000
+#define EMAC_MR0_WKE                    0x04000000
 
-/* Emac */
-typedef struct emac_regs {
-        u32 em0mr0;
-        u32 em0mr1;
-        u32 em0tmr0;
-        u32 em0tmr1;
-        u32 em0rmr;
-        u32 em0isr;
-        u32 em0iser;
-        u32 em0iahr;
-        u32 em0ialr;
-        u32 em0vtpid;
-        u32 em0vtci;
-        u32 em0ptr;
-        u32 em0iaht1;
-        u32 em0iaht2;
-        u32 em0iaht3;
-        u32 em0iaht4;
-        u32 em0gaht1;
-        u32 em0gaht2;
-        u32 em0gaht3;
-        u32 em0gaht4;
-        u32 em0lsah;
-        u32 em0lsal;
-        u32 em0ipgvr;
-        u32 em0stacr;
-        u32 em0trtr;
-        u32 em0rwmr;
-} emac_t;
+/* EMACx_MR1 */
+#define EMAC_MR1_FDE                    0x80000000
+#define EMAC_MR1_ILE                    0x40000000
+#define EMAC_MR1_VLE                    0x20000000
+#define EMAC_MR1_EIFC                   0x10000000
+#define EMAC_MR1_APP                    0x08000000
+#define EMAC_MR1_IST                    0x01000000
 
-/* MODE REG 0 */
-#define EMAC_M0_RXI                     0x80000000
-#define EMAC_M0_TXI                     0x40000000
-#define EMAC_M0_SRST                    0x20000000
-#define EMAC_M0_TXE                     0x10000000
-#define EMAC_M0_RXE                     0x08000000
-#define EMAC_M0_WKE                     0x04000000
+#define EMAC_MR1_MF_MASK                0x00c00000
+#define EMAC_MR1_MF_10                  0x00000000
+#define EMAC_MR1_MF_100                 0x00400000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_MR1_MF_1000                0x00000000
+#define EMAC_MR1_MF_1000GPCS            0x00000000
+#define EMAC_MR1_MF_IPPA(id)            0x00000000
+#else
+#define EMAC_MR1_MF_1000                0x00800000
+#define EMAC_MR1_MF_1000GPCS            0x00c00000
+#define EMAC_MR1_MF_IPPA(id)            (((id) & 0x1f) << 6)
+#endif
 
-/* MODE Reg 1 */
-#define EMAC_M1_FDE                     0x80000000
-#define EMAC_M1_ILE                     0x40000000
-#define EMAC_M1_VLE                     0x20000000
-#define EMAC_M1_EIFC                    0x10000000
-#define EMAC_M1_APP                     0x08000000
-#define EMAC_M1_AEMI                    0x02000000
-#define EMAC_M1_IST                     0x01000000
-#define EMAC_M1_MF_1000GPCS             0x00c00000      /* Internal GPCS */
-#define EMAC_M1_MF_1000MBPS             0x00800000      /* External GPCS */
-#define EMAC_M1_MF_100MBPS              0x00400000
-#define EMAC_M1_RFS_16K                 0x00280000      /* 000 for 512 byte */
-#define EMAC_M1_TR                      0x00008000
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_M1_RFS_8K                  0x00200000
-#define EMAC_M1_RFS_4K                  0x00180000
-#define EMAC_M1_RFS_2K                  0x00100000
-#define EMAC_M1_RFS_1K                  0x00080000
-#define EMAC_M1_TX_FIFO_16K             0x00050000      /* 0's for 512 byte */
-#define EMAC_M1_TX_FIFO_8K              0x00040000
-#define EMAC_M1_TX_FIFO_4K              0x00030000
-#define EMAC_M1_TX_FIFO_2K              0x00020000
-#define EMAC_M1_TX_FIFO_1K              0x00010000
-#define EMAC_M1_TX_TR                   0x00008000
-#define EMAC_M1_TX_MWSW                 0x00001000      /* 0 wait for status */
-#define EMAC_M1_JUMBO_ENABLE            0x00000800      /* Upt to 9Kr status */
-#define EMAC_M1_OPB_CLK_66              0x00000008      /* 66Mhz */
-#define EMAC_M1_OPB_CLK_83              0x00000010      /* 83Mhz */
-#define EMAC_M1_OPB_CLK_100             0x00000018      /* 100Mhz */
-#define EMAC_M1_OPB_CLK_100P            0x00000020      /* 100Mhz+ */
-#else                           /* CONFIG_IBM_EMAC4 */
-#define EMAC_M1_RFS_4K                  0x00300000      /* ~4k for 512 byte */
-#define EMAC_M1_RFS_2K                  0x00200000
-#define EMAC_M1_RFS_1K                  0x00100000
-#define EMAC_M1_TX_FIFO_2K              0x00080000      /* 0's for 512 byte */
-#define EMAC_M1_TX_FIFO_1K              0x00040000
-#define EMAC_M1_TR0_DEPEND              0x00010000      /* 0'x for single packet */
-#define EMAC_M1_TR1_DEPEND              0x00004000
-#define EMAC_M1_TR1_MULTI               0x00002000
-#define EMAC_M1_JUMBO_ENABLE            0x00001000
-#endif                          /* CONFIG_IBM_EMAC4 */
-#define EMAC_M1_BASE                    (EMAC_M1_TX_FIFO_2K | \
-                                        EMAC_M1_APP | \
-                                        EMAC_M1_TR | EMAC_M1_VLE)
+#define EMAC_TX_FIFO_SIZE               2048
 
-/* Transmit Mode Register 0 */
-#define EMAC_TMR0_GNP0                  0x80000000
-#define EMAC_TMR0_GNP1                  0x40000000
-#define EMAC_TMR0_GNPD                  0x20000000
-#define EMAC_TMR0_FC                    0x10000000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_MR1_RFS_4K                 0x00300000
+#define EMAC_MR1_RFS_16K                0x00000000
+#define EMAC_RX_FIFO_SIZE(gige)         4096
+#define EMAC_MR1_TFS_2K                 0x00080000
+#define EMAC_MR1_TR0_MULT               0x00008000
+#define EMAC_MR1_JPSM                   0x00000000
+#define EMAC_MR1_BASE(opb)              (EMAC_MR1_TFS_2K | EMAC_MR1_TR0_MULT)
+#else
+#define EMAC_MR1_RFS_4K                 0x00180000
+#define EMAC_MR1_RFS_16K                0x00280000
+#define EMAC_RX_FIFO_SIZE(gige)         ((gige) ? 16384 : 4096)
+#define EMAC_MR1_TFS_2K                 0x00020000
+#define EMAC_MR1_TR                     0x00008000
+#define EMAC_MR1_MWSW_001               0x00001000
+#define EMAC_MR1_JPSM                   0x00000800
+#define EMAC_MR1_OBCI_MASK              0x00000038
+#define EMAC_MR1_OBCI_50                0x00000000
+#define EMAC_MR1_OBCI_66                0x00000008
+#define EMAC_MR1_OBCI_83                0x00000010
+#define EMAC_MR1_OBCI_100               0x00000018
+#define EMAC_MR1_OBCI_100P              0x00000020
+#define EMAC_MR1_OBCI(freq)             ((freq) <= 50  ? EMAC_MR1_OBCI_50 : \
+                                         (freq) <= 66  ? EMAC_MR1_OBCI_66 : \
+                                         (freq) <= 83  ? EMAC_MR1_OBCI_83 : \
+                                         (freq) <= 100 ? EMAC_MR1_OBCI_100 : EMAC_MR1_OBCI_100P)
+#define EMAC_MR1_BASE(opb)              (EMAC_MR1_TFS_2K | EMAC_MR1_TR | \
+                                         EMAC_MR1_MWSW_001 | EMAC_MR1_OBCI(opb))
+#endif
+
+/* EMACx_TMR0 */
+#define EMAC_TMR0_GNP                   0x80000000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TMR0_DEFAULT               0x00000000      
+#else
 #define EMAC_TMR0_TFAE_2_32             0x00000001
 #define EMAC_TMR0_TFAE_4_64             0x00000002
 #define EMAC_TMR0_TFAE_8_128            0x00000003
@@ -112,14 +144,36 @@ typedef struct emac_regs {
 #define EMAC_TMR0_TFAE_32_512           0x00000005
 #define EMAC_TMR0_TFAE_64_1024          0x00000006
 #define EMAC_TMR0_TFAE_128_2048         0x00000007
+#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_2_32
+#endif
+#define EMAC_TMR0_XMIT                  (EMAC_TMR0_GNP | EMAC_TMR0_DEFAULT)
+
+/* EMACx_TMR1 */
+
+/* IBM manuals are not very clear here. 
+ * This is my interpretation of how things are. --ebs
+ */
+#if defined(CONFIG_40x)
+#define EMAC_FIFO_ENTRY_SIZE            8
+#define EMAC_MAL_BURST_SIZE             (16 * 4)
+#else
+#define EMAC_FIFO_ENTRY_SIZE            16
+#define EMAC_MAL_BURST_SIZE             (64 * 4)
+#endif
+
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TMR1(l,h)                  (((l) << 27) | (((h) & 0xff) << 16))
+#else
+#define EMAC_TMR1(l,h)                  (((l) << 27) | (((h) & 0x3ff) << 14))
+#endif
 
-/* Receive Mode Register */
+/* EMACx_RMR */
 #define EMAC_RMR_SP                     0x80000000
 #define EMAC_RMR_SFCS                   0x40000000
-#define EMAC_RMR_ARRP                   0x20000000
-#define EMAC_RMR_ARP                    0x10000000
-#define EMAC_RMR_AROP                   0x08000000
-#define EMAC_RMR_ARPI                   0x04000000
+#define EMAC_RMR_RRP                    0x20000000
+#define EMAC_RMR_RFP                    0x10000000
+#define EMAC_RMR_ROP                    0x08000000
+#define EMAC_RMR_RPIR                   0x04000000
 #define EMAC_RMR_PPP                    0x02000000
 #define EMAC_RMR_PME                    0x01000000
 #define EMAC_RMR_PMME                   0x00800000
@@ -127,6 +181,9 @@ typedef struct emac_regs {
 #define EMAC_RMR_MIAE                   0x00200000
 #define EMAC_RMR_BAE                    0x00100000
 #define EMAC_RMR_MAE                    0x00080000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_RMR_BASE                   0x00000000
+#else
 #define EMAC_RMR_RFAF_2_32              0x00000001
 #define EMAC_RMR_RFAF_4_64              0x00000002
 #define EMAC_RMR_RFAF_8_128             0x00000003
@@ -134,9 +191,21 @@ typedef struct emac_regs {
 #define EMAC_RMR_RFAF_32_512            0x00000005
 #define EMAC_RMR_RFAF_64_1024           0x00000006
 #define EMAC_RMR_RFAF_128_2048          0x00000007
-#define EMAC_RMR_BASE                   (EMAC_RMR_IAE | EMAC_RMR_BAE)
+#define EMAC_RMR_BASE                   EMAC_RMR_RFAF_128_2048
+#endif
 
-/* Interrupt Status & enable Regs */
+/* EMACx_ISR & EMACx_ISER */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_ISR_TXPE                   0x00000000
+#define EMAC_ISR_RXPE                   0x00000000
+#define EMAC_ISR_TXUE                   0x00000000
+#define EMAC_ISR_RXOE                   0x00000000
+#else
+#define EMAC_ISR_TXPE                   0x20000000
+#define EMAC_ISR_RXPE                   0x10000000
+#define EMAC_ISR_TXUE                   0x08000000
+#define EMAC_ISR_RXOE                   0x04000000
+#endif
 #define EMAC_ISR_OVR                    0x02000000
 #define EMAC_ISR_PP                     0x01000000
 #define EMAC_ISR_BP                     0x00800000
@@ -147,53 +216,62 @@ typedef struct emac_regs {
 #define EMAC_ISR_PTLE                   0x00040000
 #define EMAC_ISR_ORE                    0x00020000
 #define EMAC_ISR_IRE                    0x00010000
-#define EMAC_ISR_DBDM                   0x00000200
-#define EMAC_ISR_DB0                    0x00000100
-#define EMAC_ISR_SE0                    0x00000080
-#define EMAC_ISR_TE0                    0x00000040
-#define EMAC_ISR_DB1                    0x00000020
-#define EMAC_ISR_SE1                    0x00000010
-#define EMAC_ISR_TE1                    0x00000008
+#define EMAC_ISR_SQE                    0x00000080
+#define EMAC_ISR_TE                     0x00000040
 #define EMAC_ISR_MOS                    0x00000002
 #define EMAC_ISR_MOF                    0x00000001
 
-/* STA CONTROL REG */
+/* EMACx_STACR */
+#define EMAC_STACR_PHYD_MASK            0xffff
+#define EMAC_STACR_PHYD_SHIFT           16
 #define EMAC_STACR_OC                   0x00008000
 #define EMAC_STACR_PHYE                 0x00004000
-#define EMAC_STACR_WRITE                0x00002000
-#define EMAC_STACR_READ                 0x00001000
-#define EMAC_STACR_CLK_83MHZ            0x00000800      /* 0's for 50Mhz */
-#define EMAC_STACR_CLK_66MHZ            0x00000400
-#define EMAC_STACR_CLK_100MHZ           0x00000C00
+#define EMAC_STACR_STAC_MASK            0x00003000
+#define EMAC_STACR_STAC_READ            0x00001000
+#define EMAC_STACR_STAC_WRITE           0x00002000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_STACR_OPBC_MASK            0x00000C00
+#define EMAC_STACR_OPBC_50              0x00000000
+#define EMAC_STACR_OPBC_66              0x00000400
+#define EMAC_STACR_OPBC_83              0x00000800
+#define EMAC_STACR_OPBC_100             0x00000C00
+#define EMAC_STACR_OPBC(freq)           ((freq) <= 50 ? EMAC_STACR_OPBC_50 : \
+                                         (freq) <= 66 ? EMAC_STACR_OPBC_66 : \
+                                         (freq) <= 83 ? EMAC_STACR_OPBC_83 : EMAC_STACR_OPBC_100)
+#define EMAC_STACR_BASE(opb)            EMAC_STACR_OPBC(opb)
+#else
+#define EMAC_STACR_BASE(opb)            0x00000000
+#endif
+#define EMAC_STACR_PCDA_MASK            0x1f
+#define EMAC_STACR_PCDA_SHIFT           5
+#define EMAC_STACR_PRA_MASK             0x1f
+
+/* EMACx_TRTR */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TRTR_SHIFT                 27
+#else
+#define EMAC_TRTR_SHIFT                 24
+#endif
+#define EMAC_TRTR(size)                 ((((size) >> 6) - 1) << EMAC_TRTR_SHIFT)
 
-/* Transmit Request Threshold Register */
-#define EMAC_TRTR_1600                  0x18000000      /* 0's for 64 Bytes */
-#define EMAC_TRTR_1024                  0x0f000000
-#define EMAC_TRTR_512                   0x07000000
-#define EMAC_TRTR_256                   0x03000000
-#define EMAC_TRTR_192                   0x10000000
-#define EMAC_TRTR_128                   0x01000000
+/* EMACx_RWMR */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_RWMR(l,h)                  (((l) << 23) | ( ((h) & 0x1ff) << 7))   
+#else
+#define EMAC_RWMR(l,h)                  (((l) << 22) | ( ((h) & 0x3ff) << 6))   
+#endif
 
+/* EMAC specific TX descriptor control fields (write access) */
 #define EMAC_TX_CTRL_GFCS               0x0200
 #define EMAC_TX_CTRL_GP                 0x0100
 #define EMAC_TX_CTRL_ISA                0x0080
 #define EMAC_TX_CTRL_RSA                0x0040
 #define EMAC_TX_CTRL_IVT                0x0020
 #define EMAC_TX_CTRL_RVT                0x0010
-#define EMAC_TX_CTRL_TAH_CSUM           0x000e  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG4           0x000a  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG3           0x0008  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG2           0x0006  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG1           0x0004  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG0           0x0002  /* TAH only */
-#define EMAC_TX_CTRL_TAH_DIS            0x0000  /* TAH only */
+#define EMAC_TX_CTRL_TAH_CSUM           0x000e
 
-#define EMAC_TX_CTRL_DFLT ( \
-        MAL_TX_CTRL_INTR | EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP )
-
-/* madmal transmit status / Control bits */
+/* EMAC specific TX descriptor status fields (read access) */
 #define EMAC_TX_ST_BFCS                 0x0200
-#define EMAC_TX_ST_BPP                  0x0100
 #define EMAC_TX_ST_LCS                  0x0080
 #define EMAC_TX_ST_ED                   0x0040
 #define EMAC_TX_ST_EC                   0x0020
@@ -202,8 +280,16 @@ typedef struct emac_regs {
 #define EMAC_TX_ST_SC                   0x0004
 #define EMAC_TX_ST_UR                   0x0002
 #define EMAC_TX_ST_SQE                  0x0001
+#if !defined(CONFIG_IBM_EMAC_TAH)
+#define EMAC_IS_BAD_TX(v)               ((v) & (EMAC_TX_ST_LCS | EMAC_TX_ST_ED | \
+                                         EMAC_TX_ST_EC | EMAC_TX_ST_LC | \
+                                         EMAC_TX_ST_MC | EMAC_TX_ST_UR))
+#else
+#define EMAC_IS_BAD_TX(v)               ((v) & (EMAC_TX_ST_LCS | EMAC_TX_ST_ED | \
+                                         EMAC_TX_ST_EC | EMAC_TX_ST_LC))
+#endif                                   
 
-/* madmal receive status / Control bits */
+/* EMAC specific RX descriptor status fields (read access) */
 #define EMAC_RX_ST_OE                   0x0200
 #define EMAC_RX_ST_PP                   0x0100
 #define EMAC_RX_ST_BP                   0x0080
@@ -214,54 +300,10 @@ typedef struct emac_regs {
 #define EMAC_RX_ST_PTL                  0x0004
 #define EMAC_RX_ST_ORE                  0x0002
 #define EMAC_RX_ST_IRE                  0x0001
-#define EMAC_BAD_RX_PACKET              0x02ff
-#define EMAC_CSUM_VER_ERROR             0x0003
-
-/* identify a bad rx packet dependent on emac features */
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_IS_BAD_RX_PACKET(desc) \
-        (((desc & (EMAC_BAD_RX_PACKET & ~EMAC_CSUM_VER_ERROR)) || \
-        ((desc & EMAC_CSUM_VER_ERROR) == EMAC_RX_ST_ORE) || \
-        ((desc & EMAC_CSUM_VER_ERROR) == EMAC_RX_ST_IRE)))
-#else
-#define EMAC_IS_BAD_RX_PACKET(desc) \
-         (desc & EMAC_BAD_RX_PACKET)
-#endif
-
-/* SoC implementation specific EMAC register defaults */
-#if defined(CONFIG_440GP)
-#define EMAC_RWMR_DEFAULT               0x80009000
-#define EMAC_TMR0_DEFAULT               0x00000000
-#define EMAC_TMR1_DEFAULT               0xf8640000
-#elif defined(CONFIG_440GX)
-#define EMAC_RWMR_DEFAULT               0x1000a200
-#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_2_32
-#define EMAC_TMR1_DEFAULT               0xa00f0000
-#elif defined(CONFIG_440SP)
-#define EMAC_RWMR_DEFAULT               0x08002000
-#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_128_2048
-#define EMAC_TMR1_DEFAULT               0xf8200000
-#else
-#define EMAC_RWMR_DEFAULT               0x0f002000
-#define EMAC_TMR0_DEFAULT               0x00000000
-#define EMAC_TMR1_DEFAULT               0x380f0000
-#endif                          /* CONFIG_440GP */
-
-/* Revision specific EMAC register defaults */
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_M1_DEFAULT                 (EMAC_M1_BASE | \
-                                        EMAC_M1_OPB_CLK_83 | \
-                                        EMAC_M1_TX_MWSW)
-#define EMAC_RMR_DEFAULT                (EMAC_RMR_BASE | \
-                                        EMAC_RMR_RFAF_128_2048)
-#define EMAC_TMR0_XMIT                  (EMAC_TMR0_GNP0 | \
-                                        EMAC_TMR0_DEFAULT)
-#define EMAC_TRTR_DEFAULT               EMAC_TRTR_1024
-#else                           /* !CONFIG_IBM_EMAC4 */
-#define EMAC_M1_DEFAULT                 EMAC_M1_BASE
-#define EMAC_RMR_DEFAULT                EMAC_RMR_BASE
-#define EMAC_TMR0_XMIT                  EMAC_TMR0_GNP0
-#define EMAC_TRTR_DEFAULT               EMAC_TRTR_1600
-#endif                          /* CONFIG_IBM_EMAC4 */
-
-#endif
+#define EMAC_RX_TAH_BAD_CSUM            0x0003
+#define EMAC_BAD_RX_MASK                (EMAC_RX_ST_OE | EMAC_RX_ST_BP | \
+                                         EMAC_RX_ST_RP | EMAC_RX_ST_SE | \
+                                         EMAC_RX_ST_AE | EMAC_RX_ST_BFCS | \
+                                         EMAC_RX_ST_PTL | EMAC_RX_ST_ORE | \
+                                         EMAC_RX_ST_IRE )
+#endif /* __IBM_EMAC_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_core.c b/drivers/net/ibm_emac/ibm_emac_core.c
index 14e9b6315f20..943fbd1546ff 100644
--- a/drivers/net/ibm_emac/ibm_emac_core.c
+++ b/drivers/net/ibm_emac/ibm_emac_core.c
@@ -1,13 +1,14 @@
 /*
- * ibm_emac_core.c
+ * drivers/net/ibm_emac/ibm_emac_core.c
  *
- * Ethernet driver for the built in ethernet on the IBM 4xx PowerPC
- * processors.
- * 
- * (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ * Driver for PowerPC 4xx on-chip ethernet controller.
  *
- * Based on original work by
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
  *      Armin Kuster <akuster@mvista.com>
  *      Johnnie Peters <jpeters@mvista.com>
  *
@@ -15,29 +16,24 @@
  * 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.
- * TODO
- *       - Check for races in the "remove" code path
- *       - Add some Power Management to the MAC and the PHY
- *       - Audit remaining of non-rewritten code (--BenH)
- *       - Cleanup message display using msglevel mecanism
- *       - Address all errata
- *       - Audit all register update paths to ensure they
- *         are being written post soft reset if required.
+ *
  */
+
+#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ptrace.h>
 #include <linux/errno.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/types.h>
-#include <linux/dma-mapping.h>
+#include <linux/pci.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/crc32.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/bitops.h>
@@ -45,1691 +41,1893 @@
 #include <asm/processor.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <asm/irq.h>
 #include <asm/uaccess.h>
 #include <asm/ocp.h>
 
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/crc32.h>
-
 #include "ibm_emac_core.h"
-
-//#define MDIO_DEBUG(fmt) printk fmt
-#define MDIO_DEBUG(fmt)
-
-//#define LINK_DEBUG(fmt) printk fmt
-#define LINK_DEBUG(fmt)
-
-//#define PKT_DEBUG(fmt) printk fmt
-#define PKT_DEBUG(fmt)
-
-#define DRV_NAME        "emac"
-#define DRV_VERSION     "2.0"
-#define DRV_AUTHOR      "Benjamin Herrenschmidt <benh@kernel.crashing.org>"
-#define DRV_DESC        "IBM EMAC Ethernet driver"
+#include "ibm_emac_debug.h"
 
 /*
- * When mdio_idx >= 0, contains a list of emac ocp_devs
- * that have had their initialization deferred until the
- * common MDIO controller has been initialized.
+ * Lack of dma_unmap_???? calls is intentional.
+ *
+ * API-correct usage requires additional support state information to be 
+ * maintained for every RX and TX buffer descriptor (BD). Unfortunately, due to
+ * EMAC design (e.g. TX buffer passed from network stack can be split into
+ * several BDs, dma_map_single/dma_map_page can be used to map particular BD),
+ * maintaining such information will add additional overhead.
+ * Current DMA API implementation for 4xx processors only ensures cache coherency
+ * and dma_unmap_???? routines are empty and are likely to stay this way.
+ * I decided to omit dma_unmap_??? calls because I don't want to add additional
+ * complexity just for the sake of following some abstract API, when it doesn't
+ * add any real benefit to the driver. I understand that this decision maybe 
+ * controversial, but I really tried to make code API-correct and efficient 
+ * at the same time and didn't come up with code I liked :(.                --ebs
  */
-LIST_HEAD(emac_init_list);
 
-MODULE_AUTHOR(DRV_AUTHOR);
+#define DRV_NAME        "emac"
+#define DRV_VERSION     "3.53"
+#define DRV_DESC        "PPC 4xx OCP EMAC driver"
+
 MODULE_DESCRIPTION(DRV_DESC);
+MODULE_AUTHOR
+    ("Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>");
 MODULE_LICENSE("GPL");
 
-static int skb_res = SKB_RES;
-module_param(skb_res, int, 0444);
-MODULE_PARM_DESC(skb_res, "Amount of data to reserve on skb buffs\n"
-                 "The 405 handles a misaligned IP header fine but\n"
-                 "this can help if you are routing to a tunnel or a\n"
-                 "device that needs aligned data. 0..2");
-
-#define RGMII_PRIV(ocpdev) ((struct ibm_ocp_rgmii*)ocp_get_drvdata(ocpdev))
+/* minimum number of free TX descriptors required to wake up TX process */
+#define EMAC_TX_WAKEUP_THRESH           (NUM_TX_BUFF / 4)
 
-static unsigned int rgmii_enable[] = {
-        RGMII_RTBI,
-        RGMII_RGMII,
-        RGMII_TBI,
-        RGMII_GMII
-};
+/* If packet size is less than this number, we allocate small skb and copy packet 
+ * contents into it instead of just sending original big skb up
+ */
+#define EMAC_RX_COPY_THRESH             CONFIG_IBM_EMAC_RX_COPY_THRESHOLD
 
-static unsigned int rgmii_speed_mask[] = {
-        RGMII_MII2_SPDMASK,
-        RGMII_MII3_SPDMASK
-};
+/* Since multiple EMACs share MDIO lines in various ways, we need
+ * to avoid re-using the same PHY ID in cases where the arch didn't
+ * setup precise phy_map entries
+ */
+static u32 busy_phy_map;
 
-static unsigned int rgmii_speed100[] = {
-        RGMII_MII2_100MB,
-        RGMII_MII3_100MB
-};
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && (defined(CONFIG_405EP) || defined(CONFIG_440EP))
+/* 405EP has "EMAC to PHY Control Register" (CPC0_EPCTL) which can help us
+ * with PHY RX clock problem.
+ * 440EP has more sane SDR0_MFR register implementation than 440GX, which
+ * also allows controlling each EMAC clock
+ */
+static inline void EMAC_RX_CLK_TX(int idx)
+{
+        unsigned long flags;
+        local_irq_save(flags);
 
-static unsigned int rgmii_speed1000[] = {
-        RGMII_MII2_1000MB,
-        RGMII_MII3_1000MB
-};
+#if defined(CONFIG_405EP)
+        mtdcr(0xf3, mfdcr(0xf3) | (1 << idx));
+#else /* CONFIG_440EP */
+        SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) | (0x08000000 >> idx));
+#endif
 
-#define ZMII_PRIV(ocpdev) ((struct ibm_ocp_zmii*)ocp_get_drvdata(ocpdev))
+        local_irq_restore(flags);
+}
 
-static unsigned int zmii_enable[][4] = {
-        {ZMII_SMII0, ZMII_RMII0, ZMII_MII0,
-         ~(ZMII_MDI1 | ZMII_MDI2 | ZMII_MDI3)},
-        {ZMII_SMII1, ZMII_RMII1, ZMII_MII1,
-         ~(ZMII_MDI0 | ZMII_MDI2 | ZMII_MDI3)},
-        {ZMII_SMII2, ZMII_RMII2, ZMII_MII2,
-         ~(ZMII_MDI0 | ZMII_MDI1 | ZMII_MDI3)},
-        {ZMII_SMII3, ZMII_RMII3, ZMII_MII3, ~(ZMII_MDI0 | ZMII_MDI1 | ZMII_MDI2)}
-};
+static inline void EMAC_RX_CLK_DEFAULT(int idx)
+{
+        unsigned long flags;
+        local_irq_save(flags);
 
-static unsigned int mdi_enable[] = {
-        ZMII_MDI0,
-        ZMII_MDI1,
-        ZMII_MDI2,
-        ZMII_MDI3
-};
+#if defined(CONFIG_405EP)
+        mtdcr(0xf3, mfdcr(0xf3) & ~(1 << idx));
+#else /* CONFIG_440EP */
+        SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) & ~(0x08000000 >> idx));
+#endif
 
-static unsigned int zmii_speed = 0x0;
-static unsigned int zmii_speed100[] = {
-        ZMII_MII0_100MB,
-        ZMII_MII1_100MB,
-        ZMII_MII2_100MB,
-        ZMII_MII3_100MB
-};
+        local_irq_restore(flags);
+}
+#else
+#define EMAC_RX_CLK_TX(idx)             ((void)0)
+#define EMAC_RX_CLK_DEFAULT(idx)        ((void)0)
+#endif
 
-/* Since multiple EMACs share MDIO lines in various ways, we need
- * to avoid re-using the same PHY ID in cases where the arch didn't
- * setup precise phy_map entries
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && defined(CONFIG_440GX)
+/* We can switch Ethernet clock to the internal source through SDR0_MFR[ECS],
+ * unfortunately this is less flexible than 440EP case, because it's a global 
+ * setting for all EMACs, therefore we do this clock trick only during probe.
  */
-static u32 busy_phy_map = 0;
+#define EMAC_CLK_INTERNAL               SDR_WRITE(DCRN_SDR_MFR, \
+                                            SDR_READ(DCRN_SDR_MFR) | 0x08000000)
+#define EMAC_CLK_EXTERNAL               SDR_WRITE(DCRN_SDR_MFR, \
+                                            SDR_READ(DCRN_SDR_MFR) & ~0x08000000)
+#else
+#define EMAC_CLK_INTERNAL               ((void)0)
+#define EMAC_CLK_EXTERNAL               ((void)0)
+#endif
 
-/* If EMACs share a common MDIO device, this points to it */
-static struct net_device *mdio_ndev = NULL;
+/* I don't want to litter system log with timeout errors 
+ * when we have brain-damaged PHY.
+ */
+static inline void emac_report_timeout_error(struct ocp_enet_private *dev,
+                                             const char *error)
+{
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
+        DBG("%d: %s" NL, dev->def->index, error);
+#else
+        if (net_ratelimit())
+                printk(KERN_ERR "emac%d: %s\n", dev->def->index, error);
+#endif
+}
 
-struct emac_def_dev {
-        struct list_head link;
-        struct ocp_device *ocpdev;
-        struct ibm_ocp_mal *mal;
+/* PHY polling intervals */
+#define PHY_POLL_LINK_ON        HZ
+#define PHY_POLL_LINK_OFF       (HZ / 5)
+
+/* Please, keep in sync with struct ibm_emac_stats/ibm_emac_error_stats */
+static const char emac_stats_keys[EMAC_ETHTOOL_STATS_COUNT][ETH_GSTRING_LEN] = {
+        "rx_packets", "rx_bytes", "tx_packets", "tx_bytes", "rx_packets_csum",
+        "tx_packets_csum", "tx_undo", "rx_dropped_stack", "rx_dropped_oom",
+        "rx_dropped_error", "rx_dropped_resize", "rx_dropped_mtu",
+        "rx_stopped", "rx_bd_errors", "rx_bd_overrun", "rx_bd_bad_packet",
+        "rx_bd_runt_packet", "rx_bd_short_event", "rx_bd_alignment_error",
+        "rx_bd_bad_fcs", "rx_bd_packet_too_long", "rx_bd_out_of_range",
+        "rx_bd_in_range", "rx_parity", "rx_fifo_overrun", "rx_overrun",
+        "rx_bad_packet", "rx_runt_packet", "rx_short_event",
+        "rx_alignment_error", "rx_bad_fcs", "rx_packet_too_long",
+        "rx_out_of_range", "rx_in_range", "tx_dropped", "tx_bd_errors",
+        "tx_bd_bad_fcs", "tx_bd_carrier_loss", "tx_bd_excessive_deferral",
+        "tx_bd_excessive_collisions", "tx_bd_late_collision",
+        "tx_bd_multple_collisions", "tx_bd_single_collision",
+        "tx_bd_underrun", "tx_bd_sqe", "tx_parity", "tx_underrun", "tx_sqe",
+        "tx_errors"
 };
 
-static struct net_device_stats *emac_stats(struct net_device *dev)
+static irqreturn_t emac_irq(int irq, void *dev_instance, struct pt_regs *regs);
+static void emac_clean_tx_ring(struct ocp_enet_private *dev);
+
+static inline int emac_phy_supports_gige(int phy_mode)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        return &fep->stats;
-};
+        return  phy_mode == PHY_MODE_GMII ||
+                phy_mode == PHY_MODE_RGMII ||
+                phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
 
-static int
-emac_init_rgmii(struct ocp_device *rgmii_dev, int input, int phy_mode)
+static inline int emac_phy_gpcs(int phy_mode)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(rgmii_dev);
-        const char *mode_name[] = { "RTBI", "RGMII", "TBI", "GMII" };
-        int mode = -1;
+        return  phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
 
-        if (!rgmii) {
-                rgmii = kmalloc(sizeof(struct ibm_ocp_rgmii), GFP_KERNEL);
+static inline void emac_tx_enable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-                if (rgmii == NULL) {
-                        printk(KERN_ERR
-                               "rgmii%d: Out of memory allocating RGMII structure!\n",
-                               rgmii_dev->def->index);
-                        return -ENOMEM;
-                }
+        local_irq_save(flags);
 
-                memset(rgmii, 0, sizeof(*rgmii));
+        DBG("%d: tx_enable" NL, dev->def->index);
 
-                rgmii->base =
-                    (struct rgmii_regs *)ioremap(rgmii_dev->def->paddr,
-                                                 sizeof(*rgmii->base));
-                if (rgmii->base == NULL) {
-                        printk(KERN_ERR
-                               "rgmii%d: Cannot ioremap bridge registers!\n",
-                               rgmii_dev->def->index);
+        r = in_be32(&p->mr0);
+        if (!(r & EMAC_MR0_TXE))
+                out_be32(&p->mr0, r | EMAC_MR0_TXE);
+        local_irq_restore(flags);
+}
 
-                        kfree(rgmii);
-                        return -ENOMEM;
-                }
-                ocp_set_drvdata(rgmii_dev, rgmii);
-        }
+static void emac_tx_disable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        if (phy_mode) {
-                switch (phy_mode) {
-                case PHY_MODE_GMII:
-                        mode = GMII;
-                        break;
-                case PHY_MODE_TBI:
-                        mode = TBI;
-                        break;
-                case PHY_MODE_RTBI:
-                        mode = RTBI;
-                        break;
-                case PHY_MODE_RGMII:
-                default:
-                        mode = RGMII;
-                }
-                rgmii->base->fer &= ~RGMII_FER_MASK(input);
-                rgmii->base->fer |= rgmii_enable[mode] << (4 * input);
-        } else {
-                switch ((rgmii->base->fer & RGMII_FER_MASK(input)) >> (4 *
-                                                                       input)) {
-                case RGMII_RTBI:
-                        mode = RTBI;
-                        break;
-                case RGMII_RGMII:
-                        mode = RGMII;
-                        break;
-                case RGMII_TBI:
-                        mode = TBI;
-                        break;
-                case RGMII_GMII:
-                        mode = GMII;
-                }
-        }
+        local_irq_save(flags);
+
+        DBG("%d: tx_disable" NL, dev->def->index);
 
-        /* Set mode to RGMII if nothing valid is detected */
-        if (mode < 0)
-                mode = RGMII;
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_TXE) {
+                int n = 300;
+                out_be32(&p->mr0, r & ~EMAC_MR0_TXE);
+                while (!(in_be32(&p->mr0) & EMAC_MR0_TXI) && n)
+                        --n;
+                if (unlikely(!n))
+                        emac_report_timeout_error(dev, "TX disable timeout");
+        }
+        local_irq_restore(flags);
+}
 
-        printk(KERN_NOTICE "rgmii%d: input %d in %s mode\n",
-               rgmii_dev->def->index, input, mode_name[mode]);
+static void emac_rx_enable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        rgmii->mode[input] = mode;
-        rgmii->users++;
+        local_irq_save(flags);
+        if (unlikely(dev->commac.rx_stopped))
+                goto out;
 
-        return 0;
+        DBG("%d: rx_enable" NL, dev->def->index);
+
+        r = in_be32(&p->mr0);
+        if (!(r & EMAC_MR0_RXE)) {
+                if (unlikely(!(r & EMAC_MR0_RXI))) {
+                        /* Wait if previous async disable is still in progress */
+                        int n = 100;
+                        while (!(r = in_be32(&p->mr0) & EMAC_MR0_RXI) && n)
+                                --n;
+                        if (unlikely(!n))
+                                emac_report_timeout_error(dev,
+                                                          "RX disable timeout");
+                }
+                out_be32(&p->mr0, r | EMAC_MR0_RXE);
+        }
+      out:
+        local_irq_restore(flags);
 }
 
-static void
-emac_rgmii_port_speed(struct ocp_device *ocpdev, int input, int speed)
+static void emac_rx_disable(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(ocpdev);
-        unsigned int rgmii_speed;
-
-        rgmii_speed = in_be32(&rgmii->base->ssr);
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        rgmii_speed &= ~rgmii_speed_mask[input];
+        local_irq_save(flags);
 
-        if (speed == 1000)
-                rgmii_speed |= rgmii_speed1000[input];
-        else if (speed == 100)
-                rgmii_speed |= rgmii_speed100[input];
+        DBG("%d: rx_disable" NL, dev->def->index);
 
-        out_be32(&rgmii->base->ssr, rgmii_speed);
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_RXE) {
+                int n = 300;
+                out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
+                while (!(in_be32(&p->mr0) & EMAC_MR0_RXI) && n)
+                        --n;
+                if (unlikely(!n))
+                        emac_report_timeout_error(dev, "RX disable timeout");
+        }
+        local_irq_restore(flags);
 }
 
-static void emac_close_rgmii(struct ocp_device *ocpdev)
+static inline void emac_rx_disable_async(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(ocpdev);
-        BUG_ON(!rgmii || rgmii->users == 0);
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        if (!--rgmii->users) {
-                ocp_set_drvdata(ocpdev, NULL);
-                iounmap((void *)rgmii->base);
-                kfree(rgmii);
-        }
+        local_irq_save(flags);
+
+        DBG("%d: rx_disable_async" NL, dev->def->index);
+
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_RXE)
+                out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
+        local_irq_restore(flags);
 }
 
-static int emac_init_zmii(struct ocp_device *zmii_dev, int input, int phy_mode)
+static int emac_reset(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(zmii_dev);
-        const char *mode_name[] = { "SMII", "RMII", "MII" };
-        int mode = -1;
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        int n = 20;
 
-        if (!zmii) {
-                zmii = kmalloc(sizeof(struct ibm_ocp_zmii), GFP_KERNEL);
-                if (zmii == NULL) {
-                        printk(KERN_ERR
-                               "zmii%d: Out of memory allocating ZMII structure!\n",
-                               zmii_dev->def->index);
-                        return -ENOMEM;
-                }
-                memset(zmii, 0, sizeof(*zmii));
+        DBG("%d: reset" NL, dev->def->index);
 
-                zmii->base =
-                    (struct zmii_regs *)ioremap(zmii_dev->def->paddr,
-                                                sizeof(*zmii->base));
-                if (zmii->base == NULL) {
-                        printk(KERN_ERR
-                               "zmii%d: Cannot ioremap bridge registers!\n",
-                               zmii_dev->def->index);
+        local_irq_save(flags);
 
-                        kfree(zmii);
-                        return -ENOMEM;
-                }
-                ocp_set_drvdata(zmii_dev, zmii);
+        if (!dev->reset_failed) {
+                /* 40x erratum suggests stopping RX channel before reset,
+                 * we stop TX as well
+                 */
+                emac_rx_disable(dev);
+                emac_tx_disable(dev);
         }
 
-        if (phy_mode) {
-                switch (phy_mode) {
-                case PHY_MODE_MII:
-                        mode = MII;
-                        break;
-                case PHY_MODE_RMII:
-                        mode = RMII;
-                        break;
-                case PHY_MODE_SMII:
-                default:
-                        mode = SMII;
-                }
-                zmii->base->fer &= ~ZMII_FER_MASK(input);
-                zmii->base->fer |= zmii_enable[input][mode];
+        out_be32(&p->mr0, EMAC_MR0_SRST);
+        while ((in_be32(&p->mr0) & EMAC_MR0_SRST) && n)
+                --n;
+        local_irq_restore(flags);
+
+        if (n) {
+                dev->reset_failed = 0;
+                return 0;
         } else {
-                switch ((zmii->base->fer & ZMII_FER_MASK(input)) << (4 * input)) {
-                case ZMII_MII0:
-                        mode = MII;
-                        break;
-                case ZMII_RMII0:
-                        mode = RMII;
-                        break;
-                case ZMII_SMII0:
-                        mode = SMII;
-                }
+                emac_report_timeout_error(dev, "reset timeout");
+                dev->reset_failed = 1;
+                return -ETIMEDOUT;
         }
+}
 
-        /* Set mode to SMII if nothing valid is detected */
-        if (mode < 0)
-                mode = SMII;
+static void emac_hash_mc(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        u16 gaht[4] = { 0 };
+        struct dev_mc_list *dmi;
 
-        printk(KERN_NOTICE "zmii%d: input %d in %s mode\n",
-               zmii_dev->def->index, input, mode_name[mode]);
+        DBG("%d: hash_mc %d" NL, dev->def->index, dev->ndev->mc_count);
 
-        zmii->mode[input] = mode;
-        zmii->users++;
+        for (dmi = dev->ndev->mc_list; dmi; dmi = dmi->next) {
+                int bit;
+                DBG2("%d: mc %02x:%02x:%02x:%02x:%02x:%02x" NL,
+                     dev->def->index,
+                     dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
+                     dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5]);
 
-        return 0;
+                bit = 63 - (ether_crc(ETH_ALEN, dmi->dmi_addr) >> 26);
+                gaht[bit >> 4] |= 0x8000 >> (bit & 0x0f);
+        }
+        out_be32(&p->gaht1, gaht[0]);
+        out_be32(&p->gaht2, gaht[1]);
+        out_be32(&p->gaht3, gaht[2]);
+        out_be32(&p->gaht4, gaht[3]);
 }
 
-static void emac_enable_zmii_port(struct ocp_device *ocpdev, int input)
+static inline u32 emac_iff2rmr(struct net_device *ndev)
 {
-        u32 mask;
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
+        u32 r = EMAC_RMR_SP | EMAC_RMR_SFCS | EMAC_RMR_IAE | EMAC_RMR_BAE |
+            EMAC_RMR_BASE;
 
-        mask = in_be32(&zmii->base->fer);
-        mask &= zmii_enable[input][MDI];        /* turn all non enabled MDI's off */
-        mask |= zmii_enable[input][zmii->mode[input]] | mdi_enable[input];
-        out_be32(&zmii->base->fer, mask);
+        if (ndev->flags & IFF_PROMISC)
+                r |= EMAC_RMR_PME;
+        else if (ndev->flags & IFF_ALLMULTI || ndev->mc_count > 32)
+                r |= EMAC_RMR_PMME;
+        else if (ndev->mc_count > 0)
+                r |= EMAC_RMR_MAE;
+
+        return r;
 }
 
-static void
-emac_zmii_port_speed(struct ocp_device *ocpdev, int input, int speed)
+static inline int emac_opb_mhz(void)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
-
-        if (speed == 100)
-                zmii_speed |= zmii_speed100[input];
-        else
-                zmii_speed &= ~zmii_speed100[input];
-
-        out_be32(&zmii->base->ssr, zmii_speed);
+        return (ocp_sys_info.opb_bus_freq + 500000) / 1000000;
 }
 
-static void emac_close_zmii(struct ocp_device *ocpdev)
+/* BHs disabled */
+static int emac_configure(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
-        BUG_ON(!zmii || zmii->users == 0);
+        struct emac_regs *p = dev->emacp;
+        struct net_device *ndev = dev->ndev;
+        int gige;
+        u32 r;
 
-        if (!--zmii->users) {
-                ocp_set_drvdata(ocpdev, NULL);
-                iounmap((void *)zmii->base);
-                kfree(zmii);
-        }
-}
+        DBG("%d: configure" NL, dev->def->index);
 
-int emac_phy_read(struct net_device *dev, int mii_id, int reg)
-{
-        int count;
-        uint32_t stacr;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        if (emac_reset(dev) < 0)
+                return -ETIMEDOUT;
 
-        MDIO_DEBUG(("%s: phy_read, id: 0x%x, reg: 0x%x\n", dev->name, mii_id,
-                    reg));
+        tah_reset(dev->tah_dev);
 
-        /* Enable proper ZMII port */
-        if (fep->zmii_dev)
-                emac_enable_zmii_port(fep->zmii_dev, fep->zmii_input);
+        /* Mode register */
+        r = EMAC_MR1_BASE(emac_opb_mhz()) | EMAC_MR1_VLE | EMAC_MR1_IST;
+        if (dev->phy.duplex == DUPLEX_FULL)
+                r |= EMAC_MR1_FDE;
+        switch (dev->phy.speed) {
+        case SPEED_1000:
+                if (emac_phy_gpcs(dev->phy.mode)) {
+                        r |= EMAC_MR1_MF_1000GPCS |
+                            EMAC_MR1_MF_IPPA(dev->phy.address);
 
-        /* Use the EMAC that has the MDIO port */
-        if (fep->mdio_dev) {
-                dev = fep->mdio_dev;
-                fep = dev->priv;
-                emacp = fep->emacp;
+                        /* Put some arbitrary OUI, Manuf & Rev IDs so we can
+                         * identify this GPCS PHY later.
+                         */
+                        out_be32(&p->ipcr, 0xdeadbeef);
+                } else
+                        r |= EMAC_MR1_MF_1000;
+                r |= EMAC_MR1_RFS_16K;
+                gige = 1;
+                
+                if (dev->ndev->mtu > ETH_DATA_LEN)
+                        r |= EMAC_MR1_JPSM;
+                break;
+        case SPEED_100:
+                r |= EMAC_MR1_MF_100;
+                /* Fall through */
+        default:
+                r |= EMAC_MR1_RFS_4K;
+                gige = 0;
+                break;
         }
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
-                udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+        if (dev->rgmii_dev)
+                rgmii_set_speed(dev->rgmii_dev, dev->rgmii_input,
+                                dev->phy.speed);
+        else
+                zmii_set_speed(dev->zmii_dev, dev->zmii_input, dev->phy.speed);
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY read timeout #1!\n", dev->name);
-                return -1;
+#if !defined(CONFIG_40x)
+        /* on 40x erratum forces us to NOT use integrated flow control, 
+         * let's hope it works on 44x ;)
+         */
+        if (dev->phy.duplex == DUPLEX_FULL) {
+                if (dev->phy.pause)
+                        r |= EMAC_MR1_EIFC | EMAC_MR1_APP;
+                else if (dev->phy.asym_pause)
+                        r |= EMAC_MR1_APP;
         }
+#endif
+        out_be32(&p->mr1, r);
+
+        /* Set individual MAC address */
+        out_be32(&p->iahr, (ndev->dev_addr[0] << 8) | ndev->dev_addr[1]);
+        out_be32(&p->ialr, (ndev->dev_addr[2] << 24) |
+                 (ndev->dev_addr[3] << 16) | (ndev->dev_addr[4] << 8) |
+                 ndev->dev_addr[5]);
+
+        /* VLAN Tag Protocol ID */
+        out_be32(&p->vtpid, 0x8100);
+
+        /* Receive mode register */
+        r = emac_iff2rmr(ndev);
+        if (r & EMAC_RMR_MAE)
+                emac_hash_mc(dev);
+        out_be32(&p->rmr, r);
+
+        /* FIFOs thresholds */
+        r = EMAC_TMR1((EMAC_MAL_BURST_SIZE / EMAC_FIFO_ENTRY_SIZE) + 1,
+                      EMAC_TX_FIFO_SIZE / 2 / EMAC_FIFO_ENTRY_SIZE);
+        out_be32(&p->tmr1, r);
+        out_be32(&p->trtr, EMAC_TRTR(EMAC_TX_FIFO_SIZE / 2));
+
+        /* PAUSE frame is sent when RX FIFO reaches its high-water mark,
+           there should be still enough space in FIFO to allow the our link
+           partner time to process this frame and also time to send PAUSE 
+           frame itself.
+
+           Here is the worst case scenario for the RX FIFO "headroom"
+           (from "The Switch Book") (100Mbps, without preamble, inter-frame gap):
+
+           1) One maximum-length frame on TX                    1522 bytes
+           2) One PAUSE frame time                                64 bytes
+           3) PAUSE frame decode time allowance                   64 bytes
+           4) One maximum-length frame on RX                    1522 bytes
+           5) Round-trip propagation delay of the link (100Mb)    15 bytes
+           ----------       
+           3187 bytes
+
+           I chose to set high-water mark to RX_FIFO_SIZE / 4 (1024 bytes)
+           low-water mark  to RX_FIFO_SIZE / 8 (512 bytes)
+         */
+        r = EMAC_RWMR(EMAC_RX_FIFO_SIZE(gige) / 8 / EMAC_FIFO_ENTRY_SIZE,
+                      EMAC_RX_FIFO_SIZE(gige) / 4 / EMAC_FIFO_ENTRY_SIZE);
+        out_be32(&p->rwmr, r);
+
+        /* Set PAUSE timer to the maximum */
+        out_be32(&p->ptr, 0xffff);
+
+        /* IRQ sources */
+        out_be32(&p->iser, EMAC_ISR_TXPE | EMAC_ISR_RXPE | /* EMAC_ISR_TXUE |
+                 EMAC_ISR_RXOE | */ EMAC_ISR_OVR | EMAC_ISR_BP | EMAC_ISR_SE |
+                 EMAC_ISR_ALE | EMAC_ISR_BFCS | EMAC_ISR_PTLE | EMAC_ISR_ORE |
+                 EMAC_ISR_IRE | EMAC_ISR_TE);
+                 
+        /* We need to take GPCS PHY out of isolate mode after EMAC reset */
+        if (emac_phy_gpcs(dev->phy.mode)) 
+                mii_reset_phy(&dev->phy);
+                 
+        return 0;
+}
 
-        /* Clear the speed bits and make a read request to the PHY */
-        stacr = ((EMAC_STACR_READ | (reg & 0x1f)) & ~EMAC_STACR_CLK_100MHZ);
-        stacr |= ((mii_id & 0x1F) << 5);
+/* BHs disabled */
+static void emac_reinitialize(struct ocp_enet_private *dev)
+{
+        DBG("%d: reinitialize" NL, dev->def->index);
 
-        out_be32(&emacp->em0stacr, stacr);
+        if (!emac_configure(dev)) {
+                emac_tx_enable(dev);
+                emac_rx_enable(dev);
+        }
+}
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
-                udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+/* BHs disabled */
+static void emac_full_tx_reset(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY read timeout #2!\n", dev->name);
-                return -1;
-        }
+        DBG("%d: full_tx_reset" NL, dev->def->index);
 
-        /* Check for a read error */
-        if (stacr & EMAC_STACR_PHYE) {
-                MDIO_DEBUG(("EMAC MDIO PHY error !\n"));
-                return -1;
-        }
+        emac_tx_disable(dev);
+        mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        emac_clean_tx_ring(dev);
+        dev->tx_cnt = dev->tx_slot = dev->ack_slot = 0;
 
-        MDIO_DEBUG((" -> 0x%x\n", stacr >> 16));
+        emac_configure(dev);
 
-        return (stacr >> 16);
+        mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        emac_tx_enable(dev);
+        emac_rx_enable(dev);
+
+        netif_wake_queue(ndev);
 }
 
-void emac_phy_write(struct net_device *dev, int mii_id, int reg, int data)
+static int __emac_mdio_read(struct ocp_enet_private *dev, u8 id, u8 reg)
 {
-        int count;
-        uint32_t stacr;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        struct emac_regs *p = dev->emacp;
+        u32 r;
+        int n;
 
-        MDIO_DEBUG(("%s phy_write, id: 0x%x, reg: 0x%x, data: 0x%x\n",
-                    dev->name, mii_id, reg, data));
+        DBG2("%d: mdio_read(%02x,%02x)" NL, dev->def->index, id, reg);
 
-        /* Enable proper ZMII port */
-        if (fep->zmii_dev)
-                emac_enable_zmii_port(fep->zmii_dev, fep->zmii_input);
+        /* Enable proper MDIO port */
+        zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
 
-        /* Use the EMAC that has the MDIO port */
-        if (fep->mdio_dev) {
-                dev = fep->mdio_dev;
-                fep = dev->priv;
-                emacp = fep->emacp;
+        /* Wait for management interface to become idle */
+        n = 10;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
+                udelay(1);
+                if (!--n)
+                        goto to;
         }
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
+        /* Issue read command */
+        out_be32(&p->stacr,
+                 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_READ |
+                 (reg & EMAC_STACR_PRA_MASK)
+                 | ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT));
+
+        /* Wait for read to complete */
+        n = 100;
+        while (!((r = in_be32(&p->stacr)) & EMAC_STACR_OC)) {
                 udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+                if (!--n)
+                        goto to;
+        }
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY write timeout #2!\n", dev->name);
-                return;
+        if (unlikely(r & EMAC_STACR_PHYE)) {
+                DBG("%d: mdio_read(%02x, %02x) failed" NL, dev->def->index,
+                    id, reg);
+                return -EREMOTEIO;
         }
 
-        /* Clear the speed bits and make a read request to the PHY */
+        r = ((r >> EMAC_STACR_PHYD_SHIFT) & EMAC_STACR_PHYD_MASK);
+        DBG2("%d: mdio_read -> %04x" NL, dev->def->index, r);
+        return r;
+      to:
+        DBG("%d: MII management interface timeout (read)" NL, dev->def->index);
+        return -ETIMEDOUT;
+}
 
-        stacr = ((EMAC_STACR_WRITE | (reg & 0x1f)) & ~EMAC_STACR_CLK_100MHZ);
-        stacr |= ((mii_id & 0x1f) << 5) | ((data & 0xffff) << 16);
+static void __emac_mdio_write(struct ocp_enet_private *dev, u8 id, u8 reg,
+                              u16 val)
+{
+        struct emac_regs *p = dev->emacp;
+        int n;
 
-        out_be32(&emacp->em0stacr, stacr);
+        DBG2("%d: mdio_write(%02x,%02x,%04x)" NL, dev->def->index, id, reg,
+             val);
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
+        /* Enable proper MDIO port */
+        zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
+
+        /* Wait for management interface to be idle */
+        n = 10;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
                 udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+                if (!--n)
+                        goto to;
+        }
 
-        if ((stacr & EMAC_STACR_OC) == 0)
-                printk(KERN_WARNING "%s: PHY write timeout #2!\n", dev->name);
+        /* Issue write command */
+        out_be32(&p->stacr,
+                 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_WRITE |
+                 (reg & EMAC_STACR_PRA_MASK) |
+                 ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT) |
+                 (val << EMAC_STACR_PHYD_SHIFT));
 
-        /* Check for a write error */
-        if ((stacr & EMAC_STACR_PHYE) != 0) {
-                MDIO_DEBUG(("EMAC MDIO PHY error !\n"));
+        /* Wait for write to complete */
+        n = 100;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
+                udelay(1);
+                if (!--n)
+                        goto to;
         }
+        return;
+      to:
+        DBG("%d: MII management interface timeout (write)" NL, dev->def->index);
 }
 
-static void emac_txeob_dev(void *param, u32 chanmask)
+static int emac_mdio_read(struct net_device *ndev, int id, int reg)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-
-        spin_lock_irqsave(&fep->lock, flags);
-
-        PKT_DEBUG(("emac_txeob_dev() entry, tx_cnt: %d\n", fep->tx_cnt));
-
-        while (fep->tx_cnt &&
-               !(fep->tx_desc[fep->ack_slot].ctrl & MAL_TX_CTRL_READY)) {
+        struct ocp_enet_private *dev = ndev->priv;
+        int res;
+
+        local_bh_disable();
+        res = __emac_mdio_read(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
+                               (u8) reg);
+        local_bh_enable();
+        return res;
+}
 
-                if (fep->tx_desc[fep->ack_slot].ctrl & MAL_TX_CTRL_LAST) {
-                        /* Tell the system the transmit completed. */
-                        dma_unmap_single(&fep->ocpdev->dev,
-                                         fep->tx_desc[fep->ack_slot].data_ptr,
-                                         fep->tx_desc[fep->ack_slot].data_len,
-                                         DMA_TO_DEVICE);
-                        dev_kfree_skb_irq(fep->tx_skb[fep->ack_slot]);
+static void emac_mdio_write(struct net_device *ndev, int id, int reg, int val)
+{
+        struct ocp_enet_private *dev = ndev->priv;
 
-                        if (fep->tx_desc[fep->ack_slot].ctrl &
-                            (EMAC_TX_ST_EC | EMAC_TX_ST_MC | EMAC_TX_ST_SC))
-                                fep->stats.collisions++;
-                }
+        local_bh_disable();
+        __emac_mdio_write(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
+                          (u8) reg, (u16) val);
+        local_bh_enable();
+}
 
-                fep->tx_skb[fep->ack_slot] = (struct sk_buff *)NULL;
-                if (++fep->ack_slot == NUM_TX_BUFF)
-                        fep->ack_slot = 0;
+/* BHs disabled */
+static void emac_set_multicast_list(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct emac_regs *p = dev->emacp;
+        u32 rmr = emac_iff2rmr(ndev);
+
+        DBG("%d: multicast %08x" NL, dev->def->index, rmr);
+        BUG_ON(!netif_running(dev->ndev));
+
+        /* I decided to relax register access rules here to avoid
+         * full EMAC reset.
+         *
+         * There is a real problem with EMAC4 core if we use MWSW_001 bit 
+         * in MR1 register and do a full EMAC reset.
+         * One TX BD status update is delayed and, after EMAC reset, it 
+         * never happens, resulting in TX hung (it'll be recovered by TX 
+         * timeout handler eventually, but this is just gross).
+         * So we either have to do full TX reset or try to cheat here :)
+         *
+         * The only required change is to RX mode register, so I *think* all
+         * we need is just to stop RX channel. This seems to work on all
+         * tested SoCs.                                                --ebs
+         */
+        emac_rx_disable(dev);
+        if (rmr & EMAC_RMR_MAE)
+                emac_hash_mc(dev);
+        out_be32(&p->rmr, rmr);
+        emac_rx_enable(dev);
+}
 
-                fep->tx_cnt--;
+/* BHs disabled */
+static int emac_resize_rx_ring(struct ocp_enet_private *dev, int new_mtu)
+{
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+        int rx_sync_size = emac_rx_sync_size(new_mtu);
+        int rx_skb_size = emac_rx_skb_size(new_mtu);
+        int i, ret = 0;
+
+        emac_rx_disable(dev);
+        mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+
+        if (dev->rx_sg_skb) {
+                ++dev->estats.rx_dropped_resize;
+                dev_kfree_skb(dev->rx_sg_skb);
+                dev->rx_sg_skb = NULL;
         }
-        if (fep->tx_cnt < NUM_TX_BUFF)
-                netif_wake_queue(dev);
 
-        PKT_DEBUG(("emac_txeob_dev() exit, tx_cnt: %d\n", fep->tx_cnt));
+        /* Make a first pass over RX ring and mark BDs ready, dropping 
+         * non-processed packets on the way. We need this as a separate pass
+         * to simplify error recovery in the case of allocation failure later.
+         */
+        for (i = 0; i < NUM_RX_BUFF; ++i) {
+                if (dev->rx_desc[i].ctrl & MAL_RX_CTRL_FIRST)
+                        ++dev->estats.rx_dropped_resize;
 
-        spin_unlock_irqrestore(&fep->lock, flags);
-}
+                dev->rx_desc[i].data_len = 0;
+                dev->rx_desc[i].ctrl = MAL_RX_CTRL_EMPTY |
+                    (i == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
+        }
 
-/*
-  Fill/Re-fill the rx chain with valid ctrl/ptrs.
-  This function will fill from rx_slot up to the parm end.
-  So to completely fill the chain pre-set rx_slot to 0 and
-  pass in an end of 0.
- */
-static void emac_rx_fill(struct net_device *dev, int end)
-{
-        int i;
-        struct ocp_enet_private *fep = dev->priv;
-
-        i = fep->rx_slot;
-        do {
-                /* We don't want the 16 bytes skb_reserve done by dev_alloc_skb,
-                 * it breaks our cache line alignement. However, we still allocate
-                 * +16 so that we end up allocating the exact same size as
-                 * dev_alloc_skb() would do.
-                 * Also, because of the skb_res, the max DMA size we give to EMAC
-                 * is slighly wrong, causing it to potentially DMA 2 more bytes
-                 * from a broken/oversized packet. These 16 bytes will take care
-                 * that we don't walk on somebody else toes with that.
-                 */
-                fep->rx_skb[i] =
-                    alloc_skb(fep->rx_buffer_size + 16, GFP_ATOMIC);
-
-                if (fep->rx_skb[i] == NULL) {
-                        /* Keep rx_slot here, the next time clean/fill is called
-                         * we will try again before the MAL wraps back here
-                         * If the MAL tries to use this descriptor with
-                         * the EMPTY bit off it will cause the
-                         * rxde interrupt.  That is where we will
-                         * try again to allocate an sk_buff.
-                         */
-                        break;
+        /* Reallocate RX ring only if bigger skb buffers are required */
+        if (rx_skb_size <= dev->rx_skb_size)
+                goto skip;
 
+        /* Second pass, allocate new skbs */
+        for (i = 0; i < NUM_RX_BUFF; ++i) {
+                struct sk_buff *skb = alloc_skb(rx_skb_size, GFP_ATOMIC);
+                if (!skb) {
+                        ret = -ENOMEM;
+                        goto oom;
                 }
 
-                if (skb_res)
-                        skb_reserve(fep->rx_skb[i], skb_res);
+                BUG_ON(!dev->rx_skb[i]);
+                dev_kfree_skb(dev->rx_skb[i]);
 
-                /* We must NOT dma_map_single the cache line right after the
-                 * buffer, so we must crop our sync size to account for the
-                 * reserved space
-                 */
-                fep->rx_desc[i].data_ptr =
-                    (unsigned char *)dma_map_single(&fep->ocpdev->dev,
-                                                    (void *)fep->rx_skb[i]->
-                                                    data,
-                                                    fep->rx_buffer_size -
-                                                    skb_res, DMA_FROM_DEVICE);
-
-                /*
-                 * Some 4xx implementations use the previously
-                 * reserved bits in data_len to encode the MS
-                 * 4-bits of a 36-bit physical address (ERPN)
-                 * This must be initialized.
-                 */
-                fep->rx_desc[i].data_len = 0;
-                fep->rx_desc[i].ctrl = MAL_RX_CTRL_EMPTY | MAL_RX_CTRL_INTR |
-                    (i == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
+                skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
+                dev->rx_desc[i].data_ptr =
+                    dma_map_single(dev->ldev, skb->data - 2, rx_sync_size,
+                                   DMA_FROM_DEVICE) + 2;
+                dev->rx_skb[i] = skb;
+        }
+      skip:
+        /* Check if we need to change "Jumbo" bit in MR1 */
+        if ((new_mtu > ETH_DATA_LEN) ^ (dev->ndev->mtu > ETH_DATA_LEN)) {
+                /* This is to prevent starting RX channel in emac_rx_enable() */
+                dev->commac.rx_stopped = 1;
+
+                dev->ndev->mtu = new_mtu;
+                emac_full_tx_reset(dev->ndev);
+        }
 
-        } while ((i = (i + 1) % NUM_RX_BUFF) != end);
+        mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(new_mtu));
+      oom:
+        /* Restart RX */
+        dev->commac.rx_stopped = dev->rx_slot = 0;
+        mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        emac_rx_enable(dev);
 
-        fep->rx_slot = i;
+        return ret;
 }
 
-static void
-emac_rx_csum(struct net_device *dev, unsigned short ctrl, struct sk_buff *skb)
+/* Process ctx, rtnl_lock semaphore */
+static int emac_change_mtu(struct net_device *ndev, int new_mtu)
 {
-        struct ocp_enet_private *fep = dev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
+        int ret = 0;
 
-        /* Exit if interface has no TAH engine */
-        if (!fep->tah_dev) {
-                skb->ip_summed = CHECKSUM_NONE;
-                return;
-        }
+        if (new_mtu < EMAC_MIN_MTU || new_mtu > EMAC_MAX_MTU)
+                return -EINVAL;
 
-        /* Check for TCP/UDP/IP csum error */
-        if (ctrl & EMAC_CSUM_VER_ERROR) {
-                /* Let the stack verify checksum errors */
-                skb->ip_summed = CHECKSUM_NONE;
-/*              adapter->hw_csum_err++; */
-        } else {
-                /* Csum is good */
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-/*              adapter->hw_csum_good++; */
-        }
-}
+        DBG("%d: change_mtu(%d)" NL, dev->def->index, new_mtu);
 
-static int emac_rx_clean(struct net_device *dev)
-{
-        int i, b, bnum = 0, buf[6];
-        int error, frame_length;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned short ctrl;
+        local_bh_disable();
+        if (netif_running(ndev)) {
+                /* Check if we really need to reinitalize RX ring */
+                if (emac_rx_skb_size(ndev->mtu) != emac_rx_skb_size(new_mtu))
+                        ret = emac_resize_rx_ring(dev, new_mtu);
+        }
 
-        i = fep->rx_slot;
+        if (!ret) {
+                ndev->mtu = new_mtu;
+                dev->rx_skb_size = emac_rx_skb_size(new_mtu);
+                dev->rx_sync_size = emac_rx_sync_size(new_mtu);
+        }       
+        local_bh_enable();
 
-        PKT_DEBUG(("emac_rx_clean() entry, rx_slot: %d\n", fep->rx_slot));
+        return ret;
+}
 
-        do {
-                if (fep->rx_skb[i] == NULL)
-                        continue;       /*we have already handled the packet but haved failed to alloc */
-                /* 
-                   since rx_desc is in uncached mem we don't keep reading it directly 
-                   we pull out a local copy of ctrl and do the checks on the copy.
-                 */
-                ctrl = fep->rx_desc[i].ctrl;
-                if (ctrl & MAL_RX_CTRL_EMPTY)
-                        break;  /*we don't have any more ready packets */
-
-                if (EMAC_IS_BAD_RX_PACKET(ctrl)) {
-                        fep->stats.rx_errors++;
-                        fep->stats.rx_dropped++;
-
-                        if (ctrl & EMAC_RX_ST_OE)
-                                fep->stats.rx_fifo_errors++;
-                        if (ctrl & EMAC_RX_ST_AE)
-                                fep->stats.rx_frame_errors++;
-                        if (ctrl & EMAC_RX_ST_BFCS)
-                                fep->stats.rx_crc_errors++;
-                        if (ctrl & (EMAC_RX_ST_RP | EMAC_RX_ST_PTL |
-                                    EMAC_RX_ST_ORE | EMAC_RX_ST_IRE))
-                                fep->stats.rx_length_errors++;
-                } else {
-                        if ((ctrl & (MAL_RX_CTRL_FIRST | MAL_RX_CTRL_LAST)) ==
-                            (MAL_RX_CTRL_FIRST | MAL_RX_CTRL_LAST)) {
-                                /* Single descriptor packet */
-                                emac_rx_csum(dev, ctrl, fep->rx_skb[i]);
-                                /* Send the skb up the chain. */
-                                frame_length = fep->rx_desc[i].data_len - 4;
-                                skb_put(fep->rx_skb[i], frame_length);
-                                fep->rx_skb[i]->dev = dev;
-                                fep->rx_skb[i]->protocol =
-                                    eth_type_trans(fep->rx_skb[i], dev);
-                                error = netif_rx(fep->rx_skb[i]);
-
-                                if ((error == NET_RX_DROP) ||
-                                    (error == NET_RX_BAD)) {
-                                        fep->stats.rx_dropped++;
-                                } else {
-                                        fep->stats.rx_packets++;
-                                        fep->stats.rx_bytes += frame_length;
-                                }
-                                fep->rx_skb[i] = NULL;
-                        } else {
-                                /* Multiple descriptor packet */
-                                if (ctrl & MAL_RX_CTRL_FIRST) {
-                                        if (fep->rx_desc[(i + 1) % NUM_RX_BUFF].
-                                            ctrl & MAL_RX_CTRL_EMPTY)
-                                                break;
-                                        bnum = 0;
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        continue;
-                                }
-                                if (((ctrl & MAL_RX_CTRL_FIRST) !=
-                                     MAL_RX_CTRL_FIRST) &&
-                                    ((ctrl & MAL_RX_CTRL_LAST) !=
-                                     MAL_RX_CTRL_LAST)) {
-                                        if (fep->rx_desc[(i + 1) %
-                                                         NUM_RX_BUFF].ctrl &
-                                            MAL_RX_CTRL_EMPTY) {
-                                                i = buf[0];
-                                                break;
-                                        }
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        continue;
-                                }
-                                if (ctrl & MAL_RX_CTRL_LAST) {
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        skb_put(fep->rx_skb[buf[0]],
-                                                fep->rx_desc[buf[0]].data_len);
-                                        for (b = 1; b < bnum; b++) {
-                                                /*
-                                                 * MAL is braindead, we need
-                                                 * to copy the remainder
-                                                 * of the packet from the
-                                                 * latter descriptor buffers
-                                                 * to the first skb. Then
-                                                 * dispose of the source
-                                                 * skbs.
-                                                 *
-                                                 * Once the stack is fixed
-                                                 * to handle frags on most
-                                                 * protocols we can generate
-                                                 * a fragmented skb with
-                                                 * no copies.
-                                                 */
-                                                memcpy(fep->rx_skb[buf[0]]->
-                                                       data +
-                                                       fep->rx_skb[buf[0]]->len,
-                                                       fep->rx_skb[buf[b]]->
-                                                       data,
-                                                       fep->rx_desc[buf[b]].
-                                                       data_len);
-                                                skb_put(fep->rx_skb[buf[0]],
-                                                        fep->rx_desc[buf[b]].
-                                                        data_len);
-                                                dma_unmap_single(&fep->ocpdev->
-                                                                 dev,
-                                                                 fep->
-                                                                 rx_desc[buf
-                                                                         [b]].
-                                                                 data_ptr,
-                                                                 fep->
-                                                                 rx_desc[buf
-                                                                         [b]].
-                                                                 data_len,
-                                                                 DMA_FROM_DEVICE);
-                                                dev_kfree_skb(fep->
-                                                              rx_skb[buf[b]]);
-                                        }
-                                        emac_rx_csum(dev, ctrl,
-                                                     fep->rx_skb[buf[0]]);
-
-                                        fep->rx_skb[buf[0]]->dev = dev;
-                                        fep->rx_skb[buf[0]]->protocol =
-                                            eth_type_trans(fep->rx_skb[buf[0]],
-                                                           dev);
-                                        error = netif_rx(fep->rx_skb[buf[0]]);
-
-                                        if ((error == NET_RX_DROP)
-                                            || (error == NET_RX_BAD)) {
-                                                fep->stats.rx_dropped++;
-                                        } else {
-                                                fep->stats.rx_packets++;
-                                                fep->stats.rx_bytes +=
-                                                    fep->rx_skb[buf[0]]->len;
-                                        }
-                                        for (b = 0; b < bnum; b++)
-                                                fep->rx_skb[buf[b]] = NULL;
-                                }
-                        }
+static void emac_clean_tx_ring(struct ocp_enet_private *dev)
+{
+        int i;
+        for (i = 0; i < NUM_TX_BUFF; ++i) {
+                if (dev->tx_skb[i]) {
+                        dev_kfree_skb(dev->tx_skb[i]);
+                        dev->tx_skb[i] = NULL;
+                        if (dev->tx_desc[i].ctrl & MAL_TX_CTRL_READY)
+                                ++dev->estats.tx_dropped;
                 }
-        } while ((i = (i + 1) % NUM_RX_BUFF) != fep->rx_slot);
-
-        PKT_DEBUG(("emac_rx_clean() exit, rx_slot: %d\n", fep->rx_slot));
-
-        return i;
+                dev->tx_desc[i].ctrl = 0;
+                dev->tx_desc[i].data_ptr = 0;
+        }
 }
 
-static void emac_rxeob_dev(void *param, u32 chanmask)
+static void emac_clean_rx_ring(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-        int n;
+        int i;
+        for (i = 0; i < NUM_RX_BUFF; ++i)
+                if (dev->rx_skb[i]) {
+                        dev->rx_desc[i].ctrl = 0;
+                        dev_kfree_skb(dev->rx_skb[i]);
+                        dev->rx_skb[i] = NULL;
+                        dev->rx_desc[i].data_ptr = 0;
+                }
 
-        spin_lock_irqsave(&fep->lock, flags);
-        if ((n = emac_rx_clean(dev)) != fep->rx_slot)
-                emac_rx_fill(dev, n);
-        spin_unlock_irqrestore(&fep->lock, flags);
+        if (dev->rx_sg_skb) {
+                dev_kfree_skb(dev->rx_sg_skb);
+                dev->rx_sg_skb = NULL;
+        }
 }
 
-/*
- * This interrupt should never occurr, we don't program
- * the MAL for contiunous mode.
- */
-static void emac_txde_dev(void *param, u32 chanmask)
+static inline int emac_alloc_rx_skb(struct ocp_enet_private *dev, int slot,
+                                    int flags)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
+        struct sk_buff *skb = alloc_skb(dev->rx_skb_size, flags);
+        if (unlikely(!skb))
+                return -ENOMEM;
 
-        printk(KERN_WARNING "%s: transmit descriptor error\n", dev->name);
+        dev->rx_skb[slot] = skb;
+        dev->rx_desc[slot].data_len = 0;
 
-        emac_mac_dump(dev);
-        emac_mal_dump(dev);
+        skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
+        dev->rx_desc[slot].data_ptr = 
+            dma_map_single(dev->ldev, skb->data - 2, dev->rx_sync_size, 
+                           DMA_FROM_DEVICE) + 2;
+        barrier();
+        dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
+            (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
 
-        /* Reenable the transmit channel */
-        mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
+        return 0;
 }
 
-/*
- * This interrupt should be very rare at best.  This occurs when
- * the hardware has a problem with the receive descriptors.  The manual
- * states that it occurs when the hardware cannot the receive descriptor
- * empty bit is not set.  The recovery mechanism will be to
- * traverse through the descriptors, handle any that are marked to be
- * handled and reinitialize each along the way.  At that point the driver
- * will be restarted.
- */
-static void emac_rxde_dev(void *param, u32 chanmask)
+static void emac_print_link_status(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-
-        if (net_ratelimit()) {
-                printk(KERN_WARNING "%s: receive descriptor error\n",
-                       fep->ndev->name);
+        if (netif_carrier_ok(dev->ndev))
+                printk(KERN_INFO "%s: link is up, %d %s%s\n",
+                       dev->ndev->name, dev->phy.speed,
+                       dev->phy.duplex == DUPLEX_FULL ? "FDX" : "HDX",
+                       dev->phy.pause ? ", pause enabled" :
+                       dev->phy.asym_pause ? ", assymetric pause enabled" : "");
+        else
+                printk(KERN_INFO "%s: link is down\n", dev->ndev->name);
+}
 
-                emac_mac_dump(dev);
-                emac_mal_dump(dev);
-                emac_desc_dump(dev);
+/* Process ctx, rtnl_lock semaphore */
+static int emac_open(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+        int err, i;
+
+        DBG("%d: open" NL, dev->def->index);
+
+        /* Setup error IRQ handler */
+        err = request_irq(dev->def->irq, emac_irq, 0, "EMAC", dev);
+        if (err) {
+                printk(KERN_ERR "%s: failed to request IRQ %d\n",
+                       ndev->name, dev->def->irq);
+                return err;
         }
 
-        /* Disable RX channel */
-        spin_lock_irqsave(&fep->lock, flags);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-
-        /* For now, charge the error against all emacs */
-        fep->stats.rx_errors++;
-
-        /* so do we have any good packets still? */
-        emac_rx_clean(dev);
-
-        /* When the interface is restarted it resets processing to the
-         *  first descriptor in the table.
-         */
-
-        fep->rx_slot = 0;
-        emac_rx_fill(dev, 0);
+        /* Allocate RX ring */
+        for (i = 0; i < NUM_RX_BUFF; ++i)
+                if (emac_alloc_rx_skb(dev, i, GFP_KERNEL)) {
+                        printk(KERN_ERR "%s: failed to allocate RX ring\n",
+                               ndev->name);
+                        goto oom;
+                }
 
-        set_mal_dcrn(fep->mal, DCRN_MALRXEOBISR, fep->commac.rx_chan_mask);
-        set_mal_dcrn(fep->mal, DCRN_MALRXDEIR, fep->commac.rx_chan_mask);
+        local_bh_disable();
+        dev->tx_cnt = dev->tx_slot = dev->ack_slot = dev->rx_slot =
+            dev->commac.rx_stopped = 0;
+        dev->rx_sg_skb = NULL;
+
+        if (dev->phy.address >= 0) {
+                int link_poll_interval;
+                if (dev->phy.def->ops->poll_link(&dev->phy)) {
+                        dev->phy.def->ops->read_link(&dev->phy);
+                        EMAC_RX_CLK_DEFAULT(dev->def->index);
+                        netif_carrier_on(dev->ndev);
+                        link_poll_interval = PHY_POLL_LINK_ON;
+                } else {
+                        EMAC_RX_CLK_TX(dev->def->index);
+                        netif_carrier_off(dev->ndev);
+                        link_poll_interval = PHY_POLL_LINK_OFF;
+                }
+                mod_timer(&dev->link_timer, jiffies + link_poll_interval);
+                emac_print_link_status(dev);
+        } else
+                netif_carrier_on(dev->ndev);
+
+        emac_configure(dev);
+        mal_poll_add(dev->mal, &dev->commac);
+        mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(ndev->mtu));
+        mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        emac_tx_enable(dev);
+        emac_rx_enable(dev);
+        netif_start_queue(ndev);
+        local_bh_enable();
 
-        /* Reenable the receive channels */
-        mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-        spin_unlock_irqrestore(&fep->lock, flags);
+        return 0;
+      oom:
+        emac_clean_rx_ring(dev);
+        free_irq(dev->def->irq, dev);
+        return -ENOMEM;
 }
 
-static irqreturn_t
-emac_mac_irq(int irq, void *dev_instance, struct pt_regs *regs)
+/* BHs disabled */
+static int emac_link_differs(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = dev_instance;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        unsigned long tmp_em0isr;
+        u32 r = in_be32(&dev->emacp->mr1);
 
-        /* EMAC interrupt */
-        tmp_em0isr = in_be32(&emacp->em0isr);
-        if (tmp_em0isr & (EMAC_ISR_TE0 | EMAC_ISR_TE1)) {
-                /* This error is a hard transmit error - could retransmit */
-                fep->stats.tx_errors++;
+        int duplex = r & EMAC_MR1_FDE ? DUPLEX_FULL : DUPLEX_HALF;
+        int speed, pause, asym_pause;
 
-                /* Reenable the transmit channel */
-                mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
+        if (r & (EMAC_MR1_MF_1000 | EMAC_MR1_MF_1000GPCS))
+                speed = SPEED_1000;
+        else if (r & EMAC_MR1_MF_100)
+                speed = SPEED_100;
+        else
+                speed = SPEED_10;
 
-        } else {
-                fep->stats.rx_errors++;
+        switch (r & (EMAC_MR1_EIFC | EMAC_MR1_APP)) {
+        case (EMAC_MR1_EIFC | EMAC_MR1_APP):
+                pause = 1;
+                asym_pause = 0;
+                break;
+        case EMAC_MR1_APP:
+                pause = 0;
+                asym_pause = 1;
+                break;
+        default:
+                pause = asym_pause = 0;
         }
-
-        if (tmp_em0isr & EMAC_ISR_RP)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_ALE)
-                fep->stats.rx_frame_errors++;
-        if (tmp_em0isr & EMAC_ISR_BFCS)
-                fep->stats.rx_crc_errors++;
-        if (tmp_em0isr & EMAC_ISR_PTLE)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_ORE)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_TE0)
-                fep->stats.tx_aborted_errors++;
-
-        emac_err_dump(dev, tmp_em0isr);
-
-        out_be32(&emacp->em0isr, tmp_em0isr);
-
-        return IRQ_HANDLED;
+        return speed != dev->phy.speed || duplex != dev->phy.duplex ||
+            pause != dev->phy.pause || asym_pause != dev->phy.asym_pause;
 }
 
-static int emac_start_xmit(struct sk_buff *skb, struct net_device *dev)
+/* BHs disabled */
+static void emac_link_timer(unsigned long data)
 {
-        unsigned short ctrl;
-        unsigned long flags;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        int len = skb->len;
-        unsigned int offset = 0, size, f, tx_slot_first;
-        unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
+        struct ocp_enet_private *dev = (struct ocp_enet_private *)data;
+        int link_poll_interval;
 
-        spin_lock_irqsave(&fep->lock, flags);
+        DBG2("%d: link timer" NL, dev->def->index);
 
-        len -= skb->data_len;
+        if (dev->phy.def->ops->poll_link(&dev->phy)) {
+                if (!netif_carrier_ok(dev->ndev)) {
+                        EMAC_RX_CLK_DEFAULT(dev->def->index);
 
-        if ((fep->tx_cnt + nr_frags + len / DESC_BUF_SIZE + 1) > NUM_TX_BUFF) {
-                PKT_DEBUG(("emac_start_xmit() stopping queue\n"));
-                netif_stop_queue(dev);
-                spin_unlock_irqrestore(&fep->lock, flags);
-                return -EBUSY;
-        }
+                        /* Get new link parameters */
+                        dev->phy.def->ops->read_link(&dev->phy);
 
-        tx_slot_first = fep->tx_slot;
+                        if (dev->tah_dev || emac_link_differs(dev))
+                                emac_full_tx_reset(dev->ndev);
 
-        while (len) {
-                size = min(len, DESC_BUF_SIZE);
-
-                fep->tx_desc[fep->tx_slot].data_len = (short)size;
-                fep->tx_desc[fep->tx_slot].data_ptr =
-                    (unsigned char *)dma_map_single(&fep->ocpdev->dev,
-                                                    (void *)((unsigned int)skb->
-                                                             data + offset),
-                                                    size, DMA_TO_DEVICE);
-
-                ctrl = EMAC_TX_CTRL_DFLT;
-                if (fep->tx_slot != tx_slot_first)
-                        ctrl |= MAL_TX_CTRL_READY;
-                if ((NUM_TX_BUFF - 1) == fep->tx_slot)
-                        ctrl |= MAL_TX_CTRL_WRAP;
-                if (!nr_frags && (len == size)) {
-                        ctrl |= MAL_TX_CTRL_LAST;
-                        fep->tx_skb[fep->tx_slot] = skb;
+                        netif_carrier_on(dev->ndev);
+                        emac_print_link_status(dev);
+                }
+                link_poll_interval = PHY_POLL_LINK_ON;
+        } else {
+                if (netif_carrier_ok(dev->ndev)) {
+                        EMAC_RX_CLK_TX(dev->def->index);
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
+                        emac_reinitialize(dev);
+#endif
+                        netif_carrier_off(dev->ndev);
+                        emac_print_link_status(dev);
                 }
-                if (skb->ip_summed == CHECKSUM_HW)
-                        ctrl |= EMAC_TX_CTRL_TAH_CSUM;
 
-                fep->tx_desc[fep->tx_slot].ctrl = ctrl;
+                /* Retry reset if the previous attempt failed.
+                 * This is needed mostly for CONFIG_IBM_EMAC_PHY_RX_CLK_FIX
+                 * case, but I left it here because it shouldn't trigger for
+                 * sane PHYs anyway.
+                 */
+                if (unlikely(dev->reset_failed))
+                        emac_reinitialize(dev);
 
-                len -= size;
-                offset += size;
+                link_poll_interval = PHY_POLL_LINK_OFF;
+        }
+        mod_timer(&dev->link_timer, jiffies + link_poll_interval);
+}
 
-                /* Bump tx count */
-                if (++fep->tx_cnt == NUM_TX_BUFF)
-                        netif_stop_queue(dev);
+/* BHs disabled */
+static void emac_force_link_update(struct ocp_enet_private *dev)
+{
+        netif_carrier_off(dev->ndev);
+        if (timer_pending(&dev->link_timer))
+                mod_timer(&dev->link_timer, jiffies + PHY_POLL_LINK_OFF);
+}
 
-                /* Next descriptor */
-                if (++fep->tx_slot == NUM_TX_BUFF)
-                        fep->tx_slot = 0;
-        }
+/* Process ctx, rtnl_lock semaphore */
+static int emac_close(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        for (f = 0; f < nr_frags; f++) {
-                struct skb_frag_struct *frag;
+        DBG("%d: close" NL, dev->def->index);
 
-                frag = &skb_shinfo(skb)->frags[f];
-                len = frag->size;
-                offset = 0;
-
-                while (len) {
-                        size = min(len, DESC_BUF_SIZE);
-
-                        dma_map_page(&fep->ocpdev->dev,
-                                     frag->page,
-                                     frag->page_offset + offset,
-                                     size, DMA_TO_DEVICE);
-
-                        ctrl = EMAC_TX_CTRL_DFLT | MAL_TX_CTRL_READY;
-                        if ((NUM_TX_BUFF - 1) == fep->tx_slot)
-                                ctrl |= MAL_TX_CTRL_WRAP;
-                        if ((f == (nr_frags - 1)) && (len == size)) {
-                                ctrl |= MAL_TX_CTRL_LAST;
-                                fep->tx_skb[fep->tx_slot] = skb;
-                        }
+        local_bh_disable();
 
-                        if (skb->ip_summed == CHECKSUM_HW)
-                                ctrl |= EMAC_TX_CTRL_TAH_CSUM;
+        if (dev->phy.address >= 0)
+                del_timer_sync(&dev->link_timer);
 
-                        fep->tx_desc[fep->tx_slot].data_len = (short)size;
-                        fep->tx_desc[fep->tx_slot].data_ptr =
-                            (char *)((page_to_pfn(frag->page) << PAGE_SHIFT) +
-                                     frag->page_offset + offset);
-                        fep->tx_desc[fep->tx_slot].ctrl = ctrl;
+        netif_stop_queue(ndev);
+        emac_rx_disable(dev);
+        emac_tx_disable(dev);
+        mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        mal_poll_del(dev->mal, &dev->commac);
+        local_bh_enable();
 
-                        len -= size;
-                        offset += size;
+        emac_clean_tx_ring(dev);
+        emac_clean_rx_ring(dev);
+        free_irq(dev->def->irq, dev);
 
-                        /* Bump tx count */
-                        if (++fep->tx_cnt == NUM_TX_BUFF)
-                                netif_stop_queue(dev);
+        return 0;
+}
 
-                        /* Next descriptor */
-                        if (++fep->tx_slot == NUM_TX_BUFF)
-                                fep->tx_slot = 0;
-                }
+static inline u16 emac_tx_csum(struct ocp_enet_private *dev,
+                               struct sk_buff *skb)
+{
+#if defined(CONFIG_IBM_EMAC_TAH)
+        if (skb->ip_summed == CHECKSUM_HW) {
+                ++dev->stats.tx_packets_csum;
+                return EMAC_TX_CTRL_TAH_CSUM;
         }
+#endif
+        return 0;
+}
 
-        /*
-         * Deferred set READY on first descriptor of packet to
-         * avoid TX MAL race.
-         */
-        fep->tx_desc[tx_slot_first].ctrl |= MAL_TX_CTRL_READY;
-
-        /* Send the packet out. */
-        out_be32(&emacp->em0tmr0, EMAC_TMR0_XMIT);
+static inline int emac_xmit_finish(struct ocp_enet_private *dev, int len)
+{
+        struct emac_regs *p = dev->emacp;
+        struct net_device *ndev = dev->ndev;
 
-        fep->stats.tx_packets++;
-        fep->stats.tx_bytes += skb->len;
+        /* Send the packet out */
+        out_be32(&p->tmr0, EMAC_TMR0_XMIT);
 
-        PKT_DEBUG(("emac_start_xmit() exitn"));
+        if (unlikely(++dev->tx_cnt == NUM_TX_BUFF)) {
+                netif_stop_queue(ndev);
+                DBG2("%d: stopped TX queue" NL, dev->def->index);
+        }
 
-        spin_unlock_irqrestore(&fep->lock, flags);
+        ndev->trans_start = jiffies;
+        ++dev->stats.tx_packets;
+        dev->stats.tx_bytes += len;
 
         return 0;
 }
 
-static int emac_adjust_to_link(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
-        emac_t *emacp = fep->emacp;
-        unsigned long mode_reg;
-        int full_duplex, speed;
+        struct ocp_enet_private *dev = ndev->priv;
+        unsigned int len = skb->len;
+        int slot;
 
-        full_duplex = 0;
-        speed = SPEED_10;
+        u16 ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
+            MAL_TX_CTRL_LAST | emac_tx_csum(dev, skb);
 
-        /* set mode register 1 defaults */
-        mode_reg = EMAC_M1_DEFAULT;
-
-        /* Read link mode on PHY */
-        if (fep->phy_mii.def->ops->read_link(&fep->phy_mii) == 0) {
-                /* If an error occurred, we don't deal with it yet */
-                full_duplex = (fep->phy_mii.duplex == DUPLEX_FULL);
-                speed = fep->phy_mii.speed;
+        slot = dev->tx_slot++;
+        if (dev->tx_slot == NUM_TX_BUFF) {
+                dev->tx_slot = 0;
+                ctrl |= MAL_TX_CTRL_WRAP;
         }
 
+        DBG2("%d: xmit(%u) %d" NL, dev->def->index, len, slot);
 
-        /* set speed (default is 10Mb) */
-        switch (speed) {
-        case SPEED_1000:
-                mode_reg |= EMAC_M1_RFS_16K;
-                if (fep->rgmii_dev) {
-                        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(fep->rgmii_dev);
-
-                        if ((rgmii->mode[fep->rgmii_input] == RTBI)
-                            || (rgmii->mode[fep->rgmii_input] == TBI))
-                                mode_reg |= EMAC_M1_MF_1000GPCS;
-                        else
-                                mode_reg |= EMAC_M1_MF_1000MBPS;
-
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              1000);
-                }
-                break;
-        case SPEED_100:
-                mode_reg |= EMAC_M1_MF_100MBPS | EMAC_M1_RFS_4K;
-                if (fep->rgmii_dev)
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              100);
-                if (fep->zmii_dev)
-                        emac_zmii_port_speed(fep->zmii_dev, fep->zmii_input,
-                                             100);
-                break;
-        case SPEED_10:
-        default:
-                mode_reg = (mode_reg & ~EMAC_M1_MF_100MBPS) | EMAC_M1_RFS_4K;
-                if (fep->rgmii_dev)
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              10);
-                if (fep->zmii_dev)
-                        emac_zmii_port_speed(fep->zmii_dev, fep->zmii_input,
-                                             10);
-        }
-
-        if (full_duplex)
-                mode_reg |= EMAC_M1_FDE | EMAC_M1_EIFC | EMAC_M1_IST;
-        else
-                mode_reg &= ~(EMAC_M1_FDE | EMAC_M1_EIFC | EMAC_M1_ILE);
+        dev->tx_skb[slot] = skb;
+        dev->tx_desc[slot].data_ptr = dma_map_single(dev->ldev, skb->data, len,
+                                                     DMA_TO_DEVICE);
+        dev->tx_desc[slot].data_len = (u16) len;
+        barrier();
+        dev->tx_desc[slot].ctrl = ctrl;
 
-        LINK_DEBUG(("%s: adjust to link, speed: %d, duplex: %d, opened: %d\n",
-                    fep->ndev->name, speed, full_duplex, fep->opened));
-
-        printk(KERN_INFO "%s: Speed: %d, %s duplex.\n",
-               fep->ndev->name, speed, full_duplex ? "Full" : "Half");
-        if (fep->opened)
-                out_be32(&emacp->em0mr1, mode_reg);
-
-        return 0;
+        return emac_xmit_finish(dev, len);
 }
 
-static int emac_set_mac_address(struct net_device *ndev, void *p)
+#if defined(CONFIG_IBM_EMAC_TAH)
+static inline int emac_xmit_split(struct ocp_enet_private *dev, int slot,
+                                  u32 pd, int len, int last, u16 base_ctrl)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-        emac_t *emacp = fep->emacp;
-        struct sockaddr *addr = p;
+        while (1) {
+                u16 ctrl = base_ctrl;
+                int chunk = min(len, MAL_MAX_TX_SIZE);
+                len -= chunk;
 
-        if (!is_valid_ether_addr(addr->sa_data))
-                return -EADDRNOTAVAIL;
+                slot = (slot + 1) % NUM_TX_BUFF;
 
-        memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+                if (last && !len)
+                        ctrl |= MAL_TX_CTRL_LAST;
+                if (slot == NUM_TX_BUFF - 1)
+                        ctrl |= MAL_TX_CTRL_WRAP;
 
-        /* set the high address */
-        out_be32(&emacp->em0iahr,
-                 (fep->ndev->dev_addr[0] << 8) | fep->ndev->dev_addr[1]);
+                dev->tx_skb[slot] = NULL;
+                dev->tx_desc[slot].data_ptr = pd;
+                dev->tx_desc[slot].data_len = (u16) chunk;
+                dev->tx_desc[slot].ctrl = ctrl;
+                ++dev->tx_cnt;
 
-        /* set the low address */
-        out_be32(&emacp->em0ialr,
-                 (fep->ndev->dev_addr[2] << 24) | (fep->ndev->dev_addr[3] << 16)
-                 | (fep->ndev->dev_addr[4] << 8) | fep->ndev->dev_addr[5]);
+                if (!len)
+                        break;
 
-        return 0;
+                pd += chunk;
+        }
+        return slot;
 }
 
-static int emac_change_mtu(struct net_device *dev, int new_mtu)
+/* BHs disabled (SG version for TAH equipped EMACs) */
+static int emac_start_xmit_sg(struct sk_buff *skb, struct net_device *ndev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int old_mtu = dev->mtu;
-        unsigned long mode_reg;
-        emac_t *emacp = fep->emacp;
-        u32 em0mr0;
-        int i, full;
-        unsigned long flags;
+        struct ocp_enet_private *dev = ndev->priv;
+        int nr_frags = skb_shinfo(skb)->nr_frags;
+        int len = skb->len, chunk;
+        int slot, i;
+        u16 ctrl;
+        u32 pd;
 
-        if ((new_mtu < EMAC_MIN_MTU) || (new_mtu > EMAC_MAX_MTU)) {
-                printk(KERN_ERR
-                       "emac: Invalid MTU setting, MTU must be between %d and %d\n",
-                       EMAC_MIN_MTU, EMAC_MAX_MTU);
-                return -EINVAL;
-        }
+        /* This is common "fast" path */
+        if (likely(!nr_frags && len <= MAL_MAX_TX_SIZE))
+                return emac_start_xmit(skb, ndev);
 
-        if (old_mtu != new_mtu && netif_running(dev)) {
-                /* Stop rx engine */
-                em0mr0 = in_be32(&emacp->em0mr0);
-                out_be32(&emacp->em0mr0, em0mr0 & ~EMAC_M0_RXE);
-
-                /* Wait for descriptors to be empty */
-                do {
-                        full = 0;
-                        for (i = 0; i < NUM_RX_BUFF; i++)
-                                if (!(fep->rx_desc[i].ctrl & MAL_RX_CTRL_EMPTY)) {
-                                        printk(KERN_NOTICE
-                                               "emac: RX ring is still full\n");
-                                        full = 1;
-                                }
-                } while (full);
-
-                spin_lock_irqsave(&fep->lock, flags);
-
-                mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-
-                /* Destroy all old rx skbs */
-                for (i = 0; i < NUM_RX_BUFF; i++) {
-                        dma_unmap_single(&fep->ocpdev->dev,
-                                         fep->rx_desc[i].data_ptr,
-                                         fep->rx_desc[i].data_len,
-                                         DMA_FROM_DEVICE);
-                        dev_kfree_skb(fep->rx_skb[i]);
-                        fep->rx_skb[i] = NULL;
-                }
+        len -= skb->data_len;
 
-                /* Set new rx_buffer_size, jumbo cap, and advertise new mtu */
-                mode_reg = in_be32(&emacp->em0mr1);
-                if (new_mtu > ENET_DEF_MTU_SIZE) {
-                        mode_reg |= EMAC_M1_JUMBO_ENABLE;
-                        fep->rx_buffer_size = EMAC_MAX_FRAME;
-                } else {
-                        mode_reg &= ~EMAC_M1_JUMBO_ENABLE;
-                        fep->rx_buffer_size = ENET_DEF_BUF_SIZE;
-                }
-                dev->mtu = new_mtu;
-                out_be32(&emacp->em0mr1, mode_reg);
+        /* Note, this is only an *estimation*, we can still run out of empty
+         * slots because of the additional fragmentation into
+         * MAL_MAX_TX_SIZE-sized chunks
+         */
+        if (unlikely(dev->tx_cnt + nr_frags + mal_tx_chunks(len) > NUM_TX_BUFF))
+                goto stop_queue;
+
+        ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
+            emac_tx_csum(dev, skb);
+        slot = dev->tx_slot;
+
+        /* skb data */
+        dev->tx_skb[slot] = NULL;
+        chunk = min(len, MAL_MAX_TX_SIZE);
+        dev->tx_desc[slot].data_ptr = pd =
+            dma_map_single(dev->ldev, skb->data, len, DMA_TO_DEVICE);
+        dev->tx_desc[slot].data_len = (u16) chunk;
+        len -= chunk;
+        if (unlikely(len))
+                slot = emac_xmit_split(dev, slot, pd + chunk, len, !nr_frags,
+                                       ctrl);
+        /* skb fragments */
+        for (i = 0; i < nr_frags; ++i) {
+                struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
+                len = frag->size;
 
-                /* Re-init rx skbs */
-                fep->rx_slot = 0;
-                emac_rx_fill(dev, 0);
+                if (unlikely(dev->tx_cnt + mal_tx_chunks(len) >= NUM_TX_BUFF))
+                        goto undo_frame;
 
-                /* Restart the rx engine */
-                mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-                out_be32(&emacp->em0mr0, em0mr0 | EMAC_M0_RXE);
+                pd = dma_map_page(dev->ldev, frag->page, frag->page_offset, len,
+                                  DMA_TO_DEVICE);
 
-                spin_unlock_irqrestore(&fep->lock, flags);
+                slot = emac_xmit_split(dev, slot, pd, len, i == nr_frags - 1,
+                                       ctrl);
         }
 
-        return 0;
-}
+        DBG2("%d: xmit_sg(%u) %d - %d" NL, dev->def->index, skb->len,
+             dev->tx_slot, slot);
 
-static void __emac_set_multicast_list(struct net_device *dev)
-{
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        u32 rmr = in_be32(&emacp->em0rmr);
+        /* Attach skb to the last slot so we don't release it too early */
+        dev->tx_skb[slot] = skb;
 
-        /* First clear all special bits, they can be set later */
-        rmr &= ~(EMAC_RMR_PME | EMAC_RMR_PMME | EMAC_RMR_MAE);
+        /* Send the packet out */
+        if (dev->tx_slot == NUM_TX_BUFF - 1)
+                ctrl |= MAL_TX_CTRL_WRAP;
+        barrier();
+        dev->tx_desc[dev->tx_slot].ctrl = ctrl;
+        dev->tx_slot = (slot + 1) % NUM_TX_BUFF;
 
-        if (dev->flags & IFF_PROMISC) {
-                rmr |= EMAC_RMR_PME;
-        } else if (dev->flags & IFF_ALLMULTI || 32 < dev->mc_count) {
-                /*
-                 * Must be setting up to use multicast
-                 * Now check for promiscuous multicast
-                 */
-                rmr |= EMAC_RMR_PMME;
-        } else if (dev->flags & IFF_MULTICAST && 0 < dev->mc_count) {
-                unsigned short em0gaht[4] = { 0, 0, 0, 0 };
-                struct dev_mc_list *dmi;
-
-                /* Need to hash on the multicast address. */
-                for (dmi = dev->mc_list; dmi; dmi = dmi->next) {
-                        unsigned long mc_crc;
-                        unsigned int bit_number;
-
-                        mc_crc = ether_crc(6, (char *)dmi->dmi_addr);
-                        bit_number = 63 - (mc_crc >> 26);       /* MSB: 0 LSB: 63 */
-                        em0gaht[bit_number >> 4] |=
-                            0x8000 >> (bit_number & 0x0f);
-                }
-                emacp->em0gaht1 = em0gaht[0];
-                emacp->em0gaht2 = em0gaht[1];
-                emacp->em0gaht3 = em0gaht[2];
-                emacp->em0gaht4 = em0gaht[3];
+        return emac_xmit_finish(dev, skb->len);
 
-                /* Turn on multicast addressing */
-                rmr |= EMAC_RMR_MAE;
+      undo_frame:
+        /* Well, too bad. Our previous estimation was overly optimistic. 
+         * Undo everything.
+         */
+        while (slot != dev->tx_slot) {
+                dev->tx_desc[slot].ctrl = 0;
+                --dev->tx_cnt;
+                if (--slot < 0)
+                        slot = NUM_TX_BUFF - 1;
         }
-        out_be32(&emacp->em0rmr, rmr);
+        ++dev->estats.tx_undo;
+
+      stop_queue:
+        netif_stop_queue(ndev);
+        DBG2("%d: stopped TX queue" NL, dev->def->index);
+        return 1;
 }
+#else
+# define emac_start_xmit_sg     emac_start_xmit
+#endif  /* !defined(CONFIG_IBM_EMAC_TAH) */
 
-static int emac_init_tah(struct ocp_enet_private *fep)
+/* BHs disabled */
+static void emac_parse_tx_error(struct ocp_enet_private *dev, u16 ctrl)
 {
-        tah_t *tahp;
+        struct ibm_emac_error_stats *st = &dev->estats;
+        DBG("%d: BD TX error %04x" NL, dev->def->index, ctrl);
+
+        ++st->tx_bd_errors;
+        if (ctrl & EMAC_TX_ST_BFCS)
+                ++st->tx_bd_bad_fcs;
+        if (ctrl & EMAC_TX_ST_LCS)
+                ++st->tx_bd_carrier_loss;
+        if (ctrl & EMAC_TX_ST_ED)
+                ++st->tx_bd_excessive_deferral;
+        if (ctrl & EMAC_TX_ST_EC)
+                ++st->tx_bd_excessive_collisions;
+        if (ctrl & EMAC_TX_ST_LC)
+                ++st->tx_bd_late_collision;
+        if (ctrl & EMAC_TX_ST_MC)
+                ++st->tx_bd_multple_collisions;
+        if (ctrl & EMAC_TX_ST_SC)
+                ++st->tx_bd_single_collision;
+        if (ctrl & EMAC_TX_ST_UR)
+                ++st->tx_bd_underrun;
+        if (ctrl & EMAC_TX_ST_SQE)
+                ++st->tx_bd_sqe;
+}
 
-        /* Initialize TAH and enable checksum verification */
-        tahp = (tah_t *) ioremap(fep->tah_dev->def->paddr, sizeof(*tahp));
+static void emac_poll_tx(void *param)
+{
+        struct ocp_enet_private *dev = param;
+        DBG2("%d: poll_tx, %d %d" NL, dev->def->index, dev->tx_cnt,
+             dev->ack_slot);
+
+        if (dev->tx_cnt) {
+                u16 ctrl;
+                int slot = dev->ack_slot, n = 0;
+              again:
+                ctrl = dev->tx_desc[slot].ctrl;
+                if (!(ctrl & MAL_TX_CTRL_READY)) {
+                        struct sk_buff *skb = dev->tx_skb[slot];
+                        ++n;
+
+                        if (skb) {
+                                dev_kfree_skb(skb);
+                                dev->tx_skb[slot] = NULL;
+                        }
+                        slot = (slot + 1) % NUM_TX_BUFF;
 
-        if (tahp == NULL) {
-                printk(KERN_ERR "tah%d: Cannot ioremap TAH registers!\n",
-                       fep->tah_dev->def->index);
+                        if (unlikely(EMAC_IS_BAD_TX(ctrl)))
+                                emac_parse_tx_error(dev, ctrl);
 
-                return -ENOMEM;
-        }
-
-        out_be32(&tahp->tah_mr, TAH_MR_SR);
+                        if (--dev->tx_cnt)
+                                goto again;
+                }
+                if (n) {
+                        dev->ack_slot = slot;
+                        if (netif_queue_stopped(dev->ndev) &&
+                            dev->tx_cnt < EMAC_TX_WAKEUP_THRESH)
+                                netif_wake_queue(dev->ndev);
 
-        /* wait for reset to complete */
-        while (in_be32(&tahp->tah_mr) & TAH_MR_SR) ;
+                        DBG2("%d: tx %d pkts" NL, dev->def->index, n);
+                }
+        }
+}
 
-        /* 10KB TAH TX FIFO accomodates the max MTU of 9000 */
-        out_be32(&tahp->tah_mr,
-                 TAH_MR_CVR | TAH_MR_ST_768 | TAH_MR_TFS_10KB | TAH_MR_DTFP |
-                 TAH_MR_DIG);
+static inline void emac_recycle_rx_skb(struct ocp_enet_private *dev, int slot,
+                                       int len)
+{
+        struct sk_buff *skb = dev->rx_skb[slot];
+        DBG2("%d: recycle %d %d" NL, dev->def->index, slot, len);
 
-        iounmap(tahp);
+        if (len) 
+                dma_map_single(dev->ldev, skb->data - 2, 
+                               EMAC_DMA_ALIGN(len + 2), DMA_FROM_DEVICE);
 
-        return 0;
+        dev->rx_desc[slot].data_len = 0;
+        barrier();
+        dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
+            (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
 }
 
-static void emac_init_rings(struct net_device *dev)
+static void emac_parse_rx_error(struct ocp_enet_private *dev, u16 ctrl)
 {
-        struct ocp_enet_private *ep = dev->priv;
-        int loop;
+        struct ibm_emac_error_stats *st = &dev->estats;
+        DBG("%d: BD RX error %04x" NL, dev->def->index, ctrl);
+
+        ++st->rx_bd_errors;
+        if (ctrl & EMAC_RX_ST_OE)
+                ++st->rx_bd_overrun;
+        if (ctrl & EMAC_RX_ST_BP)
+                ++st->rx_bd_bad_packet;
+        if (ctrl & EMAC_RX_ST_RP)
+                ++st->rx_bd_runt_packet;
+        if (ctrl & EMAC_RX_ST_SE)
+                ++st->rx_bd_short_event;
+        if (ctrl & EMAC_RX_ST_AE)
+                ++st->rx_bd_alignment_error;
+        if (ctrl & EMAC_RX_ST_BFCS)
+                ++st->rx_bd_bad_fcs;
+        if (ctrl & EMAC_RX_ST_PTL)
+                ++st->rx_bd_packet_too_long;
+        if (ctrl & EMAC_RX_ST_ORE)
+                ++st->rx_bd_out_of_range;
+        if (ctrl & EMAC_RX_ST_IRE)
+                ++st->rx_bd_in_range;
+}
 
-        ep->tx_desc = (struct mal_descriptor *)((char *)ep->mal->tx_virt_addr +
-                                                (ep->mal_tx_chan *
-                                                 MAL_DT_ALIGN));
-        ep->rx_desc =
-            (struct mal_descriptor *)((char *)ep->mal->rx_virt_addr +
-                                      (ep->mal_rx_chan * MAL_DT_ALIGN));
+static inline void emac_rx_csum(struct ocp_enet_private *dev,
+                                struct sk_buff *skb, u16 ctrl)
+{
+#if defined(CONFIG_IBM_EMAC_TAH)
+        if (!ctrl && dev->tah_dev) {
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                ++dev->stats.rx_packets_csum;
+        }
+#endif
+}
 
-        /* Fill in the transmit descriptor ring. */
-        for (loop = 0; loop < NUM_TX_BUFF; loop++) {
-                if (ep->tx_skb[loop]) {
-                        dma_unmap_single(&ep->ocpdev->dev,
-                                         ep->tx_desc[loop].data_ptr,
-                                         ep->tx_desc[loop].data_len,
-                                         DMA_TO_DEVICE);
-                        dev_kfree_skb_irq(ep->tx_skb[loop]);
+static inline int emac_rx_sg_append(struct ocp_enet_private *dev, int slot)
+{
+        if (likely(dev->rx_sg_skb != NULL)) {
+                int len = dev->rx_desc[slot].data_len;
+                int tot_len = dev->rx_sg_skb->len + len;
+
+                if (unlikely(tot_len + 2 > dev->rx_skb_size)) {
+                        ++dev->estats.rx_dropped_mtu;
+                        dev_kfree_skb(dev->rx_sg_skb);
+                        dev->rx_sg_skb = NULL;
+                } else {
+                        cacheable_memcpy(dev->rx_sg_skb->tail,
+                                         dev->rx_skb[slot]->data, len);
+                        skb_put(dev->rx_sg_skb, len);
+                        emac_recycle_rx_skb(dev, slot, len);
+                        return 0;
                 }
-                ep->tx_skb[loop] = NULL;
-                ep->tx_desc[loop].ctrl = 0;
-                ep->tx_desc[loop].data_len = 0;
-                ep->tx_desc[loop].data_ptr = NULL;
-        }
-        ep->tx_desc[loop - 1].ctrl |= MAL_TX_CTRL_WRAP;
-
-        /* Format the receive descriptor ring. */
-        ep->rx_slot = 0;
-        /* Default is MTU=1500 + Ethernet overhead */
-        ep->rx_buffer_size = dev->mtu + ENET_HEADER_SIZE + ENET_FCS_SIZE;
-        emac_rx_fill(dev, 0);
-        if (ep->rx_slot != 0) {
-                printk(KERN_ERR
-                       "%s: Not enough mem for RxChain durning Open?\n",
-                       dev->name);
-                /*We couldn't fill the ring at startup?
-                 *We could clean up and fail to open but right now we will try to
-                 *carry on. It may be a sign of a bad NUM_RX_BUFF value
-                 */
         }
-
-        ep->tx_cnt = 0;
-        ep->tx_slot = 0;
-        ep->ack_slot = 0;
+        emac_recycle_rx_skb(dev, slot, 0);
+        return -1;
 }
 
-static void emac_reset_configure(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_poll_rx(void *param, int budget)
 {
-        emac_t *emacp = fep->emacp;
-        int i;
-
-        mal_disable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
+        struct ocp_enet_private *dev = param;
+        int slot = dev->rx_slot, received = 0;
 
-        /*
-         * Check for a link, some PHYs don't provide a clock if
-         * no link is present.  Some EMACs will not come out of
-         * soft reset without a PHY clock present.
-         */
-        if (fep->phy_mii.def->ops->poll_link(&fep->phy_mii)) {
-                /* Reset the EMAC */
-                out_be32(&emacp->em0mr0, EMAC_M0_SRST);
-                udelay(20);
-                for (i = 0; i < 100; i++) {
-                        if ((in_be32(&emacp->em0mr0) & EMAC_M0_SRST) == 0)
-                                break;
-                        udelay(10);
-                }
-
-                if (i >= 100) {
-                        printk(KERN_ERR "%s: Cannot reset EMAC\n",
-                               fep->ndev->name);
-                        return;
-                }
-        }
+        DBG2("%d: poll_rx(%d)" NL, dev->def->index, budget);
 
-        /* Switch IRQs off for now */
-        out_be32(&emacp->em0iser, 0);
+      again:
+        while (budget > 0) {
+                int len;
+                struct sk_buff *skb;
+                u16 ctrl = dev->rx_desc[slot].ctrl;
 
-        /* Configure MAL rx channel */
-        mal_set_rcbs(fep->mal, fep->mal_rx_chan, DESC_BUF_SIZE_REG);
+                if (ctrl & MAL_RX_CTRL_EMPTY)
+                        break;
 
-        /* set the high address */
-        out_be32(&emacp->em0iahr,
-                 (fep->ndev->dev_addr[0] << 8) | fep->ndev->dev_addr[1]);
+                skb = dev->rx_skb[slot];
+                barrier();
+                len = dev->rx_desc[slot].data_len;
 
-        /* set the low address */
-        out_be32(&emacp->em0ialr,
-                 (fep->ndev->dev_addr[2] << 24) | (fep->ndev->dev_addr[3] << 16)
-                 | (fep->ndev->dev_addr[4] << 8) | fep->ndev->dev_addr[5]);
+                if (unlikely(!MAL_IS_SINGLE_RX(ctrl)))
+                        goto sg;
 
-        /* Adjust to link */
-        if (netif_carrier_ok(fep->ndev))
-                emac_adjust_to_link(fep);
+                ctrl &= EMAC_BAD_RX_MASK;
+                if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
+                        emac_parse_rx_error(dev, ctrl);
+                        ++dev->estats.rx_dropped_error;
+                        emac_recycle_rx_skb(dev, slot, 0);
+                        len = 0;
+                        goto next;
+                }
 
-        /* enable broadcast/individual address and RX FIFO defaults */
-        out_be32(&emacp->em0rmr, EMAC_RMR_DEFAULT);
+                if (len && len < EMAC_RX_COPY_THRESH) {
+                        struct sk_buff *copy_skb =
+                            alloc_skb(len + EMAC_RX_SKB_HEADROOM + 2, GFP_ATOMIC);
+                        if (unlikely(!copy_skb))
+                                goto oom;
+
+                        skb_reserve(copy_skb, EMAC_RX_SKB_HEADROOM + 2);
+                        cacheable_memcpy(copy_skb->data - 2, skb->data - 2,
+                                         len + 2);
+                        emac_recycle_rx_skb(dev, slot, len);
+                        skb = copy_skb;
+                } else if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC)))
+                        goto oom;
+
+                skb_put(skb, len);
+              push_packet:
+                skb->dev = dev->ndev;
+                skb->protocol = eth_type_trans(skb, dev->ndev);
+                emac_rx_csum(dev, skb, ctrl);
+
+                if (unlikely(netif_receive_skb(skb) == NET_RX_DROP))
+                        ++dev->estats.rx_dropped_stack;
+              next:
+                ++dev->stats.rx_packets;
+              skip:
+                dev->stats.rx_bytes += len;
+                slot = (slot + 1) % NUM_RX_BUFF;
+                --budget;
+                ++received;
+                continue;
+              sg:
+                if (ctrl & MAL_RX_CTRL_FIRST) {
+                        BUG_ON(dev->rx_sg_skb);
+                        if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC))) {
+                                DBG("%d: rx OOM %d" NL, dev->def->index, slot);
+                                ++dev->estats.rx_dropped_oom;
+                                emac_recycle_rx_skb(dev, slot, 0);
+                        } else {
+                                dev->rx_sg_skb = skb;
+                                skb_put(skb, len);
+                        }
+                } else if (!emac_rx_sg_append(dev, slot) &&
+                           (ctrl & MAL_RX_CTRL_LAST)) {
+
+                        skb = dev->rx_sg_skb;
+                        dev->rx_sg_skb = NULL;
+
+                        ctrl &= EMAC_BAD_RX_MASK;
+                        if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
+                                emac_parse_rx_error(dev, ctrl);
+                                ++dev->estats.rx_dropped_error;
+                                dev_kfree_skb(skb);
+                                len = 0;
+                        } else
+                                goto push_packet;
+                }
+                goto skip;
+              oom:
+                DBG("%d: rx OOM %d" NL, dev->def->index, slot);
+                /* Drop the packet and recycle skb */
+                ++dev->estats.rx_dropped_oom;
+                emac_recycle_rx_skb(dev, slot, 0);
+                goto next;
+        }
 
-        /* set transmit request threshold register */
-        out_be32(&emacp->em0trtr, EMAC_TRTR_DEFAULT);
+        if (received) {
+                DBG2("%d: rx %d BDs" NL, dev->def->index, received);
+                dev->rx_slot = slot;
+        }
 
-        /* Reconfigure multicast */
-        __emac_set_multicast_list(fep->ndev);
+        if (unlikely(budget && dev->commac.rx_stopped)) {
+                struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        /* Set receiver/transmitter defaults */
-        out_be32(&emacp->em0rwmr, EMAC_RWMR_DEFAULT);
-        out_be32(&emacp->em0tmr0, EMAC_TMR0_DEFAULT);
-        out_be32(&emacp->em0tmr1, EMAC_TMR1_DEFAULT);
+                barrier();
+                if (!(dev->rx_desc[slot].ctrl & MAL_RX_CTRL_EMPTY)) {
+                        DBG2("%d: rx restart" NL, dev->def->index);
+                        received = 0;
+                        goto again;
+                }
 
-        /* set frame gap */
-        out_be32(&emacp->em0ipgvr, CONFIG_IBM_EMAC_FGAP);
-        
-        /* set VLAN Tag Protocol Identifier */
-        out_be32(&emacp->em0vtpid, 0x8100);
+                if (dev->rx_sg_skb) {
+                        DBG2("%d: dropping partial rx packet" NL,
+                             dev->def->index);
+                        ++dev->estats.rx_dropped_error;
+                        dev_kfree_skb(dev->rx_sg_skb);
+                        dev->rx_sg_skb = NULL;
+                }
 
-        /* Init ring buffers */
-        emac_init_rings(fep->ndev);
+                dev->commac.rx_stopped = 0;
+                mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+                emac_rx_enable(dev);
+                dev->rx_slot = 0;
+        }
+        return received;
 }
 
-static void emac_kick(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_peek_rx(void *param)
 {
-        emac_t *emacp = fep->emacp;
-        unsigned long emac_ier;
-
-        emac_ier = EMAC_ISR_PP | EMAC_ISR_BP | EMAC_ISR_RP |
-            EMAC_ISR_SE | EMAC_ISR_PTLE | EMAC_ISR_ALE |
-            EMAC_ISR_BFCS | EMAC_ISR_ORE | EMAC_ISR_IRE;
+        struct ocp_enet_private *dev = param;
+        return !(dev->rx_desc[dev->rx_slot].ctrl & MAL_RX_CTRL_EMPTY);
+}
 
-        out_be32(&emacp->em0iser, emac_ier);
+/* BHs disabled */
+static int emac_peek_rx_sg(void *param)
+{
+        struct ocp_enet_private *dev = param;
+        int slot = dev->rx_slot;
+        while (1) {
+                u16 ctrl = dev->rx_desc[slot].ctrl;
+                if (ctrl & MAL_RX_CTRL_EMPTY)
+                        return 0;
+                else if (ctrl & MAL_RX_CTRL_LAST)
+                        return 1;
 
-        /* enable all MAL transmit and receive channels */
-        mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
+                slot = (slot + 1) % NUM_RX_BUFF;
 
-        /* set transmit and receive enable */
-        out_be32(&emacp->em0mr0, EMAC_M0_TXE | EMAC_M0_RXE);
+                /* I'm just being paranoid here :) */
+                if (unlikely(slot == dev->rx_slot))
+                        return 0;
+        }
 }
 
-static void
-emac_start_link(struct ocp_enet_private *fep, struct ethtool_cmd *ep)
+/* Hard IRQ */
+static void emac_rxde(void *param)
 {
-        u32 advertise;
-        int autoneg;
-        int forced_speed;
-        int forced_duplex;
+        struct ocp_enet_private *dev = param;
+        ++dev->estats.rx_stopped;
+        emac_rx_disable_async(dev);
+}
 
-        /* Default advertise */
-        advertise = ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
-            ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
-            ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full;
-        autoneg = fep->want_autoneg;
-        forced_speed = fep->phy_mii.speed;
-        forced_duplex = fep->phy_mii.duplex;
+/* Hard IRQ */
+static irqreturn_t emac_irq(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ocp_enet_private *dev = dev_instance;
+        struct emac_regs *p = dev->emacp;
+        struct ibm_emac_error_stats *st = &dev->estats;
+
+        u32 isr = in_be32(&p->isr);
+        out_be32(&p->isr, isr);
+
+        DBG("%d: isr = %08x" NL, dev->def->index, isr);
+
+        if (isr & EMAC_ISR_TXPE)
+                ++st->tx_parity;
+        if (isr & EMAC_ISR_RXPE)
+                ++st->rx_parity;
+        if (isr & EMAC_ISR_TXUE)
+                ++st->tx_underrun;
+        if (isr & EMAC_ISR_RXOE)
+                ++st->rx_fifo_overrun;
+        if (isr & EMAC_ISR_OVR)
+                ++st->rx_overrun;
+        if (isr & EMAC_ISR_BP)
+                ++st->rx_bad_packet;
+        if (isr & EMAC_ISR_RP)
+                ++st->rx_runt_packet;
+        if (isr & EMAC_ISR_SE)
+                ++st->rx_short_event;
+        if (isr & EMAC_ISR_ALE)
+                ++st->rx_alignment_error;
+        if (isr & EMAC_ISR_BFCS)
+                ++st->rx_bad_fcs;
+        if (isr & EMAC_ISR_PTLE)
+                ++st->rx_packet_too_long;
+        if (isr & EMAC_ISR_ORE)
+                ++st->rx_out_of_range;
+        if (isr & EMAC_ISR_IRE)
+                ++st->rx_in_range;
+        if (isr & EMAC_ISR_SQE)
+                ++st->tx_sqe;
+        if (isr & EMAC_ISR_TE)
+                ++st->tx_errors;
 
-        /* Setup link parameters */
-        if (ep) {
-                if (ep->autoneg == AUTONEG_ENABLE) {
-                        advertise = ep->advertising;
-                        autoneg = 1;
-                } else {
-                        autoneg = 0;
-                        forced_speed = ep->speed;
-                        forced_duplex = ep->duplex;
-                }
-        }
+        return IRQ_HANDLED;
+}
 
-        /* Configure PHY & start aneg */
-        fep->want_autoneg = autoneg;
-        if (autoneg) {
-                LINK_DEBUG(("%s: start link aneg, advertise: 0x%x\n",
-                            fep->ndev->name, advertise));
-                fep->phy_mii.def->ops->setup_aneg(&fep->phy_mii, advertise);
-        } else {
-                LINK_DEBUG(("%s: start link forced, speed: %d, duplex: %d\n",
-                            fep->ndev->name, forced_speed, forced_duplex));
-                fep->phy_mii.def->ops->setup_forced(&fep->phy_mii, forced_speed,
-                                                    forced_duplex);
-        }
-        fep->timer_ticks = 0;
-        mod_timer(&fep->link_timer, jiffies + HZ);
+static struct net_device_stats *emac_stats(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ibm_emac_stats *st = &dev->stats;
+        struct ibm_emac_error_stats *est = &dev->estats;
+        struct net_device_stats *nst = &dev->nstats;
+
+        DBG2("%d: stats" NL, dev->def->index);
+
+        /* Compute "legacy" statistics */
+        local_irq_disable();
+        nst->rx_packets = (unsigned long)st->rx_packets;
+        nst->rx_bytes = (unsigned long)st->rx_bytes;
+        nst->tx_packets = (unsigned long)st->tx_packets;
+        nst->tx_bytes = (unsigned long)st->tx_bytes;
+        nst->rx_dropped = (unsigned long)(est->rx_dropped_oom +
+                                          est->rx_dropped_error +
+                                          est->rx_dropped_resize +
+                                          est->rx_dropped_mtu);
+        nst->tx_dropped = (unsigned long)est->tx_dropped;
+
+        nst->rx_errors = (unsigned long)est->rx_bd_errors;
+        nst->rx_fifo_errors = (unsigned long)(est->rx_bd_overrun +
+                                              est->rx_fifo_overrun +
+                                              est->rx_overrun);
+        nst->rx_frame_errors = (unsigned long)(est->rx_bd_alignment_error +
+                                               est->rx_alignment_error);
+        nst->rx_crc_errors = (unsigned long)(est->rx_bd_bad_fcs +
+                                             est->rx_bad_fcs);
+        nst->rx_length_errors = (unsigned long)(est->rx_bd_runt_packet +
+                                                est->rx_bd_short_event +
+                                                est->rx_bd_packet_too_long +
+                                                est->rx_bd_out_of_range +
+                                                est->rx_bd_in_range +
+                                                est->rx_runt_packet +
+                                                est->rx_short_event +
+                                                est->rx_packet_too_long +
+                                                est->rx_out_of_range +
+                                                est->rx_in_range);
+
+        nst->tx_errors = (unsigned long)(est->tx_bd_errors + est->tx_errors);
+        nst->tx_fifo_errors = (unsigned long)(est->tx_bd_underrun +
+                                              est->tx_underrun);
+        nst->tx_carrier_errors = (unsigned long)est->tx_bd_carrier_loss;
+        nst->collisions = (unsigned long)(est->tx_bd_excessive_deferral +
+                                          est->tx_bd_excessive_collisions +
+                                          est->tx_bd_late_collision +
+                                          est->tx_bd_multple_collisions);
+        local_irq_enable();
+        return nst;
 }
 
-static void emac_link_timer(unsigned long data)
+static void emac_remove(struct ocp_device *ocpdev)
 {
-        struct ocp_enet_private *fep = (struct ocp_enet_private *)data;
-        int link;
+        struct ocp_enet_private *dev = ocp_get_drvdata(ocpdev);
 
-        if (fep->going_away)
-                return;
+        DBG("%d: remove" NL, dev->def->index);
 
-        spin_lock_irq(&fep->lock);
+        ocp_set_drvdata(ocpdev, 0);
+        unregister_netdev(dev->ndev);
 
-        link = fep->phy_mii.def->ops->poll_link(&fep->phy_mii);
-        LINK_DEBUG(("%s: poll_link: %d\n", fep->ndev->name, link));
+        tah_fini(dev->tah_dev);
+        rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
+        zmii_fini(dev->zmii_dev, dev->zmii_input);
 
-        if (link == netif_carrier_ok(fep->ndev)) {
-                if (!link && fep->want_autoneg && (++fep->timer_ticks) > 10)
-                        emac_start_link(fep, NULL);
-                goto out;
-        }
-        printk(KERN_INFO "%s: Link is %s\n", fep->ndev->name,
-               link ? "Up" : "Down");
-        if (link) {
-                netif_carrier_on(fep->ndev);
-                /* Chip needs a full reset on config change. That sucks, so I
-                 * should ultimately move that to some tasklet to limit
-                 * latency peaks caused by this code
-                 */
-                emac_reset_configure(fep);
-                if (fep->opened)
-                        emac_kick(fep);
-        } else {
-                fep->timer_ticks = 0;
-                netif_carrier_off(fep->ndev);
-        }
-      out:
-        mod_timer(&fep->link_timer, jiffies + HZ);
-        spin_unlock_irq(&fep->lock);
+        emac_dbg_register(dev->def->index, 0);
+
+        mal_unregister_commac(dev->mal, &dev->commac);
+        iounmap((void *)dev->emacp);
+        kfree(dev->ndev);
 }
 
-static void emac_set_multicast_list(struct net_device *dev)
-{
-        struct ocp_enet_private *fep = dev->priv;
+static struct mal_commac_ops emac_commac_ops = {
+        .poll_tx = &emac_poll_tx,
+        .poll_rx = &emac_poll_rx,
+        .peek_rx = &emac_peek_rx,
+        .rxde = &emac_rxde,
+};
 
-        spin_lock_irq(&fep->lock);
-        __emac_set_multicast_list(dev);
-        spin_unlock_irq(&fep->lock);
-}
+static struct mal_commac_ops emac_commac_sg_ops = {
+        .poll_tx = &emac_poll_tx,
+        .poll_rx = &emac_poll_rx,
+        .peek_rx = &emac_peek_rx_sg,
+        .rxde = &emac_rxde,
+};
 
-static int emac_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+/* Ethtool support */
+static int emac_ethtool_get_settings(struct net_device *ndev,
+                                     struct ethtool_cmd *cmd)
 {
-        struct ocp_enet_private *fep = ndev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
 
-        cmd->supported = fep->phy_mii.def->features;
+        cmd->supported = dev->phy.features;
         cmd->port = PORT_MII;
-        cmd->transceiver = XCVR_EXTERNAL;
-        cmd->phy_address = fep->mii_phy_addr;
-        spin_lock_irq(&fep->lock);
-        cmd->autoneg = fep->want_autoneg;
-        cmd->speed = fep->phy_mii.speed;
-        cmd->duplex = fep->phy_mii.duplex;
-        spin_unlock_irq(&fep->lock);
+        cmd->phy_address = dev->phy.address;
+        cmd->transceiver =
+            dev->phy.address >= 0 ? XCVR_EXTERNAL : XCVR_INTERNAL;
+
+        local_bh_disable();
+        cmd->advertising = dev->phy.advertising;
+        cmd->autoneg = dev->phy.autoneg;
+        cmd->speed = dev->phy.speed;
+        cmd->duplex = dev->phy.duplex;
+        local_bh_enable();
+
         return 0;
 }
 
-static int emac_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+static int emac_ethtool_set_settings(struct net_device *ndev,
+                                     struct ethtool_cmd *cmd)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-        unsigned long features = fep->phy_mii.def->features;
+        struct ocp_enet_private *dev = ndev->priv;
+        u32 f = dev->phy.features;
 
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
+        DBG("%d: set_settings(%d, %d, %d, 0x%08x)" NL, dev->def->index,
+            cmd->autoneg, cmd->speed, cmd->duplex, cmd->advertising);
 
+        /* Basic sanity checks */
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
         if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
                 return -EINVAL;
         if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
                 return -EINVAL;
         if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL)
                 return -EINVAL;
-        if (cmd->autoneg == AUTONEG_DISABLE)
+
+        if (cmd->autoneg == AUTONEG_DISABLE) {
                 switch (cmd->speed) {
                 case SPEED_10:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_10baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_10baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_10baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_10baseT_Full))
                                 return -EINVAL;
                         break;
                 case SPEED_100:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_100baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_100baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_100baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_100baseT_Full))
                                 return -EINVAL;
                         break;
                 case SPEED_1000:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_1000baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_1000baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_1000baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_1000baseT_Full))
                                 return -EINVAL;
                         break;
                 default:
                         return -EINVAL;
-        } else if ((features & SUPPORTED_Autoneg) == 0)
-                return -EINVAL;
-        spin_lock_irq(&fep->lock);
-        emac_start_link(fep, cmd);
-        spin_unlock_irq(&fep->lock);
+                }
+
+                local_bh_disable();
+                dev->phy.def->ops->setup_forced(&dev->phy, cmd->speed,
+                                                cmd->duplex);
+
+        } else {
+                if (!(f & SUPPORTED_Autoneg))
+                        return -EINVAL;
+
+                local_bh_disable();
+                dev->phy.def->ops->setup_aneg(&dev->phy,
+                                              (cmd->advertising & f) |
+                                              (dev->phy.advertising &
+                                               (ADVERTISED_Pause |
+                                                ADVERTISED_Asym_Pause)));
+        }
+        emac_force_link_update(dev);
+        local_bh_enable();
+
         return 0;
 }
 
-static void
-emac_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
+static void emac_ethtool_get_ringparam(struct net_device *ndev,
+                                       struct ethtool_ringparam *rp)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-
-        strcpy(info->driver, DRV_NAME);
-        strcpy(info->version, DRV_VERSION);
-        info->fw_version[0] = '\0';
-        sprintf(info->bus_info, "IBM EMAC %d", fep->ocpdev->def->index);
-        info->regdump_len = 0;
+        rp->rx_max_pending = rp->rx_pending = NUM_RX_BUFF;
+        rp->tx_max_pending = rp->tx_pending = NUM_TX_BUFF;
 }
 
-static int emac_nway_reset(struct net_device *ndev)
+static void emac_ethtool_get_pauseparam(struct net_device *ndev,
+                                        struct ethtool_pauseparam *pp)
 {
-        struct ocp_enet_private *fep = ndev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
+
+        local_bh_disable();
+        if ((dev->phy.features & SUPPORTED_Autoneg) &&
+            (dev->phy.advertising & (ADVERTISED_Pause | ADVERTISED_Asym_Pause)))
+                pp->autoneg = 1;
+
+        if (dev->phy.duplex == DUPLEX_FULL) {
+                if (dev->phy.pause)
+                        pp->rx_pause = pp->tx_pause = 1;
+                else if (dev->phy.asym_pause)
+                        pp->tx_pause = 1;
+        }
+        local_bh_enable();
+}
 
-        if (!fep->want_autoneg)
-                return -EINVAL;
-        spin_lock_irq(&fep->lock);
-        emac_start_link(fep, NULL);
-        spin_unlock_irq(&fep->lock);
-        return 0;
+static u32 emac_ethtool_get_rx_csum(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        return dev->tah_dev != 0;
 }
 
-static u32 emac_get_link(struct net_device *ndev)
+static int emac_get_regs_len(struct ocp_enet_private *dev)
 {
-        return netif_carrier_ok(ndev);
+        return sizeof(struct emac_ethtool_regs_subhdr) + EMAC_ETHTOOL_REGS_SIZE;
 }
 
-static struct ethtool_ops emac_ethtool_ops = {
-        .get_settings = emac_get_settings,
-        .set_settings = emac_set_settings,
-        .get_drvinfo = emac_get_drvinfo,
-        .nway_reset = emac_nway_reset,
-        .get_link = emac_get_link
-};
+static int emac_ethtool_get_regs_len(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        return sizeof(struct emac_ethtool_regs_hdr) +
+            emac_get_regs_len(dev) + mal_get_regs_len(dev->mal) +
+            zmii_get_regs_len(dev->zmii_dev) +
+            rgmii_get_regs_len(dev->rgmii_dev) +
+            tah_get_regs_len(dev->tah_dev);
+}
 
-static int emac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+static void *emac_dump_regs(struct ocp_enet_private *dev, void *buf)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        uint16_t *data = (uint16_t *) & rq->ifr_ifru;
+        struct emac_ethtool_regs_subhdr *hdr = buf;
 
-        switch (cmd) {
-        case SIOCGMIIPHY:
-                data[0] = fep->mii_phy_addr;
-                /* Fall through */
-        case SIOCGMIIREG:
-                data[3] = emac_phy_read(dev, fep->mii_phy_addr, data[1]);
-                return 0;
-        case SIOCSMIIREG:
-                if (!capable(CAP_NET_ADMIN))
-                        return -EPERM;
+        hdr->version = EMAC_ETHTOOL_REGS_VER;
+        hdr->index = dev->def->index;
+        memcpy_fromio(hdr + 1, dev->emacp, EMAC_ETHTOOL_REGS_SIZE);
+        return ((void *)(hdr + 1) + EMAC_ETHTOOL_REGS_SIZE);
+}
 
-                emac_phy_write(dev, fep->mii_phy_addr, data[1], data[2]);
-                return 0;
-        default:
-                return -EOPNOTSUPP;
+static void emac_ethtool_get_regs(struct net_device *ndev,
+                                  struct ethtool_regs *regs, void *buf)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct emac_ethtool_regs_hdr *hdr = buf;
+
+        hdr->components = 0;
+        buf = hdr + 1;
+
+        local_irq_disable();
+        buf = mal_dump_regs(dev->mal, buf);
+        buf = emac_dump_regs(dev, buf);
+        if (dev->zmii_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_ZMII;
+                buf = zmii_dump_regs(dev->zmii_dev, buf);
         }
+        if (dev->rgmii_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_RGMII;
+                buf = rgmii_dump_regs(dev->rgmii_dev, buf);
+        }
+        if (dev->tah_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_TAH;
+                buf = tah_dump_regs(dev->tah_dev, buf);
+        }
+        local_irq_enable();
 }
 
-static int emac_open(struct net_device *dev)
+static int emac_ethtool_nway_reset(struct net_device *ndev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int rc;
+        struct ocp_enet_private *dev = ndev->priv;
+        int res = 0;
 
-        spin_lock_irq(&fep->lock);
+        DBG("%d: nway_reset" NL, dev->def->index);
 
-        fep->opened = 1;
-        netif_carrier_off(dev);
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
 
-        /* Reset & configure the chip */
-        emac_reset_configure(fep);
+        local_bh_disable();
+        if (!dev->phy.autoneg) {
+                res = -EINVAL;
+                goto out;
+        }
 
-        spin_unlock_irq(&fep->lock);
+        dev->phy.def->ops->setup_aneg(&dev->phy, dev->phy.advertising);
+        emac_force_link_update(dev);
 
-        /* Request our interrupt lines */
-        rc = request_irq(dev->irq, emac_mac_irq, 0, "IBM EMAC MAC", dev);
-        if (rc != 0) {
-                printk("dev->irq %d failed\n", dev->irq);
-                goto bail;
-        }
-        /* Kick the chip rx & tx channels into life */
-        spin_lock_irq(&fep->lock);
-        emac_kick(fep);
-        spin_unlock_irq(&fep->lock);
+      out:
+        local_bh_enable();
+        return res;
+}
 
-        netif_start_queue(dev);
-      bail:
-        return rc;
+static int emac_ethtool_get_stats_count(struct net_device *ndev)
+{
+        return EMAC_ETHTOOL_STATS_COUNT;
 }
 
-static int emac_close(struct net_device *dev)
+static void emac_ethtool_get_strings(struct net_device *ndev, u32 stringset,
+                                     u8 * buf)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        if (stringset == ETH_SS_STATS)
+                memcpy(buf, &emac_stats_keys, sizeof(emac_stats_keys));
+}
 
-        /* XXX Stop IRQ emitting here */
-        spin_lock_irq(&fep->lock);
-        fep->opened = 0;
-        mal_disable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-        netif_carrier_off(dev);
-        netif_stop_queue(dev);
+static void emac_ethtool_get_ethtool_stats(struct net_device *ndev,
+                                           struct ethtool_stats *estats,
+                                           u64 * tmp_stats)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        local_irq_disable();
+        memcpy(tmp_stats, &dev->stats, sizeof(dev->stats));
+        tmp_stats += sizeof(dev->stats) / sizeof(u64);
+        memcpy(tmp_stats, &dev->estats, sizeof(dev->estats));
+        local_irq_enable();
+}
 
-        /*
-         * Check for a link, some PHYs don't provide a clock if
-         * no link is present.  Some EMACs will not come out of
-         * soft reset without a PHY clock present.
-         */
-        if (fep->phy_mii.def->ops->poll_link(&fep->phy_mii)) {
-                out_be32(&emacp->em0mr0, EMAC_M0_SRST);
-                udelay(10);
+static void emac_ethtool_get_drvinfo(struct net_device *ndev,
+                                     struct ethtool_drvinfo *info)
+{
+        struct ocp_enet_private *dev = ndev->priv;
 
-                if (emacp->em0mr0 & EMAC_M0_SRST) {
-                        /*not sure what to do here hopefully it clears before another open */
-                        printk(KERN_ERR
-                               "%s: Phy SoftReset didn't clear, no link?\n",
-                               dev->name);
-                }
-        }
+        strcpy(info->driver, "ibm_emac");
+        strcpy(info->version, DRV_VERSION);
+        info->fw_version[0] = '\0';
+        sprintf(info->bus_info, "PPC 4xx EMAC %d", dev->def->index);
+        info->n_stats = emac_ethtool_get_stats_count(ndev);
+        info->regdump_len = emac_ethtool_get_regs_len(ndev);
+}
 
-        /* Free the irq's */
-        free_irq(dev->irq, dev);
+static struct ethtool_ops emac_ethtool_ops = {
+        .get_settings = emac_ethtool_get_settings,
+        .set_settings = emac_ethtool_set_settings,
+        .get_drvinfo = emac_ethtool_get_drvinfo,
 
-        spin_unlock_irq(&fep->lock);
+        .get_regs_len = emac_ethtool_get_regs_len,
+        .get_regs = emac_ethtool_get_regs,
 
-        return 0;
-}
+        .nway_reset = emac_ethtool_nway_reset,
 
-static void emac_remove(struct ocp_device *ocpdev)
-{
-        struct net_device *dev = ocp_get_drvdata(ocpdev);
-        struct ocp_enet_private *ep = dev->priv;
-
-        /* FIXME: locking, races, ... */
-        ep->going_away = 1;
-        ocp_set_drvdata(ocpdev, NULL);
-        if (ep->rgmii_dev)
-                emac_close_rgmii(ep->rgmii_dev);
-        if (ep->zmii_dev)
-                emac_close_zmii(ep->zmii_dev);
-
-        unregister_netdev(dev);
-        del_timer_sync(&ep->link_timer);
-        mal_unregister_commac(ep->mal, &ep->commac);
-        iounmap((void *)ep->emacp);
-        kfree(dev);
-}
-
-struct mal_commac_ops emac_commac_ops = {
-        .txeob = &emac_txeob_dev,
-        .txde = &emac_txde_dev,
-        .rxeob = &emac_rxeob_dev,
-        .rxde = &emac_rxde_dev,
+        .get_ringparam = emac_ethtool_get_ringparam,
+        .get_pauseparam = emac_ethtool_get_pauseparam,
+
+        .get_rx_csum = emac_ethtool_get_rx_csum,
+
+        .get_strings = emac_ethtool_get_strings,
+        .get_stats_count = emac_ethtool_get_stats_count,
+        .get_ethtool_stats = emac_ethtool_get_ethtool_stats,
+
+        .get_link = ethtool_op_get_link,
+        .get_tx_csum = ethtool_op_get_tx_csum,
+        .get_sg = ethtool_op_get_sg,
 };
 
-#ifdef CONFIG_NET_POLL_CONTROLLER
-static void emac_netpoll(struct net_device *ndev)
+static int emac_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
 {
-        emac_rxeob_dev((void *)ndev, 0);
-        emac_txeob_dev((void *)ndev, 0);
+        struct ocp_enet_private *dev = ndev->priv;
+        uint16_t *data = (uint16_t *) & rq->ifr_ifru;
+
+        DBG("%d: ioctl %08x" NL, dev->def->index, cmd);
+
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
+
+        switch (cmd) {
+        case SIOCGMIIPHY:
+        case SIOCDEVPRIVATE:
+                data[0] = dev->phy.address;
+                /* Fall through */
+        case SIOCGMIIREG:
+        case SIOCDEVPRIVATE + 1:
+                data[3] = emac_mdio_read(ndev, dev->phy.address, data[1]);
+                return 0;
+
+        case SIOCSMIIREG:
+        case SIOCDEVPRIVATE + 2:
+                if (!capable(CAP_NET_ADMIN))
+                        return -EPERM;
+                emac_mdio_write(ndev, dev->phy.address, data[1], data[2]);
+                return 0;
+        default:
+                return -EOPNOTSUPP;
+        }
 }
-#endif
 
-static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
+static int __init emac_probe(struct ocp_device *ocpdev)
 {
-        int deferred_init = 0;
-        int rc = 0, i;
+        struct ocp_func_emac_data *emacdata = ocpdev->def->additions;
         struct net_device *ndev;
-        struct ocp_enet_private *ep;
-        struct ocp_func_emac_data *emacdata;
-        int commac_reg = 0;
-        u32 phy_map;
+        struct ocp_device *maldev;
+        struct ocp_enet_private *dev;
+        int err, i;
+
+        DBG("%d: probe" NL, ocpdev->def->index);
 
-        emacdata = (struct ocp_func_emac_data *)ocpdev->def->additions;
         if (!emacdata) {
                 printk(KERN_ERR "emac%d: Missing additional data!\n",
                        ocpdev->def->index);
@@ -1738,304 +1936,312 @@ static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
 
         /* Allocate our net_device structure */
         ndev = alloc_etherdev(sizeof(struct ocp_enet_private));
-        if (ndev == NULL) {
-                printk(KERN_ERR
-                       "emac%d: Could not allocate ethernet device.\n",
+        if (!ndev) {
+                printk(KERN_ERR "emac%d: could not allocate ethernet device!\n",
                        ocpdev->def->index);
                 return -ENOMEM;
         }
-        ep = ndev->priv;
-        ep->ndev = ndev;
-        ep->ocpdev = ocpdev;
-        ndev->irq = ocpdev->def->irq;
-        ep->wol_irq = emacdata->wol_irq;
-        if (emacdata->mdio_idx >= 0) {
-                if (emacdata->mdio_idx == ocpdev->def->index) {
-                        /* Set the common MDIO net_device */
-                        mdio_ndev = ndev;
-                        deferred_init = 1;
-                }
-                ep->mdio_dev = mdio_ndev;
-        } else {
-                ep->mdio_dev = ndev;
-        }
+        dev = ndev->priv;
+        dev->ndev = ndev;
+        dev->ldev = &ocpdev->dev;
+        dev->def = ocpdev->def;
+        SET_MODULE_OWNER(ndev);
 
-        ocp_set_drvdata(ocpdev, ndev);
-
-        spin_lock_init(&ep->lock);
-
-        /* Fill out MAL informations and register commac */
-        ep->mal = mal;
-        ep->mal_tx_chan = emacdata->mal_tx_chan;
-        ep->mal_rx_chan = emacdata->mal_rx_chan;
-        ep->commac.ops = &emac_commac_ops;
-        ep->commac.dev = ndev;
-        ep->commac.tx_chan_mask = MAL_CHAN_MASK(ep->mal_tx_chan);
-        ep->commac.rx_chan_mask = MAL_CHAN_MASK(ep->mal_rx_chan);
-        rc = mal_register_commac(ep->mal, &ep->commac);
-        if (rc != 0)
-                goto bail;
-        commac_reg = 1;
-
-        /* Map our MMIOs */
-        ep->emacp = (emac_t *) ioremap(ocpdev->def->paddr, sizeof(emac_t));
-
-        /* Check if we need to attach to a ZMII */
-        if (emacdata->zmii_idx >= 0) {
-                ep->zmii_input = emacdata->zmii_mux;
-                ep->zmii_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_ZMII,
-                                    emacdata->zmii_idx);
-                if (ep->zmii_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: ZMII %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->zmii_idx);
-                else if ((rc =
-                          emac_init_zmii(ep->zmii_dev, ep->zmii_input,
-                                         emacdata->phy_mode)) != 0)
-                        goto bail;
+        /* Find MAL device we are connected to */
+        maldev =
+            ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_MAL, emacdata->mal_idx);
+        if (!maldev) {
+                printk(KERN_ERR "emac%d: unknown mal%d device!\n",
+                       dev->def->index, emacdata->mal_idx);
+                err = -ENODEV;
+                goto out;
+        }
+        dev->mal = ocp_get_drvdata(maldev);
+        if (!dev->mal) {
+                printk(KERN_ERR "emac%d: mal%d hasn't been initialized yet!\n",
+                       dev->def->index, emacdata->mal_idx);
+                err = -ENODEV;
+                goto out;
         }
 
-        /* Check if we need to attach to a RGMII */
-        if (emacdata->rgmii_idx >= 0) {
-                ep->rgmii_input = emacdata->rgmii_mux;
-                ep->rgmii_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_RGMII,
-                                    emacdata->rgmii_idx);
-                if (ep->rgmii_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: RGMII %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->rgmii_idx);
-                else if ((rc =
-                          emac_init_rgmii(ep->rgmii_dev, ep->rgmii_input,
-                                          emacdata->phy_mode)) != 0)
-                        goto bail;
+        /* Register with MAL */
+        dev->commac.ops = &emac_commac_ops;
+        dev->commac.dev = dev;
+        dev->commac.tx_chan_mask = MAL_CHAN_MASK(emacdata->mal_tx_chan);
+        dev->commac.rx_chan_mask = MAL_CHAN_MASK(emacdata->mal_rx_chan);
+        err = mal_register_commac(dev->mal, &dev->commac);
+        if (err) {
+                printk(KERN_ERR "emac%d: failed to register with mal%d!\n",
+                       dev->def->index, emacdata->mal_idx);
+                goto out;
+        }
+        dev->rx_skb_size = emac_rx_skb_size(ndev->mtu);
+        dev->rx_sync_size = emac_rx_sync_size(ndev->mtu);
+
+        /* Get pointers to BD rings */
+        dev->tx_desc =
+            dev->mal->bd_virt + mal_tx_bd_offset(dev->mal,
+                                                 emacdata->mal_tx_chan);
+        dev->rx_desc =
+            dev->mal->bd_virt + mal_rx_bd_offset(dev->mal,
+                                                 emacdata->mal_rx_chan);
+
+        DBG("%d: tx_desc %p" NL, ocpdev->def->index, dev->tx_desc);
+        DBG("%d: rx_desc %p" NL, ocpdev->def->index, dev->rx_desc);
+
+        /* Clean rings */
+        memset(dev->tx_desc, 0, NUM_TX_BUFF * sizeof(struct mal_descriptor));
+        memset(dev->rx_desc, 0, NUM_RX_BUFF * sizeof(struct mal_descriptor));
+
+        /* If we depend on another EMAC for MDIO, check whether it was probed already */
+        if (emacdata->mdio_idx >= 0 && emacdata->mdio_idx != ocpdev->def->index) {
+                struct ocp_device *mdiodev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_EMAC,
+                                    emacdata->mdio_idx);
+                if (!mdiodev) {
+                        printk(KERN_ERR "emac%d: unknown emac%d device!\n",
+                               dev->def->index, emacdata->mdio_idx);
+                        err = -ENODEV;
+                        goto out2;
+                }
+                dev->mdio_dev = ocp_get_drvdata(mdiodev);
+                if (!dev->mdio_dev) {
+                        printk(KERN_ERR
+                               "emac%d: emac%d hasn't been initialized yet!\n",
+                               dev->def->index, emacdata->mdio_idx);
+                        err = -ENODEV;
+                        goto out2;
+                }
         }
 
-        /* Check if we need to attach to a TAH */
-        if (emacdata->tah_idx >= 0) {
-                ep->tah_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_TAH,
-                                    emacdata->tah_idx);
-                if (ep->tah_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: TAH %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->tah_idx);
-                else if ((rc = emac_init_tah(ep)) != 0)
-                        goto bail;
+        /* Attach to ZMII, if needed */
+        if ((err = zmii_attach(dev)) != 0)
+                goto out2;
+
+        /* Attach to RGMII, if needed */
+        if ((err = rgmii_attach(dev)) != 0)
+                goto out3;
+
+        /* Attach to TAH, if needed */
+        if ((err = tah_attach(dev)) != 0)
+                goto out4;
+
+        /* Map EMAC regs */
+        dev->emacp =
+            (struct emac_regs *)ioremap(dev->def->paddr,
+                                        sizeof(struct emac_regs));
+        if (!dev->emacp) {
+                printk(KERN_ERR "emac%d: could not ioremap device registers!\n",
+                       dev->def->index);
+                err = -ENOMEM;
+                goto out5;
         }
 
-        if (deferred_init) {
-                if (!list_empty(&emac_init_list)) {
-                        struct list_head *entry;
-                        struct emac_def_dev *ddev;
+        /* Fill in MAC address */
+        for (i = 0; i < 6; ++i)
+                ndev->dev_addr[i] = emacdata->mac_addr[i];
 
-                        list_for_each(entry, &emac_init_list) {
-                                ddev =
-                                    list_entry(entry, struct emac_def_dev,
-                                               link);
-                                emac_init_device(ddev->ocpdev, ddev->mal);
-                        }
+        /* Set some link defaults before we can find out real parameters */
+        dev->phy.speed = SPEED_100;
+        dev->phy.duplex = DUPLEX_FULL;
+        dev->phy.autoneg = AUTONEG_DISABLE;
+        dev->phy.pause = dev->phy.asym_pause = 0;
+        init_timer(&dev->link_timer);
+        dev->link_timer.function = emac_link_timer;
+        dev->link_timer.data = (unsigned long)dev;
+
+        /* Find PHY if any */
+        dev->phy.dev = ndev;
+        dev->phy.mode = emacdata->phy_mode;
+        if (emacdata->phy_map != 0xffffffff) {
+                u32 phy_map = emacdata->phy_map | busy_phy_map;
+                u32 adv;
+
+                DBG("%d: PHY maps %08x %08x" NL, dev->def->index,
+                    emacdata->phy_map, busy_phy_map);
+
+                EMAC_RX_CLK_TX(dev->def->index);
+
+                dev->phy.mdio_read = emac_mdio_read;
+                dev->phy.mdio_write = emac_mdio_write;
+
+                /* Configure EMAC with defaults so we can at least use MDIO
+                 * This is needed mostly for 440GX
+                 */
+                if (emac_phy_gpcs(dev->phy.mode)) {
+                        /* XXX
+                         * Make GPCS PHY address equal to EMAC index.
+                         * We probably should take into account busy_phy_map
+                         * and/or phy_map here.
+                         */
+                        dev->phy.address = dev->def->index;
                 }
-        }
+                
+                emac_configure(dev);
 
-        /* Init link monitoring timer */
-        init_timer(&ep->link_timer);
-        ep->link_timer.function = emac_link_timer;
-        ep->link_timer.data = (unsigned long)ep;
-        ep->timer_ticks = 0;
-
-        /* Fill up the mii_phy structure */
-        ep->phy_mii.dev = ndev;
-        ep->phy_mii.mdio_read = emac_phy_read;
-        ep->phy_mii.mdio_write = emac_phy_write;
-        ep->phy_mii.mode = emacdata->phy_mode;
-
-        /* Find PHY */
-        phy_map = emacdata->phy_map | busy_phy_map;
-        for (i = 0; i <= 0x1f; i++, phy_map >>= 1) {
-                if ((phy_map & 0x1) == 0) {
-                        int val = emac_phy_read(ndev, i, MII_BMCR);
-                        if (val != 0xffff && val != -1)
-                                break;
+                for (i = 0; i < 0x20; phy_map >>= 1, ++i)
+                        if (!(phy_map & 1)) {
+                                int r;
+                                busy_phy_map |= 1 << i;
+
+                                /* Quick check if there is a PHY at the address */
+                                r = emac_mdio_read(dev->ndev, i, MII_BMCR);
+                                if (r == 0xffff || r < 0)
+                                        continue;
+                                if (!mii_phy_probe(&dev->phy, i))
+                                        break;
+                        }
+                if (i == 0x20) {
+                        printk(KERN_WARNING "emac%d: can't find PHY!\n",
+                               dev->def->index);
+                        goto out6;
                 }
-        }
-        if (i == 0x20) {
-                printk(KERN_WARNING "emac%d: Can't find PHY.\n",
-                       ocpdev->def->index);
-                rc = -ENODEV;
-                goto bail;
-        }
-        busy_phy_map |= 1 << i;
-        ep->mii_phy_addr = i;
-        rc = mii_phy_probe(&ep->phy_mii, i);
-        if (rc) {
-                printk(KERN_WARNING "emac%d: Failed to probe PHY type.\n",
-                       ocpdev->def->index);
-                rc = -ENODEV;
-                goto bail;
-        }
-        
-        /* Disable any PHY features not supported by the platform */
-        ep->phy_mii.def->features &= ~emacdata->phy_feat_exc;
 
-        /* Setup initial PHY config & startup aneg */
-        if (ep->phy_mii.def->ops->init)
-                ep->phy_mii.def->ops->init(&ep->phy_mii);
-        netif_carrier_off(ndev);
-        if (ep->phy_mii.def->features & SUPPORTED_Autoneg)
-                ep->want_autoneg = 1;
-        else {
-                ep->want_autoneg = 0;
+                /* Init PHY */
+                if (dev->phy.def->ops->init)
+                        dev->phy.def->ops->init(&dev->phy);
                 
-                /* Select highest supported speed/duplex */
-                if (ep->phy_mii.def->features & SUPPORTED_1000baseT_Full) {
-                        ep->phy_mii.speed = SPEED_1000;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_1000baseT_Half) {
-                        ep->phy_mii.speed = SPEED_1000;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_100baseT_Full) {
-                        ep->phy_mii.speed = SPEED_100;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_100baseT_Half) {
-                        ep->phy_mii.speed = SPEED_100;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_10baseT_Full) {
-                        ep->phy_mii.speed = SPEED_10;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
+                /* Disable any PHY features not supported by the platform */
+                dev->phy.def->features &= ~emacdata->phy_feat_exc;
+
+                /* Setup initial link parameters */
+                if (dev->phy.features & SUPPORTED_Autoneg) {
+                        adv = dev->phy.features;
+#if !defined(CONFIG_40x)
+                        adv |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
+#endif
+                        /* Restart autonegotiation */
+                        dev->phy.def->ops->setup_aneg(&dev->phy, adv);
                 } else {
-                        ep->phy_mii.speed = SPEED_10;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
+                        u32 f = dev->phy.def->features;
+                        int speed = SPEED_10, fd = DUPLEX_HALF;
+
+                        /* Select highest supported speed/duplex */
+                        if (f & SUPPORTED_1000baseT_Full) {
+                                speed = SPEED_1000;
+                                fd = DUPLEX_FULL;
+                        } else if (f & SUPPORTED_1000baseT_Half)
+                                speed = SPEED_1000;
+                        else if (f & SUPPORTED_100baseT_Full) {
+                                speed = SPEED_100;
+                                fd = DUPLEX_FULL;
+                        } else if (f & SUPPORTED_100baseT_Half)
+                                speed = SPEED_100;
+                        else if (f & SUPPORTED_10baseT_Full)
+                                fd = DUPLEX_FULL;
+
+                        /* Force link parameters */
+                        dev->phy.def->ops->setup_forced(&dev->phy, speed, fd);
                 }
-        }
-        emac_start_link(ep, NULL);
+        } else {
+                emac_reset(dev);
 
-        /* read the MAC Address */
-        for (i = 0; i < 6; i++)
-                ndev->dev_addr[i] = emacdata->mac_addr[i];
+                /* PHY-less configuration.
+                 * XXX I probably should move these settings to emacdata
+                 */
+                dev->phy.address = -1;
+                dev->phy.features = SUPPORTED_100baseT_Full | SUPPORTED_MII;
+                dev->phy.pause = 1;
+        }
 
         /* Fill in the driver function table */
         ndev->open = &emac_open;
-        ndev->hard_start_xmit = &emac_start_xmit;
+        if (dev->tah_dev) {
+                ndev->hard_start_xmit = &emac_start_xmit_sg;
+                ndev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
+        } else
+                ndev->hard_start_xmit = &emac_start_xmit;
+        ndev->tx_timeout = &emac_full_tx_reset;
+        ndev->watchdog_timeo = 5 * HZ;
         ndev->stop = &emac_close;
         ndev->get_stats = &emac_stats;
-        if (emacdata->jumbo)
-                ndev->change_mtu = &emac_change_mtu;
-        ndev->set_mac_address = &emac_set_mac_address;
         ndev->set_multicast_list = &emac_set_multicast_list;
         ndev->do_ioctl = &emac_ioctl;
+        if (emac_phy_supports_gige(emacdata->phy_mode)) {
+                ndev->change_mtu = &emac_change_mtu;
+                dev->commac.ops = &emac_commac_sg_ops;
+        }
         SET_ETHTOOL_OPS(ndev, &emac_ethtool_ops);
-        if (emacdata->tah_idx >= 0)
-                ndev->features = NETIF_F_IP_CSUM | NETIF_F_SG;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        ndev->poll_controller = emac_netpoll;
-#endif
 
-        SET_MODULE_OWNER(ndev);
+        netif_carrier_off(ndev);
+        netif_stop_queue(ndev);
+
+        err = register_netdev(ndev);
+        if (err) {
+                printk(KERN_ERR "emac%d: failed to register net device (%d)!\n",
+                       dev->def->index, err);
+                goto out6;
+        }
 
-        rc = register_netdev(ndev);
-        if (rc != 0)
-                goto bail;
+        ocp_set_drvdata(ocpdev, dev);
 
-        printk("%s: IBM emac, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-               ndev->name,
+        printk("%s: emac%d, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+               ndev->name, dev->def->index,
                ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
                ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
-        printk(KERN_INFO "%s: Found %s PHY (0x%02x)\n",
-               ndev->name, ep->phy_mii.def->name, ep->mii_phy_addr);
 
-      bail:
-        if (rc && commac_reg)
-                mal_unregister_commac(ep->mal, &ep->commac);
-        if (rc && ndev)
-                kfree(ndev);
+        if (dev->phy.address >= 0)
+                printk("%s: found %s PHY (0x%02x)\n", ndev->name,
+                       dev->phy.def->name, dev->phy.address);
 
-        return rc;
-}
-
-static int emac_probe(struct ocp_device *ocpdev)
-{
-        struct ocp_device *maldev;
-        struct ibm_ocp_mal *mal;
-        struct ocp_func_emac_data *emacdata;
-
-        emacdata = (struct ocp_func_emac_data *)ocpdev->def->additions;
-        if (emacdata == NULL) {
-                printk(KERN_ERR "emac%d: Missing additional datas !\n",
-                       ocpdev->def->index);
-                return -ENODEV;
-        }
-
-        /* Get the MAL device  */
-        maldev = ocp_find_device(OCP_ANY_ID, OCP_FUNC_MAL, emacdata->mal_idx);
-        if (maldev == NULL) {
-                printk("No maldev\n");
-                return -ENODEV;
-        }
-        /*
-         * Get MAL driver data, it must be here due to link order.
-         * When the driver is modularized, symbol dependencies will
-         * ensure the MAL driver is already present if built as a
-         * module.
-         */
-        mal = (struct ibm_ocp_mal *)ocp_get_drvdata(maldev);
-        if (mal == NULL) {
-                printk("No maldrv\n");
-                return -ENODEV;
-        }
-
-        /* If we depend on another EMAC for MDIO, wait for it to show up */
-        if (emacdata->mdio_idx >= 0 &&
-            (emacdata->mdio_idx != ocpdev->def->index) && !mdio_ndev) {
-                struct emac_def_dev *ddev;
-                /* Add this index to the deferred init table */
-                ddev = kmalloc(sizeof(struct emac_def_dev), GFP_KERNEL);
-                ddev->ocpdev = ocpdev;
-                ddev->mal = mal;
-                list_add_tail(&ddev->link, &emac_init_list);
-        } else {
-                emac_init_device(ocpdev, mal);
-        }
+        emac_dbg_register(dev->def->index, dev);
 
         return 0;
+      out6:
+        iounmap((void *)dev->emacp);
+      out5:
+        tah_fini(dev->tah_dev);
+      out4:
+        rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
+      out3:
+        zmii_fini(dev->zmii_dev, dev->zmii_input);
+      out2:
+        mal_unregister_commac(dev->mal, &dev->commac);
+      out:
+        kfree(ndev);
+        return err;
 }
 
-/* Structure for a device driver */
 static struct ocp_device_id emac_ids[] = {
-        {.vendor = OCP_ANY_ID,.function = OCP_FUNC_EMAC},
-        {.vendor = OCP_VENDOR_INVALID}
+        { .vendor = OCP_VENDOR_IBM, .function = OCP_FUNC_EMAC },
+        { .vendor = OCP_VENDOR_INVALID}
 };
 
 static struct ocp_driver emac_driver = {
         .name = "emac",
         .id_table = emac_ids,
-
         .probe = emac_probe,
         .remove = emac_remove,
 };
 
 static int __init emac_init(void)
 {
-        printk(KERN_INFO DRV_NAME ": " DRV_DESC ", version " DRV_VERSION "\n");
-        printk(KERN_INFO "Maintained by " DRV_AUTHOR "\n");
+        printk(KERN_INFO DRV_DESC ", version " DRV_VERSION "\n");
+
+        DBG(": init" NL);
 
-        if (skb_res > 2) {
-                printk(KERN_WARNING "Invalid skb_res: %d, cropping to 2\n",
-                       skb_res);
-                skb_res = 2;
+        if (mal_init())
+                return -ENODEV;
+
+        EMAC_CLK_INTERNAL;
+        if (ocp_register_driver(&emac_driver)) {
+                EMAC_CLK_EXTERNAL;
+                ocp_unregister_driver(&emac_driver);
+                mal_exit();
+                return -ENODEV;
         }
+        EMAC_CLK_EXTERNAL;
 
-        return ocp_register_driver(&emac_driver);
+        emac_init_debug();
+        return 0;
 }
 
 static void __exit emac_exit(void)
 {
+        DBG(": exit" NL);
         ocp_unregister_driver(&emac_driver);
+        mal_exit();
+        emac_fini_debug();
 }
 
 module_init(emac_init);
diff --git a/drivers/net/ibm_emac/ibm_emac_core.h b/drivers/net/ibm_emac/ibm_emac_core.h
index 97e6e1ea8c89..e9b44d030ac3 100644
--- a/drivers/net/ibm_emac/ibm_emac_core.h
+++ b/drivers/net/ibm_emac/ibm_emac_core.h
@@ -1,146 +1,221 @@
 /*
- * ibm_emac_core.h
+ * drivers/net/ibm_emac/ibm_emac_core.h
  *
- * Ethernet driver for the built in ethernet on the IBM 405 PowerPC
- * processor.
+ * Driver for PowerPC 4xx on-chip ethernet controller.
  *
- *      Armin Kuster akuster@mvista.com
- *      Sept, 2001
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- *      Orignial driver
- *         Johnnie Peters
- *         jpeters@mvista.com
- *
- * Copyright 2000 MontaVista Softare Inc.
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Johnnie Peters <jpeters@mvista.com>
+ *      Copyright 2000, 2001 MontaVista Softare Inc.
  *
  * 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.
+ *
  */
+#ifndef __IBM_EMAC_CORE_H_
+#define __IBM_EMAC_CORE_H_
 
-#ifndef _IBM_EMAC_CORE_H_
-#define _IBM_EMAC_CORE_H_
-
+#include <linux/config.h>
 #include <linux/netdevice.h>
+#include <linux/dma-mapping.h>
 #include <asm/ocp.h>
-#include <asm/mmu.h>            /* For phys_addr_t */
 
 #include "ibm_emac.h"
 #include "ibm_emac_phy.h"
-#include "ibm_emac_rgmii.h"
 #include "ibm_emac_zmii.h"
+#include "ibm_emac_rgmii.h"
 #include "ibm_emac_mal.h"
 #include "ibm_emac_tah.h"
 
-#ifndef CONFIG_IBM_EMAC_TXB
-#define NUM_TX_BUFF             64
-#define NUM_RX_BUFF             64
-#else
-#define NUM_TX_BUFF             CONFIG_IBM_EMAC_TXB
-#define NUM_RX_BUFF             CONFIG_IBM_EMAC_RXB
-#endif
+#define NUM_TX_BUFF                     CONFIG_IBM_EMAC_TXB
+#define NUM_RX_BUFF                     CONFIG_IBM_EMAC_RXB
 
-/* This does 16 byte alignment, exactly what we need.
- * The packet length includes FCS, but we don't want to
- * include that when passing upstream as it messes up
- * bridging applications.
- */
-#ifndef CONFIG_IBM_EMAC_SKBRES
-#define SKB_RES 2
-#else
-#define SKB_RES CONFIG_IBM_EMAC_SKBRES
+/* Simple sanity check */
+#if NUM_TX_BUFF > 256 || NUM_RX_BUFF > 256
+#error Invalid number of buffer descriptors (greater than 256)
 #endif
 
-/* Note about alignement. alloc_skb() returns a cache line
- * aligned buffer. However, dev_alloc_skb() will add 16 more
- * bytes and "reserve" them, so our buffer will actually end
- * on a half cache line. What we do is to use directly
- * alloc_skb, allocate 16 more bytes to match the total amount
- * allocated by dev_alloc_skb(), but we don't reserve.
+// XXX
+#define EMAC_MIN_MTU                    46
+#define EMAC_MAX_MTU                    9000
+
+/* Maximum L2 header length (VLAN tagged, no FCS) */
+#define EMAC_MTU_OVERHEAD               (6 * 2 + 2 + 4)
+
+/* RX BD size for the given MTU */
+static inline int emac_rx_size(int mtu)
+{
+        if (mtu > ETH_DATA_LEN)
+                return MAL_MAX_RX_SIZE;
+        else
+                return mal_rx_size(ETH_DATA_LEN + EMAC_MTU_OVERHEAD);
+}
+
+#define EMAC_DMA_ALIGN(x)               ALIGN((x), dma_get_cache_alignment())
+
+#define EMAC_RX_SKB_HEADROOM            \
+        EMAC_DMA_ALIGN(CONFIG_IBM_EMAC_RX_SKB_HEADROOM)
+
+/* Size of RX skb for the given MTU */
+static inline int emac_rx_skb_size(int mtu)
+{
+        int size = max(mtu + EMAC_MTU_OVERHEAD, emac_rx_size(mtu));
+        return EMAC_DMA_ALIGN(size + 2) + EMAC_RX_SKB_HEADROOM;
+}
+
+/* RX DMA sync size */
+static inline int emac_rx_sync_size(int mtu)
+{
+        return EMAC_DMA_ALIGN(emac_rx_size(mtu) + 2);
+}
+
+/* Driver statistcs is split into two parts to make it more cache friendly:
+ *   - normal statistics (packet count, etc)
+ *   - error statistics
+ *
+ * When statistics is requested by ethtool, these parts are concatenated,
+ * normal one goes first.
+ *
+ * Please, keep these structures in sync with emac_stats_keys.
  */
-#define MAX_NUM_BUF_DESC        255
-#define DESC_BUF_SIZE           4080    /* max 4096-16 */
-#define DESC_BUF_SIZE_REG       (DESC_BUF_SIZE / 16)
-
-/* Transmitter timeout. */
-#define TX_TIMEOUT              (2*HZ)
-
-/* MDIO latency delay */
-#define MDIO_DELAY              250
-
-/* Power managment shift registers */
-#define IBM_CPM_EMMII   0       /* Shift value for MII */
-#define IBM_CPM_EMRX    1       /* Shift value for recv */
-#define IBM_CPM_EMTX    2       /* Shift value for MAC */
-#define IBM_CPM_EMAC(x) (((x)>>IBM_CPM_EMMII) | ((x)>>IBM_CPM_EMRX) | ((x)>>IBM_CPM_EMTX))
-
-#define ENET_HEADER_SIZE        14
-#define ENET_FCS_SIZE           4
-#define ENET_DEF_MTU_SIZE       1500
-#define ENET_DEF_BUF_SIZE       (ENET_DEF_MTU_SIZE + ENET_HEADER_SIZE + ENET_FCS_SIZE)
-#define EMAC_MIN_FRAME          64
-#define EMAC_MAX_FRAME          9018
-#define EMAC_MIN_MTU            (EMAC_MIN_FRAME - ENET_HEADER_SIZE - ENET_FCS_SIZE)
-#define EMAC_MAX_MTU            (EMAC_MAX_FRAME - ENET_HEADER_SIZE - ENET_FCS_SIZE)
-
-#ifdef CONFIG_IBM_EMAC_ERRMSG
-void emac_serr_dump_0(struct net_device *dev);
-void emac_serr_dump_1(struct net_device *dev);
-void emac_err_dump(struct net_device *dev, int em0isr);
-void emac_phy_dump(struct net_device *);
-void emac_desc_dump(struct net_device *);
-void emac_mac_dump(struct net_device *);
-void emac_mal_dump(struct net_device *);
-#else
-#define emac_serr_dump_0(dev) do { } while (0)
-#define emac_serr_dump_1(dev) do { } while (0)
-#define emac_err_dump(dev,x) do { } while (0)
-#define emac_phy_dump(dev) do { } while (0)
-#define emac_desc_dump(dev) do { } while (0)
-#define emac_mac_dump(dev) do { } while (0)
-#define emac_mal_dump(dev) do { } while (0)
-#endif
+
+/* Normal TX/RX Statistics */
+struct ibm_emac_stats {
+        u64 rx_packets;
+        u64 rx_bytes;
+        u64 tx_packets;
+        u64 tx_bytes;
+        u64 rx_packets_csum;
+        u64 tx_packets_csum;
+};
+
+/* Error statistics */
+struct ibm_emac_error_stats {
+        u64 tx_undo;
+
+        /* Software RX Errors */
+        u64 rx_dropped_stack;
+        u64 rx_dropped_oom;
+        u64 rx_dropped_error;
+        u64 rx_dropped_resize;
+        u64 rx_dropped_mtu;
+        u64 rx_stopped;
+        /* BD reported RX errors */
+        u64 rx_bd_errors;
+        u64 rx_bd_overrun;
+        u64 rx_bd_bad_packet;
+        u64 rx_bd_runt_packet;
+        u64 rx_bd_short_event;
+        u64 rx_bd_alignment_error;
+        u64 rx_bd_bad_fcs;
+        u64 rx_bd_packet_too_long;
+        u64 rx_bd_out_of_range;
+        u64 rx_bd_in_range;
+        /* EMAC IRQ reported RX errors */
+        u64 rx_parity;
+        u64 rx_fifo_overrun;
+        u64 rx_overrun;
+        u64 rx_bad_packet;
+        u64 rx_runt_packet;
+        u64 rx_short_event;
+        u64 rx_alignment_error;
+        u64 rx_bad_fcs;
+        u64 rx_packet_too_long;
+        u64 rx_out_of_range;
+        u64 rx_in_range;
+
+        /* Software TX Errors */
+        u64 tx_dropped;
+        /* BD reported TX errors */
+        u64 tx_bd_errors;
+        u64 tx_bd_bad_fcs;
+        u64 tx_bd_carrier_loss;
+        u64 tx_bd_excessive_deferral;
+        u64 tx_bd_excessive_collisions;
+        u64 tx_bd_late_collision;
+        u64 tx_bd_multple_collisions;
+        u64 tx_bd_single_collision;
+        u64 tx_bd_underrun;
+        u64 tx_bd_sqe;
+        /* EMAC IRQ reported TX errors */
+        u64 tx_parity;
+        u64 tx_underrun;
+        u64 tx_sqe;
+        u64 tx_errors;
+};
+
+#define EMAC_ETHTOOL_STATS_COUNT        ((sizeof(struct ibm_emac_stats) + \
+                                          sizeof(struct ibm_emac_error_stats)) \
+                                         / sizeof(u64))
 
 struct ocp_enet_private {
-        struct sk_buff *tx_skb[NUM_TX_BUFF];
-        struct sk_buff *rx_skb[NUM_RX_BUFF];
-        struct mal_descriptor *tx_desc;
-        struct mal_descriptor *rx_desc;
-        struct mal_descriptor *rx_dirty;
-        struct net_device_stats stats;
-        int tx_cnt;
-        int rx_slot;
-        int dirty_rx;
-        int tx_slot;
-        int ack_slot;
-        int rx_buffer_size;
-
-        struct mii_phy phy_mii;
-        int mii_phy_addr;
-        int want_autoneg;
-        int timer_ticks;
-        struct timer_list link_timer;
-        struct net_device *mdio_dev;
-
-        struct ocp_device *rgmii_dev;
-        int rgmii_input;
-
-        struct ocp_device *zmii_dev;
-        int zmii_input;
-
-        struct ibm_ocp_mal *mal;
-        int mal_tx_chan, mal_rx_chan;
-        struct mal_commac commac;
-
-        struct ocp_device *tah_dev;
-
-        int opened;
-        int going_away;
-        int wol_irq;
-        emac_t *emacp;
-        struct ocp_device *ocpdev;
-        struct net_device *ndev;
-        spinlock_t lock;
+        struct net_device               *ndev;          /* 0 */
+        struct emac_regs                *emacp;
+        
+        struct mal_descriptor           *tx_desc;
+        int                             tx_cnt;
+        int                             tx_slot;
+        int                             ack_slot;
+
+        struct mal_descriptor           *rx_desc;
+        int                             rx_slot;
+        struct sk_buff                  *rx_sg_skb;     /* 1 */
+        int                             rx_skb_size;
+        int                             rx_sync_size;
+
+        struct ibm_emac_stats           stats;
+        struct ocp_device               *tah_dev;
+
+        struct ibm_ocp_mal              *mal;
+        struct mal_commac               commac;
+
+        struct sk_buff                  *tx_skb[NUM_TX_BUFF];
+        struct sk_buff                  *rx_skb[NUM_RX_BUFF];
+
+        struct ocp_device               *zmii_dev;
+        int                             zmii_input;
+        struct ocp_enet_private         *mdio_dev;
+        struct ocp_device               *rgmii_dev;
+        int                             rgmii_input;
+
+        struct ocp_def                  *def;
+
+        struct mii_phy                  phy;
+        struct timer_list               link_timer;
+        int                             reset_failed;
+
+        struct ibm_emac_error_stats     estats;
+        struct net_device_stats         nstats;
+
+        struct device*                  ldev;
 };
-#endif                          /* _IBM_EMAC_CORE_H_ */
+
+/* Ethtool get_regs complex data.
+ * We want to get not just EMAC registers, but also MAL, ZMII, RGMII, TAH 
+ * when available.
+ * 
+ * Returned BLOB consists of the ibm_emac_ethtool_regs_hdr, 
+ * MAL registers, EMAC registers and optional ZMII, RGMII, TAH registers.
+ * Each register component is preceded with emac_ethtool_regs_subhdr.
+ * Order of the optional headers follows their relative bit posititions 
+ * in emac_ethtool_regs_hdr.components
+ */
+#define EMAC_ETHTOOL_REGS_ZMII          0x00000001
+#define EMAC_ETHTOOL_REGS_RGMII         0x00000002
+#define EMAC_ETHTOOL_REGS_TAH           0x00000004
+
+struct emac_ethtool_regs_hdr {
+        u32 components;
+};
+
+struct emac_ethtool_regs_subhdr {
+        u32 version;
+        u32 index;
+};
+
+#endif                          /* __IBM_EMAC_CORE_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_debug.c b/drivers/net/ibm_emac/ibm_emac_debug.c
index c8512046cf84..75d3b8639041 100644
--- a/drivers/net/ibm_emac/ibm_emac_debug.c
+++ b/drivers/net/ibm_emac/ibm_emac_debug.c
@@ -1,224 +1,213 @@
 /*
- * ibm_ocp_debug.c
+ * drivers/net/ibm_emac/ibm_emac_debug.c
  *
- * This has all the debug routines that where in *_enet.c
+ * Driver for PowerPC 4xx on-chip ethernet controller, debug print routines.
  *
- *      Armin Kuster akuster@mvista.com
- *      April , 2002
- *
- * Copyright 2002 MontaVista Softare Inc.
+ * Copyright (c) 2004, 2005 Zultys Technologies
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
  * 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.
+ *
  */
-
 #include <linux/config.h>
+#include <linux/init.h>
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/sysrq.h>
 #include <asm/io.h>
-#include "ibm_ocp_mal.h"
-#include "ibm_ocp_zmii.h"
-#include "ibm_ocp_enet.h"
 
-extern int emac_phy_read(struct net_device *dev, int mii_id, int reg);
+#include "ibm_emac_core.h"
+
+static void emac_desc_dump(int idx, struct ocp_enet_private *p)
+{
+        int i;
+        printk("** EMAC%d TX BDs **\n"
+               " tx_cnt = %d tx_slot = %d ack_slot = %d\n",
+               idx, p->tx_cnt, p->tx_slot, p->ack_slot);
+        for (i = 0; i < NUM_TX_BUFF / 2; ++i)
+                printk
+                    ("bd[%2d] 0x%08x %c 0x%04x %4u - bd[%2d] 0x%08x %c 0x%04x %4u\n",
+                     i, p->tx_desc[i].data_ptr, p->tx_skb[i] ? 'V' : ' ',
+                     p->tx_desc[i].ctrl, p->tx_desc[i].data_len,
+                     NUM_TX_BUFF / 2 + i,
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].data_ptr,
+                     p->tx_skb[NUM_TX_BUFF / 2 + i] ? 'V' : ' ',
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].ctrl,
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].data_len);
+
+        printk("** EMAC%d RX BDs **\n"
+               " rx_slot = %d rx_stopped = %d rx_skb_size = %d rx_sync_size = %d\n"
+               " rx_sg_skb = 0x%p\n",
+               idx, p->rx_slot, p->commac.rx_stopped, p->rx_skb_size,
+               p->rx_sync_size, p->rx_sg_skb);
+        for (i = 0; i < NUM_RX_BUFF / 2; ++i)
+                printk
+                    ("bd[%2d] 0x%08x %c 0x%04x %4u - bd[%2d] 0x%08x %c 0x%04x %4u\n",
+                     i, p->rx_desc[i].data_ptr, p->rx_skb[i] ? 'V' : ' ',
+                     p->rx_desc[i].ctrl, p->rx_desc[i].data_len,
+                     NUM_RX_BUFF / 2 + i,
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].data_ptr,
+                     p->rx_skb[NUM_RX_BUFF / 2 + i] ? 'V' : ' ',
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].ctrl,
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].data_len);
+}
+
+static void emac_mac_dump(int idx, struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+
+        printk("** EMAC%d registers **\n"
+               "MR0 = 0x%08x MR1 = 0x%08x TMR0 = 0x%08x TMR1 = 0x%08x\n"
+               "RMR = 0x%08x ISR = 0x%08x ISER = 0x%08x\n"
+               "IAR = %04x%08x VTPID = 0x%04x VTCI = 0x%04x\n"
+               "IAHT: 0x%04x 0x%04x 0x%04x 0x%04x "
+               "GAHT: 0x%04x 0x%04x 0x%04x 0x%04x\n"
+               "LSA = %04x%08x IPGVR = 0x%04x\n"
+               "STACR = 0x%08x TRTR = 0x%08x RWMR = 0x%08x\n"
+               "OCTX = 0x%08x OCRX = 0x%08x IPCR = 0x%08x\n",
+               idx, in_be32(&p->mr0), in_be32(&p->mr1),
+               in_be32(&p->tmr0), in_be32(&p->tmr1),
+               in_be32(&p->rmr), in_be32(&p->isr), in_be32(&p->iser),
+               in_be32(&p->iahr), in_be32(&p->ialr), in_be32(&p->vtpid),
+               in_be32(&p->vtci),
+               in_be32(&p->iaht1), in_be32(&p->iaht2), in_be32(&p->iaht3),
+               in_be32(&p->iaht4),
+               in_be32(&p->gaht1), in_be32(&p->gaht2), in_be32(&p->gaht3),
+               in_be32(&p->gaht4),
+               in_be32(&p->lsah), in_be32(&p->lsal), in_be32(&p->ipgvr),
+               in_be32(&p->stacr), in_be32(&p->trtr), in_be32(&p->rwmr),
+               in_be32(&p->octx), in_be32(&p->ocrx), in_be32(&p->ipcr)
+            );
+
+        emac_desc_dump(idx, dev);
+}
+
+static void emac_mal_dump(struct ibm_ocp_mal *mal)
+{
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        int i;
+
+        printk("** MAL%d Registers **\n"
+               "CFG = 0x%08x ESR = 0x%08x IER = 0x%08x\n"
+               "TX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n"
+               "RX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n",
+               mal->def->index,
+               get_mal_dcrn(mal, MAL_CFG), get_mal_dcrn(mal, MAL_ESR),
+               get_mal_dcrn(mal, MAL_IER),
+               get_mal_dcrn(mal, MAL_TXCASR), get_mal_dcrn(mal, MAL_TXCARR),
+               get_mal_dcrn(mal, MAL_TXEOBISR), get_mal_dcrn(mal, MAL_TXDEIR),
+               get_mal_dcrn(mal, MAL_RXCASR), get_mal_dcrn(mal, MAL_RXCARR),
+               get_mal_dcrn(mal, MAL_RXEOBISR), get_mal_dcrn(mal, MAL_RXDEIR)
+            );
+
+        printk("TX|");
+        for (i = 0; i < maldata->num_tx_chans; ++i) {
+                if (i && !(i % 4))
+                        printk("\n   ");
+                printk("CTP%d = 0x%08x ", i, get_mal_dcrn(mal, MAL_TXCTPR(i)));
+        }
+        printk("\nRX|");
+        for (i = 0; i < maldata->num_rx_chans; ++i) {
+                if (i && !(i % 4))
+                        printk("\n   ");
+                printk("CTP%d = 0x%08x ", i, get_mal_dcrn(mal, MAL_RXCTPR(i)));
+        }
+        printk("\n   ");
+        for (i = 0; i < maldata->num_rx_chans; ++i) {
+                u32 r = get_mal_dcrn(mal, MAL_RCBS(i));
+                if (i && !(i % 3))
+                        printk("\n   ");
+                printk("RCBS%d = 0x%08x (%d) ", i, r, r * 16);
+        }
+        printk("\n");
+}
+
+static struct ocp_enet_private *__emacs[4];
+static struct ibm_ocp_mal *__mals[1];
 
-void emac_phy_dump(struct net_device *dev)
+void emac_dbg_register(int idx, struct ocp_enet_private *dev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long i;
-        uint data;
-
-        printk(KERN_DEBUG " Prepare for Phy dump....\n");
-        for (i = 0; i < 0x1A; i++) {
-                data = emac_phy_read(dev, fep->mii_phy_addr, i);
-                printk(KERN_DEBUG "Phy reg 0x%lx ==> %4x\n", i, data);
-                if (i == 0x07)
-                        i = 0x0f;
+        unsigned long flags;
+
+        if (idx >= sizeof(__emacs) / sizeof(__emacs[0])) {
+                printk(KERN_WARNING
+                       "invalid index %d when registering EMAC for debugging\n",
+                       idx);
+                return;
         }
+
+        local_irq_save(flags);
+        __emacs[idx] = dev;
+        local_irq_restore(flags);
 }
 
-void emac_desc_dump(struct net_device *dev)
+void mal_dbg_register(int idx, struct ibm_ocp_mal *mal)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int curr_slot;
-
-        printk(KERN_DEBUG
-               "dumping the receive descriptors:  current slot is %d\n",
-               fep->rx_slot);
-        for (curr_slot = 0; curr_slot < NUM_RX_BUFF; curr_slot++) {
-                printk(KERN_DEBUG
-                       "Desc %02d: status 0x%04x, length %3d, addr 0x%x\n",
-                       curr_slot, fep->rx_desc[curr_slot].ctrl,
-                       fep->rx_desc[curr_slot].data_len,
-                       (unsigned int)fep->rx_desc[curr_slot].data_ptr);
+        unsigned long flags;
+
+        if (idx >= sizeof(__mals) / sizeof(__mals[0])) {
+                printk(KERN_WARNING
+                       "invalid index %d when registering MAL for debugging\n",
+                       idx);
+                return;
         }
+
+        local_irq_save(flags);
+        __mals[idx] = mal;
+        local_irq_restore(flags);
 }
 
-void emac_mac_dump(struct net_device *dev)
+void emac_dbg_dump_all(void)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        volatile emac_t *emacp = fep->emacp;
-
-        printk(KERN_DEBUG "EMAC DEBUG ********** \n");
-        printk(KERN_DEBUG "EMAC_M0  ==> 0x%x\n", in_be32(&emacp->em0mr0));
-        printk(KERN_DEBUG "EMAC_M1  ==> 0x%x\n", in_be32(&emacp->em0mr1));
-        printk(KERN_DEBUG "EMAC_TXM0==> 0x%x\n", in_be32(&emacp->em0tmr0));
-        printk(KERN_DEBUG "EMAC_TXM1==> 0x%x\n", in_be32(&emacp->em0tmr1));
-        printk(KERN_DEBUG "EMAC_RXM ==> 0x%x\n", in_be32(&emacp->em0rmr));
-        printk(KERN_DEBUG "EMAC_ISR ==> 0x%x\n", in_be32(&emacp->em0isr));
-        printk(KERN_DEBUG "EMAC_IER ==> 0x%x\n", in_be32(&emacp->em0iser));
-        printk(KERN_DEBUG "EMAC_IAH ==> 0x%x\n", in_be32(&emacp->em0iahr));
-        printk(KERN_DEBUG "EMAC_IAL ==> 0x%x\n", in_be32(&emacp->em0ialr));
-        printk(KERN_DEBUG "EMAC_VLAN_TPID_REG ==> 0x%x\n",
-               in_be32(&emacp->em0vtpid));
+        unsigned int i;
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        for (i = 0; i < sizeof(__mals) / sizeof(__mals[0]); ++i)
+                if (__mals[i])
+                        emac_mal_dump(__mals[i]);
+
+        for (i = 0; i < sizeof(__emacs) / sizeof(__emacs[0]); ++i)
+                if (__emacs[i])
+                        emac_mac_dump(i, __emacs[i]);
+
+        local_irq_restore(flags);
 }
 
-void emac_mal_dump(struct net_device *dev)
+#if defined(CONFIG_MAGIC_SYSRQ)
+static void emac_sysrq_handler(int key, struct pt_regs *pt_regs,
+                               struct tty_struct *tty)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-
-        printk(KERN_DEBUG " MAL DEBUG ********** \n");
-        printk(KERN_DEBUG " MCR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALCR));
-        printk(KERN_DEBUG " ESR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALESR));
-        printk(KERN_DEBUG " IER      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALIER));
-#ifdef CONFIG_40x
-        printk(KERN_DEBUG " DBR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALDBR));
-#endif                          /* CONFIG_40x */
-        printk(KERN_DEBUG " TXCASR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCASR));
-        printk(KERN_DEBUG " TXCARR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCARR));
-        printk(KERN_DEBUG " TXEOBISR ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXEOBISR));
-        printk(KERN_DEBUG " TXDEIR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXDEIR));
-        printk(KERN_DEBUG " RXCASR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCASR));
-        printk(KERN_DEBUG " RXCARR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCARR));
-        printk(KERN_DEBUG " RXEOBISR ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXEOBISR));
-        printk(KERN_DEBUG " RXDEIR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXDEIR));
-        printk(KERN_DEBUG " TXCTP0R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP0R));
-        printk(KERN_DEBUG " TXCTP1R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP1R));
-        printk(KERN_DEBUG " TXCTP2R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP2R));
-        printk(KERN_DEBUG " TXCTP3R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP3R));
-        printk(KERN_DEBUG " RXCTP0R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCTP0R));
-        printk(KERN_DEBUG " RXCTP1R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCTP1R));
-        printk(KERN_DEBUG " RCBS0    ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRCBS0));
-        printk(KERN_DEBUG " RCBS1    ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRCBS1));
+        emac_dbg_dump_all();
 }
 
-void emac_serr_dump_0(struct net_device *dev)
+static struct sysrq_key_op emac_sysrq_op = {
+        .handler = emac_sysrq_handler,
+        .help_msg = "emaC",
+        .action_msg = "Show EMAC(s) status",
+};
+
+int __init emac_init_debug(void)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-        unsigned long int mal_error, plb_error, plb_addr;
-
-        mal_error = get_mal_dcrn(mal, DCRN_MALESR);
-        printk(KERN_DEBUG "ppc405_eth_serr: %s channel %ld \n",
-               (mal_error & 0x40000000) ? "Receive" :
-               "Transmit", (mal_error & 0x3e000000) >> 25);
-        printk(KERN_DEBUG "  -----  latched error  -----\n");
-        if (mal_error & MALESR_DE)
-                printk(KERN_DEBUG "  DE: descriptor error\n");
-        if (mal_error & MALESR_OEN)
-                printk(KERN_DEBUG "  ONE: OPB non-fullword error\n");
-        if (mal_error & MALESR_OTE)
-                printk(KERN_DEBUG "  OTE: OPB timeout error\n");
-        if (mal_error & MALESR_OSE)
-                printk(KERN_DEBUG "  OSE: OPB slave error\n");
-
-        if (mal_error & MALESR_PEIN) {
-                plb_error = mfdcr(DCRN_PLB0_BESR);
-                printk(KERN_DEBUG
-                       "  PEIN: PLB error, PLB0_BESR is 0x%x\n",
-                       (unsigned int)plb_error);
-                plb_addr = mfdcr(DCRN_PLB0_BEAR);
-                printk(KERN_DEBUG
-                       "  PEIN: PLB error, PLB0_BEAR is 0x%x\n",
-                       (unsigned int)plb_addr);
-        }
+        return register_sysrq_key('c', &emac_sysrq_op);
 }
 
-void emac_serr_dump_1(struct net_device *dev)
+void __exit emac_fini_debug(void)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-        int mal_error = get_mal_dcrn(mal, DCRN_MALESR);
-
-        printk(KERN_DEBUG "  -----  cumulative errors  -----\n");
-        if (mal_error & MALESR_DEI)
-                printk(KERN_DEBUG "  DEI: descriptor error interrupt\n");
-        if (mal_error & MALESR_ONEI)
-                printk(KERN_DEBUG "  OPB non-fullword error interrupt\n");
-        if (mal_error & MALESR_OTEI)
-                printk(KERN_DEBUG "  OTEI: timeout error interrupt\n");
-        if (mal_error & MALESR_OSEI)
-                printk(KERN_DEBUG "  OSEI: slave error interrupt\n");
-        if (mal_error & MALESR_PBEI)
-                printk(KERN_DEBUG "  PBEI: PLB bus error interrupt\n");
+        unregister_sysrq_key('c', &emac_sysrq_op);
 }
 
-void emac_err_dump(struct net_device *dev, int em0isr)
+#else
+int __init emac_init_debug(void)
+{
+        return 0;
+}
+void __exit emac_fini_debug(void)
 {
-        printk(KERN_DEBUG "%s: on-chip ethernet error:\n", dev->name);
-
-        if (em0isr & EMAC_ISR_OVR)
-                printk(KERN_DEBUG "  OVR: overrun\n");
-        if (em0isr & EMAC_ISR_PP)
-                printk(KERN_DEBUG "  PP: control pause packet\n");
-        if (em0isr & EMAC_ISR_BP)
-                printk(KERN_DEBUG "  BP: packet error\n");
-        if (em0isr & EMAC_ISR_RP)
-                printk(KERN_DEBUG "  RP: runt packet\n");
-        if (em0isr & EMAC_ISR_SE)
-                printk(KERN_DEBUG "  SE: short event\n");
-        if (em0isr & EMAC_ISR_ALE)
-                printk(KERN_DEBUG "  ALE: odd number of nibbles in packet\n");
-        if (em0isr & EMAC_ISR_BFCS)
-                printk(KERN_DEBUG "  BFCS: bad FCS\n");
-        if (em0isr & EMAC_ISR_PTLE)
-                printk(KERN_DEBUG "  PTLE: oversized packet\n");
-        if (em0isr & EMAC_ISR_ORE)
-                printk(KERN_DEBUG
-                       "  ORE: packet length field > max allowed LLC\n");
-        if (em0isr & EMAC_ISR_IRE)
-                printk(KERN_DEBUG "  IRE: In Range error\n");
-        if (em0isr & EMAC_ISR_DBDM)
-                printk(KERN_DEBUG "  DBDM: xmit error or SQE\n");
-        if (em0isr & EMAC_ISR_DB0)
-                printk(KERN_DEBUG "  DB0: xmit error or SQE on TX channel 0\n");
-        if (em0isr & EMAC_ISR_SE0)
-                printk(KERN_DEBUG
-                       "  SE0: Signal Quality Error test failure from TX channel 0\n");
-        if (em0isr & EMAC_ISR_TE0)
-                printk(KERN_DEBUG "  TE0: xmit channel 0 aborted\n");
-        if (em0isr & EMAC_ISR_DB1)
-                printk(KERN_DEBUG "  DB1: xmit error or SQE on TX channel \n");
-        if (em0isr & EMAC_ISR_SE1)
-                printk(KERN_DEBUG
-                       "  SE1: Signal Quality Error test failure from TX channel 1\n");
-        if (em0isr & EMAC_ISR_TE1)
-                printk(KERN_DEBUG "  TE1: xmit channel 1 aborted\n");
-        if (em0isr & EMAC_ISR_MOS)
-                printk(KERN_DEBUG "  MOS\n");
-        if (em0isr & EMAC_ISR_MOF)
-                printk(KERN_DEBUG "  MOF\n");
-
-        emac_mac_dump(dev);
-        emac_mal_dump(dev);
 }
+#endif                          /* CONFIG_MAGIC_SYSRQ */
diff --git a/drivers/net/ibm_emac/ibm_emac_debug.h b/drivers/net/ibm_emac/ibm_emac_debug.h
new file mode 100644
index 000000000000..e85fbe0a8da9
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_debug.h
@@ -0,0 +1,63 @@
+/*
+ * drivers/net/ibm_emac/ibm_ocp_debug.h
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, debug print routines.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * 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.
+ *
+ */
+#ifndef __IBM_EMAC_DEBUG_H_
+#define __IBM_EMAC_DEBUG_H_
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include "ibm_emac_core.h"
+#include "ibm_emac_mal.h"
+
+#if defined(CONFIG_IBM_EMAC_DEBUG)
+void emac_dbg_register(int idx, struct ocp_enet_private *dev);
+void mal_dbg_register(int idx, struct ibm_ocp_mal *mal);
+int emac_init_debug(void) __init;
+void emac_fini_debug(void) __exit;
+void emac_dbg_dump_all(void);
+# define DBG_LEVEL              1
+#else
+# define emac_dbg_register(x,y) ((void)0)
+# define mal_dbg_register(x,y)  ((void)0)
+# define emac_init_debug()      ((void)0)
+# define emac_fini_debug()      ((void)0)
+# define emac_dbg_dump_all()    ((void)0)
+# define DBG_LEVEL              0
+#endif
+
+#if DBG_LEVEL > 0
+#  define DBG(f,x...)           printk("emac" f, ##x)
+#  define MAL_DBG(f,x...)       printk("mal" f, ##x)
+#  define ZMII_DBG(f,x...)      printk("zmii" f, ##x)
+#  define RGMII_DBG(f,x...)     printk("rgmii" f, ##x)
+#  define NL                    "\n"
+#else
+#  define DBG(f,x...)           ((void)0)
+#  define MAL_DBG(f,x...)       ((void)0)
+#  define ZMII_DBG(f,x...)      ((void)0)
+#  define RGMII_DBG(f,x...)     ((void)0)
+#endif
+#if DBG_LEVEL > 1
+#  define DBG2(f,x...)          DBG(f, ##x)
+#  define MAL_DBG2(f,x...)      MAL_DBG(f, ##x)
+#  define ZMII_DBG2(f,x...)     ZMII_DBG(f, ##x)
+#  define RGMII_DBG2(f,x...)    RGMII_DBG(f, ##x)
+#else
+#  define DBG2(f,x...)          ((void)0)
+#  define MAL_DBG2(f,x...)      ((void)0)
+#  define ZMII_DBG2(f,x...)     ((void)0)
+#  define RGMII_DBG2(f,x...)    ((void)0)
+#endif
+
+#endif                          /* __IBM_EMAC_DEBUG_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_mal.c b/drivers/net/ibm_emac/ibm_emac_mal.c
index e59f57f363ca..da88d43081cc 100644
--- a/drivers/net/ibm_emac/ibm_emac_mal.c
+++ b/drivers/net/ibm_emac/ibm_emac_mal.c
@@ -1,436 +1,565 @@
 /*
- * ibm_ocp_mal.c
+ * drivers/net/ibm_emac/ibm_emac_mal.c
  *
- *      Armin Kuster akuster@mvista.com
- *      Juen, 2002
+ * Memory Access Layer (MAL) support
+ * 
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2002 MontaVista Softare Inc.
+ * Based on original work by
+ *      Benjamin Herrenschmidt <benh@kernel.crashing.org>,
+ *      David Gibson <hermes@gibson.dropbear.id.au>,
+ *
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002 MontaVista Softare Inc.
  *
  * 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.
+ *
  */
-
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/io.h>
-#include <asm/irq.h>
 #include <asm/ocp.h>
 
+#include "ibm_emac_core.h"
 #include "ibm_emac_mal.h"
+#include "ibm_emac_debug.h"
 
-// Locking: Should we share a lock with the client ? The client could provide
-// a lock pointer (optionally) in the commac structure... I don't think this is
-// really necessary though
-
-/* This lock protects the commac list. On today UP implementations, it's
- * really only used as IRQ protection in mal_{register,unregister}_commac()
- */
-static DEFINE_RWLOCK(mal_list_lock);
-
-int mal_register_commac(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+int __init mal_register_commac(struct ibm_ocp_mal *mal,
+                               struct mal_commac *commac)
 {
         unsigned long flags;
+        local_irq_save(flags);
 
-        write_lock_irqsave(&mal_list_lock, flags);
+        MAL_DBG("%d: reg(%08x, %08x)" NL, mal->def->index,
+                commac->tx_chan_mask, commac->rx_chan_mask);
 
-        /* Don't let multiple commacs claim the same channel */
+        /* Don't let multiple commacs claim the same channel(s) */
         if ((mal->tx_chan_mask & commac->tx_chan_mask) ||
             (mal->rx_chan_mask & commac->rx_chan_mask)) {
-                write_unlock_irqrestore(&mal_list_lock, flags);
+                local_irq_restore(flags);
+                printk(KERN_WARNING "mal%d: COMMAC channels conflict!\n",
+                       mal->def->index);
                 return -EBUSY;
         }
 
         mal->tx_chan_mask |= commac->tx_chan_mask;
         mal->rx_chan_mask |= commac->rx_chan_mask;
+        list_add(&commac->list, &mal->list);
 
-        list_add(&commac->list, &mal->commac);
-
-        write_unlock_irqrestore(&mal_list_lock, flags);
-
+        local_irq_restore(flags);
         return 0;
 }
 
-int mal_unregister_commac(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+void __exit mal_unregister_commac(struct ibm_ocp_mal *mal,
+                                  struct mal_commac *commac)
 {
         unsigned long flags;
+        local_irq_save(flags);
 
-        write_lock_irqsave(&mal_list_lock, flags);
+        MAL_DBG("%d: unreg(%08x, %08x)" NL, mal->def->index,
+                commac->tx_chan_mask, commac->rx_chan_mask);
 
         mal->tx_chan_mask &= ~commac->tx_chan_mask;
         mal->rx_chan_mask &= ~commac->rx_chan_mask;
-
         list_del_init(&commac->list);
 
-        write_unlock_irqrestore(&mal_list_lock, flags);
-
-        return 0;
+        local_irq_restore(flags);
 }
 
 int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel, unsigned long size)
 {
-        switch (channel) {
-        case 0:
-                set_mal_dcrn(mal, DCRN_MALRCBS0, size);
-                break;
-#ifdef DCRN_MALRCBS1
-        case 1:
-                set_mal_dcrn(mal, DCRN_MALRCBS1, size);
-                break;
-#endif
-#ifdef DCRN_MALRCBS2
-        case 2:
-                set_mal_dcrn(mal, DCRN_MALRCBS2, size);
-                break;
-#endif
-#ifdef DCRN_MALRCBS3
-        case 3:
-                set_mal_dcrn(mal, DCRN_MALRCBS3, size);
-                break;
-#endif
-        default:
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_rx_chans ||
+               size > MAL_MAX_RX_SIZE);
+
+        MAL_DBG("%d: set_rbcs(%d, %lu)" NL, mal->def->index, channel, size);
+
+        if (size & 0xf) {
+                printk(KERN_WARNING
+                       "mal%d: incorrect RX size %lu for the channel %d\n",
+                       mal->def->index, size, channel);
                 return -EINVAL;
         }
 
+        set_mal_dcrn(mal, MAL_RCBS(channel), size >> 4);
         return 0;
 }
 
-static irqreturn_t mal_serr(int irq, void *dev_instance, struct pt_regs *regs)
+int mal_tx_bd_offset(struct ibm_ocp_mal *mal, int channel)
 {
-        struct ibm_ocp_mal *mal = dev_instance;
-        unsigned long mal_error;
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_tx_chans);
+        return channel * NUM_TX_BUFF;
+}
 
-        /*
-         * This SERR applies to one of the devices on the MAL, here we charge
-         * it against the first EMAC registered for the MAL.
-         */
+int mal_rx_bd_offset(struct ibm_ocp_mal *mal, int channel)
+{
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_rx_chans);
+        return maldata->num_tx_chans * NUM_TX_BUFF + channel * NUM_RX_BUFF;
+}
 
-        mal_error = get_mal_dcrn(mal, DCRN_MALESR);
+void mal_enable_tx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        local_bh_disable();
+        MAL_DBG("%d: enable_tx(%d)" NL, mal->def->index, channel);
+        set_mal_dcrn(mal, MAL_TXCASR,
+                     get_mal_dcrn(mal, MAL_TXCASR) | MAL_CHAN_MASK(channel));
+        local_bh_enable();
+}
 
-        printk(KERN_ERR "%s: System Error (MALESR=%lx)\n",
-               "MAL" /* FIXME: get the name right */ , mal_error);
+void mal_disable_tx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        set_mal_dcrn(mal, MAL_TXCARR, MAL_CHAN_MASK(channel));
+        MAL_DBG("%d: disable_tx(%d)" NL, mal->def->index, channel);
+}
 
-        /* FIXME: decipher error */
-        /* DIXME: distribute to commacs, if possible */
+void mal_enable_rx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        local_bh_disable();
+        MAL_DBG("%d: enable_rx(%d)" NL, mal->def->index, channel);
+        set_mal_dcrn(mal, MAL_RXCASR,
+                     get_mal_dcrn(mal, MAL_RXCASR) | MAL_CHAN_MASK(channel));
+        local_bh_enable();
+}
 
-        /* Clear the error status register */
-        set_mal_dcrn(mal, DCRN_MALESR, mal_error);
+void mal_disable_rx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        set_mal_dcrn(mal, MAL_RXCARR, MAL_CHAN_MASK(channel));
+        MAL_DBG("%d: disable_rx(%d)" NL, mal->def->index, channel);
+}
 
-        return IRQ_HANDLED;
+void mal_poll_add(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+{
+        local_bh_disable();
+        MAL_DBG("%d: poll_add(%p)" NL, mal->def->index, commac);
+        list_add_tail(&commac->poll_list, &mal->poll_list);
+        local_bh_enable();
 }
 
-static irqreturn_t mal_txeob(int irq, void *dev_instance, struct pt_regs *regs)
+void mal_poll_del(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+{
+        local_bh_disable();
+        MAL_DBG("%d: poll_del(%p)" NL, mal->def->index, commac);
+        list_del(&commac->poll_list);
+        local_bh_enable();
+}
+
+/* synchronized by mal_poll() */
+static inline void mal_enable_eob_irq(struct ibm_ocp_mal *mal)
+{
+        MAL_DBG2("%d: enable_irq" NL, mal->def->index);
+        set_mal_dcrn(mal, MAL_CFG, get_mal_dcrn(mal, MAL_CFG) | MAL_CFG_EOPIE);
+}
+
+/* synchronized by __LINK_STATE_RX_SCHED bit in ndev->state */
+static inline void mal_disable_eob_irq(struct ibm_ocp_mal *mal)
+{
+        set_mal_dcrn(mal, MAL_CFG, get_mal_dcrn(mal, MAL_CFG) & ~MAL_CFG_EOPIE);
+        MAL_DBG2("%d: disable_irq" NL, mal->def->index);
+}
+
+static irqreturn_t mal_serr(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
-        struct list_head *l;
-        unsigned long isr;
+        u32 esr = get_mal_dcrn(mal, MAL_ESR);
 
-        isr = get_mal_dcrn(mal, DCRN_MALTXEOBISR);
-        set_mal_dcrn(mal, DCRN_MALTXEOBISR, isr);
+        /* Clear the error status register */
+        set_mal_dcrn(mal, MAL_ESR, esr);
 
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        MAL_DBG("%d: SERR %08x" NL, mal->def->index, esr);
 
-                if (isr & mc->tx_chan_mask) {
-                        mc->ops->txeob(mc->dev, isr & mc->tx_chan_mask);
+        if (esr & MAL_ESR_EVB) {
+                if (esr & MAL_ESR_DE) {
+                        /* We ignore Descriptor error,
+                         * TXDE or RXDE interrupt will be generated anyway.
+                         */
+                        return IRQ_HANDLED;
                 }
+
+                if (esr & MAL_ESR_PEIN) {
+                        /* PLB error, it's probably buggy hardware or
+                         * incorrect physical address in BD (i.e. bug)
+                         */
+                        if (net_ratelimit())
+                                printk(KERN_ERR
+                                       "mal%d: system error, PLB (ESR = 0x%08x)\n",
+                                       mal->def->index, esr);
+                        return IRQ_HANDLED;
+                }
+
+                /* OPB error, it's probably buggy hardware or incorrect EBC setup */
+                if (net_ratelimit())
+                        printk(KERN_ERR
+                               "mal%d: system error, OPB (ESR = 0x%08x)\n",
+                               mal->def->index, esr);
         }
-        read_unlock(&mal_list_lock);
+        return IRQ_HANDLED;
+}
+
+static inline void mal_schedule_poll(struct ibm_ocp_mal *mal)
+{
+        if (likely(netif_rx_schedule_prep(&mal->poll_dev))) {
+                MAL_DBG2("%d: schedule_poll" NL, mal->def->index);
+                mal_disable_eob_irq(mal);
+                __netif_rx_schedule(&mal->poll_dev);
+        } else
+                MAL_DBG2("%d: already in poll" NL, mal->def->index);
+}
 
+static irqreturn_t mal_txeob(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ibm_ocp_mal *mal = dev_instance;
+        u32 r = get_mal_dcrn(mal, MAL_TXEOBISR);
+        MAL_DBG2("%d: txeob %08x" NL, mal->def->index, r);
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_TXEOBISR, r);
         return IRQ_HANDLED;
 }
 
 static irqreturn_t mal_rxeob(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
-        struct list_head *l;
-        unsigned long isr;
+        u32 r = get_mal_dcrn(mal, MAL_RXEOBISR);
+        MAL_DBG2("%d: rxeob %08x" NL, mal->def->index, r);
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_RXEOBISR, r);
+        return IRQ_HANDLED;
+}
 
-        isr = get_mal_dcrn(mal, DCRN_MALRXEOBISR);
-        set_mal_dcrn(mal, DCRN_MALRXEOBISR, isr);
+static irqreturn_t mal_txde(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ibm_ocp_mal *mal = dev_instance;
+        u32 deir = get_mal_dcrn(mal, MAL_TXDEIR);
+        set_mal_dcrn(mal, MAL_TXDEIR, deir);
 
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        MAL_DBG("%d: txde %08x" NL, mal->def->index, deir);
 
-                if (isr & mc->rx_chan_mask) {
-                        mc->ops->rxeob(mc->dev, isr & mc->rx_chan_mask);
-                }
-        }
-        read_unlock(&mal_list_lock);
+        if (net_ratelimit())
+                printk(KERN_ERR
+                       "mal%d: TX descriptor error (TXDEIR = 0x%08x)\n",
+                       mal->def->index, deir);
 
         return IRQ_HANDLED;
 }
 
-static irqreturn_t mal_txde(int irq, void *dev_instance, struct pt_regs *regs)
+static irqreturn_t mal_rxde(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
         struct list_head *l;
-        unsigned long deir;
+        u32 deir = get_mal_dcrn(mal, MAL_RXDEIR);
 
-        deir = get_mal_dcrn(mal, DCRN_MALTXDEIR);
+        MAL_DBG("%d: rxde %08x" NL, mal->def->index, deir);
 
-        /* FIXME: print which MAL correctly */
-        printk(KERN_WARNING "%s: Tx descriptor error (MALTXDEIR=%lx)\n",
-               "MAL", deir);
-
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
+        list_for_each(l, &mal->list) {
                 struct mal_commac *mc = list_entry(l, struct mal_commac, list);
-
-                if (deir & mc->tx_chan_mask) {
-                        mc->ops->txde(mc->dev, deir & mc->tx_chan_mask);
+                if (deir & mc->rx_chan_mask) {
+                        mc->rx_stopped = 1;
+                        mc->ops->rxde(mc->dev);
                 }
         }
-        read_unlock(&mal_list_lock);
+
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_RXDEIR, deir);
 
         return IRQ_HANDLED;
 }
 
-/*
- * This interrupt should be very rare at best.  This occurs when
- * the hardware has a problem with the receive descriptors.  The manual
- * states that it occurs when the hardware cannot the receive descriptor
- * empty bit is not set.  The recovery mechanism will be to
- * traverse through the descriptors, handle any that are marked to be
- * handled and reinitialize each along the way.  At that point the driver
- * will be restarted.
- */
-static irqreturn_t mal_rxde(int irq, void *dev_instance, struct pt_regs *regs)
+static int mal_poll(struct net_device *ndev, int *budget)
 {
-        struct ibm_ocp_mal *mal = dev_instance;
+        struct ibm_ocp_mal *mal = ndev->priv;
         struct list_head *l;
-        unsigned long deir;
-
-        deir = get_mal_dcrn(mal, DCRN_MALRXDEIR);
+        int rx_work_limit = min(ndev->quota, *budget), received = 0, done;
+
+        MAL_DBG2("%d: poll(%d) %d ->" NL, mal->def->index, *budget,
+                 rx_work_limit);
+      again:
+        /* Process TX skbs */
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                mc->ops->poll_tx(mc->dev);
+        }
 
-        /*
-         * This really is needed.  This case encountered in stress testing.
+        /* Process RX skbs.
+         * We _might_ need something more smart here to enforce polling fairness.
          */
-        if (deir == 0)
-                return IRQ_HANDLED;
-
-        /* FIXME: print which MAL correctly */
-        printk(KERN_WARNING "%s: Rx descriptor error (MALRXDEIR=%lx)\n",
-               "MAL", deir);
-
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                int n = mc->ops->poll_rx(mc->dev, rx_work_limit);
+                if (n) {
+                        received += n;
+                        rx_work_limit -= n;
+                        if (rx_work_limit <= 0) {
+                                done = 0;
+                                goto more_work; // XXX What if this is the last one ?
+                        }
+                }
+        }
 
-                if (deir & mc->rx_chan_mask) {
-                        mc->ops->rxde(mc->dev, deir & mc->rx_chan_mask);
+        /* We need to disable IRQs to protect from RXDE IRQ here */
+        local_irq_disable();
+        __netif_rx_complete(ndev);
+        mal_enable_eob_irq(mal);
+        local_irq_enable();
+
+        done = 1;
+
+        /* Check for "rotting" packet(s) */
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                if (unlikely(mc->ops->peek_rx(mc->dev) || mc->rx_stopped)) {
+                        MAL_DBG2("%d: rotting packet" NL, mal->def->index);
+                        if (netif_rx_reschedule(ndev, received))
+                                mal_disable_eob_irq(mal);
+                        else
+                                MAL_DBG2("%d: already in poll list" NL,
+                                         mal->def->index);
+
+                        if (rx_work_limit > 0)
+                                goto again;
+                        else
+                                goto more_work;
                 }
+                mc->ops->poll_tx(mc->dev);
         }
-        read_unlock(&mal_list_lock);
 
-        return IRQ_HANDLED;
+      more_work:
+        ndev->quota -= received;
+        *budget -= received;
+
+        MAL_DBG2("%d: poll() %d <- %d" NL, mal->def->index, *budget,
+                 done ? 0 : 1);
+        return done ? 0 : 1;
+}
+
+static void mal_reset(struct ibm_ocp_mal *mal)
+{
+        int n = 10;
+        MAL_DBG("%d: reset" NL, mal->def->index);
+
+        set_mal_dcrn(mal, MAL_CFG, MAL_CFG_SR);
+
+        /* Wait for reset to complete (1 system clock) */
+        while ((get_mal_dcrn(mal, MAL_CFG) & MAL_CFG_SR) && n)
+                --n;
+
+        if (unlikely(!n))
+                printk(KERN_ERR "mal%d: reset timeout\n", mal->def->index);
+}
+
+int mal_get_regs_len(struct ibm_ocp_mal *mal)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct ibm_mal_regs);
+}
+
+void *mal_dump_regs(struct ibm_ocp_mal *mal, void *buf)
+{
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct ibm_mal_regs *regs = (struct ibm_mal_regs *)(hdr + 1);
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        int i;
+
+        hdr->version = MAL_VERSION;
+        hdr->index = mal->def->index;
+
+        regs->tx_count = maldata->num_tx_chans;
+        regs->rx_count = maldata->num_rx_chans;
+
+        regs->cfg = get_mal_dcrn(mal, MAL_CFG);
+        regs->esr = get_mal_dcrn(mal, MAL_ESR);
+        regs->ier = get_mal_dcrn(mal, MAL_IER);
+        regs->tx_casr = get_mal_dcrn(mal, MAL_TXCASR);
+        regs->tx_carr = get_mal_dcrn(mal, MAL_TXCARR);
+        regs->tx_eobisr = get_mal_dcrn(mal, MAL_TXEOBISR);
+        regs->tx_deir = get_mal_dcrn(mal, MAL_TXDEIR);
+        regs->rx_casr = get_mal_dcrn(mal, MAL_RXCASR);
+        regs->rx_carr = get_mal_dcrn(mal, MAL_RXCARR);
+        regs->rx_eobisr = get_mal_dcrn(mal, MAL_RXEOBISR);
+        regs->rx_deir = get_mal_dcrn(mal, MAL_RXDEIR);
+
+        for (i = 0; i < regs->tx_count; ++i)
+                regs->tx_ctpr[i] = get_mal_dcrn(mal, MAL_TXCTPR(i));
+
+        for (i = 0; i < regs->rx_count; ++i) {
+                regs->rx_ctpr[i] = get_mal_dcrn(mal, MAL_RXCTPR(i));
+                regs->rcbs[i] = get_mal_dcrn(mal, MAL_RCBS(i));
+        }
+        return regs + 1;
 }
 
 static int __init mal_probe(struct ocp_device *ocpdev)
 {
-        struct ibm_ocp_mal *mal = NULL;
+        struct ibm_ocp_mal *mal;
         struct ocp_func_mal_data *maldata;
-        int err = 0;
+        int err = 0, i, bd_size;
+
+        MAL_DBG("%d: probe" NL, ocpdev->def->index);
 
-        maldata = (struct ocp_func_mal_data *)ocpdev->def->additions;
+        maldata = ocpdev->def->additions;
         if (maldata == NULL) {
-                printk(KERN_ERR "mal%d: Missing additional datas !\n",
+                printk(KERN_ERR "mal%d: missing additional data!\n",
                        ocpdev->def->index);
                 return -ENODEV;
         }
 
-        mal = kmalloc(sizeof(struct ibm_ocp_mal), GFP_KERNEL);
-        if (mal == NULL) {
+        mal = kzalloc(sizeof(struct ibm_ocp_mal), GFP_KERNEL);
+        if (!mal) {
                 printk(KERN_ERR
-                       "mal%d: Out of memory allocating MAL structure !\n",
+                       "mal%d: out of memory allocating MAL structure!\n",
                        ocpdev->def->index);
                 return -ENOMEM;
         }
-        memset(mal, 0, sizeof(*mal));
-
-        switch (ocpdev->def->index) {
-        case 0:
-                mal->dcrbase = DCRN_MAL_BASE;
-                break;
-#ifdef DCRN_MAL1_BASE
-        case 1:
-                mal->dcrbase = DCRN_MAL1_BASE;
-                break;
-#endif
-        default:
-                BUG();
-        }
-
-        /**************************/
+        mal->dcrbase = maldata->dcr_base;
+        mal->def = ocpdev->def;
 
-        INIT_LIST_HEAD(&mal->commac);
+        INIT_LIST_HEAD(&mal->poll_list);
+        set_bit(__LINK_STATE_START, &mal->poll_dev.state);
+        mal->poll_dev.weight = CONFIG_IBM_EMAC_POLL_WEIGHT;
+        mal->poll_dev.poll = mal_poll;
+        mal->poll_dev.priv = mal;
+        atomic_set(&mal->poll_dev.refcnt, 1);
 
-        set_mal_dcrn(mal, DCRN_MALRXCARR, 0xFFFFFFFF);
-        set_mal_dcrn(mal, DCRN_MALTXCARR, 0xFFFFFFFF);
+        INIT_LIST_HEAD(&mal->list);
 
-        set_mal_dcrn(mal, DCRN_MALCR, MALCR_MMSR);      /* 384 */
-        /* FIXME: Add delay */
+        /* Load power-on reset defaults */
+        mal_reset(mal);
 
         /* Set the MAL configuration register */
-        set_mal_dcrn(mal, DCRN_MALCR,
-                     MALCR_PLBB | MALCR_OPBBL | MALCR_LEA |
-                     MALCR_PLBLT_DEFAULT);
-
-        /* It would be nice to allocate buffers separately for each
-         * channel, but we can't because the channels share the upper
-         * 13 bits of address lines.  Each channels buffer must also
-         * be 4k aligned, so we allocate 4k for each channel.  This is
-         * inefficient FIXME: do better, if possible */
-        mal->tx_virt_addr = dma_alloc_coherent(&ocpdev->dev,
-                                               MAL_DT_ALIGN *
-                                               maldata->num_tx_chans,
-                                               &mal->tx_phys_addr, GFP_KERNEL);
-        if (mal->tx_virt_addr == NULL) {
+        set_mal_dcrn(mal, MAL_CFG, MAL_CFG_DEFAULT | MAL_CFG_PLBB |
+                     MAL_CFG_OPBBL | MAL_CFG_LEA);
+
+        mal_enable_eob_irq(mal);
+
+        /* Allocate space for BD rings */
+        BUG_ON(maldata->num_tx_chans <= 0 || maldata->num_tx_chans > 32);
+        BUG_ON(maldata->num_rx_chans <= 0 || maldata->num_rx_chans > 32);
+        bd_size = sizeof(struct mal_descriptor) *
+            (NUM_TX_BUFF * maldata->num_tx_chans +
+             NUM_RX_BUFF * maldata->num_rx_chans);
+        mal->bd_virt =
+            dma_alloc_coherent(&ocpdev->dev, bd_size, &mal->bd_dma, GFP_KERNEL);
+
+        if (!mal->bd_virt) {
                 printk(KERN_ERR
-                       "mal%d: Out of memory allocating MAL descriptors !\n",
-                       ocpdev->def->index);
+                       "mal%d: out of memory allocating RX/TX descriptors!\n",
+                       mal->def->index);
                 err = -ENOMEM;
                 goto fail;
         }
+        memset(mal->bd_virt, 0, bd_size);
 
-        /* God, oh, god, I hate DCRs */
-        set_mal_dcrn(mal, DCRN_MALTXCTP0R, mal->tx_phys_addr);
-#ifdef DCRN_MALTXCTP1R
-        if (maldata->num_tx_chans > 1)
-                set_mal_dcrn(mal, DCRN_MALTXCTP1R,
-                             mal->tx_phys_addr + MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP1R */
-#ifdef DCRN_MALTXCTP2R
-        if (maldata->num_tx_chans > 2)
-                set_mal_dcrn(mal, DCRN_MALTXCTP2R,
-                             mal->tx_phys_addr + 2 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP2R */
-#ifdef DCRN_MALTXCTP3R
-        if (maldata->num_tx_chans > 3)
-                set_mal_dcrn(mal, DCRN_MALTXCTP3R,
-                             mal->tx_phys_addr + 3 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP3R */
-#ifdef DCRN_MALTXCTP4R
-        if (maldata->num_tx_chans > 4)
-                set_mal_dcrn(mal, DCRN_MALTXCTP4R,
-                             mal->tx_phys_addr + 4 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP4R */
-#ifdef DCRN_MALTXCTP5R
-        if (maldata->num_tx_chans > 5)
-                set_mal_dcrn(mal, DCRN_MALTXCTP5R,
-                             mal->tx_phys_addr + 5 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP5R */
-#ifdef DCRN_MALTXCTP6R
-        if (maldata->num_tx_chans > 6)
-                set_mal_dcrn(mal, DCRN_MALTXCTP6R,
-                             mal->tx_phys_addr + 6 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP6R */
-#ifdef DCRN_MALTXCTP7R
-        if (maldata->num_tx_chans > 7)
-                set_mal_dcrn(mal, DCRN_MALTXCTP7R,
-                             mal->tx_phys_addr + 7 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP7R */
-
-        mal->rx_virt_addr = dma_alloc_coherent(&ocpdev->dev,
-                                               MAL_DT_ALIGN *
-                                               maldata->num_rx_chans,
-                                               &mal->rx_phys_addr, GFP_KERNEL);
-
-        set_mal_dcrn(mal, DCRN_MALRXCTP0R, mal->rx_phys_addr);
-#ifdef DCRN_MALRXCTP1R
-        if (maldata->num_rx_chans > 1)
-                set_mal_dcrn(mal, DCRN_MALRXCTP1R,
-                             mal->rx_phys_addr + MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP1R */
-#ifdef DCRN_MALRXCTP2R
-        if (maldata->num_rx_chans > 2)
-                set_mal_dcrn(mal, DCRN_MALRXCTP2R,
-                             mal->rx_phys_addr + 2 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP2R */
-#ifdef DCRN_MALRXCTP3R
-        if (maldata->num_rx_chans > 3)
-                set_mal_dcrn(mal, DCRN_MALRXCTP3R,
-                             mal->rx_phys_addr + 3 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP3R */
+        for (i = 0; i < maldata->num_tx_chans; ++i)
+                set_mal_dcrn(mal, MAL_TXCTPR(i), mal->bd_dma +
+                             sizeof(struct mal_descriptor) *
+                             mal_tx_bd_offset(mal, i));
+
+        for (i = 0; i < maldata->num_rx_chans; ++i)
+                set_mal_dcrn(mal, MAL_RXCTPR(i), mal->bd_dma +
+                             sizeof(struct mal_descriptor) *
+                             mal_rx_bd_offset(mal, i));
 
         err = request_irq(maldata->serr_irq, mal_serr, 0, "MAL SERR", mal);
         if (err)
-                goto fail;
-        err = request_irq(maldata->txde_irq, mal_txde, 0, "MAL TX DE ", mal);
+                goto fail2;
+        err = request_irq(maldata->txde_irq, mal_txde, 0, "MAL TX DE", mal);
         if (err)
-                goto fail;
+                goto fail3;
         err = request_irq(maldata->txeob_irq, mal_txeob, 0, "MAL TX EOB", mal);
         if (err)
-                goto fail;
+                goto fail4;
         err = request_irq(maldata->rxde_irq, mal_rxde, 0, "MAL RX DE", mal);
         if (err)
-                goto fail;
+                goto fail5;
         err = request_irq(maldata->rxeob_irq, mal_rxeob, 0, "MAL RX EOB", mal);
         if (err)
-                goto fail;
+                goto fail6;
 
-        set_mal_dcrn(mal, DCRN_MALIER,
-                     MALIER_DE | MALIER_NE | MALIER_TE |
-                     MALIER_OPBE | MALIER_PLBE);
+        /* Enable all MAL SERR interrupt sources */
+        set_mal_dcrn(mal, MAL_IER, MAL_IER_EVENTS);
 
-        /* Advertise me to the rest of the world */
+        /* Advertise this instance to the rest of the world */
         ocp_set_drvdata(ocpdev, mal);
 
-        printk(KERN_INFO "mal%d: Initialized, %d tx channels, %d rx channels\n",
-               ocpdev->def->index, maldata->num_tx_chans,
-               maldata->num_rx_chans);
+        mal_dbg_register(mal->def->index, mal);
 
+        printk(KERN_INFO "mal%d: initialized, %d TX channels, %d RX channels\n",
+               mal->def->index, maldata->num_tx_chans, maldata->num_rx_chans);
         return 0;
 
+      fail6:
+        free_irq(maldata->rxde_irq, mal);
+      fail5:
+        free_irq(maldata->txeob_irq, mal);
+      fail4:
+        free_irq(maldata->txde_irq, mal);
+      fail3:
+        free_irq(maldata->serr_irq, mal);
+      fail2:
+        dma_free_coherent(&ocpdev->dev, bd_size, mal->bd_virt, mal->bd_dma);
       fail:
-        /* FIXME: dispose requested IRQs ! */
-        if (err && mal)
-                kfree(mal);
+        kfree(mal);
         return err;
 }
 
 static void __exit mal_remove(struct ocp_device *ocpdev)
 {
         struct ibm_ocp_mal *mal = ocp_get_drvdata(ocpdev);
-        struct ocp_func_mal_data *maldata = ocpdev->def->additions;
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+
+        MAL_DBG("%d: remove" NL, mal->def->index);
 
-        BUG_ON(!maldata);
+        /* Syncronize with scheduled polling, 
+           stolen from net/core/dev.c:dev_close() 
+         */
+        clear_bit(__LINK_STATE_START, &mal->poll_dev.state);
+        netif_poll_disable(&mal->poll_dev);
+
+        if (!list_empty(&mal->list)) {
+                /* This is *very* bad */
+                printk(KERN_EMERG
+                       "mal%d: commac list is not empty on remove!\n",
+                       mal->def->index);
+        }
 
         ocp_set_drvdata(ocpdev, NULL);
 
-        /* FIXME: shut down the MAL, deal with dependency with emac */
         free_irq(maldata->serr_irq, mal);
         free_irq(maldata->txde_irq, mal);
         free_irq(maldata->txeob_irq, mal);
         free_irq(maldata->rxde_irq, mal);
         free_irq(maldata->rxeob_irq, mal);
 
-        if (mal->tx_virt_addr)
-                dma_free_coherent(&ocpdev->dev,
-                                  MAL_DT_ALIGN * maldata->num_tx_chans,
-                                  mal->tx_virt_addr, mal->tx_phys_addr);
+        mal_reset(mal);
 
-        if (mal->rx_virt_addr)
-                dma_free_coherent(&ocpdev->dev,
-                                  MAL_DT_ALIGN * maldata->num_rx_chans,
-                                  mal->rx_virt_addr, mal->rx_phys_addr);
+        mal_dbg_register(mal->def->index, NULL);
+
+        dma_free_coherent(&ocpdev->dev,
+                          sizeof(struct mal_descriptor) *
+                          (NUM_TX_BUFF * maldata->num_tx_chans +
+                           NUM_RX_BUFF * maldata->num_rx_chans), mal->bd_virt,
+                          mal->bd_dma);
 
         kfree(mal);
 }
 
 /* Structure for a device driver */
 static struct ocp_device_id mal_ids[] = {
-        {.vendor = OCP_ANY_ID,.function = OCP_FUNC_MAL},
-        {.vendor = OCP_VENDOR_INVALID}
+        { .vendor = OCP_VENDOR_IBM, .function = OCP_FUNC_MAL },
+        { .vendor = OCP_VENDOR_INVALID}
 };
 
 static struct ocp_driver mal_driver = {
@@ -441,23 +570,14 @@ static struct ocp_driver mal_driver = {
         .remove = mal_remove,
 };
 
-static int __init init_mals(void)
+int __init mal_init(void)
 {
-        int rc;
-
-        rc = ocp_register_driver(&mal_driver);
-        if (rc < 0) {
-                ocp_unregister_driver(&mal_driver);
-                return -ENODEV;
-        }
-
-        return 0;
+        MAL_DBG(": init" NL);
+        return ocp_register_driver(&mal_driver);
 }
 
-static void __exit exit_mals(void)
+void __exit mal_exit(void)
 {
+        MAL_DBG(": exit" NL);
         ocp_unregister_driver(&mal_driver);
 }
-
-module_init(init_mals);
-module_exit(exit_mals);
diff --git a/drivers/net/ibm_emac/ibm_emac_mal.h b/drivers/net/ibm_emac/ibm_emac_mal.h
index dd9f0dabc6e0..15b0bdae26ac 100644
--- a/drivers/net/ibm_emac/ibm_emac_mal.h
+++ b/drivers/net/ibm_emac/ibm_emac_mal.h
@@ -1,131 +1,267 @@
-#ifndef _IBM_EMAC_MAL_H
-#define _IBM_EMAC_MAL_H
+/*
+ * drivers/net/ibm_emac/ibm_emac_mal.h
+ *
+ * Memory Access Layer (MAL) support
+ * 
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002 MontaVista Softare Inc.
+ *
+ * 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.
+ *
+ */
+#ifndef __IBM_EMAC_MAL_H_
+#define __IBM_EMAC_MAL_H_
 
+#include <linux/config.h>
+#include <linux/init.h>
 #include <linux/list.h>
+#include <linux/netdevice.h>
 
-#define MAL_DT_ALIGN    (4096)  /* Alignment for each channel's descriptor table */
+#include <asm/io.h>
 
-#define MAL_CHAN_MASK(chan)     (0x80000000 >> (chan))
+/*
+ * These MAL "versions" probably aren't the real versions IBM uses for these 
+ * MAL cores, I assigned them just to make #ifdefs in this file nicer and 
+ * reflect the fact that 40x and 44x have slightly different MALs. --ebs
+ */
+#if defined(CONFIG_405GP) || defined(CONFIG_405GPR) || defined(CONFIG_405EP) || \
+    defined(CONFIG_440EP) || defined(CONFIG_NP405H)
+#define MAL_VERSION             1
+#elif defined(CONFIG_440GP) || defined(CONFIG_440GX) || defined(CONFIG_440SP)
+#define MAL_VERSION             2
+#else
+#error "Unknown SoC, please check chip manual and choose MAL 'version'"
+#endif
+
+/* MALx DCR registers */
+#define MAL_CFG                 0x00
+#define   MAL_CFG_SR            0x80000000
+#define   MAL_CFG_PLBB          0x00004000
+#define   MAL_CFG_OPBBL         0x00000080
+#define   MAL_CFG_EOPIE         0x00000004
+#define   MAL_CFG_LEA           0x00000002
+#define   MAL_CFG_SD            0x00000001
+#if MAL_VERSION == 1
+#define   MAL_CFG_PLBP_MASK     0x00c00000
+#define   MAL_CFG_PLBP_10       0x00800000
+#define   MAL_CFG_GA            0x00200000
+#define   MAL_CFG_OA            0x00100000
+#define   MAL_CFG_PLBLE         0x00080000
+#define   MAL_CFG_PLBT_MASK     0x00078000
+#define   MAL_CFG_DEFAULT       (MAL_CFG_PLBP_10 | MAL_CFG_PLBT_MASK)
+#elif MAL_VERSION == 2
+#define   MAL_CFG_RPP_MASK      0x00c00000
+#define   MAL_CFG_RPP_10        0x00800000
+#define   MAL_CFG_RMBS_MASK     0x00300000
+#define   MAL_CFG_WPP_MASK      0x000c0000
+#define   MAL_CFG_WPP_10        0x00080000
+#define   MAL_CFG_WMBS_MASK     0x00030000
+#define   MAL_CFG_PLBLE         0x00008000
+#define   MAL_CFG_DEFAULT       (MAL_CFG_RMBS_MASK | MAL_CFG_WMBS_MASK | \
+                                 MAL_CFG_RPP_10 | MAL_CFG_WPP_10)
+#else
+#error "Unknown MAL version"
+#endif
+
+#define MAL_ESR                 0x01
+#define   MAL_ESR_EVB           0x80000000
+#define   MAL_ESR_CIDT          0x40000000
+#define   MAL_ESR_CID_MASK      0x3e000000
+#define   MAL_ESR_CID_SHIFT     25
+#define   MAL_ESR_DE            0x00100000
+#define   MAL_ESR_OTE           0x00040000
+#define   MAL_ESR_OSE           0x00020000
+#define   MAL_ESR_PEIN          0x00010000
+#define   MAL_ESR_DEI           0x00000010
+#define   MAL_ESR_OTEI          0x00000004
+#define   MAL_ESR_OSEI          0x00000002
+#define   MAL_ESR_PBEI          0x00000001
+#if MAL_VERSION == 1
+#define   MAL_ESR_ONE           0x00080000
+#define   MAL_ESR_ONEI          0x00000008
+#elif MAL_VERSION == 2
+#define   MAL_ESR_PTE           0x00800000
+#define   MAL_ESR_PRE           0x00400000
+#define   MAL_ESR_PWE           0x00200000
+#define   MAL_ESR_PTEI          0x00000080
+#define   MAL_ESR_PREI          0x00000040
+#define   MAL_ESR_PWEI          0x00000020
+#else
+#error "Unknown MAL version"
+#endif
+
+#define MAL_IER                 0x02
+#define   MAL_IER_DE            0x00000010
+#define   MAL_IER_OTE           0x00000004
+#define   MAL_IER_OE            0x00000002
+#define   MAL_IER_PE            0x00000001
+#if MAL_VERSION == 1
+#define   MAL_IER_NWE           0x00000008
+#define   MAL_IER_SOC_EVENTS    MAL_IER_NWE
+#elif MAL_VERSION == 2
+#define   MAL_IER_PT            0x00000080
+#define   MAL_IER_PRE           0x00000040
+#define   MAL_IER_PWE           0x00000020
+#define   MAL_IER_SOC_EVENTS    (MAL_IER_PT | MAL_IER_PRE | MAL_IER_PWE)
+#else
+#error "Unknown MAL version"
+#endif
+#define   MAL_IER_EVENTS        (MAL_IER_SOC_EVENTS | MAL_IER_OTE | \
+                                 MAL_IER_OTE | MAL_IER_OE | MAL_IER_PE)
+
+#define MAL_TXCASR              0x04
+#define MAL_TXCARR              0x05
+#define MAL_TXEOBISR            0x06
+#define MAL_TXDEIR              0x07
+#define MAL_RXCASR              0x10
+#define MAL_RXCARR              0x11
+#define MAL_RXEOBISR            0x12
+#define MAL_RXDEIR              0x13
+#define MAL_TXCTPR(n)           ((n) + 0x20)
+#define MAL_RXCTPR(n)           ((n) + 0x40)
+#define MAL_RCBS(n)             ((n) + 0x60)
+
+/* In reality MAL can handle TX buffers up to 4095 bytes long, 
+ * but this isn't a good round number :)                 --ebs
+ */
+#define MAL_MAX_TX_SIZE         4080
+#define MAL_MAX_RX_SIZE         4080
+
+static inline int mal_rx_size(int len)
+{
+        len = (len + 0xf) & ~0xf;
+        return len > MAL_MAX_RX_SIZE ? MAL_MAX_RX_SIZE : len;
+}
+
+static inline int mal_tx_chunks(int len)
+{
+        return (len + MAL_MAX_TX_SIZE - 1) / MAL_MAX_TX_SIZE;
+}
+
+#define MAL_CHAN_MASK(n)        (0x80000000 >> (n))
 
 /* MAL Buffer Descriptor structure */
 struct mal_descriptor {
-        unsigned short ctrl;    /* MAL / Commac status control bits */
-        short data_len;         /* Max length is 4K-1 (12 bits)     */
-        unsigned char *data_ptr;        /* pointer to actual data buffer    */
-} __attribute__ ((packed));
+        u16 ctrl;               /* MAL / Commac status control bits */
+        u16 data_len;           /* Max length is 4K-1 (12 bits)     */
+        u32 data_ptr;           /* pointer to actual data buffer    */
+};
 
 /* the following defines are for the MadMAL status and control registers. */
 /* MADMAL transmit and receive status/control bits  */
-#define MAL_RX_CTRL_EMPTY               0x8000
-#define MAL_RX_CTRL_WRAP                0x4000
-#define MAL_RX_CTRL_CM                  0x2000
-#define MAL_RX_CTRL_LAST                0x1000
-#define MAL_RX_CTRL_FIRST               0x0800
-#define MAL_RX_CTRL_INTR                0x0400
-
-#define MAL_TX_CTRL_READY               0x8000
-#define MAL_TX_CTRL_WRAP                0x4000
-#define MAL_TX_CTRL_CM                  0x2000
-#define MAL_TX_CTRL_LAST                0x1000
-#define MAL_TX_CTRL_INTR                0x0400
+#define MAL_RX_CTRL_EMPTY       0x8000
+#define MAL_RX_CTRL_WRAP        0x4000
+#define MAL_RX_CTRL_CM          0x2000
+#define MAL_RX_CTRL_LAST        0x1000
+#define MAL_RX_CTRL_FIRST       0x0800
+#define MAL_RX_CTRL_INTR        0x0400
+#define MAL_RX_CTRL_SINGLE      (MAL_RX_CTRL_LAST | MAL_RX_CTRL_FIRST)
+#define MAL_IS_SINGLE_RX(ctrl)  (((ctrl) & MAL_RX_CTRL_SINGLE) == MAL_RX_CTRL_SINGLE)
+
+#define MAL_TX_CTRL_READY       0x8000
+#define MAL_TX_CTRL_WRAP        0x4000
+#define MAL_TX_CTRL_CM          0x2000
+#define MAL_TX_CTRL_LAST        0x1000
+#define MAL_TX_CTRL_INTR        0x0400
 
 struct mal_commac_ops {
-        void (*txeob) (void *dev, u32 chanmask);
-        void (*txde) (void *dev, u32 chanmask);
-        void (*rxeob) (void *dev, u32 chanmask);
-        void (*rxde) (void *dev, u32 chanmask);
+        void    (*poll_tx) (void *dev);
+        int     (*poll_rx) (void *dev, int budget);
+        int     (*peek_rx) (void *dev);
+        void    (*rxde) (void *dev);
 };
 
 struct mal_commac {
-        struct mal_commac_ops *ops;
-        void *dev;
-        u32 tx_chan_mask, rx_chan_mask;
-        struct list_head list;
+        struct mal_commac_ops   *ops;
+        void                    *dev;
+        struct list_head        poll_list;
+        int                     rx_stopped;
+
+        u32                     tx_chan_mask;
+        u32                     rx_chan_mask;
+        struct list_head        list;
 };
 
 struct ibm_ocp_mal {
-        int dcrbase;
+        int                     dcrbase;
 
-        struct list_head commac;
-        u32 tx_chan_mask, rx_chan_mask;
+        struct list_head        poll_list;
+        struct net_device       poll_dev;
 
-        dma_addr_t tx_phys_addr;
-        struct mal_descriptor *tx_virt_addr;
+        struct list_head        list;
+        u32                     tx_chan_mask;
+        u32                     rx_chan_mask;
 
-        dma_addr_t rx_phys_addr;
-        struct mal_descriptor *rx_virt_addr;
-};
+        dma_addr_t              bd_dma;
+        struct mal_descriptor   *bd_virt;
 
-#define GET_MAL_STANZA(base,dcrn) \
-        case base: \
-                x = mfdcr(dcrn(base)); \
-                break;
-
-#define SET_MAL_STANZA(base,dcrn, val) \
-        case base: \
-                mtdcr(dcrn(base), (val)); \
-                break;
-
-#define GET_MAL0_STANZA(dcrn) GET_MAL_STANZA(DCRN_MAL_BASE,dcrn)
-#define SET_MAL0_STANZA(dcrn,val) SET_MAL_STANZA(DCRN_MAL_BASE,dcrn,val)
-
-#ifdef DCRN_MAL1_BASE
-#define GET_MAL1_STANZA(dcrn) GET_MAL_STANZA(DCRN_MAL1_BASE,dcrn)
-#define SET_MAL1_STANZA(dcrn,val) SET_MAL_STANZA(DCRN_MAL1_BASE,dcrn,val)
-#else                           /* ! DCRN_MAL1_BASE */
-#define GET_MAL1_STANZA(dcrn)
-#define SET_MAL1_STANZA(dcrn,val)
-#endif
+        struct ocp_def          *def;
+};
 
-#define get_mal_dcrn(mal, dcrn) ({ \
-        u32 x; \
-        switch ((mal)->dcrbase) { \
-                GET_MAL0_STANZA(dcrn) \
-                GET_MAL1_STANZA(dcrn) \
-        default: \
-                x = 0; \
-                BUG(); \
-        } \
-x; })
-
-#define set_mal_dcrn(mal, dcrn, val) do { \
-        switch ((mal)->dcrbase) { \
-                SET_MAL0_STANZA(dcrn,val) \
-                SET_MAL1_STANZA(dcrn,val) \
-        default: \
-                BUG(); \
-        } } while (0)
-
-static inline void mal_enable_tx_channels(struct ibm_ocp_mal *mal, u32 chanmask)
+static inline u32 get_mal_dcrn(struct ibm_ocp_mal *mal, int reg)
 {
-        set_mal_dcrn(mal, DCRN_MALTXCASR,
-                     get_mal_dcrn(mal, DCRN_MALTXCASR) | chanmask);
+        return mfdcr(mal->dcrbase + reg);
 }
 
-static inline void mal_disable_tx_channels(struct ibm_ocp_mal *mal,
-                                           u32 chanmask)
+static inline void set_mal_dcrn(struct ibm_ocp_mal *mal, int reg, u32 val)
 {
-        set_mal_dcrn(mal, DCRN_MALTXCARR, chanmask);
+        mtdcr(mal->dcrbase + reg, val);
 }
 
-static inline void mal_enable_rx_channels(struct ibm_ocp_mal *mal, u32 chanmask)
-{
-        set_mal_dcrn(mal, DCRN_MALRXCASR,
-                     get_mal_dcrn(mal, DCRN_MALRXCASR) | chanmask);
-}
+/* Register MAL devices */
+int mal_init(void) __init;
+void mal_exit(void) __exit;
 
-static inline void mal_disable_rx_channels(struct ibm_ocp_mal *mal,
-                                           u32 chanmask)
-{
-        set_mal_dcrn(mal, DCRN_MALRXCARR, chanmask);
-}
+int mal_register_commac(struct ibm_ocp_mal *mal,
+                        struct mal_commac *commac) __init;
+void mal_unregister_commac(struct ibm_ocp_mal *mal,
+                           struct mal_commac *commac) __exit;
+int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel, unsigned long size);
+
+/* Returns BD ring offset for a particular channel
+   (in 'struct mal_descriptor' elements)
+*/
+int mal_tx_bd_offset(struct ibm_ocp_mal *mal, int channel);
+int mal_rx_bd_offset(struct ibm_ocp_mal *mal, int channel);
+
+void mal_enable_tx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_disable_tx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_enable_rx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_disable_rx_channel(struct ibm_ocp_mal *mal, int channel);
 
-extern int mal_register_commac(struct ibm_ocp_mal *mal,
-                               struct mal_commac *commac);
-extern int mal_unregister_commac(struct ibm_ocp_mal *mal,
-                                 struct mal_commac *commac);
+/* Add/remove EMAC to/from MAL polling list */
+void mal_poll_add(struct ibm_ocp_mal *mal, struct mal_commac *commac);
+void mal_poll_del(struct ibm_ocp_mal *mal, struct mal_commac *commac);
+
+/* Ethtool MAL registers */
+struct ibm_mal_regs {
+        u32 tx_count;
+        u32 rx_count;
+
+        u32 cfg;
+        u32 esr;
+        u32 ier;
+        u32 tx_casr;
+        u32 tx_carr;
+        u32 tx_eobisr;
+        u32 tx_deir;
+        u32 rx_casr;
+        u32 rx_carr;
+        u32 rx_eobisr;
+        u32 rx_deir;
+        u32 tx_ctpr[32];
+        u32 rx_ctpr[32];
+        u32 rcbs[32];
+};
 
-extern int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel,
-                        unsigned long size);
+int mal_get_regs_len(struct ibm_ocp_mal *mal);
+void *mal_dump_regs(struct ibm_ocp_mal *mal, void *buf);
 
-#endif                          /* _IBM_EMAC_MAL_H */
+#endif                          /* __IBM_EMAC_MAL_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_phy.c b/drivers/net/ibm_emac/ibm_emac_phy.c
index 14213f090e91..a27e49cfe43b 100644
--- a/drivers/net/ibm_emac/ibm_emac_phy.c
+++ b/drivers/net/ibm_emac/ibm_emac_phy.c
@@ -1,96 +1,80 @@
 /*
- * ibm_ocp_phy.c
+ * drivers/net/ibm_emac/ibm_emac_phy.c
  *
- * PHY drivers for the ibm ocp ethernet driver. Borrowed
- * from sungem_phy.c, though I only kept the generic MII
+ * Driver for PowerPC 4xx on-chip ethernet controller, PHY support.
+ * Borrowed from sungem_phy.c, though I only kept the generic MII
  * driver for now.
  * 
  * This file should be shared with other drivers or eventually
  * merged as the "low level" part of miilib
  * 
  * (c) 2003, Benjamin Herrenscmidt (benh@kernel.crashing.org)
+ * (c) 2004-2005, Eugene Surovegin <ebs@ebshome.net>
  *
  */
-
 #include <linux/config.h>
-
 #include <linux/module.h>
-
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/types.h>
 #include <linux/netdevice.h>
-#include <linux/etherdevice.h>
 #include <linux/mii.h>
 #include <linux/ethtool.h>
 #include <linux/delay.h>
 
+#include <asm/ocp.h>
+
 #include "ibm_emac_phy.h"
 
-static int reset_one_mii_phy(struct mii_phy *phy, int phy_id)
+static inline int phy_read(struct mii_phy *phy, int reg)
+{
+        return phy->mdio_read(phy->dev, phy->address, reg);
+}
+
+static inline void phy_write(struct mii_phy *phy, int reg, int val)
 {
-        u16 val;
+        phy->mdio_write(phy->dev, phy->address, reg, val);
+}
+
+int mii_reset_phy(struct mii_phy *phy)
+{
+        int val;
         int limit = 10000;
 
-        val = __phy_read(phy, phy_id, MII_BMCR);
+        val = phy_read(phy, MII_BMCR);
         val &= ~BMCR_ISOLATE;
         val |= BMCR_RESET;
-        __phy_write(phy, phy_id, MII_BMCR, val);
+        phy_write(phy, MII_BMCR, val);
 
-        udelay(100);
+        udelay(300);
 
         while (limit--) {
-                val = __phy_read(phy, phy_id, MII_BMCR);
-                if ((val & BMCR_RESET) == 0)
+                val = phy_read(phy, MII_BMCR);
+                if (val >= 0 && (val & BMCR_RESET) == 0)
                         break;
                 udelay(10);
         }
         if ((val & BMCR_ISOLATE) && limit > 0)
-                __phy_write(phy, phy_id, MII_BMCR, val & ~BMCR_ISOLATE);
-
-        return (limit <= 0);
-}
-
-static int cis8201_init(struct mii_phy *phy)
-{
-        u16 epcr;
-
-        epcr = phy_read(phy, MII_CIS8201_EPCR);
-        epcr &= ~EPCR_MODE_MASK;
-
-        switch (phy->mode) {
-        case PHY_MODE_TBI:
-                epcr |= EPCR_TBI_MODE;
-                break;
-        case PHY_MODE_RTBI:
-                epcr |= EPCR_RTBI_MODE;
-                break;
-        case PHY_MODE_GMII:
-                epcr |= EPCR_GMII_MODE;
-                break;
-        case PHY_MODE_RGMII:
-        default:
-                epcr |= EPCR_RGMII_MODE;
-        }
+                phy_write(phy, MII_BMCR, val & ~BMCR_ISOLATE);
 
-        phy_write(phy, MII_CIS8201_EPCR, epcr);
-
-        return 0;
+        return limit <= 0;
 }
 
 static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
 {
-        u16 ctl, adv;
+        int ctl, adv;
 
-        phy->autoneg = 1;
+        phy->autoneg = AUTONEG_ENABLE;
         phy->speed = SPEED_10;
         phy->duplex = DUPLEX_HALF;
-        phy->pause = 0;
+        phy->pause = phy->asym_pause = 0;
         phy->advertising = advertise;
 
         /* Setup standard advertise */
         adv = phy_read(phy, MII_ADVERTISE);
-        adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
+        if (adv < 0)
+                return adv;
+        adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
+                 ADVERTISE_PAUSE_ASYM);
         if (advertise & ADVERTISED_10baseT_Half)
                 adv |= ADVERTISE_10HALF;
         if (advertise & ADVERTISED_10baseT_Full)
@@ -99,8 +83,25 @@ static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
                 adv |= ADVERTISE_100HALF;
         if (advertise & ADVERTISED_100baseT_Full)
                 adv |= ADVERTISE_100FULL;
+        if (advertise & ADVERTISED_Pause)
+                adv |= ADVERTISE_PAUSE_CAP;
+        if (advertise & ADVERTISED_Asym_Pause)
+                adv |= ADVERTISE_PAUSE_ASYM;
         phy_write(phy, MII_ADVERTISE, adv);
 
+        if (phy->features &
+            (SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half)) {
+                adv = phy_read(phy, MII_CTRL1000);
+                if (adv < 0)
+                        return adv;
+                adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
+                if (advertise & ADVERTISED_1000baseT_Full)
+                        adv |= ADVERTISE_1000FULL;
+                if (advertise & ADVERTISED_1000baseT_Half)
+                        adv |= ADVERTISE_1000HALF;
+                phy_write(phy, MII_CTRL1000, adv);
+        }
+
         /* Start/Restart aneg */
         ctl = phy_read(phy, MII_BMCR);
         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
@@ -111,14 +112,16 @@ static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
 
 static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
 {
-        u16 ctl;
+        int ctl;
 
-        phy->autoneg = 0;
+        phy->autoneg = AUTONEG_DISABLE;
         phy->speed = speed;
         phy->duplex = fd;
-        phy->pause = 0;
+        phy->pause = phy->asym_pause = 0;
 
         ctl = phy_read(phy, MII_BMCR);
+        if (ctl < 0)
+                return ctl;
         ctl &= ~(BMCR_FULLDPLX | BMCR_SPEED100 | BMCR_ANENABLE);
 
         /* First reset the PHY */
@@ -132,6 +135,8 @@ static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
                 ctl |= BMCR_SPEED100;
                 break;
         case SPEED_1000:
+                ctl |= BMCR_SPEED1000;
+                break;
         default:
                 return -EINVAL;
         }
@@ -144,112 +149,143 @@ static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
 
 static int genmii_poll_link(struct mii_phy *phy)
 {
-        u16 status;
+        int status;
 
-        (void)phy_read(phy, MII_BMSR);
+        /* Clear latched value with dummy read */
+        phy_read(phy, MII_BMSR);
         status = phy_read(phy, MII_BMSR);
-        if ((status & BMSR_LSTATUS) == 0)
+        if (status < 0 || (status & BMSR_LSTATUS) == 0)
                 return 0;
-        if (phy->autoneg && !(status & BMSR_ANEGCOMPLETE))
+        if (phy->autoneg == AUTONEG_ENABLE && !(status & BMSR_ANEGCOMPLETE))
                 return 0;
         return 1;
 }
 
-#define MII_CIS8201_ACSR        0x1c
-#define  ACSR_DUPLEX_STATUS     0x0020
-#define  ACSR_SPEED_1000BASET   0x0010
-#define  ACSR_SPEED_100BASET    0x0008
-
-static int cis8201_read_link(struct mii_phy *phy)
+static int genmii_read_link(struct mii_phy *phy)
 {
-        u16 acsr;
+        if (phy->autoneg == AUTONEG_ENABLE) {
+                int glpa = 0;
+                int lpa = phy_read(phy, MII_LPA) & phy_read(phy, MII_ADVERTISE);
+                if (lpa < 0)
+                        return lpa;
+
+                if (phy->features &
+                    (SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half)) {
+                        int adv = phy_read(phy, MII_CTRL1000);
+                        glpa = phy_read(phy, MII_STAT1000);
+
+                        if (glpa < 0 || adv < 0)
+                                return adv;
+
+                        glpa &= adv << 2;
+                }
+
+                phy->speed = SPEED_10;
+                phy->duplex = DUPLEX_HALF;
+                phy->pause = phy->asym_pause = 0;
+
+                if (glpa & (LPA_1000FULL | LPA_1000HALF)) {
+                        phy->speed = SPEED_1000;
+                        if (glpa & LPA_1000FULL)
+                                phy->duplex = DUPLEX_FULL;
+                } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
+                        phy->speed = SPEED_100;
+                        if (lpa & LPA_100FULL)
+                                phy->duplex = DUPLEX_FULL;
+                } else if (lpa & LPA_10FULL)
+                        phy->duplex = DUPLEX_FULL;
 
-        if (phy->autoneg) {
-                acsr = phy_read(phy, MII_CIS8201_ACSR);
+                if (phy->duplex == DUPLEX_FULL) {
+                        phy->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
+                        phy->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
+                }
+        } else {
+                int bmcr = phy_read(phy, MII_BMCR);
+                if (bmcr < 0)
+                        return bmcr;
 
-                if (acsr & ACSR_DUPLEX_STATUS)
+                if (bmcr & BMCR_FULLDPLX)
                         phy->duplex = DUPLEX_FULL;
                 else
                         phy->duplex = DUPLEX_HALF;
-                if (acsr & ACSR_SPEED_1000BASET) {
+                if (bmcr & BMCR_SPEED1000)
                         phy->speed = SPEED_1000;
-                } else if (acsr & ACSR_SPEED_100BASET)
+                else if (bmcr & BMCR_SPEED100)
                         phy->speed = SPEED_100;
                 else
                         phy->speed = SPEED_10;
-                phy->pause = 0;
-        }
-        /* On non-aneg, we assume what we put in BMCR is the speed,
-         * though magic-aneg shouldn't prevent this case from occurring
-         */
 
+                phy->pause = phy->asym_pause = 0;
+        }
         return 0;
 }
 
-static int genmii_read_link(struct mii_phy *phy)
+/* Generic implementation for most 10/100/1000 PHYs */
+static struct mii_phy_ops generic_phy_ops = {
+        .setup_aneg     = genmii_setup_aneg,
+        .setup_forced   = genmii_setup_forced,
+        .poll_link      = genmii_poll_link,
+        .read_link      = genmii_read_link
+};
+
+static struct mii_phy_def genmii_phy_def = {
+        .phy_id         = 0x00000000,
+        .phy_id_mask    = 0x00000000,
+        .name           = "Generic MII",
+        .ops            = &generic_phy_ops
+};
+
+/* CIS8201 */
+#define MII_CIS8201_EPCR        0x17
+#define  EPCR_MODE_MASK         0x3000
+#define  EPCR_GMII_MODE         0x0000
+#define  EPCR_RGMII_MODE        0x1000
+#define  EPCR_TBI_MODE          0x2000
+#define  EPCR_RTBI_MODE         0x3000
+
+static int cis8201_init(struct mii_phy *phy)
 {
-        u16 lpa;
+        int epcr;
 
-        if (phy->autoneg) {
-                lpa = phy_read(phy, MII_LPA) & phy_read(phy, MII_ADVERTISE);
+        epcr = phy_read(phy, MII_CIS8201_EPCR);
+        if (epcr < 0)
+                return epcr;
 
-                phy->speed = SPEED_10;
-                phy->duplex = DUPLEX_HALF;
-                phy->pause = 0;
+        epcr &= ~EPCR_MODE_MASK;
 
-                if (lpa & (LPA_100FULL | LPA_100HALF)) {
-                        phy->speed = SPEED_100;
-                        if (lpa & LPA_100FULL)
-                                phy->duplex = DUPLEX_FULL;
-                } else if (lpa & LPA_10FULL)
-                        phy->duplex = DUPLEX_FULL;
+        switch (phy->mode) {
+        case PHY_MODE_TBI:
+                epcr |= EPCR_TBI_MODE;
+                break;
+        case PHY_MODE_RTBI:
+                epcr |= EPCR_RTBI_MODE;
+                break;
+        case PHY_MODE_GMII:
+                epcr |= EPCR_GMII_MODE;
+                break;
+        case PHY_MODE_RGMII:
+        default:
+                epcr |= EPCR_RGMII_MODE;
         }
-        /* On non-aneg, we assume what we put in BMCR is the speed,
-         * though magic-aneg shouldn't prevent this case from occurring
-         */
+
+        phy_write(phy, MII_CIS8201_EPCR, epcr);
 
         return 0;
 }
 
-#define MII_BASIC_FEATURES      (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \
-                                 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \
-                                 SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII)
-#define MII_GBIT_FEATURES       (MII_BASIC_FEATURES | \
-                                 SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full)
-
-/* CIS8201 phy ops */
 static struct mii_phy_ops cis8201_phy_ops = {
-        init:cis8201_init,
-        setup_aneg:genmii_setup_aneg,
-        setup_forced:genmii_setup_forced,
-        poll_link:genmii_poll_link,
-        read_link:cis8201_read_link
-};
-
-/* Generic implementation for most 10/100 PHYs */
-static struct mii_phy_ops generic_phy_ops = {
-        setup_aneg:genmii_setup_aneg,
-        setup_forced:genmii_setup_forced,
-        poll_link:genmii_poll_link,
-        read_link:genmii_read_link
+        .init           = cis8201_init,
+        .setup_aneg     = genmii_setup_aneg,
+        .setup_forced   = genmii_setup_forced,
+        .poll_link      = genmii_poll_link,
+        .read_link      = genmii_read_link
 };
 
 static struct mii_phy_def cis8201_phy_def = {
-        phy_id:0x000fc410,
-        phy_id_mask:0x000ffff0,
-        name:"CIS8201 Gigabit Ethernet",
-        features:MII_GBIT_FEATURES,
-        magic_aneg:0,
-        ops:&cis8201_phy_ops
-};
-
-static struct mii_phy_def genmii_phy_def = {
-        phy_id:0x00000000,
-        phy_id_mask:0x00000000,
-        name:"Generic MII",
-        features:MII_BASIC_FEATURES,
-        magic_aneg:0,
-        ops:&generic_phy_ops
+        .phy_id         = 0x000fc410,
+        .phy_id_mask    = 0x000ffff0,
+        .name           = "CIS8201 Gigabit Ethernet",
+        .ops            = &cis8201_phy_ops
 };
 
 static struct mii_phy_def *mii_phy_table[] = {
@@ -258,39 +294,60 @@ static struct mii_phy_def *mii_phy_table[] = {
         NULL
 };
 
-int mii_phy_probe(struct mii_phy *phy, int mii_id)
+int mii_phy_probe(struct mii_phy *phy, int address)
 {
-        int rc;
-        u32 id;
         struct mii_phy_def *def;
         int i;
+        u32 id;
 
-        phy->autoneg = 0;
+        phy->autoneg = AUTONEG_DISABLE;
         phy->advertising = 0;
-        phy->mii_id = mii_id;
-        phy->speed = 0;
-        phy->duplex = 0;
-        phy->pause = 0;
-
-        /* Take PHY out of isloate mode and reset it. */
-        rc = reset_one_mii_phy(phy, mii_id);
-        if (rc)
+        phy->address = address;
+        phy->speed = SPEED_10;
+        phy->duplex = DUPLEX_HALF;
+        phy->pause = phy->asym_pause = 0;
+
+        /* Take PHY out of isolate mode and reset it. */
+        if (mii_reset_phy(phy))
                 return -ENODEV;
 
         /* Read ID and find matching entry */
-        id = (phy_read(phy, MII_PHYSID1) << 16 | phy_read(phy, MII_PHYSID2))
-            & 0xfffffff0;
+        id = (phy_read(phy, MII_PHYSID1) << 16) | phy_read(phy, MII_PHYSID2);
         for (i = 0; (def = mii_phy_table[i]) != NULL; i++)
                 if ((id & def->phy_id_mask) == def->phy_id)
                         break;
         /* Should never be NULL (we have a generic entry), but... */
-        if (def == NULL)
+        if (!def)
                 return -ENODEV;
 
         phy->def = def;
 
+        /* Determine PHY features if needed */
+        phy->features = def->features;
+        if (!phy->features) {
+                u16 bmsr = phy_read(phy, MII_BMSR);
+                if (bmsr & BMSR_ANEGCAPABLE)
+                        phy->features |= SUPPORTED_Autoneg;
+                if (bmsr & BMSR_10HALF)
+                        phy->features |= SUPPORTED_10baseT_Half;
+                if (bmsr & BMSR_10FULL)
+                        phy->features |= SUPPORTED_10baseT_Full;
+                if (bmsr & BMSR_100HALF)
+                        phy->features |= SUPPORTED_100baseT_Half;
+                if (bmsr & BMSR_100FULL)
+                        phy->features |= SUPPORTED_100baseT_Full;
+                if (bmsr & BMSR_ESTATEN) {
+                        u16 esr = phy_read(phy, MII_ESTATUS);
+                        if (esr & ESTATUS_1000_TFULL)
+                                phy->features |= SUPPORTED_1000baseT_Full;
+                        if (esr & ESTATUS_1000_THALF)
+                                phy->features |= SUPPORTED_1000baseT_Half;
+                }
+                phy->features |= SUPPORTED_MII;
+        }
+
         /* Setup default advertising */
-        phy->advertising = def->features;
+        phy->advertising = phy->features;
 
         return 0;
 }
diff --git a/drivers/net/ibm_emac/ibm_emac_phy.h b/drivers/net/ibm_emac/ibm_emac_phy.h
index 61afbea96563..a70e0fea54c4 100644
--- a/drivers/net/ibm_emac/ibm_emac_phy.h
+++ b/drivers/net/ibm_emac/ibm_emac_phy.h
@@ -1,65 +1,25 @@
-
 /*
- * ibm_emac_phy.h
- *
+ * drivers/net/ibm_emac/ibm_emac_phy.h
  *
- *      Benjamin Herrenschmidt <benh@kernel.crashing.org>
- *      February 2003
+ * Driver for PowerPC 4xx on-chip ethernet controller, PHY support
  *
- * 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.
+ * Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ * February 2003
  *
- *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR   IMPLIED
- *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
- *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
- *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT,  INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
- *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *  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.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
+ * Minor additions by Eugene Surovegin <ebs@ebshome.net>, 2004
  *
+ * 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 file basically duplicates sungem_phy.{c,h} with different PHYs
  * supported. I'm looking into merging that in a single mii layer more
  * flexible than mii.c 
  */
 
-#ifndef _IBM_EMAC_PHY_H_
-#define _IBM_EMAC_PHY_H_
-
-/*
- * PHY mode settings
- * Used for multi-mode capable PHYs
- */
-#define PHY_MODE_NA     0
-#define PHY_MODE_MII    1
-#define PHY_MODE_RMII   2
-#define PHY_MODE_SMII   3
-#define PHY_MODE_RGMII  4
-#define PHY_MODE_TBI    5
-#define PHY_MODE_GMII   6
-#define PHY_MODE_RTBI   7
-#define PHY_MODE_SGMII  8
-
-/*
- * PHY specific registers/values
- */
-
-/* CIS8201 */
-#define MII_CIS8201_EPCR        0x17
-#define EPCR_MODE_MASK          0x3000
-#define EPCR_GMII_MODE          0x0000
-#define EPCR_RGMII_MODE         0x1000
-#define EPCR_TBI_MODE           0x2000
-#define EPCR_RTBI_MODE          0x3000
+#ifndef _IBM_OCP_PHY_H_
+#define _IBM_OCP_PHY_H_
 
 struct mii_phy;
 
@@ -77,7 +37,8 @@ struct mii_phy_ops {
 struct mii_phy_def {
         u32 phy_id;             /* Concatenated ID1 << 16 | ID2 */
         u32 phy_id_mask;        /* Significant bits */
-        u32 features;           /* Ethtool SUPPORTED_* defines */
+        u32 features;           /* Ethtool SUPPORTED_* defines or 
+                                   0 for autodetect */
         int magic_aneg;         /* Autoneg does all speed test for us */
         const char *name;
         const struct mii_phy_ops *ops;
@@ -86,8 +47,11 @@ struct mii_phy_def {
 /* An instance of a PHY, partially borrowed from mii_if_info */
 struct mii_phy {
         struct mii_phy_def *def;
-        int advertising;
-        int mii_id;
+        u32 advertising;        /* Ethtool ADVERTISED_* defines */
+        u32 features;           /* Copied from mii_phy_def.features 
+                                   or determined automaticaly */
+        int address;            /* PHY address */
+        int mode;               /* PHY mode */
 
         /* 1: autoneg enabled, 0: disabled */
         int autoneg;
@@ -98,40 +62,19 @@ struct mii_phy {
         int speed;
         int duplex;
         int pause;
-
-        /* PHY mode - if needed */
-        int mode;
+        int asym_pause;
 
         /* Provided by host chip */
         struct net_device *dev;
-        int (*mdio_read) (struct net_device * dev, int mii_id, int reg);
-        void (*mdio_write) (struct net_device * dev, int mii_id, int reg,
+        int (*mdio_read) (struct net_device * dev, int addr, int reg);
+        void (*mdio_write) (struct net_device * dev, int addr, int reg,
                             int val);
 };
 
 /* Pass in a struct mii_phy with dev, mdio_read and mdio_write
  * filled, the remaining fields will be filled on return
  */
-extern int mii_phy_probe(struct mii_phy *phy, int mii_id);
-
-static inline int __phy_read(struct mii_phy *phy, int id, int reg)
-{
-        return phy->mdio_read(phy->dev, id, reg);
-}
-
-static inline void __phy_write(struct mii_phy *phy, int id, int reg, int val)
-{
-        phy->mdio_write(phy->dev, id, reg, val);
-}
-
-static inline int phy_read(struct mii_phy *phy, int reg)
-{
-        return phy->mdio_read(phy->dev, phy->mii_id, reg);
-}
-
-static inline void phy_write(struct mii_phy *phy, int reg, int val)
-{
-        phy->mdio_write(phy->dev, phy->mii_id, reg, val);
-}
+int mii_phy_probe(struct mii_phy *phy, int address);
+int mii_reset_phy(struct mii_phy *phy);
 
-#endif                          /* _IBM_EMAC_PHY_H_ */
+#endif                          /* _IBM_OCP_PHY_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_rgmii.c b/drivers/net/ibm_emac/ibm_emac_rgmii.c
new file mode 100644
index 000000000000..f0b1ffb2dbbf
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_rgmii.c
@@ -0,0 +1,201 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_rgmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, RGMII bridge support.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      Copyright 2004 MontaVista Software, Inc.
+ * 
+ * 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.
+ *
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/ethtool.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+#include "ibm_emac_debug.h"
+
+/* RGMIIx_FER */
+#define RGMII_FER_MASK(idx)     (0x7 << ((idx) * 4))
+#define RGMII_FER_RTBI(idx)     (0x4 << ((idx) * 4))
+#define RGMII_FER_RGMII(idx)    (0x5 << ((idx) * 4))
+#define RGMII_FER_TBI(idx)      (0x6 << ((idx) * 4))
+#define RGMII_FER_GMII(idx)     (0x7 << ((idx) * 4))
+
+/* RGMIIx_SSR */
+#define RGMII_SSR_MASK(idx)     (0x7 << ((idx) * 8))
+#define RGMII_SSR_100(idx)      (0x2 << ((idx) * 8))
+#define RGMII_SSR_1000(idx)     (0x4 << ((idx) * 8))
+
+/* RGMII bridge supports only GMII/TBI and RGMII/RTBI PHYs */
+static inline int rgmii_valid_mode(int phy_mode)
+{
+        return  phy_mode == PHY_MODE_GMII ||
+                phy_mode == PHY_MODE_RGMII ||
+                phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
+
+static inline const char *rgmii_mode_name(int mode)
+{
+        switch (mode) {
+        case PHY_MODE_RGMII:
+                return "RGMII";
+        case PHY_MODE_TBI:
+                return "TBI";
+        case PHY_MODE_GMII:
+                return "GMII";
+        case PHY_MODE_RTBI:
+                return "RTBI";
+        default:
+                BUG();
+        }
+}
+
+static inline u32 rgmii_mode_mask(int mode, int input)
+{
+        switch (mode) {
+        case PHY_MODE_RGMII:
+                return RGMII_FER_RGMII(input);
+        case PHY_MODE_TBI:
+                return RGMII_FER_TBI(input);
+        case PHY_MODE_GMII:
+                return RGMII_FER_GMII(input);
+        case PHY_MODE_RTBI:
+                return RGMII_FER_RTBI(input);
+        default:
+                BUG();
+        }
+}
+
+static int __init rgmii_init(struct ocp_device *ocpdev, int input, int mode)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        struct rgmii_regs *p;
+
+        RGMII_DBG("%d: init(%d, %d)" NL, ocpdev->def->index, input, mode);
+
+        if (!dev) {
+                dev = kzalloc(sizeof(struct ibm_ocp_rgmii), GFP_KERNEL);
+                if (!dev) {
+                        printk(KERN_ERR
+                               "rgmii%d: couldn't allocate device structure!\n",
+                               ocpdev->def->index);
+                        return -ENOMEM;
+                }
+
+                p = (struct rgmii_regs *)ioremap(ocpdev->def->paddr,
+                                                 sizeof(struct rgmii_regs));
+                if (!p) {
+                        printk(KERN_ERR
+                               "rgmii%d: could not ioremap device registers!\n",
+                               ocpdev->def->index);
+                        kfree(dev);
+                        return -ENOMEM;
+                }
+
+                dev->base = p;
+                ocp_set_drvdata(ocpdev, dev);
+
+                /* Disable all inputs by default */
+                out_be32(&p->fer, 0);
+        } else
+                p = dev->base;
+
+        /* Enable this input */
+        out_be32(&p->fer, in_be32(&p->fer) | rgmii_mode_mask(mode, input));
+
+        printk(KERN_NOTICE "rgmii%d: input %d in %s mode\n",
+               ocpdev->def->index, input, rgmii_mode_name(mode));
+
+        ++dev->users;
+        return 0;
+}
+
+int __init rgmii_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        /* Check if we need to attach to a RGMII */
+        if (emacdata->rgmii_idx >= 0 && rgmii_valid_mode(emacdata->phy_mode)) {
+                dev->rgmii_input = emacdata->rgmii_mux;
+                dev->rgmii_dev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_RGMII,
+                                    emacdata->rgmii_idx);
+                if (!dev->rgmii_dev) {
+                        printk(KERN_ERR "emac%d: unknown rgmii%d!\n",
+                               dev->def->index, emacdata->rgmii_idx);
+                        return -ENODEV;
+                }
+                if (rgmii_init
+                    (dev->rgmii_dev, dev->rgmii_input, emacdata->phy_mode)) {
+                        printk(KERN_ERR
+                               "emac%d: rgmii%d initialization failed!\n",
+                               dev->def->index, emacdata->rgmii_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void rgmii_set_speed(struct ocp_device *ocpdev, int input, int speed)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        u32 ssr = in_be32(&dev->base->ssr) & ~RGMII_SSR_MASK(input);
+
+        RGMII_DBG("%d: speed(%d, %d)" NL, ocpdev->def->index, input, speed);
+
+        if (speed == SPEED_1000)
+                ssr |= RGMII_SSR_1000(input);
+        else if (speed == SPEED_100)
+                ssr |= RGMII_SSR_100(input);
+
+        out_be32(&dev->base->ssr, ssr);
+}
+
+void __exit __rgmii_fini(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        BUG_ON(!dev || dev->users == 0);
+
+        RGMII_DBG("%d: fini(%d)" NL, ocpdev->def->index, input);
+
+        /* Disable this input */
+        out_be32(&dev->base->fer,
+                 in_be32(&dev->base->fer) & ~RGMII_FER_MASK(input));
+
+        if (!--dev->users) {
+                /* Free everything if this is the last user */
+                ocp_set_drvdata(ocpdev, NULL);
+                iounmap((void *)dev->base);
+                kfree(dev);
+        }
+}
+
+int __rgmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct rgmii_regs);
+}
+
+void *rgmii_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct rgmii_regs *regs = (struct rgmii_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev->base, sizeof(struct rgmii_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_rgmii.h b/drivers/net/ibm_emac/ibm_emac_rgmii.h
index 49f188f4ea6e..a1ffb8a44fff 100644
--- a/drivers/net/ibm_emac/ibm_emac_rgmii.h
+++ b/drivers/net/ibm_emac/ibm_emac_rgmii.h
@@ -1,5 +1,7 @@
 /*
- * Defines for the IBM RGMII bridge
+ * drivers/net/ibm_emac/ibm_emac_rgmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, RGMII bridge support.
  *
  * Based on ocp_zmii.h/ibm_emac_zmii.h
  * Armin Kuster akuster@mvista.com
@@ -7,6 +9,9 @@
  * Copyright 2004 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
  * 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
@@ -19,47 +24,42 @@
 #include <linux/config.h>
 
 /* RGMII bridge */
-typedef struct rgmii_regs {
+struct rgmii_regs {
         u32 fer;                /* Function enable register */
         u32 ssr;                /* Speed select register */
-} rgmii_t;
-
-#define RGMII_INPUTS                    4
+};
 
 /* RGMII device */
 struct ibm_ocp_rgmii {
         struct rgmii_regs *base;
-        int mode[RGMII_INPUTS];
         int users;              /* number of EMACs using this RGMII bridge */
 };
 
-/* Fuctional Enable Reg */
-#define RGMII_FER_MASK(x)               (0x00000007 << (4*x))
-#define RGMII_RTBI                      0x00000004
-#define RGMII_RGMII                     0x00000005
-#define RGMII_TBI                       0x00000006
-#define RGMII_GMII                      0x00000007
-
-/* Speed Selection reg */
+#ifdef CONFIG_IBM_EMAC_RGMII
+int rgmii_attach(void *emac) __init;
 
-#define RGMII_SP2_100   0x00000002
-#define RGMII_SP2_1000  0x00000004
-#define RGMII_SP3_100   0x00000200
-#define RGMII_SP3_1000  0x00000400
+void __rgmii_fini(struct ocp_device *ocpdev, int input) __exit;
+static inline void rgmii_fini(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __rgmii_fini(ocpdev, input);
+}
 
-#define RGMII_MII2_SPDMASK       0x00000007
-#define RGMII_MII3_SPDMASK       0x00000700
+void rgmii_set_speed(struct ocp_device *ocpdev, int input, int speed);
 
-#define RGMII_MII2_100MB         RGMII_SP2_100 & ~RGMII_SP2_1000
-#define RGMII_MII2_1000MB        RGMII_SP2_1000 & ~RGMII_SP2_100
-#define RGMII_MII2_10MB          ~(RGMII_SP2_100 | RGMII_SP2_1000)
-#define RGMII_MII3_100MB         RGMII_SP3_100 & ~RGMII_SP3_1000
-#define RGMII_MII3_1000MB        RGMII_SP3_1000 & ~RGMII_SP3_100
-#define RGMII_MII3_10MB          ~(RGMII_SP3_100 | RGMII_SP3_1000)
+int __rgmii_get_regs_len(struct ocp_device *ocpdev);
+static inline int rgmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __rgmii_get_regs_len(ocpdev) : 0;
+}
 
-#define RTBI            0
-#define RGMII           1
-#define TBI             2
-#define GMII            3
+void *rgmii_dump_regs(struct ocp_device *ocpdev, void *buf);
+#else
+# define rgmii_attach(x)        0
+# define rgmii_fini(x,y)        ((void)0)
+# define rgmii_set_speed(x,y,z) ((void)0)
+# define rgmii_get_regs_len(x)  0
+# define rgmii_dump_regs(x,buf) (buf)
+#endif                          /* !CONFIG_IBM_EMAC_RGMII */
 
 #endif                          /* _IBM_EMAC_RGMII_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_tah.c b/drivers/net/ibm_emac/ibm_emac_tah.c
new file mode 100644
index 000000000000..af08afc22f9f
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_tah.c
@@ -0,0 +1,111 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_tah.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, TAH support.
+ *
+ * Copyright 2004 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * Copyright (c) 2005 Eugene Surovegin <ebs@ebshome.net>
+ *
+ * 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.
+ */
+#include <linux/config.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+
+static int __init tah_init(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p;
+
+        if (ocp_get_drvdata(ocpdev)) {
+                printk(KERN_ERR "tah%d: already in use!\n", ocpdev->def->index);
+                return -EBUSY;
+        }
+
+        /* Initialize TAH and enable IPv4 checksum verification, no TSO yet */
+        p = (struct tah_regs *)ioremap(ocpdev->def->paddr, sizeof(*p));
+        if (!p) {
+                printk(KERN_ERR "tah%d: could not ioremap device registers!\n",
+                       ocpdev->def->index);
+                return -ENOMEM;
+        }
+        ocp_set_drvdata(ocpdev, p);
+        __tah_reset(ocpdev);
+
+        return 0;
+}
+
+int __init tah_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        /* Check if we need to attach to a TAH */
+        if (emacdata->tah_idx >= 0) {
+                dev->tah_dev = ocp_find_device(OCP_ANY_ID, OCP_FUNC_TAH,
+                                               emacdata->tah_idx);
+                if (!dev->tah_dev) {
+                        printk(KERN_ERR "emac%d: unknown tah%d!\n",
+                               dev->def->index, emacdata->tah_idx);
+                        return -ENODEV;
+                }
+                if (tah_init(dev->tah_dev)) {
+                        printk(KERN_ERR
+                               "emac%d: tah%d initialization failed!\n",
+                               dev->def->index, emacdata->tah_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void __exit __tah_fini(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p = ocp_get_drvdata(ocpdev);
+        BUG_ON(!p);
+        ocp_set_drvdata(ocpdev, NULL);
+        iounmap((void *)p);
+}
+
+void __tah_reset(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p = ocp_get_drvdata(ocpdev);
+        int n;
+
+        /* Reset TAH */
+        out_be32(&p->mr, TAH_MR_SR);
+        n = 100;
+        while ((in_be32(&p->mr) & TAH_MR_SR) && n)
+                --n;
+
+        if (unlikely(!n))
+                printk(KERN_ERR "tah%d: reset timeout\n", ocpdev->def->index);
+
+        /* 10KB TAH TX FIFO accomodates the max MTU of 9000 */
+        out_be32(&p->mr,
+                 TAH_MR_CVR | TAH_MR_ST_768 | TAH_MR_TFS_10KB | TAH_MR_DTFP |
+                 TAH_MR_DIG);
+}
+
+int __tah_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct tah_regs);
+}
+
+void *tah_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct tah_regs *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct tah_regs *regs = (struct tah_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev, sizeof(struct tah_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_tah.h b/drivers/net/ibm_emac/ibm_emac_tah.h
index ecfc69805521..9299b5dd7eb1 100644
--- a/drivers/net/ibm_emac/ibm_emac_tah.h
+++ b/drivers/net/ibm_emac/ibm_emac_tah.h
@@ -1,9 +1,13 @@
 /*
- * Defines for the IBM TAH
+ * drivers/net/ibm_emac/ibm_emac_tah.h
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, TAH support.
  *
  * Copyright 2004 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright (c) 2005 Eugene Surovegin <ebs@ebshome.net>
+ *
  * 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
@@ -13,36 +17,72 @@
 #ifndef _IBM_EMAC_TAH_H
 #define _IBM_EMAC_TAH_H
 
+#include <linux/config.h>
+#include <linux/init.h>
+#include <asm/ocp.h>
+
 /* TAH */
-typedef struct tah_regs {
-        u32 tah_revid;
+struct tah_regs {
+        u32 revid;
         u32 pad[3];
-        u32 tah_mr;
-        u32 tah_ssr0;
-        u32 tah_ssr1;
-        u32 tah_ssr2;
-        u32 tah_ssr3;
-        u32 tah_ssr4;
-        u32 tah_ssr5;
-        u32 tah_tsr;
-} tah_t;
+        u32 mr;
+        u32 ssr0;
+        u32 ssr1;
+        u32 ssr2;
+        u32 ssr3;
+        u32 ssr4;
+        u32 ssr5;
+        u32 tsr;
+};
 
 /* TAH engine */
-#define TAH_MR_CVR                      0x80000000
-#define TAH_MR_SR                       0x40000000
-#define TAH_MR_ST_256                   0x01000000
-#define TAH_MR_ST_512                   0x02000000
-#define TAH_MR_ST_768                   0x03000000
-#define TAH_MR_ST_1024                  0x04000000
-#define TAH_MR_ST_1280                  0x05000000
-#define TAH_MR_ST_1536                  0x06000000
-#define TAH_MR_TFS_16KB                 0x00000000
-#define TAH_MR_TFS_2KB                  0x00200000
-#define TAH_MR_TFS_4KB                  0x00400000
-#define TAH_MR_TFS_6KB                  0x00600000
-#define TAH_MR_TFS_8KB                  0x00800000
-#define TAH_MR_TFS_10KB                 0x00a00000
-#define TAH_MR_DTFP                     0x00100000
-#define TAH_MR_DIG                      0x00080000
+#define TAH_MR_CVR              0x80000000
+#define TAH_MR_SR               0x40000000
+#define TAH_MR_ST_256           0x01000000
+#define TAH_MR_ST_512           0x02000000
+#define TAH_MR_ST_768           0x03000000
+#define TAH_MR_ST_1024          0x04000000
+#define TAH_MR_ST_1280          0x05000000
+#define TAH_MR_ST_1536          0x06000000
+#define TAH_MR_TFS_16KB         0x00000000
+#define TAH_MR_TFS_2KB          0x00200000
+#define TAH_MR_TFS_4KB          0x00400000
+#define TAH_MR_TFS_6KB          0x00600000
+#define TAH_MR_TFS_8KB          0x00800000
+#define TAH_MR_TFS_10KB         0x00a00000
+#define TAH_MR_DTFP             0x00100000
+#define TAH_MR_DIG              0x00080000
+
+#ifdef CONFIG_IBM_EMAC_TAH
+int tah_attach(void *emac) __init;
+
+void __tah_fini(struct ocp_device *ocpdev) __exit;
+static inline void tah_fini(struct ocp_device *ocpdev)
+{
+        if (ocpdev)
+                __tah_fini(ocpdev);
+}
+
+void __tah_reset(struct ocp_device *ocpdev);
+static inline void tah_reset(struct ocp_device *ocpdev)
+{
+        if (ocpdev)
+                __tah_reset(ocpdev);
+}
+
+int __tah_get_regs_len(struct ocp_device *ocpdev);
+static inline int tah_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __tah_get_regs_len(ocpdev) : 0;
+}
+
+void *tah_dump_regs(struct ocp_device *ocpdev, void *buf);
+#else
+# define tah_attach(x)          0
+# define tah_fini(x)            ((void)0)
+# define tah_reset(x)           ((void)0)
+# define tah_get_regs_len(x)    0
+# define tah_dump_regs(x,buf)   (buf)
+#endif                          /* !CONFIG_IBM_EMAC_TAH */
 
 #endif                          /* _IBM_EMAC_TAH_H */
diff --git a/drivers/net/ibm_emac/ibm_emac_zmii.c b/drivers/net/ibm_emac/ibm_emac_zmii.c
new file mode 100644
index 000000000000..35c1185079ed
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_zmii.c
@@ -0,0 +1,255 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_zmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2001 MontaVista Softare Inc.
+ *
+ * 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.
+ *
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/ethtool.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+#include "ibm_emac_debug.h"
+
+/* ZMIIx_FER */
+#define ZMII_FER_MDI(idx)       (0x80000000 >> ((idx) * 4))
+#define ZMII_FER_MDI_ALL        (ZMII_FER_MDI(0) | ZMII_FER_MDI(1) | \
+                                 ZMII_FER_MDI(2) | ZMII_FER_MDI(3))
+
+#define ZMII_FER_SMII(idx)      (0x40000000 >> ((idx) * 4))
+#define ZMII_FER_RMII(idx)      (0x20000000 >> ((idx) * 4))
+#define ZMII_FER_MII(idx)       (0x10000000 >> ((idx) * 4))
+
+/* ZMIIx_SSR */
+#define ZMII_SSR_SCI(idx)       (0x40000000 >> ((idx) * 4))
+#define ZMII_SSR_FSS(idx)       (0x20000000 >> ((idx) * 4))
+#define ZMII_SSR_SP(idx)        (0x10000000 >> ((idx) * 4))
+
+/* ZMII only supports MII, RMII and SMII 
+ * we also support autodetection for backward compatibility
+ */
+static inline int zmii_valid_mode(int mode)
+{
+        return  mode == PHY_MODE_MII ||
+                mode == PHY_MODE_RMII ||
+                mode == PHY_MODE_SMII ||
+                mode == PHY_MODE_NA;
+}
+
+static inline const char *zmii_mode_name(int mode)
+{
+        switch (mode) {
+        case PHY_MODE_MII:
+                return "MII";
+        case PHY_MODE_RMII:
+                return "RMII";
+        case PHY_MODE_SMII:
+                return "SMII";
+        default:
+                BUG();
+        }
+}
+
+static inline u32 zmii_mode_mask(int mode, int input)
+{
+        switch (mode) {
+        case PHY_MODE_MII:
+                return ZMII_FER_MII(input);
+        case PHY_MODE_RMII:
+                return ZMII_FER_RMII(input);
+        case PHY_MODE_SMII:
+                return ZMII_FER_SMII(input);
+        default:
+                return 0;
+        }
+}
+
+static int __init zmii_init(struct ocp_device *ocpdev, int input, int *mode)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        struct zmii_regs *p;
+
+        ZMII_DBG("%d: init(%d, %d)" NL, ocpdev->def->index, input, *mode);
+
+        if (!dev) {
+                dev = kzalloc(sizeof(struct ibm_ocp_zmii), GFP_KERNEL);
+                if (!dev) {
+                        printk(KERN_ERR
+                               "zmii%d: couldn't allocate device structure!\n",
+                               ocpdev->def->index);
+                        return -ENOMEM;
+                }
+                dev->mode = PHY_MODE_NA;
+
+                p = (struct zmii_regs *)ioremap(ocpdev->def->paddr,
+                                                sizeof(struct zmii_regs));
+                if (!p) {
+                        printk(KERN_ERR
+                               "zmii%d: could not ioremap device registers!\n",
+                               ocpdev->def->index);
+                        kfree(dev);
+                        return -ENOMEM;
+                }
+                dev->base = p;
+                ocp_set_drvdata(ocpdev, dev);
+                
+                /* We may need FER value for autodetection later */
+                dev->fer_save = in_be32(&p->fer);
+
+                /* Disable all inputs by default */
+                out_be32(&p->fer, 0);
+        } else
+                p = dev->base;
+
+        if (!zmii_valid_mode(*mode)) {
+                /* Probably an EMAC connected to RGMII, 
+                 * but it still may need ZMII for MDIO 
+                 */
+                goto out;
+        }
+
+        /* Autodetect ZMII mode if not specified.
+         * This is only for backward compatibility with the old driver.
+         * Please, always specify PHY mode in your board port to avoid
+         * any surprises.
+         */
+        if (dev->mode == PHY_MODE_NA) {
+                if (*mode == PHY_MODE_NA) {
+                        u32 r = dev->fer_save;
+
+                        ZMII_DBG("%d: autodetecting mode, FER = 0x%08x" NL,
+                                 ocpdev->def->index, r);
+                        
+                        if (r & (ZMII_FER_MII(0) | ZMII_FER_MII(1)))
+                                dev->mode = PHY_MODE_MII;
+                        else if (r & (ZMII_FER_RMII(0) | ZMII_FER_RMII(1)))
+                                dev->mode = PHY_MODE_RMII;
+                        else
+                                dev->mode = PHY_MODE_SMII;
+                } else
+                        dev->mode = *mode;
+
+                printk(KERN_NOTICE "zmii%d: bridge in %s mode\n",
+                       ocpdev->def->index, zmii_mode_name(dev->mode));
+        } else {
+                /* All inputs must use the same mode */
+                if (*mode != PHY_MODE_NA && *mode != dev->mode) {
+                        printk(KERN_ERR
+                               "zmii%d: invalid mode %d specified for input %d\n",
+                               ocpdev->def->index, *mode, input);
+                        return -EINVAL;
+                }
+        }
+
+        /* Report back correct PHY mode, 
+         * it may be used during PHY initialization.
+         */
+        *mode = dev->mode;
+
+        /* Enable this input */
+        out_be32(&p->fer, in_be32(&p->fer) | zmii_mode_mask(dev->mode, input));
+      out:
+        ++dev->users;
+        return 0;
+}
+
+int __init zmii_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        if (emacdata->zmii_idx >= 0) {
+                dev->zmii_input = emacdata->zmii_mux;
+                dev->zmii_dev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_ZMII,
+                                    emacdata->zmii_idx);
+                if (!dev->zmii_dev) {
+                        printk(KERN_ERR "emac%d: unknown zmii%d!\n",
+                               dev->def->index, emacdata->zmii_idx);
+                        return -ENODEV;
+                }
+                if (zmii_init
+                    (dev->zmii_dev, dev->zmii_input, &emacdata->phy_mode)) {
+                        printk(KERN_ERR
+                               "emac%d: zmii%d initialization failed!\n",
+                               dev->def->index, emacdata->zmii_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void __zmii_enable_mdio(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        u32 fer = in_be32(&dev->base->fer) & ~ZMII_FER_MDI_ALL;
+
+        ZMII_DBG2("%d: mdio(%d)" NL, ocpdev->def->index, input);
+
+        out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input));
+}
+
+void __zmii_set_speed(struct ocp_device *ocpdev, int input, int speed)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        u32 ssr = in_be32(&dev->base->ssr);
+
+        ZMII_DBG("%d: speed(%d, %d)" NL, ocpdev->def->index, input, speed);
+
+        if (speed == SPEED_100)
+                ssr |= ZMII_SSR_SP(input);
+        else
+                ssr &= ~ZMII_SSR_SP(input);
+
+        out_be32(&dev->base->ssr, ssr);
+}
+
+void __exit __zmii_fini(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        BUG_ON(!dev || dev->users == 0);
+
+        ZMII_DBG("%d: fini(%d)" NL, ocpdev->def->index, input);
+
+        /* Disable this input */
+        out_be32(&dev->base->fer,
+                 in_be32(&dev->base->fer) & ~zmii_mode_mask(dev->mode, input));
+
+        if (!--dev->users) {
+                /* Free everything if this is the last user */
+                ocp_set_drvdata(ocpdev, NULL);
+                iounmap((void *)dev->base);
+                kfree(dev);
+        }
+}
+
+int __zmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct zmii_regs);
+}
+
+void *zmii_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct zmii_regs *regs = (struct zmii_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev->base, sizeof(struct zmii_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_zmii.h b/drivers/net/ibm_emac/ibm_emac_zmii.h
index 6f6cd2a39e38..0bb26062c0ad 100644
--- a/drivers/net/ibm_emac/ibm_emac_zmii.h
+++ b/drivers/net/ibm_emac/ibm_emac_zmii.h
@@ -1,23 +1,27 @@
 /*
- * ocp_zmii.h
+ * drivers/net/ibm_emac/ibm_emac_zmii.h
  *
- * Defines for the IBM ZMII bridge
+ * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
  *
- *      Armin Kuster akuster@mvista.com
- *      Dec, 2001
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2001 MontaVista Softare Inc.
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2001 MontaVista Softare Inc.
  *
  * 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.
+ *
  */
-
 #ifndef _IBM_EMAC_ZMII_H_
 #define _IBM_EMAC_ZMII_H_
 
 #include <linux/config.h>
+#include <linux/init.h>
+#include <asm/ocp.h>
 
 /* ZMII bridge registers */
 struct zmii_regs {
@@ -26,68 +30,54 @@ struct zmii_regs {
         u32 smiirs;             /* SMII status reg */
 };
 
-#define ZMII_INPUTS     4
-
 /* ZMII device */
 struct ibm_ocp_zmii {
         struct zmii_regs *base;
-        int mode[ZMII_INPUTS];
+        int mode;               /* subset of PHY_MODE_XXXX */
         int users;              /* number of EMACs using this ZMII bridge */
+        u32 fer_save;           /* FER value left by firmware */
 };
 
-/* Fuctional Enable Reg */
-
-#define ZMII_FER_MASK(x)        (0xf0000000 >> (4*x))
-
-#define ZMII_MDI0       0x80000000
-#define ZMII_SMII0      0x40000000
-#define ZMII_RMII0      0x20000000
-#define ZMII_MII0       0x10000000
-#define ZMII_MDI1       0x08000000
-#define ZMII_SMII1      0x04000000
-#define ZMII_RMII1      0x02000000
-#define ZMII_MII1       0x01000000
-#define ZMII_MDI2       0x00800000
-#define ZMII_SMII2      0x00400000
-#define ZMII_RMII2      0x00200000
-#define ZMII_MII2       0x00100000
-#define ZMII_MDI3       0x00080000
-#define ZMII_SMII3      0x00040000
-#define ZMII_RMII3      0x00020000
-#define ZMII_MII3       0x00010000
+#ifdef CONFIG_IBM_EMAC_ZMII
+int zmii_attach(void *emac) __init;
 
-/* Speed Selection reg */
+void __zmii_fini(struct ocp_device *ocpdev, int input) __exit;
+static inline void zmii_fini(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __zmii_fini(ocpdev, input);
+}
 
-#define ZMII_SCI0       0x40000000
-#define ZMII_FSS0       0x20000000
-#define ZMII_SP0        0x10000000
-#define ZMII_SCI1       0x04000000
-#define ZMII_FSS1       0x02000000
-#define ZMII_SP1        0x01000000
-#define ZMII_SCI2       0x00400000
-#define ZMII_FSS2       0x00200000
-#define ZMII_SP2        0x00100000
-#define ZMII_SCI3       0x00040000
-#define ZMII_FSS3       0x00020000
-#define ZMII_SP3        0x00010000
+void __zmii_enable_mdio(struct ocp_device *ocpdev, int input);
+static inline void zmii_enable_mdio(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __zmii_enable_mdio(ocpdev, input);
+}
 
-#define ZMII_MII0_100MB ZMII_SP0
-#define ZMII_MII0_10MB  ~ZMII_SP0
-#define ZMII_MII1_100MB ZMII_SP1
-#define ZMII_MII1_10MB  ~ZMII_SP1
-#define ZMII_MII2_100MB ZMII_SP2
-#define ZMII_MII2_10MB  ~ZMII_SP2
-#define ZMII_MII3_100MB ZMII_SP3
-#define ZMII_MII3_10MB  ~ZMII_SP3
+void __zmii_set_speed(struct ocp_device *ocpdev, int input, int speed);
+static inline void zmii_set_speed(struct ocp_device *ocpdev, int input,
+                                  int speed)
+{
+        if (ocpdev)
+                __zmii_set_speed(ocpdev, input, speed);
+}
 
-/* SMII Status reg */
+int __zmii_get_regs_len(struct ocp_device *ocpdev);
+static inline int zmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __zmii_get_regs_len(ocpdev) : 0;
+}
 
-#define ZMII_STS0 0xFF000000    /* EMAC0 smii status mask */
-#define ZMII_STS1 0x00FF0000    /* EMAC1 smii status mask */
+void *zmii_dump_regs(struct ocp_device *ocpdev, void *buf);
 
-#define SMII    0
-#define RMII    1
-#define MII     2
-#define MDI     3
+#else
+# define zmii_attach(x)         0
+# define zmii_fini(x,y)         ((void)0)
+# define zmii_enable_mdio(x,y)  ((void)0)
+# define zmii_set_speed(x,y,z)  ((void)0)
+# define zmii_get_regs_len(x)   0
+# define zmii_dump_regs(x,buf)  (buf)
+#endif                          /* !CONFIG_IBM_EMAC_ZMII */
 
 #endif                          /* _IBM_EMAC_ZMII_H_ */
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index cbe9368a4d56..e5246f227c98 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -96,7 +96,7 @@ static void ibmveth_proc_unregister_driver(void);
 static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter);
 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter);
 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
-static inline void ibmveth_schedule_replenishing(struct ibmveth_adapter*);
+static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
 
 #ifdef CONFIG_PROC_FS
 #define IBMVETH_PROC_DIR "net/ibmveth"
@@ -181,6 +181,7 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
         atomic_set(&pool->available, 0);
         pool->producer_index = 0;
         pool->consumer_index = 0;
+        pool->active = 0;
 
         return 0;
 }
@@ -236,7 +237,7 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                 lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
                     
                 if(lpar_rc != H_Success) {
-                        pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
+                        pool->free_map[free_index] = index;
                         pool->skbuff[index] = NULL;
                         pool->consumer_index--;
                         dma_unmap_single(&adapter->vdev->dev,
@@ -255,37 +256,19 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
         atomic_add(buffers_added, &(pool->available));
 }
 
-/* check if replenishing is needed.  */
-static inline int ibmveth_is_replenishing_needed(struct ibmveth_adapter *adapter)
-{
-        return ((atomic_read(&adapter->rx_buff_pool[0].available) < adapter->rx_buff_pool[0].threshold) ||
-                (atomic_read(&adapter->rx_buff_pool[1].available) < adapter->rx_buff_pool[1].threshold) ||
-                (atomic_read(&adapter->rx_buff_pool[2].available) < adapter->rx_buff_pool[2].threshold));
-}
-
-/* kick the replenish tasklet if we need replenishing and it isn't already running */
-static inline void ibmveth_schedule_replenishing(struct ibmveth_adapter *adapter)
-{
-        if(ibmveth_is_replenishing_needed(adapter) &&
-           (atomic_dec_if_positive(&adapter->not_replenishing) == 0)) {
-                schedule_work(&adapter->replenish_task);
-        }
-}
-
-/* replenish tasklet routine */
+/* replenish routine */
 static void ibmveth_replenish_task(struct ibmveth_adapter *adapter) 
 {
+        int i;
+
         adapter->replenish_task_cycles++;
 
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[0]);
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[1]);
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[2]);
+        for(i = 0; i < IbmVethNumBufferPools; i++)
+                if(adapter->rx_buff_pool[i].active)
+                        ibmveth_replenish_buffer_pool(adapter, 
+                                                     &adapter->rx_buff_pool[i]);
 
         adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
-
-        atomic_inc(&adapter->not_replenishing);
-
-        ibmveth_schedule_replenishing(adapter);
 }
 
 /* empty and free ana buffer pool - also used to do cleanup in error paths */
@@ -293,10 +276,8 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm
 {
         int i;
 
-        if(pool->free_map) {
-                kfree(pool->free_map);
-                pool->free_map  = NULL;
-        }
+        kfree(pool->free_map);
+        pool->free_map = NULL;
 
         if(pool->skbuff && pool->dma_addr) {
                 for(i = 0; i < pool->size; ++i) {
@@ -321,6 +302,7 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm
                 kfree(pool->skbuff);
                 pool->skbuff = NULL;
         }
+        pool->active = 0;
 }
 
 /* remove a buffer from a pool */
@@ -379,6 +361,12 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         ibmveth_assert(pool < IbmVethNumBufferPools);
         ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
 
+        if(!adapter->rx_buff_pool[pool].active) {
+                ibmveth_rxq_harvest_buffer(adapter);
+                ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
+                return;
+        }
+
         desc.desc = 0;
         desc.fields.valid = 1;
         desc.fields.length = adapter->rx_buff_pool[pool].buff_size;
@@ -409,6 +397,8 @@ static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
 
 static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
 {
+        int i;
+
         if(adapter->buffer_list_addr != NULL) {
                 if(!dma_mapping_error(adapter->buffer_list_dma)) {
                         dma_unmap_single(&adapter->vdev->dev,
@@ -443,26 +433,24 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
                 adapter->rx_queue.queue_addr = NULL;
         }
 
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[0]);
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[1]);
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[2]);
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[i]);
 }
 
 static int ibmveth_open(struct net_device *netdev)
 {
         struct ibmveth_adapter *adapter = netdev->priv;
         u64 mac_address = 0;
-        int rxq_entries;
+        int rxq_entries = 1;
         unsigned long lpar_rc;
         int rc;
         union ibmveth_buf_desc rxq_desc;
+        int i;
 
         ibmveth_debug_printk("open starting\n");
 
-        rxq_entries =
-                adapter->rx_buff_pool[0].size +
-                adapter->rx_buff_pool[1].size +
-                adapter->rx_buff_pool[2].size + 1;
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                rxq_entries += adapter->rx_buff_pool[i].size;
     
         adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
         adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
@@ -502,14 +490,8 @@ static int ibmveth_open(struct net_device *netdev)
         adapter->rx_queue.num_slots = rxq_entries;
         adapter->rx_queue.toggle = 1;
 
-        if(ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[0]) ||
-           ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[1]) ||
-           ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[2]))
-        {
-                ibmveth_error_printk("unable to allocate buffer pools\n");
-                ibmveth_cleanup(adapter);
-                return -ENOMEM;
-        }
+        /* call change_mtu to init the buffer pools based in initial mtu */
+        ibmveth_change_mtu(netdev, netdev->mtu);
 
         memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);
         mac_address = mac_address >> 16;
@@ -552,10 +534,10 @@ static int ibmveth_open(struct net_device *netdev)
                 return rc;
         }
 
-        netif_start_queue(netdev);
+        ibmveth_debug_printk("initial replenish cycle\n");
+        ibmveth_replenish_task(adapter);
 
-        ibmveth_debug_printk("scheduling initial replenish cycle\n");
-        ibmveth_schedule_replenishing(adapter);
+        netif_start_queue(netdev);
 
         ibmveth_debug_printk("open complete\n");
 
@@ -573,9 +555,6 @@ static int ibmveth_close(struct net_device *netdev)
 
         free_irq(netdev->irq, netdev);
 
-        cancel_delayed_work(&adapter->replenish_task);
-        flush_scheduled_work();
-
         do {
                 lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
         } while (H_isLongBusy(lpar_rc) || (lpar_rc == H_Busy));
@@ -640,12 +619,18 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
         unsigned long lpar_rc;
         int nfrags = 0, curfrag;
         unsigned long correlator;
+        unsigned long flags;
         unsigned int retry_count;
+        unsigned int tx_dropped = 0;
+        unsigned int tx_bytes = 0;
+        unsigned int tx_packets = 0;
+        unsigned int tx_send_failed = 0;
+        unsigned int tx_map_failed = 0;
+
 
         if ((skb_shinfo(skb)->nr_frags + 1) > IbmVethMaxSendFrags) {
-                adapter->stats.tx_dropped++;
-                dev_kfree_skb(skb);
-                return 0;
+                tx_dropped++;
+                goto out;
         }
 
         memset(&desc, 0, sizeof(desc));
@@ -664,10 +649,9 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 
         if(dma_mapping_error(desc[0].fields.address)) {
                 ibmveth_error_printk("tx: unable to map initial fragment\n");
-                adapter->tx_map_failed++;
-                adapter->stats.tx_dropped++;
-                dev_kfree_skb(skb);
-                return 0;
+                tx_map_failed++;
+                tx_dropped++;
+                goto out;
         }
 
         curfrag = nfrags;
@@ -684,8 +668,8 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 
                 if(dma_mapping_error(desc[curfrag+1].fields.address)) {
                         ibmveth_error_printk("tx: unable to map fragment %d\n", curfrag);
-                        adapter->tx_map_failed++;
-                        adapter->stats.tx_dropped++;
+                        tx_map_failed++;
+                        tx_dropped++;
                         /* Free all the mappings we just created */
                         while(curfrag < nfrags) {
                                 dma_unmap_single(&adapter->vdev->dev,
@@ -694,8 +678,7 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                                  DMA_TO_DEVICE);
                                 curfrag++;
                         }
-                        dev_kfree_skb(skb);
-                        return 0;
+                        goto out;
                 }
         }
 
@@ -720,11 +703,12 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                         ibmveth_error_printk("tx: desc[%i] valid=%d, len=%d, address=0x%d\n", i,
                                              desc[i].fields.valid, desc[i].fields.length, desc[i].fields.address);
                 }
-                adapter->tx_send_failed++;
-                adapter->stats.tx_dropped++;
+                tx_send_failed++;
+                tx_dropped++;
         } else {
-                adapter->stats.tx_packets++;
-                adapter->stats.tx_bytes += skb->len;
+                tx_packets++;
+                tx_bytes += skb->len;
+                netdev->trans_start = jiffies;
         }
 
         do {
@@ -733,6 +717,14 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                 desc[nfrags].fields.length, DMA_TO_DEVICE);
         } while(--nfrags >= 0);
 
+out:    spin_lock_irqsave(&adapter->stats_lock, flags);
+        adapter->stats.tx_dropped += tx_dropped;
+        adapter->stats.tx_bytes += tx_bytes;
+        adapter->stats.tx_packets += tx_packets;
+        adapter->tx_send_failed += tx_send_failed;
+        adapter->tx_map_failed += tx_map_failed;
+        spin_unlock_irqrestore(&adapter->stats_lock, flags);
+
         dev_kfree_skb(skb);
         return 0;
 }
@@ -776,13 +768,14 @@ static int ibmveth_poll(struct net_device *netdev, int *budget)
                                 adapter->stats.rx_packets++;
                                 adapter->stats.rx_bytes += length;
                                 frames_processed++;
+                                netdev->last_rx = jiffies;
                         }
                 } else {
                         more_work = 0;
                 }
         } while(more_work && (frames_processed < max_frames_to_process));
 
-        ibmveth_schedule_replenishing(adapter);
+        ibmveth_replenish_task(adapter);
 
         if(more_work) {
                 /* more work to do - return that we are not done yet */
@@ -883,17 +876,54 @@ static void ibmveth_set_multicast_list(struct net_device *netdev)
 
 static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
 {
-        if ((new_mtu < 68) || (new_mtu > (1<<20)))
+        struct ibmveth_adapter *adapter = dev->priv;
+        int i;
+        int prev_smaller = 1;
+
+        if ((new_mtu < 68) || 
+            (new_mtu > (pool_size[IbmVethNumBufferPools-1]) - IBMVETH_BUFF_OH))
                 return -EINVAL;
+
+        for(i = 0; i<IbmVethNumBufferPools; i++) {
+                int activate = 0;
+                if (new_mtu > (pool_size[i]  - IBMVETH_BUFF_OH)) { 
+                        activate = 1;
+                        prev_smaller= 1;
+                } else {
+                        if (prev_smaller)
+                                activate = 1;
+                        prev_smaller= 0;
+                }
+
+                if (activate && !adapter->rx_buff_pool[i].active) {
+                        struct ibmveth_buff_pool *pool = 
+                                                &adapter->rx_buff_pool[i];
+                        if(ibmveth_alloc_buffer_pool(pool)) {
+                                ibmveth_error_printk("unable to alloc pool\n");
+                                return -ENOMEM;
+                        }
+                        adapter->rx_buff_pool[i].active = 1;
+                } else if (!activate && adapter->rx_buff_pool[i].active) {
+                        adapter->rx_buff_pool[i].active = 0;
+                        h_free_logical_lan_buffer(adapter->vdev->unit_address,
+                                          (u64)pool_size[i]);
+                }
+
+        }
+
+        /* kick the interrupt handler so that the new buffer pools get
+           replenished or deallocated */
+        ibmveth_interrupt(dev->irq, dev, NULL);
+
         dev->mtu = new_mtu;
         return 0;       
 }
 
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
-        int rc;
+        int rc, i;
         struct net_device *netdev;
-        struct ibmveth_adapter *adapter;
+        struct ibmveth_adapter *adapter = NULL;
 
         unsigned char *mac_addr_p;
         unsigned int *mcastFilterSize_p;
@@ -960,23 +990,21 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
         netdev->ethtool_ops           = &netdev_ethtool_ops;
         netdev->change_mtu         = ibmveth_change_mtu;
         SET_NETDEV_DEV(netdev, &dev->dev);
+        netdev->features |= NETIF_F_LLTX; 
+        spin_lock_init(&adapter->stats_lock);
 
         memcpy(&netdev->dev_addr, &adapter->mac_addr, netdev->addr_len);
 
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[0], 0, IbmVethPool0DftCnt, IbmVethPool0DftSize);
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[1], 1, IbmVethPool1DftCnt, IbmVethPool1DftSize);
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[2], 2, IbmVethPool2DftCnt, IbmVethPool2DftSize);
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i, 
+                                         pool_count[i], pool_size[i]);
 
         ibmveth_debug_printk("adapter @ 0x%p\n", adapter);
 
-        INIT_WORK(&adapter->replenish_task, (void*)ibmveth_replenish_task, (void*)adapter);
-
         adapter->buffer_list_dma = DMA_ERROR_CODE;
         adapter->filter_list_dma = DMA_ERROR_CODE;
         adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
 
-        atomic_set(&adapter->not_replenishing, 1);
-
         ibmveth_debug_printk("registering netdev...\n");
 
         rc = register_netdev(netdev);
diff --git a/drivers/net/ibmveth.h b/drivers/net/ibmveth.h
index 51a470da9686..46919a814fca 100644
--- a/drivers/net/ibmveth.h
+++ b/drivers/net/ibmveth.h
@@ -49,6 +49,7 @@
 #define H_SEND_LOGICAL_LAN       0x120
 #define H_MULTICAST_CTRL         0x130
 #define H_CHANGE_LOGICAL_LAN_MAC 0x14C
+#define H_FREE_LOGICAL_LAN_BUFFER 0x1D4
 
 /* hcall macros */
 #define h_register_logical_lan(ua, buflst, rxq, fltlst, mac) \
@@ -69,13 +70,15 @@
 #define h_change_logical_lan_mac(ua, mac) \
   plpar_hcall_norets(H_CHANGE_LOGICAL_LAN_MAC, ua, mac)
 
-#define IbmVethNumBufferPools 3
-#define IbmVethPool0DftSize (1024 * 2)
-#define IbmVethPool1DftSize (1024 * 4)
-#define IbmVethPool2DftSize (1024 * 10)
-#define IbmVethPool0DftCnt  256
-#define IbmVethPool1DftCnt  256
-#define IbmVethPool2DftCnt  256
+#define h_free_logical_lan_buffer(ua, bufsize) \
+  plpar_hcall_norets(H_FREE_LOGICAL_LAN_BUFFER, ua, bufsize)
+
+#define IbmVethNumBufferPools 5
+#define IBMVETH_BUFF_OH 22 /* Overhead: 14 ethernet header + 8 opaque handle */
+
+/* pool_size should be sorted */
+static int pool_size[] = { 512, 1024 * 2, 1024 * 16, 1024 * 32, 1024 * 64 };
+static int pool_count[] = { 256, 768, 256, 256, 256 };
 
 #define IBM_VETH_INVALID_MAP ((u16)0xffff)
 
@@ -90,6 +93,7 @@ struct ibmveth_buff_pool {
     u16 *free_map;
     dma_addr_t *dma_addr;
     struct sk_buff **skbuff;
+    int active;
 };
 
 struct ibmveth_rx_q {
@@ -114,10 +118,6 @@ struct ibmveth_adapter {
     dma_addr_t filter_list_dma;
     struct ibmveth_buff_pool rx_buff_pool[IbmVethNumBufferPools];
     struct ibmveth_rx_q rx_queue;
-    atomic_t not_replenishing;
-
-    /* helper tasks */
-    struct work_struct replenish_task;
 
     /* adapter specific stats */
     u64 replenish_task_cycles;
@@ -131,6 +131,7 @@ struct ibmveth_adapter {
     u64 tx_linearize_failed;
     u64 tx_map_failed;
     u64 tx_send_failed;
+    spinlock_t stats_lock;
 };
 
 struct ibmveth_buf_desc_fields {        
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index ca5914091d3a..d54156f11e61 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -400,5 +400,15 @@ config VIA_FIR
           To compile it as a module, choose M here: the module will be called
           via-ircc.
 
+config PXA_FICP
+        tristate "Intel PXA2xx Internal FICP"
+        depends on ARCH_PXA && IRDA
+        help
+          Say Y or M here if you want to build support for the PXA2xx
+          built-in IRDA interface which can support both SIR and FIR.
+          This driver relies on platform specific helper routines so
+          available capabilities may vary from one PXA2xx target to
+          another.
+
 endmenu
 
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
index 29a8bd812b21..e7a8b7f7f5dd 100644
--- a/drivers/net/irda/Makefile
+++ b/drivers/net/irda/Makefile
@@ -18,6 +18,7 @@ obj-$(CONFIG_SMC_IRCC_FIR)	+= smsc-ircc2.o
 obj-$(CONFIG_ALI_FIR)           += ali-ircc.o
 obj-$(CONFIG_VLSI_FIR)          += vlsi_ir.o
 obj-$(CONFIG_VIA_FIR)           += via-ircc.o
+obj-$(CONFIG_PXA_FICP)          += pxaficp_ir.o
 # Old dongle drivers for old SIR drivers
 obj-$(CONFIG_ESI_DONGLE_OLD)            += esi.o
 obj-$(CONFIG_TEKRAM_DONGLE_OLD) += tekram.o
diff --git a/drivers/net/irda/donauboe.c b/drivers/net/irda/donauboe.c
index 0a08c539c051..0282771b1cbb 100644
--- a/drivers/net/irda/donauboe.c
+++ b/drivers/net/irda/donauboe.c
@@ -1695,11 +1695,9 @@ toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
 
 freebufs:
   for (i = 0; i < TX_SLOTS; ++i)
-    if (self->tx_bufs[i])
-      kfree (self->tx_bufs[i]);
+    kfree (self->tx_bufs[i]);
   for (i = 0; i < RX_SLOTS; ++i)
-    if (self->rx_bufs[i])
-      kfree (self->rx_bufs[i]);
+    kfree (self->rx_bufs[i]);
   kfree(self->ringbuf);
 
 freeregion:
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 6c766fdc51a6..c22c0517883c 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1168,10 +1168,8 @@ static inline void irda_usb_close(struct irda_usb_cb *self)
         unregister_netdev(self->netdev);
 
         /* Remove the speed buffer */
-        if (self->speed_buff != NULL) {
-                kfree(self->speed_buff);
-                self->speed_buff = NULL;
-        }
+        kfree(self->speed_buff);
+        self->speed_buff = NULL;
 }
 
 /********************** USB CONFIG SUBROUTINES **********************/
diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
index 5971315f3fa0..3d016a498e1d 100644
--- a/drivers/net/irda/irport.c
+++ b/drivers/net/irda/irport.c
@@ -235,8 +235,7 @@ static int irport_close(struct irport_cb *self)
                    __FUNCTION__, self->io.sir_base);
         release_region(self->io.sir_base, self->io.sir_ext);
 
-        if (self->tx_buff.head)
-                kfree(self->tx_buff.head);
+        kfree(self->tx_buff.head);
         
         if (self->rx_buff.skb)
                 kfree_skb(self->rx_buff.skb);
diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
new file mode 100644
index 000000000000..b886b07412a6
--- /dev/null
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -0,0 +1,865 @@
+/*
+ * linux/drivers/net/irda/pxaficp_ir.c
+ *
+ * Based on sa1100_ir.c by Russell King
+ *
+ * Changes copyright (C) 2003-2005 MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Infra-red driver (SIR/FIR) for the PXA2xx embedded microprocessor
+ *
+ */
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/netdevice.h>
+#include <linux/slab.h>
+#include <linux/rtnetlink.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/pm.h>
+
+#include <net/irda/irda.h>
+#include <net/irda/irmod.h>
+#include <net/irda/wrapper.h>
+#include <net/irda/irda_device.h>
+
+#include <asm/irq.h>
+#include <asm/dma.h>
+#include <asm/delay.h>
+#include <asm/hardware.h>
+#include <asm/arch/irda.h>
+#include <asm/arch/pxa-regs.h>
+
+#ifdef CONFIG_MACH_MAINSTONE
+#include <asm/arch/mainstone.h>
+#endif
+
+#define IrSR_RXPL_NEG_IS_ZERO (1<<4)
+#define IrSR_RXPL_POS_IS_ZERO 0x0
+#define IrSR_TXPL_NEG_IS_ZERO (1<<3)
+#define IrSR_TXPL_POS_IS_ZERO 0x0
+#define IrSR_XMODE_PULSE_1_6  (1<<2)
+#define IrSR_XMODE_PULSE_3_16 0x0
+#define IrSR_RCVEIR_IR_MODE   (1<<1)
+#define IrSR_RCVEIR_UART_MODE 0x0
+#define IrSR_XMITIR_IR_MODE   (1<<0)
+#define IrSR_XMITIR_UART_MODE 0x0
+
+#define IrSR_IR_RECEIVE_ON (\
+                IrSR_RXPL_NEG_IS_ZERO | \
+                IrSR_TXPL_POS_IS_ZERO | \
+                IrSR_XMODE_PULSE_3_16 | \
+                IrSR_RCVEIR_IR_MODE   | \
+                IrSR_XMITIR_UART_MODE)
+
+#define IrSR_IR_TRANSMIT_ON (\
+                IrSR_RXPL_NEG_IS_ZERO | \
+                IrSR_TXPL_POS_IS_ZERO | \
+                IrSR_XMODE_PULSE_3_16 | \
+                IrSR_RCVEIR_UART_MODE | \
+                IrSR_XMITIR_IR_MODE)
+
+struct pxa_irda {
+        int                     speed;
+        int                     newspeed;
+        unsigned long           last_oscr;
+
+        unsigned char           *dma_rx_buff;
+        unsigned char           *dma_tx_buff;
+        dma_addr_t              dma_rx_buff_phy;
+        dma_addr_t              dma_tx_buff_phy;
+        unsigned int            dma_tx_buff_len;
+        int                     txdma;
+        int                     rxdma;
+
+        struct net_device_stats stats;
+        struct irlap_cb         *irlap;
+        struct qos_info         qos;
+
+        iobuff_t                tx_buff;
+        iobuff_t                rx_buff;
+
+        struct device           *dev;
+        struct pxaficp_platform_data *pdata;
+};
+
+
+#define IS_FIR(si)              ((si)->speed >= 4000000)
+#define IRDA_FRAME_SIZE_LIMIT   2047
+
+inline static void pxa_irda_fir_dma_rx_start(struct pxa_irda *si)
+{
+        DCSR(si->rxdma)  = DCSR_NODESC;
+        DSADR(si->rxdma) = __PREG(ICDR);
+        DTADR(si->rxdma) = si->dma_rx_buff_phy;
+        DCMD(si->rxdma) = DCMD_INCTRGADDR | DCMD_FLOWSRC |  DCMD_WIDTH1 | DCMD_BURST32 | IRDA_FRAME_SIZE_LIMIT;
+        DCSR(si->rxdma) |= DCSR_RUN;
+}
+
+inline static void pxa_irda_fir_dma_tx_start(struct pxa_irda *si)
+{
+        DCSR(si->txdma)  = DCSR_NODESC;
+        DSADR(si->txdma) = si->dma_tx_buff_phy;
+        DTADR(si->txdma) = __PREG(ICDR);
+        DCMD(si->txdma) = DCMD_INCSRCADDR | DCMD_FLOWTRG |  DCMD_ENDIRQEN | DCMD_WIDTH1 | DCMD_BURST32 | si->dma_tx_buff_len;
+        DCSR(si->txdma) |= DCSR_RUN;
+}
+
+/*
+ * Set the IrDA communications speed.
+ */
+static int pxa_irda_set_speed(struct pxa_irda *si, int speed)
+{
+        unsigned long flags;
+        unsigned int divisor;
+
+        switch (speed) {
+        case 9600:      case 19200:     case 38400:
+        case 57600:     case 115200:
+
+                /* refer to PXA250/210 Developer's Manual 10-7 */
+                /*  BaudRate = 14.7456 MHz / (16*Divisor) */
+                divisor = 14745600 / (16 * speed);
+
+                local_irq_save(flags);
+
+                if (IS_FIR(si)) {
+                        /* stop RX DMA */
+                        DCSR(si->rxdma) &= ~DCSR_RUN;
+                        /* disable FICP */
+                        ICCR0 = 0;
+                        pxa_set_cken(CKEN13_FICP, 0);
+
+                        /* set board transceiver to SIR mode */
+                        si->pdata->transceiver_mode(si->dev, IR_SIRMODE);
+
+                        /* configure GPIO46/47 */
+                        pxa_gpio_mode(GPIO46_STRXD_MD);
+                        pxa_gpio_mode(GPIO47_STTXD_MD);
+
+                        /* enable the STUART clock */
+                        pxa_set_cken(CKEN5_STUART, 1);
+                }
+
+                /* disable STUART first */
+                STIER = 0;
+
+                /* access DLL & DLH */
+                STLCR |= LCR_DLAB;
+                STDLL = divisor & 0xff;
+                STDLH = divisor >> 8;
+                STLCR &= ~LCR_DLAB;
+
+                si->speed = speed;
+                STISR = IrSR_IR_RECEIVE_ON | IrSR_XMODE_PULSE_1_6;
+                STIER = IER_UUE | IER_RLSE | IER_RAVIE | IER_RTIOE;
+
+                local_irq_restore(flags);
+                break;
+
+        case 4000000:
+                local_irq_save(flags);
+
+                /* disable STUART */
+                STIER = 0;
+                STISR = 0;
+                pxa_set_cken(CKEN5_STUART, 0);
+
+                /* disable FICP first */
+                ICCR0 = 0;
+
+                /* set board transceiver to FIR mode */
+                si->pdata->transceiver_mode(si->dev, IR_FIRMODE);
+
+                /* configure GPIO46/47 */
+                pxa_gpio_mode(GPIO46_ICPRXD_MD);
+                pxa_gpio_mode(GPIO47_ICPTXD_MD);
+
+                /* enable the FICP clock */
+                pxa_set_cken(CKEN13_FICP, 1);
+
+                si->speed = speed;
+                pxa_irda_fir_dma_rx_start(si);
+                ICCR0 = ICCR0_ITR | ICCR0_RXE;
+
+                local_irq_restore(flags);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* SIR interrupt service routine. */
+static irqreturn_t pxa_irda_sir_irq(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct pxa_irda *si = netdev_priv(dev);
+        int iir, lsr, data;
+
+        iir = STIIR;
+
+        switch  (iir & 0x0F) {
+        case 0x06: /* Receiver Line Status */
+                lsr = STLSR;
+                while (lsr & LSR_FIFOE) {
+                        data = STRBR;
+                        if (lsr & (LSR_OE | LSR_PE | LSR_FE | LSR_BI)) {
+                                printk(KERN_DEBUG "pxa_ir: sir receiving error\n");
+                                si->stats.rx_errors++;
+                                if (lsr & LSR_FE)
+                                        si->stats.rx_frame_errors++;
+                                if (lsr & LSR_OE)
+                                        si->stats.rx_fifo_errors++;
+                        } else {
+                                si->stats.rx_bytes++;
+                                async_unwrap_char(dev, &si->stats, &si->rx_buff, data);
+                        }
+                        lsr = STLSR;
+                }
+                dev->last_rx = jiffies;
+                si->last_oscr = OSCR;
+                break;
+
+        case 0x04: /* Received Data Available */
+                   /* forth through */
+
+        case 0x0C: /* Character Timeout Indication */
+                do  {
+                    si->stats.rx_bytes++;
+                    async_unwrap_char(dev, &si->stats, &si->rx_buff, STRBR);
+                } while (STLSR & LSR_DR);
+                dev->last_rx = jiffies;
+                si->last_oscr = OSCR;
+                break;
+
+        case 0x02: /* Transmit FIFO Data Request */
+                while ((si->tx_buff.len) && (STLSR & LSR_TDRQ)) {
+                        STTHR = *si->tx_buff.data++;
+                        si->tx_buff.len -= 1;
+                }
+
+                if (si->tx_buff.len == 0) {
+                        si->stats.tx_packets++;
+                        si->stats.tx_bytes += si->tx_buff.data -
+                                              si->tx_buff.head;
+
+                        /* We need to ensure that the transmitter has finished. */
+                        while ((STLSR & LSR_TEMT) == 0)
+                                cpu_relax();
+                        si->last_oscr = OSCR;
+
+                        /*
+                        * Ok, we've finished transmitting.  Now enable
+                        * the receiver.  Sometimes we get a receive IRQ
+                        * immediately after a transmit...
+                        */
+                        if (si->newspeed) {
+                                pxa_irda_set_speed(si, si->newspeed);
+                                si->newspeed = 0;
+                        } else {
+                                /* enable IR Receiver, disable IR Transmitter */
+                                STISR = IrSR_IR_RECEIVE_ON | IrSR_XMODE_PULSE_1_6;
+                                /* enable STUART and receive interrupts */
+                                STIER = IER_UUE | IER_RLSE | IER_RAVIE | IER_RTIOE;
+                        }
+                        /* I'm hungry! */
+                        netif_wake_queue(dev);
+                }
+                break;
+        }
+
+        return IRQ_HANDLED;
+}
+
+/* FIR Receive DMA interrupt handler */
+static void pxa_irda_fir_dma_rx_irq(int channel, void *data, struct pt_regs *regs)
+{
+        int dcsr = DCSR(channel);
+
+        DCSR(channel) = dcsr & ~DCSR_RUN;
+
+        printk(KERN_DEBUG "pxa_ir: fir rx dma bus error %#x\n", dcsr);
+}
+
+/* FIR Transmit DMA interrupt handler */
+static void pxa_irda_fir_dma_tx_irq(int channel, void *data, struct pt_regs *regs)
+{
+        struct net_device *dev = data;
+        struct pxa_irda *si = netdev_priv(dev);
+        int dcsr;
+
+        dcsr = DCSR(channel);
+        DCSR(channel) = dcsr & ~DCSR_RUN;
+
+        if (dcsr & DCSR_ENDINTR)  {
+                si->stats.tx_packets++;
+                si->stats.tx_bytes += si->dma_tx_buff_len;
+        } else {
+                si->stats.tx_errors++;
+        }
+
+        while (ICSR1 & ICSR1_TBY)
+                cpu_relax();
+        si->last_oscr = OSCR;
+
+        /*
+         * HACK: It looks like the TBY bit is dropped too soon.
+         * Without this delay things break.
+         */
+        udelay(120);
+
+        if (si->newspeed) {
+                pxa_irda_set_speed(si, si->newspeed);
+                si->newspeed = 0;
+        } else {
+                ICCR0 = 0;
+                pxa_irda_fir_dma_rx_start(si);
+                ICCR0 = ICCR0_ITR | ICCR0_RXE;
+        }
+        netif_wake_queue(dev);
+}
+
+/* EIF(Error in FIFO/End in Frame) handler for FIR */
+static void pxa_irda_fir_irq_eif(struct pxa_irda *si, struct net_device *dev)
+{
+        unsigned int len, stat, data;
+
+        /* Get the current data position. */
+        len = DTADR(si->rxdma) - si->dma_rx_buff_phy;
+
+        do {
+                /* Read Status, and then Data.   */
+                stat = ICSR1;
+                rmb();
+                data = ICDR;
+
+                if (stat & (ICSR1_CRE | ICSR1_ROR)) {
+                        si->stats.rx_errors++;
+                        if (stat & ICSR1_CRE) {
+                                printk(KERN_DEBUG "pxa_ir: fir receive CRC error\n");
+                                si->stats.rx_crc_errors++;
+                        }
+                        if (stat & ICSR1_ROR) {
+                                printk(KERN_DEBUG "pxa_ir: fir receive overrun\n");
+                                si->stats.rx_frame_errors++;
+                        }
+                } else  {
+                        si->dma_rx_buff[len++] = data;
+                }
+                /* If we hit the end of frame, there's no point in continuing. */
+                if (stat & ICSR1_EOF)
+                        break;
+        } while (ICSR0 & ICSR0_EIF);
+
+        if (stat & ICSR1_EOF) {
+                /* end of frame. */
+                struct sk_buff *skb = alloc_skb(len+1,GFP_ATOMIC);
+                if (!skb)  {
+                        printk(KERN_ERR "pxa_ir: fir out of memory for receive skb\n");
+                        si->stats.rx_dropped++;
+                        return;
+                }
+
+                /* Align IP header to 20 bytes  */
+                skb_reserve(skb, 1);
+                memcpy(skb->data, si->dma_rx_buff, len);
+                skb_put(skb, len);
+
+                /* Feed it to IrLAP  */
+                skb->dev = dev;
+                skb->mac.raw  = skb->data;
+                skb->protocol = htons(ETH_P_IRDA);
+                netif_rx(skb);
+
+                si->stats.rx_packets++;
+                si->stats.rx_bytes += len;
+
+                dev->last_rx = jiffies;
+        }
+}
+
+/* FIR interrupt handler */
+static irqreturn_t pxa_irda_fir_irq(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct pxa_irda *si = netdev_priv(dev);
+        int icsr0;
+
+        /* stop RX DMA */
+        DCSR(si->rxdma) &= ~DCSR_RUN;
+        si->last_oscr = OSCR;
+        icsr0 = ICSR0;
+
+        if (icsr0 & (ICSR0_FRE | ICSR0_RAB)) {
+                if (icsr0 & ICSR0_FRE) {
+                        printk(KERN_DEBUG "pxa_ir: fir receive frame error\n");
+                        si->stats.rx_frame_errors++;
+                } else {
+                        printk(KERN_DEBUG "pxa_ir: fir receive abort\n");
+                        si->stats.rx_errors++;
+                }
+                ICSR0 = icsr0 & (ICSR0_FRE | ICSR0_RAB);
+        }
+
+        if (icsr0 & ICSR0_EIF) {
+                /* An error in FIFO occured, or there is a end of frame */
+                pxa_irda_fir_irq_eif(si, dev);
+        }
+
+        ICCR0 = 0;
+        pxa_irda_fir_dma_rx_start(si);
+        ICCR0 = ICCR0_ITR | ICCR0_RXE;
+
+        return IRQ_HANDLED;
+}
+
+/* hard_xmit interface of irda device */
+static int pxa_irda_hard_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct pxa_irda *si = netdev_priv(dev);
+        int speed = irda_get_next_speed(skb);
+
+        /*
+         * Does this packet contain a request to change the interface
+         * speed?  If so, remember it until we complete the transmission
+         * of this frame.
+         */
+        if (speed != si->speed && speed != -1)
+                si->newspeed = speed;
+
+        /*
+         * If this is an empty frame, we can bypass a lot.
+         */
+        if (skb->len == 0) {
+                if (si->newspeed) {
+                        si->newspeed = 0;
+                        pxa_irda_set_speed(si, speed);
+                }
+                dev_kfree_skb(skb);
+                return 0;
+        }
+
+        netif_stop_queue(dev);
+
+        if (!IS_FIR(si)) {
+                si->tx_buff.data = si->tx_buff.head;
+                si->tx_buff.len  = async_wrap_skb(skb, si->tx_buff.data, si->tx_buff.truesize);
+
+                /* Disable STUART interrupts and switch to transmit mode. */
+                STIER = 0;
+                STISR = IrSR_IR_TRANSMIT_ON | IrSR_XMODE_PULSE_1_6;
+
+                /* enable STUART and transmit interrupts */
+                STIER = IER_UUE | IER_TIE;
+        } else {
+                unsigned long mtt = irda_get_mtt(skb);
+
+                si->dma_tx_buff_len = skb->len;
+                memcpy(si->dma_tx_buff, skb->data, skb->len);
+
+                if (mtt)
+                        while ((unsigned)(OSCR - si->last_oscr)/4 < mtt)
+                                cpu_relax();
+
+                /* stop RX DMA,  disable FICP */
+                DCSR(si->rxdma) &= ~DCSR_RUN;
+                ICCR0 = 0;
+
+                pxa_irda_fir_dma_tx_start(si);
+                ICCR0 = ICCR0_ITR | ICCR0_TXE;
+        }
+
+        dev_kfree_skb(skb);
+        dev->trans_start = jiffies;
+        return 0;
+}
+
+static int pxa_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
+{
+        struct if_irda_req *rq = (struct if_irda_req *)ifreq;
+        struct pxa_irda *si = netdev_priv(dev);
+        int ret;
+
+        switch (cmd) {
+        case SIOCSBANDWIDTH:
+                ret = -EPERM;
+                if (capable(CAP_NET_ADMIN)) {
+                        /*
+                         * We are unable to set the speed if the
+                         * device is not running.
+                         */
+                        if (netif_running(dev)) {
+                                ret = pxa_irda_set_speed(si,
+                                                rq->ifr_baudrate);
+                        } else {
+                                printk(KERN_INFO "pxa_ir: SIOCSBANDWIDTH: !netif_running\n");
+                                ret = 0;
+                        }
+                }
+                break;
+
+        case SIOCSMEDIABUSY:
+                ret = -EPERM;
+                if (capable(CAP_NET_ADMIN)) {
+                        irda_device_set_media_busy(dev, TRUE);
+                        ret = 0;
+                }
+                break;
+
+        case SIOCGRECEIVING:
+                ret = 0;
+                rq->ifr_receiving = IS_FIR(si) ? 0
+                                        : si->rx_buff.state != OUTSIDE_FRAME;
+                break;
+
+        default:
+                ret = -EOPNOTSUPP;
+                break;
+        }
+
+        return ret;
+}
+
+static struct net_device_stats *pxa_irda_stats(struct net_device *dev)
+{
+        struct pxa_irda *si = netdev_priv(dev);
+        return &si->stats;
+}
+
+static void pxa_irda_startup(struct pxa_irda *si)
+{
+        /* Disable STUART interrupts */
+        STIER = 0;
+        /* enable STUART interrupt to the processor */
+        STMCR = MCR_OUT2;
+        /* configure SIR frame format: StartBit - Data 7 ... Data 0 - Stop Bit */
+        STLCR = LCR_WLS0 | LCR_WLS1;
+        /* enable FIFO, we use FIFO to improve performance */
+        STFCR = FCR_TRFIFOE | FCR_ITL_32;
+
+        /* disable FICP */
+        ICCR0 = 0;
+        /* configure FICP ICCR2 */
+        ICCR2 = ICCR2_TXP | ICCR2_TRIG_32;
+
+        /* configure DMAC */
+        DRCMR17 = si->rxdma | DRCMR_MAPVLD;
+        DRCMR18 = si->txdma | DRCMR_MAPVLD;
+
+        /* force SIR reinitialization */
+        si->speed = 4000000;
+        pxa_irda_set_speed(si, 9600);
+
+        printk(KERN_DEBUG "pxa_ir: irda startup\n");
+}
+
+static void pxa_irda_shutdown(struct pxa_irda *si)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        /* disable STUART and interrupt */
+        STIER = 0;
+        /* disable STUART SIR mode */
+        STISR = 0;
+        /* disable the STUART clock */
+        pxa_set_cken(CKEN5_STUART, 0);
+
+        /* disable DMA */
+        DCSR(si->txdma) &= ~DCSR_RUN;
+        DCSR(si->rxdma) &= ~DCSR_RUN;
+        /* disable FICP */
+        ICCR0 = 0;
+        /* disable the FICP clock */
+        pxa_set_cken(CKEN13_FICP, 0);
+
+        DRCMR17 = 0;
+        DRCMR18 = 0;
+
+        local_irq_restore(flags);
+
+        /* power off board transceiver */
+        si->pdata->transceiver_mode(si->dev, IR_OFF);
+
+        printk(KERN_DEBUG "pxa_ir: irda shutdown\n");
+}
+
+static int pxa_irda_start(struct net_device *dev)
+{
+        struct pxa_irda *si = netdev_priv(dev);
+        int err;
+
+        si->speed = 9600;
+
+        err = request_irq(IRQ_STUART, pxa_irda_sir_irq, 0, dev->name, dev);
+        if (err)
+                goto err_irq1;
+
+        err = request_irq(IRQ_ICP, pxa_irda_fir_irq, 0, dev->name, dev);
+        if (err)
+                goto err_irq2;
+
+        /*
+         * The interrupt must remain disabled for now.
+         */
+        disable_irq(IRQ_STUART);
+        disable_irq(IRQ_ICP);
+
+        err = -EBUSY;
+        si->rxdma = pxa_request_dma("FICP_RX",DMA_PRIO_LOW, pxa_irda_fir_dma_rx_irq, dev);
+        if (si->rxdma < 0)
+                goto err_rx_dma;
+
+        si->txdma = pxa_request_dma("FICP_TX",DMA_PRIO_LOW, pxa_irda_fir_dma_tx_irq, dev);
+        if (si->txdma < 0)
+                goto err_tx_dma;
+
+        err = -ENOMEM;
+        si->dma_rx_buff = dma_alloc_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT,
+                                             &si->dma_rx_buff_phy, GFP_KERNEL );
+        if (!si->dma_rx_buff)
+                goto err_dma_rx_buff;
+
+        si->dma_tx_buff = dma_alloc_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT,
+                                             &si->dma_tx_buff_phy, GFP_KERNEL );
+        if (!si->dma_tx_buff)
+                goto err_dma_tx_buff;
+
+        /* Setup the serial port for the initial speed. */
+        pxa_irda_startup(si);
+
+        /*
+         * Open a new IrLAP layer instance.
+         */
+        si->irlap = irlap_open(dev, &si->qos, "pxa");
+        err = -ENOMEM;
+        if (!si->irlap)
+                goto err_irlap;
+
+        /*
+         * Now enable the interrupt and start the queue
+         */
+        enable_irq(IRQ_STUART);
+        enable_irq(IRQ_ICP);
+        netif_start_queue(dev);
+
+        printk(KERN_DEBUG "pxa_ir: irda driver opened\n");
+
+        return 0;
+
+err_irlap:
+        pxa_irda_shutdown(si);
+        dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_tx_buff, si->dma_tx_buff_phy);
+err_dma_tx_buff:
+        dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_rx_buff, si->dma_rx_buff_phy);
+err_dma_rx_buff:
+        pxa_free_dma(si->txdma);
+err_tx_dma:
+        pxa_free_dma(si->rxdma);
+err_rx_dma:
+        free_irq(IRQ_ICP, dev);
+err_irq2:
+        free_irq(IRQ_STUART, dev);
+err_irq1:
+
+        return err;
+}
+
+static int pxa_irda_stop(struct net_device *dev)
+{
+        struct pxa_irda *si = netdev_priv(dev);
+
+        netif_stop_queue(dev);
+
+        pxa_irda_shutdown(si);
+
+        /* Stop IrLAP */
+        if (si->irlap) {
+                irlap_close(si->irlap);
+                si->irlap = NULL;
+        }
+
+        free_irq(IRQ_STUART, dev);
+        free_irq(IRQ_ICP, dev);
+
+        pxa_free_dma(si->rxdma);
+        pxa_free_dma(si->txdma);
+
+        if (si->dma_rx_buff)
+                dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_tx_buff, si->dma_tx_buff_phy);
+        if (si->dma_tx_buff)
+                dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_rx_buff, si->dma_rx_buff_phy);
+
+        printk(KERN_DEBUG "pxa_ir: irda driver closed\n");
+        return 0;
+}
+
+static int pxa_irda_suspend(struct device *_dev, pm_message_t state)
+{
+        struct net_device *dev = dev_get_drvdata(_dev);
+        struct pxa_irda *si;
+
+        if (dev && netif_running(dev)) {
+                si = netdev_priv(dev);
+                netif_device_detach(dev);
+                pxa_irda_shutdown(si);
+        }
+
+        return 0;
+}
+
+static int pxa_irda_resume(struct device *_dev)
+{
+        struct net_device *dev = dev_get_drvdata(_dev);
+        struct pxa_irda *si;
+
+        if (dev && netif_running(dev)) {
+                si = netdev_priv(dev);
+                pxa_irda_startup(si);
+                netif_device_attach(dev);
+                netif_wake_queue(dev);
+        }
+
+        return 0;
+}
+
+
+static int pxa_irda_init_iobuf(iobuff_t *io, int size)
+{
+        io->head = kmalloc(size, GFP_KERNEL | GFP_DMA);
+        if (io->head != NULL) {
+                io->truesize = size;
+                io->in_frame = FALSE;
+                io->state    = OUTSIDE_FRAME;
+                io->data     = io->head;
+        }
+        return io->head ? 0 : -ENOMEM;
+}
+
+static int pxa_irda_probe(struct device *_dev)
+{
+        struct platform_device *pdev = to_platform_device(_dev);
+        struct net_device *dev;
+        struct pxa_irda *si;
+        unsigned int baudrate_mask;
+        int err;
+
+        if (!pdev->dev.platform_data)
+                return -ENODEV;
+
+        err = request_mem_region(__PREG(STUART), 0x24, "IrDA") ? 0 : -EBUSY;
+        if (err)
+                goto err_mem_1;
+
+        err = request_mem_region(__PREG(FICP), 0x1c, "IrDA") ? 0 : -EBUSY;
+        if (err)
+                goto err_mem_2;
+
+        dev = alloc_irdadev(sizeof(struct pxa_irda));
+        if (!dev)
+                goto err_mem_3;
+
+        si = netdev_priv(dev);
+        si->dev = &pdev->dev;
+        si->pdata = pdev->dev.platform_data;
+
+        /*
+         * Initialise the SIR buffers
+         */
+        err = pxa_irda_init_iobuf(&si->rx_buff, 14384);
+        if (err)
+                goto err_mem_4;
+        err = pxa_irda_init_iobuf(&si->tx_buff, 4000);
+        if (err)
+                goto err_mem_5;
+
+        dev->hard_start_xmit    = pxa_irda_hard_xmit;
+        dev->open               = pxa_irda_start;
+        dev->stop               = pxa_irda_stop;
+        dev->do_ioctl           = pxa_irda_ioctl;
+        dev->get_stats          = pxa_irda_stats;
+
+        irda_init_max_qos_capabilies(&si->qos);
+
+        baudrate_mask = 0;
+        if (si->pdata->transceiver_cap & IR_SIRMODE)
+                baudrate_mask |= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
+        if (si->pdata->transceiver_cap & IR_FIRMODE)
+                baudrate_mask |= IR_4000000 << 8;
+
+        si->qos.baud_rate.bits &= baudrate_mask;
+        si->qos.min_turn_time.bits = 7;  /* 1ms or more */
+
+        irda_qos_bits_to_value(&si->qos);
+
+        err = register_netdev(dev);
+
+        if (err == 0)
+                dev_set_drvdata(&pdev->dev, dev);
+
+        if (err) {
+                kfree(si->tx_buff.head);
+err_mem_5:
+                kfree(si->rx_buff.head);
+err_mem_4:
+                free_netdev(dev);
+err_mem_3:
+                release_mem_region(__PREG(FICP), 0x1c);
+err_mem_2:
+                release_mem_region(__PREG(STUART), 0x24);
+        }
+err_mem_1:
+        return err;
+}
+
+static int pxa_irda_remove(struct device *_dev)
+{
+        struct net_device *dev = dev_get_drvdata(_dev);
+
+        if (dev) {
+                struct pxa_irda *si = netdev_priv(dev);
+                unregister_netdev(dev);
+                kfree(si->tx_buff.head);
+                kfree(si->rx_buff.head);
+                free_netdev(dev);
+        }
+
+        release_mem_region(__PREG(STUART), 0x24);
+        release_mem_region(__PREG(FICP), 0x1c);
+
+        return 0;
+}
+
+static struct device_driver pxa_ir_driver = {
+        .name           = "pxa2xx-ir",
+        .bus            = &platform_bus_type,
+        .probe          = pxa_irda_probe,
+        .remove         = pxa_irda_remove,
+        .suspend        = pxa_irda_suspend,
+        .resume         = pxa_irda_resume,
+};
+
+static int __init pxa_irda_init(void)
+{
+        return driver_register(&pxa_ir_driver);
+}
+
+static void __exit pxa_irda_exit(void)
+{
+        driver_unregister(&pxa_ir_driver);
+}
+
+module_init(pxa_irda_init);
+module_exit(pxa_irda_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/irda/sa1100_ir.c b/drivers/net/irda/sa1100_ir.c
index 8d34ac60d906..06883309916d 100644
--- a/drivers/net/irda/sa1100_ir.c
+++ b/drivers/net/irda/sa1100_ir.c
@@ -291,12 +291,12 @@ static void sa1100_irda_shutdown(struct sa1100_irda *si)
 /*
  * Suspend the IrDA interface.
  */
-static int sa1100_irda_suspend(struct device *_dev, pm_message_t state, u32 level)
+static int sa1100_irda_suspend(struct device *_dev, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(_dev);
         struct sa1100_irda *si;
 
-        if (!dev || level != SUSPEND_DISABLE)
+        if (!dev)
                 return 0;
 
         si = dev->priv;
@@ -316,12 +316,12 @@ static int sa1100_irda_suspend(struct device *_dev, pm_message_t state, u32 leve
 /*
  * Resume the IrDA interface.
  */
-static int sa1100_irda_resume(struct device *_dev, u32 level)
+static int sa1100_irda_resume(struct device *_dev)
 {
         struct net_device *dev = dev_get_drvdata(_dev);
         struct sa1100_irda *si;
 
-        if (!dev || level != RESUME_ENABLE)
+        if (!dev)
                 return 0;
 
         si = dev->priv;
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index efc5a8870565..df22b8b532e7 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -490,8 +490,7 @@ static void sirdev_free_buffers(struct sir_dev *dev)
 {
         if (dev->rx_buff.skb)
                 kfree_skb(dev->rx_buff.skb);
-        if (dev->tx_buff.head)
-                kfree(dev->tx_buff.head);
+        kfree(dev->tx_buff.head);
         dev->rx_buff.head = dev->tx_buff.head = NULL;
         dev->rx_buff.skb = NULL;
 }
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index dd89bda1f131..140b7cdb1f7e 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -213,8 +213,8 @@ static int  smsc_ircc_probe_transceiver_smsc_ircc_atc(int fir_base);
 
 /* Power Management */
 
-static int smsc_ircc_suspend(struct device *dev, pm_message_t state, u32 level);
-static int smsc_ircc_resume(struct device *dev, u32 level);
+static int smsc_ircc_suspend(struct device *dev, pm_message_t state);
+static int smsc_ircc_resume(struct device *dev);
 
 static struct device_driver smsc_ircc_driver = {
         .name           = SMSC_IRCC2_DRIVER_NAME,
@@ -638,21 +638,14 @@ static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self)
  */
 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self)
 {
-        int iobase, ir_mode, ctrl, fast;
-
-        IRDA_ASSERT(self != NULL, return;);
-
-        iobase = self->io.fir_base;
-        ir_mode = IRCC_CFGA_IRDA_SIR_A;
-        ctrl = 0;
-        fast = 0;
+        int iobase = self->io.fir_base;
 
         register_bank(iobase, 0);
         outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
         outb(0x00, iobase + IRCC_MASTER);
 
         register_bank(iobase, 1);
-        outb(((inb(iobase + IRCC_SCE_CFGA) & 0x87) | ir_mode),
+        outb(((inb(iobase + IRCC_SCE_CFGA) & 0x87) | IRCC_CFGA_IRDA_SIR_A),
              iobase + IRCC_SCE_CFGA);
 
 #ifdef smsc_669 /* Uses pin 88/89 for Rx/Tx */
@@ -666,10 +659,10 @@ static void smsc_ircc_init_chip(struct smsc_ircc_cb *self)
         outb(SMSC_IRCC2_FIFO_THRESHOLD, iobase + IRCC_FIFO_THRESHOLD);
 
         register_bank(iobase, 4);
-        outb((inb(iobase + IRCC_CONTROL) & 0x30) | ctrl, iobase + IRCC_CONTROL);
+        outb((inb(iobase + IRCC_CONTROL) & 0x30), iobase + IRCC_CONTROL);
 
         register_bank(iobase, 0);
-        outb(fast, iobase + IRCC_LCR_A);
+        outb(0, iobase + IRCC_LCR_A);
 
         smsc_ircc_set_sir_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
 
@@ -1556,6 +1549,46 @@ static int ircc_is_receiving(struct smsc_ircc_cb *self)
 }
 #endif /* unused */
 
+static int smsc_ircc_request_irq(struct smsc_ircc_cb *self)
+{
+        int error;
+
+        error = request_irq(self->io.irq, smsc_ircc_interrupt, 0,
+                            self->netdev->name, self->netdev);
+        if (error)
+                IRDA_DEBUG(0, "%s(), unable to allocate irq=%d, err=%d\n",
+                           __FUNCTION__, self->io.irq, error);
+
+        return error;
+}
+
+static void smsc_ircc_start_interrupts(struct smsc_ircc_cb *self)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&self->lock, flags);
+
+        self->io.speed = 0;
+        smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
+
+        spin_unlock_irqrestore(&self->lock, flags);
+}
+
+static void smsc_ircc_stop_interrupts(struct smsc_ircc_cb *self)
+{
+        int iobase = self->io.fir_base;
+        unsigned long flags;
+
+        spin_lock_irqsave(&self->lock, flags);
+
+        register_bank(iobase, 0);
+        outb(0, iobase + IRCC_IER);
+        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
+        outb(0x00, iobase + IRCC_MASTER);
+
+        spin_unlock_irqrestore(&self->lock, flags);
+}
+
 
 /*
  * Function smsc_ircc_net_open (dev)
@@ -1567,7 +1600,6 @@ static int smsc_ircc_net_open(struct net_device *dev)
 {
         struct smsc_ircc_cb *self;
         char hwname[16];
-        unsigned long flags;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
@@ -1575,6 +1607,11 @@ static int smsc_ircc_net_open(struct net_device *dev)
         self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return 0;);
 
+        if (self->io.suspended) {
+                IRDA_DEBUG(0, "%s(), device is suspended\n", __FUNCTION__);
+                return -EAGAIN;
+        }
+
         if (request_irq(self->io.irq, smsc_ircc_interrupt, 0, dev->name,
                         (void *) dev)) {
                 IRDA_DEBUG(0, "%s(), unable to allocate irq=%d\n",
@@ -1582,11 +1619,7 @@ static int smsc_ircc_net_open(struct net_device *dev)
                 return -EAGAIN;
         }
 
-        spin_lock_irqsave(&self->lock, flags);
-        /*smsc_ircc_sir_start(self);*/
-        self->io.speed = 0;
-        smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
-        spin_unlock_irqrestore(&self->lock, flags);
+        smsc_ircc_start_interrupts(self);
 
         /* Give self a hardware name */
         /* It would be cool to offer the chip revision here - Jean II */
@@ -1639,37 +1672,63 @@ static int smsc_ircc_net_close(struct net_device *dev)
                 irlap_close(self->irlap);
         self->irlap = NULL;
 
-        free_irq(self->io.irq, dev);
+        smsc_ircc_stop_interrupts(self);
+
+        /* if we are called from smsc_ircc_resume we don't have IRQ reserved */
+        if (!self->io.suspended)
+                free_irq(self->io.irq, dev);
+
         disable_dma(self->io.dma);
         free_dma(self->io.dma);
 
         return 0;
 }
 
-static int smsc_ircc_suspend(struct device *dev, pm_message_t state, u32 level)
+static int smsc_ircc_suspend(struct device *dev, pm_message_t state)
 {
         struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
-        IRDA_MESSAGE("%s, Suspending\n", driver_name);
+        if (!self->io.suspended) {
+                IRDA_DEBUG(1, "%s, Suspending\n", driver_name);
 
-        if (level == SUSPEND_DISABLE && !self->io.suspended) {
-                smsc_ircc_net_close(self->netdev);
+                rtnl_lock();
+                if (netif_running(self->netdev)) {
+                        netif_device_detach(self->netdev);
+                        smsc_ircc_stop_interrupts(self);
+                        free_irq(self->io.irq, self->netdev);
+                        disable_dma(self->io.dma);
+                }
                 self->io.suspended = 1;
+                rtnl_unlock();
         }
 
         return 0;
 }
 
-static int smsc_ircc_resume(struct device *dev, u32 level)
+static int smsc_ircc_resume(struct device *dev)
 {
         struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
-        if (level == RESUME_ENABLE && self->io.suspended) {
-
-                smsc_ircc_net_open(self->netdev);
+        if (self->io.suspended) {
+                IRDA_DEBUG(1, "%s, Waking up\n", driver_name);
+
+                rtnl_lock();
+                smsc_ircc_init_chip(self);
+                if (netif_running(self->netdev)) {
+                        if (smsc_ircc_request_irq(self)) {
+                                /*
+                                 * Don't fail resume process, just kill this
+                                 * network interface
+                                 */
+                                unregister_netdevice(self->netdev);
+                        } else {
+                                enable_dma(self->io.dma);
+                                smsc_ircc_start_interrupts(self);
+                                netif_device_attach(self->netdev);
+                        }
+                }
                 self->io.suspended = 0;
-
-                IRDA_MESSAGE("%s, Waking up\n", driver_name);
+                rtnl_unlock();
         }
         return 0;
 }
@@ -1682,9 +1741,6 @@ static int smsc_ircc_resume(struct device *dev, u32 level)
  */
 static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
 {
-        int iobase;
-        unsigned long flags;
-
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
         IRDA_ASSERT(self != NULL, return -1;);
@@ -1694,22 +1750,7 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
         /* Remove netdevice */
         unregister_netdev(self->netdev);
 
-        /* Make sure the irq handler is not exectuting */
-        spin_lock_irqsave(&self->lock, flags);
-
-        /* Stop interrupts */
-        iobase = self->io.fir_base;
-        register_bank(iobase, 0);
-        outb(0, iobase + IRCC_IER);
-        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
-        outb(0x00, iobase + IRCC_MASTER);
-#if 0
-        /* Reset to SIR mode */
-        register_bank(iobase, 1);
-        outb(IRCC_CFGA_IRDA_SIR_A|IRCC_CFGA_TX_POLARITY, iobase + IRCC_SCE_CFGA);
-        outb(IRCC_CFGB_IR, iobase + IRCC_SCE_CFGB);
-#endif
-        spin_unlock_irqrestore(&self->lock, flags);
+        smsc_ircc_stop_interrupts(self);
 
         /* Release the PORTS that this driver is using */
         IRDA_DEBUG(0, "%s(), releasing 0x%03x\n",  __FUNCTION__,
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c
index 15f207323d97..3961a754e920 100644
--- a/drivers/net/irda/stir4200.c
+++ b/drivers/net/irda/stir4200.c
@@ -678,10 +678,9 @@ static void turnaround_delay(const struct stir_cb *stir, long us)
                 return;
 
         ticks = us / (1000000 / HZ);
-        if (ticks > 0) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule_timeout(1 + ticks);
-        } else
+        if (ticks > 0)
+                schedule_timeout_interruptible(1 + ticks);
+        else
                 udelay(us);
 }
 
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
index 651c5a6578fd..a9f49f058cfb 100644
--- a/drivers/net/irda/vlsi_ir.c
+++ b/drivers/net/irda/vlsi_ir.c
@@ -473,8 +473,7 @@ static int vlsi_free_ring(struct vlsi_ring *r)
                 rd_set_addr_status(rd, 0, 0);
                 if (busaddr)
                         pci_unmap_single(r->pdev, busaddr, r->len, r->dir);
-                if (rd->buf)
-                        kfree(rd->buf);
+                kfree(rd->buf);
         }
         kfree(r);
         return 0;
diff --git a/drivers/net/ixgb/ixgb_ethtool.c b/drivers/net/ixgb/ixgb_ethtool.c
index 9d026ed77ddd..04e47189d830 100644
--- a/drivers/net/ixgb/ixgb_ethtool.c
+++ b/drivers/net/ixgb/ixgb_ethtool.c
@@ -645,11 +645,10 @@ ixgb_phys_id(struct net_device *netdev, uint32_t data)
 
         mod_timer(&adapter->blink_timer, jiffies);
 
-        set_current_state(TASK_INTERRUPTIBLE);
-        if(data)
-                schedule_timeout(data * HZ);
+        if (data)
+                schedule_timeout_interruptible(data * HZ);
         else
-                schedule_timeout(MAX_SCHEDULE_TIMEOUT);
+                schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT);
 
         del_timer_sync(&adapter->blink_timer);
         ixgb_led_off(&adapter->hw);
@@ -723,6 +722,7 @@ struct ethtool_ops ixgb_ethtool_ops = {
         .phys_id = ixgb_phys_id,
         .get_stats_count = ixgb_get_stats_count,
         .get_ethtool_stats = ixgb_get_ethtool_stats,
+        .get_perm_addr = ethtool_op_get_perm_addr,
 };
 
 void ixgb_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index 89d6d69be382..176680cb153e 100644
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -460,8 +460,9 @@ ixgb_probe(struct pci_dev *pdev,
         }
 
         ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
+        memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
 
-        if(!is_valid_ether_addr(netdev->dev_addr)) {
+        if(!is_valid_ether_addr(netdev->perm_addr)) {
                 err = -EIO;
                 goto err_eeprom;
         }
diff --git a/drivers/net/lance.c b/drivers/net/lance.c
index b4929beb33b2..1d75ca0bb939 100644
--- a/drivers/net/lance.c
+++ b/drivers/net/lance.c
@@ -298,7 +298,7 @@ enum {OLD_LANCE = 0, PCNET_ISA=1, PCNET_ISAP=2, PCNET_PCI=3, PCNET_VLB=4, PCNET_
 static unsigned char lance_need_isa_bounce_buffers = 1;
 
 static int lance_open(struct net_device *dev);
-static void lance_init_ring(struct net_device *dev, int mode);
+static void lance_init_ring(struct net_device *dev, gfp_t mode);
 static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static int lance_rx(struct net_device *dev);
 static irqreturn_t lance_interrupt(int irq, void *dev_id, struct pt_regs *regs);
@@ -846,7 +846,7 @@ lance_purge_ring(struct net_device *dev)
 
 /* Initialize the LANCE Rx and Tx rings. */
 static void
-lance_init_ring(struct net_device *dev, int gfp)
+lance_init_ring(struct net_device *dev, gfp_t gfp)
 {
         struct lance_private *lp = dev->priv;
         int i;
diff --git a/drivers/net/lasi_82596.c b/drivers/net/lasi_82596.c
index 41bad07ac1ac..f7b7238d8352 100644
--- a/drivers/net/lasi_82596.c
+++ b/drivers/net/lasi_82596.c
@@ -415,6 +415,10 @@ static int rx_ring_size = RX_RING_SIZE;
 static int ticks_limit = 100;
 static int max_cmd_backlog = TX_RING_SIZE-1;
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void i596_poll_controller(struct net_device *dev);
+#endif
+
 
 static inline void CA(struct net_device *dev)
 {
@@ -636,11 +640,11 @@ static int init_i596_mem(struct net_device *dev)
 
         disable_irq(dev->irq);  /* disable IRQs from LAN */
         DEB(DEB_INIT,
-                printk("RESET 82596 port: %p (with IRQ %d disabled)\n",
-                       (void*)(dev->base_addr + PA_I82596_RESET),
+                printk("RESET 82596 port: %lx (with IRQ %d disabled)\n",
+                       (dev->base_addr + PA_I82596_RESET),
                        dev->irq));
         
-        gsc_writel(0, (void*)(dev->base_addr + PA_I82596_RESET)); /* Hard Reset */
+        gsc_writel(0, (dev->base_addr + PA_I82596_RESET)); /* Hard Reset */
         udelay(100);                    /* Wait 100us - seems to help */
 
         /* change the scp address */
@@ -1209,6 +1213,9 @@ static int __devinit i82596_probe(struct net_device *dev,
         dev->set_multicast_list = set_multicast_list;
         dev->tx_timeout = i596_tx_timeout;
         dev->watchdog_timeo = TX_TIMEOUT;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = i596_poll_controller;
+#endif
 
         dev->priv = (void *)(dev->mem_start);
 
@@ -1242,6 +1249,14 @@ static int __devinit i82596_probe(struct net_device *dev,
         return 0;
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void i596_poll_controller(struct net_device *dev)
+{
+        disable_irq(dev->irq);
+        i596_interrupt(dev->irq, dev, NULL);
+        enable_irq(dev->irq);
+}
+#endif
 
 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
@@ -1528,17 +1543,18 @@ lan_init_chip(struct parisc_device *dev)
         
         if (!dev->irq) {
                 printk(KERN_ERR "%s: IRQ not found for i82596 at 0x%lx\n",
-                        __FILE__, dev->hpa);
+                        __FILE__, dev->hpa.start);
                 return -ENODEV;
         }
 
-        printk(KERN_INFO "Found i82596 at 0x%lx, IRQ %d\n", dev->hpa, dev->irq);
+        printk(KERN_INFO "Found i82596 at 0x%lx, IRQ %d\n", dev->hpa.start,
+                        dev->irq);
 
         netdevice = alloc_etherdev(0);
         if (!netdevice)
                 return -ENOMEM;
 
-        netdevice->base_addr = dev->hpa;
+        netdevice->base_addr = dev->hpa.start;
         netdevice->irq = dev->irq;
 
         retval = i82596_probe(netdevice, &dev->dev);
@@ -1566,7 +1582,7 @@ static struct parisc_device_id lan_tbl[] = {
 MODULE_DEVICE_TABLE(parisc, lan_tbl);
 
 static struct parisc_driver lan_driver = {
-        .name           = "Apricot",
+        .name           = "lasi_82596",
         .id_table       = lan_tbl,
         .probe          = lan_init_chip,
 };
diff --git a/drivers/net/lne390.c b/drivers/net/lne390.c
index 27f0d8ac4c40..309d254842cf 100644
--- a/drivers/net/lne390.c
+++ b/drivers/net/lne390.c
@@ -298,7 +298,7 @@ static int __init lne390_probe1(struct net_device *dev, int ioaddr)
         return 0;
 unmap:
         if (ei_status.reg0)
-                iounmap((void *)dev->mem_start);
+                iounmap(ei_status.mem);
 cleanup:
         free_irq(dev->irq, dev);
         return ret;
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index f2fc1f26cd4b..2a5add257b8f 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -1036,10 +1036,8 @@ static void __exit mace_cleanup(void)
 {
         macio_unregister_driver(&mace_driver);
 
-        if (dummy_buf) {
-                kfree(dummy_buf);
-                dummy_buf = NULL;
-        }
+        kfree(dummy_buf);
+        dummy_buf = NULL;
 }
 
 MODULE_AUTHOR("Paul Mackerras");
diff --git a/drivers/net/mii.c b/drivers/net/mii.c
index c33cb3dc942b..e42aa797f08b 100644
--- a/drivers/net/mii.c
+++ b/drivers/net/mii.c
@@ -207,6 +207,20 @@ int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
         return 0;
 }
 
+int mii_check_gmii_support(struct mii_if_info *mii)
+{
+        int reg;
+
+        reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+        if (reg & BMSR_ESTATEN) {
+                reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
+                if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
+                        return 1;
+        }
+
+        return 0;
+}
+
 int mii_link_ok (struct mii_if_info *mii)
 {
         /* first, a dummy read, needed to latch some MII phys */
@@ -394,5 +408,6 @@ EXPORT_SYMBOL(mii_ethtool_gset);
 EXPORT_SYMBOL(mii_ethtool_sset);
 EXPORT_SYMBOL(mii_check_link);
 EXPORT_SYMBOL(mii_check_media);
+EXPORT_SYMBOL(mii_check_gmii_support);
 EXPORT_SYMBOL(generic_mii_ioctl);
 
diff --git a/drivers/net/mipsnet.c b/drivers/net/mipsnet.c
new file mode 100644
index 000000000000..f79f7ee72ab8
--- /dev/null
+++ b/drivers/net/mipsnet.c
@@ -0,0 +1,371 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#define DEBUG
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/sched.h>
+#include <linux/etherdevice.h>
+#include <linux/netdevice.h>
+#include <asm/io.h>
+#include <asm/mips-boards/simint.h>
+
+#include "mipsnet.h"            /* actual device IO mapping */
+
+#define MIPSNET_VERSION "2005-06-20"
+
+#define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
+
+struct mipsnet_priv {
+        struct net_device_stats stats;
+};
+
+static struct platform_device *mips_plat_dev;
+
+static char mipsnet_string[] = "mipsnet";
+
+/*
+ * Copy data from the MIPSNET rx data port
+ */
+static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
+                        int len)
+{
+        uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
+        if (available_len < len)
+                return -EFAULT;
+
+        for (; len > 0; len--, kdata++) {
+                *kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
+        }
+
+        return inl(mipsnet_reg_address(dev, rxDataCount));
+}
+
+static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
+        struct sk_buff *skb)
+{
+        int count_to_go = skb->len;
+        char *buf_ptr = skb->data;
+        struct mipsnet_priv *mp = netdev_priv(dev);
+
+        pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
+                 dev->name, __FUNCTION__, skb->len);
+
+        outl(skb->len, mipsnet_reg_address(dev, txDataCount));
+
+        pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
+                 dev->name, __FUNCTION__, skb->len);
+
+        for (; count_to_go; buf_ptr++, count_to_go--) {
+                outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
+        }
+
+        mp->stats.tx_packets++;
+        mp->stats.tx_bytes += skb->len;
+
+        return skb->len;
+}
+
+static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        pr_debug("%s:%s(): transmitting %d bytes\n",
+                 dev->name, __FUNCTION__, skb->len);
+
+        /* Only one packet at a time. Once TXDONE interrupt is serviced, the
+         * queue will be restarted.
+         */
+        netif_stop_queue(dev);
+        mipsnet_put_todevice(dev, skb);
+
+        return 0;
+}
+
+static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
+{
+        struct sk_buff *skb;
+        size_t len = count;
+        struct mipsnet_priv *mp = netdev_priv(dev);
+
+        if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
+                mp->stats.rx_dropped++;
+                return -ENOMEM;
+        }
+
+        skb_reserve(skb, 2);
+        if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
+                return -EFAULT;
+
+        skb->dev = dev;
+        skb->protocol = eth_type_trans(skb, dev);
+        skb->ip_summed = CHECKSUM_UNNECESSARY;
+
+        pr_debug("%s:%s(): pushing RXed data to kernel\n",
+                 dev->name, __FUNCTION__);
+        netif_rx(skb);
+
+        mp->stats.rx_packets++;
+        mp->stats.rx_bytes += len;
+
+        return count;
+}
+
+static irqreturn_t
+mipsnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+
+        irqreturn_t retval = IRQ_NONE;
+        uint64_t interruptFlags;
+
+        if (irq == dev->irq) {
+                pr_debug("%s:%s(): irq %d for device\n",
+                         dev->name, __FUNCTION__, irq);
+
+                retval = IRQ_HANDLED;
+
+                interruptFlags =
+                    inl(mipsnet_reg_address(dev, interruptControl));
+                pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
+                         __FUNCTION__, interruptFlags);
+
+                if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
+                        pr_debug("%s:%s(): got TXDone\n",
+                                 dev->name, __FUNCTION__);
+                        outl(MIPSNET_INTCTL_TXDONE,
+                             mipsnet_reg_address(dev, interruptControl));
+                        // only one packet at a time, we are done.
+                        netif_wake_queue(dev);
+                } else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
+                        pr_debug("%s:%s(): got RX data\n",
+                                 dev->name, __FUNCTION__);
+                        mipsnet_get_fromdev(dev,
+                                    inl(mipsnet_reg_address(dev, rxDataCount)));
+                        pr_debug("%s:%s(): clearing RX int\n",
+                                 dev->name, __FUNCTION__);
+                        outl(MIPSNET_INTCTL_RXDONE,
+                             mipsnet_reg_address(dev, interruptControl));
+
+                } else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
+                        pr_debug("%s:%s(): got test interrupt\n",
+                                 dev->name, __FUNCTION__);
+                        // TESTBIT is cleared on read.
+                        //    And takes effect after a write with 0
+                        outl(0, mipsnet_reg_address(dev, interruptControl));
+                } else {
+                        pr_debug("%s:%s(): no valid fags 0x%016llx\n",
+                                 dev->name, __FUNCTION__, interruptFlags);
+                        // Maybe shared IRQ, just ignore, no clearing.
+                        retval = IRQ_NONE;
+                }
+
+        } else {
+                printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
+                       dev->name, __FUNCTION__, irq);
+                retval = IRQ_NONE;
+        }
+        return retval;
+}                               //mipsnet_interrupt()
+
+static int mipsnet_open(struct net_device *dev)
+{
+        int err;
+        pr_debug("%s: mipsnet_open\n", dev->name);
+
+        err = request_irq(dev->irq, &mipsnet_interrupt,
+                          SA_SHIRQ, dev->name, (void *) dev);
+
+        if (err) {
+                pr_debug("%s: %s(): can't get irq %d\n",
+                         dev->name, __FUNCTION__, dev->irq);
+                release_region(dev->base_addr, MIPSNET_IO_EXTENT);
+                return err;
+        }
+
+        pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
+                 dev->name, __FUNCTION__, dev->base_addr, dev->irq);
+
+
+        netif_start_queue(dev);
+
+        // test interrupt handler
+        outl(MIPSNET_INTCTL_TESTBIT,
+             mipsnet_reg_address(dev, interruptControl));
+
+
+        return 0;
+}
+
+static int mipsnet_close(struct net_device *dev)
+{
+        pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
+        netif_stop_queue(dev);
+        return 0;
+}
+
+static struct net_device_stats *mipsnet_get_stats(struct net_device *dev)
+{
+        struct mipsnet_priv *mp = netdev_priv(dev);
+
+        return &mp->stats;
+}
+
+static void mipsnet_set_mclist(struct net_device *dev)
+{
+        // we don't do anything
+        return;
+}
+
+static int __init mipsnet_probe(struct device *dev)
+{
+        struct net_device *netdev;
+        int err;
+
+        netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
+        if (!netdev) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        dev_set_drvdata(dev, netdev);
+
+        netdev->open                    = mipsnet_open;
+        netdev->stop                    = mipsnet_close;
+        netdev->hard_start_xmit         = mipsnet_xmit;
+        netdev->get_stats               = mipsnet_get_stats;
+        netdev->set_multicast_list      = mipsnet_set_mclist;
+
+        /*
+         * TODO: probe for these or load them from PARAM
+         */
+        netdev->base_addr = 0x4200;
+        netdev->irq = MIPSCPU_INT_BASE + MIPSCPU_INT_MB0 +
+                      inl(mipsnet_reg_address(netdev, interruptInfo));
+
+        // Get the io region now, get irq on open()
+        if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
+                pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
+                         "for dev is not availble.\n", netdev->name,
+                         __FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
+                err = -EBUSY;
+                goto out_free_netdev;
+        }
+
+        /*
+         * Lacking any better mechanism to allocate a MAC address we use a
+         * random one ...
+         */
+        random_ether_addr(netdev->dev_addr);
+
+        err = register_netdev(netdev);
+        if (err) {
+                printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
+                goto out_free_region;
+        }
+
+        return 0;
+
+out_free_region:
+        release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
+
+out_free_netdev:
+        free_netdev(netdev);
+
+out:
+        return err;
+}
+
+static int __devexit mipsnet_device_remove(struct device *device)
+{
+        struct net_device *dev = dev_get_drvdata(device);
+
+        unregister_netdev(dev);
+        release_region(dev->base_addr, MIPSNET_IO_EXTENT);
+        free_netdev(dev);
+        dev_set_drvdata(device, NULL);
+
+        return 0;
+}
+
+static struct device_driver mipsnet_driver = {
+        .name   = mipsnet_string,
+        .bus    = &platform_bus_type,
+        .probe  = mipsnet_probe,
+        .remove = __devexit_p(mipsnet_device_remove),
+};
+
+static void mipsnet_platform_release(struct device *device)
+{
+        struct platform_device *pldev;
+
+        /* free device */
+        pldev = to_platform_device(device);
+        kfree(pldev);
+}
+
+static int __init mipsnet_init_module(void)
+{
+        struct platform_device *pldev;
+        int err;
+
+        printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
+               "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
+
+        if (driver_register(&mipsnet_driver)) {
+                printk(KERN_ERR "Driver registration failed\n");
+                err = -ENODEV;
+                goto out;
+        }
+
+        if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto out_unregister_driver;
+        }
+
+        memset (pldev, 0, sizeof (*pldev));
+        pldev->name             = mipsnet_string;
+        pldev->id               = 0;
+        pldev->dev.release      = mipsnet_platform_release;
+
+        if (platform_device_register(pldev)) {
+                err = -ENODEV;
+                goto out_free_pldev;
+        }
+
+        if (!pldev->dev.driver) {
+                /*
+                 * The driver was not bound to this device, there was
+                 * no hardware at this address. Unregister it, as the
+                 * release fuction will take care of freeing the
+                 * allocated structure
+                 */
+                platform_device_unregister (pldev);
+        }
+
+        mips_plat_dev           = pldev;
+
+        return 0;
+
+out_free_pldev:
+        kfree(pldev);
+
+out_unregister_driver:
+        driver_unregister(&mipsnet_driver);
+out:
+        return err;
+}
+
+static void __exit mipsnet_exit_module(void)
+{
+        pr_debug("MIPSNet Ethernet driver exiting\n");
+
+        driver_unregister(&mipsnet_driver);
+}
+
+module_init(mipsnet_init_module);
+module_exit(mipsnet_exit_module);
diff --git a/drivers/net/mipsnet.h b/drivers/net/mipsnet.h
new file mode 100644
index 000000000000..878535953cb1
--- /dev/null
+++ b/drivers/net/mipsnet.h
@@ -0,0 +1,127 @@
+//
+// <COPYRIGHT CLASS="1B" YEAR="2005">
+// Unpublished work (c) MIPS Technologies, Inc.  All rights reserved.
+// Unpublished rights reserved under the copyright laws of the U.S.A. and
+//  other countries.
+//
+// PROPRIETARY / SECRET CONFIDENTIAL INFORMATION OF MIPS TECHNOLOGIES, INC.
+// FOR INTERNAL USE ONLY.
+//
+// Under no circumstances (contract or otherwise) may this information be
+// disclosed to, or copied, modified or used by anyone other than employees
+// or contractors of MIPS Technologies having a need to know.
+// </COPYRIGHT>
+//
+//++
+// File: MIPS_Net.h
+//
+// Description:
+//   The definition of the emulated MIPSNET device's interface.
+//
+// Notes: This include file needs to work from a Linux device drivers.
+//
+//--
+//
+
+#ifndef __MIPSNET_H
+#define __MIPSNET_H
+
+/*
+ *  Id of this Net device, as seen by the core.
+ */
+#define MIPS_NET_DEV_ID ((uint64_t)           \
+                             ((uint64_t)'M'<< 0)| \
+                             ((uint64_t)'I'<< 8)| \
+                             ((uint64_t)'P'<<16)| \
+                             ((uint64_t)'S'<<24)| \
+                             ((uint64_t)'N'<<32)| \
+                             ((uint64_t)'E'<<40)| \
+                             ((uint64_t)'T'<<48)| \
+                             ((uint64_t)'0'<<56))
+
+/*
+ * Net status/control block as seen by sw in the core.
+ * (Why not use bit fields? can't be bothered with cross-platform struct
+ *  packing.)
+ */
+typedef struct _net_control_block {
+        /// dev info for probing
+        ///  reads as MIPSNET%d where %d is some form of version
+        uint64_t devId;         /*0x00 */
+
+        /*
+         * read only busy flag.
+         * Set and cleared by the Net Device to indicate that an rx or a tx
+         * is in progress.
+         */
+        uint32_t busy;          /*0x08 */
+
+        /*
+         * Set by the Net Device.
+         * The device will set it once data has been received.
+         * The value is the number of bytes that should be read from
+         * rxDataBuffer.  The value will decrease till 0 until all the data
+         * from rxDataBuffer has been read.
+         */
+        uint32_t rxDataCount;   /*0x0c */
+#define MIPSNET_MAX_RXTX_DATACOUNT (1<<16)
+
+        /*
+         * Settable from the MIPS core, cleared by the Net Device.
+         * The core should set the number of bytes it wants to send,
+         *   then it should write those bytes of data to txDataBuffer.
+         * The device will clear txDataCount has been processed (not necessarily sent).
+         */
+        uint32_t txDataCount;   /*0x10 */
+
+        /*
+         * Interrupt control
+         *
+         * Used to clear the interrupted generated by this dev.
+         * Write a 1 to clear the interrupt. (except bit31).
+         *
+         * Bit0 is set if it was a tx-done interrupt.
+         * Bit1 is set when new rx-data is available.
+         *      Until this bit is cleared there will be no other RXs.
+         *
+         * Bit31 is used for testing, it clears after a read.
+         *    Writing 1 to this bit will cause an interrupt to be generated.
+         *    To clear the test interrupt, write 0 to this register.
+         */
+        uint32_t interruptControl;      /*0x14 */
+#define MIPSNET_INTCTL_TXDONE     ((uint32_t)(1<< 0))
+#define MIPSNET_INTCTL_RXDONE     ((uint32_t)(1<< 1))
+#define MIPSNET_INTCTL_TESTBIT    ((uint32_t)(1<<31))
+#define MIPSNET_INTCTL_ALLSOURCES (MIPSNET_INTCTL_TXDONE|MIPSNET_INTCTL_RXDONE|MIPSNET_INTCTL_TESTBIT)
+
+        /*
+         * Readonly core-specific interrupt info for the device to signal the core.
+         * The meaning of the contents of this field might change.
+         */
+        /*###\todo: the whole memIntf interrupt scheme is messy: the device should have
+         *  no control what so ever of what VPE/register set is being used.
+         *  The MemIntf should only expose interrupt lines, and something in the
+         *  config should be responsible for the line<->core/vpe bindings.
+         */
+        uint32_t interruptInfo; /*0x18 */
+
+        /*
+         *  This is where the received data is read out.
+         *  There is more data to read until rxDataReady is 0.
+         *  Only 1 byte at this regs offset is used.
+         */
+        uint32_t rxDataBuffer;  /*0x1c */
+
+        /*
+         * This is where the data to transmit is written.
+         * Data should be written for the amount specified in the txDataCount register.
+         *  Only 1 byte at this regs offset is used.
+         */
+        uint32_t txDataBuffer;  /*0x20 */
+} MIPS_T_NetControl;
+
+#define MIPSNET_IO_EXTENT 0x40  /* being generous */
+
+#define field_offset(field) ((int)&((MIPS_T_NetControl*)(0))->field)
+
+#endif /* __MIPSNET_H */
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index f0996ce5c268..6c86dca62e2a 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -277,7 +277,7 @@ static void myri_init_rings(struct myri_eth *mp, int from_irq)
         struct recvq __iomem *rq = mp->rq;
         struct myri_rxd __iomem *rxd = &rq->myri_rxd[0];
         struct net_device *dev = mp->dev;
-        int gfp_flags = GFP_KERNEL;
+        gfp_t gfp_flags = GFP_KERNEL;
         int i;
 
         if (from_irq || in_interrupt())
diff --git a/drivers/net/myri_sbus.h b/drivers/net/myri_sbus.h
index 9391e55a5e92..47722f708a41 100644
--- a/drivers/net/myri_sbus.h
+++ b/drivers/net/myri_sbus.h
@@ -296,7 +296,7 @@ struct myri_eth {
 /* We use this to acquire receive skb's that we can DMA directly into. */
 #define ALIGNED_RX_SKB_ADDR(addr) \
         ((((unsigned long)(addr) + (64 - 1)) & ~(64 - 1)) - (unsigned long)(addr))
-static inline struct sk_buff *myri_alloc_skb(unsigned int length, int gfp_flags)
+static inline struct sk_buff *myri_alloc_skb(unsigned int length, gfp_t gfp_flags)
 {
         struct sk_buff *skb;
 
diff --git a/drivers/net/ne.c b/drivers/net/ne.c
index d209a1556b2e..0de8fdd2aa86 100644
--- a/drivers/net/ne.c
+++ b/drivers/net/ne.c
@@ -54,6 +54,10 @@ static const char version2[] =
 #include <asm/system.h>
 #include <asm/io.h>
 
+#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
+#include <asm/tx4938/rbtx4938.h>
+#endif
+
 #include "8390.h"
 
 #define DRV_NAME "ne"
@@ -111,6 +115,9 @@ bad_clone_list[] __initdata = {
     {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
     {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
     {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
+#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
+    {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}},  /* Toshiba built-in */
+#endif
     {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
     {NULL,}
 };
@@ -226,6 +233,10 @@ struct net_device * __init ne_probe(int unit)
         sprintf(dev->name, "eth%d", unit);
         netdev_boot_setup_check(dev);
 
+#ifdef CONFIG_TOSHIBA_RBTX4938
+        dev->base_addr = 0x07f20280;
+        dev->irq = RBTX4938_RTL_8019_IRQ;
+#endif
         err = do_ne_probe(dev);
         if (err)
                 goto out;
@@ -506,6 +517,10 @@ static int __init ne_probe1(struct net_device *dev, int ioaddr)
         ei_status.name = name;
         ei_status.tx_start_page = start_page;
         ei_status.stop_page = stop_page;
+#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
+        wordlength = 1;
+#endif
+
 #ifdef CONFIG_PLAT_OAKS32R
         ei_status.word16 = 0;
 #else
diff --git a/drivers/net/ne2k-pci.c b/drivers/net/ne2k-pci.c
index f1c01ac29102..d11821dd86ed 100644
--- a/drivers/net/ne2k-pci.c
+++ b/drivers/net/ne2k-pci.c
@@ -372,6 +372,7 @@ static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
                 printk("%2.2X%s", SA_prom[i], i == 5 ? ".\n": ":");
                 dev->dev_addr[i] = SA_prom[i];
         }
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         return 0;
 
@@ -637,6 +638,7 @@ static struct ethtool_ops ne2k_pci_ethtool_ops = {
         .get_drvinfo            = ne2k_pci_get_drvinfo,
         .get_tx_csum            = ethtool_op_get_tx_csum,
         .get_sg                 = ethtool_op_get_sg,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static void __devexit ne2k_pci_remove_one (struct pci_dev *pdev)
@@ -673,7 +675,6 @@ static int ne2k_pci_resume (struct pci_dev *pdev)
         pci_set_power_state(pdev, 0);
         pci_restore_state(pdev);
         pci_enable_device(pdev);
-        pci_set_master(pdev);
         NS8390_init(dev, 1);
         netif_device_attach(dev);
 
diff --git a/drivers/net/ni65.c b/drivers/net/ni65.c
index 925d1dfcc4dc..bb42ff218484 100644
--- a/drivers/net/ni65.c
+++ b/drivers/net/ni65.c
@@ -696,8 +696,7 @@ static void ni65_free_buffer(struct priv *p)
                 return;
 
         for(i=0;i<TMDNUM;i++) {
-                if(p->tmdbounce[i])
-                        kfree(p->tmdbounce[i]);
+                kfree(p->tmdbounce[i]);
 #ifdef XMT_VIA_SKB
                 if(p->tmd_skb[i])
                         dev_kfree_skb(p->tmd_skb[i]);
@@ -710,12 +709,10 @@ static void ni65_free_buffer(struct priv *p)
                 if(p->recv_skb[i])
                         dev_kfree_skb(p->recv_skb[i]);
 #else
-                if(p->recvbounce[i])
-                        kfree(p->recvbounce[i]);
+                kfree(p->recvbounce[i]);
 #endif
         }
-        if(p->self)
-                kfree(p->self);
+        kfree(p->self);
 }
 
 
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index e4811b42a6b7..a3c3fc9c0d8a 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -1632,8 +1632,7 @@ static void ns83820_run_bist(struct net_device *ndev, const char *name, u32 enab
                         timed_out = 1;
                         break;
                 }
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
+                schedule_timeout_uninterruptible(1);
         }
 
         if (status & fail)
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 9f22d138e3ad..818c185d6438 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1020,6 +1020,12 @@ static void set_misc_reg(struct net_device *dev)
         } else {
             outb(full_duplex ? 4 : 0, nic_base + DLINK_DIAG);
         }
+    } else if (info->flags & IS_DL10019) {
+        /* Advertise 100F, 100H, 10F, 10H */
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 4, 0x01e1);
+        /* Restart MII autonegotiation */
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
     }
 }
 
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 113b68099216..70fe81a89df9 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -22,8 +22,8 @@
  *************************************************************************/
 
 #define DRV_NAME        "pcnet32"
-#define DRV_VERSION     "1.30j"
-#define DRV_RELDATE     "29.04.2005"
+#define DRV_VERSION     "1.31a"
+#define DRV_RELDATE     "12.Sep.2005"
 #define PFX             DRV_NAME ": "
 
 static const char *version =
@@ -257,6 +257,9 @@ static int homepna[MAX_UNITS];
  * v1.30h  24 Jun 2004 Don Fry correctly select auto, speed, duplex in bcr32.
  * v1.30i  28 Jun 2004 Don Fry change to use module_param.
  * v1.30j  29 Apr 2005 Don Fry fix skb/map leak with loopback test.
+ * v1.31   02 Sep 2005 Hubert WS Lin <wslin@tw.ibm.c0m> added set_ringparam().
+ * v1.31a  12 Sep 2005 Hubert WS Lin <wslin@tw.ibm.c0m> set min ring size to 4
+ *         to allow loopback test to work unchanged.
  */
 
 
@@ -266,17 +269,17 @@ static int homepna[MAX_UNITS];
  * That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4).
  */
 #ifndef PCNET32_LOG_TX_BUFFERS
-#define PCNET32_LOG_TX_BUFFERS 4
-#define PCNET32_LOG_RX_BUFFERS 5
+#define PCNET32_LOG_TX_BUFFERS          4
+#define PCNET32_LOG_RX_BUFFERS          5
+#define PCNET32_LOG_MAX_TX_BUFFERS      9       /* 2^9 == 512 */
+#define PCNET32_LOG_MAX_RX_BUFFERS      9
 #endif
 
 #define TX_RING_SIZE            (1 << (PCNET32_LOG_TX_BUFFERS))
-#define TX_RING_MOD_MASK        (TX_RING_SIZE - 1)
-#define TX_RING_LEN_BITS        ((PCNET32_LOG_TX_BUFFERS) << 12)
+#define TX_MAX_RING_SIZE        (1 << (PCNET32_LOG_MAX_TX_BUFFERS))
 
 #define RX_RING_SIZE            (1 << (PCNET32_LOG_RX_BUFFERS))
-#define RX_RING_MOD_MASK        (RX_RING_SIZE - 1)
-#define RX_RING_LEN_BITS        ((PCNET32_LOG_RX_BUFFERS) << 4)
+#define RX_MAX_RING_SIZE        (1 << (PCNET32_LOG_MAX_RX_BUFFERS))
 
 #define PKT_BUF_SZ              1544
 
@@ -334,14 +337,14 @@ struct pcnet32_access {
 };
 
 /*
- * The first three fields of pcnet32_private are read by the ethernet device
- * so we allocate the structure should be allocated by pci_alloc_consistent().
+ * The first field of pcnet32_private is read by the ethernet device
+ * so the structure should be allocated using pci_alloc_consistent().
  */
 struct pcnet32_private {
-    /* The Tx and Rx ring entries must be aligned on 16-byte boundaries in 32bit mode. */
-    struct pcnet32_rx_head    rx_ring[RX_RING_SIZE];
-    struct pcnet32_tx_head    tx_ring[TX_RING_SIZE];
     struct pcnet32_init_block init_block;
+    /* The Tx and Rx ring entries must be aligned on 16-byte boundaries in 32bit mode. */
+    struct pcnet32_rx_head    *rx_ring;
+    struct pcnet32_tx_head    *tx_ring;
     dma_addr_t          dma_addr;       /* DMA address of beginning of this
                                            object, returned by
                                            pci_alloc_consistent */
@@ -349,13 +352,21 @@ struct pcnet32_private {
                                            structure */
     const char          *name;
     /* The saved address of a sent-in-place packet/buffer, for skfree(). */
-    struct sk_buff      *tx_skbuff[TX_RING_SIZE];
-    struct sk_buff      *rx_skbuff[RX_RING_SIZE];
-    dma_addr_t          tx_dma_addr[TX_RING_SIZE];
-    dma_addr_t          rx_dma_addr[RX_RING_SIZE];
+    struct sk_buff      **tx_skbuff;
+    struct sk_buff      **rx_skbuff;
+    dma_addr_t          *tx_dma_addr;
+    dma_addr_t          *rx_dma_addr;
     struct pcnet32_access       a;
     spinlock_t          lock;           /* Guard lock */
     unsigned int        cur_rx, cur_tx; /* The next free ring entry */
+    unsigned int        rx_ring_size;   /* current rx ring size */
+    unsigned int        tx_ring_size;   /* current tx ring size */
+    unsigned int        rx_mod_mask;    /* rx ring modular mask */
+    unsigned int        tx_mod_mask;    /* tx ring modular mask */
+    unsigned short      rx_len_bits;
+    unsigned short      tx_len_bits;
+    dma_addr_t          rx_ring_dma_addr;
+    dma_addr_t          tx_ring_dma_addr;
     unsigned int        dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
     struct net_device_stats stats;
     char                tx_full;
@@ -397,6 +408,9 @@ static int pcnet32_get_regs_len(struct net_device *dev);
 static void pcnet32_get_regs(struct net_device *dev, struct ethtool_regs *regs,
         void *ptr);
 static void pcnet32_purge_tx_ring(struct net_device *dev);
+static int pcnet32_alloc_ring(struct net_device *dev);
+static void pcnet32_free_ring(struct net_device *dev);
+
 
 enum pci_flags_bit {
     PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
@@ -613,10 +627,62 @@ static void pcnet32_get_ringparam(struct net_device *dev, struct ethtool_ringpar
 {
     struct pcnet32_private *lp = dev->priv;
 
-    ering->tx_max_pending = TX_RING_SIZE - 1;
-    ering->tx_pending = lp->cur_tx - lp->dirty_tx;
-    ering->rx_max_pending = RX_RING_SIZE - 1;
-    ering->rx_pending = lp->cur_rx & RX_RING_MOD_MASK;
+    ering->tx_max_pending = TX_MAX_RING_SIZE - 1;
+    ering->tx_pending = lp->tx_ring_size - 1;
+    ering->rx_max_pending = RX_MAX_RING_SIZE - 1;
+    ering->rx_pending = lp->rx_ring_size - 1;
+}
+
+static int pcnet32_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
+{
+    struct pcnet32_private *lp = dev->priv;
+    unsigned long flags;
+    int i;
+
+    if (ering->rx_mini_pending || ering->rx_jumbo_pending)
+        return -EINVAL;
+
+    if (netif_running(dev))
+        pcnet32_close(dev);
+
+    spin_lock_irqsave(&lp->lock, flags);
+    pcnet32_free_ring(dev);
+    lp->tx_ring_size = min(ering->tx_pending, (unsigned int) TX_MAX_RING_SIZE);
+    lp->rx_ring_size = min(ering->rx_pending, (unsigned int) RX_MAX_RING_SIZE);
+
+    /* set the minimum ring size to 4, to allow the loopback test to work
+     * unchanged.
+     */
+    for (i = 2; i <= PCNET32_LOG_MAX_TX_BUFFERS; i++) {
+        if (lp->tx_ring_size <= (1 << i))
+            break;
+    }
+    lp->tx_ring_size = (1 << i);
+    lp->tx_mod_mask = lp->tx_ring_size - 1;
+    lp->tx_len_bits = (i << 12);
+
+    for (i = 2; i <= PCNET32_LOG_MAX_RX_BUFFERS; i++) {
+        if (lp->rx_ring_size <= (1 << i))
+            break;
+    }
+    lp->rx_ring_size = (1 << i);
+    lp->rx_mod_mask = lp->rx_ring_size - 1;
+    lp->rx_len_bits = (i << 4);
+
+    if (pcnet32_alloc_ring(dev)) {
+        pcnet32_free_ring(dev);
+        return -ENOMEM;
+    }
+
+    spin_unlock_irqrestore(&lp->lock, flags);
+
+    if (pcnet32_debug & NETIF_MSG_DRV)
+        printk(KERN_INFO PFX "Ring Param Settings: RX: %d, TX: %d\n", lp->rx_ring_size, lp->tx_ring_size);
+
+    if (netif_running(dev))
+        pcnet32_open(dev);
+
+    return 0;
 }
 
 static void pcnet32_get_strings(struct net_device *dev, u32 stringset, u8 *data)
@@ -948,6 +1014,7 @@ static struct ethtool_ops pcnet32_ethtool_ops = {
     .nway_reset         = pcnet32_nway_reset,
     .get_link           = pcnet32_get_link,
     .get_ringparam      = pcnet32_get_ringparam,
+    .set_ringparam      = pcnet32_set_ringparam,
     .get_tx_csum        = ethtool_op_get_tx_csum,
     .get_sg             = ethtool_op_get_sg,
     .get_tso            = ethtool_op_get_tso,
@@ -957,6 +1024,7 @@ static struct ethtool_ops pcnet32_ethtool_ops = {
     .phys_id            = pcnet32_phys_id,
     .get_regs_len       = pcnet32_get_regs_len,
     .get_regs           = pcnet32_get_regs,
+    .get_perm_addr      = ethtool_op_get_perm_addr,
 };
 
 /* only probes for non-PCI devices, the rest are handled by
@@ -1185,9 +1253,10 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
             memcpy(dev->dev_addr, promaddr, 6);
         }
     }
+    memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
     /* if the ethernet address is not valid, force to 00:00:00:00:00:00 */
-    if (!is_valid_ether_addr(dev->dev_addr))
+    if (!is_valid_ether_addr(dev->perm_addr))
         memset(dev->dev_addr, 0, sizeof(dev->dev_addr));
 
     if (pcnet32_debug & NETIF_MSG_PROBE) {
@@ -1239,6 +1308,12 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
     dev->priv = lp;
     lp->name = chipname;
     lp->shared_irq = shared;
+    lp->tx_ring_size = TX_RING_SIZE;            /* default tx ring size */
+    lp->rx_ring_size = RX_RING_SIZE;            /* default rx ring size */
+    lp->tx_mod_mask = lp->tx_ring_size - 1;
+    lp->rx_mod_mask = lp->rx_ring_size - 1;
+    lp->tx_len_bits = (PCNET32_LOG_TX_BUFFERS << 12);
+    lp->rx_len_bits = (PCNET32_LOG_RX_BUFFERS << 4);
     lp->mii_if.full_duplex = fdx;
     lp->mii_if.phy_id_mask = 0x1f;
     lp->mii_if.reg_num_mask = 0x1f;
@@ -1265,21 +1340,23 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
     }
     lp->a = *a;
 
+    if (pcnet32_alloc_ring(dev)) {
+        ret = -ENOMEM;
+        goto err_free_ring;
+    }
     /* detect special T1/E1 WAN card by checking for MAC address */
     if (dev->dev_addr[0] == 0x00 && dev->dev_addr[1] == 0xe0
             && dev->dev_addr[2] == 0x75)
         lp->options = PCNET32_PORT_FD | PCNET32_PORT_GPSI;
 
     lp->init_block.mode = le16_to_cpu(0x0003);  /* Disable Rx and Tx. */
-    lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
+    lp->init_block.tlen_rlen = le16_to_cpu(lp->tx_len_bits | lp->rx_len_bits);
     for (i = 0; i < 6; i++)
         lp->init_block.phys_addr[i] = dev->dev_addr[i];
     lp->init_block.filter[0] = 0x00000000;
     lp->init_block.filter[1] = 0x00000000;
-    lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr +
-            offsetof(struct pcnet32_private, rx_ring));
-    lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr +
-            offsetof(struct pcnet32_private, tx_ring));
+    lp->init_block.rx_ring = (u32)le32_to_cpu(lp->rx_ring_dma_addr);
+    lp->init_block.tx_ring = (u32)le32_to_cpu(lp->tx_ring_dma_addr);
 
     /* switch pcnet32 to 32bit mode */
     a->write_bcr(ioaddr, 20, 2);
@@ -1310,7 +1387,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
             if (pcnet32_debug & NETIF_MSG_PROBE)
                 printk(", failed to detect IRQ line.\n");
             ret = -ENODEV;
-            goto err_free_consistent;
+            goto err_free_ring;
         }
         if (pcnet32_debug & NETIF_MSG_PROBE)
             printk(", probed IRQ %d.\n", dev->irq);
@@ -1341,7 +1418,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
 
     /* Fill in the generic fields of the device structure. */
     if (register_netdev(dev))
-        goto err_free_consistent;
+        goto err_free_ring;
 
     if (pdev) {
         pci_set_drvdata(pdev, dev);
@@ -1359,6 +1436,8 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
 
     return 0;
 
+err_free_ring:
+    pcnet32_free_ring(dev);
 err_free_consistent:
     pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
 err_free_netdev:
@@ -1369,6 +1448,86 @@ err_release_region:
 }
 
 
+static int pcnet32_alloc_ring(struct net_device *dev)
+{
+    struct pcnet32_private *lp = dev->priv;
+
+    if ((lp->tx_ring = pci_alloc_consistent(lp->pci_dev, sizeof(struct pcnet32_tx_head) * lp->tx_ring_size,
+        &lp->tx_ring_dma_addr)) == NULL) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Consistent memory allocation failed.\n");
+        return -ENOMEM;
+    }
+
+    if ((lp->rx_ring = pci_alloc_consistent(lp->pci_dev, sizeof(struct pcnet32_rx_head) * lp->rx_ring_size,
+        &lp->rx_ring_dma_addr)) == NULL) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Consistent memory allocation failed.\n");
+        return -ENOMEM;
+    }
+
+    if (!(lp->tx_dma_addr = kmalloc(sizeof(dma_addr_t) * lp->tx_ring_size, GFP_ATOMIC))) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Memory allocation failed.\n");
+        return -ENOMEM;
+    }
+    memset(lp->tx_dma_addr, 0, sizeof(dma_addr_t) * lp->tx_ring_size);
+
+    if (!(lp->rx_dma_addr = kmalloc(sizeof(dma_addr_t) * lp->rx_ring_size, GFP_ATOMIC))) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Memory allocation failed.\n");
+        return -ENOMEM;
+    }
+    memset(lp->rx_dma_addr, 0, sizeof(dma_addr_t) * lp->rx_ring_size);
+
+    if (!(lp->tx_skbuff = kmalloc(sizeof(struct sk_buff *) * lp->tx_ring_size, GFP_ATOMIC))) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Memory allocation failed.\n");
+        return -ENOMEM;
+    }
+    memset(lp->tx_skbuff, 0, sizeof(struct sk_buff *) * lp->tx_ring_size);
+
+    if (!(lp->rx_skbuff = kmalloc(sizeof(struct sk_buff *) * lp->rx_ring_size, GFP_ATOMIC))) {
+        if (pcnet32_debug & NETIF_MSG_DRV)
+            printk(KERN_ERR PFX "Memory allocation failed.\n");
+        return -ENOMEM;
+    }
+    memset(lp->rx_skbuff, 0, sizeof(struct sk_buff *) * lp->rx_ring_size);
+
+    return 0;
+}
+
+
+static void pcnet32_free_ring(struct net_device *dev)
+{
+    struct pcnet32_private *lp = dev->priv;
+
+    kfree(lp->tx_skbuff);
+    lp->tx_skbuff = NULL;
+
+    kfree(lp->rx_skbuff);
+    lp->rx_skbuff = NULL;
+
+    kfree(lp->tx_dma_addr);
+    lp->tx_dma_addr = NULL;
+
+    kfree(lp->rx_dma_addr);
+    lp->rx_dma_addr = NULL;
+
+    if (lp->tx_ring) {
+        pci_free_consistent(lp->pci_dev, sizeof(struct pcnet32_tx_head) * lp->tx_ring_size,
+                lp->tx_ring, lp->tx_ring_dma_addr);
+        lp->tx_ring = NULL;
+    }
+
+    if (lp->rx_ring) {
+        pci_free_consistent(lp->pci_dev, sizeof(struct pcnet32_rx_head) * lp->rx_ring_size,
+                lp->rx_ring, lp->rx_ring_dma_addr);
+        lp->rx_ring = NULL;
+    }
+}
+
+
 static int
 pcnet32_open(struct net_device *dev)
 {
@@ -1400,8 +1559,8 @@ pcnet32_open(struct net_device *dev)
     if (netif_msg_ifup(lp))
         printk(KERN_DEBUG "%s: pcnet32_open() irq %d tx/rx rings %#x/%#x init %#x.\n",
                dev->name, dev->irq,
-               (u32) (lp->dma_addr + offsetof(struct pcnet32_private, tx_ring)),
-               (u32) (lp->dma_addr + offsetof(struct pcnet32_private, rx_ring)),
+               (u32) (lp->tx_ring_dma_addr),
+               (u32) (lp->rx_ring_dma_addr),
                (u32) (lp->dma_addr + offsetof(struct pcnet32_private, init_block)));
 
     /* set/reset autoselect bit */
@@ -1521,7 +1680,7 @@ pcnet32_open(struct net_device *dev)
 
 err_free_ring:
     /* free any allocated skbuffs */
-    for (i = 0; i < RX_RING_SIZE; i++) {
+    for (i = 0; i < lp->rx_ring_size; i++) {
         lp->rx_ring[i].status = 0;
         if (lp->rx_skbuff[i]) {
             pci_unmap_single(lp->pci_dev, lp->rx_dma_addr[i], PKT_BUF_SZ-2,
@@ -1531,6 +1690,9 @@ err_free_ring:
         lp->rx_skbuff[i] = NULL;
         lp->rx_dma_addr[i] = 0;
     }
+
+    pcnet32_free_ring(dev);
+
     /*
      * Switch back to 16bit mode to avoid problems with dumb
      * DOS packet driver after a warm reboot
@@ -1562,7 +1724,7 @@ pcnet32_purge_tx_ring(struct net_device *dev)
     struct pcnet32_private *lp = dev->priv;
     int i;
 
-    for (i = 0; i < TX_RING_SIZE; i++) {
+    for (i = 0; i < lp->tx_ring_size; i++) {
         lp->tx_ring[i].status = 0;      /* CPU owns buffer */
         wmb();  /* Make sure adapter sees owner change */
         if (lp->tx_skbuff[i]) {
@@ -1587,7 +1749,7 @@ pcnet32_init_ring(struct net_device *dev)
     lp->cur_rx = lp->cur_tx = 0;
     lp->dirty_rx = lp->dirty_tx = 0;
 
-    for (i = 0; i < RX_RING_SIZE; i++) {
+    for (i = 0; i < lp->rx_ring_size; i++) {
         struct sk_buff *rx_skbuff = lp->rx_skbuff[i];
         if (rx_skbuff == NULL) {
             if (!(rx_skbuff = lp->rx_skbuff[i] = dev_alloc_skb (PKT_BUF_SZ))) {
@@ -1611,20 +1773,18 @@ pcnet32_init_ring(struct net_device *dev)
     }
     /* The Tx buffer address is filled in as needed, but we do need to clear
      * the upper ownership bit. */
-    for (i = 0; i < TX_RING_SIZE; i++) {
+    for (i = 0; i < lp->tx_ring_size; i++) {
         lp->tx_ring[i].status = 0;      /* CPU owns buffer */
         wmb();  /* Make sure adapter sees owner change */
         lp->tx_ring[i].base = 0;
         lp->tx_dma_addr[i] = 0;
     }
 
-    lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
+    lp->init_block.tlen_rlen = le16_to_cpu(lp->tx_len_bits | lp->rx_len_bits);
     for (i = 0; i < 6; i++)
         lp->init_block.phys_addr[i] = dev->dev_addr[i];
-    lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr +
-            offsetof(struct pcnet32_private, rx_ring));
-    lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr +
-            offsetof(struct pcnet32_private, tx_ring));
+    lp->init_block.rx_ring = (u32)le32_to_cpu(lp->rx_ring_dma_addr);
+    lp->init_block.tx_ring = (u32)le32_to_cpu(lp->tx_ring_dma_addr);
     wmb();      /* Make sure all changes are visible */
     return 0;
 }
@@ -1682,13 +1842,13 @@ pcnet32_tx_timeout (struct net_device *dev)
         printk(KERN_DEBUG " Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
            lp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
            lp->cur_rx);
-        for (i = 0 ; i < RX_RING_SIZE; i++)
+        for (i = 0 ; i < lp->rx_ring_size; i++)
         printk("%s %08x %04x %08x %04x", i & 1 ? "" : "\n ",
                le32_to_cpu(lp->rx_ring[i].base),
                (-le16_to_cpu(lp->rx_ring[i].buf_length)) & 0xffff,
                le32_to_cpu(lp->rx_ring[i].msg_length),
                le16_to_cpu(lp->rx_ring[i].status));
-        for (i = 0 ; i < TX_RING_SIZE; i++)
+        for (i = 0 ; i < lp->tx_ring_size; i++)
         printk("%s %08x %04x %08x %04x", i & 1 ? "" : "\n ",
                le32_to_cpu(lp->tx_ring[i].base),
                (-le16_to_cpu(lp->tx_ring[i].length)) & 0xffff,
@@ -1729,7 +1889,7 @@ pcnet32_start_xmit(struct sk_buff *skb, struct net_device *dev)
     /* Fill in a Tx ring entry */
 
     /* Mask to ring buffer boundary. */
-    entry = lp->cur_tx & TX_RING_MOD_MASK;
+    entry = lp->cur_tx & lp->tx_mod_mask;
 
     /* Caution: the write order is important here, set the status
      * with the "ownership" bits last. */
@@ -1753,7 +1913,7 @@ pcnet32_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
     dev->trans_start = jiffies;
 
-    if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base != 0) {
+    if (lp->tx_ring[(entry+1) & lp->tx_mod_mask].base != 0) {
         lp->tx_full = 1;
         netif_stop_queue(dev);
     }
@@ -1806,7 +1966,7 @@ pcnet32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
             int delta;
 
             while (dirty_tx != lp->cur_tx) {
-                int entry = dirty_tx & TX_RING_MOD_MASK;
+                int entry = dirty_tx & lp->tx_mod_mask;
                 int status = (short)le16_to_cpu(lp->tx_ring[entry].status);
 
                 if (status < 0)
@@ -1864,18 +2024,18 @@ pcnet32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                 dirty_tx++;
             }
 
-            delta = (lp->cur_tx - dirty_tx) & (TX_RING_MOD_MASK + TX_RING_SIZE);
-            if (delta > TX_RING_SIZE) {
+            delta = (lp->cur_tx - dirty_tx) & (lp->tx_mod_mask + lp->tx_ring_size);
+            if (delta > lp->tx_ring_size) {
                 if (netif_msg_drv(lp))
                     printk(KERN_ERR "%s: out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
                             dev->name, dirty_tx, lp->cur_tx, lp->tx_full);
-                dirty_tx += TX_RING_SIZE;
-                delta -= TX_RING_SIZE;
+                dirty_tx += lp->tx_ring_size;
+                delta -= lp->tx_ring_size;
             }
 
             if (lp->tx_full &&
                 netif_queue_stopped(dev) &&
-                delta < TX_RING_SIZE - 2) {
+                delta < lp->tx_ring_size - 2) {
                 /* The ring is no longer full, clear tbusy. */
                 lp->tx_full = 0;
                 netif_wake_queue (dev);
@@ -1932,8 +2092,8 @@ static int
 pcnet32_rx(struct net_device *dev)
 {
     struct pcnet32_private *lp = dev->priv;
-    int entry = lp->cur_rx & RX_RING_MOD_MASK;
-    int boguscnt = RX_RING_SIZE / 2;
+    int entry = lp->cur_rx & lp->rx_mod_mask;
+    int boguscnt = lp->rx_ring_size / 2;
 
     /* If we own the next entry, it's a new packet. Send it up. */
     while ((short)le16_to_cpu(lp->rx_ring[entry].status) >= 0) {
@@ -1998,12 +2158,12 @@ pcnet32_rx(struct net_device *dev)
                     if (netif_msg_drv(lp))
                         printk(KERN_ERR "%s: Memory squeeze, deferring packet.\n",
                                 dev->name);
-                    for (i = 0; i < RX_RING_SIZE; i++)
+                    for (i = 0; i < lp->rx_ring_size; i++)
                         if ((short)le16_to_cpu(lp->rx_ring[(entry+i)
-                                    & RX_RING_MOD_MASK].status) < 0)
+                                    & lp->rx_mod_mask].status) < 0)
                             break;
 
-                    if (i > RX_RING_SIZE -2) {
+                    if (i > lp->rx_ring_size -2) {
                         lp->stats.rx_dropped++;
                         lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
                         wmb();  /* Make sure adapter sees owner change */
@@ -2041,7 +2201,7 @@ pcnet32_rx(struct net_device *dev)
         lp->rx_ring[entry].buf_length = le16_to_cpu(2-PKT_BUF_SZ);
         wmb(); /* Make sure owner changes after all others are visible */
         lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
-        entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
+        entry = (++lp->cur_rx) & lp->rx_mod_mask;
         if (--boguscnt <= 0) break;     /* don't stay in loop forever */
     }
 
@@ -2084,7 +2244,7 @@ pcnet32_close(struct net_device *dev)
     spin_lock_irqsave(&lp->lock, flags);
 
     /* free all allocated skbuffs */
-    for (i = 0; i < RX_RING_SIZE; i++) {
+    for (i = 0; i < lp->rx_ring_size; i++) {
         lp->rx_ring[i].status = 0;
         wmb();          /* Make sure adapter sees owner change */
         if (lp->rx_skbuff[i]) {
@@ -2096,7 +2256,7 @@ pcnet32_close(struct net_device *dev)
         lp->rx_dma_addr[i] = 0;
     }
 
-    for (i = 0; i < TX_RING_SIZE; i++) {
+    for (i = 0; i < lp->tx_ring_size; i++) {
         lp->tx_ring[i].status = 0;      /* CPU owns buffer */
         wmb();          /* Make sure adapter sees owner change */
         if (lp->tx_skbuff[i]) {
@@ -2265,6 +2425,7 @@ static void __devexit pcnet32_remove_one(struct pci_dev *pdev)
         struct pcnet32_private *lp = dev->priv;
 
         unregister_netdev(dev);
+        pcnet32_free_ring(dev);
         release_region(dev->base_addr, PCNET32_TOTAL_SIZE);
         pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
         free_netdev(dev);
@@ -2340,6 +2501,7 @@ static void __exit pcnet32_cleanup_module(void)
         struct pcnet32_private *lp = pcnet32_dev->priv;
         next_dev = lp->next;
         unregister_netdev(pcnet32_dev);
+        pcnet32_free_ring(pcnet32_dev);
         release_region(pcnet32_dev->base_addr, PCNET32_TOTAL_SIZE);
         pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
         free_netdev(pcnet32_dev);
diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig
index 14f4de1a8180..c782a6329805 100644
--- a/drivers/net/phy/Kconfig
+++ b/drivers/net/phy/Kconfig
@@ -12,14 +12,6 @@ config PHYLIB
           devices.  This option provides infrastructure for
           managing PHY devices.
 
-config PHYCONTROL
-        bool "  Support for automatically handling PHY state changes"
-        depends on PHYLIB
-        help
-          Adds code to perform all the work for keeping PHY link
-          state (speed/duplex/etc) up-to-date.  Also handles
-          interrupts.
-
 comment "MII PHY device drivers"
         depends on PHYLIB
 
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 90630672703d..ad93b0da87f0 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -133,13 +133,9 @@ static int mdio_bus_suspend(struct device * dev, pm_message_t state)
         int ret = 0;
         struct device_driver *drv = dev->driver;
 
-        if (drv && drv->suspend) {
-                ret = drv->suspend(dev, state, SUSPEND_DISABLE);
-                if (ret == 0)
-                        ret = drv->suspend(dev, state, SUSPEND_SAVE_STATE);
-                if (ret == 0)
-                        ret = drv->suspend(dev, state, SUSPEND_POWER_DOWN);
-        }
+        if (drv && drv->suspend)
+                ret = drv->suspend(dev, state);
+
         return ret;
 }
 
@@ -148,13 +144,9 @@ static int mdio_bus_resume(struct device * dev)
         int ret = 0;
         struct device_driver *drv = dev->driver;
 
-        if (drv && drv->resume) {
-                ret = drv->resume(dev, RESUME_POWER_ON);
-                if (ret == 0)
-                        ret = drv->resume(dev, RESUME_RESTORE_STATE);
-                if (ret == 0)
-                        ret = drv->resume(dev, RESUME_ENABLE);
-        }
+        if (drv && drv->resume)
+                ret = drv->resume(dev);
+
         return ret;
 }
 
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index d9e11f93bf3a..9209da9dde0d 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -242,10 +242,6 @@ EXPORT_SYMBOL(phy_sanitize_settings);
  *   choose the next best ones from the ones selected, so we don't
  *   care if ethtool tries to give us bad values
  *
- * A note about the PHYCONTROL Layer.  If you turn off
- * CONFIG_PHYCONTROL, you will need to read the PHY status
- * registers after this function completes, and update your
- * controller manually.
  */
 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
 {
@@ -380,7 +376,6 @@ int phy_start_aneg(struct phy_device *phydev)
 
         err = phydev->drv->config_aneg(phydev);
 
-#ifdef CONFIG_PHYCONTROL
         if (err < 0)
                 goto out_unlock;
 
@@ -395,14 +390,12 @@ int phy_start_aneg(struct phy_device *phydev)
         }
 
 out_unlock:
-#endif
         spin_unlock(&phydev->lock);
         return err;
 }
 EXPORT_SYMBOL(phy_start_aneg);
 
 
-#ifdef CONFIG_PHYCONTROL
 static void phy_change(void *data);
 static void phy_timer(unsigned long data);
 
@@ -868,4 +861,3 @@ static void phy_timer(unsigned long data)
         mod_timer(&phydev->phy_timer, jiffies + PHY_STATE_TIME * HZ);
 }
 
-#endif /* CONFIG_PHYCONTROL */
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 33f7bdb5857c..6da1aa0706a1 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -101,7 +101,6 @@ struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
         return dev;
 }
 
-#ifdef CONFIG_PHYCONTROL
 /* phy_prepare_link:
  *
  * description: Tells the PHY infrastructure to handle the
@@ -160,8 +159,6 @@ void phy_disconnect(struct phy_device *phydev)
 }
 EXPORT_SYMBOL(phy_disconnect);
 
-#endif /* CONFIG_PHYCONTROL */
-
 /* phy_attach:
  *
  *   description: Called by drivers to attach to a particular PHY
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 0df7e92b0bf8..d3c9958b00d0 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -863,7 +863,7 @@ static int __init ppp_init(void)
                         err = PTR_ERR(ppp_class);
                         goto out_chrdev;
                 }
-                class_device_create(ppp_class, MKDEV(PPP_MAJOR, 0), NULL, "ppp");
+                class_device_create(ppp_class, NULL, MKDEV(PPP_MAJOR, 0), NULL, "ppp");
                 err = devfs_mk_cdev(MKDEV(PPP_MAJOR, 0),
                                 S_IFCHR|S_IRUSR|S_IWUSR, "ppp");
                 if (err)
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index afb3f186b884..159b56a56ef4 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -1027,6 +1027,7 @@ static struct ethtool_ops rtl8169_ethtool_ops = {
         .get_strings            = rtl8169_get_strings,
         .get_stats_count        = rtl8169_get_stats_count,
         .get_ethtool_stats      = rtl8169_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static void rtl8169_write_gmii_reg_bit(void __iomem *ioaddr, int reg, int bitnum,
@@ -1511,6 +1512,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         /* Get MAC address.  FIXME: read EEPROM */
         for (i = 0; i < MAC_ADDR_LEN; i++)
                 dev->dev_addr[i] = RTL_R8(MAC0 + i);
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         dev->open = rtl8169_open;
         dev->hard_start_xmit = rtl8169_start_xmit;
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
new file mode 100644
index 000000000000..12cde0604580
--- /dev/null
+++ b/drivers/net/rionet.c
@@ -0,0 +1,574 @@
+/*
+ * rionet - Ethernet driver over RapidIO messaging services
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/rio.h>
+#include <linux/rio_drv.h>
+#include <linux/rio_ids.h>
+
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/crc32.h>
+#include <linux/ethtool.h>
+
+#define DRV_NAME        "rionet"
+#define DRV_VERSION     "0.2"
+#define DRV_AUTHOR      "Matt Porter <mporter@kernel.crashing.org>"
+#define DRV_DESC        "Ethernet over RapidIO"
+
+MODULE_AUTHOR(DRV_AUTHOR);
+MODULE_DESCRIPTION(DRV_DESC);
+MODULE_LICENSE("GPL");
+
+#define RIONET_DEFAULT_MSGLEVEL \
+                        (NETIF_MSG_DRV          | \
+                         NETIF_MSG_LINK         | \
+                         NETIF_MSG_RX_ERR       | \
+                         NETIF_MSG_TX_ERR)
+
+#define RIONET_DOORBELL_JOIN    0x1000
+#define RIONET_DOORBELL_LEAVE   0x1001
+
+#define RIONET_MAILBOX          0
+
+#define RIONET_TX_RING_SIZE     CONFIG_RIONET_TX_SIZE
+#define RIONET_RX_RING_SIZE     CONFIG_RIONET_RX_SIZE
+
+static LIST_HEAD(rionet_peers);
+
+struct rionet_private {
+        struct rio_mport *mport;
+        struct sk_buff *rx_skb[RIONET_RX_RING_SIZE];
+        struct sk_buff *tx_skb[RIONET_TX_RING_SIZE];
+        struct net_device_stats stats;
+        int rx_slot;
+        int tx_slot;
+        int tx_cnt;
+        int ack_slot;
+        spinlock_t lock;
+        spinlock_t tx_lock;
+        u32 msg_enable;
+};
+
+struct rionet_peer {
+        struct list_head node;
+        struct rio_dev *rdev;
+        struct resource *res;
+};
+
+static int rionet_check = 0;
+static int rionet_capable = 1;
+
+/*
+ * This is a fast lookup table for for translating TX
+ * Ethernet packets into a destination RIO device. It
+ * could be made into a hash table to save memory depending
+ * on system trade-offs.
+ */
+static struct rio_dev *rionet_active[RIO_MAX_ROUTE_ENTRIES];
+
+#define is_rionet_capable(pef, src_ops, dst_ops)                \
+                        ((pef & RIO_PEF_INB_MBOX) &&            \
+                         (pef & RIO_PEF_INB_DOORBELL) &&        \
+                         (src_ops & RIO_SRC_OPS_DOORBELL) &&    \
+                         (dst_ops & RIO_DST_OPS_DOORBELL))
+#define dev_rionet_capable(dev) \
+        is_rionet_capable(dev->pef, dev->src_ops, dev->dst_ops)
+
+#define RIONET_MAC_MATCH(x)     (*(u32 *)x == 0x00010001)
+#define RIONET_GET_DESTID(x)    (*(u16 *)(x + 4))
+
+static struct net_device_stats *rionet_stats(struct net_device *ndev)
+{
+        struct rionet_private *rnet = ndev->priv;
+        return &rnet->stats;
+}
+
+static int rionet_rx_clean(struct net_device *ndev)
+{
+        int i;
+        int error = 0;
+        struct rionet_private *rnet = ndev->priv;
+        void *data;
+
+        i = rnet->rx_slot;
+
+        do {
+                if (!rnet->rx_skb[i])
+                        continue;
+
+                if (!(data = rio_get_inb_message(rnet->mport, RIONET_MAILBOX)))
+                        break;
+
+                rnet->rx_skb[i]->data = data;
+                skb_put(rnet->rx_skb[i], RIO_MAX_MSG_SIZE);
+                rnet->rx_skb[i]->dev = ndev;
+                rnet->rx_skb[i]->protocol =
+                    eth_type_trans(rnet->rx_skb[i], ndev);
+                error = netif_rx(rnet->rx_skb[i]);
+
+                if (error == NET_RX_DROP) {
+                        rnet->stats.rx_dropped++;
+                } else if (error == NET_RX_BAD) {
+                        if (netif_msg_rx_err(rnet))
+                                printk(KERN_WARNING "%s: bad rx packet\n",
+                                       DRV_NAME);
+                        rnet->stats.rx_errors++;
+                } else {
+                        rnet->stats.rx_packets++;
+                        rnet->stats.rx_bytes += RIO_MAX_MSG_SIZE;
+                }
+
+        } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != rnet->rx_slot);
+
+        return i;
+}
+
+static void rionet_rx_fill(struct net_device *ndev, int end)
+{
+        int i;
+        struct rionet_private *rnet = ndev->priv;
+
+        i = rnet->rx_slot;
+        do {
+                rnet->rx_skb[i] = dev_alloc_skb(RIO_MAX_MSG_SIZE);
+
+                if (!rnet->rx_skb[i])
+                        break;
+
+                rio_add_inb_buffer(rnet->mport, RIONET_MAILBOX,
+                                   rnet->rx_skb[i]->data);
+        } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != end);
+
+        rnet->rx_slot = i;
+}
+
+static int rionet_queue_tx_msg(struct sk_buff *skb, struct net_device *ndev,
+                               struct rio_dev *rdev)
+{
+        struct rionet_private *rnet = ndev->priv;
+
+        rio_add_outb_message(rnet->mport, rdev, 0, skb->data, skb->len);
+        rnet->tx_skb[rnet->tx_slot] = skb;
+
+        rnet->stats.tx_packets++;
+        rnet->stats.tx_bytes += skb->len;
+
+        if (++rnet->tx_cnt == RIONET_TX_RING_SIZE)
+                netif_stop_queue(ndev);
+
+        ++rnet->tx_slot;
+        rnet->tx_slot &= (RIONET_TX_RING_SIZE - 1);
+
+        if (netif_msg_tx_queued(rnet))
+                printk(KERN_INFO "%s: queued skb %8.8x len %8.8x\n", DRV_NAME,
+                       (u32) skb, skb->len);
+
+        return 0;
+}
+
+static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+        int i;
+        struct rionet_private *rnet = ndev->priv;
+        struct ethhdr *eth = (struct ethhdr *)skb->data;
+        u16 destid;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        if (!spin_trylock(&rnet->tx_lock)) {
+                local_irq_restore(flags);
+                return NETDEV_TX_LOCKED;
+        }
+
+        if ((rnet->tx_cnt + 1) > RIONET_TX_RING_SIZE) {
+                netif_stop_queue(ndev);
+                spin_unlock_irqrestore(&rnet->tx_lock, flags);
+                printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n",
+                       ndev->name);
+                return NETDEV_TX_BUSY;
+        }
+
+        if (eth->h_dest[0] & 0x01) {
+                for (i = 0; i < RIO_MAX_ROUTE_ENTRIES; i++)
+                        if (rionet_active[i])
+                                rionet_queue_tx_msg(skb, ndev,
+                                                    rionet_active[i]);
+        } else if (RIONET_MAC_MATCH(eth->h_dest)) {
+                destid = RIONET_GET_DESTID(eth->h_dest);
+                if (rionet_active[destid])
+                        rionet_queue_tx_msg(skb, ndev, rionet_active[destid]);
+        }
+
+        spin_unlock_irqrestore(&rnet->tx_lock, flags);
+
+        return 0;
+}
+
+static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u16 tid,
+                               u16 info)
+{
+        struct net_device *ndev = dev_id;
+        struct rionet_private *rnet = ndev->priv;
+        struct rionet_peer *peer;
+
+        if (netif_msg_intr(rnet))
+                printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x",
+                       DRV_NAME, sid, tid, info);
+        if (info == RIONET_DOORBELL_JOIN) {
+                if (!rionet_active[sid]) {
+                        list_for_each_entry(peer, &rionet_peers, node) {
+                                if (peer->rdev->destid == sid)
+                                        rionet_active[sid] = peer->rdev;
+                        }
+                        rio_mport_send_doorbell(mport, sid,
+                                                RIONET_DOORBELL_JOIN);
+                }
+        } else if (info == RIONET_DOORBELL_LEAVE) {
+                rionet_active[sid] = NULL;
+        } else {
+                if (netif_msg_intr(rnet))
+                        printk(KERN_WARNING "%s: unhandled doorbell\n",
+                               DRV_NAME);
+        }
+}
+
+static void rionet_inb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
+{
+        int n;
+        struct net_device *ndev = dev_id;
+        struct rionet_private *rnet = (struct rionet_private *)ndev->priv;
+
+        if (netif_msg_intr(rnet))
+                printk(KERN_INFO "%s: inbound message event, mbox %d slot %d\n",
+                       DRV_NAME, mbox, slot);
+
+        spin_lock(&rnet->lock);
+        if ((n = rionet_rx_clean(ndev)) != rnet->rx_slot)
+                rionet_rx_fill(ndev, n);
+        spin_unlock(&rnet->lock);
+}
+
+static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
+{
+        struct net_device *ndev = dev_id;
+        struct rionet_private *rnet = ndev->priv;
+
+        spin_lock(&rnet->lock);
+
+        if (netif_msg_intr(rnet))
+                printk(KERN_INFO
+                       "%s: outbound message event, mbox %d slot %d\n",
+                       DRV_NAME, mbox, slot);
+
+        while (rnet->tx_cnt && (rnet->ack_slot != slot)) {
+                /* dma unmap single */
+                dev_kfree_skb_irq(rnet->tx_skb[rnet->ack_slot]);
+                rnet->tx_skb[rnet->ack_slot] = NULL;
+                ++rnet->ack_slot;
+                rnet->ack_slot &= (RIONET_TX_RING_SIZE - 1);
+                rnet->tx_cnt--;
+        }
+
+        if (rnet->tx_cnt < RIONET_TX_RING_SIZE)
+                netif_wake_queue(ndev);
+
+        spin_unlock(&rnet->lock);
+}
+
+static int rionet_open(struct net_device *ndev)
+{
+        int i, rc = 0;
+        struct rionet_peer *peer, *tmp;
+        u32 pwdcsr;
+        struct rionet_private *rnet = ndev->priv;
+
+        if (netif_msg_ifup(rnet))
+                printk(KERN_INFO "%s: open\n", DRV_NAME);
+
+        if ((rc = rio_request_inb_dbell(rnet->mport,
+                                        (void *)ndev,
+                                        RIONET_DOORBELL_JOIN,
+                                        RIONET_DOORBELL_LEAVE,
+                                        rionet_dbell_event)) < 0)
+                goto out;
+
+        if ((rc = rio_request_inb_mbox(rnet->mport,
+                                       (void *)ndev,
+                                       RIONET_MAILBOX,
+                                       RIONET_RX_RING_SIZE,
+                                       rionet_inb_msg_event)) < 0)
+                goto out;
+
+        if ((rc = rio_request_outb_mbox(rnet->mport,
+                                        (void *)ndev,
+                                        RIONET_MAILBOX,
+                                        RIONET_TX_RING_SIZE,
+                                        rionet_outb_msg_event)) < 0)
+                goto out;
+
+        /* Initialize inbound message ring */
+        for (i = 0; i < RIONET_RX_RING_SIZE; i++)
+                rnet->rx_skb[i] = NULL;
+        rnet->rx_slot = 0;
+        rionet_rx_fill(ndev, 0);
+
+        rnet->tx_slot = 0;
+        rnet->tx_cnt = 0;
+        rnet->ack_slot = 0;
+
+        netif_carrier_on(ndev);
+        netif_start_queue(ndev);
+
+        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
+                if (!(peer->res = rio_request_outb_dbell(peer->rdev,
+                                                         RIONET_DOORBELL_JOIN,
+                                                         RIONET_DOORBELL_LEAVE)))
+                {
+                        printk(KERN_ERR "%s: error requesting doorbells\n",
+                               DRV_NAME);
+                        continue;
+                }
+
+                /*
+                 * If device has initialized inbound doorbells,
+                 * send a join message
+                 */
+                rio_read_config_32(peer->rdev, RIO_WRITE_PORT_CSR, &pwdcsr);
+                if (pwdcsr & RIO_DOORBELL_AVAIL)
+                        rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
+        }
+
+      out:
+        return rc;
+}
+
+static int rionet_close(struct net_device *ndev)
+{
+        struct rionet_private *rnet = (struct rionet_private *)ndev->priv;
+        struct rionet_peer *peer, *tmp;
+        int i;
+
+        if (netif_msg_ifup(rnet))
+                printk(KERN_INFO "%s: close\n", DRV_NAME);
+
+        netif_stop_queue(ndev);
+        netif_carrier_off(ndev);
+
+        for (i = 0; i < RIONET_RX_RING_SIZE; i++)
+                if (rnet->rx_skb[i])
+                        kfree_skb(rnet->rx_skb[i]);
+
+        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
+                if (rionet_active[peer->rdev->destid]) {
+                        rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE);
+                        rionet_active[peer->rdev->destid] = NULL;
+                }
+                rio_release_outb_dbell(peer->rdev, peer->res);
+        }
+
+        rio_release_inb_dbell(rnet->mport, RIONET_DOORBELL_JOIN,
+                              RIONET_DOORBELL_LEAVE);
+        rio_release_inb_mbox(rnet->mport, RIONET_MAILBOX);
+        rio_release_outb_mbox(rnet->mport, RIONET_MAILBOX);
+
+        return 0;
+}
+
+static void rionet_remove(struct rio_dev *rdev)
+{
+        struct net_device *ndev = NULL;
+        struct rionet_peer *peer, *tmp;
+
+        unregister_netdev(ndev);
+        kfree(ndev);
+
+        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
+                list_del(&peer->node);
+                kfree(peer);
+        }
+}
+
+static void rionet_get_drvinfo(struct net_device *ndev,
+                               struct ethtool_drvinfo *info)
+{
+        struct rionet_private *rnet = ndev->priv;
+
+        strcpy(info->driver, DRV_NAME);
+        strcpy(info->version, DRV_VERSION);
+        strcpy(info->fw_version, "n/a");
+        strcpy(info->bus_info, rnet->mport->name);
+}
+
+static u32 rionet_get_msglevel(struct net_device *ndev)
+{
+        struct rionet_private *rnet = ndev->priv;
+
+        return rnet->msg_enable;
+}
+
+static void rionet_set_msglevel(struct net_device *ndev, u32 value)
+{
+        struct rionet_private *rnet = ndev->priv;
+
+        rnet->msg_enable = value;
+}
+
+static struct ethtool_ops rionet_ethtool_ops = {
+        .get_drvinfo = rionet_get_drvinfo,
+        .get_msglevel = rionet_get_msglevel,
+        .set_msglevel = rionet_set_msglevel,
+        .get_link = ethtool_op_get_link,
+};
+
+static int rionet_setup_netdev(struct rio_mport *mport)
+{
+        int rc = 0;
+        struct net_device *ndev = NULL;
+        struct rionet_private *rnet;
+        u16 device_id;
+
+        /* Allocate our net_device structure */
+        ndev = alloc_etherdev(sizeof(struct rionet_private));
+        if (ndev == NULL) {
+                printk(KERN_INFO "%s: could not allocate ethernet device.\n",
+                       DRV_NAME);
+                rc = -ENOMEM;
+                goto out;
+        }
+
+        /* Set up private area */
+        rnet = (struct rionet_private *)ndev->priv;
+        rnet->mport = mport;
+
+        /* Set the default MAC address */
+        device_id = rio_local_get_device_id(mport);
+        ndev->dev_addr[0] = 0x00;
+        ndev->dev_addr[1] = 0x01;
+        ndev->dev_addr[2] = 0x00;
+        ndev->dev_addr[3] = 0x01;
+        ndev->dev_addr[4] = device_id >> 8;
+        ndev->dev_addr[5] = device_id & 0xff;
+
+        /* Fill in the driver function table */
+        ndev->open = &rionet_open;
+        ndev->hard_start_xmit = &rionet_start_xmit;
+        ndev->stop = &rionet_close;
+        ndev->get_stats = &rionet_stats;
+        ndev->mtu = RIO_MAX_MSG_SIZE - 14;
+        ndev->features = NETIF_F_LLTX;
+        SET_ETHTOOL_OPS(ndev, &rionet_ethtool_ops);
+
+        SET_MODULE_OWNER(ndev);
+
+        spin_lock_init(&rnet->lock);
+        spin_lock_init(&rnet->tx_lock);
+
+        rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL;
+
+        rc = register_netdev(ndev);
+        if (rc != 0)
+                goto out;
+
+        printk("%s: %s %s Version %s, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+               ndev->name,
+               DRV_NAME,
+               DRV_DESC,
+               DRV_VERSION,
+               ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
+               ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
+
+      out:
+        return rc;
+}
+
+/*
+ * XXX Make multi-net safe
+ */
+static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
+{
+        int rc = -ENODEV;
+        u32 lpef, lsrc_ops, ldst_ops;
+        struct rionet_peer *peer;
+
+        /* If local device is not rionet capable, give up quickly */
+        if (!rionet_capable)
+                goto out;
+
+        /*
+         * First time through, make sure local device is rionet
+         * capable, setup netdev,  and set flags so this is skipped
+         * on later probes
+         */
+        if (!rionet_check) {
+                rio_local_read_config_32(rdev->net->hport, RIO_PEF_CAR, &lpef);
+                rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
+                                         &lsrc_ops);
+                rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
+                                         &ldst_ops);
+                if (!is_rionet_capable(lpef, lsrc_ops, ldst_ops)) {
+                        printk(KERN_ERR
+                               "%s: local device is not network capable\n",
+                               DRV_NAME);
+                        rionet_check = 1;
+                        rionet_capable = 0;
+                        goto out;
+                }
+
+                rc = rionet_setup_netdev(rdev->net->hport);
+                rionet_check = 1;
+        }
+
+        /*
+         * If the remote device has mailbox/doorbell capabilities,
+         * add it to the peer list.
+         */
+        if (dev_rionet_capable(rdev)) {
+                if (!(peer = kmalloc(sizeof(struct rionet_peer), GFP_KERNEL))) {
+                        rc = -ENOMEM;
+                        goto out;
+                }
+                peer->rdev = rdev;
+                list_add_tail(&peer->node, &rionet_peers);
+        }
+
+      out:
+        return rc;
+}
+
+static struct rio_device_id rionet_id_table[] = {
+        {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)}
+};
+
+static struct rio_driver rionet_driver = {
+        .name = "rionet",
+        .id_table = rionet_id_table,
+        .probe = rionet_probe,
+        .remove = rionet_remove,
+};
+
+static int __init rionet_init(void)
+{
+        return rio_register_driver(&rionet_driver);
+}
+
+static void __exit rionet_exit(void)
+{
+        rio_unregister_driver(&rionet_driver);
+}
+
+module_init(rionet_init);
+module_exit(rionet_exit);
diff --git a/drivers/net/rrunner.c b/drivers/net/rrunner.c
index ec1a18d189a1..19c2df9c86fe 100644
--- a/drivers/net/rrunner.c
+++ b/drivers/net/rrunner.c
@@ -1710,10 +1710,8 @@ static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                         error = -EFAULT;
                 }
         wf_out:
-                if (oldimage)
-                        kfree(oldimage);
-                if (image)
-                        kfree(image);
+                kfree(oldimage);
+                kfree(image);
                 return error;
                 
         case SIOCRRID:
diff --git a/drivers/net/s2io-regs.h b/drivers/net/s2io-regs.h
index 7cefe5507b9e..00179bc3437f 100644
--- a/drivers/net/s2io-regs.h
+++ b/drivers/net/s2io-regs.h
@@ -814,6 +814,17 @@ typedef struct _XENA_dev_config {
         u64 rxgxs_ber_0;        /* CHANGED */
         u64 rxgxs_ber_1;        /* CHANGED */
 
+        u64 spi_control;
+#define SPI_CONTROL_KEY(key)            vBIT(key,0,4)
+#define SPI_CONTROL_BYTECNT(cnt)        vBIT(cnt,29,3)
+#define SPI_CONTROL_CMD(cmd)            vBIT(cmd,32,8)
+#define SPI_CONTROL_ADDR(addr)          vBIT(addr,40,24)
+#define SPI_CONTROL_SEL1                BIT(4)
+#define SPI_CONTROL_REQ                 BIT(7)
+#define SPI_CONTROL_NACK                BIT(5)
+#define SPI_CONTROL_DONE                BIT(6)
+        u64 spi_data;
+#define SPI_DATA_WRITE(data,len)        vBIT(data,0,len)
 } XENA_dev_config_t;
 
 #define XENA_REG_SPACE  sizeof(XENA_dev_config_t)
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index dd451e099a4c..3f5e93aad5c7 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -65,9 +65,11 @@
 #include "s2io.h"
 #include "s2io-regs.h"
 
+#define DRV_VERSION "Version 2.0.9.1"
+
 /* S2io Driver name & version. */
 static char s2io_driver_name[] = "Neterion";
-static char s2io_driver_version[] = "Version 2.0.8.1";
+static char s2io_driver_version[] = DRV_VERSION;
 
 static inline int RXD_IS_UP2DT(RxD_t *rxdp)
 {
@@ -307,6 +309,8 @@ static unsigned int indicate_max_pkts;
 #endif
 /* Frequency of Rx desc syncs expressed as power of 2 */
 static unsigned int rxsync_frequency = 3;
+/* Interrupt type. Values can be 0(INTA), 1(MSI), 2(MSI_X) */
+static unsigned int intr_type = 0;
 
 /*
  * S2IO device table.
@@ -701,8 +705,7 @@ static void free_shared_mem(struct s2io_nic *nic)
                         }
                         kfree(mac_control->rings[i].ba[j]);
                 }
-                if (mac_control->rings[i].ba)
-                        kfree(mac_control->rings[i].ba);
+                kfree(mac_control->rings[i].ba);
         }
 #endif
 
@@ -1396,8 +1399,13 @@ static int init_nic(struct s2io_nic *nic)
                 writeq(val64, &bar0->rti_data1_mem);
 
                 val64 = RTI_DATA2_MEM_RX_UFC_A(0x1) |
-                    RTI_DATA2_MEM_RX_UFC_B(0x2) |
-                    RTI_DATA2_MEM_RX_UFC_C(0x40) | RTI_DATA2_MEM_RX_UFC_D(0x80);
+                    RTI_DATA2_MEM_RX_UFC_B(0x2) ;
+                if (nic->intr_type == MSI_X)
+                    val64 |= (RTI_DATA2_MEM_RX_UFC_C(0x20) | \
+                                RTI_DATA2_MEM_RX_UFC_D(0x40));
+                else
+                    val64 |= (RTI_DATA2_MEM_RX_UFC_C(0x40) | \
+                                RTI_DATA2_MEM_RX_UFC_D(0x80));
                 writeq(val64, &bar0->rti_data2_mem);
 
                 for (i = 0; i < config->rx_ring_num; i++) {
@@ -1507,17 +1515,15 @@ static int init_nic(struct s2io_nic *nic)
 #define LINK_UP_DOWN_INTERRUPT          1
 #define MAC_RMAC_ERR_TIMER              2
 
-#if defined(CONFIG_MSI_MODE) || defined(CONFIG_MSIX_MODE)
-#define s2io_link_fault_indication(x) MAC_RMAC_ERR_TIMER
-#else
 int s2io_link_fault_indication(nic_t *nic)
 {
+        if (nic->intr_type != INTA)
+                return MAC_RMAC_ERR_TIMER;
         if (nic->device_type == XFRAME_II_DEVICE)
                 return LINK_UP_DOWN_INTERRUPT;
         else
                 return MAC_RMAC_ERR_TIMER;
 }
-#endif
 
 /**
  *  en_dis_able_nic_intrs - Enable or Disable the interrupts
@@ -1941,11 +1947,14 @@ static int start_nic(struct s2io_nic *nic)
         }
 
         /*  Enable select interrupts */
-        interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR;
-        interruptible |= TX_PIC_INTR | RX_PIC_INTR;
-        interruptible |= TX_MAC_INTR | RX_MAC_INTR;
-
-        en_dis_able_nic_intrs(nic, interruptible, ENABLE_INTRS);
+        if (nic->intr_type != INTA)
+                en_dis_able_nic_intrs(nic, ENA_ALL_INTRS, DISABLE_INTRS);
+        else {
+                interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR;
+                interruptible |= TX_PIC_INTR | RX_PIC_INTR;
+                interruptible |= TX_MAC_INTR | RX_MAC_INTR;
+                en_dis_able_nic_intrs(nic, interruptible, ENABLE_INTRS);
+        }
 
         /*
          * With some switches, link might be already up at this point.
@@ -2633,11 +2642,11 @@ static void tx_intr_handler(fifo_info_t *fifo_data)
                         err = txdlp->Control_1 & TXD_T_CODE;
                         if ((err >> 48) == 0xA) {
                                 DBG_PRINT(TX_DBG, "TxD returned due \
-                                                to loss of link\n");
+to loss of link\n");
                         }
                         else {
                                 DBG_PRINT(ERR_DBG, "***TxD error \
-                                                %llx\n", err);
+%llx\n", err);
                         }
                 }
 
@@ -2854,6 +2863,9 @@ void s2io_reset(nic_t * sp)
         /* Set swapper to enable I/O register access */
         s2io_set_swapper(sp);
 
+        /* Restore the MSIX table entries from local variables */
+        restore_xmsi_data(sp);
+
         /* Clear certain PCI/PCI-X fields after reset */
         if (sp->device_type == XFRAME_II_DEVICE) {
                 /* Clear parity err detect bit */
@@ -2983,8 +2995,9 @@ int s2io_set_swapper(nic_t * sp)
                  SWAPPER_CTRL_RXD_W_FE |
                  SWAPPER_CTRL_RXF_W_FE |
                  SWAPPER_CTRL_XMSI_FE |
-                 SWAPPER_CTRL_XMSI_SE |
                  SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
+        if (sp->intr_type == INTA)
+                val64 |= SWAPPER_CTRL_XMSI_SE;
         writeq(val64, &bar0->swapper_ctrl);
 #else
         /*
@@ -3005,8 +3018,9 @@ int s2io_set_swapper(nic_t * sp)
                  SWAPPER_CTRL_RXD_W_SE |
                  SWAPPER_CTRL_RXF_W_FE |
                  SWAPPER_CTRL_XMSI_FE |
-                 SWAPPER_CTRL_XMSI_SE |
                  SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
+        if (sp->intr_type == INTA)
+                val64 |= SWAPPER_CTRL_XMSI_SE;
         writeq(val64, &bar0->swapper_ctrl);
 #endif
         val64 = readq(&bar0->swapper_ctrl);
@@ -3028,6 +3042,201 @@ int s2io_set_swapper(nic_t * sp)
         return SUCCESS;
 }
 
+int wait_for_msix_trans(nic_t *nic, int i)
+{
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
+        u64 val64;
+        int ret = 0, cnt = 0;
+
+        do {
+                val64 = readq(&bar0->xmsi_access);
+                if (!(val64 & BIT(15)))
+                        break;
+                mdelay(1);
+                cnt++;
+        } while(cnt < 5);
+        if (cnt == 5) {
+                DBG_PRINT(ERR_DBG, "XMSI # %d Access failed\n", i);
+                ret = 1;
+        }
+
+        return ret;
+}
+
+void restore_xmsi_data(nic_t *nic)
+{
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
+        u64 val64;
+        int i;
+
+        for (i=0; i< MAX_REQUESTED_MSI_X; i++) {
+                writeq(nic->msix_info[i].addr, &bar0->xmsi_address);
+                writeq(nic->msix_info[i].data, &bar0->xmsi_data);
+                val64 = (BIT(7) | BIT(15) | vBIT(i, 26, 6));
+                writeq(val64, &bar0->xmsi_access);
+                if (wait_for_msix_trans(nic, i)) {
+                        DBG_PRINT(ERR_DBG, "failed in %s\n", __FUNCTION__);
+                        continue;
+                }
+        }
+}
+
+void store_xmsi_data(nic_t *nic)
+{
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
+        u64 val64, addr, data;
+        int i;
+
+        /* Store and display */
+        for (i=0; i< MAX_REQUESTED_MSI_X; i++) {
+                val64 = (BIT(15) | vBIT(i, 26, 6));
+                writeq(val64, &bar0->xmsi_access);
+                if (wait_for_msix_trans(nic, i)) {
+                        DBG_PRINT(ERR_DBG, "failed in %s\n", __FUNCTION__);
+                        continue;
+                }
+                addr = readq(&bar0->xmsi_address);
+                data = readq(&bar0->xmsi_data);
+                if (addr && data) {
+                        nic->msix_info[i].addr = addr;
+                        nic->msix_info[i].data = data;
+                }
+        }
+}
+
+int s2io_enable_msi(nic_t *nic)
+{
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
+        u16 msi_ctrl, msg_val;
+        struct config_param *config = &nic->config;
+        struct net_device *dev = nic->dev;
+        u64 val64, tx_mat, rx_mat;
+        int i, err;
+
+        val64 = readq(&bar0->pic_control);
+        val64 &= ~BIT(1);
+        writeq(val64, &bar0->pic_control);
+
+        err = pci_enable_msi(nic->pdev);
+        if (err) {
+                DBG_PRINT(ERR_DBG, "%s: enabling MSI failed\n",
+                          nic->dev->name);
+                return err;
+        }
+
+        /*
+         * Enable MSI and use MSI-1 in stead of the standard MSI-0
+         * for interrupt handling.
+         */
+        pci_read_config_word(nic->pdev, 0x4c, &msg_val);
+        msg_val ^= 0x1;
+        pci_write_config_word(nic->pdev, 0x4c, msg_val);
+        pci_read_config_word(nic->pdev, 0x4c, &msg_val);
+
+        pci_read_config_word(nic->pdev, 0x42, &msi_ctrl);
+        msi_ctrl |= 0x10;
+        pci_write_config_word(nic->pdev, 0x42, msi_ctrl);
+
+        /* program MSI-1 into all usable Tx_Mat and Rx_Mat fields */
+        tx_mat = readq(&bar0->tx_mat0_n[0]);
+        for (i=0; i<config->tx_fifo_num; i++) {
+                tx_mat |= TX_MAT_SET(i, 1);
+        }
+        writeq(tx_mat, &bar0->tx_mat0_n[0]);
+
+        rx_mat = readq(&bar0->rx_mat);
+        for (i=0; i<config->rx_ring_num; i++) {
+                rx_mat |= RX_MAT_SET(i, 1);
+        }
+        writeq(rx_mat, &bar0->rx_mat);
+
+        dev->irq = nic->pdev->irq;
+        return 0;
+}
+
+int s2io_enable_msi_x(nic_t *nic)
+{
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
+        u64 tx_mat, rx_mat;
+        u16 msi_control; /* Temp variable */
+        int ret, i, j, msix_indx = 1;
+
+        nic->entries = kmalloc(MAX_REQUESTED_MSI_X * sizeof(struct msix_entry),
+                               GFP_KERNEL);
+        if (nic->entries == NULL) {
+                DBG_PRINT(ERR_DBG, "%s: Memory allocation failed\n", __FUNCTION__);
+                return -ENOMEM;
+        }
+        memset(nic->entries, 0, MAX_REQUESTED_MSI_X * sizeof(struct msix_entry));
+
+        nic->s2io_entries =
+                kmalloc(MAX_REQUESTED_MSI_X * sizeof(struct s2io_msix_entry),
+                                   GFP_KERNEL);
+        if (nic->s2io_entries == NULL) {
+                DBG_PRINT(ERR_DBG, "%s: Memory allocation failed\n", __FUNCTION__);
+                kfree(nic->entries);
+                return -ENOMEM;
+        }
+        memset(nic->s2io_entries, 0,
+               MAX_REQUESTED_MSI_X * sizeof(struct s2io_msix_entry));
+
+        for (i=0; i< MAX_REQUESTED_MSI_X; i++) {
+                nic->entries[i].entry = i;
+                nic->s2io_entries[i].entry = i;
+                nic->s2io_entries[i].arg = NULL;
+                nic->s2io_entries[i].in_use = 0;
+        }
+
+        tx_mat = readq(&bar0->tx_mat0_n[0]);
+        for (i=0; i<nic->config.tx_fifo_num; i++, msix_indx++) {
+                tx_mat |= TX_MAT_SET(i, msix_indx);
+                nic->s2io_entries[msix_indx].arg = &nic->mac_control.fifos[i];
+                nic->s2io_entries[msix_indx].type = MSIX_FIFO_TYPE;
+                nic->s2io_entries[msix_indx].in_use = MSIX_FLG;
+        }
+        writeq(tx_mat, &bar0->tx_mat0_n[0]);
+
+        if (!nic->config.bimodal) {
+                rx_mat = readq(&bar0->rx_mat);
+                for (j=0; j<nic->config.rx_ring_num; j++, msix_indx++) {
+                        rx_mat |= RX_MAT_SET(j, msix_indx);
+                        nic->s2io_entries[msix_indx].arg = &nic->mac_control.rings[j];
+                        nic->s2io_entries[msix_indx].type = MSIX_RING_TYPE;
+                        nic->s2io_entries[msix_indx].in_use = MSIX_FLG;
+                }
+                writeq(rx_mat, &bar0->rx_mat);
+        } else {
+                tx_mat = readq(&bar0->tx_mat0_n[7]);
+                for (j=0; j<nic->config.rx_ring_num; j++, msix_indx++) {
+                        tx_mat |= TX_MAT_SET(i, msix_indx);
+                        nic->s2io_entries[msix_indx].arg = &nic->mac_control.rings[j];
+                        nic->s2io_entries[msix_indx].type = MSIX_RING_TYPE;
+                        nic->s2io_entries[msix_indx].in_use = MSIX_FLG;
+                }
+                writeq(tx_mat, &bar0->tx_mat0_n[7]);
+        }
+
+        ret = pci_enable_msix(nic->pdev, nic->entries, MAX_REQUESTED_MSI_X);
+        if (ret) {
+                DBG_PRINT(ERR_DBG, "%s: Enabling MSIX failed\n", nic->dev->name);
+                kfree(nic->entries);
+                kfree(nic->s2io_entries);
+                nic->entries = NULL;
+                nic->s2io_entries = NULL;
+                return -ENOMEM;
+        }
+
+        /*
+         * To enable MSI-X, MSI also needs to be enabled, due to a bug
+         * in the herc NIC. (Temp change, needs to be removed later)
+         */
+        pci_read_config_word(nic->pdev, 0x42, &msi_control);
+        msi_control |= 0x1; /* Enable MSI */
+        pci_write_config_word(nic->pdev, 0x42, msi_control);
+
+        return 0;
+}
+
 /* ********************************************************* *
  * Functions defined below concern the OS part of the driver *
  * ********************************************************* */
@@ -3048,6 +3257,8 @@ int s2io_open(struct net_device *dev)
 {
         nic_t *sp = dev->priv;
         int err = 0;
+        int i;
+        u16 msi_control; /* Temp variable */
 
         /*
          * Make sure you have link off by default every time
@@ -3064,13 +3275,55 @@ int s2io_open(struct net_device *dev)
                 goto hw_init_failed;
         }
 
+        /* Store the values of the MSIX table in the nic_t structure */
+        store_xmsi_data(sp);
+
         /* After proper initialization of H/W, register ISR */
-        err = request_irq((int) sp->pdev->irq, s2io_isr, SA_SHIRQ,
-                          sp->name, dev);
-        if (err) {
-                DBG_PRINT(ERR_DBG, "%s: ISR registration failed\n",
-                          dev->name);
-                goto isr_registration_failed;
+        if (sp->intr_type == MSI) {
+                err = request_irq((int) sp->pdev->irq, s2io_msi_handle, 
+                        SA_SHIRQ, sp->name, dev);
+                if (err) {
+                        DBG_PRINT(ERR_DBG, "%s: MSI registration \
+failed\n", dev->name);
+                        goto isr_registration_failed;
+                }
+        }
+        if (sp->intr_type == MSI_X) {
+                for (i=1; (sp->s2io_entries[i].in_use == MSIX_FLG); i++) {
+                        if (sp->s2io_entries[i].type == MSIX_FIFO_TYPE) {
+                                sprintf(sp->desc1, "%s:MSI-X-%d-TX",
+                                        dev->name, i);
+                                err = request_irq(sp->entries[i].vector,
+                                          s2io_msix_fifo_handle, 0, sp->desc1,
+                                          sp->s2io_entries[i].arg);
+                                DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc1, 
+                                                        sp->msix_info[i].addr);
+                        } else {
+                                sprintf(sp->desc2, "%s:MSI-X-%d-RX",
+                                        dev->name, i);
+                                err = request_irq(sp->entries[i].vector,
+                                          s2io_msix_ring_handle, 0, sp->desc2,
+                                          sp->s2io_entries[i].arg);
+                                DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc2, 
+                                                        sp->msix_info[i].addr);
+                        }
+                        if (err) {
+                                DBG_PRINT(ERR_DBG, "%s: MSI-X-%d registration \
+failed\n", dev->name, i);
+                                DBG_PRINT(ERR_DBG, "Returned: %d\n", err);
+                                goto isr_registration_failed;
+                        }
+                        sp->s2io_entries[i].in_use = MSIX_REGISTERED_SUCCESS;
+                }
+        }
+        if (sp->intr_type == INTA) {
+                err = request_irq((int) sp->pdev->irq, s2io_isr, SA_SHIRQ,
+                                sp->name, dev);
+                if (err) {
+                        DBG_PRINT(ERR_DBG, "%s: ISR registration failed\n",
+                                  dev->name);
+                        goto isr_registration_failed;
+                }
         }
 
         if (s2io_set_mac_addr(dev, dev->dev_addr) == FAILURE) {
@@ -3083,11 +3336,37 @@ int s2io_open(struct net_device *dev)
         return 0;
 
 setting_mac_address_failed:
-        free_irq(sp->pdev->irq, dev);
+        if (sp->intr_type != MSI_X)
+                free_irq(sp->pdev->irq, dev);
 isr_registration_failed:
         del_timer_sync(&sp->alarm_timer);
+        if (sp->intr_type == MSI_X) {
+                if (sp->device_type == XFRAME_II_DEVICE) {
+                        for (i=1; (sp->s2io_entries[i].in_use == 
+                                MSIX_REGISTERED_SUCCESS); i++) {
+                                int vector = sp->entries[i].vector;
+                                void *arg = sp->s2io_entries[i].arg;
+
+                                free_irq(vector, arg);
+                        }
+                        pci_disable_msix(sp->pdev);
+
+                        /* Temp */
+                        pci_read_config_word(sp->pdev, 0x42, &msi_control);
+                        msi_control &= 0xFFFE; /* Disable MSI */
+                        pci_write_config_word(sp->pdev, 0x42, msi_control);
+                }
+        }
+        else if (sp->intr_type == MSI)
+                pci_disable_msi(sp->pdev);
         s2io_reset(sp);
 hw_init_failed:
+        if (sp->intr_type == MSI_X) {
+                if (sp->entries)
+                        kfree(sp->entries);
+                if (sp->s2io_entries)
+                        kfree(sp->s2io_entries);
+        }
         return err;
 }
 
@@ -3107,12 +3386,35 @@ hw_init_failed:
 int s2io_close(struct net_device *dev)
 {
         nic_t *sp = dev->priv;
+        int i;
+        u16 msi_control;
+
         flush_scheduled_work();
         netif_stop_queue(dev);
         /* Reset card, kill tasklet and free Tx and Rx buffers. */
         s2io_card_down(sp);
 
-        free_irq(sp->pdev->irq, dev);
+        if (sp->intr_type == MSI_X) {
+                if (sp->device_type == XFRAME_II_DEVICE) {
+                        for (i=1; (sp->s2io_entries[i].in_use == 
+                                        MSIX_REGISTERED_SUCCESS); i++) {
+                                int vector = sp->entries[i].vector;
+                                void *arg = sp->s2io_entries[i].arg;
+
+                                free_irq(vector, arg);
+                        }
+                        pci_read_config_word(sp->pdev, 0x42, &msi_control);
+                        msi_control &= 0xFFFE; /* Disable MSI */
+                        pci_write_config_word(sp->pdev, 0x42, msi_control);
+
+                        pci_disable_msix(sp->pdev);
+                }
+        }
+        else {
+                free_irq(sp->pdev->irq, dev);
+                if (sp->intr_type == MSI)
+                        pci_disable_msi(sp->pdev);
+        }       
         sp->device_close_flag = TRUE;   /* Device is shut down. */
         return 0;
 }
@@ -3278,6 +3580,104 @@ s2io_alarm_handle(unsigned long data)
         mod_timer(&sp->alarm_timer, jiffies + HZ / 2);
 }
 
+static irqreturn_t
+s2io_msi_handle(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = (struct net_device *) dev_id;
+        nic_t *sp = dev->priv;
+        int i;
+        int ret;
+        mac_info_t *mac_control;
+        struct config_param *config;
+
+        atomic_inc(&sp->isr_cnt);
+        mac_control = &sp->mac_control;
+        config = &sp->config;
+        DBG_PRINT(INTR_DBG, "%s: MSI handler\n", __FUNCTION__);
+
+        /* If Intr is because of Rx Traffic */
+        for (i = 0; i < config->rx_ring_num; i++)
+                rx_intr_handler(&mac_control->rings[i]);
+
+        /* If Intr is because of Tx Traffic */
+        for (i = 0; i < config->tx_fifo_num; i++)
+                tx_intr_handler(&mac_control->fifos[i]);
+
+        /*
+         * If the Rx buffer count is below the panic threshold then
+         * reallocate the buffers from the interrupt handler itself,
+         * else schedule a tasklet to reallocate the buffers.
+         */
+        for (i = 0; i < config->rx_ring_num; i++) {
+                int rxb_size = atomic_read(&sp->rx_bufs_left[i]);
+                int level = rx_buffer_level(sp, rxb_size, i);
+
+                if ((level == PANIC) && (!TASKLET_IN_USE)) {
+                        DBG_PRINT(INTR_DBG, "%s: Rx BD hit ", dev->name);
+                        DBG_PRINT(INTR_DBG, "PANIC levels\n");
+                        if ((ret = fill_rx_buffers(sp, i)) == -ENOMEM) {
+                                DBG_PRINT(ERR_DBG, "%s:Out of memory",
+                                          dev->name);
+                                DBG_PRINT(ERR_DBG, " in ISR!!\n");
+                                clear_bit(0, (&sp->tasklet_status));
+                                atomic_dec(&sp->isr_cnt);
+                                return IRQ_HANDLED;
+                        }
+                        clear_bit(0, (&sp->tasklet_status));
+                } else if (level == LOW) {
+                        tasklet_schedule(&sp->task);
+                }
+        }
+
+        atomic_dec(&sp->isr_cnt);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t
+s2io_msix_ring_handle(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ring_info_t *ring = (ring_info_t *)dev_id;
+        nic_t *sp = ring->nic;
+        int rxb_size, level, rng_n;
+
+        atomic_inc(&sp->isr_cnt);
+        rx_intr_handler(ring);
+
+        rng_n = ring->ring_no;
+        rxb_size = atomic_read(&sp->rx_bufs_left[rng_n]);
+        level = rx_buffer_level(sp, rxb_size, rng_n);
+
+        if ((level == PANIC) && (!TASKLET_IN_USE)) {
+                int ret;
+                DBG_PRINT(INTR_DBG, "%s: Rx BD hit ", __FUNCTION__);
+                DBG_PRINT(INTR_DBG, "PANIC levels\n");
+                if ((ret = fill_rx_buffers(sp, rng_n)) == -ENOMEM) {
+                        DBG_PRINT(ERR_DBG, "Out of memory in %s",
+                                  __FUNCTION__);
+                        clear_bit(0, (&sp->tasklet_status));
+                        return IRQ_HANDLED;
+                }
+                clear_bit(0, (&sp->tasklet_status));
+        } else if (level == LOW) {
+                tasklet_schedule(&sp->task);
+        }
+        atomic_dec(&sp->isr_cnt);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t
+s2io_msix_fifo_handle(int irq, void *dev_id, struct pt_regs *regs)
+{
+        fifo_info_t *fifo = (fifo_info_t *)dev_id;
+        nic_t *sp = fifo->nic;
+
+        atomic_inc(&sp->isr_cnt);
+        tx_intr_handler(fifo);
+        atomic_dec(&sp->isr_cnt);
+        return IRQ_HANDLED;
+}
+
 static void s2io_txpic_intr_handle(nic_t *sp)
 {
         XENA_dev_config_t __iomem *bar0 = sp->bar0;
@@ -3778,11 +4178,10 @@ static void s2io_ethtool_gdrvinfo(struct net_device *dev,
 {
         nic_t *sp = dev->priv;
 
-        strncpy(info->driver, s2io_driver_name, sizeof(s2io_driver_name));
-        strncpy(info->version, s2io_driver_version,
-                sizeof(s2io_driver_version));
-        strncpy(info->fw_version, "", 32);
-        strncpy(info->bus_info, pci_name(sp->pdev), 32);
+        strncpy(info->driver, s2io_driver_name, sizeof(info->driver));
+        strncpy(info->version, s2io_driver_version, sizeof(info->version));
+        strncpy(info->fw_version, "", sizeof(info->fw_version));
+        strncpy(info->bus_info, pci_name(sp->pdev), sizeof(info->bus_info));
         info->regdump_len = XENA_REG_SPACE;
         info->eedump_len = XENA_EEPROM_SPACE;
         info->testinfo_len = S2IO_TEST_LEN;
@@ -3978,29 +4377,53 @@ static int s2io_ethtool_setpause_data(struct net_device *dev,
  */
 
 #define S2IO_DEV_ID             5
-static int read_eeprom(nic_t * sp, int off, u32 * data)
+static int read_eeprom(nic_t * sp, int off, u64 * data)
 {
         int ret = -1;
         u32 exit_cnt = 0;
         u64 val64;
         XENA_dev_config_t __iomem *bar0 = sp->bar0;
 
-        val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
-            I2C_CONTROL_BYTE_CNT(0x3) | I2C_CONTROL_READ |
-            I2C_CONTROL_CNTL_START;
-        SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
+        if (sp->device_type == XFRAME_I_DEVICE) {
+                val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
+                    I2C_CONTROL_BYTE_CNT(0x3) | I2C_CONTROL_READ |
+                    I2C_CONTROL_CNTL_START;
+                SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
 
-        while (exit_cnt < 5) {
-                val64 = readq(&bar0->i2c_control);
-                if (I2C_CONTROL_CNTL_END(val64)) {
-                        *data = I2C_CONTROL_GET_DATA(val64);
-                        ret = 0;
-                        break;
+                while (exit_cnt < 5) {
+                        val64 = readq(&bar0->i2c_control);
+                        if (I2C_CONTROL_CNTL_END(val64)) {
+                                *data = I2C_CONTROL_GET_DATA(val64);
+                                ret = 0;
+                                break;
+                        }
+                        msleep(50);
+                        exit_cnt++;
                 }
-                msleep(50);
-                exit_cnt++;
         }
 
+        if (sp->device_type == XFRAME_II_DEVICE) {
+                val64 = SPI_CONTROL_KEY(0x9) | SPI_CONTROL_SEL1 |
+                        SPI_CONTROL_BYTECNT(0x3) | 
+                        SPI_CONTROL_CMD(0x3) | SPI_CONTROL_ADDR(off);
+                SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
+                val64 |= SPI_CONTROL_REQ;
+                SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
+                while (exit_cnt < 5) {
+                        val64 = readq(&bar0->spi_control);
+                        if (val64 & SPI_CONTROL_NACK) {
+                                ret = 1;
+                                break;
+                        } else if (val64 & SPI_CONTROL_DONE) {
+                                *data = readq(&bar0->spi_data);
+                                *data &= 0xffffff;
+                                ret = 0;
+                                break;
+                        }
+                        msleep(50);
+                        exit_cnt++;
+                }
+        }
         return ret;
 }
 
@@ -4019,28 +4442,53 @@ static int read_eeprom(nic_t * sp, int off, u32 * data)
  *  0 on success, -1 on failure.
  */
 
-static int write_eeprom(nic_t * sp, int off, u32 data, int cnt)
+static int write_eeprom(nic_t * sp, int off, u64 data, int cnt)
 {
         int exit_cnt = 0, ret = -1;
         u64 val64;
         XENA_dev_config_t __iomem *bar0 = sp->bar0;
 
-        val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
-            I2C_CONTROL_BYTE_CNT(cnt) | I2C_CONTROL_SET_DATA(data) |
-            I2C_CONTROL_CNTL_START;
-        SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
+        if (sp->device_type == XFRAME_I_DEVICE) {
+                val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
+                    I2C_CONTROL_BYTE_CNT(cnt) | I2C_CONTROL_SET_DATA((u32)data) |
+                    I2C_CONTROL_CNTL_START;
+                SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
+
+                while (exit_cnt < 5) {
+                        val64 = readq(&bar0->i2c_control);
+                        if (I2C_CONTROL_CNTL_END(val64)) {
+                                if (!(val64 & I2C_CONTROL_NACK))
+                                        ret = 0;
+                                break;
+                        }
+                        msleep(50);
+                        exit_cnt++;
+                }
+        }
 
-        while (exit_cnt < 5) {
-                val64 = readq(&bar0->i2c_control);
-                if (I2C_CONTROL_CNTL_END(val64)) {
-                        if (!(val64 & I2C_CONTROL_NACK))
+        if (sp->device_type == XFRAME_II_DEVICE) {
+                int write_cnt = (cnt == 8) ? 0 : cnt;
+                writeq(SPI_DATA_WRITE(data,(cnt<<3)), &bar0->spi_data);
+
+                val64 = SPI_CONTROL_KEY(0x9) | SPI_CONTROL_SEL1 |
+                        SPI_CONTROL_BYTECNT(write_cnt) | 
+                        SPI_CONTROL_CMD(0x2) | SPI_CONTROL_ADDR(off);
+                SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
+                val64 |= SPI_CONTROL_REQ;
+                SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
+                while (exit_cnt < 5) {
+                        val64 = readq(&bar0->spi_control);
+                        if (val64 & SPI_CONTROL_NACK) {
+                                ret = 1;
+                                break;
+                        } else if (val64 & SPI_CONTROL_DONE) {
                                 ret = 0;
-                        break;
+                                break;
+                        }
+                        msleep(50);
+                        exit_cnt++;
                 }
-                msleep(50);
-                exit_cnt++;
         }
-
         return ret;
 }
 
@@ -4060,7 +4508,8 @@ static int write_eeprom(nic_t * sp, int off, u32 data, int cnt)
 static int s2io_ethtool_geeprom(struct net_device *dev,
                          struct ethtool_eeprom *eeprom, u8 * data_buf)
 {
-        u32 data, i, valid;
+        u32 i, valid;
+        u64 data;
         nic_t *sp = dev->priv;
 
         eeprom->magic = sp->pdev->vendor | (sp->pdev->device << 16);
@@ -4098,7 +4547,7 @@ static int s2io_ethtool_seeprom(struct net_device *dev,
                                 u8 * data_buf)
 {
         int len = eeprom->len, cnt = 0;
-        u32 valid = 0, data;
+        u64 valid = 0, data;
         nic_t *sp = dev->priv;
 
         if (eeprom->magic != (sp->pdev->vendor | (sp->pdev->device << 16))) {
@@ -4146,7 +4595,7 @@ static int s2io_ethtool_seeprom(struct net_device *dev,
 static int s2io_register_test(nic_t * sp, uint64_t * data)
 {
         XENA_dev_config_t __iomem *bar0 = sp->bar0;
-        u64 val64 = 0;
+        u64 val64 = 0, exp_val;
         int fail = 0;
 
         val64 = readq(&bar0->pif_rd_swapper_fb);
@@ -4162,7 +4611,11 @@ static int s2io_register_test(nic_t * sp, uint64_t * data)
         }
 
         val64 = readq(&bar0->rx_queue_cfg);
-        if (val64 != 0x0808080808080808ULL) {
+        if (sp->device_type == XFRAME_II_DEVICE)
+                exp_val = 0x0404040404040404ULL;
+        else
+                exp_val = 0x0808080808080808ULL;
+        if (val64 != exp_val) {
                 fail = 1;
                 DBG_PRINT(INFO_DBG, "Read Test level 3 fails\n");
         }
@@ -4190,7 +4643,7 @@ static int s2io_register_test(nic_t * sp, uint64_t * data)
         }
 
         *data = fail;
-        return 0;
+        return fail;
 }
 
 /**
@@ -4209,58 +4662,83 @@ static int s2io_register_test(nic_t * sp, uint64_t * data)
 static int s2io_eeprom_test(nic_t * sp, uint64_t * data)
 {
         int fail = 0;
-        u32 ret_data;
+        u64 ret_data, org_4F0, org_7F0;
+        u8 saved_4F0 = 0, saved_7F0 = 0;
+        struct net_device *dev = sp->dev;
 
         /* Test Write Error at offset 0 */
-        if (!write_eeprom(sp, 0, 0, 3))
-                fail = 1;
+        /* Note that SPI interface allows write access to all areas
+         * of EEPROM. Hence doing all negative testing only for Xframe I.
+         */
+        if (sp->device_type == XFRAME_I_DEVICE)
+                if (!write_eeprom(sp, 0, 0, 3))
+                        fail = 1;
+
+        /* Save current values at offsets 0x4F0 and 0x7F0 */
+        if (!read_eeprom(sp, 0x4F0, &org_4F0))
+                saved_4F0 = 1;
+        if (!read_eeprom(sp, 0x7F0, &org_7F0))
+                saved_7F0 = 1;
 
         /* Test Write at offset 4f0 */
-        if (write_eeprom(sp, 0x4F0, 0x01234567, 3))
+        if (write_eeprom(sp, 0x4F0, 0x012345, 3))
                 fail = 1;
         if (read_eeprom(sp, 0x4F0, &ret_data))
                 fail = 1;
 
-        if (ret_data != 0x01234567)
+        if (ret_data != 0x012345) {
+                DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x4F0. Data written %llx Data read %llx\n", dev->name, (u64)0x12345, ret_data); 
                 fail = 1;
+        }
 
         /* Reset the EEPROM data go FFFF */
-        write_eeprom(sp, 0x4F0, 0xFFFFFFFF, 3);
+        write_eeprom(sp, 0x4F0, 0xFFFFFF, 3);
 
         /* Test Write Request Error at offset 0x7c */
-        if (!write_eeprom(sp, 0x07C, 0, 3))
-                fail = 1;
+        if (sp->device_type == XFRAME_I_DEVICE)
+                if (!write_eeprom(sp, 0x07C, 0, 3))
+                        fail = 1;
 
-        /* Test Write Request at offset 0x7fc */
-        if (write_eeprom(sp, 0x7FC, 0x01234567, 3))
+        /* Test Write Request at offset 0x7f0 */
+        if (write_eeprom(sp, 0x7F0, 0x012345, 3))
                 fail = 1;
-        if (read_eeprom(sp, 0x7FC, &ret_data))
+        if (read_eeprom(sp, 0x7F0, &ret_data))
                 fail = 1;
 
-        if (ret_data != 0x01234567)
+        if (ret_data != 0x012345) {
+                DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x7F0. Data written %llx Data read %llx\n", dev->name, (u64)0x12345, ret_data); 
                 fail = 1;
+        }
 
         /* Reset the EEPROM data go FFFF */
-        write_eeprom(sp, 0x7FC, 0xFFFFFFFF, 3);
+        write_eeprom(sp, 0x7F0, 0xFFFFFF, 3);
 
-        /* Test Write Error at offset 0x80 */
-        if (!write_eeprom(sp, 0x080, 0, 3))
-                fail = 1;
+        if (sp->device_type == XFRAME_I_DEVICE) {
+                /* Test Write Error at offset 0x80 */
+                if (!write_eeprom(sp, 0x080, 0, 3))
+                        fail = 1;
 
-        /* Test Write Error at offset 0xfc */
-        if (!write_eeprom(sp, 0x0FC, 0, 3))
-                fail = 1;
+                /* Test Write Error at offset 0xfc */
+                if (!write_eeprom(sp, 0x0FC, 0, 3))
+                        fail = 1;
 
-        /* Test Write Error at offset 0x100 */
-        if (!write_eeprom(sp, 0x100, 0, 3))
-                fail = 1;
+                /* Test Write Error at offset 0x100 */
+                if (!write_eeprom(sp, 0x100, 0, 3))
+                        fail = 1;
 
-        /* Test Write Error at offset 4ec */
-        if (!write_eeprom(sp, 0x4EC, 0, 3))
-                fail = 1;
+                /* Test Write Error at offset 4ec */
+                if (!write_eeprom(sp, 0x4EC, 0, 3))
+                        fail = 1;
+        }
+
+        /* Restore values at offsets 0x4F0 and 0x7F0 */
+        if (saved_4F0)
+                write_eeprom(sp, 0x4F0, org_4F0, 3);
+        if (saved_7F0)
+                write_eeprom(sp, 0x7F0, org_7F0, 3);
 
         *data = fail;
-        return 0;
+        return fail;
 }
 
 /**
@@ -4342,7 +4820,7 @@ static int s2io_rldram_test(nic_t * sp, uint64_t * data)
 {
         XENA_dev_config_t __iomem *bar0 = sp->bar0;
         u64 val64;
-        int cnt, iteration = 0, test_pass = 0;
+        int cnt, iteration = 0, test_fail = 0;
 
         val64 = readq(&bar0->adapter_control);
         val64 &= ~ADAPTER_ECC_EN;
@@ -4350,7 +4828,7 @@ static int s2io_rldram_test(nic_t * sp, uint64_t * data)
 
         val64 = readq(&bar0->mc_rldram_test_ctrl);
         val64 |= MC_RLDRAM_TEST_MODE;
-        writeq(val64, &bar0->mc_rldram_test_ctrl);
+        SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
 
         val64 = readq(&bar0->mc_rldram_mrs);
         val64 |= MC_RLDRAM_QUEUE_SIZE_ENABLE;
@@ -4378,17 +4856,12 @@ static int s2io_rldram_test(nic_t * sp, uint64_t * data)
                 }
                 writeq(val64, &bar0->mc_rldram_test_d2);
 
-                val64 = (u64) (0x0000003fffff0000ULL);
+                val64 = (u64) (0x0000003ffffe0100ULL);
                 writeq(val64, &bar0->mc_rldram_test_add);
 
-
-                val64 = MC_RLDRAM_TEST_MODE;
-                writeq(val64, &bar0->mc_rldram_test_ctrl);
-
-                val64 |=
-                    MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_WRITE |
-                    MC_RLDRAM_TEST_GO;
-                writeq(val64, &bar0->mc_rldram_test_ctrl);
+                val64 = MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_WRITE |
+                        MC_RLDRAM_TEST_GO;
+                SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
 
                 for (cnt = 0; cnt < 5; cnt++) {
                         val64 = readq(&bar0->mc_rldram_test_ctrl);
@@ -4400,11 +4873,8 @@ static int s2io_rldram_test(nic_t * sp, uint64_t * data)
                 if (cnt == 5)
                         break;
 
-                val64 = MC_RLDRAM_TEST_MODE;
-                writeq(val64, &bar0->mc_rldram_test_ctrl);
-
-                val64 |= MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_GO;
-                writeq(val64, &bar0->mc_rldram_test_ctrl);
+                val64 = MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_GO;
+                SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
 
                 for (cnt = 0; cnt < 5; cnt++) {
                         val64 = readq(&bar0->mc_rldram_test_ctrl);
@@ -4417,18 +4887,18 @@ static int s2io_rldram_test(nic_t * sp, uint64_t * data)
                         break;
 
                 val64 = readq(&bar0->mc_rldram_test_ctrl);
-                if (val64 & MC_RLDRAM_TEST_PASS)
-                        test_pass = 1;
+                if (!(val64 & MC_RLDRAM_TEST_PASS))
+                        test_fail = 1;
 
                 iteration++;
         }
 
-        if (!test_pass)
-                *data = 1;
-        else
-                *data = 0;
+        *data = test_fail;
 
-        return 0;
+        /* Bring the adapter out of test mode */
+        SPECIAL_REG_WRITE(0, &bar0->mc_rldram_test_ctrl, LF);
+
+        return test_fail;
 }
 
 /**
@@ -4932,7 +5402,7 @@ static void s2io_card_down(nic_t * sp)
 
 static int s2io_card_up(nic_t * sp)
 {
-        int i, ret;
+        int i, ret = 0;
         mac_info_t *mac_control;
         struct config_param *config;
         struct net_device *dev = (struct net_device *) sp->dev;
@@ -4944,6 +5414,15 @@ static int s2io_card_up(nic_t * sp)
                 return -ENODEV;
         }
 
+        if (sp->intr_type == MSI)
+                ret = s2io_enable_msi(sp);
+        else if (sp->intr_type == MSI_X)
+                ret = s2io_enable_msi_x(sp);
+        if (ret) {
+                DBG_PRINT(ERR_DBG, "%s: Defaulting to INTA\n", dev->name);
+                sp->intr_type = INTA;
+        }
+
         /*
          * Initializing the Rx buffers. For now we are considering only 1
          * Rx ring and initializing buffers into 30 Rx blocks
@@ -5228,6 +5707,8 @@ static void s2io_init_pci(nic_t * sp)
 
 MODULE_AUTHOR("Raghavendra Koushik <raghavendra.koushik@neterion.com>");
 MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
 module_param(tx_fifo_num, int, 0);
 module_param(rx_ring_num, int, 0);
 module_param_array(tx_fifo_len, uint, NULL, 0);
@@ -5245,6 +5726,7 @@ module_param(bimodal, bool, 0);
 module_param(indicate_max_pkts, int, 0);
 #endif
 module_param(rxsync_frequency, int, 0);
+module_param(intr_type, int, 0);
 
 /**
  *  s2io_init_nic - Initialization of the adapter .
@@ -5274,9 +5756,16 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         mac_info_t *mac_control;
         struct config_param *config;
         int mode;
+        u8 dev_intr_type = intr_type;
 
 #ifdef CONFIG_S2IO_NAPI
-        DBG_PRINT(ERR_DBG, "NAPI support has been enabled\n");
+        if (dev_intr_type != INTA) {
+                DBG_PRINT(ERR_DBG, "NAPI cannot be enabled when MSI/MSI-X \
+is enabled. Defaulting to INTA\n");
+                dev_intr_type = INTA;
+        }
+        else
+                DBG_PRINT(ERR_DBG, "NAPI support has been enabled\n");
 #endif
 
         if ((ret = pci_enable_device(pdev))) {
@@ -5303,10 +5792,35 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
                 return -ENOMEM;
         }
 
-        if (pci_request_regions(pdev, s2io_driver_name)) {
-                DBG_PRINT(ERR_DBG, "Request Regions failed\n"),
-                    pci_disable_device(pdev);
-                return -ENODEV;
+        if ((dev_intr_type == MSI_X) && 
+                        ((pdev->device != PCI_DEVICE_ID_HERC_WIN) &&
+                        (pdev->device != PCI_DEVICE_ID_HERC_UNI))) {
+                DBG_PRINT(ERR_DBG, "Xframe I does not support MSI_X. \
+Defaulting to INTA\n");
+                dev_intr_type = INTA;
+        }
+        if (dev_intr_type != MSI_X) {
+                if (pci_request_regions(pdev, s2io_driver_name)) {
+                        DBG_PRINT(ERR_DBG, "Request Regions failed\n"),
+                            pci_disable_device(pdev);
+                        return -ENODEV;
+                }
+        }
+        else {
+                if (!(request_mem_region(pci_resource_start(pdev, 0),
+                         pci_resource_len(pdev, 0), s2io_driver_name))) {
+                        DBG_PRINT(ERR_DBG, "bar0 Request Regions failed\n");
+                        pci_disable_device(pdev);
+                        return -ENODEV;
+                }
+                if (!(request_mem_region(pci_resource_start(pdev, 2),
+                         pci_resource_len(pdev, 2), s2io_driver_name))) {
+                        DBG_PRINT(ERR_DBG, "bar1 Request Regions failed\n");
+                        release_mem_region(pci_resource_start(pdev, 0),
+                                   pci_resource_len(pdev, 0));
+                        pci_disable_device(pdev);
+                        return -ENODEV;
+                }
         }
 
         dev = alloc_etherdev(sizeof(nic_t));
@@ -5329,6 +5843,7 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         sp->pdev = pdev;
         sp->high_dma_flag = dma_flag;
         sp->device_enabled_once = FALSE;
+        sp->intr_type = dev_intr_type;
 
         if ((pdev->device == PCI_DEVICE_ID_HERC_WIN) ||
                 (pdev->device == PCI_DEVICE_ID_HERC_UNI))
@@ -5336,6 +5851,7 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         else
                 sp->device_type = XFRAME_I_DEVICE;
 
+                
         /* Initialize some PCI/PCI-X fields of the NIC. */
         s2io_init_pci(sp);
 
@@ -5571,12 +6087,23 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         if (sp->device_type & XFRAME_II_DEVICE) {
                 DBG_PRINT(ERR_DBG, "%s: Neterion Xframe II 10GbE adapter ",
                           dev->name);
-                DBG_PRINT(ERR_DBG, "(rev %d), %s",
+                DBG_PRINT(ERR_DBG, "(rev %d), Version %s",
                                 get_xena_rev_id(sp->pdev),
                                 s2io_driver_version);
 #ifdef CONFIG_2BUFF_MODE
                 DBG_PRINT(ERR_DBG, ", Buffer mode %d",2);
 #endif
+                switch(sp->intr_type) {
+                        case INTA:
+                                DBG_PRINT(ERR_DBG, ", Intr type INTA");
+                                break;
+                        case MSI:
+                                DBG_PRINT(ERR_DBG, ", Intr type MSI");
+                                break;
+                        case MSI_X:
+                                DBG_PRINT(ERR_DBG, ", Intr type MSI-X");
+                                break;
+                }
 
                 DBG_PRINT(ERR_DBG, "\nCopyright(c) 2002-2005 Neterion Inc.\n");
                 DBG_PRINT(ERR_DBG, "MAC ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n",
@@ -5595,12 +6122,23 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         } else {
                 DBG_PRINT(ERR_DBG, "%s: Neterion Xframe I 10GbE adapter ",
                           dev->name);
-                DBG_PRINT(ERR_DBG, "(rev %d), %s",
+                DBG_PRINT(ERR_DBG, "(rev %d), Version %s",
                                         get_xena_rev_id(sp->pdev),
                                         s2io_driver_version);
 #ifdef CONFIG_2BUFF_MODE
                 DBG_PRINT(ERR_DBG, ", Buffer mode %d",2);
 #endif
+                switch(sp->intr_type) {
+                        case INTA:
+                                DBG_PRINT(ERR_DBG, ", Intr type INTA");
+                                break;
+                        case MSI:
+                                DBG_PRINT(ERR_DBG, ", Intr type MSI");
+                                break;
+                        case MSI_X:
+                                DBG_PRINT(ERR_DBG, ", Intr type MSI-X");
+                                break;
+                }
                 DBG_PRINT(ERR_DBG, "\nCopyright(c) 2002-2005 Neterion Inc.\n");
                 DBG_PRINT(ERR_DBG, "MAC ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n",
                           sp->def_mac_addr[0].mac_addr[0],
@@ -5644,7 +6182,14 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
       mem_alloc_failed:
         free_shared_mem(sp);
         pci_disable_device(pdev);
-        pci_release_regions(pdev);
+        if (dev_intr_type != MSI_X)
+                pci_release_regions(pdev);
+        else {
+                release_mem_region(pci_resource_start(pdev, 0),
+                        pci_resource_len(pdev, 0));
+                release_mem_region(pci_resource_start(pdev, 2),
+                        pci_resource_len(pdev, 2));
+        }
         pci_set_drvdata(pdev, NULL);
         free_netdev(dev);
 
@@ -5678,7 +6223,14 @@ static void __devexit s2io_rem_nic(struct pci_dev *pdev)
         iounmap(sp->bar0);
         iounmap(sp->bar1);
         pci_disable_device(pdev);
-        pci_release_regions(pdev);
+        if (sp->intr_type != MSI_X)
+                pci_release_regions(pdev);
+        else {
+                release_mem_region(pci_resource_start(pdev, 0),
+                        pci_resource_len(pdev, 0));
+                release_mem_region(pci_resource_start(pdev, 2),
+                        pci_resource_len(pdev, 2));
+        }
         pci_set_drvdata(pdev, NULL);
         free_netdev(dev);
 }
diff --git a/drivers/net/s2io.h b/drivers/net/s2io.h
index 89151cb52181..1cc24b56760e 100644
--- a/drivers/net/s2io.h
+++ b/drivers/net/s2io.h
@@ -652,6 +652,30 @@ typedef struct {
 #define SMALL_BLK_CNT   30
 #define LARGE_BLK_CNT   100
 
+/*
+ * Structure to keep track of the MSI-X vectors and the corresponding
+ * argument registered against each vector
+ */
+#define MAX_REQUESTED_MSI_X     17
+struct s2io_msix_entry
+{
+        u16 vector;
+        u16 entry;
+        void *arg;
+
+        u8 type;
+#define MSIX_FIFO_TYPE  1
+#define MSIX_RING_TYPE  2
+
+        u8 in_use;
+#define MSIX_REGISTERED_SUCCESS 0xAA
+};
+
+struct msix_info_st {
+        u64 addr;
+        u64 data;
+};
+
 /* Structure representing one instance of the NIC */
 struct s2io_nic {
 #ifdef CONFIG_S2IO_NAPI
@@ -719,13 +743,8 @@ struct s2io_nic {
          *  a schedule task that will set the correct Link state once the
          *  NIC's PHY has stabilized after a state change.
          */
-#ifdef INIT_TQUEUE
-        struct tq_struct rst_timer_task;
-        struct tq_struct set_link_task;
-#else
         struct work_struct rst_timer_task;
         struct work_struct set_link_task;
-#endif
 
         /* Flag that can be used to turn on or turn off the Rx checksum
          * offload feature.
@@ -748,10 +767,23 @@ struct s2io_nic {
         atomic_t card_state;
         volatile unsigned long link_state;
         struct vlan_group *vlgrp;
+#define MSIX_FLG                0xA5
+        struct msix_entry *entries;
+        struct s2io_msix_entry *s2io_entries;
+        char desc1[35];
+        char desc2[35];
+
+        struct msix_info_st msix_info[0x3f];
+
 #define XFRAME_I_DEVICE         1
 #define XFRAME_II_DEVICE        2
         u8 device_type;
 
+#define INTA    0
+#define MSI     1
+#define MSI_X   2
+        u8 intr_type;
+
         spinlock_t      rx_lock;
         atomic_t        isr_cnt;
 };
@@ -886,6 +918,13 @@ static int s2io_poll(struct net_device *dev, int *budget);
 static void s2io_init_pci(nic_t * sp);
 int s2io_set_mac_addr(struct net_device *dev, u8 * addr);
 static void s2io_alarm_handle(unsigned long data);
+static int s2io_enable_msi(nic_t *nic);
+static irqreturn_t s2io_msi_handle(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t
+s2io_msix_ring_handle(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t
+s2io_msix_fifo_handle(int irq, void *dev_id, struct pt_regs *regs);
+int s2io_enable_msi_x(nic_t *nic);
 static irqreturn_t s2io_isr(int irq, void *dev_id, struct pt_regs *regs);
 static int verify_xena_quiescence(nic_t *sp, u64 val64, int flag);
 static struct ethtool_ops netdev_ethtool_ops;
@@ -894,4 +933,5 @@ int s2io_set_swapper(nic_t * sp);
 static void s2io_card_down(nic_t *nic);
 static int s2io_card_up(nic_t *nic);
 int get_xena_rev_id(struct pci_dev *pdev);
+void restore_xmsi_data(nic_t *nic);
 #endif                          /* _S2IO_H */
diff --git a/drivers/net/saa9730.c b/drivers/net/saa9730.c
index fd0167077fbe..110e777f206e 100644
--- a/drivers/net/saa9730.c
+++ b/drivers/net/saa9730.c
@@ -997,10 +997,7 @@ static void __devexit saa9730_remove_one(struct pci_dev *pdev)
 
         if (dev) {
                 unregister_netdev(dev);
-
-                if (dev->priv)
-                        kfree(dev->priv);
-
+                kfree(dev->priv);
                 free_netdev(dev);
                 pci_release_regions(pdev);
                 pci_disable_device(pdev);
@@ -1096,8 +1093,7 @@ static int lan_saa9730_init(struct net_device *dev, int ioaddr, int irq)
         return 0;
 
  out:
-        if (dev->priv)
-                kfree(dev->priv);
+        kfree(dev->priv);
         return ret;
 }
 
diff --git a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c
index 7abd55a4fb21..aa4ca1821759 100644
--- a/drivers/net/sb1250-mac.c
+++ b/drivers/net/sb1250-mac.c
@@ -10,7 +10,7 @@
  * 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.
@@ -118,8 +118,6 @@ MODULE_PARM_DESC(int_timeout, "Timeout value");
  ********************************************************************* */
 
 
-typedef unsigned long sbmac_port_t;
-
 typedef enum { sbmac_speed_auto, sbmac_speed_10,
                sbmac_speed_100, sbmac_speed_1000 } sbmac_speed_t;
 
@@ -129,7 +127,7 @@ typedef enum { sbmac_duplex_auto, sbmac_duplex_half,
 typedef enum { sbmac_fc_auto, sbmac_fc_disabled, sbmac_fc_frame,
                sbmac_fc_collision, sbmac_fc_carrier } sbmac_fc_t;
 
-typedef enum { sbmac_state_uninit, sbmac_state_off, sbmac_state_on, 
+typedef enum { sbmac_state_uninit, sbmac_state_off, sbmac_state_on,
                sbmac_state_broken } sbmac_state_t;
 
 
@@ -144,17 +142,13 @@ typedef enum { sbmac_state_uninit, sbmac_state_off, sbmac_state_on,
 
 #define NUMCACHEBLKS(x) (((x)+SMP_CACHE_BYTES-1)/SMP_CACHE_BYTES)
 
-#define SBMAC_READCSR(t)        __raw_readq((unsigned long)t)
-#define SBMAC_WRITECSR(t,v)     __raw_writeq(v, (unsigned long)t)
- 
-
 #define SBMAC_MAX_TXDESCR       32
 #define SBMAC_MAX_RXDESCR       32
 
 #define ETHER_ALIGN     2
 #define ETHER_ADDR_LEN  6
-#define ENET_PACKET_SIZE        1518 
-/*#define ENET_PACKET_SIZE      9216 */ 
+#define ENET_PACKET_SIZE        1518
+/*#define ENET_PACKET_SIZE      9216 */
 
 /**********************************************************************
  *  DMA Descriptor structure
@@ -172,12 +166,12 @@ typedef unsigned long paddr_t;
  ********************************************************************* */
 
 typedef struct sbmacdma_s {
-        
-        /* 
+
+        /*
          * This stuff is used to identify the channel and the registers
          * associated with it.
          */
-        
+
         struct sbmac_softc *sbdma_eth;          /* back pointer to associated MAC */
         int              sbdma_channel; /* channel number */
         int              sbdma_txdir;       /* direction (1=transmit) */
@@ -187,21 +181,21 @@ typedef struct sbmacdma_s {
         int              sbdma_int_timeout; /* # usec rx/tx interrupt */
 #endif
 
-        sbmac_port_t     sbdma_config0; /* DMA config register 0 */
-        sbmac_port_t     sbdma_config1; /* DMA config register 1 */
-        sbmac_port_t     sbdma_dscrbase;        /* Descriptor base address */
-        sbmac_port_t     sbdma_dscrcnt;     /* Descriptor count register */
-        sbmac_port_t     sbdma_curdscr; /* current descriptor address */
-        
+        volatile void __iomem *sbdma_config0;   /* DMA config register 0 */
+        volatile void __iomem *sbdma_config1;   /* DMA config register 1 */
+        volatile void __iomem *sbdma_dscrbase;  /* Descriptor base address */
+        volatile void __iomem *sbdma_dscrcnt;     /* Descriptor count register */
+        volatile void __iomem *sbdma_curdscr;   /* current descriptor address */
+
         /*
          * This stuff is for maintenance of the ring
          */
-        
+
         sbdmadscr_t     *sbdma_dscrtable;       /* base of descriptor table */
         sbdmadscr_t     *sbdma_dscrtable_end; /* end of descriptor table */
-        
+
         struct sk_buff **sbdma_ctxtable;    /* context table, one per descr */
-        
+
         paddr_t          sbdma_dscrtable_phys; /* and also the phys addr */
         sbdmadscr_t     *sbdma_addptr;  /* next dscr for sw to add */
         sbdmadscr_t     *sbdma_remptr;  /* next dscr for sw to remove */
@@ -213,15 +207,15 @@ typedef struct sbmacdma_s {
  ********************************************************************* */
 
 struct sbmac_softc {
-        
+
         /*
          * Linux-specific things
          */
-        
+
         struct net_device *sbm_dev;             /* pointer to linux device */
         spinlock_t sbm_lock;            /* spin lock */
         struct timer_list sbm_timer;            /* for monitoring MII */
-        struct net_device_stats sbm_stats; 
+        struct net_device_stats sbm_stats;
         int sbm_devflags;                       /* current device flags */
 
         int          sbm_phy_oldbmsr;
@@ -229,31 +223,31 @@ struct sbmac_softc {
         int          sbm_phy_oldk1stsr;
         int          sbm_phy_oldlinkstat;
         int sbm_buffersize;
-        
+
         unsigned char sbm_phys[2];
-        
+
         /*
          * Controller-specific things
          */
-        
-        unsigned long   sbm_base;          /* MAC's base address */
+
+        volatile void __iomem *sbm_base;          /* MAC's base address */
         sbmac_state_t    sbm_state;         /* current state */
-        
-        sbmac_port_t     sbm_macenable; /* MAC Enable Register */
-        sbmac_port_t     sbm_maccfg;    /* MAC Configuration Register */
-        sbmac_port_t     sbm_fifocfg;   /* FIFO configuration register */
-        sbmac_port_t     sbm_framecfg;  /* Frame configuration register */
-        sbmac_port_t     sbm_rxfilter;  /* receive filter register */
-        sbmac_port_t     sbm_isr;               /* Interrupt status register */
-        sbmac_port_t     sbm_imr;               /* Interrupt mask register */
-        sbmac_port_t     sbm_mdio;              /* MDIO register */
-        
+
+        volatile void __iomem   *sbm_macenable; /* MAC Enable Register */
+        volatile void __iomem   *sbm_maccfg;    /* MAC Configuration Register */
+        volatile void __iomem   *sbm_fifocfg;   /* FIFO configuration register */
+        volatile void __iomem   *sbm_framecfg;  /* Frame configuration register */
+        volatile void __iomem   *sbm_rxfilter;  /* receive filter register */
+        volatile void __iomem   *sbm_isr;       /* Interrupt status register */
+        volatile void __iomem   *sbm_imr;       /* Interrupt mask register */
+        volatile void __iomem   *sbm_mdio;      /* MDIO register */
+
         sbmac_speed_t    sbm_speed;             /* current speed */
         sbmac_duplex_t   sbm_duplex;    /* current duplex */
         sbmac_fc_t       sbm_fc;                /* current flow control setting */
-        
+
         unsigned char    sbm_hwaddr[ETHER_ADDR_LEN];
-        
+
         sbmacdma_t       sbm_txdma;             /* for now, only use channel 0 */
         sbmacdma_t       sbm_rxdma;
         int              rx_hw_checksum;
@@ -302,6 +296,7 @@ static void sbmac_set_rx_mode(struct net_device *dev);
 static int sbmac_mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static int sbmac_close(struct net_device *dev);
 static int sbmac_mii_poll(struct sbmac_softc *s,int noisy);
+static int sbmac_mii_probe(struct net_device *dev);
 
 static void sbmac_mii_sync(struct sbmac_softc *s);
 static void sbmac_mii_senddata(struct sbmac_softc *s,unsigned int data, int bitcnt);
@@ -439,6 +434,9 @@ static uint64_t sbmac_orig_hwaddr[MAX_UNITS];
 
 #define MII_BMCR        0x00    /* Basic mode control register (rw) */
 #define MII_BMSR        0x01    /* Basic mode status register (ro) */
+#define MII_PHYIDR1     0x02
+#define MII_PHYIDR2     0x03
+
 #define MII_K1STSR      0x0A    /* 1K Status Register (ro) */
 #define MII_ANLPAR      0x05    /* Autonegotiation lnk partner abilities (rw) */
 
@@ -450,13 +448,13 @@ static uint64_t sbmac_orig_hwaddr[MAX_UNITS];
 
 /**********************************************************************
  *  SBMAC_MII_SYNC(s)
- *  
+ *
  *  Synchronize with the MII - send a pattern of bits to the MII
  *  that will guarantee that it is ready to accept a command.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -467,25 +465,25 @@ static void sbmac_mii_sync(struct sbmac_softc *s)
         uint64_t bits;
         int mac_mdio_genc;
 
-        mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;
-        
+        mac_mdio_genc = __raw_readq(s->sbm_mdio) & M_MAC_GENC;
+
         bits = M_MAC_MDIO_DIR_OUTPUT | M_MAC_MDIO_OUT;
-        
-        SBMAC_WRITECSR(s->sbm_mdio,bits | mac_mdio_genc);
-        
+
+        __raw_writeq(bits | mac_mdio_genc, s->sbm_mdio);
+
         for (cnt = 0; cnt < 32; cnt++) {
-                SBMAC_WRITECSR(s->sbm_mdio,bits | M_MAC_MDC | mac_mdio_genc);
-                SBMAC_WRITECSR(s->sbm_mdio,bits | mac_mdio_genc);
+                __raw_writeq(bits | M_MAC_MDC | mac_mdio_genc, s->sbm_mdio);
+                __raw_writeq(bits | mac_mdio_genc, s->sbm_mdio);
         }
 }
 
 /**********************************************************************
  *  SBMAC_MII_SENDDATA(s,data,bitcnt)
- *  
+ *
  *  Send some bits to the MII.  The bits to be sent are right-
  *  justified in the 'data' parameter.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
  *         data - data to send
  *         bitcnt - number of bits to send
@@ -498,20 +496,20 @@ static void sbmac_mii_senddata(struct sbmac_softc *s,unsigned int data, int bitc
         unsigned int curmask;
         int mac_mdio_genc;
 
-        mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;
-        
+        mac_mdio_genc = __raw_readq(s->sbm_mdio) & M_MAC_GENC;
+
         bits = M_MAC_MDIO_DIR_OUTPUT;
-        SBMAC_WRITECSR(s->sbm_mdio,bits | mac_mdio_genc);
-        
+        __raw_writeq(bits | mac_mdio_genc, s->sbm_mdio);
+
         curmask = 1 << (bitcnt - 1);
-        
+
         for (i = 0; i < bitcnt; i++) {
                 if (data & curmask)
                         bits |= M_MAC_MDIO_OUT;
                 else bits &= ~M_MAC_MDIO_OUT;
-                SBMAC_WRITECSR(s->sbm_mdio,bits | mac_mdio_genc);
-                SBMAC_WRITECSR(s->sbm_mdio,bits | M_MAC_MDC | mac_mdio_genc);
-                SBMAC_WRITECSR(s->sbm_mdio,bits | mac_mdio_genc);
+                __raw_writeq(bits | mac_mdio_genc, s->sbm_mdio);
+                __raw_writeq(bits | M_MAC_MDC | mac_mdio_genc, s->sbm_mdio);
+                __raw_writeq(bits | mac_mdio_genc, s->sbm_mdio);
                 curmask >>= 1;
         }
 }
@@ -520,14 +518,14 @@ static void sbmac_mii_senddata(struct sbmac_softc *s,unsigned int data, int bitc
 
 /**********************************************************************
  *  SBMAC_MII_READ(s,phyaddr,regidx)
- *  
+ *
  *  Read a PHY register.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
  *         phyaddr - PHY's address
  *         regidx = index of register to read
- *         
+ *
  *  Return value:
  *         value read, or 0 if an error occurred.
  ********************************************************************* */
@@ -543,9 +541,9 @@ static unsigned int sbmac_mii_read(struct sbmac_softc *s,int phyaddr,int regidx)
          * Synchronize ourselves so that the PHY knows the next
          * thing coming down is a command
          */
-        
+
         sbmac_mii_sync(s);
-        
+
         /*
          * Send the data to the PHY.  The sequence is
          * a "start" command (2 bits)
@@ -553,59 +551,55 @@ static unsigned int sbmac_mii_read(struct sbmac_softc *s,int phyaddr,int regidx)
          * the PHY addr (5 bits)
          * the register index (5 bits)
          */
-        
+
         sbmac_mii_senddata(s,MII_COMMAND_START, 2);
         sbmac_mii_senddata(s,MII_COMMAND_READ, 2);
         sbmac_mii_senddata(s,phyaddr, 5);
         sbmac_mii_senddata(s,regidx, 5);
-        
-        mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;
-        
-        /* 
+
+        mac_mdio_genc = __raw_readq(s->sbm_mdio) & M_MAC_GENC;
+
+        /*
          * Switch the port around without a clock transition.
          */
-        SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);
-        
+        __raw_writeq(M_MAC_MDIO_DIR_INPUT | mac_mdio_genc, s->sbm_mdio);
+
         /*
          * Send out a clock pulse to signal we want the status
          */
-        
-        SBMAC_WRITECSR(s->sbm_mdio,
-                       M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc);
-        SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);
-        
-        /* 
+
+        __raw_writeq(M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc, s->sbm_mdio);
+        __raw_writeq(M_MAC_MDIO_DIR_INPUT | mac_mdio_genc, s->sbm_mdio);
+
+        /*
          * If an error occurred, the PHY will signal '1' back
          */
-        error = SBMAC_READCSR(s->sbm_mdio) & M_MAC_MDIO_IN;
-        
-        /* 
+        error = __raw_readq(s->sbm_mdio) & M_MAC_MDIO_IN;
+
+        /*
          * Issue an 'idle' clock pulse, but keep the direction
          * the same.
          */
-        SBMAC_WRITECSR(s->sbm_mdio,
-                       M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc);
-        SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);
-        
+        __raw_writeq(M_MAC_MDIO_DIR_INPUT | M_MAC_MDC | mac_mdio_genc, s->sbm_mdio);
+        __raw_writeq(M_MAC_MDIO_DIR_INPUT | mac_mdio_genc, s->sbm_mdio);
+
         regval = 0;
-        
+
         for (idx = 0; idx < 16; idx++) {
                 regval <<= 1;
-                
+
                 if (error == 0) {
-                        if (SBMAC_READCSR(s->sbm_mdio) & M_MAC_MDIO_IN)
+                        if (__raw_readq(s->sbm_mdio) & M_MAC_MDIO_IN)
                                 regval |= 1;
                 }
-                
-                SBMAC_WRITECSR(s->sbm_mdio,
-                               M_MAC_MDIO_DIR_INPUT|M_MAC_MDC | mac_mdio_genc);
-                SBMAC_WRITECSR(s->sbm_mdio,
-                               M_MAC_MDIO_DIR_INPUT | mac_mdio_genc);
+
+                __raw_writeq(M_MAC_MDIO_DIR_INPUT|M_MAC_MDC | mac_mdio_genc, s->sbm_mdio);
+                __raw_writeq(M_MAC_MDIO_DIR_INPUT | mac_mdio_genc, s->sbm_mdio);
         }
-        
+
         /* Switch back to output */
-        SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc);
-        
+        __raw_writeq(M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc, s->sbm_mdio);
+
         if (error == 0)
                 return regval;
         return 0;
@@ -614,15 +608,15 @@ static unsigned int sbmac_mii_read(struct sbmac_softc *s,int phyaddr,int regidx)
 
 /**********************************************************************
  *  SBMAC_MII_WRITE(s,phyaddr,regidx,regval)
- *  
+ *
  *  Write a value to a PHY register.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
  *         phyaddr - PHY to use
  *         regidx - register within the PHY
  *         regval - data to write to register
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -633,7 +627,7 @@ static void sbmac_mii_write(struct sbmac_softc *s,int phyaddr,int regidx,
         int mac_mdio_genc;
 
         sbmac_mii_sync(s);
-        
+
         sbmac_mii_senddata(s,MII_COMMAND_START,2);
         sbmac_mii_senddata(s,MII_COMMAND_WRITE,2);
         sbmac_mii_senddata(s,phyaddr, 5);
@@ -641,27 +635,27 @@ static void sbmac_mii_write(struct sbmac_softc *s,int phyaddr,int regidx,
         sbmac_mii_senddata(s,MII_COMMAND_ACK,2);
         sbmac_mii_senddata(s,regval,16);
 
-        mac_mdio_genc = SBMAC_READCSR(s->sbm_mdio) & M_MAC_GENC;
+        mac_mdio_genc = __raw_readq(s->sbm_mdio) & M_MAC_GENC;
 
-        SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc);
+        __raw_writeq(M_MAC_MDIO_DIR_OUTPUT | mac_mdio_genc, s->sbm_mdio);
 }
 
 
 
 /**********************************************************************
  *  SBDMA_INITCTX(d,s,chan,txrx,maxdescr)
- *  
+ *
  *  Initialize a DMA channel context.  Since there are potentially
  *  eight DMA channels per MAC, it's nice to do this in a standard
- *  way.  
- *  
- *  Input parameters: 
+ *  way.
+ *
+ *  Input parameters:
  *         d - sbmacdma_t structure (DMA channel context)
  *         s - sbmac_softc structure (pointer to a MAC)
  *         chan - channel number (0..1 right now)
  *         txrx - Identifies DMA_TX or DMA_RX for channel direction
  *      maxdescr - number of descriptors
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -672,101 +666,87 @@ static void sbdma_initctx(sbmacdma_t *d,
                           int txrx,
                           int maxdescr)
 {
-        /* 
-         * Save away interesting stuff in the structure 
+        /*
+         * Save away interesting stuff in the structure
          */
-        
+
         d->sbdma_eth       = s;
         d->sbdma_channel   = chan;
         d->sbdma_txdir     = txrx;
-        
+
 #if 0
         /* RMON clearing */
         s->sbe_idx =(s->sbm_base - A_MAC_BASE_0)/MAC_SPACING;
 #endif
 
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BYTES)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_COLLISIONS)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_LATE_COL)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_EX_COL)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_FCS_ERROR)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_ABORT)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BAD)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_GOOD)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_RUNT)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_OVERSIZE)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BYTES)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_MCAST)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BCAST)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BAD)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_GOOD)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_RUNT)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_OVERSIZE)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_FCS_ERROR)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_LENGTH_ERROR)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_CODE_ERROR)), 0);
-        SBMAC_WRITECSR(IOADDR(
-        A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_ALIGN_ERROR)), 0);
-
-        /* 
-         * initialize register pointers 
-         */
-        
-        d->sbdma_config0 = 
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BYTES)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_COLLISIONS)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_LATE_COL)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_EX_COL)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_FCS_ERROR)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_ABORT)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_BAD)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_GOOD)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_RUNT)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_TX_OVERSIZE)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BYTES)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_MCAST)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BCAST)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_BAD)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_GOOD)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_RUNT)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_OVERSIZE)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_FCS_ERROR)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_LENGTH_ERROR)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_CODE_ERROR)));
+        __raw_writeq(0, IOADDR(A_MAC_REGISTER(s->sbe_idx, R_MAC_RMON_RX_ALIGN_ERROR)));
+
+        /*
+         * initialize register pointers
+         */
+
+        d->sbdma_config0 =
                 s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CONFIG0);
-        d->sbdma_config1 = 
+        d->sbdma_config1 =
                 s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CONFIG1);
-        d->sbdma_dscrbase = 
+        d->sbdma_dscrbase =
                 s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_BASE);
-        d->sbdma_dscrcnt = 
+        d->sbdma_dscrcnt =
                 s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_CNT);
-        d->sbdma_curdscr =      
+        d->sbdma_curdscr =
                 s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CUR_DSCRADDR);
-        
+
         /*
          * Allocate memory for the ring
          */
-        
+
         d->sbdma_maxdescr = maxdescr;
-        
-        d->sbdma_dscrtable = (sbdmadscr_t *) 
-                kmalloc(d->sbdma_maxdescr*sizeof(sbdmadscr_t), GFP_KERNEL);
-        
+
+        d->sbdma_dscrtable = (sbdmadscr_t *)
+                kmalloc((d->sbdma_maxdescr+1)*sizeof(sbdmadscr_t), GFP_KERNEL);
+
+        /*
+         * The descriptor table must be aligned to at least 16 bytes or the
+         * MAC will corrupt it.
+         */
+        d->sbdma_dscrtable = (sbdmadscr_t *)
+                ALIGN((unsigned long)d->sbdma_dscrtable, sizeof(sbdmadscr_t));
+
         memset(d->sbdma_dscrtable,0,d->sbdma_maxdescr*sizeof(sbdmadscr_t));
-        
+
         d->sbdma_dscrtable_end = d->sbdma_dscrtable + d->sbdma_maxdescr;
-        
+
         d->sbdma_dscrtable_phys = virt_to_phys(d->sbdma_dscrtable);
-        
+
         /*
          * And context table
          */
-        
-        d->sbdma_ctxtable = (struct sk_buff **) 
+
+        d->sbdma_ctxtable = (struct sk_buff **)
                 kmalloc(d->sbdma_maxdescr*sizeof(struct sk_buff *), GFP_KERNEL);
-        
+
         memset(d->sbdma_ctxtable,0,d->sbdma_maxdescr*sizeof(struct sk_buff *));
-        
+
 #ifdef CONFIG_SBMAC_COALESCE
         /*
          * Setup Rx/Tx DMA coalescing defaults
@@ -777,7 +757,7 @@ static void sbdma_initctx(sbmacdma_t *d,
         } else {
                 d->sbdma_int_pktcnt = 1;
         }
-        
+
         if ( int_timeout ) {
                 d->sbdma_int_timeout = int_timeout;
         } else {
@@ -789,13 +769,13 @@ static void sbdma_initctx(sbmacdma_t *d,
 
 /**********************************************************************
  *  SBDMA_CHANNEL_START(d)
- *  
+ *
  *  Initialize the hardware registers for a DMA channel.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d - DMA channel to init (context must be previously init'd
  *         rxtx - DMA_RX or DMA_TX depending on what type of channel
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -805,24 +785,21 @@ static void sbdma_channel_start(sbmacdma_t *d, int rxtx )
         /*
          * Turn on the DMA channel
          */
-        
+
 #ifdef CONFIG_SBMAC_COALESCE
-        SBMAC_WRITECSR(d->sbdma_config1,
-                       V_DMA_INT_TIMEOUT(d->sbdma_int_timeout) |
-                       0);
-        SBMAC_WRITECSR(d->sbdma_config0,
-                       M_DMA_EOP_INT_EN |
+        __raw_writeq(V_DMA_INT_TIMEOUT(d->sbdma_int_timeout) |
+                       0, d->sbdma_config1);
+        __raw_writeq(M_DMA_EOP_INT_EN |
                        V_DMA_RINGSZ(d->sbdma_maxdescr) |
                        V_DMA_INT_PKTCNT(d->sbdma_int_pktcnt) |
-                       0);
+                       0, d->sbdma_config0);
 #else
-        SBMAC_WRITECSR(d->sbdma_config1,0);
-        SBMAC_WRITECSR(d->sbdma_config0,
-                       V_DMA_RINGSZ(d->sbdma_maxdescr) |
-                       0);
+        __raw_writeq(0, d->sbdma_config1);
+        __raw_writeq(V_DMA_RINGSZ(d->sbdma_maxdescr) |
+                       0, d->sbdma_config0);
 #endif
 
-        SBMAC_WRITECSR(d->sbdma_dscrbase,d->sbdma_dscrtable_phys);
+        __raw_writeq(d->sbdma_dscrtable_phys, d->sbdma_dscrbase);
 
         /*
          * Initialize ring pointers
@@ -834,12 +811,12 @@ static void sbdma_channel_start(sbmacdma_t *d, int rxtx )
 
 /**********************************************************************
  *  SBDMA_CHANNEL_STOP(d)
- *  
+ *
  *  Initialize the hardware registers for a DMA channel.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d - DMA channel to init (context must be previously init'd
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -849,44 +826,44 @@ static void sbdma_channel_stop(sbmacdma_t *d)
         /*
          * Turn off the DMA channel
          */
-        
-        SBMAC_WRITECSR(d->sbdma_config1,0);
-        
-        SBMAC_WRITECSR(d->sbdma_dscrbase,0);
-        
-        SBMAC_WRITECSR(d->sbdma_config0,0);
-        
+
+        __raw_writeq(0, d->sbdma_config1);
+
+        __raw_writeq(0, d->sbdma_dscrbase);
+
+        __raw_writeq(0, d->sbdma_config0);
+
         /*
          * Zero ring pointers
          */
-        
-        d->sbdma_addptr = 0;
-        d->sbdma_remptr = 0;
+
+        d->sbdma_addptr = NULL;
+        d->sbdma_remptr = NULL;
 }
 
 static void sbdma_align_skb(struct sk_buff *skb,int power2,int offset)
 {
         unsigned long addr;
         unsigned long newaddr;
-        
+
         addr = (unsigned long) skb->data;
-        
+
         newaddr = (addr + power2 - 1) & ~(power2 - 1);
-        
+
         skb_reserve(skb,newaddr-addr+offset);
 }
 
 
 /**********************************************************************
  *  SBDMA_ADD_RCVBUFFER(d,sb)
- *  
+ *
  *  Add a buffer to the specified DMA channel.   For receive channels,
  *  this queues a buffer for inbound packets.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d - DMA channel descriptor
  *         sb - sk_buff to add, or NULL if we should allocate one
- *         
+ *
  *  Return value:
  *         0 if buffer could not be added (ring is full)
  *         1 if buffer added successfully
@@ -899,24 +876,24 @@ static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb)
         sbdmadscr_t *nextdsc;
         struct sk_buff *sb_new = NULL;
         int pktsize = ENET_PACKET_SIZE;
-        
+
         /* get pointer to our current place in the ring */
-        
+
         dsc = d->sbdma_addptr;
         nextdsc = SBDMA_NEXTBUF(d,sbdma_addptr);
-        
+
         /*
          * figure out if the ring is full - if the next descriptor
          * is the same as the one that we're going to remove from
          * the ring, the ring is full
          */
-        
+
         if (nextdsc == d->sbdma_remptr) {
                 return -ENOSPC;
         }
 
-        /* 
-         * Allocate a sk_buff if we don't already have one.  
+        /*
+         * Allocate a sk_buff if we don't already have one.
          * If we do have an sk_buff, reset it so that it's empty.
          *
          * Note: sk_buffs don't seem to be guaranteed to have any sort
@@ -925,7 +902,7 @@ static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb)
          *
          *    1. the data does not start in the middle of a cache line.
          *    2. The data does not end in the middle of a cache line
-         *    3. The buffer can be aligned such that the IP addresses are 
+         *    3. The buffer can be aligned such that the IP addresses are
          *       naturally aligned.
          *
          *  Remember, the SOCs MAC writes whole cache lines at a time,
@@ -933,7 +910,7 @@ static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb)
          *  data portion starts in the middle of a cache line, the SOC
          *  DMA will trash the beginning (and ending) portions.
          */
-        
+
         if (sb == NULL) {
                 sb_new = dev_alloc_skb(ENET_PACKET_SIZE + SMP_CACHE_BYTES * 2 + ETHER_ALIGN);
                 if (sb_new == NULL) {
@@ -949,23 +926,22 @@ static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb)
         }
         else {
                 sb_new = sb;
-                /* 
+                /*
                  * nothing special to reinit buffer, it's already aligned
                  * and sb->data already points to a good place.
                  */
         }
-        
+
         /*
-         * fill in the descriptor 
+         * fill in the descriptor
          */
-        
+
 #ifdef CONFIG_SBMAC_COALESCE
         /*
          * Do not interrupt per DMA transfer.
          */
         dsc->dscr_a = virt_to_phys(sb_new->data) |
-                V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |
-                0;
+                V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) | 0;
 #else
         dsc->dscr_a = virt_to_phys(sb_new->data) |
                 V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |
@@ -974,38 +950,38 @@ static int sbdma_add_rcvbuffer(sbmacdma_t *d,struct sk_buff *sb)
 
         /* receiving: no options */
         dsc->dscr_b = 0;
-        
+
         /*
-         * fill in the context 
+         * fill in the context
          */
-        
+
         d->sbdma_ctxtable[dsc-d->sbdma_dscrtable] = sb_new;
-        
-        /* 
-         * point at next packet 
+
+        /*
+         * point at next packet
          */
-        
+
         d->sbdma_addptr = nextdsc;
-        
-        /* 
+
+        /*
          * Give the buffer to the DMA engine.
          */
-        
-        SBMAC_WRITECSR(d->sbdma_dscrcnt,1);
-        
+
+        __raw_writeq(1, d->sbdma_dscrcnt);
+
         return 0;                                       /* we did it */
 }
 
 /**********************************************************************
  *  SBDMA_ADD_TXBUFFER(d,sb)
- *  
+ *
  *  Add a transmit buffer to the specified DMA channel, causing a
  *  transmit to start.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d - DMA channel descriptor
  *         sb - sk_buff to add
- *         
+ *
  *  Return value:
  *         0 transmit queued successfully
  *         otherwise error code
@@ -1019,70 +995,70 @@ static int sbdma_add_txbuffer(sbmacdma_t *d,struct sk_buff *sb)
         uint64_t phys;
         uint64_t ncb;
         int length;
-        
+
         /* get pointer to our current place in the ring */
-        
+
         dsc = d->sbdma_addptr;
         nextdsc = SBDMA_NEXTBUF(d,sbdma_addptr);
-        
+
         /*
          * figure out if the ring is full - if the next descriptor
          * is the same as the one that we're going to remove from
          * the ring, the ring is full
          */
-        
+
         if (nextdsc == d->sbdma_remptr) {
                 return -ENOSPC;
         }
-        
+
         /*
          * Under Linux, it's not necessary to copy/coalesce buffers
          * like it is on NetBSD.  We think they're all contiguous,
          * but that may not be true for GBE.
          */
-        
+
         length = sb->len;
-        
+
         /*
          * fill in the descriptor.  Note that the number of cache
          * blocks in the descriptor is the number of blocks
          * *spanned*, so we need to add in the offset (if any)
          * while doing the calculation.
          */
-        
+
         phys = virt_to_phys(sb->data);
         ncb = NUMCACHEBLKS(length+(phys & (SMP_CACHE_BYTES - 1)));
 
-        dsc->dscr_a = phys | 
+        dsc->dscr_a = phys |
                 V_DMA_DSCRA_A_SIZE(ncb) |
 #ifndef CONFIG_SBMAC_COALESCE
                 M_DMA_DSCRA_INTERRUPT |
 #endif
                 M_DMA_ETHTX_SOP;
-        
+
         /* transmitting: set outbound options and length */
 
         dsc->dscr_b = V_DMA_DSCRB_OPTIONS(K_DMA_ETHTX_APPENDCRC_APPENDPAD) |
                 V_DMA_DSCRB_PKT_SIZE(length);
-        
+
         /*
-         * fill in the context 
+         * fill in the context
          */
-        
+
         d->sbdma_ctxtable[dsc-d->sbdma_dscrtable] = sb;
-        
-        /* 
-         * point at next packet 
+
+        /*
+         * point at next packet
          */
-        
+
         d->sbdma_addptr = nextdsc;
-        
-        /* 
+
+        /*
          * Give the buffer to the DMA engine.
          */
-        
-        SBMAC_WRITECSR(d->sbdma_dscrcnt,1);
-        
+
+        __raw_writeq(1, d->sbdma_dscrcnt);
+
         return 0;                                       /* we did it */
 }
 
@@ -1091,12 +1067,12 @@ static int sbdma_add_txbuffer(sbmacdma_t *d,struct sk_buff *sb)
 
 /**********************************************************************
  *  SBDMA_EMPTYRING(d)
- *  
+ *
  *  Free all allocated sk_buffs on the specified DMA channel;
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d  - DMA channel
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1105,7 +1081,7 @@ static void sbdma_emptyring(sbmacdma_t *d)
 {
         int idx;
         struct sk_buff *sb;
-        
+
         for (idx = 0; idx < d->sbdma_maxdescr; idx++) {
                 sb = d->sbdma_ctxtable[idx];
                 if (sb) {
@@ -1118,13 +1094,13 @@ static void sbdma_emptyring(sbmacdma_t *d)
 
 /**********************************************************************
  *  SBDMA_FILLRING(d)
- *  
+ *
  *  Fill the specified DMA channel (must be receive channel)
  *  with sk_buffs
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         d - DMA channel
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1132,7 +1108,7 @@ static void sbdma_emptyring(sbmacdma_t *d)
 static void sbdma_fillring(sbmacdma_t *d)
 {
         int idx;
-        
+
         for (idx = 0; idx < SBMAC_MAX_RXDESCR-1; idx++) {
                 if (sbdma_add_rcvbuffer(d,NULL) != 0)
                         break;
@@ -1142,16 +1118,16 @@ static void sbdma_fillring(sbmacdma_t *d)
 
 /**********************************************************************
  *  SBDMA_RX_PROCESS(sc,d)
- *  
- *  Process "completed" receive buffers on the specified DMA channel.  
+ *
+ *  Process "completed" receive buffers on the specified DMA channel.
  *  Note that this isn't really ideal for priority channels, since
- *  it processes all of the packets on a given channel before 
- *  returning. 
+ *  it processes all of the packets on a given channel before
+ *  returning.
  *
- *  Input parameters: 
+ *  Input parameters:
  *         sc - softc structure
  *         d - DMA channel context
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1163,56 +1139,56 @@ static void sbdma_rx_process(struct sbmac_softc *sc,sbmacdma_t *d)
         sbdmadscr_t *dsc;
         struct sk_buff *sb;
         int len;
-        
+
         for (;;) {
-                /* 
+                /*
                  * figure out where we are (as an index) and where
                  * the hardware is (also as an index)
                  *
-                 * This could be done faster if (for example) the 
+                 * This could be done faster if (for example) the
                  * descriptor table was page-aligned and contiguous in
                  * both virtual and physical memory -- you could then
                  * just compare the low-order bits of the virtual address
                  * (sbdma_remptr) and the physical address (sbdma_curdscr CSR)
                  */
-                
+
                 curidx = d->sbdma_remptr - d->sbdma_dscrtable;
-                hwidx = (int) (((SBMAC_READCSR(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
+                hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
                                 d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));
-                
+
                 /*
                  * If they're the same, that means we've processed all
                  * of the descriptors up to (but not including) the one that
                  * the hardware is working on right now.
                  */
-                
+
                 if (curidx == hwidx)
                         break;
-                
+
                 /*
                  * Otherwise, get the packet's sk_buff ptr back
                  */
-                
+
                 dsc = &(d->sbdma_dscrtable[curidx]);
                 sb = d->sbdma_ctxtable[curidx];
                 d->sbdma_ctxtable[curidx] = NULL;
-                
+
                 len = (int)G_DMA_DSCRB_PKT_SIZE(dsc->dscr_b) - 4;
-                
+
                 /*
                  * Check packet status.  If good, process it.
                  * If not, silently drop it and put it back on the
                  * receive ring.
                  */
-                
+
                 if (!(dsc->dscr_a & M_DMA_ETHRX_BAD)) {
-                        
+
                         /*
                          * Add a new buffer to replace the old one.  If we fail
                          * to allocate a buffer, we're going to drop this
                          * packet and put it right back on the receive ring.
                          */
-                        
+
                         if (sbdma_add_rcvbuffer(d,NULL) == -ENOBUFS) {
                                 sc->sbm_stats.rx_dropped++;
                                 sbdma_add_rcvbuffer(d,sb); /* re-add old buffer */
@@ -1221,7 +1197,7 @@ static void sbdma_rx_process(struct sbmac_softc *sc,sbmacdma_t *d)
                                  * Set length into the packet
                                  */
                                 skb_put(sb,len);
-                                
+
                                 /*
                                  * Buffer has been replaced on the
                                  * receive ring.  Pass the buffer to
@@ -1240,7 +1216,7 @@ static void sbdma_rx_process(struct sbmac_softc *sc,sbmacdma_t *d)
                                                 sb->ip_summed = CHECKSUM_NONE;
                                         }
                                 }
-                                
+
                                 netif_rx(sb);
                         }
                 } else {
@@ -1251,14 +1227,14 @@ static void sbdma_rx_process(struct sbmac_softc *sc,sbmacdma_t *d)
                         sc->sbm_stats.rx_errors++;
                         sbdma_add_rcvbuffer(d,sb);
                 }
-                
-                
-                /* 
+
+
+                /*
                  * .. and advance to the next buffer.
                  */
-                
+
                 d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);
-                
+
         }
 }
 
@@ -1266,17 +1242,17 @@ static void sbdma_rx_process(struct sbmac_softc *sc,sbmacdma_t *d)
 
 /**********************************************************************
  *  SBDMA_TX_PROCESS(sc,d)
- *  
- *  Process "completed" transmit buffers on the specified DMA channel.  
+ *
+ *  Process "completed" transmit buffers on the specified DMA channel.
  *  This is normally called within the interrupt service routine.
  *  Note that this isn't really ideal for priority channels, since
- *  it processes all of the packets on a given channel before 
- *  returning. 
+ *  it processes all of the packets on a given channel before
+ *  returning.
  *
- *  Input parameters: 
+ *  Input parameters:
  *      sc - softc structure
  *         d - DMA channel context
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1290,21 +1266,21 @@ static void sbdma_tx_process(struct sbmac_softc *sc,sbmacdma_t *d)
         unsigned long flags;
 
         spin_lock_irqsave(&(sc->sbm_lock), flags);
-        
+
         for (;;) {
-                /* 
+                /*
                  * figure out where we are (as an index) and where
                  * the hardware is (also as an index)
                  *
-                 * This could be done faster if (for example) the 
+                 * This could be done faster if (for example) the
                  * descriptor table was page-aligned and contiguous in
                  * both virtual and physical memory -- you could then
                  * just compare the low-order bits of the virtual address
                  * (sbdma_remptr) and the physical address (sbdma_curdscr CSR)
                  */
-                
+
                 curidx = d->sbdma_remptr - d->sbdma_dscrtable;
-                hwidx = (int) (((SBMAC_READCSR(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
+                hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
                                 d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));
 
                 /*
@@ -1312,75 +1288,75 @@ static void sbdma_tx_process(struct sbmac_softc *sc,sbmacdma_t *d)
                  * of the descriptors up to (but not including) the one that
                  * the hardware is working on right now.
                  */
-                
+
                 if (curidx == hwidx)
                         break;
-                
+
                 /*
                  * Otherwise, get the packet's sk_buff ptr back
                  */
-                
+
                 dsc = &(d->sbdma_dscrtable[curidx]);
                 sb = d->sbdma_ctxtable[curidx];
                 d->sbdma_ctxtable[curidx] = NULL;
-                
+
                 /*
                  * Stats
                  */
-                
+
                 sc->sbm_stats.tx_bytes += sb->len;
                 sc->sbm_stats.tx_packets++;
-                
+
                 /*
                  * for transmits, we just free buffers.
                  */
-                
+
                 dev_kfree_skb_irq(sb);
-                
-                /* 
+
+                /*
                  * .. and advance to the next buffer.
                  */
 
                 d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);
-                
+
         }
-        
+
         /*
          * Decide if we should wake up the protocol or not.
          * Other drivers seem to do this when we reach a low
          * watermark on the transmit queue.
          */
-        
+
         netif_wake_queue(d->sbdma_eth->sbm_dev);
-        
+
         spin_unlock_irqrestore(&(sc->sbm_lock), flags);
-        
+
 }
 
 
 
 /**********************************************************************
  *  SBMAC_INITCTX(s)
- *  
+ *
  *  Initialize an Ethernet context structure - this is called
  *  once per MAC on the 1250.  Memory is allocated here, so don't
  *  call it again from inside the ioctl routines that bring the
  *  interface up/down
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac context structure
- *         
+ *
  *  Return value:
  *         0
  ********************************************************************* */
 
 static int sbmac_initctx(struct sbmac_softc *s)
 {
-        
-        /* 
-         * figure out the addresses of some ports 
+
+        /*
+         * figure out the addresses of some ports
          */
-        
+
         s->sbm_macenable = s->sbm_base + R_MAC_ENABLE;
         s->sbm_maccfg    = s->sbm_base + R_MAC_CFG;
         s->sbm_fifocfg   = s->sbm_base + R_MAC_THRSH_CFG;
@@ -1397,29 +1373,29 @@ static int sbmac_initctx(struct sbmac_softc *s)
         s->sbm_phy_oldanlpar = 0;
         s->sbm_phy_oldk1stsr = 0;
         s->sbm_phy_oldlinkstat = 0;
-        
+
         /*
          * Initialize the DMA channels.  Right now, only one per MAC is used
          * Note: Only do this _once_, as it allocates memory from the kernel!
          */
-        
+
         sbdma_initctx(&(s->sbm_txdma),s,0,DMA_TX,SBMAC_MAX_TXDESCR);
         sbdma_initctx(&(s->sbm_rxdma),s,0,DMA_RX,SBMAC_MAX_RXDESCR);
-        
+
         /*
          * initial state is OFF
          */
-        
+
         s->sbm_state = sbmac_state_off;
-        
+
         /*
          * Initial speed is (XXX TEMP) 10MBit/s HDX no FC
          */
-        
+
         s->sbm_speed = sbmac_speed_10;
         s->sbm_duplex = sbmac_duplex_half;
         s->sbm_fc = sbmac_fc_disabled;
-        
+
         return 0;
 }
 
@@ -1430,7 +1406,7 @@ static void sbdma_uninitctx(struct sbmacdma_s *d)
                 kfree(d->sbdma_dscrtable);
                 d->sbdma_dscrtable = NULL;
         }
-        
+
         if (d->sbdma_ctxtable) {
                 kfree(d->sbdma_ctxtable);
                 d->sbdma_ctxtable = NULL;
@@ -1447,12 +1423,12 @@ static void sbmac_uninitctx(struct sbmac_softc *sc)
 
 /**********************************************************************
  *  SBMAC_CHANNEL_START(s)
- *  
+ *
  *  Start packet processing on this MAC.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1460,49 +1436,49 @@ static void sbmac_uninitctx(struct sbmac_softc *sc)
 static void sbmac_channel_start(struct sbmac_softc *s)
 {
         uint64_t reg;
-        sbmac_port_t port;
+        volatile void __iomem *port;
         uint64_t cfg,fifo,framecfg;
         int idx, th_value;
-        
+
         /*
          * Don't do this if running
          */
 
         if (s->sbm_state == sbmac_state_on)
                 return;
-        
+
         /*
          * Bring the controller out of reset, but leave it off.
          */
-        
-        SBMAC_WRITECSR(s->sbm_macenable,0);
-        
+
+        __raw_writeq(0, s->sbm_macenable);
+
         /*
          * Ignore all received packets
          */
-        
-        SBMAC_WRITECSR(s->sbm_rxfilter,0);
-        
-        /* 
+
+        __raw_writeq(0, s->sbm_rxfilter);
+
+        /*
          * Calculate values for various control registers.
          */
-        
+
         cfg = M_MAC_RETRY_EN |
-                M_MAC_TX_HOLD_SOP_EN | 
+                M_MAC_TX_HOLD_SOP_EN |
                 V_MAC_TX_PAUSE_CNT_16K |
                 M_MAC_AP_STAT_EN |
                 M_MAC_FAST_SYNC |
                 M_MAC_SS_EN |
                 0;
-        
-        /* 
+
+        /*
          * Be sure that RD_THRSH+WR_THRSH <= 32 for pass1 pars
          * and make sure that RD_THRSH + WR_THRSH <=128 for pass2 and above
          * Use a larger RD_THRSH for gigabit
          */
-        if (periph_rev >= 2) 
+        if (periph_rev >= 2)
                 th_value = 64;
-        else 
+        else
                 th_value = 28;
 
         fifo = V_MAC_TX_WR_THRSH(4) |   /* Must be '4' or '8' */
@@ -1520,51 +1496,51 @@ static void sbmac_channel_start(struct sbmac_softc *s)
                 V_MAC_BACKOFF_SEL(1);
 
         /*
-         * Clear out the hash address map 
+         * Clear out the hash address map
          */
-        
+
         port = s->sbm_base + R_MAC_HASH_BASE;
         for (idx = 0; idx < MAC_HASH_COUNT; idx++) {
-                SBMAC_WRITECSR(port,0);
+                __raw_writeq(0, port);
                 port += sizeof(uint64_t);
         }
-        
+
         /*
          * Clear out the exact-match table
          */
-        
+
         port = s->sbm_base + R_MAC_ADDR_BASE;
         for (idx = 0; idx < MAC_ADDR_COUNT; idx++) {
-                SBMAC_WRITECSR(port,0);
+                __raw_writeq(0, port);
                 port += sizeof(uint64_t);
         }
-        
+
         /*
          * Clear out the DMA Channel mapping table registers
          */
-        
+
         port = s->sbm_base + R_MAC_CHUP0_BASE;
         for (idx = 0; idx < MAC_CHMAP_COUNT; idx++) {
-                SBMAC_WRITECSR(port,0);
+                __raw_writeq(0, port);
                 port += sizeof(uint64_t);
         }
 
 
         port = s->sbm_base + R_MAC_CHLO0_BASE;
         for (idx = 0; idx < MAC_CHMAP_COUNT; idx++) {
-                SBMAC_WRITECSR(port,0);
+                __raw_writeq(0, port);
                 port += sizeof(uint64_t);
         }
-        
+
         /*
          * Program the hardware address.  It goes into the hardware-address
          * register as well as the first filter register.
          */
-        
+
         reg = sbmac_addr2reg(s->sbm_hwaddr);
-        
+
         port = s->sbm_base + R_MAC_ADDR_BASE;
-        SBMAC_WRITECSR(port,reg);
+        __raw_writeq(reg, port);
         port = s->sbm_base + R_MAC_ETHERNET_ADDR;
 
 #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
@@ -1573,108 +1549,105 @@ static void sbmac_channel_start(struct sbmac_softc *s)
          * destination address in the R_MAC_ETHERNET_ADDR register.
          * Set the value to zero.
          */
-        SBMAC_WRITECSR(port,0);
+        __raw_writeq(0, port);
 #else
-        SBMAC_WRITECSR(port,reg);
+        __raw_writeq(reg, port);
 #endif
-        
+
         /*
          * Set the receive filter for no packets, and write values
          * to the various config registers
          */
-        
-        SBMAC_WRITECSR(s->sbm_rxfilter,0);
-        SBMAC_WRITECSR(s->sbm_imr,0);
-        SBMAC_WRITECSR(s->sbm_framecfg,framecfg);
-        SBMAC_WRITECSR(s->sbm_fifocfg,fifo);
-        SBMAC_WRITECSR(s->sbm_maccfg,cfg);
-        
+
+        __raw_writeq(0, s->sbm_rxfilter);
+        __raw_writeq(0, s->sbm_imr);
+        __raw_writeq(framecfg, s->sbm_framecfg);
+        __raw_writeq(fifo, s->sbm_fifocfg);
+        __raw_writeq(cfg, s->sbm_maccfg);
+
         /*
          * Initialize DMA channels (rings should be ok now)
          */
-        
+
         sbdma_channel_start(&(s->sbm_rxdma), DMA_RX);
         sbdma_channel_start(&(s->sbm_txdma), DMA_TX);
-        
+
         /*
          * Configure the speed, duplex, and flow control
          */
 
         sbmac_set_speed(s,s->sbm_speed);
         sbmac_set_duplex(s,s->sbm_duplex,s->sbm_fc);
-        
+
         /*
          * Fill the receive ring
          */
-        
+
         sbdma_fillring(&(s->sbm_rxdma));
-        
-        /* 
+
+        /*
          * Turn on the rest of the bits in the enable register
-         */      
-        
-        SBMAC_WRITECSR(s->sbm_macenable,
-                       M_MAC_RXDMA_EN0 |
+         */
+
+        __raw_writeq(M_MAC_RXDMA_EN0 |
                        M_MAC_TXDMA_EN0 |
                        M_MAC_RX_ENABLE |
-                       M_MAC_TX_ENABLE);
-        
-        
+                       M_MAC_TX_ENABLE, s->sbm_macenable);
+
+
 
 
 #ifdef CONFIG_SBMAC_COALESCE
         /*
          * Accept any TX interrupt and EOP count/timer RX interrupts on ch 0
          */
-        SBMAC_WRITECSR(s->sbm_imr,
-                       ((M_MAC_INT_EOP_COUNT | M_MAC_INT_EOP_TIMER) << S_MAC_TX_CH0) |
-                       ((M_MAC_INT_EOP_COUNT | M_MAC_INT_EOP_TIMER) << S_MAC_RX_CH0));
+        __raw_writeq(((M_MAC_INT_EOP_COUNT | M_MAC_INT_EOP_TIMER) << S_MAC_TX_CH0) |
+                       ((M_MAC_INT_EOP_COUNT | M_MAC_INT_EOP_TIMER) << S_MAC_RX_CH0), s->sbm_imr);
 #else
         /*
          * Accept any kind of interrupt on TX and RX DMA channel 0
          */
-        SBMAC_WRITECSR(s->sbm_imr,
-                       (M_MAC_INT_CHANNEL << S_MAC_TX_CH0) |
-                       (M_MAC_INT_CHANNEL << S_MAC_RX_CH0));
+        __raw_writeq((M_MAC_INT_CHANNEL << S_MAC_TX_CH0) |
+                       (M_MAC_INT_CHANNEL << S_MAC_RX_CH0), s->sbm_imr);
 #endif
-        
-        /* 
-         * Enable receiving unicasts and broadcasts 
+
+        /*
+         * Enable receiving unicasts and broadcasts
          */
-        
-        SBMAC_WRITECSR(s->sbm_rxfilter,M_MAC_UCAST_EN | M_MAC_BCAST_EN);
-        
+
+        __raw_writeq(M_MAC_UCAST_EN | M_MAC_BCAST_EN, s->sbm_rxfilter);
+
         /*
-         * we're running now. 
+         * we're running now.
          */
-        
+
         s->sbm_state = sbmac_state_on;
-        
-        /* 
-         * Program multicast addresses 
+
+        /*
+         * Program multicast addresses
          */
-        
+
         sbmac_setmulti(s);
-        
-        /* 
-         * If channel was in promiscuous mode before, turn that on 
+
+        /*
+         * If channel was in promiscuous mode before, turn that on
          */
-        
+
         if (s->sbm_devflags & IFF_PROMISC) {
                 sbmac_promiscuous_mode(s,1);
         }
-        
+
 }
 
 
 /**********************************************************************
  *  SBMAC_CHANNEL_STOP(s)
- *  
+ *
  *  Stop packet processing on this MAC.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1682,49 +1655,49 @@ static void sbmac_channel_start(struct sbmac_softc *s)
 static void sbmac_channel_stop(struct sbmac_softc *s)
 {
         /* don't do this if already stopped */
-        
+
         if (s->sbm_state == sbmac_state_off)
                 return;
-        
+
         /* don't accept any packets, disable all interrupts */
-        
-        SBMAC_WRITECSR(s->sbm_rxfilter,0);
-        SBMAC_WRITECSR(s->sbm_imr,0);
-        
+
+        __raw_writeq(0, s->sbm_rxfilter);
+        __raw_writeq(0, s->sbm_imr);
+
         /* Turn off ticker */
-        
+
         /* XXX */
-        
+
         /* turn off receiver and transmitter */
-        
-        SBMAC_WRITECSR(s->sbm_macenable,0);
-        
+
+        __raw_writeq(0, s->sbm_macenable);
+
         /* We're stopped now. */
-        
+
         s->sbm_state = sbmac_state_off;
-        
+
         /*
          * Stop DMA channels (rings should be ok now)
          */
-        
+
         sbdma_channel_stop(&(s->sbm_rxdma));
         sbdma_channel_stop(&(s->sbm_txdma));
-        
+
         /* Empty the receive and transmit rings */
-        
+
         sbdma_emptyring(&(s->sbm_rxdma));
         sbdma_emptyring(&(s->sbm_txdma));
-        
+
 }
 
 /**********************************************************************
  *  SBMAC_SET_CHANNEL_STATE(state)
- *  
+ *
  *  Set the channel's state ON or OFF
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         state - new state
- *         
+ *
  *  Return value:
  *         old state
  ********************************************************************* */
@@ -1732,43 +1705,43 @@ static sbmac_state_t sbmac_set_channel_state(struct sbmac_softc *sc,
                                              sbmac_state_t state)
 {
         sbmac_state_t oldstate = sc->sbm_state;
-        
+
         /*
          * If same as previous state, return
          */
-        
+
         if (state == oldstate) {
                 return oldstate;
         }
-        
+
         /*
-         * If new state is ON, turn channel on 
+         * If new state is ON, turn channel on
          */
-        
+
         if (state == sbmac_state_on) {
                 sbmac_channel_start(sc);
         }
         else {
                 sbmac_channel_stop(sc);
         }
-        
+
         /*
          * Return previous state
          */
-        
+
         return oldstate;
 }
 
 
 /**********************************************************************
  *  SBMAC_PROMISCUOUS_MODE(sc,onoff)
- *  
+ *
  *  Turn on or off promiscuous mode
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         sc - softc
  *      onoff - 1 to turn on, 0 to turn off
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1776,30 +1749,30 @@ static sbmac_state_t sbmac_set_channel_state(struct sbmac_softc *sc,
 static void sbmac_promiscuous_mode(struct sbmac_softc *sc,int onoff)
 {
         uint64_t reg;
-        
+
         if (sc->sbm_state != sbmac_state_on)
                 return;
-        
+
         if (onoff) {
-                reg = SBMAC_READCSR(sc->sbm_rxfilter);
+                reg = __raw_readq(sc->sbm_rxfilter);
                 reg |= M_MAC_ALLPKT_EN;
-                SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
-        }       
+                __raw_writeq(reg, sc->sbm_rxfilter);
+        }
         else {
-                reg = SBMAC_READCSR(sc->sbm_rxfilter);
+                reg = __raw_readq(sc->sbm_rxfilter);
                 reg &= ~M_MAC_ALLPKT_EN;
-                SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
+                __raw_writeq(reg, sc->sbm_rxfilter);
         }
 }
 
 /**********************************************************************
  *  SBMAC_SETIPHDR_OFFSET(sc,onoff)
- *  
+ *
  *  Set the iphdr offset as 15 assuming ethernet encapsulation
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         sc - softc
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -1807,12 +1780,12 @@ static void sbmac_promiscuous_mode(struct sbmac_softc *sc,int onoff)
 static void sbmac_set_iphdr_offset(struct sbmac_softc *sc)
 {
         uint64_t reg;
-        
+
         /* Hard code the off set to 15 for now */
-        reg = SBMAC_READCSR(sc->sbm_rxfilter);
+        reg = __raw_readq(sc->sbm_rxfilter);
         reg &= ~M_MAC_IPHDR_OFFSET | V_MAC_IPHDR_OFFSET(15);
-        SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
-        
+        __raw_writeq(reg, sc->sbm_rxfilter);
+
         /* read system identification to determine revision */
         if (periph_rev >= 2) {
                 sc->rx_hw_checksum = ENABLE;
@@ -1824,13 +1797,13 @@ static void sbmac_set_iphdr_offset(struct sbmac_softc *sc)
 
 /**********************************************************************
  *  SBMAC_ADDR2REG(ptr)
- *  
+ *
  *  Convert six bytes into the 64-bit register value that
  *  we typically write into the SBMAC's address/mcast registers
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         ptr - pointer to 6 bytes
- *         
+ *
  *  Return value:
  *         register value
  ********************************************************************* */
@@ -1838,35 +1811,35 @@ static void sbmac_set_iphdr_offset(struct sbmac_softc *sc)
 static uint64_t sbmac_addr2reg(unsigned char *ptr)
 {
         uint64_t reg = 0;
-        
+
         ptr += 6;
-        
-        reg |= (uint64_t) *(--ptr); 
+
+        reg |= (uint64_t) *(--ptr);
         reg <<= 8;
-        reg |= (uint64_t) *(--ptr); 
+        reg |= (uint64_t) *(--ptr);
         reg <<= 8;
-        reg |= (uint64_t) *(--ptr); 
+        reg |= (uint64_t) *(--ptr);
         reg <<= 8;
-        reg |= (uint64_t) *(--ptr); 
+        reg |= (uint64_t) *(--ptr);
         reg <<= 8;
-        reg |= (uint64_t) *(--ptr); 
+        reg |= (uint64_t) *(--ptr);
         reg <<= 8;
-        reg |= (uint64_t) *(--ptr); 
-        
+        reg |= (uint64_t) *(--ptr);
+
         return reg;
 }
 
 
 /**********************************************************************
  *  SBMAC_SET_SPEED(s,speed)
- *  
+ *
  *  Configure LAN speed for the specified MAC.
  *  Warning: must be called when MAC is off!
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
  *         speed - speed to set MAC to (see sbmac_speed_t enum)
- *         
+ *
  *  Return value:
  *         1 if successful
  *      0 indicates invalid parameters
@@ -1880,31 +1853,31 @@ static int sbmac_set_speed(struct sbmac_softc *s,sbmac_speed_t speed)
         /*
          * Save new current values
          */
-        
+
         s->sbm_speed = speed;
-        
+
         if (s->sbm_state == sbmac_state_on)
                 return 0;       /* save for next restart */
 
         /*
-         * Read current register values 
+         * Read current register values
          */
-        
-        cfg = SBMAC_READCSR(s->sbm_maccfg);
-        framecfg = SBMAC_READCSR(s->sbm_framecfg);
-        
+
+        cfg = __raw_readq(s->sbm_maccfg);
+        framecfg = __raw_readq(s->sbm_framecfg);
+
         /*
          * Mask out the stuff we want to change
          */
-        
+
         cfg &= ~(M_MAC_BURST_EN | M_MAC_SPEED_SEL);
         framecfg &= ~(M_MAC_IFG_RX | M_MAC_IFG_TX | M_MAC_IFG_THRSH |
                       M_MAC_SLOT_SIZE);
-        
+
         /*
          * Now add in the new bits
          */
-        
+
         switch (speed) {
         case sbmac_speed_10:
                 framecfg |= V_MAC_IFG_RX_10 |
@@ -1913,7 +1886,7 @@ static int sbmac_set_speed(struct sbmac_softc *s,sbmac_speed_t speed)
                         V_MAC_SLOT_SIZE_10;
                 cfg |= V_MAC_SPEED_SEL_10MBPS;
                 break;
-                
+
         case sbmac_speed_100:
                 framecfg |= V_MAC_IFG_RX_100 |
                         V_MAC_IFG_TX_100 |
@@ -1921,7 +1894,7 @@ static int sbmac_set_speed(struct sbmac_softc *s,sbmac_speed_t speed)
                         V_MAC_SLOT_SIZE_100;
                 cfg |= V_MAC_SPEED_SEL_100MBPS ;
                 break;
-                
+
         case sbmac_speed_1000:
                 framecfg |= V_MAC_IFG_RX_1000 |
                         V_MAC_IFG_TX_1000 |
@@ -1929,34 +1902,34 @@ static int sbmac_set_speed(struct sbmac_softc *s,sbmac_speed_t speed)
                         V_MAC_SLOT_SIZE_1000;
                 cfg |= V_MAC_SPEED_SEL_1000MBPS | M_MAC_BURST_EN;
                 break;
-                
+
         case sbmac_speed_auto:          /* XXX not implemented */
                 /* fall through */
         default:
                 return 0;
         }
-        
+
         /*
-         * Send the bits back to the hardware 
+         * Send the bits back to the hardware
          */
-        
-        SBMAC_WRITECSR(s->sbm_framecfg,framecfg);
-        SBMAC_WRITECSR(s->sbm_maccfg,cfg);
-        
+
+        __raw_writeq(framecfg, s->sbm_framecfg);
+        __raw_writeq(cfg, s->sbm_maccfg);
+
         return 1;
 }
 
 /**********************************************************************
  *  SBMAC_SET_DUPLEX(s,duplex,fc)
- *  
+ *
  *  Set Ethernet duplex and flow control options for this MAC
  *  Warning: must be called when MAC is off!
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         s - sbmac structure
  *         duplex - duplex setting (see sbmac_duplex_t)
  *         fc - flow control setting (see sbmac_fc_t)
- *         
+ *
  *  Return value:
  *         1 if ok
  *         0 if an invalid parameter combination was specified
@@ -1965,67 +1938,67 @@ static int sbmac_set_speed(struct sbmac_softc *s,sbmac_speed_t speed)
 static int sbmac_set_duplex(struct sbmac_softc *s,sbmac_duplex_t duplex,sbmac_fc_t fc)
 {
         uint64_t cfg;
-        
+
         /*
          * Save new current values
          */
-        
+
         s->sbm_duplex = duplex;
         s->sbm_fc = fc;
-        
+
         if (s->sbm_state == sbmac_state_on)
                 return 0;       /* save for next restart */
-        
+
         /*
-         * Read current register values 
+         * Read current register values
          */
-        
-        cfg = SBMAC_READCSR(s->sbm_maccfg);
-        
+
+        cfg = __raw_readq(s->sbm_maccfg);
+
         /*
          * Mask off the stuff we're about to change
          */
-        
+
         cfg &= ~(M_MAC_FC_SEL | M_MAC_FC_CMD | M_MAC_HDX_EN);
-        
-        
+
+
         switch (duplex) {
         case sbmac_duplex_half:
                 switch (fc) {
                 case sbmac_fc_disabled:
                         cfg |= M_MAC_HDX_EN | V_MAC_FC_CMD_DISABLED;
                         break;
-                        
+
                 case sbmac_fc_collision:
                         cfg |= M_MAC_HDX_EN | V_MAC_FC_CMD_ENABLED;
                         break;
-                        
+
                 case sbmac_fc_carrier:
                         cfg |= M_MAC_HDX_EN | V_MAC_FC_CMD_ENAB_FALSECARR;
                         break;
-                        
+
                 case sbmac_fc_auto:             /* XXX not implemented */
-                        /* fall through */                                         
+                        /* fall through */
                 case sbmac_fc_frame:            /* not valid in half duplex */
                 default:                        /* invalid selection */
                         return 0;
                 }
                 break;
-                
+
         case sbmac_duplex_full:
                 switch (fc) {
                 case sbmac_fc_disabled:
                         cfg |= V_MAC_FC_CMD_DISABLED;
                         break;
-                        
+
                 case sbmac_fc_frame:
                         cfg |= V_MAC_FC_CMD_ENABLED;
                         break;
-                        
+
                 case sbmac_fc_collision:        /* not valid in full duplex */
                 case sbmac_fc_carrier:          /* not valid in full duplex */
                 case sbmac_fc_auto:             /* XXX not implemented */
-                        /* fall through */                                         
+                        /* fall through */
                 default:
                         return 0;
                 }
@@ -2034,13 +2007,13 @@ static int sbmac_set_duplex(struct sbmac_softc *s,sbmac_duplex_t duplex,sbmac_fc
                 /* XXX not implemented */
                 break;
         }
-        
+
         /*
-         * Send the bits back to the hardware 
+         * Send the bits back to the hardware
          */
-        
-        SBMAC_WRITECSR(s->sbm_maccfg,cfg);
-        
+
+        __raw_writeq(cfg, s->sbm_maccfg);
+
         return 1;
 }
 
@@ -2049,12 +2022,12 @@ static int sbmac_set_duplex(struct sbmac_softc *s,sbmac_duplex_t duplex,sbmac_fc
 
 /**********************************************************************
  *  SBMAC_INTR()
- *  
+ *
  *  Interrupt handler for MAC interrupts
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         MAC structure
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -2066,27 +2039,27 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance,struct pt_regs *rgs)
         int handled = 0;
 
         for (;;) {
-                
+
                 /*
                  * Read the ISR (this clears the bits in the real
                  * register, except for counter addr)
                  */
-                
-                isr = SBMAC_READCSR(sc->sbm_isr) & ~M_MAC_COUNTER_ADDR;
-                
+
+                isr = __raw_readq(sc->sbm_isr) & ~M_MAC_COUNTER_ADDR;
+
                 if (isr == 0)
                         break;
 
                 handled = 1;
-                
+
                 /*
                  * Transmits on channel 0
                  */
-                
+
                 if (isr & (M_MAC_INT_CHANNEL << S_MAC_TX_CH0)) {
                         sbdma_tx_process(sc,&(sc->sbm_txdma));
                 }
-                
+
                 /*
                  * Receives on channel 0
                  */
@@ -2106,8 +2079,8 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance,struct pt_regs *rgs)
                  * EOP_SEEN here takes care of this case.
                  * (EOP_SEEN is part of M_MAC_INT_CHANNEL << S_MAC_RX_CH0)
                  */
-                 
-                
+
+
                 if (isr & (M_MAC_INT_CHANNEL << S_MAC_RX_CH0)) {
                         sbdma_rx_process(sc,&(sc->sbm_rxdma));
                 }
@@ -2118,29 +2091,29 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance,struct pt_regs *rgs)
 
 /**********************************************************************
  *  SBMAC_START_TX(skb,dev)
- *  
- *  Start output on the specified interface.  Basically, we 
+ *
+ *  Start output on the specified interface.  Basically, we
  *  queue as many buffers as we can until the ring fills up, or
  *  we run off the end of the queue, whichever comes first.
- *  
- *  Input parameters: 
- *         
- *         
+ *
+ *  Input parameters:
+ *
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
 static int sbmac_start_tx(struct sk_buff *skb, struct net_device *dev)
 {
         struct sbmac_softc *sc = netdev_priv(dev);
-        
+
         /* lock eth irq */
         spin_lock_irq (&sc->sbm_lock);
-        
+
         /*
-         * Put the buffer on the transmit ring.  If we 
+         * Put the buffer on the transmit ring.  If we
          * don't have room, stop the queue.
          */
-        
+
         if (sbdma_add_txbuffer(&(sc->sbm_txdma),skb)) {
                 /* XXX save skb that we could not send */
                 netif_stop_queue(dev);
@@ -2148,24 +2121,24 @@ static int sbmac_start_tx(struct sk_buff *skb, struct net_device *dev)
 
                 return 1;
         }
-        
+
         dev->trans_start = jiffies;
-        
+
         spin_unlock_irq (&sc->sbm_lock);
-        
+
         return 0;
 }
 
 /**********************************************************************
  *  SBMAC_SETMULTI(sc)
- *  
+ *
  *  Reprogram the multicast table into the hardware, given
  *  the list of multicasts associated with the interface
  *  structure.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         sc - softc
- *         
+ *
  *  Return value:
  *         nothing
  ********************************************************************* */
@@ -2173,75 +2146,75 @@ static int sbmac_start_tx(struct sk_buff *skb, struct net_device *dev)
 static void sbmac_setmulti(struct sbmac_softc *sc)
 {
         uint64_t reg;
-        sbmac_port_t port;
+        volatile void __iomem *port;
         int idx;
         struct dev_mc_list *mclist;
         struct net_device *dev = sc->sbm_dev;
-        
-        /* 
+
+        /*
          * Clear out entire multicast table.  We do this by nuking
          * the entire hash table and all the direct matches except
-         * the first one, which is used for our station address 
+         * the first one, which is used for our station address
          */
-        
+
         for (idx = 1; idx < MAC_ADDR_COUNT; idx++) {
                 port = sc->sbm_base + R_MAC_ADDR_BASE+(idx*sizeof(uint64_t));
-                SBMAC_WRITECSR(port,0); 
+                __raw_writeq(0, port);
         }
-        
+
         for (idx = 0; idx < MAC_HASH_COUNT; idx++) {
                 port = sc->sbm_base + R_MAC_HASH_BASE+(idx*sizeof(uint64_t));
-                SBMAC_WRITECSR(port,0); 
+                __raw_writeq(0, port);
         }
-        
+
         /*
          * Clear the filter to say we don't want any multicasts.
          */
-        
-        reg = SBMAC_READCSR(sc->sbm_rxfilter);
+
+        reg = __raw_readq(sc->sbm_rxfilter);
         reg &= ~(M_MAC_MCAST_INV | M_MAC_MCAST_EN);
-        SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
-        
+        __raw_writeq(reg, sc->sbm_rxfilter);
+
         if (dev->flags & IFF_ALLMULTI) {
-                /* 
-                 * Enable ALL multicasts.  Do this by inverting the 
-                 * multicast enable bit. 
+                /*
+                 * Enable ALL multicasts.  Do this by inverting the
+                 * multicast enable bit.
                  */
-                reg = SBMAC_READCSR(sc->sbm_rxfilter);
+                reg = __raw_readq(sc->sbm_rxfilter);
                 reg |= (M_MAC_MCAST_INV | M_MAC_MCAST_EN);
-                SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
+                __raw_writeq(reg, sc->sbm_rxfilter);
                 return;
         }
-        
 
-        /* 
+
+        /*
          * Progam new multicast entries.  For now, only use the
          * perfect filter.  In the future we'll need to use the
          * hash filter if the perfect filter overflows
          */
-        
+
         /* XXX only using perfect filter for now, need to use hash
          * XXX if the table overflows */
-        
+
         idx = 1;                /* skip station address */
         mclist = dev->mc_list;
         while (mclist && (idx < MAC_ADDR_COUNT)) {
                 reg = sbmac_addr2reg(mclist->dmi_addr);
                 port = sc->sbm_base + R_MAC_ADDR_BASE+(idx * sizeof(uint64_t));
-                SBMAC_WRITECSR(port,reg);
+                __raw_writeq(reg, port);
                 idx++;
                 mclist = mclist->next;
         }
-        
-        /*      
+
+        /*
          * Enable the "accept multicast bits" if we programmed at least one
-         * multicast. 
+         * multicast.
          */
-        
+
         if (idx > 1) {
-                reg = SBMAC_READCSR(sc->sbm_rxfilter);
+                reg = __raw_readq(sc->sbm_rxfilter);
                 reg |= M_MAC_MCAST_EN;
-                SBMAC_WRITECSR(sc->sbm_rxfilter,reg);
+                __raw_writeq(reg, sc->sbm_rxfilter);
         }
 }
 
@@ -2250,12 +2223,12 @@ static void sbmac_setmulti(struct sbmac_softc *sc)
 #if defined(SBMAC_ETH0_HWADDR) || defined(SBMAC_ETH1_HWADDR) || defined(SBMAC_ETH2_HWADDR)
 /**********************************************************************
  *  SBMAC_PARSE_XDIGIT(str)
- *  
+ *
  *  Parse a hex digit, returning its value
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         str - character
- *         
+ *
  *  Return value:
  *         hex value, or -1 if invalid
  ********************************************************************* */
@@ -2263,7 +2236,7 @@ static void sbmac_setmulti(struct sbmac_softc *sc)
 static int sbmac_parse_xdigit(char str)
 {
         int digit;
-        
+
         if ((str >= '0') && (str <= '9'))
                 digit = str - '0';
         else if ((str >= 'a') && (str <= 'f'))
@@ -2272,20 +2245,20 @@ static int sbmac_parse_xdigit(char str)
                 digit = str - 'A' + 10;
         else
                 return -1;
-        
+
         return digit;
 }
 
 /**********************************************************************
  *  SBMAC_PARSE_HWADDR(str,hwaddr)
- *  
+ *
  *  Convert a string in the form xx:xx:xx:xx:xx:xx into a 6-byte
  *  Ethernet address.
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         str - string
  *         hwaddr - pointer to hardware address
- *         
+ *
  *  Return value:
  *         0 if ok, else -1
  ********************************************************************* */
@@ -2294,7 +2267,7 @@ static int sbmac_parse_hwaddr(char *str, unsigned char *hwaddr)
 {
         int digit1,digit2;
         int idx = 6;
-        
+
         while (*str && (idx > 0)) {
                 digit1 = sbmac_parse_xdigit(*str);
                 if (digit1 < 0)
@@ -2302,7 +2275,7 @@ static int sbmac_parse_hwaddr(char *str, unsigned char *hwaddr)
                 str++;
                 if (!*str)
                         return -1;
-                
+
                 if ((*str == ':') || (*str == '-')) {
                         digit2 = digit1;
                         digit1 = 0;
@@ -2313,10 +2286,10 @@ static int sbmac_parse_hwaddr(char *str, unsigned char *hwaddr)
                                 return -1;
                         str++;
                 }
-                
+
                 *hwaddr++ = (digit1 << 4) | digit2;
                 idx--;
-                
+
                 if (*str == '-')
                         str++;
                 if (*str == ':')
@@ -2337,12 +2310,12 @@ static int sb1250_change_mtu(struct net_device *_dev, int new_mtu)
 
 /**********************************************************************
  *  SBMAC_INIT(dev)
- *  
+ *
  *  Attach routine - init hardware and hook ourselves into linux
- *  
- *  Input parameters: 
+ *
+ *  Input parameters:
  *         dev - net_device structure
- *         
+ *
  *  Return value:
  *         status
  ********************************************************************* */
@@ -2354,53 +2327,53 @@ static int sbmac_init(struct net_device *dev, int idx)
         uint64_t ea_reg;
         int i;
         int err;
-        
+
         sc = netdev_priv(dev);
-        
+
         /* Determine controller base address */
-        
+
         sc->sbm_base = IOADDR(dev->base_addr);
         sc->sbm_dev = dev;
         sc->sbe_idx = idx;
-        
+
         eaddr = sc->sbm_hwaddr;
-        
-        /* 
+
+        /*
          * Read the ethernet address.  The firwmare left this programmed
          * for us in the ethernet address register for each mac.
          */
-        
-        ea_reg = SBMAC_READCSR(sc->sbm_base + R_MAC_ETHERNET_ADDR);
-        SBMAC_WRITECSR(sc->sbm_base + R_MAC_ETHERNET_ADDR, 0);
+
+        ea_reg = __raw_readq(sc->sbm_base + R_MAC_ETHERNET_ADDR);
+        __raw_writeq(0, sc->sbm_base + R_MAC_ETHERNET_ADDR);
         for (i = 0; i < 6; i++) {
                 eaddr[i] = (uint8_t) (ea_reg & 0xFF);
                 ea_reg >>= 8;
         }
-        
+
         for (i = 0; i < 6; i++) {
                 dev->dev_addr[i] = eaddr[i];
         }
-        
-        
+
+
         /*
-         * Init packet size 
+         * Init packet size
          */
-        
+
         sc->sbm_buffersize = ENET_PACKET_SIZE + SMP_CACHE_BYTES * 2 + ETHER_ALIGN;
 
-        /* 
+        /*
          * Initialize context (get pointers to registers and stuff), then
          * allocate the memory for the descriptor tables.
          */
-        
+
         sbmac_initctx(sc);
-        
+
         /*
          * Set up Linux device callins
          */
-        
+
         spin_lock_init(&(sc->sbm_lock));
-        
+
         dev->open               = sbmac_open;
         dev->hard_start_xmit    = sbmac_start_tx;
         dev->stop               = sbmac_close;
@@ -2419,7 +2392,7 @@ static int sbmac_init(struct net_device *dev, int idx)
         if (err)
                 goto out_uninit;
 
-        if (periph_rev >= 2) {
+        if (sc->rx_hw_checksum == ENABLE) {
                 printk(KERN_INFO "%s: enabling TCP rcv checksum\n",
                         sc->sbm_dev->name);
         }
@@ -2430,10 +2403,10 @@ static int sbmac_init(struct net_device *dev, int idx)
          * was being displayed)
          */
         printk(KERN_INFO
-               "%s: SiByte Ethernet at 0x%08lX, address: %02X:%02X:%02X:%02X:%02X:%02X\n", 
+               "%s: SiByte Ethernet at 0x%08lX, address: %02X:%02X:%02X:%02X:%02X:%02X\n",
                dev->name, dev->base_addr,
                eaddr[0],eaddr[1],eaddr[2],eaddr[3],eaddr[4],eaddr[5]);
-        
+
 
         return 0;
 
@@ -2447,54 +2420,86 @@ out_uninit:
 static int sbmac_open(struct net_device *dev)
 {
         struct sbmac_softc *sc = netdev_priv(dev);
-        
+
         if (debug > 1) {
                 printk(KERN_DEBUG "%s: sbmac_open() irq %d.\n", dev->name, dev->irq);
         }
-        
-        /* 
+
+        /*
          * map/route interrupt (clear status first, in case something
          * weird is pending; we haven't initialized the mac registers
          * yet)
          */
 
-        SBMAC_READCSR(sc->sbm_isr);
+        __raw_readq(sc->sbm_isr);
         if (request_irq(dev->irq, &sbmac_intr, SA_SHIRQ, dev->name, dev))
                 return -EBUSY;
 
         /*
-         * Configure default speed 
+         * Probe phy address
+         */
+
+        if(sbmac_mii_probe(dev) == -1) {
+                printk("%s: failed to probe PHY.\n", dev->name);
+                return -EINVAL;
+        }
+
+        /*
+         * Configure default speed
          */
 
         sbmac_mii_poll(sc,noisy_mii);
-        
+
         /*
          * Turn on the channel
          */
 
         sbmac_set_channel_state(sc,sbmac_state_on);
-        
+
         /*
          * XXX Station address is in dev->dev_addr
          */
-        
+
         if (dev->if_port == 0)
-                dev->if_port = 0; 
-        
+                dev->if_port = 0;
+
         netif_start_queue(dev);
-        
+
         sbmac_set_rx_mode(dev);
-        
+
         /* Set the timer to check for link beat. */
         init_timer(&sc->sbm_timer);
         sc->sbm_timer.expires = jiffies + 2 * HZ/100;
         sc->sbm_timer.data = (unsigned long)dev;
         sc->sbm_timer.function = &sbmac_timer;
         add_timer(&sc->sbm_timer);
-        
+
         return 0;
 }
 
+static int sbmac_mii_probe(struct net_device *dev)
+{
+        int i;
+        struct sbmac_softc *s = netdev_priv(dev);
+        u16 bmsr, id1, id2;
+        u32 vendor, device;
+
+        for (i=1; i<31; i++) {
+        bmsr = sbmac_mii_read(s, i, MII_BMSR);
+                if (bmsr != 0) {
+                        s->sbm_phys[0] = i;
+                        id1 = sbmac_mii_read(s, i, MII_PHYIDR1);
+                        id2 = sbmac_mii_read(s, i, MII_PHYIDR2);
+                        vendor = ((u32)id1 << 6) | ((id2 >> 10) & 0x3f);
+                        device = (id2 >> 4) & 0x3f;
+
+                        printk(KERN_INFO "%s: found phy %d, vendor %06x part %02x\n",
+                                dev->name, i, vendor, device);
+                        return i;
+                }
+        }
+        return -1;
+}
 
 
 static int sbmac_mii_poll(struct sbmac_softc *s,int noisy)
@@ -2609,20 +2614,20 @@ static void sbmac_timer(unsigned long data)
         int mii_status;
 
         spin_lock_irq (&sc->sbm_lock);
-        
+
         /* make IFF_RUNNING follow the MII status bit "Link established" */
         mii_status = sbmac_mii_read(sc, sc->sbm_phys[0], MII_BMSR);
-        
+
         if ( (mii_status & BMSR_LINKSTAT) != (sc->sbm_phy_oldlinkstat) ) {
                 sc->sbm_phy_oldlinkstat = mii_status & BMSR_LINKSTAT;
                 if (mii_status & BMSR_LINKSTAT) {
                         netif_carrier_on(dev);
                 }
                 else {
-                        netif_carrier_off(dev); 
+                        netif_carrier_off(dev);
                 }
         }
-        
+
         /*
          * Poll the PHY to see what speed we should be running at
          */
@@ -2640,9 +2645,9 @@ static void sbmac_timer(unsigned long data)
                         sbmac_channel_start(sc);
                 }
         }
-        
+
         spin_unlock_irq (&sc->sbm_lock);
-        
+
         sc->sbm_timer.expires = jiffies + next_tick;
         add_timer(&sc->sbm_timer);
 }
@@ -2651,13 +2656,13 @@ static void sbmac_timer(unsigned long data)
 static void sbmac_tx_timeout (struct net_device *dev)
 {
         struct sbmac_softc *sc = netdev_priv(dev);
-        
+
         spin_lock_irq (&sc->sbm_lock);
-        
-        
+
+
         dev->trans_start = jiffies;
         sc->sbm_stats.tx_errors++;
-        
+
         spin_unlock_irq (&sc->sbm_lock);
 
         printk (KERN_WARNING "%s: Transmit timed out\n",dev->name);
@@ -2670,13 +2675,13 @@ static struct net_device_stats *sbmac_get_stats(struct net_device *dev)
 {
         struct sbmac_softc *sc = netdev_priv(dev);
         unsigned long flags;
-        
+
         spin_lock_irqsave(&sc->sbm_lock, flags);
-        
+
         /* XXX update other stats here */
-        
+
         spin_unlock_irqrestore(&sc->sbm_lock, flags);
-        
+
         return &sc->sbm_stats;
 }
 
@@ -2693,8 +2698,8 @@ static void sbmac_set_rx_mode(struct net_device *dev)
                 /*
                  * Promiscuous changed.
                  */
-                
-                if (dev->flags & IFF_PROMISC) { 
+
+                if (dev->flags & IFF_PROMISC) {
                         /* Unconditionally log net taps. */
                         msg_flag = 1;
                         sbmac_promiscuous_mode(sc,1);
@@ -2705,18 +2710,18 @@ static void sbmac_set_rx_mode(struct net_device *dev)
                 }
         }
         spin_unlock_irqrestore(&sc->sbm_lock, flags);
-        
+
         if (msg_flag) {
                 printk(KERN_NOTICE "%s: Promiscuous mode %sabled.\n",
                        dev->name,(msg_flag==1)?"en":"dis");
         }
-        
+
         /*
          * Program the multicasts.  Do this every time.
          */
-        
+
         sbmac_setmulti(sc);
-        
+
 }
 
 static int sbmac_mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
@@ -2725,10 +2730,10 @@ static int sbmac_mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         u16 *data = (u16 *)&rq->ifr_ifru;
         unsigned long flags;
         int retval;
-        
+
         spin_lock_irqsave(&sc->sbm_lock, flags);
         retval = 0;
-        
+
         switch(cmd) {
         case SIOCDEVPRIVATE:            /* Get the address of the PHY in use. */
                 data[0] = sc->sbm_phys[0] & 0x1f;
@@ -2750,7 +2755,7 @@ static int sbmac_mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         default:
                 retval = -EOPNOTSUPP;
         }
-        
+
         spin_unlock_irqrestore(&sc->sbm_lock, flags);
         return retval;
 }
@@ -2781,7 +2786,7 @@ static int sbmac_close(struct net_device *dev)
 
         sbdma_emptyring(&(sc->sbm_txdma));
         sbdma_emptyring(&(sc->sbm_rxdma));
-        
+
         return 0;
 }
 
@@ -2793,13 +2798,13 @@ sbmac_setup_hwaddr(int chan,char *addr)
 {
         uint8_t eaddr[6];
         uint64_t val;
-        sbmac_port_t port;
+        unsigned long port;
 
         port = A_MAC_CHANNEL_BASE(chan);
         sbmac_parse_hwaddr(addr,eaddr);
         val = sbmac_addr2reg(eaddr);
-        SBMAC_WRITECSR(IOADDR(port+R_MAC_ETHERNET_ADDR),val);
-        val = SBMAC_READCSR(IOADDR(port+R_MAC_ETHERNET_ADDR));
+        __raw_writeq(val, IOADDR(port+R_MAC_ETHERNET_ADDR));
+        val = __raw_readq(IOADDR(port+R_MAC_ETHERNET_ADDR));
 }
 #endif
 
@@ -2810,9 +2815,9 @@ sbmac_init_module(void)
 {
         int idx;
         struct net_device *dev;
-        sbmac_port_t port;
+        unsigned long port;
         int chip_max_units;
-        
+
         /*
          * For bringup when not using the firmware, we can pre-fill
          * the MAC addresses using the environment variables
@@ -2858,13 +2863,13 @@ sbmac_init_module(void)
 
                 port = A_MAC_CHANNEL_BASE(idx);
 
-                /*      
+                /*
                  * The R_MAC_ETHERNET_ADDR register will be set to some nonzero
                  * value for us by the firmware if we're going to use this MAC.
                  * If we find a zero, skip this MAC.
                  */
 
-                sbmac_orig_hwaddr[idx] = SBMAC_READCSR(IOADDR(port+R_MAC_ETHERNET_ADDR));
+                sbmac_orig_hwaddr[idx] = __raw_readq(IOADDR(port+R_MAC_ETHERNET_ADDR));
                 if (sbmac_orig_hwaddr[idx] == 0) {
                         printk(KERN_DEBUG "sbmac: not configuring MAC at "
                                "%lx\n", port);
@@ -2876,7 +2881,7 @@ sbmac_init_module(void)
                  */
 
                 dev = alloc_etherdev(sizeof(struct sbmac_softc));
-                if (!dev) 
+                if (!dev)
                         return -ENOMEM; /* return ENOMEM */
 
                 printk(KERN_DEBUG "sbmac: configuring MAC at %lx\n", port);
@@ -2886,8 +2891,7 @@ sbmac_init_module(void)
                 dev->mem_end = 0;
                 if (sbmac_init(dev, idx)) {
                         port = A_MAC_CHANNEL_BASE(idx);
-                        SBMAC_WRITECSR(IOADDR(port+R_MAC_ETHERNET_ADDR),
-                                       sbmac_orig_hwaddr[idx]);
+                        __raw_writeq(sbmac_orig_hwaddr[idx], IOADDR(port+R_MAC_ETHERNET_ADDR));
                         free_netdev(dev);
                         continue;
                 }
diff --git a/drivers/net/sgiseeq.c b/drivers/net/sgiseeq.c
index 9bc3b1c0dd6a..a4614df38a90 100644
--- a/drivers/net/sgiseeq.c
+++ b/drivers/net/sgiseeq.c
@@ -32,8 +32,6 @@
 
 #include "sgiseeq.h"
 
-static char *version = "sgiseeq.c: David S. Miller (dm@engr.sgi.com)\n";
-
 static char *sgiseeqstr = "SGI Seeq8003";
 
 /*
@@ -113,9 +111,9 @@ static struct net_device *root_sgiseeq_dev;
 
 static inline void hpc3_eth_reset(struct hpc3_ethregs *hregs)
 {
-        hregs->rx_reset = HPC3_ERXRST_CRESET | HPC3_ERXRST_CLRIRQ;
+        hregs->reset = HPC3_ERST_CRESET | HPC3_ERST_CLRIRQ;
         udelay(20);
-        hregs->rx_reset = 0;
+        hregs->reset = 0;
 }
 
 static inline void reset_hpc3_and_seeq(struct hpc3_ethregs *hregs,
@@ -252,7 +250,6 @@ void sgiseeq_dump_rings(void)
 
 #define TSTAT_INIT_SEEQ (SEEQ_TCMD_IPT|SEEQ_TCMD_I16|SEEQ_TCMD_IC|SEEQ_TCMD_IUF)
 #define TSTAT_INIT_EDLC ((TSTAT_INIT_SEEQ) | SEEQ_TCMD_RB2)
-#define RDMACFG_INIT    (HPC3_ERXDCFG_FRXDC | HPC3_ERXDCFG_FEOP | HPC3_ERXDCFG_FIRQ)
 
 static int init_seeq(struct net_device *dev, struct sgiseeq_private *sp,
                      struct sgiseeq_regs *sregs)
@@ -274,8 +271,6 @@ static int init_seeq(struct net_device *dev, struct sgiseeq_private *sp,
                 sregs->tstat = TSTAT_INIT_SEEQ;
         }
 
-        hregs->rx_dconfig |= RDMACFG_INIT;
-
         hregs->rx_ndptr = CPHYSADDR(sp->rx_desc);
         hregs->tx_ndptr = CPHYSADDR(sp->tx_desc);
 
@@ -446,7 +441,7 @@ static irqreturn_t sgiseeq_interrupt(int irq, void *dev_id, struct pt_regs *regs
         spin_lock(&sp->tx_lock);
 
         /* Ack the IRQ and set software state. */
-        hregs->rx_reset = HPC3_ERXRST_CLRIRQ;
+        hregs->reset = HPC3_ERST_CLRIRQ;
 
         /* Always check for received packets. */
         sgiseeq_rx(dev, sp, hregs, sregs);
@@ -493,11 +488,13 @@ static int sgiseeq_close(struct net_device *dev)
 {
         struct sgiseeq_private *sp = netdev_priv(dev);
         struct sgiseeq_regs *sregs = sp->sregs;
+        unsigned int irq = dev->irq;
 
         netif_stop_queue(dev);
 
         /* Shutdown the Seeq. */
         reset_hpc3_and_seeq(sp->hregs, sregs);
+        free_irq(irq, dev);
 
         return 0;
 }
@@ -644,7 +641,7 @@ static inline void setup_rx_ring(struct sgiseeq_rx_desc *buf, int nbufs)
 
 #define ALIGNED(x)  ((((unsigned long)(x)) + 0xf) & ~(0xf))
 
-static int sgiseeq_init(struct hpc3_regs* regs, int irq)
+static int sgiseeq_init(struct hpc3_regs* hpcregs, int irq)
 {
         struct sgiseeq_init_block *sr;
         struct sgiseeq_private *sp;
@@ -680,8 +677,8 @@ static int sgiseeq_init(struct hpc3_regs* regs, int irq)
         gpriv = sp;
         gdev = dev;
 #endif
-        sp->sregs = (struct sgiseeq_regs *) &hpc3c0->eth_ext[0];
-        sp->hregs = &hpc3c0->ethregs;
+        sp->sregs = (struct sgiseeq_regs *) &hpcregs->eth_ext[0];
+        sp->hregs = &hpcregs->ethregs;
         sp->name = sgiseeqstr;
         sp->mode = SEEQ_RCMD_RBCAST;
 
@@ -698,6 +695,11 @@ static int sgiseeq_init(struct hpc3_regs* regs, int irq)
         setup_rx_ring(sp->rx_desc, SEEQ_RX_BUFFERS);
         setup_tx_ring(sp->tx_desc, SEEQ_TX_BUFFERS);
 
+        /* Setup PIO and DMA transfer timing */
+        sp->hregs->pconfig = 0x161;
+        sp->hregs->dconfig = HPC3_EDCFG_FIRQ | HPC3_EDCFG_FEOP |
+                             HPC3_EDCFG_FRXDC | HPC3_EDCFG_PTO | 0x026;
+
         /* Reset the chip. */
         hpc3_eth_reset(sp->hregs);
 
@@ -724,7 +726,7 @@ static int sgiseeq_init(struct hpc3_regs* regs, int irq)
                 goto err_out_free_page;
         }
 
-        printk(KERN_INFO "%s: SGI Seeq8003 ", dev->name);
+        printk(KERN_INFO "%s: %s ", dev->name, sgiseeqstr);
         for (i = 0; i < 6; i++)
                 printk("%2.2x%c", dev->dev_addr[i], i == 5 ? '\n' : ':');
 
@@ -734,7 +736,7 @@ static int sgiseeq_init(struct hpc3_regs* regs, int irq)
         return 0;
 
 err_out_free_page:
-        free_page((unsigned long) sp);
+        free_page((unsigned long) sp->srings);
 err_out_free_dev:
         kfree(dev);
 
@@ -744,8 +746,6 @@ err_out:
 
 static int __init sgiseeq_probe(void)
 {
-        printk(version);
-
         /* On board adapter on 1st HPC is always present */
         return sgiseeq_init(hpc3c0, SGI_ENET_IRQ);
 }
@@ -754,15 +754,12 @@ static void __exit sgiseeq_exit(void)
 {
         struct net_device *next, *dev;
         struct sgiseeq_private *sp;
-        int irq;
 
         for (dev = root_sgiseeq_dev; dev; dev = next) {
                 sp = (struct sgiseeq_private *) netdev_priv(dev);
                 next = sp->next_module;
-                irq = dev->irq;
                 unregister_netdev(dev);
-                free_irq(irq, dev);
-                free_page((unsigned long) sp);
+                free_page((unsigned long) sp->srings);
                 free_netdev(dev);
         }
 }
@@ -770,4 +767,6 @@ static void __exit sgiseeq_exit(void)
 module_init(sgiseeq_probe);
 module_exit(sgiseeq_exit);
 
+MODULE_DESCRIPTION("SGI Seeq 8003 driver");
+MODULE_AUTHOR("Linux/MIPS Mailing List <linux-mips@linux-mips.org>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index 92f75529eff8..478791e09bf7 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -842,7 +842,7 @@ static void sis190_set_rx_mode(struct net_device *dev)
                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
                      i++, mclist = mclist->next) {
                         int bit_nr =
-                                ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
+                                ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x3f;
                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
                         rx_mode |= AcceptMulticast;
                 }
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 23b713c700b3..1d4d88680db1 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -1696,15 +1696,20 @@ static int sis900_rx(struct net_device *net_dev)
         long ioaddr = net_dev->base_addr;
         unsigned int entry = sis_priv->cur_rx % NUM_RX_DESC;
         u32 rx_status = sis_priv->rx_ring[entry].cmdsts;
+        int rx_work_limit;
 
         if (netif_msg_rx_status(sis_priv))
                 printk(KERN_DEBUG "sis900_rx, cur_rx:%4.4d, dirty_rx:%4.4d "
                        "status:0x%8.8x\n",
                        sis_priv->cur_rx, sis_priv->dirty_rx, rx_status);
+        rx_work_limit = sis_priv->dirty_rx + NUM_RX_DESC - sis_priv->cur_rx;
 
         while (rx_status & OWN) {
                 unsigned int rx_size;
 
+                if (--rx_work_limit < 0)
+                        break;
+
                 rx_size = (rx_status & DSIZE) - CRC_SIZE;
 
                 if (rx_status & (ABORT|OVERRUN|TOOLONG|RUNT|RXISERR|CRCERR|FAERR)) {
@@ -1732,9 +1737,11 @@ static int sis900_rx(struct net_device *net_dev)
                            we are working on NULL sk_buff :-( */
                         if (sis_priv->rx_skbuff[entry] == NULL) {
                                 if (netif_msg_rx_err(sis_priv))
-                                        printk(KERN_INFO "%s: NULL pointer " 
-                                                "encountered in Rx ring, skipping\n",
-                                                net_dev->name);
+                                        printk(KERN_WARNING "%s: NULL pointer " 
+                                              "encountered in Rx ring\n"
+                                              "cur_rx:%4.4d, dirty_rx:%4.4d\n",
+                                              net_dev->name, sis_priv->cur_rx,
+                                              sis_priv->dirty_rx);
                                 break;
                         }
 
@@ -1770,6 +1777,7 @@ static int sis900_rx(struct net_device *net_dev)
                                 sis_priv->rx_ring[entry].cmdsts = 0;
                                 sis_priv->rx_ring[entry].bufptr = 0;
                                 sis_priv->stats.rx_dropped++;
+                                sis_priv->cur_rx++;
                                 break;
                         }
                         skb->dev = net_dev;
@@ -1787,7 +1795,7 @@ static int sis900_rx(struct net_device *net_dev)
 
         /* refill the Rx buffer, what if the rate of refilling is slower
          * than consuming ?? */
-        for (;sis_priv->cur_rx - sis_priv->dirty_rx > 0; sis_priv->dirty_rx++) {
+        for (; sis_priv->cur_rx != sis_priv->dirty_rx; sis_priv->dirty_rx++) {
                 struct sk_buff *skb;
 
                 entry = sis_priv->dirty_rx % NUM_RX_DESC;
diff --git a/drivers/net/skfp/smt.c b/drivers/net/skfp/smt.c
index f17c05cbe44b..99a776a51fb5 100644
--- a/drivers/net/skfp/smt.c
+++ b/drivers/net/skfp/smt.c
@@ -1896,7 +1896,7 @@ void smt_swap_para(struct smt_header *sm, int len, int direction)
 
 static void smt_string_swap(char *data, const char *format, int len)
 {
-        const char      *open_paren = 0 ;
+        const char      *open_paren = NULL ;
         int     x ;
 
         while (len > 0  && *format) {
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index c2e6484ef138..572f121b1f4e 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -730,6 +730,7 @@ static struct ethtool_ops skge_ethtool_ops = {
         .phys_id        = skge_phys_id,
         .get_stats_count = skge_get_stats_count,
         .get_ethtool_stats = skge_get_ethtool_stats,
+        .get_perm_addr  = ethtool_op_get_perm_addr,
 };
 
 /*
@@ -3096,6 +3097,7 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
 
         /* read the mac address */
         memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port*8, ETH_ALEN);
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         /* device is off until link detection */
         netif_carrier_off(dev);
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index 1438fdd20826..c573bb351d4c 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1983,6 +1983,10 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr)
         if (lp->version >= (CHIP_91100 << 4))
                 smc_phy_detect(dev);
 
+        /* then shut everything down to save power */
+        smc_shutdown(dev);
+        smc_phy_powerdown(dev);
+
         /* Set default parameters */
         lp->msg_enable = NETIF_MSG_LINK;
         lp->ctl_rfduplx = 0;
@@ -2291,11 +2295,11 @@ static int smc_drv_remove(struct device *dev)
         return 0;
 }
 
-static int smc_drv_suspend(struct device *dev, pm_message_t state, u32 level)
+static int smc_drv_suspend(struct device *dev, pm_message_t state)
 {
         struct net_device *ndev = dev_get_drvdata(dev);
 
-        if (ndev && level == SUSPEND_DISABLE) {
+        if (ndev) {
                 if (netif_running(ndev)) {
                         netif_device_detach(ndev);
                         smc_shutdown(ndev);
@@ -2305,12 +2309,12 @@ static int smc_drv_suspend(struct device *dev, pm_message_t state, u32 level)
         return 0;
 }
 
-static int smc_drv_resume(struct device *dev, u32 level)
+static int smc_drv_resume(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct net_device *ndev = dev_get_drvdata(dev);
 
-        if (ndev && level == RESUME_ENABLE) {
+        if (ndev) {
                 struct smc_local *lp = netdev_priv(ndev);
                 smc_enable_device(pdev);
                 if (netif_running(ndev)) {
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index ac9ce6509eee..817f200742c3 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -230,12 +230,12 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define SMC_CAN_USE_16BIT       1
 #define SMC_CAN_USE_32BIT       0
 
-#define SMC_inb(a, r)           inb((a) + (r) - 0xa0000000)
-#define SMC_inw(a, r)           inw((a) + (r) - 0xa0000000)
-#define SMC_outb(v, a, r)       outb(v, (a) + (r) - 0xa0000000)
-#define SMC_outw(v, a, r)       outw(v, (a) + (r) - 0xa0000000)
-#define SMC_insw(a, r, p, l)    insw((a) + (r) - 0xa0000000, p, l)
-#define SMC_outsw(a, r, p, l)   outsw((a) + (r) - 0xa0000000, p, l)
+#define SMC_inb(a, r)           inb((u32)a) + (r))
+#define SMC_inw(a, r)           inw(((u32)a) + (r))
+#define SMC_outb(v, a, r)       outb(v, ((u32)a) + (r))
+#define SMC_outw(v, a, r)       outw(v, ((u32)a) + (r))
+#define SMC_insw(a, r, p, l)    insw(((u32)a) + (r), p, l)
+#define SMC_outsw(a, r, p, l)   outsw(((u32)a) + (r), p, l)
 
 #define set_irq_type(irq, type) do {} while(0)
 
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index efdb179ecc8c..38b2b0a3ce96 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -1091,8 +1091,10 @@ static int netdev_open(struct net_device *dev)
                 rx_ring_size = sizeof(struct starfire_rx_desc) * RX_RING_SIZE;
                 np->queue_mem_size = tx_done_q_size + rx_done_q_size + tx_ring_size + rx_ring_size;
                 np->queue_mem = pci_alloc_consistent(np->pci_dev, np->queue_mem_size, &np->queue_mem_dma);
-                if (np->queue_mem == 0)
+                if (np->queue_mem == NULL) {
+                        free_irq(dev->irq, dev);
                         return -ENOMEM;
+                }
 
                 np->tx_done_q     = np->queue_mem;
                 np->tx_done_q_dma = np->queue_mem_dma;
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index f88f5e32b714..cfaf47c63c58 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -214,7 +214,8 @@ static void bigmac_init_rings(struct bigmac *bp, int from_irq)
 {
         struct bmac_init_block *bb = bp->bmac_block;
         struct net_device *dev = bp->dev;
-        int i, gfp_flags = GFP_KERNEL;
+        int i;
+        gfp_t gfp_flags = GFP_KERNEL;
 
         if (from_irq || in_interrupt())
                 gfp_flags = GFP_ATOMIC;
diff --git a/drivers/net/sunbmac.h b/drivers/net/sunbmac.h
index 5674003fc38a..b0dbc5187143 100644
--- a/drivers/net/sunbmac.h
+++ b/drivers/net/sunbmac.h
@@ -339,7 +339,7 @@ struct bigmac {
 #define ALIGNED_RX_SKB_ADDR(addr) \
         ((((unsigned long)(addr) + (64 - 1)) & ~(64 - 1)) - (unsigned long)(addr))
 
-static inline struct sk_buff *big_mac_alloc_skb(unsigned int length, int gfp_flags)
+static inline struct sk_buff *big_mac_alloc_skb(unsigned int length, gfp_t gfp_flags)
 {
         struct sk_buff *skb;
 
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c
index d500a5771dbc..0ab9c38b4a34 100644
--- a/drivers/net/sundance.c
+++ b/drivers/net/sundance.c
@@ -80,7 +80,7 @@
           I/O access could affect performance in ARM-based system
         - Add Linux software VLAN support
         
-        Version LK1.08 (D-Link):
+        Version LK1.08 (Philippe De Muyter phdm@macqel.be):
         - Fix bug of custom mac address 
         (StationAddr register only accept word write) 
 
@@ -91,11 +91,14 @@
         Version LK1.09a (ICPlus):
         - Add the delay time in reading the contents of EEPROM
 
+        Version LK1.10 (Philippe De Muyter phdm@macqel.be):
+        - Make 'unblock interface after Tx underrun' work
+
 */
 
 #define DRV_NAME        "sundance"
-#define DRV_VERSION     "1.01+LK1.09a"
-#define DRV_RELDATE     "10-Jul-2003"
+#define DRV_VERSION     "1.01+LK1.10"
+#define DRV_RELDATE     "28-Oct-2005"
 
 
 /* The user-configurable values.
@@ -263,8 +266,10 @@ IV. Notes
 IVb. References
 
 The Sundance ST201 datasheet, preliminary version.
-http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
-http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
+The Kendin KS8723 datasheet, preliminary version.
+The ICplus IP100 datasheet, preliminary version.
+http://www.scyld.com/expert/100mbps.html
+http://www.scyld.com/expert/NWay.html
 
 IVc. Errata
 
@@ -500,6 +505,25 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static int  netdev_close(struct net_device *dev);
 static struct ethtool_ops ethtool_ops;
 
+static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
+{
+        struct netdev_private *np = netdev_priv(dev);
+        void __iomem *ioaddr = np->base + ASICCtrl;
+        int countdown;
+
+        /* ST201 documentation states ASICCtrl is a 32bit register */
+        iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
+        /* ST201 documentation states reset can take up to 1 ms */
+        countdown = 10 + 1;
+        while (ioread32 (ioaddr) & (ResetBusy << 16)) {
+                if (--countdown == 0) {
+                        printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
+                        break;
+                }
+                udelay(100);
+        }
+}
+
 static int __devinit sundance_probe1 (struct pci_dev *pdev,
                                       const struct pci_device_id *ent)
 {
@@ -518,6 +542,7 @@ static int __devinit sundance_probe1 (struct pci_dev *pdev,
 #else
         int bar = 1;
 #endif
+        int phy, phy_idx = 0;
 
 
 /* when built into the kernel, we only print version if device is found */
@@ -549,6 +574,7 @@ static int __devinit sundance_probe1 (struct pci_dev *pdev,
         for (i = 0; i < 3; i++)
                 ((u16 *)dev->dev_addr)[i] =
                         le16_to_cpu(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         dev->base_addr = (unsigned long)ioaddr;
         dev->irq = irq;
@@ -605,33 +631,31 @@ static int __devinit sundance_probe1 (struct pci_dev *pdev,
                         printk("%2.2x:", dev->dev_addr[i]);
         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
 
-        if (1) {
-                int phy, phy_idx = 0;
-                np->phys[0] = 1;                /* Default setting */
-                np->mii_preamble_required++;
-                for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
-                        int mii_status = mdio_read(dev, phy, MII_BMSR);
-                        if (mii_status != 0xffff  &&  mii_status != 0x0000) {
-                                np->phys[phy_idx++] = phy;
-                                np->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
-                                if ((mii_status & 0x0040) == 0)
-                                        np->mii_preamble_required++;
-                                printk(KERN_INFO "%s: MII PHY found at address %d, status "
-                                           "0x%4.4x advertising %4.4x.\n",
-                                           dev->name, phy, mii_status, np->mii_if.advertising);
-                        }
-                }
-                np->mii_preamble_required--;
-
-                if (phy_idx == 0) {
-                        printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
-                                   dev->name, ioread32(ioaddr + ASICCtrl));
-                        goto err_out_unregister;
+        np->phys[0] = 1;                /* Default setting */
+        np->mii_preamble_required++;
+        for (phy = 1; phy <= 32 && phy_idx < MII_CNT; phy++) {
+                int mii_status = mdio_read(dev, phy, MII_BMSR);
+                int phyx = phy & 0x1f;
+                if (mii_status != 0xffff  &&  mii_status != 0x0000) {
+                        np->phys[phy_idx++] = phyx;
+                        np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
+                        if ((mii_status & 0x0040) == 0)
+                                np->mii_preamble_required++;
+                        printk(KERN_INFO "%s: MII PHY found at address %d, status "
+                                   "0x%4.4x advertising %4.4x.\n",
+                                   dev->name, phyx, mii_status, np->mii_if.advertising);
                 }
+        }
+        np->mii_preamble_required--;
 
-                np->mii_if.phy_id = np->phys[0];
+        if (phy_idx == 0) {
+                printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
+                           dev->name, ioread32(ioaddr + ASICCtrl));
+                goto err_out_unregister;
         }
 
+        np->mii_if.phy_id = np->phys[0];
+
         /* Parse override configuration */
         np->an_enable = 1;
         if (card_idx < MAX_UNITS) {
@@ -692,7 +716,7 @@ static int __devinit sundance_probe1 (struct pci_dev *pdev,
         /* Reset the chip to erase previous misconfiguration. */
         if (netif_msg_hw(np))
                 printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));
-        iowrite16(0x007f, ioaddr + ASICCtrl + 2);
+        iowrite16(0x00ff, ioaddr + ASICCtrl + 2);
         if (netif_msg_hw(np))
                 printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));
 
@@ -1190,23 +1214,33 @@ static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *rgs
                                             ("%s: Transmit status is %2.2x.\n",
                                         dev->name, tx_status);
                                 if (tx_status & 0x1e) {
+                                        if (netif_msg_tx_err(np))
+                                                printk("%s: Transmit error status %4.4x.\n",
+                                                           dev->name, tx_status);
                                         np->stats.tx_errors++;
                                         if (tx_status & 0x10)
                                                 np->stats.tx_fifo_errors++;
                                         if (tx_status & 0x08)
                                                 np->stats.collisions++;
+                                        if (tx_status & 0x04)
+                                                np->stats.tx_fifo_errors++;
                                         if (tx_status & 0x02)
                                                 np->stats.tx_window_errors++;
-                                        /* This reset has not been verified!. */
-                                        if (tx_status & 0x10) { /* Reset the Tx. */
-                                                np->stats.tx_fifo_errors++;
-                                                spin_lock(&np->lock);
-                                                reset_tx(dev);
-                                                spin_unlock(&np->lock);
+                                        /*
+                                        ** This reset has been verified on
+                                        ** DFE-580TX boards ! phdm@macqel.be.
+                                        */
+                                        if (tx_status & 0x10) { /* TxUnderrun */
+                                                unsigned short txthreshold;
+
+                                                txthreshold = ioread16 (ioaddr + TxStartThresh);
+                                                /* Restart Tx FIFO and transmitter */
+                                                sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
+                                                iowrite16 (txthreshold, ioaddr + TxStartThresh);
+                                                /* No need to reset the Tx pointer here */
                                         }
-                                        if (tx_status & 0x1e)   /* Restart the Tx. */
-                                                iowrite16 (TxEnable,
-                                                        ioaddr + MACCtrl1);
+                                        /* Restart the Tx. */
+                                        iowrite16 (TxEnable, ioaddr + MACCtrl1);
                                 }
                                 /* Yup, this is a documentation bug.  It cost me *hours*. */
                                 iowrite16 (0, ioaddr + TxStatus);
@@ -1619,6 +1653,7 @@ static struct ethtool_ops ethtool_ops = {
         .get_link = get_link,
         .get_msglevel = get_msglevel,
         .set_msglevel = set_msglevel,
+        .get_perm_addr = ethtool_op_get_perm_addr,
 };
 
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 1802c3b48799..1828a6bf8458 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -37,6 +37,7 @@
 #include <linux/tcp.h>
 #include <linux/workqueue.h>
 #include <linux/prefetch.h>
+#include <linux/dma-mapping.h>
 
 #include <net/checksum.h>
 
@@ -67,8 +68,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.42"
-#define DRV_MODULE_RELDATE      "Oct 3, 2005"
+#define DRV_MODULE_VERSION      "3.43"
+#define DRV_MODULE_RELDATE      "Oct 24, 2005"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -219,6 +220,10 @@ static struct pci_device_id tg3_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S,
@@ -466,6 +471,15 @@ static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
         spin_unlock_irqrestore(&tp->indirect_lock, flags);
 }
 
+static void tg3_write_mem_fast(struct tg3 *tp, u32 off, u32 val)
+{
+        /* If no workaround is needed, write to mem space directly */
+        if (tp->write32 != tg3_write_indirect_reg32)
+                tw32(NIC_SRAM_WIN_BASE + off, val);
+        else
+                tg3_write_mem(tp, off, val);
+}
+
 static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
 {
         unsigned long flags;
@@ -570,7 +584,7 @@ static void tg3_switch_clocks(struct tg3 *tp)
         u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
         u32 orig_clock_ctrl;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                 return;
 
         orig_clock_ctrl = clock_ctrl;
@@ -1210,7 +1224,7 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
                      CLOCK_CTRL_ALTCLK |
                      CLOCK_CTRL_PWRDOWN_PLL133);
                 udelay(40);
-        } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+        } else if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                 /* do nothing */
         } else if (!((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
                      (tp->tg3_flags & TG3_FLAG_ENABLE_ASF))) {
@@ -3712,14 +3726,14 @@ static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
         dev->mtu = new_mtu;
 
         if (new_mtu > ETH_DATA_LEN) {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                         tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
                         ethtool_op_set_tso(dev, 0);
                 }
                 else
                         tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
         } else {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                         tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
                 tp->tg3_flags &= ~TG3_FLAG_JUMBO_RING_ENABLE;
         }
@@ -3850,7 +3864,7 @@ static void tg3_init_rings(struct tg3 *tp)
         memset(tp->tx_ring, 0, TG3_TX_RING_BYTES);
 
         tp->rx_pkt_buf_sz = RX_PKT_BUF_SZ;
-        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) &&
+        if ((tp->tg3_flags2 & TG3_FLG2_5780_CLASS) &&
             (tp->dev->mtu > ETH_DATA_LEN))
                 tp->rx_pkt_buf_sz = RX_JUMBO_PKT_BUF_SZ;
 
@@ -3905,10 +3919,8 @@ static void tg3_init_rings(struct tg3 *tp)
  */
 static void tg3_free_consistent(struct tg3 *tp)
 {
-        if (tp->rx_std_buffers) {
-                kfree(tp->rx_std_buffers);
-                tp->rx_std_buffers = NULL;
-        }
+        kfree(tp->rx_std_buffers);
+        tp->rx_std_buffers = NULL;
         if (tp->rx_std) {
                 pci_free_consistent(tp->pdev, TG3_RX_RING_BYTES,
                                     tp->rx_std, tp->rx_std_mapping);
@@ -4347,7 +4359,7 @@ static int tg3_chip_reset(struct tg3 *tp)
         val &= ~PCIX_CAPS_RELAXED_ORDERING;
         pci_write_config_dword(tp->pdev, TG3PCI_X_CAPS, val);
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                 u32 val;
 
                 /* Chip reset on 5780 will reset MSI enable bit,
@@ -6003,7 +6015,7 @@ static int tg3_reset_hw(struct tg3 *tp)
         tw32(MAC_RCV_VALUE_1, 0xffffffff & RCV_RULE_DISABLE_MASK);
 
         if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
-            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780))
+            !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 limit = 8;
         else
                 limit = 16;
@@ -6191,14 +6203,16 @@ static void tg3_timer(unsigned long __opaque)
                 tp->timer_counter = tp->timer_multiplier;
         }
 
-        /* Heartbeat is only sent once every 120 seconds.  */
+        /* Heartbeat is only sent once every 2 seconds.  */
         if (!--tp->asf_counter) {
                 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
                         u32 val;
 
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_ALIVE);
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 3);
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_MBOX,
+                                           FWCMD_NICDRV_ALIVE2);
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
+                        /* 5 seconds timeout */
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 5);
                         val = tr32(GRC_RX_CPU_EVENT);
                         val |= (1 << 14);
                         tw32(GRC_RX_CPU_EVENT, val);
@@ -6409,7 +6423,7 @@ static int tg3_open(struct net_device *dev)
                 tp->timer_counter = tp->timer_multiplier =
                         (HZ / tp->timer_offset);
                 tp->asf_counter = tp->asf_multiplier =
-                        ((HZ / tp->timer_offset) * 120);
+                        ((HZ / tp->timer_offset) * 2);
 
                 init_timer(&tp->timer);
                 tp->timer.expires = jiffies + tp->timer_offset;
@@ -7237,7 +7251,7 @@ static int tg3_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 cmd->supported |= (SUPPORTED_1000baseT_Half |
                                    SUPPORTED_1000baseT_Full);
 
-        if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES))
+        if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
                 cmd->supported |= (SUPPORTED_100baseT_Half |
                                   SUPPORTED_100baseT_Full |
                                   SUPPORTED_10baseT_Half |
@@ -7264,7 +7278,7 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
         struct tg3 *tp = netdev_priv(dev);
   
-        if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
+        if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) { 
                 /* These are the only valid advertisement bits allowed.  */
                 if (cmd->autoneg == AUTONEG_ENABLE &&
                     (cmd->advertising & ~(ADVERTISED_1000baseT_Half |
@@ -7272,7 +7286,17 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                                           ADVERTISED_Autoneg |
                                           ADVERTISED_FIBRE)))
                         return -EINVAL;
-        }
+                /* Fiber can only do SPEED_1000.  */
+                else if ((cmd->autoneg != AUTONEG_ENABLE) &&
+                         (cmd->speed != SPEED_1000))
+                        return -EINVAL;
+        /* Copper cannot force SPEED_1000.  */
+        } else if ((cmd->autoneg != AUTONEG_ENABLE) &&
+                   (cmd->speed == SPEED_1000))
+                return -EINVAL;
+        else if ((cmd->speed == SPEED_1000) &&
+                 (tp->tg3_flags2 & TG3_FLAG_10_100_ONLY))
+                return -EINVAL;
 
         tg3_full_lock(tp, 0);
 
@@ -8380,7 +8404,7 @@ static void __devinit tg3_get_nvram_info(struct tg3 *tp)
         }
 
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) ||
-            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)) {
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
                 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
                         case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
                                 tp->nvram_jedecnum = JEDEC_ATMEL;
@@ -8980,7 +9004,7 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 
                 tp->phy_id = eeprom_phy_id;
                 if (eeprom_phy_serdes) {
-                        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+                        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                                 tp->tg3_flags2 |= TG3_FLG2_MII_SERDES;
                         else
                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
@@ -9393,8 +9417,11 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         }
 
         /* Find msi capability. */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
+                tp->tg3_flags2 |= TG3_FLG2_5780_CLASS;
                 tp->msi_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_MSI);
+        }
 
         /* Initialize misc host control in PCI block. */
         tp->misc_host_ctrl |= (misc_ctrl_reg &
@@ -9412,7 +9439,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
 
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
@@ -9607,7 +9634,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
          * ether_setup() via the alloc_etherdev() call
          */
         if (tp->dev->mtu > ETH_DATA_LEN &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780)
+            !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
 
         /* Determine WakeOnLan speed to use. */
@@ -9830,7 +9857,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
         mac_offset = 0x7c;
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
              !(tp->tg3_flags & TG3_FLG2_SUN_570X)) ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
                         mac_offset = 0xcc;
                 if (tg3_nvram_lock(tp))
@@ -10148,6 +10175,9 @@ static int __devinit tg3_test_dma(struct tg3 *tp)
                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
                         /* 5780 always in PCIX mode */
                         tp->dma_rwctrl |= 0x00144000;
+                } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
+                        /* 5714 always in PCIX mode */
+                        tp->dma_rwctrl |= 0x00148000;
                 } else {
                         tp->dma_rwctrl |= 0x001b000f;
                 }
@@ -10347,6 +10377,7 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case PHY_ID_BCM5705:    return "5705";
         case PHY_ID_BCM5750:    return "5750";
         case PHY_ID_BCM5752:    return "5752";
+        case PHY_ID_BCM5714:    return "5714";
         case PHY_ID_BCM5780:    return "5780";
         case PHY_ID_BCM8002:    return "8002/serdes";
         case 0:                 return "serdes";
@@ -10492,17 +10523,17 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         }
 
         /* Configure DMA attributes. */
-        err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
         if (!err) {
                 pci_using_dac = 1;
-                err = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
+                err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
                 if (err < 0) {
                         printk(KERN_ERR PFX "Unable to obtain 64 bit DMA "
                                "for consistent allocations\n");
                         goto err_out_free_res;
                 }
         } else {
-                err = pci_set_dma_mask(pdev, 0xffffffffULL);
+                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (err) {
                         printk(KERN_ERR PFX "No usable DMA configuration, "
                                "aborting.\n");
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 2e733c60bfa4..fb7e2a5f4a08 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -137,6 +137,7 @@
 #define   ASIC_REV_5750                  0x04
 #define   ASIC_REV_5752                  0x06
 #define   ASIC_REV_5780                  0x08
+#define   ASIC_REV_5714                  0x09
 #define  GET_CHIP_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 8)
 #define   CHIPREV_5700_AX                0x70
 #define   CHIPREV_5700_BX                0x71
@@ -531,6 +532,8 @@
 #define  MAC_SERDES_CFG_EDGE_SELECT      0x00001000
 #define MAC_SERDES_STAT                 0x00000594
 /* 0x598 --> 0x5b0 unused */
+#define SERDES_RX_CTRL                  0x000005b0      /* 5780/5714 only */
+#define  SERDES_RX_SIG_DETECT            0x00000400
 #define SG_DIG_CTRL                     0x000005b0
 #define  SG_DIG_USING_HW_AUTONEG         0x80000000
 #define  SG_DIG_SOFT_RESET               0x40000000
@@ -1329,6 +1332,8 @@
 #define  GRC_LCLCTRL_CLEARINT           0x00000002
 #define  GRC_LCLCTRL_SETINT             0x00000004
 #define  GRC_LCLCTRL_INT_ON_ATTN        0x00000008
+#define  GRC_LCLCTRL_USE_SIG_DETECT     0x00000010      /* 5714/5780 only */
+#define  GRC_LCLCTRL_USE_EXT_SIG_DETECT 0x00000020      /* 5714/5780 only */
 #define  GRC_LCLCTRL_GPIO_INPUT3        0x00000020
 #define  GRC_LCLCTRL_GPIO_OE3           0x00000040
 #define  GRC_LCLCTRL_GPIO_OUTPUT3       0x00000080
@@ -1507,6 +1512,7 @@
 #define  FWCMD_NICDRV_IPV6ADDR_CHG       0x00000004
 #define  FWCMD_NICDRV_FIX_DMAR           0x00000005
 #define  FWCMD_NICDRV_FIX_DMAW           0x00000006
+#define  FWCMD_NICDRV_ALIVE2             0x0000000d
 #define NIC_SRAM_FW_CMD_LEN_MBOX        0x00000b7c
 #define NIC_SRAM_FW_CMD_DATA_MBOX       0x00000b80
 #define NIC_SRAM_FW_ASF_STATUS_MBOX     0x00000c00
@@ -2175,6 +2181,7 @@ struct tg3 {
                                         TG3_FLG2_MII_SERDES)
 #define TG3_FLG2_PARALLEL_DETECT        0x01000000
 #define TG3_FLG2_ICH_WORKAROUND         0x02000000
+#define TG3_FLG2_5780_CLASS             0x04000000
 
         u32                             split_mode_max_reqs;
 #define SPLIT_MODE_5704_MAX_REQ         3
@@ -2222,6 +2229,7 @@ struct tg3 {
 #define PHY_ID_BCM5705                  0x600081a0
 #define PHY_ID_BCM5750                  0x60008180
 #define PHY_ID_BCM5752                  0x60008100
+#define PHY_ID_BCM5714                  0x60008340
 #define PHY_ID_BCM5780                  0x60008350
 #define PHY_ID_BCM8002                  0x60010140
 #define PHY_ID_INVALID                  0xffffffff
@@ -2246,8 +2254,8 @@ struct tg3 {
          (X) == PHY_ID_BCM5411 || (X) == PHY_ID_BCM5701 || \
          (X) == PHY_ID_BCM5703 || (X) == PHY_ID_BCM5704 || \
          (X) == PHY_ID_BCM5705 || (X) == PHY_ID_BCM5750 || \
-         (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5780 || \
-         (X) == PHY_ID_BCM8002)
+         (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5714 || \
+         (X) == PHY_ID_BCM5780 || (X) == PHY_ID_BCM8002)
 
         struct tg3_hw_stats             *hw_stats;
         dma_addr_t                      stats_mapping;
diff --git a/drivers/net/tokenring/ibmtr.c b/drivers/net/tokenring/ibmtr.c
index 32057e65808b..9f491563944e 100644
--- a/drivers/net/tokenring/ibmtr.c
+++ b/drivers/net/tokenring/ibmtr.c
@@ -318,7 +318,7 @@ static void ibmtr_cleanup_card(struct net_device *dev)
         if (dev->base_addr) {
                 outb(0,dev->base_addr+ADAPTRESET);
                 
-                schedule_timeout(TR_RST_TIME); /* wait 50ms */
+                schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
 
                 outb(0,dev->base_addr+ADAPTRESETREL);
         }
@@ -854,8 +854,7 @@ static int tok_init_card(struct net_device *dev)
         writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
         outb(0, PIOaddr + ADAPTRESET);
 
-        current->state=TASK_UNINTERRUPTIBLE;
-        schedule_timeout(TR_RST_TIME); /* wait 50ms */
+        schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
 
         outb(0, PIOaddr + ADAPTRESETREL);
 #ifdef ENABLE_PAGING
@@ -903,8 +902,8 @@ static int tok_open(struct net_device *dev)
                         DPRINTK("Adapter is up and running\n");
                         return 0;
                 }
-                current->state=TASK_INTERRUPTIBLE;
-                i=schedule_timeout(TR_RETRY_INTERVAL); /* wait 30 seconds */
+                i=schedule_timeout_interruptible(TR_RETRY_INTERVAL);
+                                                        /* wait 30 seconds */
                 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
         }
         outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
diff --git a/drivers/net/tokenring/olympic.c b/drivers/net/tokenring/olympic.c
index 9e7923192a49..05477d24fd49 100644
--- a/drivers/net/tokenring/olympic.c
+++ b/drivers/net/tokenring/olympic.c
@@ -1101,7 +1101,7 @@ static int olympic_close(struct net_device *dev)
 
         while(olympic_priv->srb_queued) {
 
-                t = schedule_timeout(60*HZ); 
+                t = schedule_timeout_interruptible(60*HZ);
 
                 if(signal_pending(current))     {            
                         printk(KERN_WARNING "%s: SRB timed out.\n",dev->name);
diff --git a/drivers/net/tokenring/tms380tr.c b/drivers/net/tokenring/tms380tr.c
index 2e39bf1f7462..c1925590a0e1 100644
--- a/drivers/net/tokenring/tms380tr.c
+++ b/drivers/net/tokenring/tms380tr.c
@@ -1243,8 +1243,7 @@ void tms380tr_wait(unsigned long time)
         
         tmp = jiffies + time/(1000000/HZ);
         do {
-                current->state          = TASK_INTERRUPTIBLE;
-                tmp = schedule_timeout(tmp);
+                tmp = schedule_timeout_interruptible(tmp);
         } while(time_after(tmp, jiffies));
 #else
         udelay(time);
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index a22d00198e4d..d7fb3ffe06ac 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -1787,10 +1787,15 @@ static void __init de21041_get_srom_info (struct de_private *de)
         /* DEC now has a specification but early board makers
            just put the address in the first EEPROM locations. */
         /* This does  memcmp(eedata, eedata+16, 8) */
+
+#ifndef CONFIG_MIPS_COBALT
+
         for (i = 0; i < 8; i ++)
                 if (ee_data[i] != ee_data[16+i])
                         sa_offset = 20;
 
+#endif
+
         /* store MAC address */
         for (i = 0; i < 6; i ++)
                 de->dev->dev_addr[i] = ee_data[i + sa_offset];
@@ -2071,8 +2076,7 @@ static int __init de_init_one (struct pci_dev *pdev,
         return 0;
 
 err_out_iomap:
-        if (de->ee_data)
-                kfree(de->ee_data);
+        kfree(de->ee_data);
         iounmap(regs);
 err_out_res:
         pci_release_regions(pdev);
@@ -2091,8 +2095,7 @@ static void __exit de_remove_one (struct pci_dev *pdev)
         if (!dev)
                 BUG();
         unregister_netdev(dev);
-        if (de->ee_data)
-                kfree(de->ee_data);
+        kfree(de->ee_data);
         iounmap(de->regs);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index 6266a9a7e6e3..125ed00e95a5 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -1727,8 +1727,7 @@ err_out_free_ring:
                              tp->rx_ring, tp->rx_ring_dma);
 
 err_out_mtable:
-        if (tp->mtable)
-                kfree (tp->mtable);
+        kfree (tp->mtable);
         pci_iounmap(pdev, ioaddr);
 
 err_out_free_res:
@@ -1806,8 +1805,7 @@ static void __devexit tulip_remove_one (struct pci_dev *pdev)
                              sizeof (struct tulip_rx_desc) * RX_RING_SIZE +
                              sizeof (struct tulip_tx_desc) * TX_RING_SIZE,
                              tp->rx_ring, tp->rx_ring_dma);
-        if (tp->mtable)
-                kfree (tp->mtable);
+        kfree (tp->mtable);
         pci_iounmap(pdev, tp->base_addr);
         free_netdev (dev);
         pci_release_regions (pdev);
diff --git a/drivers/net/typhoon.c b/drivers/net/typhoon.c
index ecfa6f8805ce..4c76cb794bfb 100644
--- a/drivers/net/typhoon.c
+++ b/drivers/net/typhoon.c
@@ -419,10 +419,9 @@ typhoon_reset(void __iomem *ioaddr, int wait_type)
                            TYPHOON_STATUS_WAITING_FOR_HOST)
                                 goto out;
 
-                        if(wait_type == WaitSleep) {
-                                set_current_state(TASK_UNINTERRUPTIBLE);
-                                schedule_timeout(1);
-                        } else
+                        if(wait_type == WaitSleep)
+                                schedule_timeout_uninterruptible(1);
+                        else
                                 udelay(TYPHOON_UDELAY);
                 }
 
diff --git a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
index fc7738ffbfff..241871589283 100644
--- a/drivers/net/via-rhine.c
+++ b/drivers/net/via-rhine.c
@@ -490,6 +490,8 @@ struct rhine_private {
         u8 tx_thresh, rx_thresh;
 
         struct mii_if_info mii_if;
+        struct work_struct tx_timeout_task;
+        struct work_struct check_media_task;
         void __iomem *base;
 };
 
@@ -497,6 +499,8 @@ static int  mdio_read(struct net_device *dev, int phy_id, int location);
 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 static int  rhine_open(struct net_device *dev);
 static void rhine_tx_timeout(struct net_device *dev);
+static void rhine_tx_timeout_task(struct net_device *dev);
+static void rhine_check_media_task(struct net_device *dev);
 static int  rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
 static irqreturn_t rhine_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
 static void rhine_tx(struct net_device *dev);
@@ -814,8 +818,9 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
 
         for (i = 0; i < 6; i++)
                 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
+        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
-        if (!is_valid_ether_addr(dev->dev_addr)) {
+        if (!is_valid_ether_addr(dev->perm_addr)) {
                 rc = -EIO;
                 printk(KERN_ERR "Invalid MAC address\n");
                 goto err_out_unmap;
@@ -850,6 +855,12 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
         if (rp->quirks & rqRhineI)
                 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
 
+        INIT_WORK(&rp->tx_timeout_task,
+                  (void (*)(void *))rhine_tx_timeout_task, dev);
+
+        INIT_WORK(&rp->check_media_task,
+                  (void (*)(void *))rhine_check_media_task, dev);
+
         /* dev->name not defined before register_netdev()! */
         rc = register_netdev(dev);
         if (rc)
@@ -1076,6 +1087,11 @@ static void rhine_check_media(struct net_device *dev, unsigned int init_media)
                    ioaddr + ChipCmd1);
 }
 
+static void rhine_check_media_task(struct net_device *dev)
+{
+        rhine_check_media(dev, 0);
+}
+
 static void init_registers(struct net_device *dev)
 {
         struct rhine_private *rp = netdev_priv(dev);
@@ -1129,8 +1145,8 @@ static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
         if (quirks & rqRhineI) {
                 iowrite8(0x01, ioaddr + MIIRegAddr);    // MII_BMSR
 
-                /* Can be called from ISR. Evil. */
-                mdelay(1);
+                /* Do not call from ISR! */
+                msleep(1);
 
                 /* 0x80 must be set immediately before turning it off */
                 iowrite8(0x80, ioaddr + MIICmd);
@@ -1220,6 +1236,16 @@ static int rhine_open(struct net_device *dev)
 static void rhine_tx_timeout(struct net_device *dev)
 {
         struct rhine_private *rp = netdev_priv(dev);
+
+        /*
+         * Move bulk of work outside of interrupt context
+         */
+        schedule_work(&rp->tx_timeout_task);
+}
+
+static void rhine_tx_timeout_task(struct net_device *dev)
+{
+        struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
 
         printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
@@ -1625,7 +1651,7 @@ static void rhine_error(struct net_device *dev, int intr_status)
         spin_lock(&rp->lock);
 
         if (intr_status & IntrLinkChange)
-                rhine_check_media(dev, 0);
+                schedule_work(&rp->check_media_task);
         if (intr_status & IntrStatsMax) {
                 rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
                 rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
@@ -1829,6 +1855,7 @@ static struct ethtool_ops netdev_ethtool_ops = {
         .set_wol                = rhine_set_wol,
         .get_sg                 = ethtool_op_get_sg,
         .get_tx_csum            = ethtool_op_get_tx_csum,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
@@ -1872,6 +1899,9 @@ static int rhine_close(struct net_device *dev)
         spin_unlock_irq(&rp->lock);
 
         free_irq(rp->pdev->irq, dev);
+
+        flush_scheduled_work();
+
         free_rbufs(dev);
         free_tbufs(dev);
         free_ring(dev);
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index abc5cee6eedc..a368d08e7d19 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -1212,10 +1212,8 @@ static void velocity_free_td_ring(struct velocity_info *vptr)
                         velocity_free_td_ring_entry(vptr, j, i);
 
                 }
-                if (vptr->td_infos[j]) {
-                        kfree(vptr->td_infos[j]);
-                        vptr->td_infos[j] = NULL;
-                }
+                kfree(vptr->td_infos[j]);
+                vptr->td_infos[j] = NULL;
         }
 }
 
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 7ff814fd65d0..e392ee8b37a1 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -400,7 +400,7 @@ static int __init cosa_init(void)
                 goto out_chrdev;
         }
         for (i=0; i<nr_cards; i++) {
-                class_device_create(cosa_class, MKDEV(cosa_major, i),
+                class_device_create(cosa_class, NULL, MKDEV(cosa_major, i),
                                 NULL, "cosa%d", i);
                 err = devfs_mk_cdev(MKDEV(cosa_major, i),
                                 S_IFCHR|S_IRUSR|S_IWUSR,
@@ -1617,8 +1617,7 @@ static int get_wait_data(struct cosa_data *cosa)
                         return r;
                 }
                 /* sleep if not ready to read */
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule_timeout(1);
+                schedule_timeout_interruptible(1);
         }
         printk(KERN_INFO "cosa: timeout in get_wait_data (status 0x%x)\n",
                 cosa_getstatus(cosa));
@@ -1644,8 +1643,7 @@ static int put_wait_data(struct cosa_data *cosa, int data)
                 }
 #if 0
                 /* sleep if not ready to read */
-                current->state = TASK_INTERRUPTIBLE;
-                schedule_timeout(1);
+                schedule_timeout_interruptible(1);
 #endif
         }
         printk(KERN_INFO "cosa%d: timeout in put_wait_data (status 0x%x)\n",
diff --git a/drivers/net/wan/cycx_drv.c b/drivers/net/wan/cycx_drv.c
index 9e56fc346ba4..e6d005726aad 100644
--- a/drivers/net/wan/cycx_drv.c
+++ b/drivers/net/wan/cycx_drv.c
@@ -109,7 +109,7 @@ static long cycx_2x_irq_options[]  = { 7, 3, 5, 9, 10, 11, 12, 15 };
  *              < 0     error.
  * Context:     process */
 
-int __init cycx_drv_init(void)
+static int __init cycx_drv_init(void)
 {
         printk(KERN_INFO "%s v%u.%u %s\n", fullname, MOD_VERSION, MOD_RELEASE,
                          copyright);
@@ -119,7 +119,7 @@ int __init cycx_drv_init(void)
 
 /* Module 'remove' entry point.
  * o release all remaining system resources */
-void cycx_drv_cleanup(void)
+static void cycx_drv_cleanup(void)
 {
 }
 
@@ -184,8 +184,7 @@ int cycx_down(struct cycx_hw *hw)
 }
 
 /* Enable interrupt generation.  */
-EXPORT_SYMBOL(cycx_inten);
-void cycx_inten(struct cycx_hw *hw)
+static void cycx_inten(struct cycx_hw *hw)
 {
         writeb(0, hw->dpmbase);
 }
diff --git a/drivers/net/wan/cycx_main.c b/drivers/net/wan/cycx_main.c
index 7b48064364dc..430b1f630fb4 100644
--- a/drivers/net/wan/cycx_main.c
+++ b/drivers/net/wan/cycx_main.c
@@ -103,7 +103,7 @@ static struct cycx_device *cycx_card_array;	/* adapter data space */
  *              < 0     error.
  * Context:     process
  */
-int __init cycx_init(void)
+static int __init cycx_init(void)
 {
         int cnt, err = -ENOMEM;
 
diff --git a/drivers/net/wan/cycx_x25.c b/drivers/net/wan/cycx_x25.c
index 02d57c0b4243..a631d1c2fa14 100644
--- a/drivers/net/wan/cycx_x25.c
+++ b/drivers/net/wan/cycx_x25.c
@@ -78,6 +78,7 @@
 
 #define CYCLOMX_X25_DEBUG 1
 
+#include <linux/ctype.h>        /* isdigit() */
 #include <linux/errno.h>        /* return codes */
 #include <linux/if_arp.h>       /* ARPHRD_HWX25 */
 #include <linux/kernel.h>       /* printk(), and other useful stuff */
@@ -418,7 +419,7 @@ static int cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
 
                 /* Set channel timeouts (default if not specified) */
                 chan->idle_tmout = conf->idle_timeout ? conf->idle_timeout : 90;
-        } else if (is_digit(conf->addr[0])) {   /* PVC */
+        } else if (isdigit(conf->addr[0])) {    /* PVC */
                 s16 lcn = dec_to_uint(conf->addr, 0);
 
                 if (lcn >= card->u.x.lo_pvc && lcn <= card->u.x.hi_pvc)
@@ -1531,7 +1532,7 @@ static unsigned dec_to_uint(u8 *str, int len)
         if (!len)
                 len = strlen(str);
 
-        for (; len && is_digit(*str); ++str, --len)
+        for (; len && isdigit(*str); ++str, --len)
                 val = (val * 10) + (*str - (unsigned) '0');
 
         return val;
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 520a77a798e2..2f61a47b4716 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -446,8 +446,8 @@ static inline unsigned int dscc4_tx_quiescent(struct dscc4_dev_priv *dpriv,
         return readl(dpriv->base_addr + CH0FTDA + dpriv->dev_id*4) == dpriv->ltda;
 }
 
-int state_check(u32 state, struct dscc4_dev_priv *dpriv, struct net_device *dev,
-                const char *msg)
+static int state_check(u32 state, struct dscc4_dev_priv *dpriv,
+                       struct net_device *dev, const char *msg)
 {
         int ret = 0;
 
@@ -466,8 +466,9 @@ int state_check(u32 state, struct dscc4_dev_priv *dpriv, struct net_device *dev,
         return ret;
 }
 
-void dscc4_tx_print(struct net_device *dev, struct dscc4_dev_priv *dpriv,
-                    char *msg)
+static void dscc4_tx_print(struct net_device *dev,
+                           struct dscc4_dev_priv *dpriv,
+                           char *msg)
 {
         printk(KERN_DEBUG "%s: tx_current=%02d tx_dirty=%02d (%s)\n",
                dev->name, dpriv->tx_current, dpriv->tx_dirty, msg);
@@ -507,7 +508,8 @@ static void dscc4_release_ring(struct dscc4_dev_priv *dpriv)
         }
 }
 
-inline int try_get_rx_skb(struct dscc4_dev_priv *dpriv, struct net_device *dev)
+static inline int try_get_rx_skb(struct dscc4_dev_priv *dpriv,
+                                 struct net_device *dev)
 {
         unsigned int dirty = dpriv->rx_dirty%RX_RING_SIZE;
         struct RxFD *rx_fd = dpriv->rx_fd + dirty;
@@ -542,8 +544,7 @@ static int dscc4_wait_ack_cec(struct dscc4_dev_priv *dpriv,
                                msg, i);
                         goto done;
                 }
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(10);
+                schedule_timeout_uninterruptible(10);
                 rmb();
         } while (++i > 0);
         printk(KERN_ERR "%s: %s timeout\n", dev->name, msg);
@@ -588,8 +589,7 @@ static inline int dscc4_xpr_ack(struct dscc4_dev_priv *dpriv)
                     (dpriv->iqtx[cur] & Xpr))
                         break;
                 smp_rmb();
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(10);
+                schedule_timeout_uninterruptible(10);
         } while (++i > 0);
 
         return (i >= 0 ) ? i : -EAGAIN;
@@ -1035,8 +1035,7 @@ static void dscc4_pci_reset(struct pci_dev *pdev, void __iomem *ioaddr)
         /* Flush posted writes */
         readl(ioaddr + GSTAR);
 
-        set_current_state(TASK_UNINTERRUPTIBLE);
-        schedule_timeout(10);
+        schedule_timeout_uninterruptible(10);
 
         for (i = 0; i < 16; i++)
                 pci_write_config_dword(pdev, i << 2, dscc4_pci_config_store[i]);
@@ -1894,7 +1893,7 @@ try:
  * It failed and locked solid. Thus the introduction of a dummy skb.
  * Problem is acknowledged in errata sheet DS5. Joy :o/
  */
-struct sk_buff *dscc4_init_dummy_skb(struct dscc4_dev_priv *dpriv)
+static struct sk_buff *dscc4_init_dummy_skb(struct dscc4_dev_priv *dpriv)
 {
         struct sk_buff *skb;
 
diff --git a/drivers/net/wan/farsync.c b/drivers/net/wan/farsync.c
index 2c83cca34b86..7981a2c7906e 100644
--- a/drivers/net/wan/farsync.c
+++ b/drivers/net/wan/farsync.c
@@ -74,11 +74,11 @@ MODULE_LICENSE("GPL");
 /*
  * Modules parameters and associated varaibles
  */
-int fst_txq_low = FST_LOW_WATER_MARK;
-int fst_txq_high = FST_HIGH_WATER_MARK;
-int fst_max_reads = 7;
-int fst_excluded_cards = 0;
-int fst_excluded_list[FST_MAX_CARDS];
+static int fst_txq_low = FST_LOW_WATER_MARK;
+static int fst_txq_high = FST_HIGH_WATER_MARK;
+static int fst_max_reads = 7;
+static int fst_excluded_cards = 0;
+static int fst_excluded_list[FST_MAX_CARDS];
 
 module_param(fst_txq_low, int, 0);
 module_param(fst_txq_high, int, 0);
@@ -572,13 +572,13 @@ static void do_bottom_half_rx(struct fst_card_info *card);
 static void fst_process_tx_work_q(unsigned long work_q);
 static void fst_process_int_work_q(unsigned long work_q);
 
-DECLARE_TASKLET(fst_tx_task, fst_process_tx_work_q, 0);
-DECLARE_TASKLET(fst_int_task, fst_process_int_work_q, 0);
+static DECLARE_TASKLET(fst_tx_task, fst_process_tx_work_q, 0);
+static DECLARE_TASKLET(fst_int_task, fst_process_int_work_q, 0);
 
-struct fst_card_info *fst_card_array[FST_MAX_CARDS];
-spinlock_t fst_work_q_lock;
-u64 fst_work_txq;
-u64 fst_work_intq;
+static struct fst_card_info *fst_card_array[FST_MAX_CARDS];
+static spinlock_t fst_work_q_lock;
+static u64 fst_work_txq;
+static u64 fst_work_intq;
 
 static void
 fst_q_work_item(u64 * queue, int card_index)
@@ -980,8 +980,7 @@ fst_issue_cmd(struct fst_port_info *port, unsigned short cmd)
         /* Wait for any previous command to complete */
         while (mbval > NAK) {
                 spin_unlock_irqrestore(&card->card_lock, flags);
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
+                schedule_timeout_uninterruptible(1);
                 spin_lock_irqsave(&card->card_lock, flags);
 
                 if (++safety > 2000) {
@@ -1498,7 +1497,7 @@ do_bottom_half_rx(struct fst_card_info *card)
  *      The interrupt service routine
  *      Dev_id is our fst_card_info pointer
  */
-irqreturn_t
+static irqreturn_t
 fst_intr(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct fst_card_info *card;
diff --git a/drivers/net/wan/hdlc_fr.c b/drivers/net/wan/hdlc_fr.c
index a5d6891c9d4c..e1601d35dced 100644
--- a/drivers/net/wan/hdlc_fr.c
+++ b/drivers/net/wan/hdlc_fr.c
@@ -330,7 +330,7 @@ static int pvc_close(struct net_device *dev)
 
 
 
-int pvc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+static int pvc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
         pvc_device *pvc = dev_to_pvc(dev);
         fr_proto_pvc_info info;
diff --git a/drivers/net/wan/lmc/lmc_debug.c b/drivers/net/wan/lmc/lmc_debug.c
index 9dccd9546a17..3b94352b0d03 100644
--- a/drivers/net/wan/lmc/lmc_debug.c
+++ b/drivers/net/wan/lmc/lmc_debug.c
@@ -8,10 +8,10 @@
 /*
  * Prints out len, max to 80 octets using printk, 20 per line
  */
-void lmcConsoleLog(char *type, unsigned char *ucData, int iLen)
-{
 #ifdef DEBUG
 #ifdef LMC_PACKET_LOG
+void lmcConsoleLog(char *type, unsigned char *ucData, int iLen)
+{
   int iNewLine = 1;
   char str[80], *pstr;
   
@@ -43,26 +43,24 @@ void lmcConsoleLog(char *type, unsigned char *ucData, int iLen)
     }
   sprintf(pstr, "\n");
   printk(str);
+}
 #endif
 #endif
-}
 
 #ifdef DEBUG
 u_int32_t lmcEventLogIndex = 0;
 u_int32_t lmcEventLogBuf[LMC_EVENTLOGSIZE * LMC_EVENTLOGARGS];
-#endif
 
 void lmcEventLog (u_int32_t EventNum, u_int32_t arg2, u_int32_t arg3)
 {
-#ifdef DEBUG
   lmcEventLogBuf[lmcEventLogIndex++] = EventNum;
   lmcEventLogBuf[lmcEventLogIndex++] = arg2;
   lmcEventLogBuf[lmcEventLogIndex++] = arg3;
   lmcEventLogBuf[lmcEventLogIndex++] = jiffies;
 
   lmcEventLogIndex &= (LMC_EVENTLOGSIZE * LMC_EVENTLOGARGS) - 1;
-#endif
 }
+#endif  /*  DEBUG  */
 
 void lmc_trace(struct net_device *dev, char *msg){
 #ifdef LMC_TRACE
diff --git a/drivers/net/wan/lmc/lmc_media.c b/drivers/net/wan/lmc/lmc_media.c
index f55ce76b00ed..af8b55fdd9d9 100644
--- a/drivers/net/wan/lmc/lmc_media.c
+++ b/drivers/net/wan/lmc/lmc_media.c
@@ -48,14 +48,6 @@
   */
 
 /*
- * For lack of a better place, put the SSI cable stuff here.
- */
-char *lmc_t1_cables[] = {
-  "V.10/RS423", "EIA530A", "reserved", "X.21", "V.35",
-  "EIA449/EIA530/V.36", "V.28/EIA232", "none", NULL
-};
-
-/*
  * protocol independent method.
  */
 static void lmc_set_protocol (lmc_softc_t * const, lmc_ctl_t *);
diff --git a/drivers/net/wan/pc300.h b/drivers/net/wan/pc300.h
index 73401b0f0151..2024b26b99e6 100644
--- a/drivers/net/wan/pc300.h
+++ b/drivers/net/wan/pc300.h
@@ -472,24 +472,8 @@ enum pc300_loopback_cmds {
 
 #ifdef __KERNEL__
 /* Function Prototypes */
-int dma_buf_write(pc300_t *, int, ucchar *, int);
-int dma_buf_read(pc300_t *, int, struct sk_buff *);
 void tx_dma_start(pc300_t *, int);
-void rx_dma_start(pc300_t *, int);
-void tx_dma_stop(pc300_t *, int);
-void rx_dma_stop(pc300_t *, int);
-int cpc_queue_xmit(struct sk_buff *, struct net_device *);
-void cpc_net_rx(struct net_device *);
-void cpc_sca_status(pc300_t *, int);
-int cpc_change_mtu(struct net_device *, int);
-int cpc_ioctl(struct net_device *, struct ifreq *, int);
-int ch_config(pc300dev_t *);
-int rx_config(pc300dev_t *);
-int tx_config(pc300dev_t *);
-void cpc_opench(pc300dev_t *);
-void cpc_closech(pc300dev_t *);
 int cpc_open(struct net_device *dev);
-int cpc_close(struct net_device *dev);
 int cpc_set_media(hdlc_device *, int);
 #endif /* __KERNEL__ */
 
diff --git a/drivers/net/wan/pc300_drv.c b/drivers/net/wan/pc300_drv.c
index 3e7753b10717..a3e65d1bc19b 100644
--- a/drivers/net/wan/pc300_drv.c
+++ b/drivers/net/wan/pc300_drv.c
@@ -291,6 +291,7 @@ static uclong detect_ram(pc300_t *);
 static void plx_init(pc300_t *);
 static void cpc_trace(struct net_device *, struct sk_buff *, char);
 static int cpc_attach(struct net_device *, unsigned short, unsigned short);
+static int cpc_close(struct net_device *dev);
 
 #ifdef CONFIG_PC300_MLPPP
 void cpc_tty_init(pc300dev_t * dev);
@@ -437,7 +438,7 @@ static void rx_dma_buf_check(pc300_t * card, int ch)
         printk("\n");
 }
 
-int dma_get_rx_frame_size(pc300_t * card, int ch)
+static int dma_get_rx_frame_size(pc300_t * card, int ch)
 {
         volatile pcsca_bd_t __iomem *ptdescr;
         ucshort first_bd = card->chan[ch].rx_first_bd;
@@ -462,7 +463,7 @@ int dma_get_rx_frame_size(pc300_t * card, int ch)
  * dma_buf_write: writes a frame to the Tx DMA buffers
  * NOTE: this function writes one frame at a time.
  */
-int dma_buf_write(pc300_t * card, int ch, ucchar * ptdata, int len)
+static int dma_buf_write(pc300_t * card, int ch, ucchar * ptdata, int len)
 {
         int i, nchar;
         volatile pcsca_bd_t __iomem *ptdescr;
@@ -503,7 +504,7 @@ int dma_buf_write(pc300_t * card, int ch, ucchar * ptdata, int len)
  * dma_buf_read: reads a frame from the Rx DMA buffers
  * NOTE: this function reads one frame at a time.
  */
-int dma_buf_read(pc300_t * card, int ch, struct sk_buff *skb)
+static int dma_buf_read(pc300_t * card, int ch, struct sk_buff *skb)
 {
         int nchar;
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
@@ -560,7 +561,7 @@ int dma_buf_read(pc300_t * card, int ch, struct sk_buff *skb)
         return (rcvd);
 }
 
-void tx_dma_stop(pc300_t * card, int ch)
+static void tx_dma_stop(pc300_t * card, int ch)
 {
         void __iomem *scabase = card->hw.scabase;
         ucchar drr_ena_bit = 1 << (5 + 2 * ch);
@@ -571,7 +572,7 @@ void tx_dma_stop(pc300_t * card, int ch)
         cpc_writeb(scabase + DRR, drr_rst_bit & ~drr_ena_bit);
 }
 
-void rx_dma_stop(pc300_t * card, int ch)
+static void rx_dma_stop(pc300_t * card, int ch)
 {
         void __iomem *scabase = card->hw.scabase;
         ucchar drr_ena_bit = 1 << (4 + 2 * ch);
@@ -582,7 +583,7 @@ void rx_dma_stop(pc300_t * card, int ch)
         cpc_writeb(scabase + DRR, drr_rst_bit & ~drr_ena_bit);
 }
 
-void rx_dma_start(pc300_t * card, int ch)
+static void rx_dma_start(pc300_t * card, int ch)
 {
         void __iomem *scabase = card->hw.scabase;
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
@@ -607,7 +608,7 @@ void rx_dma_start(pc300_t * card, int ch)
 /*************************/
 /***   FALC Routines   ***/
 /*************************/
-void falc_issue_cmd(pc300_t * card, int ch, ucchar cmd)
+static void falc_issue_cmd(pc300_t * card, int ch, ucchar cmd)
 {
         void __iomem *falcbase = card->hw.falcbase;
         unsigned long i = 0;
@@ -622,7 +623,7 @@ void falc_issue_cmd(pc300_t * card, int ch, ucchar cmd)
         cpc_writeb(falcbase + F_REG(CMDR, ch), cmd);
 }
 
-void falc_intr_enable(pc300_t * card, int ch)
+static void falc_intr_enable(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -672,7 +673,7 @@ void falc_intr_enable(pc300_t * card, int ch)
         }
 }
 
-void falc_open_timeslot(pc300_t * card, int ch, int timeslot)
+static void falc_open_timeslot(pc300_t * card, int ch, int timeslot)
 {
         void __iomem *falcbase = card->hw.falcbase;
         ucchar tshf = card->chan[ch].falc.offset;
@@ -688,7 +689,7 @@ void falc_open_timeslot(pc300_t * card, int ch, int timeslot)
                         (0x80 >> (timeslot & 0x07)));
 }
 
-void falc_close_timeslot(pc300_t * card, int ch, int timeslot)
+static void falc_close_timeslot(pc300_t * card, int ch, int timeslot)
 {
         void __iomem *falcbase = card->hw.falcbase;
         ucchar tshf = card->chan[ch].falc.offset;
@@ -704,7 +705,7 @@ void falc_close_timeslot(pc300_t * card, int ch, int timeslot)
                    ~(0x80 >> (timeslot & 0x07)));
 }
 
-void falc_close_all_timeslots(pc300_t * card, int ch)
+static void falc_close_all_timeslots(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -726,7 +727,7 @@ void falc_close_all_timeslots(pc300_t * card, int ch)
         }
 }
 
-void falc_open_all_timeslots(pc300_t * card, int ch)
+static void falc_open_all_timeslots(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -758,7 +759,7 @@ void falc_open_all_timeslots(pc300_t * card, int ch)
         }
 }
 
-void falc_init_timeslot(pc300_t * card, int ch)
+static void falc_init_timeslot(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -776,7 +777,7 @@ void falc_init_timeslot(pc300_t * card, int ch)
         }
 }
 
-void falc_enable_comm(pc300_t * card, int ch)
+static void falc_enable_comm(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         falc_t *pfalc = (falc_t *) & chan->falc;
@@ -792,7 +793,7 @@ void falc_enable_comm(pc300_t * card, int ch)
                    ~((CPLD_REG1_FALC_DCD | CPLD_REG1_FALC_CTS) << (2 * ch)));
 }
 
-void falc_disable_comm(pc300_t * card, int ch)
+static void falc_disable_comm(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         falc_t *pfalc = (falc_t *) & chan->falc;
@@ -806,7 +807,7 @@ void falc_disable_comm(pc300_t * card, int ch)
                    ((CPLD_REG1_FALC_DCD | CPLD_REG1_FALC_CTS) << (2 * ch)));
 }
 
-void falc_init_t1(pc300_t * card, int ch)
+static void falc_init_t1(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -975,7 +976,7 @@ void falc_init_t1(pc300_t * card, int ch)
         falc_close_all_timeslots(card, ch);
 }
 
-void falc_init_e1(pc300_t * card, int ch)
+static void falc_init_e1(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1155,7 +1156,7 @@ void falc_init_e1(pc300_t * card, int ch)
         falc_close_all_timeslots(card, ch);
 }
 
-void falc_init_hdlc(pc300_t * card, int ch)
+static void falc_init_hdlc(pc300_t * card, int ch)
 {
         void __iomem *falcbase = card->hw.falcbase;
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
@@ -1181,7 +1182,7 @@ void falc_init_hdlc(pc300_t * card, int ch)
         falc_intr_enable(card, ch);
 }
 
-void te_config(pc300_t * card, int ch)
+static void te_config(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1241,7 +1242,7 @@ void te_config(pc300_t * card, int ch)
         CPC_UNLOCK(card, flags);
 }
 
-void falc_check_status(pc300_t * card, int ch, unsigned char frs0)
+static void falc_check_status(pc300_t * card, int ch, unsigned char frs0)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1397,7 +1398,7 @@ void falc_check_status(pc300_t * card, int ch, unsigned char frs0)
         }
 }
 
-void falc_update_stats(pc300_t * card, int ch)
+static void falc_update_stats(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1450,7 +1451,7 @@ void falc_update_stats(pc300_t * card, int ch)
  *              the synchronizer and then sent to the system interface.
  *----------------------------------------------------------------------------
  */
-void falc_remote_loop(pc300_t * card, int ch, int loop_on)
+static void falc_remote_loop(pc300_t * card, int ch, int loop_on)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1495,7 +1496,7 @@ void falc_remote_loop(pc300_t * card, int ch, int loop_on)
  *              coding must be identical.
  *----------------------------------------------------------------------------
  */
-void falc_local_loop(pc300_t * card, int ch, int loop_on)
+static void falc_local_loop(pc300_t * card, int ch, int loop_on)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         falc_t *pfalc = (falc_t *) & chan->falc;
@@ -1522,7 +1523,7 @@ void falc_local_loop(pc300_t * card, int ch, int loop_on)
  *              looped. They are originated by the FALC-LH transmitter.
  *----------------------------------------------------------------------------
  */
-void falc_payload_loop(pc300_t * card, int ch, int loop_on)
+static void falc_payload_loop(pc300_t * card, int ch, int loop_on)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1576,7 +1577,7 @@ void falc_payload_loop(pc300_t * card, int ch, int loop_on)
  * Description: Turns XLU bit off in the proper register
  *----------------------------------------------------------------------------
  */
-void turn_off_xlu(pc300_t * card, int ch)
+static void turn_off_xlu(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1597,7 +1598,7 @@ void turn_off_xlu(pc300_t * card, int ch)
  * Description: Turns XLD bit off in the proper register
  *----------------------------------------------------------------------------
  */
-void turn_off_xld(pc300_t * card, int ch)
+static void turn_off_xld(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1619,7 +1620,7 @@ void turn_off_xld(pc300_t * card, int ch)
  *              to generate a LOOP activation code over a T1/E1 line.
  *----------------------------------------------------------------------------
  */
-void falc_generate_loop_up_code(pc300_t * card, int ch)
+static void falc_generate_loop_up_code(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1652,7 +1653,7 @@ void falc_generate_loop_up_code(pc300_t * card, int ch)
  *              to generate a LOOP deactivation code over a T1/E1 line.
  *----------------------------------------------------------------------------
  */
-void falc_generate_loop_down_code(pc300_t * card, int ch)
+static void falc_generate_loop_down_code(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1682,7 +1683,7 @@ void falc_generate_loop_down_code(pc300_t * card, int ch)
  *              it on the reception side.
  *----------------------------------------------------------------------------
  */
-void falc_pattern_test(pc300_t * card, int ch, unsigned int activate)
+static void falc_pattern_test(pc300_t * card, int ch, unsigned int activate)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -1729,7 +1730,7 @@ void falc_pattern_test(pc300_t * card, int ch, unsigned int activate)
  * Description: This routine returns the bit error counter value
  *----------------------------------------------------------------------------
  */
-ucshort falc_pattern_test_error(pc300_t * card, int ch)
+static ucshort falc_pattern_test_error(pc300_t * card, int ch)
 {
         pc300ch_t *chan = (pc300ch_t *) & card->chan[ch];
         falc_t *pfalc = (falc_t *) & chan->falc;
@@ -1769,7 +1770,7 @@ cpc_trace(struct net_device *dev, struct sk_buff *skb_main, char rx_tx)
         netif_rx(skb);
 }
 
-void cpc_tx_timeout(struct net_device *dev)
+static void cpc_tx_timeout(struct net_device *dev)
 {
         pc300dev_t *d = (pc300dev_t *) dev->priv;
         pc300ch_t *chan = (pc300ch_t *) d->chan;
@@ -1797,7 +1798,7 @@ void cpc_tx_timeout(struct net_device *dev)
         netif_wake_queue(dev);
 }
 
-int cpc_queue_xmit(struct sk_buff *skb, struct net_device *dev)
+static int cpc_queue_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         pc300dev_t *d = (pc300dev_t *) dev->priv;
         pc300ch_t *chan = (pc300ch_t *) d->chan;
@@ -1880,7 +1881,7 @@ int cpc_queue_xmit(struct sk_buff *skb, struct net_device *dev)
         return 0;
 }
 
-void cpc_net_rx(struct net_device *dev)
+static void cpc_net_rx(struct net_device *dev)
 {
         pc300dev_t *d = (pc300dev_t *) dev->priv;
         pc300ch_t *chan = (pc300ch_t *) d->chan;
@@ -2403,7 +2404,7 @@ static irqreturn_t cpc_intr(int irq, void *dev_id, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
-void cpc_sca_status(pc300_t * card, int ch)
+static void cpc_sca_status(pc300_t * card, int ch)
 {
         ucchar ilar;
         void __iomem *scabase = card->hw.scabase;
@@ -2495,7 +2496,7 @@ void cpc_sca_status(pc300_t * card, int ch)
         }
 }
 
-void cpc_falc_status(pc300_t * card, int ch)
+static void cpc_falc_status(pc300_t * card, int ch)
 {
         pc300ch_t *chan = &card->chan[ch];
         falc_t *pfalc = (falc_t *) & chan->falc;
@@ -2523,7 +2524,7 @@ void cpc_falc_status(pc300_t * card, int ch)
         CPC_UNLOCK(card, flags);
 }
 
-int cpc_change_mtu(struct net_device *dev, int new_mtu)
+static int cpc_change_mtu(struct net_device *dev, int new_mtu)
 {
         if ((new_mtu < 128) || (new_mtu > PC300_DEF_MTU))
                 return -EINVAL;
@@ -2531,7 +2532,7 @@ int cpc_change_mtu(struct net_device *dev, int new_mtu)
         return 0;
 }
 
-int cpc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+static int cpc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
         hdlc_device *hdlc = dev_to_hdlc(dev);
         pc300dev_t *d = (pc300dev_t *) dev->priv;
@@ -2856,7 +2857,7 @@ static int clock_rate_calc(uclong rate, uclong clock, int *br_io)
         }
 }
 
-int ch_config(pc300dev_t * d)
+static int ch_config(pc300dev_t * d)
 {
         pc300ch_t *chan = (pc300ch_t *) d->chan;
         pc300chconf_t *conf = (pc300chconf_t *) & chan->conf;
@@ -3004,7 +3005,7 @@ int ch_config(pc300dev_t * d)
         return 0;
 }
 
-int rx_config(pc300dev_t * d)
+static int rx_config(pc300dev_t * d)
 {
         pc300ch_t *chan = (pc300ch_t *) d->chan;
         pc300_t *card = (pc300_t *) chan->card;
@@ -3035,7 +3036,7 @@ int rx_config(pc300dev_t * d)
         return 0;
 }
 
-int tx_config(pc300dev_t * d)
+static int tx_config(pc300dev_t * d)
 {
         pc300ch_t *chan = (pc300ch_t *) d->chan;
         pc300_t *card = (pc300_t *) chan->card;
@@ -3098,7 +3099,7 @@ static int cpc_attach(struct net_device *dev, unsigned short encoding,
         return 0;
 }
 
-void cpc_opench(pc300dev_t * d)
+static void cpc_opench(pc300dev_t * d)
 {
         pc300ch_t *chan = (pc300ch_t *) d->chan;
         pc300_t *card = (pc300_t *) chan->card;
@@ -3116,7 +3117,7 @@ void cpc_opench(pc300dev_t * d)
                    cpc_readb(scabase + M_REG(CTL, ch)) & ~(CTL_RTS | CTL_DTR));
 }
 
-void cpc_closech(pc300dev_t * d)
+static void cpc_closech(pc300dev_t * d)
 {
         pc300ch_t *chan = (pc300ch_t *) d->chan;
         pc300_t *card = (pc300_t *) chan->card;
@@ -3173,7 +3174,7 @@ int cpc_open(struct net_device *dev)
         return 0;
 }
 
-int cpc_close(struct net_device *dev)
+static int cpc_close(struct net_device *dev)
 {
         hdlc_device *hdlc = dev_to_hdlc(dev);
         pc300dev_t *d = (pc300dev_t *) dev->priv;
diff --git a/drivers/net/wan/pc300_tty.c b/drivers/net/wan/pc300_tty.c
index 8454bf6caaa7..52f26b9c69d2 100644
--- a/drivers/net/wan/pc300_tty.c
+++ b/drivers/net/wan/pc300_tty.c
@@ -112,10 +112,10 @@ typedef	struct _st_cpc_tty_area {
 static struct tty_driver serial_drv;
 
 /* local variables */
-st_cpc_tty_area cpc_tty_area[CPC_TTY_NPORTS];
+static st_cpc_tty_area  cpc_tty_area[CPC_TTY_NPORTS];
 
-int cpc_tty_cnt=0;      /* number of intrfaces configured with MLPPP */
-int cpc_tty_unreg_flag = 0;
+static int cpc_tty_cnt = 0;     /* number of intrfaces configured with MLPPP */
+static int cpc_tty_unreg_flag = 0;
 
 /* TTY functions prototype */
 static int cpc_tty_open(struct tty_struct *tty, struct file *flip);
@@ -132,9 +132,9 @@ static void cpc_tty_trace(pc300dev_t *dev, char* buf, int len, char rxtx);
 static void cpc_tty_signal_off(pc300dev_t *pc300dev, unsigned char);
 static void cpc_tty_signal_on(pc300dev_t *pc300dev, unsigned char);
 
-int pc300_tiocmset(struct tty_struct *, struct file *,
-                        unsigned int, unsigned int);
-int pc300_tiocmget(struct tty_struct *, struct file *);
+static int pc300_tiocmset(struct tty_struct *, struct file *,
+                          unsigned int, unsigned int);
+static int pc300_tiocmget(struct tty_struct *, struct file *);
 
 /* functions called by PC300 driver */
 void cpc_tty_init(pc300dev_t *dev);
@@ -538,8 +538,8 @@ static int cpc_tty_chars_in_buffer(struct tty_struct *tty)
         return(0); 
 } 
 
-int pc300_tiocmset(struct tty_struct *tty, struct file *file,
-                        unsigned int set, unsigned int clear)
+static int pc300_tiocmset(struct tty_struct *tty, struct file *file,
+                          unsigned int set, unsigned int clear)
 {
         st_cpc_tty_area    *cpc_tty; 
 
@@ -565,7 +565,7 @@ int pc300_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
-int pc300_tiocmget(struct tty_struct *tty, struct file *file)
+static int pc300_tiocmget(struct tty_struct *tty, struct file *file)
 {
         unsigned int result;
         unsigned char status;
diff --git a/drivers/net/wan/sdla.c b/drivers/net/wan/sdla.c
index 3ac9a45b20fa..036adc4f8ba7 100644
--- a/drivers/net/wan/sdla.c
+++ b/drivers/net/wan/sdla.c
@@ -182,7 +182,7 @@ static char sdla_byte(struct net_device *dev, int addr)
         return(byte);
 }
 
-void sdla_stop(struct net_device *dev)
+static void sdla_stop(struct net_device *dev)
 {
         struct frad_local *flp;
 
@@ -209,7 +209,7 @@ void sdla_stop(struct net_device *dev)
         }
 }
 
-void sdla_start(struct net_device *dev)
+static void sdla_start(struct net_device *dev)
 {
         struct frad_local *flp;
 
@@ -247,7 +247,7 @@ void sdla_start(struct net_device *dev)
  *
  ***************************************************/
 
-int sdla_z80_poll(struct net_device *dev, int z80_addr, int jiffs, char resp1, char resp2)
+static int sdla_z80_poll(struct net_device *dev, int z80_addr, int jiffs, char resp1, char resp2)
 {
         unsigned long start, done, now;
         char          resp, *temp;
@@ -505,7 +505,7 @@ static int sdla_cmd(struct net_device *dev, int cmd, short dlci, short flags,
 
 static int sdla_reconfig(struct net_device *dev);
 
-int sdla_activate(struct net_device *slave, struct net_device *master)
+static int sdla_activate(struct net_device *slave, struct net_device *master)
 {
         struct frad_local *flp;
         int i;
@@ -527,7 +527,7 @@ int sdla_activate(struct net_device *slave, struct net_device *master)
         return(0);
 }
 
-int sdla_deactivate(struct net_device *slave, struct net_device *master)
+static int sdla_deactivate(struct net_device *slave, struct net_device *master)
 {
         struct frad_local *flp;
         int               i;
@@ -549,7 +549,7 @@ int sdla_deactivate(struct net_device *slave, struct net_device *master)
         return(0);
 }
 
-int sdla_assoc(struct net_device *slave, struct net_device *master)
+static int sdla_assoc(struct net_device *slave, struct net_device *master)
 {
         struct frad_local *flp;
         int               i;
@@ -585,7 +585,7 @@ int sdla_assoc(struct net_device *slave, struct net_device *master)
         return(0);
 }
 
-int sdla_deassoc(struct net_device *slave, struct net_device *master)
+static int sdla_deassoc(struct net_device *slave, struct net_device *master)
 {
         struct frad_local *flp;
         int               i;
@@ -613,7 +613,7 @@ int sdla_deassoc(struct net_device *slave, struct net_device *master)
         return(0);
 }
 
-int sdla_dlci_conf(struct net_device *slave, struct net_device *master, int get)
+static int sdla_dlci_conf(struct net_device *slave, struct net_device *master, int get)
 {
         struct frad_local *flp;
         struct dlci_local *dlp;
@@ -1324,7 +1324,7 @@ NOTE:  This is rather a useless action right now, as the
         return(0);
 }
 
-int sdla_change_mtu(struct net_device *dev, int new_mtu)
+static int sdla_change_mtu(struct net_device *dev, int new_mtu)
 {
         struct frad_local *flp;
 
@@ -1337,7 +1337,7 @@ int sdla_change_mtu(struct net_device *dev, int new_mtu)
         return(-EOPNOTSUPP);
 }
 
-int sdla_set_config(struct net_device *dev, struct ifmap *map)
+static int sdla_set_config(struct net_device *dev, struct ifmap *map)
 {
         struct frad_local *flp;
         int               i;
diff --git a/drivers/net/wan/sdla_fr.c b/drivers/net/wan/sdla_fr.c
index 0497dbdb8631..7f1ce9d4333e 100644
--- a/drivers/net/wan/sdla_fr.c
+++ b/drivers/net/wan/sdla_fr.c
@@ -822,7 +822,7 @@ static int new_if(struct wan_device* wandev, struct net_device* dev,
         chan->card = card;
 
         /* verify media address */
-        if (is_digit(conf->addr[0])) {
+        if (isdigit(conf->addr[0])) {
 
                 dlci = dec_to_uint(conf->addr, 0);
 
@@ -3456,7 +3456,7 @@ static unsigned int dec_to_uint (unsigned char* str, int len)
         if (!len) 
                 len = strlen(str);
 
-        for (val = 0; len && is_digit(*str); ++str, --len)
+        for (val = 0; len && isdigit(*str); ++str, --len)
                 val = (val * 10) + (*str - (unsigned)'0');
 
         return val;
diff --git a/drivers/net/wan/sdla_x25.c b/drivers/net/wan/sdla_x25.c
index 8a95d61a2f8f..63f846d6f3a6 100644
--- a/drivers/net/wan/sdla_x25.c
+++ b/drivers/net/wan/sdla_x25.c
@@ -957,7 +957,7 @@ static int new_if(struct wan_device* wandev, struct net_device* dev,
                 chan->hold_timeout = (conf->hold_timeout) ? 
                                         conf->hold_timeout : 10;
 
-        }else if (is_digit(conf->addr[0])){     /* PVC */
+        }else if (isdigit(conf->addr[0])){      /* PVC */
                 int lcn = dec_to_uint(conf->addr, 0);
 
                 if ((lcn >= card->u.x.lo_pvc) && (lcn <= card->u.x.hi_pvc)){
@@ -3875,7 +3875,7 @@ static unsigned int dec_to_uint (unsigned char* str, int len)
         if (!len) 
                 len = strlen(str);
 
-        for (val = 0; len && is_digit(*str); ++str, --len)
+        for (val = 0; len && isdigit(*str); ++str, --len)
                 val = (val * 10) + (*str - (unsigned)'0');
         
         return val;
@@ -3896,9 +3896,9 @@ static unsigned int hex_to_uint (unsigned char* str, int len)
         for (val = 0; len; ++str, --len)
         {
                 ch = *str;
-                if (is_digit(ch))
+                if (isdigit(ch))
                         val = (val << 4) + (ch - (unsigned)'0');
-                else if (is_hex_digit(ch))
+                else if (isxdigit(ch))
                         val = (val << 4) + ((ch & 0xDF) - (unsigned)'A' + 10);
                 else break;
         }
diff --git a/drivers/net/wan/sdladrv.c b/drivers/net/wan/sdladrv.c
index c8bc6da57a41..7c2cf2e76300 100644
--- a/drivers/net/wan/sdladrv.c
+++ b/drivers/net/wan/sdladrv.c
@@ -642,9 +642,7 @@ int sdla_mapmem (sdlahw_t* hw, unsigned long addr)
  * Enable interrupt generation.
  */
 
-EXPORT_SYMBOL(sdla_inten);
-
-int sdla_inten (sdlahw_t* hw)
+static int sdla_inten (sdlahw_t* hw)
 {
         unsigned port = hw->port;
         int tmp, i;
@@ -698,8 +696,7 @@ int sdla_inten (sdlahw_t* hw)
  * Disable interrupt generation.
  */
 
-EXPORT_SYMBOL(sdla_intde);
-
+#if 0
 int sdla_intde (sdlahw_t* hw)
 {
         unsigned port = hw->port;
@@ -748,14 +745,13 @@ int sdla_intde (sdlahw_t* hw)
         }
         return 0;
 }
+#endif  /*  0  */
 
 /*============================================================================
  * Acknowledge SDLA hardware interrupt.
  */
 
-EXPORT_SYMBOL(sdla_intack);
-
-int sdla_intack (sdlahw_t* hw)
+static int sdla_intack (sdlahw_t* hw)
 {
         unsigned port = hw->port;
         int tmp;
@@ -827,8 +823,7 @@ void read_S514_int_stat (sdlahw_t* hw, u32* int_status)
  * Generate an interrupt to adapter's CPU.
  */
 
-EXPORT_SYMBOL(sdla_intr);
-
+#if 0
 int sdla_intr (sdlahw_t* hw)
 {
         unsigned port = hw->port;
@@ -863,6 +858,7 @@ int sdla_intr (sdlahw_t* hw)
         }
         return 0;
 }
+#endif  /*  0  */
 
 /*============================================================================
  * Execute Adapter Command.
diff --git a/drivers/net/wan/syncppp.c b/drivers/net/wan/syncppp.c
index a6d3b55013a5..2d1bba06a085 100644
--- a/drivers/net/wan/syncppp.c
+++ b/drivers/net/wan/syncppp.c
@@ -221,7 +221,7 @@ static void sppp_clear_timeout(struct sppp *p)
  *      here.
  */
  
-void sppp_input (struct net_device *dev, struct sk_buff *skb)
+static void sppp_input (struct net_device *dev, struct sk_buff *skb)
 {
         struct ppp_header *h;
         struct sppp *sp = (struct sppp *)sppp_of(dev);
@@ -355,8 +355,6 @@ done:
         return;
 }
 
-EXPORT_SYMBOL(sppp_input);
-
 /*
  *      Handle transmit packets.
  */
@@ -990,7 +988,7 @@ EXPORT_SYMBOL(sppp_reopen);
  *      the mtu is out of range.
  */
  
-int sppp_change_mtu(struct net_device *dev, int new_mtu)
+static int sppp_change_mtu(struct net_device *dev, int new_mtu)
 {
         if(new_mtu<128||new_mtu>PPP_MTU||(dev->flags&IFF_UP))
                 return -EINVAL;
@@ -998,8 +996,6 @@ int sppp_change_mtu(struct net_device *dev, int new_mtu)
         return 0;
 }
 
-EXPORT_SYMBOL(sppp_change_mtu);
-
 /**
  *      sppp_do_ioctl - Ioctl handler for ppp/hdlc
  *      @dev: Device subject to ioctl
@@ -1456,7 +1452,7 @@ static int sppp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_t
         return 0;
 }
 
-struct packet_type sppp_packet_type = {
+static struct packet_type sppp_packet_type = {
         .type   = __constant_htons(ETH_P_WAN_PPP),
         .func   = sppp_rcv,
 };
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 06998c2240d9..750c0167539c 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -35,6 +35,7 @@
 #include <linux/interrupt.h>
 #include <linux/in.h>
 #include <linux/bitops.h>
+#include <linux/scatterlist.h>
 #include <asm/io.h>
 #include <asm/system.h>
 
@@ -1046,7 +1047,6 @@ static WifiCtlHdr wifictlhdr8023 = {
         }
 };
 
-#ifdef WIRELESS_EXT
 // Frequency list (map channels to frequencies)
 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
                                 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
@@ -1067,7 +1067,6 @@ typedef struct wep_key_t {
 
 /* List of Wireless Handlers (new API) */
 static const struct iw_handler_def      airo_handler_def;
-#endif /* WIRELESS_EXT */
 
 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
 
@@ -1110,10 +1109,8 @@ static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
 static int airo_thread(void *data);
 static void timer_func( struct net_device *dev );
 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
-#ifdef WIRELESS_EXT
 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
 static void airo_read_wireless_stats (struct airo_info *local);
-#endif /* WIRELESS_EXT */
 #ifdef CISCO_EXT
 static int readrids(struct net_device *dev, aironet_ioctl *comp);
 static int writerids(struct net_device *dev, aironet_ioctl *comp);
@@ -1187,12 +1184,10 @@ struct airo_info {
                 int fid;
         } xmit, xmit11;
         struct net_device *wifidev;
-#ifdef WIRELESS_EXT
         struct iw_statistics    wstats;         // wireless stats
         unsigned long           scan_timestamp; /* Time started to scan */
         struct iw_spy_data      spy_data;
         struct iw_public_data   wireless_data;
-#endif /* WIRELESS_EXT */
 #ifdef MICSUPPORT
         /* MIC stuff */
         struct crypto_tfm       *tfm;
@@ -1596,11 +1591,9 @@ static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct
                 aes_counter[12] = (u8)(counter >> 24);
                 counter++;
                 memcpy (plain, aes_counter, 16);
-                sg[0].page = virt_to_page(plain);
-                sg[0].offset = ((long) plain & ~PAGE_MASK);
-                sg[0].length = 16;
+                sg_set_buf(sg, plain, 16);
                 crypto_cipher_encrypt(tfm, sg, sg, 16);
-                cipher = kmap(sg[0].page) + sg[0].offset;
+                cipher = kmap(sg->page) + sg->offset;
                 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
                         context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
                         j += 4;
@@ -2387,14 +2380,10 @@ void stop_airo_card( struct net_device *dev, int freeres )
                         dev_kfree_skb(skb);
         }
 
-        if (ai->flash)
-                kfree(ai->flash);
-        if (ai->rssi)
-                kfree(ai->rssi);
-        if (ai->APList)
-                kfree(ai->APList);
-        if (ai->SSID)
-                kfree(ai->SSID);
+        kfree(ai->flash);
+        kfree(ai->rssi);
+        kfree(ai->APList);
+        kfree(ai->SSID);
         if (freeres) {
                 /* PCMCIA frees this stuff, so only for PCI and ISA */
                 release_region( dev->base_addr, 64 );
@@ -2527,7 +2516,8 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
         unsigned long mem_start, mem_len, aux_start, aux_len;
         int rc = -1;
         int i;
-        unsigned char *busaddroff,*vpackoff;
+        dma_addr_t busaddroff;
+        unsigned char *vpackoff;
         unsigned char __iomem *pciaddroff;
 
         mem_start = pci_resource_start(pci, 1);
@@ -2570,7 +2560,7 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
         /*
          * Setup descriptor RX, TX, CONFIG
          */
-        busaddroff = (unsigned char *)ai->shared_dma;
+        busaddroff = ai->shared_dma;
         pciaddroff = ai->pciaux + AUX_OFFSET;
         vpackoff   = ai->shared;
 
@@ -2579,7 +2569,7 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
                 ai->rxfids[i].pending = 0;
                 ai->rxfids[i].card_ram_off = pciaddroff;
                 ai->rxfids[i].virtual_host_addr = vpackoff;
-                ai->rxfids[i].rx_desc.host_addr = (dma_addr_t) busaddroff;
+                ai->rxfids[i].rx_desc.host_addr = busaddroff;
                 ai->rxfids[i].rx_desc.valid = 1;
                 ai->rxfids[i].rx_desc.len = PKTSIZE;
                 ai->rxfids[i].rx_desc.rdy = 0;
@@ -2594,7 +2584,7 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
                 ai->txfids[i].card_ram_off = pciaddroff;
                 ai->txfids[i].virtual_host_addr = vpackoff;
                 ai->txfids[i].tx_desc.valid = 1;
-                ai->txfids[i].tx_desc.host_addr = (dma_addr_t) busaddroff;
+                ai->txfids[i].tx_desc.host_addr = busaddroff;
                 memcpy(ai->txfids[i].virtual_host_addr,
                         &wifictlhdr8023, sizeof(wifictlhdr8023));
 
@@ -2607,8 +2597,8 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
         /* Rid descriptor setup */
         ai->config_desc.card_ram_off = pciaddroff;
         ai->config_desc.virtual_host_addr = vpackoff;
-        ai->config_desc.rid_desc.host_addr = (dma_addr_t) busaddroff;
-        ai->ridbus = (dma_addr_t)busaddroff;
+        ai->config_desc.rid_desc.host_addr = busaddroff;
+        ai->ridbus = busaddroff;
         ai->config_desc.rid_desc.rid = 0;
         ai->config_desc.rid_desc.len = RIDSIZE;
         ai->config_desc.rid_desc.valid = 1;
@@ -2647,9 +2637,7 @@ static void wifi_setup(struct net_device *dev)
         dev->get_stats = &airo_get_stats;
         dev->set_mac_address = &airo_set_mac_address;
         dev->do_ioctl = &airo_ioctl;
-#ifdef WIRELESS_EXT
         dev->wireless_handlers = &airo_handler_def;
-#endif /* WIRELESS_EXT */
         dev->change_mtu = &airo_change_mtu;
         dev->open = &airo_open;
         dev->stop = &airo_close;
@@ -2675,9 +2663,7 @@ static struct net_device *init_wifidev(struct airo_info *ai,
         dev->priv = ethdev->priv;
         dev->irq = ethdev->irq;
         dev->base_addr = ethdev->base_addr;
-#ifdef WIRELESS_EXT
         dev->wireless_data = ethdev->wireless_data;
-#endif /* WIRELESS_EXT */
         memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
         err = register_netdev(dev);
         if (err<0) {
@@ -2755,11 +2741,9 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
         dev->set_multicast_list = &airo_set_multicast_list;
         dev->set_mac_address = &airo_set_mac_address;
         dev->do_ioctl = &airo_ioctl;
-#ifdef WIRELESS_EXT
         dev->wireless_handlers = &airo_handler_def;
         ai->wireless_data.spy_data = &ai->spy_data;
         dev->wireless_data = &ai->wireless_data;
-#endif /* WIRELESS_EXT */
         dev->change_mtu = &airo_change_mtu;
         dev->open = &airo_open;
         dev->stop = &airo_close;
@@ -3637,10 +3621,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
         int rc;
 
         memset( &mySsid, 0, sizeof( mySsid ) );
-        if (ai->flash) {
-                kfree (ai->flash);
-                ai->flash = NULL;
-        }
+        kfree (ai->flash);
+        ai->flash = NULL;
 
         /* The NOP is the first step in getting the card going */
         cmd.cmd = NOP;
@@ -3677,14 +3659,10 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                 tdsRssiRid rssi_rid;
                 CapabilityRid cap_rid;
 
-                if (ai->APList) {
-                        kfree(ai->APList);
-                        ai->APList = NULL;
-                }
-                if (ai->SSID) {
-                        kfree(ai->SSID);
-                        ai->SSID = NULL;
-                }
+                kfree(ai->APList);
+                ai->APList = NULL;
+                kfree(ai->SSID);
+                ai->SSID = NULL;
                 // general configuration (read/modify/write)
                 status = readConfigRid(ai, lock);
                 if ( status != SUCCESS ) return ERROR;
@@ -3698,10 +3676,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                                 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
                 }
                 else {
-                        if (ai->rssi) {
-                                kfree(ai->rssi);
-                                ai->rssi = NULL;
-                        }
+                        kfree(ai->rssi);
+                        ai->rssi = NULL;
                         if (cap_rid.softCap & 8)
                                 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
                         else
@@ -5380,11 +5356,13 @@ static int proc_BSSList_open( struct inode *inode, struct file *file ) {
 
 static int proc_close( struct inode *inode, struct file *file )
 {
-        struct proc_data *data = (struct proc_data *)file->private_data;
-        if ( data->on_close != NULL ) data->on_close( inode, file );
-        if ( data->rbuffer ) kfree( data->rbuffer );
-        if ( data->wbuffer ) kfree( data->wbuffer );
-        kfree( data );
+        struct proc_data *data = file->private_data;
+
+        if (data->on_close != NULL)
+                data->on_close(inode, file);
+        kfree(data->rbuffer);
+        kfree(data->wbuffer);
+        kfree(data);
         return 0;
 }
 
@@ -5515,12 +5493,13 @@ static int airo_pci_resume(struct pci_dev *pdev)
         struct net_device *dev = pci_get_drvdata(pdev);
         struct airo_info *ai = dev->priv;
         Resp rsp;
+        pci_power_t prev_state = pdev->current_state;
 
-        pci_set_power_state(pdev, 0);
+        pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
-        pci_enable_wake(pdev, pci_choose_state(pdev, ai->power), 0);
+        pci_enable_wake(pdev, PCI_D0, 0);
 
-        if (ai->power.event > 1) {
+        if (prev_state != PCI_D1) {
                 reset_card(dev, 0);
                 mpi_init_descriptors(ai);
                 setup_card(ai, dev->dev_addr, 0);
@@ -5598,7 +5577,6 @@ static void __exit airo_cleanup_module( void )
         remove_proc_entry("aironet", proc_root_driver);
 }
 
-#ifdef WIRELESS_EXT
 /*
  * Initial Wireless Extension code for Aironet driver by :
  *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
@@ -7107,8 +7085,6 @@ static const struct iw_handler_def	airo_handler_def =
         .get_wireless_stats = airo_get_wireless_stats,
 };
 
-#endif /* WIRELESS_EXT */
-
 /*
  * This defines the configuration part of the Wireless Extensions
  * Note : irq and spinlock protection will occur in the subroutines
@@ -7187,7 +7163,6 @@ static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         return rc;
 }
 
-#ifdef WIRELESS_EXT
 /*
  * Get the Wireless stats out of the driver
  * Note : irq and spinlock protection will occur in the subroutines
@@ -7260,7 +7235,6 @@ static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
 
         return &local->wstats;
 }
-#endif /* WIRELESS_EXT */
 
 #ifdef CISCO_EXT
 /*
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index bf25584d68d3..784de9109113 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -258,9 +258,7 @@ static void airo_detach(dev_link_t *link)
         
         /* Unlink device structure, free pieces */
         *linkp = link->next;
-        if (link->priv) {
-                kfree(link->priv);
-        }
+        kfree(link->priv);
         kfree(link);
         
 } /* airo_detach */
diff --git a/drivers/net/wireless/airport.c b/drivers/net/wireless/airport.c
index 9d496703c465..7b321f7cf358 100644
--- a/drivers/net/wireless/airport.c
+++ b/drivers/net/wireless/airport.c
@@ -15,28 +15,11 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/wireless.h>
-
-#include <asm/io.h>
-#include <asm/system.h>
-#include <asm/current.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
+#include <linux/delay.h>
 #include <asm/pmac_feature.h>
-#include <asm/irq.h>
-#include <asm/uaccess.h>
 
 #include "orinoco.h"
 
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index 587869d86eee..1fbe027d26b6 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -618,12 +618,12 @@ static int atmel_lock_mac(struct atmel_private *priv);
 static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data);
 static void atmel_command_irq(struct atmel_private *priv);
 static int atmel_validate_channel(struct atmel_private *priv, int channel);
-static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr *header, 
+static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 
                                    u16 frame_len, u8 rssi);
 static void atmel_management_timer(u_long a);
 static void atmel_send_command(struct atmel_private *priv, int command, void *cmd, int cmd_size);
 static int atmel_send_command_wait(struct atmel_private *priv, int command, void *cmd, int cmd_size);
-static void atmel_transmit_management_frame(struct atmel_private *priv, struct ieee80211_hdr *header,
+static void atmel_transmit_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header,
                                             u8 *body, int body_len);
 
 static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index);
@@ -827,7 +827,7 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 l
 static int start_tx (struct sk_buff *skb, struct net_device *dev)
 {
         struct atmel_private *priv = netdev_priv(dev);
-        struct ieee80211_hdr header;
+        struct ieee80211_hdr_4addr header;
         unsigned long flags;
         u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
         u8 SNAP_RFC1024[6] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
@@ -902,7 +902,7 @@ static int start_tx (struct sk_buff *skb, struct net_device *dev)
 }
 
 static void atmel_transmit_management_frame(struct atmel_private *priv, 
-                                            struct ieee80211_hdr *header,
+                                            struct ieee80211_hdr_4addr *header,
                                             u8 *body, int body_len)
 {
         u16 buff;
@@ -917,7 +917,7 @@ static void atmel_transmit_management_frame(struct atmel_private *priv,
         tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT);
 }
         
-static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr *header, 
+static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 
                          u16 msdu_size, u16 rx_packet_loc, u32 crc)
 {
         /* fast path: unfragmented packet copy directly into skbuf */
@@ -990,7 +990,7 @@ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
         return (crc ^ 0xffffffff) == netcrc;
 }
 
-static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr *header, 
+static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 
                          u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no, u8 frag_no, int more_frags)
 {
         u8 mac4[6]; 
@@ -1082,7 +1082,7 @@ static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr *heade
 static void rx_done_irq(struct atmel_private *priv)
 {
         int i;
-        struct ieee80211_hdr header;
+        struct ieee80211_hdr_4addr header;
         
         for (i = 0; 
              atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID &&
@@ -1653,8 +1653,7 @@ void stop_atmel_card(struct net_device *dev, int freeres)
         unregister_netdev(dev);
         remove_proc_entry("driver/atmel", NULL);
         free_irq(dev->irq, dev);
-        if (priv->firmware)
-                kfree(priv->firmware);
+        kfree(priv->firmware);
         if (freeres) {
                 /* PCMCIA frees this stuff, so only for PCI */
                 release_region(dev->base_addr, 64);
@@ -2450,8 +2449,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                         break;
                 }
 
-                if (priv->firmware)
-                        kfree(priv->firmware);
+                kfree(priv->firmware);
                 
                 priv->firmware = new_firmware;
                 priv->firmware_length = com.len;
@@ -2650,7 +2648,7 @@ static void handle_beacon_probe(struct atmel_private *priv, u16 capability, u8 c
  
 static void send_authentication_request(struct atmel_private *priv, u8 *challenge, int challenge_len)
 {
-        struct ieee80211_hdr header;
+        struct ieee80211_hdr_4addr header;
         struct auth_body auth;
         
         header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH); 
@@ -2688,7 +2686,7 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
 {
         u8 *ssid_el_p;
         int bodysize;
-        struct ieee80211_hdr header;
+        struct ieee80211_hdr_4addr header;
         struct ass_req_format {
                 u16 capability;
                 u16 listen_interval; 
@@ -2738,7 +2736,7 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
         atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize);
 }
 
-static int is_frame_from_current_bss(struct atmel_private *priv, struct ieee80211_hdr *header)
+static int is_frame_from_current_bss(struct atmel_private *priv, struct ieee80211_hdr_4addr *header)
 {
         if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS)
                 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0;
@@ -2788,7 +2786,7 @@ static int retrieve_bss(struct atmel_private *priv)
 }
 
 
-static void store_bss_info(struct atmel_private *priv, struct ieee80211_hdr *header,
+static void store_bss_info(struct atmel_private *priv, struct ieee80211_hdr_4addr *header,
                            u16 capability, u16 beacon_period, u8 channel, u8 rssi, 
                            u8 ssid_len, u8 *ssid, int is_beacon)
 {
@@ -3072,7 +3070,7 @@ static void atmel_smooth_qual(struct atmel_private *priv)
 }
 
 /* deals with incoming managment frames. */
-static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr *header, 
+static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 
                       u16 frame_len, u8 rssi)
 {
         u16 subtype;
diff --git a/drivers/net/wireless/atmel_cs.c b/drivers/net/wireless/atmel_cs.c
index ff031a3985b3..195cb36619e8 100644
--- a/drivers/net/wireless/atmel_cs.c
+++ b/drivers/net/wireless/atmel_cs.c
@@ -259,8 +259,7 @@ static void atmel_detach(dev_link_t *link)
 
         /* Unlink device structure, free pieces */
         *linkp = link->next;
-        if (link->priv)
-                kfree(link->priv);
+        kfree(link->priv);
         kfree(link);
 }
 
diff --git a/drivers/net/wireless/hermes.c b/drivers/net/wireless/hermes.c
index 21c3d0d227e6..579480dad374 100644
--- a/drivers/net/wireless/hermes.c
+++ b/drivers/net/wireless/hermes.c
@@ -39,17 +39,10 @@
  */
 
 #include <linux/config.h>
-
 #include <linux/module.h>
-#include <linux/types.h>
-#include <linux/threads.h>
-#include <linux/smp.h>
-#include <asm/io.h>
-#include <linux/delay.h>
-#include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/net.h>
-#include <asm/errno.h>
+#include <linux/init.h>
+#include <linux/delay.h>
 
 #include "hermes.h"
 
@@ -451,6 +444,43 @@ int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, unsigned len,
         return err;
 }
 
+/* Write a block of data to the chip's buffer with padding if
+ * neccessary, via the BAP. Synchronization/serialization is the
+ * caller's problem. len must be even.
+ *
+ * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
+ */
+int hermes_bap_pwrite_pad(hermes_t *hw, int bap, const void *buf, unsigned data_len, unsigned len,
+                      u16 id, u16 offset)
+{
+        int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
+        int err = 0;
+
+        if (len < 0 || len % 2 || data_len > len)
+                return -EINVAL;
+
+        err = hermes_bap_seek(hw, bap, id, offset);
+        if (err)
+                goto out;
+
+        /* Transfer all the complete words of data */
+        hermes_write_words(hw, dreg, buf, data_len/2);
+        /* If there is an odd byte left over pad and transfer it */
+        if (data_len & 1) {
+                u8 end[2];
+                end[1] = 0;
+                end[0] = ((unsigned char *)buf)[data_len - 1];
+                hermes_write_words(hw, dreg, end, 1);
+                data_len ++;
+        }
+        /* Now send zeros for the padding */
+        if (data_len < len)
+                hermes_clear_words(hw, dreg, (len - data_len) / 2);
+        /* Complete */
+ out:
+        return err;
+}
+
 /* Read a Length-Type-Value record from the card.
  *
  * If length is NULL, we ignore the length read from the card, and
@@ -538,6 +568,7 @@ EXPORT_SYMBOL(hermes_allocate);
 
 EXPORT_SYMBOL(hermes_bap_pread);
 EXPORT_SYMBOL(hermes_bap_pwrite);
+EXPORT_SYMBOL(hermes_bap_pwrite_pad);
 EXPORT_SYMBOL(hermes_read_ltv);
 EXPORT_SYMBOL(hermes_write_ltv);
 
diff --git a/drivers/net/wireless/hermes.h b/drivers/net/wireless/hermes.h
index 8c9e874c9118..a6bd472d75d4 100644
--- a/drivers/net/wireless/hermes.h
+++ b/drivers/net/wireless/hermes.h
@@ -30,9 +30,8 @@
  * access to the hermes_t structure, and to the hardware
 */
 
-#include <linux/delay.h>
 #include <linux/if_ether.h>
-#include <asm/byteorder.h>
+#include <asm/io.h>
 
 /*
  * Limits and constants
@@ -192,13 +191,13 @@
 #define HERMES_RXSTAT_WMP               (0x6000)        /* Wavelan-II Management Protocol frame */
 
 struct hermes_tx_descriptor {
-        u16 status;
-        u16 reserved1;
-        u16 reserved2;
-        u32 sw_support;
+        __le16 status;
+        __le16 reserved1;
+        __le16 reserved2;
+        __le32 sw_support;
         u8 retry_count;
         u8 tx_rate;
-        u16 tx_control; 
+        __le16 tx_control;      
 } __attribute__ ((packed));
 
 #define HERMES_TXSTAT_RETRYERR          (0x0001)
@@ -222,60 +221,60 @@ struct hermes_tx_descriptor {
 #define HERMES_INQ_SEC_STAT_AGERE       (0xF202)
 
 struct hermes_tallies_frame {
-        u16 TxUnicastFrames;
-        u16 TxMulticastFrames;
-        u16 TxFragments;
-        u16 TxUnicastOctets;
-        u16 TxMulticastOctets;
-        u16 TxDeferredTransmissions;
-        u16 TxSingleRetryFrames;
-        u16 TxMultipleRetryFrames;
-        u16 TxRetryLimitExceeded;
-        u16 TxDiscards;
-        u16 RxUnicastFrames;
-        u16 RxMulticastFrames;
-        u16 RxFragments;
-        u16 RxUnicastOctets;
-        u16 RxMulticastOctets;
-        u16 RxFCSErrors;
-        u16 RxDiscards_NoBuffer;
-        u16 TxDiscardsWrongSA;
-        u16 RxWEPUndecryptable;
-        u16 RxMsgInMsgFragments;
-        u16 RxMsgInBadMsgFragments;
+        __le16 TxUnicastFrames;
+        __le16 TxMulticastFrames;
+        __le16 TxFragments;
+        __le16 TxUnicastOctets;
+        __le16 TxMulticastOctets;
+        __le16 TxDeferredTransmissions;
+        __le16 TxSingleRetryFrames;
+        __le16 TxMultipleRetryFrames;
+        __le16 TxRetryLimitExceeded;
+        __le16 TxDiscards;
+        __le16 RxUnicastFrames;
+        __le16 RxMulticastFrames;
+        __le16 RxFragments;
+        __le16 RxUnicastOctets;
+        __le16 RxMulticastOctets;
+        __le16 RxFCSErrors;
+        __le16 RxDiscards_NoBuffer;
+        __le16 TxDiscardsWrongSA;
+        __le16 RxWEPUndecryptable;
+        __le16 RxMsgInMsgFragments;
+        __le16 RxMsgInBadMsgFragments;
         /* Those last are probably not available in very old firmwares */
-        u16 RxDiscards_WEPICVError;
-        u16 RxDiscards_WEPExcluded;
+        __le16 RxDiscards_WEPICVError;
+        __le16 RxDiscards_WEPExcluded;
 } __attribute__ ((packed));
 
 /* Grabbed from wlan-ng - Thanks Mark... - Jean II
  * This is the result of a scan inquiry command */
 /* Structure describing info about an Access Point */
 struct prism2_scan_apinfo {
-        u16 channel;            /* Channel where the AP sits */
-        u16 noise;              /* Noise level */
-        u16 level;              /* Signal level */
+        __le16 channel;         /* Channel where the AP sits */
+        __le16 noise;           /* Noise level */
+        __le16 level;           /* Signal level */
         u8 bssid[ETH_ALEN];     /* MAC address of the Access Point */
-        u16 beacon_interv;      /* Beacon interval */
-        u16 capabilities;       /* Capabilities */
-        u16 essid_len;          /* ESSID length */
+        __le16 beacon_interv;   /* Beacon interval */
+        __le16 capabilities;    /* Capabilities */
+        __le16 essid_len;       /* ESSID length */
         u8 essid[32];           /* ESSID of the network */
         u8 rates[10];           /* Bit rate supported */
-        u16 proberesp_rate;     /* Data rate of the response frame */
-        u16 atim;               /* ATIM window time, Kus (hostscan only) */
+        __le16 proberesp_rate;  /* Data rate of the response frame */
+        __le16 atim;            /* ATIM window time, Kus (hostscan only) */
 } __attribute__ ((packed));
 
 /* Same stuff for the Lucent/Agere card.
  * Thanks to h1kari <h1kari AT dachb0den.com> - Jean II */
 struct agere_scan_apinfo {
-        u16 channel;            /* Channel where the AP sits */
-        u16 noise;              /* Noise level */
-        u16 level;              /* Signal level */
+        __le16 channel;         /* Channel where the AP sits */
+        __le16 noise;           /* Noise level */
+        __le16 level;           /* Signal level */
         u8 bssid[ETH_ALEN];     /* MAC address of the Access Point */
-        u16 beacon_interv;      /* Beacon interval */
-        u16 capabilities;       /* Capabilities */
+        __le16 beacon_interv;   /* Beacon interval */
+        __le16 capabilities;    /* Capabilities */
         /* bits: 0-ess, 1-ibss, 4-privacy [wep] */
-        u16 essid_len;          /* ESSID length */
+        __le16 essid_len;       /* ESSID length */
         u8 essid[32];           /* ESSID of the network */
 } __attribute__ ((packed));
 
@@ -283,16 +282,16 @@ struct agere_scan_apinfo {
 struct symbol_scan_apinfo {
         u8 channel;             /* Channel where the AP sits */
         u8 unknown1;            /* 8 in 2.9x and 3.9x f/w, 0 otherwise */
-        u16 noise;              /* Noise level */
-        u16 level;              /* Signal level */
+        __le16 noise;           /* Noise level */
+        __le16 level;           /* Signal level */
         u8 bssid[ETH_ALEN];     /* MAC address of the Access Point */
-        u16 beacon_interv;      /* Beacon interval */
-        u16 capabilities;       /* Capabilities */
+        __le16 beacon_interv;   /* Beacon interval */
+        __le16 capabilities;    /* Capabilities */
         /* bits: 0-ess, 1-ibss, 4-privacy [wep] */
-        u16 essid_len;          /* ESSID length */
+        __le16 essid_len;       /* ESSID length */
         u8 essid[32];           /* ESSID of the network */
-        u16 rates[5];           /* Bit rate supported */
-        u16 basic_rates;        /* Basic rates bitmask */
+        __le16 rates[5];        /* Bit rate supported */
+        __le16 basic_rates;     /* Basic rates bitmask */
         u8 unknown2[6];         /* Always FF:FF:FF:FF:00:00 */
         u8 unknown3[8];         /* Always 0, appeared in f/w 3.91-68 */
 } __attribute__ ((packed));
@@ -312,7 +311,7 @@ union hermes_scan_info {
 #define HERMES_LINKSTATUS_ASSOC_FAILED    (0x0006)
   
 struct hermes_linkstatus {
-        u16 linkstatus;         /* Link status */
+        __le16 linkstatus;         /* Link status */
 } __attribute__ ((packed));
 
 struct hermes_response {
@@ -321,8 +320,8 @@ struct hermes_response {
 
 /* "ID" structure - used for ESSID and station nickname */
 struct hermes_idstring {
-        u16 len;
-        u16 val[16];
+        __le16 len;
+        __le16 val[16];
 } __attribute__ ((packed));
 
 struct hermes_multicast {
@@ -377,6 +376,8 @@ int hermes_bap_pread(hermes_t *hw, int bap, void *buf, unsigned len,
                        u16 id, u16 offset);
 int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, unsigned len,
                         u16 id, u16 offset);
+int hermes_bap_pwrite_pad(hermes_t *hw, int bap, const void *buf,
+                        unsigned data_len, unsigned len, u16 id, u16 offset);
 int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned buflen,
                     u16 *length, void *buf);
 int hermes_write_ltv(hermes_t *hw, int bap, u16 rid,
@@ -447,7 +448,7 @@ static inline void hermes_clear_words(struct hermes *hw, int off, unsigned count
 
 static inline int hermes_read_wordrec(hermes_t *hw, int bap, u16 rid, u16 *word)
 {
-        u16 rec;
+        __le16 rec;
         int err;
 
         err = HERMES_READ_RECORD(hw, bap, rid, &rec);
@@ -457,7 +458,7 @@ static inline int hermes_read_wordrec(hermes_t *hw, int bap, u16 rid, u16 *word)
 
 static inline int hermes_write_wordrec(hermes_t *hw, int bap, u16 rid, u16 word)
 {
-        u16 rec = cpu_to_le16(word);
+        __le16 rec = cpu_to_le16(word);
         return HERMES_WRITE_RECORD(hw, bap, rid, &rec);
 }
 
diff --git a/drivers/net/wireless/hostap/hostap.c b/drivers/net/wireless/hostap/hostap.c
index e7f5821b4942..6a96cd9f2685 100644
--- a/drivers/net/wireless/hostap/hostap.c
+++ b/drivers/net/wireless/hostap/hostap.c
@@ -716,9 +716,6 @@ static int prism2_close(struct net_device *dev)
                 hostap_deauth_all_stas(dev, local->ap, 1);
 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
 
-        if (local->func->dev_close && local->func->dev_close(local))
-                return 0;
-
         if (dev == local->dev) {
                 local->func->hw_shutdown(dev, HOSTAP_HW_ENABLE_CMDCOMPL);
         }
@@ -766,9 +763,6 @@ static int prism2_open(struct net_device *dev)
             local->hw_downloading)
                 return -ENODEV;
 
-        if (local->func->dev_open && local->func->dev_open(local))
-                return 1;
-
         if (!try_module_get(local->hw_module))
                 return -ENODEV;
         local->num_dev_open++;
diff --git a/drivers/net/wireless/hostap/hostap_80211_rx.c b/drivers/net/wireless/hostap/hostap_80211_rx.c
index b0501243b175..ffac50899454 100644
--- a/drivers/net/wireless/hostap/hostap_80211_rx.c
+++ b/drivers/net/wireless/hostap/hostap_80211_rx.c
@@ -6,10 +6,10 @@
 void hostap_dump_rx_80211(const char *name, struct sk_buff *skb,
                           struct hostap_80211_rx_status *rx_stats)
 {
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
 
         printk(KERN_DEBUG "%s: RX signal=%d noise=%d rate=%d len=%d "
                "jiffies=%ld\n",
@@ -51,7 +51,7 @@ int prism2_rx_80211(struct net_device *dev, struct sk_buff *skb,
         int hdrlen, phdrlen, head_need, tail_need;
         u16 fc;
         int prism_header, ret;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         iface = netdev_priv(dev);
         local = iface->local;
@@ -70,7 +70,7 @@ int prism2_rx_80211(struct net_device *dev, struct sk_buff *skb,
                 phdrlen = 0;
         }
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
 
         if (type == PRISM2_RX_MGMT && (fc & IEEE80211_FCTL_VERS)) {
@@ -215,7 +215,7 @@ prism2_frag_cache_find(local_info_t *local, unsigned int seq,
 
 /* Called only as a tasklet (software IRQ) */
 static struct sk_buff *
-prism2_frag_cache_get(local_info_t *local, struct ieee80211_hdr *hdr)
+prism2_frag_cache_get(local_info_t *local, struct ieee80211_hdr_4addr *hdr)
 {
         struct sk_buff *skb = NULL;
         u16 sc;
@@ -229,7 +229,7 @@ prism2_frag_cache_get(local_info_t *local, struct ieee80211_hdr *hdr)
         if (frag == 0) {
                 /* Reserve enough space to fit maximum frame length */
                 skb = dev_alloc_skb(local->dev->mtu +
-                                    sizeof(struct ieee80211_hdr) +
+                                    sizeof(struct ieee80211_hdr_4addr) +
                                     8 /* LLC */ +
                                     2 /* alignment */ +
                                     8 /* WEP */ + ETH_ALEN /* WDS */);
@@ -267,7 +267,7 @@ prism2_frag_cache_get(local_info_t *local, struct ieee80211_hdr *hdr)
 
 /* Called only as a tasklet (software IRQ) */
 static int prism2_frag_cache_invalidate(local_info_t *local,
-                                        struct ieee80211_hdr *hdr)
+                                        struct ieee80211_hdr_4addr *hdr)
 {
         u16 sc;
         unsigned int seq;
@@ -441,7 +441,7 @@ hostap_rx_frame_mgmt(local_info_t *local, struct sk_buff *skb,
                      u16 stype)
 {
         if (local->iw_mode == IW_MODE_MASTER) {
-                hostap_update_sta_ps(local, (struct ieee80211_hdr *)
+                hostap_update_sta_ps(local, (struct ieee80211_hdr_4addr *)
                                      skb->data);
         }
 
@@ -520,7 +520,7 @@ static inline struct net_device *prism2_rx_get_wds(local_info_t *local,
 
 
 static inline int
-hostap_rx_frame_wds(local_info_t *local, struct ieee80211_hdr *hdr,
+hostap_rx_frame_wds(local_info_t *local, struct ieee80211_hdr_4addr *hdr,
                     u16 fc, struct net_device **wds)
 {
         /* FIX: is this really supposed to accept WDS frames only in Master
@@ -579,13 +579,13 @@ static int hostap_is_eapol_frame(local_info_t *local, struct sk_buff *skb)
 {
         struct net_device *dev = local->dev;
         u16 fc, ethertype;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u8 *pos;
 
         if (skb->len < 24)
                 return 0;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
 
         /* check that the frame is unicast frame to us */
@@ -619,13 +619,13 @@ static inline int
 hostap_rx_frame_decrypt(local_info_t *local, struct sk_buff *skb,
                         struct ieee80211_crypt_data *crypt)
 {
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         int res, hdrlen;
 
         if (crypt == NULL || crypt->ops->decrypt_mpdu == NULL)
                 return 0;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         hdrlen = hostap_80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
 
         if (local->tkip_countermeasures &&
@@ -658,13 +658,13 @@ static inline int
 hostap_rx_frame_decrypt_msdu(local_info_t *local, struct sk_buff *skb,
                              int keyidx, struct ieee80211_crypt_data *crypt)
 {
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         int res, hdrlen;
 
         if (crypt == NULL || crypt->ops->decrypt_msdu == NULL)
                 return 0;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         hdrlen = hostap_80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
 
         atomic_inc(&crypt->refcnt);
@@ -689,7 +689,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
 {
         struct hostap_interface *iface;
         local_info_t *local;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         size_t hdrlen;
         u16 fc, type, stype, sc;
         struct net_device *wds = NULL;
@@ -716,7 +716,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
         dev = local->ddev;
         iface = netdev_priv(dev);
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         stats = hostap_get_stats(dev);
 
         if (skb->len < 10)
@@ -737,7 +737,8 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
                 struct iw_quality wstats;
                 wstats.level = rx_stats->signal;
                 wstats.noise = rx_stats->noise;
-                wstats.updated = 6;     /* No qual value */
+                wstats.updated = IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_UPDATED
+                        | IW_QUAL_QUAL_INVALID | IW_QUAL_DBM;
                 /* Update spy records */
                 wireless_spy_update(dev, hdr->addr2, &wstats);
         }
@@ -889,7 +890,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
         if (local->host_decrypt && (fc & IEEE80211_FCTL_PROTECTED) &&
             (keyidx = hostap_rx_frame_decrypt(local, skb, crypt)) < 0)
                 goto rx_dropped;
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
 
         /* skb: hdr + (possibly fragmented) plaintext payload */
 
@@ -941,7 +942,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
                 /* this was the last fragment and the frame will be
                  * delivered, so remove skb from fragment cache */
                 skb = frag_skb;
-                hdr = (struct ieee80211_hdr *) skb->data;
+                hdr = (struct ieee80211_hdr_4addr *) skb->data;
                 prism2_frag_cache_invalidate(local, hdr);
         }
 
@@ -952,7 +953,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
             hostap_rx_frame_decrypt_msdu(local, skb, keyidx, crypt))
                 goto rx_dropped;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         if (crypt && !(fc & IEEE80211_FCTL_PROTECTED) && !local->open_wep) {
                 if (local->ieee_802_1x &&
                     hostap_is_eapol_frame(local, skb)) {
diff --git a/drivers/net/wireless/hostap/hostap_80211_tx.c b/drivers/net/wireless/hostap/hostap_80211_tx.c
index 6358015f6526..9d24f8a38ac5 100644
--- a/drivers/net/wireless/hostap/hostap_80211_tx.c
+++ b/drivers/net/wireless/hostap/hostap_80211_tx.c
@@ -1,9 +1,9 @@
 void hostap_dump_tx_80211(const char *name, struct sk_buff *skb)
 {
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
 
         printk(KERN_DEBUG "%s: TX len=%d jiffies=%ld\n",
                name, skb->len, jiffies);
@@ -41,7 +41,7 @@ int hostap_data_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct hostap_interface *iface;
         local_info_t *local;
         int need_headroom, need_tailroom = 0;
-        struct ieee80211_hdr hdr;
+        struct ieee80211_hdr_4addr hdr;
         u16 fc, ethertype = 0;
         enum {
                 WDS_NO = 0, WDS_OWN_FRAME, WDS_COMPLIANT_FRAME
@@ -244,7 +244,7 @@ int hostap_mgmt_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct hostap_interface *iface;
         local_info_t *local;
         struct hostap_skb_tx_data *meta;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc;
 
         iface = netdev_priv(dev);
@@ -266,7 +266,7 @@ int hostap_mgmt_start_xmit(struct sk_buff *skb, struct net_device *dev)
         meta->iface = iface;
 
         if (skb->len >= IEEE80211_DATA_HDR3_LEN + sizeof(rfc1042_header) + 2) {
-                hdr = (struct ieee80211_hdr *) skb->data;
+                hdr = (struct ieee80211_hdr_4addr *) skb->data;
                 fc = le16_to_cpu(hdr->frame_ctl);
                 if (WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA &&
                     WLAN_FC_GET_STYPE(fc) == IEEE80211_STYPE_DATA) {
@@ -289,7 +289,7 @@ struct sk_buff * hostap_tx_encrypt(struct sk_buff *skb,
 {
         struct hostap_interface *iface;
         local_info_t *local;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc;
         int hdr_len, res;
 
@@ -303,7 +303,7 @@ struct sk_buff * hostap_tx_encrypt(struct sk_buff *skb,
 
         if (local->tkip_countermeasures &&
             crypt && crypt->ops && strcmp(crypt->ops->name, "TKIP") == 0) {
-                hdr = (struct ieee80211_hdr *) skb->data;
+                hdr = (struct ieee80211_hdr_4addr *) skb->data;
                 if (net_ratelimit()) {
                         printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
                                "TX packet to " MACSTR "\n",
@@ -317,15 +317,15 @@ struct sk_buff * hostap_tx_encrypt(struct sk_buff *skb,
         if (skb == NULL)
                 return NULL;
 
-        if ((skb_headroom(skb) < crypt->ops->extra_prefix_len ||
-             skb_tailroom(skb) < crypt->ops->extra_postfix_len) &&
-            pskb_expand_head(skb, crypt->ops->extra_prefix_len,
-                             crypt->ops->extra_postfix_len, GFP_ATOMIC)) {
+        if ((skb_headroom(skb) < crypt->ops->extra_mpdu_prefix_len ||
+             skb_tailroom(skb) < crypt->ops->extra_mpdu_postfix_len) &&
+            pskb_expand_head(skb, crypt->ops->extra_mpdu_prefix_len,
+                             crypt->ops->extra_mpdu_postfix_len, GFP_ATOMIC)) {
                 kfree_skb(skb);
                 return NULL;
         }
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
         hdr_len = hostap_80211_get_hdrlen(fc);
 
@@ -360,7 +360,7 @@ int hostap_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
         ap_tx_ret tx_ret;
         struct hostap_skb_tx_data *meta;
         int no_encrypt = 0;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         iface = netdev_priv(dev);
         local = iface->local;
@@ -403,7 +403,7 @@ int hostap_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
         tx_ret = hostap_handle_sta_tx(local, &tx);
         skb = tx.skb;
         meta = (struct hostap_skb_tx_data *) skb->cb;
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
         switch (tx_ret) {
         case AP_TX_CONTINUE:
diff --git a/drivers/net/wireless/hostap/hostap_ap.c b/drivers/net/wireless/hostap/hostap_ap.c
index 930cef8367f2..9da94ab7f05f 100644
--- a/drivers/net/wireless/hostap/hostap_ap.c
+++ b/drivers/net/wireless/hostap/hostap_ap.c
@@ -591,14 +591,14 @@ static void hostap_ap_tx_cb(struct sk_buff *skb, int ok, void *data)
 {
         struct ap_data *ap = data;
         u16 fc;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         if (!ap->local->hostapd || !ap->local->apdev) {
                 dev_kfree_skb(skb);
                 return;
         }
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
 
         /* Pass the TX callback frame to the hostapd; use 802.11 header version
@@ -623,7 +623,7 @@ static void hostap_ap_tx_cb_auth(struct sk_buff *skb, int ok, void *data)
 {
         struct ap_data *ap = data;
         struct net_device *dev = ap->local->dev;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc, *pos, auth_alg, auth_transaction, status;
         struct sta_info *sta = NULL;
         char *txt = NULL;
@@ -633,7 +633,7 @@ static void hostap_ap_tx_cb_auth(struct sk_buff *skb, int ok, void *data)
                 return;
         }
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
         if (WLAN_FC_GET_TYPE(fc) != IEEE80211_FTYPE_MGMT ||
             WLAN_FC_GET_STYPE(fc) != IEEE80211_STYPE_AUTH ||
@@ -692,7 +692,7 @@ static void hostap_ap_tx_cb_assoc(struct sk_buff *skb, int ok, void *data)
 {
         struct ap_data *ap = data;
         struct net_device *dev = ap->local->dev;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc, *pos, status;
         struct sta_info *sta = NULL;
         char *txt = NULL;
@@ -702,7 +702,7 @@ static void hostap_ap_tx_cb_assoc(struct sk_buff *skb, int ok, void *data)
                 return;
         }
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
         if (WLAN_FC_GET_TYPE(fc) != IEEE80211_FTYPE_MGMT ||
             (WLAN_FC_GET_STYPE(fc) != IEEE80211_STYPE_ASSOC_RESP &&
@@ -757,12 +757,12 @@ static void hostap_ap_tx_cb_assoc(struct sk_buff *skb, int ok, void *data)
 static void hostap_ap_tx_cb_poll(struct sk_buff *skb, int ok, void *data)
 {
         struct ap_data *ap = data;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         struct sta_info *sta;
 
         if (skb->len < 24)
                 goto fail;
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         if (ok) {
                 spin_lock(&ap->sta_table_lock);
                 sta = ap_get_sta(ap, hdr->addr1);
@@ -918,7 +918,7 @@ static void prism2_send_mgmt(struct net_device *dev,
 {
         struct hostap_interface *iface;
         local_info_t *local;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         u16 fc;
         struct sk_buff *skb;
         struct hostap_skb_tx_data *meta;
@@ -944,7 +944,7 @@ static void prism2_send_mgmt(struct net_device *dev,
 
         fc = type_subtype;
         hdrlen = hostap_80211_get_hdrlen(fc);
-        hdr = (struct ieee80211_hdr *) skb_put(skb, hdrlen);
+        hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, hdrlen);
         if (body)
                 memcpy(skb_put(skb, body_len), body, body_len);
 
@@ -1256,14 +1256,14 @@ static char * ap_auth_make_challenge(struct ap_data *ap)
         }
 
         skb = dev_alloc_skb(WLAN_AUTH_CHALLENGE_LEN +
-                            ap->crypt->extra_prefix_len +
-                            ap->crypt->extra_postfix_len);
+                            ap->crypt->extra_mpdu_prefix_len +
+                            ap->crypt->extra_mpdu_postfix_len);
         if (skb == NULL) {
                 kfree(tmpbuf);
                 return NULL;
         }
 
-        skb_reserve(skb, ap->crypt->extra_prefix_len);
+        skb_reserve(skb, ap->crypt->extra_mpdu_prefix_len);
         memset(skb_put(skb, WLAN_AUTH_CHALLENGE_LEN), 0,
                WLAN_AUTH_CHALLENGE_LEN);
         if (ap->crypt->encrypt_mpdu(skb, 0, ap->crypt_priv)) {
@@ -1272,7 +1272,7 @@ static char * ap_auth_make_challenge(struct ap_data *ap)
                 return NULL;
         }
 
-        memcpy(tmpbuf, skb->data + ap->crypt->extra_prefix_len,
+        memcpy(tmpbuf, skb->data + ap->crypt->extra_mpdu_prefix_len,
                WLAN_AUTH_CHALLENGE_LEN);
         dev_kfree_skb(skb);
 
@@ -1285,7 +1285,7 @@ static void handle_authen(local_info_t *local, struct sk_buff *skb,
                           struct hostap_80211_rx_status *rx_stats)
 {
         struct net_device *dev = local->dev;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
         size_t hdrlen;
         struct ap_data *ap = local->ap;
         char body[8 + WLAN_AUTH_CHALLENGE_LEN], *challenge = NULL;
@@ -1498,7 +1498,7 @@ static void handle_assoc(local_info_t *local, struct sk_buff *skb,
                          struct hostap_80211_rx_status *rx_stats, int reassoc)
 {
         struct net_device *dev = local->dev;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
         char body[12], *p, *lpos;
         int len, left;
         u16 *pos;
@@ -1705,7 +1705,7 @@ static void handle_deauth(local_info_t *local, struct sk_buff *skb,
                           struct hostap_80211_rx_status *rx_stats)
 {
         struct net_device *dev = local->dev;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
         char *body = (char *) (skb->data + IEEE80211_MGMT_HDR_LEN);
         int len;
         u16 reason_code, *pos;
@@ -1746,7 +1746,7 @@ static void handle_disassoc(local_info_t *local, struct sk_buff *skb,
                             struct hostap_80211_rx_status *rx_stats)
 {
         struct net_device *dev = local->dev;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
         char *body = skb->data + IEEE80211_MGMT_HDR_LEN;
         int len;
         u16 reason_code, *pos;
@@ -1784,7 +1784,7 @@ static void handle_disassoc(local_info_t *local, struct sk_buff *skb,
 
 /* Called only as a scheduled task for pending AP frames. */
 static void ap_handle_data_nullfunc(local_info_t *local,
-                                    struct ieee80211_hdr *hdr)
+                                    struct ieee80211_hdr_4addr *hdr)
 {
         struct net_device *dev = local->dev;
 
@@ -1801,7 +1801,7 @@ static void ap_handle_data_nullfunc(local_info_t *local,
 
 /* Called only as a scheduled task for pending AP frames. */
 static void ap_handle_dropped_data(local_info_t *local,
-                                   struct ieee80211_hdr *hdr)
+                                   struct ieee80211_hdr_4addr *hdr)
 {
         struct net_device *dev = local->dev;
         struct sta_info *sta;
@@ -1860,7 +1860,7 @@ static void pspoll_send_buffered(local_info_t *local, struct sta_info *sta,
 
 /* Called only as a scheduled task for pending AP frames. */
 static void handle_pspoll(local_info_t *local,
-                          struct ieee80211_hdr *hdr,
+                          struct ieee80211_hdr_4addr *hdr,
                           struct hostap_80211_rx_status *rx_stats)
 {
         struct net_device *dev = local->dev;
@@ -1979,7 +1979,7 @@ static void handle_wds_oper_queue(void *data)
 static void handle_beacon(local_info_t *local, struct sk_buff *skb,
                           struct hostap_80211_rx_status *rx_stats)
 {
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
         char *body = skb->data + IEEE80211_MGMT_HDR_LEN;
         int len, left;
         u16 *pos, beacon_int, capability;
@@ -2137,11 +2137,11 @@ static void handle_ap_item(local_info_t *local, struct sk_buff *skb,
         struct net_device *dev = local->dev;
 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
         u16 fc, type, stype;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         /* FIX: should give skb->len to handler functions and check that the
          * buffer is long enough */
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
         type = WLAN_FC_GET_TYPE(fc);
         stype = WLAN_FC_GET_STYPE(fc);
@@ -2258,7 +2258,7 @@ void hostap_rx(struct net_device *dev, struct sk_buff *skb,
         struct hostap_interface *iface;
         local_info_t *local;
         u16 fc;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         iface = netdev_priv(dev);
         local = iface->local;
@@ -2268,7 +2268,7 @@ void hostap_rx(struct net_device *dev, struct sk_buff *skb,
 
         local->stats.rx_packets++;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         fc = le16_to_cpu(hdr->frame_ctl);
 
         if (local->ap->ap_policy == AP_OTHER_AP_SKIP_ALL &&
@@ -2289,7 +2289,7 @@ void hostap_rx(struct net_device *dev, struct sk_buff *skb,
 static void schedule_packet_send(local_info_t *local, struct sta_info *sta)
 {
         struct sk_buff *skb;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         struct hostap_80211_rx_status rx_stats;
 
         if (skb_queue_empty(&sta->tx_buf))
@@ -2302,7 +2302,7 @@ static void schedule_packet_send(local_info_t *local, struct sta_info *sta)
                 return;
         }
 
-        hdr = (struct ieee80211_hdr *) skb_put(skb, 16);
+        hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, 16);
 
         /* Generate a fake pspoll frame to start packet delivery */
         hdr->frame_ctl = __constant_cpu_to_le16(
@@ -2349,7 +2349,7 @@ static int prism2_ap_get_sta_qual(local_info_t *local, struct sockaddr addr[],
                 qual[count].noise = HFA384X_LEVEL_TO_dBm(sta->last_rx_silence);
                 qual[count].updated = sta->last_rx_updated;
 
-                sta->last_rx_updated = 0;
+                sta->last_rx_updated = IW_QUAL_DBM;
 
                 count++;
                 if (count >= buf_size)
@@ -2467,7 +2467,7 @@ static int prism2_ap_translate_scan(struct net_device *dev, char *buffer)
                 }
 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
 
-                sta->last_rx_updated = 0;
+                sta->last_rx_updated = IW_QUAL_DBM;
 
                 /* To be continued, we should make good use of IWEVCUSTOM */
         }
@@ -2685,7 +2685,7 @@ ap_tx_ret hostap_handle_sta_tx(local_info_t *local, struct hostap_tx_data *tx)
         struct sta_info *sta = NULL;
         struct sk_buff *skb = tx->skb;
         int set_tim, ret;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         struct hostap_skb_tx_data *meta;
 
         meta = (struct hostap_skb_tx_data *) skb->cb;
@@ -2694,7 +2694,7 @@ ap_tx_ret hostap_handle_sta_tx(local_info_t *local, struct hostap_tx_data *tx)
             meta->iface->type == HOSTAP_INTERFACE_STA)
                 goto out;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
 
         if (hdr->addr1[0] & 0x01) {
                 /* broadcast/multicast frame - no AP related processing */
@@ -2821,10 +2821,10 @@ void hostap_handle_sta_release(void *ptr)
 void hostap_handle_sta_tx_exc(local_info_t *local, struct sk_buff *skb)
 {
         struct sta_info *sta;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
         struct hostap_skb_tx_data *meta;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
         meta = (struct hostap_skb_tx_data *) skb->cb;
 
         spin_lock(&local->ap->sta_table_lock);
@@ -2892,7 +2892,7 @@ static void hostap_update_sta_ps2(local_info_t *local, struct sta_info *sta,
 
 /* Called only as a tasklet (software IRQ). Called for each RX frame to update
  * STA power saving state. pwrmgt is a flag from 802.11 frame_ctl field. */
-int hostap_update_sta_ps(local_info_t *local, struct ieee80211_hdr *hdr)
+int hostap_update_sta_ps(local_info_t *local, struct ieee80211_hdr_4addr *hdr)
 {
         struct sta_info *sta;
         u16 fc;
@@ -2925,12 +2925,12 @@ ap_rx_ret hostap_handle_sta_rx(local_info_t *local, struct net_device *dev,
         int ret;
         struct sta_info *sta;
         u16 fc, type, stype;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_4addr *hdr;
 
         if (local->ap == NULL)
                 return AP_RX_CONTINUE;
 
-        hdr = (struct ieee80211_hdr *) skb->data;
+        hdr = (struct ieee80211_hdr_4addr *) skb->data;
 
         fc = le16_to_cpu(hdr->frame_ctl);
         type = WLAN_FC_GET_TYPE(fc);
@@ -3058,7 +3058,7 @@ ap_rx_ret hostap_handle_sta_rx(local_info_t *local, struct net_device *dev,
 
 /* Called only as a tasklet (software IRQ) */
 int hostap_handle_sta_crypto(local_info_t *local,
-                             struct ieee80211_hdr *hdr,
+                             struct ieee80211_hdr_4addr *hdr,
                              struct ieee80211_crypt_data **crypt,
                              void **sta_ptr)
 {
@@ -3160,7 +3160,7 @@ int hostap_add_sta(struct ap_data *ap, u8 *sta_addr)
 
 /* Called only as a tasklet (software IRQ) */
 int hostap_update_rx_stats(struct ap_data *ap,
-                           struct ieee80211_hdr *hdr,
+                           struct ieee80211_hdr_4addr *hdr,
                            struct hostap_80211_rx_status *rx_stats)
 {
         struct sta_info *sta;
@@ -3174,7 +3174,7 @@ int hostap_update_rx_stats(struct ap_data *ap,
                 sta->last_rx_silence = rx_stats->noise;
                 sta->last_rx_signal = rx_stats->signal;
                 sta->last_rx_rate = rx_stats->rate;
-                sta->last_rx_updated = 7;
+                sta->last_rx_updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
                 if (rx_stats->rate == 10)
                         sta->rx_count[0]++;
                 else if (rx_stats->rate == 20)
diff --git a/drivers/net/wireless/hostap/hostap_ap.h b/drivers/net/wireless/hostap/hostap_ap.h
index 816a52bcea8f..6d00df69c2e3 100644
--- a/drivers/net/wireless/hostap/hostap_ap.h
+++ b/drivers/net/wireless/hostap/hostap_ap.h
@@ -233,7 +233,7 @@ struct hostap_tx_data {
 ap_tx_ret hostap_handle_sta_tx(local_info_t *local, struct hostap_tx_data *tx);
 void hostap_handle_sta_release(void *ptr);
 void hostap_handle_sta_tx_exc(local_info_t *local, struct sk_buff *skb);
-int hostap_update_sta_ps(local_info_t *local, struct ieee80211_hdr *hdr);
+int hostap_update_sta_ps(local_info_t *local, struct ieee80211_hdr_4addr *hdr);
 typedef enum {
         AP_RX_CONTINUE, AP_RX_DROP, AP_RX_EXIT, AP_RX_CONTINUE_NOT_AUTHORIZED
 } ap_rx_ret;
@@ -241,13 +241,13 @@ ap_rx_ret hostap_handle_sta_rx(local_info_t *local, struct net_device *dev,
                                struct sk_buff *skb,
                                struct hostap_80211_rx_status *rx_stats,
                                int wds);
-int hostap_handle_sta_crypto(local_info_t *local, struct ieee80211_hdr *hdr,
+int hostap_handle_sta_crypto(local_info_t *local, struct ieee80211_hdr_4addr *hdr,
                              struct ieee80211_crypt_data **crypt,
                              void **sta_ptr);
 int hostap_is_sta_assoc(struct ap_data *ap, u8 *sta_addr);
 int hostap_is_sta_authorized(struct ap_data *ap, u8 *sta_addr);
 int hostap_add_sta(struct ap_data *ap, u8 *sta_addr);
-int hostap_update_rx_stats(struct ap_data *ap, struct ieee80211_hdr *hdr,
+int hostap_update_rx_stats(struct ap_data *ap, struct ieee80211_hdr_4addr *hdr,
                            struct hostap_80211_rx_status *rx_stats);
 void hostap_update_rates(local_info_t *local);
 void hostap_add_wds_links(local_info_t *local);
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index faa83badf0a1..2643976a6677 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -492,42 +492,10 @@ static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
 }
 
 
-static int prism2_pccard_dev_open(local_info_t *local)
-{
-        struct hostap_cs_priv *hw_priv = local->hw_priv;
-        hw_priv->link->open++;
-        return 0;
-}
-
-
-static int prism2_pccard_dev_close(local_info_t *local)
-{
-        struct hostap_cs_priv *hw_priv;
-
-        if (local == NULL || local->hw_priv == NULL)
-                return 1;
-        hw_priv = local->hw_priv;
-        if (hw_priv->link == NULL)
-                return 1;
-
-        if (!hw_priv->link->open) {
-                printk(KERN_WARNING "%s: prism2_pccard_dev_close(): "
-                       "link not open?!\n", local->dev->name);
-                return 1;
-        }
-
-        hw_priv->link->open--;
-
-        return 0;
-}
-
-
 static struct prism2_helper_functions prism2_pccard_funcs =
 {
         .card_present   = prism2_pccard_card_present,
         .cor_sreset     = prism2_pccard_cor_sreset,
-        .dev_open       = prism2_pccard_dev_open,
-        .dev_close      = prism2_pccard_dev_close,
         .genesis_reset  = prism2_pccard_genesis_reset,
         .hw_type        = HOSTAP_HW_PCCARD,
 };
@@ -597,13 +565,14 @@ static void prism2_detach(dev_link_t *link)
         *linkp = link->next;
         /* release net devices */
         if (link->priv) {
+                struct hostap_cs_priv *hw_priv;
                 struct net_device *dev;
                 struct hostap_interface *iface;
                 dev = link->priv;
                 iface = netdev_priv(dev);
-                kfree(iface->local->hw_priv);
-                iface->local->hw_priv = NULL;
+                hw_priv = iface->local->hw_priv;
                 prism2_free_local_data(dev);
+                kfree(hw_priv);
         }
         kfree(link);
 }
@@ -883,6 +852,13 @@ static int prism2_event(event_t event, int priority,
 {
         dev_link_t *link = args->client_data;
         struct net_device *dev = (struct net_device *) link->priv;
+        int dev_open = 0;
+
+        if (link->state & DEV_CONFIG) {
+                struct hostap_interface *iface = netdev_priv(dev);
+                if (iface && iface->local)
+                        dev_open = iface->local->num_dev_open > 0;
+        }
 
         switch (event) {
         case CS_EVENT_CARD_INSERTION:
@@ -911,7 +887,7 @@ static int prism2_event(event_t event, int priority,
         case CS_EVENT_RESET_PHYSICAL:
                 PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_RESET_PHYSICAL\n", dev_info);
                 if (link->state & DEV_CONFIG) {
-                        if (link->open) {
+                        if (dev_open) {
                                 netif_stop_queue(dev);
                                 netif_device_detach(dev);
                         }
@@ -931,8 +907,8 @@ static int prism2_event(event_t event, int priority,
                         pcmcia_request_configuration(link->handle,
                                                      &link->conf);
                         prism2_hw_shutdown(dev, 1);
-                        prism2_hw_config(dev, link->open ? 0 : 1);
-                        if (link->open) {
+                        prism2_hw_config(dev, dev_open ? 0 : 1);
+                        if (dev_open) {
                                 netif_device_attach(dev);
                                 netif_start_queue(dev);
                         }
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index e533a663deda..59fc15572395 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -3322,6 +3322,18 @@ static void prism2_free_local_data(struct net_device *dev)
         iface = netdev_priv(dev);
         local = iface->local;
 
+        /* Unregister all netdevs before freeing local data. */
+        list_for_each_safe(ptr, n, &local->hostap_interfaces) {
+                iface = list_entry(ptr, struct hostap_interface, list);
+                if (iface->type == HOSTAP_INTERFACE_MASTER) {
+                        /* special handling for this interface below */
+                        continue;
+                }
+                hostap_remove_interface(iface->dev, 0, 1);
+        }
+
+        unregister_netdev(local->dev);
+
         flush_scheduled_work();
 
         if (timer_pending(&local->crypt_deinit_timer))
@@ -3382,15 +3394,6 @@ static void prism2_free_local_data(struct net_device *dev)
         prism2_download_free_data(local->dl_sec);
 #endif /* PRISM2_DOWNLOAD_SUPPORT */
 
-        list_for_each_safe(ptr, n, &local->hostap_interfaces) {
-                iface = list_entry(ptr, struct hostap_interface, list);
-                if (iface->type == HOSTAP_INTERFACE_MASTER) {
-                        /* special handling for this interface below */
-                        continue;
-                }
-                hostap_remove_interface(iface->dev, 0, 1);
-        }
-
         prism2_clear_set_tim_queue(local);
 
         list_for_each_safe(ptr, n, &local->bss_list) {
@@ -3403,7 +3406,6 @@ static void prism2_free_local_data(struct net_device *dev)
         kfree(local->last_scan_results);
         kfree(local->generic_elem);
 
-        unregister_netdev(local->dev);
         free_netdev(local->dev);
 }
 
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index e720369a3515..2617d70bcda9 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -50,7 +50,8 @@ static struct iw_statistics *hostap_get_wireless_stats(struct net_device *dev)
 #endif /* in_atomic */
 
                 if (update && prism2_update_comms_qual(dev) == 0)
-                        wstats->qual.updated = 7;
+                        wstats->qual.updated = IW_QUAL_ALL_UPDATED |
+                                IW_QUAL_DBM;
 
                 wstats->qual.qual = local->comms_qual;
                 wstats->qual.level = local->avg_signal;
@@ -59,7 +60,7 @@ static struct iw_statistics *hostap_get_wireless_stats(struct net_device *dev)
                 wstats->qual.qual = 0;
                 wstats->qual.level = 0;
                 wstats->qual.noise = 0;
-                wstats->qual.updated = 0;
+                wstats->qual.updated = IW_QUAL_ALL_INVALID;
         }
 
         return wstats;
@@ -551,7 +552,6 @@ static int prism2_ioctl_giwaplist(struct net_device *dev,
 
         kfree(addr);
         kfree(qual);
-
         return 0;
 }
 
@@ -1827,13 +1827,6 @@ static char * __prism2_translate_scan(local_info_t *local,
         iwe.cmd = SIOCGIWAP;
         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
         memcpy(iwe.u.ap_addr.sa_data, bssid, ETH_ALEN);
-        /* FIX:
-         * I do not know how this is possible, but iwe_stream_add_event
-         * seems to re-order memcpy execution so that len is set only
-         * after copying.. Pre-setting len here "fixes" this, but real
-         * problems should be solved (after which these iwe.len
-         * settings could be removed from this function). */
-        iwe.len = IW_EV_ADDR_LEN;
         current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
                                           IW_EV_ADDR_LEN);
 
@@ -1843,7 +1836,6 @@ static char * __prism2_translate_scan(local_info_t *local,
         iwe.cmd = SIOCGIWESSID;
         iwe.u.data.length = ssid_len;
         iwe.u.data.flags = 1;
-        iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
         current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, ssid);
 
         memset(&iwe, 0, sizeof(iwe));
@@ -1859,7 +1851,6 @@ static char * __prism2_translate_scan(local_info_t *local,
                         iwe.u.mode = IW_MODE_MASTER;
                 else
                         iwe.u.mode = IW_MODE_ADHOC;
-                iwe.len = IW_EV_UINT_LEN;
                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
                                                   IW_EV_UINT_LEN);
         }
@@ -1877,7 +1868,6 @@ static char * __prism2_translate_scan(local_info_t *local,
         if (chan > 0) {
                 iwe.u.freq.m = freq_list[le16_to_cpu(chan - 1)] * 100000;
                 iwe.u.freq.e = 1;
-                iwe.len = IW_EV_FREQ_LEN;
                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
                                                   IW_EV_FREQ_LEN);
         }
@@ -1894,7 +1884,10 @@ static char * __prism2_translate_scan(local_info_t *local,
                         iwe.u.qual.noise =
                                 HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->anl));
                 }
-                iwe.len = IW_EV_QUAL_LEN;
+                iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED
+                        | IW_QUAL_NOISE_UPDATED
+                        | IW_QUAL_QUAL_INVALID
+                        | IW_QUAL_DBM;
                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
                                                   IW_EV_QUAL_LEN);
         }
@@ -1906,7 +1899,6 @@ static char * __prism2_translate_scan(local_info_t *local,
         else
                 iwe.u.data.flags = IW_ENCODE_DISABLED;
         iwe.u.data.length = 0;
-        iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
         current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, "");
 
         /* TODO: add SuppRates into BSS table */
@@ -1930,7 +1922,7 @@ static char * __prism2_translate_scan(local_info_t *local,
         }
 
         /* TODO: add BeaconInt,resp_rate,atim into BSS table */
-        buf = kmalloc(MAX_WPA_IE_LEN * 2 + 30, GFP_KERNEL);
+        buf = kmalloc(MAX_WPA_IE_LEN * 2 + 30, GFP_ATOMIC);
         if (buf && scan) {
                 memset(&iwe, 0, sizeof(iwe));
                 iwe.cmd = IWEVCUSTOM;
@@ -3088,9 +3080,7 @@ static int prism2_ioctl_priv_download(local_info_t *local, struct iw_point *p)
         ret = local->func->download(local, param);
 
  out:
-        if (param != NULL)
-                kfree(param);
-
+        kfree(param);
         return ret;
 }
 #endif /* PRISM2_DOWNLOAD_SUPPORT */
@@ -3897,9 +3887,7 @@ static int prism2_ioctl_priv_hostapd(local_info_t *local, struct iw_point *p)
         }
 
  out:
-        if (param != NULL)
-                kfree(param);
-
+        kfree(param);
         return ret;
 }
 
diff --git a/drivers/net/wireless/hostap/hostap_pci.c b/drivers/net/wireless/hostap/hostap_pci.c
index 025f8cdb5566..da0c80fb941c 100644
--- a/drivers/net/wireless/hostap/hostap_pci.c
+++ b/drivers/net/wireless/hostap/hostap_pci.c
@@ -59,11 +59,13 @@ static struct pci_device_id prism2_pci_id_table[] __devinitdata = {
 static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
 {
         struct hostap_interface *iface;
+        struct hostap_pci_priv *hw_priv;
         local_info_t *local;
         unsigned long flags;
 
         iface = netdev_priv(dev);
         local = iface->local;
+        hw_priv = local->hw_priv;
 
         spin_lock_irqsave(&local->lock, flags);
         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTB, a, v);
@@ -74,12 +76,14 @@ static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
 static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
 {
         struct hostap_interface *iface;
+        struct hostap_pci_priv *hw_priv;
         local_info_t *local;
         unsigned long flags;
         u8 v;
 
         iface = netdev_priv(dev);
         local = iface->local;
+        hw_priv = local->hw_priv;
 
         spin_lock_irqsave(&local->lock, flags);
         v = readb(hw_priv->mem_start + a);
@@ -91,11 +95,13 @@ static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
 static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
 {
         struct hostap_interface *iface;
+        struct hostap_pci_priv *hw_priv;
         local_info_t *local;
         unsigned long flags;
 
         iface = netdev_priv(dev);
         local = iface->local;
+        hw_priv = local->hw_priv;
 
         spin_lock_irqsave(&local->lock, flags);
         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTW, a, v);
@@ -106,12 +112,14 @@ static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
 static inline u16 hfa384x_inw_debug(struct net_device *dev, int a)
 {
         struct hostap_interface *iface;
+        struct hostap_pci_priv *hw_priv;
         local_info_t *local;
         unsigned long flags;
         u16 v;
 
         iface = netdev_priv(dev);
         local = iface->local;
+        hw_priv = local->hw_priv;
 
         spin_lock_irqsave(&local->lock, flags);
         v = readw(hw_priv->mem_start + a);
@@ -277,8 +285,6 @@ static struct prism2_helper_functions prism2_pci_funcs =
 {
         .card_present   = NULL,
         .cor_sreset     = prism2_pci_cor_sreset,
-        .dev_open       = NULL,
-        .dev_close      = NULL,
         .genesis_reset  = prism2_pci_genesis_reset,
         .hw_type        = HOSTAP_HW_PCI,
 };
@@ -352,8 +358,6 @@ static int prism2_pci_probe(struct pci_dev *pdev,
         return hostap_hw_ready(dev);
 
  fail:
-        kfree(hw_priv);
-
         if (irq_registered && dev)
                 free_irq(dev->irq, dev);
 
@@ -364,10 +368,8 @@ static int prism2_pci_probe(struct pci_dev *pdev,
 
  err_out_disable:
         pci_disable_device(pdev);
-        kfree(hw_priv);
-        if (local)
-                local->hw_priv = NULL;
         prism2_free_local_data(dev);
+        kfree(hw_priv);
 
         return -ENODEV;
 }
@@ -392,9 +394,8 @@ static void prism2_pci_remove(struct pci_dev *pdev)
                 free_irq(dev->irq, dev);
 
         mem_start = hw_priv->mem_start;
-        kfree(hw_priv);
-        iface->local->hw_priv = NULL;
         prism2_free_local_data(dev);
+        kfree(hw_priv);
 
         iounmap(mem_start);
 
@@ -441,7 +442,7 @@ static int prism2_pci_resume(struct pci_dev *pdev)
 MODULE_DEVICE_TABLE(pci, prism2_pci_id_table);
 
 static struct pci_driver prism2_pci_drv_id = {
-        .name           = "prism2_pci",
+        .name           = "hostap_pci",
         .id_table       = prism2_pci_id_table,
         .probe          = prism2_pci_probe,
         .remove         = prism2_pci_remove,
diff --git a/drivers/net/wireless/hostap/hostap_plx.c b/drivers/net/wireless/hostap/hostap_plx.c
index 474ef83d813e..78d67b408b2f 100644
--- a/drivers/net/wireless/hostap/hostap_plx.c
+++ b/drivers/net/wireless/hostap/hostap_plx.c
@@ -328,8 +328,6 @@ static struct prism2_helper_functions prism2_plx_funcs =
 {
         .card_present   = NULL,
         .cor_sreset     = prism2_plx_cor_sreset,
-        .dev_open       = NULL,
-        .dev_close      = NULL,
         .genesis_reset  = prism2_plx_genesis_reset,
         .hw_type        = HOSTAP_HW_PLX,
 };
@@ -570,10 +568,8 @@ static int prism2_plx_probe(struct pci_dev *pdev,
         return hostap_hw_ready(dev);
 
  fail:
-        kfree(hw_priv);
-        if (local)
-                local->hw_priv = NULL;
         prism2_free_local_data(dev);
+        kfree(hw_priv);
 
         if (irq_registered && dev)
                 free_irq(dev->irq, dev);
@@ -606,9 +602,8 @@ static void prism2_plx_remove(struct pci_dev *pdev)
         if (dev->irq)
                 free_irq(dev->irq, dev);
 
-        kfree(iface->local->hw_priv);
-        iface->local->hw_priv = NULL;
         prism2_free_local_data(dev);
+        kfree(hw_priv);
         pci_disable_device(pdev);
 }
 
@@ -616,7 +611,7 @@ static void prism2_plx_remove(struct pci_dev *pdev)
 MODULE_DEVICE_TABLE(pci, prism2_plx_id_table);
 
 static struct pci_driver prism2_plx_drv_id = {
-        .name           = "prism2_plx",
+        .name           = "hostap_plx",
         .id_table       = prism2_plx_id_table,
         .probe          = prism2_plx_probe,
         .remove         = prism2_plx_remove,
diff --git a/drivers/net/wireless/hostap/hostap_wlan.h b/drivers/net/wireless/hostap/hostap_wlan.h
index cc061e1560d3..cfd801559492 100644
--- a/drivers/net/wireless/hostap/hostap_wlan.h
+++ b/drivers/net/wireless/hostap/hostap_wlan.h
@@ -552,8 +552,6 @@ struct prism2_helper_functions {
          * (hostap_{cs,plx,pci}.c */
         int (*card_present)(local_info_t *local);
         void (*cor_sreset)(local_info_t *local);
-        int (*dev_open)(local_info_t *local);
-        int (*dev_close)(local_info_t *local);
         void (*genesis_reset)(local_info_t *local, int hcr);
 
         /* the following functions are from hostap_hw.c, but they may have some
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c
index 2414e6493aa5..ad7f8cd76db9 100644
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -800,8 +800,7 @@ static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
          * doesn't seem to have as many firmware restart cycles...
          *
          * As a test, we're sticking in a 1/100s delay here */
-        set_current_state(TASK_UNINTERRUPTIBLE);
-        schedule_timeout(HZ / 100);
+        schedule_timeout_uninterruptible(msecs_to_jiffies(10));
 
         return 0;
 
@@ -1256,8 +1255,7 @@ static int ipw2100_start_adapter(struct ipw2100_priv *priv)
         IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n");
         i = 5000;
         do {
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(40 * HZ / 1000);
+                schedule_timeout_uninterruptible(msecs_to_jiffies(40));
                 /* Todo... wait for sync command ... */
 
                 read_register(priv->net_dev, IPW_REG_INTA, &inta);
@@ -1411,8 +1409,7 @@ static int ipw2100_hw_phy_off(struct ipw2100_priv *priv)
                     (val2 & IPW2100_COMMAND_PHY_OFF))
                         return 0;
 
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(HW_PHY_OFF_LOOP_DELAY);
+                schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
         }
 
         return -EIO;
@@ -1466,7 +1463,7 @@ fail_up:
 
 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
 {
-#define HW_POWER_DOWN_DELAY (HZ / 10)
+#define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
 
         struct host_command cmd = {
                 .host_command = HOST_PRE_POWER_DOWN,
@@ -1520,10 +1517,8 @@ static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
                         printk(KERN_WARNING DRV_NAME ": "
                                "%s: Power down command failed: Error %d\n",
                                priv->net_dev->name, err);
-                else {
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        schedule_timeout(HW_POWER_DOWN_DELAY);
-                }
+                else
+                        schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
         }
 
         priv->status &= ~STATUS_ENABLED;
@@ -2953,7 +2948,7 @@ static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
         int next = txq->next;
         int i = 0;
         struct ipw2100_data_header *ipw_hdr;
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr_3addr *hdr;
 
         while (!list_empty(&priv->tx_pend_list)) {
                 /* if there isn't enough space in TBD queue, then
@@ -2989,7 +2984,7 @@ static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
                 packet->index = txq->next;
 
                 ipw_hdr = packet->info.d_struct.data;
-                hdr = (struct ieee80211_hdr *)packet->info.d_struct.txb->
+                hdr = (struct ieee80211_hdr_3addr *)packet->info.d_struct.txb->
                         fragments[0]->data;
 
                 if (priv->ieee->iw_mode == IW_MODE_INFRA) {
@@ -3274,7 +3269,8 @@ static irqreturn_t ipw2100_interrupt(int irq, void *data,
         return IRQ_NONE;
 }
 
-static int ipw2100_tx(struct ieee80211_txb *txb, struct net_device *dev)
+static int ipw2100_tx(struct ieee80211_txb *txb, struct net_device *dev,
+                      int pri)
 {
         struct ipw2100_priv *priv = ieee80211_priv(dev);
         struct list_head *element;
diff --git a/drivers/net/wireless/ipw2100.h b/drivers/net/wireless/ipw2100.h
index 2a3cdbd50168..c9e99ce15d66 100644
--- a/drivers/net/wireless/ipw2100.h
+++ b/drivers/net/wireless/ipw2100.h
@@ -808,7 +808,7 @@ struct ipw2100_priv {
 struct ipw2100_rx {
         union {
                 unsigned char payload[IPW_RX_NIC_BUFFER_LENGTH];
-                struct ieee80211_hdr header;
+                struct ieee80211_hdr_4addr header;
                 u32 status;
                 struct ipw2100_notification notification;
                 struct ipw2100_cmd_header command;
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index b7f275c00de3..3db0c32afe82 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -4030,6 +4030,10 @@ static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
         int i;
 
         rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
+        if (unlikely(!rxq)) {
+                IPW_ERROR("memory allocation failed\n");
+                return NULL;
+        }
         memset(rxq, 0, sizeof(*rxq));
         spin_lock_init(&rxq->lock);
         INIT_LIST_HEAD(&rxq->rx_free);
@@ -4904,7 +4908,7 @@ static void ipw_rx(struct ipw_priv *priv)
 {
         struct ipw_rx_mem_buffer *rxb;
         struct ipw_rx_packet *pkt;
-        struct ieee80211_hdr *header;
+        struct ieee80211_hdr_4addr *header;
         u32 r, w, i;
         u8 network_packet;
 
@@ -4967,8 +4971,9 @@ static void ipw_rx(struct ipw_priv *priv)
 #endif
 
                                 header =
-                                    (struct ieee80211_hdr *)(rxb->skb->data +
-                                                             IPW_RX_FRAME_SIZE);
+                                    (struct ieee80211_hdr_4addr *)(rxb->skb->
+                                                                   data +
+                                                                   IPW_RX_FRAME_SIZE);
                                 /* TODO: Check Ad-Hoc dest/source and make sure
                                  * that we are actually parsing these packets
                                  * correctly -- we should probably use the
@@ -5317,8 +5322,6 @@ static int ipw_wx_set_freq(struct net_device *dev,
 
         IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
         return ipw_set_channel(priv, (u8) fwrq->m);
-
-        return 0;
 }
 
 static int ipw_wx_get_freq(struct net_device *dev,
@@ -6010,12 +6013,12 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
         }
 
         if (priv->adapter == IPW_2915ABG) {
-                priv->ieee->abg_ture = 1;
+                priv->ieee->abg_true = 1;
                 if (mode & IEEE_A) {
                         band |= IEEE80211_52GHZ_BAND;
                         modulation |= IEEE80211_OFDM_MODULATION;
                 } else
-                        priv->ieee->abg_ture = 0;
+                        priv->ieee->abg_true = 0;
         } else {
                 if (mode & IEEE_A) {
                         IPW_WARNING("Attempt to set 2200BG into "
@@ -6023,20 +6026,20 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
                         return -EINVAL;
                 }
 
-                priv->ieee->abg_ture = 0;
+                priv->ieee->abg_true = 0;
         }
 
         if (mode & IEEE_B) {
                 band |= IEEE80211_24GHZ_BAND;
                 modulation |= IEEE80211_CCK_MODULATION;
         } else
-                priv->ieee->abg_ture = 0;
+                priv->ieee->abg_true = 0;
 
         if (mode & IEEE_G) {
                 band |= IEEE80211_24GHZ_BAND;
                 modulation |= IEEE80211_OFDM_MODULATION;
         } else
-                priv->ieee->abg_ture = 0;
+                priv->ieee->abg_true = 0;
 
         priv->ieee->mode = mode;
         priv->ieee->freq_band = band;
@@ -6325,7 +6328,7 @@ we need to heavily modify the ieee80211_skb_to_txb.
 
 static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
 {
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)
+        struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
             txb->fragments[0]->data;
         int i = 0;
         struct tfd_frame *tfd;
@@ -6448,7 +6451,7 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
 }
 
 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
-                                   struct net_device *dev)
+                                   struct net_device *dev, int pri)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         unsigned long flags;
@@ -7108,7 +7111,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 printk(KERN_INFO DRV_NAME
                        ": Detected Intel PRO/Wireless 2915ABG Network "
                        "Connection\n");
-                priv->ieee->abg_ture = 1;
+                priv->ieee->abg_true = 1;
                 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
                 modulation = IEEE80211_OFDM_MODULATION |
                     IEEE80211_CCK_MODULATION;
@@ -7124,7 +7127,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                ": Detected Intel PRO/Wireless 2200BG Network "
                                "Connection\n");
 
-                priv->ieee->abg_ture = 0;
+                priv->ieee->abg_true = 0;
                 band = IEEE80211_24GHZ_BAND;
                 modulation = IEEE80211_OFDM_MODULATION |
                     IEEE80211_CCK_MODULATION;
diff --git a/drivers/net/wireless/ipw2200.h b/drivers/net/wireless/ipw2200.h
index 5b00882133f9..e9cf32bf3e31 100644
--- a/drivers/net/wireless/ipw2200.h
+++ b/drivers/net/wireless/ipw2200.h
@@ -1654,12 +1654,12 @@ static const long ipw_frequencies[] = {
 
 #define IPW_MAX_CONFIG_RETRIES 10
 
-static inline u32 frame_hdr_len(struct ieee80211_hdr *hdr)
+static inline u32 frame_hdr_len(struct ieee80211_hdr_4addr *hdr)
 {
         u32 retval;
         u16 fc;
 
-        retval = sizeof(struct ieee80211_hdr);
+        retval = sizeof(struct ieee80211_hdr_3addr);
         fc = le16_to_cpu(hdr->frame_ctl);
 
         /*
diff --git a/drivers/net/wireless/netwave_cs.c b/drivers/net/wireless/netwave_cs.c
index ca6c03c89926..92793b958e32 100644
--- a/drivers/net/wireless/netwave_cs.c
+++ b/drivers/net/wireless/netwave_cs.c
@@ -57,9 +57,7 @@
 #include <linux/bitops.h>
 #ifdef CONFIG_NET_RADIO
 #include <linux/wireless.h>
-#if WIRELESS_EXT > 12
 #include <net/iw_handler.h>
-#endif  /* WIRELESS_EXT > 12 */
 #endif
 
 #include <pcmcia/cs_types.h>
@@ -225,10 +223,7 @@ static void update_stats(struct net_device *dev);
 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
 
 /* Wireless extensions */
-#ifdef WIRELESS_EXT
 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
-#endif
-static int netwave_ioctl(struct net_device *, struct ifreq *, int);
 
 static void set_multicast_list(struct net_device *dev);
 
@@ -260,26 +255,7 @@ static dev_link_t *dev_list;
    because they generally can't be allocated dynamically.
 */
 
-#if WIRELESS_EXT <= 12
-/* Wireless extensions backward compatibility */
-
-/* Part of iw_handler prototype we need */
-struct iw_request_info
-{
-        __u16           cmd;            /* Wireless Extension command */
-        __u16           flags;          /* More to come ;-) */
-};
-
-/* Wireless Extension Backward compatibility - Jean II
- * If the new wireless device private ioctl range is not defined,
- * default to standard device private ioctl range */
-#ifndef SIOCIWFIRSTPRIV
-#define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
-#endif /* SIOCIWFIRSTPRIV */
-
-#else   /* WIRELESS_EXT <= 12 */
 static const struct iw_handler_def      netwave_handler_def;
-#endif  /* WIRELESS_EXT <= 12 */
 
 #define SIOCGIPSNAP     SIOCIWFIRSTPRIV + 1     /* Site Survey Snapshot */
 
@@ -319,9 +295,7 @@ typedef struct netwave_private {
     struct timer_list      watchdog;    /* To avoid blocking state */
     struct site_survey     nss;
     struct net_device_stats stats;
-#ifdef WIRELESS_EXT
     struct iw_statistics   iw_stats;    /* Wireless stats */
-#endif
 } netwave_private;
 
 #ifdef NETWAVE_STATS
@@ -353,7 +327,6 @@ static inline void wait_WOC(unsigned int iobase)
     while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ; 
 }
 
-#ifdef WIRELESS_EXT
 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase, 
                              kio_addr_t iobase) {
     u_short resultBuffer;
@@ -376,9 +349,7 @@ static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase,
                       sizeof(struct site_survey)); 
     } 
 }
-#endif
 
-#ifdef WIRELESS_EXT
 /*
  * Function netwave_get_wireless_stats (dev)
  *
@@ -411,7 +382,6 @@ static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
     
     return &priv->iw_stats;
 }
-#endif
 
 /*
  * Function netwave_attach (void)
@@ -471,13 +441,7 @@ static dev_link_t *netwave_attach(void)
     dev->get_stats  = &netwave_get_stats;
     dev->set_multicast_list = &set_multicast_list;
     /* wireless extensions */
-#if WIRELESS_EXT <= 16
-    dev->get_wireless_stats = &netwave_get_wireless_stats;
-#endif /* WIRELESS_EXT <= 16 */
-#if WIRELESS_EXT > 12
     dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
-#endif /* WIRELESS_EXT > 12 */
-    dev->do_ioctl = &netwave_ioctl;
 
     dev->tx_timeout = &netwave_watchdog;
     dev->watchdog_timeo = TX_TIMEOUT;
@@ -576,13 +540,8 @@ static int netwave_set_nwid(struct net_device *dev,
         /* Disable interrupts & save flags */
         spin_lock_irqsave(&priv->spinlock, flags);
 
-#if WIRELESS_EXT > 8
         if(!wrqu->nwid.disabled) {
             domain = wrqu->nwid.value;
-#else   /* WIRELESS_EXT > 8 */
-        if(wrqu->nwid.on) {
-            domain = wrqu->nwid.nwid;
-#endif  /* WIRELESS_EXT > 8 */
             printk( KERN_DEBUG "Setting domain to 0x%x%02x\n", 
                     (domain >> 8) & 0x01, domain & 0xff);
             wait_WOC(iobase);
@@ -606,15 +565,9 @@ static int netwave_get_nwid(struct net_device *dev,
                             union iwreq_data *wrqu,
                             char *extra)
 {
-#if WIRELESS_EXT > 8
         wrqu->nwid.value = domain;
         wrqu->nwid.disabled = 0;
         wrqu->nwid.fixed = 1;
-#else   /* WIRELESS_EXT > 8 */
-        wrqu->nwid.nwid = domain;
-        wrqu->nwid.on = 1;
-#endif  /* WIRELESS_EXT > 8 */
-
         return 0;
 }
 
@@ -657,17 +610,11 @@ static int netwave_get_scramble(struct net_device *dev,
 {
         key[1] = scramble_key & 0xff;
         key[0] = (scramble_key>>8) & 0xff;
-#if WIRELESS_EXT > 8
         wrqu->encoding.flags = IW_ENCODE_ENABLED;
         wrqu->encoding.length = 2;
-#else /* WIRELESS_EXT > 8 */
-        wrqu->encoding.method = 1;
-#endif  /* WIRELESS_EXT > 8 */
-
         return 0;
 }
 
-#if WIRELESS_EXT > 8
 /*
  * Wireless Handler : get mode
  */
@@ -683,7 +630,6 @@ static int netwave_get_mode(struct net_device *dev,
 
         return 0;
 }
-#endif  /* WIRELESS_EXT > 8 */
 
 /*
  * Wireless Handler : get range info
@@ -702,11 +648,9 @@ static int netwave_get_range(struct net_device *dev,
         /* Set all the info we don't care or don't know about to zero */
         memset(range, 0, sizeof(struct iw_range));
 
-#if WIRELESS_EXT > 10
         /* Set the Wireless Extension versions */
         range->we_version_compiled = WIRELESS_EXT;
         range->we_version_source = 9;   /* Nothing for us in v10 and v11 */
-#endif /* WIRELESS_EXT > 10 */
                    
         /* Set information in the range struct */
         range->throughput = 450 * 1000; /* don't argue on this ! */
@@ -720,16 +664,12 @@ static int netwave_get_range(struct net_device *dev,
         range->max_qual.level = 255;
         range->max_qual.noise = 0;
                    
-#if WIRELESS_EXT > 7
         range->num_bitrates = 1;
         range->bitrate[0] = 1000000;    /* 1 Mb/s */
-#endif /* WIRELESS_EXT > 7 */
 
-#if WIRELESS_EXT > 8
         range->encoding_size[0] = 2;            /* 16 bits scrambling */
         range->num_encoding_sizes = 1;
         range->max_encoding_tokens = 1; /* Only one key possible */
-#endif /* WIRELESS_EXT > 8 */
 
         return ret;
 }
@@ -775,8 +715,6 @@ static const struct iw_priv_args netwave_private_args[] = {
     "getsitesurvey" },
 };
 
-#if WIRELESS_EXT > 12
-
 static const iw_handler         netwave_handler[] =
 {
         NULL,                           /* SIOCSIWNAME */
@@ -839,131 +777,8 @@ static const struct iw_handler_def	netwave_handler_def =
         .standard       = (iw_handler *) netwave_handler,
         .private        = (iw_handler *) netwave_private_handler,
         .private_args   = (struct iw_priv_args *) netwave_private_args,
-#if WIRELESS_EXT > 16
         .get_wireless_stats = netwave_get_wireless_stats,
-#endif /* WIRELESS_EXT > 16 */
 };
-#endif /* WIRELESS_EXT > 12 */
-
-/*
- * Function netwave_ioctl (dev, rq, cmd)
- *
- *     Perform ioctl : config & info stuff
- *     This is the stuff that are treated the wireless extensions (iwconfig)
- *
- */
-static int netwave_ioctl(struct net_device *dev, /* ioctl device */
-                         struct ifreq *rq,       /* Data passed */
-                         int    cmd)         /* Ioctl number */
-{
-    int                 ret = 0;
-#ifdef WIRELESS_EXT
-#if WIRELESS_EXT <= 12
-    struct iwreq *wrq = (struct iwreq *) rq;
-#endif
-#endif
-        
-    DEBUG(0, "%s: ->netwave_ioctl(cmd=0x%X)\n", dev->name, cmd);
-        
-    /* Look what is the request */
-    switch(cmd) {
-        /* --------------- WIRELESS EXTENSIONS --------------- */
-#ifdef WIRELESS_EXT
-#if WIRELESS_EXT <= 12
-    case SIOCGIWNAME:
-        netwave_get_name(dev, NULL, &(wrq->u), NULL);
-        break;
-    case SIOCSIWNWID:
-        ret = netwave_set_nwid(dev, NULL, &(wrq->u), NULL);
-        break;
-    case SIOCGIWNWID:
-        ret = netwave_get_nwid(dev, NULL, &(wrq->u), NULL);
-        break;
-#if WIRELESS_EXT > 8    /* Note : The API did change... */
-    case SIOCGIWENCODE:
-        /* Get scramble key */
-        if(wrq->u.encoding.pointer != (caddr_t) 0)
-          {
-            char        key[2];
-            ret = netwave_get_scramble(dev, NULL, &(wrq->u), key);
-            if(copy_to_user(wrq->u.encoding.pointer, key, 2))
-              ret = -EFAULT;
-          }
-        break;
-    case SIOCSIWENCODE:
-        /* Set  scramble key */
-        if(wrq->u.encoding.pointer != (caddr_t) 0)
-          {
-            char        key[2];
-            if(copy_from_user(key, wrq->u.encoding.pointer, 2))
-              {
-                ret = -EFAULT;
-                break;
-              }
-            ret = netwave_set_scramble(dev, NULL, &(wrq->u), key);
-          }
-        break;
-    case SIOCGIWMODE:
-        /* Mode of operation */
-        ret = netwave_get_mode(dev, NULL, &(wrq->u), NULL);
-        break;
-#else /* WIRELESS_EXT > 8 */
-    case SIOCGIWENCODE:
-        /* Get scramble key */
-        ret = netwave_get_scramble(dev, NULL, &(wrq->u),
-                                   (char *) &wrq->u.encoding.code);
-        break;
-    case SIOCSIWENCODE:
-        /* Set  scramble key */
-        ret = netwave_set_scramble(dev, NULL, &(wrq->u),
-                                   (char *) &wrq->u.encoding.code);
-        break;
-#endif /* WIRELESS_EXT > 8 */
-   case SIOCGIWRANGE:
-       /* Basic checking... */
-       if(wrq->u.data.pointer != (caddr_t) 0) {
-           struct iw_range range;
-           ret = netwave_get_range(dev, NULL, &(wrq->u), (char *) &range);
-           if (copy_to_user(wrq->u.data.pointer, &range,
-                            sizeof(struct iw_range)))
-               ret = -EFAULT;
-       }
-       break;
-    case SIOCGIWPRIV:
-        /* Basic checking... */
-        if(wrq->u.data.pointer != (caddr_t) 0) {
-            /* Set the number of ioctl available */
-            wrq->u.data.length = sizeof(netwave_private_args) / sizeof(netwave_private_args[0]);
-                        
-            /* Copy structure to the user buffer */
-            if(copy_to_user(wrq->u.data.pointer,
-                            (u_char *) netwave_private_args,
-                            sizeof(netwave_private_args)))
-              ret = -EFAULT;
-        } 
-        break;
-    case SIOCGIPSNAP:
-        if(wrq->u.data.pointer != (caddr_t) 0) {
-            char buffer[sizeof( struct site_survey)];
-            ret = netwave_get_snap(dev, NULL, &(wrq->u), buffer);
-            /* Copy structure to the user buffer */
-            if(copy_to_user(wrq->u.data.pointer, 
-                            buffer,
-                            sizeof( struct site_survey)))
-              {
-                printk(KERN_DEBUG "Bad buffer!\n");
-                break;
-              }
-        }
-        break;
-#endif /* WIRELESS_EXT <= 12 */
-#endif /* WIRELESS_EXT */
-    default:
-        ret = -EOPNOTSUPP;
-    }
-        
-    return ret;
-}
 
 /*
  * Function netwave_pcmcia_config (link)
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index 15ceaf615756..488ab06fb79f 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -77,30 +77,16 @@
 #define DRIVER_NAME "orinoco"
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
 #include <linux/netdevice.h>
-#include <linux/if_arp.h>
 #include <linux/etherdevice.h>
 #include <linux/ethtool.h>
 #include <linux/wireless.h>
 #include <net/iw_handler.h>
 #include <net/ieee80211.h>
 
-#include <net/ieee80211.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-
-#include "hermes.h"
 #include "hermes_rid.h"
 #include "orinoco.h"
 
@@ -137,7 +123,7 @@ MODULE_PARM_DESC(force_monitor, "Allow monitor mode for all firmware versions");
 
 /* We do this this way to avoid ifdefs in the actual code */
 #ifdef WIRELESS_SPY
-#define SPY_NUMBER(priv)        (priv->spy_number)
+#define SPY_NUMBER(priv)        (priv->spy_data.spy_number)
 #else
 #define SPY_NUMBER(priv)        0
 #endif /* WIRELESS_SPY */
@@ -216,31 +202,32 @@ static struct {
 /********************************************************************/
 
 /* Used in Event handling.
- * We avoid nested structres as they break on ARM -- Moustafa */
+ * We avoid nested structures as they break on ARM -- Moustafa */
 struct hermes_tx_descriptor_802_11 {
         /* hermes_tx_descriptor */
-        u16 status;
-        u16 reserved1;
-        u16 reserved2;
-        u32 sw_support;
+        __le16 status;
+        __le16 reserved1;
+        __le16 reserved2;
+        __le32 sw_support;
         u8 retry_count;
         u8 tx_rate;
-        u16 tx_control;
+        __le16 tx_control;
 
-        /* ieee802_11_hdr */
-        u16 frame_ctl;
-        u16 duration_id;
+        /* ieee80211_hdr */
+        __le16 frame_ctl;
+        __le16 duration_id;
         u8 addr1[ETH_ALEN];
         u8 addr2[ETH_ALEN];
         u8 addr3[ETH_ALEN];
-        u16 seq_ctl;
+        __le16 seq_ctl;
         u8 addr4[ETH_ALEN];
-        u16 data_len;
+
+        __le16 data_len;
 
         /* ethhdr */
-        unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
-        unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
-        unsigned short  h_proto;                /* packet type ID field */
+        u8 h_dest[ETH_ALEN];    /* destination eth addr */
+        u8 h_source[ETH_ALEN];  /* source ether addr    */
+        __be16 h_proto;         /* packet type ID field */
 
         /* p8022_hdr */
         u8 dsap;
@@ -248,31 +235,31 @@ struct hermes_tx_descriptor_802_11 {
         u8 ctrl;
         u8 oui[3];
 
-        u16 ethertype;
+        __be16 ethertype;
 } __attribute__ ((packed));
 
 /* Rx frame header except compatibility 802.3 header */
 struct hermes_rx_descriptor {
         /* Control */
-        u16 status;
-        u32 time;
+        __le16 status;
+        __le32 time;
         u8 silence;
         u8 signal;
         u8 rate;
         u8 rxflow;
-        u32 reserved;
+        __le32 reserved;
 
         /* 802.11 header */
-        u16 frame_ctl;
-        u16 duration_id;
+        __le16 frame_ctl;
+        __le16 duration_id;
         u8 addr1[ETH_ALEN];
         u8 addr2[ETH_ALEN];
         u8 addr3[ETH_ALEN];
-        u16 seq_ctl;
+        __le16 seq_ctl;
         u8 addr4[ETH_ALEN];
 
         /* Data length */
-        u16 data_len;
+        __le16 data_len;
 } __attribute__ ((packed));
 
 /********************************************************************/
@@ -396,14 +383,14 @@ static struct iw_statistics *orinoco_get_wireless_stats(struct net_device *dev)
                 /* If a spy address is defined, we report stats of the
                  * first spy address - Jean II */
                 if (SPY_NUMBER(priv)) {
-                        wstats->qual.qual = priv->spy_stat[0].qual;
-                        wstats->qual.level = priv->spy_stat[0].level;
-                        wstats->qual.noise = priv->spy_stat[0].noise;
-                        wstats->qual.updated = priv->spy_stat[0].updated;
+                        wstats->qual.qual = priv->spy_data.spy_stat[0].qual;
+                        wstats->qual.level = priv->spy_data.spy_stat[0].level;
+                        wstats->qual.noise = priv->spy_data.spy_stat[0].noise;
+                        wstats->qual.updated = priv->spy_data.spy_stat[0].updated;
                 }
         } else {
                 struct {
-                        u16 qual, signal, noise;
+                        __le16 qual, signal, noise;
                 } __attribute__ ((packed)) cq;
 
                 err = HERMES_READ_RECORD(hw, USER_BAP,
@@ -503,13 +490,12 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                 return 0;
         }
 
-        /* Check packet length, pad short packets, round up odd length */
+        /* Length of the packet body */
+        /* FIXME: what if the skb is smaller than this? */
         len = max_t(int, ALIGN(skb->len, 2), ETH_ZLEN);
-        if (skb->len < len) {
-                skb = skb_padto(skb, len);
-                if (skb == NULL)
-                        goto fail;
-        }
+        skb = skb_padto(skb, len);
+        if (skb == NULL)
+                goto fail;
         len -= ETH_HLEN;
 
         eh = (struct ethhdr *)skb->data;
@@ -556,13 +542,21 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                         stats->tx_errors++;
                         goto fail;
                 }
+                /* Actual xfer length - allow for padding */
+                len = ALIGN(data_len, 2);
+                if (len < ETH_ZLEN - ETH_HLEN)
+                        len = ETH_ZLEN - ETH_HLEN;
         } else { /* IEEE 802.3 frame */
                 data_len = len + ETH_HLEN;
                 data_off = HERMES_802_3_OFFSET;
                 p = skb->data;
+                /* Actual xfer length - round up for odd length packets */
+                len = ALIGN(data_len, 2);
+                if (len < ETH_ZLEN)
+                        len = ETH_ZLEN;
         }
 
-        err = hermes_bap_pwrite(hw, USER_BAP, p, data_len,
+        err = hermes_bap_pwrite_pad(hw, USER_BAP, p, data_len, len,
                                 txfid, data_off);
         if (err) {
                 printk(KERN_ERR "%s: Error %d writing packet to BAP\n",
@@ -634,16 +628,17 @@ static void __orinoco_ev_txexc(struct net_device *dev, hermes_t *hw)
         struct orinoco_private *priv = netdev_priv(dev);
         struct net_device_stats *stats = &priv->stats;
         u16 fid = hermes_read_regn(hw, TXCOMPLFID);
+        u16 status;
         struct hermes_tx_descriptor_802_11 hdr;
         int err = 0;
 
         if (fid == DUMMY_FID)
                 return; /* Nothing's really happened */
 
-        /* Read the frame header */
+        /* Read part of the frame header - we need status and addr1 */
         err = hermes_bap_pread(hw, IRQ_BAP, &hdr,
-                               sizeof(struct hermes_tx_descriptor) +
-                               sizeof(struct ieee80211_hdr),
+                               offsetof(struct hermes_tx_descriptor_802_11,
+                                        addr2),
                                fid, 0);
 
         hermes_write_regn(hw, TXCOMPLFID, DUMMY_FID);
@@ -663,8 +658,8 @@ static void __orinoco_ev_txexc(struct net_device *dev, hermes_t *hw)
          * exceeded, because that's the only status that really mean
          * that this particular node went away.
          * Other errors means that *we* screwed up. - Jean II */
-        hdr.status = le16_to_cpu(hdr.status);
-        if (hdr.status & (HERMES_TXSTAT_RETRYERR | HERMES_TXSTAT_AGEDERR)) {
+        status = le16_to_cpu(hdr.status);
+        if (status & (HERMES_TXSTAT_RETRYERR | HERMES_TXSTAT_AGEDERR)) {
                 union iwreq_data        wrqu;
 
                 /* Copy 802.11 dest address.
@@ -723,18 +718,13 @@ static inline int is_ethersnap(void *_hdr)
 static inline void orinoco_spy_gather(struct net_device *dev, u_char *mac,
                                       int level, int noise)
 {
-        struct orinoco_private *priv = netdev_priv(dev);
-        int i;
-
-        /* Gather wireless spy statistics: for each packet, compare the
-         * source address with out list, and if match, get the stats... */
-        for (i = 0; i < priv->spy_number; i++)
-                if (!memcmp(mac, priv->spy_address[i], ETH_ALEN)) {
-                        priv->spy_stat[i].level = level - 0x95;
-                        priv->spy_stat[i].noise = noise - 0x95;
-                        priv->spy_stat[i].qual = (level > noise) ? (level - noise) : 0;
-                        priv->spy_stat[i].updated = 7;
-                }
+        struct iw_quality wstats;
+        wstats.level = level - 0x95;
+        wstats.noise = noise - 0x95;
+        wstats.qual = (level > noise) ? (level - noise) : 0;
+        wstats.updated = 7;
+        /* Update spy records */
+        wireless_spy_update(dev, mac, &wstats);
 }
 
 static void orinoco_stat_gather(struct net_device *dev,
@@ -1055,7 +1045,7 @@ static void orinoco_join_ap(struct net_device *dev)
         unsigned long flags;
         struct join_req {
                 u8 bssid[ETH_ALEN];
-                u16 channel;
+                __le16 channel;
         } __attribute__ ((packed)) req;
         const int atom_len = offsetof(struct prism2_scan_apinfo, atim);
         struct prism2_scan_apinfo *atom = NULL;
@@ -1070,7 +1060,7 @@ static void orinoco_join_ap(struct net_device *dev)
                 return;
 
         if (orinoco_lock(priv, &flags) != 0)
-                goto out;
+                goto fail_lock;
 
         /* Sanity checks in case user changed something in the meantime */
         if (! priv->bssid_fixed)
@@ -1115,8 +1105,10 @@ static void orinoco_join_ap(struct net_device *dev)
                 printk(KERN_ERR "%s: Error issuing join request\n", dev->name);
 
  out:
-        kfree(buf);
         orinoco_unlock(priv, &flags);
+
+ fail_lock:
+        kfree(buf);
 }
 
 /* Send new BSSID to userspace */
@@ -1134,12 +1126,14 @@ static void orinoco_send_wevents(struct net_device *dev)
         err = hermes_read_ltv(hw, IRQ_BAP, HERMES_RID_CURRENTBSSID,
                               ETH_ALEN, NULL, wrqu.ap_addr.sa_data);
         if (err != 0)
-                return;
+                goto out;
 
         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 
         /* Send event to user space */
         wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+
+ out:
         orinoco_unlock(priv, &flags);
 }
 
@@ -1148,8 +1142,8 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
         struct orinoco_private *priv = netdev_priv(dev);
         u16 infofid;
         struct {
-                u16 len;
-                u16 type;
+                __le16 len;
+                __le16 type;
         } __attribute__ ((packed)) info;
         int len, type;
         int err;
@@ -2464,6 +2458,10 @@ struct net_device *alloc_orinocodev(int sizeof_card,
         dev->get_stats = orinoco_get_stats;
         dev->ethtool_ops = &orinoco_ethtool_ops;
         dev->wireless_handlers = (struct iw_handler_def *)&orinoco_handler_def;
+#ifdef WIRELESS_SPY
+        priv->wireless_data.spy_data = &priv->spy_data;
+        dev->wireless_data = &priv->wireless_data;
+#endif
         dev->change_mtu = orinoco_change_mtu;
         dev->set_multicast_list = orinoco_set_multicast_list;
         /* we use the default eth_mac_addr for setting the MAC addr */
@@ -2835,7 +2833,7 @@ static int orinoco_ioctl_getiwrange(struct net_device *dev,
                 }
         }
 
-        if ((priv->iw_mode == IW_MODE_ADHOC) && (priv->spy_number == 0)){
+        if ((priv->iw_mode == IW_MODE_ADHOC) && (!SPY_NUMBER(priv))){
                 /* Quality stats meaningless in ad-hoc mode */
         } else {
                 range->max_qual.qual = 0x8b - 0x2f;
@@ -2882,6 +2880,14 @@ static int orinoco_ioctl_getiwrange(struct net_device *dev,
         range->min_r_time = 0;
         range->max_r_time = 65535 * 1000;       /* ??? */
 
+        /* Event capability (kernel) */
+        IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
+        /* Event capability (driver) */
+        IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY);
+        IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
+        IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
+        IW_EVENT_CAPA_SET(range->event_capa, IWEVTXDROP);
+
         TRACE_EXIT(dev->name);
 
         return 0;
@@ -3841,92 +3847,6 @@ static int orinoco_ioctl_getrid(struct net_device *dev,
         return err;
 }
 
-/* Spy is used for link quality/strength measurements in Ad-Hoc mode
- * Jean II */
-static int orinoco_ioctl_setspy(struct net_device *dev,
-                                struct iw_request_info *info,
-                                struct iw_point *srq,
-                                char *extra)
-
-{
-        struct orinoco_private *priv = netdev_priv(dev);
-        struct sockaddr *address = (struct sockaddr *) extra;
-        int number = srq->length;
-        int i;
-        unsigned long flags;
-
-        /* Make sure nobody mess with the structure while we do */
-        if (orinoco_lock(priv, &flags) != 0)
-                return -EBUSY;
-
-        /* orinoco_lock() doesn't disable interrupts, so make sure the
-         * interrupt rx path don't get confused while we copy */
-        priv->spy_number = 0;
-
-        if (number > 0) {
-                /* Extract the addresses */
-                for (i = 0; i < number; i++)
-                        memcpy(priv->spy_address[i], address[i].sa_data,
-                               ETH_ALEN);
-                /* Reset stats */
-                memset(priv->spy_stat, 0,
-                       sizeof(struct iw_quality) * IW_MAX_SPY);
-                /* Set number of addresses */
-                priv->spy_number = number;
-        }
-
-        /* Now, let the others play */
-        orinoco_unlock(priv, &flags);
-
-        /* Do NOT call commit handler */
-        return 0;
-}
-
-static int orinoco_ioctl_getspy(struct net_device *dev,
-                                struct iw_request_info *info,
-                                struct iw_point *srq,
-                                char *extra)
-{
-        struct orinoco_private *priv = netdev_priv(dev);
-        struct sockaddr *address = (struct sockaddr *) extra;
-        int number;
-        int i;
-        unsigned long flags;
-
-        if (orinoco_lock(priv, &flags) != 0)
-                return -EBUSY;
-
-        number = priv->spy_number;
-        /* Create address struct */
-        for (i = 0; i < number; i++) {
-                memcpy(address[i].sa_data, priv->spy_address[i], ETH_ALEN);
-                address[i].sa_family = AF_UNIX;
-        }
-        if (number > 0) {
-                /* Create address struct */
-                for (i = 0; i < number; i++) {
-                        memcpy(address[i].sa_data, priv->spy_address[i],
-                               ETH_ALEN);
-                        address[i].sa_family = AF_UNIX;
-                }
-                /* Copy stats */
-                /* In theory, we should disable irqs while copying the stats
-                 * because the rx path might update it in the middle...
-                 * Bah, who care ? - Jean II */
-                memcpy(extra  + (sizeof(struct sockaddr) * number),
-                       priv->spy_stat, sizeof(struct iw_quality) * number);
-        }
-        /* Reset updated flags. */
-        for (i = 0; i < number; i++)
-                priv->spy_stat[i].updated = 0;
-
-        orinoco_unlock(priv, &flags);
-
-        srq->length = number;
-
-        return 0;
-}
-
 /* Trigger a scan (look for other cells in the vicinity */
 static int orinoco_ioctl_setscan(struct net_device *dev,
                                  struct iw_request_info *info,
@@ -3999,7 +3919,7 @@ static int orinoco_ioctl_setscan(struct net_device *dev,
                                                    HERMES_HOSTSCAN_SYMBOL_BCAST);
                         break;
                 case FIRMWARE_TYPE_INTERSIL: {
-                        u16 req[3];
+                        __le16 req[3];
 
                         req[0] = cpu_to_le16(0x3fff);   /* All channels */
                         req[1] = cpu_to_le16(0x0001);   /* rate 1 Mbps */
@@ -4073,7 +3993,7 @@ static inline int orinoco_translate_scan(struct net_device *dev,
         case FIRMWARE_TYPE_INTERSIL:
                 offset = 4;
                 if (priv->has_hostscan) {
-                        atom_len = le16_to_cpup((u16 *)scan);
+                        atom_len = le16_to_cpup((__le16 *)scan);
                         /* Sanity check for atom_len */
                         if (atom_len < sizeof(struct prism2_scan_apinfo)) {
                                 printk(KERN_ERR "%s: Invalid atom_len in scan data: %d\n",
@@ -4357,8 +4277,10 @@ static const iw_handler	orinoco_handler[] = {
         [SIOCSIWSENS  -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_setsens,
         [SIOCGIWSENS  -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_getsens,
         [SIOCGIWRANGE -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_getiwrange,
-        [SIOCSIWSPY   -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_setspy,
-        [SIOCGIWSPY   -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_getspy,
+        [SIOCSIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_set_spy,
+        [SIOCGIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_get_spy,
+        [SIOCSIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_set_thrspy,
+        [SIOCGIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_get_thrspy,
         [SIOCSIWAP    -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_setwap,
         [SIOCGIWAP    -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_getwap,
         [SIOCSIWSCAN  -SIOCIWFIRST] = (iw_handler) orinoco_ioctl_setscan,
diff --git a/drivers/net/wireless/orinoco.h b/drivers/net/wireless/orinoco.h
index 2f213a7103fe..7a17bb31fc89 100644
--- a/drivers/net/wireless/orinoco.h
+++ b/drivers/net/wireless/orinoco.h
@@ -7,12 +7,11 @@
 #ifndef _ORINOCO_H
 #define _ORINOCO_H
 
-#define DRIVER_VERSION "0.15rc2"
+#define DRIVER_VERSION "0.15rc3"
 
-#include <linux/types.h>
-#include <linux/spinlock.h>
 #include <linux/netdevice.h>
 #include <linux/wireless.h>
+#include <net/iw_handler.h>
 #include <linux/version.h>
 
 #include "hermes.h"
@@ -28,7 +27,7 @@
 #define ORINOCO_MAX_KEYS        4
 
 struct orinoco_key {
-        u16 len;        /* always stored as little-endian */
+        __le16 len;     /* always stored as little-endian */
         char data[ORINOCO_MAX_KEY_SIZE];
 } __attribute__ ((packed));
 
@@ -36,14 +35,14 @@ struct header_struct {
         /* 802.3 */
         u8 dest[ETH_ALEN];
         u8 src[ETH_ALEN];
-        u16 len;
+        __be16 len;
         /* 802.2 */
         u8 dsap;
         u8 ssap;
         u8 ctrl;
         /* SNAP */
         u8 oui[3];
-        u16 ethertype;
+        unsigned short ethertype;
 } __attribute__ ((packed));
 
 typedef enum {
@@ -112,9 +111,8 @@ struct orinoco_private {
         u16 pm_on, pm_mcast, pm_period, pm_timeout;
         u16 preamble;
 #ifdef WIRELESS_SPY
-        int                     spy_number;
-        u_char                  spy_address[IW_MAX_SPY][ETH_ALEN];
-        struct iw_quality       spy_stat[IW_MAX_SPY];
+        struct iw_spy_data spy_data; /* iwspy support */
+        struct iw_public_data   wireless_data;
 #endif
 
         /* Configuration dependent variables */
diff --git a/drivers/net/wireless/orinoco_cs.c b/drivers/net/wireless/orinoco_cs.c
index bedd7f9f23e4..dc1128a00971 100644
--- a/drivers/net/wireless/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco_cs.c
@@ -14,33 +14,16 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-#ifdef  __IN_PCMCIA_PACKAGE__
-#include <pcmcia/k_compat.h>
-#endif /* __IN_PCMCIA_PACKAGE__ */
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/ioport.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/wireless.h>
-
+#include <linux/delay.h>
 #include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
 
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-
 #include "orinoco.h"
 
 /********************************************************************/
@@ -97,17 +80,8 @@ static dev_link_t *dev_list; /* = NULL */
 /* Function prototypes                                              */
 /********************************************************************/
 
-/* device methods */
-static int orinoco_cs_hard_reset(struct orinoco_private *priv);
-
-/* PCMCIA gumpf */
-static void orinoco_cs_config(dev_link_t * link);
-static void orinoco_cs_release(dev_link_t * link);
-static int orinoco_cs_event(event_t event, int priority,
-                            event_callback_args_t * args);
-
-static dev_link_t *orinoco_cs_attach(void);
-static void orinoco_cs_detach(dev_link_t *);
+static void orinoco_cs_release(dev_link_t *link);
+static void orinoco_cs_detach(dev_link_t *link);
 
 /********************************************************************/
 /* Device methods                                                   */
@@ -603,49 +577,85 @@ static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
         "Pavel Roskin <proski@gnu.org>, et al)";
 
 static struct pcmcia_device_id orinoco_cs_ids[] = {
-        PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7300),
-        PCMCIA_DEVICE_MANF_CARD(0x0138, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x0156, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x01eb, 0x080a),
-        PCMCIA_DEVICE_MANF_CARD(0x0261, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0001),
-        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0305),
-        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1613),
-        PCMCIA_DEVICE_MANF_CARD(0x028a, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x028a, 0x0673),
-        PCMCIA_DEVICE_MANF_CARD(0x02aa, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x02ac, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0x14ea, 0xb001),
-        PCMCIA_DEVICE_MANF_CARD(0x50c2, 0x7300),
-        PCMCIA_DEVICE_MANF_CARD(0x9005, 0x0021),
-        PCMCIA_DEVICE_MANF_CARD(0xc250, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0002),
-        PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0005),
+        PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7100), /* SonicWALL Long Range Wireless Card */
+        PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7300), /* Sohoware NCP110, Philips 802.11b */
+        PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0002), /* AnyPoint(TM) Wireless II PC Card */
+        PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0777), /* 3Com AirConnect PCI 777A */
+        PCMCIA_DEVICE_MANF_CARD(0x0126, 0x8000), /* PROXIM RangeLAN-DS/LAN PC CARD */
+        PCMCIA_DEVICE_MANF_CARD(0x0138, 0x0002), /* Compaq WL100 11 Mbps Wireless Adapter */
+        PCMCIA_DEVICE_MANF_CARD(0x0156, 0x0002), /* Lucent Orinoco and old Intersil */
+        PCMCIA_DEVICE_MANF_CARD(0x016b, 0x0001), /* Ericsson WLAN Card C11 */
+        PCMCIA_DEVICE_MANF_CARD(0x01eb, 0x080a), /* Nortel Networks eMobility 802.11 Wireless Adapter */
+        PCMCIA_DEVICE_MANF_CARD(0x01ff, 0x0008), /* Intermec MobileLAN 11Mbps 802.11b WLAN Card */
+        PCMCIA_DEVICE_MANF_CARD(0x0250, 0x0002), /* Samsung SWL2000-N 11Mb/s WLAN Card */
+        PCMCIA_DEVICE_MANF_CARD(0x0261, 0x0002), /* AirWay 802.11 Adapter (PCMCIA) */
+        PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0001), /* ARtem Onair */
+        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0305), /* Buffalo WLI-PCM-S11 */
+        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1612), /* Linksys WPC11 Version 2.5 */
+        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1613), /* Linksys WPC11 Version 3 */
+        PCMCIA_DEVICE_MANF_CARD(0x028a, 0x0002), /* Compaq HNW-100 11 Mbps Wireless Adapter */
+        PCMCIA_DEVICE_MANF_CARD(0x028a, 0x0673), /* Linksys WCF12 Wireless CompactFlash Card */
+        PCMCIA_DEVICE_MANF_CARD(0x02aa, 0x0002), /* ASUS SpaceLink WL-100 */
+        PCMCIA_DEVICE_MANF_CARD(0x02ac, 0x0002), /* SpeedStream SS1021 Wireless Adapter */
+        PCMCIA_DEVICE_MANF_CARD(0x14ea, 0xb001), /* PLANEX RoadLannerWave GW-NS11H */
+        PCMCIA_DEVICE_MANF_CARD(0x50c2, 0x7300), /* Airvast WN-100 */
+        PCMCIA_DEVICE_MANF_CARD(0x9005, 0x0021), /* Adaptec Ultra Wireless ANW-8030 */
+        PCMCIA_DEVICE_MANF_CARD(0xc001, 0x0008), /* CONTEC FLEXSCAN/FX-DDS110-PCC */
+        PCMCIA_DEVICE_MANF_CARD(0xc250, 0x0002), /* Conceptronic CON11Cpro, EMTAC A2424i */
+        PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0002), /* Safeway 802.11b, ZCOMAX AirRunner/XI-300 */
+        PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0005), /* D-Link DCF660, Sandisk Connect SDWCFB-000 */
+        PCMCIA_DEVICE_PROD_ID12(" ", "IEEE 802.11 Wireless LAN/PC Card", 0x3b6e20c8, 0xefccafe9),
         PCMCIA_DEVICE_PROD_ID12("3Com", "3CRWE737A AirConnect Wireless LAN PC Card", 0x41240e5b, 0x56010af3),
-        PCMCIA_DEVICE_PROD_ID123("Instant Wireless ", " Network PC CARD", "Version 01.02", 0x11d901af, 0x6e9bd926, 0x4b74baa0),
         PCMCIA_DEVICE_PROD_ID12("ACTIONTEC", "PRISM Wireless LAN PC Card", 0x393089da, 0xa71e69d5),
+        PCMCIA_DEVICE_PROD_ID12("Addtron", "AWP-100 Wireless PCMCIA", 0xe6ec52ce, 0x08649af2),
+        PCMCIA_DEVICE_PROD_ID123("AIRVAST", "IEEE 802.11b Wireless PCMCIA Card", "HFA3863", 0xea569531, 0x4bcb9645, 0x355cb092),
+        PCMCIA_DEVICE_PROD_ID12("Allied Telesyn", "AT-WCL452 Wireless PCMCIA Radio", 0x5cd01705, 0x4271660f),
+        PCMCIA_DEVICE_PROD_ID12("ASUS", "802_11b_PC_CARD_25", 0x78fc06ee, 0xdb9aa842),
+        PCMCIA_DEVICE_PROD_ID12("ASUS", "802_11B_CF_CARD_25", 0x78fc06ee, 0x45a50c1e),
         PCMCIA_DEVICE_PROD_ID12("Avaya Communication", "Avaya Wireless PC Card", 0xd8a43b78, 0x0d341169),
+        PCMCIA_DEVICE_PROD_ID12("BENQ", "AWL100 PCMCIA ADAPTER", 0x35dadc74, 0x01f7fedb),
         PCMCIA_DEVICE_PROD_ID12("BUFFALO", "WLI-PCM-L11G", 0x2decece3, 0xf57ca4b3),
+        PCMCIA_DEVICE_PROD_ID12("BUFFALO", "WLI-CF-S11G", 0x2decece3, 0x82067c18),
         PCMCIA_DEVICE_PROD_ID12("Cabletron", "RoamAbout 802.11 DS", 0x32d445f5, 0xedeffd90),
+        PCMCIA_DEVICE_PROD_ID12("Compaq", "WL200_11Mbps_Wireless_PCI_Card", 0x54f7c49c, 0x15a75e5b),
+        PCMCIA_DEVICE_PROD_ID123("corega", "WL PCCL-11", "ISL37300P", 0x0a21501a, 0x59868926, 0xc9049a39),
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "Wireless LAN PCC-11", 0x5261440f, 0xa6405584),
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "Wireless LAN PCCA-11", 0x5261440f, 0xdf6115f9),
         PCMCIA_DEVICE_PROD_ID12("corega_K.K.", "Wireless_LAN_PCCB-11", 0x29e33311, 0xee7a27ae),
         PCMCIA_DEVICE_PROD_ID12("D", "Link DRC-650 11Mbps WLAN Card", 0x71b18589, 0xf144e3ac),
         PCMCIA_DEVICE_PROD_ID12("D", "Link DWL-650 11Mbps WLAN Card", 0x71b18589, 0xb6f1b0ab),
+        PCMCIA_DEVICE_PROD_ID12("D-Link Corporation", "D-Link DWL-650H 11Mbps WLAN Adapter", 0xef544d24, 0xcd8ea916),
+        PCMCIA_DEVICE_PROD_ID12("Digital Data Communications", "WPC-0100", 0xfdd73470, 0xe0b6f146),
         PCMCIA_DEVICE_PROD_ID12("ELSA", "AirLancer MC-11", 0x4507a33a, 0xef54f0e3),
         PCMCIA_DEVICE_PROD_ID12("HyperLink", "Wireless PC Card 11Mbps", 0x56cc3f1a, 0x0bcf220c),
+        PCMCIA_DEVICE_PROD_ID123("Instant Wireless ", " Network PC CARD", "Version 01.02", 0x11d901af, 0x6e9bd926, 0x4b74baa0),
+        PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless 2011 LAN PC Card", 0x816cc815, 0x07f58077),
         PCMCIA_DEVICE_PROD_ID12("INTERSIL", "HFA384x/IEEE", 0x74c5e40d, 0xdb472a18),
+        PCMCIA_DEVICE_PROD_ID12("INTERSIL", "I-GATE 11M PC Card / PC Card plus", 0x74c5e40d, 0x8304ff77),
+        PCMCIA_DEVICE_PROD_ID12("Intersil", "PRISM 2_5 PCMCIA ADAPTER", 0x4b801a17, 0x6345a0bf),
+        PCMCIA_DEVICE_PROD_ID123("Intersil", "PRISM Freedom PCMCIA Adapter", "ISL37100P", 0x4b801a17, 0xf222ec2d, 0x630d52b2),
+        PCMCIA_DEVICE_PROD_ID12("LeArtery", "SYNCBYAIR 11Mbps Wireless LAN PC Card", 0x7e3b326a, 0x49893e92),
+        PCMCIA_DEVICE_PROD_ID12("Linksys", "Wireless CompactFlash Card", 0x0733cc81, 0x0c52f395),
         PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/IEEE", 0x23eb9949, 0xc562e72a),
         PCMCIA_DEVICE_PROD_ID12("MELCO", "WLI-PCM-L11", 0x481e0094, 0x7360e410),
         PCMCIA_DEVICE_PROD_ID12("MELCO", "WLI-PCM-L11G", 0x481e0094, 0xf57ca4b3),
         PCMCIA_DEVICE_PROD_ID12("Microsoft", "Wireless Notebook Adapter MN-520", 0x5961bf85, 0x6eec8c01),
         PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/IEEE", 0x24358cd4, 0xc562e72a),
+        PCMCIA_DEVICE_PROD_ID12("NETGEAR MA401 Wireless PC", "Card", 0xa37434e9, 0x9762e8f1),
         PCMCIA_DEVICE_PROD_ID12("NETGEAR MA401RA Wireless PC", "Card", 0x0306467f, 0x9762e8f1),
+        PCMCIA_DEVICE_PROD_ID12("Nortel Networks", "emobility 802.11 Wireless LAN PC Card", 0x2d617ea0, 0x88cd5767),
+        PCMCIA_DEVICE_PROD_ID12("OEM", "PRISM2 IEEE 802.11 PC-Card", 0xfea54c90, 0x48f2bdd6),
+        PCMCIA_DEVICE_PROD_ID12("OTC", "Wireless AirEZY 2411-PCC WLAN Card", 0x4ac44287, 0x235a6bed),
+        PCMCIA_DEVICE_PROD_ID123("PCMCIA", "11M WLAN Card v2.5", "ISL37300P", 0x281f1c5d, 0x6e440487, 0xc9049a39),
         PCMCIA_DEVICE_PROD_ID12("PLANEX", "GeoWave/GW-CF110", 0x209f40ab, 0xd9715264),
+        PCMCIA_DEVICE_PROD_ID12("PLANEX", "GeoWave/GW-NS110", 0x209f40ab, 0x46263178),
         PCMCIA_DEVICE_PROD_ID12("PROXIM", "LAN PC CARD HARMONY 80211B", 0xc6536a5e, 0x090c3cd9),
         PCMCIA_DEVICE_PROD_ID12("PROXIM", "LAN PCI CARD HARMONY 80211B", 0xc6536a5e, 0x9f494e26),
         PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "11Mbps WLAN Card", 0x43d74cb4, 0x579bd91b),
-        PCMCIA_DEVICE_PROD_ID1("Symbol Technologies", 0x3f02b4d6),
+        PCMCIA_DEVICE_PROD_ID12("SMC", "SMC2632W", 0xc4f8b18b, 0x474a1f2a),
+        PCMCIA_DEVICE_PROD_ID12("Symbol Technologies", "LA4111 Spectrum24 Wireless LAN PC Card", 0x3f02b4d6, 0x3663cb0e),
+        PCMCIA_DEVICE_PROD_ID123("The Linksys Group, Inc.", "Instant Wireless Network PC Card", "ISL37300P", 0xa5f472c2, 0x590eb502, 0xc9049a39),
+        PCMCIA_DEVICE_PROD_ID12("ZoomAir 11Mbps High", "Rate wireless Networking", 0x273fe3db, 0x32a1eaee),
         PCMCIA_DEVICE_NULL,
 };
 MODULE_DEVICE_TABLE(pcmcia, orinoco_cs_ids);
@@ -656,8 +666,8 @@ static struct pcmcia_driver orinoco_driver = {
                 .name   = DRIVER_NAME,
         },
         .attach         = orinoco_cs_attach,
-        .event          = orinoco_cs_event,
         .detach         = orinoco_cs_detach,
+        .event          = orinoco_cs_event,
         .id_table       = orinoco_cs_ids,
 };
 
diff --git a/drivers/net/wireless/orinoco_nortel.c b/drivers/net/wireless/orinoco_nortel.c
index 86fa58e5cfac..d8afd51ff8a5 100644
--- a/drivers/net/wireless/orinoco_nortel.c
+++ b/drivers/net/wireless/orinoco_nortel.c
@@ -40,29 +40,13 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 #include <linux/pci.h>
-#include <linux/fcntl.h>
-
 #include <pcmcia/cisreg.h>
 
-#include "hermes.h"
 #include "orinoco.h"
 
 #define COR_OFFSET    (0xe0)    /* COR attribute offset of Prism2 PC card */
@@ -108,7 +92,7 @@ static int nortel_pci_cor_reset(struct orinoco_private *priv)
         return 0;
 }
 
-int nortel_pci_hw_init(struct nortel_pci_card *card)
+static int nortel_pci_hw_init(struct nortel_pci_card *card)
 {
         int i;
         u32 reg;
diff --git a/drivers/net/wireless/orinoco_pci.c b/drivers/net/wireless/orinoco_pci.c
index 42e03438291b..5362c214fc8e 100644
--- a/drivers/net/wireless/orinoco_pci.c
+++ b/drivers/net/wireless/orinoco_pci.c
@@ -93,28 +93,12 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 #include <linux/pci.h>
-#include <linux/fcntl.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
 
-#include "hermes.h"
 #include "orinoco.h"
 
 /* All the magic there is from wlan-ng */
diff --git a/drivers/net/wireless/orinoco_plx.c b/drivers/net/wireless/orinoco_plx.c
index 7ab05b89fb3f..210e73776545 100644
--- a/drivers/net/wireless/orinoco_plx.c
+++ b/drivers/net/wireless/orinoco_plx.c
@@ -117,29 +117,13 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 #include <linux/pci.h>
-#include <linux/fcntl.h>
-
 #include <pcmcia/cisreg.h>
 
-#include "hermes.h"
 #include "orinoco.h"
 
 #define COR_OFFSET      (0x3e0) /* COR attribute offset of Prism2 PC card */
diff --git a/drivers/net/wireless/orinoco_tmd.c b/drivers/net/wireless/orinoco_tmd.c
index 85893f42445b..5e68b7026186 100644
--- a/drivers/net/wireless/orinoco_tmd.c
+++ b/drivers/net/wireless/orinoco_tmd.c
@@ -53,29 +53,13 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ioport.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 #include <linux/pci.h>
-#include <linux/fcntl.h>
-
 #include <pcmcia/cisreg.h>
 
-#include "hermes.h"
 #include "orinoco.h"
 
 #define COR_VALUE       (COR_LEVEL_REQ | COR_FUNC_ENA) /* Enable PC card with interrupt in level trigger */
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index 9a8790e3580c..5c1a1adf1ff8 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -462,14 +462,12 @@ prism54_get_range(struct net_device *ndev, struct iw_request_info *info,
         /* txpower is supported in dBm's */
         range->txpower_capa = IW_TXPOW_DBM;
 
-#if WIRELESS_EXT > 16
         /* Event capability (kernel + driver) */
         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
         IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
         IW_EVENT_CAPA_MASK(SIOCGIWAP));
         range->event_capa[1] = IW_EVENT_CAPA_K_1;
         range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVCUSTOM);
-#endif /* WIRELESS_EXT > 16 */
 
         if (islpci_get_state(priv) < PRV_STATE_INIT)
                 return 0;
@@ -693,14 +691,13 @@ prism54_get_scan(struct net_device *ndev, struct iw_request_info *info,
                                                    extra + dwrq->length,
                                                    &(bsslist->bsslist[i]),
                                                    noise);
-#if WIRELESS_EXT > 16
+
                 /* Check if there is space for one more entry */
                 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
                         /* Ask user space to try again with a bigger buffer */
                         rvalue = -E2BIG;
                         break;
                 }
-#endif /* WIRELESS_EXT > 16 */
         }
 
         kfree(bsslist);
@@ -2727,12 +2724,7 @@ const struct iw_handler_def prism54_handler_def = {
         .standard = (iw_handler *) prism54_handler,
         .private = (iw_handler *) prism54_private_handler,
         .private_args = (struct iw_priv_args *) prism54_private_args,
-#if WIRELESS_EXT > 16
         .get_wireless_stats = prism54_get_wireless_stats,
-#endif /* WIRELESS_EXT > 16 */
-#if WIRELESS_EXT == 16
-        .spy_offset = offsetof(islpci_private, spy_data),
-#endif /* WIRELESS_EXT == 16 */
 };
 
 /* For wpa_supplicant */
diff --git a/drivers/net/wireless/prism54/islpci_dev.c b/drivers/net/wireless/prism54/islpci_dev.c
index 6f13d4a8e2d3..78bdb359835e 100644
--- a/drivers/net/wireless/prism54/islpci_dev.c
+++ b/drivers/net/wireless/prism54/islpci_dev.c
@@ -439,8 +439,7 @@ prism54_bring_down(islpci_private *priv)
         wmb();
 
         /* wait a while for the device to reset */
-        set_current_state(TASK_UNINTERRUPTIBLE);
-        schedule_timeout(50*HZ/1000);
+        schedule_timeout_uninterruptible(msecs_to_jiffies(50));
 
         return 0;
 }
@@ -491,8 +490,7 @@ islpci_reset_if(islpci_private *priv)
                 /* The software reset acknowledge needs about 220 msec here.
                  * Be conservative and wait for up to one second. */
         
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                remaining = schedule_timeout(HZ);
+                remaining = schedule_timeout_uninterruptible(HZ);
 
                 if(remaining > 0) {
                         result = 0;
@@ -756,8 +754,7 @@ islpci_free_memory(islpci_private *priv)
                         pci_unmap_single(priv->pdev, buf->pci_addr,
                                          buf->size, PCI_DMA_FROMDEVICE);
                 buf->pci_addr = 0;
-                if (buf->mem)
-                        kfree(buf->mem);
+                kfree(buf->mem);
                 buf->size = 0;
                 buf->mem = NULL;
         }
@@ -839,13 +836,9 @@ islpci_setup(struct pci_dev *pdev)
         priv->ndev->type = (priv->iw_mode == IW_MODE_MONITOR) ?
                 priv->monitor_type : ARPHRD_ETHER;
 
-#if WIRELESS_EXT > 16
         /* Add pointers to enable iwspy support. */
         priv->wireless_data.spy_data = &priv->spy_data;
         ndev->wireless_data = &priv->wireless_data;
-#else  /* WIRELESS_EXT > 16 */
-        ndev->get_wireless_stats = &prism54_get_wireless_stats;
-#endif /* WIRELESS_EXT > 16 */
 
         /* save the start and end address of the PCI memory area */
         ndev->mem_start = (unsigned long) priv->device_base;
diff --git a/drivers/net/wireless/prism54/islpci_dev.h b/drivers/net/wireless/prism54/islpci_dev.h
index 32a1019f1b36..efbed4397951 100644
--- a/drivers/net/wireless/prism54/islpci_dev.h
+++ b/drivers/net/wireless/prism54/islpci_dev.h
@@ -100,9 +100,7 @@ typedef struct {
 
         struct iw_spy_data spy_data; /* iwspy support */
 
-#if WIRELESS_EXT > 16
         struct iw_public_data wireless_data;
-#endif /* WIRELESS_EXT > 16 */
 
         int monitor_type; /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_PRISM */
 
diff --git a/drivers/net/wireless/prism54/islpci_eth.c b/drivers/net/wireless/prism54/islpci_eth.c
index 5952e9960499..3b49efa37ee5 100644
--- a/drivers/net/wireless/prism54/islpci_eth.c
+++ b/drivers/net/wireless/prism54/islpci_eth.c
@@ -97,12 +97,6 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         /* lock the driver code */
         spin_lock_irqsave(&priv->slock, flags);
 
-        /* determine the amount of fragments needed to store the frame */
-
-        frame_size = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
-        if (init_wds)
-                frame_size += 6;
-
         /* check whether the destination queue has enough fragments for the frame */
         curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ]);
         if (unlikely(curr_frag - priv->free_data_tx >= ISL38XX_CB_TX_QSIZE)) {
@@ -213,6 +207,7 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         /* store the skb address for future freeing  */
         priv->data_low_tx[index] = skb;
         /* set the proper fragment start address and size information */
+        frame_size = skb->len;
         fragment->size = cpu_to_le16(frame_size);
         fragment->flags = cpu_to_le16(0);       /* set to 1 if more fragments */
         fragment->address = cpu_to_le32(pci_map_address);
@@ -246,12 +241,10 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         return 0;
 
       drop_free:
-        /* free the skbuf structure before aborting */
-        dev_kfree_skb(skb);
-        skb = NULL;
-
         priv->statistics.tx_dropped++;
         spin_unlock_irqrestore(&priv->slock, flags);
+        dev_kfree_skb(skb);
+        skb = NULL;
         return err;
 }
 
diff --git a/drivers/net/wireless/prism54/islpci_mgt.c b/drivers/net/wireless/prism54/islpci_mgt.c
index b6f2e5a223be..6a60c5970cb5 100644
--- a/drivers/net/wireless/prism54/islpci_mgt.c
+++ b/drivers/net/wireless/prism54/islpci_mgt.c
@@ -137,7 +137,7 @@ islpci_mgmt_rx_fill(struct net_device *ndev)
                                                        PCI_DMA_FROMDEVICE);
                         if (!buf->pci_addr) {
                                 printk(KERN_WARNING
-                                       "Failed to make memory DMA'able\n.");
+                                       "Failed to make memory DMA'able.\n");
                                 return -ENOMEM;
                         }
                 }
@@ -455,7 +455,7 @@ islpci_mgt_transaction(struct net_device *ndev,
                        struct islpci_mgmtframe **recvframe)
 {
         islpci_private *priv = netdev_priv(ndev);
-        const long wait_cycle_jiffies = (ISL38XX_WAIT_CYCLE * 10 * HZ) / 1000;
+        const long wait_cycle_jiffies = msecs_to_jiffies(ISL38XX_WAIT_CYCLE * 10);
         long timeout_left = ISL38XX_MAX_WAIT_CYCLES * wait_cycle_jiffies;
         int err;
         DEFINE_WAIT(wait);
@@ -475,8 +475,7 @@ islpci_mgt_transaction(struct net_device *ndev,
                 int timeleft;
                 struct islpci_mgmtframe *frame;
 
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                timeleft = schedule_timeout(wait_cycle_jiffies);
+                timeleft = schedule_timeout_uninterruptible(wait_cycle_jiffies);
                 frame = xchg(&priv->mgmt_received, NULL);
                 if (frame) {
                         if (frame->header->oid == oid) {
diff --git a/drivers/net/wireless/prism54/oid_mgt.c b/drivers/net/wireless/prism54/oid_mgt.c
index 12123e24b113..eea2f04c8c6d 100644
--- a/drivers/net/wireless/prism54/oid_mgt.c
+++ b/drivers/net/wireless/prism54/oid_mgt.c
@@ -268,11 +268,10 @@ mgt_clean(islpci_private *priv)
 
         if (!priv->mib)
                 return;
-        for (i = 0; i < OID_NUM_LAST; i++)
-                if (priv->mib[i]) {
-                        kfree(priv->mib[i]);
-                        priv->mib[i] = NULL;
-                }
+        for (i = 0; i < OID_NUM_LAST; i++) {
+                kfree(priv->mib[i]);
+                priv->mib[i] = NULL;
+        }
         kfree(priv->mib);
         priv->mib = NULL;
 }
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index e9c5ea0f5535..70fd6fd8feb9 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -1649,28 +1649,28 @@ static iw_stats * ray_get_wireless_stats(struct net_device *	dev)
  */
 
 static const iw_handler ray_handler[] = {
-        [SIOCSIWCOMMIT-SIOCIWFIRST] (iw_handler) ray_commit,
-        [SIOCGIWNAME  -SIOCIWFIRST] (iw_handler) ray_get_name,
-        [SIOCSIWFREQ  -SIOCIWFIRST] (iw_handler) ray_set_freq,
-        [SIOCGIWFREQ  -SIOCIWFIRST] (iw_handler) ray_get_freq,
-        [SIOCSIWMODE  -SIOCIWFIRST] (iw_handler) ray_set_mode,
-        [SIOCGIWMODE  -SIOCIWFIRST] (iw_handler) ray_get_mode,
-        [SIOCGIWRANGE -SIOCIWFIRST] (iw_handler) ray_get_range,
+        [SIOCSIWCOMMIT-SIOCIWFIRST] = (iw_handler) ray_commit,
+        [SIOCGIWNAME  -SIOCIWFIRST] = (iw_handler) ray_get_name,
+        [SIOCSIWFREQ  -SIOCIWFIRST] = (iw_handler) ray_set_freq,
+        [SIOCGIWFREQ  -SIOCIWFIRST] = (iw_handler) ray_get_freq,
+        [SIOCSIWMODE  -SIOCIWFIRST] = (iw_handler) ray_set_mode,
+        [SIOCGIWMODE  -SIOCIWFIRST] = (iw_handler) ray_get_mode,
+        [SIOCGIWRANGE -SIOCIWFIRST] = (iw_handler) ray_get_range,
 #ifdef WIRELESS_SPY
-        [SIOCSIWSPY   -SIOCIWFIRST] (iw_handler) iw_handler_set_spy,
-        [SIOCGIWSPY   -SIOCIWFIRST] (iw_handler) iw_handler_get_spy,
-        [SIOCSIWTHRSPY-SIOCIWFIRST] (iw_handler) iw_handler_set_thrspy,
-        [SIOCGIWTHRSPY-SIOCIWFIRST] (iw_handler) iw_handler_get_thrspy,
+        [SIOCSIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_set_spy,
+        [SIOCGIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_get_spy,
+        [SIOCSIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_set_thrspy,
+        [SIOCGIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_get_thrspy,
 #endif  /* WIRELESS_SPY */
-        [SIOCGIWAP    -SIOCIWFIRST] (iw_handler) ray_get_wap,
-        [SIOCSIWESSID -SIOCIWFIRST] (iw_handler) ray_set_essid,
-        [SIOCGIWESSID -SIOCIWFIRST] (iw_handler) ray_get_essid,
-        [SIOCSIWRATE  -SIOCIWFIRST] (iw_handler) ray_set_rate,
-        [SIOCGIWRATE  -SIOCIWFIRST] (iw_handler) ray_get_rate,
-        [SIOCSIWRTS   -SIOCIWFIRST] (iw_handler) ray_set_rts,
-        [SIOCGIWRTS   -SIOCIWFIRST] (iw_handler) ray_get_rts,
-        [SIOCSIWFRAG  -SIOCIWFIRST] (iw_handler) ray_set_frag,
-        [SIOCGIWFRAG  -SIOCIWFIRST] (iw_handler) ray_get_frag,
+        [SIOCGIWAP    -SIOCIWFIRST] = (iw_handler) ray_get_wap,
+        [SIOCSIWESSID -SIOCIWFIRST] = (iw_handler) ray_set_essid,
+        [SIOCGIWESSID -SIOCIWFIRST] = (iw_handler) ray_get_essid,
+        [SIOCSIWRATE  -SIOCIWFIRST] = (iw_handler) ray_set_rate,
+        [SIOCGIWRATE  -SIOCIWFIRST] = (iw_handler) ray_get_rate,
+        [SIOCSIWRTS   -SIOCIWFIRST] = (iw_handler) ray_set_rts,
+        [SIOCGIWRTS   -SIOCIWFIRST] = (iw_handler) ray_get_rts,
+        [SIOCSIWFRAG  -SIOCIWFIRST] = (iw_handler) ray_set_frag,
+        [SIOCGIWFRAG  -SIOCIWFIRST] = (iw_handler) ray_get_frag,
 };
 
 #define SIOCSIPFRAMING  SIOCIWFIRSTPRIV         /* Set framing mode */
@@ -1678,9 +1678,9 @@ static const iw_handler	ray_handler[] = {
 #define SIOCGIPCOUNTRY  SIOCIWFIRSTPRIV + 3     /* Get country code */
 
 static const iw_handler ray_private_handler[] = {
-        [0] (iw_handler) ray_set_framing,
-        [1] (iw_handler) ray_get_framing,
-        [3] (iw_handler) ray_get_country,
+        [0] = (iw_handler) ray_set_framing,
+        [1] = (iw_handler) ray_get_framing,
+        [3] = (iw_handler) ray_get_country,
 };
 
 static const struct iw_priv_args        ray_private_args[] = {
diff --git a/drivers/net/wireless/spectrum_cs.c b/drivers/net/wireless/spectrum_cs.c
index 39c6cdf7f3f7..b1bbc8e8e91f 100644
--- a/drivers/net/wireless/spectrum_cs.c
+++ b/drivers/net/wireless/spectrum_cs.c
@@ -22,58 +22,23 @@
 #define PFX DRIVER_NAME ": "
 
 #include <linux/config.h>
-#ifdef  __IN_PCMCIA_PACKAGE__
-#include <pcmcia/k_compat.h>
-#endif /* __IN_PCMCIA_PACKAGE__ */
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/ioport.h>
-#include <linux/netdevice.h>
-#include <linux/if_arp.h>
-#include <linux/etherdevice.h>
-#include <linux/wireless.h>
-
+#include <linux/delay.h>
+#include <linux/firmware.h>
 #include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
 
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/system.h>
-
 #include "orinoco.h"
 
-/*
- * If SPECTRUM_FW_INCLUDED is defined, the firmware is hardcoded into
- * the driver.  Use get_symbol_fw script to generate spectrum_fw.h and
- * copy it to the same directory as spectrum_cs.c.
- *
- * If SPECTRUM_FW_INCLUDED is not defined, the firmware is loaded at the
- * runtime using hotplug.  Use the same get_symbol_fw script to generate
- * files symbol_sp24t_prim_fw symbol_sp24t_sec_fw, copy them to the
- * hotplug firmware directory (typically /usr/lib/hotplug/firmware) and
- * make sure that you have hotplug installed and enabled in the kernel.
- */
-/* #define SPECTRUM_FW_INCLUDED 1 */
-
-#ifdef SPECTRUM_FW_INCLUDED
-/* Header with the firmware */
-#include "spectrum_fw.h"
-#else   /* !SPECTRUM_FW_INCLUDED */
-#include <linux/firmware.h>
 static unsigned char *primsym;
 static unsigned char *secsym;
 static const char primary_fw_name[] = "symbol_sp24t_prim_fw";
 static const char secondary_fw_name[] = "symbol_sp24t_sec_fw";
-#endif  /* !SPECTRUM_FW_INCLUDED */
 
 /********************************************************************/
 /* Module stuff                                                     */
@@ -124,17 +89,8 @@ static dev_link_t *dev_list; /* = NULL */
 /* Function prototypes                                              */
 /********************************************************************/
 
-/* device methods */
-static int spectrum_cs_hard_reset(struct orinoco_private *priv);
-
-/* PCMCIA gumpf */
-static void spectrum_cs_config(dev_link_t * link);
-static void spectrum_cs_release(dev_link_t * link);
-static int spectrum_cs_event(event_t event, int priority,
-                            event_callback_args_t * args);
-
-static dev_link_t *spectrum_cs_attach(void);
-static void spectrum_cs_detach(dev_link_t *);
+static void spectrum_cs_release(dev_link_t *link);
+static void spectrum_cs_detach(dev_link_t *link);
 
 /********************************************************************/
 /* Firmware downloader                                              */
@@ -182,8 +138,8 @@ static void spectrum_cs_detach(dev_link_t *);
  * Each block has the following structure.
  */
 struct dblock {
-        u32 _addr;              /* adapter address where to write the block */
-        u16 _len;               /* length of the data only, in bytes */
+        __le32 _addr;           /* adapter address where to write the block */
+        __le16 _len;            /* length of the data only, in bytes */
         char data[0];           /* data to be written */
 } __attribute__ ((packed));
 
@@ -193,9 +149,9 @@ struct dblock {
  * items with matching ID should be written.
  */
 struct pdr {
-        u32 _id;                /* record ID */
-        u32 _addr;              /* adapter address where to write the data */
-        u32 _len;               /* expected length of the data, in bytes */
+        __le32 _id;             /* record ID */
+        __le32 _addr;           /* adapter address where to write the data */
+        __le32 _len;            /* expected length of the data, in bytes */
         char next[0];           /* next PDR starts here */
 } __attribute__ ((packed));
 
@@ -206,8 +162,8 @@ struct pdr {
  * be plugged into the secondary firmware.
  */
 struct pdi {
-        u16 _len;               /* length of ID and data, in words */
-        u16 _id;                /* record ID */
+        __le16 _len;            /* length of ID and data, in words */
+        __le16 _id;             /* record ID */
         char data[0];           /* plug data */
 } __attribute__ ((packed));;
 
@@ -414,7 +370,7 @@ spectrum_plug_pdi(hermes_t *hw, struct pdr *first_pdr, struct pdi *pdi)
 
 /* Read PDA from the adapter */
 static int
-spectrum_read_pda(hermes_t *hw, u16 *pda, int pda_len)
+spectrum_read_pda(hermes_t *hw, __le16 *pda, int pda_len)
 {
         int ret;
         int pda_size;
@@ -445,7 +401,7 @@ spectrum_read_pda(hermes_t *hw, u16 *pda, int pda_len)
 /* Parse PDA and write the records into the adapter */
 static int
 spectrum_apply_pda(hermes_t *hw, const struct dblock *first_block,
-                   u16 *pda)
+                   __le16 *pda)
 {
         int ret;
         struct pdi *pdi;
@@ -511,7 +467,7 @@ spectrum_dl_image(hermes_t *hw, dev_link_t *link,
         const struct dblock *first_block;
 
         /* Plug Data Area (PDA) */
-        u16 pda[PDA_WORDS];
+        __le16 pda[PDA_WORDS];
 
         /* Binary block begins after the 0x1A marker */
         ptr = image;
@@ -571,8 +527,6 @@ spectrum_dl_firmware(hermes_t *hw, dev_link_t *link)
 {
         int ret;
         client_handle_t handle = link->handle;
-
-#ifndef SPECTRUM_FW_INCLUDED
         const struct firmware *fw_entry;
 
         if (request_firmware(&fw_entry, primary_fw_name,
@@ -592,7 +546,6 @@ spectrum_dl_firmware(hermes_t *hw, dev_link_t *link)
                        secondary_fw_name);
                 return -ENOENT;
         }
-#endif
 
         /* Load primary firmware */
         ret = spectrum_dl_image(hw, link, primsym);
@@ -1085,7 +1038,7 @@ static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
 static struct pcmcia_device_id spectrum_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4100 */
         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
-        PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0001), /* Intel PRO/Wireless 2011B */
+        PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
         PCMCIA_DEVICE_NULL,
 };
 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
@@ -1096,8 +1049,8 @@ static struct pcmcia_driver orinoco_driver = {
                 .name   = DRIVER_NAME,
         },
         .attach         = spectrum_cs_attach,
-        .event          = spectrum_cs_event,
         .detach         = spectrum_cs_detach,
+        .event          = spectrum_cs_event,
         .id_table       = spectrum_cs_ids,
 };
 
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index 7bc7fc823128..d25264ba0c0e 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -860,12 +860,9 @@ static int allocate_buffers(struct strip *strip_info, int mtu)
                 strip_info->mtu = dev->mtu = mtu;
                 return (1);
         }
-        if (r)
-                kfree(r);
-        if (s)
-                kfree(s);
-        if (t)
-                kfree(t);
+        kfree(r);
+        kfree(s);
+        kfree(t);
         return (0);
 }
 
@@ -922,13 +919,9 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
         printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
                strip_info->dev->name, old_mtu, strip_info->mtu);
 
-        if (orbuff)
-                kfree(orbuff);
-        if (osbuff)
-                kfree(osbuff);
-        if (otbuff)
-                kfree(otbuff);
-
+        kfree(orbuff);
+        kfree(osbuff);
+        kfree(otbuff);
         return 0;
 }
 
@@ -2498,18 +2491,13 @@ static int strip_close_low(struct net_device *dev)
         /*
          * Free all STRIP frame buffers.
          */
-        if (strip_info->rx_buff) {
-                kfree(strip_info->rx_buff);
-                strip_info->rx_buff = NULL;
-        }
-        if (strip_info->sx_buff) {
-                kfree(strip_info->sx_buff);
-                strip_info->sx_buff = NULL;
-        }
-        if (strip_info->tx_buff) {
-                kfree(strip_info->tx_buff);
-                strip_info->tx_buff = NULL;
-        }
+        kfree(strip_info->rx_buff);
+        strip_info->rx_buff = NULL;
+        kfree(strip_info->sx_buff);
+        strip_info->sx_buff = NULL;
+        kfree(strip_info->tx_buff);
+        strip_info->tx_buff = NULL;
+
         del_timer(&strip_info->idle_timer);
         return 0;
 }
diff --git a/drivers/net/wireless/wavelan.c b/drivers/net/wireless/wavelan.c
index 7a5e20a17890..b0d8b5b03152 100644
--- a/drivers/net/wireless/wavelan.c
+++ b/drivers/net/wireless/wavelan.c
@@ -430,7 +430,6 @@ static void fee_read(unsigned long ioaddr,	/* I/O port of the card */
         }
 }
 
-#ifdef WIRELESS_EXT             /* if the wireless extension exists in the kernel */
 
 /*------------------------------------------------------------------*/
 /*
@@ -514,7 +513,6 @@ static void fee_write(unsigned long ioaddr,	/* I/O port of the card */
         fee_wait(ioaddr, 10, 100);
 #endif                          /* EEPROM_IS_PROTECTED */
 }
-#endif                          /* WIRELESS_EXT */
 
 /************************ I82586 SUBROUTINES *************************/
 /*
@@ -973,11 +971,9 @@ static void wv_mmc_show(struct net_device * dev)
         mmc_read(ioaddr, 0, (u8 *) & m, sizeof(m));
         mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0);
 
-#ifdef WIRELESS_EXT             /* if wireless extension exists in the kernel */
         /* Don't forget to update statistics */
         lp->wstats.discard.nwid +=
             (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
-#endif                          /* WIRELESS_EXT */
 
         printk(KERN_DEBUG "##### WaveLAN modem status registers: #####\n");
 #ifdef DEBUG_SHOW_UNUSED
@@ -1499,7 +1495,6 @@ static int wavelan_set_mac_address(struct net_device * dev, void *addr)
 }
 #endif                          /* SET_MAC_ADDRESS */
 
-#ifdef WIRELESS_EXT             /* if wireless extensions exist in the kernel */
 
 /*------------------------------------------------------------------*/
 /*
@@ -2473,7 +2468,6 @@ static iw_stats *wavelan_get_wireless_stats(struct net_device * dev)
 #endif
         return &lp->wstats;
 }
-#endif                          /* WIRELESS_EXT */
 
 /************************* PACKET RECEPTION *************************/
 /*
@@ -4194,11 +4188,9 @@ static int __init wavelan_config(struct net_device *dev, unsigned short ioaddr)
         dev->set_mac_address = &wavelan_set_mac_address;
 #endif                          /* SET_MAC_ADDRESS */
 
-#ifdef WIRELESS_EXT             /* if wireless extension exists in the kernel */
         dev->wireless_handlers = &wavelan_handler_def;
         lp->wireless_data.spy_data = &lp->spy_data;
         dev->wireless_data = &lp->wireless_data;
-#endif
 
         dev->mtu = WAVELAN_MTU;
 
diff --git a/drivers/net/wireless/wavelan.p.h b/drivers/net/wireless/wavelan.p.h
index 509ff22a6caa..166e28b9a4f7 100644
--- a/drivers/net/wireless/wavelan.p.h
+++ b/drivers/net/wireless/wavelan.p.h
@@ -409,11 +409,9 @@
 #define MULTICAST_AVOID         /* Avoid extra multicast (I'm sceptical). */
 #undef SET_MAC_ADDRESS          /* Experimental */
 
-#ifdef WIRELESS_EXT     /* If wireless extensions exist in the kernel */
 /* Warning:  this stuff will slow down the driver. */
 #define WIRELESS_SPY            /* Enable spying addresses. */
 #undef HISTOGRAM                /* Enable histogram of signal level. */
-#endif
 
 /****************************** DEBUG ******************************/
 
@@ -506,12 +504,10 @@ struct net_local
   u_short       tx_first_free;
   u_short       tx_first_in_use;
 
-#ifdef WIRELESS_EXT
   iw_stats      wstats;         /* Wireless-specific statistics */
 
   struct iw_spy_data    spy_data;
   struct iw_public_data wireless_data;
-#endif
 
 #ifdef HISTOGRAM
   int           his_number;             /* number of intervals */
diff --git a/drivers/net/wireless/wavelan_cs.c b/drivers/net/wireless/wavelan_cs.c
index 183c4732ef65..4b3c98f5c564 100644
--- a/drivers/net/wireless/wavelan_cs.c
+++ b/drivers/net/wireless/wavelan_cs.c
@@ -415,7 +415,6 @@ fee_read(u_long		base,	/* i/o port of the card */
     }
 }
 
-#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
 
 /*------------------------------------------------------------------*/
 /*
@@ -500,7 +499,6 @@ fee_write(u_long	base,	/* i/o port of the card */
   fee_wait(base, 10, 100);
 #endif  /* EEPROM_IS_PROTECTED */
 }
-#endif  /* WIRELESS_EXT */
 
 /******************* WaveLAN Roaming routines... ********************/
 
@@ -1161,10 +1159,8 @@ wv_mmc_show(struct net_device *	dev)
   mmc_read(base, 0, (u_char *)&m, sizeof(m));
   mmc_out(base, mmwoff(0, mmw_freeze), 0);
 
-#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
   /* Don't forget to update statistics */
   lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
-#endif  /* WIRELESS_EXT */
 
   spin_unlock_irqrestore(&lp->spinlock, flags);
 
@@ -1550,7 +1546,6 @@ wavelan_set_mac_address(struct net_device *	dev,
 }
 #endif  /* SET_MAC_ADDRESS */
 
-#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
 
 /*------------------------------------------------------------------*/
 /*
@@ -2793,7 +2788,6 @@ wavelan_get_wireless_stats(struct net_device *	dev)
 #endif
   return &lp->wstats;
 }
-#endif  /* WIRELESS_EXT */
 
 /************************* PACKET RECEPTION *************************/
 /*
@@ -4679,11 +4673,9 @@ wavelan_attach(void)
   dev->watchdog_timeo   = WATCHDOG_JIFFIES;
   SET_ETHTOOL_OPS(dev, &ops);
 
-#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
   dev->wireless_handlers = &wavelan_handler_def;
   lp->wireless_data.spy_data = &lp->spy_data;
   dev->wireless_data = &lp->wireless_data;
-#endif
 
   /* Other specific data */
   dev->mtu = WAVELAN_MTU;
diff --git a/drivers/net/wireless/wavelan_cs.p.h b/drivers/net/wireless/wavelan_cs.p.h
index 01d882be8790..724a715089c9 100644
--- a/drivers/net/wireless/wavelan_cs.p.h
+++ b/drivers/net/wireless/wavelan_cs.p.h
@@ -472,11 +472,9 @@
 #define MULTICAST_AVOID         /* Avoid extra multicast (I'm sceptical) */
 #undef SET_MAC_ADDRESS          /* Experimental */
 
-#ifdef WIRELESS_EXT     /* If wireless extension exist in the kernel */
 /* Warning : these stuff will slow down the driver... */
 #define WIRELESS_SPY            /* Enable spying addresses */
 #undef HISTOGRAM                /* Enable histogram of sig level... */
-#endif
 
 /****************************** DEBUG ******************************/
 
@@ -624,12 +622,10 @@ struct net_local
   int           rfp;            /* Last DMA machine receive pointer */
   int           overrunning;    /* Receiver overrun flag */
 
-#ifdef WIRELESS_EXT
   iw_stats      wstats;         /* Wireless specific stats */
 
   struct iw_spy_data    spy_data;
   struct iw_public_data wireless_data;
-#endif
 
 #ifdef HISTOGRAM
   int           his_number;             /* Number of intervals */
diff --git a/drivers/net/wireless/wl3501.h b/drivers/net/wireless/wl3501.h
index 7fcbe589c3f2..4303c50c2ab6 100644
--- a/drivers/net/wireless/wl3501.h
+++ b/drivers/net/wireless/wl3501.h
@@ -548,7 +548,7 @@ struct wl3501_80211_tx_plcp_hdr {
 
 struct wl3501_80211_tx_hdr {
         struct wl3501_80211_tx_plcp_hdr pclp_hdr;
-        struct ieee80211_hdr            mac_hdr;
+        struct ieee80211_hdr_4addr              mac_hdr;
 } __attribute__ ((packed));
 
 /*