Merge branch 'linux-2.6'

30 files changed, 211 insertions, 132 deletions

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 6cde4edc846b..d9107e542dfa 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2588,7 +2588,6 @@ config MLX4_DEBUG
 config TEHUTI
         tristate "Tehuti Networks 10G Ethernet"
         depends on PCI
-        select ZLIB_INFLATE
         help
           Tehuti Networks 10G Ethernet NIC
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index da767d3d5af5..4e7b46e44874 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -56,8 +56,8 @@
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.6.8"
-#define DRV_MODULE_RELDATE      "October 17, 2007"
+#define DRV_MODULE_VERSION      "1.6.9"
+#define DRV_MODULE_RELDATE      "December 8, 2007"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -2387,18 +2387,24 @@ bnx2_reuse_rx_skb(struct bnx2 *bp, struct sk_buff *skb,
         prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
 }
 
+static inline u16
+bnx2_get_hw_rx_cons(struct bnx2 *bp)
+{
+        u16 cons = bp->status_blk->status_rx_quick_consumer_index0;
+
+        if (unlikely((cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT))
+                cons++;
+        return cons;
+}
+
 static int
 bnx2_rx_int(struct bnx2 *bp, int budget)
 {
-        struct status_block *sblk = bp->status_blk;
         u16 hw_cons, sw_cons, sw_ring_cons, sw_prod, sw_ring_prod;
         struct l2_fhdr *rx_hdr;
         int rx_pkt = 0;
 
-        hw_cons = bp->hw_rx_cons = sblk->status_rx_quick_consumer_index0;
-        if ((hw_cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT) {
-                hw_cons++;
-        }
+        hw_cons = bnx2_get_hw_rx_cons(bp);
         sw_cons = bp->rx_cons;
         sw_prod = bp->rx_prod;
 
@@ -2515,10 +2521,7 @@ next_rx:
 
                 /* Refresh hw_cons to see if there is new work */
                 if (sw_cons == hw_cons) {
-                        hw_cons = bp->hw_rx_cons =
-                                sblk->status_rx_quick_consumer_index0;
-                        if ((hw_cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT)
-                                hw_cons++;
+                        hw_cons = bnx2_get_hw_rx_cons(bp);
                         rmb();
                 }
         }
@@ -2622,7 +2625,7 @@ bnx2_has_work(struct bnx2 *bp)
 {
         struct status_block *sblk = bp->status_blk;
 
-        if ((sblk->status_rx_quick_consumer_index0 != bp->hw_rx_cons) ||
+        if ((bnx2_get_hw_rx_cons(bp) != bp->rx_cons) ||
             (sblk->status_tx_quick_consumer_index0 != bp->hw_tx_cons))
                 return 1;
 
@@ -2655,7 +2658,7 @@ static int bnx2_poll_work(struct bnx2 *bp, int work_done, int budget)
         if (sblk->status_tx_quick_consumer_index0 != bp->hw_tx_cons)
                 bnx2_tx_int(bp);
 
-        if (sblk->status_rx_quick_consumer_index0 != bp->hw_rx_cons)
+        if (bnx2_get_hw_rx_cons(bp) != bp->rx_cons)
                 work_done += bnx2_rx_int(bp, budget - work_done);
 
         return work_done;
@@ -4177,7 +4180,6 @@ bnx2_init_rx_ring(struct bnx2 *bp)
 
         ring_prod = prod = bp->rx_prod = 0;
         bp->rx_cons = 0;
-        bp->hw_rx_cons = 0;
         bp->rx_prod_bseq = 0;
 
         for (i = 0; i < bp->rx_max_ring; i++) {
@@ -6685,8 +6687,9 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         } else if (CHIP_NUM(bp) == CHIP_NUM_5706 ||
                    CHIP_NUM(bp) == CHIP_NUM_5708)
                 bp->phy_flags |= PHY_CRC_FIX_FLAG;
-        else if (CHIP_ID(bp) == CHIP_ID_5709_A0 ||
-                 CHIP_ID(bp) == CHIP_ID_5709_A1)
+        else if (CHIP_NUM(bp) == CHIP_NUM_5709 &&
+                 (CHIP_REV(bp) == CHIP_REV_Ax ||
+                  CHIP_REV(bp) == CHIP_REV_Bx))
                 bp->phy_flags |= PHY_DIS_EARLY_DAC_FLAG;
 
         if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index 1dce0d1a2581..30ba366608b0 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -6513,7 +6513,6 @@ struct bnx2 {
         u32                     rx_prod_bseq;
         u16                     rx_prod;
         u16                     rx_cons;
-        u16                     hw_rx_cons;
 
         u32                     rx_csum;
 
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index e1c8a0d023ea..2b06e4b4dabc 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2737,8 +2737,9 @@ static int e100_suspend(struct pci_dev *pdev, pm_message_t state)
                 pci_enable_wake(pdev, PCI_D3cold, 0);
         }
 
-        pci_disable_device(pdev);
         free_irq(pdev->irq, netdev);
+
+        pci_disable_device(pdev);
         pci_set_power_state(pdev, PCI_D3hot);
 
         return 0;
@@ -2780,6 +2781,8 @@ static void e100_shutdown(struct pci_dev *pdev)
                 pci_enable_wake(pdev, PCI_D3cold, 0);
         }
 
+        free_irq(pdev->irq, netdev);
+
         pci_disable_device(pdev);
         pci_set_power_state(pdev, PCI_D3hot);
 }
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index 5ff856d7590b..fe3d8a621c33 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -149,7 +149,7 @@ static int setup_data(struct net_device *dev)
 {
         struct fs_enet_private *fep = netdev_priv(dev);
 
-#ifdef CONFIG_PPC_CPM_NEW_BINDING
+#ifndef CONFIG_PPC_CPM_NEW_BINDING
         struct fs_platform_info *fpi = fep->fpi;
 
         fep->scc.idx = fs_get_scc_index(fpi->fs_no);
diff --git a/drivers/net/hamachi.c b/drivers/net/hamachi.c
index ed407c85708f..b53f6b6491b3 100644
--- a/drivers/net/hamachi.c
+++ b/drivers/net/hamachi.c
@@ -204,8 +204,10 @@ KERN_INFO "   Further modifications by Keith Underwood <keithu@parl.clemson.edu>
 /* Condensed bus+endian portability operations. */
 #if ADDRLEN == 64
 #define cpu_to_leXX(addr)       cpu_to_le64(addr)
+#define leXX_to_cpu(addr)       le64_to_cpu(addr)
 #else
 #define cpu_to_leXX(addr)       cpu_to_le32(addr)
+#define leXX_to_cpu(addr)       le32_to_cpu(addr)
 #endif
 
 
@@ -465,12 +467,12 @@ enum intr_status_bits {
 
 /* The Hamachi Rx and Tx buffer descriptors. */
 struct hamachi_desc {
-        u32 status_n_length;
+        __le32 status_n_length;
 #if ADDRLEN == 64
         u32 pad;
-        u64 addr;
+        __le64 addr;
 #else
-        u32 addr;
+        __le32 addr;
 #endif
 };
 
@@ -874,13 +876,13 @@ static int hamachi_open(struct net_device *dev)
 
 #if ADDRLEN == 64
         /* writellll anyone ? */
-        writel(cpu_to_le64(hmp->rx_ring_dma), ioaddr + RxPtr);
-        writel(cpu_to_le64(hmp->rx_ring_dma) >> 32, ioaddr + RxPtr + 4);
-        writel(cpu_to_le64(hmp->tx_ring_dma), ioaddr + TxPtr);
-        writel(cpu_to_le64(hmp->tx_ring_dma) >> 32, ioaddr + TxPtr + 4);
+        writel(hmp->rx_ring_dma, ioaddr + RxPtr);
+        writel(hmp->rx_ring_dma >> 32, ioaddr + RxPtr + 4);
+        writel(hmp->tx_ring_dma, ioaddr + TxPtr);
+        writel(hmp->tx_ring_dma >> 32, ioaddr + TxPtr + 4);
 #else
-        writel(cpu_to_le32(hmp->rx_ring_dma), ioaddr + RxPtr);
-        writel(cpu_to_le32(hmp->tx_ring_dma), ioaddr + TxPtr);
+        writel(hmp->rx_ring_dma, ioaddr + RxPtr);
+        writel(hmp->tx_ring_dma, ioaddr + TxPtr);
 #endif
 
         /* TODO:  It would make sense to organize this as words since the card
@@ -1019,8 +1021,8 @@ static inline int hamachi_tx(struct net_device *dev)
                 skb = hmp->tx_skbuff[entry];
                 if (skb) {
                         pci_unmap_single(hmp->pci_dev,
-                                hmp->tx_ring[entry].addr, skb->len,
-                                PCI_DMA_TODEVICE);
+                                leXX_to_cpu(hmp->tx_ring[entry].addr),
+                                skb->len, PCI_DMA_TODEVICE);
                         dev_kfree_skb(skb);
                         hmp->tx_skbuff[entry] = NULL;
                 }
@@ -1071,10 +1073,10 @@ static void hamachi_tx_timeout(struct net_device *dev)
         {
                 printk(KERN_DEBUG "  Rx ring %p: ", hmp->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
-                        printk(" %8.8x", (unsigned int)hmp->rx_ring[i].status_n_length);
+                        printk(" %8.8x", le32_to_cpu(hmp->rx_ring[i].status_n_length));
                 printk("\n"KERN_DEBUG"  Tx ring %p: ", hmp->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %4.4x", hmp->tx_ring[i].status_n_length);
+                        printk(" %4.4x", le32_to_cpu(hmp->tx_ring[i].status_n_length));
                 printk("\n");
         }
 
@@ -1099,14 +1101,15 @@ static void hamachi_tx_timeout(struct net_device *dev)
                 struct sk_buff *skb;
 
                 if (i >= TX_RING_SIZE - 1)
-                        hmp->tx_ring[i].status_n_length = cpu_to_le32(
-                                DescEndRing |
-                                (hmp->tx_ring[i].status_n_length & 0x0000FFFF));
+                        hmp->tx_ring[i].status_n_length =
+                                cpu_to_le32(DescEndRing) |
+                                (hmp->tx_ring[i].status_n_length &
+                                 cpu_to_le32(0x0000ffff));
                 else
-                        hmp->tx_ring[i].status_n_length &= 0x0000ffff;
+                        hmp->tx_ring[i].status_n_length &= cpu_to_le32(0x0000ffff);
                 skb = hmp->tx_skbuff[i];
                 if (skb){
-                        pci_unmap_single(hmp->pci_dev, hmp->tx_ring[i].addr,
+                        pci_unmap_single(hmp->pci_dev, leXX_to_cpu(hmp->tx_ring[i].addr),
                                 skb->len, PCI_DMA_TODEVICE);
                         dev_kfree_skb(skb);
                         hmp->tx_skbuff[i] = NULL;
@@ -1128,7 +1131,8 @@ static void hamachi_tx_timeout(struct net_device *dev)
                 struct sk_buff *skb = hmp->rx_skbuff[i];
 
                 if (skb){
-                        pci_unmap_single(hmp->pci_dev, hmp->rx_ring[i].addr,
+                        pci_unmap_single(hmp->pci_dev,
+                                leXX_to_cpu(hmp->rx_ring[i].addr),
                                 hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(skb);
                         hmp->rx_skbuff[i] = NULL;
@@ -1420,7 +1424,7 @@ static irqreturn_t hamachi_interrupt(int irq, void *dev_instance)
                                         /* Free the original skb. */
                                         if (skb){
                                                 pci_unmap_single(hmp->pci_dev,
-                                                        hmp->tx_ring[entry].addr,
+                                                        leXX_to_cpu(hmp->tx_ring[entry].addr),
                                                         skb->len,
                                                         PCI_DMA_TODEVICE);
                                                 dev_kfree_skb_irq(skb);
@@ -1500,11 +1504,11 @@ static int hamachi_rx(struct net_device *dev)
                 if (desc_status & DescOwn)
                         break;
                 pci_dma_sync_single_for_cpu(hmp->pci_dev,
-                                            desc->addr,
+                                            leXX_to_cpu(desc->addr),
                                             hmp->rx_buf_sz,
                                             PCI_DMA_FROMDEVICE);
                 buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
-                frame_status = le32_to_cpu(get_unaligned((s32*)&(buf_addr[data_size - 12])));
+                frame_status = le32_to_cpu(get_unaligned((__le32*)&(buf_addr[data_size - 12])));
                 if (hamachi_debug > 4)
                         printk(KERN_DEBUG "  hamachi_rx() status was %8.8x.\n",
                                 frame_status);
@@ -1518,9 +1522,9 @@ static int hamachi_rx(struct net_device *dev)
                                    dev->name, desc, &hmp->rx_ring[hmp->cur_rx % RX_RING_SIZE]);
                         printk(KERN_WARNING "%s: Oversized Ethernet frame -- next status %x/%x last status %x.\n",
                                    dev->name,
-                                   hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length & 0xffff0000,
-                                   hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length & 0x0000ffff,
-                                   hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length);
+                                   le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0xffff0000,
+                                   le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0x0000ffff,
+                                   le32_to_cpu(hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length));
                         hmp->stats.rx_length_errors++;
                 } /* else  Omit for prototype errata??? */
                 if (frame_status & 0x00380000) {
@@ -1566,7 +1570,7 @@ static int hamachi_rx(struct net_device *dev)
 #endif
                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
                                 pci_dma_sync_single_for_cpu(hmp->pci_dev,
-                                                            hmp->rx_ring[entry].addr,
+                                                            leXX_to_cpu(hmp->rx_ring[entry].addr),
                                                             hmp->rx_buf_sz,
                                                             PCI_DMA_FROMDEVICE);
                                 /* Call copy + cksum if available. */
@@ -1579,12 +1583,12 @@ static int hamachi_rx(struct net_device *dev)
                                         + entry*sizeof(*desc), pkt_len);
 #endif
                                 pci_dma_sync_single_for_device(hmp->pci_dev,
-                                                               hmp->rx_ring[entry].addr,
+                                                               leXX_to_cpu(hmp->rx_ring[entry].addr),
                                                                hmp->rx_buf_sz,
                                                                PCI_DMA_FROMDEVICE);
                         } else {
                                 pci_unmap_single(hmp->pci_dev,
-                                                 hmp->rx_ring[entry].addr,
+                                                 leXX_to_cpu(hmp->rx_ring[entry].addr),
                                                  hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                                 skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
                                 hmp->rx_skbuff[entry] = NULL;
@@ -1787,21 +1791,21 @@ static int hamachi_close(struct net_device *dev)
         for (i = 0; i < RX_RING_SIZE; i++) {
                 skb = hmp->rx_skbuff[i];
                 hmp->rx_ring[i].status_n_length = 0;
-                hmp->rx_ring[i].addr = 0xBADF00D0; /* An invalid address. */
                 if (skb) {
                         pci_unmap_single(hmp->pci_dev,
-                                hmp->rx_ring[i].addr, hmp->rx_buf_sz,
-                                PCI_DMA_FROMDEVICE);
+                                leXX_to_cpu(hmp->rx_ring[i].addr),
+                                hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(skb);
                         hmp->rx_skbuff[i] = NULL;
                 }
+                hmp->rx_ring[i].addr = cpu_to_leXX(0xBADF00D0); /* An invalid address. */
         }
         for (i = 0; i < TX_RING_SIZE; i++) {
                 skb = hmp->tx_skbuff[i];
                 if (skb) {
                         pci_unmap_single(hmp->pci_dev,
-                                hmp->tx_ring[i].addr, skb->len,
-                                PCI_DMA_TODEVICE);
+                                leXX_to_cpu(hmp->tx_ring[i].addr),
+                                skb->len, PCI_DMA_TODEVICE);
                         dev_kfree_skb(skb);
                         hmp->tx_skbuff[i] = NULL;
                 }
diff --git a/drivers/net/ibm_newemac/debug.c b/drivers/net/ibm_newemac/debug.c
index a2fc660ca5d4..86b756a30784 100644
--- a/drivers/net/ibm_newemac/debug.c
+++ b/drivers/net/ibm_newemac/debug.c
@@ -26,7 +26,7 @@
 
 #include "core.h"
 
-static spinlock_t emac_dbg_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(emac_dbg_lock);
 
 static void emac_desc_dump(struct emac_instance *p)
 {
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index c6355c00fd7a..9081234ab458 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1168,6 +1168,7 @@ static int stir421x_patch_device(struct irda_usb_cb *self)
 static int irda_usb_net_open(struct net_device *netdev)
 {
         struct irda_usb_cb *self;
+        unsigned long flags;
         char    hwname[16];
         int i;
         
@@ -1177,13 +1178,16 @@ static int irda_usb_net_open(struct net_device *netdev)
         self = (struct irda_usb_cb *) netdev->priv;
         IRDA_ASSERT(self != NULL, return -1;);
 
+        spin_lock_irqsave(&self->lock, flags);
         /* Can only open the device if it's there */
         if(!self->present) {
+                spin_unlock_irqrestore(&self->lock, flags);
                 IRDA_WARNING("%s(), device not present!\n", __FUNCTION__);
                 return -1;
         }
 
         if(self->needspatch) {
+                spin_unlock_irqrestore(&self->lock, flags);
                 IRDA_WARNING("%s(), device needs patch\n", __FUNCTION__) ;
                 return -EIO ;
         }
@@ -1198,6 +1202,7 @@ static int irda_usb_net_open(struct net_device *netdev)
         /* To do *before* submitting Rx urbs and starting net Tx queue
          * Jean II */
         self->netopen = 1;
+        spin_unlock_irqrestore(&self->lock, flags);
 
         /* 
          * Now that everything should be initialized properly,
diff --git a/drivers/net/irda/mcs7780.c b/drivers/net/irda/mcs7780.c
index 0b769192d4ce..93916cf33f29 100644
--- a/drivers/net/irda/mcs7780.c
+++ b/drivers/net/irda/mcs7780.c
@@ -677,6 +677,8 @@ static int mcs_net_close(struct net_device *netdev)
         /* Stop transmit processing */
         netif_stop_queue(netdev);
 
+        kfree_skb(mcs->rx_buff.skb);
+
         /* kill and free the receive and transmit URBs */
         usb_kill_urb(mcs->rx_urb);
         usb_free_urb(mcs->rx_urb);
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c
index 042bc2f0417d..e59c485bc497 100644
--- a/drivers/net/irda/stir4200.c
+++ b/drivers/net/irda/stir4200.c
@@ -142,9 +142,6 @@ enum StirCtrl2Mask {
 };
 
 enum StirFifoCtlMask {
-        FIFOCTL_EOF = 0x80,
-        FIFOCTL_UNDER = 0x40,
-        FIFOCTL_OVER = 0x20,
         FIFOCTL_DIR = 0x10,
         FIFOCTL_CLR = 0x08,
         FIFOCTL_EMPTY = 0x04,
@@ -594,9 +591,10 @@ static int fifo_txwait(struct stir_cb *stir, int space)
 {
         int err;
         unsigned long count, status;
+        unsigned long prev_count = 0x1fff;
 
         /* Read FIFO status and count */
-        for(;;) {
+        for (;; prev_count = count) {
                 err = read_reg(stir, REG_FIFOCTL, stir->fifo_status, 
                                    FIFO_REGS_SIZE);
                 if (unlikely(err != FIFO_REGS_SIZE)) {
@@ -629,6 +627,10 @@ static int fifo_txwait(struct stir_cb *stir, int space)
                 if (space >= 0 && STIR_FIFO_SIZE - 4 > space + count)
                         return 0;
 
+                /* queue confused */
+                if (prev_count < count)
+                        break;
+
                 /* estimate transfer time for remaining chars */
                 msleep((count * 8000) / stir->speed);
         }
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index 3021234b1e17..bf9085fe035a 100644
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -320,10 +320,22 @@ ixgb_down(struct ixgb_adapter *adapter, boolean_t kill_watchdog)
 void
 ixgb_reset(struct ixgb_adapter *adapter)
 {
+        struct ixgb_hw *hw = &adapter->hw;
 
-        ixgb_adapter_stop(&adapter->hw);
-        if(!ixgb_init_hw(&adapter->hw))
+        ixgb_adapter_stop(hw);
+        if (!ixgb_init_hw(hw))
                 DPRINTK(PROBE, ERR, "ixgb_init_hw failed.\n");
+
+        /* restore frame size information */
+        IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);
+        if (hw->max_frame_size >
+            IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
+                u32 ctrl0 = IXGB_READ_REG(hw, CTRL0);
+                if (!(ctrl0 & IXGB_CTRL0_JFE)) {
+                        ctrl0 |= IXGB_CTRL0_JFE;
+                        IXGB_WRITE_REG(hw, CTRL0, ctrl0);
+                }
+        }
 }
 
 /**
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index db6a97d1d7b1..51bbd582f16c 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1746,6 +1746,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "NE2K.cis"),
         PCMCIA_DEVICE_CIS_PROD_ID12("PMX   ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "PE-200.cis"),
         PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "tamarack.cis"),
+        PCMCIA_DEVICE_PROD_ID12("Ethernet", "CF Size PC Card", 0x00b2e941, 0x43ac239b),
         PCMCIA_DEVICE_PROD_ID123("Fast Ethernet", "CF Size PC Card", "1.0",
                 0xb4be14e3, 0x43ac239b, 0x0877b627),
         PCMCIA_DEVICE_NULL
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 121cb100f93a..9d80f1cf73ac 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -3737,7 +3737,7 @@ static int s2io_enable_msi_x(struct s2io_nic *nic)
 }
 
 /* Handle software interrupt used during MSI(X) test */
-static irqreturn_t __devinit s2io_test_intr(int irq, void *dev_id)
+static irqreturn_t s2io_test_intr(int irq, void *dev_id)
 {
         struct s2io_nic *sp = dev_id;
 
@@ -3748,7 +3748,7 @@ static irqreturn_t __devinit s2io_test_intr(int irq, void *dev_id)
 }
 
 /* Test interrupt path by forcing a a software IRQ */
-static int __devinit s2io_test_msi(struct s2io_nic *sp)
+static int s2io_test_msi(struct s2io_nic *sp)
 {
         struct pci_dev *pdev = sp->pdev;
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index 720088396bb9..7eab072ae792 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -474,7 +474,7 @@ static inline void sis190_map_to_asic(struct RxDesc *desc, dma_addr_t mapping,
 static inline void sis190_make_unusable_by_asic(struct RxDesc *desc)
 {
         desc->PSize = 0x0;
-        desc->addr = 0xdeadbeef;
+        desc->addr = cpu_to_le32(0xdeadbeef);
         desc->size &= cpu_to_le32(RingEnd);
         wmb();
         desc->status = 0x0;
@@ -580,7 +580,7 @@ static int sis190_rx_interrupt(struct net_device *dev,
                 struct RxDesc *desc = tp->RxDescRing + entry;
                 u32 status;
 
-                if (desc->status & OWNbit)
+                if (le32_to_cpu(desc->status) & OWNbit)
                         break;
 
                 status = le32_to_cpu(desc->PSize);
@@ -1381,7 +1381,7 @@ out:
         return rc;
 }
 
-static void __devexit sis190_mii_remove(struct net_device *dev)
+static void sis190_mii_remove(struct net_device *dev)
 {
         struct sis190_private *tp = netdev_priv(dev);
 
@@ -1538,9 +1538,9 @@ static int __devinit sis190_get_mac_addr_from_eeprom(struct pci_dev *pdev,
 
         /* Get MAC address from EEPROM */
         for (i = 0; i < MAC_ADDR_LEN / 2; i++) {
-                __le16 w = sis190_read_eeprom(ioaddr, EEPROMMACAddr + i);
+                u16 w = sis190_read_eeprom(ioaddr, EEPROMMACAddr + i);
 
-                ((u16 *)dev->dev_addr)[i] = le16_to_cpu(w);
+                ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(w);
         }
 
         sis190_set_rgmii(tp, sis190_read_eeprom(ioaddr, EEPROMInfo));
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 6197afb3ed83..a74fc11a6482 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -822,8 +822,13 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 
         sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), rx_reg);
 
-        /* Flush Rx MAC FIFO on any flow control or error */
-        sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR);
+        if (hw->chip_id == CHIP_ID_YUKON_XL) {
+                /* Hardware errata - clear flush mask */
+                sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), 0);
+        } else {
+                /* Flush Rx MAC FIFO on any flow control or error */
+                sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR);
+        }
 
         /* Set threshold to 0xa (64 bytes) + 1 to workaround pause bug  */
         reg = RX_GMF_FL_THR_DEF + 1;
diff --git a/drivers/net/smc911x.h b/drivers/net/smc911x.h
index d04e4fa35206..7defa63b9c74 100644
--- a/drivers/net/smc911x.h
+++ b/drivers/net/smc911x.h
@@ -76,7 +76,7 @@
 
 
 
-#if      SMC_USE_PXA_DMA
+#ifdef SMC_USE_PXA_DMA
 #define SMC_USE_DMA
 
 /*
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index bcc430bd9e49..6e00dc857afa 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -1742,7 +1742,7 @@ static void set_rx_mode(struct net_device *dev)
                         if (vlan_group_get_device(np->vlgrp, i)) {
                                 if (vlan_count >= 32)
                                         break;
-                                writew(cpu_to_be16(i), filter_addr);
+                                writew(i, filter_addr);
                                 filter_addr += 16;
                                 vlan_count++;
                         }
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c
index ff98f5d597f1..0a6186d4a48e 100644
--- a/drivers/net/sundance.c
+++ b/drivers/net/sundance.c
@@ -340,9 +340,9 @@ enum mac_ctrl1_bits {
 /* Note that using only 32 bit fields simplifies conversion to big-endian
    architectures. */
 struct netdev_desc {
-        u32 next_desc;
-        u32 status;
-        struct desc_frag { u32 addr, length; } frag[1];
+        __le32 next_desc;
+        __le32 status;
+        struct desc_frag { __le32 addr, length; } frag[1];
 };
 
 /* Bits in netdev_desc.status */
@@ -495,8 +495,8 @@ static int __devinit sundance_probe1 (struct pci_dev *pdev,
                 goto err_out_res;
 
         for (i = 0; i < 3; i++)
-                ((u16 *)dev->dev_addr)[i] =
-                        le16_to_cpu(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
+                ((__le16 *)dev->dev_addr)[i] =
+                        cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 
         dev->base_addr = (unsigned long)ioaddr;
@@ -1090,8 +1090,8 @@ reset_tx (struct net_device *dev)
                 skb = np->tx_skbuff[i];
                 if (skb) {
                         pci_unmap_single(np->pci_dev,
-                                np->tx_ring[i].frag[0].addr, skb->len,
-                                PCI_DMA_TODEVICE);
+                                le32_to_cpu(np->tx_ring[i].frag[0].addr),
+                                skb->len, PCI_DMA_TODEVICE);
                         if (irq)
                                 dev_kfree_skb_irq (skb);
                         else
@@ -1214,7 +1214,7 @@ static irqreturn_t intr_handler(int irq, void *dev_instance)
                                 skb = np->tx_skbuff[entry];
                                 /* Free the original skb. */
                                 pci_unmap_single(np->pci_dev,
-                                        np->tx_ring[entry].frag[0].addr,
+                                        le32_to_cpu(np->tx_ring[entry].frag[0].addr),
                                         skb->len, PCI_DMA_TODEVICE);
                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
                                 np->tx_skbuff[entry] = NULL;
@@ -1233,7 +1233,7 @@ static irqreturn_t intr_handler(int irq, void *dev_instance)
                                 skb = np->tx_skbuff[entry];
                                 /* Free the original skb. */
                                 pci_unmap_single(np->pci_dev,
-                                        np->tx_ring[entry].frag[0].addr,
+                                        le32_to_cpu(np->tx_ring[entry].frag[0].addr),
                                         skb->len, PCI_DMA_TODEVICE);
                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
                                 np->tx_skbuff[entry] = NULL;
@@ -1311,19 +1311,19 @@ static void rx_poll(unsigned long data)
                                 && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
                                 pci_dma_sync_single_for_cpu(np->pci_dev,
-                                                            desc->frag[0].addr,
+                                                            le32_to_cpu(desc->frag[0].addr),
                                                             np->rx_buf_sz,
                                                             PCI_DMA_FROMDEVICE);
 
                                 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
                                 pci_dma_sync_single_for_device(np->pci_dev,
-                                                               desc->frag[0].addr,
+                                                               le32_to_cpu(desc->frag[0].addr),
                                                                np->rx_buf_sz,
                                                                PCI_DMA_FROMDEVICE);
                                 skb_put(skb, pkt_len);
                         } else {
                                 pci_unmap_single(np->pci_dev,
-                                        desc->frag[0].addr,
+                                        le32_to_cpu(desc->frag[0].addr),
                                         np->rx_buf_sz,
                                         PCI_DMA_FROMDEVICE);
                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
@@ -1709,23 +1709,23 @@ static int netdev_close(struct net_device *dev)
         /* Free all the skbuffs in the Rx queue. */
         for (i = 0; i < RX_RING_SIZE; i++) {
                 np->rx_ring[i].status = 0;
-                np->rx_ring[i].frag[0].addr = 0xBADF00D0; /* An invalid address. */
                 skb = np->rx_skbuff[i];
                 if (skb) {
                         pci_unmap_single(np->pci_dev,
-                                np->rx_ring[i].frag[0].addr, np->rx_buf_sz,
-                                PCI_DMA_FROMDEVICE);
+                                le32_to_cpu(np->rx_ring[i].frag[0].addr),
+                                np->rx_buf_sz, PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(skb);
                         np->rx_skbuff[i] = NULL;
                 }
+                np->rx_ring[i].frag[0].addr = cpu_to_le32(0xBADF00D0); /* poison */
         }
         for (i = 0; i < TX_RING_SIZE; i++) {
                 np->tx_ring[i].next_desc = 0;
                 skb = np->tx_skbuff[i];
                 if (skb) {
                         pci_unmap_single(np->pci_dev,
-                                np->tx_ring[i].frag[0].addr, skb->len,
-                                PCI_DMA_TODEVICE);
+                                le32_to_cpu(np->tx_ring[i].frag[0].addr),
+                                skb->len, PCI_DMA_TODEVICE);
                         dev_kfree_skb(skb);
                         np->tx_skbuff[i] = NULL;
                 }
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 0f7626856a6b..8d456e379a86 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3447,7 +3447,7 @@ static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit
         u16 length, howmany = 0;
         u32 bd_status;
         u8 *bdBuffer;
-        struct net_device * dev;
+        struct net_device *dev;
 
         ugeth_vdbg("%s: IN", __FUNCTION__);
 
diff --git a/drivers/net/ucc_geth_mii.h b/drivers/net/ucc_geth_mii.h
index d83437039919..1e45b2028a50 100644
--- a/drivers/net/ucc_geth_mii.h
+++ b/drivers/net/ucc_geth_mii.h
@@ -96,5 +96,5 @@ enum enet_tbi_mii_reg {
 int uec_mdio_read(struct mii_bus *bus, int mii_id, int regnum);
 int uec_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
 int __init uec_mdio_init(void);
-void __exit uec_mdio_exit(void);
+void uec_mdio_exit(void);
 #endif                          /* __UEC_MII_H */
diff --git a/drivers/net/wan/syncppp.c b/drivers/net/wan/syncppp.c
index 232ecba5340f..61e24b7a45a3 100644
--- a/drivers/net/wan/syncppp.c
+++ b/drivers/net/wan/syncppp.c
@@ -107,24 +107,24 @@
 struct ppp_header {
         u8 address;
         u8 control;
-        u16 protocol;
+        __be16 protocol;
 };
 #define PPP_HEADER_LEN          sizeof (struct ppp_header)
 
 struct lcp_header {
         u8 type;
         u8 ident;
-        u16 len;
+        __be16 len;
 };
 #define LCP_HEADER_LEN          sizeof (struct lcp_header)
 
 struct cisco_packet {
-        u32 type;
-        u32 par1;
-        u32 par2;
-        u16 rel;
-        u16 time0;
-        u16 time1;
+        __be32 type;
+        __be32 par1;
+        __be32 par2;
+        __be16 rel;
+        __be16 time0;
+        __be16 time1;
 };
 #define CISCO_PACKET_LEN 18
 #define CISCO_BIG_PACKET_LEN 20
@@ -139,7 +139,7 @@ static struct sk_buff_head tx_queue;
 static void sppp_keepalive (unsigned long dummy);
 static void sppp_cp_send (struct sppp *sp, u16 proto, u8 type,
         u8 ident, u16 len, void *data);
-static void sppp_cisco_send (struct sppp *sp, int type, long par1, long par2);
+static void sppp_cisco_send (struct sppp *sp, int type, u32 par1, u32 par2);
 static void sppp_lcp_input (struct sppp *sp, struct sk_buff *m);
 static void sppp_cisco_input (struct sppp *sp, struct sk_buff *m);
 static void sppp_ipcp_input (struct sppp *sp, struct sk_buff *m);
@@ -447,7 +447,7 @@ static void sppp_keepalive (unsigned long dummy)
                         sppp_cisco_send (sp, CISCO_KEEPALIVE_REQ, ++sp->pp_seq,
                                 sp->pp_rseq);
                 else if (sp->lcp.state == LCP_STATE_OPENED) {
-                        long nmagic = htonl (sp->lcp.magic);
+                        __be32 nmagic = htonl (sp->lcp.magic);
                         sp->lcp.echoid = ++sp->pp_seq;
                         sppp_cp_send (sp, PPP_LCP, LCP_ECHO_REQ,
                                 sp->lcp.echoid, 4, &nmagic);
@@ -667,7 +667,7 @@ badreq:
                                         dev->name, len);
                         break;
                 }
-                if (ntohl (*(long*)(h+1)) == sp->lcp.magic) {
+                if (ntohl (*(__be32*)(h+1)) == sp->lcp.magic) {
                         /* Line loopback mode detected. */
                         printk (KERN_WARNING "%s: loopback\n", dev->name);
                         if_down (dev);
@@ -680,7 +680,7 @@ badreq:
                         sppp_lcp_open (sp);
                         break;
                 }
-                *(long*)(h+1) = htonl (sp->lcp.magic);
+                *(__be32 *)(h+1) = htonl (sp->lcp.magic);
                 sppp_cp_send (sp, PPP_LCP, LCP_ECHO_REPLY, h->ident, len-4, h+1);
                 break;
         case LCP_ECHO_REPLY:
@@ -692,7 +692,7 @@ badreq:
                                         dev->name, len);
                         break;
                 }
-                if (ntohl (*(long*)(h+1)) != sp->lcp.magic)
+                if (ntohl(*(__be32 *)(h+1)) != sp->lcp.magic)
                 sp->pp_alivecnt = 0;
                 break;
         }
@@ -765,7 +765,7 @@ static void sppp_cisco_input (struct sppp *sp, struct sk_buff *skb)
                 {
                 struct in_device *in_dev;
                 struct in_ifaddr *ifa;
-                __be32 addr = 0, mask = ~0; /* FIXME: is the mask correct? */
+                __be32 addr = 0, mask = htonl(~0U); /* FIXME: is the mask correct? */
 #ifdef CONFIG_INET
                 rcu_read_lock();
                 if ((in_dev = __in_dev_get_rcu(dev)) != NULL)
@@ -782,8 +782,7 @@ static void sppp_cisco_input (struct sppp *sp, struct sk_buff *skb)
                 }
                 rcu_read_unlock();
 #endif          
-                /* I hope both addr and mask are in the net order */
-                sppp_cisco_send (sp, CISCO_ADDR_REPLY, addr, mask);
+                sppp_cisco_send (sp, CISCO_ADDR_REPLY, ntohl(addr), ntohl(mask));
                 break;
                 }
         }
@@ -844,7 +843,7 @@ static void sppp_cp_send (struct sppp *sp, u16 proto, u8 type,
  * Send Cisco keepalive packet.
  */
 
-static void sppp_cisco_send (struct sppp *sp, int type, long par1, long par2)
+static void sppp_cisco_send (struct sppp *sp, int type, u32 par1, u32 par2)
 {
         struct ppp_header *h;
         struct cisco_packet *ch;
@@ -868,7 +867,7 @@ static void sppp_cisco_send (struct sppp *sp, int type, long par1, long par2)
         ch->type = htonl (type);
         ch->par1 = htonl (par1);
         ch->par2 = htonl (par2);
-        ch->rel = -1;
+        ch->rel = htons(0xffff);
         ch->time0 = htons ((u16) (t >> 16));
         ch->time1 = htons ((u16) t);
 
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index 2b733c582915..5583719a0dca 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -264,6 +264,7 @@ config IPW2200_DEBUG
 config LIBERTAS
         tristate "Marvell 8xxx Libertas WLAN driver support"
         depends on WLAN_80211
+        select WIRELESS_EXT
         select IEEE80211
         select FW_LOADER
         ---help---
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 19e588582c7c..6c0e2b9f7760 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -163,6 +163,9 @@ static void b43_map_led(struct b43_wldev *dev,
                 b43_register_led(dev, &dev->led_radio, name,
                                  b43_rfkill_led_name(dev),
                                  led_index, activelow);
+                /* Sync the RF-kill LED state with the switch state. */
+                if (dev->radio_hw_enable)
+                        b43_led_turn_on(dev, led_index, activelow);
                 break;
         case B43_LED_WEIRD:
         case B43_LED_ASSOC:
@@ -232,4 +235,5 @@ void b43_leds_exit(struct b43_wldev *dev)
         b43_unregister_led(&dev->led_tx);
         b43_unregister_led(&dev->led_rx);
         b43_unregister_led(&dev->led_assoc);
+        b43_unregister_led(&dev->led_radio);
 }
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index b45eecc53c4a..1c93b4f4bfe3 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2163,7 +2163,6 @@ static void b43_mgmtframe_txantenna(struct b43_wldev *dev, int antenna)
 static void b43_chip_exit(struct b43_wldev *dev)
 {
         b43_radio_turn_off(dev, 1);
-        b43_leds_exit(dev);
         b43_gpio_cleanup(dev);
         /* firmware is released later */
 }
@@ -2191,11 +2190,10 @@ static int b43_chip_init(struct b43_wldev *dev)
         err = b43_gpio_init(dev);
         if (err)
                 goto out;       /* firmware is released later */
-        b43_leds_init(dev);
 
         err = b43_upload_initvals(dev);
         if (err)
-                goto err_leds_exit;
+                goto err_gpio_clean;
         b43_radio_turn_on(dev);
 
         b43_write16(dev, 0x03E6, 0x0000);
@@ -2271,8 +2269,7 @@ out:
 
 err_radio_off:
         b43_radio_turn_off(dev, 1);
-err_leds_exit:
-        b43_leds_exit(dev);
+err_gpio_clean:
         b43_gpio_cleanup(dev);
         return err;
 }
@@ -3273,10 +3270,7 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
                 return;
         b43_set_status(dev, B43_STAT_UNINIT);
 
-        mutex_unlock(&dev->wl->mutex);
-        b43_rfkill_exit(dev);
-        mutex_lock(&dev->wl->mutex);
-
+        b43_leds_exit(dev);
         b43_rng_exit(dev->wl);
         b43_pio_free(dev);
         b43_dma_free(dev);
@@ -3405,12 +3399,12 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
         memset(wl->mac_addr, 0, ETH_ALEN);
         b43_upload_card_macaddress(dev);
         b43_security_init(dev);
-        b43_rfkill_init(dev);
         b43_rng_init(wl);
 
         b43_set_status(dev, B43_STAT_INITIALIZED);
 
-      out:
+        b43_leds_init(dev);
+out:
         return err;
 
       err_chip_exit:
@@ -3499,6 +3493,10 @@ static int b43_start(struct ieee80211_hw *hw)
         int did_init = 0;
         int err = 0;
 
+        /* First register RFkill.
+         * LEDs that are registered later depend on it. */
+        b43_rfkill_init(dev);
+
         mutex_lock(&wl->mutex);
 
         if (b43_status(dev) < B43_STAT_INITIALIZED) {
@@ -3528,6 +3526,8 @@ static void b43_stop(struct ieee80211_hw *hw)
         struct b43_wl *wl = hw_to_b43_wl(hw);
         struct b43_wldev *dev = wl->current_dev;
 
+        b43_rfkill_exit(dev);
+
         mutex_lock(&wl->mutex);
         if (b43_status(dev) >= B43_STAT_STARTED)
                 b43_wireless_core_stop(dev);
diff --git a/drivers/net/wireless/b43/rfkill.c b/drivers/net/wireless/b43/rfkill.c
index 9b1f905ffbf4..98cf70c5fd47 100644
--- a/drivers/net/wireless/b43/rfkill.c
+++ b/drivers/net/wireless/b43/rfkill.c
@@ -25,6 +25,8 @@
 #include "rfkill.h"
 #include "b43.h"
 
+#include <linux/kmod.h>
+
 
 /* Returns TRUE, if the radio is enabled in hardware. */
 static bool b43_is_hw_radio_enabled(struct b43_wldev *dev)
@@ -50,7 +52,10 @@ static void b43_rfkill_poll(struct input_polled_dev *poll_dev)
         bool report_change = 0;
 
         mutex_lock(&wl->mutex);
-        B43_WARN_ON(b43_status(dev) < B43_STAT_INITIALIZED);
+        if (unlikely(b43_status(dev) < B43_STAT_INITIALIZED)) {
+                mutex_unlock(&wl->mutex);
+                return;
+        }
         enabled = b43_is_hw_radio_enabled(dev);
         if (unlikely(enabled != dev->radio_hw_enable)) {
                 dev->radio_hw_enable = enabled;
@@ -60,8 +65,12 @@ static void b43_rfkill_poll(struct input_polled_dev *poll_dev)
         }
         mutex_unlock(&wl->mutex);
 
-        if (unlikely(report_change))
-                input_report_key(poll_dev->input, KEY_WLAN, enabled);
+        /* send the radio switch event to the system - note both a key press
+         * and a release are required */
+        if (unlikely(report_change)) {
+                input_report_key(poll_dev->input, KEY_WLAN, 1);
+                input_report_key(poll_dev->input, KEY_WLAN, 0);
+        }
 }
 
 /* Called when the RFKILL toggled in software. */
@@ -69,13 +78,15 @@ static int b43_rfkill_soft_toggle(void *data, enum rfkill_state state)
 {
         struct b43_wldev *dev = data;
         struct b43_wl *wl = dev->wl;
-        int err = 0;
+        int err = -EBUSY;
 
         if (!wl->rfkill.registered)
                 return 0;
 
         mutex_lock(&wl->mutex);
-        B43_WARN_ON(b43_status(dev) < B43_STAT_INITIALIZED);
+        if (b43_status(dev) < B43_STAT_INITIALIZED)
+                goto out_unlock;
+        err = 0;
         switch (state) {
         case RFKILL_STATE_ON:
                 if (!dev->radio_hw_enable) {
@@ -133,9 +144,25 @@ void b43_rfkill_init(struct b43_wldev *dev)
         rfk->poll_dev->poll = b43_rfkill_poll;
         rfk->poll_dev->poll_interval = 1000; /* msecs */
 
+        rfk->poll_dev->input->name = rfk->name;
+        rfk->poll_dev->input->id.bustype = BUS_HOST;
+        rfk->poll_dev->input->id.vendor = dev->dev->bus->boardinfo.vendor;
+        rfk->poll_dev->input->evbit[0] = BIT(EV_KEY);
+        set_bit(KEY_WLAN, rfk->poll_dev->input->keybit);
+
         err = rfkill_register(rfk->rfkill);
         if (err)
                 goto err_free_polldev;
+
+#ifdef CONFIG_RFKILL_INPUT_MODULE
+        /* B43 RF-kill isn't useful without the rfkill-input subsystem.
+         * Try to load the module. */
+        err = request_module("rfkill-input");
+        if (err)
+                b43warn(wl, "Failed to load the rfkill-input module. "
+                        "The built-in radio LED will not work.\n");
+#endif /* CONFIG_RFKILL_INPUT */
+
         err = input_register_polled_device(rfk->poll_dev);
         if (err)
                 goto err_unreg_rfk;
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
index 35dbe4554513..76e9dd843faa 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_debugfs.c
@@ -219,7 +219,7 @@ static ssize_t tsf_write_file(struct file *file, const char __user *user_buf,
         ssize_t buf_size;
         ssize_t res;
         unsigned long flags;
-        u64 tsf;
+        unsigned long long tsf;
 
         buf_size = min(count, sizeof (really_big_buffer) - 1);
         down(&big_buffer_sem);
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index 54f44e5473c0..da51f477e9df 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -10751,7 +10751,7 @@ static void ipw_bg_link_down(struct work_struct *work)
         mutex_unlock(&priv->mutex);
 }
 
-static int ipw_setup_deferred_work(struct ipw_priv *priv)
+static int __devinit ipw_setup_deferred_work(struct ipw_priv *priv)
 {
         int ret = 0;
 
@@ -11600,7 +11600,8 @@ static void ipw_prom_free(struct ipw_priv *priv)
 #endif
 
 
-static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit ipw_pci_probe(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
 {
         int err = 0;
         struct net_device *net_dev;
@@ -11767,7 +11768,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         return err;
 }
 
-static void ipw_pci_remove(struct pci_dev *pdev)
+static void __devexit ipw_pci_remove(struct pci_dev *pdev)
 {
         struct ipw_priv *priv = pci_get_drvdata(pdev);
         struct list_head *p, *q;
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 4bdf237f6adc..3d1da0759b97 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -4743,8 +4743,10 @@ static void iwl_irq_tasklet(struct iwl_priv *priv)
                  *   when we loaded driver, and is now set to "enable".
                  * After we're Alive, RF_KILL gets handled by
                  *   iwl_rx_card_state_notif() */
-                if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status))
+                if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status)) {
+                        clear_bit(STATUS_RF_KILL_HW, &priv->status);
                         queue_work(priv->workqueue, &priv->restart);
+                }
 
                 handled |= CSR_INT_BIT_RF_KILL;
         }
@@ -6171,6 +6173,7 @@ static void iwl_alive_start(struct iwl_priv *priv)
                 mutex_lock(&priv->mutex);
 
                 if (rc) {
+                        iwl_rate_control_unregister(priv->hw);
                         IWL_ERROR("Failed to register network "
                                   "device (error %d)\n", rc);
                         return;
diff --git a/drivers/net/wireless/iwlwifi/iwl4965-base.c b/drivers/net/wireless/iwlwifi/iwl4965-base.c
index 8f85564ec6fa..b54fe5e6d529 100644
--- a/drivers/net/wireless/iwlwifi/iwl4965-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl4965-base.c
@@ -5059,8 +5059,10 @@ static void iwl_irq_tasklet(struct iwl_priv *priv)
                  *   when we loaded driver, and is now set to "enable".
                  * After we're Alive, RF_KILL gets handled by
                  *   iwl_rx_card_state_notif() */
-                if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status))
+                if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status)) {
+                        clear_bit(STATUS_RF_KILL_HW, &priv->status);
                         queue_work(priv->workqueue, &priv->restart);
+                }
 
                 handled |= CSR_INT_BIT_RF_KILL;
         }
@@ -6527,6 +6529,7 @@ static void iwl_alive_start(struct iwl_priv *priv)
                 mutex_lock(&priv->mutex);
 
                 if (rc) {
+                        iwl_rate_control_unregister(priv->hw);
                         IWL_ERROR("Failed to register network "
                                   "device (error %d)\n", rc);
                         return;
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.c b/drivers/net/wireless/zd1211rw/zd_mac.c
index a903645e157a..5298a8bf1129 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.c
+++ b/drivers/net/wireless/zd1211rw/zd_mac.c
@@ -1130,6 +1130,8 @@ static void zd_mac_rx(struct zd_mac *mac, struct sk_buff *skb)
         __skb_trim(skb, skb->len -
                         (IEEE80211_FCS_LEN + sizeof(struct rx_status)));
 
+        ZD_ASSERT(IS_ALIGNED((unsigned long)skb->data, 4));
+
         update_qual_rssi(mac, skb->data, skb->len, stats.signal,
                          status->signal_strength);
 
@@ -1166,15 +1168,19 @@ static void do_rx(unsigned long mac_ptr)
 int zd_mac_rx_irq(struct zd_mac *mac, const u8 *buffer, unsigned int length)
 {
         struct sk_buff *skb;
+        unsigned int reserved =
+                ALIGN(max_t(unsigned int,
+                            sizeof(struct zd_rt_hdr), ZD_PLCP_HEADER_SIZE), 4) -
+                ZD_PLCP_HEADER_SIZE;
 
-        skb = dev_alloc_skb(sizeof(struct zd_rt_hdr) + length);
+        skb = dev_alloc_skb(reserved + length);
         if (!skb) {
                 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
                 dev_warn(zd_mac_dev(mac), "Could not allocate skb.\n");
                 ieee->stats.rx_dropped++;
                 return -ENOMEM;
         }
-        skb_reserve(skb, sizeof(struct zd_rt_hdr));
+        skb_reserve(skb, reserved);
         memcpy(__skb_put(skb, length), buffer, length);
         skb_queue_tail(&mac->rx_queue, skb);
         tasklet_schedule(&mac->rx_tasklet);