67 files changed, 1829 insertions, 1325 deletions
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index 1363083b4d83..14dbad14afb6 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -52,6 +52,7 @@
 #include <linux/mii.h>
 #include <linux/skbuff.h>
 #include <linux/delay.h>
+#include <linux/crc32.h>
 #include <asm/mipsregs.h>
 #include <asm/irq.h>
 #include <asm/io.h>
@@ -2070,23 +2071,6 @@ static void au1000_tx_timeout(struct net_device *dev)
        netif_wake_queue(dev);
 }
-static unsigned const ethernet_polynomial = 0x04c11db7U;
-static inline u32 ether_crc(int length, unsigned char *data)
-{
-    int crc = -1;
-    while(--length >= 0) {
-                unsigned char current_octet = *data++;
-                int bit;
-                for (bit = 0; bit < 8; bit++, current_octet >>= 1)
-                        crc = (crc << 1) ^
-                                ((crc < 0) ^ (current_octet & 1) ? 
-                                 ethernet_polynomial : 0);
-    }
-    return crc;
-}
 static void set_rx_mode(struct net_device *dev)
 {
        struct au1000_private *aup = (struct au1000_private *) dev->priv;
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 3d306681919e..d8233e0b7899 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -650,9 +650,11 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
        /* Hardware bug work-around, the chip is unable to do PCI DMA
           to/from anything above 1GB :-( */
-        if (mapping + RX_PKT_BUF_SZ > B44_DMA_MASK) {
+        if (dma_mapping_error(mapping) ||
+                mapping + RX_PKT_BUF_SZ > B44_DMA_MASK) {
                /* Sigh... */
-                pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
+                if (!dma_mapping_error(mapping))
+                        pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
                dev_kfree_skb_any(skb);
                skb = __dev_alloc_skb(RX_PKT_BUF_SZ,GFP_DMA);
                if (skb == NULL)
@@ -660,8 +662,10 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
                mapping = pci_map_single(bp->pdev, skb->data,
                                         RX_PKT_BUF_SZ,
                                         PCI_DMA_FROMDEVICE);
-                if (mapping + RX_PKT_BUF_SZ > B44_DMA_MASK) {
+                if (dma_mapping_error(mapping) ||
-                        pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
+                        mapping + RX_PKT_BUF_SZ > B44_DMA_MASK) {
+                        if (!dma_mapping_error(mapping))
+                                pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
                        dev_kfree_skb_any(skb);
                        return -ENOMEM;
                }
@@ -967,9 +971,10 @@ static int b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
        }
        mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE);
-        if (mapping + len > B44_DMA_MASK) {
+        if (dma_mapping_error(mapping) || mapping + len > B44_DMA_MASK) {
                /* Chip can't handle DMA to/from >1GB, use bounce buffer */
-                pci_unmap_single(bp->pdev, mapping, len, PCI_DMA_TODEVICE);
+                if (!dma_mapping_error(mapping))
+                        pci_unmap_single(bp->pdev, mapping, len, PCI_DMA_TODEVICE);
                bounce_skb = __dev_alloc_skb(TX_PKT_BUF_SZ,
                                             GFP_ATOMIC|GFP_DMA);
@@ -978,8 +983,9 @@ static int b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
                mapping = pci_map_single(bp->pdev, bounce_skb->data,
                                         len, PCI_DMA_TODEVICE);
-                if (mapping + len > B44_DMA_MASK) {
+                if (dma_mapping_error(mapping) || mapping + len > B44_DMA_MASK) {
-                        pci_unmap_single(bp->pdev, mapping,
+                        if (!dma_mapping_error(mapping))
+                                pci_unmap_single(bp->pdev, mapping,
                                         len, PCI_DMA_TODEVICE);
                        dev_kfree_skb_any(bounce_skb);
                        goto err_out;
@@ -1203,7 +1209,8 @@ static int b44_alloc_consistent(struct b44 *bp)
                                             DMA_TABLE_BYTES,
                                             DMA_BIDIRECTIONAL);
-                if (rx_ring_dma + size > B44_DMA_MASK) {
+                if (dma_mapping_error(rx_ring_dma) ||
+                        rx_ring_dma + size > B44_DMA_MASK) {
                        kfree(rx_ring);
                        goto out_err;
                }
@@ -1229,7 +1236,8 @@ static int b44_alloc_consistent(struct b44 *bp)
                                             DMA_TABLE_BYTES,
                                             DMA_TO_DEVICE);
-                if (tx_ring_dma + size > B44_DMA_MASK) {
+                if (dma_mapping_error(tx_ring_dma) ||
+                        tx_ring_dma + size > B44_DMA_MASK) {
                        kfree(tx_ring);
                        goto out_err;
                }
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 5ca99e26660a..54161aef3cac 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -55,8 +55,8 @@
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.4.39"
+#define DRV_MODULE_VERSION      "1.4.40"
-#define DRV_MODULE_RELDATE      "March 22, 2006"
+#define DRV_MODULE_RELDATE      "May 22, 2006"
 #define RUN_AT(x) (jiffies + (x))
@@ -2945,7 +2945,7 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
                int buf_size)
 {
        u32 written, offset32, len32;
-        u8 *buf, start[4], end[4];
+        u8 *buf, start[4], end[4], *flash_buffer = NULL;
        int rc = 0;
        int align_start, align_end;
@@ -2985,12 +2985,19 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
                memcpy(buf + align_start, data_buf, buf_size);
        }
+        if (bp->flash_info->buffered == 0) {
+                flash_buffer = kmalloc(264, GFP_KERNEL);
+                if (flash_buffer == NULL) {
+                        rc = -ENOMEM;
+                        goto nvram_write_end;
+                }
+        }
        written = 0;
        while ((written < len32) && (rc == 0)) {
                u32 page_start, page_end, data_start, data_end;
                u32 addr, cmd_flags;
                int i;
-                u8 flash_buffer[264];
                /* Find the page_start addr */
                page_start = offset32 + written;
@@ -3061,7 +3068,7 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
                }
                /* Loop to write the new data from data_start to data_end */
-                for (addr = data_start; addr < data_end; addr += 4, i++) {
+                for (addr = data_start; addr < data_end; addr += 4, i += 4) {
                        if ((addr == page_end - 4) ||
                                ((bp->flash_info->buffered) &&
                                 (addr == data_end - 4))) {
@@ -3109,6 +3116,9 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
        }
 nvram_write_end:
+        if (bp->flash_info->buffered == 0)
+                kfree(flash_buffer);
        if (align_start || align_end)
                kfree(buf);
        return rc;
diff --git a/drivers/net/dl2k.c b/drivers/net/dl2k.c
index 1f3627470c95..038447fb5c5e 100644
--- a/drivers/net/dl2k.c
+++ b/drivers/net/dl2k.c
@@ -53,6 +53,7 @@
 #define DRV_VERSION     "v1.17b"
 #define DRV_RELDATE     "2006/03/10"
 #include "dl2k.h"
+#include <linux/dma-mapping.h>
 static char version[] __devinitdata =
      KERN_INFO DRV_NAME " " DRV_VERSION " " DRV_RELDATE "\n";  
@@ -765,7 +766,7 @@ rio_free_tx (struct net_device *dev, int irq)
                        break;
                skb = np->tx_skbuff[entry];
                pci_unmap_single (np->pdev,
-                                  np->tx_ring[entry].fraginfo & 0xffffffffffff,
+                                  np->tx_ring[entry].fraginfo & DMA_48BIT_MASK,
                                  skb->len, PCI_DMA_TODEVICE);
                if (irq)
                        dev_kfree_skb_irq (skb);
@@ -893,7 +894,7 @@ receive_packet (struct net_device *dev)
                        /* Small skbuffs for short packets */
                        if (pkt_len > copy_thresh) {
                                pci_unmap_single (np->pdev,
-                                                  desc->fraginfo & 0xffffffffffff,
+                                                  desc->fraginfo & DMA_48BIT_MASK,
                                                  np->rx_buf_sz,
                                                  PCI_DMA_FROMDEVICE);
                                skb_put (skb = np->rx_skbuff[entry], pkt_len);
@@ -901,7 +902,7 @@ receive_packet (struct net_device *dev)
                        } else if ((skb = dev_alloc_skb (pkt_len + 2)) != NULL) {
                                pci_dma_sync_single_for_cpu(np->pdev,
                                                            desc->fraginfo & 
-                                                                0xffffffffffff,
+                                                                DMA_48BIT_MASK,
                                                            np->rx_buf_sz,
                                                            PCI_DMA_FROMDEVICE);
                                skb->dev = dev;
@@ -913,7 +914,7 @@ receive_packet (struct net_device *dev)
                                skb_put (skb, pkt_len);
                                pci_dma_sync_single_for_device(np->pdev,
                                                               desc->fraginfo &
-                                                                 0xffffffffffff,
+                                                                 DMA_48BIT_MASK,
                                                               np->rx_buf_sz,
                                                               PCI_DMA_FROMDEVICE);
                        }
@@ -1800,7 +1801,7 @@ rio_close (struct net_device *dev)
                skb = np->rx_skbuff[i];
                if (skb) {
                        pci_unmap_single(np->pdev, 
-                                         np->rx_ring[i].fraginfo & 0xffffffffffff,
+                                         np->rx_ring[i].fraginfo & DMA_48BIT_MASK,
                                         skb->len, PCI_DMA_FROMDEVICE);
                        dev_kfree_skb (skb);
                        np->rx_skbuff[i] = NULL;
@@ -1810,7 +1811,7 @@ rio_close (struct net_device *dev)
                skb = np->tx_skbuff[i];
                if (skb) {
                        pci_unmap_single(np->pdev, 
-                                         np->tx_ring[i].fraginfo & 0xffffffffffff,
+                                         np->tx_ring[i].fraginfo & DMA_48BIT_MASK,
                                         skb->len, PCI_DMA_TODEVICE);
                        dev_kfree_skb (skb);
                        np->tx_skbuff[i] = NULL;
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index ecccca35c6f4..d1c705b412c2 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -870,13 +870,16 @@ e1000_intr_test(struct e1000_adapter *adapter, uint64_t *data)
        *data = 0;
        /* Hook up test interrupt handler just for this test */
-        if (!request_irq(irq, &e1000_test_intr, 0, netdev->name, netdev)) {
+        if (!request_irq(irq, &e1000_test_intr, SA_PROBEIRQ, netdev->name,
+                         netdev)) {
                shared_int = FALSE;
        } else if (request_irq(irq, &e1000_test_intr, SA_SHIRQ,
                              netdev->name, netdev)){
                *data = 1;
                return -1;
        }
+        DPRINTK(PROBE,INFO, "testing %s interrupt\n",
+                (shared_int ? "shared" : "unshared"));
        /* Disable all the interrupts */
        E1000_WRITE_REG(&adapter->hw, IMC, 0xFFFFFFFF);
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index add8dc4aa7b0..97e71a4fe8eb 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -220,6 +220,7 @@ static void e1000_restore_vlan(struct e1000_adapter *adapter);
 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 static int e1000_resume(struct pci_dev *pdev);
 #endif
+static void e1000_shutdown(struct pci_dev *pdev);
 #ifdef CONFIG_NET_POLL_CONTROLLER
 /* for netdump / net console */
@@ -235,8 +236,9 @@ static struct pci_driver e1000_driver = {
        /* Power Managment Hooks */
 #ifdef CONFIG_PM
        .suspend  = e1000_suspend,
-        .resume   = e1000_resume
+        .resume   = e1000_resume,
 #endif
+        .shutdown = e1000_shutdown
 };
 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
@@ -3517,7 +3519,7 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
        buffer_info = &rx_ring->buffer_info[i];
        while (rx_desc->status & E1000_RXD_STAT_DD) {
-                struct sk_buff *skb, *next_skb;
+                struct sk_buff *skb;
                u8 status;
 #ifdef CONFIG_E1000_NAPI
                if (*work_done >= work_to_do)
@@ -3535,8 +3537,6 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
                prefetch(next_rxd);
                next_buffer = &rx_ring->buffer_info[i];
-                next_skb = next_buffer->skb;
-                prefetch(next_skb->data - NET_IP_ALIGN);
                cleaned = TRUE;
                cleaned_count++;
@@ -3666,7 +3666,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
        struct e1000_buffer *buffer_info, *next_buffer;
        struct e1000_ps_page *ps_page;
        struct e1000_ps_page_dma *ps_page_dma;
-        struct sk_buff *skb, *next_skb;
+        struct sk_buff *skb;
        unsigned int i, j;
        uint32_t length, staterr;
        int cleaned_count = 0;
@@ -3695,8 +3695,6 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                prefetch(next_rxd);
                next_buffer = &rx_ring->buffer_info[i];
-                next_skb = next_buffer->skb;
-                prefetch(next_skb->data - NET_IP_ALIGN);
                cleaned = TRUE;
                cleaned_count++;
@@ -3768,6 +3766,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                        ps_page->ps_page[j] = NULL;
                        skb->len += length;
                        skb->data_len += length;
+                        skb->truesize += length;
                }
 copydone:
@@ -4610,6 +4609,12 @@ e1000_resume(struct pci_dev *pdev)
        return 0;
 }
 #endif
+static void e1000_shutdown(struct pci_dev *pdev)
+{
+        e1000_suspend(pdev, PMSG_SUSPEND);
+}
 #ifdef CONFIG_NET_POLL_CONTROLLER
 /*
 * Polling 'interrupt' - used by things like netconsole to send skbs
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 7627a75f4f7c..feb5b223cd60 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -105,6 +105,8 @@
 *      0.50: 20 Jan 2006: Add 8021pq tagging support.
 *      0.51: 20 Jan 2006: Add 64bit consistent memory allocation for rings.
 *      0.52: 20 Jan 2006: Add MSI/MSIX support.
+ *      0.53: 19 Mar 2006: Fix init from low power mode and add hw reset.
+ *      0.54: 21 Mar 2006: Fix spin locks for multi irqs and cleanup.
 *
 * Known bugs:
 * We suspect that on some hardware no TX done interrupts are generated.
@@ -116,7 +118,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.52"
+#define FORCEDETH_VERSION               "0.54"
 #define DRV_NAME                        "forcedeth"
 #include <linux/module.h>
@@ -160,6 +162,7 @@
 #define DEV_HAS_VLAN            0x0020  /* device supports vlan tagging and striping */
 #define DEV_HAS_MSI             0x0040  /* device supports MSI */
 #define DEV_HAS_MSI_X           0x0080  /* device supports MSI-X */
+#define DEV_HAS_POWER_CNTRL     0x0100  /* device supports power savings */
 enum {
        NvRegIrqStatus = 0x000,
@@ -203,6 +206,8 @@ enum {
 #define NVREG_MISC1_HD          0x02
 #define NVREG_MISC1_FORCE       0x3b0f3c
+        NvRegMacReset = 0x3c,
+#define NVREG_MAC_RESET_ASSERT  0x0F3
        NvRegTransmitterControl = 0x084,
 #define NVREG_XMITCTL_START     0x01
        NvRegTransmitterStatus = 0x088,
@@ -326,6 +331,10 @@ enum {
        NvRegMSIXMap0 = 0x3e0,
        NvRegMSIXMap1 = 0x3e4,
        NvRegMSIXIrqStatus = 0x3f0,
+        NvRegPowerState2 = 0x600,
+#define NVREG_POWERSTATE2_POWERUP_MASK          0x0F11
+#define NVREG_POWERSTATE2_POWERUP_REV_A3        0x0001
 };
 /* Big endian: should work, but is untested */
@@ -414,7 +423,8 @@ typedef union _ring_type {
 #define NV_RX3_VLAN_TAG_MASK    (0x0000FFFF)
 /* Miscelaneous hardware related defines: */
-#define NV_PCI_REGSZ            0x270
+#define NV_PCI_REGSZ_VER1       0x270
+#define NV_PCI_REGSZ_VER2       0x604
 /* various timeout delays: all in usec */
 #define NV_TXRX_RESET_DELAY     4
@@ -431,6 +441,7 @@ typedef union _ring_type {
 #define NV_MIIBUSY_DELAY        50
 #define NV_MIIPHY_DELAY 10
 #define NV_MIIPHY_DELAYMAX      10000
+#define NV_MAC_RESET_DELAY      64
 #define NV_WAKEUPPATTERNS       5
 #define NV_WAKEUPMASKENTRIES    4
@@ -552,6 +563,8 @@ struct fe_priv {
        u32 desc_ver;
        u32 txrxctl_bits;
        u32 vlanctl_bits;
+        u32 driver_data;
+        u32 register_size;
        void __iomem *base;
@@ -698,6 +711,72 @@ static void setup_hw_rings(struct net_device *dev, int rxtx_flags)
        }
 }
+static int using_multi_irqs(struct net_device *dev)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+            ((np->msi_flags & NV_MSI_X_ENABLED) &&
+             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1)))
+                return 0;
+        else
+                return 1;
+}
+static void nv_enable_irq(struct net_device *dev)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        if (!using_multi_irqs(dev)) {
+                if (np->msi_flags & NV_MSI_X_ENABLED)
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
+                else
+                        enable_irq(dev->irq);
+        } else {
+                enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+        }
+}
+static void nv_disable_irq(struct net_device *dev)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        if (!using_multi_irqs(dev)) {
+                if (np->msi_flags & NV_MSI_X_ENABLED)
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
+                else
+                        disable_irq(dev->irq);
+        } else {
+                disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+        }
+}
+/* In MSIX mode, a write to irqmask behaves as XOR */
+static void nv_enable_hw_interrupts(struct net_device *dev, u32 mask)
+{
+        u8 __iomem *base = get_hwbase(dev);
+        writel(mask, base + NvRegIrqMask);
+}
+static void nv_disable_hw_interrupts(struct net_device *dev, u32 mask)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        if (np->msi_flags & NV_MSI_X_ENABLED) {
+                writel(mask, base + NvRegIrqMask);
+        } else {
+                if (np->msi_flags & NV_MSI_ENABLED)
+                        writel(0, base + NvRegMSIIrqMask);
+                writel(0, base + NvRegIrqMask);
+        }
+}
 #define MII_READ        (-1)
 /* mii_rw: read/write a register on the PHY.
 *
@@ -919,6 +998,24 @@ static void nv_txrx_reset(struct net_device *dev)
        pci_push(base);
 }
+static void nv_mac_reset(struct net_device *dev)
+{
+        struct fe_priv *np = netdev_priv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        dprintk(KERN_DEBUG "%s: nv_mac_reset\n", dev->name);
+        writel(NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | np->txrxctl_bits, base + NvRegTxRxControl);
+        pci_push(base);
+        writel(NVREG_MAC_RESET_ASSERT, base + NvRegMacReset);
+        pci_push(base);
+        udelay(NV_MAC_RESET_DELAY);
+        writel(0, base + NvRegMacReset);
+        pci_push(base);
+        udelay(NV_MAC_RESET_DELAY);
+        writel(NVREG_TXRXCTL_BIT2 | np->txrxctl_bits, base + NvRegTxRxControl);
+        pci_push(base);
+}
 /*
 * nv_get_stats: dev->get_stats function
 * Get latest stats value from the nic.
@@ -989,24 +1086,25 @@ static void nv_do_rx_refill(unsigned long data)
        struct net_device *dev = (struct net_device *) data;
        struct fe_priv *np = netdev_priv(dev);
+        if (!using_multi_irqs(dev)) {
-        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+                if (np->msi_flags & NV_MSI_X_ENABLED)
-            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
-             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                else
-                disable_irq(dev->irq);
+                        disable_irq(dev->irq);
        } else {
                disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
        }
        if (nv_alloc_rx(dev)) {
-                spin_lock(&np->lock);
+                spin_lock_irq(&np->lock);
                if (!np->in_shutdown)
                        mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
-                spin_unlock(&np->lock);
+                spin_unlock_irq(&np->lock);
        }
-        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+        if (!using_multi_irqs(dev)) {
-            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+                if (np->msi_flags & NV_MSI_X_ENABLED)
-             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
-                enable_irq(dev->irq);
+                else
+                        enable_irq(dev->irq);
        } else {
                enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
        }
@@ -1331,7 +1429,7 @@ static void nv_tx_timeout(struct net_device *dev)
                                dev->name, (unsigned long)np->ring_addr,
                                np->next_tx, np->nic_tx);
                printk(KERN_INFO "%s: Dumping tx registers\n", dev->name);
-                for (i=0;i<0x400;i+= 32) {
+                for (i=0;i<=np->register_size;i+= 32) {
                        printk(KERN_INFO "%3x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
                                        i,
                                        readl(base + i + 0), readl(base + i + 4),
@@ -1638,15 +1736,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                 * guessed, there is probably a simpler approach.
                 * Changing the MTU is a rare event, it shouldn't matter.
                 */
-                if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+                nv_disable_irq(dev);
-                    ((np->msi_flags & NV_MSI_X_ENABLED) && 
-                     ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
-                        disable_irq(dev->irq);
-                } else {
-                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
-                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
-                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
-                }
                spin_lock_bh(&dev->xmit_lock);
                spin_lock(&np->lock);
                /* stop engines */
@@ -1679,15 +1769,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                nv_start_tx(dev);
                spin_unlock(&np->lock);
                spin_unlock_bh(&dev->xmit_lock);
-                if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+                nv_enable_irq(dev);
-                    ((np->msi_flags & NV_MSI_X_ENABLED) && 
-                     ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
-                        enable_irq(dev->irq);
-                } else {
-                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
-                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
-                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
-                }
        }
        return 0;
 }
@@ -2078,16 +2160,16 @@ static irqreturn_t nv_nic_irq_tx(int foo, void *data, struct pt_regs *regs)
                if (!(events & np->irqmask))
                        break;
-                spin_lock(&np->lock);
+                spin_lock_irq(&np->lock);
                nv_tx_done(dev);
-                spin_unlock(&np->lock);
+                spin_unlock_irq(&np->lock);
                
                if (events & (NVREG_IRQ_TX_ERR)) {
                        dprintk(KERN_DEBUG "%s: received irq with events 0x%x. Probably TX fail.\n",
                                                dev->name, events);
                }
                if (i > max_interrupt_work) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        /* disable interrupts on the nic */
                        writel(NVREG_IRQ_TX_ALL, base + NvRegIrqMask);
                        pci_push(base);
@@ -2097,7 +2179,7 @@ static irqreturn_t nv_nic_irq_tx(int foo, void *data, struct pt_regs *regs)
                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                        }
                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_tx.\n", dev->name, i);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                        break;
                }
@@ -2127,14 +2209,14 @@ static irqreturn_t nv_nic_irq_rx(int foo, void *data, struct pt_regs *regs)
                
                nv_rx_process(dev);
                if (nv_alloc_rx(dev)) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        if (!np->in_shutdown)
                                mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                }
                
                if (i > max_interrupt_work) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        /* disable interrupts on the nic */
                        writel(NVREG_IRQ_RX_ALL, base + NvRegIrqMask);
                        pci_push(base);
@@ -2144,7 +2226,7 @@ static irqreturn_t nv_nic_irq_rx(int foo, void *data, struct pt_regs *regs)
                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                        }
                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_rx.\n", dev->name, i);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                        break;
                }
@@ -2173,14 +2255,14 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data, struct pt_regs *regs)
                        break;
                
                if (events & NVREG_IRQ_LINK) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        nv_link_irq(dev);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                }
                if (np->need_linktimer && time_after(jiffies, np->link_timeout)) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        nv_linkchange(dev);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                        np->link_timeout = jiffies + LINK_TIMEOUT;
                }
                if (events & (NVREG_IRQ_UNKNOWN)) {
@@ -2188,7 +2270,7 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data, struct pt_regs *regs)
                                                dev->name, events);
                }
                if (i > max_interrupt_work) {
-                        spin_lock(&np->lock);
+                        spin_lock_irq(&np->lock);
                        /* disable interrupts on the nic */
                        writel(NVREG_IRQ_OTHER, base + NvRegIrqMask);
                        pci_push(base);
@@ -2198,7 +2280,7 @@ static irqreturn_t nv_nic_irq_other(int foo, void *data, struct pt_regs *regs)
                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
                        }
                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_other.\n", dev->name, i);
-                        spin_unlock(&np->lock);
+                        spin_unlock_irq(&np->lock);
                        break;
                }
@@ -2221,10 +2303,11 @@ static void nv_do_nic_poll(unsigned long data)
         * nv_nic_irq because that may decide to do otherwise
         */
-        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+        if (!using_multi_irqs(dev)) {
-            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+                if (np->msi_flags & NV_MSI_X_ENABLED)
-             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
-                disable_irq(dev->irq);
+                else
+                        disable_irq(dev->irq);
                mask = np->irqmask;
        } else {
                if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
@@ -2247,11 +2330,12 @@ static void nv_do_nic_poll(unsigned long data)
        writel(mask, base + NvRegIrqMask);
        pci_push(base);
-        if (!(np->msi_flags & NV_MSI_X_ENABLED) || 
+        if (!using_multi_irqs(dev)) {
-            ((np->msi_flags & NV_MSI_X_ENABLED) && 
-             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
                nv_nic_irq((int) 0, (void *) data, (struct pt_regs *) NULL);
-                enable_irq(dev->irq);
+                if (np->msi_flags & NV_MSI_X_ENABLED)
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
+                else
+                        enable_irq(dev->irq);
        } else {
                if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
                        nv_nic_irq_rx((int) 0, (void *) data, (struct pt_regs *) NULL);
@@ -2488,11 +2572,11 @@ static int nv_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 }
 #define FORCEDETH_REGS_VER      1
-#define FORCEDETH_REGS_SIZE     0x400 /* 256 32-bit registers */
 static int nv_get_regs_len(struct net_device *dev)
 {
-        return FORCEDETH_REGS_SIZE;
+        struct fe_priv *np = netdev_priv(dev);
+        return np->register_size;
 }
 static void nv_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *buf)
@@ -2504,7 +2588,7 @@ static void nv_get_regs(struct net_device *dev, struct ethtool_regs *regs, void
        regs->version = FORCEDETH_REGS_VER;
        spin_lock_irq(&np->lock);
-        for (i=0;i<FORCEDETH_REGS_SIZE/sizeof(u32);i++)
+        for (i = 0;i <= np->register_size/sizeof(u32); i++)
                rbuf[i] = readl(base + i*sizeof(u32));
        spin_unlock_irq(&np->lock);
 }
@@ -2531,6 +2615,18 @@ static int nv_nway_reset(struct net_device *dev)
        return ret;
 }
+#ifdef NETIF_F_TSO
+static int nv_set_tso(struct net_device *dev, u32 value)
+{
+        struct fe_priv *np = netdev_priv(dev);
+        if ((np->driver_data & DEV_HAS_CHECKSUM))
+                return ethtool_op_set_tso(dev, value);
+        else
+                return value ? -EOPNOTSUPP : 0;
+}
+#endif
 static struct ethtool_ops ops = {
        .get_drvinfo = nv_get_drvinfo,
        .get_link = ethtool_op_get_link,
@@ -2542,6 +2638,10 @@ static struct ethtool_ops ops = {
        .get_regs = nv_get_regs,
        .nway_reset = nv_nway_reset,
        .get_perm_addr = ethtool_op_get_perm_addr,
+#ifdef NETIF_F_TSO
+        .get_tso = ethtool_op_get_tso,
+        .set_tso = nv_set_tso
+#endif
 };
 static void nv_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
@@ -2598,6 +2698,113 @@ static void set_msix_vector_map(struct net_device *dev, u32 vector, u32 irqmask)
        writel(readl(base + NvRegMSIXMap1) | msixmap, base + NvRegMSIXMap1);
 }
+static int nv_request_irq(struct net_device *dev)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        int ret = 1;
+        int i;
+        if (np->msi_flags & NV_MSI_X_CAPABLE) {
+                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
+                        np->msi_x_entry[i].entry = i;
+                }
+                if ((ret = pci_enable_msix(np->pci_dev, np->msi_x_entry, (np->msi_flags & NV_MSI_X_VECTORS_MASK))) == 0) {
+                        np->msi_flags |= NV_MSI_X_ENABLED;
+                        if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT) {
+                                /* Request irq for rx handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, &nv_nic_irq_rx, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for rx %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_err;
+                                }
+                                /* Request irq for tx handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, &nv_nic_irq_tx, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for tx %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_free_rx;
+                                }
+                                /* Request irq for link and timer handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector, &nv_nic_irq_other, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for link %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_free_tx;
+                                }
+                                /* map interrupts to their respective vector */
+                                writel(0, base + NvRegMSIXMap0);
+                                writel(0, base + NvRegMSIXMap1);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_RX, NVREG_IRQ_RX_ALL);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_TX, NVREG_IRQ_TX_ALL);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_OTHER, NVREG_IRQ_OTHER);
+                        } else {
+                                /* Request irq for all interrupts */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_err;
+                                }
+                                /* map interrupts to vector 0 */
+                                writel(0, base + NvRegMSIXMap0);
+                                writel(0, base + NvRegMSIXMap1);
+                        }
+                }
+        }
+        if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) {
+                if ((ret = pci_enable_msi(np->pci_dev)) == 0) {
+                        np->msi_flags |= NV_MSI_ENABLED;
+                        if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
+                                printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
+                                pci_disable_msi(np->pci_dev);
+                                np->msi_flags &= ~NV_MSI_ENABLED;
+                                goto out_err;
+                        }
+                        /* map interrupts to vector 0 */
+                        writel(0, base + NvRegMSIMap0);
+                        writel(0, base + NvRegMSIMap1);
+                        /* enable msi vector 0 */
+                        writel(NVREG_MSI_VECTOR_0_ENABLED, base + NvRegMSIIrqMask);
+                }
+        }
+        if (ret != 0) {
+                if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0)
+                        goto out_err;
+        }
+        return 0;
+out_free_tx:
+        free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, dev);
+out_free_rx:
+        free_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, dev);
+out_err:
+        return 1;
+}
+static void nv_free_irq(struct net_device *dev)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        int i;
+        if (np->msi_flags & NV_MSI_X_ENABLED) {
+                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
+                        free_irq(np->msi_x_entry[i].vector, dev);
+                }
+                pci_disable_msix(np->pci_dev);
+                np->msi_flags &= ~NV_MSI_X_ENABLED;
+        } else {
+                free_irq(np->pci_dev->irq, dev);
+                if (np->msi_flags & NV_MSI_ENABLED) {
+                        pci_disable_msi(np->pci_dev);
+                        np->msi_flags &= ~NV_MSI_ENABLED;
+                }
+        }
+}
 static int nv_open(struct net_device *dev)
 {
        struct fe_priv *np = netdev_priv(dev);
@@ -2608,6 +2815,8 @@ static int nv_open(struct net_device *dev)
        dprintk(KERN_DEBUG "nv_open: begin\n");
        /* 1) erase previous misconfiguration */
+        if (np->driver_data & DEV_HAS_POWER_CNTRL)
+                nv_mac_reset(dev);
        /* 4.1-1: stop adapter: ignored, 4.3 seems to be overkill */
        writel(NVREG_MCASTADDRA_FORCE, base + NvRegMulticastAddrA);
        writel(0, base + NvRegMulticastAddrB);
@@ -2688,86 +2897,18 @@ static int nv_open(struct net_device *dev)
        udelay(10);
        writel(readl(base + NvRegPowerState) | NVREG_POWERSTATE_VALID, base + NvRegPowerState);
-        writel(0, base + NvRegIrqMask);
+        nv_disable_hw_interrupts(dev, np->irqmask);
        pci_push(base);
        writel(NVREG_MIISTAT_MASK2, base + NvRegMIIStatus);
        writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
        pci_push(base);
-        if (np->msi_flags & NV_MSI_X_CAPABLE) {
+        if (nv_request_irq(dev)) {
-                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
+                goto out_drain;
-                        np->msi_x_entry[i].entry = i;
-                }
-                if ((ret = pci_enable_msix(np->pci_dev, np->msi_x_entry, (np->msi_flags & NV_MSI_X_VECTORS_MASK))) == 0) {
-                        np->msi_flags |= NV_MSI_X_ENABLED;
-                        if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT) {
-                                /* Request irq for rx handling */
-                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, &nv_nic_irq_rx, SA_SHIRQ, dev->name, dev) != 0) {
-                                        printk(KERN_INFO "forcedeth: request_irq failed for rx %d\n", ret);
-                                        pci_disable_msix(np->pci_dev);
-                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
-                                        goto out_drain;
-                                }
-                                /* Request irq for tx handling */
-                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, &nv_nic_irq_tx, SA_SHIRQ, dev->name, dev) != 0) {
-                                        printk(KERN_INFO "forcedeth: request_irq failed for tx %d\n", ret);
-                                        pci_disable_msix(np->pci_dev);
-                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
-                                        goto out_drain;
-                                }
-                                /* Request irq for link and timer handling */
-                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector, &nv_nic_irq_other, SA_SHIRQ, dev->name, dev) != 0) {
-                                        printk(KERN_INFO "forcedeth: request_irq failed for link %d\n", ret);
-                                        pci_disable_msix(np->pci_dev);
-                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
-                                        goto out_drain;
-                                }
-                                /* map interrupts to their respective vector */
-                                writel(0, base + NvRegMSIXMap0);
-                                writel(0, base + NvRegMSIXMap1);
-                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_RX, NVREG_IRQ_RX_ALL);
-                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_TX, NVREG_IRQ_TX_ALL);
-                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_OTHER, NVREG_IRQ_OTHER);
-                        } else {
-                                /* Request irq for all interrupts */
-                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
-                                        printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
-                                        pci_disable_msix(np->pci_dev);
-                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
-                                        goto out_drain;
-                                }
-                                /* map interrupts to vector 0 */
-                                writel(0, base + NvRegMSIXMap0);
-                                writel(0, base + NvRegMSIXMap1);
-                        }
-                }
-        }
-        if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) {
-                if ((ret = pci_enable_msi(np->pci_dev)) == 0) {
-                        np->msi_flags |= NV_MSI_ENABLED;
-                        if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
-                                printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
-                                pci_disable_msi(np->pci_dev);
-                                np->msi_flags &= ~NV_MSI_ENABLED;
-                                goto out_drain;
-                        }
-                        /* map interrupts to vector 0 */
-                        writel(0, base + NvRegMSIMap0);
-                        writel(0, base + NvRegMSIMap1);
-                        /* enable msi vector 0 */
-                        writel(NVREG_MSI_VECTOR_0_ENABLED, base + NvRegMSIIrqMask);
-                }
-        }
-        if (ret != 0) {
-                if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0)
-                        goto out_drain;
        }
        /* ask for interrupts */
-        writel(np->irqmask, base + NvRegIrqMask);
+        nv_enable_hw_interrupts(dev, np->irqmask);
        spin_lock_irq(&np->lock);
        writel(NVREG_MCASTADDRA_FORCE, base + NvRegMulticastAddrA);
@@ -2811,7 +2952,6 @@ static int nv_close(struct net_device *dev)
 {
        struct fe_priv *np = netdev_priv(dev);
        u8 __iomem *base;
-        int i;
        spin_lock_irq(&np->lock);
        np->in_shutdown = 1;
@@ -2829,31 +2969,13 @@ static int nv_close(struct net_device *dev)
        /* disable interrupts on the nic or we will lock up */
        base = get_hwbase(dev);
-        if (np->msi_flags & NV_MSI_X_ENABLED) {
+        nv_disable_hw_interrupts(dev, np->irqmask);
-                writel(np->irqmask, base + NvRegIrqMask);
-        } else {
-                if (np->msi_flags & NV_MSI_ENABLED)
-                        writel(0, base + NvRegMSIIrqMask);
-                writel(0, base + NvRegIrqMask);
-        }
        pci_push(base);
        dprintk(KERN_INFO "%s: Irqmask is zero again\n", dev->name);
        spin_unlock_irq(&np->lock);
-        if (np->msi_flags & NV_MSI_X_ENABLED) {
+        nv_free_irq(dev);
-                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
-                        free_irq(np->msi_x_entry[i].vector, dev);
-                }
-                pci_disable_msix(np->pci_dev);
-                np->msi_flags &= ~NV_MSI_X_ENABLED;
-        } else {
-                free_irq(np->pci_dev->irq, dev);
-                if (np->msi_flags & NV_MSI_ENABLED) {
-                        pci_disable_msi(np->pci_dev);
-                        np->msi_flags &= ~NV_MSI_ENABLED;
-                }
-        }
        drain_ring(dev);
@@ -2878,6 +3000,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        unsigned long addr;
        u8 __iomem *base;
        int err, i;
+        u32 powerstate;
        dev = alloc_etherdev(sizeof(struct fe_priv));
        err = -ENOMEM;
@@ -2910,6 +3033,11 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        if (err < 0)
                goto out_disable;
+        if (id->driver_data & (DEV_HAS_VLAN|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL))
+                np->register_size = NV_PCI_REGSZ_VER2;
+        else
+                np->register_size = NV_PCI_REGSZ_VER1;
        err = -EINVAL;
        addr = 0;
        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
@@ -2918,7 +3046,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                                pci_resource_len(pci_dev, i),
                                pci_resource_flags(pci_dev, i));
                if (pci_resource_flags(pci_dev, i) & IORESOURCE_MEM &&
-                                pci_resource_len(pci_dev, i) >= NV_PCI_REGSZ) {
+                                pci_resource_len(pci_dev, i) >= np->register_size) {
                        addr = pci_resource_start(pci_dev, i);
                        break;
                }
@@ -2929,24 +3057,25 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                goto out_relreg;
        }
+        /* copy of driver data */
+        np->driver_data = id->driver_data;
        /* handle different descriptor versions */
        if (id->driver_data & DEV_HAS_HIGH_DMA) {
                /* packet format 3: supports 40-bit addressing */
                np->desc_ver = DESC_VER_3;
+                np->txrxctl_bits = NVREG_TXRXCTL_DESC_3;
                if (pci_set_dma_mask(pci_dev, DMA_39BIT_MASK)) {
                        printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n",
                                        pci_name(pci_dev));
                } else {
-                        if (pci_set_consistent_dma_mask(pci_dev, 0x0000007fffffffffULL)) {
+                        dev->features |= NETIF_F_HIGHDMA;
-                                printk(KERN_INFO "forcedeth: 64-bit DMA (consistent) failed for device %s.\n",
+                        printk(KERN_INFO "forcedeth: using HIGHDMA\n");
-                                        pci_name(pci_dev));
+                }
-                                goto out_relreg;
+                if (pci_set_consistent_dma_mask(pci_dev, 0x0000007fffffffffULL)) {
-                        } else {
+                        printk(KERN_INFO "forcedeth: 64-bit DMA (consistent) failed for device %s.\n",
-                                dev->features |= NETIF_F_HIGHDMA;
+                               pci_name(pci_dev));
-                                printk(KERN_INFO "forcedeth: using HIGHDMA\n");
-                        }
                }
-                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;
@@ -2986,7 +3115,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        }
        err = -ENOMEM;
-        np->base = ioremap(addr, NV_PCI_REGSZ);
+        np->base = ioremap(addr, np->register_size);
        if (!np->base)
                goto out_relreg;
        dev->base_addr = (unsigned long)np->base;
@@ -3062,6 +3191,20 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
        writel(0, base + NvRegWakeUpFlags);
        np->wolenabled = 0;
+        if (id->driver_data & DEV_HAS_POWER_CNTRL) {
+                u8 revision_id;
+                pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id);
+                /* take phy and nic out of low power mode */
+                powerstate = readl(base + NvRegPowerState2);
+                powerstate &= ~NVREG_POWERSTATE2_POWERUP_MASK;
+                if ((id->device == PCI_DEVICE_ID_NVIDIA_NVENET_12 ||
+                     id->device == PCI_DEVICE_ID_NVIDIA_NVENET_13) &&
+                    revision_id >= 0xA3)
+                        powerstate |= NVREG_POWERSTATE2_POWERUP_REV_A3;
+                writel(powerstate, base + NvRegPowerState2);
+        }
        if (np->desc_ver == DESC_VER_1) {
                np->tx_flags = NV_TX_VALID;
        } else {
@@ -3223,19 +3366,19 @@ static struct pci_device_id pci_tbl[] = {
        },
        {       /* MCP51 Ethernet Controller */
                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_12),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL,
        },
        {       /* MCP51 Ethernet Controller */
                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_13),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL,
        },
        {       /* 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_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL,
        },
        {       /* 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_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X|DEV_HAS_POWER_CNTRL,
        },
        {0,},
 };
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 771e25d8c417..218d31764c52 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -210,7 +210,8 @@ static int gfar_probe(struct platform_device *pdev)
                goto regs_fail;
        }
-        spin_lock_init(&priv->lock);
+        spin_lock_init(&priv->txlock);
+        spin_lock_init(&priv->rxlock);
        platform_set_drvdata(pdev, dev);
@@ -515,11 +516,13 @@ void stop_gfar(struct net_device *dev)
        phy_stop(priv->phydev);
        /* Lock it down */
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
+        spin_lock(&priv->rxlock);
        gfar_halt(dev);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock(&priv->rxlock);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        /* Free the IRQs */
        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
@@ -605,14 +608,15 @@ void gfar_start(struct net_device *dev)
        tempval |= DMACTRL_INIT_SETTINGS;
        gfar_write(&priv->regs->dmactrl, tempval);
-        /* Clear THLT, so that the DMA starts polling now */
-        gfar_write(&regs->tstat, TSTAT_CLEAR_THALT);
        /* Make sure we aren't stopped */
        tempval = gfar_read(&priv->regs->dmactrl);
        tempval &= ~(DMACTRL_GRS | DMACTRL_GTS);
        gfar_write(&priv->regs->dmactrl, tempval);
+        /* Clear THLT/RHLT, so that the DMA starts polling now */
+        gfar_write(&regs->tstat, TSTAT_CLEAR_THALT);
+        gfar_write(&regs->rstat, RSTAT_CLEAR_RHALT);
        /* Unmask the interrupts we look for */
        gfar_write(&regs->imask, IMASK_DEFAULT);
 }
@@ -928,12 +932,13 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        struct txfcb *fcb = NULL;
        struct txbd8 *txbdp;
        u16 status;
+        unsigned long flags;
        /* Update transmit stats */
        priv->stats.tx_bytes += skb->len;
        /* Lock priv now */
-        spin_lock_irq(&priv->lock);
+        spin_lock_irqsave(&priv->txlock, flags);
        /* Point at the first free tx descriptor */
        txbdp = priv->cur_tx;
@@ -1004,7 +1009,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        gfar_write(&priv->regs->tstat, TSTAT_CLEAR_THALT);
        /* Unlock priv */
-        spin_unlock_irq(&priv->lock);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        return 0;
 }
@@ -1049,7 +1054,7 @@ static void gfar_vlan_rx_register(struct net_device *dev,
        unsigned long flags;
        u32 tempval;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->rxlock, flags);
        priv->vlgrp = grp;
@@ -1076,7 +1081,7 @@ static void gfar_vlan_rx_register(struct net_device *dev,
                gfar_write(&priv->regs->rctrl, tempval);
        }
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
 }
@@ -1085,12 +1090,12 @@ static void gfar_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
        struct gfar_private *priv = netdev_priv(dev);
        unsigned long flags;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->rxlock, flags);
        if (priv->vlgrp)
                priv->vlgrp->vlan_devices[vid] = NULL;
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
 }
@@ -1179,7 +1184,7 @@ static irqreturn_t gfar_transmit(int irq, void *dev_id, struct pt_regs *regs)
        gfar_write(&priv->regs->ievent, IEVENT_TX_MASK);
        /* Lock priv */
-        spin_lock(&priv->lock);
+        spin_lock(&priv->txlock);
        bdp = priv->dirty_tx;
        while ((bdp->status & TXBD_READY) == 0) {
                /* If dirty_tx and cur_tx are the same, then either the */
@@ -1224,7 +1229,7 @@ static irqreturn_t gfar_transmit(int irq, void *dev_id, struct pt_regs *regs)
        else
                gfar_write(&priv->regs->txic, 0);
-        spin_unlock(&priv->lock);
+        spin_unlock(&priv->txlock);
        return IRQ_HANDLED;
 }
@@ -1305,9 +1310,10 @@ irqreturn_t gfar_receive(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);
 #ifdef CONFIG_GFAR_NAPI
        u32 tempval;
+#else
+        unsigned long flags;
 #endif
        /* Clear IEVENT, so rx interrupt isn't called again
@@ -1330,7 +1336,7 @@ irqreturn_t gfar_receive(int irq, void *dev_id, struct pt_regs *regs)
        }
 #else
-        spin_lock(&priv->lock);
+        spin_lock_irqsave(&priv->rxlock, flags);
        gfar_clean_rx_ring(dev, priv->rx_ring_size);
        /* If we are coalescing interrupts, update the timer */
@@ -1341,7 +1347,7 @@ irqreturn_t gfar_receive(int irq, void *dev_id, struct pt_regs *regs)
        else
                gfar_write(&priv->regs->rxic, 0);
-        spin_unlock(&priv->lock);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
 #endif
        return IRQ_HANDLED;
@@ -1490,13 +1496,6 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
        /* Update the current rxbd pointer to be the next one */
        priv->cur_rx = bdp;
-        /* If no packets have arrived since the
-         * last one we processed, clear the IEVENT RX and
-         * BSY bits so that another interrupt won't be
-         * generated when we set IMASK */
-        if (bdp->status & RXBD_EMPTY)
-                gfar_write(&priv->regs->ievent, IEVENT_RX_MASK);
        return howmany;
 }
@@ -1516,7 +1515,7 @@ static int gfar_poll(struct net_device *dev, int *budget)
        rx_work_limit -= howmany;
        *budget -= howmany;
-        if (rx_work_limit >= 0) {
+        if (rx_work_limit > 0) {
                netif_rx_complete(dev);
                /* Clear the halt bit in RSTAT */
@@ -1533,7 +1532,8 @@ static int gfar_poll(struct net_device *dev, int *budget)
                        gfar_write(&priv->regs->rxic, 0);
        }
-        return (rx_work_limit < 0) ? 1 : 0;
+        /* Return 1 if there's more work to do */
+        return (rx_work_limit > 0) ? 0 : 1;
 }
 #endif
@@ -1629,7 +1629,7 @@ static void adjust_link(struct net_device *dev)
        struct phy_device *phydev = priv->phydev;
        int new_state = 0;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
        if (phydev->link) {
                u32 tempval = gfar_read(&regs->maccfg2);
                u32 ecntrl = gfar_read(&regs->ecntrl);
@@ -1694,7 +1694,7 @@ static void adjust_link(struct net_device *dev)
        if (new_state && netif_msg_link(priv))
                phy_print_status(phydev);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->txlock, flags);
 }
 /* Update the hash table based on the current list of multicast
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index d37d5401be6e..127c98cf3336 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -656,43 +656,62 @@ struct gfar {
 * the buffer descriptor determines the actual condition.
 */
 struct gfar_private {
-        /* pointers to arrays of skbuffs for tx and rx */
+        /* Fields controlled by TX lock */
+        spinlock_t txlock;
+        /* Pointer to the array of skbuffs */
        struct sk_buff ** tx_skbuff;
-        struct sk_buff ** rx_skbuff;
-        /* indices pointing to the next free sbk in skb arrays */
+        /* next free skb in the array */
        u16 skb_curtx;
-        u16 skb_currx;
-        /* index of the first skb which hasn't been transmitted
+        /* First skb in line to be transmitted */
-         * yet. */
        u16 skb_dirtytx;
        /* Configuration info for the coalescing features */
        unsigned char txcoalescing;
        unsigned short txcount;
        unsigned short txtime;
+        /* Buffer descriptor pointers */
+        struct txbd8 *tx_bd_base;       /* First tx buffer descriptor */
+        struct txbd8 *cur_tx;           /* Next free ring entry */
+        struct txbd8 *dirty_tx;         /* First buffer in line
+                                           to be transmitted */
+        unsigned int tx_ring_size;
+        /* RX Locked fields */
+        spinlock_t rxlock;
+        /* skb array and index */
+        struct sk_buff ** rx_skbuff;
+        u16 skb_currx;
+        /* RX Coalescing values */
        unsigned char rxcoalescing;
        unsigned short rxcount;
        unsigned short rxtime;
-        /* GFAR addresses */
+        struct rxbd8 *rx_bd_base;       /* First Rx buffers */
-        struct rxbd8 *rx_bd_base;       /* Base addresses of Rx and Tx Buffers */
-        struct txbd8 *tx_bd_base;
        struct rxbd8 *cur_rx;           /* Next free rx ring entry */
-        struct txbd8 *cur_tx;           /* Next free ring entry */
-        struct txbd8 *dirty_tx;         /* The Ring entry to be freed. */
+        /* RX parameters */
-        struct gfar __iomem *regs;      /* Pointer to the GFAR memory mapped Registers */
+        unsigned int rx_ring_size;
-        u32 __iomem *hash_regs[16];
-        int hash_width;
-        struct net_device_stats stats; /* linux network statistics */
-        struct gfar_extra_stats extra_stats;
-        spinlock_t lock;
        unsigned int rx_buffer_size;
        unsigned int rx_stash_size;
        unsigned int rx_stash_index;
-        unsigned int tx_ring_size;
-        unsigned int rx_ring_size;
+        struct vlan_group *vlgrp;
+        /* Unprotected fields */
+        /* Pointer to the GFAR memory mapped Registers */
+        struct gfar __iomem *regs;
+        /* Hash registers and their width */
+        u32 __iomem *hash_regs[16];
+        int hash_width;
+        /* global parameters */
        unsigned int fifo_threshold;
        unsigned int fifo_starve;
        unsigned int fifo_starve_off;
@@ -702,13 +721,15 @@ struct gfar_private {
                extended_hash:1,
                bd_stash_en:1;
        unsigned short padding;
-        struct vlan_group *vlgrp;
-        /* Info structure initialized by board setup code */
        unsigned int interruptTransmit;
        unsigned int interruptReceive;
        unsigned int interruptError;
+        /* info structure initialized by platform code */
        struct gianfar_platform_data *einfo;
+        /* PHY stuff */
        struct phy_device *phydev;
        struct mii_bus *mii_bus;
        int oldspeed;
@@ -716,6 +737,10 @@ struct gfar_private {
        int oldlink;
        uint32_t msg_enable;
+        /* Network Statistics */
+        struct net_device_stats stats;
+        struct gfar_extra_stats extra_stats;
 };
 static inline u32 gfar_read(volatile unsigned __iomem *addr)
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 5de7b2e259dc..d69698c695ef 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -455,10 +455,14 @@ static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rva
                /* Halt TX and RX, and process the frames which
                 * have already been received */
-                spin_lock_irqsave(&priv->lock, flags);
+                spin_lock_irqsave(&priv->txlock, flags);
+                spin_lock(&priv->rxlock);
                gfar_halt(dev);
                gfar_clean_rx_ring(dev, priv->rx_ring_size);
-                spin_unlock_irqrestore(&priv->lock, flags);
+                spin_unlock(&priv->rxlock);
+                spin_unlock_irqrestore(&priv->txlock, flags);
                /* Now we take down the rings to rebuild them */
                stop_gfar(dev);
@@ -488,10 +492,14 @@ static int gfar_set_rx_csum(struct net_device *dev, uint32_t data)
                /* Halt TX and RX, and process the frames which
                 * have already been received */
-                spin_lock_irqsave(&priv->lock, flags);
+                spin_lock_irqsave(&priv->txlock, flags);
+                spin_lock(&priv->rxlock);
                gfar_halt(dev);
                gfar_clean_rx_ring(dev, priv->rx_ring_size);
-                spin_unlock_irqrestore(&priv->lock, flags);
+                spin_unlock(&priv->rxlock);
+                spin_unlock_irqrestore(&priv->txlock, flags);
                /* Now we take down the rings to rebuild them */
                stop_gfar(dev);
@@ -523,7 +531,7 @@ static int gfar_set_tx_csum(struct net_device *dev, uint32_t data)
        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
                return -EOPNOTSUPP;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
        gfar_halt(dev);
        if (data)
@@ -532,7 +540,7 @@ static int gfar_set_tx_csum(struct net_device *dev, uint32_t data)
                dev->features &= ~NETIF_F_IP_CSUM;
        gfar_start(dev);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        return 0;
 }
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index 51ef181b1368..a6d5c43199cb 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -82,7 +82,7 @@ static ssize_t gfar_set_bd_stash(struct class_device *cdev,
        else
                return count;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->rxlock, flags);
        /* Set the new stashing value */
        priv->bd_stash_en = new_setting;
@@ -96,7 +96,7 @@ static ssize_t gfar_set_bd_stash(struct class_device *cdev,
        gfar_write(&priv->regs->attr, temp);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
        return count;
 }
@@ -118,7 +118,7 @@ static ssize_t gfar_set_rx_stash_size(struct class_device *cdev,
        u32 temp;
        unsigned long flags;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->rxlock, flags);
        if (length > priv->rx_buffer_size)
                return count;
@@ -142,7 +142,7 @@ static ssize_t gfar_set_rx_stash_size(struct class_device *cdev,
        gfar_write(&priv->regs->attr, temp);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
        return count;
 }
@@ -166,7 +166,7 @@ static ssize_t gfar_set_rx_stash_index(struct class_device *cdev,
        u32 temp;
        unsigned long flags;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->rxlock, flags);
        if (index > priv->rx_stash_size)
                return count;
@@ -180,7 +180,7 @@ static ssize_t gfar_set_rx_stash_index(struct class_device *cdev,
        temp |= ATTRELI_EI(index);
        gfar_write(&priv->regs->attreli, flags);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->rxlock, flags);
        return count;
 }
@@ -205,7 +205,7 @@ static ssize_t gfar_set_fifo_threshold(struct class_device *cdev,
        if (length > GFAR_MAX_FIFO_THRESHOLD)
                return count;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
        priv->fifo_threshold = length;
@@ -214,7 +214,7 @@ static ssize_t gfar_set_fifo_threshold(struct class_device *cdev,
        temp |= length;
        gfar_write(&priv->regs->fifo_tx_thr, temp);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        return count;
 }
@@ -240,7 +240,7 @@ static ssize_t gfar_set_fifo_starve(struct class_device *cdev,
        if (num > GFAR_MAX_FIFO_STARVE)
                return count;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
        priv->fifo_starve = num;
@@ -249,7 +249,7 @@ static ssize_t gfar_set_fifo_starve(struct class_device *cdev,
        temp |= num;
        gfar_write(&priv->regs->fifo_tx_starve, temp);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        return count;
 }
@@ -274,7 +274,7 @@ static ssize_t gfar_set_fifo_starve_off(struct class_device *cdev,
        if (num > GFAR_MAX_FIFO_STARVE_OFF)
                return count;
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->txlock, flags);
        priv->fifo_starve_off = num;
@@ -283,7 +283,7 @@ static ssize_t gfar_set_fifo_starve_off(struct class_device *cdev,
        temp |= num;
        gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->txlock, flags);
        return count;
 }
diff --git a/drivers/net/hamradio/dmascc.c b/drivers/net/hamradio/dmascc.c
index 79a8fbcf5f93..0d5fccc984bb 100644
--- a/drivers/net/hamradio/dmascc.c
+++ b/drivers/net/hamradio/dmascc.c
@@ -582,7 +582,6 @@ static int __init setup_adapter(int card_base, int type, int n)
                INIT_WORK(&priv->rx_work, rx_bh, priv);
                dev->priv = priv;
                sprintf(dev->name, "dmascc%i", 2 * n + i);
-                SET_MODULE_OWNER(dev);
                dev->base_addr = card_base;
                dev->irq = irq;
                dev->open = scc_open;
diff --git a/drivers/net/hamradio/scc.c b/drivers/net/hamradio/scc.c
index 6ace0e914fd1..5927784df3f9 100644
--- a/drivers/net/hamradio/scc.c
+++ b/drivers/net/hamradio/scc.c
@@ -1550,7 +1550,6 @@ static unsigned char ax25_nocall[AX25_ADDR_LEN] =
 static void scc_net_setup(struct net_device *dev)
 {
-        SET_MODULE_OWNER(dev);
        dev->tx_queue_len    = 16;      /* should be enough... */
        dev->open            = scc_net_open;
diff --git a/drivers/net/hamradio/yam.c b/drivers/net/hamradio/yam.c
index fe22479eb202..b49884048caa 100644
--- a/drivers/net/hamradio/yam.c
+++ b/drivers/net/hamradio/yam.c
@@ -1098,7 +1098,6 @@ static void yam_setup(struct net_device *dev)
        dev->base_addr = yp->iobase;
        dev->irq = yp->irq;
-        SET_MODULE_OWNER(dev);
        dev->open = yam_open;
        dev->stop = yam_close;
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index 5e6d00752990..cff8598aa800 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -33,7 +33,7 @@ config DONGLE
 config ESI_DONGLE
        tristate "ESI JetEye PC dongle"
-        depends on DONGLE && IRDA
+        depends on IRTTY_SIR && DONGLE && IRDA
        help
          Say Y here if you want to build support for the Extended Systems
          JetEye PC dongle.  To compile it as a module, choose M here. The ESI
@@ -44,7 +44,7 @@ config ESI_DONGLE
 config ACTISYS_DONGLE
        tristate "ACTiSYS IR-220L and IR220L+ dongle"
-        depends on DONGLE && IRDA
+        depends on IRTTY_SIR && DONGLE && IRDA
        help
          Say Y here if you want to build support for the ACTiSYS IR-220L and
          IR220L+ dongles.  To compile it as a module, choose M here. The
@@ -55,7 +55,7 @@ config ACTISYS_DONGLE
 config TEKRAM_DONGLE
        tristate "Tekram IrMate 210B dongle"
-        depends on DONGLE && IRDA
+        depends on IRTTY_SIR && DONGLE && IRDA
        help
          Say Y here if you want to build support for the Tekram IrMate 210B
          dongle.  To compile it as a module, choose M here. The Tekram dongle
@@ -66,7 +66,7 @@ config TEKRAM_DONGLE
 config TOIM3232_DONGLE
        tristate "TOIM3232 IrDa dongle"
-        depends on DONGLE && IRDA
+        depends on IRTTY_SIR && DONGLE && IRDA
        help
          Say Y here if you want to build support for the Vishay/Temic
          TOIM3232 and TOIM4232 based dongles.
@@ -74,7 +74,7 @@ config TOIM3232_DONGLE
 config LITELINK_DONGLE
        tristate "Parallax LiteLink dongle"
-        depends on DONGLE && IRDA
+        depends on IRTTY_SIR && DONGLE && IRDA
        help
          Say Y here if you want to build support for the Parallax Litelink
          dongle.  To compile it as a module, choose M here.  The Parallax
@@ -85,7 +85,7 @@ config LITELINK_DONGLE
 config MA600_DONGLE
        tristate "Mobile Action MA600 dongle"
-        depends on DONGLE && IRDA && EXPERIMENTAL
+        depends on IRTTY_SIR && DONGLE && IRDA && EXPERIMENTAL
        help
          Say Y here if you want to build support for the Mobile Action MA600
          dongle.  To compile it as a module, choose M here. The MA600 dongle
@@ -98,7 +98,7 @@ config MA600_DONGLE
 config GIRBIL_DONGLE
        tristate "Greenwich GIrBIL dongle"
-        depends on DONGLE && IRDA && EXPERIMENTAL
+        depends on IRTTY_SIR && DONGLE && IRDA && EXPERIMENTAL
        help
          Say Y here if you want to build support for the Greenwich GIrBIL
          dongle.  If you want to compile it as a module, choose M here.
@@ -109,7 +109,7 @@ config GIRBIL_DONGLE
 config MCP2120_DONGLE
        tristate "Microchip MCP2120"
-        depends on DONGLE && IRDA && EXPERIMENTAL
+        depends on IRTTY_SIR && DONGLE && IRDA && EXPERIMENTAL
        help
          Say Y here if you want to build support for the Microchip MCP2120
          dongle.  If you want to compile it as a module, choose M here.
@@ -123,7 +123,7 @@ config MCP2120_DONGLE
 config OLD_BELKIN_DONGLE
        tristate "Old Belkin dongle"
-        depends on DONGLE && IRDA && EXPERIMENTAL
+        depends on IRTTY_SIR && DONGLE && IRDA && EXPERIMENTAL
        help
          Say Y here if you want to build support for the Adaptec Airport 1000
          and 2000 dongles.  If you want to compile it as a module, choose
@@ -132,7 +132,7 @@ config OLD_BELKIN_DONGLE
 config ACT200L_DONGLE
        tristate "ACTiSYS IR-200L dongle"
-        depends on DONGLE && IRDA && EXPERIMENTAL
+        depends on IRTTY_SIR && DONGLE && IRDA && EXPERIMENTAL
        help
          Say Y here if you want to build support for the ACTiSYS IR-200L
          dongle. If you want to compile it as a module, choose M here.
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
index 27ab75f20799..c1ce2398efea 100644
--- a/drivers/net/irda/Makefile
+++ b/drivers/net/irda/Makefile
@@ -46,4 +46,4 @@ obj-$(CONFIG_MA600_DONGLE)	+= ma600-sir.o
 obj-$(CONFIG_TOIM3232_DONGLE)   += toim3232-sir.o
 # The SIR helper module
-sir-dev-objs := sir_dev.o sir_dongle.o sir_kthread.o
+sir-dev-objs := sir_dev.o sir_dongle.o
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 606243d11793..cd87593e4e8a 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1778,7 +1778,7 @@ static int irda_usb_probe(struct usb_interface *intf,
        if (self->needspatch) {
                ret = usb_control_msg (self->usbdev, usb_sndctrlpipe (self->usbdev, 0),
-                                       0x02, 0x40, 0, 0, 0, 0, msecs_to_jiffies(500));
+                                       0x02, 0x40, 0, 0, NULL, 0, 500);
                if (ret < 0) {
                        IRDA_DEBUG (0, "usb_control_msg failed %d\n", ret);
                        goto err_out_3;
@@ -1815,14 +1815,14 @@ static int irda_usb_probe(struct usb_interface *intf,
                self->needspatch = (ret < 0);
                if (ret < 0) {
                        printk("patch_device failed\n");
-                        goto err_out_4;
+                        goto err_out_5;
                }
                /* replace IrDA class descriptor with what patched device is now reporting */
                irda_desc = irda_usb_find_class_desc (self->usbintf);
                if (irda_desc == NULL) {
                        ret = -ENODEV;
-                        goto err_out_4;
+                        goto err_out_5;
                }
                if (self->irda_desc)
                        kfree (self->irda_desc);
@@ -1832,6 +1832,8 @@ static int irda_usb_probe(struct usb_interface *intf,
        return 0;
+err_out_5:
+        unregister_netdev(self->netdev);
 err_out_4:
        kfree(self->speed_buff);
 err_out_3:
diff --git a/drivers/net/irda/sir-dev.h b/drivers/net/irda/sir-dev.h
index f69fb4cec76f..9fa294a546d6 100644
--- a/drivers/net/irda/sir-dev.h
+++ b/drivers/net/irda/sir-dev.h
@@ -15,23 +15,14 @@
 #define IRDA_SIR_H
 #include <linux/netdevice.h>
+#include <linux/workqueue.h>
 #include <net/irda/irda.h>
 #include <net/irda/irda_device.h>               // iobuff_t
-/* FIXME: unify irda_request with sir_fsm! */
-struct irda_request {
-        struct list_head lh_request;
-        unsigned long pending;
-        void (*func)(void *);
-        void *data;
-        struct timer_list timer;
-};
 struct sir_fsm {
        struct semaphore        sem;
-        struct irda_request     rq;
+        struct work_struct      work;
        unsigned                state, substate;
        int                     param;
        int                     result;
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index ea7c9464d46a..3b5854d10c17 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -23,6 +23,298 @@
 #include "sir-dev.h"
+static struct workqueue_struct *irda_sir_wq;
+/* STATE MACHINE */
+/* substate handler of the config-fsm to handle the cases where we want
+ * to wait for transmit completion before changing the port configuration
+ */
+static int sirdev_tx_complete_fsm(struct sir_dev *dev)
+{
+        struct sir_fsm *fsm = &dev->fsm;
+        unsigned next_state, delay;
+        unsigned bytes_left;
+        do {
+                next_state = fsm->substate;     /* default: stay in current substate */
+                delay = 0;
+                switch(fsm->substate) {
+                case SIRDEV_STATE_WAIT_XMIT:
+                        if (dev->drv->chars_in_buffer)
+                                bytes_left = dev->drv->chars_in_buffer(dev);
+                        else
+                                bytes_left = 0;
+                        if (!bytes_left) {
+                                next_state = SIRDEV_STATE_WAIT_UNTIL_SENT;
+                                break;
+                        }
+                        if (dev->speed > 115200)
+                                delay = (bytes_left*8*10000) / (dev->speed/100);
+                        else if (dev->speed > 0)
+                                delay = (bytes_left*10*10000) / (dev->speed/100);
+                        else
+                                delay = 0;
+                        /* expected delay (usec) until remaining bytes are sent */
+                        if (delay < 100) {
+                                udelay(delay);
+                                delay = 0;
+                                break;
+                        }
+                        /* sleep some longer delay (msec) */
+                        delay = (delay+999) / 1000;
+                        break;
+                case SIRDEV_STATE_WAIT_UNTIL_SENT:
+                        /* block until underlaying hardware buffer are empty */
+                        if (dev->drv->wait_until_sent)
+                                dev->drv->wait_until_sent(dev);
+                        next_state = SIRDEV_STATE_TX_DONE;
+                        break;
+                case SIRDEV_STATE_TX_DONE:
+                        return 0;
+                default:
+                        IRDA_ERROR("%s - undefined state\n", __FUNCTION__);
+                        return -EINVAL;
+                }
+                fsm->substate = next_state;
+        } while (delay == 0);
+        return delay;
+}
+/*
+ * Function sirdev_config_fsm
+ *
+ * State machine to handle the configuration of the device (and attached dongle, if any).
+ * This handler is scheduled for execution in kIrDAd context, so we can sleep.
+ * however, kIrDAd is shared by all sir_dev devices so we better don't sleep there too
+ * long. Instead, for longer delays we start a timer to reschedule us later.
+ * On entry, fsm->sem is always locked and the netdev xmit queue stopped.
+ * Both must be unlocked/restarted on completion - but only on final exit.
+ */
+static void sirdev_config_fsm(void *data)
+{
+        struct sir_dev *dev = data;
+        struct sir_fsm *fsm = &dev->fsm;
+        int next_state;
+        int ret = -1;
+        unsigned delay;
+        IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies);
+        do {
+                IRDA_DEBUG(3, "%s - state=0x%04x / substate=0x%04x\n",
+                        __FUNCTION__, fsm->state, fsm->substate);
+                next_state = fsm->state;
+                delay = 0;
+                switch(fsm->state) {
+                case SIRDEV_STATE_DONGLE_OPEN:
+                        if (dev->dongle_drv != NULL) {
+                                ret = sirdev_put_dongle(dev);
+                                if (ret) {
+                                        fsm->result = -EINVAL;
+                                        next_state = SIRDEV_STATE_ERROR;
+                                        break;
+                                }
+                        }
+                        /* Initialize dongle */
+                        ret = sirdev_get_dongle(dev, fsm->param);
+                        if (ret) {
+                                fsm->result = ret;
+                                next_state = SIRDEV_STATE_ERROR;
+                                break;
+                        }
+                        /* Dongles are powered through the modem control lines which
+                         * were just set during open. Before resetting, let's wait for
+                         * the power to stabilize. This is what some dongle drivers did
+                         * in open before, while others didn't - should be safe anyway.
+                         */
+                        delay = 50;
+                        fsm->substate = SIRDEV_STATE_DONGLE_RESET;
+                        next_state = SIRDEV_STATE_DONGLE_RESET;
+                        fsm->param = 9600;
+                        break;
+                case SIRDEV_STATE_DONGLE_CLOSE:
+                        /* shouldn't we just treat this as success=? */
+                        if (dev->dongle_drv == NULL) {
+                                fsm->result = -EINVAL;
+                                next_state = SIRDEV_STATE_ERROR;
+                                break;
+                        }
+                        ret = sirdev_put_dongle(dev);
+                        if (ret) {
+                                fsm->result = ret;
+                                next_state = SIRDEV_STATE_ERROR;
+                                break;
+                        }
+                        next_state = SIRDEV_STATE_DONE;
+                        break;
+                case SIRDEV_STATE_SET_DTR_RTS:
+                        ret = sirdev_set_dtr_rts(dev,
+                                (fsm->param&0x02) ? TRUE : FALSE,
+                                (fsm->param&0x01) ? TRUE : FALSE);
+                        next_state = SIRDEV_STATE_DONE;
+                        break;
+                case SIRDEV_STATE_SET_SPEED:
+                        fsm->substate = SIRDEV_STATE_WAIT_XMIT;
+                        next_state = SIRDEV_STATE_DONGLE_CHECK;
+                        break;
+                case SIRDEV_STATE_DONGLE_CHECK:
+                        ret = sirdev_tx_complete_fsm(dev);
+                        if (ret < 0) {
+                                fsm->result = ret;
+                                next_state = SIRDEV_STATE_ERROR;
+                                break;
+                        }
+                        if ((delay=ret) != 0)
+                                break;
+                        if (dev->dongle_drv) {
+                                fsm->substate = SIRDEV_STATE_DONGLE_RESET;
+                                next_state = SIRDEV_STATE_DONGLE_RESET;
+                        }
+                        else {
+                                dev->speed = fsm->param;
+                                next_state = SIRDEV_STATE_PORT_SPEED;
+                        }
+                        break;
+                case SIRDEV_STATE_DONGLE_RESET:
+                        if (dev->dongle_drv->reset) {
+                                ret = dev->dongle_drv->reset(dev);
+                                if (ret < 0) {
+                                        fsm->result = ret;
+                                        next_state = SIRDEV_STATE_ERROR;
+                                        break;
+                                }
+                        }
+                        else
+                                ret = 0;
+                        if ((delay=ret) == 0) {
+                                /* set serial port according to dongle default speed */
+                                if (dev->drv->set_speed)
+                                        dev->drv->set_speed(dev, dev->speed);
+                                fsm->substate = SIRDEV_STATE_DONGLE_SPEED;
+                                next_state = SIRDEV_STATE_DONGLE_SPEED;
+                        }
+                        break;
+                case SIRDEV_STATE_DONGLE_SPEED:
+                        if (dev->dongle_drv->reset) {
+                                ret = dev->dongle_drv->set_speed(dev, fsm->param);
+                                if (ret < 0) {
+                                        fsm->result = ret;
+                                        next_state = SIRDEV_STATE_ERROR;
+                                        break;
+                                }
+                        }
+                        else
+                                ret = 0;
+                        if ((delay=ret) == 0)
+                                next_state = SIRDEV_STATE_PORT_SPEED;
+                        break;
+                case SIRDEV_STATE_PORT_SPEED:
+                        /* Finally we are ready to change the serial port speed */
+                        if (dev->drv->set_speed)
+                                dev->drv->set_speed(dev, dev->speed);
+                        dev->new_speed = 0;
+                        next_state = SIRDEV_STATE_DONE;
+                        break;
+                case SIRDEV_STATE_DONE:
+                        /* Signal network layer so it can send more frames */
+                        netif_wake_queue(dev->netdev);
+                        next_state = SIRDEV_STATE_COMPLETE;
+                        break;
+                default:
+                        IRDA_ERROR("%s - undefined state\n", __FUNCTION__);
+                        fsm->result = -EINVAL;
+                        /* fall thru */
+                case SIRDEV_STATE_ERROR:
+                        IRDA_ERROR("%s - error: %d\n", __FUNCTION__, fsm->result);
+#if 0   /* don't enable this before we have netdev->tx_timeout to recover */
+                        netif_stop_queue(dev->netdev);
+#else
+                        netif_wake_queue(dev->netdev);
+#endif
+                        /* fall thru */
+                case SIRDEV_STATE_COMPLETE:
+                        /* config change finished, so we are not busy any longer */
+                        sirdev_enable_rx(dev);
+                        up(&fsm->sem);
+                        return;
+                }
+                fsm->state = next_state;
+        } while(!delay);
+        queue_delayed_work(irda_sir_wq, &fsm->work, msecs_to_jiffies(delay));
+}
+/* schedule some device configuration task for execution by kIrDAd
+ * on behalf of the above state machine.
+ * can be called from process or interrupt/tasklet context.
+ */
+int sirdev_schedule_request(struct sir_dev *dev, int initial_state, unsigned param)
+{
+        struct sir_fsm *fsm = &dev->fsm;
+        IRDA_DEBUG(2, "%s - state=0x%04x / param=%u\n", __FUNCTION__, initial_state, param);
+        if (down_trylock(&fsm->sem)) {
+                if (in_interrupt()  ||  in_atomic()  ||  irqs_disabled()) {
+                        IRDA_DEBUG(1, "%s(), state machine busy!\n", __FUNCTION__);
+                        return -EWOULDBLOCK;
+                } else
+                        down(&fsm->sem);
+        }
+        if (fsm->state == SIRDEV_STATE_DEAD) {
+                /* race with sirdev_close should never happen */
+                IRDA_ERROR("%s(), instance staled!\n", __FUNCTION__);
+                up(&fsm->sem);
+                return -ESTALE;         /* or better EPIPE? */
+        }
+        netif_stop_queue(dev->netdev);
+        atomic_set(&dev->enable_rx, 0);
+        fsm->state = initial_state;
+        fsm->param = param;
+        fsm->result = 0;
+        INIT_WORK(&fsm->work, sirdev_config_fsm, dev);
+        queue_work(irda_sir_wq, &fsm->work);
+        return 0;
+}
 /***************************************************************************/
 void sirdev_enable_rx(struct sir_dev *dev)
@@ -619,10 +911,6 @@ struct sir_dev * sirdev_get_instance(const struct sir_driver *drv, const char *n
        spin_lock_init(&dev->tx_lock);
        init_MUTEX(&dev->fsm.sem);
-        INIT_LIST_HEAD(&dev->fsm.rq.lh_request);
-        dev->fsm.rq.pending = 0;
-        init_timer(&dev->fsm.rq.timer);
        dev->drv = drv;
        dev->netdev = ndev;
@@ -682,3 +970,22 @@ int sirdev_put_instance(struct sir_dev *dev)
 }
 EXPORT_SYMBOL(sirdev_put_instance);
+static int __init sir_wq_init(void)
+{
+        irda_sir_wq = create_singlethread_workqueue("irda_sir_wq");
+        if (!irda_sir_wq)
+                return -ENOMEM;
+        return 0;
+}
+static void __exit sir_wq_exit(void)
+{
+        destroy_workqueue(irda_sir_wq);
+}
+module_init(sir_wq_init);
+module_exit(sir_wq_exit);
+MODULE_AUTHOR("Martin Diehl <info@mdiehl.de>");
+MODULE_DESCRIPTION("IrDA SIR core");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/irda/sir_kthread.c b/drivers/net/irda/sir_kthread.c
deleted file mode 100644
index e3904d6bfecd..000000000000
--- a/drivers/net/irda/sir_kthread.c
+++ /dev/null
@@ -1,508 +0,0 @@
-/*********************************************************************
- *
- *      sir_kthread.c:          dedicated thread to process scheduled
- *                              sir device setup requests
- *
- *      Copyright (c) 2002 Martin Diehl
- *
- *      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/version.h>
-#include <linux/init.h>
-#include <linux/smp_lock.h>
-#include <linux/completion.h>
-#include <linux/delay.h>
-#include <net/irda/irda.h>
-#include "sir-dev.h"
-/**************************************************************************
- *
- * kIrDAd kernel thread and config state machine
- *
- */
-struct irda_request_queue {
-        struct list_head request_list;
-        spinlock_t lock;
-        task_t *thread;
-        struct completion exit;
-        wait_queue_head_t kick, done;
-        atomic_t num_pending;
-};
-static struct irda_request_queue irda_rq_queue;
-static int irda_queue_request(struct irda_request *rq)
-{
-        int ret = 0;
-        unsigned long flags;
-        if (!test_and_set_bit(0, &rq->pending)) {
-                spin_lock_irqsave(&irda_rq_queue.lock, flags);
-                list_add_tail(&rq->lh_request, &irda_rq_queue.request_list);
-                wake_up(&irda_rq_queue.kick);
-                atomic_inc(&irda_rq_queue.num_pending);
-                spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
-                ret = 1;
-        }
-        return ret;
-}
-static void irda_request_timer(unsigned long data)
-{
-        struct irda_request *rq = (struct irda_request *)data;
-        unsigned long flags;
-        
-        spin_lock_irqsave(&irda_rq_queue.lock, flags);
-        list_add_tail(&rq->lh_request, &irda_rq_queue.request_list);
-        wake_up(&irda_rq_queue.kick);
-        spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
-}
-static int irda_queue_delayed_request(struct irda_request *rq, unsigned long delay)
-{
-        int ret = 0;
-        struct timer_list *timer = &rq->timer;
-        if (!test_and_set_bit(0, &rq->pending)) {
-                timer->expires = jiffies + delay;
-                timer->function = irda_request_timer;
-                timer->data = (unsigned long)rq;
-                atomic_inc(&irda_rq_queue.num_pending);
-                add_timer(timer);
-                ret = 1;
-        }
-        return ret;
-}
-static void run_irda_queue(void)
-{
-        unsigned long flags;
-        struct list_head *entry, *tmp;
-        struct irda_request *rq;
-        spin_lock_irqsave(&irda_rq_queue.lock, flags);
-        list_for_each_safe(entry, tmp, &irda_rq_queue.request_list) {
-                rq = list_entry(entry, struct irda_request, lh_request);
-                list_del_init(entry);
-                spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
-                clear_bit(0, &rq->pending);
-                rq->func(rq->data);
-                if (atomic_dec_and_test(&irda_rq_queue.num_pending))
-                        wake_up(&irda_rq_queue.done);
-                spin_lock_irqsave(&irda_rq_queue.lock, flags);
-        }
-        spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
-}               
-static int irda_thread(void *startup)
-{
-        DECLARE_WAITQUEUE(wait, current);
-        daemonize("kIrDAd");
-        irda_rq_queue.thread = current;
-        complete((struct completion *)startup);
-        while (irda_rq_queue.thread != NULL) {
-                /* We use TASK_INTERRUPTIBLE, rather than
-                 * TASK_UNINTERRUPTIBLE.  Andrew Morton made this
-                 * change ; he told me that it is safe, because "signal
-                 * blocking is now handled in daemonize()", he added
-                 * that the problem is that "uninterruptible sleep
-                 * contributes to load average", making user worry.
-                 * Jean II */
-                set_task_state(current, TASK_INTERRUPTIBLE);
-                add_wait_queue(&irda_rq_queue.kick, &wait);
-                if (list_empty(&irda_rq_queue.request_list))
-                        schedule();
-                else
-                        __set_task_state(current, TASK_RUNNING);
-                remove_wait_queue(&irda_rq_queue.kick, &wait);
-                /* make swsusp happy with our thread */
-                try_to_freeze();
-                run_irda_queue();
-        }
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,35)
-        reparent_to_init();
-#endif
-        complete_and_exit(&irda_rq_queue.exit, 0);
-        /* never reached */
-        return 0;
-}
-static void flush_irda_queue(void)
-{
-        if (atomic_read(&irda_rq_queue.num_pending)) {
-                DECLARE_WAITQUEUE(wait, current);
-                if (!list_empty(&irda_rq_queue.request_list))
-                        run_irda_queue();
-                set_task_state(current, TASK_UNINTERRUPTIBLE);
-                add_wait_queue(&irda_rq_queue.done, &wait);
-                if (atomic_read(&irda_rq_queue.num_pending))
-                        schedule();
-                else
-                        __set_task_state(current, TASK_RUNNING);
-                remove_wait_queue(&irda_rq_queue.done, &wait);
-        }
-}
-/* substate handler of the config-fsm to handle the cases where we want
- * to wait for transmit completion before changing the port configuration
- */
-static int irda_tx_complete_fsm(struct sir_dev *dev)
-{
-        struct sir_fsm *fsm = &dev->fsm;
-        unsigned next_state, delay;
-        unsigned bytes_left;
-        do {
-                next_state = fsm->substate;     /* default: stay in current substate */
-                delay = 0;
-                switch(fsm->substate) {
-                case SIRDEV_STATE_WAIT_XMIT:
-                        if (dev->drv->chars_in_buffer)
-                                bytes_left = dev->drv->chars_in_buffer(dev);
-                        else
-                                bytes_left = 0;
-                        if (!bytes_left) {
-                                next_state = SIRDEV_STATE_WAIT_UNTIL_SENT;
-                                break;
-                        }
-                        if (dev->speed > 115200)
-                                delay = (bytes_left*8*10000) / (dev->speed/100);
-                        else if (dev->speed > 0)
-                                delay = (bytes_left*10*10000) / (dev->speed/100);
-                        else
-                                delay = 0;
-                        /* expected delay (usec) until remaining bytes are sent */
-                        if (delay < 100) {
-                                udelay(delay);
-                                delay = 0;
-                                break;
-                        }
-                        /* sleep some longer delay (msec) */
-                        delay = (delay+999) / 1000;
-                        break;
-                case SIRDEV_STATE_WAIT_UNTIL_SENT:
-                        /* block until underlaying hardware buffer are empty */
-                        if (dev->drv->wait_until_sent)
-                                dev->drv->wait_until_sent(dev);
-                        next_state = SIRDEV_STATE_TX_DONE;
-                        break;
-                case SIRDEV_STATE_TX_DONE:
-                        return 0;
-                default:
-                        IRDA_ERROR("%s - undefined state\n", __FUNCTION__);
-                        return -EINVAL;
-                }
-                fsm->substate = next_state;
-        } while (delay == 0);
-        return delay;
-}
-/*
- * Function irda_config_fsm
- *
- * State machine to handle the configuration of the device (and attached dongle, if any).
- * This handler is scheduled for execution in kIrDAd context, so we can sleep.
- * however, kIrDAd is shared by all sir_dev devices so we better don't sleep there too
- * long. Instead, for longer delays we start a timer to reschedule us later.
- * On entry, fsm->sem is always locked and the netdev xmit queue stopped.
- * Both must be unlocked/restarted on completion - but only on final exit.
- */
-static void irda_config_fsm(void *data)
-{
-        struct sir_dev *dev = data;
-        struct sir_fsm *fsm = &dev->fsm;
-        int next_state;
-        int ret = -1;
-        unsigned delay;
-        IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies); 
-        do {
-                IRDA_DEBUG(3, "%s - state=0x%04x / substate=0x%04x\n",
-                        __FUNCTION__, fsm->state, fsm->substate);
-                next_state = fsm->state;
-                delay = 0;
-                switch(fsm->state) {
-                case SIRDEV_STATE_DONGLE_OPEN:
-                        if (dev->dongle_drv != NULL) {
-                                ret = sirdev_put_dongle(dev);
-                                if (ret) {
-                                        fsm->result = -EINVAL;
-                                        next_state = SIRDEV_STATE_ERROR;
-                                        break;
-                                }
-                        }
-                        /* Initialize dongle */
-                        ret = sirdev_get_dongle(dev, fsm->param);
-                        if (ret) {
-                                fsm->result = ret;
-                                next_state = SIRDEV_STATE_ERROR;
-                                break;
-                        }
-                        /* Dongles are powered through the modem control lines which
-                         * were just set during open. Before resetting, let's wait for
-                         * the power to stabilize. This is what some dongle drivers did
-                         * in open before, while others didn't - should be safe anyway.
-                         */
-                        delay = 50;
-                        fsm->substate = SIRDEV_STATE_DONGLE_RESET;
-                        next_state = SIRDEV_STATE_DONGLE_RESET;
-                        fsm->param = 9600;
-                        break;
-                case SIRDEV_STATE_DONGLE_CLOSE:
-                        /* shouldn't we just treat this as success=? */
-                        if (dev->dongle_drv == NULL) {
-                                fsm->result = -EINVAL;
-                                next_state = SIRDEV_STATE_ERROR;
-                                break;
-                        }
-                        ret = sirdev_put_dongle(dev);
-                        if (ret) {
-                                fsm->result = ret;
-                                next_state = SIRDEV_STATE_ERROR;
-                                break;
-                        }
-                        next_state = SIRDEV_STATE_DONE;
-                        break;
-                case SIRDEV_STATE_SET_DTR_RTS:
-                        ret = sirdev_set_dtr_rts(dev,
-                                (fsm->param&0x02) ? TRUE : FALSE,
-                                (fsm->param&0x01) ? TRUE : FALSE);
-                        next_state = SIRDEV_STATE_DONE;
-                        break;
-                case SIRDEV_STATE_SET_SPEED:
-                        fsm->substate = SIRDEV_STATE_WAIT_XMIT;
-                        next_state = SIRDEV_STATE_DONGLE_CHECK;
-                        break;
-                case SIRDEV_STATE_DONGLE_CHECK:
-                        ret = irda_tx_complete_fsm(dev);
-                        if (ret < 0) {
-                                fsm->result = ret;
-                                next_state = SIRDEV_STATE_ERROR;
-                                break;
-                        }
-                        if ((delay=ret) != 0)
-                                break;
-                        if (dev->dongle_drv) {
-                                fsm->substate = SIRDEV_STATE_DONGLE_RESET;
-                                next_state = SIRDEV_STATE_DONGLE_RESET;
-                        }
-                        else {
-                                dev->speed = fsm->param;
-                                next_state = SIRDEV_STATE_PORT_SPEED;
-                        }
-                        break;
-                case SIRDEV_STATE_DONGLE_RESET:
-                        if (dev->dongle_drv->reset) {
-                                ret = dev->dongle_drv->reset(dev);      
-                                if (ret < 0) {
-                                        fsm->result = ret;
-                                        next_state = SIRDEV_STATE_ERROR;
-                                        break;
-                                }
-                        }
-                        else
-                                ret = 0;
-                        if ((delay=ret) == 0) {
-                                /* set serial port according to dongle default speed */
-                                if (dev->drv->set_speed)
-                                        dev->drv->set_speed(dev, dev->speed);
-                                fsm->substate = SIRDEV_STATE_DONGLE_SPEED;
-                                next_state = SIRDEV_STATE_DONGLE_SPEED;
-                        }
-                        break;
-                case SIRDEV_STATE_DONGLE_SPEED:                         
-                        if (dev->dongle_drv->reset) {
-                                ret = dev->dongle_drv->set_speed(dev, fsm->param);
-                                if (ret < 0) {
-                                        fsm->result = ret;
-                                        next_state = SIRDEV_STATE_ERROR;
-                                        break;
-                                }
-                        }
-                        else
-                                ret = 0;
-                        if ((delay=ret) == 0)
-                                next_state = SIRDEV_STATE_PORT_SPEED;
-                        break;
-                case SIRDEV_STATE_PORT_SPEED:
-                        /* Finally we are ready to change the serial port speed */
-                        if (dev->drv->set_speed)
-                                dev->drv->set_speed(dev, dev->speed);
-                        dev->new_speed = 0;
-                        next_state = SIRDEV_STATE_DONE;
-                        break;
-                case SIRDEV_STATE_DONE:
-                        /* Signal network layer so it can send more frames */
-                        netif_wake_queue(dev->netdev);
-                        next_state = SIRDEV_STATE_COMPLETE;
-                        break;
-                default:
-                        IRDA_ERROR("%s - undefined state\n", __FUNCTION__);
-                        fsm->result = -EINVAL;
-                        /* fall thru */
-                case SIRDEV_STATE_ERROR:
-                        IRDA_ERROR("%s - error: %d\n", __FUNCTION__, fsm->result);
-#if 0   /* don't enable this before we have netdev->tx_timeout to recover */
-                        netif_stop_queue(dev->netdev);
-#else
-                        netif_wake_queue(dev->netdev);
-#endif
-                        /* fall thru */
-                case SIRDEV_STATE_COMPLETE:
-                        /* config change finished, so we are not busy any longer */
-                        sirdev_enable_rx(dev);
-                        up(&fsm->sem);
-                        return;
-                }
-                fsm->state = next_state;
-        } while(!delay);
-        irda_queue_delayed_request(&fsm->rq, msecs_to_jiffies(delay));
-}
-/* schedule some device configuration task for execution by kIrDAd
- * on behalf of the above state machine.
- * can be called from process or interrupt/tasklet context.
- */
-int sirdev_schedule_request(struct sir_dev *dev, int initial_state, unsigned param)
-{
-        struct sir_fsm *fsm = &dev->fsm;
-        int xmit_was_down;
-        IRDA_DEBUG(2, "%s - state=0x%04x / param=%u\n", __FUNCTION__, initial_state, param);
-        if (down_trylock(&fsm->sem)) {
-                if (in_interrupt()  ||  in_atomic()  ||  irqs_disabled()) {
-                        IRDA_DEBUG(1, "%s(), state machine busy!\n", __FUNCTION__);
-                        return -EWOULDBLOCK;
-                } else
-                        down(&fsm->sem);
-        }
-        if (fsm->state == SIRDEV_STATE_DEAD) {
-                /* race with sirdev_close should never happen */
-                IRDA_ERROR("%s(), instance staled!\n", __FUNCTION__);
-                up(&fsm->sem);
-                return -ESTALE;         /* or better EPIPE? */
-        }
-        xmit_was_down = netif_queue_stopped(dev->netdev);
-        netif_stop_queue(dev->netdev);
-        atomic_set(&dev->enable_rx, 0);
-        fsm->state = initial_state;
-        fsm->param = param;
-        fsm->result = 0;
-        INIT_LIST_HEAD(&fsm->rq.lh_request);
-        fsm->rq.pending = 0;
-        fsm->rq.func = irda_config_fsm;
-        fsm->rq.data = dev;
-        if (!irda_queue_request(&fsm->rq)) {    /* returns 0 on error! */
-                atomic_set(&dev->enable_rx, 1);
-                if (!xmit_was_down)
-                        netif_wake_queue(dev->netdev);          
-                up(&fsm->sem);
-                return -EAGAIN;
-        }
-        return 0;
-}
-static int __init irda_thread_create(void)
-{
-        struct completion startup;
-        int pid;
-        spin_lock_init(&irda_rq_queue.lock);
-        irda_rq_queue.thread = NULL;
-        INIT_LIST_HEAD(&irda_rq_queue.request_list);
-        init_waitqueue_head(&irda_rq_queue.kick);
-        init_waitqueue_head(&irda_rq_queue.done);
-        atomic_set(&irda_rq_queue.num_pending, 0);
-        init_completion(&startup);
-        pid = kernel_thread(irda_thread, &startup, CLONE_FS|CLONE_FILES);
-        if (pid <= 0)
-                return -EAGAIN;
-        else
-                wait_for_completion(&startup);
-        return 0;
-}
-static void __exit irda_thread_join(void)
-{
-        if (irda_rq_queue.thread) {
-                flush_irda_queue();
-                init_completion(&irda_rq_queue.exit);
-                irda_rq_queue.thread = NULL;
-                wake_up(&irda_rq_queue.kick);           
-                wait_for_completion(&irda_rq_queue.exit);
-        }
-}
-module_init(irda_thread_create);
-module_exit(irda_thread_join);
-MODULE_AUTHOR("Martin Diehl <info@mdiehl.de>");
-MODULE_DESCRIPTION("IrDA SIR core");
-MODULE_LICENSE("GPL");
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index bbcfc8ec35a1..a4674044bd6f 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -54,6 +54,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/serial_reg.h>
 #include <linux/dma-mapping.h>
+#include <linux/pnp.h>
 #include <linux/platform_device.h>
 #include <asm/io.h>
@@ -225,6 +226,8 @@ static int __init smsc_superio_lpc(unsigned short cfg_base);
 #ifdef CONFIG_PCI
 static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuration *conf);
 static int __init preconfigure_through_82801(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
+static void __init preconfigure_ali_port(struct pci_dev *dev,
+                                         unsigned short port);
 static int __init preconfigure_through_ali(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
 static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
                                                    unsigned short ircc_fir,
@@ -356,6 +359,16 @@ static inline void register_bank(int iobase, int bank)
               iobase + IRCC_MASTER);
 }
+#ifdef  CONFIG_PNP
+/* PNP hotplug support */
+static const struct pnp_device_id smsc_ircc_pnp_table[] = {
+        { .id = "SMCf010", .driver_data = 0 },
+        /* and presumably others */
+        { }
+};
+MODULE_DEVICE_TABLE(pnp, smsc_ircc_pnp_table);
+#endif
 /*******************************************************************************
 *
@@ -2070,7 +2083,8 @@ static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self)
 /* PROBING
 *
- *
+ * REVISIT we can be told about the device by PNP, and should use that info
+ * instead of probing hardware and creating a platform_device ...
 */
 static int __init smsc_ircc_look_for_chips(void)
@@ -2327,9 +2341,14 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
 * pre-configuration not properly done by the BIOS (especially laptops)
 * This code is based in part on smcinit.c, tosh1800-smcinit.c
 * and tosh2450-smcinit.c. The table lists the device entries
- * for ISA bridges with an LPC (Local Peripheral Configurator)
+ * for ISA bridges with an LPC (Low Pin Count) controller which
- * that are in turn used to configure the SMSC device with default
+ * handles the communication with the SMSC device. After the LPC
- * SIR and FIR I/O ports, DMA and IRQ.
+ * controller is initialized through PCI, the SMSC device is initialized
+ * through a dedicated port in the ISA port-mapped I/O area, this latter
+ * area is used to configure the SMSC device with default
+ * SIR and FIR I/O ports, DMA and IRQ. Different vendors have
+ * used different sets of parameters and different control port
+ * addresses making a subsystem device table necessary.
 */
 #ifdef CONFIG_PCI
 #define PCIID_VENDOR_INTEL 0x8086
@@ -2340,9 +2359,10 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __dev
                .device = 0x24cc,
                .subvendor = 0x103c,
                .subdevice = 0x088c,
-                .sir_io = 0x02f8, /* Quite certain these are the same for nc8000 as for nc6000 */
+                /* Quite certain these are the same for nc8000 as for nc6000 */
+                .sir_io = 0x02f8,
                .fir_io = 0x0130,
-                .fir_irq = 0x09,
+                .fir_irq = 0x05,
                .fir_dma = 0x03,
                .cfg_base = 0x004e,
                .preconfigure = preconfigure_through_82801,
@@ -2355,60 +2375,79 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __dev
                .subdevice = 0x0890,
                .sir_io = 0x02f8,
                .fir_io = 0x0130,
-                .fir_irq = 0x09,
+                .fir_irq = 0x05,
                .fir_dma = 0x03,
                .cfg_base = 0x004e,
                .preconfigure = preconfigure_through_82801,
                .name = "HP nc6000",
        },
        {
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge */
+                /* Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge */
+                .vendor = PCIID_VENDOR_INTEL,
                .device = 0x24c0,
                .subvendor = 0x1179,
-                .subdevice = 0xffff, /* 0xffff is "any", Not sure, 0x0001 or 0x0002 */
+                .subdevice = 0xffff, /* 0xffff is "any" */
                .sir_io = 0x03f8,
                .fir_io = 0x0130,
                .fir_irq = 0x07,
                .fir_dma = 0x01,
                .cfg_base = 0x002e,
                .preconfigure = preconfigure_through_82801,
-                .name = "Toshiba Satellite 2450",
+                .name = "Toshiba laptop with Intel 82801DB/DBL LPC bridge",
        },
        {
                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801CAM ISA bridge */
-                .device = 0x248c, /* Some use 24cc? */
+                .device = 0x248c,
+                .subvendor = 0x1179,
+                .subdevice = 0xffff, /* 0xffff is "any" */
+                .sir_io = 0x03f8,
+                .fir_io = 0x0130,
+                .fir_irq = 0x03,
+                .fir_dma = 0x03,
+                .cfg_base = 0x002e,
+                .preconfigure = preconfigure_through_82801,
+                .name = "Toshiba laptop with Intel 82801CAM ISA bridge",
+        },
+        {
+                /* 82801DBM (ICH4-M) LPC Interface Bridge */
+                .vendor = PCIID_VENDOR_INTEL,
+                .device = 0x24cc,
                .subvendor = 0x1179,
-                .subdevice = 0xffff, /* 0xffff is "any", Not sure, 0x0001 or 0x0002 */
+                .subdevice = 0xffff, /* 0xffff is "any" */
                .sir_io = 0x03f8,
                .fir_io = 0x0130,
                .fir_irq = 0x03,
                .fir_dma = 0x03,
                .cfg_base = 0x002e,
                .preconfigure = preconfigure_through_82801,
-                .name = "Toshiba Satellite 5100/5200, Tecra 9100",
+                .name = "Toshiba laptop with Intel 8281DBM LPC bridge",
        },
        {
-                .vendor = PCIID_VENDOR_ALI, /* ALi M1533/M1535 PCI to ISA Bridge [Aladdin IV/V/V+] */
+                /* ALi M1533/M1535 PCI to ISA Bridge [Aladdin IV/V/V+] */
+                .vendor = PCIID_VENDOR_ALI,
                .device = 0x1533,
                .subvendor = 0x1179,
-                .subdevice = 0xffff, /* 0xffff is "any", Not sure, 0x0001 or 0x0002 */
+                .subdevice = 0xffff, /* 0xffff is "any" */
                .sir_io = 0x02e8,
                .fir_io = 0x02f8,
                .fir_irq = 0x07,
                .fir_dma = 0x03,
                .cfg_base = 0x002e,
                .preconfigure = preconfigure_through_ali,
-                .name = "Toshiba Satellite 1800",
+                .name = "Toshiba laptop with ALi ISA bridge",
        },
        { } // Terminator
 };
 /*
- * This sets up the basic SMSC parameters (FIR port, SIR port, FIR DMA, FIR IRQ)
+ * This sets up the basic SMSC parameters
+ * (FIR port, SIR port, FIR DMA, FIR IRQ)
 * through the chip configuration port.
 */
-static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuration *conf)
+static int __init preconfigure_smsc_chip(struct
+                                         smsc_ircc_subsystem_configuration
+                                         *conf)
 {
        unsigned short iobase = conf->cfg_base;
        unsigned char tmpbyte;
@@ -2416,7 +2455,9 @@ static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuratio
        outb(LPC47N227_CFGACCESSKEY, iobase); // enter configuration state
        outb(SMSCSIOFLAT_DEVICEID_REG, iobase); // set for device ID
        tmpbyte = inb(iobase +1); // Read device ID
-        IRDA_DEBUG(0, "Detected Chip id: 0x%02x, setting up registers...\n",tmpbyte);
+        IRDA_DEBUG(0,
+                   "Detected Chip id: 0x%02x, setting up registers...\n",
+                   tmpbyte);
        /* Disable UART1 and set up SIR I/O port */
        outb(0x24, iobase);  // select CR24 - UART1 base addr
@@ -2426,6 +2467,7 @@ static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuratio
        tmpbyte = inb(iobase + 1);
        if (tmpbyte != (conf->sir_io >> 2) ) {
                IRDA_WARNING("ERROR: could not configure SIR ioport.\n");
+                IRDA_WARNING("Try to supply ircc_cfg argument.\n");
                return -ENXIO;
        }
@@ -2461,7 +2503,8 @@ static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuratio
        outb(SMSCSIOFLAT_UARTMODE0C_REG, iobase);  // CR0C - UART mode
        tmpbyte = inb(iobase + 1);
-        tmpbyte &= ~SMSCSIOFLAT_UART2MODE_MASK | SMSCSIOFLAT_UART2MODE_VAL_IRDA;
+        tmpbyte &= ~SMSCSIOFLAT_UART2MODE_MASK |
+                SMSCSIOFLAT_UART2MODE_VAL_IRDA;
        outb(tmpbyte, iobase + 1); // enable IrDA (HPSIR) mode, high speed
        outb(LPC47N227_APMBOOTDRIVE_REG, iobase);  // CR07 - Auto Pwr Mgt/boot drive sel
@@ -2486,53 +2529,226 @@ static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuratio
        return 0;
 }
-/* 82801CAM registers */
+/* 82801CAM generic registers */
 #define VID 0x00
 #define DID 0x02
-#define PIRQA_ROUT 0x60
+#define PIRQ_A_D_ROUT 0x60
+#define SIRQ_CNTL 0x64
+#define PIRQ_E_H_ROUT 0x68
 #define PCI_DMA_C 0x90
+/* LPC-specific registers */
 #define COM_DEC 0xe0
+#define GEN1_DEC 0xe4
 #define LPC_EN 0xe6
 #define GEN2_DEC 0xec
 /*
- * Sets up the I/O range using the 82801CAM ISA bridge, 82801DBM LPC bridge or
+ * Sets up the I/O range using the 82801CAM ISA bridge, 82801DBM LPC bridge
- * Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge. They all work the same way!
+ * or Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge.
+ * They all work the same way!
 */
 static int __init preconfigure_through_82801(struct pci_dev *dev,
-                                  struct smsc_ircc_subsystem_configuration *conf)
+                                             struct
+                                             smsc_ircc_subsystem_configuration
+                                             *conf)
 {
        unsigned short tmpword;
-        int ret;
+        unsigned char tmpbyte;
-        IRDA_MESSAGE("Setting up the SMSC device via the 82801 controller.\n");
+        IRDA_MESSAGE("Setting up Intel 82801 controller and SMSC device\n");
-        pci_write_config_byte(dev, COM_DEC, 0x10);
+        /*
+         * Select the range for the COMA COM port (SIR)
+         * Register COM_DEC:
+         * Bit 7: reserved
+         * Bit 6-4, COMB decode range
+         * Bit 3: reserved
+         * Bit 2-0, COMA decode range
+         *
+         * Decode ranges:
+         *   000 = 0x3f8-0x3ff (COM1)
+         *   001 = 0x2f8-0x2ff (COM2)
+         *   010 = 0x220-0x227
+         *   011 = 0x228-0x22f
+         *   100 = 0x238-0x23f
+         *   101 = 0x2e8-0x2ef (COM4)
+         *   110 = 0x338-0x33f
+         *   111 = 0x3e8-0x3ef (COM3)
+         */
+        pci_read_config_byte(dev, COM_DEC, &tmpbyte);
+        tmpbyte &= 0xf8; /* mask COMA bits */
+        switch(conf->sir_io) {
+        case 0x3f8:
+                tmpbyte |= 0x00;
+                break;
+        case 0x2f8:
+                tmpbyte |= 0x01;
+                break;
+        case 0x220:
+                tmpbyte |= 0x02;
+                break;
+        case 0x228:
+                tmpbyte |= 0x03;
+                break;
+        case 0x238:
+                tmpbyte |= 0x04;
+                break;
+        case 0x2e8:
+                tmpbyte |= 0x05;
+                break;
+        case 0x338:
+                tmpbyte |= 0x06;
+                break;
+        case 0x3e8:
+                tmpbyte |= 0x07;
+                break;
+        default:
+                tmpbyte |= 0x01; /* COM2 default */
+        }
+        IRDA_DEBUG(1, "COM_DEC (write): 0x%02x\n", tmpbyte);
+        pci_write_config_byte(dev, COM_DEC, tmpbyte);
-        /* Enable LPC */
+        /* Enable Low Pin Count interface */
-        pci_read_config_word(dev, LPC_EN, &tmpword); /* LPC_EN register */
+        pci_read_config_word(dev, LPC_EN, &tmpword);
-        tmpword &= 0xfffd; /* mask bit 1 */
+        /* These seem to be set up at all times,
-        tmpword |= 0x0001; /* set bit 0 : COMA addr range enable */
+         * just make sure it is properly set.
+         */
+        switch(conf->cfg_base) {
+        case 0x04e:
+                tmpword |= 0x2000;
+                break;
+        case 0x02e:
+                tmpword |= 0x1000;
+                break;
+        case 0x062:
+                tmpword |= 0x0800;
+                break;
+        case 0x060:
+                tmpword |= 0x0400;
+                break;
+        default:
+                IRDA_WARNING("Uncommon I/O base address: 0x%04x\n",
+                             conf->cfg_base);
+                break;
+        }
+        tmpword &= 0xfffd; /* disable LPC COMB */
+        tmpword |= 0x0001; /* set bit 0 : enable LPC COMA addr range (GEN2) */
+        IRDA_DEBUG(1, "LPC_EN (write): 0x%04x\n", tmpword);
        pci_write_config_word(dev, LPC_EN, tmpword);
-        /* Setup DMA */
+        /*
-        pci_write_config_word(dev, PCI_DMA_C, 0xc0c0); /* LPC I/F DMA on, channel 3  -- rtm (?? PCI DMA ?) */
+         * Configure LPC DMA channel
-        pci_write_config_word(dev, GEN2_DEC, 0x131); /* LPC I/F 2nd decode range */
+         * PCI_DMA_C bits:
+         * Bit 15-14: DMA channel 7 select
+         * Bit 13-12: DMA channel 6 select
+         * Bit 11-10: DMA channel 5 select
+         * Bit 9-8:   Reserved
+         * Bit 7-6:   DMA channel 3 select
+         * Bit 5-4:   DMA channel 2 select
+         * Bit 3-2:   DMA channel 1 select
+         * Bit 1-0:   DMA channel 0 select
+         *  00 = Reserved value
+         *  01 = PC/PCI DMA
+         *  10 = Reserved value
+         *  11 = LPC I/F DMA
+         */
+        pci_read_config_word(dev, PCI_DMA_C, &tmpword);
+        switch(conf->fir_dma) {
+        case 0x07:
+                tmpword |= 0xc000;
+                break;
+        case 0x06:
+                tmpword |= 0x3000;
+                break;
+        case 0x05:
+                tmpword |= 0x0c00;
+                break;
+        case 0x03:
+                tmpword |= 0x00c0;
+                break;
+        case 0x02:
+                tmpword |= 0x0030;
+                break;
+        case 0x01:
+                tmpword |= 0x000c;
+                break;
+        case 0x00:
+                tmpword |= 0x0003;
+                break;
+        default:
+                break; /* do not change settings */
+        }
+        IRDA_DEBUG(1, "PCI_DMA_C (write): 0x%04x\n", tmpword);
+        pci_write_config_word(dev, PCI_DMA_C, tmpword);
+        /*
+         * GEN2_DEC bits:
+         * Bit 15-4: Generic I/O range
+         * Bit 3-1: reserved (read as 0)
+         * Bit 0: enable GEN2 range on LPC I/F
+         */
+        tmpword = conf->fir_io & 0xfff8;
+        tmpword |= 0x0001;
+        IRDA_DEBUG(1, "GEN2_DEC (write): 0x%04x\n", tmpword);
+        pci_write_config_word(dev, GEN2_DEC, tmpword);
        /* Pre-configure chip */
-        ret = preconfigure_smsc_chip(conf);
+        return preconfigure_smsc_chip(conf);
+}
-        /* Disable LPC */
+/*
-        pci_read_config_word(dev, LPC_EN, &tmpword); /* LPC_EN register */
+ * Pre-configure a certain port on the ALi 1533 bridge.
-        tmpword &= 0xfffc; /* mask bit 1 and bit 0, COMA addr range disable */
+ * This is based on reverse-engineering since ALi does not
-        pci_write_config_word(dev, LPC_EN, tmpword);
+ * provide any data sheet for the 1533 chip.
-        return ret;
+ */
+static void __init preconfigure_ali_port(struct pci_dev *dev,
+                                         unsigned short port)
+{
+        unsigned char reg;
+        /* These bits obviously control the different ports */
+        unsigned char mask;
+        unsigned char tmpbyte;
+        switch(port) {
+        case 0x0130:
+        case 0x0178:
+                reg = 0xb0;
+                mask = 0x80;
+                break;
+        case 0x03f8:
+                reg = 0xb4;
+                mask = 0x80;
+                break;
+        case 0x02f8:
+                reg = 0xb4;
+                mask = 0x30;
+                break;
+        case 0x02e8:
+                reg = 0xb4;
+                mask = 0x08;
+                break;
+        default:
+                IRDA_ERROR("Failed to configure unsupported port on ALi 1533 bridge: 0x%04x\n", port);
+                return;
+        }
+        pci_read_config_byte(dev, reg, &tmpbyte);
+        /* Turn on the right bits */
+        tmpbyte |= mask;
+        pci_write_config_byte(dev, reg, tmpbyte);
+        IRDA_MESSAGE("Activated ALi 1533 ISA bridge port 0x%04x.\n", port);
+        return;
 }
 static int __init preconfigure_through_ali(struct pci_dev *dev,
-                                  struct smsc_ircc_subsystem_configuration *conf)
+                                           struct
+                                           smsc_ircc_subsystem_configuration
+                                           *conf)
 {
-        /* TODO: put in ALi 1533 configuration here. */
+        /* Configure the two ports on the ALi 1533 */
-        IRDA_MESSAGE("SORRY: %s has an unsupported bridge controller (ALi): not pre-configured.\n", conf->name);
+        preconfigure_ali_port(dev, conf->sir_io);
-        return -ENODEV;
+        preconfigure_ali_port(dev, conf->fir_io);
+        /* Pre-configure chip */
+        return preconfigure_smsc_chip(conf);
 }
 static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
@@ -2552,9 +2768,10 @@ static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
                struct smsc_ircc_subsystem_configuration *conf;
                /*
-                 * Cache the subsystem vendor/device: some manufacturers fail to set
+                 * Cache the subsystem vendor/device:
-                 * this for all components, so we save it in case there is just
+                 * some manufacturers fail to set this for all components,
-                 * 0x0000 0x0000 on the device we want to check.
+                 * so we save it in case there is just 0x0000 0x0000 on the
+                 * device we want to check.
                 */
                if (dev->subsystem_vendor != 0x0000U) {
                        ss_vendor = dev->subsystem_vendor;
@@ -2564,13 +2781,20 @@ static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
                for( ; conf->subvendor; conf++) {
                        if(conf->vendor == dev->vendor &&
                           conf->device == dev->device &&
-                           conf->subvendor == ss_vendor && /* Sometimes these are cached values */
+                           conf->subvendor == ss_vendor &&
-                           (conf->subdevice == ss_device || conf->subdevice == 0xffff)) {
+                           /* Sometimes these are cached values */
-                                struct smsc_ircc_subsystem_configuration tmpconf;
+                           (conf->subdevice == ss_device ||
+                            conf->subdevice == 0xffff)) {
+                                struct smsc_ircc_subsystem_configuration
+                                        tmpconf;
-                                memcpy(&tmpconf, conf, sizeof(struct smsc_ircc_subsystem_configuration));
+                                memcpy(&tmpconf, conf,
+                                       sizeof(struct smsc_ircc_subsystem_configuration));
-                                /* Override the default values with anything passed in as parameter */
+                                /*
+                                 * Override the default values with anything
+                                 * passed in as parameter
+                                 */
                                if (ircc_cfg != 0)
                                        tmpconf.cfg_base = ircc_cfg;
                                if (ircc_fir != 0)
diff --git a/drivers/net/ixp2000/enp2611.c b/drivers/net/ixp2000/enp2611.c
index 6f7dce8eba51..b67f586d7392 100644
--- a/drivers/net/ixp2000/enp2611.c
+++ b/drivers/net/ixp2000/enp2611.c
@@ -149,6 +149,8 @@ static void enp2611_check_link_status(unsigned long __dummy)
                int status;
                dev = nds[i];
+                if (dev == NULL)
+                        continue;
                status = pm3386_is_link_up(i);
                if (status && !netif_carrier_ok(dev)) {
@@ -191,6 +193,7 @@ static void enp2611_set_port_admin_status(int port, int up)
 static int __init enp2611_init_module(void)
 { 
+        int ports;
        int i;
        if (!machine_is_enp2611())
@@ -199,7 +202,8 @@ static int __init enp2611_init_module(void)
        caleb_reset();
        pm3386_reset();
-        for (i = 0; i < 3; i++) {
+        ports = pm3386_port_count();
+        for (i = 0; i < ports; i++) {
                nds[i] = ixpdev_alloc(i, sizeof(struct enp2611_ixpdev_priv));
                if (nds[i] == NULL) {
                        while (--i >= 0)
@@ -215,9 +219,10 @@ static int __init enp2611_init_module(void)
        ixp2400_msf_init(&enp2611_msf_parameters);
-        if (ixpdev_init(3, nds, enp2611_set_port_admin_status)) {
+        if (ixpdev_init(ports, nds, enp2611_set_port_admin_status)) {
-                for (i = 0; i < 3; i++)
+                for (i = 0; i < ports; i++)
-                        free_netdev(nds[i]);
+                        if (nds[i])
+                                free_netdev(nds[i]);
                return -EINVAL;
        }
diff --git a/drivers/net/ixp2000/pm3386.c b/drivers/net/ixp2000/pm3386.c
index 5c7ab7564053..5224651c9aac 100644
--- a/drivers/net/ixp2000/pm3386.c
+++ b/drivers/net/ixp2000/pm3386.c
@@ -86,40 +86,53 @@ static void pm3386_port_reg_write(int port, int _reg, int spacing, u16 value)
        pm3386_reg_write(port >> 1, reg, value);
 }
+int pm3386_secondary_present(void)
+{
+        return pm3386_reg_read(1, 0) == 0x3386;
+}
 void pm3386_reset(void)
 {
        u8 mac[3][6];
+        int secondary;
+        secondary = pm3386_secondary_present();
        /* Save programmed MAC addresses.  */
        pm3386_get_mac(0, mac[0]);
        pm3386_get_mac(1, mac[1]);
-        pm3386_get_mac(2, mac[2]);
+        if (secondary)
+                pm3386_get_mac(2, mac[2]);
        /* Assert analog and digital reset.  */
        pm3386_reg_write(0, 0x002, 0x0060);
-        pm3386_reg_write(1, 0x002, 0x0060);
+        if (secondary)
+                pm3386_reg_write(1, 0x002, 0x0060);
        mdelay(1);
        /* Deassert analog reset.  */
        pm3386_reg_write(0, 0x002, 0x0062);
-        pm3386_reg_write(1, 0x002, 0x0062);
+        if (secondary)
+                pm3386_reg_write(1, 0x002, 0x0062);
        mdelay(10);
        /* Deassert digital reset.  */
        pm3386_reg_write(0, 0x002, 0x0063);
-        pm3386_reg_write(1, 0x002, 0x0063);
+        if (secondary)
+                pm3386_reg_write(1, 0x002, 0x0063);
        mdelay(10);
        /* Restore programmed MAC addresses.  */
        pm3386_set_mac(0, mac[0]);
        pm3386_set_mac(1, mac[1]);
-        pm3386_set_mac(2, mac[2]);
+        if (secondary)
+                pm3386_set_mac(2, mac[2]);
        /* Disable carrier on all ports.  */
        pm3386_set_carrier(0, 0);
        pm3386_set_carrier(1, 0);
-        pm3386_set_carrier(2, 0);
+        if (secondary)
+                pm3386_set_carrier(2, 0);
 }
 static u16 swaph(u16 x)
@@ -127,6 +140,11 @@ static u16 swaph(u16 x)
        return ((x << 8) | (x >> 8)) & 0xffff;
 }
+int pm3386_port_count(void)
+{
+        return 2 + pm3386_secondary_present();
+}
 void pm3386_init_port(int port)
 {
        int pm = port >> 1;
diff --git a/drivers/net/ixp2000/pm3386.h b/drivers/net/ixp2000/pm3386.h
index fe92bb056ac4..cc4183dca911 100644
--- a/drivers/net/ixp2000/pm3386.h
+++ b/drivers/net/ixp2000/pm3386.h
@@ -13,6 +13,7 @@
 #define __PM3386_H
 void pm3386_reset(void);
+int pm3386_port_count(void);
 void pm3386_init_port(int port);
 void pm3386_get_mac(int port, u8 *mac);
 void pm3386_set_mac(int port, u8 *mac);
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index ea62a3e7d586..411f4d809c47 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -1419,6 +1419,8 @@ static int mv643xx_eth_probe(struct platform_device *pdev)
        mv643xx_eth_update_pscr(dev, &cmd);
        mv643xx_set_settings(dev, &cmd);
+        SET_MODULE_OWNER(dev);
+        SET_NETDEV_DEV(dev, &pdev->dev);
        err = register_netdev(dev);
        if (err)
                goto out;
diff --git a/drivers/net/ne.c b/drivers/net/ne.c
index 08b218c5bfbc..b32765215f75 100644
--- a/drivers/net/ne.c
+++ b/drivers/net/ne.c
@@ -139,8 +139,9 @@ bad_clone_list[] __initdata = {
 #if defined(CONFIG_PLAT_MAPPI)
 #  define DCR_VAL 0x4b
-#elif defined(CONFIG_PLAT_OAKS32R)
+#elif defined(CONFIG_PLAT_OAKS32R)  || \
-#  define DCR_VAL 0x48
+   defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
+#  define DCR_VAL 0x48          /* 8-bit mode */
 #else
 #  define DCR_VAL 0x49
 #endif
@@ -226,7 +227,7 @@ struct net_device * __init ne_probe(int unit)
        netdev_boot_setup_check(dev);
 #ifdef CONFIG_TOSHIBA_RBTX4938
-        dev->base_addr = 0x07f20280;
+        dev->base_addr = RBTX4938_RTL_8019_BASE;
        dev->irq = RBTX4938_RTL_8019_IRQ;
 #endif
        err = do_ne_probe(dev);
@@ -396,10 +397,22 @@ static int __init ne_probe1(struct net_device *dev, int ioaddr)
                /* We must set the 8390 for word mode. */
                outb_p(DCR_VAL, ioaddr + EN0_DCFG);
                start_page = NESM_START_PG;
-                stop_page = NESM_STOP_PG;
+                /*
+                 * Realtek RTL8019AS datasheet says that the PSTOP register
+                 * shouldn't exceed 0x60 in 8-bit mode.
+                 * This chip can be identified by reading the signature from
+                 * the  remote byte count registers (otherwise write-only)...
+                 */
+                if ((DCR_VAL & 0x01) == 0 &&            /* 8-bit mode */
+                    inb(ioaddr + EN0_RCNTLO) == 0x50 &&
+                    inb(ioaddr + EN0_RCNTHI) == 0x70)
+                        stop_page = 0x60;
+                else
+                        stop_page = NESM_STOP_PG;
        } else {
                start_page = NE1SM_START_PG;
-                stop_page = NE1SM_STOP_PG;
+                stop_page  = NE1SM_STOP_PG;
        }
 #if  defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
@@ -509,15 +522,9 @@ 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
+        /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
-        ei_status.word16 = 0;
+        ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
-#else
-        ei_status.word16 = (wordlength == 2);
-#endif
        ei_status.rx_start_page = start_page + TX_PAGES;
 #ifdef PACKETBUF_MEMSIZE
diff --git a/drivers/net/netconsole.c b/drivers/net/netconsole.c
index 66e74f740261..bf58db29e2ed 100644
--- a/drivers/net/netconsole.c
+++ b/drivers/net/netconsole.c
@@ -107,7 +107,7 @@ static int init_netconsole(void)
        if(!configured) {
                printk("netconsole: not configured, aborting\n");
-                return -EINVAL;
+                return 0;
        }
        if(netpoll_setup(&np))
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index 448a09488529..2ea66aca648b 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -1691,17 +1691,6 @@ static void do_set_multicast_list(struct net_device *dev)
                memset(ei_local->mcfilter, 0xFF, 8);
        }
-        /* 
-         * DP8390 manuals don't specify any magic sequence for altering
-         * the multicast regs on an already running card. To be safe, we
-         * ensure multicast mode is off prior to loading up the new hash
-         * table. If this proves to be not enough, we can always resort
-         * to stopping the NIC, loading the table and then restarting.
-         */
-         
-        if (netif_running(dev))
-                outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
        outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
        for(i = 0; i < 8; i++) 
        {
@@ -1715,6 +1704,8 @@ static void do_set_multicast_list(struct net_device *dev)
                outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
        else
                outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
+        outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
 }
 /*
diff --git a/drivers/net/pcmcia/nmclan_cs.c b/drivers/net/pcmcia/nmclan_cs.c
index 4260c2128f47..a8f6bfc96fd2 100644
--- a/drivers/net/pcmcia/nmclan_cs.c
+++ b/drivers/net/pcmcia/nmclan_cs.c
@@ -1204,7 +1204,7 @@ static int mace_rx(struct net_device *dev, unsigned char RxCnt)
        dev->last_rx = jiffies;
        lp->linux_stats.rx_packets++;
-        lp->linux_stats.rx_bytes += skb->len;
+        lp->linux_stats.rx_bytes += pkt_len;
        outb(0xFF, ioaddr + AM2150_RCV_NEXT); /* skip to next frame */
        continue;
      } else {
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 506e777c5f06..d090df413049 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1639,6 +1639,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
        PCMCIA_DEVICE_PROD_ID12("CONTEC", "C-NET(PC)C-10L", 0x21cab552, 0xf6f90722),
        PCMCIA_DEVICE_PROD_ID12("corega", "FEther PCC-TXF", 0x0a21501a, 0xa51564a2),
        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-T", 0x5261440f, 0xfa9d85bd),
+        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-TD", 0x5261440f, 0xc49bd73d),
        PCMCIA_DEVICE_PROD_ID12("Corega K.K.", "corega EtherII PCC-TD", 0xd4fdcbd8, 0xc49bd73d),
        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-T", 0x5261440f, 0x6705fcaa),
        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FastEther PCC-TX", 0x5261440f, 0x485e85d9),
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 07c31f19c6ba..fc08c4af506c 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -1774,8 +1774,6 @@ static int pcnet32_open(struct net_device *dev)
                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
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 459443b572ce..1b236bdf6b92 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -60,8 +60,10 @@ int mdiobus_register(struct mii_bus *bus)
        for (i = 0; i < PHY_MAX_ADDR; i++) {
                struct phy_device *phydev;
-                if (bus->phy_mask & (1 << i))
+                if (bus->phy_mask & (1 << i)) {
+                        bus->phy_map[i] = NULL;
                        continue;
+                }
                phydev = get_phy_device(bus, i);
diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
index 475dc930380f..0d101a18026a 100644
--- a/drivers/net/pppoe.c
+++ b/drivers/net/pppoe.c
@@ -861,6 +861,9 @@ static int __pppoe_xmit(struct sock *sk, struct sk_buff *skb)
                 * give dev_queue_xmit something it can free.
                 */
                skb2 = skb_clone(skb, GFP_ATOMIC);
+                if (skb2 == NULL)
+                        goto abort;
        }
        ph = (struct pppoe_hdr *) skb_push(skb2, sizeof(struct pppoe_hdr));
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index b82191d2bee1..f5a3bf4d959a 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -127,6 +127,7 @@ static const struct mii_chip_info {
 } mii_chip_table[] = {
        { "SiS 900 Internal MII PHY",           0x001d, 0x8000, LAN },
        { "SiS 7014 Physical Layer Solution",   0x0016, 0xf830, LAN },
+        { "SiS 900 on Foxconn 661 7MI",         0x0143, 0xBC70, LAN },
        { "Altimata AC101LF PHY",               0x0022, 0x5520, LAN },
        { "ADM 7001 LAN PHY",                   0x002e, 0xcc60, LAN },
        { "AMD 79C901 10BASE-T PHY",            0x0000, 0x6B70, LAN },
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index a70c2b0cc104..5ca5a1b546a1 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -78,8 +78,7 @@ static const struct pci_device_id skge_id_table[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_YU) },
        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_DGE510T), },
-        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b00) },
+        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) },    /* DGE-530T */
-        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) },
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4320) },
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5005) }, /* Belkin */
        { PCI_DEVICE(PCI_VENDOR_ID_CNET, PCI_DEVICE_ID_CNET_GIGACARD) },
@@ -402,7 +401,7 @@ static int skge_set_ring_param(struct net_device *dev,
        int err;
        if (p->rx_pending == 0 || p->rx_pending > MAX_RX_RING_SIZE ||
-            p->tx_pending == 0 || p->tx_pending > MAX_TX_RING_SIZE)
+            p->tx_pending < MAX_SKB_FRAGS+1 || p->tx_pending > MAX_TX_RING_SIZE)
                return -EINVAL;
        skge->rx_ring.count = p->rx_pending;
@@ -2717,8 +2716,7 @@ static int skge_poll(struct net_device *dev, int *budget)
                if (control & BMU_OWN)
                        break;
-                skb = skge_rx_get(skge, e, control, rd->status,
+                skb = skge_rx_get(skge, e, control, rd->status, rd->csum2);
-                                  le16_to_cpu(rd->csum2));
                if (likely(skb)) {
                        dev->last_rx = jiffies;
                        netif_receive_skb(skb);
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 67b0eab16589..959109609d85 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -51,7 +51,7 @@
 #include "sky2.h"
 #define DRV_NAME                "sky2"
-#define DRV_VERSION             "1.1"
+#define DRV_VERSION             "1.4"
 #define PFX                     DRV_NAME " "
 /*
@@ -79,6 +79,8 @@
 #define NAPI_WEIGHT             64
 #define PHY_RETRIES             1000
+#define RING_NEXT(x,s)  (((x)+1) & ((s)-1))
 static const u32 default_msg =
    NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
    | NETIF_MSG_TIMER | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR
@@ -96,9 +98,14 @@ static int disable_msi = 0;
 module_param(disable_msi, int, 0);
 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
+static int idle_timeout = 100;
+module_param(idle_timeout, int, 0);
+MODULE_PARM_DESC(idle_timeout, "Idle timeout workaround for lost interrupts (ms)");
 static const struct pci_device_id sky2_id_table[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) },
+        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b00) },    /* DGE-560T */
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4340) },
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4341) },
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4342) },
@@ -122,6 +129,7 @@ MODULE_DEVICE_TABLE(pci, sky2_id_table);
 /* Avoid conditionals by using array */
 static const unsigned txqaddr[] = { Q_XA1, Q_XA2 };
 static const unsigned rxqaddr[] = { Q_R1, Q_R2 };
+static const u32 portirq_msk[] = { Y2_IS_PORT_1, Y2_IS_PORT_2 };
 /* This driver supports yukon2 chipset only */
 static const char *yukon2_name[] = {
@@ -228,6 +236,7 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
                }
                if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
+                        sky2_write16(hw, B0_CTST, Y2_HW_WOL_ON);
                        sky2_pci_write32(hw, PCI_DEV_REG3, 0);
                        reg1 = sky2_pci_read32(hw, PCI_DEV_REG4);
                        reg1 &= P_ASPM_CONTROL_MSK;
@@ -298,7 +307,8 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
        struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
        u16 ctrl, ct1000, adv, pg, ledctrl, ledover;
-        if (sky2->autoneg == AUTONEG_ENABLE && hw->chip_id != CHIP_ID_YUKON_XL) {
+        if (sky2->autoneg == AUTONEG_ENABLE &&
+            !(hw->chip_id == CHIP_ID_YUKON_XL || hw->chip_id == CHIP_ID_YUKON_EC_U)) {
                u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL);
                ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK |
@@ -326,7 +336,7 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
                        ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO);
                        if (sky2->autoneg == AUTONEG_ENABLE &&
-                            hw->chip_id == CHIP_ID_YUKON_XL) {
+                            (hw->chip_id == CHIP_ID_YUKON_XL || hw->chip_id == CHIP_ID_YUKON_EC_U)) {
                                ctrl &= ~PHY_M_PC_DSC_MSK;
                                ctrl |= PHY_M_PC_DSC(2) | PHY_M_PC_DOWN_S_ENA;
                        }
@@ -442,10 +452,11 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
                /* set LED Function Control register */
-                gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, (PHY_M_LEDC_LOS_CTRL(1) |     /* LINK/ACT */
+                gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
-                                                           PHY_M_LEDC_INIT_CTRL(7) |    /* 10 Mbps */
+                             (PHY_M_LEDC_LOS_CTRL(1) |  /* LINK/ACT */
-                                                           PHY_M_LEDC_STA1_CTRL(7) |    /* 100 Mbps */
+                              PHY_M_LEDC_INIT_CTRL(7) | /* 10 Mbps */
-                                                           PHY_M_LEDC_STA0_CTRL(7)));   /* 1000 Mbps */
+                              PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
+                              PHY_M_LEDC_STA0_CTRL(7)));        /* 1000 Mbps */
                /* set Polarity Control register */
                gm_phy_write(hw, port, PHY_MARV_PHY_STAT,
@@ -459,6 +470,25 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
                /* restore page register */
                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
                break;
+        case CHIP_ID_YUKON_EC_U:
+                pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
+                /* select page 3 to access LED control register */
+                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
+                /* set LED Function Control register */
+                gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
+                             (PHY_M_LEDC_LOS_CTRL(1) |  /* LINK/ACT */
+                              PHY_M_LEDC_INIT_CTRL(8) | /* 10 Mbps */
+                              PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
+                              PHY_M_LEDC_STA0_CTRL(7)));/* 1000 Mbps */
+                /* set Blink Rate in LED Timer Control Register */
+                gm_phy_write(hw, port, PHY_MARV_INT_MASK,
+                             ledctrl | PHY_M_LED_BLINK_RT(BLINK_84MS));
+                /* restore page register */
+                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
+                break;
        default:
                /* set Tx LED (LED_TX) to blink mode on Rx OR Tx activity */
@@ -467,19 +497,21 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
                ledover |= PHY_M_LED_MO_RX(MO_LED_OFF);
        }
-        if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev >= 2) {
+        if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev == CHIP_REV_YU_EC_A1) {
                /* apply fixes in PHY AFE */
-                gm_phy_write(hw, port, 22, 255);
+                pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
+                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 255);
                /* increase differential signal amplitude in 10BASE-T */
-                gm_phy_write(hw, port, 24, 0xaa99);
+                gm_phy_write(hw, port, 0x18, 0xaa99);
-                gm_phy_write(hw, port, 23, 0x2011);
+                gm_phy_write(hw, port, 0x17, 0x2011);
                /* fix for IEEE A/B Symmetry failure in 1000BASE-T */
-                gm_phy_write(hw, port, 24, 0xa204);
+                gm_phy_write(hw, port, 0x18, 0xa204);
-                gm_phy_write(hw, port, 23, 0x2002);
+                gm_phy_write(hw, port, 0x17, 0x2002);
                /* set page register to 0 */
-                gm_phy_write(hw, port, 22, 0);
+                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
        } else {
                gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
@@ -553,6 +585,11 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
                if (sky2->duplex == DUPLEX_FULL)
                        reg |= GM_GPCR_DUP_FULL;
+                /* turn off pause in 10/100mbps half duplex */
+                else if (sky2->speed != SPEED_1000 &&
+                         hw->chip_id != CHIP_ID_YUKON_EC_U)
+                        sky2->tx_pause = sky2->rx_pause = 0;
        } else
                reg = GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100 | GM_GPCR_DUP_FULL;
@@ -719,7 +756,7 @@ static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2)
 {
        struct sky2_tx_le *le = sky2->tx_le + sky2->tx_prod;
-        sky2->tx_prod = (sky2->tx_prod + 1) % TX_RING_SIZE;
+        sky2->tx_prod = RING_NEXT(sky2->tx_prod, TX_RING_SIZE);
        return le;
 }
@@ -735,7 +772,7 @@ static inline void sky2_put_idx(struct sky2_hw *hw, unsigned q, u16 idx)
 static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2)
 {
        struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put;
-        sky2->rx_put = (sky2->rx_put + 1) % RX_LE_SIZE;
+        sky2->rx_put = RING_NEXT(sky2->rx_put, RX_LE_SIZE);
        return le;
 }
@@ -925,8 +962,7 @@ static inline struct sk_buff *sky2_alloc_skb(unsigned int size, gfp_t gfp_mask)
        skb = alloc_skb(size + RX_SKB_ALIGN, gfp_mask);
        if (likely(skb)) {
                unsigned long p = (unsigned long) skb->data;
-                skb_reserve(skb,
+                skb_reserve(skb, ALIGN(p, RX_SKB_ALIGN) - p);
-                        ((p + RX_SKB_ALIGN - 1) & ~(RX_SKB_ALIGN - 1)) - p);
        }
        return skb;
@@ -943,6 +979,7 @@ static int sky2_rx_start(struct sky2_port *sky2)
        struct sky2_hw *hw = sky2->hw;
        unsigned rxq = rxqaddr[sky2->port];
        int i;
+        unsigned thresh;
        sky2->rx_put = sky2->rx_next = 0;
        sky2_qset(hw, rxq);
@@ -967,9 +1004,21 @@ static int sky2_rx_start(struct sky2_port *sky2)
                sky2_rx_add(sky2, re->mapaddr);
        }
-        /* Truncate oversize frames */
-        sky2_write16(hw, SK_REG(sky2->port, RX_GMF_TR_THR), sky2->rx_bufsize - 8);
+        /*
-        sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_ON);
+         * The receiver hangs if it receives frames larger than the
+         * packet buffer. As a workaround, truncate oversize frames, but
+         * the register is limited to 9 bits, so if you do frames > 2052
+         * you better get the MTU right!
+         */
+        thresh = (sky2->rx_bufsize - 8) / sizeof(u32);
+        if (thresh > 0x1ff)
+                sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_OFF);
+        else {
+                sky2_write16(hw, SK_REG(sky2->port, RX_GMF_TR_THR), thresh);
+                sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_ON);
+        }
        /* Tell chip about available buffers */
        sky2_write16(hw, Y2_QADDR(rxq, PREF_UNIT_PUT_IDX), sky2->rx_put);
@@ -986,7 +1035,25 @@ static int sky2_up(struct net_device *dev)
        struct sky2_hw *hw = sky2->hw;
        unsigned port = sky2->port;
        u32 ramsize, rxspace, imask;
-        int err = -ENOMEM;
+        int cap, err = -ENOMEM;
+        struct net_device *otherdev = hw->dev[sky2->port^1];
+        /*
+         * On dual port PCI-X card, there is an problem where status
+         * can be received out of order due to split transactions
+         */
+        if (otherdev && netif_running(otherdev) &&
+            (cap = pci_find_capability(hw->pdev, PCI_CAP_ID_PCIX))) {
+                struct sky2_port *osky2 = netdev_priv(otherdev);
+                u16 cmd;
+                cmd = sky2_pci_read16(hw, cap + PCI_X_CMD);
+                cmd &= ~PCI_X_CMD_MAX_SPLIT;
+                sky2_pci_write16(hw, cap + PCI_X_CMD, cmd);
+                sky2->rx_csum = 0;
+                osky2->rx_csum = 0;
+        }
        if (netif_msg_ifup(sky2))
                printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
@@ -1051,7 +1118,7 @@ static int sky2_up(struct net_device *dev)
        /* Enable interrupts from phy/mac for port */
        imask = sky2_read32(hw, B0_IMSK);
-        imask |= (port == 0) ? Y2_IS_PORT_1 : Y2_IS_PORT_2;
+        imask |= portirq_msk[port];
        sky2_write32(hw, B0_IMSK, imask);
        return 0;
@@ -1079,7 +1146,7 @@ err_out:
 /* Modular subtraction in ring */
 static inline int tx_dist(unsigned tail, unsigned head)
 {
-        return (head - tail) % TX_RING_SIZE;
+        return (head - tail) & (TX_RING_SIZE - 1);
 }
 /* Number of list elements available for next tx */
@@ -1256,7 +1323,7 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
                le->opcode = OP_BUFFER | HW_OWNER;
                fre = sky2->tx_ring
-                    + ((re - sky2->tx_ring) + i + 1) % TX_RING_SIZE;
+                    + RING_NEXT((re - sky2->tx_ring) + i, TX_RING_SIZE);
                pci_unmap_addr_set(fre, mapaddr, mapping);
        }
@@ -1316,7 +1383,7 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
                        struct tx_ring_info *fre;
-                        fre = sky2->tx_ring + (put + i + 1) % TX_RING_SIZE;
+                        fre = sky2->tx_ring + RING_NEXT(put + i, TX_RING_SIZE);
                        pci_unmap_page(pdev, pci_unmap_addr(fre, mapaddr),
                                       skb_shinfo(skb)->frags[i].size,
                                       PCI_DMA_TODEVICE);
@@ -1402,7 +1469,7 @@ static int sky2_down(struct net_device *dev)
        /* Disable port IRQ */
        imask = sky2_read32(hw, B0_IMSK);
-        imask &= ~(sky2->port == 0) ? Y2_IS_PORT_1 : Y2_IS_PORT_2;
+        imask &= ~portirq_msk[port];
        sky2_write32(hw, B0_IMSK, imask);
        /* turn off LED's */
@@ -1499,17 +1566,26 @@ static void sky2_link_up(struct sky2_port *sky2)
        sky2_write8(hw, SK_REG(port, LNK_LED_REG),
                    LINKLED_ON | LINKLED_BLINK_OFF | LINKLED_LINKSYNC_OFF);
-        if (hw->chip_id == CHIP_ID_YUKON_XL) {
+        if (hw->chip_id == CHIP_ID_YUKON_XL || hw->chip_id == CHIP_ID_YUKON_EC_U) {
                u16 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
+                u16 led = PHY_M_LEDC_LOS_CTRL(1);       /* link active */
+                switch(sky2->speed) {
+                case SPEED_10:
+                        led |= PHY_M_LEDC_INIT_CTRL(7);
+                        break;
+                case SPEED_100:
+                        led |= PHY_M_LEDC_STA1_CTRL(7);
+                        break;
+                case SPEED_1000:
+                        led |= PHY_M_LEDC_STA0_CTRL(7);
+                        break;
+                }
                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
-                gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, PHY_M_LEDC_LOS_CTRL(1) |      /* LINK/ACT */
+                gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, led);
-                             PHY_M_LEDC_INIT_CTRL(sky2->speed ==
-                                                  SPEED_10 ? 7 : 0) |
-                             PHY_M_LEDC_STA1_CTRL(sky2->speed ==
-                                                  SPEED_100 ? 7 : 0) |
-                             PHY_M_LEDC_STA0_CTRL(sky2->speed ==
-                                                  SPEED_1000 ? 7 : 0));
                gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
        }
@@ -1584,7 +1660,7 @@ static int sky2_autoneg_done(struct sky2_port *sky2, u16 aux)
        sky2->speed = sky2_phy_speed(hw, aux);
        /* Pause bits are offset (9..8) */
-        if (hw->chip_id == CHIP_ID_YUKON_XL)
+        if (hw->chip_id == CHIP_ID_YUKON_XL || hw->chip_id == CHIP_ID_YUKON_EC_U)
                aux >>= 6;
        sky2->rx_pause = (aux & PHY_M_PS_RX_P_EN) != 0;
@@ -1686,13 +1762,12 @@ static void sky2_tx_timeout(struct net_device *dev)
 }
-#define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 /* Want receive buffer size to be multiple of 64 bits
 * and incl room for vlan and truncation
 */
 static inline unsigned sky2_buf_size(int mtu)
 {
-        return roundup(mtu + ETH_HLEN + VLAN_HLEN, 8) + 8;
+        return ALIGN(mtu + ETH_HLEN + VLAN_HLEN, 8) + 8;
 }
 static int sky2_change_mtu(struct net_device *dev, int new_mtu)
@@ -1857,39 +1932,38 @@ static inline void sky2_tx_done(struct net_device *dev, u16 last)
        }
 }
+/* Is status ring empty or is there more to do? */
+static inline int sky2_more_work(const struct sky2_hw *hw)
+{
+        return (hw->st_idx != sky2_read16(hw, STAT_PUT_IDX));
+}
 /* Process status response ring */
 static int sky2_status_intr(struct sky2_hw *hw, int to_do)
 {
        int work_done = 0;
+        u16 hwidx = sky2_read16(hw, STAT_PUT_IDX);
        rmb();
-        for(;;) {
+        while (hw->st_idx != hwidx) {
                struct sky2_status_le *le  = hw->st_le + hw->st_idx;
                struct net_device *dev;
                struct sky2_port *sky2;
                struct sk_buff *skb;
                u32 status;
                u16 length;
-                u8  link, opcode;
-                opcode = le->opcode;
+                hw->st_idx = RING_NEXT(hw->st_idx, STATUS_RING_SIZE);
-                if (!opcode)
-                        break;
-                opcode &= ~HW_OWNER;
-                hw->st_idx = (hw->st_idx + 1) % STATUS_RING_SIZE;
+                BUG_ON(le->link >= 2);
-                le->opcode = 0;
+                dev = hw->dev[le->link];
-                link = le->link;
-                BUG_ON(link >= 2);
-                dev = hw->dev[link];
                sky2 = netdev_priv(dev);
                length = le->length;
                status = le->status;
-                switch (opcode) {
+                switch (le->opcode & ~HW_OWNER) {
                case OP_RXSTAT:
                        skb = sky2_receive(sky2, length, status);
                        if (!skb)
@@ -1929,7 +2003,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do)
                case OP_TXINDEXLE:
                        /* TX index reports status for both ports */
-                        sky2_tx_done(hw->dev[0], status & 0xffff);
+                        BUILD_BUG_ON(TX_RING_SIZE > 0x1000);
+                        sky2_tx_done(hw->dev[0], status & 0xfff);
                        if (hw->dev[1])
                                sky2_tx_done(hw->dev[1],
                                     ((status >> 24) & 0xff)
@@ -1939,8 +2014,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do)
                default:
                        if (net_ratelimit())
                                printk(KERN_WARNING PFX
-                                       "unknown status opcode 0x%x\n", opcode);
+                                       "unknown status opcode 0x%x\n", le->opcode);
-                        break;
+                        goto exit_loop;
                }
        }
@@ -2086,6 +2161,21 @@ static void sky2_descriptor_error(struct sky2_hw *hw, unsigned port,
        }
 }
+/* If idle then force a fake soft NAPI poll once a second
+ * to work around cases where sharing an edge triggered interrupt.
+ */
+static void sky2_idle(unsigned long arg)
+{
+        struct sky2_hw *hw = (struct sky2_hw *) arg;
+        struct net_device *dev = hw->dev[0];
+        if (__netif_rx_schedule_prep(dev))
+                __netif_rx_schedule(dev);
+        mod_timer(&hw->idle_timer, jiffies + msecs_to_jiffies(idle_timeout));
+}
 static int sky2_poll(struct net_device *dev0, int *budget)
 {
        struct sky2_hw *hw = ((struct sky2_port *) netdev_priv(dev0))->hw;
@@ -2093,49 +2183,46 @@ static int sky2_poll(struct net_device *dev0, int *budget)
        int work_done = 0;
        u32 status = sky2_read32(hw, B0_Y2_SP_EISR);
-        if (unlikely(status & ~Y2_IS_STAT_BMU)) {
+        if (status & Y2_IS_HW_ERR)
-                if (status & Y2_IS_HW_ERR)
+                sky2_hw_intr(hw);
-                        sky2_hw_intr(hw);
-                if (status & Y2_IS_IRQ_PHY1)
-                        sky2_phy_intr(hw, 0);
-                if (status & Y2_IS_IRQ_PHY2)
+        if (status & Y2_IS_IRQ_PHY1)
-                        sky2_phy_intr(hw, 1);
+                sky2_phy_intr(hw, 0);
-                if (status & Y2_IS_IRQ_MAC1)
+        if (status & Y2_IS_IRQ_PHY2)
-                        sky2_mac_intr(hw, 0);
+                sky2_phy_intr(hw, 1);
-                if (status & Y2_IS_IRQ_MAC2)
+        if (status & Y2_IS_IRQ_MAC1)
-                        sky2_mac_intr(hw, 1);
+                sky2_mac_intr(hw, 0);
-                if (status & Y2_IS_CHK_RX1)
+        if (status & Y2_IS_IRQ_MAC2)
-                        sky2_descriptor_error(hw, 0, "receive", Y2_IS_CHK_RX1);
+                sky2_mac_intr(hw, 1);
-                if (status & Y2_IS_CHK_RX2)
+        if (status & Y2_IS_CHK_RX1)
-                        sky2_descriptor_error(hw, 1, "receive", Y2_IS_CHK_RX2);
+                sky2_descriptor_error(hw, 0, "receive", Y2_IS_CHK_RX1);
-                if (status & Y2_IS_CHK_TXA1)
+        if (status & Y2_IS_CHK_RX2)
-                        sky2_descriptor_error(hw, 0, "transmit", Y2_IS_CHK_TXA1);
+                sky2_descriptor_error(hw, 1, "receive", Y2_IS_CHK_RX2);
-                if (status & Y2_IS_CHK_TXA2)
+        if (status & Y2_IS_CHK_TXA1)
-                        sky2_descriptor_error(hw, 1, "transmit", Y2_IS_CHK_TXA2);
+                sky2_descriptor_error(hw, 0, "transmit", Y2_IS_CHK_TXA1);
-        }
-        if (status & Y2_IS_STAT_BMU) {
+        if (status & Y2_IS_CHK_TXA2)
-                work_done = sky2_status_intr(hw, work_limit);
+                sky2_descriptor_error(hw, 1, "transmit", Y2_IS_CHK_TXA2);
-                *budget -= work_done;
-                dev0->quota -= work_done;
-                if (work_done >= work_limit)
+        work_done = sky2_status_intr(hw, work_limit);
-                        return 1;
+        *budget -= work_done;
+        dev0->quota -= work_done;
+        if (status & Y2_IS_STAT_BMU)
                sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
-        }
+        if (sky2_more_work(hw))
+                return 1;
        netif_rx_complete(dev0);
-        status = sky2_read32(hw, B0_Y2_SP_LISR);
+        sky2_read32(hw, B0_Y2_SP_LISR);
        return 0;
 }
@@ -2153,8 +2240,6 @@ static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs)
        prefetch(&hw->st_le[hw->st_idx]);
        if (likely(__netif_rx_schedule_prep(dev0)))
                __netif_rx_schedule(dev0);
-        else
-                printk(KERN_DEBUG PFX "irq race detected\n");
        return IRQ_HANDLED;
 }
@@ -2193,7 +2278,7 @@ static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk)
 }
-static int sky2_reset(struct sky2_hw *hw)
+static int __devinit sky2_reset(struct sky2_hw *hw)
 {
        u16 status;
        u8 t8, pmd_type;
@@ -2218,13 +2303,6 @@ static int sky2_reset(struct sky2_hw *hw)
                return -EOPNOTSUPP;
        }
-        /* This chip is new and not tested yet */
-        if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
-                pr_info(PFX "%s: is a version of Yukon 2 chipset that has not been tested yet.\n",
-                        pci_name(hw->pdev));
-                pr_info("Please report success/failure to maintainer <shemminger@osdl.org>\n");
-        }
        /* disable ASF */
        if (hw->chip_id <= CHIP_ID_YUKON_EC) {
                sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
@@ -3028,12 +3106,7 @@ static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw,
        sky2->duplex = -1;
        sky2->speed = -1;
        sky2->advertising = sky2_supported_modes(hw);
+        sky2->rx_csum = 1;
-        /* Receive checksum disabled for Yukon XL
-         * because of observed problems with incorrect
-         * values when multiple packets are received in one interrupt
-         */
-        sky2->rx_csum = (hw->chip_id != CHIP_ID_YUKON_XL);
        spin_lock_init(&sky2->phy_lock);
        sky2->tx_pending = TX_DEF_PENDING;
@@ -3276,6 +3349,11 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
        sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
+        setup_timer(&hw->idle_timer, sky2_idle, (unsigned long) hw);
+        if (idle_timeout > 0)
+                mod_timer(&hw->idle_timer,
+                          jiffies + msecs_to_jiffies(idle_timeout));
        pci_set_drvdata(pdev, hw);
        return 0;
@@ -3311,13 +3389,17 @@ static void __devexit sky2_remove(struct pci_dev *pdev)
        if (!hw)
                return;
+        del_timer_sync(&hw->idle_timer);
+        sky2_write32(hw, B0_IMSK, 0);
+        synchronize_irq(hw->pdev->irq);
        dev0 = hw->dev[0];
        dev1 = hw->dev[1];
        if (dev1)
                unregister_netdev(dev1);
        unregister_netdev(dev0);
-        sky2_write32(hw, B0_IMSK, 0);
        sky2_set_power_state(hw, PCI_D3hot);
        sky2_write16(hw, B0_Y2LED, LED_STAT_OFF);
        sky2_write8(hw, B0_CTST, CS_RST_SET);
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index 89dd18cd12f0..8a0bc5525f0a 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -214,6 +214,8 @@ enum csr_regs {
 enum {
        Y2_VMAIN_AVAIL  = 1<<17,/* VMAIN available (YUKON-2 only) */
        Y2_VAUX_AVAIL   = 1<<16,/* VAUX available (YUKON-2 only) */
+        Y2_HW_WOL_ON    = 1<<15,/* HW WOL On  (Yukon-EC Ultra A1 only) */
+        Y2_HW_WOL_OFF   = 1<<14,/* HW WOL On  (Yukon-EC Ultra A1 only) */
        Y2_ASF_ENABLE   = 1<<13,/* ASF Unit Enable (YUKON-2 only) */
        Y2_ASF_DISABLE  = 1<<12,/* ASF Unit Disable (YUKON-2 only) */
        Y2_CLK_RUN_ENA  = 1<<11,/* CLK_RUN Enable  (YUKON-2 only) */
@@ -378,6 +380,9 @@ enum {
        CHIP_REV_YU_EC_A1    = 0,  /* Chip Rev. for Yukon-EC A1/A0 */
        CHIP_REV_YU_EC_A2    = 1,  /* Chip Rev. for Yukon-EC A2 */
        CHIP_REV_YU_EC_A3    = 2,  /* Chip Rev. for Yukon-EC A3 */
+        CHIP_REV_YU_EC_U_A0  = 0,
+        CHIP_REV_YU_EC_U_A1  = 1,
 };
 /*      B2_Y2_CLK_GATE   8 bit  Clock Gating (Yukon-2 only) */
@@ -1880,6 +1885,8 @@ struct sky2_hw {
        struct sky2_status_le *st_le;
        u32                  st_idx;
        dma_addr_t           st_dma;
+        struct timer_list    idle_timer;
        int                  msi_detected;
        wait_queue_head_t    msi_wait;
 };
diff --git a/drivers/net/spider_net.c b/drivers/net/spider_net.c
index 43f5e86fc559..394339d5e87c 100644
--- a/drivers/net/spider_net.c
+++ b/drivers/net/spider_net.c
@@ -1652,6 +1652,8 @@ spider_net_enable_card(struct spider_net_card *card)
                { SPIDER_NET_GFTRESTRT, SPIDER_NET_RESTART_VALUE },
                { SPIDER_NET_GMRWOLCTRL, 0 },
+                { SPIDER_NET_GTESTMD, 0x10000000 },
+                { SPIDER_NET_GTTQMSK, 0x00400040 },
                { SPIDER_NET_GTESTMD, 0 },
                { SPIDER_NET_GMACINTEN, 0 },
@@ -1792,15 +1794,7 @@ spider_net_setup_phy(struct spider_net_card *card)
        if (phy->def->ops->setup_forced)
                phy->def->ops->setup_forced(phy, SPEED_1000, DUPLEX_FULL);
-        /* the following two writes could be moved to sungem_phy.c */
+        phy->def->ops->enable_fiber(phy);
-        /* enable fiber mode */
-        spider_net_write_phy(card->netdev, 1, MII_NCONFIG, 0x9020);
-        /* LEDs active in both modes, autosense prio = fiber */
-        spider_net_write_phy(card->netdev, 1, MII_NCONFIG, 0x945f);
-        /* switch off fibre autoneg */
-        spider_net_write_phy(card->netdev, 1, MII_NCONFIG, 0xfc01);
-        spider_net_write_phy(card->netdev, 1, 0x0b, 0x0004);
        phy->def->ops->read_link(phy);
        pr_info("Found %s with %i Mbps, %s-duplex.\n", phy->def->name,
diff --git a/drivers/net/spider_net.h b/drivers/net/spider_net.h
index 5922b529a048..3b8d951cf73c 100644
--- a/drivers/net/spider_net.h
+++ b/drivers/net/spider_net.h
@@ -120,6 +120,8 @@ extern char spider_net_driver_name[];
 #define SPIDER_NET_GMRUAFILnR           0x00000500
 #define SPIDER_NET_GMRUA0FIL15R         0x00000578
+#define SPIDER_NET_GTTQMSK              0x00000934
 /* RX DMA controller registers, all 0x00000a.. are for DMA controller A,
 * 0x00000b.. for DMA controller B, etc. */
 #define SPIDER_NET_GDADCHA              0x00000a00
diff --git a/drivers/net/sungem_phy.c b/drivers/net/sungem_phy.c
index cb0aba95d4e3..b2ddd5e79303 100644
--- a/drivers/net/sungem_phy.c
+++ b/drivers/net/sungem_phy.c
@@ -275,7 +275,7 @@ static int bcm5411_init(struct mii_phy* phy)
        return 0;
 }
-static int bcm5411_suspend(struct mii_phy* phy)
+static int generic_suspend(struct mii_phy* phy)
 {
        phy_write(phy, MII_BMCR, BMCR_PDOWN);
@@ -329,6 +329,30 @@ static int bcm5421_init(struct mii_phy* phy)
        return 0;
 }
+static int bcm5421_enable_fiber(struct mii_phy* phy)
+{
+        /* enable fiber mode */
+        phy_write(phy, MII_NCONFIG, 0x9020);
+        /* LEDs active in both modes, autosense prio = fiber */
+        phy_write(phy, MII_NCONFIG, 0x945f);
+        /* switch off fibre autoneg */
+        phy_write(phy, MII_NCONFIG, 0xfc01);
+        phy_write(phy, 0x0b, 0x0004);
+        return 0;
+}
+static int bcm5461_enable_fiber(struct mii_phy* phy)
+{
+        phy_write(phy, MII_NCONFIG, 0xfc0c);
+        phy_write(phy, MII_BMCR, 0x4140);
+        phy_write(phy, MII_NCONFIG, 0xfc0b);
+        phy_write(phy, MII_BMCR, 0x0140);
+        return 0;
+}
 static int bcm54xx_setup_aneg(struct mii_phy *phy, u32 advertise)
 {
        u16 ctl, adv;
@@ -738,7 +762,7 @@ static struct mii_phy_def bcm5401_phy_def = {
 /* Broadcom BCM 5411 */
 static struct mii_phy_ops bcm5411_phy_ops = {
        .init           = bcm5411_init,
-        .suspend        = bcm5411_suspend,
+        .suspend        = generic_suspend,
        .setup_aneg     = bcm54xx_setup_aneg,
        .setup_forced   = bcm54xx_setup_forced,
        .poll_link      = genmii_poll_link,
@@ -757,11 +781,12 @@ static struct mii_phy_def bcm5411_phy_def = {
 /* Broadcom BCM 5421 */
 static struct mii_phy_ops bcm5421_phy_ops = {
        .init           = bcm5421_init,
-        .suspend        = bcm5411_suspend,
+        .suspend        = generic_suspend,
        .setup_aneg     = bcm54xx_setup_aneg,
        .setup_forced   = bcm54xx_setup_forced,
        .poll_link      = genmii_poll_link,
        .read_link      = bcm54xx_read_link,
+        .enable_fiber   = bcm5421_enable_fiber,
 };
 static struct mii_phy_def bcm5421_phy_def = {
@@ -776,7 +801,7 @@ static struct mii_phy_def bcm5421_phy_def = {
 /* Broadcom BCM 5421 built-in K2 */
 static struct mii_phy_ops bcm5421k2_phy_ops = {
        .init           = bcm5421_init,
-        .suspend        = bcm5411_suspend,
+        .suspend        = generic_suspend,
        .setup_aneg     = bcm54xx_setup_aneg,
        .setup_forced   = bcm54xx_setup_forced,
        .poll_link      = genmii_poll_link,
@@ -792,10 +817,29 @@ static struct mii_phy_def bcm5421k2_phy_def = {
        .ops            = &bcm5421k2_phy_ops
 };
+static struct mii_phy_ops bcm5461_phy_ops = {
+        .init           = bcm5421_init,
+        .suspend        = generic_suspend,
+        .setup_aneg     = bcm54xx_setup_aneg,
+        .setup_forced   = bcm54xx_setup_forced,
+        .poll_link      = genmii_poll_link,
+        .read_link      = bcm54xx_read_link,
+        .enable_fiber   = bcm5461_enable_fiber,
+};
+static struct mii_phy_def bcm5461_phy_def = {
+        .phy_id         = 0x002060c0,
+        .phy_id_mask    = 0xfffffff0,
+        .name           = "BCM5461",
+        .features       = MII_GBIT_FEATURES,
+        .magic_aneg     = 1,
+        .ops            = &bcm5461_phy_ops
+};
 /* Broadcom BCM 5462 built-in Vesta */
 static struct mii_phy_ops bcm5462V_phy_ops = {
        .init           = bcm5421_init,
-        .suspend        = bcm5411_suspend,
+        .suspend        = generic_suspend,
        .setup_aneg     = bcm54xx_setup_aneg,
        .setup_forced   = bcm54xx_setup_forced,
        .poll_link      = genmii_poll_link,
@@ -816,6 +860,7 @@ static struct mii_phy_def bcm5462V_phy_def = {
 * would be useful here) --BenH.
 */
 static struct mii_phy_ops marvell_phy_ops = {
+        .suspend        = generic_suspend,
        .setup_aneg     = marvell_setup_aneg,
        .setup_forced   = marvell_setup_forced,
        .poll_link      = genmii_poll_link,
@@ -856,6 +901,7 @@ static struct mii_phy_def* mii_phy_table[] = {
        &bcm5411_phy_def,
        &bcm5421_phy_def,
        &bcm5421k2_phy_def,
+        &bcm5461_phy_def,
        &bcm5462V_phy_def,
        &marvell_phy_def,
        &genmii_phy_def,
diff --git a/drivers/net/sungem_phy.h b/drivers/net/sungem_phy.h
index 430544496c52..69e125197fcf 100644
--- a/drivers/net/sungem_phy.h
+++ b/drivers/net/sungem_phy.h
@@ -12,6 +12,7 @@ struct mii_phy_ops
        int             (*setup_forced)(struct mii_phy *phy, int speed, int fd);
        int             (*poll_link)(struct mii_phy *phy);
        int             (*read_link)(struct mii_phy *phy);
+        int             (*enable_fiber)(struct mii_phy *phy);
 };
 /* Structure used to statically define an mii/gii based PHY */
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 73e271e59c6a..49ad60b72657 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -69,8 +69,8 @@
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.56"
+#define DRV_MODULE_VERSION      "3.58"
-#define DRV_MODULE_RELDATE      "Apr 1, 2006"
+#define DRV_MODULE_RELDATE      "May 22, 2006"
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -974,6 +974,8 @@ static int tg3_phy_reset_5703_4_5(struct tg3 *tp)
        return err;
 }
+static void tg3_link_report(struct tg3 *);
 /* This will reset the tigon3 PHY if there is no valid
 * link unless the FORCE argument is non-zero.
 */
@@ -987,6 +989,11 @@ static int tg3_phy_reset(struct tg3 *tp)
        if (err != 0)
                return -EBUSY;
+        if (netif_running(tp->dev) && netif_carrier_ok(tp->dev)) {
+                netif_carrier_off(tp->dev);
+                tg3_link_report(tp);
+        }
        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
@@ -1023,6 +1030,12 @@ out:
                tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x14e2);
                tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
        }
+        else if (tp->tg3_flags2 & TG3_FLG2_PHY_JITTER_BUG) {
+                tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
+                tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
+                tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x010b);
+                tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
+        }
        /* Set Extended packet length bit (bit 14) on all chips that */
        /* support jumbo frames */
        if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
@@ -3531,7 +3544,7 @@ static irqreturn_t tg3_test_isr(int irq, void *dev_id,
        return IRQ_RETVAL(0);
 }
-static int tg3_init_hw(struct tg3 *);
+static int tg3_init_hw(struct tg3 *, int);
 static int tg3_halt(struct tg3 *, int, int);
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -3567,7 +3580,7 @@ static void tg3_reset_task(void *_data)
        tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER;
        tg3_halt(tp, RESET_KIND_SHUTDOWN, 0);
-        tg3_init_hw(tp);
+        tg3_init_hw(tp, 1);
        tg3_netif_start(tp);
@@ -4042,7 +4055,7 @@ static int tg3_change_mtu(struct net_device *dev, int new_mtu)
        tg3_set_mtu(dev, tp, new_mtu);
-        tg3_init_hw(tp);
+        tg3_init_hw(tp, 0);
        tg3_netif_start(tp);
@@ -5719,9 +5732,23 @@ static int tg3_set_mac_addr(struct net_device *dev, void *p)
        if (!netif_running(dev))
                return 0;
-        spin_lock_bh(&tp->lock);
+        if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
-        __tg3_set_mac_addr(tp);
+                /* Reset chip so that ASF can re-init any MAC addresses it
-        spin_unlock_bh(&tp->lock);
+                 * needs.
+                 */
+                tg3_netif_stop(tp);
+                tg3_full_lock(tp, 1);
+                tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
+                tg3_init_hw(tp, 0);
+                tg3_netif_start(tp);
+                tg3_full_unlock(tp);
+        } else {
+                spin_lock_bh(&tp->lock);
+                __tg3_set_mac_addr(tp);
+                spin_unlock_bh(&tp->lock);
+        }
        return 0;
 }
@@ -5771,7 +5798,7 @@ static void __tg3_set_coalesce(struct tg3 *tp, struct ethtool_coalesce *ec)
 }
 /* tp->lock is held. */
-static int tg3_reset_hw(struct tg3 *tp)
+static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
 {
        u32 val, rdmac_mode;
        int i, err, limit;
@@ -5786,7 +5813,7 @@ static int tg3_reset_hw(struct tg3 *tp)
                tg3_abort_hw(tp, 1);
        }
-        if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
+        if ((tp->tg3_flags2 & TG3_FLG2_MII_SERDES) && reset_phy)
                tg3_phy_reset(tp);
        err = tg3_chip_reset(tp);
@@ -6327,7 +6354,7 @@ static int tg3_reset_hw(struct tg3 *tp)
                tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
        }
-        err = tg3_setup_phy(tp, 1);
+        err = tg3_setup_phy(tp, reset_phy);
        if (err)
                return err;
@@ -6400,7 +6427,7 @@ static int tg3_reset_hw(struct tg3 *tp)
 /* Called at device open time to get the chip ready for
 * packet processing.  Invoked with tp->lock held.
 */
-static int tg3_init_hw(struct tg3 *tp)
+static int tg3_init_hw(struct tg3 *tp, int reset_phy)
 {
        int err;
@@ -6413,7 +6440,7 @@ static int tg3_init_hw(struct tg3 *tp)
        tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
-        err = tg3_reset_hw(tp);
+        err = tg3_reset_hw(tp, reset_phy);
 out:
        return err;
@@ -6461,6 +6488,10 @@ static void tg3_periodic_fetch_stats(struct tg3 *tp)
        TG3_STAT_ADD32(&sp->rx_frame_too_long_errors, MAC_RX_STATS_FRAME_TOO_LONG);
        TG3_STAT_ADD32(&sp->rx_jabbers, MAC_RX_STATS_JABBERS);
        TG3_STAT_ADD32(&sp->rx_undersize_packets, MAC_RX_STATS_UNDERSIZE);
+        TG3_STAT_ADD32(&sp->rxbds_empty, RCVLPC_NO_RCV_BD_CNT);
+        TG3_STAT_ADD32(&sp->rx_discards, RCVLPC_IN_DISCARDS_CNT);
+        TG3_STAT_ADD32(&sp->rx_errors, RCVLPC_IN_ERRORS_CNT);
 }
 static void tg3_timer(unsigned long __opaque)
@@ -6683,7 +6714,7 @@ static int tg3_test_msi(struct tg3 *tp)
        tg3_full_lock(tp, 1);
        tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
-        err = tg3_init_hw(tp);
+        err = tg3_init_hw(tp, 1);
        tg3_full_unlock(tp);
@@ -6748,7 +6779,7 @@ static int tg3_open(struct net_device *dev)
        tg3_full_lock(tp, 0);
-        err = tg3_init_hw(tp);
+        err = tg3_init_hw(tp, 1);
        if (err) {
                tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
                tg3_free_rings(tp);
@@ -7626,21 +7657,23 @@ 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_ANY_SERDES))
+        if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)) {
                cmd->supported |= (SUPPORTED_100baseT_Half |
                                  SUPPORTED_100baseT_Full |
                                  SUPPORTED_10baseT_Half |
                                  SUPPORTED_10baseT_Full |
                                  SUPPORTED_MII);
-        else
+                cmd->port = PORT_TP;
+        } else {
                cmd->supported |= SUPPORTED_FIBRE;
+                cmd->port = PORT_FIBRE;
+        }
  
        cmd->advertising = tp->link_config.advertising;
        if (netif_running(dev)) {
                cmd->speed = tp->link_config.active_speed;
                cmd->duplex = tp->link_config.active_duplex;
        }
-        cmd->port = 0;
        cmd->phy_address = PHY_ADDR;
        cmd->transceiver = 0;
        cmd->autoneg = tp->link_config.autoneg;
@@ -7839,7 +7872,7 @@ static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *e
        if (netif_running(dev)) {
                tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
-                tg3_init_hw(tp);
+                tg3_init_hw(tp, 1);
                tg3_netif_start(tp);
        }
@@ -7884,7 +7917,7 @@ static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam
        if (netif_running(dev)) {
                tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
-                tg3_init_hw(tp);
+                tg3_init_hw(tp, 1);
                tg3_netif_start(tp);
        }
@@ -8427,6 +8460,9 @@ static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
        tx_len = 1514;
        skb = dev_alloc_skb(tx_len);
+        if (!skb)
+                return -ENOMEM;
        tx_data = skb_put(skb, tx_len);
        memcpy(tx_data, tp->dev->dev_addr, 6);
        memset(tx_data + 6, 0x0, 8);
@@ -8522,7 +8558,7 @@ static int tg3_test_loopback(struct tg3 *tp)
        if (!netif_running(tp->dev))
                return TG3_LOOPBACK_FAILED;
-        tg3_reset_hw(tp);
+        tg3_reset_hw(tp, 1);
        if (tg3_run_loopback(tp, TG3_MAC_LOOPBACK))
                err |= TG3_MAC_LOOPBACK_FAILED;
@@ -8596,7 +8632,7 @@ static void tg3_self_test(struct net_device *dev, struct ethtool_test *etest,
                tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
                if (netif_running(dev)) {
                        tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
-                        tg3_init_hw(tp);
+                        tg3_init_hw(tp, 1);
                        tg3_netif_start(tp);
                }
@@ -9377,7 +9413,7 @@ static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
                if ((page_off == 0) || (i == 0))
                        nvram_cmd |= NVRAM_CMD_FIRST;
-                else if (page_off == (tp->nvram_pagesize - 4))
+                if (page_off == (tp->nvram_pagesize - 4))
                        nvram_cmd |= NVRAM_CMD_LAST;
                if (i == (len - 4))
@@ -10353,10 +10389,13 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
        if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0)
                tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
-        if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
+        if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
-            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755) &&
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
-            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787))
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
-                tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
+                        tp->tg3_flags2 |= TG3_FLG2_PHY_JITTER_BUG;
+                else
+                        tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
+        }
        tp->coalesce_mode = 0;
        if (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_AX &&
@@ -11569,7 +11608,7 @@ static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
                tg3_full_lock(tp, 0);
                tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
-                tg3_init_hw(tp);
+                tg3_init_hw(tp, 1);
                tp->timer.expires = jiffies + tp->timer_offset;
                add_timer(&tp->timer);
@@ -11603,7 +11642,7 @@ static int tg3_resume(struct pci_dev *pdev)
        tg3_full_lock(tp, 0);
        tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
-        tg3_init_hw(tp);
+        tg3_init_hw(tp, 1);
        tp->timer.expires = jiffies + tp->timer_offset;
        add_timer(&tp->timer);
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 8c8b987d1250..0e29b885d449 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2215,6 +2215,7 @@ struct tg3 {
 #define TG3_FLG2_HW_TSO_2               0x08000000
 #define TG3_FLG2_HW_TSO                 (TG3_FLG2_HW_TSO_1 | TG3_FLG2_HW_TSO_2)
 #define TG3_FLG2_1SHOT_MSI              0x10000000
+#define TG3_FLG2_PHY_JITTER_BUG         0x20000000
        u32                             split_mode_max_reqs;
 #define SPLIT_MODE_5704_MAX_REQ         3
diff --git a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c
index ba05dedf29d3..136a70c4d5e4 100644
--- a/drivers/net/tulip/winbond-840.c
+++ b/drivers/net/tulip/winbond-840.c
@@ -850,7 +850,7 @@ static void init_rxtx_rings(struct net_device *dev)
                        break;
                skb->dev = dev;                 /* Mark as being used by this device. */
                np->rx_addr[i] = pci_map_single(np->pci_dev,skb->data,
-                                        skb->len,PCI_DMA_FROMDEVICE);
+                                        np->rx_buf_sz,PCI_DMA_FROMDEVICE);
                np->rx_ring[i].buffer1 = np->rx_addr[i];
                np->rx_ring[i].status = DescOwn;
@@ -1316,7 +1316,7 @@ static int netdev_rx(struct net_device *dev)
                        skb->dev = dev;                 /* Mark as being used by this device. */
                        np->rx_addr[entry] = pci_map_single(np->pci_dev,
                                                        skb->data,
-                                                        skb->len, PCI_DMA_FROMDEVICE);
+                                                        np->rx_buf_sz, PCI_DMA_FROMDEVICE);
                        np->rx_ring[entry].buffer1 = np->rx_addr[entry];
                }
                wmb();
diff --git a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
index 6a23964c1317..fdc21037f6dc 100644
--- a/drivers/net/via-rhine.c
+++ b/drivers/net/via-rhine.c
@@ -129,6 +129,7 @@
        - Massive clean-up
        - Rewrite PHY, media handling (remove options, full_duplex, backoff)
        - Fix Tx engine race for good
+        - Craig Brind: Zero padded aligned buffers for short packets.
 */
@@ -490,8 +491,6 @@ 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;
 };
@@ -499,8 +498,6 @@ 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);
@@ -855,12 +852,6 @@ 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)
@@ -1107,11 +1098,6 @@ static void rhine_set_carrier(struct mii_if_info *mii)
                       netif_carrier_ok(mii->dev));
 }
-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);
@@ -1165,8 +1151,8 @@ static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
        if (quirks & rqRhineI) {
                iowrite8(0x01, ioaddr + MIIRegAddr);    // MII_BMSR
-                /* Do not call from ISR! */
+                /* Can be called from ISR. Evil. */
-                msleep(1);
+                mdelay(1);
                /* 0x80 must be set immediately before turning it off */
                iowrite8(0x80, ioaddr + MIICmd);
@@ -1256,16 +1242,6 @@ 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 "
@@ -1326,7 +1302,12 @@ static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
                        rp->stats.tx_dropped++;
                        return 0;
                }
+                /* Padding is not copied and so must be redone. */
                skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
+                if (skb->len < ETH_ZLEN)
+                        memset(rp->tx_buf[entry] + skb->len, 0,
+                               ETH_ZLEN - skb->len);
                rp->tx_skbuff_dma[entry] = 0;
                rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
                                                      (rp->tx_buf[entry] -
@@ -1671,7 +1652,7 @@ static void rhine_error(struct net_device *dev, int intr_status)
        spin_lock(&rp->lock);
        if (intr_status & IntrLinkChange)
-                schedule_work(&rp->check_media_task);
+                rhine_check_media(dev, 0);
        if (intr_status & IntrStatsMax) {
                rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
                rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
@@ -1921,9 +1902,6 @@ 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/wireless/Kconfig b/drivers/net/wireless/Kconfig
index bad09ebdb50b..e0874cbfefea 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -6,7 +6,7 @@ menu "Wireless LAN (non-hamradio)"
        depends on NETDEVICES
 config NET_RADIO
-        bool "Wireless LAN drivers (non-hamradio)"
+        bool "Wireless LAN drivers (non-hamradio) & Wireless Extensions"
        select WIRELESS_EXT
        ---help---
          Support for wireless LANs and everything having to do with radio,
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 108d9fed8f07..00764ddd74d8 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -3139,6 +3139,7 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                }
                if ( status & EV_LINK ) {
                        union iwreq_data        wrqu;
+                        int scan_forceloss = 0;
                        /* The link status has changed, if you want to put a
                           monitor hook in, do it here.  (Remember that
                           interrupts are still disabled!)
@@ -3157,7 +3158,8 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                          code) */
 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
                           code) */
-#define ASSOCIATED 0x0400 /* Assocatied */
+#define ASSOCIATED 0x0400 /* Associated */
+#define REASSOCIATED 0x0600 /* Reassociated?  Only on firmware >= 5.30.17 */
 #define RC_RESERVED 0 /* Reserved return code */
 #define RC_NOREASON 1 /* Unspecified reason */
 #define RC_AUTHINV 2 /* Previous authentication invalid */
@@ -3174,44 +3176,30 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                          leaving BSS */
 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
                       Authenticated with the responding station */
-                        if (newStatus != ASSOCIATED) {
+                        if (newStatus == FORCELOSS && apriv->scan_timeout > 0)
-                                if (auto_wep && !apriv->expires) {
+                                scan_forceloss = 1;
-                                        apriv->expires = RUN_AT(3*HZ);
+                        if(newStatus == ASSOCIATED || newStatus == REASSOCIATED) {
-                                        wake_up_interruptible(&apriv->thr_wait);
-                                }
-                        } else {
-                                struct task_struct *task = apriv->task;
                                if (auto_wep)
                                        apriv->expires = 0;
-                                if (task)
+                                if (apriv->task)
-                                        wake_up_process (task);
+                                        wake_up_process (apriv->task);
                                set_bit(FLAG_UPDATE_UNI, &apriv->flags);
                                set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
-                        }
-                        /* Question : is ASSOCIATED the only status
-                         * that is valid ? We want to catch handover
-                         * and reassociations as valid status
-                         * Jean II */
-                        if(newStatus == ASSOCIATED) {
-#if 0
-                                /* FIXME: Grabbing scan results here
-                                 * seems to be too early???  Just wait for
-                                 * timeout instead. */
-                                if (apriv->scan_timeout > 0) {
-                                        set_bit(JOB_SCAN_RESULTS, &apriv->flags);
-                                        wake_up_interruptible(&apriv->thr_wait);
-                                }
-#endif
                                if (down_trylock(&apriv->sem) != 0) {
                                        set_bit(JOB_EVENT, &apriv->flags);
                                        wake_up_interruptible(&apriv->thr_wait);
                                } else
                                        airo_send_event(dev);
-                        } else {
+                        } else if (!scan_forceloss) {
-                                memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
+                                if (auto_wep && !apriv->expires) {
-                                wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+                                        apriv->expires = RUN_AT(3*HZ);
+                                        wake_up_interruptible(&apriv->thr_wait);
+                                }
                                /* Send event to user space */
+                                memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
+                                wrqu.ap_addr.sa_family = ARPHRD_ETHER;
                                wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
                        }
                }
@@ -7136,10 +7124,10 @@ static int airo_set_scan(struct net_device *dev,
                goto out;
        /* Initiate a scan command */
+        ai->scan_timeout = RUN_AT(3*HZ);
        memset(&cmd, 0, sizeof(cmd));
        cmd.cmd=CMD_LISTBSS;
        issuecommand(ai, &cmd, &rsp);
-        ai->scan_timeout = RUN_AT(3*HZ);
        wake = 1;
 out:
diff --git a/drivers/net/wireless/arlan-main.c b/drivers/net/wireless/arlan-main.c
index 0e1ac338cac1..bed6823d9809 100644
--- a/drivers/net/wireless/arlan-main.c
+++ b/drivers/net/wireless/arlan-main.c
@@ -1838,7 +1838,7 @@ struct net_device * __init arlan_probe(int unit)
 }
 #ifdef  MODULE
-int init_module(void)
+int __init init_module(void)
 {
        int i = 0;
@@ -1860,7 +1860,7 @@ int init_module(void)
 }
-void cleanup_module(void)
+void __exit cleanup_module(void)
 {
        int i = 0;
        struct net_device *dev;
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index 87afa6878f26..8606c88886fc 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -3463,6 +3463,7 @@ static void atmel_command_irq(struct atmel_private *priv)
        u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
        u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET));
        int fast_scan;
+        union iwreq_data wrqu;
        if (status == CMD_STATUS_IDLE ||
            status == CMD_STATUS_IN_PROGRESS)
@@ -3487,6 +3488,7 @@ static void atmel_command_irq(struct atmel_private *priv)
                        atmel_scan(priv, 1);
                } else {
                        int bss_index = retrieve_bss(priv);
+                        int notify_scan_complete = 1;
                        if (bss_index != -1) {
                                atmel_join_bss(priv, bss_index);
                        } else if (priv->operating_mode == IW_MODE_ADHOC &&
@@ -3495,8 +3497,14 @@ static void atmel_command_irq(struct atmel_private *priv)
                        } else {
                                priv->fast_scan = !fast_scan;
                                atmel_scan(priv, 1);
+                                notify_scan_complete = 0;
                        }
                        priv->site_survey_state = SITE_SURVEY_COMPLETED;
+                        if (notify_scan_complete) {
+                                wrqu.data.length = 0;
+                                wrqu.data.flags = 0;
+                                wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
+                        }
                }
                break;
@@ -3509,6 +3517,9 @@ static void atmel_command_irq(struct atmel_private *priv)
                priv->site_survey_state = SITE_SURVEY_COMPLETED;
                if (priv->station_is_associated) {
                        atmel_enter_state(priv, STATION_STATE_READY);
+                        wrqu.data.length = 0;
+                        wrqu.data.flags = 0;
+                        wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
                } else {
                        atmel_scan(priv, 1);
                }
diff --git a/drivers/net/wireless/bcm43xx/Kconfig b/drivers/net/wireless/bcm43xx/Kconfig
index 418465600a77..25ea4748f0b9 100644
--- a/drivers/net/wireless/bcm43xx/Kconfig
+++ b/drivers/net/wireless/bcm43xx/Kconfig
@@ -17,8 +17,11 @@ config BCM43XX_DEBUG
 config BCM43XX_DMA
        bool
+        depends on BCM43XX
 config BCM43XX_PIO
        bool
+        depends on BCM43XX
 choice
        prompt "BCM43xx data transfer mode"
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx.h b/drivers/net/wireless/bcm43xx/bcm43xx.h
index dcadd295de4f..2e83083935e1 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx.h
@@ -15,7 +15,6 @@
 #include "bcm43xx_debugfs.h"
 #include "bcm43xx_leds.h"
-#include "bcm43xx_sysfs.h"
 #define PFX                             KBUILD_MODNAME ": "
@@ -638,8 +637,6 @@ struct bcm43xx_key {
 };
 struct bcm43xx_private {
-        struct bcm43xx_sysfs sysfs;
        struct ieee80211_device *ieee;
        struct ieee80211softmac_device *softmac;
@@ -772,6 +769,20 @@ struct bcm43xx_private * bcm43xx_priv(struct net_device *dev)
        return ieee80211softmac_priv(dev);
 }
+struct device;
+static inline
+struct bcm43xx_private * dev_to_bcm(struct device *dev)
+{
+        struct net_device *net_dev;
+        struct bcm43xx_private *bcm;
+        net_dev = dev_get_drvdata(dev);
+        bcm = bcm43xx_priv(net_dev);
+        return bcm;
+}
 /* Helper function, which returns a boolean.
 * TRUE, if PIO is used; FALSE, if DMA is used.
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
index d2c3401e9b70..35a4fcb6d923 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
@@ -452,12 +452,12 @@ void bcm43xx_printk_dump(const char *data,
        size_t i;
        char c;
-        printk(KERN_INFO PFX "Data dump (%s, %u bytes):",
+        printk(KERN_INFO PFX "Data dump (%s, %zd bytes):",
               description, size);
        for (i = 0; i < size; i++) {
                c = data[i];
                if (i % 8 == 0)
-                        printk("\n" KERN_INFO PFX "0x%08x:  0x%02x, ", i, c & 0xff);
+                        printk("\n" KERN_INFO PFX "0x%08zx:  0x%02x, ", i, c & 0xff);
                else
                        printk("0x%02x, ", c & 0xff);
        }
@@ -472,12 +472,12 @@ void bcm43xx_printk_bitdump(const unsigned char *data,
        int j;
        const unsigned char *d;
-        printk(KERN_INFO PFX "*** Bitdump (%s, %u bytes, %s) ***",
+        printk(KERN_INFO PFX "*** Bitdump (%s, %zd bytes, %s) ***",
               description, bytes, msb_to_lsb ? "MSB to LSB" : "LSB to MSB");
        for (i = 0; i < bytes; i++) {
                d = data + i;
                if (i % 8 == 0)
-                        printk("\n" KERN_INFO PFX "0x%08x:  ", i);
+                        printk("\n" KERN_INFO PFX "0x%08zx:  ", i);
                if (msb_to_lsb) {
                        for (j = 7; j >= 0; j--) {
                                if (*d & (1 << j))
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_dma.c b/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
index c3681b8f09b4..d0318e525ba7 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
@@ -196,8 +196,9 @@ static int alloc_ringmemory(struct bcm43xx_dmaring *ring)
        }
        if (ring->dmabase + BCM43xx_DMA_RINGMEMSIZE > BCM43xx_DMA_BUSADDRMAX) {
                printk(KERN_ERR PFX ">>>FATAL ERROR<<<  DMA RINGMEMORY >1G "
-                                    "(0x%08x, len: %lu)\n",
+                                    "(0x%llx, len: %lu)\n",
-                       ring->dmabase, BCM43xx_DMA_RINGMEMSIZE);
+                                (unsigned long long)ring->dmabase,
+                                BCM43xx_DMA_RINGMEMSIZE);
                dma_free_coherent(dev, BCM43xx_DMA_RINGMEMSIZE,
                                  ring->vbase, ring->dmabase);
                return -ENOMEM;
@@ -307,8 +308,8 @@ static int setup_rx_descbuffer(struct bcm43xx_dmaring *ring,
                unmap_descbuffer(ring, dmaaddr, ring->rx_buffersize, 0);
                dev_kfree_skb_any(skb);
                printk(KERN_ERR PFX ">>>FATAL ERROR<<<  DMA RX SKB >1G "
-                                    "(0x%08x, len: %u)\n",
+                                    "(0x%llx, len: %u)\n",
-                       dmaaddr, ring->rx_buffersize);
+                        (unsigned long long)dmaaddr, ring->rx_buffersize);
                return -ENOMEM;
        }
        meta->skb = skb;
@@ -623,25 +624,28 @@ err_destroy_tx0:
 static u16 generate_cookie(struct bcm43xx_dmaring *ring,
                           int slot)
 {
-        u16 cookie = 0x0000;
+        u16 cookie = 0xF000;
        /* Use the upper 4 bits of the cookie as
         * DMA controller ID and store the slot number
-         * in the lower 12 bits
+         * in the lower 12 bits.
+         * Note that the cookie must never be 0, as this
+         * is a special value used in RX path.
         */
        switch (ring->mmio_base) {
        default:
                assert(0);
        case BCM43xx_MMIO_DMA1_BASE:
+                cookie = 0xA000;
                break;
        case BCM43xx_MMIO_DMA2_BASE:
-                cookie = 0x1000;
+                cookie = 0xB000;
                break;
        case BCM43xx_MMIO_DMA3_BASE:
-                cookie = 0x2000;
+                cookie = 0xC000;
                break;
        case BCM43xx_MMIO_DMA4_BASE:
-                cookie = 0x3000;
+                cookie = 0xD000;
                break;
        }
        assert(((u16)slot & 0xF000) == 0x0000);
@@ -659,16 +663,16 @@ struct bcm43xx_dmaring * parse_cookie(struct bcm43xx_private *bcm,
        struct bcm43xx_dmaring *ring = NULL;
        switch (cookie & 0xF000) {
-        case 0x0000:
+        case 0xA000:
                ring = dma->tx_ring0;
                break;
-        case 0x1000:
+        case 0xB000:
                ring = dma->tx_ring1;
                break;
-        case 0x2000:
+        case 0xC000:
                ring = dma->tx_ring2;
                break;
-        case 0x3000:
+        case 0xD000:
                ring = dma->tx_ring3;
                break;
        default:
@@ -729,8 +733,8 @@ static int dma_tx_fragment(struct bcm43xx_dmaring *ring,
        if (unlikely(meta->dmaaddr + skb->len > BCM43xx_DMA_BUSADDRMAX)) {
                return_slot(ring, slot);
                printk(KERN_ERR PFX ">>>FATAL ERROR<<<  DMA TX SKB >1G "
-                                    "(0x%08x, len: %u)\n",
+                                    "(0x%llx, len: %u)\n",
-                       meta->dmaaddr, skb->len);
+                        (unsigned long long)meta->dmaaddr, skb->len);
                return -ENOMEM;
        }
@@ -838,8 +842,18 @@ static void dma_rx(struct bcm43xx_dmaring *ring,
                /* We received an xmit status. */
                struct bcm43xx_hwxmitstatus *hw = (struct bcm43xx_hwxmitstatus *)skb->data;
                struct bcm43xx_xmitstatus stat;
+                int i = 0;
                stat.cookie = le16_to_cpu(hw->cookie);
+                while (stat.cookie == 0) {
+                        if (unlikely(++i >= 10000)) {
+                                assert(0);
+                                break;
+                        }
+                        udelay(2);
+                        barrier();
+                        stat.cookie = le16_to_cpu(hw->cookie);
+                }
                stat.flags = hw->flags;
                stat.cnt1 = hw->cnt1;
                stat.cnt2 = hw->cnt2;
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_dma.h b/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
index 2d520e4b0276..b7d77638ba8c 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
@@ -213,6 +213,14 @@ static inline
 void bcm43xx_dma_rx(struct bcm43xx_dmaring *ring)
 {
 }
+static inline
+void bcm43xx_dma_tx_suspend(struct bcm43xx_dmaring *ring)
+{
+}
+static inline
+void bcm43xx_dma_tx_resume(struct bcm43xx_dmaring *ring)
+{
+}
 #endif /* CONFIG_BCM43XX_DMA */
 #endif /* BCM43xx_DMA_H_ */
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_main.c b/drivers/net/wireless/bcm43xx/bcm43xx_main.c
index c37371fc9e01..7ed18cad29f7 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_main.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_main.c
@@ -52,6 +52,7 @@
 #include "bcm43xx_wx.h"
 #include "bcm43xx_ethtool.h"
 #include "bcm43xx_xmit.h"
+#include "bcm43xx_sysfs.h"
 MODULE_DESCRIPTION("Broadcom BCM43xx wireless driver");
@@ -938,9 +939,9 @@ static int bcm43xx_sprom_extract(struct bcm43xx_private *bcm)
        return 0;
 }
-static void bcm43xx_geo_init(struct bcm43xx_private *bcm)
+static int bcm43xx_geo_init(struct bcm43xx_private *bcm)
 {
-        struct ieee80211_geo geo;
+        struct ieee80211_geo *geo;
        struct ieee80211_channel *chan;
        int have_a = 0, have_bg = 0;
        int i;
@@ -948,7 +949,10 @@ static void bcm43xx_geo_init(struct bcm43xx_private *bcm)
        struct bcm43xx_phyinfo *phy;
        const char *iso_country;
-        memset(&geo, 0, sizeof(geo));
+        geo = kzalloc(sizeof(*geo), GFP_KERNEL);
+        if (!geo)
+                return -ENOMEM;
        for (i = 0; i < bcm->nr_80211_available; i++) {
                phy = &(bcm->core_80211_ext[i].phy);
                switch (phy->type) {
@@ -966,31 +970,36 @@ static void bcm43xx_geo_init(struct bcm43xx_private *bcm)
        iso_country = bcm43xx_locale_iso(bcm->sprom.locale);
        if (have_a) {
-                for (i = 0, channel = 0; channel < 201; channel++) {
+                for (i = 0, channel = IEEE80211_52GHZ_MIN_CHANNEL;
-                        chan = &geo.a[i++];
+                      channel <= IEEE80211_52GHZ_MAX_CHANNEL; channel++) {
+                        chan = &geo->a[i++];
                        chan->freq = bcm43xx_channel_to_freq_a(channel);
                        chan->channel = channel;
                }
-                geo.a_channels = i;
+                geo->a_channels = i;
        }
        if (have_bg) {
-                for (i = 0, channel = 1; channel < 15; channel++) {
+                for (i = 0, channel = IEEE80211_24GHZ_MIN_CHANNEL;
-                        chan = &geo.bg[i++];
+                      channel <= IEEE80211_24GHZ_MAX_CHANNEL; channel++) {
+                        chan = &geo->bg[i++];
                        chan->freq = bcm43xx_channel_to_freq_bg(channel);
                        chan->channel = channel;
                }
-                geo.bg_channels = i;
+                geo->bg_channels = i;
        }
-        memcpy(geo.name, iso_country, 2);
+        memcpy(geo->name, iso_country, 2);
        if (0 /*TODO: Outdoor use only */)
-                geo.name[2] = 'O';
+                geo->name[2] = 'O';
        else if (0 /*TODO: Indoor use only */)
-                geo.name[2] = 'I';
+                geo->name[2] = 'I';
        else
-                geo.name[2] = ' ';
+                geo->name[2] = ' ';
-        geo.name[3] = '\0';
+        geo->name[3] = '\0';
+        ieee80211_set_geo(bcm->ieee, geo);
+        kfree(geo);
-        ieee80211_set_geo(bcm->ieee, &geo);
+        return 0;
 }
 /* DummyTransmission function, as documented on 
@@ -3262,6 +3271,9 @@ static int bcm43xx_init_board(struct bcm43xx_private *bcm)
        bcm43xx_sysfs_register(bcm);
        //FIXME: check for bcm43xx_sysfs_register failure. This function is a bit messy regarding unwinding, though...
+        /*FIXME: This should be handled by softmac instead. */
+        schedule_work(&bcm->softmac->associnfo.work);
        assert(err == 0);
 out:
        return err;
@@ -3478,16 +3490,17 @@ static int bcm43xx_attach_board(struct bcm43xx_private *bcm)
                        goto err_80211_unwind;
                bcm43xx_wireless_core_disable(bcm);
        }
+        err = bcm43xx_geo_init(bcm);
+        if (err)
+                goto err_80211_unwind;
        bcm43xx_pctl_set_crystal(bcm, 0);
        /* Set the MAC address in the networking subsystem */
-        if (bcm43xx_current_phy(bcm)->type == BCM43xx_PHYTYPE_A)
+        if (is_valid_ether_addr(bcm->sprom.et1macaddr))
                memcpy(bcm->net_dev->dev_addr, bcm->sprom.et1macaddr, 6);
        else
                memcpy(bcm->net_dev->dev_addr, bcm->sprom.il0macaddr, 6);
-        bcm43xx_geo_init(bcm);
        snprintf(bcm->nick, IW_ESSID_MAX_SIZE,
                 "Broadcom %04X", bcm->chip_id);
@@ -3522,6 +3535,7 @@ static inline int bcm43xx_tx(struct bcm43xx_private *bcm,
                err = bcm43xx_pio_tx(bcm, txb);
        else
                err = bcm43xx_dma_tx(bcm, txb);
+        bcm->net_dev->trans_start = jiffies;
        return err;
 }
@@ -3935,9 +3949,6 @@ static int bcm43xx_resume(struct pci_dev *pdev)
        netif_device_attach(net_dev);
        
-        /*FIXME: This should be handled by softmac instead. */
-        schedule_work(&bcm->softmac->associnfo.work);
        dprintk(KERN_INFO PFX "Device resumed.\n");
        return 0;
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_main.h b/drivers/net/wireless/bcm43xx/bcm43xx_main.h
index eca79a38594a..30a202b258b5 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_main.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_main.h
@@ -118,12 +118,14 @@ int bcm43xx_channel_to_freq(struct bcm43xx_private *bcm,
 static inline
 int bcm43xx_is_valid_channel_a(u8 channel)
 {
-        return (channel <= 200);
+        return (channel >= IEEE80211_52GHZ_MIN_CHANNEL
+               && channel <= IEEE80211_52GHZ_MAX_CHANNEL);
 }
 static inline
 int bcm43xx_is_valid_channel_bg(u8 channel)
 {
-        return (channel >= 1 && channel <= 14);
+        return (channel >= IEEE80211_24GHZ_MIN_CHANNEL
+               && channel <= IEEE80211_24GHZ_MAX_CHANNEL);
 }
 static inline
 int bcm43xx_is_valid_channel(struct bcm43xx_private *bcm,
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_phy.c b/drivers/net/wireless/bcm43xx/bcm43xx_phy.c
index 0a66f43ca0c0..b0abac515530 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_phy.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_phy.c
@@ -1287,7 +1287,7 @@ static void bcm43xx_phy_initg(struct bcm43xx_private *bcm)
        if (radio->revision == 8)
                bcm43xx_phy_write(bcm, 0x0805, 0x3230);
        bcm43xx_phy_init_pctl(bcm);
-        if (bcm->chip_id == 0x4306 && bcm->chip_package != 2) {
+        if (bcm->chip_id == 0x4306 && bcm->chip_package == 2) {
                bcm43xx_phy_write(bcm, 0x0429,
                                  bcm43xx_phy_read(bcm, 0x0429) & 0xBFFF);
                bcm43xx_phy_write(bcm, 0x04C3,
@@ -2151,6 +2151,7 @@ int bcm43xx_phy_init_tssi2dbm_table(struct bcm43xx_private *bcm)
                                phy->tssi2dbm = NULL;
                                printk(KERN_ERR PFX "Could not generate "
                                                    "tssi2dBm table\n");
+                                kfree(dyn_tssi2dbm);
                                return -ENODEV;
                        }
                phy->tssi2dbm = dyn_tssi2dbm;
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_pio.c b/drivers/net/wireless/bcm43xx/bcm43xx_pio.c
index c59ddd40680d..0aa1bd269a25 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_pio.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_pio.c
@@ -27,6 +27,7 @@
 #include "bcm43xx_pio.h"
 #include "bcm43xx_main.h"
 #include "bcm43xx_xmit.h"
+#include "bcm43xx_power.h"
 #include <linux/delay.h>
@@ -44,10 +45,10 @@ static void tx_octet(struct bcm43xx_pioqueue *queue,
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXDATA,
                                  octet);
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
-                                  BCM43xx_PIO_TXCTL_WRITEHI);
+                                  BCM43xx_PIO_TXCTL_WRITELO);
        } else {
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
-                                  BCM43xx_PIO_TXCTL_WRITEHI);
+                                  BCM43xx_PIO_TXCTL_WRITELO);
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXDATA,
                                  octet);
        }
@@ -103,7 +104,7 @@ static void tx_complete(struct bcm43xx_pioqueue *queue,
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXDATA,
                                  skb->data[skb->len - 1]);
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
-                                  BCM43xx_PIO_TXCTL_WRITEHI |
+                                  BCM43xx_PIO_TXCTL_WRITELO |
                                  BCM43xx_PIO_TXCTL_COMPLETE);
        } else {
                bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
@@ -112,9 +113,10 @@ static void tx_complete(struct bcm43xx_pioqueue *queue,
 }
 static u16 generate_cookie(struct bcm43xx_pioqueue *queue,
-                           int packetindex)
+                           struct bcm43xx_pio_txpacket *packet)
 {
        u16 cookie = 0x0000;
+        int packetindex;
        /* We use the upper 4 bits for the PIO
         * controller ID and the lower 12 bits
@@ -135,6 +137,7 @@ static u16 generate_cookie(struct bcm43xx_pioqueue *queue,
        default:
                assert(0);
        }
+        packetindex = pio_txpacket_getindex(packet);
        assert(((u16)packetindex & 0xF000) == 0x0000);
        cookie |= (u16)packetindex;
@@ -184,7 +187,7 @@ static void pio_tx_write_fragment(struct bcm43xx_pioqueue *queue,
        bcm43xx_generate_txhdr(queue->bcm,
                               &txhdr, skb->data, skb->len,
                               (packet->xmitted_frags == 0),
-                               generate_cookie(queue, pio_txpacket_getindex(packet)));
+                               generate_cookie(queue, packet));
        tx_start(queue);
        octets = skb->len + sizeof(txhdr);
@@ -241,7 +244,7 @@ static int pio_tx_packet(struct bcm43xx_pio_txpacket *packet)
                queue->tx_devq_packets++;
                queue->tx_devq_used += octets;
-                assert(packet->xmitted_frags <= packet->txb->nr_frags);
+                assert(packet->xmitted_frags < packet->txb->nr_frags);
                packet->xmitted_frags++;
                packet->xmitted_octets += octets;
        }
@@ -257,8 +260,14 @@ static void tx_tasklet(unsigned long d)
        unsigned long flags;
        struct bcm43xx_pio_txpacket *packet, *tmp_packet;
        int err;
+        u16 txctl;
        bcm43xx_lock_mmio(bcm, flags);
+        txctl = bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL);
+        if (txctl & BCM43xx_PIO_TXCTL_SUSPEND)
+                goto out_unlock;
        list_for_each_entry_safe(packet, tmp_packet, &queue->txqueue, list) {
                assert(packet->xmitted_frags < packet->txb->nr_frags);
                if (packet->xmitted_frags == 0) {
@@ -288,6 +297,7 @@ static void tx_tasklet(unsigned long d)
        next_packet:
                continue;
        }
+out_unlock:
        bcm43xx_unlock_mmio(bcm, flags);
 }
@@ -330,12 +340,19 @@ struct bcm43xx_pioqueue * bcm43xx_setup_pioqueue(struct bcm43xx_private *bcm,
                     (unsigned long)queue);
        value = bcm43xx_read32(bcm, BCM43xx_MMIO_STATUS_BITFIELD);
-        value |= BCM43xx_SBF_XFER_REG_BYTESWAP;
+        value &= ~BCM43xx_SBF_XFER_REG_BYTESWAP;
        bcm43xx_write32(bcm, BCM43xx_MMIO_STATUS_BITFIELD, value);
        qsize = bcm43xx_read16(bcm, queue->mmio_base + BCM43xx_PIO_TXQBUFSIZE);
+        if (qsize == 0) {
+                printk(KERN_ERR PFX "ERROR: This card does not support PIO "
+                                    "operation mode. Please use DMA mode "
+                                    "(module parameter pio=0).\n");
+                goto err_freequeue;
+        }
        if (qsize <= BCM43xx_PIO_TXQADJUST) {
-                printk(KERN_ERR PFX "PIO tx device-queue too small (%u)\n", qsize);
+                printk(KERN_ERR PFX "PIO tx device-queue too small (%u)\n",
+                       qsize);
                goto err_freequeue;
        }
        qsize -= BCM43xx_PIO_TXQADJUST;
@@ -444,15 +461,10 @@ int bcm43xx_pio_tx(struct bcm43xx_private *bcm,
 {
        struct bcm43xx_pioqueue *queue = bcm43xx_current_pio(bcm)->queue1;
        struct bcm43xx_pio_txpacket *packet;
-        u16 tmp;
        assert(!queue->tx_suspended);
        assert(!list_empty(&queue->txfree));
-        tmp = bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL);
-        if (tmp & BCM43xx_PIO_TXCTL_SUSPEND)
-                return -EBUSY;
        packet = list_entry(queue->txfree.next, struct bcm43xx_pio_txpacket, list);
        packet->txb = txb;
        packet->xmitted_frags = 0;
@@ -462,7 +474,7 @@ int bcm43xx_pio_tx(struct bcm43xx_private *bcm,
        assert(queue->nr_txfree < BCM43xx_PIO_MAXTXPACKETS);
        /* Suspend TX, if we are out of packets in the "free" queue. */
-        if (unlikely(list_empty(&queue->txfree))) {
+        if (list_empty(&queue->txfree)) {
                netif_stop_queue(queue->bcm->net_dev);
                queue->tx_suspended = 1;
        }
@@ -480,15 +492,15 @@ void bcm43xx_pio_handle_xmitstatus(struct bcm43xx_private *bcm,
        queue = parse_cookie(bcm, status->cookie, &packet);
        assert(queue);
-//TODO
-if (!queue)
-return;
        free_txpacket(packet, 1);
-        if (unlikely(queue->tx_suspended)) {
+        if (queue->tx_suspended) {
                queue->tx_suspended = 0;
                netif_wake_queue(queue->bcm->net_dev);
        }
-        /* If there are packets on the txqueue, poke the tasklet. */
+        /* If there are packets on the txqueue, poke the tasklet
+         * to transmit them.
+         */
        if (!list_empty(&queue->txqueue))
                tasklet_schedule(&queue->txtask);
 }
@@ -519,12 +531,9 @@ void bcm43xx_pio_rx(struct bcm43xx_pioqueue *queue)
        int i, preamble_readwords;
        struct sk_buff *skb;
-return;
        tmp = bcm43xx_pio_read(queue, BCM43xx_PIO_RXCTL);
-        if (!(tmp & BCM43xx_PIO_RXCTL_DATAAVAILABLE)) {
+        if (!(tmp & BCM43xx_PIO_RXCTL_DATAAVAILABLE))
-                dprintkl(KERN_ERR PFX "PIO RX: No data available\n");//TODO: remove this printk.
                return;
-        }
        bcm43xx_pio_write(queue, BCM43xx_PIO_RXCTL,
                          BCM43xx_PIO_RXCTL_DATAAVAILABLE);
@@ -538,8 +547,7 @@ return;
        return;
 data_ready:
-//FIXME: endianess in this function.
+        len = bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA);
-        len = le16_to_cpu(bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA));
        if (unlikely(len > 0x700)) {
                pio_rx_error(queue, 0, "len > 0x700");
                return;
@@ -555,7 +563,7 @@ data_ready:
                preamble_readwords = 18 / sizeof(u16);
        for (i = 0; i < preamble_readwords; i++) {
                tmp = bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA);
-                preamble[i + 1] = cpu_to_be16(tmp);//FIXME?
+                preamble[i + 1] = cpu_to_le16(tmp);
        }
        rxhdr = (struct bcm43xx_rxhdr *)preamble;
        rxflags2 = le16_to_cpu(rxhdr->flags2);
@@ -591,16 +599,40 @@ data_ready:
        }
        skb_put(skb, len);
        for (i = 0; i < len - 1; i += 2) {
-                tmp = cpu_to_be16(bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA));
+                tmp = bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA);
-                *((u16 *)(skb->data + i)) = tmp;
+                *((u16 *)(skb->data + i)) = cpu_to_le16(tmp);
        }
        if (len % 2) {
                tmp = bcm43xx_pio_read(queue, BCM43xx_PIO_RXDATA);
                skb->data[len - 1] = (tmp & 0x00FF);
+/* The specs say the following is required, but
+ * it is wrong and corrupts the PLCP. If we don't do
+ * this, the PLCP seems to be correct. So ifdef it out for now.
+ */
+#if 0
                if (rxflags2 & BCM43xx_RXHDR_FLAGS2_TYPE2FRAME)
-                        skb->data[0x20] = (tmp & 0xFF00) >> 8;
+                        skb->data[2] = (tmp & 0xFF00) >> 8;
                else
-                        skb->data[0x1E] = (tmp & 0xFF00) >> 8;
+                        skb->data[0] = (tmp & 0xFF00) >> 8;
+#endif
        }
+        skb_trim(skb, len - IEEE80211_FCS_LEN);
        bcm43xx_rx(queue->bcm, skb, rxhdr);
 }
+void bcm43xx_pio_tx_suspend(struct bcm43xx_pioqueue *queue)
+{
+        bcm43xx_power_saving_ctl_bits(queue->bcm, -1, 1);
+        bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
+                          bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL)
+                          | BCM43xx_PIO_TXCTL_SUSPEND);
+}
+void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue)
+{
+        bcm43xx_pio_write(queue, BCM43xx_PIO_TXCTL,
+                          bcm43xx_pio_read(queue, BCM43xx_PIO_TXCTL)
+                          & ~BCM43xx_PIO_TXCTL_SUSPEND);
+        bcm43xx_power_saving_ctl_bits(queue->bcm, -1, -1);
+        tasklet_schedule(&queue->txtask);
+}
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_pio.h b/drivers/net/wireless/bcm43xx/bcm43xx_pio.h
index 970627bc1769..dfc78209e3a3 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_pio.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_pio.h
@@ -14,8 +14,8 @@
 #define BCM43xx_PIO_RXCTL               0x08
 #define BCM43xx_PIO_RXDATA              0x0A
-#define BCM43xx_PIO_TXCTL_WRITEHI       (1 << 0)
+#define BCM43xx_PIO_TXCTL_WRITELO       (1 << 0)
-#define BCM43xx_PIO_TXCTL_WRITELO       (1 << 1)
+#define BCM43xx_PIO_TXCTL_WRITEHI       (1 << 1)
 #define BCM43xx_PIO_TXCTL_COMPLETE      (1 << 2)
 #define BCM43xx_PIO_TXCTL_INIT          (1 << 3)
 #define BCM43xx_PIO_TXCTL_SUSPEND       (1 << 7)
@@ -95,6 +95,7 @@ void bcm43xx_pio_write(struct bcm43xx_pioqueue *queue,
                       u16 offset, u16 value)
 {
        bcm43xx_write16(queue->bcm, queue->mmio_base + offset, value);
+        mmiowb();
 }
@@ -107,6 +108,9 @@ void bcm43xx_pio_handle_xmitstatus(struct bcm43xx_private *bcm,
                                   struct bcm43xx_xmitstatus *status);
 void bcm43xx_pio_rx(struct bcm43xx_pioqueue *queue);
+void bcm43xx_pio_tx_suspend(struct bcm43xx_pioqueue *queue);
+void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue);
 #else /* CONFIG_BCM43XX_PIO */
 static inline
@@ -133,6 +137,14 @@ static inline
 void bcm43xx_pio_rx(struct bcm43xx_pioqueue *queue)
 {
 }
+static inline
+void bcm43xx_pio_tx_suspend(struct bcm43xx_pioqueue *queue)
+{
+}
+static inline
+void bcm43xx_pio_tx_resume(struct bcm43xx_pioqueue *queue)
+{
+}
 #endif /* CONFIG_BCM43XX_PIO */
 #endif /* BCM43xx_PIO_H_ */
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_power.c b/drivers/net/wireless/bcm43xx/bcm43xx_power.c
index 3c92b62807c5..6569da3a7a39 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_power.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_power.c
@@ -35,77 +35,101 @@
 #include "bcm43xx_main.h"
+/* Get the Slow Clock Source */
+static int bcm43xx_pctl_get_slowclksrc(struct bcm43xx_private *bcm)
+{
+        u32 tmp;
+        int err;
+        assert(bcm->current_core == &bcm->core_chipcommon);
+        if (bcm->current_core->rev < 6) {
+                if (bcm->bustype == BCM43xx_BUSTYPE_PCMCIA ||
+                    bcm->bustype == BCM43xx_BUSTYPE_SB)
+                        return BCM43xx_PCTL_CLKSRC_XTALOS;
+                if (bcm->bustype == BCM43xx_BUSTYPE_PCI) {
+                        err = bcm43xx_pci_read_config32(bcm, BCM43xx_PCTL_OUT, &tmp);
+                        assert(!err);
+                        if (tmp & 0x10)
+                                return BCM43xx_PCTL_CLKSRC_PCI;
+                        return BCM43xx_PCTL_CLKSRC_XTALOS;
+                }
+        }
+        if (bcm->current_core->rev < 10) {
+                tmp = bcm43xx_read32(bcm, BCM43xx_CHIPCOMMON_SLOWCLKCTL);
+                tmp &= 0x7;
+                if (tmp == 0)
+                        return BCM43xx_PCTL_CLKSRC_LOPWROS;
+                if (tmp == 1)
+                        return BCM43xx_PCTL_CLKSRC_XTALOS;
+                if (tmp == 2)
+                        return BCM43xx_PCTL_CLKSRC_PCI;
+        }
+        return BCM43xx_PCTL_CLKSRC_XTALOS;
+}
 /* Get max/min slowclock frequency
 * as described in http://bcm-specs.sipsolutions.net/PowerControl
 */
 static int bcm43xx_pctl_clockfreqlimit(struct bcm43xx_private *bcm,
                                       int get_max)
 {
-        int limit = 0;
+        int limit;
+        int clocksrc;
        int divisor;
-        int selection;
-        int err;
        u32 tmp;
-        struct bcm43xx_coreinfo *old_core;
-        if (!(bcm->chipcommon_capabilities & BCM43xx_CAPABILITIES_PCTL))
+        assert(bcm->chipcommon_capabilities & BCM43xx_CAPABILITIES_PCTL);
-                goto out;
+        assert(bcm->current_core == &bcm->core_chipcommon);
-        old_core = bcm->current_core;
-        err = bcm43xx_switch_core(bcm, &bcm->core_chipcommon);
-        if (err)
-                goto out;
+        clocksrc = bcm43xx_pctl_get_slowclksrc(bcm);
        if (bcm->current_core->rev < 6) {
-                if ((bcm->bustype == BCM43xx_BUSTYPE_PCMCIA) ||
+                switch (clocksrc) {
-                        (bcm->bustype == BCM43xx_BUSTYPE_SB)) {
+                case BCM43xx_PCTL_CLKSRC_PCI:
-                        selection = 1;
+                        divisor = 64;
+                        break;
+                case BCM43xx_PCTL_CLKSRC_XTALOS:
                        divisor = 32;
-                } else {
+                        break;
-                        err = bcm43xx_pci_read_config32(bcm, BCM43xx_PCTL_OUT, &tmp);
+                default:
-                        if (err) {
+                        assert(0);
-                                printk(KERN_ERR PFX "clockfreqlimit pcicfg read failure\n");
+                        divisor = 1;
-                                goto out_switchback;
-                        }
-                        if (tmp & 0x10) {
-                                /* PCI */
-                                selection = 2;
-                                divisor = 64;
-                        } else {
-                                /* XTAL */
-                                selection = 1;
-                                divisor = 32;
-                        }
                }
        } else if (bcm->current_core->rev < 10) {
-                selection = (tmp & 0x07);
+                switch (clocksrc) {
-                if (selection) {
+                case BCM43xx_PCTL_CLKSRC_LOPWROS:
+                        divisor = 1;
+                        break;
+                case BCM43xx_PCTL_CLKSRC_XTALOS:
+                case BCM43xx_PCTL_CLKSRC_PCI:
                        tmp = bcm43xx_read32(bcm, BCM43xx_CHIPCOMMON_SLOWCLKCTL);
-                        divisor = 4 * (1 + ((tmp & 0xFFFF0000) >> 16));
+                        divisor = ((tmp & 0xFFFF0000) >> 16) + 1;
-                } else
+                        divisor *= 4;
+                        break;
+                default:
+                        assert(0);
                        divisor = 1;
+                }
        } else {
                tmp = bcm43xx_read32(bcm, BCM43xx_CHIPCOMMON_SYSCLKCTL);
-                divisor = 4 * (1 + ((tmp & 0xFFFF0000) >> 16));
+                divisor = ((tmp & 0xFFFF0000) >> 16) + 1;
-                selection = 1;
+                divisor *= 4;
        }
-        
-        switch (selection) {
+        switch (clocksrc) {
-        case 0:
+        case BCM43xx_PCTL_CLKSRC_LOPWROS:
-                /* LPO */
                if (get_max)
                        limit = 43000;
                else
                        limit = 25000;
                break;
-        case 1:
+        case BCM43xx_PCTL_CLKSRC_XTALOS:
-                /* XTAL */
                if (get_max)
                        limit = 20200000;
                else
                        limit = 19800000;
                break;
-        case 2:
+        case BCM43xx_PCTL_CLKSRC_PCI:
-                /* PCI */
                if (get_max)
                        limit = 34000000;
                else
@@ -113,17 +137,14 @@ static int bcm43xx_pctl_clockfreqlimit(struct bcm43xx_private *bcm,
                break;
        default:
                assert(0);
+                limit = 0;
        }
        limit /= divisor;
-out_switchback:
-        err = bcm43xx_switch_core(bcm, old_core);
-        assert(err == 0);
-out:
        return limit;
 }
 /* init power control
 * as described in http://bcm-specs.sipsolutions.net/PowerControl
 */
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_power.h b/drivers/net/wireless/bcm43xx/bcm43xx_power.h
index 5f63640810bd..c966ab3a5a8c 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_power.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_power.h
@@ -33,6 +33,15 @@
 #include <linux/types.h>
+/* Clock sources */
+enum {
+        /* PCI clock */
+        BCM43xx_PCTL_CLKSRC_PCI,
+        /* Crystal slow clock oscillator */
+        BCM43xx_PCTL_CLKSRC_XTALOS,
+        /* Low power oscillator */
+        BCM43xx_PCTL_CLKSRC_LOPWROS,
+};
 struct bcm43xx_private;
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c
index c44d890b949b..b438f48e891d 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.c
@@ -71,14 +71,46 @@ static int get_boolean(const char *buf, size_t count)
        return -EINVAL;
 }
+static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len)
+{
+        int i, pos = 0;
+        for (i = 0; i < BCM43xx_SPROM_SIZE; i++) {
+                pos += snprintf(buf + pos, buf_len - pos - 1,
+                                "%04X", swab16(sprom[i]) & 0xFFFF);
+        }
+        pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
+        return pos + 1;
+}
+static int hex2sprom(u16 *sprom, const char *dump, size_t len)
+{
+        char tmp[5] = { 0 };
+        int cnt = 0;
+        unsigned long parsed;
+        if (len < BCM43xx_SPROM_SIZE * sizeof(u16) * 2)
+                return -EINVAL;
+        while (cnt < BCM43xx_SPROM_SIZE) {
+                memcpy(tmp, dump, 4);
+                dump += 4;
+                parsed = simple_strtoul(tmp, NULL, 16);
+                sprom[cnt++] = swab16((u16)parsed);
+        }
+        return 0;
+}
 static ssize_t bcm43xx_attr_sprom_show(struct device *dev,
                                       struct device_attribute *attr,
                                       char *buf)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_sprom);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        u16 *sprom;
        unsigned long flags;
-        int i, err;
+        int err;
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
@@ -91,55 +123,53 @@ static ssize_t bcm43xx_attr_sprom_show(struct device *dev,
        bcm43xx_lock_mmio(bcm, flags);
        assert(bcm->initialized);
        err = bcm43xx_sprom_read(bcm, sprom);
-        if (!err) {
+        if (!err)
-                for (i = 0; i < BCM43xx_SPROM_SIZE; i++) {
+                err = sprom2hex(sprom, buf, PAGE_SIZE);
-                        buf[i * 2] = sprom[i] & 0x00FF;
-                        buf[i * 2 + 1] = (sprom[i] & 0xFF00) >> 8;
-                }
-        }
        bcm43xx_unlock_mmio(bcm, flags);
        kfree(sprom);
-        return err ? err : BCM43xx_SPROM_SIZE * sizeof(u16);
+        return err;
 }
 static ssize_t bcm43xx_attr_sprom_store(struct device *dev,
                                        struct device_attribute *attr,
                                        const char *buf, size_t count)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_sprom);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        u16 *sprom;
        unsigned long flags;
-        int i, err;
+        int err;
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
-        if (count != BCM43xx_SPROM_SIZE * sizeof(u16))
-                return -EINVAL;
        sprom = kmalloc(BCM43xx_SPROM_SIZE * sizeof(*sprom),
                        GFP_KERNEL);
        if (!sprom)
                return -ENOMEM;
-        for (i = 0; i < BCM43xx_SPROM_SIZE; i++) {
+        err = hex2sprom(sprom, buf, count);
-                sprom[i] = buf[i * 2] & 0xFF;
+        if (err)
-                sprom[i] |= ((u16)(buf[i * 2 + 1] & 0xFF)) << 8;
+                goto out_kfree;
-        }
        bcm43xx_lock_mmio(bcm, flags);
        assert(bcm->initialized);
        err = bcm43xx_sprom_write(bcm, sprom);
        bcm43xx_unlock_mmio(bcm, flags);
+out_kfree:
        kfree(sprom);
        return err ? err : count;
 }
+static DEVICE_ATTR(sprom, 0600,
+                   bcm43xx_attr_sprom_show,
+                   bcm43xx_attr_sprom_store);
 static ssize_t bcm43xx_attr_interfmode_show(struct device *dev,
                                            struct device_attribute *attr,
                                            char *buf)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_interfmode);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        unsigned long flags;
        int err;
        ssize_t count = 0;
@@ -175,7 +205,7 @@ static ssize_t bcm43xx_attr_interfmode_store(struct device *dev,
                                             struct device_attribute *attr,
                                             const char *buf, size_t count)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_interfmode);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        unsigned long flags;
        int err;
        int mode;
@@ -215,11 +245,15 @@ static ssize_t bcm43xx_attr_interfmode_store(struct device *dev,
        return err ? err : count;
 }
+static DEVICE_ATTR(interference, 0644,
+                   bcm43xx_attr_interfmode_show,
+                   bcm43xx_attr_interfmode_store);
 static ssize_t bcm43xx_attr_preamble_show(struct device *dev,
                                          struct device_attribute *attr,
                                          char *buf)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_preamble);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        unsigned long flags;
        int err;
        ssize_t count;
@@ -245,7 +279,7 @@ static ssize_t bcm43xx_attr_preamble_store(struct device *dev,
                                           struct device_attribute *attr,
                                           const char *buf, size_t count)
 {
-        struct bcm43xx_private *bcm = devattr_to_bcm(attr, attr_preamble);
+        struct bcm43xx_private *bcm = dev_to_bcm(dev);
        unsigned long flags;
        int err;
        int value;
@@ -267,56 +301,41 @@ static ssize_t bcm43xx_attr_preamble_store(struct device *dev,
        return err ? err : count;
 }
+static DEVICE_ATTR(shortpreamble, 0644,
+                   bcm43xx_attr_preamble_show,
+                   bcm43xx_attr_preamble_store);
 int bcm43xx_sysfs_register(struct bcm43xx_private *bcm)
 {
        struct device *dev = &bcm->pci_dev->dev;
-        struct bcm43xx_sysfs *sysfs = &bcm->sysfs;
        int err;
        assert(bcm->initialized);
-        sysfs->attr_sprom.attr.name = "sprom";
+        err = device_create_file(dev, &dev_attr_sprom);
-        sysfs->attr_sprom.attr.owner = THIS_MODULE;
-        sysfs->attr_sprom.attr.mode = 0600;
-        sysfs->attr_sprom.show = bcm43xx_attr_sprom_show;
-        sysfs->attr_sprom.store = bcm43xx_attr_sprom_store;
-        err = device_create_file(dev, &sysfs->attr_sprom);
        if (err)
                goto out;
+        err = device_create_file(dev, &dev_attr_interference);
-        sysfs->attr_interfmode.attr.name = "interference";
-        sysfs->attr_interfmode.attr.owner = THIS_MODULE;
-        sysfs->attr_interfmode.attr.mode = 0600;
-        sysfs->attr_interfmode.show = bcm43xx_attr_interfmode_show;
-        sysfs->attr_interfmode.store = bcm43xx_attr_interfmode_store;
-        err = device_create_file(dev, &sysfs->attr_interfmode);
        if (err)
                goto err_remove_sprom;
+        err = device_create_file(dev, &dev_attr_shortpreamble);
-        sysfs->attr_preamble.attr.name = "shortpreamble";
-        sysfs->attr_preamble.attr.owner = THIS_MODULE;
-        sysfs->attr_preamble.attr.mode = 0600;
-        sysfs->attr_preamble.show = bcm43xx_attr_preamble_show;
-        sysfs->attr_preamble.store = bcm43xx_attr_preamble_store;
-        err = device_create_file(dev, &sysfs->attr_preamble);
        if (err)
                goto err_remove_interfmode;
 out:
        return err;
 err_remove_interfmode:
-        device_remove_file(dev, &sysfs->attr_interfmode);
+        device_remove_file(dev, &dev_attr_interference);
 err_remove_sprom:
-        device_remove_file(dev, &sysfs->attr_sprom);
+        device_remove_file(dev, &dev_attr_sprom);
        goto out;
 }
 void bcm43xx_sysfs_unregister(struct bcm43xx_private *bcm)
 {
        struct device *dev = &bcm->pci_dev->dev;
-        struct bcm43xx_sysfs *sysfs = &bcm->sysfs;
-        device_remove_file(dev, &sysfs->attr_preamble);
+        device_remove_file(dev, &dev_attr_shortpreamble);
-        device_remove_file(dev, &sysfs->attr_interfmode);
+        device_remove_file(dev, &dev_attr_interference);
-        device_remove_file(dev, &sysfs->attr_sprom);
+        device_remove_file(dev, &dev_attr_sprom);
 }
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.h b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.h
index 57f14514e3e0..cc701df71e2a 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_sysfs.h
@@ -1,22 +1,6 @@
 #ifndef BCM43xx_SYSFS_H_
 #define BCM43xx_SYSFS_H_
-#include <linux/device.h>
-struct bcm43xx_sysfs {
-        struct device_attribute attr_sprom;
-        struct device_attribute attr_interfmode;
-        struct device_attribute attr_preamble;
-};
-#define devattr_to_bcm(attr, attr_name) ({                              \
-        struct bcm43xx_sysfs *__s; struct bcm43xx_private *__p;         \
-        __s = container_of((attr), struct bcm43xx_sysfs, attr_name);    \
-        __p = container_of(__s, struct bcm43xx_private, sysfs);         \
-        __p;                                                            \
-                                        })
 struct bcm43xx_private;
 int bcm43xx_sysfs_register(struct bcm43xx_private *bcm);
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_wx.c b/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
index 3daee828ef4b..b45063974ae9 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
@@ -182,8 +182,11 @@ static int bcm43xx_wx_set_mode(struct net_device *net_dev,
                mode = BCM43xx_INITIAL_IWMODE;
        bcm43xx_lock_mmio(bcm, flags);
-        if (bcm->ieee->iw_mode != mode)
+        if (bcm->initialized) {
-                bcm43xx_set_iwmode(bcm, mode);
+                if (bcm->ieee->iw_mode != mode)
+                        bcm43xx_set_iwmode(bcm, mode);
+        } else
+                bcm->ieee->iw_mode = mode;
        bcm43xx_unlock_mmio(bcm, flags);
        return 0;
@@ -962,22 +965,22 @@ static const struct iw_priv_args bcm43xx_priv_wx_args[] = {
        {
                .cmd            = PRIV_WX_SET_SHORTPREAMBLE,
                .set_args       = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
-                .name           = "set_shortpreambl",
+                .name           = "set_shortpreamb",
        },
        {
                .cmd            = PRIV_WX_GET_SHORTPREAMBLE,
                .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
-                .name           = "get_shortpreambl",
+                .name           = "get_shortpreamb",
        },
        {
                .cmd            = PRIV_WX_SET_SWENCRYPTION,
                .set_args       = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
-                .name           = "set_swencryption",
+                .name           = "set_swencrypt",
        },
        {
                .cmd            = PRIV_WX_GET_SWENCRYPTION,
                .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
-                .name           = "get_swencryption",
+                .name           = "get_swencrypt",
        },
        {
                .cmd            = PRIV_WX_SPROM_WRITE,
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index 8b37e824dfcb..8399de581893 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -1860,7 +1860,7 @@ static char * __prism2_translate_scan(local_info_t *local,
        memset(&iwe, 0, sizeof(iwe));
        iwe.cmd = SIOCGIWFREQ;
        if (scan) {
-                chan = scan->chid;
+                chan = le16_to_cpu(scan->chid);
        } else if (bss) {
                chan = bss->chan;
        } else {
@@ -1868,7 +1868,7 @@ 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.m = freq_list[chan - 1] * 100000;
                iwe.u.freq.e = 1;
                current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
                                                  IW_EV_FREQ_LEN);
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index 8dfdfbd5966c..c2d0b09e0418 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -390,7 +390,7 @@ static struct iw_statistics *orinoco_get_wireless_stats(struct net_device *dev)
                }
        } else {
                struct {
-                        __le16 qual, signal, noise;
+                        __le16 qual, signal, noise, unused;
                } __attribute__ ((packed)) cq;
                err = HERMES_READ_RECORD(hw, USER_BAP,
@@ -812,7 +812,6 @@ static void orinoco_rx_monitor(struct net_device *dev, u16 rxfid,
        if (datalen > IEEE80211_DATA_LEN + 12) {
                printk(KERN_DEBUG "%s: oversized monitor frame, "
                       "data length = %d\n", dev->name, datalen);
-                err = -EIO;
                stats->rx_length_errors++;
                goto update_stats;
        }
@@ -821,8 +820,7 @@ static void orinoco_rx_monitor(struct net_device *dev, u16 rxfid,
        if (!skb) {
                printk(KERN_WARNING "%s: Cannot allocate skb for monitor frame\n",
                       dev->name);
-                err = -ENOMEM;
+                goto update_stats;
-                goto drop;
        }
        /* Copy the 802.11 header to the skb */
diff --git a/drivers/net/wireless/wavelan.c b/drivers/net/wireless/wavelan.c
index ff192e96268a..dade4b903579 100644
--- a/drivers/net/wireless/wavelan.c
+++ b/drivers/net/wireless/wavelan.c
@@ -4306,7 +4306,7 @@ out:
 * Insertion of the module
 * I'm now quite proud of the multi-device support.
 */
-int init_module(void)
+int __init init_module(void)
 {
        int ret = -EIO;         /* Return error if no cards found */
        int i;