116 files changed, 1428 insertions, 575 deletions

diff --git a/drivers/net/3c509.c b/drivers/net/3c509.c
index 3a7bc524af33..c7a4f3bcc2bc 100644
--- a/drivers/net/3c509.c
+++ b/drivers/net/3c509.c
@@ -94,7 +94,7 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 
-static char version[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
+static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
 
 #ifdef EL3_DEBUG
 static int el3_debug = EL3_DEBUG;
@@ -186,7 +186,7 @@ static int max_interrupt_work = 10;
 static int nopnp;
 #endif
 
-static int __init el3_common_init(struct net_device *dev);
+static int __devinit el3_common_init(struct net_device *dev);
 static void el3_common_remove(struct net_device *dev);
 static ushort id_read_eeprom(int index);
 static ushort read_eeprom(int ioaddr, int index);
@@ -537,7 +537,7 @@ static struct mca_driver el3_mca_driver = {
 static int mca_registered;
 #endif /* CONFIG_MCA */
 
-static int __init el3_common_init(struct net_device *dev)
+static int __devinit el3_common_init(struct net_device *dev)
 {
         struct el3_private *lp = netdev_priv(dev);
         int err;
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index f749b40f954e..231eeaf1d552 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1825,9 +1825,10 @@ config FEC2
 
 config FEC_MPC52xx
         tristate "MPC52xx FEC driver"
-        depends on PPC_MPC52xx && PPC_BESTCOMM_FEC
+        depends on PPC_MPC52xx && PPC_BESTCOMM
         select CRC32
         select PHYLIB
+        select PPC_BESTCOMM_FEC
         ---help---
           This option enables support for the MPC5200's on-chip
           Fast Ethernet Controller
@@ -2010,9 +2011,13 @@ config IGB_LRO
           If in doubt, say N.
 
 config IGB_DCA
-        bool "Enable DCA"
+        bool "Direct Cache Access (DCA) Support"
         default y
         depends on IGB && DCA && !(IGB=y && DCA=m)
+        ---help---
+          Say Y here if you want to use Direct Cache Access (DCA) in the
+          driver.  DCA is a method for warming the CPU cache before data
+          is used, with the intent of lessening the impact of cache misses.
 
 source "drivers/net/ixp2000/Kconfig"
 
@@ -2437,9 +2442,13 @@ config IXGBE
           will be called ixgbe.
 
 config IXGBE_DCA
-        bool
+        bool "Direct Cache Access (DCA) Support"
         default y
         depends on IXGBE && DCA && !(IXGBE=y && DCA=m)
+        ---help---
+          Say Y here if you want to use Direct Cache Access (DCA) in the
+          driver.  DCA is a method for warming the CPU cache before data
+          is used, with the intent of lessening the impact of cache misses.
 
 config IXGB
         tristate "Intel(R) PRO/10GbE support"
@@ -2489,9 +2498,13 @@ config MYRI10GE
           will be called myri10ge.
 
 config MYRI10GE_DCA
-        bool
+        bool "Direct Cache Access (DCA) Support"
         default y
         depends on MYRI10GE && DCA && !(MYRI10GE=y && DCA=m)
+        ---help---
+          Say Y here if you want to use Direct Cache Access (DCA) in the
+          driver.  DCA is a method for warming the CPU cache before data
+          is used, with the intent of lessening the impact of cache misses.
 
 config NETXEN_NIC
         tristate "NetXen Multi port (1/10) Gigabit Ethernet NIC"
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index f19acf8b9220..017383ad5ec6 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -114,7 +114,7 @@ obj-$(CONFIG_EL2) += 3c503.o 8390p.o
 obj-$(CONFIG_NE2000) += ne.o 8390p.o
 obj-$(CONFIG_NE2_MCA) += ne2.o 8390p.o
 obj-$(CONFIG_HPLAN) += hp.o 8390p.o
-obj-$(CONFIG_HPLAN_PLUS) += hp-plus.o 8390.o
+obj-$(CONFIG_HPLAN_PLUS) += hp-plus.o 8390p.o
 obj-$(CONFIG_ULTRA) += smc-ultra.o 8390.o
 obj-$(CONFIG_ULTRAMCA) += smc-mca.o 8390.o
 obj-$(CONFIG_ULTRA32) += smc-ultra32.o 8390.o
diff --git a/drivers/net/amd8111e.c b/drivers/net/amd8111e.c
index c54967f7942a..07a6697e3635 100644
--- a/drivers/net/amd8111e.c
+++ b/drivers/net/amd8111e.c
@@ -644,10 +644,6 @@ This function frees the  transmiter and receiver descriptor rings.
 */
 static void amd8111e_free_ring(struct amd8111e_priv* lp)
 {
-
-        /* Free transmit and receive skbs */
-        amd8111e_free_skbs(lp->amd8111e_net_dev);
-
         /* Free transmit and receive descriptor rings */
         if(lp->rx_ring){
                 pci_free_consistent(lp->pci_dev,
@@ -833,12 +829,14 @@ static int amd8111e_rx_poll(struct napi_struct *napi, int budget)
 
         } while(intr0 & RINT0);
 
-        /* Receive descriptor is empty now */
-        spin_lock_irqsave(&lp->lock, flags);
-        __netif_rx_complete(dev, napi);
-        writel(VAL0|RINTEN0, mmio + INTEN0);
-        writel(VAL2 | RDMD0, mmio + CMD0);
-        spin_unlock_irqrestore(&lp->lock, flags);
+        if (rx_pkt_limit > 0) {
+                /* Receive descriptor is empty now */
+                spin_lock_irqsave(&lp->lock, flags);
+                __netif_rx_complete(dev, napi);
+                writel(VAL0|RINTEN0, mmio + INTEN0);
+                writel(VAL2 | RDMD0, mmio + CMD0);
+                spin_unlock_irqrestore(&lp->lock, flags);
+        }
 
 rx_not_empty:
         return num_rx_pkt;
@@ -1231,7 +1229,9 @@ static int amd8111e_close(struct net_device * dev)
 
         amd8111e_disable_interrupt(lp);
         amd8111e_stop_chip(lp);
-        amd8111e_free_ring(lp);
+
+        /* Free transmit and receive skbs */
+        amd8111e_free_skbs(lp->amd8111e_net_dev);
 
         netif_carrier_off(lp->amd8111e_net_dev);
 
@@ -1241,6 +1241,7 @@ static int amd8111e_close(struct net_device * dev)
 
         spin_unlock_irq(&lp->lock);
         free_irq(dev->irq, dev);
+        amd8111e_free_ring(lp);
 
         /* Update the statistics before closing */
         amd8111e_get_stats(dev);
diff --git a/drivers/net/arm/at91_ether.c b/drivers/net/arm/at91_ether.c
index 0fa53464efb2..6f431a887e7e 100644
--- a/drivers/net/arm/at91_ether.c
+++ b/drivers/net/arm/at91_ether.c
@@ -1080,7 +1080,8 @@ static int __init at91ether_setup(unsigned long phy_type, unsigned short phy_add
                 init_timer(&lp->check_timer);
                 lp->check_timer.data = (unsigned long)dev;
                 lp->check_timer.function = at91ether_check_link;
-        }
+        } else if (lp->board_data.phy_irq_pin >= 32)
+                gpio_request(lp->board_data.phy_irq_pin, "ethernet_phy");
 
         /* Display ethernet banner */
         printk(KERN_INFO "%s: AT91 ethernet at 0x%08x int=%d %s%s (%s)\n",
@@ -1167,6 +1168,9 @@ static int __devexit at91ether_remove(struct platform_device *pdev)
         struct net_device *dev = platform_get_drvdata(pdev);
         struct at91_private *lp = netdev_priv(dev);
 
+        if (lp->board_data.phy_irq_pin >= 32)
+                gpio_free(lp->board_data.phy_irq_pin);
+
         unregister_netdev(dev);
         free_irq(dev->irq, dev);
         dma_free_coherent(NULL, sizeof(struct recv_desc_bufs), lp->dlist, (dma_addr_t)lp->dlist_phys);
diff --git a/drivers/net/atl1e/atl1e.h b/drivers/net/atl1e/atl1e.h
index b645fa0f3f64..c49550d507a0 100644
--- a/drivers/net/atl1e/atl1e.h
+++ b/drivers/net/atl1e/atl1e.h
@@ -46,7 +46,6 @@
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/tcp.h>
-#include <linux/mii.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
 #include <linux/workqueue.h>
diff --git a/drivers/net/atl1e/atl1e_hw.c b/drivers/net/atl1e/atl1e_hw.c
index 8cbc1b59bd62..4a7700620119 100644
--- a/drivers/net/atl1e/atl1e_hw.c
+++ b/drivers/net/atl1e/atl1e_hw.c
@@ -163,9 +163,6 @@ int atl1e_read_mac_addr(struct atl1e_hw *hw)
  * atl1e_hash_mc_addr
  *  purpose
  *      set hash value for a multicast address
- *      hash calcu processing :
- *          1. calcu 32bit CRC for multicast address
- *          2. reverse crc with MSB to LSB
  */
 u32 atl1e_hash_mc_addr(struct atl1e_hw *hw, u8 *mc_addr)
 {
@@ -174,7 +171,6 @@ u32 atl1e_hash_mc_addr(struct atl1e_hw *hw, u8 *mc_addr)
         int i;
 
         crc32 = ether_crc_le(6, mc_addr);
-        crc32 = ~crc32;
         for (i = 0; i < 32; i++)
                 value |= (((crc32 >> i) & 1) << (31 - i));
 
diff --git a/drivers/net/atlx/atl1.c b/drivers/net/atlx/atl1.c
index 3cf59a7f5a1c..aef403d299ee 100644
--- a/drivers/net/atlx/atl1.c
+++ b/drivers/net/atlx/atl1.c
@@ -2310,7 +2310,8 @@ static void atl1_tx_queue(struct atl1_adapter *adapter, u16 count,
                 if (tpd != ptpd)
                         memcpy(tpd, ptpd, sizeof(struct tx_packet_desc));
                 tpd->buffer_addr = cpu_to_le64(buffer_info->dma);
-                tpd->word2 = (cpu_to_le16(buffer_info->length) &
+                tpd->word2 &= ~(TPD_BUFLEN_MASK << TPD_BUFLEN_SHIFT);
+                tpd->word2 |= (cpu_to_le16(buffer_info->length) &
                         TPD_BUFLEN_MASK) << TPD_BUFLEN_SHIFT;
 
                 /*
@@ -2409,8 +2410,8 @@ static int atl1_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 vlan_tag = (vlan_tag << 4) | (vlan_tag >> 13) |
                         ((vlan_tag >> 9) & 0x8);
                 ptpd->word3 |= 1 << TPD_INS_VL_TAG_SHIFT;
-                ptpd->word3 |= (vlan_tag & TPD_VL_TAGGED_MASK) <<
-                        TPD_VL_TAGGED_SHIFT;
+                ptpd->word2 |= (vlan_tag & TPD_VLANTAG_MASK) <<
+                        TPD_VLANTAG_SHIFT;
         }
 
         tso = atl1_tso(adapter, skb, ptpd);
@@ -3403,14 +3404,8 @@ static void atl1_get_wol(struct net_device *netdev,
 {
         struct atl1_adapter *adapter = netdev_priv(netdev);
 
-        wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
+        wol->supported = WAKE_MAGIC;
         wol->wolopts = 0;
-        if (adapter->wol & ATLX_WUFC_EX)
-                wol->wolopts |= WAKE_UCAST;
-        if (adapter->wol & ATLX_WUFC_MC)
-                wol->wolopts |= WAKE_MCAST;
-        if (adapter->wol & ATLX_WUFC_BC)
-                wol->wolopts |= WAKE_BCAST;
         if (adapter->wol & ATLX_WUFC_MAG)
                 wol->wolopts |= WAKE_MAGIC;
         return;
@@ -3421,15 +3416,10 @@ static int atl1_set_wol(struct net_device *netdev,
 {
         struct atl1_adapter *adapter = netdev_priv(netdev);
 
-        if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
+        if (wol->wolopts & (WAKE_PHY | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
+                WAKE_ARP | WAKE_MAGICSECURE))
                 return -EOPNOTSUPP;
         adapter->wol = 0;
-        if (wol->wolopts & WAKE_UCAST)
-                adapter->wol |= ATLX_WUFC_EX;
-        if (wol->wolopts & WAKE_MCAST)
-                adapter->wol |= ATLX_WUFC_MC;
-        if (wol->wolopts & WAKE_BCAST)
-                adapter->wol |= ATLX_WUFC_BC;
         if (wol->wolopts & WAKE_MAGIC)
                 adapter->wol |= ATLX_WUFC_MAG;
         return 0;
diff --git a/drivers/net/atlx/atl1.h b/drivers/net/atlx/atl1.h
index a5015b14a429..ffa73fc8d95e 100644
--- a/drivers/net/atlx/atl1.h
+++ b/drivers/net/atlx/atl1.h
@@ -504,7 +504,7 @@ struct rx_free_desc {
 #define TPD_PKTNT_MASK          0x0001
 #define TPD_PKTINT_SHIFT        15
 #define TPD_VLANTAG_MASK        0xFFFF
-#define TPD_VLAN_SHIFT          16
+#define TPD_VLANTAG_SHIFT       16
 
 /* tpd word 3 bits 0:13 */
 #define TPD_EOP_MASK            0x0001
diff --git a/drivers/net/atlx/atl2.c b/drivers/net/atlx/atl2.c
index f5bdc92c1a65..8571e8c0bc67 100644
--- a/drivers/net/atlx/atl2.c
+++ b/drivers/net/atlx/atl2.c
@@ -1690,9 +1690,11 @@ static int atl2_resume(struct pci_dev *pdev)
 
         ATL2_WRITE_REG(&adapter->hw, REG_WOL_CTRL, 0);
 
-        err = atl2_request_irq(adapter);
-        if (netif_running(netdev) && err)
-                return err;
+        if (netif_running(netdev)) {
+                err = atl2_request_irq(adapter);
+                if (err)
+                        return err;
+        }
 
         atl2_reset_hw(&adapter->hw);
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 430d430bce29..9e8222f9e90e 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -543,9 +543,9 @@ bnx2_free_rx_mem(struct bnx2 *bp)
                 for (j = 0; j < bp->rx_max_pg_ring; j++) {
                         if (rxr->rx_pg_desc_ring[j])
                                 pci_free_consistent(bp->pdev, RXBD_RING_SIZE,
-                                                    rxr->rx_pg_desc_ring[i],
-                                                    rxr->rx_pg_desc_mapping[i]);
-                        rxr->rx_pg_desc_ring[i] = NULL;
+                                                    rxr->rx_pg_desc_ring[j],
+                                                    rxr->rx_pg_desc_mapping[j]);
+                        rxr->rx_pg_desc_ring[j] = NULL;
                 }
                 if (rxr->rx_pg_ring)
                         vfree(rxr->rx_pg_ring);
@@ -3144,6 +3144,28 @@ bnx2_has_work(struct bnx2_napi *bnapi)
         return 0;
 }
 
+static void
+bnx2_chk_missed_msi(struct bnx2 *bp)
+{
+        struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
+        u32 msi_ctrl;
+
+        if (bnx2_has_work(bnapi)) {
+                msi_ctrl = REG_RD(bp, BNX2_PCICFG_MSI_CONTROL);
+                if (!(msi_ctrl & BNX2_PCICFG_MSI_CONTROL_ENABLE))
+                        return;
+
+                if (bnapi->last_status_idx == bp->idle_chk_status_idx) {
+                        REG_WR(bp, BNX2_PCICFG_MSI_CONTROL, msi_ctrl &
+                               ~BNX2_PCICFG_MSI_CONTROL_ENABLE);
+                        REG_WR(bp, BNX2_PCICFG_MSI_CONTROL, msi_ctrl);
+                        bnx2_msi(bp->irq_tbl[0].vector, bnapi);
+                }
+        }
+
+        bp->idle_chk_status_idx = bnapi->last_status_idx;
+}
+
 static void bnx2_poll_link(struct bnx2 *bp, struct bnx2_napi *bnapi)
 {
         struct status_block *sblk = bnapi->status_blk.msi;
@@ -3218,14 +3240,15 @@ static int bnx2_poll(struct napi_struct *napi, int budget)
 
                 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
 
-                if (unlikely(work_done >= budget))
-                        break;
-
                 /* bnapi->last_status_idx is used below to tell the hw how
                  * much work has been processed, so we must read it before
                  * checking for more work.
                  */
                 bnapi->last_status_idx = sblk->status_idx;
+
+                if (unlikely(work_done >= budget))
+                        break;
+
                 rmb();
                 if (likely(!bnx2_has_work(bnapi))) {
                         netif_rx_complete(bp->dev, napi);
@@ -4570,6 +4593,8 @@ bnx2_init_chip(struct bnx2 *bp)
         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++)
                 bp->bnx2_napi[i].last_status_idx = 0;
 
+        bp->idle_chk_status_idx = 0xffff;
+
         bp->rx_mode = BNX2_EMAC_RX_MODE_SORT_MODE;
 
         /* Set up how to generate a link change interrupt. */
@@ -5718,6 +5743,10 @@ bnx2_timer(unsigned long data)
         if (atomic_read(&bp->intr_sem) != 0)
                 goto bnx2_restart_timer;
 
+        if ((bp->flags & (BNX2_FLAG_USING_MSI | BNX2_FLAG_ONE_SHOT_MSI)) ==
+             BNX2_FLAG_USING_MSI)
+                bnx2_chk_missed_msi(bp);
+
         bnx2_send_heart_beat(bp);
 
         bp->stats_blk->stat_FwRxDrop =
@@ -7204,10 +7233,13 @@ static void
 poll_bnx2(struct net_device *dev)
 {
         struct bnx2 *bp = netdev_priv(dev);
+        int i;
 
-        disable_irq(bp->pdev->irq);
-        bnx2_interrupt(bp->pdev->irq, dev);
-        enable_irq(bp->pdev->irq);
+        for (i = 0; i < bp->irq_nvecs; i++) {
+                disable_irq(bp->irq_tbl[i].vector);
+                bnx2_interrupt(bp->irq_tbl[i].vector, &bp->bnx2_napi[i]);
+                enable_irq(bp->irq_tbl[i].vector);
+        }
 }
 #endif
 
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index 617d95340160..0b032c3c7b61 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -378,6 +378,9 @@ struct l2_fhdr {
  *  pci_config_l definition
  *  offset: 0000
  */
+#define BNX2_PCICFG_MSI_CONTROL                         0x00000058
+#define BNX2_PCICFG_MSI_CONTROL_ENABLE                   (1L<<16)
+
 #define BNX2_PCICFG_MISC_CONFIG                         0x00000068
 #define BNX2_PCICFG_MISC_CONFIG_TARGET_BYTE_SWAP         (1L<<2)
 #define BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP      (1L<<3)
@@ -6863,6 +6866,9 @@ struct bnx2 {
 
         u8                      num_tx_rings;
         u8                      num_rx_rings;
+
+        u32                     idle_chk_status_idx;
+
 };
 
 #define REG_RD(bp, offset)                                      \
diff --git a/drivers/net/bnx2x_init.h b/drivers/net/bnx2x_init.h
index 130927cfc75b..a6c0b3abba29 100644
--- a/drivers/net/bnx2x_init.h
+++ b/drivers/net/bnx2x_init.h
@@ -564,14 +564,15 @@ static const struct arb_line write_arb_addr[NUM_WR_Q-1] = {
 
 static void bnx2x_init_pxp(struct bnx2x *bp)
 {
+        u16 devctl;
         int r_order, w_order;
         u32 val, i;
 
         pci_read_config_word(bp->pdev,
-                             bp->pcie_cap + PCI_EXP_DEVCTL, (u16 *)&val);
-        DP(NETIF_MSG_HW, "read 0x%x from devctl\n", (u16)val);
-        w_order = ((val & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
-        r_order = ((val & PCI_EXP_DEVCTL_READRQ) >> 12);
+                             bp->pcie_cap + PCI_EXP_DEVCTL, &devctl);
+        DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
+        w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
+        r_order = ((devctl & PCI_EXP_DEVCTL_READRQ) >> 12);
 
         if (r_order > MAX_RD_ORD) {
                 DP(NETIF_MSG_HW, "read order of %d  order adjusted to %d\n",
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index fce745148ff9..600210d7eff9 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -59,8 +59,8 @@
 #include "bnx2x.h"
 #include "bnx2x_init.h"
 
-#define DRV_MODULE_VERSION      "1.45.22"
-#define DRV_MODULE_RELDATE      "2008/09/09"
+#define DRV_MODULE_VERSION      "1.45.23"
+#define DRV_MODULE_RELDATE      "2008/11/03"
 #define BNX2X_BC_VER            0x040200
 
 /* Time in jiffies before concluding the transmitter is hung */
@@ -6481,6 +6481,7 @@ load_int_disable:
         bnx2x_free_irq(bp);
 load_error:
         bnx2x_free_mem(bp);
+        bp->port.pmf = 0;
 
         /* TBD we really need to reset the chip
            if we want to recover from this */
@@ -6791,6 +6792,7 @@ unload_error:
         /* Report UNLOAD_DONE to MCP */
         if (!BP_NOMCP(bp))
                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
+        bp->port.pmf = 0;
 
         /* Free SKBs, SGEs, TPA pool and driver internals */
         bnx2x_free_skbs(bp);
@@ -10204,8 +10206,6 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return -ENOMEM;
         }
 
-        netif_carrier_off(dev);
-
         bp = netdev_priv(dev);
         bp->msglevel = debug;
 
@@ -10229,6 +10229,8 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 goto init_one_exit;
         }
 
+        netif_carrier_off(dev);
+
         bp->common.name = board_info[ent->driver_data].name;
         printk(KERN_INFO "%s: %s (%c%d) PCI-E x%d %s found at mem %lx,"
                " IRQ %d, ", dev->name, bp->common.name,
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index ade5f3f6693b..87437c788476 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -169,11 +169,14 @@ static void tlb_clear_slave(struct bonding *bond, struct slave *slave, int save_
         /* clear slave from tx_hashtbl */
         tx_hash_table = BOND_ALB_INFO(bond).tx_hashtbl;
 
-        index = SLAVE_TLB_INFO(slave).head;
-        while (index != TLB_NULL_INDEX) {
-                u32 next_index = tx_hash_table[index].next;
-                tlb_init_table_entry(&tx_hash_table[index], save_load);
-                index = next_index;
+        /* skip this if we've already freed the tx hash table */
+        if (tx_hash_table) {
+                index = SLAVE_TLB_INFO(slave).head;
+                while (index != TLB_NULL_INDEX) {
+                        u32 next_index = tx_hash_table[index].next;
+                        tlb_init_table_entry(&tx_hash_table[index], save_load);
+                        index = next_index;
+                }
         }
 
         tlb_init_slave(slave);
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 832739f38db4..a3efba59eee9 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1979,6 +1979,20 @@ void bond_destroy(struct bonding *bond)
         unregister_netdevice(bond->dev);
 }
 
+static void bond_destructor(struct net_device *bond_dev)
+{
+        struct bonding *bond = bond_dev->priv;
+
+        if (bond->wq)
+                destroy_workqueue(bond->wq);
+
+        netif_addr_lock_bh(bond_dev);
+        bond_mc_list_destroy(bond);
+        netif_addr_unlock_bh(bond_dev);
+
+        free_netdev(bond_dev);
+}
+
 /*
 * First release a slave and than destroy the bond if no more slaves iare left.
 * Must be under rtnl_lock when this function is called.
@@ -2376,6 +2390,9 @@ static void bond_miimon_commit(struct bonding *bond)
                         continue;
 
                 case BOND_LINK_DOWN:
+                        if (slave->link_failure_count < UINT_MAX)
+                                slave->link_failure_count++;
+
                         slave->link = BOND_LINK_DOWN;
 
                         if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
@@ -4550,7 +4567,7 @@ static int bond_init(struct net_device *bond_dev, struct bond_params *params)
 
         bond_set_mode_ops(bond, bond->params.mode);
 
-        bond_dev->destructor = free_netdev;
+        bond_dev->destructor = bond_destructor;
 
         /* Initialize the device options */
         bond_dev->tx_queue_len = 0;
@@ -4589,20 +4606,6 @@ static int bond_init(struct net_device *bond_dev, struct bond_params *params)
         return 0;
 }
 
-/* De-initialize device specific data.
- * Caller must hold rtnl_lock.
- */
-static void bond_deinit(struct net_device *bond_dev)
-{
-        struct bonding *bond = bond_dev->priv;
-
-        list_del(&bond->bond_list);
-
-#ifdef CONFIG_PROC_FS
-        bond_remove_proc_entry(bond);
-#endif
-}
-
 static void bond_work_cancel_all(struct bonding *bond)
 {
         write_lock_bh(&bond->lock);
@@ -4624,6 +4627,22 @@ static void bond_work_cancel_all(struct bonding *bond)
                 cancel_delayed_work(&bond->ad_work);
 }
 
+/* De-initialize device specific data.
+ * Caller must hold rtnl_lock.
+ */
+static void bond_deinit(struct net_device *bond_dev)
+{
+        struct bonding *bond = bond_dev->priv;
+
+        list_del(&bond->bond_list);
+
+        bond_work_cancel_all(bond);
+
+#ifdef CONFIG_PROC_FS
+        bond_remove_proc_entry(bond);
+#endif
+}
+
 /* Unregister and free all bond devices.
  * Caller must hold rtnl_lock.
  */
@@ -4635,9 +4654,6 @@ static void bond_free_all(void)
                 struct net_device *bond_dev = bond->dev;
 
                 bond_work_cancel_all(bond);
-                netif_addr_lock_bh(bond_dev);
-                bond_mc_list_destroy(bond);
-                netif_addr_unlock_bh(bond_dev);
                 /* Release the bonded slaves */
                 bond_release_all(bond_dev);
                 bond_destroy(bond);
diff --git a/drivers/net/chelsio/sge.c b/drivers/net/chelsio/sge.c
index d6c7d2aa761b..7092df50ff78 100644
--- a/drivers/net/chelsio/sge.c
+++ b/drivers/net/chelsio/sge.c
@@ -1035,10 +1035,6 @@ MODULE_PARM_DESC(copybreak, "Receive copy threshold");
  *      @pdev: the PCI device that received the packet
  *      @fl: the SGE free list holding the packet
  *      @len: the actual packet length, excluding any SGE padding
- *      @dma_pad: padding at beginning of buffer left by SGE DMA
- *      @skb_pad: padding to be used if the packet is copied
- *      @copy_thres: length threshold under which a packet should be copied
- *      @drop_thres: # of remaining buffers before we start dropping packets
  *
  *      Get the next packet from a free list and complete setup of the
  *      sk_buff.  If the packet is small we make a copy and recycle the
diff --git a/drivers/net/cris/eth_v10.c b/drivers/net/cris/eth_v10.c
index 65d0a9103297..7e8a63106bdf 100644
--- a/drivers/net/cris/eth_v10.c
+++ b/drivers/net/cris/eth_v10.c
@@ -32,14 +32,14 @@
 #include <linux/skbuff.h>
 #include <linux/ethtool.h>
 
-#include <asm/arch/svinto.h>/* DMA and register descriptions */
+#include <arch/svinto.h>/* DMA and register descriptions */
 #include <asm/io.h>         /* CRIS_LED_* I/O functions */
 #include <asm/irq.h>
 #include <asm/dma.h>
 #include <asm/system.h>
 #include <asm/ethernet.h>
 #include <asm/cache.h>
-#include <asm/arch/io_interface_mux.h>
+#include <arch/io_interface_mux.h>
 
 //#define ETHDEBUG
 #define D(x)
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 1ace41a13ac3..2c341f83d327 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -1307,8 +1307,10 @@ static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
         u32 fw_vers = 0;
         u32 tp_vers = 0;
 
+        spin_lock(&adapter->stats_lock);
         t3_get_fw_version(adapter, &fw_vers);
         t3_get_tp_version(adapter, &tp_vers);
+        spin_unlock(&adapter->stats_lock);
 
         strcpy(info->driver, DRV_NAME);
         strcpy(info->version, DRV_VERSION);
@@ -2699,7 +2701,7 @@ static void set_nqsets(struct adapter *adap)
         int hwports = adap->params.nports;
         int nqsets = SGE_QSETS;
 
-        if (adap->params.rev > 0) {
+        if (adap->params.rev > 0 && adap->flags & USING_MSIX) {
                 if (hwports == 2 &&
                     (hwports * nqsets > SGE_QSETS ||
                      num_cpus >= nqsets / hwports))
diff --git a/drivers/net/cxgb3/t3_hw.c b/drivers/net/cxgb3/t3_hw.c
index 968f64be3743..9a0898b0dbce 100644
--- a/drivers/net/cxgb3/t3_hw.c
+++ b/drivers/net/cxgb3/t3_hw.c
@@ -572,7 +572,7 @@ struct t3_vpd {
         u32 pad;                /* for multiple-of-4 sizing and alignment */
 };
 
-#define EEPROM_MAX_POLL   4
+#define EEPROM_MAX_POLL   40
 #define EEPROM_STAT_ADDR  0x4000
 #define VPD_BASE          0xc00
 
@@ -3690,6 +3690,12 @@ int t3_prep_adapter(struct adapter *adapter, const struct adapter_info *ai,
                         ;
 
                 pti = &port_types[adapter->params.vpd.port_type[j]];
+                if (!pti->phy_prep) {
+                        CH_ALERT(adapter, "Invalid port type index %d\n",
+                                 adapter->params.vpd.port_type[j]);
+                        return -EINVAL;
+                }
+
                 ret = pti->phy_prep(&p->phy, adapter, ai->phy_base_addr + j,
                                     ai->mdio_ops);
                 if (ret)
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 3d69fae781cf..e8bfcce6b319 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -166,7 +166,7 @@
 
 #define DRV_NAME                "e100"
 #define DRV_EXT                 "-NAPI"
-#define DRV_VERSION             "3.5.23-k4"DRV_EXT
+#define DRV_VERSION             "3.5.23-k6"DRV_EXT
 #define DRV_DESCRIPTION         "Intel(R) PRO/100 Network Driver"
 #define DRV_COPYRIGHT           "Copyright(c) 1999-2006 Intel Corporation"
 #define PFX                     DRV_NAME ": "
@@ -1804,7 +1804,7 @@ static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
                 struct rfd *prev_rfd = (struct rfd *)rx->prev->skb->data;
                 put_unaligned_le32(rx->dma_addr, &prev_rfd->link);
                 pci_dma_sync_single_for_device(nic->pdev, rx->prev->dma_addr,
-                        sizeof(struct rfd), PCI_DMA_TODEVICE);
+                        sizeof(struct rfd), PCI_DMA_BIDIRECTIONAL);
         }
 
         return 0;
@@ -1823,7 +1823,7 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx,
 
         /* Need to sync before taking a peek at cb_complete bit */
         pci_dma_sync_single_for_cpu(nic->pdev, rx->dma_addr,
-                sizeof(struct rfd), PCI_DMA_FROMDEVICE);
+                sizeof(struct rfd), PCI_DMA_BIDIRECTIONAL);
         rfd_status = le16_to_cpu(rfd->status);
 
         DPRINTK(RX_STATUS, DEBUG, "status=0x%04X\n", rfd_status);
@@ -1850,7 +1850,7 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx,
 
         /* Get data */
         pci_unmap_single(nic->pdev, rx->dma_addr,
-                RFD_BUF_LEN, PCI_DMA_FROMDEVICE);
+                RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL);
 
         /* If this buffer has the el bit, but we think the receiver
          * is still running, check to see if it really stopped while
@@ -1943,7 +1943,7 @@ static void e100_rx_clean(struct nic *nic, unsigned int *work_done,
                 new_before_last_rfd->command |= cpu_to_le16(cb_el);
                 pci_dma_sync_single_for_device(nic->pdev,
                         new_before_last_rx->dma_addr, sizeof(struct rfd),
-                        PCI_DMA_TODEVICE);
+                        PCI_DMA_BIDIRECTIONAL);
 
                 /* Now that we have a new stopping point, we can clear the old
                  * stopping point.  We must sync twice to get the proper
@@ -1951,11 +1951,11 @@ static void e100_rx_clean(struct nic *nic, unsigned int *work_done,
                 old_before_last_rfd->command &= ~cpu_to_le16(cb_el);
                 pci_dma_sync_single_for_device(nic->pdev,
                         old_before_last_rx->dma_addr, sizeof(struct rfd),
-                        PCI_DMA_TODEVICE);
+                        PCI_DMA_BIDIRECTIONAL);
                 old_before_last_rfd->size = cpu_to_le16(VLAN_ETH_FRAME_LEN);
                 pci_dma_sync_single_for_device(nic->pdev,
                         old_before_last_rx->dma_addr, sizeof(struct rfd),
-                        PCI_DMA_TODEVICE);
+                        PCI_DMA_BIDIRECTIONAL);
         }
 
         if(restart_required) {
@@ -1978,7 +1978,7 @@ static void e100_rx_clean_list(struct nic *nic)
                 for(rx = nic->rxs, i = 0; i < count; rx++, i++) {
                         if(rx->skb) {
                                 pci_unmap_single(nic->pdev, rx->dma_addr,
-                                        RFD_BUF_LEN, PCI_DMA_FROMDEVICE);
+                                        RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL);
                                 dev_kfree_skb(rx->skb);
                         }
                 }
@@ -2021,7 +2021,7 @@ static int e100_rx_alloc_list(struct nic *nic)
         before_last->command |= cpu_to_le16(cb_el);
         before_last->size = 0;
         pci_dma_sync_single_for_device(nic->pdev, rx->dma_addr,
-                sizeof(struct rfd), PCI_DMA_TODEVICE);
+                sizeof(struct rfd), PCI_DMA_BIDIRECTIONAL);
 
         nic->rx_to_use = nic->rx_to_clean = nic->rxs;
         nic->ru_running = RU_SUSPENDED;
@@ -2222,7 +2222,7 @@ static int e100_loopback_test(struct nic *nic, enum loopback loopback_mode)
         msleep(10);
 
         pci_dma_sync_single_for_cpu(nic->pdev, nic->rx_to_clean->dma_addr,
-                        RFD_BUF_LEN, PCI_DMA_FROMDEVICE);
+                        RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL);
 
         if(memcmp(nic->rx_to_clean->skb->data + sizeof(struct rfd),
            skb->data, ETH_DATA_LEN))
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index 6a3893acfe04..c854c96f5ab3 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -1774,7 +1774,8 @@ static void e1000_get_wol(struct net_device *netdev,
 
         /* this function will set ->supported = 0 and return 1 if wol is not
          * supported by this hardware */
-        if (e1000_wol_exclusion(adapter, wol))
+        if (e1000_wol_exclusion(adapter, wol) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return;
 
         /* apply any specific unsupported masks here */
@@ -1811,7 +1812,8 @@ static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
                 return -EOPNOTSUPP;
 
-        if (e1000_wol_exclusion(adapter, wol))
+        if (e1000_wol_exclusion(adapter, wol) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return wol->wolopts ? -EOPNOTSUPP : 0;
 
         switch (hw->device_id) {
@@ -1838,6 +1840,8 @@ static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & WAKE_MAGIC)
                 adapter->wol |= E1000_WUFC_MAG;
 
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
+
         return 0;
 }
 
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index fac82152e4c8..872799b746f5 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -1179,6 +1179,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
 
         /* initialize the wol settings based on the eeprom settings */
         adapter->wol = adapter->eeprom_wol;
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
         /* print bus type/speed/width info */
         DPRINTK(PROBE, INFO, "(PCI%s:%s:%s) ",
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index c55de1c027af..c55fd6fdb91c 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -299,6 +299,7 @@ struct e1000_adapter {
         unsigned long led_status;
 
         unsigned int flags;
+        unsigned int flags2;
         struct work_struct downshift_task;
         struct work_struct update_phy_task;
 };
@@ -306,6 +307,7 @@ struct e1000_adapter {
 struct e1000_info {
         enum e1000_mac_type     mac;
         unsigned int            flags;
+        unsigned int            flags2;
         u32                     pba;
         s32                     (*get_variants)(struct e1000_adapter *);
         struct e1000_mac_operations *mac_ops;
@@ -347,6 +349,9 @@ struct e1000_info {
 #define FLAG_RX_RESTART_NOW               (1 << 30)
 #define FLAG_MSI_TEST_FAILED              (1 << 31)
 
+/* CRC Stripping defines */
+#define FLAG2_CRC_STRIPPING               (1 << 0)
+
 #define E1000_RX_DESC_PS(R, i)      \
         (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
 #define E1000_GET_DESC(R, i, type)      (&(((struct type *)((R).desc))[i]))
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index 70c11c811a08..62421ce96311 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -1713,7 +1713,8 @@ static void e1000_get_wol(struct net_device *netdev,
         wol->supported = 0;
         wol->wolopts = 0;
 
-        if (!(adapter->flags & FLAG_HAS_WOL))
+        if (!(adapter->flags & FLAG_HAS_WOL) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return;
 
         wol->supported = WAKE_UCAST | WAKE_MCAST |
@@ -1751,7 +1752,8 @@ static int e1000_set_wol(struct net_device *netdev,
         if (wol->wolopts & WAKE_MAGICSECURE)
                 return -EOPNOTSUPP;
 
-        if (!(adapter->flags & FLAG_HAS_WOL))
+        if (!(adapter->flags & FLAG_HAS_WOL) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return wol->wolopts ? -EOPNOTSUPP : 0;
 
         /* these settings will always override what we currently have */
@@ -1770,6 +1772,8 @@ static int e1000_set_wol(struct net_device *netdev,
         if (wol->wolopts & WAKE_ARP)
                 adapter->wol |= E1000_WUFC_ARP;
 
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
+
         return 0;
 }
 
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 523b9716a543..d115a6d30f29 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -1893,12 +1893,17 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
                 ctrl |= E1000_CTRL_PHY_RST;
         }
         ret_val = e1000_acquire_swflag_ich8lan(hw);
+        /* Whether or not the swflag was acquired, we need to reset the part */
         hw_dbg(hw, "Issuing a global reset to ich8lan");
         ew32(CTRL, (ctrl | E1000_CTRL_RST));
         msleep(20);
 
-        /* release the swflag because it is not reset by hardware reset */
-        e1000_release_swflag_ich8lan(hw);
+        if (!ret_val) {
+                /* release the swflag because it is not reset by
+                 * hardware reset
+                 */
+                e1000_release_swflag_ich8lan(hw);
+        }
 
         ret_val = e1000e_get_auto_rd_done(hw);
         if (ret_val) {
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index abd492b7336d..122539a0e1fe 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -345,7 +345,6 @@ no_buffers:
 /**
  * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
  * @adapter: address of board private structure
- * @rx_ring: pointer to receive ring structure
  * @cleaned_count: number of buffers to allocate this pass
  **/
 
@@ -499,6 +498,10 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
                         goto next_desc;
                 }
 
+                /* adjust length to remove Ethernet CRC */
+                if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))
+                        length -= 4;
+
                 total_rx_bytes += length;
                 total_rx_packets++;
 
@@ -804,6 +807,10 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                         pci_dma_sync_single_for_device(pdev, ps_page->dma,
                                 PAGE_SIZE, PCI_DMA_FROMDEVICE);
 
+                        /* remove the CRC */
+                        if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))
+                                l1 -= 4;
+
                         skb_put(skb, l1);
                         goto copydone;
                 } /* if */
@@ -825,6 +832,12 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                         skb->truesize += length;
                 }
 
+                /* strip the ethernet crc, problem is we're using pages now so
+                 * this whole operation can get a little cpu intensive
+                 */
+                if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))
+                        pskb_trim(skb, skb->len - 4);
+
 copydone:
                 total_rx_bytes += skb->len;
                 total_rx_packets++;
@@ -2301,8 +2314,12 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         else
                 rctl |= E1000_RCTL_LPE;
 
-        /* Enable hardware CRC frame stripping */
-        rctl |= E1000_RCTL_SECRC;
+        /* Some systems expect that the CRC is included in SMBUS traffic. The
+         * hardware strips the CRC before sending to both SMBUS (BMC) and to
+         * host memory when this is enabled
+         */
+        if (adapter->flags2 & FLAG2_CRC_STRIPPING)
+                rctl |= E1000_RCTL_SECRC;
 
         /* Setup buffer sizes */
         rctl &= ~E1000_RCTL_SZ_4096;
@@ -4766,6 +4783,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         adapter->ei = ei;
         adapter->pba = ei->pba;
         adapter->flags = ei->flags;
+        adapter->flags2 = ei->flags2;
         adapter->hw.adapter = adapter;
         adapter->hw.mac.type = ei->mac;
         adapter->msg_enable = (1 << NETIF_MSG_DRV | NETIF_MSG_PROBE) - 1;
@@ -4970,6 +4988,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
 
         /* initialize the wol settings based on the eeprom settings */
         adapter->wol = adapter->eeprom_wol;
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
         /* reset the hardware with the new settings */
         e1000e_reset(adapter);
@@ -5008,6 +5027,7 @@ err_hw_init:
 err_sw_init:
         if (adapter->hw.flash_address)
                 iounmap(adapter->hw.flash_address);
+        e1000e_reset_interrupt_capability(adapter);
 err_flashmap:
         iounmap(adapter->hw.hw_addr);
 err_ioremap:
diff --git a/drivers/net/e1000e/param.c b/drivers/net/e1000e/param.c
index 77a3d7207a5f..e909f96698e8 100644
--- a/drivers/net/e1000e/param.c
+++ b/drivers/net/e1000e/param.c
@@ -151,6 +151,16 @@ E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
  */
 E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
 
+/*
+ * Enable CRC Stripping
+ *
+ * Valid Range: 0, 1
+ *
+ * Default Value: 1 (enabled)
+ */
+E1000_PARAM(CrcStripping, "Enable CRC Stripping, disable if your BMC needs " \
+                          "the CRC");
+
 struct e1000_option {
         enum { enable_option, range_option, list_option } type;
         const char *name;
@@ -404,6 +414,21 @@ void __devinit e1000e_check_options(struct e1000_adapter *adapter)
                                 adapter->flags |= FLAG_SMART_POWER_DOWN;
                 }
         }
+        { /* CRC Stripping */
+                const struct e1000_option opt = {
+                        .type = enable_option,
+                        .name = "CRC Stripping",
+                        .err  = "defaulting to enabled",
+                        .def  = OPTION_ENABLED
+                };
+
+                if (num_CrcStripping > bd) {
+                        unsigned int crc_stripping = CrcStripping[bd];
+                        e1000_validate_option(&crc_stripping, &opt, adapter);
+                        if (crc_stripping == OPTION_ENABLED)
+                                adapter->flags2 |= FLAG2_CRC_STRIPPING;
+                }
+        }
         { /* Kumeran Lock Loss Workaround */
                 const struct e1000_option opt = {
                         .type = enable_option,
diff --git a/drivers/net/ehea/ehea.h b/drivers/net/ehea/ehea.h
index 82dd1a891ce7..002d918fb4c7 100644
--- a/drivers/net/ehea/ehea.h
+++ b/drivers/net/ehea/ehea.h
@@ -40,7 +40,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "ehea"
-#define DRV_VERSION     "EHEA_0094"
+#define DRV_VERSION     "EHEA_0095"
 
 /* eHEA capability flags */
 #define DLPAR_PORT_ADD_REM 1
diff --git a/drivers/net/ehea/ehea_qmr.c b/drivers/net/ehea/ehea_qmr.c
index 9b61dc9865d1..9d006878f045 100644
--- a/drivers/net/ehea/ehea_qmr.c
+++ b/drivers/net/ehea/ehea_qmr.c
@@ -632,10 +632,13 @@ static void ehea_rebuild_busmap(void)
         }
 }
 
-static int ehea_update_busmap(unsigned long pfn, unsigned long pgnum, int add)
+static int ehea_update_busmap(unsigned long pfn, unsigned long nr_pages, int add)
 {
         unsigned long i, start_section, end_section;
 
+        if (!nr_pages)
+                return 0;
+
         if (!ehea_bmap) {
                 ehea_bmap = kzalloc(sizeof(struct ehea_bmap), GFP_KERNEL);
                 if (!ehea_bmap)
@@ -643,7 +646,7 @@ static int ehea_update_busmap(unsigned long pfn, unsigned long pgnum, int add)
         }
 
         start_section = (pfn * PAGE_SIZE) / EHEA_SECTSIZE;
-        end_section = start_section + ((pgnum * PAGE_SIZE) / EHEA_SECTSIZE);
+        end_section = start_section + ((nr_pages * PAGE_SIZE) / EHEA_SECTSIZE);
         /* Mark entries as valid or invalid only; address is assigned later */
         for (i = start_section; i < end_section; i++) {
                 u64 flag;
@@ -692,10 +695,54 @@ int ehea_rem_sect_bmap(unsigned long pfn, unsigned long nr_pages)
         return ret;
 }
 
-static int ehea_create_busmap_callback(unsigned long pfn,
-                                       unsigned long nr_pages, void *arg)
+static int ehea_is_hugepage(unsigned long pfn)
+{
+        int page_order;
+
+        if (pfn & EHEA_HUGEPAGE_PFN_MASK)
+                return 0;
+
+        page_order = compound_order(pfn_to_page(pfn));
+        if (page_order + PAGE_SHIFT != EHEA_HUGEPAGESHIFT)
+                return 0;
+
+        return 1;
+}
+
+static int ehea_create_busmap_callback(unsigned long initial_pfn,
+                                       unsigned long total_nr_pages, void *arg)
 {
-        return ehea_update_busmap(pfn, nr_pages, EHEA_BUSMAP_ADD_SECT);
+        int ret;
+        unsigned long pfn, start_pfn, end_pfn, nr_pages;
+
+        if ((total_nr_pages * PAGE_SIZE) < EHEA_HUGEPAGE_SIZE)
+                return ehea_update_busmap(initial_pfn, total_nr_pages,
+                                          EHEA_BUSMAP_ADD_SECT);
+
+        /* Given chunk is >= 16GB -> check for hugepages */
+        start_pfn = initial_pfn;
+        end_pfn = initial_pfn + total_nr_pages;
+        pfn = start_pfn;
+
+        while (pfn < end_pfn) {
+                if (ehea_is_hugepage(pfn)) {
+                        /* Add mem found in front of the hugepage */
+                        nr_pages = pfn - start_pfn;
+                        ret = ehea_update_busmap(start_pfn, nr_pages,
+                                                 EHEA_BUSMAP_ADD_SECT);
+                        if (ret)
+                                return ret;
+
+                        /* Skip the hugepage */
+                        pfn += (EHEA_HUGEPAGE_SIZE / PAGE_SIZE);
+                        start_pfn = pfn;
+                } else
+                        pfn += (EHEA_SECTSIZE / PAGE_SIZE);
+        }
+
+        /* Add mem found behind the hugepage(s)  */
+        nr_pages = pfn - start_pfn;
+        return ehea_update_busmap(start_pfn, nr_pages, EHEA_BUSMAP_ADD_SECT);
 }
 
 int ehea_create_busmap(void)
diff --git a/drivers/net/ehea/ehea_qmr.h b/drivers/net/ehea/ehea_qmr.h
index 1e58dc06b7d2..0817c1e74a19 100644
--- a/drivers/net/ehea/ehea_qmr.h
+++ b/drivers/net/ehea/ehea_qmr.h
@@ -40,6 +40,9 @@
 #define EHEA_PAGESIZE          (1UL << EHEA_PAGESHIFT)
 #define EHEA_SECTSIZE          (1UL << 24)
 #define EHEA_PAGES_PER_SECTION (EHEA_SECTSIZE >> EHEA_PAGESHIFT)
+#define EHEA_HUGEPAGESHIFT     34
+#define EHEA_HUGEPAGE_SIZE     (1UL << EHEA_HUGEPAGESHIFT)
+#define EHEA_HUGEPAGE_PFN_MASK ((EHEA_HUGEPAGE_SIZE - 1) >> PAGE_SHIFT)
 
 #if ((1UL << SECTION_SIZE_BITS) < EHEA_SECTSIZE)
 #error eHEA module cannot work if kernel sectionsize < ehea sectionsize
diff --git a/drivers/net/enc28j60.c b/drivers/net/enc28j60.c
index e1b441effbbe..36cb6e95b465 100644
--- a/drivers/net/enc28j60.c
+++ b/drivers/net/enc28j60.c
@@ -568,6 +568,17 @@ static u16 erxrdpt_workaround(u16 next_packet_ptr, u16 start, u16 end)
         return erxrdpt;
 }
 
+/*
+ * Calculate wrap around when reading beyond the end of the RX buffer
+ */
+static u16 rx_packet_start(u16 ptr)
+{
+        if (ptr + RSV_SIZE > RXEND_INIT)
+                return (ptr + RSV_SIZE) - (RXEND_INIT - RXSTART_INIT + 1);
+        else
+                return ptr + RSV_SIZE;
+}
+
 static void nolock_rxfifo_init(struct enc28j60_net *priv, u16 start, u16 end)
 {
         u16 erxrdpt;
@@ -938,8 +949,9 @@ static void enc28j60_hw_rx(struct net_device *ndev)
                         skb->dev = ndev;
                         skb_reserve(skb, NET_IP_ALIGN);
                         /* copy the packet from the receive buffer */
-                        enc28j60_mem_read(priv, priv->next_pk_ptr + sizeof(rsv),
-                                        len, skb_put(skb, len));
+                        enc28j60_mem_read(priv,
+                                rx_packet_start(priv->next_pk_ptr),
+                                len, skb_put(skb, len));
                         if (netif_msg_pktdata(priv))
                                 dump_packet(__func__, skb->len, skb->data);
                         skb->protocol = eth_type_trans(skb, ndev);
@@ -947,7 +959,7 @@ static void enc28j60_hw_rx(struct net_device *ndev)
                         ndev->stats.rx_packets++;
                         ndev->stats.rx_bytes += len;
                         ndev->last_rx = jiffies;
-                        netif_rx(skb);
+                        netif_rx_ni(skb);
                 }
         }
         /*
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index cb51c1fb0338..a6f49d025787 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -1099,7 +1099,9 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
         ndev->stop = fs_enet_close;
         ndev->get_stats = fs_enet_get_stats;
         ndev->set_multicast_list = fs_set_multicast_list;
-
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        ndev->poll_controller = fs_enet_netpoll;
+#endif
         if (fpi->use_napi)
                 netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi,
                                fpi->napi_weight);
@@ -1209,7 +1211,7 @@ static void __exit fs_cleanup(void)
 static void fs_enet_netpoll(struct net_device *dev)
 {
        disable_irq(dev->irq);
-       fs_enet_interrupt(dev->irq, dev, NULL);
+       fs_enet_interrupt(dev->irq, dev);
        enable_irq(dev->irq);
 }
 #endif
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 64b201134fdb..c4af949bf860 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -586,6 +586,18 @@ static void gfar_configure_serdes(struct net_device *dev)
         struct gfar_mii __iomem *regs =
                         (void __iomem *)&priv->regs->gfar_mii_regs;
         int tbipa = gfar_read(&priv->regs->tbipa);
+        struct mii_bus *bus = gfar_get_miibus(priv);
+
+        if (bus)
+                mutex_lock(&bus->mdio_lock);
+
+        /* If the link is already up, we must already be ok, and don't need to
+         * configure and reset the TBI<->SerDes link.  Maybe U-Boot configured
+         * everything for us?  Resetting it takes the link down and requires
+         * several seconds for it to come back.
+         */
+        if (gfar_local_mdio_read(regs, tbipa, MII_BMSR) & BMSR_LSTATUS)
+                goto done;
 
         /* Single clk mode, mii mode off(for serdes communication) */
         gfar_local_mdio_write(regs, tbipa, MII_TBICON, TBICON_CLK_SELECT);
@@ -596,6 +608,10 @@ static void gfar_configure_serdes(struct net_device *dev)
 
         gfar_local_mdio_write(regs, tbipa, MII_BMCR, BMCR_ANENABLE |
                         BMCR_ANRESTART | BMCR_FULLDPLX | BMCR_SPEED1000);
+
+        done:
+        if (bus)
+                mutex_unlock(&bus->mdio_lock);
 }
 
 static void init_registers(struct net_device *dev)
@@ -1391,6 +1407,10 @@ static int gfar_clean_tx_ring(struct net_device *dev)
                 if (bdp->status & TXBD_DEF)
                         dev->stats.collisions++;
 
+                /* Unmap the DMA memory */
+                dma_unmap_single(&priv->dev->dev, bdp->bufPtr,
+                                bdp->length, DMA_TO_DEVICE);
+
                 /* Free the sk buffer associated with this TxBD */
                 dev_kfree_skb_irq(priv->tx_skbuff[priv->skb_dirtytx]);
 
@@ -1650,6 +1670,9 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
 
                 skb = priv->rx_skbuff[priv->skb_currx];
 
+                dma_unmap_single(&priv->dev->dev, bdp->bufPtr,
+                                priv->rx_buffer_size, DMA_FROM_DEVICE);
+
                 /* We drop the frame if we failed to allocate a new buffer */
                 if (unlikely(!newskb || !(bdp->status & RXBD_LAST) ||
                                  bdp->status & RXBD_ERR)) {
@@ -1658,14 +1681,8 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
                         if (unlikely(!newskb))
                                 newskb = skb;
 
-                        if (skb) {
-                                dma_unmap_single(&priv->dev->dev,
-                                                bdp->bufPtr,
-                                                priv->rx_buffer_size,
-                                                DMA_FROM_DEVICE);
-
+                        if (skb)
                                 dev_kfree_skb_any(skb);
-                        }
                 } else {
                         /* Increment the number of packets */
                         dev->stats.rx_packets++;
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
index bf73eea98010..0e2595d24933 100644
--- a/drivers/net/gianfar_mii.c
+++ b/drivers/net/gianfar_mii.c
@@ -269,6 +269,27 @@ static struct device_driver gianfar_mdio_driver = {
         .remove = gfar_mdio_remove,
 };
 
+static int match_mdio_bus(struct device *dev, void *data)
+{
+        const struct gfar_private *priv = data;
+        const struct platform_device *pdev = to_platform_device(dev);
+
+        return !strcmp(pdev->name, gianfar_mdio_driver.name) &&
+                pdev->id == priv->einfo->mdio_bus;
+}
+
+/* Given a gfar_priv structure, find the mii_bus controlled by this device (not
+ * necessarily the same as the bus the gfar's PHY is on), if one exists.
+ * Normally only the first gianfar controls a mii_bus.  */
+struct mii_bus *gfar_get_miibus(const struct gfar_private *priv)
+{
+        /*const*/ struct device *d;
+
+        d = bus_find_device(gianfar_mdio_driver.bus, NULL, (void *)priv,
+                            match_mdio_bus);
+        return d ? dev_get_drvdata(d) : NULL;
+}
+
 int __init gfar_mdio_init(void)
 {
         return driver_register(&gianfar_mdio_driver);
diff --git a/drivers/net/gianfar_mii.h b/drivers/net/gianfar_mii.h
index 2af28b16a0e2..02dc970ca1ff 100644
--- a/drivers/net/gianfar_mii.h
+++ b/drivers/net/gianfar_mii.h
@@ -18,6 +18,8 @@
 #ifndef __GIANFAR_MII_H
 #define __GIANFAR_MII_H
 
+struct gfar_private; /* forward ref */
+
 #define MIIMIND_BUSY            0x00000001
 #define MIIMIND_NOTVALID        0x00000004
 
@@ -44,6 +46,7 @@ int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
 int gfar_local_mdio_write(struct gfar_mii __iomem *regs, int mii_id,
                           int regnum, u16 value);
 int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum);
+struct mii_bus *gfar_get_miibus(const struct gfar_private *priv);
 int __init gfar_mdio_init(void);
 void gfar_mdio_exit(void);
 #endif /* GIANFAR_PHY_H */
diff --git a/drivers/net/hp-plus.c b/drivers/net/hp-plus.c
index fbbd3e660c27..c01e290d09d2 100644
--- a/drivers/net/hp-plus.c
+++ b/drivers/net/hp-plus.c
@@ -230,7 +230,7 @@ static int __init hpp_probe1(struct net_device *dev, int ioaddr)
         dev->open = &hpp_open;
         dev->stop = &hpp_close;
 #ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = ei_poll;
+        dev->poll_controller = eip_poll;
 #endif
 
         ei_status.name = name;
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index 2ee2622258f5..901212aa37cb 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -2605,7 +2605,7 @@ static int __devinit emac_init_config(struct emac_instance *dev)
                     of_device_is_compatible(np, "ibm,emac-440gr"))
                         dev->features |= EMAC_FTR_440EP_PHY_CLK_FIX;
                 if (of_device_is_compatible(np, "ibm,emac-405ez")) {
-#ifdef CONFIG_IBM_NEW_EMAC_NO_FLOW_CONTROL
+#ifdef CONFIG_IBM_NEW_EMAC_NO_FLOW_CTRL
                         dev->features |= EMAC_FTR_NO_FLOW_CONTROL_40x;
 #else
                         printk(KERN_ERR "%s: Flow control not disabled!\n",
diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c
index 58906c984be9..89964fa739a0 100644
--- a/drivers/net/igb/igb_ethtool.c
+++ b/drivers/net/igb/igb_ethtool.c
@@ -1776,7 +1776,8 @@ static void igb_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
 
         /* this function will set ->supported = 0 and return 1 if wol is not
          * supported by this hardware */
-        if (igb_wol_exclusion(adapter, wol))
+        if (igb_wol_exclusion(adapter, wol) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return;
 
         /* apply any specific unsupported masks here */
@@ -1805,7 +1806,8 @@ static int igb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
                 return -EOPNOTSUPP;
 
-        if (igb_wol_exclusion(adapter, wol))
+        if (igb_wol_exclusion(adapter, wol) ||
+            !device_can_wakeup(&adapter->pdev->dev))
                 return wol->wolopts ? -EOPNOTSUPP : 0;
 
         switch (hw->device_id) {
@@ -1825,6 +1827,8 @@ static int igb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & WAKE_MAGIC)
                 adapter->wol |= E1000_WUFC_MAG;
 
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
+
         return 0;
 }
 
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 1f397cd99414..20d27e622ec1 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -1019,10 +1019,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                         state &= ~PCIE_LINK_STATE_L0S;
                         pci_write_config_word(us_dev, pos + PCI_EXP_LNKCTL,
                                               state);
-                        printk(KERN_INFO "Disabling ASPM L0s upstream switch "
-                               "port %x:%x.%x\n", us_dev->bus->number,
-                               PCI_SLOT(us_dev->devfn),
-                               PCI_FUNC(us_dev->devfn));
+                        dev_info(&pdev->dev,
+                                 "Disabling ASPM L0s upstream switch port %s\n",
+                                 pci_name(us_dev));
                 }
         default:
                 break;
@@ -1244,6 +1243,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
 
         /* initialize the wol settings based on the eeprom settings */
         adapter->wol = adapter->eeprom_wol;
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
         /* reset the hardware with the new settings */
         igb_reset(adapter);
@@ -1980,7 +1980,6 @@ static void igb_configure_rx(struct igb_adapter *adapter)
 
 /**
  * igb_free_tx_resources - Free Tx Resources per Queue
- * @adapter: board private structure
  * @tx_ring: Tx descriptor ring for a specific queue
  *
  * Free all transmit software resources
@@ -2033,7 +2032,6 @@ static void igb_unmap_and_free_tx_resource(struct igb_adapter *adapter,
 
 /**
  * igb_clean_tx_ring - Free Tx Buffers
- * @adapter: board private structure
  * @tx_ring: ring to be cleaned
  **/
 static void igb_clean_tx_ring(struct igb_ring *tx_ring)
@@ -2080,7 +2078,6 @@ static void igb_clean_all_tx_rings(struct igb_adapter *adapter)
 
 /**
  * igb_free_rx_resources - Free Rx Resources
- * @adapter: board private structure
  * @rx_ring: ring to clean the resources from
  *
  * Free all receive software resources
@@ -2120,7 +2117,6 @@ static void igb_free_all_rx_resources(struct igb_adapter *adapter)
 
 /**
  * igb_clean_rx_ring - Free Rx Buffers per Queue
- * @adapter: board private structure
  * @rx_ring: ring to free buffers from
  **/
 static void igb_clean_rx_ring(struct igb_ring *rx_ring)
diff --git a/drivers/net/ipg.c b/drivers/net/ipg.c
index 7373dafbb3f7..059369885be1 100644
--- a/drivers/net/ipg.c
+++ b/drivers/net/ipg.c
@@ -1112,7 +1112,7 @@ static void ipg_nic_rx_free_skb(struct net_device *dev)
                 struct ipg_rx *rxfd = sp->rxd + entry;
 
                 pci_unmap_single(sp->pdev,
-                        le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+                        le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                         sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
                 dev_kfree_skb_irq(sp->rx_buff[entry]);
                 sp->rx_buff[entry] = NULL;
@@ -1179,7 +1179,7 @@ static int ipg_nic_rx_check_error(struct net_device *dev)
                  */
                 if (sp->rx_buff[entry]) {
                         pci_unmap_single(sp->pdev,
-                                le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+                                le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                                 sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 
                         dev_kfree_skb_irq(sp->rx_buff[entry]);
@@ -1246,7 +1246,7 @@ static void ipg_nic_rx_with_start(struct net_device *dev,
         if (jumbo->found_start)
                 dev_kfree_skb_irq(jumbo->skb);
 
-        pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
+        pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
                          sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 
         skb_put(skb, sp->rxfrag_size);
@@ -1349,7 +1349,7 @@ static int ipg_nic_rx_jumbo(struct net_device *dev)
                 unsigned int entry = curr % IPG_RFDLIST_LENGTH;
                 struct ipg_rx *rxfd = sp->rxd + entry;
 
-                if (!(rxfd->rfs & le64_to_cpu(IPG_RFS_RFDDONE)))
+                if (!(rxfd->rfs & cpu_to_le64(IPG_RFS_RFDDONE)))
                         break;
 
                 switch (ipg_nic_rx_check_frame_type(dev)) {
diff --git a/drivers/net/irda/ks959-sir.c b/drivers/net/irda/ks959-sir.c
index 2482d61662a2..2e67ae015d91 100644
--- a/drivers/net/irda/ks959-sir.c
+++ b/drivers/net/irda/ks959-sir.c
@@ -118,7 +118,6 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <linux/kref.h>
 #include <linux/usb.h>
 #include <linux/device.h>
diff --git a/drivers/net/irda/ksdazzle-sir.c b/drivers/net/irda/ksdazzle-sir.c
index 1e0de93fd618..3843b5faba8b 100644
--- a/drivers/net/irda/ksdazzle-sir.c
+++ b/drivers/net/irda/ksdazzle-sir.c
@@ -82,7 +82,6 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <linux/kref.h>
 #include <linux/usb.h>
 #include <linux/device.h>
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 7548fb7360d9..5236f633ee36 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1287,13 +1287,39 @@ static void ixgbe_set_itr(struct ixgbe_adapter *adapter)
         return;
 }
 
-static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter);
+/**
+ * ixgbe_irq_disable - Mask off interrupt generation on the NIC
+ * @adapter: board private structure
+ **/
+static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
+{
+        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
+        if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
+                int i;
+                for (i = 0; i < adapter->num_msix_vectors; i++)
+                        synchronize_irq(adapter->msix_entries[i].vector);
+        } else {
+                synchronize_irq(adapter->pdev->irq);
+        }
+}
+
+/**
+ * ixgbe_irq_enable - Enable default interrupt generation settings
+ * @adapter: board private structure
+ **/
+static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
+{
+        u32 mask;
+        mask = IXGBE_EIMS_ENABLE_MASK;
+        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
+}
 
 /**
  * ixgbe_intr - legacy mode Interrupt Handler
  * @irq: interrupt number
  * @data: pointer to a network interface device structure
- * @pt_regs: CPU registers structure
  **/
 static irqreturn_t ixgbe_intr(int irq, void *data)
 {
@@ -1394,35 +1420,6 @@ static void ixgbe_free_irq(struct ixgbe_adapter *adapter)
 }
 
 /**
- * ixgbe_irq_disable - Mask off interrupt generation on the NIC
- * @adapter: board private structure
- **/
-static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
-{
-        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
-        IXGBE_WRITE_FLUSH(&adapter->hw);
-        if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
-                int i;
-                for (i = 0; i < adapter->num_msix_vectors; i++)
-                        synchronize_irq(adapter->msix_entries[i].vector);
-        } else {
-                synchronize_irq(adapter->pdev->irq);
-        }
-}
-
-/**
- * ixgbe_irq_enable - Enable default interrupt generation settings
- * @adapter: board private structure
- **/
-static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
-{
-        u32 mask;
-        mask = IXGBE_EIMS_ENABLE_MASK;
-        IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
-        IXGBE_WRITE_FLUSH(&adapter->hw);
-}
-
-/**
  * ixgbe_configure_msi_and_legacy - Initialize PIN (INTA...) and MSI interrupts
  *
  **/
@@ -2332,7 +2329,7 @@ static void ixgbe_acquire_msix_vectors(struct ixgbe_adapter *adapter,
  * Once we know the feature-set enabled for the device, we'll cache
  * the register offset the descriptor ring is assigned to.
  **/
-static void __devinit ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
+static void ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
 {
         int feature_mask = 0, rss_i;
         int i, txr_idx, rxr_idx;
@@ -2369,7 +2366,7 @@ static void __devinit ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
  * number of queues at compile-time.  The polling_netdev array is
  * intended for Multiqueue, but should work fine with a single queue.
  **/
-static int __devinit ixgbe_alloc_queues(struct ixgbe_adapter *adapter)
+static int ixgbe_alloc_queues(struct ixgbe_adapter *adapter)
 {
         int i;
 
@@ -2410,8 +2407,7 @@ err_tx_ring_allocation:
  * Attempt to configure the interrupts using the best available
  * capabilities of the hardware and the kernel.
  **/
-static int __devinit ixgbe_set_interrupt_capability(struct ixgbe_adapter
-                                                    *adapter)
+static int ixgbe_set_interrupt_capability(struct ixgbe_adapter *adapter)
 {
         int err = 0;
         int vector, v_budget;
@@ -2503,7 +2499,7 @@ static void ixgbe_reset_interrupt_capability(struct ixgbe_adapter *adapter)
  * - Hardware queue count (num_*_queues)
  *   - defined by miscellaneous hardware support/features (RSS, etc.)
  **/
-static int __devinit ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
+static int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
 {
         int err;
 
diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index 81c6cdc3851f..665e70d620fc 100644
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -912,23 +912,23 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
                 skb_put(skb, framesize);
                 skb->protocol = eth_type_trans(skb, jme->dev);
 
-                if (jme_rxsum_ok(jme, rxdesc->descwb.flags))
+                if (jme_rxsum_ok(jme, le16_to_cpu(rxdesc->descwb.flags)))
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                 else
                         skb->ip_summed = CHECKSUM_NONE;
 
-                if (rxdesc->descwb.flags & RXWBFLAG_TAGON) {
+                if (rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_TAGON)) {
                         if (jme->vlgrp) {
                                 jme->jme_vlan_rx(skb, jme->vlgrp,
-                                        le32_to_cpu(rxdesc->descwb.vlan));
+                                        le16_to_cpu(rxdesc->descwb.vlan));
                                 NET_STAT(jme).rx_bytes += 4;
                         }
                 } else {
                         jme->jme_rx(skb);
                 }
 
-                if ((le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST) ==
-                                RXWBFLAG_DEST_MUL)
+                if ((rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_DEST)) ==
+                    cpu_to_le16(RXWBFLAG_DEST_MUL))
                         ++(NET_STAT(jme).multicast);
 
                 jme->dev->last_rx = jiffies;
@@ -961,7 +961,7 @@ jme_process_receive(struct jme_adapter *jme, int limit)
                 rxdesc = rxring->desc;
                 rxdesc += i;
 
-                if ((rxdesc->descwb.flags & RXWBFLAG_OWN) ||
+                if ((rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_OWN)) ||
                 !(rxdesc->descwb.desccnt & RXWBDCNT_WBCPL))
                         goto out;
 
@@ -1763,10 +1763,9 @@ jme_expand_header(struct jme_adapter *jme, struct sk_buff *skb)
 }
 
 static int
-jme_tx_tso(struct sk_buff *skb,
-                u16 *mss, u8 *flags)
+jme_tx_tso(struct sk_buff *skb, __le16 *mss, u8 *flags)
 {
-        *mss = skb_shinfo(skb)->gso_size << TXDESC_MSS_SHIFT;
+        *mss = cpu_to_le16(skb_shinfo(skb)->gso_size << TXDESC_MSS_SHIFT);
         if (*mss) {
                 *flags |= TXFLAG_LSEN;
 
@@ -1826,11 +1825,11 @@ jme_tx_csum(struct jme_adapter *jme, struct sk_buff *skb, u8 *flags)
 }
 
 static inline void
-jme_tx_vlan(struct sk_buff *skb, u16 *vlan, u8 *flags)
+jme_tx_vlan(struct sk_buff *skb, __le16 *vlan, u8 *flags)
 {
         if (vlan_tx_tag_present(skb)) {
                 *flags |= TXFLAG_TAGON;
-                *vlan = vlan_tx_tag_get(skb);
+                *vlan = cpu_to_le16(vlan_tx_tag_get(skb));
         }
 }
 
diff --git a/drivers/net/jme.h b/drivers/net/jme.h
index f863aee6648b..3f5d91543246 100644
--- a/drivers/net/jme.h
+++ b/drivers/net/jme.h
@@ -22,7 +22,7 @@
  */
 
 #ifndef __JME_H_INCLUDED__
-#define __JME_H_INCLUDEE__
+#define __JME_H_INCLUDED__
 
 #define DRV_NAME        "jme"
 #define DRV_VERSION     "1.0.3"
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index 3b43bfd85a0f..b1ac63ab8c16 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -76,15 +76,6 @@ static int loopback_xmit(struct sk_buff *skb, struct net_device *dev)
 
         skb->protocol = eth_type_trans(skb,dev);
 
-#ifdef LOOPBACK_TSO
-        if (skb_is_gso(skb)) {
-                BUG_ON(skb->protocol != htons(ETH_P_IP));
-                BUG_ON(ip_hdr(skb)->protocol != IPPROTO_TCP);
-
-                emulate_large_send_offload(skb);
-                return 0;
-        }
-#endif
         dev->last_rx = jiffies;
 
         /* it's OK to use per_cpu_ptr() because BHs are off */
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index 42394505bb50..590039cbb146 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -70,6 +70,9 @@ static void macvlan_broadcast(struct sk_buff *skb,
         struct sk_buff *nskb;
         unsigned int i;
 
+        if (skb->protocol == htons(ETH_P_PAUSE))
+                return;
+
         for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
                 hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[i], hlist) {
                         dev = vlan->dev;
diff --git a/drivers/net/mlx4/en_main.c b/drivers/net/mlx4/en_main.c
index 1b0eebf84f76..4b9794e97a79 100644
--- a/drivers/net/mlx4/en_main.c
+++ b/drivers/net/mlx4/en_main.c
@@ -35,7 +35,6 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/netdevice.h>
-#include <linux/cpumask.h>
 
 #include <linux/mlx4/driver.h>
 #include <linux/mlx4/device.h>
diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c
index a339afbeed38..96e709d6440a 100644
--- a/drivers/net/mlx4/en_netdev.c
+++ b/drivers/net/mlx4/en_netdev.c
@@ -656,10 +656,10 @@ static int mlx4_en_start_port(struct net_device *dev)
         /* Configure port */
         err = mlx4_SET_PORT_general(mdev->dev, priv->port,
                                     priv->rx_skb_size + ETH_FCS_LEN,
-                                    mdev->profile.tx_pause,
-                                    mdev->profile.tx_ppp,
-                                    mdev->profile.rx_pause,
-                                    mdev->profile.rx_ppp);
+                                    priv->prof->tx_pause,
+                                    priv->prof->tx_ppp,
+                                    priv->prof->rx_pause,
+                                    priv->prof->rx_ppp);
         if (err) {
                 mlx4_err(mdev, "Failed setting port general configurations"
                                " for port %d, with error %d\n", priv->port, err);
@@ -706,7 +706,7 @@ tx_err:
         mlx4_en_release_rss_steer(priv);
 rx_err:
         for (i = 0; i < priv->rx_ring_num; i++)
-                mlx4_en_deactivate_rx_ring(priv, &priv->rx_ring[rx_index]);
+                mlx4_en_deactivate_rx_ring(priv, &priv->rx_ring[i]);
 cq_err:
         while (rx_index--)
                 mlx4_en_deactivate_cq(priv, &priv->rx_cq[rx_index]);
diff --git a/drivers/net/mlx4/en_params.c b/drivers/net/mlx4/en_params.c
index c2e69b1bcd0a..95706ee1c019 100644
--- a/drivers/net/mlx4/en_params.c
+++ b/drivers/net/mlx4/en_params.c
@@ -90,6 +90,7 @@ MLX4_EN_PARM_INT(rx_ring_size2, MLX4_EN_AUTO_CONF, "Rx ring size for port 2");
 int mlx4_en_get_profile(struct mlx4_en_dev *mdev)
 {
         struct mlx4_en_profile *params = &mdev->profile;
+        int i;
 
         params->rx_moder_cnt = min_t(int, rx_moder_cnt, MLX4_EN_AUTO_CONF);
         params->rx_moder_time = min_t(int, rx_moder_time, MLX4_EN_AUTO_CONF);
@@ -97,11 +98,13 @@ int mlx4_en_get_profile(struct mlx4_en_dev *mdev)
         params->rss_xor = (rss_xor != 0);
         params->rss_mask = rss_mask & 0x1f;
         params->num_lro = min_t(int, num_lro , MLX4_EN_MAX_LRO_DESCRIPTORS);
-        params->rx_pause = pprx;
-        params->rx_ppp = pfcrx;
-        params->tx_pause = pptx;
-        params->tx_ppp = pfctx;
-        if (params->rx_ppp || params->tx_ppp) {
+        for (i = 1; i <= MLX4_MAX_PORTS; i++) {
+                params->prof[i].rx_pause = pprx;
+                params->prof[i].rx_ppp = pfcrx;
+                params->prof[i].tx_pause = pptx;
+                params->prof[i].tx_ppp = pfctx;
+        }
+        if (pfcrx || pfctx) {
                 params->prof[1].tx_ring_num = MLX4_EN_TX_RING_NUM;
                 params->prof[2].tx_ring_num = MLX4_EN_TX_RING_NUM;
         } else {
@@ -407,14 +410,14 @@ static int mlx4_en_set_pauseparam(struct net_device *dev,
         struct mlx4_en_dev *mdev = priv->mdev;
         int err;
 
-        mdev->profile.tx_pause = pause->tx_pause != 0;
-        mdev->profile.rx_pause = pause->rx_pause != 0;
+        priv->prof->tx_pause = pause->tx_pause != 0;
+        priv->prof->rx_pause = pause->rx_pause != 0;
         err = mlx4_SET_PORT_general(mdev->dev, priv->port,
                                     priv->rx_skb_size + ETH_FCS_LEN,
-                                    mdev->profile.tx_pause,
-                                    mdev->profile.tx_ppp,
-                                    mdev->profile.rx_pause,
-                                    mdev->profile.rx_ppp);
+                                    priv->prof->tx_pause,
+                                    priv->prof->tx_ppp,
+                                    priv->prof->rx_pause,
+                                    priv->prof->rx_ppp);
         if (err)
                 mlx4_err(mdev, "Failed setting pause params to\n");
 
@@ -425,10 +428,9 @@ static void mlx4_en_get_pauseparam(struct net_device *dev,
                                  struct ethtool_pauseparam *pause)
 {
         struct mlx4_en_priv *priv = netdev_priv(dev);
-        struct mlx4_en_dev *mdev = priv->mdev;
 
-        pause->tx_pause = mdev->profile.tx_pause;
-        pause->rx_pause = mdev->profile.rx_pause;
+        pause->tx_pause = priv->prof->tx_pause;
+        pause->rx_pause = priv->prof->rx_pause;
 }
 
 static void mlx4_en_get_ringparam(struct net_device *dev,
diff --git a/drivers/net/mlx4/fw.c b/drivers/net/mlx4/fw.c
index be09fdb79cb8..cee199ceba2f 100644
--- a/drivers/net/mlx4/fw.c
+++ b/drivers/net/mlx4/fw.c
@@ -360,9 +360,9 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_PORT_ETH_MTU_OFFSET               0x02
 #define QUERY_PORT_WIDTH_OFFSET                 0x06
 #define QUERY_PORT_MAX_GID_PKEY_OFFSET          0x07
-#define QUERY_PORT_MAC_OFFSET                   0x08
 #define QUERY_PORT_MAX_MACVLAN_OFFSET           0x0a
 #define QUERY_PORT_MAX_VL_OFFSET                0x0b
+#define QUERY_PORT_MAC_OFFSET                   0x10
 
                 for (i = 1; i <= dev_cap->num_ports; ++i) {
                         err = mlx4_cmd_box(dev, 0, mailbox->dma, i, 0, MLX4_CMD_QUERY_PORT,
diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index 468921b8f4b6..90a0281d15ea 100644
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -753,6 +753,7 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
         struct mlx4_priv *priv = mlx4_priv(dev);
         int err;
         int port;
+        __be32 ib_port_default_caps;
 
         err = mlx4_init_uar_table(dev);
         if (err) {
@@ -852,6 +853,13 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
         }
 
         for (port = 1; port <= dev->caps.num_ports; port++) {
+                ib_port_default_caps = 0;
+                err = mlx4_get_port_ib_caps(dev, port, &ib_port_default_caps);
+                if (err)
+                        mlx4_warn(dev, "failed to get port %d default "
+                                  "ib capabilities (%d). Continuing with "
+                                  "caps = 0\n", port, err);
+                dev->caps.ib_port_def_cap[port] = ib_port_default_caps;
                 err = mlx4_SET_PORT(dev, port);
                 if (err) {
                         mlx4_err(dev, "Failed to set port %d, aborting\n",
diff --git a/drivers/net/mlx4/mlx4.h b/drivers/net/mlx4/mlx4.h
index fa431fad0eec..34c909deaff3 100644
--- a/drivers/net/mlx4/mlx4.h
+++ b/drivers/net/mlx4/mlx4.h
@@ -87,6 +87,9 @@ enum {
 
 #ifdef CONFIG_MLX4_DEBUG
 extern int mlx4_debug_level;
+#else /* CONFIG_MLX4_DEBUG */
+#define mlx4_debug_level        (0)
+#endif /* CONFIG_MLX4_DEBUG */
 
 #define mlx4_dbg(mdev, format, arg...)                                  \
         do {                                                            \
@@ -94,12 +97,6 @@ extern int mlx4_debug_level;
                         dev_printk(KERN_DEBUG, &mdev->pdev->dev, format, ## arg); \
         } while (0)
 
-#else /* CONFIG_MLX4_DEBUG */
-
-#define mlx4_dbg(mdev, format, arg...) do { (void) mdev; } while (0)
-
-#endif /* CONFIG_MLX4_DEBUG */
-
 #define mlx4_err(mdev, format, arg...) \
         dev_err(&mdev->pdev->dev, format, ## arg)
 #define mlx4_info(mdev, format, arg...) \
@@ -388,5 +385,6 @@ void mlx4_init_mac_table(struct mlx4_dev *dev, struct mlx4_mac_table *table);
 void mlx4_init_vlan_table(struct mlx4_dev *dev, struct mlx4_vlan_table *table);
 
 int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port);
+int mlx4_get_port_ib_caps(struct mlx4_dev *dev, u8 port, __be32 *caps);
 
 #endif /* MLX4_H */
diff --git a/drivers/net/mlx4/mlx4_en.h b/drivers/net/mlx4/mlx4_en.h
index 11fb17c6e97b..98ddc0811f93 100644
--- a/drivers/net/mlx4/mlx4_en.h
+++ b/drivers/net/mlx4/mlx4_en.h
@@ -322,6 +322,10 @@ struct mlx4_en_port_profile {
         u32 rx_ring_num;
         u32 tx_ring_size;
         u32 rx_ring_size;
+        u8 rx_pause;
+        u8 rx_ppp;
+        u8 tx_pause;
+        u8 tx_ppp;
 };
 
 struct mlx4_en_profile {
@@ -333,10 +337,6 @@ struct mlx4_en_profile {
         int rx_moder_cnt;
         int rx_moder_time;
         int auto_moder;
-        u8 rx_pause;
-        u8 rx_ppp;
-        u8 tx_pause;
-        u8 tx_ppp;
         u8 no_reset;
         struct mlx4_en_port_profile prof[MLX4_MAX_PORTS + 1];
 };
diff --git a/drivers/net/mlx4/port.c b/drivers/net/mlx4/port.c
index e2fdab42c4ce..0a057e5dc63b 100644
--- a/drivers/net/mlx4/port.c
+++ b/drivers/net/mlx4/port.c
@@ -258,6 +258,42 @@ out:
 }
 EXPORT_SYMBOL_GPL(mlx4_unregister_vlan);
 
+int mlx4_get_port_ib_caps(struct mlx4_dev *dev, u8 port, __be32 *caps)
+{
+        struct mlx4_cmd_mailbox *inmailbox, *outmailbox;
+        u8 *inbuf, *outbuf;
+        int err;
+
+        inmailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(inmailbox))
+                return PTR_ERR(inmailbox);
+
+        outmailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(outmailbox)) {
+                mlx4_free_cmd_mailbox(dev, inmailbox);
+                return PTR_ERR(outmailbox);
+        }
+
+        inbuf = inmailbox->buf;
+        outbuf = outmailbox->buf;
+        memset(inbuf, 0, 256);
+        memset(outbuf, 0, 256);
+        inbuf[0] = 1;
+        inbuf[1] = 1;
+        inbuf[2] = 1;
+        inbuf[3] = 1;
+        *(__be16 *) (&inbuf[16]) = cpu_to_be16(0x0015);
+        *(__be32 *) (&inbuf[20]) = cpu_to_be32(port);
+
+        err = mlx4_cmd_box(dev, inmailbox->dma, outmailbox->dma, port, 3,
+                           MLX4_CMD_MAD_IFC, MLX4_CMD_TIME_CLASS_C);
+        if (!err)
+                *caps = *(__be32 *) (outbuf + 84);
+        mlx4_free_cmd_mailbox(dev, inmailbox);
+        mlx4_free_cmd_mailbox(dev, outmailbox);
+        return err;
+}
+
 int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port)
 {
         struct mlx4_cmd_mailbox *mailbox;
@@ -273,7 +309,8 @@ int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port)
                 ((u8 *) mailbox->buf)[3] = 6;
                 ((__be16 *) mailbox->buf)[4] = cpu_to_be16(1 << 15);
                 ((__be16 *) mailbox->buf)[6] = cpu_to_be16(1 << 15);
-        }
+        } else
+                ((__be32 *) mailbox->buf)[1] = dev->caps.ib_port_def_cap[port];
         err = mlx4_cmd(dev, mailbox->dma, port, is_eth, MLX4_CMD_SET_PORT,
                        MLX4_CMD_TIME_CLASS_B);
 
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index a9c8c08044b1..e513f76f2a9f 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -899,7 +899,8 @@ static int txq_reclaim(struct tx_queue *txq, int budget, int force)
                 if (skb != NULL) {
                         if (skb_queue_len(&mp->rx_recycle) <
                                         mp->default_rx_ring_size &&
-                            skb_recycle_check(skb, mp->skb_size))
+                            skb_recycle_check(skb, mp->skb_size +
+                                        dma_get_cache_alignment() - 1))
                                 __skb_queue_head(&mp->rx_recycle, skb);
                         else
                                 dev_kfree_skb(skb);
@@ -1066,9 +1067,12 @@ static int smi_wait_ready(struct mv643xx_eth_shared_private *msp)
                 return 0;
         }
 
-        if (!wait_event_timeout(msp->smi_busy_wait, smi_is_done(msp),
-                                msecs_to_jiffies(100)))
-                return -ETIMEDOUT;
+        if (!smi_is_done(msp)) {
+                wait_event_timeout(msp->smi_busy_wait, smi_is_done(msp),
+                                   msecs_to_jiffies(100));
+                if (!smi_is_done(msp))
+                        return -ETIMEDOUT;
+        }
 
         return 0;
 }
@@ -2432,8 +2436,8 @@ static int mv643xx_eth_shared_remove(struct platform_device *pdev)
         struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
 
         if (pd == NULL || pd->shared_smi == NULL) {
-                mdiobus_free(msp->smi_bus);
                 mdiobus_unregister(msp->smi_bus);
+                mdiobus_free(msp->smi_bus);
         }
         if (msp->err_interrupt != NO_IRQ)
                 free_irq(msp->err_interrupt, msp);
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index b1556b2e404c..b37867097308 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -75,7 +75,7 @@
 #include "myri10ge_mcp.h"
 #include "myri10ge_mcp_gen_header.h"
 
-#define MYRI10GE_VERSION_STR "1.4.3-1.371"
+#define MYRI10GE_VERSION_STR "1.4.3-1.378"
 
 MODULE_DESCRIPTION("Myricom 10G driver (10GbE)");
 MODULE_AUTHOR("Maintainer: help@myri.com");
@@ -1393,6 +1393,8 @@ myri10ge_tx_done(struct myri10ge_slice_state *ss, int mcp_index)
                 if (tx->req == tx->done) {
                         tx->queue_active = 0;
                         put_be32(htonl(1), tx->send_stop);
+                        mb();
+                        mmiowb();
                 }
                 __netif_tx_unlock(dev_queue);
         }
@@ -2864,6 +2866,8 @@ again:
         if ((mgp->dev->real_num_tx_queues > 1) && tx->queue_active == 0) {
                 tx->queue_active = 1;
                 put_be32(htonl(1), tx->send_go);
+                mb();
+                mmiowb();
         }
         tx->pkt_start++;
         if ((avail - count) < MXGEFW_MAX_SEND_DESC) {
diff --git a/drivers/net/netx-eth.c b/drivers/net/netx-eth.c
index b9bed82e1d21..b289a0a2b945 100644
--- a/drivers/net/netx-eth.c
+++ b/drivers/net/netx-eth.c
@@ -401,6 +401,8 @@ static int netx_eth_drv_probe(struct platform_device *pdev)
         priv->xmac_base = priv->xc->xmac_base;
         priv->sram_base = priv->xc->sram_base;
 
+        spin_lock_init(&priv->lock);
+
         ret = pfifo_request(PFIFO_MASK(priv->id));
         if (ret) {
                 printk("unable to request PFIFO\n");
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index ebc812702903..1b6f548c4411 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -33,8 +33,8 @@
 
 #define DRV_MODULE_NAME         "niu"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "0.9"
-#define DRV_MODULE_RELDATE      "May 4, 2008"
+#define DRV_MODULE_VERSION      "1.0"
+#define DRV_MODULE_RELDATE      "Nov 14, 2008"
 
 static char version[] __devinitdata =
         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
@@ -51,8 +51,7 @@ MODULE_VERSION(DRV_MODULE_VERSION);
 #ifndef readq
 static u64 readq(void __iomem *reg)
 {
-        return (((u64)readl(reg + 0x4UL) << 32) |
-                (u64)readl(reg));
+        return ((u64) readl(reg)) | (((u64) readl(reg + 4UL)) << 32);
 }
 
 static void writeq(u64 val, void __iomem *reg)
@@ -407,7 +406,7 @@ static int esr2_set_rx_cfg(struct niu *np, unsigned long channel, u32 val)
 }
 
 /* Mode is always 10G fiber.  */
-static int serdes_init_niu(struct niu *np)
+static int serdes_init_niu_10g_fiber(struct niu *np)
 {
         struct niu_link_config *lp = &np->link_config;
         u32 tx_cfg, rx_cfg;
@@ -444,6 +443,223 @@ static int serdes_init_niu(struct niu *np)
         return 0;
 }
 
+static int serdes_init_niu_1g_serdes(struct niu *np)
+{
+        struct niu_link_config *lp = &np->link_config;
+        u16 pll_cfg, pll_sts;
+        int max_retry = 100;
+        u64 sig, mask, val;
+        u32 tx_cfg, rx_cfg;
+        unsigned long i;
+        int err;
+
+        tx_cfg = (PLL_TX_CFG_ENTX | PLL_TX_CFG_SWING_1375MV |
+                  PLL_TX_CFG_RATE_HALF);
+        rx_cfg = (PLL_RX_CFG_ENRX | PLL_RX_CFG_TERM_0P8VDDT |
+                  PLL_RX_CFG_ALIGN_ENA | PLL_RX_CFG_LOS_LTHRESH |
+                  PLL_RX_CFG_RATE_HALF);
+
+        if (np->port == 0)
+                rx_cfg |= PLL_RX_CFG_EQ_LP_ADAPTIVE;
+
+        if (lp->loopback_mode == LOOPBACK_PHY) {
+                u16 test_cfg = PLL_TEST_CFG_LOOPBACK_CML_DIS;
+
+                mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                           ESR2_TI_PLL_TEST_CFG_L, test_cfg);
+
+                tx_cfg |= PLL_TX_CFG_ENTEST;
+                rx_cfg |= PLL_RX_CFG_ENTEST;
+        }
+
+        /* Initialize PLL for 1G */
+        pll_cfg = (PLL_CFG_ENPLL | PLL_CFG_MPY_8X);
+
+        err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                         ESR2_TI_PLL_CFG_L, pll_cfg);
+        if (err) {
+                dev_err(np->device, PFX "NIU Port %d "
+                        "serdes_init_niu_1g_serdes: "
+                        "mdio write to ESR2_TI_PLL_CFG_L failed", np->port);
+                return err;
+        }
+
+        pll_sts = PLL_CFG_ENPLL;
+
+        err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                         ESR2_TI_PLL_STS_L, pll_sts);
+        if (err) {
+                dev_err(np->device, PFX "NIU Port %d "
+                        "serdes_init_niu_1g_serdes: "
+                        "mdio write to ESR2_TI_PLL_STS_L failed", np->port);
+                return err;
+        }
+
+        udelay(200);
+
+        /* Initialize all 4 lanes of the SERDES.  */
+        for (i = 0; i < 4; i++) {
+                err = esr2_set_tx_cfg(np, i, tx_cfg);
+                if (err)
+                        return err;
+        }
+
+        for (i = 0; i < 4; i++) {
+                err = esr2_set_rx_cfg(np, i, rx_cfg);
+                if (err)
+                        return err;
+        }
+
+        switch (np->port) {
+        case 0:
+                val = (ESR_INT_SRDY0_P0 | ESR_INT_DET0_P0);
+                mask = val;
+                break;
+
+        case 1:
+                val = (ESR_INT_SRDY0_P1 | ESR_INT_DET0_P1);
+                mask = val;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        while (max_retry--) {
+                sig = nr64(ESR_INT_SIGNALS);
+                if ((sig & mask) == val)
+                        break;
+
+                mdelay(500);
+        }
+
+        if ((sig & mask) != val) {
+                dev_err(np->device, PFX "Port %u signal bits [%08x] are not "
+                        "[%08x]\n", np->port, (int) (sig & mask), (int) val);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int serdes_init_niu_10g_serdes(struct niu *np)
+{
+        struct niu_link_config *lp = &np->link_config;
+        u32 tx_cfg, rx_cfg, pll_cfg, pll_sts;
+        int max_retry = 100;
+        u64 sig, mask, val;
+        unsigned long i;
+        int err;
+
+        tx_cfg = (PLL_TX_CFG_ENTX | PLL_TX_CFG_SWING_1375MV);
+        rx_cfg = (PLL_RX_CFG_ENRX | PLL_RX_CFG_TERM_0P8VDDT |
+                  PLL_RX_CFG_ALIGN_ENA | PLL_RX_CFG_LOS_LTHRESH |
+                  PLL_RX_CFG_EQ_LP_ADAPTIVE);
+
+        if (lp->loopback_mode == LOOPBACK_PHY) {
+                u16 test_cfg = PLL_TEST_CFG_LOOPBACK_CML_DIS;
+
+                mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                           ESR2_TI_PLL_TEST_CFG_L, test_cfg);
+
+                tx_cfg |= PLL_TX_CFG_ENTEST;
+                rx_cfg |= PLL_RX_CFG_ENTEST;
+        }
+
+        /* Initialize PLL for 10G */
+        pll_cfg = (PLL_CFG_ENPLL | PLL_CFG_MPY_10X);
+
+        err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                         ESR2_TI_PLL_CFG_L, pll_cfg & 0xffff);
+        if (err) {
+                dev_err(np->device, PFX "NIU Port %d "
+                        "serdes_init_niu_10g_serdes: "
+                        "mdio write to ESR2_TI_PLL_CFG_L failed", np->port);
+                return err;
+        }
+
+        pll_sts = PLL_CFG_ENPLL;
+
+        err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
+                         ESR2_TI_PLL_STS_L, pll_sts & 0xffff);
+        if (err) {
+                dev_err(np->device, PFX "NIU Port %d "
+                        "serdes_init_niu_10g_serdes: "
+                        "mdio write to ESR2_TI_PLL_STS_L failed", np->port);
+                return err;
+        }
+
+        udelay(200);
+
+        /* Initialize all 4 lanes of the SERDES.  */
+        for (i = 0; i < 4; i++) {
+                err = esr2_set_tx_cfg(np, i, tx_cfg);
+                if (err)
+                        return err;
+        }
+
+        for (i = 0; i < 4; i++) {
+                err = esr2_set_rx_cfg(np, i, rx_cfg);
+                if (err)
+                        return err;
+        }
+
+        /* check if serdes is ready */
+
+        switch (np->port) {
+        case 0:
+                mask = ESR_INT_SIGNALS_P0_BITS;
+                val = (ESR_INT_SRDY0_P0 |
+                       ESR_INT_DET0_P0 |
+                       ESR_INT_XSRDY_P0 |
+                       ESR_INT_XDP_P0_CH3 |
+                       ESR_INT_XDP_P0_CH2 |
+                       ESR_INT_XDP_P0_CH1 |
+                       ESR_INT_XDP_P0_CH0);
+                break;
+
+        case 1:
+                mask = ESR_INT_SIGNALS_P1_BITS;
+                val = (ESR_INT_SRDY0_P1 |
+                       ESR_INT_DET0_P1 |
+                       ESR_INT_XSRDY_P1 |
+                       ESR_INT_XDP_P1_CH3 |
+                       ESR_INT_XDP_P1_CH2 |
+                       ESR_INT_XDP_P1_CH1 |
+                       ESR_INT_XDP_P1_CH0);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        while (max_retry--) {
+                sig = nr64(ESR_INT_SIGNALS);
+                if ((sig & mask) == val)
+                        break;
+
+                mdelay(500);
+        }
+
+        if ((sig & mask) != val) {
+                pr_info(PFX "NIU Port %u signal bits [%08x] are not "
+                        "[%08x] for 10G...trying 1G\n",
+                        np->port, (int) (sig & mask), (int) val);
+
+                /* 10G failed, try initializing at 1G */
+                err = serdes_init_niu_1g_serdes(np);
+                if (!err) {
+                        np->flags &= ~NIU_FLAGS_10G;
+                        np->mac_xcvr = MAC_XCVR_PCS;
+                }  else {
+                        dev_err(np->device, PFX "Port %u 10G/1G SERDES "
+                                "Link Failed \n", np->port);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
 static int esr_read_rxtx_ctrl(struct niu *np, unsigned long chan, u32 *val)
 {
         int err;
@@ -1955,13 +2171,23 @@ static const struct niu_phy_ops phy_ops_10g_serdes = {
         .link_status            = link_status_10g_serdes,
 };
 
+static const struct niu_phy_ops phy_ops_10g_serdes_niu = {
+        .serdes_init            = serdes_init_niu_10g_serdes,
+        .link_status            = link_status_10g_serdes,
+};
+
+static const struct niu_phy_ops phy_ops_1g_serdes_niu = {
+        .serdes_init            = serdes_init_niu_1g_serdes,
+        .link_status            = link_status_1g_serdes,
+};
+
 static const struct niu_phy_ops phy_ops_1g_rgmii = {
         .xcvr_init              = xcvr_init_1g_rgmii,
         .link_status            = link_status_1g_rgmii,
 };
 
 static const struct niu_phy_ops phy_ops_10g_fiber_niu = {
-        .serdes_init            = serdes_init_niu,
+        .serdes_init            = serdes_init_niu_10g_fiber,
         .xcvr_init              = xcvr_init_10g,
         .link_status            = link_status_10g,
 };
@@ -1999,11 +2225,21 @@ struct niu_phy_template {
         u32                             phy_addr_base;
 };
 
-static const struct niu_phy_template phy_template_niu = {
+static const struct niu_phy_template phy_template_niu_10g_fiber = {
         .ops            = &phy_ops_10g_fiber_niu,
         .phy_addr_base  = 16,
 };
 
+static const struct niu_phy_template phy_template_niu_10g_serdes = {
+        .ops            = &phy_ops_10g_serdes_niu,
+        .phy_addr_base  = 0,
+};
+
+static const struct niu_phy_template phy_template_niu_1g_serdes = {
+        .ops            = &phy_ops_1g_serdes_niu,
+        .phy_addr_base  = 0,
+};
+
 static const struct niu_phy_template phy_template_10g_fiber = {
         .ops            = &phy_ops_10g_fiber,
         .phy_addr_base  = 8,
@@ -2183,8 +2419,25 @@ static int niu_determine_phy_disposition(struct niu *np)
         u32 phy_addr_off = 0;
 
         if (plat_type == PLAT_TYPE_NIU) {
-                tp = &phy_template_niu;
-                phy_addr_off += np->port;
+                switch (np->flags &
+                        (NIU_FLAGS_10G |
+                         NIU_FLAGS_FIBER |
+                         NIU_FLAGS_XCVR_SERDES)) {
+                case NIU_FLAGS_10G | NIU_FLAGS_XCVR_SERDES:
+                        /* 10G Serdes */
+                        tp = &phy_template_niu_10g_serdes;
+                        break;
+                case NIU_FLAGS_XCVR_SERDES:
+                        /* 1G Serdes */
+                        tp = &phy_template_niu_1g_serdes;
+                        break;
+                case NIU_FLAGS_10G | NIU_FLAGS_FIBER:
+                        /* 10G Fiber */
+                default:
+                        tp = &phy_template_niu_10g_fiber;
+                        phy_addr_off += np->port;
+                        break;
+                }
         } else {
                 switch (np->flags &
                         (NIU_FLAGS_10G |
@@ -7214,6 +7467,12 @@ static int __devinit niu_phy_type_prop_decode(struct niu *np,
                 np->flags |= NIU_FLAGS_10G;
                 np->flags &= ~NIU_FLAGS_FIBER;
                 np->mac_xcvr = MAC_XCVR_XPCS;
+        } else if (!strcmp(phy_prop, "xgsd") || !strcmp(phy_prop, "gsd")) {
+                /* 10G Serdes or 1G Serdes, default to 10G */
+                np->flags |= NIU_FLAGS_10G;
+                np->flags &= ~NIU_FLAGS_FIBER;
+                np->flags |= NIU_FLAGS_XCVR_SERDES;
+                np->mac_xcvr = MAC_XCVR_XPCS;
         } else {
                 return -EINVAL;
         }
@@ -7742,6 +8001,8 @@ static int __devinit walk_phys(struct niu *np, struct niu_parent *parent)
         u32 val;
         int err;
 
+        num_10g = num_1g = 0;
+
         if (!strcmp(np->vpd.model, NIU_ALONSO_MDL_STR) ||
             !strcmp(np->vpd.model, NIU_KIMI_MDL_STR)) {
                 num_10g = 0;
@@ -7758,6 +8019,16 @@ static int __devinit walk_phys(struct niu *np, struct niu_parent *parent)
                 parent->num_ports = 2;
                 val = (phy_encode(PORT_TYPE_10G, 0) |
                        phy_encode(PORT_TYPE_10G, 1));
+        } else if ((np->flags & NIU_FLAGS_XCVR_SERDES) &&
+                   (parent->plat_type == PLAT_TYPE_NIU)) {
+                /* this is the Monza case */
+                if (np->flags & NIU_FLAGS_10G) {
+                        val = (phy_encode(PORT_TYPE_10G, 0) |
+                               phy_encode(PORT_TYPE_10G, 1));
+                } else {
+                        val = (phy_encode(PORT_TYPE_1G, 0) |
+                               phy_encode(PORT_TYPE_1G, 1));
+                }
         } else {
                 err = fill_phy_probe_info(np, parent, info);
                 if (err)
@@ -8657,7 +8928,9 @@ static void __devinit niu_device_announce(struct niu *np)
                                 dev->name,
                                 (np->flags & NIU_FLAGS_XMAC ? "XMAC" : "BMAC"),
                                 (np->flags & NIU_FLAGS_10G ? "10G" : "1G"),
-                                (np->flags & NIU_FLAGS_FIBER ? "FIBER" : "COPPER"),
+                                (np->flags & NIU_FLAGS_FIBER ? "FIBER" :
+                                 (np->flags & NIU_FLAGS_XCVR_SERDES ? "SERDES" :
+                                  "COPPER")),
                                 (np->mac_xcvr == MAC_XCVR_MII ? "MII" :
                                  (np->mac_xcvr == MAC_XCVR_PCS ? "PCS" : "XPCS")),
                                 np->vpd.phy_type);
@@ -8667,7 +8940,6 @@ static void __devinit niu_device_announce(struct niu *np)
 static int __devinit niu_pci_init_one(struct pci_dev *pdev,
                                       const struct pci_device_id *ent)
 {
-        unsigned long niureg_base, niureg_len;
         union niu_parent_id parent_id;
         struct net_device *dev;
         struct niu *np;
@@ -8758,10 +9030,7 @@ static int __devinit niu_pci_init_one(struct pci_dev *pdev,
 
         dev->features |= (NETIF_F_SG | NETIF_F_HW_CSUM);
 
-        niureg_base = pci_resource_start(pdev, 0);
-        niureg_len = pci_resource_len(pdev, 0);
-
-        np->regs = ioremap_nocache(niureg_base, niureg_len);
+        np->regs = pci_ioremap_bar(pdev, 0);
         if (!np->regs) {
                 dev_err(&pdev->dev, PFX "Cannot map device registers, "
                         "aborting.\n");
diff --git a/drivers/net/niu.h b/drivers/net/niu.h
index c6fa883daa22..180ca8ae93de 100644
--- a/drivers/net/niu.h
+++ b/drivers/net/niu.h
@@ -1048,6 +1048,13 @@
 #define  PLL_CFG_LD_SHIFT               8
 #define  PLL_CFG_MPY                    0x0000001e
 #define  PLL_CFG_MPY_SHIFT              1
+#define  PLL_CFG_MPY_4X         0x0
+#define  PLL_CFG_MPY_5X         0x00000002
+#define  PLL_CFG_MPY_6X         0x00000004
+#define  PLL_CFG_MPY_8X         0x00000008
+#define  PLL_CFG_MPY_10X                0x0000000a
+#define  PLL_CFG_MPY_12X                0x0000000c
+#define  PLL_CFG_MPY_12P5X              0x0000000e
 #define  PLL_CFG_ENPLL                  0x00000001
 
 #define ESR2_TI_PLL_STS_L               (ESR2_BASE + 0x002)
@@ -1093,6 +1100,9 @@
 #define  PLL_TX_CFG_INVPAIR             0x00000080
 #define  PLL_TX_CFG_RATE                0x00000060
 #define  PLL_TX_CFG_RATE_SHIFT          5
+#define  PLL_TX_CFG_RATE_FULL           0x0
+#define  PLL_TX_CFG_RATE_HALF           0x20
+#define  PLL_TX_CFG_RATE_QUAD           0x40
 #define  PLL_TX_CFG_BUSWIDTH            0x0000001c
 #define  PLL_TX_CFG_BUSWIDTH_SHIFT      2
 #define  PLL_TX_CFG_ENTEST              0x00000002
@@ -1132,6 +1142,9 @@
 #define  PLL_RX_CFG_INVPAIR             0x00000080
 #define  PLL_RX_CFG_RATE                0x00000060
 #define  PLL_RX_CFG_RATE_SHIFT          5
+#define  PLL_RX_CFG_RATE_FULL           0x0
+#define  PLL_RX_CFG_RATE_HALF           0x20
+#define  PLL_RX_CFG_RATE_QUAD           0x40
 #define  PLL_RX_CFG_BUSWIDTH            0x0000001c
 #define  PLL_RX_CFG_BUSWIDTH_SHIFT      2
 #define  PLL_RX_CFG_ENTEST              0x00000002
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index b37a498939ae..0418045166c3 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -779,6 +779,7 @@ static struct pcmcia_device_id axnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
         PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
+        PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
@@ -1174,7 +1175,6 @@ static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
  * ax_interrupt - handle the interrupts from an 8390
  * @irq: interrupt number
  * @dev_id: a pointer to the net_device
- * @regs: unused
  *
  * Handle the ether interface interrupts. We pull packets from
  * the 8390 via the card specific functions and fire them at the networking
diff --git a/drivers/net/pcmcia/ibmtr_cs.c b/drivers/net/pcmcia/ibmtr_cs.c
index cf3cca4642f2..f51944b28cfa 100644
--- a/drivers/net/pcmcia/ibmtr_cs.c
+++ b/drivers/net/pcmcia/ibmtr_cs.c
@@ -349,7 +349,7 @@ static int ibmtr_suspend(struct pcmcia_device *link)
         return 0;
 }
 
-static int ibmtr_resume(struct pcmcia_device *link)
+static int __devinit ibmtr_resume(struct pcmcia_device *link)
 {
         ibmtr_dev_t *info = link->priv;
         struct net_device *dev = info->dev;
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index e40d6301aa7a..ce486f094492 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1693,7 +1693,6 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("National Semiconductor", "InfoMover NE4100", 0x36e1191f, 0xa6617ec8),
         PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J12", 0x18df0ba0, 0xbc912d76),
         PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA410TX", 0x9aa79dc3, 0x60e5bc0e),
-        PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
         PCMCIA_DEVICE_PROD_ID12("Network Everywhere", "Fast Ethernet 10/100 PC Card", 0x820a67b6, 0x31ed1a5f),
         PCMCIA_DEVICE_PROD_ID12("NextCom K.K.", "Next Hawk", 0xaedaec74, 0xad050ef1),
         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "10/100Mbps Ethernet Card", 0x281f1c5d, 0x6e41773b),
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index 4aa547947040..eb6411c4694f 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -227,6 +227,59 @@ static int m88e1111_config_init(struct phy_device *phydev)
         return 0;
 }
 
+static int m88e1118_config_aneg(struct phy_device *phydev)
+{
+        int err;
+
+        err = phy_write(phydev, MII_BMCR, BMCR_RESET);
+        if (err < 0)
+                return err;
+
+        err = phy_write(phydev, MII_M1011_PHY_SCR,
+                        MII_M1011_PHY_SCR_AUTO_CROSS);
+        if (err < 0)
+                return err;
+
+        err = genphy_config_aneg(phydev);
+        return 0;
+}
+
+static int m88e1118_config_init(struct phy_device *phydev)
+{
+        int err;
+
+        /* Change address */
+        err = phy_write(phydev, 0x16, 0x0002);
+        if (err < 0)
+                return err;
+
+        /* Enable 1000 Mbit */
+        err = phy_write(phydev, 0x15, 0x1070);
+        if (err < 0)
+                return err;
+
+        /* Change address */
+        err = phy_write(phydev, 0x16, 0x0003);
+        if (err < 0)
+                return err;
+
+        /* Adjust LED Control */
+        err = phy_write(phydev, 0x10, 0x021e);
+        if (err < 0)
+                return err;
+
+        /* Reset address */
+        err = phy_write(phydev, 0x16, 0x0);
+        if (err < 0)
+                return err;
+
+        err = phy_write(phydev, MII_BMCR, BMCR_RESET);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
 static int m88e1145_config_init(struct phy_device *phydev)
 {
         int err;
@@ -416,6 +469,19 @@ static struct phy_driver marvell_drivers[] = {
                 .driver = { .owner = THIS_MODULE },
         },
         {
+                .phy_id = 0x01410e10,
+                .phy_id_mask = 0xfffffff0,
+                .name = "Marvell 88E1118",
+                .features = PHY_GBIT_FEATURES,
+                .flags = PHY_HAS_INTERRUPT,
+                .config_init = &m88e1118_config_init,
+                .config_aneg = &m88e1118_config_aneg,
+                .read_status = &genphy_read_status,
+                .ack_interrupt = &marvell_ack_interrupt,
+                .config_intr = &marvell_config_intr,
+                .driver = {.owner = THIS_MODULE,},
+        },
+        {
                 .phy_id = 0x01410cd0,
                 .phy_id_mask = 0xfffffff0,
                 .name = "Marvell 88E1145",
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index d0ed1ef284a8..289fc267edf3 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -105,8 +105,6 @@ int mdiobus_register(struct mii_bus *bus)
                 return -EINVAL;
         }
 
-        bus->state = MDIOBUS_REGISTERED;
-
         mutex_init(&bus->mdio_lock);
 
         if (bus->reset)
@@ -123,6 +121,9 @@ int mdiobus_register(struct mii_bus *bus)
                 }
         }
 
+        if (!err)
+                bus->state = MDIOBUS_REGISTERED;
+
         pr_info("%s: probed\n", bus->name);
 
         return err;
@@ -136,7 +137,7 @@ void mdiobus_unregister(struct mii_bus *bus)
         BUG_ON(bus->state != MDIOBUS_REGISTERED);
         bus->state = MDIOBUS_UNREGISTERED;
 
-        device_unregister(&bus->dev);
+        device_del(&bus->dev);
         for (i = 0; i < PHY_MAX_ADDR; i++) {
                 if (bus->phy_map[i])
                         device_unregister(&bus->phy_map[i]->dev);
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index e11b03b2b25a..25acbbde4a60 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -227,8 +227,17 @@ struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
         if (r)
                 return ERR_PTR(r);
 
-        /* If the phy_id is all Fs, there is no device there */
-        if (0xffffffff == phy_id)
+        /* If the phy_id is mostly Fs, there is no device there */
+        if ((phy_id & 0x1fffffff) == 0x1fffffff)
+                return NULL;
+
+        /*
+         * Broken hardware is sometimes missing the pull down resistor on the
+         * MDIO line, which results in reads to non-existent devices returning
+         * 0 rather than 0xffff. Catch this here and treat 0 as a non-existent
+         * device as well.
+         */
+        if (phy_id == 0)
                 return NULL;
 
         dev = phy_device_create(bus, addr, phy_id);
@@ -564,20 +573,32 @@ EXPORT_SYMBOL(genphy_restart_aneg);
  */
 int genphy_config_aneg(struct phy_device *phydev)
 {
-        int result = 0;
+        int result;
 
-        if (AUTONEG_ENABLE == phydev->autoneg) {
-                int result = genphy_config_advert(phydev);
+        if (AUTONEG_ENABLE != phydev->autoneg)
+                return genphy_setup_forced(phydev);
 
-                if (result < 0) /* error */
-                        return result;
+        result = genphy_config_advert(phydev);
+
+        if (result < 0) /* error */
+                return result;
+
+        if (result == 0) {
+                /* Advertisment hasn't changed, but maybe aneg was never on to
+                 * begin with?  Or maybe phy was isolated? */
+                int ctl = phy_read(phydev, MII_BMCR);
+
+                if (ctl < 0)
+                        return ctl;
+
+                if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
+                        result = 1; /* do restart aneg */
+        }
 
-                /* Only restart aneg if we are advertising something different
-                 * than we were before.  */
-                if (result > 0)
-                        result = genphy_restart_aneg(phydev);
-        } else
-                result = genphy_setup_forced(phydev);
+        /* Only restart aneg if we are advertising something different
+         * than we were before.  */
+        if (result > 0)
+                result = genphy_restart_aneg(phydev);
 
         return result;
 }
diff --git a/drivers/net/phy/vitesse.c b/drivers/net/phy/vitesse.c
index 8874497b6bbf..dd3b2447e85a 100644
--- a/drivers/net/phy/vitesse.c
+++ b/drivers/net/phy/vitesse.c
@@ -34,6 +34,8 @@
 #define MII_VSC8244_IMASK_DUPLEX        0x1000
 #define MII_VSC8244_IMASK_MASK          0xf000
 
+#define MII_VSC8221_IMASK_MASK          0xa000
+
 /* Vitesse Interrupt Status Register */
 #define MII_VSC8244_ISTAT               0x1a
 #define MII_VSC8244_ISTAT_STATUS        0x8000
@@ -49,6 +51,12 @@
 #define MII_VSC8244_AUXCONSTAT_GBIT     0x0010
 #define MII_VSC8244_AUXCONSTAT_100      0x0008
 
+#define MII_VSC8221_AUXCONSTAT_INIT     0x0004 /* need to set this bit? */
+#define MII_VSC8221_AUXCONSTAT_RESERVED 0x0004
+
+#define PHY_ID_VSC8244                  0x000fc6c0
+#define PHY_ID_VSC8221                  0x000fc550
+
 MODULE_DESCRIPTION("Vitesse PHY driver");
 MODULE_AUTHOR("Kriston Carson");
 MODULE_LICENSE("GPL");
@@ -95,13 +103,15 @@ static int vsc824x_ack_interrupt(struct phy_device *phydev)
         return (err < 0) ? err : 0;
 }
 
-static int vsc824x_config_intr(struct phy_device *phydev)
+static int vsc82xx_config_intr(struct phy_device *phydev)
 {
         int err;
 
         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
                 err = phy_write(phydev, MII_VSC8244_IMASK,
-                                MII_VSC8244_IMASK_MASK);
+                        phydev->drv->phy_id == PHY_ID_VSC8244 ?
+                                MII_VSC8244_IMASK_MASK :
+                                MII_VSC8221_IMASK_MASK);
         else {
                 /*
                  * The Vitesse PHY cannot clear the interrupt
@@ -120,7 +130,7 @@ static int vsc824x_config_intr(struct phy_device *phydev)
 
 /* Vitesse 824x */
 static struct phy_driver vsc8244_driver = {
-        .phy_id         = 0x000fc6c0,
+        .phy_id         = PHY_ID_VSC8244,
         .name           = "Vitesse VSC8244",
         .phy_id_mask    = 0x000fffc0,
         .features       = PHY_GBIT_FEATURES,
@@ -129,19 +139,55 @@ static struct phy_driver vsc8244_driver = {
         .config_aneg    = &genphy_config_aneg,
         .read_status    = &genphy_read_status,
         .ack_interrupt  = &vsc824x_ack_interrupt,
-        .config_intr    = &vsc824x_config_intr,
+        .config_intr    = &vsc82xx_config_intr,
         .driver         = { .owner = THIS_MODULE,},
 };
 
-static int __init vsc8244_init(void)
+static int vsc8221_config_init(struct phy_device *phydev)
 {
-        return phy_driver_register(&vsc8244_driver);
+        int err;
+
+        err = phy_write(phydev, MII_VSC8244_AUX_CONSTAT,
+                        MII_VSC8221_AUXCONSTAT_INIT);
+        return err;
+
+        /* Perhaps we should set EXT_CON1 based on the interface?
+           Options are 802.3Z SerDes or SGMII */
+}
+
+/* Vitesse 8221 */
+static struct phy_driver vsc8221_driver = {
+        .phy_id         = PHY_ID_VSC8221,
+        .phy_id_mask    = 0x000ffff0,
+        .name           = "Vitesse VSC8221",
+        .features       = PHY_GBIT_FEATURES,
+        .flags          = PHY_HAS_INTERRUPT,
+        .config_init    = &vsc8221_config_init,
+        .config_aneg    = &genphy_config_aneg,
+        .read_status    = &genphy_read_status,
+        .ack_interrupt  = &vsc824x_ack_interrupt,
+        .config_intr    = &vsc82xx_config_intr,
+        .driver         = { .owner = THIS_MODULE,},
+};
+
+static int __init vsc82xx_init(void)
+{
+        int err;
+
+        err = phy_driver_register(&vsc8244_driver);
+        if (err < 0)
+                return err;
+        err = phy_driver_register(&vsc8221_driver);
+        if (err < 0)
+                phy_driver_unregister(&vsc8244_driver);
+        return err;
 }
 
-static void __exit vsc8244_exit(void)
+static void __exit vsc82xx_exit(void)
 {
         phy_driver_unregister(&vsc8244_driver);
+        phy_driver_unregister(&vsc8221_driver);
 }
 
-module_init(vsc8244_init);
-module_exit(vsc8244_exit);
+module_init(vsc82xx_init);
+module_exit(vsc82xx_exit);
diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
index fc6f4b8c64b3..b646e92134dc 100644
--- a/drivers/net/pppoe.c
+++ b/drivers/net/pppoe.c
@@ -399,11 +399,11 @@ static int pppoe_rcv(struct sk_buff *skb,
         if (skb->len < len)
                 goto drop;
 
-        po = get_item(ph->sid, eth_hdr(skb)->h_source, dev->ifindex);
-        if (!po)
+        if (pskb_trim_rcsum(skb, len))
                 goto drop;
 
-        if (pskb_trim_rcsum(skb, len))
+        po = get_item(ph->sid, eth_hdr(skb)->h_source, dev->ifindex);
+        if (!po)
                 goto drop;
 
         return sk_receive_skb(sk_pppox(po), skb, 0);
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c
index 185b1dff10a8..e98d9773158d 100644
--- a/drivers/net/pppol2tp.c
+++ b/drivers/net/pppol2tp.c
@@ -1353,6 +1353,7 @@ static int pppol2tp_release(struct socket *sock)
                         kfree_skb(skb);
                         sock_put(sk);
                 }
+                sock_put(sk);
         }
 
         release_sock(sk);
diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index 3cdd07c45b6d..508452c02151 100644
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -1515,9 +1515,6 @@ static u32 ql_get_link_state(struct ql3_adapter *qdev)
                 linkState = LS_UP;
         } else {
                 linkState = LS_DOWN;
-                if (netif_msg_link(qdev))
-                        printk(KERN_WARNING PFX
-                               "%s: Link is down.\n", qdev->ndev->name);
         }
         return linkState;
 }
@@ -1581,10 +1578,6 @@ static int ql_finish_auto_neg(struct ql3_adapter *qdev)
                         ql_mac_enable(qdev, 1);
                 }
 
-                if (netif_msg_link(qdev))
-                        printk(KERN_DEBUG PFX
-                               "%s: Change port_link_state LS_DOWN to LS_UP.\n",
-                               qdev->ndev->name);
                 qdev->port_link_state = LS_UP;
                 netif_start_queue(qdev->ndev);
                 netif_carrier_on(qdev->ndev);
@@ -1655,14 +1648,9 @@ static void ql_link_state_machine_work(struct work_struct *work)
                 /* Fall Through */
 
         case LS_DOWN:
-                if (netif_msg_link(qdev))
-                        printk(KERN_DEBUG PFX
-                               "%s: port_link_state = LS_DOWN.\n",
-                               qdev->ndev->name);
                 if (curr_link_state == LS_UP) {
                         if (netif_msg_link(qdev))
-                                printk(KERN_DEBUG PFX
-                                       "%s: curr_link_state = LS_UP.\n",
+                                printk(KERN_INFO PFX "%s: Link is up.\n",
                                        qdev->ndev->name);
                         if (ql_is_auto_neg_complete(qdev))
                                 ql_finish_auto_neg(qdev);
@@ -1670,6 +1658,7 @@ static void ql_link_state_machine_work(struct work_struct *work)
                         if (qdev->port_link_state == LS_UP)
                                 ql_link_down_detect_clear(qdev);
 
+                        qdev->port_link_state = LS_UP;
                 }
                 break;
 
@@ -1678,12 +1667,14 @@ static void ql_link_state_machine_work(struct work_struct *work)
                  * See if the link is currently down or went down and came
                  * back up
                  */
-                if ((curr_link_state == LS_DOWN) || ql_link_down_detect(qdev)) {
+                if (curr_link_state == LS_DOWN) {
                         if (netif_msg_link(qdev))
                                 printk(KERN_INFO PFX "%s: Link is down.\n",
                                        qdev->ndev->name);
                         qdev->port_link_state = LS_DOWN;
                 }
+                if (ql_link_down_detect(qdev))
+                        qdev->port_link_state = LS_DOWN;
                 break;
         }
         spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index fa98af58223e..cd0d0873d978 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -174,8 +174,8 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
 
 /* EEPROM range with gPXE configuration */
 #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
-#define EFX_ETHTOOL_EEPROM_MIN 0x100U
-#define EFX_ETHTOOL_EEPROM_MAX 0x400U
+#define EFX_ETHTOOL_EEPROM_MIN 0x800U
+#define EFX_ETHTOOL_EEPROM_MAX 0x1800U
 
 /**************************************************************************
  *
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index a24bb68887ab..59f242a67714 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -927,7 +927,7 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         struct sh_eth_private *mdp = netdev_priv(ndev);
         struct sh_eth_txdesc *txdesc;
         u32 entry;
-        int flags;
+        unsigned long flags;
 
         spin_lock_irqsave(&mdp->lock, flags);
         if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
@@ -1141,7 +1141,7 @@ static int sh_mdio_init(struct net_device *ndev, int id)
         /* Hook up MII support for ethtool */
         mdp->mii_bus->name = "sh_mii";
         mdp->mii_bus->parent = &ndev->dev;
-        mdp->mii_bus->id[0] = id;
+        snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%x", id);
 
         /* PHY IRQ */
         mdp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index fa3a460f8e2f..8e8337e8b072 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -1630,7 +1630,6 @@ sis900_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
  *      sis900_interrupt - sis900 interrupt handler
  *      @irq: the irq number
  *      @dev_instance: the client data object
- *      @regs: snapshot of processor context
  *
  *      The interrupt handler does all of the Rx thread work,
  *      and cleans up after the Tx thread
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index f59c7772f344..9a16a79b67d0 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -499,7 +499,7 @@ static void smc911x_hardware_send_pkt(struct net_device *dev)
 #else
         SMC_PUSH_DATA(lp, buf, len);
         dev->trans_start = jiffies;
-        dev_kfree_skb(skb);
+        dev_kfree_skb_irq(skb);
 #endif
         if (!lp->tx_throttle) {
                 netif_wake_queue(dev);
@@ -1735,7 +1735,7 @@ static const struct ethtool_ops smc911x_ethtool_ops = {
  * This routine has a simple purpose -- make the SMC chip generate an
  * interrupt, so an auto-detect routine can detect it, and find the IRQ,
  */
-static int __init smc911x_findirq(struct net_device *dev)
+static int __devinit smc911x_findirq(struct net_device *dev)
 {
         struct smc911x_local *lp = netdev_priv(dev);
         int timeout = 20;
@@ -1799,7 +1799,7 @@ static int __init smc911x_findirq(struct net_device *dev)
  * o  actually GRAB the irq.
  * o  GRAB the region
  */
-static int __init smc911x_probe(struct net_device *dev)
+static int __devinit smc911x_probe(struct net_device *dev)
 {
         struct smc911x_local *lp = netdev_priv(dev);
         int i, retval;
@@ -1813,7 +1813,7 @@ static int __init smc911x_probe(struct net_device *dev)
         val = SMC_GET_BYTE_TEST(lp);
         DBG(SMC_DEBUG_MISC, "%s: endian probe returned 0x%04x\n", CARDNAME, val);
         if (val != 0x87654321) {
-                printk(KERN_ERR "Invalid chip endian 0x08%x\n",val);
+                printk(KERN_ERR "Invalid chip endian 0x%08x\n",val);
                 retval = -ENODEV;
                 goto err_out;
         }
@@ -2048,9 +2048,11 @@ err_out:
  *       0 --> there is a device
  *       anything else, error
  */
-static int smc911x_drv_probe(struct platform_device *pdev)
+static int __devinit smc911x_drv_probe(struct platform_device *pdev)
 {
+#ifdef SMC_DYNAMIC_BUS_CONFIG
         struct smc911x_platdata *pd = pdev->dev.platform_data;
+#endif
         struct net_device *ndev;
         struct resource *res;
         struct smc911x_local *lp;
@@ -2122,7 +2124,7 @@ out:
         return ret;
 }
 
-static int smc911x_drv_remove(struct platform_device *pdev)
+static int __devexit smc911x_drv_remove(struct platform_device *pdev)
 {
         struct net_device *ndev = platform_get_drvdata(pdev);
         struct smc911x_local *lp = netdev_priv(ndev);
@@ -2182,9 +2184,9 @@ static int smc911x_drv_resume(struct platform_device *dev)
 
                 if (netif_running(ndev)) {
                         smc911x_reset(ndev);
-                        smc911x_enable(ndev);
                         if (lp->phy_type != 0)
                                 smc911x_phy_configure(&lp->phy_configure);
+                        smc911x_enable(ndev);
                         netif_device_attach(ndev);
                 }
         }
@@ -2193,7 +2195,7 @@ static int smc911x_drv_resume(struct platform_device *dev)
 
 static struct platform_driver smc911x_driver = {
         .probe           = smc911x_drv_probe,
-        .remove  = smc911x_drv_remove,
+        .remove  = __devexit_p(smc911x_drv_remove),
         .suspend         = smc911x_drv_suspend,
         .resume  = smc911x_drv_resume,
         .driver  = {
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index c70870e0fd61..35c56abf4113 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1696,7 +1696,7 @@ static const struct ethtool_ops smc_ethtool_ops = {
  * I just deleted auto_irq.c, since it was never built...
  *   --jgarzik
  */
-static int __init smc_findirq(struct smc_local *lp)
+static int __devinit smc_findirq(struct smc_local *lp)
 {
         void __iomem *ioaddr = lp->base;
         int timeout = 20;
@@ -1770,7 +1770,7 @@ static int __init smc_findirq(struct smc_local *lp)
  * o  actually GRAB the irq.
  * o  GRAB the region
  */
-static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
+static int __devinit smc_probe(struct net_device *dev, void __iomem *ioaddr,
                             unsigned long irq_flags)
 {
         struct smc_local *lp = netdev_priv(dev);
@@ -2060,7 +2060,7 @@ static int smc_request_attrib(struct platform_device *pdev,
                               struct net_device *ndev)
 {
         struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib");
-        struct smc_local *lp = netdev_priv(ndev);
+        struct smc_local *lp __maybe_unused = netdev_priv(ndev);
 
         if (!res)
                 return 0;
@@ -2075,7 +2075,7 @@ static void smc_release_attrib(struct platform_device *pdev,
                                struct net_device *ndev)
 {
         struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib");
-        struct smc_local *lp = netdev_priv(ndev);
+        struct smc_local *lp __maybe_unused = netdev_priv(ndev);
 
         if (res)
                 release_mem_region(res->start, ATTRIB_SIZE);
@@ -2126,7 +2126,7 @@ static void smc_release_datacs(struct platform_device *pdev, struct net_device *
  *      0 --> there is a device
  *      anything else, error
  */
-static int smc_drv_probe(struct platform_device *pdev)
+static int __devinit smc_drv_probe(struct platform_device *pdev)
 {
         struct smc91x_platdata *pd = pdev->dev.platform_data;
         struct smc_local *lp;
@@ -2240,7 +2240,7 @@ static int smc_drv_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int smc_drv_remove(struct platform_device *pdev)
+static int __devexit smc_drv_remove(struct platform_device *pdev)
 {
         struct net_device *ndev = platform_get_drvdata(pdev);
         struct smc_local *lp = netdev_priv(ndev);
@@ -2305,7 +2305,7 @@ static int smc_drv_resume(struct platform_device *dev)
 
 static struct platform_driver smc_driver = {
         .probe          = smc_drv_probe,
-        .remove         = smc_drv_remove,
+        .remove         = __devexit_p(smc_drv_remove),
         .suspend        = smc_drv_suspend,
         .resume         = smc_drv_resume,
         .driver         = {
diff --git a/drivers/net/spider_net.c b/drivers/net/spider_net.c
index b6435d0d71f9..07599b492359 100644
--- a/drivers/net/spider_net.c
+++ b/drivers/net/spider_net.c
@@ -672,7 +672,6 @@ write_hash:
 /**
  * spider_net_prepare_tx_descr - fill tx descriptor with skb data
  * @card: card structure
- * @descr: descriptor structure to fill out
  * @skb: packet to use
  *
  * returns 0 on success, <0 on failure.
@@ -867,7 +866,6 @@ spider_net_release_tx_chain(struct spider_net_card *card, int brutal)
 /**
  * spider_net_kick_tx_dma - enables TX DMA processing
  * @card: card structure
- * @descr: descriptor address to enable TX processing at
  *
  * This routine will start the transmit DMA running if
  * it is not already running. This routine ned only be
@@ -1637,7 +1635,6 @@ spider_net_handle_error_irq(struct spider_net_card *card, u32 status_reg,
  * spider_net_interrupt - interrupt handler for spider_net
  * @irq: interrupt number
  * @ptr: pointer to net_device
- * @regs: PU registers
  *
  * returns IRQ_HANDLED, if interrupt was for driver, or IRQ_NONE, if no
  * interrupt found raised by card.
@@ -2419,7 +2416,6 @@ spider_net_undo_pci_setup(struct spider_net_card *card)
 
 /**
  * spider_net_setup_pci_dev - sets up the device in terms of PCI operations
- * @card: card structure
  * @pdev: PCI device
  *
  * Returns the card structure or NULL if any errors occur
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index 1d2ef8f47780..5a40f2d78beb 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -1509,6 +1509,11 @@ static int __netdev_rx(struct net_device *dev, int *quota)
                 desc->status = 0;
                 np->rx_done = (np->rx_done + 1) % DONE_Q_SIZE;
         }
+
+        if (*quota == 0) {      /* out of rx quota */
+                retcode = 1;
+                goto out;
+        }
         writew(np->rx_done, np->base + CompletionQConsumerIdx);
 
  out:
diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index 4291458955ef..fed7eba65ead 100644
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -1142,6 +1142,70 @@ static int gem_start_xmit(struct sk_buff *skb, struct net_device *dev)
         return NETDEV_TX_OK;
 }
 
+static void gem_pcs_reset(struct gem *gp)
+{
+        int limit;
+        u32 val;
+
+        /* Reset PCS unit. */
+        val = readl(gp->regs + PCS_MIICTRL);
+        val |= PCS_MIICTRL_RST;
+        writel(val, gp->regs + PCS_MIICTRL);
+
+        limit = 32;
+        while (readl(gp->regs + PCS_MIICTRL) & PCS_MIICTRL_RST) {
+                udelay(100);
+                if (limit-- <= 0)
+                        break;
+        }
+        if (limit <= 0)
+                printk(KERN_WARNING "%s: PCS reset bit would not clear.\n",
+                       gp->dev->name);
+}
+
+static void gem_pcs_reinit_adv(struct gem *gp)
+{
+        u32 val;
+
+        /* Make sure PCS is disabled while changing advertisement
+         * configuration.
+         */
+        val = readl(gp->regs + PCS_CFG);
+        val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
+        writel(val, gp->regs + PCS_CFG);
+
+        /* Advertise all capabilities except assymetric
+         * pause.
+         */
+        val = readl(gp->regs + PCS_MIIADV);
+        val |= (PCS_MIIADV_FD | PCS_MIIADV_HD |
+                PCS_MIIADV_SP | PCS_MIIADV_AP);
+        writel(val, gp->regs + PCS_MIIADV);
+
+        /* Enable and restart auto-negotiation, disable wrapback/loopback,
+         * and re-enable PCS.
+         */
+        val = readl(gp->regs + PCS_MIICTRL);
+        val |= (PCS_MIICTRL_RAN | PCS_MIICTRL_ANE);
+        val &= ~PCS_MIICTRL_WB;
+        writel(val, gp->regs + PCS_MIICTRL);
+
+        val = readl(gp->regs + PCS_CFG);
+        val |= PCS_CFG_ENABLE;
+        writel(val, gp->regs + PCS_CFG);
+
+        /* Make sure serialink loopback is off.  The meaning
+         * of this bit is logically inverted based upon whether
+         * you are in Serialink or SERDES mode.
+         */
+        val = readl(gp->regs + PCS_SCTRL);
+        if (gp->phy_type == phy_serialink)
+                val &= ~PCS_SCTRL_LOOP;
+        else
+                val |= PCS_SCTRL_LOOP;
+        writel(val, gp->regs + PCS_SCTRL);
+}
+
 #define STOP_TRIES 32
 
 /* Must be invoked under gp->lock and gp->tx_lock. */
@@ -1168,6 +1232,9 @@ static void gem_reset(struct gem *gp)
 
         if (limit <= 0)
                 printk(KERN_ERR "%s: SW reset is ghetto.\n", gp->dev->name);
+
+        if (gp->phy_type == phy_serialink || gp->phy_type == phy_serdes)
+                gem_pcs_reinit_adv(gp);
 }
 
 /* Must be invoked under gp->lock and gp->tx_lock. */
@@ -1324,7 +1391,7 @@ static int gem_set_link_modes(struct gem *gp)
                    gp->phy_type == phy_serdes) {
                 u32 pcs_lpa = readl(gp->regs + PCS_MIILP);
 
-                if (pcs_lpa & PCS_MIIADV_FD)
+                if ((pcs_lpa & PCS_MIIADV_FD) || gp->phy_type == phy_serdes)
                         full_duplex = 1;
                 speed = SPEED_1000;
         }
@@ -1488,6 +1555,9 @@ static void gem_link_timer(unsigned long data)
                         val = readl(gp->regs + PCS_MIISTAT);
 
                 if ((val & PCS_MIISTAT_LS) != 0) {
+                        if (gp->lstate == link_up)
+                                goto restart;
+
                         gp->lstate = link_up;
                         netif_carrier_on(gp->dev);
                         (void)gem_set_link_modes(gp);
@@ -1708,61 +1778,8 @@ static void gem_init_phy(struct gem *gp)
                 if (gp->phy_mii.def && gp->phy_mii.def->ops->init)
                         gp->phy_mii.def->ops->init(&gp->phy_mii);
         } else {
-                u32 val;
-                int limit;
-
-                /* Reset PCS unit. */
-                val = readl(gp->regs + PCS_MIICTRL);
-                val |= PCS_MIICTRL_RST;
-                writeb(val, gp->regs + PCS_MIICTRL);
-
-                limit = 32;
-                while (readl(gp->regs + PCS_MIICTRL) & PCS_MIICTRL_RST) {
-                        udelay(100);
-                        if (limit-- <= 0)
-                                break;
-                }
-                if (limit <= 0)
-                        printk(KERN_WARNING "%s: PCS reset bit would not clear.\n",
-                               gp->dev->name);
-
-                /* Make sure PCS is disabled while changing advertisement
-                 * configuration.
-                 */
-                val = readl(gp->regs + PCS_CFG);
-                val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
-                writel(val, gp->regs + PCS_CFG);
-
-                /* Advertise all capabilities except assymetric
-                 * pause.
-                 */
-                val = readl(gp->regs + PCS_MIIADV);
-                val |= (PCS_MIIADV_FD | PCS_MIIADV_HD |
-                        PCS_MIIADV_SP | PCS_MIIADV_AP);
-                writel(val, gp->regs + PCS_MIIADV);
-
-                /* Enable and restart auto-negotiation, disable wrapback/loopback,
-                 * and re-enable PCS.
-                 */
-                val = readl(gp->regs + PCS_MIICTRL);
-                val |= (PCS_MIICTRL_RAN | PCS_MIICTRL_ANE);
-                val &= ~PCS_MIICTRL_WB;
-                writel(val, gp->regs + PCS_MIICTRL);
-
-                val = readl(gp->regs + PCS_CFG);
-                val |= PCS_CFG_ENABLE;
-                writel(val, gp->regs + PCS_CFG);
-
-                /* Make sure serialink loopback is off.  The meaning
-                 * of this bit is logically inverted based upon whether
-                 * you are in Serialink or SERDES mode.
-                 */
-                val = readl(gp->regs + PCS_SCTRL);
-                if (gp->phy_type == phy_serialink)
-                        val &= ~PCS_SCTRL_LOOP;
-                else
-                        val |= PCS_SCTRL_LOOP;
-                writel(val, gp->regs + PCS_SCTRL);
+                gem_pcs_reset(gp);
+                gem_pcs_reinit_adv(gp);
         }
 
         /* Default aneg parameters */
@@ -2680,6 +2697,21 @@ static int gem_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 cmd->speed = 0;
                 cmd->duplex = cmd->port = cmd->phy_address =
                         cmd->transceiver = cmd->autoneg = 0;
+
+                /* serdes means usually a Fibre connector, with most fixed */
+                if (gp->phy_type == phy_serdes) {
+                        cmd->port = PORT_FIBRE;
+                        cmd->supported = (SUPPORTED_1000baseT_Half |
+                                SUPPORTED_1000baseT_Full |
+                                SUPPORTED_FIBRE | SUPPORTED_Autoneg |
+                                SUPPORTED_Pause | SUPPORTED_Asym_Pause);
+                        cmd->advertising = cmd->supported;
+                        cmd->transceiver = XCVR_INTERNAL;
+                        if (gp->lstate == link_up)
+                                cmd->speed = SPEED_1000;
+                        cmd->duplex = DUPLEX_FULL;
+                        cmd->autoneg = 1;
+                }
         }
         cmd->maxtxpkt = cmd->maxrxpkt = 0;
 
diff --git a/drivers/net/tlan.c b/drivers/net/tlan.c
index c41d68761364..e60498232b94 100644
--- a/drivers/net/tlan.c
+++ b/drivers/net/tlan.c
@@ -1098,6 +1098,7 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
         dma_addr_t      tail_list_phys;
         u8              *tail_buffer;
         unsigned long   flags;
+        unsigned int    txlen;
 
         if ( ! priv->phyOnline ) {
                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n",
@@ -1108,6 +1109,7 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
         if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))
                 return 0;
+        txlen = max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE);
 
         tail_list = priv->txList + priv->txTail;
         tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
@@ -1125,16 +1127,16 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
         if ( bbuf ) {
                 tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
-                skb_copy_from_linear_data(skb, tail_buffer, skb->len);
+                skb_copy_from_linear_data(skb, tail_buffer, txlen);
         } else {
                 tail_list->buffer[0].address = pci_map_single(priv->pciDev,
-                                                              skb->data, skb->len,
+                                                              skb->data, txlen,
                                                               PCI_DMA_TODEVICE);
                 TLan_StoreSKB(tail_list, skb);
         }
 
-        tail_list->frameSize = (u16) skb->len;
-        tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
+        tail_list->frameSize = (u16) txlen;
+        tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) txlen;
         tail_list->buffer[1].count = 0;
         tail_list->buffer[1].address = 0;
 
@@ -1431,7 +1433,9 @@ static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
                 if ( ! bbuf ) {
                         struct sk_buff *skb = TLan_GetSKB(head_list);
                         pci_unmap_single(priv->pciDev, head_list->buffer[0].address,
-                                         skb->len, PCI_DMA_TODEVICE);
+                                         max(skb->len,
+                                             (unsigned int)TLAN_MIN_FRAME_SIZE),
+                                         PCI_DMA_TODEVICE);
                         dev_kfree_skb_any(skb);
                         head_list->buffer[8].address = 0;
                         head_list->buffer[9].address = 0;
@@ -2055,9 +2059,12 @@ static void TLan_FreeLists( struct net_device *dev )
                         list = priv->txList + i;
                         skb = TLan_GetSKB(list);
                         if ( skb ) {
-                                pci_unmap_single(priv->pciDev,
-                                                 list->buffer[0].address, skb->len,
-                                                 PCI_DMA_TODEVICE);
+                                pci_unmap_single(
+                                        priv->pciDev,
+                                        list->buffer[0].address,
+                                        max(skb->len,
+                                            (unsigned int)TLAN_MIN_FRAME_SIZE),
+                                        PCI_DMA_TODEVICE);
                                 dev_kfree_skb_any( skb );
                                 list->buffer[8].address = 0;
                                 list->buffer[9].address = 0;
diff --git a/drivers/net/tulip/dmfe.c b/drivers/net/tulip/dmfe.c
index 8e46a513a252..c91852f49a48 100644
--- a/drivers/net/tulip/dmfe.c
+++ b/drivers/net/tulip/dmfe.c
@@ -420,9 +420,13 @@ static int __devinit dmfe_init_one (struct pci_dev *pdev,
         /* Allocate Tx/Rx descriptor memory */
         db->desc_pool_ptr = pci_alloc_consistent(pdev, sizeof(struct tx_desc) *
                         DESC_ALL_CNT + 0x20, &db->desc_pool_dma_ptr);
+        if (!db->desc_pool_ptr)
+                goto err_out_res;
 
         db->buf_pool_ptr = pci_alloc_consistent(pdev, TX_BUF_ALLOC *
                         TX_DESC_CNT + 4, &db->buf_pool_dma_ptr);
+        if (!db->buf_pool_ptr)
+                goto err_out_free_desc;
 
         db->first_tx_desc = (struct tx_desc *) db->desc_pool_ptr;
         db->first_tx_desc_dma = db->desc_pool_dma_ptr;
@@ -469,7 +473,7 @@ static int __devinit dmfe_init_one (struct pci_dev *pdev,
 
         err = register_netdev (dev);
         if (err)
-                goto err_out_res;
+                goto err_out_free_buf;
 
         printk(KERN_INFO "%s: Davicom DM%04lx at pci%s, "
                "%s, irq %d.\n",
@@ -483,6 +487,12 @@ static int __devinit dmfe_init_one (struct pci_dev *pdev,
 
         return 0;
 
+err_out_free_buf:
+        pci_free_consistent(pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
+                            db->buf_pool_ptr, db->buf_pool_dma_ptr);
+err_out_free_desc:
+        pci_free_consistent(pdev, sizeof(struct tx_desc) * DESC_ALL_CNT + 0x20,
+                            db->desc_pool_ptr, db->desc_pool_dma_ptr);
 err_out_res:
         pci_release_regions(pdev);
 err_out_disable:
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 6daea0c91862..33b6d1b122fb 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -1070,8 +1070,6 @@ static int tun_chr_close(struct inode *inode, struct file *file)
 
         DBG(KERN_INFO "%s: tun_chr_close\n", tun->dev->name);
 
-        tun_chr_fasync(-1, file, 0);
-
         rtnl_lock();
 
         /* Detach from net device */
diff --git a/drivers/net/ucc_geth_ethtool.c b/drivers/net/ucc_geth_ethtool.c
index cfbbfee55836..68a7f5414133 100644
--- a/drivers/net/ucc_geth_ethtool.c
+++ b/drivers/net/ucc_geth_ethtool.c
@@ -37,7 +37,6 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 #include <asm/types.h>
-#include <asm/uaccess.h>
 
 #include "ucc_geth.h"
 #include "ucc_geth_mii.h"
@@ -324,17 +323,17 @@ static void uec_get_ethtool_stats(struct net_device *netdev,
         if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
                 base = (u32 __iomem *)&ugeth->ug_regs->tx64;
                 for (i = 0; i < UEC_HW_STATS_LEN; i++)
-                        data[j++] = (u64)in_be32(&base[i]);
+                        data[j++] = in_be32(&base[i]);
         }
         if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
                 base = (u32 __iomem *)ugeth->p_tx_fw_statistics_pram;
                 for (i = 0; i < UEC_TX_FW_STATS_LEN; i++)
-                        data[j++] = (u64)in_be32(&base[i]);
+                        data[j++] = base ? in_be32(&base[i]) : 0;
         }
         if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX) {
                 base = (u32 __iomem *)ugeth->p_rx_fw_statistics_pram;
                 for (i = 0; i < UEC_RX_FW_STATS_LEN; i++)
-                        data[j++] = (u64)in_be32(&base[i]);
+                        data[j++] = base ? in_be32(&base[i]) : 0;
         }
 }
 
diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
index 37ecf845edfe..de57490103fc 100644
--- a/drivers/net/usb/asix.c
+++ b/drivers/net/usb/asix.c
@@ -1102,12 +1102,14 @@ static int ax88178_link_reset(struct usbnet *dev)
         mode = AX88178_MEDIUM_DEFAULT;
 
         if (ecmd.speed == SPEED_1000)
-                mode |= AX_MEDIUM_GM | AX_MEDIUM_ENCK;
+                mode |= AX_MEDIUM_GM;
         else if (ecmd.speed == SPEED_100)
                 mode |= AX_MEDIUM_PS;
         else
                 mode &= ~(AX_MEDIUM_PS | AX_MEDIUM_GM);
 
+        mode |= AX_MEDIUM_ENCK;
+
         if (ecmd.duplex == DUPLEX_FULL)
                 mode |= AX_MEDIUM_FD;
         else
@@ -1444,6 +1446,10 @@ static const struct usb_device_id	products [] = {
         // Apple USB Ethernet Adapter
         USB_DEVICE(0x05ac, 0x1402),
         .driver_info = (unsigned long) &ax88772_info,
+}, {
+        // Cables-to-Go USB Ethernet Adapter
+        USB_DEVICE(0x0b95, 0x772a),
+        .driver_info = (unsigned long) &ax88772_info,
 },
         { },            // END
 };
diff --git a/drivers/net/usb/dm9601.c b/drivers/net/usb/dm9601.c
index 78df2be8a728..db3377dae9d5 100644
--- a/drivers/net/usb/dm9601.c
+++ b/drivers/net/usb/dm9601.c
@@ -396,6 +396,20 @@ static void dm9601_set_multicast(struct net_device *net)
         dm_write_reg_async(dev, DM_RX_CTRL, rx_ctl);
 }
 
+static int dm9601_set_mac_address(struct net_device *net, void *p)
+{
+        struct sockaddr *addr = p;
+        struct usbnet *dev = netdev_priv(net);
+
+        if (!is_valid_ether_addr(addr->sa_data))
+                return -EINVAL;
+
+        memcpy(net->dev_addr, addr->sa_data, net->addr_len);
+        dm_write_async(dev, DM_PHY_ADDR, net->addr_len, net->dev_addr);
+
+        return 0;
+}
+
 static int dm9601_bind(struct usbnet *dev, struct usb_interface *intf)
 {
         int ret;
@@ -406,6 +420,7 @@ static int dm9601_bind(struct usbnet *dev, struct usb_interface *intf)
 
         dev->net->do_ioctl = dm9601_ioctl;
         dev->net->set_multicast_list = dm9601_set_multicast;
+        dev->net->set_mac_address = dm9601_set_mac_address;
         dev->net->ethtool_ops = &dm9601_ethtool_ops;
         dev->net->hard_header_len += DM_TX_OVERHEAD;
         dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 1164c52e2c0a..8e90891f0e42 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -2184,19 +2184,20 @@ static void hso_create_rfkill(struct hso_device *hso_dev,
                              struct usb_interface *interface)
 {
         struct hso_net *hso_net = dev2net(hso_dev);
-        struct device *dev = hso_dev->dev;
+        struct device *dev = &hso_net->net->dev;
         char *rfkn;
 
         hso_net->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
-                                 RFKILL_TYPE_WLAN);
+                                 RFKILL_TYPE_WWAN);
         if (!hso_net->rfkill) {
-                dev_err(dev, "%s - Out of memory", __func__);
+                dev_err(dev, "%s - Out of memory\n", __func__);
                 return;
         }
         rfkn = kzalloc(20, GFP_KERNEL);
         if (!rfkn) {
                 rfkill_free(hso_net->rfkill);
-                dev_err(dev, "%s - Out of memory", __func__);
+                hso_net->rfkill = NULL;
+                dev_err(dev, "%s - Out of memory\n", __func__);
                 return;
         }
         snprintf(rfkn, 20, "hso-%d",
@@ -2209,7 +2210,8 @@ static void hso_create_rfkill(struct hso_device *hso_dev,
                 kfree(rfkn);
                 hso_net->rfkill->name = NULL;
                 rfkill_free(hso_net->rfkill);
-                dev_err(dev, "%s - Failed to register rfkill", __func__);
+                hso_net->rfkill = NULL;
+                dev_err(dev, "%s - Failed to register rfkill\n", __func__);
                 return;
         }
 }
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index 2dced383bcfb..11cb3e504e1c 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -521,7 +521,7 @@ static void __devexit velocity_remove1(struct pci_dev *pdev)
  *      we don't duplicate code for each option.
  */
 
-static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, char *devname)
+static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname)
 {
         if (val == -1)
                 *opt = def;
@@ -550,7 +550,7 @@ static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max,
  *      we don't duplicate code for each option.
  */
 
-static void __devinit velocity_set_bool_opt(u32 * opt, int val, int def, u32 flag, char *name, char *devname)
+static void __devinit velocity_set_bool_opt(u32 * opt, int val, int def, u32 flag, char *name, const char *devname)
 {
         (*opt) &= (~flag);
         if (val == -1)
@@ -576,7 +576,7 @@ static void __devinit velocity_set_bool_opt(u32 * opt, int val, int def, u32 fla
  *      for the current device
  */
 
-static void __devinit velocity_get_options(struct velocity_opt *opts, int index, char *devname)
+static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname)
 {
 
         velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
@@ -863,6 +863,7 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
         static int first = 1;
         struct net_device *dev;
         int i;
+        const char *drv_string;
         const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
         struct velocity_info *vptr;
         struct mac_regs __iomem * regs;
@@ -935,7 +936,9 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
                 dev->dev_addr[i] = readb(&regs->PAR[i]);
 
 
-        velocity_get_options(&vptr->options, velocity_nics, dev->name);
+        drv_string = dev_driver_string(&pdev->dev);
+
+        velocity_get_options(&vptr->options, velocity_nics, drv_string);
 
         /*
          *      Mask out the options cannot be set to the chip
@@ -2293,7 +2296,7 @@ static void velocity_set_multi(struct net_device *dev)
                 }
 
                 mac_set_cam_mask(regs, vptr->mCAMmask);
-                rx_mode = (RCR_AM | RCR_AB);
+                rx_mode = RCR_AM | RCR_AB | RCR_AP;
         }
         if (dev->mtu > 1500)
                 rx_mode |= RCR_AL;
diff --git a/drivers/net/wan/syncppp.c b/drivers/net/wan/syncppp.c
index 327d58589e12..6e92f7b44b1a 100644
--- a/drivers/net/wan/syncppp.c
+++ b/drivers/net/wan/syncppp.c
@@ -756,10 +756,11 @@ static void sppp_cisco_input (struct sppp *sp, struct sk_buff *skb)
         case CISCO_ADDR_REQ:
                 /* Stolen from net/ipv4/devinet.c -- SIOCGIFADDR ioctl */
                 {
-                struct in_device *in_dev;
-                struct in_ifaddr *ifa;
                 __be32 addr = 0, mask = htonl(~0U); /* FIXME: is the mask correct? */
 #ifdef CONFIG_INET
+                struct in_device *in_dev;
+                struct in_ifaddr *ifa;
+
                 rcu_read_lock();
                 if ((in_dev = __in_dev_get_rcu(dev)) != NULL)
                 {
diff --git a/drivers/net/wan/z85230.c b/drivers/net/wan/z85230.c
index ccd9cd35ecbe..5bf7e01ef0e9 100644
--- a/drivers/net/wan/z85230.c
+++ b/drivers/net/wan/z85230.c
@@ -695,7 +695,6 @@ EXPORT_SYMBOL(z8530_nop);
  *      z8530_interrupt - Handle an interrupt from a Z8530
  *      @irq:   Interrupt number
  *      @dev_id: The Z8530 device that is interrupting.
- *      @regs: unused
  *
  *      A Z85[2]30 device has stuck its hand in the air for attention.
  *      We scan both the channels on the chip for events and then call
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index 0f1d6bdd51a2..2d14255eb103 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -240,6 +240,10 @@ static u64 ath5k_get_tsf(struct ieee80211_hw *hw);
 static void ath5k_reset_tsf(struct ieee80211_hw *hw);
 static int ath5k_beacon_update(struct ieee80211_hw *hw,
                 struct sk_buff *skb);
+static void ath5k_bss_info_changed(struct ieee80211_hw *hw,
+                struct ieee80211_vif *vif,
+                struct ieee80211_bss_conf *bss_conf,
+                u32 changes);
 
 static struct ieee80211_ops ath5k_hw_ops = {
         .tx             = ath5k_tx,
@@ -256,6 +260,7 @@ static struct ieee80211_ops ath5k_hw_ops = {
         .get_tx_stats   = ath5k_get_tx_stats,
         .get_tsf        = ath5k_get_tsf,
         .reset_tsf      = ath5k_reset_tsf,
+        .bss_info_changed = ath5k_bss_info_changed,
 };
 
 /*
@@ -661,8 +666,7 @@ ath5k_pci_resume(struct pci_dev *pdev)
 {
         struct ieee80211_hw *hw = pci_get_drvdata(pdev);
         struct ath5k_softc *sc = hw->priv;
-        struct ath5k_hw *ah = sc->ah;
-        int i, err;
+        int err;
 
         pci_restore_state(pdev);
 
@@ -688,16 +692,6 @@ ath5k_pci_resume(struct pci_dev *pdev)
                 goto err_irq;
         ath5k_led_enable(sc);
 
-        /*
-         * Reset the key cache since some parts do not
-         * reset the contents on initial power up or resume.
-         *
-         * FIXME: This may need to be revisited when mac80211 becomes
-         *        aware of suspend/resume.
-         */
-        for (i = 0; i < AR5K_KEYTABLE_SIZE; i++)
-                ath5k_hw_reset_key(ah, i);
-
         return 0;
 err_irq:
         free_irq(pdev->irq, sc);
@@ -718,7 +712,6 @@ ath5k_attach(struct pci_dev *pdev, struct ieee80211_hw *hw)
         struct ath5k_softc *sc = hw->priv;
         struct ath5k_hw *ah = sc->ah;
         u8 mac[ETH_ALEN];
-        unsigned int i;
         int ret;
 
         ATH5K_DBG(sc, ATH5K_DEBUG_ANY, "devid 0x%x\n", pdev->device);
@@ -737,13 +730,6 @@ ath5k_attach(struct pci_dev *pdev, struct ieee80211_hw *hw)
                 __set_bit(ATH_STAT_MRRETRY, sc->status);
 
         /*
-         * Reset the key cache since some parts do not
-         * reset the contents on initial power up.
-         */
-        for (i = 0; i < AR5K_KEYTABLE_SIZE; i++)
-                ath5k_hw_reset_key(ah, i);
-
-        /*
          * Collect the channel list.  The 802.11 layer
          * is resposible for filtering this list based
          * on settings like the phy mode and regulatory
@@ -2202,7 +2188,8 @@ ath5k_beacon_config(struct ath5k_softc *sc)
 static int
 ath5k_init(struct ath5k_softc *sc, bool is_resume)
 {
-        int ret;
+        struct ath5k_hw *ah = sc->ah;
+        int ret, i;
 
         mutex_lock(&sc->lock);
 
@@ -2235,10 +2222,17 @@ ath5k_init(struct ath5k_softc *sc, bool is_resume)
         if (ret)
                 goto done;
 
+        /*
+         * Reset the key cache since some parts do not reset the
+         * contents on initial power up or resume from suspend.
+         */
+        for (i = 0; i < AR5K_KEYTABLE_SIZE; i++)
+                ath5k_hw_reset_key(ah, i);
+
         __set_bit(ATH_STAT_STARTED, sc->status);
 
         /* Set ack to be sent at low bit-rates */
-        ath5k_hw_set_ack_bitrate_high(sc->ah, false);
+        ath5k_hw_set_ack_bitrate_high(ah, false);
 
         mod_timer(&sc->calib_tim, round_jiffies(jiffies +
                         msecs_to_jiffies(ath5k_calinterval * 1000)));
@@ -2953,7 +2947,7 @@ static void ath5k_configure_filter(struct ieee80211_hw *hw,
                 sc->opmode != NL80211_IFTYPE_MESH_POINT &&
                 test_bit(ATH_STAT_PROMISC, sc->status))
                 rfilt |= AR5K_RX_FILTER_PROM;
-        if (sc->opmode == NL80211_IFTYPE_STATION ||
+        if ((sc->opmode == NL80211_IFTYPE_STATION && sc->assoc) ||
                 sc->opmode == NL80211_IFTYPE_ADHOC) {
                 rfilt |= AR5K_RX_FILTER_BEACON;
         }
@@ -3094,4 +3088,32 @@ ath5k_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
 end:
         return ret;
 }
+static void
+set_beacon_filter(struct ieee80211_hw *hw, bool enable)
+{
+        struct ath5k_softc *sc = hw->priv;
+        struct ath5k_hw *ah = sc->ah;
+        u32 rfilt;
+        rfilt = ath5k_hw_get_rx_filter(ah);
+        if (enable)
+                rfilt |= AR5K_RX_FILTER_BEACON;
+        else
+                rfilt &= ~AR5K_RX_FILTER_BEACON;
+        ath5k_hw_set_rx_filter(ah, rfilt);
+        sc->filter_flags = rfilt;
+}
 
+static void ath5k_bss_info_changed(struct ieee80211_hw *hw,
+                                    struct ieee80211_vif *vif,
+                                    struct ieee80211_bss_conf *bss_conf,
+                                    u32 changes)
+{
+        struct ath5k_softc *sc = hw->priv;
+        if (changes & BSS_CHANGED_ASSOC) {
+                mutex_lock(&sc->lock);
+                sc->assoc = bss_conf->assoc;
+                if (sc->opmode == NL80211_IFTYPE_STATION)
+                        set_beacon_filter(hw, sc->assoc);
+                mutex_unlock(&sc->lock);
+        }
+}
diff --git a/drivers/net/wireless/ath5k/base.h b/drivers/net/wireless/ath5k/base.h
index 06d1054ca94b..facc60ddada2 100644
--- a/drivers/net/wireless/ath5k/base.h
+++ b/drivers/net/wireless/ath5k/base.h
@@ -179,6 +179,7 @@ struct ath5k_softc {
 
         struct timer_list       calib_tim;      /* calibration timer */
         int                     power_level;    /* Requested tx power in dbm */
+        bool                    assoc;          /* assocate state */
 };
 
 #define ath5k_hw_hasbssidmask(_ah) \
diff --git a/drivers/net/wireless/ath5k/debug.c b/drivers/net/wireless/ath5k/debug.c
index 8f92d670f614..ccaeb5c219d2 100644
--- a/drivers/net/wireless/ath5k/debug.c
+++ b/drivers/net/wireless/ath5k/debug.c
@@ -339,7 +339,7 @@ static struct {
         { ATH5K_DEBUG_BEACON,   "beacon",       "beacon handling" },
         { ATH5K_DEBUG_CALIBRATE, "calib",       "periodic calibration" },
         { ATH5K_DEBUG_TXPOWER,  "txpower",      "transmit power setting" },
-        { ATH5K_DEBUG_LED,      "led",          "LED mamagement" },
+        { ATH5K_DEBUG_LED,      "led",          "LED management" },
         { ATH5K_DEBUG_DUMP_RX,  "dumprx",       "print received skb content" },
         { ATH5K_DEBUG_DUMP_TX,  "dumptx",       "print transmit skb content" },
         { ATH5K_DEBUG_DUMPBANDS, "dumpbands",   "dump bands" },
@@ -417,19 +417,19 @@ ath5k_debug_init_device(struct ath5k_softc *sc)
         sc->debug.debugfs_phydir = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
                                 ath5k_global_debugfs);
 
-        sc->debug.debugfs_debug = debugfs_create_file("debug", 0666,
+        sc->debug.debugfs_debug = debugfs_create_file("debug", S_IWUSR | S_IRUGO,
                                 sc->debug.debugfs_phydir, sc, &fops_debug);
 
-        sc->debug.debugfs_registers = debugfs_create_file("registers", 0444,
+        sc->debug.debugfs_registers = debugfs_create_file("registers", S_IRUGO,
                                 sc->debug.debugfs_phydir, sc, &fops_registers);
 
-        sc->debug.debugfs_tsf = debugfs_create_file("tsf", 0666,
+        sc->debug.debugfs_tsf = debugfs_create_file("tsf", S_IWUSR | S_IRUGO,
                                 sc->debug.debugfs_phydir, sc, &fops_tsf);
 
-        sc->debug.debugfs_beacon = debugfs_create_file("beacon", 0666,
+        sc->debug.debugfs_beacon = debugfs_create_file("beacon", S_IWUSR | S_IRUGO,
                                 sc->debug.debugfs_phydir, sc, &fops_beacon);
 
-        sc->debug.debugfs_reset = debugfs_create_file("reset", 0222,
+        sc->debug.debugfs_reset = debugfs_create_file("reset", S_IWUSR,
                                 sc->debug.debugfs_phydir, sc, &fops_reset);
 }
 
diff --git a/drivers/net/wireless/ath5k/desc.c b/drivers/net/wireless/ath5k/desc.c
index dd1374052ba9..5e362a7a3620 100644
--- a/drivers/net/wireless/ath5k/desc.c
+++ b/drivers/net/wireless/ath5k/desc.c
@@ -531,10 +531,10 @@ static int ath5k_hw_proc_5210_rx_status(struct ath5k_hw *ah,
                 AR5K_5210_RX_DESC_STATUS0_RECEIVE_SIGNAL);
         rs->rs_rate = AR5K_REG_MS(rx_status->rx_status_0,
                 AR5K_5210_RX_DESC_STATUS0_RECEIVE_RATE);
-        rs->rs_antenna = rx_status->rx_status_0 &
-                AR5K_5210_RX_DESC_STATUS0_RECEIVE_ANTENNA;
-        rs->rs_more = rx_status->rx_status_0 &
-                AR5K_5210_RX_DESC_STATUS0_MORE;
+        rs->rs_antenna = AR5K_REG_MS(rx_status->rx_status_0,
+                AR5K_5210_RX_DESC_STATUS0_RECEIVE_ANTENNA);
+        rs->rs_more = !!(rx_status->rx_status_0 &
+                AR5K_5210_RX_DESC_STATUS0_MORE);
         /* TODO: this timestamp is 13 bit, later on we assume 15 bit */
         rs->rs_tstamp = AR5K_REG_MS(rx_status->rx_status_1,
                 AR5K_5210_RX_DESC_STATUS1_RECEIVE_TIMESTAMP);
@@ -607,10 +607,10 @@ static int ath5k_hw_proc_5212_rx_status(struct ath5k_hw *ah,
                 AR5K_5212_RX_DESC_STATUS0_RECEIVE_SIGNAL);
         rs->rs_rate = AR5K_REG_MS(rx_status->rx_status_0,
                 AR5K_5212_RX_DESC_STATUS0_RECEIVE_RATE);
-        rs->rs_antenna = rx_status->rx_status_0 &
-                AR5K_5212_RX_DESC_STATUS0_RECEIVE_ANTENNA;
-        rs->rs_more = rx_status->rx_status_0 &
-                AR5K_5212_RX_DESC_STATUS0_MORE;
+        rs->rs_antenna = AR5K_REG_MS(rx_status->rx_status_0,
+                AR5K_5212_RX_DESC_STATUS0_RECEIVE_ANTENNA);
+        rs->rs_more = !!(rx_status->rx_status_0 &
+                AR5K_5212_RX_DESC_STATUS0_MORE);
         rs->rs_tstamp = AR5K_REG_MS(rx_status->rx_status_1,
                 AR5K_5212_RX_DESC_STATUS1_RECEIVE_TIMESTAMP);
         rs->rs_status = 0;
diff --git a/drivers/net/wireless/ath5k/initvals.c b/drivers/net/wireless/ath5k/initvals.c
index ea2e1a20b499..ceaa6c475c06 100644
--- a/drivers/net/wireless/ath5k/initvals.c
+++ b/drivers/net/wireless/ath5k/initvals.c
@@ -806,6 +806,8 @@ static const struct ath5k_ini_mode ar5212_rf5111_ini_mode_end[] = {
                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 } },
         { AR5K_PHY(642),
                 { 0xd03e6788, 0xd03e6788, 0xd03e6788, 0xd03e6788, 0xd03e6788 } },
+        { 0xa228,
+                { 0x000001b5, 0x000001b5, 0x000001b5, 0x000001b5, 0x000001b5 } },
         { 0xa23c,
                 { 0x13c889af, 0x13c889af, 0x13c889af, 0x13c889af, 0x13c889af } },
 };
diff --git a/drivers/net/wireless/ath5k/reset.c b/drivers/net/wireless/ath5k/reset.c
index 8f1886834e61..1b6d45b6772d 100644
--- a/drivers/net/wireless/ath5k/reset.c
+++ b/drivers/net/wireless/ath5k/reset.c
@@ -537,9 +537,10 @@ int ath5k_hw_reset(struct ath5k_hw *ah, enum nl80211_iftype op_mode,
                 mdelay(1);
 
                 /*
-                 * Write some more initial register settings
+                 * Write some more initial register settings for revised chips
                  */
-                if (ah->ah_version == AR5K_AR5212) {
+                if (ah->ah_version == AR5K_AR5212 &&
+                    ah->ah_phy_revision > 0x41) {
                         ath5k_hw_reg_write(ah, 0x0002a002, 0x982c);
 
                         if (channel->hw_value == CHANNEL_G)
@@ -558,19 +559,10 @@ int ath5k_hw_reset(struct ath5k_hw *ah, enum nl80211_iftype op_mode,
                         else
                                 ath5k_hw_reg_write(ah, 0x00000000, 0x994c);
 
-                        /* Some bits are disabled here, we know nothing about
-                         * register 0xa228 yet, most of the times this ends up
-                         * with a value 0x9b5 -haven't seen any dump with
-                         * a different value- */
-                        /* Got this from decompiling binary HAL */
-                        data = ath5k_hw_reg_read(ah, 0xa228);
-                        data &= 0xfffffdff;
-                        ath5k_hw_reg_write(ah, data, 0xa228);
-
-                        data = ath5k_hw_reg_read(ah, 0xa228);
-                        data &= 0xfffe03ff;
-                        ath5k_hw_reg_write(ah, data, 0xa228);
-                        data = 0;
+                        /* Got this from legacy-hal */
+                        AR5K_REG_DISABLE_BITS(ah, 0xa228, 0x200);
+
+                        AR5K_REG_MASKED_BITS(ah, 0xa228, 0x800, 0xfffe03ff);
 
                         /* Just write 0x9b5 ? */
                         /* ath5k_hw_reg_write(ah, 0x000009b5, 0xa228); */
diff --git a/drivers/net/wireless/ath9k/beacon.c b/drivers/net/wireless/ath9k/beacon.c
index 9e15c30bbc06..4dd1c1bda0fb 100644
--- a/drivers/net/wireless/ath9k/beacon.c
+++ b/drivers/net/wireless/ath9k/beacon.c
@@ -170,7 +170,7 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
         skb = (struct sk_buff *)bf->bf_mpdu;
         if (skb) {
                 pci_unmap_single(sc->pdev, bf->bf_dmacontext,
-                                 skb_end_pointer(skb) - skb->head,
+                                 skb->len,
                                  PCI_DMA_TODEVICE);
         }
 
@@ -193,7 +193,7 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
 
         bf->bf_buf_addr = bf->bf_dmacontext =
                 pci_map_single(sc->pdev, skb->data,
-                               skb_end_pointer(skb) - skb->head,
+                               skb->len,
                                PCI_DMA_TODEVICE);
 
         skb = ieee80211_get_buffered_bc(sc->hw, avp->av_if_data);
@@ -352,7 +352,7 @@ int ath_beacon_alloc(struct ath_softc *sc, int if_id)
         if (bf->bf_mpdu != NULL) {
                 skb = (struct sk_buff *)bf->bf_mpdu;
                 pci_unmap_single(sc->pdev, bf->bf_dmacontext,
-                                 skb_end_pointer(skb) - skb->head,
+                                 skb->len,
                                  PCI_DMA_TODEVICE);
                 dev_kfree_skb_any(skb);
                 bf->bf_mpdu = NULL;
@@ -412,7 +412,7 @@ int ath_beacon_alloc(struct ath_softc *sc, int if_id)
 
         bf->bf_buf_addr = bf->bf_dmacontext =
                 pci_map_single(sc->pdev, skb->data,
-                               skb_end_pointer(skb) - skb->head,
+                               skb->len,
                                PCI_DMA_TODEVICE);
         bf->bf_mpdu = skb;
 
@@ -439,7 +439,7 @@ void ath_beacon_return(struct ath_softc *sc, struct ath_vap *avp)
                 if (bf->bf_mpdu != NULL) {
                         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
                         pci_unmap_single(sc->pdev, bf->bf_dmacontext,
-                                         skb_end_pointer(skb) - skb->head,
+                                         skb->len,
                                          PCI_DMA_TODEVICE);
                         dev_kfree_skb_any(skb);
                         bf->bf_mpdu = NULL;
diff --git a/drivers/net/wireless/ath9k/recv.c b/drivers/net/wireless/ath9k/recv.c
index 4983402af559..504a0444d89f 100644
--- a/drivers/net/wireless/ath9k/recv.c
+++ b/drivers/net/wireless/ath9k/recv.c
@@ -49,10 +49,12 @@ static void ath_rx_buf_link(struct ath_softc *sc, struct ath_buf *bf)
         ASSERT(skb != NULL);
         ds->ds_vdata = skb->data;
 
-        /* setup rx descriptors */
+        /* setup rx descriptors. The sc_rxbufsize here tells the harware
+         * how much data it can DMA to us and that we are prepared
+         * to process */
         ath9k_hw_setuprxdesc(ah,
                              ds,
-                             skb_tailroom(skb),   /* buffer size */
+                             sc->sc_rxbufsize,
                              0);
 
         if (sc->sc_rxlink == NULL)
@@ -398,6 +400,13 @@ static struct sk_buff *ath_rxbuf_alloc(struct ath_softc *sc,
          * in rx'd frames.
          */
 
+        /* Note: the kernel can allocate a value greater than
+         * what we ask it to give us. We really only need 4 KB as that
+         * is this hardware supports and in fact we need at least 3849
+         * as that is the MAX AMSDU size this hardware supports.
+         * Unfortunately this means we may get 8 KB here from the
+         * kernel... and that is actually what is observed on some
+         * systems :( */
         skb = dev_alloc_skb(len + sc->sc_cachelsz - 1);
         if (skb != NULL) {
                 off = ((unsigned long) skb->data) % sc->sc_cachelsz;
@@ -456,7 +465,7 @@ static int ath_rx_indicate(struct ath_softc *sc,
         if (nskb != NULL) {
                 bf->bf_mpdu = nskb;
                 bf->bf_buf_addr = pci_map_single(sc->pdev, nskb->data,
-                                         skb_end_pointer(nskb) - nskb->head,
+                                         sc->sc_rxbufsize,
                                          PCI_DMA_FROMDEVICE);
                 bf->bf_dmacontext = bf->bf_buf_addr;
                 ATH_RX_CONTEXT(nskb)->ctx_rxbuf = bf;
@@ -542,7 +551,7 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
 
                         bf->bf_mpdu = skb;
                         bf->bf_buf_addr = pci_map_single(sc->pdev, skb->data,
-                                         skb_end_pointer(skb) - skb->head,
+                                         sc->sc_rxbufsize,
                                          PCI_DMA_FROMDEVICE);
                         bf->bf_dmacontext = bf->bf_buf_addr;
                         ATH_RX_CONTEXT(skb)->ctx_rxbuf = bf;
@@ -1007,7 +1016,7 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush)
 
                 pci_dma_sync_single_for_cpu(sc->pdev,
                                             bf->bf_buf_addr,
-                                            skb_tailroom(skb),
+                                            sc->sc_rxbufsize,
                                             PCI_DMA_FROMDEVICE);
                 pci_unmap_single(sc->pdev,
                                  bf->bf_buf_addr,
diff --git a/drivers/net/wireless/hostap/hostap_wlan.h b/drivers/net/wireless/hostap/hostap_wlan.h
index ffdf4876121b..a68f97c39359 100644
--- a/drivers/net/wireless/hostap/hostap_wlan.h
+++ b/drivers/net/wireless/hostap/hostap_wlan.h
@@ -918,9 +918,12 @@ struct hostap_interface {
 
 /*
  * TX meta data - stored in skb->cb buffer, so this must not be increased over
- * the 40-byte limit
+ * the 48-byte limit.
+ * THE PADDING THIS STARTS WITH IS A HORRIBLE HACK THAT SHOULD NOT LIVE
+ * TO SEE THE DAY.
  */
 struct hostap_skb_tx_data {
+        unsigned int __padding_for_default_qdiscs;
         u32 magic; /* HOSTAP_SKB_TX_DATA_MAGIC */
         u8 rate; /* transmit rate */
 #define HOSTAP_TX_FLAGS_WDS BIT(0)
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index dcce3542d5a7..7a9f901d4ff6 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -3897,6 +3897,7 @@ static int ipw_disassociate(void *data)
         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
                 return 0;
         ipw_send_disassociate(data, 0);
+        netif_carrier_off(priv->net_dev);
         return 1;
 }
 
@@ -10190,6 +10191,9 @@ static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
         u16 remaining_bytes;
         int fc;
 
+        if (!(priv->status & STATUS_ASSOCIATED))
+                goto drop;
+
         hdr_len = ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
         switch (priv->ieee->iw_mode) {
         case IW_MODE_ADHOC:
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 24a1aeb6448f..c4c0371c763b 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -1384,9 +1384,11 @@ void iwl_rx_handle(struct iwl_priv *priv)
 
                 rxq->queue[i] = NULL;
 
-                pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
-                                            priv->hw_params.rx_buf_size,
-                                            PCI_DMA_FROMDEVICE);
+                dma_sync_single_range_for_cpu(
+                                &priv->pci_dev->dev, rxb->real_dma_addr,
+                                rxb->aligned_dma_addr - rxb->real_dma_addr,
+                                priv->hw_params.rx_buf_size,
+                                PCI_DMA_FROMDEVICE);
                 pkt = (struct iwl_rx_packet *)rxb->skb->data;
 
                 /* Reclaim a command buffer only if this packet is a response
@@ -1436,8 +1438,8 @@ void iwl_rx_handle(struct iwl_priv *priv)
                         rxb->skb = NULL;
                 }
 
-                pci_unmap_single(priv->pci_dev, rxb->dma_addr,
-                                 priv->hw_params.rx_buf_size,
+                pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
+                                 priv->hw_params.rx_buf_size + 256,
                                  PCI_DMA_FROMDEVICE);
                 spin_lock_irqsave(&rxq->lock, flags);
                 list_add_tail(&rxb->list, &priv->rxq.rx_used);
@@ -2090,7 +2092,6 @@ static void iwl_alive_start(struct iwl_priv *priv)
                 iwl4965_error_recovery(priv);
 
         iwl_power_update_mode(priv, 1);
-        ieee80211_notify_mac(priv->hw, IEEE80211_NOTIFY_RE_ASSOC);
 
         if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
                 iwl4965_set_mode(priv, priv->iw_mode);
@@ -3252,7 +3253,11 @@ static void iwl4965_mac_update_tkip_key(struct ieee80211_hw *hw,
                 return;
         }
 
-        iwl_scan_cancel_timeout(priv, 100);
+        if (iwl_scan_cancel(priv)) {
+                /* cancel scan failed, just live w/ bad key and rely
+                   briefly on SW decryption */
+                return;
+        }
 
         key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
         key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index 4c312c55f90c..01a845851338 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -290,6 +290,9 @@ void iwl_clear_stations_table(struct iwl_priv *priv)
         priv->num_stations = 0;
         memset(priv->stations, 0, sizeof(priv->stations));
 
+        /* clean ucode key table bit map */
+        priv->ucode_key_table = 0;
+
         spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 EXPORT_SYMBOL(iwl_clear_stations_table);
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h
index c018121085e9..9966d4e384ce 100644
--- a/drivers/net/wireless/iwlwifi/iwl-dev.h
+++ b/drivers/net/wireless/iwlwifi/iwl-dev.h
@@ -89,7 +89,8 @@ extern struct iwl_cfg iwl5100_abg_cfg;
 #define DEFAULT_LONG_RETRY_LIMIT  4U
 
 struct iwl_rx_mem_buffer {
-        dma_addr_t dma_addr;
+        dma_addr_t real_dma_addr;
+        dma_addr_t aligned_dma_addr;
         struct sk_buff *skb;
         struct list_head list;
 };
diff --git a/drivers/net/wireless/iwlwifi/iwl-rx.c b/drivers/net/wireless/iwlwifi/iwl-rx.c
index 7cde9d76ff5d..0509c16dbe75 100644
--- a/drivers/net/wireless/iwlwifi/iwl-rx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-rx.c
@@ -204,7 +204,7 @@ int iwl_rx_queue_restock(struct iwl_priv *priv)
                 list_del(element);
 
                 /* Point to Rx buffer via next RBD in circular buffer */
-                rxq->bd[rxq->write] = iwl_dma_addr2rbd_ptr(priv, rxb->dma_addr);
+                rxq->bd[rxq->write] = iwl_dma_addr2rbd_ptr(priv, rxb->aligned_dma_addr);
                 rxq->queue[rxq->write] = rxb;
                 rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
                 rxq->free_count--;
@@ -251,7 +251,7 @@ void iwl_rx_allocate(struct iwl_priv *priv)
                 rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
 
                 /* Alloc a new receive buffer */
-                rxb->skb = alloc_skb(priv->hw_params.rx_buf_size,
+                rxb->skb = alloc_skb(priv->hw_params.rx_buf_size + 256,
                                 __GFP_NOWARN | GFP_ATOMIC);
                 if (!rxb->skb) {
                         if (net_ratelimit())
@@ -266,9 +266,17 @@ void iwl_rx_allocate(struct iwl_priv *priv)
                 list_del(element);
 
                 /* Get physical address of RB/SKB */
-                rxb->dma_addr =
-                    pci_map_single(priv->pci_dev, rxb->skb->data,
-                           priv->hw_params.rx_buf_size, PCI_DMA_FROMDEVICE);
+                rxb->real_dma_addr = pci_map_single(
+                                        priv->pci_dev,
+                                        rxb->skb->data,
+                                        priv->hw_params.rx_buf_size + 256,
+                                        PCI_DMA_FROMDEVICE);
+                /* dma address must be no more than 36 bits */
+                BUG_ON(rxb->real_dma_addr & ~DMA_BIT_MASK(36));
+                /* and also 256 byte aligned! */
+                rxb->aligned_dma_addr = ALIGN(rxb->real_dma_addr, 256);
+                skb_reserve(rxb->skb, rxb->aligned_dma_addr - rxb->real_dma_addr);
+
                 list_add_tail(&rxb->list, &rxq->rx_free);
                 rxq->free_count++;
         }
@@ -300,8 +308,8 @@ void iwl_rx_queue_free(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
                 if (rxq->pool[i].skb != NULL) {
                         pci_unmap_single(priv->pci_dev,
-                                         rxq->pool[i].dma_addr,
-                                         priv->hw_params.rx_buf_size,
+                                         rxq->pool[i].real_dma_addr,
+                                         priv->hw_params.rx_buf_size + 256,
                                          PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(rxq->pool[i].skb);
                 }
@@ -354,8 +362,8 @@ void iwl_rx_queue_reset(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
                  * to an SKB, so we need to unmap and free potential storage */
                 if (rxq->pool[i].skb != NULL) {
                         pci_unmap_single(priv->pci_dev,
-                                         rxq->pool[i].dma_addr,
-                                         priv->hw_params.rx_buf_size,
+                                         rxq->pool[i].real_dma_addr,
+                                         priv->hw_params.rx_buf_size + 256,
                                          PCI_DMA_FROMDEVICE);
                         priv->alloc_rxb_skb--;
                         dev_kfree_skb(rxq->pool[i].skb);
diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c
index 3b0bee331a33..c89365e2ca58 100644
--- a/drivers/net/wireless/iwlwifi/iwl-scan.c
+++ b/drivers/net/wireless/iwlwifi/iwl-scan.c
@@ -896,6 +896,13 @@ static void iwl_bg_request_scan(struct work_struct *data)
         return;
 
  done:
+        /* Cannot perform scan. Make sure we clear scanning
+        * bits from status so next scan request can be performed.
+        * If we don't clear scanning status bit here all next scan
+        * will fail
+        */
+        clear_bit(STATUS_SCAN_HW, &priv->status);
+        clear_bit(STATUS_SCANNING, &priv->status);
         /* inform mac80211 scan aborted */
         queue_work(priv->workqueue, &priv->scan_completed);
         mutex_unlock(&priv->mutex);
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 61797f3f8d5c..26f7084d3011 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -475,7 +475,7 @@ static int iwl_get_free_ucode_key_index(struct iwl_priv *priv)
                 if (!test_and_set_bit(i, &priv->ucode_key_table))
                         return i;
 
-        return -1;
+        return WEP_INVALID_OFFSET;
 }
 
 int iwl_send_static_wepkey_cmd(struct iwl_priv *priv, u8 send_if_empty)
@@ -620,6 +620,9 @@ static int iwl_set_wep_dynamic_key_info(struct iwl_priv *priv,
         /* else, we are overriding an existing key => no need to allocated room
          * in uCode. */
 
+        WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+                "no space for new kew");
+
         priv->stations[sta_id].sta.key.key_flags = key_flags;
         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
@@ -637,6 +640,7 @@ static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
 {
         unsigned long flags;
         __le16 key_flags = 0;
+        int ret;
 
         key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
         key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
@@ -664,14 +668,18 @@ static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
         /* else, we are overriding an existing key => no need to allocated room
          * in uCode. */
 
+        WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+                "no space for new kew");
+
         priv->stations[sta_id].sta.key.key_flags = key_flags;
         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 
+        ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
+
         spin_unlock_irqrestore(&priv->sta_lock, flags);
 
-        IWL_DEBUG_INFO("hwcrypto: modify ucode station key info\n");
-        return iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
+        return ret;
 }
 
 static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
@@ -696,6 +704,9 @@ static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
         /* else, we are overriding an existing key => no need to allocated room
          * in uCode. */
 
+        WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+                "no space for new kew");
+
         /* This copy is acutally not needed: we get the key with each TX */
         memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key, 16);
 
@@ -734,6 +745,13 @@ int iwl_remove_dynamic_key(struct iwl_priv *priv,
                 return 0;
         }
 
+        if (priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
+                IWL_WARNING("Removing wrong key %d 0x%x\n",
+                            keyconf->keyidx, key_flags);
+                spin_unlock_irqrestore(&priv->sta_lock, flags);
+                return 0;
+        }
+
         if (!test_and_clear_bit(priv->stations[sta_id].sta.key.key_offset,
                 &priv->ucode_key_table))
                 IWL_ERROR("index %d not used in uCode key table.\n",
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index d15a2c997954..45a6b0c35695 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -5768,7 +5768,6 @@ static void iwl3945_alive_start(struct iwl3945_priv *priv)
         if (priv->error_recovering)
                 iwl3945_error_recovery(priv);
 
-        ieee80211_notify_mac(priv->hw, IEEE80211_NOTIFY_RE_ASSOC);
         return;
 
  restart:
@@ -6256,6 +6255,11 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
                                               n_probes,
                         (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
 
+        if (scan->channel_count == 0) {
+                IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
+                goto done;
+        }
+
         cmd.len += le16_to_cpu(scan->tx_cmd.len) +
             scan->channel_count * sizeof(struct iwl3945_scan_channel);
         cmd.data = scan;
@@ -6273,6 +6277,14 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
         return;
 
  done:
+        /* can not perform scan make sure we clear scanning
+         * bits from status so next scan request can be performed.
+         * if we dont clear scanning status bit here all next scan
+         * will fail
+        */
+        clear_bit(STATUS_SCAN_HW, &priv->status);
+        clear_bit(STATUS_SCANNING, &priv->status);
+
         /* inform mac80211 scan aborted */
         queue_work(priv->workqueue, &priv->scan_completed);
         mutex_unlock(&priv->mutex);
diff --git a/drivers/net/wireless/libertas/cmd.c b/drivers/net/wireless/libertas/cmd.c
index 297696de2da0..8265c7d25edc 100644
--- a/drivers/net/wireless/libertas/cmd.c
+++ b/drivers/net/wireless/libertas/cmd.c
@@ -605,9 +605,9 @@ int lbs_get_tx_power(struct lbs_private *priv, s16 *curlevel, s16 *minlevel,
         if (ret == 0) {
                 *curlevel = le16_to_cpu(cmd.curlevel);
                 if (minlevel)
-                        *minlevel = le16_to_cpu(cmd.minlevel);
+                        *minlevel = cmd.minlevel;
                 if (maxlevel)
-                        *maxlevel = le16_to_cpu(cmd.maxlevel);
+                        *maxlevel = cmd.maxlevel;
         }
 
         lbs_deb_leave(LBS_DEB_CMD);
diff --git a/drivers/net/wireless/libertas/scan.c b/drivers/net/wireless/libertas/scan.c
index 8f66903641b9..22c4c6110521 100644
--- a/drivers/net/wireless/libertas/scan.c
+++ b/drivers/net/wireless/libertas/scan.c
@@ -598,8 +598,8 @@ static int lbs_process_bss(struct bss_descriptor *bss,
 
                 switch (elem->id) {
                 case MFIE_TYPE_SSID:
-                        bss->ssid_len = elem->len;
-                        memcpy(bss->ssid, elem->data, elem->len);
+                        bss->ssid_len = min_t(int, 32, elem->len);
+                        memcpy(bss->ssid, elem->data, bss->ssid_len);
                         lbs_deb_scan("got SSID IE: '%s', len %u\n",
                                      escape_essid(bss->ssid, bss->ssid_len),
                                      bss->ssid_len);
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c
index 1cc03a8dd67a..59634c33b1f9 100644
--- a/drivers/net/wireless/libertas_tf/if_usb.c
+++ b/drivers/net/wireless/libertas_tf/if_usb.c
@@ -331,7 +331,7 @@ static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
         /* Fill the receive configuration URB and initialise the Rx call back */
         usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
                           usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
-                          (void *) (skb->tail),
+                          skb_tail_pointer(skb),
                           MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp);
 
         cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index 2d022f83774c..827ca0384a4c 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -319,7 +319,7 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
         void *tmp;
         int err;
         u8 *end = (u8 *)eeprom + len;
-        u16 synth;
+        u16 synth = 0;
         DECLARE_MAC_BUF(mac);
 
         wrap = (struct eeprom_pda_wrap *) eeprom;
@@ -422,7 +422,8 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                 entry = (void *)entry + (entry_len + 1)*2;
         }
 
-        if (!priv->iq_autocal || !priv->output_limit || !priv->curve_data) {
+        if (!synth || !priv->iq_autocal || !priv->output_limit ||
+            !priv->curve_data) {
                 printk(KERN_ERR "p54: not all required entries found in eeprom!\n");
                 err = -EINVAL;
                 goto err;
diff --git a/drivers/net/wireless/p54/p54pci.c b/drivers/net/wireless/p54/p54pci.c
index 1c2a02a741af..88b3cad8b65e 100644
--- a/drivers/net/wireless/p54/p54pci.c
+++ b/drivers/net/wireless/p54/p54pci.c
@@ -346,68 +346,6 @@ static void p54p_tx(struct ieee80211_hw *dev, struct p54_control_hdr *data,
                 printk(KERN_INFO "%s: tx overflow.\n", wiphy_name(dev->wiphy));
 }
 
-static int p54p_open(struct ieee80211_hw *dev)
-{
-        struct p54p_priv *priv = dev->priv;
-        int err;
-
-        init_completion(&priv->boot_comp);
-        err = request_irq(priv->pdev->irq, &p54p_interrupt,
-                          IRQF_SHARED, "p54pci", dev);
-        if (err) {
-                printk(KERN_ERR "%s: failed to register IRQ handler\n",
-                       wiphy_name(dev->wiphy));
-                return err;
-        }
-
-        memset(priv->ring_control, 0, sizeof(*priv->ring_control));
-        err = p54p_upload_firmware(dev);
-        if (err) {
-                free_irq(priv->pdev->irq, dev);
-                return err;
-        }
-        priv->rx_idx_data = priv->tx_idx_data = 0;
-        priv->rx_idx_mgmt = priv->tx_idx_mgmt = 0;
-
-        p54p_refill_rx_ring(dev, 0, priv->ring_control->rx_data,
-                ARRAY_SIZE(priv->ring_control->rx_data), priv->rx_buf_data);
-
-        p54p_refill_rx_ring(dev, 2, priv->ring_control->rx_mgmt,
-                ARRAY_SIZE(priv->ring_control->rx_mgmt), priv->rx_buf_mgmt);
-
-        P54P_WRITE(ring_control_base, cpu_to_le32(priv->ring_control_dma));
-        P54P_READ(ring_control_base);
-        wmb();
-        udelay(10);
-
-        P54P_WRITE(int_enable, cpu_to_le32(ISL38XX_INT_IDENT_INIT));
-        P54P_READ(int_enable);
-        wmb();
-        udelay(10);
-
-        P54P_WRITE(dev_int, cpu_to_le32(ISL38XX_DEV_INT_RESET));
-        P54P_READ(dev_int);
-
-        if (!wait_for_completion_interruptible_timeout(&priv->boot_comp, HZ)) {
-                printk(KERN_ERR "%s: Cannot boot firmware!\n",
-                       wiphy_name(dev->wiphy));
-                free_irq(priv->pdev->irq, dev);
-                return -ETIMEDOUT;
-        }
-
-        P54P_WRITE(int_enable, cpu_to_le32(ISL38XX_INT_IDENT_UPDATE));
-        P54P_READ(int_enable);
-        wmb();
-        udelay(10);
-
-        P54P_WRITE(dev_int, cpu_to_le32(ISL38XX_DEV_INT_UPDATE));
-        P54P_READ(dev_int);
-        wmb();
-        udelay(10);
-
-        return 0;
-}
-
 static void p54p_stop(struct ieee80211_hw *dev)
 {
         struct p54p_priv *priv = dev->priv;
@@ -474,6 +412,68 @@ static void p54p_stop(struct ieee80211_hw *dev)
         memset(ring_control, 0, sizeof(*ring_control));
 }
 
+static int p54p_open(struct ieee80211_hw *dev)
+{
+        struct p54p_priv *priv = dev->priv;
+        int err;
+
+        init_completion(&priv->boot_comp);
+        err = request_irq(priv->pdev->irq, &p54p_interrupt,
+                          IRQF_SHARED, "p54pci", dev);
+        if (err) {
+                printk(KERN_ERR "%s: failed to register IRQ handler\n",
+                       wiphy_name(dev->wiphy));
+                return err;
+        }
+
+        memset(priv->ring_control, 0, sizeof(*priv->ring_control));
+        err = p54p_upload_firmware(dev);
+        if (err) {
+                free_irq(priv->pdev->irq, dev);
+                return err;
+        }
+        priv->rx_idx_data = priv->tx_idx_data = 0;
+        priv->rx_idx_mgmt = priv->tx_idx_mgmt = 0;
+
+        p54p_refill_rx_ring(dev, 0, priv->ring_control->rx_data,
+                ARRAY_SIZE(priv->ring_control->rx_data), priv->rx_buf_data);
+
+        p54p_refill_rx_ring(dev, 2, priv->ring_control->rx_mgmt,
+                ARRAY_SIZE(priv->ring_control->rx_mgmt), priv->rx_buf_mgmt);
+
+        P54P_WRITE(ring_control_base, cpu_to_le32(priv->ring_control_dma));
+        P54P_READ(ring_control_base);
+        wmb();
+        udelay(10);
+
+        P54P_WRITE(int_enable, cpu_to_le32(ISL38XX_INT_IDENT_INIT));
+        P54P_READ(int_enable);
+        wmb();
+        udelay(10);
+
+        P54P_WRITE(dev_int, cpu_to_le32(ISL38XX_DEV_INT_RESET));
+        P54P_READ(dev_int);
+
+        if (!wait_for_completion_interruptible_timeout(&priv->boot_comp, HZ)) {
+                printk(KERN_ERR "%s: Cannot boot firmware!\n",
+                       wiphy_name(dev->wiphy));
+                p54p_stop(dev);
+                return -ETIMEDOUT;
+        }
+
+        P54P_WRITE(int_enable, cpu_to_le32(ISL38XX_INT_IDENT_UPDATE));
+        P54P_READ(int_enable);
+        wmb();
+        udelay(10);
+
+        P54P_WRITE(dev_int, cpu_to_le32(ISL38XX_DEV_INT_UPDATE));
+        P54P_READ(dev_int);
+        wmb();
+        udelay(10);
+
+        return 0;
+}
+
 static int __devinit p54p_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *id)
 {
@@ -556,11 +556,13 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
         spin_lock_init(&priv->lock);
         tasklet_init(&priv->rx_tasklet, p54p_rx_tasklet, (unsigned long)dev);
 
-        p54p_open(dev);
+        err = p54p_open(dev);
+        if (err)
+                goto err_free_common;
         err = p54_read_eeprom(dev);
         p54p_stop(dev);
         if (err)
-                goto err_free_desc;
+                goto err_free_common;
 
         err = ieee80211_register_hw(dev);
         if (err) {
@@ -573,8 +575,6 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
 
  err_free_common:
         p54_free_common(dev);
-
- err_free_desc:
         pci_free_consistent(pdev, sizeof(*priv->ring_control),
                             priv->ring_control, priv->ring_control_dma);
 
diff --git a/drivers/net/wireless/rt2x00/Kconfig b/drivers/net/wireless/rt2x00/Kconfig
index f839ce044afd..95511ac22470 100644
--- a/drivers/net/wireless/rt2x00/Kconfig
+++ b/drivers/net/wireless/rt2x00/Kconfig
@@ -1,5 +1,5 @@
 menuconfig RT2X00
-        bool "Ralink driver support"
+        tristate "Ralink driver support"
         depends on MAC80211 && WLAN_80211 && EXPERIMENTAL
         ---help---
           This will enable the experimental support for the Ralink drivers,
diff --git a/drivers/net/wireless/rtl8187_dev.c b/drivers/net/wireless/rtl8187_dev.c
index 431e3c78bf27..69eb0132593b 100644
--- a/drivers/net/wireless/rtl8187_dev.c
+++ b/drivers/net/wireless/rtl8187_dev.c
@@ -48,6 +48,9 @@ static struct usb_device_id rtl8187_table[] __devinitdata = {
         {USB_DEVICE(0x03f0, 0xca02), .driver_info = DEVICE_RTL8187},
         /* Sitecom */
         {USB_DEVICE(0x0df6, 0x000d), .driver_info = DEVICE_RTL8187},
+        {USB_DEVICE(0x0df6, 0x0028), .driver_info = DEVICE_RTL8187B},
+        /* Abocom */
+        {USB_DEVICE(0x13d1, 0xabe6), .driver_info = DEVICE_RTL8187},
         {}
 };
 
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.c b/drivers/net/wireless/zd1211rw/zd_mac.c
index fe1867b25ff7..cac732f4047f 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.c
+++ b/drivers/net/wireless/zd1211rw/zd_mac.c
@@ -615,7 +615,7 @@ static int filter_ack(struct ieee80211_hw *hw, struct ieee80211_hdr *rx_hdr,
                 struct ieee80211_hdr *tx_hdr;
 
                 tx_hdr = (struct ieee80211_hdr *)skb->data;
-                if (likely(!compare_ether_addr(tx_hdr->addr2, rx_hdr->addr1)))
+                if (likely(!memcmp(tx_hdr->addr2, rx_hdr->addr1, ETH_ALEN)))
                 {
                         __skb_unlink(skb, q);
                         tx_status(hw, skb, IEEE80211_TX_STAT_ACK, stats->signal, 1);
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index a60ae86bd5c9..a3ccd8c1c716 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -61,6 +61,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x0105, 0x145f), .driver_info = DEVICE_ZD1211 },
         /* ZD1211B */
         { USB_DEVICE(0x0ace, 0x1215), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x0ace, 0xb215), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x157e, 0x300d), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x079b, 0x0062), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x1582, 0x6003), .driver_info = DEVICE_ZD1211B },
@@ -82,6 +83,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x0cde, 0x001a), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0586, 0x340a), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
         /* "Driverless" devices that need ejecting */
         { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
         { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index c6948d8f53f6..6d017adc914a 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -1785,7 +1785,7 @@ static int __devexit xennet_remove(struct xenbus_device *dev)
         return 0;
 }
 
-static struct xenbus_driver netfront = {
+static struct xenbus_driver netfront_driver = {
         .name = "vif",
         .owner = THIS_MODULE,
         .ids = netfront_ids,
@@ -1805,7 +1805,7 @@ static int __init netif_init(void)
 
         printk(KERN_INFO "Initialising Xen virtual ethernet driver.\n");
 
-        return xenbus_register_frontend(&netfront);
+        return xenbus_register_frontend(&netfront_driver);
 }
 module_init(netif_init);
 
@@ -1815,7 +1815,7 @@ static void __exit netif_exit(void)
         if (xen_initial_domain())
                 return;
 
-        xenbus_unregister_driver(&netfront);
+        xenbus_unregister_driver(&netfront_driver);
 }
 module_exit(netif_exit);