30 files changed, 598 insertions, 153 deletions

diff --git a/drivers/net/cris/eth_v10.c b/drivers/net/cris/eth_v10.c
index f0c8bd54ce29..021d69c5d9bc 100644
--- a/drivers/net/cris/eth_v10.c
+++ b/drivers/net/cris/eth_v10.c
@@ -1712,7 +1712,7 @@ e100_set_network_leds(int active)
 static void
 e100_netpoll(struct net_device* netdev)
 {
-        e100rxtx_interrupt(NETWORK_DMA_TX_IRQ_NBR, netdev, NULL);
+        e100rxtx_interrupt(NETWORK_DMA_TX_IRQ_NBR, netdev);
 }
 #endif
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
index 734fd87cd990..62f754bd0dfe 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
@@ -2485,6 +2485,7 @@ static int bnx2x_mcast_enqueue_cmd(struct bnx2x *bp,
                 break;
 
         default:
+                kfree(new_cmd);
                 BNX2X_ERR("Unknown command: %d\n", cmd);
                 return -EINVAL;
         }
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index c60de89b6669..90a903d83d87 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -1948,7 +1948,7 @@ static int be_rx_cqs_create(struct be_adapter *adapter)
 
         if (adapter->num_rx_qs != MAX_RX_QS)
                 dev_info(&adapter->pdev->dev,
-                        "Created only %d receive queues", adapter->num_rx_qs);
+                        "Created only %d receive queues\n", adapter->num_rx_qs);
 
         return 0;
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index f32e70300770..5aba5ecdf1e2 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -614,8 +614,8 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                 /* If source MAC is equal to our own MAC and not performing
                  * the selftest or flb disabled - drop the packet */
                 if (s_mac == priv->mac &&
-                        (!(dev->features & NETIF_F_LOOPBACK) ||
-                         !priv->validate_loopback))
+                    !((dev->features & NETIF_F_LOOPBACK) ||
+                      priv->validate_loopback))
                         goto next;
 
                 /*
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
index 019d856b1334..10bba09c44ea 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
@@ -164,7 +164,6 @@ int mlx4_en_activate_tx_ring(struct mlx4_en_priv *priv,
         ring->cons = 0xffffffff;
         ring->last_nr_txbb = 1;
         ring->poll_cnt = 0;
-        ring->blocked = 0;
         memset(ring->tx_info, 0, ring->size * sizeof(struct mlx4_en_tx_info));
         memset(ring->buf, 0, ring->buf_size);
 
@@ -365,14 +364,13 @@ static void mlx4_en_process_tx_cq(struct net_device *dev, struct mlx4_en_cq *cq)
         ring->cons += txbbs_skipped;
         netdev_tx_completed_queue(ring->tx_queue, packets, bytes);
 
-        /* Wakeup Tx queue if this ring stopped it */
-        if (unlikely(ring->blocked)) {
-                if ((u32) (ring->prod - ring->cons) <=
-                     ring->size - HEADROOM - MAX_DESC_TXBBS) {
-                        ring->blocked = 0;
-                        netif_tx_wake_queue(ring->tx_queue);
-                        priv->port_stats.wake_queue++;
-                }
+        /*
+         * Wakeup Tx queue if this stopped, and at least 1 packet
+         * was completed
+         */
+        if (netif_tx_queue_stopped(ring->tx_queue) && txbbs_skipped > 0) {
+                netif_tx_wake_queue(ring->tx_queue);
+                priv->port_stats.wake_queue++;
         }
 }
 
@@ -592,7 +590,6 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                      ring->size - HEADROOM - MAX_DESC_TXBBS)) {
                 /* every full Tx ring stops queue */
                 netif_tx_stop_queue(ring->tx_queue);
-                ring->blocked = 1;
                 priv->port_stats.queue_stopped++;
 
                 return NETDEV_TX_BUSY;
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 48d0e90194cb..827b72dfce99 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -157,9 +157,6 @@ int mlx4_check_port_params(struct mlx4_dev *dev,
                                          "on this HCA, aborting.\n");
                                 return -EINVAL;
                         }
-                        if (port_type[i] == MLX4_PORT_TYPE_ETH &&
-                            port_type[i + 1] == MLX4_PORT_TYPE_IB)
-                                return -EINVAL;
                 }
         }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index 5f1ab105debc..9d27e42264e2 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -248,7 +248,6 @@ struct mlx4_en_tx_ring {
         u32 doorbell_qpn;
         void *buf;
         u16 poll_cnt;
-        int blocked;
         struct mlx4_en_tx_info *tx_info;
         u8 *bounce_buf;
         u32 last_nr_txbb;
diff --git a/drivers/net/ethernet/mellanox/mlx4/sense.c b/drivers/net/ethernet/mellanox/mlx4/sense.c
index 802498293528..34ee09bae36e 100644
--- a/drivers/net/ethernet/mellanox/mlx4/sense.c
+++ b/drivers/net/ethernet/mellanox/mlx4/sense.c
@@ -81,20 +81,6 @@ void mlx4_do_sense_ports(struct mlx4_dev *dev,
         }
 
         /*
-         * Adjust port configuration:
-         * If port 1 sensed nothing and port 2 is IB, set both as IB
-         * If port 2 sensed nothing and port 1 is Eth, set both as Eth
-         */
-        if (stype[0] == MLX4_PORT_TYPE_ETH) {
-                for (i = 1; i < dev->caps.num_ports; i++)
-                        stype[i] = stype[i] ? stype[i] : MLX4_PORT_TYPE_ETH;
-        }
-        if (stype[dev->caps.num_ports - 1] == MLX4_PORT_TYPE_IB) {
-                for (i = 0; i < dev->caps.num_ports - 1; i++)
-                        stype[i] = stype[i] ? stype[i] : MLX4_PORT_TYPE_IB;
-        }
-
-        /*
          * If sensed nothing, remain in current configuration.
          */
         for (i = 0; i < dev->caps.num_ports; i++)
diff --git a/drivers/net/ethernet/sfc/efx.c b/drivers/net/ethernet/sfc/efx.c
index 70554a1b2b02..65a8d49106a4 100644
--- a/drivers/net/ethernet/sfc/efx.c
+++ b/drivers/net/ethernet/sfc/efx.c
@@ -1503,6 +1503,11 @@ static int efx_probe_all(struct efx_nic *efx)
                 goto fail2;
         }
 
+        BUILD_BUG_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_RXQ_MIN_ENT);
+        if (WARN_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_TXQ_MIN_ENT(efx))) {
+                rc = -EINVAL;
+                goto fail3;
+        }
         efx->rxq_entries = efx->txq_entries = EFX_DEFAULT_DMAQ_SIZE;
 
         rc = efx_probe_filters(efx);
@@ -2070,6 +2075,7 @@ static int efx_register_netdev(struct efx_nic *efx)
         net_dev->irq = efx->pci_dev->irq;
         net_dev->netdev_ops = &efx_netdev_ops;
         SET_ETHTOOL_OPS(net_dev, &efx_ethtool_ops);
+        net_dev->gso_max_segs = EFX_TSO_MAX_SEGS;
 
         rtnl_lock();
 
diff --git a/drivers/net/ethernet/sfc/efx.h b/drivers/net/ethernet/sfc/efx.h
index be8f9158a714..70755c97251a 100644
--- a/drivers/net/ethernet/sfc/efx.h
+++ b/drivers/net/ethernet/sfc/efx.h
@@ -30,6 +30,7 @@ extern netdev_tx_t
 efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb);
 extern void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index);
 extern int efx_setup_tc(struct net_device *net_dev, u8 num_tc);
+extern unsigned int efx_tx_max_skb_descs(struct efx_nic *efx);
 
 /* RX */
 extern int efx_probe_rx_queue(struct efx_rx_queue *rx_queue);
@@ -52,10 +53,15 @@ extern void efx_schedule_slow_fill(struct efx_rx_queue *rx_queue);
 #define EFX_MAX_EVQ_SIZE 16384UL
 #define EFX_MIN_EVQ_SIZE 512UL
 
-/* The smallest [rt]xq_entries that the driver supports. Callers of
- * efx_wake_queue() assume that they can subsequently send at least one
- * skb. Falcon/A1 may require up to three descriptors per skb_frag. */
-#define EFX_MIN_RING_SIZE (roundup_pow_of_two(2 * 3 * MAX_SKB_FRAGS))
+/* Maximum number of TCP segments we support for soft-TSO */
+#define EFX_TSO_MAX_SEGS        100
+
+/* The smallest [rt]xq_entries that the driver supports.  RX minimum
+ * is a bit arbitrary.  For TX, we must have space for at least 2
+ * TSO skbs.
+ */
+#define EFX_RXQ_MIN_ENT         128U
+#define EFX_TXQ_MIN_ENT(efx)    (2 * efx_tx_max_skb_descs(efx))
 
 /* Filters */
 extern int efx_probe_filters(struct efx_nic *efx);
diff --git a/drivers/net/ethernet/sfc/ethtool.c b/drivers/net/ethernet/sfc/ethtool.c
index 10536f93b561..8cba2df82b18 100644
--- a/drivers/net/ethernet/sfc/ethtool.c
+++ b/drivers/net/ethernet/sfc/ethtool.c
@@ -680,21 +680,27 @@ static int efx_ethtool_set_ringparam(struct net_device *net_dev,
                                      struct ethtool_ringparam *ring)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
+        u32 txq_entries;
 
         if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
             ring->rx_pending > EFX_MAX_DMAQ_SIZE ||
             ring->tx_pending > EFX_MAX_DMAQ_SIZE)
                 return -EINVAL;
 
-        if (ring->rx_pending < EFX_MIN_RING_SIZE ||
-            ring->tx_pending < EFX_MIN_RING_SIZE) {
+        if (ring->rx_pending < EFX_RXQ_MIN_ENT) {
                 netif_err(efx, drv, efx->net_dev,
-                          "TX and RX queues cannot be smaller than %ld\n",
-                          EFX_MIN_RING_SIZE);
+                          "RX queues cannot be smaller than %u\n",
+                          EFX_RXQ_MIN_ENT);
                 return -EINVAL;
         }
 
-        return efx_realloc_channels(efx, ring->rx_pending, ring->tx_pending);
+        txq_entries = max(ring->tx_pending, EFX_TXQ_MIN_ENT(efx));
+        if (txq_entries != ring->tx_pending)
+                netif_warn(efx, drv, efx->net_dev,
+                           "increasing TX queue size to minimum of %u\n",
+                           txq_entries);
+
+        return efx_realloc_channels(efx, ring->rx_pending, txq_entries);
 }
 
 static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
diff --git a/drivers/net/ethernet/sfc/tx.c b/drivers/net/ethernet/sfc/tx.c
index 9b225a7769f7..18713436b443 100644
--- a/drivers/net/ethernet/sfc/tx.c
+++ b/drivers/net/ethernet/sfc/tx.c
@@ -119,6 +119,25 @@ efx_max_tx_len(struct efx_nic *efx, dma_addr_t dma_addr)
         return len;
 }
 
+unsigned int efx_tx_max_skb_descs(struct efx_nic *efx)
+{
+        /* Header and payload descriptor for each output segment, plus
+         * one for every input fragment boundary within a segment
+         */
+        unsigned int max_descs = EFX_TSO_MAX_SEGS * 2 + MAX_SKB_FRAGS;
+
+        /* Possibly one more per segment for the alignment workaround */
+        if (EFX_WORKAROUND_5391(efx))
+                max_descs += EFX_TSO_MAX_SEGS;
+
+        /* Possibly more for PCIe page boundaries within input fragments */
+        if (PAGE_SIZE > EFX_PAGE_SIZE)
+                max_descs += max_t(unsigned int, MAX_SKB_FRAGS,
+                                   DIV_ROUND_UP(GSO_MAX_SIZE, EFX_PAGE_SIZE));
+
+        return max_descs;
+}
+
 /*
  * Add a socket buffer to a TX queue
  *
diff --git a/drivers/net/ethernet/ti/Kconfig b/drivers/net/ethernet/ti/Kconfig
index 1b173a6145d6..b26cbda5efa9 100644
--- a/drivers/net/ethernet/ti/Kconfig
+++ b/drivers/net/ethernet/ti/Kconfig
@@ -32,7 +32,7 @@ config TI_DAVINCI_EMAC
 
 config TI_DAVINCI_MDIO
         tristate "TI DaVinci MDIO Support"
-        depends on ARM && ( ARCH_DAVINCI || ARCH_OMAP3 )
+        depends on ARM && ( ARCH_DAVINCI || ARCH_OMAP3 || SOC_AM33XX )
         select PHYLIB
         ---help---
           This driver supports TI's DaVinci MDIO module.
@@ -42,7 +42,7 @@ config TI_DAVINCI_MDIO
 
 config TI_DAVINCI_CPDMA
         tristate "TI DaVinci CPDMA Support"
-        depends on ARM && ( ARCH_DAVINCI || ARCH_OMAP3 )
+        depends on ARM && ( ARCH_DAVINCI || ARCH_OMAP3 || SOC_AM33XX )
         ---help---
           This driver supports TI's DaVinci CPDMA dma engine.
 
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index 1e5d85b06e71..0cbc0e59252c 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -28,6 +28,9 @@
 #include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/pm_runtime.h>
+#include <linux/of.h>
+#include <linux/of_net.h>
+#include <linux/of_device.h>
 
 #include <linux/platform_data/cpsw.h>
 
@@ -709,6 +712,158 @@ static void cpsw_slave_init(struct cpsw_slave *slave, struct cpsw_priv *priv)
         slave->sliver   = regs + data->sliver_reg_ofs;
 }
 
+static int cpsw_probe_dt(struct cpsw_platform_data *data,
+                         struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        struct device_node *slave_node;
+        int i = 0, ret;
+        u32 prop;
+
+        if (!node)
+                return -EINVAL;
+
+        if (of_property_read_u32(node, "slaves", &prop)) {
+                pr_err("Missing slaves property in the DT.\n");
+                return -EINVAL;
+        }
+        data->slaves = prop;
+
+        data->slave_data = kzalloc(sizeof(struct cpsw_slave_data) *
+                                   data->slaves, GFP_KERNEL);
+        if (!data->slave_data) {
+                pr_err("Could not allocate slave memory.\n");
+                return -EINVAL;
+        }
+
+        data->no_bd_ram = of_property_read_bool(node, "no_bd_ram");
+
+        if (of_property_read_u32(node, "cpdma_channels", &prop)) {
+                pr_err("Missing cpdma_channels property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->channels = prop;
+
+        if (of_property_read_u32(node, "host_port_no", &prop)) {
+                pr_err("Missing host_port_no property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->host_port_num = prop;
+
+        if (of_property_read_u32(node, "cpdma_reg_ofs", &prop)) {
+                pr_err("Missing cpdma_reg_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpdma_reg_ofs = prop;
+
+        if (of_property_read_u32(node, "cpdma_sram_ofs", &prop)) {
+                pr_err("Missing cpdma_sram_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpdma_sram_ofs = prop;
+
+        if (of_property_read_u32(node, "ale_reg_ofs", &prop)) {
+                pr_err("Missing ale_reg_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->ale_reg_ofs = prop;
+
+        if (of_property_read_u32(node, "ale_entries", &prop)) {
+                pr_err("Missing ale_entries property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->ale_entries = prop;
+
+        if (of_property_read_u32(node, "host_port_reg_ofs", &prop)) {
+                pr_err("Missing host_port_reg_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->host_port_reg_ofs = prop;
+
+        if (of_property_read_u32(node, "hw_stats_reg_ofs", &prop)) {
+                pr_err("Missing hw_stats_reg_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->hw_stats_reg_ofs = prop;
+
+        if (of_property_read_u32(node, "bd_ram_ofs", &prop)) {
+                pr_err("Missing bd_ram_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->bd_ram_ofs = prop;
+
+        if (of_property_read_u32(node, "bd_ram_size", &prop)) {
+                pr_err("Missing bd_ram_size property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->bd_ram_size = prop;
+
+        if (of_property_read_u32(node, "rx_descs", &prop)) {
+                pr_err("Missing rx_descs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->rx_descs = prop;
+
+        if (of_property_read_u32(node, "mac_control", &prop)) {
+                pr_err("Missing mac_control property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->mac_control = prop;
+
+        for_each_child_of_node(node, slave_node) {
+                struct cpsw_slave_data *slave_data = data->slave_data + i;
+                const char *phy_id = NULL;
+                const void *mac_addr = NULL;
+
+                if (of_property_read_string(slave_node, "phy_id", &phy_id)) {
+                        pr_err("Missing slave[%d] phy_id property\n", i);
+                        ret = -EINVAL;
+                        goto error_ret;
+                }
+                slave_data->phy_id = phy_id;
+
+                if (of_property_read_u32(slave_node, "slave_reg_ofs", &prop)) {
+                        pr_err("Missing slave[%d] slave_reg_ofs property\n", i);
+                        ret = -EINVAL;
+                        goto error_ret;
+                }
+                slave_data->slave_reg_ofs = prop;
+
+                if (of_property_read_u32(slave_node, "sliver_reg_ofs",
+                                         &prop)) {
+                        pr_err("Missing slave[%d] sliver_reg_ofs property\n",
+                                i);
+                        ret = -EINVAL;
+                        goto error_ret;
+                }
+                slave_data->sliver_reg_ofs = prop;
+
+                mac_addr = of_get_mac_address(slave_node);
+                if (mac_addr)
+                        memcpy(slave_data->mac_addr, mac_addr, ETH_ALEN);
+
+                i++;
+        }
+
+        return 0;
+
+error_ret:
+        kfree(data->slave_data);
+        return ret;
+}
+
 static int __devinit cpsw_probe(struct platform_device *pdev)
 {
         struct cpsw_platform_data       *data = pdev->dev.platform_data;
@@ -720,11 +875,6 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
         struct resource                 *res;
         int ret = 0, i, k = 0;
 
-        if (!data) {
-                pr_err("platform data missing\n");
-                return -ENODEV;
-        }
-
         ndev = alloc_etherdev(sizeof(struct cpsw_priv));
         if (!ndev) {
                 pr_err("error allocating net_device\n");
@@ -734,13 +884,19 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, ndev);
         priv = netdev_priv(ndev);
         spin_lock_init(&priv->lock);
-        priv->data = *data;
         priv->pdev = pdev;
         priv->ndev = ndev;
         priv->dev  = &ndev->dev;
         priv->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG);
         priv->rx_packet_max = max(rx_packet_max, 128);
 
+        if (cpsw_probe_dt(&priv->data, pdev)) {
+                pr_err("cpsw: platform data missing\n");
+                ret = -ENODEV;
+                goto clean_ndev_ret;
+        }
+        data = &priv->data;
+
         if (is_valid_ether_addr(data->slave_data[0].mac_addr)) {
                 memcpy(priv->mac_addr, data->slave_data[0].mac_addr, ETH_ALEN);
                 pr_info("Detected MACID = %pM", priv->mac_addr);
@@ -996,11 +1152,17 @@ static const struct dev_pm_ops cpsw_pm_ops = {
         .resume         = cpsw_resume,
 };
 
+static const struct of_device_id cpsw_of_mtable[] = {
+        { .compatible = "ti,cpsw", },
+        { /* sentinel */ },
+};
+
 static struct platform_driver cpsw_driver = {
         .driver = {
                 .name    = "cpsw",
                 .owner   = THIS_MODULE,
                 .pm      = &cpsw_pm_ops,
+                .of_match_table = of_match_ptr(cpsw_of_mtable),
         },
         .probe = cpsw_probe,
         .remove = __devexit_p(cpsw_remove),
diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 6cee2917eb02..4a1a5f58fa73 100644
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -383,13 +383,6 @@ int netvsc_device_remove(struct hv_device *device)
         unsigned long flags;
 
         net_device = hv_get_drvdata(device);
-        spin_lock_irqsave(&device->channel->inbound_lock, flags);
-        net_device->destroy = true;
-        spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
-
-        /* Wait for all send completions */
-        wait_event(net_device->wait_drain,
-                   atomic_read(&net_device->num_outstanding_sends) == 0);
 
         netvsc_disconnect_vsp(net_device);
 
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index e5d6146937fa..1e88a1095934 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -718,6 +718,9 @@ static void rndis_filter_halt_device(struct rndis_device *dev)
 {
         struct rndis_request *request;
         struct rndis_halt_request *halt;
+        struct netvsc_device *nvdev = dev->net_dev;
+        struct hv_device *hdev = nvdev->dev;
+        ulong flags;
 
         /* Attempt to do a rndis device halt */
         request = get_rndis_request(dev, RNDIS_MSG_HALT,
@@ -735,6 +738,14 @@ static void rndis_filter_halt_device(struct rndis_device *dev)
         dev->state = RNDIS_DEV_UNINITIALIZED;
 
 cleanup:
+        spin_lock_irqsave(&hdev->channel->inbound_lock, flags);
+        nvdev->destroy = true;
+        spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);
+
+        /* Wait for all send completions */
+        wait_event(nvdev->wait_drain,
+                atomic_read(&nvdev->num_outstanding_sends) == 0);
+
         if (request)
                 put_rndis_request(dev, request);
         return;
diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c
index 5c0557222f20..eb3f5cefeba3 100644
--- a/drivers/net/ppp/ppp_generic.c
+++ b/drivers/net/ppp/ppp_generic.c
@@ -94,6 +94,18 @@ struct ppp_file {
 #define PF_TO_CHANNEL(pf)       PF_TO_X(pf, struct channel)
 
 /*
+ * Data structure to hold primary network stats for which
+ * we want to use 64 bit storage.  Other network stats
+ * are stored in dev->stats of the ppp strucute.
+ */
+struct ppp_link_stats {
+        u64 rx_packets;
+        u64 tx_packets;
+        u64 rx_bytes;
+        u64 tx_bytes;
+};
+
+/*
  * Data structure describing one ppp unit.
  * A ppp unit corresponds to a ppp network interface device
  * and represents a multilink bundle.
@@ -136,6 +148,7 @@ struct ppp {
         unsigned pass_len, active_len;
 #endif /* CONFIG_PPP_FILTER */
         struct net      *ppp_net;       /* the net we belong to */
+        struct ppp_link_stats stats64;  /* 64 bit network stats */
 };
 
 /*
@@ -1021,9 +1034,34 @@ ppp_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
         return err;
 }
 
+struct rtnl_link_stats64*
+ppp_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats64)
+{
+        struct ppp *ppp = netdev_priv(dev);
+
+        ppp_recv_lock(ppp);
+        stats64->rx_packets = ppp->stats64.rx_packets;
+        stats64->rx_bytes   = ppp->stats64.rx_bytes;
+        ppp_recv_unlock(ppp);
+
+        ppp_xmit_lock(ppp);
+        stats64->tx_packets = ppp->stats64.tx_packets;
+        stats64->tx_bytes   = ppp->stats64.tx_bytes;
+        ppp_xmit_unlock(ppp);
+
+        stats64->rx_errors        = dev->stats.rx_errors;
+        stats64->tx_errors        = dev->stats.tx_errors;
+        stats64->rx_dropped       = dev->stats.rx_dropped;
+        stats64->tx_dropped       = dev->stats.tx_dropped;
+        stats64->rx_length_errors = dev->stats.rx_length_errors;
+
+        return stats64;
+}
+
 static const struct net_device_ops ppp_netdev_ops = {
-        .ndo_start_xmit = ppp_start_xmit,
-        .ndo_do_ioctl   = ppp_net_ioctl,
+        .ndo_start_xmit  = ppp_start_xmit,
+        .ndo_do_ioctl    = ppp_net_ioctl,
+        .ndo_get_stats64 = ppp_get_stats64,
 };
 
 static void ppp_setup(struct net_device *dev)
@@ -1157,8 +1195,8 @@ ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
 #endif /* CONFIG_PPP_FILTER */
         }
 
-        ++ppp->dev->stats.tx_packets;
-        ppp->dev->stats.tx_bytes += skb->len - 2;
+        ++ppp->stats64.tx_packets;
+        ppp->stats64.tx_bytes += skb->len - 2;
 
         switch (proto) {
         case PPP_IP:
@@ -1745,8 +1783,8 @@ ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb)
                 break;
         }
 
-        ++ppp->dev->stats.rx_packets;
-        ppp->dev->stats.rx_bytes += skb->len - 2;
+        ++ppp->stats64.rx_packets;
+        ppp->stats64.rx_bytes += skb->len - 2;
 
         npi = proto_to_npindex(proto);
         if (npi < 0) {
@@ -2570,12 +2608,12 @@ ppp_get_stats(struct ppp *ppp, struct ppp_stats *st)
         struct slcompress *vj = ppp->vj;
 
         memset(st, 0, sizeof(*st));
-        st->p.ppp_ipackets = ppp->dev->stats.rx_packets;
+        st->p.ppp_ipackets = ppp->stats64.rx_packets;
         st->p.ppp_ierrors = ppp->dev->stats.rx_errors;
-        st->p.ppp_ibytes = ppp->dev->stats.rx_bytes;
-        st->p.ppp_opackets = ppp->dev->stats.tx_packets;
+        st->p.ppp_ibytes = ppp->stats64.rx_bytes;
+        st->p.ppp_opackets = ppp->stats64.tx_packets;
         st->p.ppp_oerrors = ppp->dev->stats.tx_errors;
-        st->p.ppp_obytes = ppp->dev->stats.tx_bytes;
+        st->p.ppp_obytes = ppp->stats64.tx_bytes;
         if (!vj)
                 return;
         st->vj.vjs_packets = vj->sls_o_compressed + vj->sls_o_uncompressed;
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 87707ab39430..ba10c469b02b 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -658,6 +658,122 @@ static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
 }
 
 
+/*************************************
+ * Multiqueue Tx port select override
+ *************************************/
+
+static int team_queue_override_init(struct team *team)
+{
+        struct list_head *listarr;
+        unsigned int queue_cnt = team->dev->num_tx_queues - 1;
+        unsigned int i;
+
+        if (!queue_cnt)
+                return 0;
+        listarr = kmalloc(sizeof(struct list_head) * queue_cnt, GFP_KERNEL);
+        if (!listarr)
+                return -ENOMEM;
+        team->qom_lists = listarr;
+        for (i = 0; i < queue_cnt; i++)
+                INIT_LIST_HEAD(listarr++);
+        return 0;
+}
+
+static void team_queue_override_fini(struct team *team)
+{
+        kfree(team->qom_lists);
+}
+
+static struct list_head *__team_get_qom_list(struct team *team, u16 queue_id)
+{
+        return &team->qom_lists[queue_id - 1];
+}
+
+/*
+ * note: already called with rcu_read_lock
+ */
+static bool team_queue_override_transmit(struct team *team, struct sk_buff *skb)
+{
+        struct list_head *qom_list;
+        struct team_port *port;
+
+        if (!team->queue_override_enabled || !skb->queue_mapping)
+                return false;
+        qom_list = __team_get_qom_list(team, skb->queue_mapping);
+        list_for_each_entry_rcu(port, qom_list, qom_list) {
+                if (!team_dev_queue_xmit(team, port, skb))
+                        return true;
+        }
+        return false;
+}
+
+static void __team_queue_override_port_del(struct team *team,
+                                           struct team_port *port)
+{
+        list_del_rcu(&port->qom_list);
+        synchronize_rcu();
+        INIT_LIST_HEAD(&port->qom_list);
+}
+
+static bool team_queue_override_port_has_gt_prio_than(struct team_port *port,
+                                                      struct team_port *cur)
+{
+        if (port->priority < cur->priority)
+                return true;
+        if (port->priority > cur->priority)
+                return false;
+        if (port->index < cur->index)
+                return true;
+        return false;
+}
+
+static void __team_queue_override_port_add(struct team *team,
+                                           struct team_port *port)
+{
+        struct team_port *cur;
+        struct list_head *qom_list;
+        struct list_head *node;
+
+        if (!port->queue_id || !team_port_enabled(port))
+                return;
+
+        qom_list = __team_get_qom_list(team, port->queue_id);
+        node = qom_list;
+        list_for_each_entry(cur, qom_list, qom_list) {
+                if (team_queue_override_port_has_gt_prio_than(port, cur))
+                        break;
+                node = &cur->qom_list;
+        }
+        list_add_tail_rcu(&port->qom_list, node);
+}
+
+static void __team_queue_override_enabled_check(struct team *team)
+{
+        struct team_port *port;
+        bool enabled = false;
+
+        list_for_each_entry(port, &team->port_list, list) {
+                if (!list_empty(&port->qom_list)) {
+                        enabled = true;
+                        break;
+                }
+        }
+        if (enabled == team->queue_override_enabled)
+                return;
+        netdev_dbg(team->dev, "%s queue override\n",
+                   enabled ? "Enabling" : "Disabling");
+        team->queue_override_enabled = enabled;
+}
+
+static void team_queue_override_port_refresh(struct team *team,
+                                             struct team_port *port)
+{
+        __team_queue_override_port_del(team, port);
+        __team_queue_override_port_add(team, port);
+        __team_queue_override_enabled_check(team);
+}
+
+
 /****************
  * Port handling
  ****************/
@@ -688,6 +804,7 @@ static void team_port_enable(struct team *team,
         hlist_add_head_rcu(&port->hlist,
                            team_port_index_hash(team, port->index));
         team_adjust_ops(team);
+        team_queue_override_port_refresh(team, port);
         if (team->ops.port_enabled)
                 team->ops.port_enabled(team, port);
 }
@@ -716,6 +833,7 @@ static void team_port_disable(struct team *team,
         hlist_del_rcu(&port->hlist);
         __reconstruct_port_hlist(team, port->index);
         port->index = -1;
+        team_queue_override_port_refresh(team, port);
         __team_adjust_ops(team, team->en_port_count - 1);
         /*
          * Wait until readers see adjusted ops. This ensures that
@@ -881,6 +999,7 @@ static int team_port_add(struct team *team, struct net_device *port_dev)
 
         port->dev = port_dev;
         port->team = team;
+        INIT_LIST_HEAD(&port->qom_list);
 
         port->orig.mtu = port_dev->mtu;
         err = dev_set_mtu(port_dev, dev->mtu);
@@ -1092,6 +1211,49 @@ static int team_user_linkup_en_option_set(struct team *team,
         return 0;
 }
 
+static int team_priority_option_get(struct team *team,
+                                    struct team_gsetter_ctx *ctx)
+{
+        struct team_port *port = ctx->info->port;
+
+        ctx->data.s32_val = port->priority;
+        return 0;
+}
+
+static int team_priority_option_set(struct team *team,
+                                    struct team_gsetter_ctx *ctx)
+{
+        struct team_port *port = ctx->info->port;
+
+        port->priority = ctx->data.s32_val;
+        team_queue_override_port_refresh(team, port);
+        return 0;
+}
+
+static int team_queue_id_option_get(struct team *team,
+                                    struct team_gsetter_ctx *ctx)
+{
+        struct team_port *port = ctx->info->port;
+
+        ctx->data.u32_val = port->queue_id;
+        return 0;
+}
+
+static int team_queue_id_option_set(struct team *team,
+                                    struct team_gsetter_ctx *ctx)
+{
+        struct team_port *port = ctx->info->port;
+
+        if (port->queue_id == ctx->data.u32_val)
+                return 0;
+        if (ctx->data.u32_val >= team->dev->real_num_tx_queues)
+                return -EINVAL;
+        port->queue_id = ctx->data.u32_val;
+        team_queue_override_port_refresh(team, port);
+        return 0;
+}
+
+
 static const struct team_option team_options[] = {
         {
                 .name = "mode",
@@ -1120,6 +1282,20 @@ static const struct team_option team_options[] = {
                 .getter = team_user_linkup_en_option_get,
                 .setter = team_user_linkup_en_option_set,
         },
+        {
+                .name = "priority",
+                .type = TEAM_OPTION_TYPE_S32,
+                .per_port = true,
+                .getter = team_priority_option_get,
+                .setter = team_priority_option_set,
+        },
+        {
+                .name = "queue_id",
+                .type = TEAM_OPTION_TYPE_U32,
+                .per_port = true,
+                .getter = team_queue_id_option_get,
+                .setter = team_queue_id_option_set,
+        },
 };
 
 static struct lock_class_key team_netdev_xmit_lock_key;
@@ -1155,6 +1331,9 @@ static int team_init(struct net_device *dev)
         for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
                 INIT_HLIST_HEAD(&team->en_port_hlist[i]);
         INIT_LIST_HEAD(&team->port_list);
+        err = team_queue_override_init(team);
+        if (err)
+                goto err_team_queue_override_init;
 
         team_adjust_ops(team);
 
@@ -1170,6 +1349,8 @@ static int team_init(struct net_device *dev)
         return 0;
 
 err_options_register:
+        team_queue_override_fini(team);
+err_team_queue_override_init:
         free_percpu(team->pcpu_stats);
 
         return err;
@@ -1187,6 +1368,7 @@ static void team_uninit(struct net_device *dev)
 
         __team_change_mode(team, NULL); /* cleanup */
         __team_options_unregister(team, team_options, ARRAY_SIZE(team_options));
+        team_queue_override_fini(team);
         mutex_unlock(&team->lock);
 }
 
@@ -1216,10 +1398,12 @@ static int team_close(struct net_device *dev)
 static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct team *team = netdev_priv(dev);
-        bool tx_success = false;
+        bool tx_success;
         unsigned int len = skb->len;
 
-        tx_success = team->ops.transmit(team, skb);
+        tx_success = team_queue_override_transmit(team, skb);
+        if (!tx_success)
+                tx_success = team->ops.transmit(team, skb);
         if (tx_success) {
                 struct team_pcpu_stats *pcpu_stats;
 
@@ -1787,6 +1971,12 @@ static int team_nl_fill_one_option_get(struct sk_buff *skb, struct team *team,
                     nla_put_flag(skb, TEAM_ATTR_OPTION_DATA))
                         goto nest_cancel;
                 break;
+        case TEAM_OPTION_TYPE_S32:
+                if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_S32))
+                        goto nest_cancel;
+                if (nla_put_s32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.s32_val))
+                        goto nest_cancel;
+                break;
         default:
                 BUG();
         }
@@ -1975,6 +2165,9 @@ static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
                 case NLA_FLAG:
                         opt_type = TEAM_OPTION_TYPE_BOOL;
                         break;
+                case NLA_S32:
+                        opt_type = TEAM_OPTION_TYPE_S32;
+                        break;
                 default:
                         goto team_put;
                 }
@@ -2031,6 +2224,9 @@ static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
                         case TEAM_OPTION_TYPE_BOOL:
                                 ctx.data.bool_val = attr_data ? true : false;
                                 break;
+                        case TEAM_OPTION_TYPE_S32:
+                                ctx.data.s32_val = nla_get_s32(attr_data);
+                                break;
                         default:
                                 BUG();
                         }
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index f4ce5957df32..4cd582a4f625 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -1225,6 +1225,26 @@ static const struct usb_device_id cdc_devs[] = {
           .driver_info = (unsigned long) &wwan_info,
         },
 
+        /* Dell branded MBM devices like DW5550 */
+        { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
+                | USB_DEVICE_ID_MATCH_VENDOR,
+          .idVendor = 0x413c,
+          .bInterfaceClass = USB_CLASS_COMM,
+          .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
+          .bInterfaceProtocol = USB_CDC_PROTO_NONE,
+          .driver_info = (unsigned long) &wwan_info,
+        },
+
+        /* Toshiba branded MBM devices */
+        { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
+                | USB_DEVICE_ID_MATCH_VENDOR,
+          .idVendor = 0x0930,
+          .bInterfaceClass = USB_CLASS_COMM,
+          .bInterfaceSubClass = USB_CDC_SUBCLASS_NCM,
+          .bInterfaceProtocol = USB_CDC_PROTO_NONE,
+          .driver_info = (unsigned long) &wwan_info,
+        },
+
         /* Generic CDC-NCM devices */
         { USB_INTERFACE_INFO(USB_CLASS_COMM,
                 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index cfa91ab7acf8..60b6a9daff7e 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -730,6 +730,7 @@ int ath9k_hw_init(struct ath_hw *ah)
         case AR9300_DEVID_QCA955X:
         case AR9300_DEVID_AR9580:
         case AR9300_DEVID_AR9462:
+        case AR9485_DEVID_AR1111:
                 break;
         default:
                 if (common->bus_ops->ath_bus_type == ATH_USB)
diff --git a/drivers/net/wireless/ath/ath9k/hw.h b/drivers/net/wireless/ath/ath9k/hw.h
index dd0c146d81dc..ce7332c64efb 100644
--- a/drivers/net/wireless/ath/ath9k/hw.h
+++ b/drivers/net/wireless/ath/ath9k/hw.h
@@ -49,6 +49,7 @@
 #define AR9300_DEVID_AR9462     0x0034
 #define AR9300_DEVID_AR9330     0x0035
 #define AR9300_DEVID_QCA955X    0x0038
+#define AR9485_DEVID_AR1111     0x0037
 
 #define AR5416_AR9100_DEVID     0x000b
 
diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c
index 87b89d55e637..d455de9162ec 100644
--- a/drivers/net/wireless/ath/ath9k/pci.c
+++ b/drivers/net/wireless/ath/ath9k/pci.c
@@ -37,6 +37,7 @@ static DEFINE_PCI_DEVICE_TABLE(ath_pci_id_table) = {
         { PCI_VDEVICE(ATHEROS, 0x0032) }, /* PCI-E  AR9485 */
         { PCI_VDEVICE(ATHEROS, 0x0033) }, /* PCI-E  AR9580 */
         { PCI_VDEVICE(ATHEROS, 0x0034) }, /* PCI-E  AR9462 */
+        { PCI_VDEVICE(ATHEROS, 0x0037) }, /* PCI-E  AR1111/AR9485 */
         { 0 }
 };
 
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index b80352b308d5..a140165dfee0 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2719,32 +2719,37 @@ static int b43_gpio_init(struct b43_wldev *dev)
         if (dev->dev->chip_id == 0x4301) {
                 mask |= 0x0060;
                 set |= 0x0060;
+        } else if (dev->dev->chip_id == 0x5354) {
+                /* Don't allow overtaking buttons GPIOs */
+                set &= 0x2; /* 0x2 is LED GPIO on BCM5354 */
         }
-        if (dev->dev->chip_id == 0x5354)
-                set &= 0xff02;
+
         if (0 /* FIXME: conditional unknown */ ) {
                 b43_write16(dev, B43_MMIO_GPIO_MASK,
                             b43_read16(dev, B43_MMIO_GPIO_MASK)
                             | 0x0100);
-                mask |= 0x0180;
-                set |= 0x0180;
+                /* BT Coexistance Input */
+                mask |= 0x0080;
+                set |= 0x0080;
+                /* BT Coexistance Out */
+                mask |= 0x0100;
+                set |= 0x0100;
         }
         if (dev->dev->bus_sprom->boardflags_lo & B43_BFL_PACTRL) {
+                /* PA is controlled by gpio 9, let ucode handle it */
                 b43_write16(dev, B43_MMIO_GPIO_MASK,
                             b43_read16(dev, B43_MMIO_GPIO_MASK)
                             | 0x0200);
                 mask |= 0x0200;
                 set |= 0x0200;
         }
-        if (dev->dev->core_rev >= 2)
-                mask |= 0x0010; /* FIXME: This is redundant. */
 
         switch (dev->dev->bus_type) {
 #ifdef CONFIG_B43_BCMA
         case B43_BUS_BCMA:
                 bcma_cc_write32(&dev->dev->bdev->bus->drv_cc, BCMA_CC_GPIOCTL,
                                 (bcma_cc_read32(&dev->dev->bdev->bus->drv_cc,
-                                        BCMA_CC_GPIOCTL) & mask) | set);
+                                        BCMA_CC_GPIOCTL) & ~mask) | set);
                 break;
 #endif
 #ifdef CONFIG_B43_SSB
@@ -2753,7 +2758,7 @@ static int b43_gpio_init(struct b43_wldev *dev)
                 if (gpiodev)
                         ssb_write32(gpiodev, B43_GPIO_CONTROL,
                                     (ssb_read32(gpiodev, B43_GPIO_CONTROL)
-                                    & mask) | set);
+                                    & ~mask) | set);
                 break;
 #endif
         }
diff --git a/drivers/net/wireless/brcm80211/brcmsmac/channel.c b/drivers/net/wireless/brcm80211/brcmsmac/channel.c
index 9a4c63f927cb..7ed7d7577024 100644
--- a/drivers/net/wireless/brcm80211/brcmsmac/channel.c
+++ b/drivers/net/wireless/brcm80211/brcmsmac/channel.c
@@ -382,9 +382,7 @@ brcms_c_channel_set_chanspec(struct brcms_cm_info *wlc_cm, u16 chanspec,
 {
         struct brcms_c_info *wlc = wlc_cm->wlc;
         struct ieee80211_channel *ch = wlc->pub->ieee_hw->conf.channel;
-        const struct ieee80211_reg_rule *reg_rule;
         struct txpwr_limits txpwr;
-        int ret;
 
         brcms_c_channel_reg_limits(wlc_cm, chanspec, &txpwr);
 
@@ -393,8 +391,7 @@ brcms_c_channel_set_chanspec(struct brcms_cm_info *wlc_cm, u16 chanspec,
         );
 
         /* set or restore gmode as required by regulatory */
-        ret = freq_reg_info(wlc->wiphy, ch->center_freq, 0, &reg_rule);
-        if (!ret && (reg_rule->flags & NL80211_RRF_NO_OFDM))
+        if (ch->flags & IEEE80211_CHAN_NO_OFDM)
                 brcms_c_set_gmode(wlc, GMODE_LEGACY_B, false);
         else
                 brcms_c_set_gmode(wlc, wlc->protection->gmode_user, false);
diff --git a/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c b/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
index 9e79d47e077f..192ad5c1fcc8 100644
--- a/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
+++ b/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
@@ -121,7 +121,8 @@ static struct ieee80211_channel brcms_2ghz_chantable[] = {
                  IEEE80211_CHAN_NO_HT40PLUS),
         CHAN2GHZ(14, 2484,
                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
-                 IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)
+                 IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS |
+                 IEEE80211_CHAN_NO_OFDM)
 };
 
 static struct ieee80211_channel brcms_5ghz_nphy_chantable[] = {
diff --git a/drivers/net/wireless/libertas/cfg.c b/drivers/net/wireless/libertas/cfg.c
index eb5de800ed90..1c10b542ab23 100644
--- a/drivers/net/wireless/libertas/cfg.c
+++ b/drivers/net/wireless/libertas/cfg.c
@@ -1254,6 +1254,7 @@ static int lbs_associate(struct lbs_private *priv,
                         netif_tx_wake_all_queues(priv->dev);
         }
 
+        kfree(cmd);
 done:
         lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
         return ret;
diff --git a/drivers/net/wireless/libertas/if_sdio.c b/drivers/net/wireless/libertas/if_sdio.c
index 76caebaa4397..e970897f6ab5 100644
--- a/drivers/net/wireless/libertas/if_sdio.c
+++ b/drivers/net/wireless/libertas/if_sdio.c
@@ -1314,6 +1314,7 @@ static void if_sdio_remove(struct sdio_func *func)
                 kfree(packet);
         }
 
+        kfree(card);
         lbs_deb_leave(LBS_DEB_SDIO);
 }
 
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 58048189bd24..fe1ea43c5149 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -571,7 +571,10 @@ static int lbs_thread(void *data)
                         netdev_info(dev, "Timeout submitting command 0x%04x\n",
                                     le16_to_cpu(cmdnode->cmdbuf->command));
                         lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
-                        if (priv->reset_card)
+
+                        /* Reset card, but only when it isn't in the process
+                         * of being shutdown anyway. */
+                        if (!dev->dismantle && priv->reset_card)
                                 priv->reset_card(priv);
                 }
                 priv->cmd_timed_out = 0;
diff --git a/drivers/net/wireless/rt2x00/rt2800lib.c b/drivers/net/wireless/rt2x00/rt2800lib.c
index 88455b1b9fe0..cb8c2aca54e4 100644
--- a/drivers/net/wireless/rt2x00/rt2800lib.c
+++ b/drivers/net/wireless/rt2x00/rt2800lib.c
@@ -221,6 +221,67 @@ static void rt2800_rf_write(struct rt2x00_dev *rt2x00dev,
         mutex_unlock(&rt2x00dev->csr_mutex);
 }
 
+static int rt2800_enable_wlan_rt3290(struct rt2x00_dev *rt2x00dev)
+{
+        u32 reg;
+        int i, count;
+
+        rt2800_register_read(rt2x00dev, WLAN_FUN_CTRL, &reg);
+        if (rt2x00_get_field32(reg, WLAN_EN))
+                return 0;
+
+        rt2x00_set_field32(&reg, WLAN_GPIO_OUT_OE_BIT_ALL, 0xff);
+        rt2x00_set_field32(&reg, FRC_WL_ANT_SET, 1);
+        rt2x00_set_field32(&reg, WLAN_CLK_EN, 0);
+        rt2x00_set_field32(&reg, WLAN_EN, 1);
+        rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
+
+        udelay(REGISTER_BUSY_DELAY);
+
+        count = 0;
+        do {
+                /*
+                 * Check PLL_LD & XTAL_RDY.
+                 */
+                for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
+                        rt2800_register_read(rt2x00dev, CMB_CTRL, &reg);
+                        if (rt2x00_get_field32(reg, PLL_LD) &&
+                            rt2x00_get_field32(reg, XTAL_RDY))
+                                break;
+                        udelay(REGISTER_BUSY_DELAY);
+                }
+
+                if (i >= REGISTER_BUSY_COUNT) {
+
+                        if (count >= 10)
+                                return -EIO;
+
+                        rt2800_register_write(rt2x00dev, 0x58, 0x018);
+                        udelay(REGISTER_BUSY_DELAY);
+                        rt2800_register_write(rt2x00dev, 0x58, 0x418);
+                        udelay(REGISTER_BUSY_DELAY);
+                        rt2800_register_write(rt2x00dev, 0x58, 0x618);
+                        udelay(REGISTER_BUSY_DELAY);
+                        count++;
+                } else {
+                        count = 0;
+                }
+
+                rt2800_register_read(rt2x00dev, WLAN_FUN_CTRL, &reg);
+                rt2x00_set_field32(&reg, PCIE_APP0_CLK_REQ, 0);
+                rt2x00_set_field32(&reg, WLAN_CLK_EN, 1);
+                rt2x00_set_field32(&reg, WLAN_RESET, 1);
+                rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
+                udelay(10);
+                rt2x00_set_field32(&reg, WLAN_RESET, 0);
+                rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
+                udelay(10);
+                rt2800_register_write(rt2x00dev, INT_SOURCE_CSR, 0x7fffffff);
+        } while (count != 0);
+
+        return 0;
+}
+
 void rt2800_mcu_request(struct rt2x00_dev *rt2x00dev,
                         const u8 command, const u8 token,
                         const u8 arg0, const u8 arg1)
@@ -400,6 +461,13 @@ int rt2800_load_firmware(struct rt2x00_dev *rt2x00dev,
 {
         unsigned int i;
         u32 reg;
+        int retval;
+
+        if (rt2x00_rt(rt2x00dev, RT3290)) {
+                retval = rt2800_enable_wlan_rt3290(rt2x00dev);
+                if (retval)
+                        return -EBUSY;
+        }
 
         /*
          * If driver doesn't wake up firmware here,
diff --git a/drivers/net/wireless/rt2x00/rt2800pci.c b/drivers/net/wireless/rt2x00/rt2800pci.c
index 235376e9cb04..98aa426a3564 100644
--- a/drivers/net/wireless/rt2x00/rt2800pci.c
+++ b/drivers/net/wireless/rt2x00/rt2800pci.c
@@ -980,66 +980,6 @@ static int rt2800pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
         return rt2800_validate_eeprom(rt2x00dev);
 }
 
-static int rt2800_enable_wlan_rt3290(struct rt2x00_dev *rt2x00dev)
-{
-        u32 reg;
-        int i, count;
-
-        rt2800_register_read(rt2x00dev, WLAN_FUN_CTRL, &reg);
-        if (rt2x00_get_field32(reg, WLAN_EN))
-                return 0;
-
-        rt2x00_set_field32(&reg, WLAN_GPIO_OUT_OE_BIT_ALL, 0xff);
-        rt2x00_set_field32(&reg, FRC_WL_ANT_SET, 1);
-        rt2x00_set_field32(&reg, WLAN_CLK_EN, 0);
-        rt2x00_set_field32(&reg, WLAN_EN, 1);
-        rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
-
-        udelay(REGISTER_BUSY_DELAY);
-
-        count = 0;
-        do {
-                /*
-                 * Check PLL_LD & XTAL_RDY.
-                 */
-                for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
-                        rt2800_register_read(rt2x00dev, CMB_CTRL, &reg);
-                        if (rt2x00_get_field32(reg, PLL_LD) &&
-                            rt2x00_get_field32(reg, XTAL_RDY))
-                                break;
-                        udelay(REGISTER_BUSY_DELAY);
-                }
-
-                if (i >= REGISTER_BUSY_COUNT) {
-
-                        if (count >= 10)
-                                return -EIO;
-
-                        rt2800_register_write(rt2x00dev, 0x58, 0x018);
-                        udelay(REGISTER_BUSY_DELAY);
-                        rt2800_register_write(rt2x00dev, 0x58, 0x418);
-                        udelay(REGISTER_BUSY_DELAY);
-                        rt2800_register_write(rt2x00dev, 0x58, 0x618);
-                        udelay(REGISTER_BUSY_DELAY);
-                        count++;
-                } else {
-                        count = 0;
-                }
-
-                rt2800_register_read(rt2x00dev, WLAN_FUN_CTRL, &reg);
-                rt2x00_set_field32(&reg, PCIE_APP0_CLK_REQ, 0);
-                rt2x00_set_field32(&reg, WLAN_CLK_EN, 1);
-                rt2x00_set_field32(&reg, WLAN_RESET, 1);
-                rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
-                udelay(10);
-                rt2x00_set_field32(&reg, WLAN_RESET, 0);
-                rt2800_register_write(rt2x00dev, WLAN_FUN_CTRL, reg);
-                udelay(10);
-                rt2800_register_write(rt2x00dev, INT_SOURCE_CSR, 0x7fffffff);
-        } while (count != 0);
-
-        return 0;
-}
 static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev)
 {
         int retval;
@@ -1063,17 +1003,6 @@ static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev)
                 return retval;
 
         /*
-         * In probe phase call rt2800_enable_wlan_rt3290 to enable wlan
-         * clk for rt3290. That avoid the MCU fail in start phase.
-         */
-        if (rt2x00_rt(rt2x00dev, RT3290)) {
-                retval = rt2800_enable_wlan_rt3290(rt2x00dev);
-
-                if (retval)
-                        return retval;
-        }
-
-        /*
          * This device has multiple filters for control frames
          * and has a separate filter for PS Poll frames.
          */