Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6

Conflicts:

	arch/sparc64/kernel/pci_psycho.c

55 files changed, 617 insertions, 379 deletions

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index a5c141cecd4e..4a11296a9514 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -822,14 +822,14 @@ config ULTRA32
           will be called smc-ultra32.
 
 config BFIN_MAC
-        tristate "Blackfin 527/536/537 on-chip mac support"
-        depends on NET_ETHERNET && (BF527 || BF537 || BF536)
+        tristate "Blackfin on-chip MAC support"
+        depends on NET_ETHERNET && (BF526 || BF527 || BF536 || BF537)
         select CRC32
         select MII
         select PHYLIB
         select BFIN_MAC_USE_L1 if DMA_UNCACHED_NONE
         help
-          This is the driver for blackfin on-chip mac device. Say Y if you want it
+          This is the driver for Blackfin on-chip mac device. Say Y if you want it
           compiled into the kernel. This driver is also available as a module
           ( = code which can be inserted in and removed from the running kernel
           whenever you want). The module will be called bfin_mac.
diff --git a/drivers/net/atl1e/atl1e_main.c b/drivers/net/atl1e/atl1e_main.c
index 82d7be1655d3..7685b995ff9b 100644
--- a/drivers/net/atl1e/atl1e_main.c
+++ b/drivers/net/atl1e/atl1e_main.c
@@ -2232,10 +2232,11 @@ static int atl1e_resume(struct pci_dev *pdev)
 
         AT_WRITE_REG(&adapter->hw, REG_WOL_CTRL, 0);
 
-        if (netif_running(netdev))
+        if (netif_running(netdev)) {
                 err = atl1e_request_irq(adapter);
                 if (err)
                         return err;
+        }
 
         atl1e_reset_hw(&adapter->hw);
 
diff --git a/drivers/net/atlx/atl1.c b/drivers/net/atlx/atl1.c
index e6a7bb79d4df..e23ce77712f1 100644
--- a/drivers/net/atlx/atl1.c
+++ b/drivers/net/atlx/atl1.c
@@ -3022,7 +3022,6 @@ static int __devinit atl1_probe(struct pci_dev *pdev,
         netdev->features = NETIF_F_HW_CSUM;
         netdev->features |= NETIF_F_SG;
         netdev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
-        netdev->features |= NETIF_F_TSO;
         netdev->features |= NETIF_F_LLTX;
 
         /*
diff --git a/drivers/net/bnx2x.h b/drivers/net/bnx2x.h
index b468f904c7f8..fd705d1295a7 100644
--- a/drivers/net/bnx2x.h
+++ b/drivers/net/bnx2x.h
@@ -151,6 +151,8 @@ struct sw_rx_page {
 #define PAGES_PER_SGE_SHIFT             0
 #define PAGES_PER_SGE                   (1 << PAGES_PER_SGE_SHIFT)
 
+#define BCM_RX_ETH_PAYLOAD_ALIGN        64
+
 /* SGE ring related macros */
 #define NUM_RX_SGE_PAGES                2
 #define RX_SGE_CNT              (BCM_PAGE_SIZE / sizeof(struct eth_rx_sge))
@@ -271,7 +273,7 @@ struct bnx2x_fastpath {
                          (fp->tx_pkt_prod != fp->tx_pkt_cons))
 
 #define BNX2X_HAS_RX_WORK(fp) \
-                        (fp->rx_comp_cons != le16_to_cpu(*fp->rx_cons_sb))
+                        (fp->rx_comp_cons != rx_cons_sb)
 
 #define BNX2X_HAS_WORK(fp)      (BNX2X_HAS_RX_WORK(fp) || BNX2X_HAS_TX_WORK(fp))
 
@@ -750,8 +752,7 @@ struct bnx2x {
 
         u32                     rx_csum;
         u32                     rx_offset;
-        u32                     rx_buf_use_size;        /* useable size */
-        u32                     rx_buf_size;            /* with alignment */
+        u32                     rx_buf_size;
 #define ETH_OVREHEAD                    (ETH_HLEN + 8)  /* 8 for CRC + VLAN */
 #define ETH_MIN_PACKET_SIZE             60
 #define ETH_MAX_PACKET_SIZE             1500
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 971576b43687..a8eb3c4a47c8 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.17"
-#define DRV_MODULE_RELDATE      "2008/08/13"
+#define DRV_MODULE_VERSION      "1.45.21"
+#define DRV_MODULE_RELDATE      "2008/09/03"
 #define BNX2X_BC_VER            0x040200
 
 /* Time in jiffies before concluding the transmitter is hung */
@@ -1027,7 +1027,7 @@ static inline int bnx2x_alloc_rx_skb(struct bnx2x *bp,
         if (unlikely(skb == NULL))
                 return -ENOMEM;
 
-        mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
+        mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_size,
                                  PCI_DMA_FROMDEVICE);
         if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
                 dev_kfree_skb(skb);
@@ -1169,7 +1169,7 @@ static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
         /* move empty skb from pool to prod and map it */
         prod_rx_buf->skb = fp->tpa_pool[queue].skb;
         mapping = pci_map_single(bp->pdev, fp->tpa_pool[queue].skb->data,
-                                 bp->rx_buf_use_size, PCI_DMA_FROMDEVICE);
+                                 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
         pci_unmap_addr_set(prod_rx_buf, mapping, mapping);
 
         /* move partial skb from cons to pool (don't unmap yet) */
@@ -1276,7 +1276,7 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
            pool entry status to BNX2X_TPA_STOP even if new skb allocation
            fails. */
         pci_unmap_single(bp->pdev, pci_unmap_addr(rx_buf, mapping),
-                         bp->rx_buf_use_size, PCI_DMA_FROMDEVICE);
+                         bp->rx_buf_size, PCI_DMA_FROMDEVICE);
 
         if (likely(new_skb)) {
                 /* fix ip xsum and give it to the stack */
@@ -1520,7 +1520,7 @@ static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                         } else if (bnx2x_alloc_rx_skb(bp, fp, bd_prod) == 0) {
                                 pci_unmap_single(bp->pdev,
                                         pci_unmap_addr(rx_buf, mapping),
-                                                 bp->rx_buf_use_size,
+                                                 bp->rx_buf_size,
                                                  PCI_DMA_FROMDEVICE);
                                 skb_reserve(skb, pad);
                                 skb_put(skb, len);
@@ -1717,8 +1717,8 @@ static int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
                 return -EEXIST;
         }
 
-        /* Try for 1 second every 5ms */
-        for (cnt = 0; cnt < 200; cnt++) {
+        /* Try for 5 second every 5ms */
+        for (cnt = 0; cnt < 1000; cnt++) {
                 /* Try to acquire the lock */
                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
                 lock_status = REG_RD(bp, hw_lock_control_reg);
@@ -2550,6 +2550,7 @@ static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
                 BNX2X_ERR("SPIO5 hw attention\n");
 
                 switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
+                case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
                 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
                         /* Fan failure attention */
 
@@ -4228,7 +4229,7 @@ static inline void bnx2x_free_tpa_pool(struct bnx2x *bp,
                 if (fp->tpa_state[i] == BNX2X_TPA_START)
                         pci_unmap_single(bp->pdev,
                                          pci_unmap_addr(rx_buf, mapping),
-                                         bp->rx_buf_use_size,
+                                         bp->rx_buf_size,
                                          PCI_DMA_FROMDEVICE);
 
                 dev_kfree_skb(skb);
@@ -4244,15 +4245,14 @@ static void bnx2x_init_rx_rings(struct bnx2x *bp)
         u16 ring_prod, cqe_ring_prod;
         int i, j;
 
-        bp->rx_buf_use_size = bp->dev->mtu;
-        bp->rx_buf_use_size += bp->rx_offset + ETH_OVREHEAD;
-        bp->rx_buf_size = bp->rx_buf_use_size + 64;
+        bp->rx_buf_size = bp->dev->mtu;
+        bp->rx_buf_size += bp->rx_offset + ETH_OVREHEAD +
+                BCM_RX_ETH_PAYLOAD_ALIGN;
 
         if (bp->flags & TPA_ENABLE_FLAG) {
                 DP(NETIF_MSG_IFUP,
-                   "rx_buf_use_size %d  rx_buf_size %d  effective_mtu %d\n",
-                   bp->rx_buf_use_size, bp->rx_buf_size,
-                   bp->dev->mtu + ETH_OVREHEAD);
+                   "rx_buf_size %d  effective_mtu %d\n",
+                   bp->rx_buf_size, bp->dev->mtu + ETH_OVREHEAD);
 
                 for_each_queue(bp, j) {
                         struct bnx2x_fastpath *fp = &bp->fp[j];
@@ -4461,9 +4461,10 @@ static void bnx2x_init_context(struct bnx2x *bp)
                 context->ustorm_st_context.common.status_block_id = sb_id;
                 context->ustorm_st_context.common.flags =
                         USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_MC_ALIGNMENT;
-                context->ustorm_st_context.common.mc_alignment_size = 64;
+                context->ustorm_st_context.common.mc_alignment_size =
+                        BCM_RX_ETH_PAYLOAD_ALIGN;
                 context->ustorm_st_context.common.bd_buff_size =
-                                                bp->rx_buf_use_size;
+                                                bp->rx_buf_size;
                 context->ustorm_st_context.common.bd_page_base_hi =
                                                 U64_HI(fp->rx_desc_mapping);
                 context->ustorm_st_context.common.bd_page_base_lo =
@@ -4605,6 +4606,17 @@ static void bnx2x_init_internal_common(struct bnx2x *bp)
 {
         int i;
 
+        if (bp->flags & TPA_ENABLE_FLAG) {
+                struct tstorm_eth_tpa_exist tpa = {0};
+
+                tpa.tpa_exist = 1;
+
+                REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET,
+                       ((u32 *)&tpa)[0]);
+                REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET + 4,
+                       ((u32 *)&tpa)[1]);
+        }
+
         /* Zero this manually as its initialization is
            currently missing in the initTool */
         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
@@ -4705,7 +4717,7 @@ static void bnx2x_init_internal_func(struct bnx2x *bp)
         }
 
         /* Init CQ ring mapping and aggregation size */
-        max_agg_size = min((u32)(bp->rx_buf_use_size +
+        max_agg_size = min((u32)(bp->rx_buf_size +
                                  8*BCM_PAGE_SIZE*PAGES_PER_SGE),
                            (u32)0xffff);
         for_each_queue(bp, i) {
@@ -5337,6 +5349,7 @@ static int bnx2x_init_common(struct bnx2x *bp)
         }
 
         switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
+        case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
         case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
                 /* Fan failure is indicated by SPIO 5 */
                 bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
@@ -5363,17 +5376,6 @@ static int bnx2x_init_common(struct bnx2x *bp)
 
         enable_blocks_attention(bp);
 
-        if (bp->flags & TPA_ENABLE_FLAG) {
-                struct tstorm_eth_tpa_exist tmp = {0};
-
-                tmp.tpa_exist = 1;
-
-                REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET,
-                       ((u32 *)&tmp)[0]);
-                REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET + 4,
-                       ((u32 *)&tmp)[1]);
-        }
-
         if (!BP_NOMCP(bp)) {
                 bnx2x_acquire_phy_lock(bp);
                 bnx2x_common_init_phy(bp, bp->common.shmem_base);
@@ -5531,6 +5533,7 @@ static int bnx2x_init_port(struct bnx2x *bp)
         /* Port DMAE comes here */
 
         switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
+        case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
         case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
                 /* add SPIO 5 to group 0 */
                 val = REG_RD(bp, MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
@@ -5937,7 +5940,7 @@ static void bnx2x_free_rx_skbs(struct bnx2x *bp)
 
                         pci_unmap_single(bp->pdev,
                                          pci_unmap_addr(rx_buf, mapping),
-                                         bp->rx_buf_use_size,
+                                         bp->rx_buf_size,
                                          PCI_DMA_FROMDEVICE);
 
                         rx_buf->skb = NULL;
@@ -6055,6 +6058,44 @@ static int bnx2x_req_irq(struct bnx2x *bp)
         return rc;
 }
 
+static void bnx2x_napi_enable(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_queue(bp, i)
+                napi_enable(&bnx2x_fp(bp, i, napi));
+}
+
+static void bnx2x_napi_disable(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_queue(bp, i)
+                napi_disable(&bnx2x_fp(bp, i, napi));
+}
+
+static void bnx2x_netif_start(struct bnx2x *bp)
+{
+        if (atomic_dec_and_test(&bp->intr_sem)) {
+                if (netif_running(bp->dev)) {
+                        if (bp->state == BNX2X_STATE_OPEN)
+                                netif_wake_queue(bp->dev);
+                        bnx2x_napi_enable(bp);
+                        bnx2x_int_enable(bp);
+                }
+        }
+}
+
+static void bnx2x_netif_stop(struct bnx2x *bp)
+{
+        bnx2x_int_disable_sync(bp);
+        if (netif_running(bp->dev)) {
+                bnx2x_napi_disable(bp);
+                netif_tx_disable(bp->dev);
+                bp->dev->trans_start = jiffies; /* prevent tx timeout */
+        }
+}
+
 /*
  * Init service functions
  */
@@ -6338,7 +6379,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         rc = bnx2x_init_hw(bp, load_code);
         if (rc) {
                 BNX2X_ERR("HW init failed, aborting\n");
-                goto load_error;
+                goto load_int_disable;
         }
 
         /* Setup NIC internals and enable interrupts */
@@ -6350,7 +6391,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 if (!load_code) {
                         BNX2X_ERR("MCP response failure, aborting\n");
                         rc = -EBUSY;
-                        goto load_int_disable;
+                        goto load_rings_free;
                 }
         }
 
@@ -6360,8 +6401,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         /* Enable Rx interrupt handling before sending the ramrod
            as it's completed on Rx FP queue */
-        for_each_queue(bp, i)
-                napi_enable(&bnx2x_fp(bp, i, napi));
+        bnx2x_napi_enable(bp);
 
         /* Enable interrupt handling */
         atomic_set(&bp->intr_sem, 0);
@@ -6369,7 +6409,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         rc = bnx2x_setup_leading(bp);
         if (rc) {
                 BNX2X_ERR("Setup leading failed!\n");
-                goto load_stop_netif;
+                goto load_netif_stop;
         }
 
         if (CHIP_IS_E1H(bp))
@@ -6382,7 +6422,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 for_each_nondefault_queue(bp, i) {
                         rc = bnx2x_setup_multi(bp, i);
                         if (rc)
-                                goto load_stop_netif;
+                                goto load_netif_stop;
                 }
 
         if (CHIP_IS_E1(bp))
@@ -6427,20 +6467,17 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         return 0;
 
-load_stop_netif:
+load_netif_stop:
+        bnx2x_napi_disable(bp);
+load_rings_free:
+        /* Free SKBs, SGEs, TPA pool and driver internals */
+        bnx2x_free_skbs(bp);
         for_each_queue(bp, i)
-                napi_disable(&bnx2x_fp(bp, i, napi));
-
+                bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
 load_int_disable:
         bnx2x_int_disable_sync(bp);
-
         /* Release IRQs */
         bnx2x_free_irq(bp);
-
-        /* Free SKBs, SGEs, TPA pool and driver internals */
-        bnx2x_free_skbs(bp);
-        for_each_queue(bp, i)
-                bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
 load_error:
         bnx2x_free_mem(bp);
 
@@ -6455,7 +6492,7 @@ static int bnx2x_stop_multi(struct bnx2x *bp, int index)
 
         /* halt the connection */
         bp->fp[index].state = BNX2X_FP_STATE_HALTING;
-        bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, index, 0, 0, 0);
+        bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, index, 0, index, 0);
 
         /* Wait for completion */
         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, index,
@@ -6613,11 +6650,9 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
         bp->rx_mode = BNX2X_RX_MODE_NONE;
         bnx2x_set_storm_rx_mode(bp);
 
-        if (netif_running(bp->dev)) {
-                netif_tx_disable(bp->dev);
-                bp->dev->trans_start = jiffies; /* prevent tx timeout */
-        }
-
+        bnx2x_netif_stop(bp);
+        if (!netif_running(bp->dev))
+                bnx2x_napi_disable(bp);
         del_timer_sync(&bp->timer);
         SHMEM_WR(bp, func_mb[BP_FUNC(bp)].drv_pulse_mb,
                  (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
@@ -6631,9 +6666,7 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
                 smp_rmb();
                 while (BNX2X_HAS_TX_WORK(fp)) {
 
-                        if (!netif_running(bp->dev))
-                                bnx2x_tx_int(fp, 1000);
-
+                        bnx2x_tx_int(fp, 1000);
                         if (!cnt) {
                                 BNX2X_ERR("timeout waiting for queue[%d]\n",
                                           i);
@@ -6649,46 +6682,12 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
                         smp_rmb();
                 }
         }
-
         /* Give HW time to discard old tx messages */
         msleep(1);
 
-        for_each_queue(bp, i)
-                napi_disable(&bnx2x_fp(bp, i, napi));
-        /* Disable interrupts after Tx and Rx are disabled on stack level */
-        bnx2x_int_disable_sync(bp);
-
         /* Release IRQs */
         bnx2x_free_irq(bp);
 
-        if (unload_mode == UNLOAD_NORMAL)
-                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
-
-        else if (bp->flags & NO_WOL_FLAG) {
-                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
-                if (CHIP_IS_E1H(bp))
-                        REG_WR(bp, MISC_REG_E1HMF_MODE, 0);
-
-        } else if (bp->wol) {
-                u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
-                u8 *mac_addr = bp->dev->dev_addr;
-                u32 val;
-                /* The mac address is written to entries 1-4 to
-                   preserve entry 0 which is used by the PMF */
-                u8 entry = (BP_E1HVN(bp) + 1)*8;
-
-                val = (mac_addr[0] << 8) | mac_addr[1];
-                EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
-
-                val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
-                      (mac_addr[4] << 8) | mac_addr[5];
-                EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
-
-                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
-
-        } else
-                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
-
         if (CHIP_IS_E1(bp)) {
                 struct mac_configuration_cmd *config =
                                                 bnx2x_sp(bp, mcast_config);
@@ -6711,14 +6710,41 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
                               U64_LO(bnx2x_sp_mapping(bp, mcast_config)), 0);
 
         } else { /* E1H */
+                REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
+
                 bnx2x_set_mac_addr_e1h(bp, 0);
 
                 for (i = 0; i < MC_HASH_SIZE; i++)
                         REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
         }
 
-        if (CHIP_IS_E1H(bp))
-                REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
+        if (unload_mode == UNLOAD_NORMAL)
+                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
+
+        else if (bp->flags & NO_WOL_FLAG) {
+                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
+                if (CHIP_IS_E1H(bp))
+                        REG_WR(bp, MISC_REG_E1HMF_MODE, 0);
+
+        } else if (bp->wol) {
+                u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
+                u8 *mac_addr = bp->dev->dev_addr;
+                u32 val;
+                /* The mac address is written to entries 1-4 to
+                   preserve entry 0 which is used by the PMF */
+                u8 entry = (BP_E1HVN(bp) + 1)*8;
+
+                val = (mac_addr[0] << 8) | mac_addr[1];
+                EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
+
+                val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
+                      (mac_addr[4] << 8) | mac_addr[5];
+                EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
+
+                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
+
+        } else
+                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
 
         /* Close multi and leading connections
            Completions for ramrods are collected in a synchronous way */
@@ -6821,6 +6847,10 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                  */
                 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
+                if (val == 0x7)
+                        REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
+                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
+
                 if (val == 0x7) {
                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
                         /* save our func */
@@ -6898,7 +6928,6 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                                (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
                                 DRV_MSG_SEQ_NUMBER_MASK);
                 }
-                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
         }
 }
 
@@ -8617,34 +8646,6 @@ test_mem_exit:
         return rc;
 }
 
-static void bnx2x_netif_start(struct bnx2x *bp)
-{
-        int i;
-
-        if (atomic_dec_and_test(&bp->intr_sem)) {
-                if (netif_running(bp->dev)) {
-                        bnx2x_int_enable(bp);
-                        for_each_queue(bp, i)
-                                napi_enable(&bnx2x_fp(bp, i, napi));
-                        if (bp->state == BNX2X_STATE_OPEN)
-                                netif_wake_queue(bp->dev);
-                }
-        }
-}
-
-static void bnx2x_netif_stop(struct bnx2x *bp)
-{
-        int i;
-
-        if (netif_running(bp->dev)) {
-                netif_tx_disable(bp->dev);
-                bp->dev->trans_start = jiffies; /* prevent tx timeout */
-                for_each_queue(bp, i)
-                        napi_disable(&bnx2x_fp(bp, i, napi));
-        }
-        bnx2x_int_disable_sync(bp);
-}
-
 static void bnx2x_wait_for_link(struct bnx2x *bp, u8 link_up)
 {
         int cnt = 1000;
@@ -9250,6 +9251,7 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
                                                  napi);
         struct bnx2x *bp = fp->bp;
         int work_done = 0;
+        u16 rx_cons_sb;
 
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic))
@@ -9265,10 +9267,16 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
         if (BNX2X_HAS_TX_WORK(fp))
                 bnx2x_tx_int(fp, budget);
 
+        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
+        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
+                rx_cons_sb++;
         if (BNX2X_HAS_RX_WORK(fp))
                 work_done = bnx2x_rx_int(fp, budget);
 
         rmb(); /* BNX2X_HAS_WORK() reads the status block */
+        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
+        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
+                rx_cons_sb++;
 
         /* must not complete if we consumed full budget */
         if ((work_done < budget) && !BNX2X_HAS_WORK(fp)) {
@@ -9484,8 +9492,7 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         fp_index = (smp_processor_id() % bp->num_queues);
         fp = &bp->fp[fp_index];
 
-        if (unlikely(bnx2x_tx_avail(bp->fp) <
-                                        (skb_shinfo(skb)->nr_frags + 3))) {
+        if (unlikely(bnx2x_tx_avail(fp) < (skb_shinfo(skb)->nr_frags + 3))) {
                 bp->eth_stats.driver_xoff++,
                 netif_stop_queue(dev);
                 BNX2X_ERR("BUG! Tx ring full when queue awake!\n");
@@ -9548,7 +9555,6 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 tx_bd->vlan = cpu_to_le16(pkt_prod);
 
         if (xmit_type) {
-
                 /* turn on parsing and get a BD */
                 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
                 pbd = (void *)&fp->tx_desc_ring[bd_prod];
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 19d32a227be1..453115acaad2 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -1838,7 +1838,7 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx,
                 if ((le16_to_cpu(rfd->command) & cb_el) &&
                     (RU_RUNNING == nic->ru_running))
 
-                        if (readb(&nic->csr->scb.status) & rus_no_res)
+                        if (ioread8(&nic->csr->scb.status) & rus_no_res)
                                 nic->ru_running = RU_SUSPENDED;
                 return -ENODATA;
         }
@@ -1861,7 +1861,7 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx,
         if ((le16_to_cpu(rfd->command) & cb_el) &&
             (RU_RUNNING == nic->ru_running)) {
 
-            if (readb(&nic->csr->scb.status) & rus_no_res)
+            if (ioread8(&nic->csr->scb.status) & rus_no_res)
                 nic->ru_running = RU_SUSPENDED;
         }
 
diff --git a/drivers/net/e1000/e1000_param.c b/drivers/net/e1000/e1000_param.c
index b9f90a5d3d4d..213437d13154 100644
--- a/drivers/net/e1000/e1000_param.c
+++ b/drivers/net/e1000/e1000_param.c
@@ -208,7 +208,7 @@ struct e1000_option {
                 } r;
                 struct { /* list_option info */
                         int nr;
-                        struct e1000_opt_list { int i; char *str; } *p;
+                        const struct e1000_opt_list { int i; char *str; } *p;
                 } l;
         } arg;
 };
@@ -242,7 +242,7 @@ static int __devinit e1000_validate_option(unsigned int *value,
                 break;
         case list_option: {
                 int i;
-                struct e1000_opt_list *ent;
+                const struct e1000_opt_list *ent;
 
                 for (i = 0; i < opt->arg.l.nr; i++) {
                         ent = &opt->arg.l.p[i];
@@ -279,7 +279,9 @@ static void e1000_check_copper_options(struct e1000_adapter *adapter);
 
 void __devinit e1000_check_options(struct e1000_adapter *adapter)
 {
+        struct e1000_option opt;
         int bd = adapter->bd_number;
+
         if (bd >= E1000_MAX_NIC) {
                 DPRINTK(PROBE, NOTICE,
                        "Warning: no configuration for board #%i\n", bd);
@@ -287,19 +289,21 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
         }
 
         { /* Transmit Descriptor Count */
-                struct e1000_option opt = {
+                struct e1000_tx_ring *tx_ring = adapter->tx_ring;
+                int i;
+                e1000_mac_type mac_type = adapter->hw.mac_type;
+
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Transmit Descriptors",
                         .err  = "using default of "
                                 __MODULE_STRING(E1000_DEFAULT_TXD),
                         .def  = E1000_DEFAULT_TXD,
-                        .arg  = { .r = { .min = E1000_MIN_TXD }}
+                        .arg  = { .r = {
+                                .min = E1000_MIN_TXD,
+                                .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD
+                                }}
                 };
-                struct e1000_tx_ring *tx_ring = adapter->tx_ring;
-                int i;
-                e1000_mac_type mac_type = adapter->hw.mac_type;
-                opt.arg.r.max = mac_type < e1000_82544 ?
-                        E1000_MAX_TXD : E1000_MAX_82544_TXD;
 
                 if (num_TxDescriptors > bd) {
                         tx_ring->count = TxDescriptors[bd];
@@ -313,19 +317,21 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                         tx_ring[i].count = tx_ring->count;
         }
         { /* Receive Descriptor Count */
-                struct e1000_option opt = {
+                struct e1000_rx_ring *rx_ring = adapter->rx_ring;
+                int i;
+                e1000_mac_type mac_type = adapter->hw.mac_type;
+
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Receive Descriptors",
                         .err  = "using default of "
                                 __MODULE_STRING(E1000_DEFAULT_RXD),
                         .def  = E1000_DEFAULT_RXD,
-                        .arg  = { .r = { .min = E1000_MIN_RXD }}
+                        .arg  = { .r = {
+                                .min = E1000_MIN_RXD,
+                                .max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD
+                        }}
                 };
-                struct e1000_rx_ring *rx_ring = adapter->rx_ring;
-                int i;
-                e1000_mac_type mac_type = adapter->hw.mac_type;
-                opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD :
-                        E1000_MAX_82544_RXD;
 
                 if (num_RxDescriptors > bd) {
                         rx_ring->count = RxDescriptors[bd];
@@ -339,7 +345,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                         rx_ring[i].count = rx_ring->count;
         }
         { /* Checksum Offload Enable/Disable */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = enable_option,
                         .name = "Checksum Offload",
                         .err  = "defaulting to Enabled",
@@ -363,7 +369,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                          { E1000_FC_FULL,    "Flow Control Enabled" },
                          { E1000_FC_DEFAULT, "Flow Control Hardware Default" }};
 
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = list_option,
                         .name = "Flow Control",
                         .err  = "reading default settings from EEPROM",
@@ -381,7 +387,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Transmit Interrupt Delay */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Transmit Interrupt Delay",
                         .err  = "using default of " __MODULE_STRING(DEFAULT_TIDV),
@@ -399,7 +405,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Transmit Absolute Interrupt Delay */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Transmit Absolute Interrupt Delay",
                         .err  = "using default of " __MODULE_STRING(DEFAULT_TADV),
@@ -417,7 +423,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Receive Interrupt Delay */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Receive Interrupt Delay",
                         .err  = "using default of " __MODULE_STRING(DEFAULT_RDTR),
@@ -435,7 +441,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Receive Absolute Interrupt Delay */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Receive Absolute Interrupt Delay",
                         .err  = "using default of " __MODULE_STRING(DEFAULT_RADV),
@@ -453,7 +459,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Interrupt Throttling Rate */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = range_option,
                         .name = "Interrupt Throttling Rate (ints/sec)",
                         .err  = "using default of " __MODULE_STRING(DEFAULT_ITR),
@@ -497,7 +503,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Smart Power Down */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = enable_option,
                         .name = "PHY Smart Power Down",
                         .err  = "defaulting to Disabled",
@@ -513,7 +519,7 @@ void __devinit e1000_check_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Kumeran Lock Loss Workaround */
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = enable_option,
                         .name = "Kumeran Lock Loss Workaround",
                         .err  = "defaulting to Enabled",
@@ -578,16 +584,18 @@ static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter)
 
 static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
 {
+        struct e1000_option opt;
         unsigned int speed, dplx, an;
         int bd = adapter->bd_number;
 
         { /* Speed */
-                struct e1000_opt_list speed_list[] = {{          0, "" },
-                                                      {   SPEED_10, "" },
-                                                      {  SPEED_100, "" },
-                                                      { SPEED_1000, "" }};
+                static const struct e1000_opt_list speed_list[] = {
+                        {          0, "" },
+                        {   SPEED_10, "" },
+                        {  SPEED_100, "" },
+                        { SPEED_1000, "" }};
 
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = list_option,
                         .name = "Speed",
                         .err  = "parameter ignored",
@@ -604,11 +612,12 @@ static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
                 }
         }
         { /* Duplex */
-                struct e1000_opt_list dplx_list[] = {{           0, "" },
-                                                     { HALF_DUPLEX, "" },
-                                                     { FULL_DUPLEX, "" }};
+                static const struct e1000_opt_list dplx_list[] = {
+                        {           0, "" },
+                        { HALF_DUPLEX, "" },
+                        { FULL_DUPLEX, "" }};
 
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = list_option,
                         .name = "Duplex",
                         .err  = "parameter ignored",
@@ -637,7 +646,7 @@ static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
                        "parameter ignored\n");
                 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
         } else { /* Autoneg */
-                struct e1000_opt_list an_list[] =
+                static const struct e1000_opt_list an_list[] =
                         #define AA "AutoNeg advertising "
                         {{ 0x01, AA "10/HD" },
                          { 0x02, AA "10/FD" },
@@ -671,7 +680,7 @@ static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
                          { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
                          { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};
 
-                struct e1000_option opt = {
+                opt = (struct e1000_option) {
                         .type = list_option,
                         .name = "AutoNeg",
                         .err  = "parameter ignored",
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 053971e5fc94..0b6ecef9a849 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -5522,7 +5522,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         if (id->driver_data & DEV_HAS_CHECKSUM) {
                 np->rx_csum = 1;
                 np->txrxctl_bits |= NVREG_TXRXCTL_RXCHECK;
-                dev->features |= NETIF_F_HW_CSUM | NETIF_F_SG;
+                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
                 dev->features |= NETIF_F_TSO;
         }
 
@@ -5835,7 +5835,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
 
         dev_printk(KERN_INFO, &pci_dev->dev, "%s%s%s%s%s%s%s%s%s%sdesc-v%u\n",
                    dev->features & NETIF_F_HIGHDMA ? "highdma " : "",
-                   dev->features & (NETIF_F_HW_CSUM | NETIF_F_SG) ?
+                   dev->features & (NETIF_F_IP_CSUM | NETIF_F_SG) ?
                         "csum " : "",
                    dev->features & (NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX) ?
                         "vlan " : "",
@@ -5975,10 +5975,12 @@ static void nv_shutdown(struct pci_dev *pdev)
         if (netif_running(dev))
                 nv_close(dev);
 
-        pci_enable_wake(pdev, PCI_D3hot, np->wolenabled);
-        pci_enable_wake(pdev, PCI_D3cold, np->wolenabled);
         pci_disable_device(pdev);
-        pci_set_power_state(pdev, PCI_D3hot);
+        if (system_state == SYSTEM_POWER_OFF) {
+                if (pci_enable_wake(pdev, PCI_D3cold, np->wolenabled))
+                        pci_enable_wake(pdev, PCI_D3hot, np->wolenabled);
+                pci_set_power_state(pdev, PCI_D3hot);
+        }
 }
 #else
 #define nv_suspend NULL
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index 9a51ec8293cc..9d461825bf4c 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -792,6 +792,10 @@ static int fs_enet_open(struct net_device *dev)
         int r;
         int err;
 
+        /* to initialize the fep->cur_rx,... */
+        /* not doing this, will cause a crash in fs_enet_rx_napi */
+        fs_init_bds(fep->ndev);
+
         if (fep->fpi->use_napi)
                 napi_enable(&fep->napi);
 
@@ -1167,6 +1171,10 @@ static struct of_device_id fs_enet_match[] = {
                 .compatible = "fsl,cpm1-scc-enet",
                 .data = (void *)&fs_scc_ops,
         },
+        {
+                .compatible = "fsl,cpm2-scc-enet",
+                .data = (void *)&fs_scc_ops,
+        },
 #endif
 #ifdef CONFIG_FS_ENET_HAS_FCC
         {
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index 029b3c7ef29c..22f50dd8b277 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -47,7 +47,6 @@
 #include "fs_enet.h"
 
 /*************************************************/
-
 #if defined(CONFIG_CPM1)
 /* for a 8xx __raw_xxx's are sufficient */
 #define __fs_out32(addr, x)     __raw_writel(x, addr)
@@ -62,6 +61,8 @@
 #define __fs_out16(addr, x)     out_be16(addr, x)
 #define __fs_in32(addr) in_be32(addr)
 #define __fs_in16(addr) in_be16(addr)
+#define __fs_out8(addr, x)      out_8(addr, x)
+#define __fs_in8(addr)  in_8(addr)
 #endif
 
 /* write, read, set bits, clear bits */
@@ -262,8 +263,13 @@ static void restart(struct net_device *dev)
 
         /* Initialize function code registers for big-endian.
          */
+#ifndef CONFIG_NOT_COHERENT_CACHE
+        W8(ep, sen_genscc.scc_rfcr, SCC_EB | SCC_GBL);
+        W8(ep, sen_genscc.scc_tfcr, SCC_EB | SCC_GBL);
+#else
         W8(ep, sen_genscc.scc_rfcr, SCC_EB);
         W8(ep, sen_genscc.scc_tfcr, SCC_EB);
+#endif
 
         /* Set maximum bytes per receive buffer.
          * This appears to be an Ethernet frame size, not the buffer
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 999d69168277..4320a983a588 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -105,6 +105,7 @@ const char gfar_driver_version[] = "1.3";
 
 static int gfar_enet_open(struct net_device *dev);
 static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev);
+static void gfar_reset_task(struct work_struct *work);
 static void gfar_timeout(struct net_device *dev);
 static int gfar_close(struct net_device *dev);
 struct sk_buff *gfar_new_skb(struct net_device *dev);
@@ -209,6 +210,7 @@ static int gfar_probe(struct platform_device *pdev)
         spin_lock_init(&priv->txlock);
         spin_lock_init(&priv->rxlock);
         spin_lock_init(&priv->bflock);
+        INIT_WORK(&priv->reset_task, gfar_reset_task);
 
         platform_set_drvdata(pdev, dev);
 
@@ -1212,6 +1214,7 @@ static int gfar_close(struct net_device *dev)
 
         napi_disable(&priv->napi);
 
+        cancel_work_sync(&priv->reset_task);
         stop_gfar(dev);
 
         /* Disconnect from the PHY */
@@ -1326,13 +1329,16 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
         return 0;
 }
 
-/* gfar_timeout gets called when a packet has not been
+/* gfar_reset_task gets scheduled when a packet has not been
  * transmitted after a set amount of time.
  * For now, assume that clearing out all the structures, and
- * starting over will fix the problem. */
-static void gfar_timeout(struct net_device *dev)
+ * starting over will fix the problem.
+ */
+static void gfar_reset_task(struct work_struct *work)
 {
-        dev->stats.tx_errors++;
+        struct gfar_private *priv = container_of(work, struct gfar_private,
+                        reset_task);
+        struct net_device *dev = priv->dev;
 
         if (dev->flags & IFF_UP) {
                 stop_gfar(dev);
@@ -1342,6 +1348,14 @@ static void gfar_timeout(struct net_device *dev)
         netif_tx_schedule_all(dev);
 }
 
+static void gfar_timeout(struct net_device *dev)
+{
+        struct gfar_private *priv = netdev_priv(dev);
+
+        dev->stats.tx_errors++;
+        schedule_work(&priv->reset_task);
+}
+
 /* Interrupt Handler for Transmit complete */
 static int gfar_clean_tx_ring(struct net_device *dev)
 {
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index d59df98bd636..f46e9b63af13 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -756,6 +756,7 @@ struct gfar_private {
 
         uint32_t msg_enable;
 
+        struct work_struct reset_task;
         /* Network Statistics */
         struct gfar_extra_stats extra_stats;
 };
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index 2e720f26ca83..ccd9d9058f6d 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -663,9 +663,6 @@ static int emac_configure(struct emac_instance *dev)
         if (emac_phy_gpcs(dev->phy.mode))
                 emac_mii_reset_phy(&dev->phy);
 
-        /* Required for Pause packet support in EMAC */
-        dev_mc_add(ndev, default_mcast_addr, sizeof(default_mcast_addr), 1);
-
         return 0;
 }
 
@@ -1150,6 +1147,9 @@ static int emac_open(struct net_device *ndev)
         } else
                 netif_carrier_on(dev->ndev);
 
+        /* Required for Pause packet support in EMAC */
+        dev_mc_add(ndev, default_mcast_addr, sizeof(default_mcast_addr), 1);
+
         emac_configure(dev);
         mal_poll_add(dev->mal, &dev->commac);
         mal_enable_tx_channel(dev->mal, dev->mal_tx_chan);
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index a03fe1fb61ca..c2d57f836088 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -904,8 +904,6 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
         unsigned long data_dma_addr;
 
         desc.fields.flags_len = IBMVETH_BUF_VALID | skb->len;
-        data_dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
-                                       skb->len, DMA_TO_DEVICE);
 
         if (skb->ip_summed == CHECKSUM_PARTIAL &&
             ip_hdr(skb)->protocol != IPPROTO_TCP && skb_checksum_help(skb)) {
@@ -924,6 +922,8 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                 buf[1] = 0;
         }
 
+        data_dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
+                                       skb->len, DMA_TO_DEVICE);
         if (dma_mapping_error(&adapter->vdev->dev, data_dma_addr)) {
                 if (!firmware_has_feature(FW_FEATURE_CMO))
                         ibmveth_error_printk("tx: unable to map xmit buffer\n");
@@ -932,6 +932,7 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                 desc.fields.address = adapter->bounce_buffer_dma;
                 tx_map_failed++;
                 used_bounce = 1;
+                wmb();
         } else
                 desc.fields.address = data_dma_addr;
 
diff --git a/drivers/net/igb/e1000_82575.c b/drivers/net/igb/e1000_82575.c
index bb823acc7443..f5e2e7235fcb 100644
--- a/drivers/net/igb/e1000_82575.c
+++ b/drivers/net/igb/e1000_82575.c
@@ -87,7 +87,6 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
         case E1000_DEV_ID_82576:
         case E1000_DEV_ID_82576_FIBER:
         case E1000_DEV_ID_82576_SERDES:
-        case E1000_DEV_ID_82576_QUAD_COPPER:
                 mac->type = e1000_82576;
                 break;
         default:
diff --git a/drivers/net/igb/e1000_hw.h b/drivers/net/igb/e1000_hw.h
index a65ccc3095c3..99504a600a80 100644
--- a/drivers/net/igb/e1000_hw.h
+++ b/drivers/net/igb/e1000_hw.h
@@ -41,7 +41,6 @@ struct e1000_hw;
 #define E1000_DEV_ID_82576                    0x10C9
 #define E1000_DEV_ID_82576_FIBER              0x10E6
 #define E1000_DEV_ID_82576_SERDES             0x10E7
-#define E1000_DEV_ID_82576_QUAD_COPPER        0x10E8
 #define E1000_DEV_ID_82575EB_COPPER           0x10A7
 #define E1000_DEV_ID_82575EB_FIBER_SERDES     0x10A9
 #define E1000_DEV_ID_82575GB_QUAD_COPPER      0x10D6
diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c
index 11aee1309951..58906c984be9 100644
--- a/drivers/net/igb/igb_ethtool.c
+++ b/drivers/net/igb/igb_ethtool.c
@@ -373,13 +373,17 @@ static void igb_get_regs(struct net_device *netdev,
         regs_buff[12] = rd32(E1000_EECD);
 
         /* Interrupt */
-        regs_buff[13] = rd32(E1000_EICR);
+        /* Reading EICS for EICR because they read the
+         * same but EICS does not clear on read */
+        regs_buff[13] = rd32(E1000_EICS);
         regs_buff[14] = rd32(E1000_EICS);
         regs_buff[15] = rd32(E1000_EIMS);
         regs_buff[16] = rd32(E1000_EIMC);
         regs_buff[17] = rd32(E1000_EIAC);
         regs_buff[18] = rd32(E1000_EIAM);
-        regs_buff[19] = rd32(E1000_ICR);
+        /* Reading ICS for ICR because they read the
+         * same but ICS does not clear on read */
+        regs_buff[19] = rd32(E1000_ICS);
         regs_buff[20] = rd32(E1000_ICS);
         regs_buff[21] = rd32(E1000_IMS);
         regs_buff[22] = rd32(E1000_IMC);
@@ -1746,15 +1750,6 @@ static int igb_wol_exclusion(struct igb_adapter *adapter,
                 /* return success for non excluded adapter ports */
                 retval = 0;
                 break;
-        case E1000_DEV_ID_82576_QUAD_COPPER:
-                /* quad port adapters only support WoL on port A */
-                if (!(adapter->flags & IGB_FLAG_QUAD_PORT_A)) {
-                        wol->supported = 0;
-                        break;
-                }
-                /* return success for non excluded adapter ports */
-                retval = 0;
-                break;
         default:
                 /* dual port cards only support WoL on port A from now on
                  * unless it was enabled in the eeprom for port B
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 8f66e15ec8d6..634c4c9d87be 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -61,7 +61,6 @@ static struct pci_device_id igb_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), board_82575 },
-        { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575GB_QUAD_COPPER), board_82575 },
@@ -521,7 +520,7 @@ static void igb_set_interrupt_capability(struct igb_adapter *adapter)
                               adapter->msix_entries,
                               numvecs);
         if (err == 0)
-                return;
+                goto out;
 
         igb_reset_interrupt_capability(adapter);
 
@@ -531,7 +530,7 @@ msi_only:
         adapter->num_tx_queues = 1;
         if (!pci_enable_msi(adapter->pdev))
                 adapter->flags |= IGB_FLAG_HAS_MSI;
-
+out:
         /* Notify the stack of the (possibly) reduced Tx Queue count. */
         adapter->netdev->real_num_tx_queues = adapter->num_tx_queues;
         return;
@@ -1217,16 +1216,6 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                 if (rd32(E1000_STATUS) & E1000_STATUS_FUNC_1)
                         adapter->eeprom_wol = 0;
                 break;
-        case E1000_DEV_ID_82576_QUAD_COPPER:
-                /* if quad port adapter, disable WoL on all but port A */
-                if (global_quad_port_a != 0)
-                        adapter->eeprom_wol = 0;
-                else
-                        adapter->flags |= IGB_FLAG_QUAD_PORT_A;
-                /* Reset for multiple quad port adapters */
-                if (++global_quad_port_a == 4)
-                        global_quad_port_a = 0;
-                break;
         }
 
         /* initialize the wol settings based on the eeprom settings */
@@ -2290,7 +2279,9 @@ static void igb_watchdog_task(struct work_struct *work)
         struct igb_ring *tx_ring = adapter->tx_ring;
         struct e1000_mac_info *mac = &adapter->hw.mac;
         u32 link;
+        u32 eics = 0;
         s32 ret_val;
+        int i;
 
         if ((netif_carrier_ok(netdev)) &&
             (rd32(E1000_STATUS) & E1000_STATUS_LU))
@@ -2392,7 +2383,13 @@ link_up:
         }
 
         /* Cause software interrupt to ensure rx ring is cleaned */
-        wr32(E1000_ICS, E1000_ICS_RXDMT0);
+        if (adapter->msix_entries) {
+                for (i = 0; i < adapter->num_rx_queues; i++)
+                        eics |= adapter->rx_ring[i].eims_value;
+                wr32(E1000_EICS, eics);
+        } else {
+                wr32(E1000_ICS, E1000_ICS_RXDMT0);
+        }
 
         /* Force detection of hung controller every watchdog period */
         tx_ring->detect_tx_hung = true;
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 34bca16d48a6..a417be7f8be5 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1636,16 +1636,17 @@ static void ixgbe_set_multi(struct net_device *netdev)
         struct ixgbe_hw *hw = &adapter->hw;
         struct dev_mc_list *mc_ptr;
         u8 *mta_list;
-        u32 fctrl;
+        u32 fctrl, vlnctrl;
         int i;
 
         /* Check for Promiscuous and All Multicast modes */
 
         fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
+        vlnctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
 
         if (netdev->flags & IFF_PROMISC) {
                 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
-                fctrl &= ~IXGBE_VLNCTRL_VFE;
+                vlnctrl &= ~IXGBE_VLNCTRL_VFE;
         } else {
                 if (netdev->flags & IFF_ALLMULTI) {
                         fctrl |= IXGBE_FCTRL_MPE;
@@ -1653,10 +1654,11 @@ static void ixgbe_set_multi(struct net_device *netdev)
                 } else {
                         fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
                 }
-                fctrl |= IXGBE_VLNCTRL_VFE;
+                vlnctrl |= IXGBE_VLNCTRL_VFE;
         }
 
         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
+        IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
 
         if (netdev->mc_count) {
                 mta_list = kcalloc(netdev->mc_count, ETH_ALEN, GFP_ATOMIC);
@@ -2302,6 +2304,12 @@ static int __devinit ixgbe_set_interrupt_capability(struct ixgbe_adapter
         int vector, v_budget;
 
         /*
+         * Set the default interrupt throttle rate.
+         */
+        adapter->rx_eitr = (1000000 / IXGBE_DEFAULT_ITR_RX_USECS);
+        adapter->tx_eitr = (1000000 / IXGBE_DEFAULT_ITR_TX_USECS);
+
+        /*
          * It's easy to be greedy for MSI-X vectors, but it really
          * doesn't do us much good if we have a lot more vectors
          * than CPU's.  So let's be conservative and only ask for
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 46819af3b062..0a18b9e96da1 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -55,7 +55,7 @@
 #include <asm/system.h>
 
 static char mv643xx_eth_driver_name[] = "mv643xx_eth";
-static char mv643xx_eth_driver_version[] = "1.2";
+static char mv643xx_eth_driver_version[] = "1.3";
 
 #define MV643XX_ETH_CHECKSUM_OFFLOAD_TX
 #define MV643XX_ETH_NAPI
@@ -474,11 +474,19 @@ static void rxq_refill(struct rx_queue *rxq)
                 /*
                  * Reserve 2+14 bytes for an ethernet header (the
                  * hardware automatically prepends 2 bytes of dummy
-                 * data to each received packet), 4 bytes for a VLAN
-                 * header, and 4 bytes for the trailing FCS -- 24
-                 * bytes total.
+                 * data to each received packet), 16 bytes for up to
+                 * four VLAN tags, and 4 bytes for the trailing FCS
+                 * -- 36 bytes total.
                  */
-                skb_size = mp->dev->mtu + 24;
+                skb_size = mp->dev->mtu + 36;
+
+                /*
+                 * Make sure that the skb size is a multiple of 8
+                 * bytes, as the lower three bits of the receive
+                 * descriptor's buffer size field are ignored by
+                 * the hardware.
+                 */
+                skb_size = (skb_size + 7) & ~7;
 
                 skb = dev_alloc_skb(skb_size + dma_get_cache_alignment() - 1);
                 if (skb == NULL)
@@ -509,10 +517,8 @@ static void rxq_refill(struct rx_queue *rxq)
                 skb_reserve(skb, 2);
         }
 
-        if (rxq->rx_desc_count != rxq->rx_ring_size) {
-                rxq->rx_oom.expires = jiffies + (HZ / 10);
-                add_timer(&rxq->rx_oom);
-        }
+        if (rxq->rx_desc_count != rxq->rx_ring_size)
+                mod_timer(&rxq->rx_oom, jiffies + (HZ / 10));
 
         spin_unlock_irqrestore(&mp->lock, flags);
 }
@@ -529,7 +535,7 @@ static int rxq_process(struct rx_queue *rxq, int budget)
         int rx;
 
         rx = 0;
-        while (rx < budget) {
+        while (rx < budget && rxq->rx_desc_count) {
                 struct rx_desc *rx_desc;
                 unsigned int cmd_sts;
                 struct sk_buff *skb;
@@ -554,7 +560,7 @@ static int rxq_process(struct rx_queue *rxq, int budget)
                 spin_unlock_irqrestore(&mp->lock, flags);
 
                 dma_unmap_single(NULL, rx_desc->buf_ptr + 2,
-                                 mp->dev->mtu + 24, DMA_FROM_DEVICE);
+                                 rx_desc->buf_size, DMA_FROM_DEVICE);
                 rxq->rx_desc_count--;
                 rx++;
 
@@ -636,9 +642,9 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
                                 txq_reclaim(mp->txq + i, 0);
 
                 if (netif_carrier_ok(mp->dev)) {
-                        spin_lock(&mp->lock);
+                        spin_lock_irq(&mp->lock);
                         __txq_maybe_wake(mp->txq + mp->txq_primary);
-                        spin_unlock(&mp->lock);
+                        spin_unlock_irq(&mp->lock);
                 }
         }
 #endif
@@ -650,8 +656,6 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
 
         if (rx < budget) {
                 netif_rx_complete(mp->dev, napi);
-                wrl(mp, INT_CAUSE(mp->port_num), 0);
-                wrl(mp, INT_CAUSE_EXT(mp->port_num), 0);
                 wrl(mp, INT_MASK(mp->port_num), INT_TX_END | INT_RX | INT_EXT);
         }
 
@@ -1796,6 +1800,7 @@ static irqreturn_t mv643xx_eth_irq(int irq, void *dev_id)
          */
 #ifdef MV643XX_ETH_NAPI
         if (int_cause & INT_RX) {
+                wrl(mp, INT_CAUSE(mp->port_num), ~(int_cause & INT_RX));
                 wrl(mp, INT_MASK(mp->port_num), 0x00000000);
                 rdl(mp, INT_MASK(mp->port_num));
 
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index 54cd89cb0838..d6524db321af 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.3.99-1.347"
+#define MYRI10GE_VERSION_STR "1.4.3-1.358"
 
 MODULE_DESCRIPTION("Myricom 10G driver (10GbE)");
 MODULE_AUTHOR("Maintainer: help@myri.com");
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 32bb47adbe39..008fd6618a5f 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -359,16 +359,6 @@ static void netxen_pcie_strap_init(struct netxen_adapter *adapter)
         int i, pos;
         struct pci_dev *pdev;
 
-        pdev = pci_get_device(0x1166, 0x0140, NULL);
-        if (pdev) {
-                pci_dev_put(pdev);
-                adapter->hw_read_wx(adapter,
-                        NETXEN_PCIE_REG(PCIE_TGT_SPLIT_CHICKEN), &chicken, 4);
-                chicken |= 0x4000;
-                adapter->hw_write_wx(adapter,
-                        NETXEN_PCIE_REG(PCIE_TGT_SPLIT_CHICKEN), &chicken, 4);
-        }
-
         pdev = adapter->pdev;
 
         adapter->hw_read_wx(adapter,
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 016d9e08692d..ebc812702903 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -5984,6 +5984,56 @@ static void niu_netif_start(struct niu *np)
         niu_enable_interrupts(np, 1);
 }
 
+static void niu_reset_buffers(struct niu *np)
+{
+        int i, j, k, err;
+
+        if (np->rx_rings) {
+                for (i = 0; i < np->num_rx_rings; i++) {
+                        struct rx_ring_info *rp = &np->rx_rings[i];
+
+                        for (j = 0, k = 0; j < MAX_RBR_RING_SIZE; j++) {
+                                struct page *page;
+
+                                page = rp->rxhash[j];
+                                while (page) {
+                                        struct page *next =
+                                                (struct page *) page->mapping;
+                                        u64 base = page->index;
+                                        base = base >> RBR_DESCR_ADDR_SHIFT;
+                                        rp->rbr[k++] = cpu_to_le32(base);
+                                        page = next;
+                                }
+                        }
+                        for (; k < MAX_RBR_RING_SIZE; k++) {
+                                err = niu_rbr_add_page(np, rp, GFP_ATOMIC, k);
+                                if (unlikely(err))
+                                        break;
+                        }
+
+                        rp->rbr_index = rp->rbr_table_size - 1;
+                        rp->rcr_index = 0;
+                        rp->rbr_pending = 0;
+                        rp->rbr_refill_pending = 0;
+                }
+        }
+        if (np->tx_rings) {
+                for (i = 0; i < np->num_tx_rings; i++) {
+                        struct tx_ring_info *rp = &np->tx_rings[i];
+
+                        for (j = 0; j < MAX_TX_RING_SIZE; j++) {
+                                if (rp->tx_buffs[j].skb)
+                                        (void) release_tx_packet(np, rp, j);
+                        }
+
+                        rp->pending = MAX_TX_RING_SIZE;
+                        rp->prod = 0;
+                        rp->cons = 0;
+                        rp->wrap_bit = 0;
+                }
+        }
+}
+
 static void niu_reset_task(struct work_struct *work)
 {
         struct niu *np = container_of(work, struct niu, reset_task);
@@ -6006,6 +6056,12 @@ static void niu_reset_task(struct work_struct *work)
 
         niu_stop_hw(np);
 
+        spin_unlock_irqrestore(&np->lock, flags);
+
+        niu_reset_buffers(np);
+
+        spin_lock_irqsave(&np->lock, flags);
+
         err = niu_init_hw(np);
         if (!err) {
                 np->timer.expires = jiffies + HZ;
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index 3f682d49a4e6..52bf11b73c6e 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -784,6 +784,7 @@ static struct pcmcia_device_id axnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
         PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
+        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("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 2d4c4ad89b8d..ebc1ae6bcbe5 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1626,6 +1626,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega EtherII PCC-TD", 0x5261440f, 0xc49bd73d),
         PCMCIA_DEVICE_PROD_ID12("Corega K.K.", "corega EtherII PCC-TD", 0xd4fdcbd8, 0xc49bd73d),
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-T", 0x5261440f, 0x6705fcaa),
+        PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega Ether PCC-TD", 0x5261440f, 0x47d5ca83),
         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FastEther PCC-TX", 0x5261440f, 0x485e85d9),
         PCMCIA_DEVICE_PROD_ID12("Corega,K.K.", "Ethernet LAN Card", 0x110d26d9, 0x9fd2f0a2),
         PCMCIA_DEVICE_PROD_ID12("corega,K.K.", "Ethernet LAN Card", 0x9791a90e, 0x9fd2f0a2),
@@ -1737,7 +1738,6 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID1("CyQ've 10 Base-T LAN CARD", 0x94faf360),
         PCMCIA_DEVICE_PROD_ID1("EP-210 PCMCIA LAN CARD.", 0x8850b4de),
         PCMCIA_DEVICE_PROD_ID1("ETHER-C16", 0x06a8514f),
-        PCMCIA_DEVICE_PROD_ID1("IC-CARD", 0x60cb09a6),
         PCMCIA_DEVICE_PROD_ID1("NE2000 Compatible", 0x75b8ad5a),
         PCMCIA_DEVICE_PROD_ID2("EN-6200P2", 0xa996d078),
         /* too generic! */
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index a3e3895e5032..0f6f9747d255 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -2792,7 +2792,7 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
                                         pkt_size, PCI_DMA_FROMDEVICE);
                                 rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
                         } else {
-                                pci_unmap_single(pdev, addr, pkt_size,
+                                pci_unmap_single(pdev, addr, tp->rx_buf_sz,
                                                  PCI_DMA_FROMDEVICE);
                                 tp->Rx_skbuff[entry] = NULL;
                         }
diff --git a/drivers/net/skfp/ess.c b/drivers/net/skfp/ess.c
index 889f98724610..a85efcfd9d0e 100644
--- a/drivers/net/skfp/ess.c
+++ b/drivers/net/skfp/ess.c
@@ -510,7 +510,7 @@ static void ess_send_response(struct s_smc *smc, struct smt_header *sm,
         chg->path.para.p_type = SMT_P320B ;
         chg->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ;
         chg->path.mib_index = SBAPATHINDEX ;
-        chg->path.path_pad = (u_short)NULL ;
+        chg->path.path_pad = 0;
         chg->path.path_index = PRIMARY_RING ;
 
         /* set P320F */
@@ -606,7 +606,7 @@ static void ess_send_alc_req(struct s_smc *smc)
         req->path.para.p_type = SMT_P320B ;
         req->path.para.p_len = sizeof(struct smt_p_320b) - PARA_LEN ;
         req->path.mib_index = SBAPATHINDEX ;
-        req->path.path_pad = (u_short)NULL ;
+        req->path.path_pad = 0;
         req->path.path_index = PRIMARY_RING ;
 
         /* set P0017 */
@@ -636,7 +636,7 @@ static void ess_send_alc_req(struct s_smc *smc)
         /* set P19 */
         req->a_addr.para.p_type = SMT_P0019 ;
         req->a_addr.para.p_len = sizeof(struct smt_p_0019) - PARA_LEN ;
-        req->a_addr.sba_pad = (u_short)NULL ;
+        req->a_addr.sba_pad = 0;
         req->a_addr.alloc_addr = null_addr ;
 
         /* set P1A */
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index 2040965d7724..24768c10cadb 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -2255,7 +2255,7 @@ static int smc_drv_remove(struct platform_device *pdev)
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-regs");
         if (!res)
-                platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         release_mem_region(res->start, SMC_IO_EXTENT);
 
         free_netdev(ndev);
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 1b7cac77159e..6e42b5a8c22b 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -397,7 +397,7 @@ static const struct usb_device_id hso_ids[] = {
         {default_port_device(0x0af0, 0xc031)},  /* Icon-Edge */
         {icon321_port_device(0x0af0, 0xd013)},  /* Module HSxPA */
         {icon321_port_device(0x0af0, 0xd031)},  /* Icon-321 */
-        {default_port_device(0x0af0, 0xd033)},  /* Icon-322 */
+        {icon321_port_device(0x0af0, 0xd033)},  /* Icon-322 */
         {USB_DEVICE(0x0af0, 0x7301)},           /* GE40x */
         {USB_DEVICE(0x0af0, 0x7361)},           /* GE40x */
         {USB_DEVICE(0x0af0, 0x7401)},           /* GI 0401 */
@@ -2613,6 +2613,7 @@ static int hso_resume(struct usb_interface *iface)
                                         "Transmitting lingering data\n");
                                 hso_net_start_xmit(hso_net->skb_tx_buf,
                                                    hso_net->net);
+                                hso_net->skb_tx_buf = NULL;
                         }
                         result = hso_start_net_device(network_table[i]);
                         if (result)
diff --git a/drivers/net/usb/mcs7830.c b/drivers/net/usb/mcs7830.c
index c3d119f997f5..ca9d00c1194e 100644
--- a/drivers/net/usb/mcs7830.c
+++ b/drivers/net/usb/mcs7830.c
@@ -46,6 +46,10 @@
 
 #define MCS7830_VENDOR_ID       0x9710
 #define MCS7830_PRODUCT_ID      0x7830
+#define MCS7730_PRODUCT_ID      0x7730
+
+#define SITECOM_VENDOR_ID       0x0DF6
+#define LN_030_PRODUCT_ID       0x0021
 
 #define MCS7830_MII_ADVERTISE   (ADVERTISE_PAUSE_CAP | ADVERTISE_100FULL | \
                                  ADVERTISE_100HALF | ADVERTISE_10FULL | \
@@ -442,6 +446,29 @@ static struct ethtool_ops mcs7830_ethtool_ops = {
         .nway_reset             = usbnet_nway_reset,
 };
 
+static int mcs7830_set_mac_address(struct net_device *netdev, void *p)
+{
+        int ret;
+        struct usbnet *dev = netdev_priv(netdev);
+        struct sockaddr *addr = p;
+
+        if (netif_running(netdev))
+                return -EBUSY;
+
+        if (!is_valid_ether_addr(addr->sa_data))
+                return -EINVAL;
+
+        memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+
+        ret = mcs7830_set_reg(dev, HIF_REG_ETHERNET_ADDR, ETH_ALEN,
+                        netdev->dev_addr);
+
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
 static int mcs7830_bind(struct usbnet *dev, struct usb_interface *udev)
 {
         struct net_device *net = dev->net;
@@ -455,6 +482,7 @@ static int mcs7830_bind(struct usbnet *dev, struct usb_interface *udev)
         net->ethtool_ops = &mcs7830_ethtool_ops;
         net->set_multicast_list = mcs7830_set_multicast;
         mcs7830_set_multicast(net);
+        net->set_mac_address = mcs7830_set_mac_address;
 
         /* reserve space for the status byte on rx */
         dev->rx_urb_size = ETH_FRAME_LEN + 1;
@@ -491,7 +519,16 @@ static int mcs7830_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 }
 
 static const struct driver_info moschip_info = {
-        .description    = "MOSCHIP 7830 usb-NET adapter",
+        .description    = "MOSCHIP 7830/7730 usb-NET adapter",
+        .bind           = mcs7830_bind,
+        .rx_fixup       = mcs7830_rx_fixup,
+        .flags          = FLAG_ETHER,
+        .in             = 1,
+        .out            = 2,
+};
+
+static const struct driver_info sitecom_info = {
+        .description    = "Sitecom LN-30 usb-NET adapter",
         .bind           = mcs7830_bind,
         .rx_fixup       = mcs7830_rx_fixup,
         .flags          = FLAG_ETHER,
@@ -504,6 +541,14 @@ static const struct usb_device_id products[] = {
                 USB_DEVICE(MCS7830_VENDOR_ID, MCS7830_PRODUCT_ID),
                 .driver_info = (unsigned long) &moschip_info,
         },
+        {
+                USB_DEVICE(MCS7830_VENDOR_ID, MCS7730_PRODUCT_ID),
+                .driver_info = (unsigned long) &moschip_info,
+        },
+        {
+                USB_DEVICE(SITECOM_VENDOR_ID, LN_030_PRODUCT_ID),
+                .driver_info = (unsigned long) &sitecom_info,
+        },
         {},
 };
 MODULE_DEVICE_TABLE(usb, products);
diff --git a/drivers/net/usb/pegasus.c b/drivers/net/usb/pegasus.c
index a84ba487c713..8c19307e5040 100644
--- a/drivers/net/usb/pegasus.c
+++ b/drivers/net/usb/pegasus.c
@@ -117,7 +117,7 @@ static void ctrl_callback(struct urb *urb)
         case -ENOENT:
                 break;
         default:
-                if (netif_msg_drv(pegasus))
+                if (netif_msg_drv(pegasus) && printk_ratelimit())
                         dev_dbg(&pegasus->intf->dev, "%s, status %d\n",
                                 __FUNCTION__, urb->status);
         }
@@ -166,7 +166,7 @@ static int get_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
                 set_current_state(TASK_RUNNING);
                 if (ret == -ENODEV)
                         netif_device_detach(pegasus->net);
-                if (netif_msg_drv(pegasus))
+                if (netif_msg_drv(pegasus) && printk_ratelimit())
                         dev_err(&pegasus->intf->dev, "%s, status %d\n",
                                         __FUNCTION__, ret);
                 goto out;
@@ -275,7 +275,7 @@ static int set_register(pegasus_t * pegasus, __u16 indx, __u8 data)
         if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
                 if (ret == -ENODEV)
                         netif_device_detach(pegasus->net);
-                if (netif_msg_drv(pegasus))
+                if (netif_msg_drv(pegasus) && printk_ratelimit())
                         dev_err(&pegasus->intf->dev, "%s, status %d\n",
                                         __FUNCTION__, ret);
                 goto out;
@@ -1209,8 +1209,7 @@ static void pegasus_set_multicast(struct net_device *net)
                 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
                 if (netif_msg_link(pegasus))
                         pr_info("%s: Promiscuous mode enabled.\n", net->name);
-        } else if (net->mc_count ||
-                   (net->flags & IFF_ALLMULTI)) {
+        } else if (net->mc_count || (net->flags & IFF_ALLMULTI)) {
                 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
                 if (netif_msg_link(pegasus))
@@ -1220,6 +1219,8 @@ static void pegasus_set_multicast(struct net_device *net)
                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
         }
 
+        pegasus->ctrl_urb->status = 0;
+
         pegasus->flags |= ETH_REGS_CHANGE;
         ctrl_callback(pegasus->ctrl_urb);
 }
diff --git a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c
index e59255a155a9..6596cd0742b9 100644
--- a/drivers/net/wan/sbni.c
+++ b/drivers/net/wan/sbni.c
@@ -1317,7 +1317,7 @@ sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
                 break;
 
         case  SIOCDEVRESINSTATS :
-                if( current->euid != 0 )        /* root only */
+                if (!capable(CAP_NET_ADMIN))
                         return  -EPERM;
                 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
                 break;
@@ -1334,7 +1334,7 @@ sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
                 break;
 
         case  SIOCDEVSHWSTATE :
-                if( current->euid != 0 )        /* root only */
+                if (!capable(CAP_NET_ADMIN))
                         return  -EPERM;
 
                 spin_lock( &nl->lock );
@@ -1355,7 +1355,7 @@ sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
 #ifdef CONFIG_SBNI_MULTILINE
 
         case  SIOCDEVENSLAVE :
-                if( current->euid != 0 )        /* root only */
+                if (!capable(CAP_NET_ADMIN))
                         return  -EPERM;
 
                 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
@@ -1370,7 +1370,7 @@ sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
                 return  enslave( dev, slave_dev );
 
         case  SIOCDEVEMANSIPATE :
-                if( current->euid != 0 )        /* root only */
+                if (!capable(CAP_NET_ADMIN))
                         return  -EPERM;
 
                 return  emancipate( dev );
diff --git a/drivers/net/wd.c b/drivers/net/wd.c
index 6f9aa1643743..fa14255282af 100644
--- a/drivers/net/wd.c
+++ b/drivers/net/wd.c
@@ -337,7 +337,7 @@ static int __init wd_probe1(struct net_device *dev, int ioaddr)
 #ifdef CONFIG_NET_POLL_CONTROLLER
         dev->poll_controller = ei_poll;
 #endif
-        NS8390p_init(dev, 0);
+        NS8390_init(dev, 0);
 
 #if 1
         /* Enable interrupt generation on softconfig cards -- M.U */
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index b20a45aa8680..0676c6d84383 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -251,7 +251,7 @@ static inline void ath5k_txbuf_free(struct ath5k_softc *sc,
                 return;
         pci_unmap_single(sc->pdev, bf->skbaddr, bf->skb->len,
                         PCI_DMA_TODEVICE);
-        dev_kfree_skb(bf->skb);
+        dev_kfree_skb_any(bf->skb);
         bf->skb = NULL;
 }
 
@@ -466,6 +466,7 @@ ath5k_pci_probe(struct pci_dev *pdev,
         mutex_init(&sc->lock);
         spin_lock_init(&sc->rxbuflock);
         spin_lock_init(&sc->txbuflock);
+        spin_lock_init(&sc->block);
 
         /* Set private data */
         pci_set_drvdata(pdev, hw);
@@ -2179,8 +2180,11 @@ ath5k_beacon_config(struct ath5k_softc *sc)
 
                 sc->imask |= AR5K_INT_SWBA;
 
-                if (ath5k_hw_hasveol(ah))
+                if (ath5k_hw_hasveol(ah)) {
+                        spin_lock(&sc->block);
                         ath5k_beacon_send(sc);
+                        spin_unlock(&sc->block);
+                }
         }
         /* TODO else AP */
 
@@ -2403,7 +2407,9 @@ ath5k_intr(int irq, void *dev_id)
                                                   TSF_TO_TU(tsf),
                                                   (unsigned long long) tsf);
                                 } else {
+                                        spin_lock(&sc->block);
                                         ath5k_beacon_send(sc);
+                                        spin_unlock(&sc->block);
                                 }
                         }
                         if (status & AR5K_INT_RXEOL) {
@@ -2745,6 +2751,11 @@ static int ath5k_add_interface(struct ieee80211_hw *hw,
                 ret = -EOPNOTSUPP;
                 goto end;
         }
+
+        /* Set to a reasonable value. Note that this will
+         * be set to mac80211's value at ath5k_config(). */
+        sc->bintval = 1000;
+
         ret = 0;
 end:
         mutex_unlock(&sc->lock);
@@ -2789,9 +2800,6 @@ ath5k_config_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
         struct ath5k_hw *ah = sc->ah;
         int ret;
 
-        /* Set to a reasonable value. Note that this will
-         * be set to mac80211's value at ath5k_config(). */
-        sc->bintval = 1000;
         mutex_lock(&sc->lock);
         if (sc->vif != vif) {
                 ret = -EIO;
@@ -3050,6 +3058,7 @@ static int
 ath5k_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
         struct ath5k_softc *sc = hw->priv;
+        unsigned long flags;
         int ret;
 
         ath5k_debug_dump_skb(sc, skb, "BC  ", 1);
@@ -3059,12 +3068,14 @@ ath5k_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
                 goto end;
         }
 
+        spin_lock_irqsave(&sc->block, flags);
         ath5k_txbuf_free(sc, sc->bbuf);
         sc->bbuf->skb = skb;
         ret = ath5k_beacon_setup(sc, sc->bbuf);
         if (ret)
                 sc->bbuf->skb = NULL;
-        else {
+        spin_unlock_irqrestore(&sc->block, flags);
+        if (!ret) {
                 ath5k_beacon_config(sc);
                 mmiowb();
         }
diff --git a/drivers/net/wireless/ath5k/base.h b/drivers/net/wireless/ath5k/base.h
index d7e03e6b8271..7ec2f377d5c7 100644
--- a/drivers/net/wireless/ath5k/base.h
+++ b/drivers/net/wireless/ath5k/base.h
@@ -172,6 +172,7 @@ struct ath5k_softc {
         struct tasklet_struct   txtq;           /* tx intr tasklet */
         struct ath5k_led        tx_led;         /* tx led */
 
+        spinlock_t              block;          /* protects beacon */
         struct ath5k_buf        *bbuf;          /* beacon buffer */
         unsigned int            bhalq,          /* SW q for outgoing beacons */
                                 bmisscount,     /* missed beacon transmits */
diff --git a/drivers/net/wireless/ath9k/beacon.c b/drivers/net/wireless/ath9k/beacon.c
index caf569401a34..00a0eaa08866 100644
--- a/drivers/net/wireless/ath9k/beacon.c
+++ b/drivers/net/wireless/ath9k/beacon.c
@@ -209,6 +209,7 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
         unsigned int curlen;
         struct ath_txq *cabq;
         struct ath_txq *mcastq;
+        struct ieee80211_tx_info *info;
         avp = sc->sc_vaps[if_id];
 
         mcastq = &avp->av_mcastq;
@@ -232,6 +233,18 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
          */
         curlen = skb->len;
 
+        info = IEEE80211_SKB_CB(skb);
+        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+                /*
+                 * TODO: make sure the seq# gets assigned properly (vs. other
+                 * TX frames)
+                 */
+                struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+                sc->seq_no += 0x10;
+                hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+                hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
+        }
+
         /* XXX: spin_lock_bh should not be used here, but sparse bitches
          * otherwise. We should fix sparse :) */
         spin_lock_bh(&mcastq->axq_lock);
diff --git a/drivers/net/wireless/ath9k/core.h b/drivers/net/wireless/ath9k/core.h
index 673b3d81133a..4ee695b76b88 100644
--- a/drivers/net/wireless/ath9k/core.h
+++ b/drivers/net/wireless/ath9k/core.h
@@ -992,6 +992,7 @@ struct ath_softc {
         u32 sc_txintrperiod;    /* tx interrupt batching */
         int sc_haltype2q[ATH9K_WME_AC_VO+1]; /* HAL WME AC -> h/w qnum */
         u32 sc_ant_tx[8];       /* recent tx frames/antenna */
+        u16 seq_no; /* TX sequence number */
 
         /* Beacon */
         struct ath9k_tx_queue_info sc_beacon_qi;
diff --git a/drivers/net/wireless/ath9k/hw.c b/drivers/net/wireless/ath9k/hw.c
index a17eb130f574..6dbfed0b4149 100644
--- a/drivers/net/wireless/ath9k/hw.c
+++ b/drivers/net/wireless/ath9k/hw.c
@@ -7285,15 +7285,15 @@ ath9k_hw_set_keycache_entry(struct ath_hal *ah, u16 entry,
                 }
                 break;
         case ATH9K_CIPHER_WEP:
-                if (k->kv_len < 40 / NBBY) {
+                if (k->kv_len < LEN_WEP40) {
                         DPRINTF(ah->ah_sc, ATH_DBG_KEYCACHE,
                                  "%s: WEP key length %u too small\n",
                                  __func__, k->kv_len);
                         return false;
                 }
-                if (k->kv_len <= 40 / NBBY)
+                if (k->kv_len <= LEN_WEP40)
                         keyType = AR_KEYTABLE_TYPE_40;
-                else if (k->kv_len <= 104 / NBBY)
+                else if (k->kv_len <= LEN_WEP104)
                         keyType = AR_KEYTABLE_TYPE_104;
                 else
                         keyType = AR_KEYTABLE_TYPE_128;
@@ -7313,7 +7313,7 @@ ath9k_hw_set_keycache_entry(struct ath_hal *ah, u16 entry,
         key2 = get_unaligned_le32(k->kv_val + 6) ^ xorMask;
         key3 = (get_unaligned_le16(k->kv_val + 10) ^ xorMask) & 0xffff;
         key4 = get_unaligned_le32(k->kv_val + 12) ^ xorMask;
-        if (k->kv_len <= 104 / NBBY)
+        if (k->kv_len <= LEN_WEP104)
                 key4 &= 0xff;
 
         if (keyType == AR_KEYTABLE_TYPE_TKIP && ATH9K_IS_MIC_ENABLED(ah)) {
diff --git a/drivers/net/wireless/ath9k/main.c b/drivers/net/wireless/ath9k/main.c
index 2888778040e4..99badf1404c3 100644
--- a/drivers/net/wireless/ath9k/main.c
+++ b/drivers/net/wireless/ath9k/main.c
@@ -206,7 +206,8 @@ static int ath_key_config(struct ath_softc *sc,
         if (!ret)
                 return -EIO;
 
-        sc->sc_keytype = hk.kv_type;
+        if (mac)
+                sc->sc_keytype = hk.kv_type;
         return 0;
 }
 
@@ -368,6 +369,20 @@ static int ath9k_tx(struct ieee80211_hw *hw,
 {
         struct ath_softc *sc = hw->priv;
         int hdrlen, padsize;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+        /*
+         * As a temporary workaround, assign seq# here; this will likely need
+         * to be cleaned up to work better with Beacon transmission and virtual
+         * BSSes.
+         */
+        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+                struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+                if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+                        sc->seq_no += 0x10;
+                hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+                hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
+        }
 
         /* Add the padding after the header if this is not already done */
         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
@@ -756,7 +771,8 @@ static int ath9k_set_key(struct ieee80211_hw *hw,
                         key->hw_key_idx = key->keyidx;
                         /* push IV and Michael MIC generation to stack */
                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-                        key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
+                        if (key->alg == ALG_TKIP)
+                                key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
                 }
                 break;
         case DISABLE_KEY:
@@ -1065,8 +1081,16 @@ void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
                 tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
                 tx_status->flags &= ~ATH_TX_BAR;
         }
-        if (tx_status->flags)
-                tx_info->status.excessive_retries = 1;
+
+        if (tx_status->flags & (ATH_TX_ERROR | ATH_TX_XRETRY)) {
+                if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+                        /* Frame was not ACKed, but an ACK was expected */
+                        tx_info->status.excessive_retries = 1;
+                }
+        } else {
+                /* Frame was ACKed */
+                tx_info->flags |= IEEE80211_TX_STAT_ACK;
+        }
 
         tx_info->status.retry_count = tx_status->retries;
 
diff --git a/drivers/net/wireless/ath9k/recv.c b/drivers/net/wireless/ath9k/recv.c
index 2fe806175c01..20ddb7acdb94 100644
--- a/drivers/net/wireless/ath9k/recv.c
+++ b/drivers/net/wireless/ath9k/recv.c
@@ -360,8 +360,9 @@ static void ath_rx_flush_tid(struct ath_softc *sc,
         struct ath_arx_tid *rxtid, int drop)
 {
         struct ath_rxbuf *rxbuf;
+        unsigned long flag;
 
-        spin_lock_bh(&rxtid->tidlock);
+        spin_lock_irqsave(&rxtid->tidlock, flag);
         while (rxtid->baw_head != rxtid->baw_tail) {
                 rxbuf = rxtid->rxbuf + rxtid->baw_head;
                 if (!rxbuf->rx_wbuf) {
@@ -382,7 +383,7 @@ static void ath_rx_flush_tid(struct ath_softc *sc,
                 INCR(rxtid->baw_head, ATH_TID_MAX_BUFS);
                 INCR(rxtid->seq_next, IEEE80211_SEQ_MAX);
         }
-        spin_unlock_bh(&rxtid->tidlock);
+        spin_unlock_irqrestore(&rxtid->tidlock, flag);
 }
 
 static struct sk_buff *ath_rxbuf_alloc(struct ath_softc *sc,
diff --git a/drivers/net/wireless/ath9k/xmit.c b/drivers/net/wireless/ath9k/xmit.c
index 157f830ee6b8..550129f717e2 100644
--- a/drivers/net/wireless/ath9k/xmit.c
+++ b/drivers/net/wireless/ath9k/xmit.c
@@ -357,9 +357,9 @@ static int ath_tx_prepare(struct ath_softc *sc,
         txctl->flags = ATH9K_TXDESC_CLRDMASK;    /* needed for crypto errors */
 
         if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK)
-                tx_info->flags |= ATH9K_TXDESC_NOACK;
+                txctl->flags |= ATH9K_TXDESC_NOACK;
         if (tx_info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
-                tx_info->flags |= ATH9K_TXDESC_RTSENA;
+                txctl->flags |= ATH9K_TXDESC_RTSENA;
 
         /*
          * Setup for rate calculations.
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index bd35bb0a1480..bd65c485098c 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -1304,7 +1304,7 @@ EXPORT_SYMBOL(atmel_open);
 int atmel_open(struct net_device *dev)
 {
         struct atmel_private *priv = netdev_priv(dev);
-        int i, channel;
+        int i, channel, err;
 
         /* any scheduled timer is no longer needed and might screw things up.. */
         del_timer_sync(&priv->management_timer);
@@ -1328,8 +1328,9 @@ int atmel_open(struct net_device *dev)
         priv->site_survey_state = SITE_SURVEY_IDLE;
         priv->station_is_associated = 0;
 
-        if (!reset_atmel_card(dev))
-                return -EAGAIN;
+        err = reset_atmel_card(dev);
+        if (err)
+                return err;
 
         if (priv->config_reg_domain) {
                 priv->reg_domain = priv->config_reg_domain;
@@ -3061,12 +3062,20 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
         }
 
         if (status == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
-                /* Do opensystem first, then try sharedkey */
+                /* Flip back and forth between WEP auth modes until the max
+                 * authentication tries has been exceeded.
+                 */
                 if (system == WLAN_AUTH_OPEN) {
                         priv->CurrentAuthentTransactionSeqNum = 0x001;
                         priv->exclude_unencrypted = 1;
                         send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
                         return;
+                } else if (   system == WLAN_AUTH_SHARED_KEY
+                           && priv->wep_is_on) {
+                        priv->CurrentAuthentTransactionSeqNum = 0x001;
+                        priv->exclude_unencrypted = 0;
+                        send_authentication_request(priv, WLAN_AUTH_OPEN, NULL, 0);
+                        return;
                 } else if (priv->connect_to_any_BSS) {
                         int bss_index;
 
@@ -3580,12 +3589,12 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
 
         if (i == 0) {
                 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name);
-                return 0;
+                return -EIO;
         }
 
         if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) {
                 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name);
-                return 0;
+                return -ENODEV;
         }
 
         /* now check for completion of MAC initialization through
@@ -3609,19 +3618,19 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
         if (i == 0) {
                 printk(KERN_ALERT "%s: MAC failed to initialise.\n",
                                 priv->dev->name);
-                return 0;
+                return -EIO;
         }
 
         /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */
         if ((mr3 & MAC_INIT_COMPLETE) &&
             !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) {
                 printk(KERN_ALERT "%s: MAC failed MR3 self-test.\n", priv->dev->name);
-                return 0;
+                return -EIO;
         }
         if ((mr1 & MAC_INIT_COMPLETE) &&
             !(atmel_read16(priv->dev, MR1) & MAC_INIT_OK)) {
                 printk(KERN_ALERT "%s: MAC failed MR1 self-test.\n", priv->dev->name);
-                return 0;
+                return -EIO;
         }
 
         atmel_copy_to_host(priv->dev, (unsigned char *)iface,
@@ -3642,7 +3651,7 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
         iface->func_ctrl = le16_to_cpu(iface->func_ctrl);
         iface->mac_status = le16_to_cpu(iface->mac_status);
 
-        return 1;
+        return 0;
 }
 
 /* determine type of memory and MAC address */
@@ -3693,7 +3702,7 @@ static int probe_atmel_card(struct net_device *dev)
                 /* Standard firmware in flash, boot it up and ask
                    for the Mac Address */
                 priv->card_type = CARD_TYPE_SPI_FLASH;
-                if (atmel_wakeup_firmware(priv)) {
+                if (atmel_wakeup_firmware(priv) == 0) {
                         atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6);
 
                         /* got address, now squash it again until the network
@@ -3835,6 +3844,7 @@ static int reset_atmel_card(struct net_device *dev)
         struct atmel_private *priv = netdev_priv(dev);
         u8 configuration;
         int old_state = priv->station_state;
+        int err = 0;
 
         /* data to add to the firmware names, in priority order
            this implemenents firmware versioning */
@@ -3868,11 +3878,12 @@ static int reset_atmel_card(struct net_device *dev)
                                                dev->name);
                                         strcpy(priv->firmware_id, "atmel_at76c502.bin");
                                 }
-                                if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) != 0) {
+                                err = request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev);
+                                if (err != 0) {
                                         printk(KERN_ALERT
                                                "%s: firmware %s is missing, cannot continue.\n",
                                                dev->name, priv->firmware_id);
-                                        return 0;
+                                        return err;
                                 }
                         } else {
                                 int fw_index = 0;
@@ -3901,7 +3912,7 @@ static int reset_atmel_card(struct net_device *dev)
                                                "%s: firmware %s is missing, cannot start.\n",
                                                dev->name, priv->firmware_id);
                                         priv->firmware_id[0] = '\0';
-                                        return 0;
+                                        return -ENOENT;
                                 }
                         }
 
@@ -3926,8 +3937,9 @@ static int reset_atmel_card(struct net_device *dev)
                         release_firmware(fw_entry);
         }
 
-        if (!atmel_wakeup_firmware(priv))
-                return 0;
+        err = atmel_wakeup_firmware(priv);
+        if (err != 0)
+                return err;
 
         /* Check the version and set the correct flag for wpa stuff,
            old and new firmware is incompatible.
@@ -3968,10 +3980,9 @@ static int reset_atmel_card(struct net_device *dev)
         if (!priv->radio_on_broken) {
                 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) ==
                     CMD_STATUS_REJECTED_RADIO_OFF) {
-                        printk(KERN_INFO
-                               "%s: cannot turn the radio on. (Hey radio, you're beautiful!)\n",
+                        printk(KERN_INFO "%s: cannot turn the radio on.\n",
                                dev->name);
-                        return 0;
+                        return -EIO;
                 }
         }
 
@@ -4006,7 +4017,7 @@ static int reset_atmel_card(struct net_device *dev)
                 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
         }
 
-        return 1;
+        return 0;
 }
 
 static void atmel_send_command(struct atmel_private *priv, int command,
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c
index e2581229d8b2..23fed3298962 100644
--- a/drivers/net/wireless/iwlwifi/iwl-4965.c
+++ b/drivers/net/wireless/iwlwifi/iwl-4965.c
@@ -474,8 +474,8 @@ static void iwl4965_apm_stop(struct iwl_priv *priv)
         iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
 
         udelay(10);
-
-        iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
+        /* clear "init complete"  move adapter D0A* --> D0U state */
+        iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
index cbc01a00eaf4..b08036a9d894 100644
--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
@@ -145,7 +145,8 @@ static void iwl5000_apm_stop(struct iwl_priv *priv)
 
         udelay(10);
 
-        iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
+        /* clear "init complete"  move adapter D0A* --> D0U state */
+        iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
 
         spin_unlock_irqrestore(&priv->lock, flags);
 }
@@ -577,14 +578,11 @@ static int iwl5000_load_section(struct iwl_priv *priv,
                 FH_TFDIB_CTRL0_REG(FH_SRVC_CHNL),
                 phy_addr & FH_MEM_TFDIB_DRAM_ADDR_LSB_MSK);
 
-        /* FIME: write the MSB of the phy_addr in CTRL1
-         * iwl_write_direct32(priv,
-                IWL_FH_TFDIB_CTRL1_REG(IWL_FH_SRVC_CHNL),
-                ((phy_addr & MSB_MSK)
-                        << FH_MEM_TFDIB_REG1_ADDR_BITSHIFT) | byte_count);
-         */
         iwl_write_direct32(priv,
-                FH_TFDIB_CTRL1_REG(FH_SRVC_CHNL), byte_cnt);
+                FH_TFDIB_CTRL1_REG(FH_SRVC_CHNL),
+                (iwl_get_dma_hi_address(phy_addr)
+                        << FH_MEM_TFDIB_REG1_ADDR_BITSHIFT) | byte_cnt);
+
         iwl_write_direct32(priv,
                 FH_TCSR_CHNL_TX_BUF_STS_REG(FH_SRVC_CHNL),
                 1 << FH_TCSR_CHNL_TX_BUF_STS_REG_POS_TB_NUM |
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
index 754fef5b592f..90a2b6dee7c0 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
@@ -1153,7 +1153,8 @@ static int rs_switch_to_mimo2(struct iwl_priv *priv,
             !sta->ht_info.ht_supported)
                 return -1;
 
-        if (priv->current_ht_config.tx_mimo_ps_mode == IWL_MIMO_PS_STATIC)
+        if (((sta->ht_info.cap & IEEE80211_HT_CAP_MIMO_PS) >> 2)
+                                                == IWL_MIMO_PS_STATIC)
                 return -1;
 
         /* Need both Tx chains/antennas to support MIMO */
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 061ffba9c884..e01f048a02dd 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -181,14 +181,14 @@ static int iwl4965_check_rxon_cmd(struct iwl_rxon_cmd *rxon)
 }
 
 /**
- * iwl4965_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
+ * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
  * @priv: staging_rxon is compared to active_rxon
  *
  * If the RXON structure is changing enough to require a new tune,
  * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
  * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
  */
-static int iwl4965_full_rxon_required(struct iwl_priv *priv)
+static int iwl_full_rxon_required(struct iwl_priv *priv)
 {
 
         /* These items are only settable from the full RXON command */
@@ -207,7 +207,6 @@ static int iwl4965_full_rxon_required(struct iwl_priv *priv)
              priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
             (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
              priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
-            (priv->staging_rxon.rx_chain != priv->active_rxon.rx_chain) ||
             (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
                 return 1;
 
@@ -263,7 +262,7 @@ static int iwl4965_commit_rxon(struct iwl_priv *priv)
         /* If we don't need to send a full RXON, we can use
          * iwl4965_rxon_assoc_cmd which is used to reconfigure filter
          * and other flags for the current radio configuration. */
-        if (!iwl4965_full_rxon_required(priv)) {
+        if (!iwl_full_rxon_required(priv)) {
                 ret = iwl_send_rxon_assoc(priv);
                 if (ret) {
                         IWL_ERROR("Error setting RXON_ASSOC (%d)\n", ret);
@@ -587,8 +586,6 @@ static void iwl4965_ht_conf(struct iwl_priv *priv,
                 iwl_conf->supported_chan_width = 0;
         }
 
-        iwl_conf->tx_mimo_ps_mode =
-                (u8)((ht_conf->cap & IEEE80211_HT_CAP_MIMO_PS) >> 2);
         memcpy(iwl_conf->supp_mcs_set, ht_conf->supp_mcs_set, 16);
 
         iwl_conf->control_channel = ht_bss_conf->primary_channel;
@@ -2190,7 +2187,10 @@ static void __iwl4965_down(struct iwl_priv *priv)
         udelay(5);
 
         /* FIXME: apm_ops.suspend(priv) */
-        priv->cfg->ops->lib->apm_ops.reset(priv);
+        if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
+                priv->cfg->ops->lib->apm_ops.stop(priv);
+        else
+                priv->cfg->ops->lib->apm_ops.reset(priv);
         priv->cfg->ops->lib->free_shared_mem(priv);
 
  exit:
@@ -2602,6 +2602,7 @@ static int iwl4965_mac_start(struct ieee80211_hw *hw)
 {
         struct iwl_priv *priv = hw->priv;
         int ret;
+        u16 pci_cmd;
 
         IWL_DEBUG_MAC80211("enter\n");
 
@@ -2612,6 +2613,13 @@ static int iwl4965_mac_start(struct ieee80211_hw *hw)
         pci_restore_state(priv->pci_dev);
         pci_enable_msi(priv->pci_dev);
 
+        /* enable interrupts if needed: hw bug w/a */
+        pci_read_config_word(priv->pci_dev, PCI_COMMAND, &pci_cmd);
+        if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
+                pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
+                pci_write_config_word(priv->pci_dev, PCI_COMMAND, pci_cmd);
+        }
+
         ret = request_irq(priv->pci_dev->irq, iwl4965_isr, IRQF_SHARED,
                           DRV_NAME, priv);
         if (ret) {
@@ -3580,7 +3588,7 @@ static int iwl4965_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *sk
 
         priv->assoc_id = 0;
         timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
-        priv->timestamp = le64_to_cpu(timestamp) +  (priv->beacon_int * 1000);
+        priv->timestamp = le64_to_cpu(timestamp);
 
         IWL_DEBUG_MAC80211("leave\n");
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -4364,15 +4372,18 @@ static void __devexit iwl4965_pci_remove(struct pci_dev *pdev)
         iwl_dbgfs_unregister(priv);
         sysfs_remove_group(&pdev->dev.kobj, &iwl4965_attribute_group);
 
+        /* ieee80211_unregister_hw call wil cause iwl4965_mac_stop to
+         * to be called and iwl4965_down since we are removing the device
+         * we need to set STATUS_EXIT_PENDING bit.
+         */
+        set_bit(STATUS_EXIT_PENDING, &priv->status);
         if (priv->mac80211_registered) {
                 ieee80211_unregister_hw(priv->hw);
                 priv->mac80211_registered = 0;
+        } else {
+                iwl4965_down(priv);
         }
 
-        set_bit(STATUS_EXIT_PENDING, &priv->status);
-
-        iwl4965_down(priv);
-
         /* make sure we flush any pending irq or
          * tasklet for the driver
          */
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index c72f72579bea..80f2f84defa8 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -592,12 +592,11 @@ static void iwlcore_free_geos(struct iwl_priv *priv)
         clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
 }
 
-static u8 is_single_rx_stream(struct iwl_priv *priv)
+static bool is_single_rx_stream(struct iwl_priv *priv)
 {
         return !priv->current_ht_config.is_ht ||
                ((priv->current_ht_config.supp_mcs_set[1] == 0) &&
-                (priv->current_ht_config.supp_mcs_set[2] == 0)) ||
-               priv->ps_mode == IWL_MIMO_PS_STATIC;
+                (priv->current_ht_config.supp_mcs_set[2] == 0));
 }
 
 static u8 iwl_is_channel_extension(struct iwl_priv *priv,
@@ -704,33 +703,39 @@ EXPORT_SYMBOL(iwl_set_rxon_ht);
  * MIMO (dual stream) requires at least 2, but works better with 3.
  * This does not determine *which* chains to use, just how many.
  */
-static int iwlcore_get_rx_chain_counter(struct iwl_priv *priv,
-                                        u8 *idle_state, u8 *rx_state)
+static int iwl_get_active_rx_chain_count(struct iwl_priv *priv)
 {
-        u8 is_single = is_single_rx_stream(priv);
-        u8 is_cam = test_bit(STATUS_POWER_PMI, &priv->status) ? 0 : 1;
+        bool is_single = is_single_rx_stream(priv);
+        bool is_cam = !test_bit(STATUS_POWER_PMI, &priv->status);
 
         /* # of Rx chains to use when expecting MIMO. */
         if (is_single || (!is_cam && (priv->ps_mode == IWL_MIMO_PS_STATIC)))
-                *rx_state = 2;
+                return 2;
         else
-                *rx_state = 3;
+                return 3;
+}
 
+static int iwl_get_idle_rx_chain_count(struct iwl_priv *priv, int active_cnt)
+{
+        int idle_cnt;
+        bool is_cam = !test_bit(STATUS_POWER_PMI, &priv->status);
         /* # Rx chains when idling and maybe trying to save power */
         switch (priv->ps_mode) {
         case IWL_MIMO_PS_STATIC:
         case IWL_MIMO_PS_DYNAMIC:
-                *idle_state = (is_cam) ? 2 : 1;
+                idle_cnt = (is_cam) ? 2 : 1;
                 break;
         case IWL_MIMO_PS_NONE:
-                *idle_state = (is_cam) ? *rx_state : 1;
+                idle_cnt = (is_cam) ? active_cnt : 1;
                 break;
+        case IWL_MIMO_PS_INVALID:
         default:
-                *idle_state = 1;
+                IWL_ERROR("invalide mimo ps mode %d\n", priv->ps_mode);
+                WARN_ON(1);
+                idle_cnt = -1;
                 break;
         }
-
-        return 0;
+        return idle_cnt;
 }
 
 /**
@@ -741,34 +746,44 @@ static int iwlcore_get_rx_chain_counter(struct iwl_priv *priv,
  */
 void iwl_set_rxon_chain(struct iwl_priv *priv)
 {
-        u8 is_single = is_single_rx_stream(priv);
-        u8 idle_state, rx_state;
-
-        priv->staging_rxon.rx_chain = 0;
-        rx_state = idle_state = 3;
+        bool is_single = is_single_rx_stream(priv);
+        bool is_cam = !test_bit(STATUS_POWER_PMI, &priv->status);
+        u8 idle_rx_cnt, active_rx_cnt;
+        u16 rx_chain;
 
         /* Tell uCode which antennas are actually connected.
          * Before first association, we assume all antennas are connected.
          * Just after first association, iwl_chain_noise_calibration()
          *    checks which antennas actually *are* connected. */
-        priv->staging_rxon.rx_chain |=
-                    cpu_to_le16(priv->hw_params.valid_rx_ant <<
-                                                 RXON_RX_CHAIN_VALID_POS);
+        rx_chain = priv->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS;
 
         /* How many receivers should we use? */
-        iwlcore_get_rx_chain_counter(priv, &idle_state, &rx_state);
-        priv->staging_rxon.rx_chain |=
-                cpu_to_le16(rx_state << RXON_RX_CHAIN_MIMO_CNT_POS);
-        priv->staging_rxon.rx_chain |=
-                cpu_to_le16(idle_state << RXON_RX_CHAIN_CNT_POS);
-
-        if (!is_single && (rx_state >= 2) &&
-            !test_bit(STATUS_POWER_PMI, &priv->status))
+        active_rx_cnt = iwl_get_active_rx_chain_count(priv);
+        idle_rx_cnt = iwl_get_idle_rx_chain_count(priv, active_rx_cnt);
+
+        /* correct rx chain count accoridng hw settings */
+        if (priv->hw_params.rx_chains_num < active_rx_cnt)
+                active_rx_cnt = priv->hw_params.rx_chains_num;
+
+        if (priv->hw_params.rx_chains_num < idle_rx_cnt)
+                idle_rx_cnt = priv->hw_params.rx_chains_num;
+
+        rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
+        rx_chain |= idle_rx_cnt  << RXON_RX_CHAIN_CNT_POS;
+
+        priv->staging_rxon.rx_chain = cpu_to_le16(rx_chain);
+
+        if (!is_single && (active_rx_cnt >= 2) && is_cam)
                 priv->staging_rxon.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
         else
                 priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
 
-        IWL_DEBUG_ASSOC("rx chain %X\n", priv->staging_rxon.rx_chain);
+        IWL_DEBUG_ASSOC("rx_chain=0x%Xi active=%d idle=%d\n",
+                        priv->staging_rxon.rx_chain,
+                        active_rx_cnt, idle_rx_cnt);
+
+        WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
+                active_rx_cnt < idle_rx_cnt);
 }
 EXPORT_SYMBOL(iwl_set_rxon_chain);
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h
index c19db438306c..cdfb343c7ec6 100644
--- a/drivers/net/wireless/iwlwifi/iwl-dev.h
+++ b/drivers/net/wireless/iwlwifi/iwl-dev.h
@@ -412,7 +412,6 @@ struct iwl_ht_info {
         /* self configuration data */
         u8 is_ht;
         u8 supported_chan_width;
-        u16 tx_mimo_ps_mode;
         u8 is_green_field;
         u8 sgf;                 /* HT_SHORT_GI_* short guard interval */
         u8 max_amsdu_size;
diff --git a/drivers/net/wireless/iwlwifi/iwl-fh.h b/drivers/net/wireless/iwlwifi/iwl-fh.h
index 944642450d3d..cd11c0ca2991 100644
--- a/drivers/net/wireless/iwlwifi/iwl-fh.h
+++ b/drivers/net/wireless/iwlwifi/iwl-fh.h
@@ -287,6 +287,7 @@
 
 #define FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE       (0x01000000)
 
+#define FH_MEM_TFDIB_REG1_ADDR_BITSHIFT 28
 
 /**
  * Transmit DMA Channel Control/Status Registers (TCSR)
diff --git a/drivers/net/wireless/iwlwifi/iwl-rx.c b/drivers/net/wireless/iwlwifi/iwl-rx.c
index f3f6ea49fdd2..e81bfc42a7cb 100644
--- a/drivers/net/wireless/iwlwifi/iwl-rx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-rx.c
@@ -1173,7 +1173,10 @@ void iwl_rx_reply_rx(struct iwl_priv *priv,
 
         rx_status.antenna = 0;
         rx_status.flag = 0;
-        rx_status.flag |= RX_FLAG_TSFT;
+
+        /* TSF isn't reliable. In order to allow smooth user experience,
+         * this W/A doesn't propagate it to the mac80211 */
+        /*rx_status.flag |= RX_FLAG_TSFT;*/
 
         if ((unlikely(rx_start->cfg_phy_cnt > 20))) {
                 IWL_DEBUG_DROP("dsp size out of range [0,20]: %d/n",
diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c
index 9bb6adb28b73..6c8ac3a87d54 100644
--- a/drivers/net/wireless/iwlwifi/iwl-scan.c
+++ b/drivers/net/wireless/iwlwifi/iwl-scan.c
@@ -421,7 +421,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
                 else
                         scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
 
-                if ((scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) && n_probes)
+                if (n_probes)
                         scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
 
                 scan_ch->active_dwell = cpu_to_le16(active_dwell);
diff --git a/drivers/net/wireless/iwlwifi/iwl-tx.c b/drivers/net/wireless/iwlwifi/iwl-tx.c
index d82823b5c8ab..78b1a7a4ca40 100644
--- a/drivers/net/wireless/iwlwifi/iwl-tx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-tx.c
@@ -402,12 +402,11 @@ static int iwl_hw_tx_queue_init(struct iwl_priv *priv,
 /**
  * iwl_tx_queue_init - Allocate and initialize one tx/cmd queue
  */
-static int iwl_tx_queue_init(struct iwl_priv *priv,
-                             struct iwl_tx_queue *txq,
+static int iwl_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
                              int slots_num, u32 txq_id)
 {
         int i, len;
-        int rc = 0;
+        int ret;
 
         /*
          * Alloc buffer array for commands (Tx or other types of commands).
@@ -426,19 +425,16 @@ static int iwl_tx_queue_init(struct iwl_priv *priv,
                                 continue;
                 }
 
-                txq->cmd[i] = kmalloc(len, GFP_KERNEL | GFP_DMA);
+                txq->cmd[i] = kmalloc(len, GFP_KERNEL);
                 if (!txq->cmd[i])
-                        return -ENOMEM;
+                        goto err;
         }
 
         /* Alloc driver data array and TFD circular buffer */
-        rc = iwl_tx_queue_alloc(priv, txq, txq_id);
-        if (rc) {
-                for (i = 0; i < slots_num; i++)
-                        kfree(txq->cmd[i]);
+        ret = iwl_tx_queue_alloc(priv, txq, txq_id);
+        if (ret)
+                goto err;
 
-                return -ENOMEM;
-        }
         txq->need_update = 0;
 
         /* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
@@ -452,6 +448,17 @@ static int iwl_tx_queue_init(struct iwl_priv *priv,
         iwl_hw_tx_queue_init(priv, txq);
 
         return 0;
+err:
+        for (i = 0; i < slots_num; i++) {
+                kfree(txq->cmd[i]);
+                txq->cmd[i] = NULL;
+        }
+
+        if (txq_id == IWL_CMD_QUEUE_NUM) {
+                kfree(txq->cmd[slots_num]);
+                txq->cmd[slots_num] = NULL;
+        }
+        return -ENOMEM;
 }
 /**
  * iwl_hw_txq_ctx_free - Free TXQ Context
diff --git a/drivers/net/wireless/libertas/if_cs.c b/drivers/net/wireless/libertas/if_cs.c
index 04d7a251e3f0..8941919001bb 100644
--- a/drivers/net/wireless/libertas/if_cs.c
+++ b/drivers/net/wireless/libertas/if_cs.c
@@ -595,7 +595,7 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                 if (ret < 0) {
                         lbs_pr_err("can't download helper at 0x%x, ret %d\n",
                                 sent, ret);
-                        goto done;
+                        goto err_release;
                 }
 
                 if (count == 0)
@@ -604,9 +604,8 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                 sent += count;
         }
 
+err_release:
         release_firmware(fw);
-        ret = 0;
-
 done:
         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
         return ret;
@@ -676,14 +675,8 @@ static int if_cs_prog_real(struct if_cs_card *card)
         }
 
         ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a);
-        if (ret < 0) {
+        if (ret < 0)
                 lbs_pr_err("firmware download failed\n");
-                goto err_release;
-        }
-
-        ret = 0;
-        goto done;
-
 
 err_release:
         release_firmware(fw);
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index 1ebcafe7ca5f..36c004e15602 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -1970,6 +1970,9 @@ __orinoco_set_multicast_list(struct net_device *dev)
                         priv->promiscuous = promisc;
         }
 
+        /* If we're not in promiscuous mode, then we need to set the
+         * group address if either we want to multicast, or if we were
+         * multicasting and want to stop */
         if (! promisc && (mc_count || priv->mc_count) ) {
                 struct dev_mc_list *p = dev->mc_list;
                 struct hermes_multicast mclist;
@@ -1989,9 +1992,10 @@ __orinoco_set_multicast_list(struct net_device *dev)
                         printk(KERN_WARNING "%s: Multicast list is "
                                "longer than mc_count\n", dev->name);
 
-                err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFGROUPADDRESSES,
-                                       HERMES_BYTES_TO_RECLEN(priv->mc_count * ETH_ALEN),
-                                       &mclist);
+                err = hermes_write_ltv(hw, USER_BAP,
+                                   HERMES_RID_CNFGROUPADDRESSES,
+                                   HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
+                                   &mclist);
                 if (err)
                         printk(KERN_ERR "%s: Error %d setting multicast list.\n",
                                dev->name, err);
diff --git a/drivers/net/wireless/rt2x00/rt2x00reg.h b/drivers/net/wireless/rt2x00/rt2x00reg.h
index 7e88ce5651b9..2ea7866abd5d 100644
--- a/drivers/net/wireless/rt2x00/rt2x00reg.h
+++ b/drivers/net/wireless/rt2x00/rt2x00reg.h
@@ -136,7 +136,7 @@ struct rt2x00_field32 {
  */
 #define is_power_of_two(x)      ( !((x) & ((x)-1)) )
 #define low_bit_mask(x)         ( ((x)-1) & ~(x) )
-#define is_valid_mask(x)        is_power_of_two(1 + (x) + low_bit_mask(x))
+#define is_valid_mask(x)        is_power_of_two(1LU + (x) + low_bit_mask(x))
 
 /*
  * Macro's to find first set bit in a variable.
@@ -173,8 +173,7 @@ struct rt2x00_field32 {
  * does not exceed the given typelimit.
  */
 #define FIELD_CHECK(__mask, __type)                     \
-        BUILD_BUG_ON(!__builtin_constant_p(__mask) ||   \
-                     !(__mask) ||                       \
+        BUILD_BUG_ON(!(__mask) ||                       \
                      !is_valid_mask(__mask) ||          \
                      (__mask) != (__type)(__mask))      \