28 files changed, 244 insertions, 101 deletions

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 9334539ebf75..f6668cdaac85 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2541,6 +2541,7 @@ source "drivers/net/stmmac/Kconfig"
 config PCH_GBE
         tristate "PCH Gigabit Ethernet"
         depends on PCI
+        select MII
         ---help---
           This is a gigabit ethernet driver for Topcliff PCH.
           Topcliff PCH is the platform controller hub that is used in Intel's
diff --git a/drivers/net/atarilance.c b/drivers/net/atarilance.c
index 3134e5326231..8cb27cb7bca1 100644
--- a/drivers/net/atarilance.c
+++ b/drivers/net/atarilance.c
@@ -407,7 +407,7 @@ static noinline int __init addr_accessible(volatile void *regp, int wordflag,
                                            int writeflag)
 {
         int             ret;
-        long    flags;
+        unsigned long   flags;
         long    *vbr, save_berr;
 
         local_irq_save(flags);
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 4e3c12371aae..407d4e272075 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -3301,7 +3301,6 @@ static int __devinit init_one(struct pci_dev *pdev,
                 pi->rx_offload = T3_RX_CSUM | T3_LRO;
                 pi->port_id = i;
                 netif_carrier_off(netdev);
-                netif_tx_stop_all_queues(netdev);
                 netdev->irq = pdev->irq;
                 netdev->mem_start = mmio_start;
                 netdev->mem_end = mmio_start + mmio_len - 1;
@@ -3342,6 +3341,7 @@ static int __devinit init_one(struct pci_dev *pdev,
                                 adapter->name = adapter->port[i]->name;
 
                         __set_bit(i, &adapter->registered_device_map);
+                        netif_tx_stop_all_queues(adapter->port[i]);
                 }
         }
         if (!adapter->registered_device_map) {
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index 5d72bda54389..f9f6645b2e61 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -296,8 +296,10 @@ static void free_tx_desc(struct adapter *adapter, struct sge_txq *q,
                 if (d->skb) {   /* an SGL is present */
                         if (need_unmap)
                                 unmap_skb(d->skb, q, cidx, pdev);
-                        if (d->eop)
+                        if (d->eop) {
                                 kfree_skb(d->skb);
+                                d->skb = NULL;
+                        }
                 }
                 ++d;
                 if (++cidx == q->size) {
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index ca663f19d7df..7236f1a53ba0 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -52,6 +52,10 @@
                               (ID_LED_DEF1_DEF2))
 
 #define E1000_GCR_L1_ACT_WITHOUT_L0S_RX 0x08000000
+#define E1000_BASE1000T_STATUS          10
+#define E1000_IDLE_ERROR_COUNT_MASK     0xFF
+#define E1000_RECEIVE_ERROR_COUNTER     21
+#define E1000_RECEIVE_ERROR_MAX         0xFFFF
 
 #define E1000_NVM_INIT_CTRL2_MNGM 0x6000 /* Manageability Operation Mode mask */
 
@@ -1243,6 +1247,39 @@ static s32 e1000_led_on_82574(struct e1000_hw *hw)
 }
 
 /**
+ *  e1000_check_phy_82574 - check 82574 phy hung state
+ *  @hw: pointer to the HW structure
+ *
+ *  Returns whether phy is hung or not
+ **/
+bool e1000_check_phy_82574(struct e1000_hw *hw)
+{
+        u16 status_1kbt = 0;
+        u16 receive_errors = 0;
+        bool phy_hung = false;
+        s32 ret_val = 0;
+
+        /*
+         * Read PHY Receive Error counter first, if its is max - all F's then
+         * read the Base1000T status register If both are max then PHY is hung.
+         */
+        ret_val = e1e_rphy(hw, E1000_RECEIVE_ERROR_COUNTER, &receive_errors);
+
+        if (ret_val)
+                goto out;
+        if (receive_errors == E1000_RECEIVE_ERROR_MAX)  {
+                ret_val = e1e_rphy(hw, E1000_BASE1000T_STATUS, &status_1kbt);
+                if (ret_val)
+                        goto out;
+                if ((status_1kbt & E1000_IDLE_ERROR_COUNT_MASK) ==
+                    E1000_IDLE_ERROR_COUNT_MASK)
+                        phy_hung = true;
+        }
+out:
+        return phy_hung;
+}
+
+/**
  *  e1000_setup_link_82571 - Setup flow control and link settings
  *  @hw: pointer to the HW structure
  *
@@ -1859,6 +1896,7 @@ struct e1000_info e1000_82574_info = {
                                   | FLAG_HAS_SMART_POWER_DOWN
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
+        .flags2                   = FLAG2_CHECK_PHY_HANG,
         .pba                    = 36,
         .max_hw_frame_size      = DEFAULT_JUMBO,
         .get_variants           = e1000_get_variants_82571,
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index cee882dd67bf..fdc67fead4ea 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -397,6 +397,7 @@ struct e1000_adapter {
         struct work_struct print_hang_task;
 
         bool idle_check;
+        int phy_hang_count;
 };
 
 struct e1000_info {
@@ -454,6 +455,7 @@ struct e1000_info {
 #define FLAG2_HAS_EEE                     (1 << 5)
 #define FLAG2_DMA_BURST                   (1 << 6)
 #define FLAG2_DISABLE_AIM                 (1 << 8)
+#define FLAG2_CHECK_PHY_HANG              (1 << 9)
 
 #define E1000_RX_DESC_PS(R, i)      \
         (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
@@ -631,6 +633,7 @@ extern s32 e1000_get_phy_info_ife(struct e1000_hw *hw);
 extern s32 e1000_check_polarity_ife(struct e1000_hw *hw);
 extern s32 e1000_phy_force_speed_duplex_ife(struct e1000_hw *hw);
 extern s32 e1000_check_polarity_igp(struct e1000_hw *hw);
+extern bool e1000_check_phy_82574(struct e1000_hw *hw);
 
 static inline s32 e1000_phy_hw_reset(struct e1000_hw *hw)
 {
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index ec8cf3f51423..c4ca1629f532 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -4098,6 +4098,25 @@ static void e1000e_enable_receives(struct e1000_adapter *adapter)
         }
 }
 
+static void e1000e_check_82574_phy_workaround(struct e1000_adapter *adapter)
+{
+        struct e1000_hw *hw = &adapter->hw;
+
+        /*
+         * With 82574 controllers, PHY needs to be checked periodically
+         * for hung state and reset, if two calls return true
+         */
+        if (e1000_check_phy_82574(hw))
+                adapter->phy_hang_count++;
+        else
+                adapter->phy_hang_count = 0;
+
+        if (adapter->phy_hang_count > 1) {
+                adapter->phy_hang_count = 0;
+                schedule_work(&adapter->reset_task);
+        }
+}
+
 /**
  * e1000_watchdog - Timer Call-back
  * @data: pointer to adapter cast into an unsigned long
@@ -4333,6 +4352,9 @@ link_up:
         if (e1000e_get_laa_state_82571(hw))
                 e1000e_rar_set(hw, adapter->hw.mac.addr, 0);
 
+        if (adapter->flags2 & FLAG2_CHECK_PHY_HANG)
+                e1000e_check_82574_phy_workaround(adapter);
+
         /* Reset the timer */
         if (!test_bit(__E1000_DOWN, &adapter->state))
                 mod_timer(&adapter->watchdog_timer,
@@ -4860,8 +4882,11 @@ static void e1000_reset_task(struct work_struct *work)
         struct e1000_adapter *adapter;
         adapter = container_of(work, struct e1000_adapter, reset_task);
 
-        e1000e_dump(adapter);
-        e_err("Reset adapter\n");
+        if (!((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
+              (adapter->flags & FLAG_RX_RESTART_NOW))) {
+                e1000e_dump(adapter);
+                e_err("Reset adapter\n");
+        }
         e1000e_reinit_locked(adapter);
 }
 
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 14db09e2fa8b..892d196f17ac 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -4107,7 +4107,6 @@ static inline int igb_maybe_stop_tx(struct igb_ring *tx_ring, int size)
 netdev_tx_t igb_xmit_frame_ring_adv(struct sk_buff *skb,
                                     struct igb_ring *tx_ring)
 {
-        struct igb_adapter *adapter = netdev_priv(tx_ring->netdev);
         int tso = 0, count;
         u32 tx_flags = 0;
         u16 first;
diff --git a/drivers/net/igbvf/netdev.c b/drivers/net/igbvf/netdev.c
index ebfaa68ee630..28af019c97bb 100644
--- a/drivers/net/igbvf/netdev.c
+++ b/drivers/net/igbvf/netdev.c
@@ -2783,15 +2783,15 @@ static int __devinit igbvf_probe(struct pci_dev *pdev,
         /* reset the hardware with the new settings */
         igbvf_reset(adapter);
 
-        /* tell the stack to leave us alone until igbvf_open() is called */
-        netif_carrier_off(netdev);
-        netif_stop_queue(netdev);
-
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
         if (err)
                 goto err_hw_init;
 
+        /* tell the stack to leave us alone until igbvf_open() is called */
+        netif_carrier_off(netdev);
+        netif_stop_queue(netdev);
+
         igbvf_print_device_info(adapter);
 
         igbvf_initialize_last_counter_stats(adapter);
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index 666207a9c039..caa8192fff2a 100644
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -533,6 +533,7 @@ ixgb_remove(struct pci_dev *pdev)
         pci_release_regions(pdev);
 
         free_netdev(netdev);
+        pci_disable_device(pdev);
 }
 
 /**
diff --git a/drivers/net/ixgbe/ixgbe_dcb.c b/drivers/net/ixgbe/ixgbe_dcb.c
index 8bb9ddb6dffe..0d44c6470ca3 100644
--- a/drivers/net/ixgbe/ixgbe_dcb.c
+++ b/drivers/net/ixgbe/ixgbe_dcb.c
@@ -43,9 +43,12 @@
  * ixgbe_dcb_check_config().
  */
 s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *dcb_config,
-                                   u8 direction)
+                                   int max_frame, u8 direction)
 {
         struct tc_bw_alloc *p;
+        int min_credit;
+        int min_multiplier;
+        int min_percent = 100;
         s32 ret_val = 0;
         /* Initialization values default for Tx settings */
         u32 credit_refill       = 0;
@@ -59,6 +62,31 @@ s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *dcb_config,
                 goto out;
         }
 
+        min_credit = ((max_frame / 2) + DCB_CREDIT_QUANTUM - 1) /
+                        DCB_CREDIT_QUANTUM;
+
+        /* Find smallest link percentage */
+        for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
+                p = &dcb_config->tc_config[i].path[direction];
+                bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];
+                link_percentage = p->bwg_percent;
+
+                link_percentage = (link_percentage * bw_percent) / 100;
+
+                if (link_percentage && link_percentage < min_percent)
+                        min_percent = link_percentage;
+        }
+
+        /*
+         * The ratio between traffic classes will control the bandwidth
+         * percentages seen on the wire. To calculate this ratio we use
+         * a multiplier. It is required that the refill credits must be
+         * larger than the max frame size so here we find the smallest
+         * multiplier that will allow all bandwidth percentages to be
+         * greater than the max frame size.
+         */
+        min_multiplier = (min_credit / min_percent) + 1;
+
         /* Find out the link percentage for each TC first */
         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
                 p = &dcb_config->tc_config[i].path[direction];
@@ -73,8 +101,9 @@ s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *dcb_config,
                 /* Save link_percentage for reference */
                 p->link_percent = (u8)link_percentage;
 
-                /* Calculate credit refill and save it */
-                credit_refill = link_percentage * MINIMUM_CREDIT_REFILL;
+                /* Calculate credit refill ratio using multiplier */
+                credit_refill = min(link_percentage * min_multiplier,
+                                    MAX_CREDIT_REFILL);
                 p->data_credits_refill = (u16)credit_refill;
 
                 /* Calculate maximum credit for the TC */
@@ -85,8 +114,8 @@ s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *dcb_config,
                  * of a TC is too small, the maximum credit may not be
                  * enough to send out a jumbo frame in data plane arbitration.
                  */
-                if (credit_max && (credit_max < MINIMUM_CREDIT_FOR_JUMBO))
-                        credit_max = MINIMUM_CREDIT_FOR_JUMBO;
+                if (credit_max && (credit_max < min_credit))
+                        credit_max = min_credit;
 
                 if (direction == DCB_TX_CONFIG) {
                         /*
diff --git a/drivers/net/ixgbe/ixgbe_dcb.h b/drivers/net/ixgbe/ixgbe_dcb.h
index eb1059f09da0..0208a87b129e 100644
--- a/drivers/net/ixgbe/ixgbe_dcb.h
+++ b/drivers/net/ixgbe/ixgbe_dcb.h
@@ -150,15 +150,14 @@ struct ixgbe_dcb_config {
 /* DCB driver APIs */
 
 /* DCB credits calculation */
-s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *, u8);
+s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *, int, u8);
 
 /* DCB hw initialization */
 s32 ixgbe_dcb_hw_config(struct ixgbe_hw *, struct ixgbe_dcb_config *);
 
 /* DCB definitions for credit calculation */
+#define DCB_CREDIT_QUANTUM      64   /* DCB Quantum */
 #define MAX_CREDIT_REFILL       511  /* 0x1FF * 64B = 32704B */
-#define MINIMUM_CREDIT_REFILL   5    /* 5*64B = 320B */
-#define MINIMUM_CREDIT_FOR_JUMBO 145  /* 145= UpperBound((9*1024+54)/64B) for 9KB jumbo frame */
 #define DCB_MAX_TSO_SIZE        (32*1024) /* MAX TSO packet size supported in DCB mode */
 #define MINIMUM_CREDIT_FOR_TSO  (DCB_MAX_TSO_SIZE/64 + 1) /* 513 for 32KB TSO packet */
 #define MAX_CREDIT              4095 /* Maximum credit supported: 256KB * 1204 / 64B */
diff --git a/drivers/net/ixgbe/ixgbe_dcb_82599.c b/drivers/net/ixgbe/ixgbe_dcb_82599.c
index 67c219f86c3a..05f224715073 100644
--- a/drivers/net/ixgbe/ixgbe_dcb_82599.c
+++ b/drivers/net/ixgbe/ixgbe_dcb_82599.c
@@ -397,6 +397,11 @@ static s32 ixgbe_dcb_config_82599(struct ixgbe_hw *hw)
         reg &= ~IXGBE_RTTDCS_ARBDIS;
         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
 
+        /* Enable Security TX Buffer IFG for DCB */
+        reg = IXGBE_READ_REG(hw, IXGBE_SECTXMINIFG);
+        reg |= IXGBE_SECTX_DCB;
+        IXGBE_WRITE_REG(hw, IXGBE_SECTXMINIFG, reg);
+
         return 0;
 }
 
diff --git a/drivers/net/ixgbe/ixgbe_dcb_82599.h b/drivers/net/ixgbe/ixgbe_dcb_82599.h
index 18d7fbf6c292..3841649fb954 100644
--- a/drivers/net/ixgbe/ixgbe_dcb_82599.h
+++ b/drivers/net/ixgbe/ixgbe_dcb_82599.h
@@ -95,6 +95,9 @@
 
 #define IXGBE_TXPBTHRESH_DCB    0xA        /* THRESH value for DCB mode */
 
+/* SECTXMINIFG DCB */
+#define IXGBE_SECTX_DCB         0x00001F00 /* DCB TX Buffer IFG */
+
 
 /* DCB hardware-specific driver APIs */
 
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index f85631263af8..2bd3eb4ee5a1 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -3347,6 +3347,7 @@ static void ixgbe_napi_disable_all(struct ixgbe_adapter *adapter)
 static void ixgbe_configure_dcb(struct ixgbe_adapter *adapter)
 {
         struct ixgbe_hw *hw = &adapter->hw;
+        int max_frame = adapter->netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
         u32 txdctl;
         int i, j;
 
@@ -3359,8 +3360,15 @@ static void ixgbe_configure_dcb(struct ixgbe_adapter *adapter)
         if (hw->mac.type == ixgbe_mac_82598EB)
                 netif_set_gso_max_size(adapter->netdev, 32768);
 
-        ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, DCB_TX_CONFIG);
-        ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, DCB_RX_CONFIG);
+#ifdef CONFIG_FCOE
+        if (adapter->netdev->features & NETIF_F_FCOE_MTU)
+                max_frame = max(max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE);
+#endif
+
+        ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, max_frame,
+                                        DCB_TX_CONFIG);
+        ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, max_frame,
+                                        DCB_RX_CONFIG);
 
         /* reconfigure the hardware */
         ixgbe_dcb_hw_config(&adapter->hw, &adapter->dcb_cfg);
diff --git a/drivers/net/lib8390.c b/drivers/net/lib8390.c
index 316bb70775b1..e7030ceb178b 100644
--- a/drivers/net/lib8390.c
+++ b/drivers/net/lib8390.c
@@ -1077,7 +1077,6 @@ static void __NS8390_init(struct net_device *dev, int startp)
         ei_outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
         ei_outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
 
-        netif_start_queue(dev);
         ei_local->tx1 = ei_local->tx2 = 0;
         ei_local->txing = 0;
 
diff --git a/drivers/net/netxen/netxen_nic_ctx.c b/drivers/net/netxen/netxen_nic_ctx.c
index 12612127a087..f7d06cbc70ae 100644
--- a/drivers/net/netxen/netxen_nic_ctx.c
+++ b/drivers/net/netxen/netxen_nic_ctx.c
@@ -255,19 +255,6 @@ out_free_rq:
 }
 
 static void
-nx_fw_cmd_reset_ctx(struct netxen_adapter *adapter)
-{
-
-        netxen_issue_cmd(adapter, adapter->ahw.pci_func, NXHAL_VERSION,
-                        adapter->ahw.pci_func, NX_DESTROY_CTX_RESET, 0,
-                        NX_CDRP_CMD_DESTROY_RX_CTX);
-
-        netxen_issue_cmd(adapter, adapter->ahw.pci_func, NXHAL_VERSION,
-                        adapter->ahw.pci_func, NX_DESTROY_CTX_RESET, 0,
-                        NX_CDRP_CMD_DESTROY_TX_CTX);
-}
-
-static void
 nx_fw_cmd_destroy_rx_ctx(struct netxen_adapter *adapter)
 {
         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
@@ -698,8 +685,6 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
         if (!NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
                 if (test_and_set_bit(__NX_FW_ATTACHED, &adapter->state))
                         goto done;
-                if (reset_devices)
-                        nx_fw_cmd_reset_ctx(adapter);
                 err = nx_fw_cmd_create_rx_ctx(adapter);
                 if (err)
                         goto err_out_free;
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 50820beac3aa..35ae1aa12896 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -1356,6 +1356,13 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 break;
         }
 
+        if (reset_devices) {
+                if (adapter->portnum == 0) {
+                        NXWR32(adapter, NX_CRB_DEV_REF_COUNT, 0);
+                        adapter->need_fw_reset = 1;
+                }
+        }
+
         err = netxen_start_firmware(adapter);
         if (err)
                 goto err_out_decr_ref;
diff --git a/drivers/net/stmmac/stmmac_main.c b/drivers/net/stmmac/stmmac_main.c
index 823b9e6431d5..06bc6034ce81 100644
--- a/drivers/net/stmmac/stmmac_main.c
+++ b/drivers/net/stmmac/stmmac_main.c
@@ -337,33 +337,19 @@ static int stmmac_init_phy(struct net_device *dev)
         return 0;
 }
 
-static inline void stmmac_mac_enable_rx(void __iomem *ioaddr)
+static inline void stmmac_enable_mac(void __iomem *ioaddr)
 {
         u32 value = readl(ioaddr + MAC_CTRL_REG);
-        value |= MAC_RNABLE_RX;
-        /* Set the RE (receive enable bit into the MAC CTRL register).  */
-        writel(value, ioaddr + MAC_CTRL_REG);
-}
 
-static inline void stmmac_mac_enable_tx(void __iomem *ioaddr)
-{
-        u32 value = readl(ioaddr + MAC_CTRL_REG);
-        value |= MAC_ENABLE_TX;
-        /* Set the TE (transmit enable bit into the MAC CTRL register).  */
+        value |= MAC_RNABLE_RX | MAC_ENABLE_TX;
         writel(value, ioaddr + MAC_CTRL_REG);
 }
 
-static inline void stmmac_mac_disable_rx(void __iomem *ioaddr)
+static inline void stmmac_disable_mac(void __iomem *ioaddr)
 {
         u32 value = readl(ioaddr + MAC_CTRL_REG);
-        value &= ~MAC_RNABLE_RX;
-        writel(value, ioaddr + MAC_CTRL_REG);
-}
 
-static inline void stmmac_mac_disable_tx(void __iomem *ioaddr)
-{
-        u32 value = readl(ioaddr + MAC_CTRL_REG);
-        value &= ~MAC_ENABLE_TX;
+        value &= ~(MAC_ENABLE_TX | MAC_RNABLE_RX);
         writel(value, ioaddr + MAC_CTRL_REG);
 }
 
@@ -857,8 +843,7 @@ static int stmmac_open(struct net_device *dev)
         writel(0xffffffff, priv->ioaddr + MMC_LOW_INTR_MASK);
 
         /* Enable the MAC Rx/Tx */
-        stmmac_mac_enable_rx(priv->ioaddr);
-        stmmac_mac_enable_tx(priv->ioaddr);
+        stmmac_enable_mac(priv->ioaddr);
 
         /* Set the HW DMA mode and the COE */
         stmmac_dma_operation_mode(priv);
@@ -928,9 +913,8 @@ static int stmmac_release(struct net_device *dev)
         /* Release and free the Rx/Tx resources */
         free_dma_desc_resources(priv);
 
-        /* Disable the MAC core */
-        stmmac_mac_disable_tx(priv->ioaddr);
-        stmmac_mac_disable_rx(priv->ioaddr);
+        /* Disable the MAC Rx/Tx */
+        stmmac_disable_mac(priv->ioaddr);
 
         netif_carrier_off(dev);
 
@@ -1787,8 +1771,7 @@ static int stmmac_dvr_remove(struct platform_device *pdev)
         priv->hw->dma->stop_rx(priv->ioaddr);
         priv->hw->dma->stop_tx(priv->ioaddr);
 
-        stmmac_mac_disable_rx(priv->ioaddr);
-        stmmac_mac_disable_tx(priv->ioaddr);
+        stmmac_disable_mac(priv->ioaddr);
 
         netif_carrier_off(ndev);
 
@@ -1839,13 +1822,11 @@ static int stmmac_suspend(struct platform_device *pdev, pm_message_t state)
                                              dis_ic);
                 priv->hw->desc->init_tx_desc(priv->dma_tx, priv->dma_tx_size);
 
-                stmmac_mac_disable_tx(priv->ioaddr);
-
                 /* Enable Power down mode by programming the PMT regs */
                 if (device_can_wakeup(priv->device))
                         priv->hw->mac->pmt(priv->ioaddr, priv->wolopts);
                 else
-                        stmmac_mac_disable_rx(priv->ioaddr);
+                        stmmac_disable_mac(priv->ioaddr);
         } else {
                 priv->shutdown = 1;
                 /* Although this can appear slightly redundant it actually
@@ -1886,8 +1867,7 @@ static int stmmac_resume(struct platform_device *pdev)
         netif_device_attach(dev);
 
         /* Enable the MAC and DMA */
-        stmmac_mac_enable_rx(priv->ioaddr);
-        stmmac_mac_enable_tx(priv->ioaddr);
+        stmmac_enable_mac(priv->ioaddr);
         priv->hw->dma->start_tx(priv->ioaddr);
         priv->hw->dma->start_rx(priv->ioaddr);
 
diff --git a/drivers/net/wireless/ath/ath5k/attach.c b/drivers/net/wireless/ath/ath5k/attach.c
index cd0b14a0a93a..fbe8aca975d8 100644
--- a/drivers/net/wireless/ath/ath5k/attach.c
+++ b/drivers/net/wireless/ath/ath5k/attach.c
@@ -139,12 +139,12 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
         /* Fill the ath5k_hw struct with the needed functions */
         ret = ath5k_hw_init_desc_functions(ah);
         if (ret)
-                goto err_free;
+                goto err;
 
         /* Bring device out of sleep and reset its units */
         ret = ath5k_hw_nic_wakeup(ah, 0, true);
         if (ret)
-                goto err_free;
+                goto err;
 
         /* Get MAC, PHY and RADIO revisions */
         ah->ah_mac_srev = srev;
@@ -234,7 +234,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
                 } else {
                         ATH5K_ERR(sc, "Couldn't identify radio revision.\n");
                         ret = -ENODEV;
-                        goto err_free;
+                        goto err;
                 }
         }
 
@@ -244,7 +244,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
         (srev < AR5K_SREV_AR2425)) {
                 ATH5K_ERR(sc, "Device not yet supported.\n");
                 ret = -ENODEV;
-                goto err_free;
+                goto err;
         }
 
         /*
@@ -252,7 +252,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
          */
         ret = ath5k_hw_post(ah);
         if (ret)
-                goto err_free;
+                goto err;
 
         /* Enable pci core retry fix on Hainan (5213A) and later chips */
         if (srev >= AR5K_SREV_AR5213A)
@@ -265,7 +265,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
         ret = ath5k_eeprom_init(ah);
         if (ret) {
                 ATH5K_ERR(sc, "unable to init EEPROM\n");
-                goto err_free;
+                goto err;
         }
 
         ee = &ah->ah_capabilities.cap_eeprom;
@@ -307,7 +307,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
         if (ret) {
                 ATH5K_ERR(sc, "unable to get device capabilities: 0x%04x\n",
                         sc->pdev->device);
-                goto err_free;
+                goto err;
         }
 
         /* Crypto settings */
@@ -341,8 +341,7 @@ int ath5k_hw_attach(struct ath5k_softc *sc)
         ath5k_hw_set_ledstate(ah, AR5K_LED_INIT);
 
         return 0;
-err_free:
-        kfree(ah);
+err:
         return ret;
 }
 
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index 973c919fdd27..9b8e7e3fcebd 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -310,7 +310,7 @@ struct ath_rx {
         u8 rxotherant;
         u32 *rxlink;
         unsigned int rxfilter;
-        spinlock_t rxflushlock;
+        spinlock_t pcu_lock;
         spinlock_t rxbuflock;
         struct list_head rxbuf;
         struct ath_descdma rxdma;
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 728d904c74d7..6576f683dba0 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -801,10 +801,16 @@ static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev)
         }
         kfree(buf);
 
-        if ((hif_dev->device_id == 0x7010) || (hif_dev->device_id == 0x7015))
+        switch (hif_dev->device_id) {
+        case 0x7010:
+        case 0x7015:
+        case 0x9018:
                 firm_offset = AR7010_FIRMWARE_TEXT;
-        else
+                break;
+        default:
                 firm_offset = AR9271_FIRMWARE_TEXT;
+                break;
+        }
 
         /*
          * Issue FW download complete command to firmware.
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index c6ec800d7a6b..b52f1cf8a603 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -241,6 +241,9 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
          */
         ath9k_hw_set_interrupts(ah, 0);
         ath_drain_all_txq(sc, false);
+
+        spin_lock_bh(&sc->rx.pcu_lock);
+
         stopped = ath_stoprecv(sc);
 
         /* XXX: do not flush receive queue here. We don't want
@@ -268,6 +271,7 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
                           "reset status %d\n",
                           channel->center_freq, r);
                 spin_unlock_bh(&sc->sc_resetlock);
+                spin_unlock_bh(&sc->rx.pcu_lock);
                 goto ps_restore;
         }
         spin_unlock_bh(&sc->sc_resetlock);
@@ -276,9 +280,12 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
                 ath_print(common, ATH_DBG_FATAL,
                           "Unable to restart recv logic\n");
                 r = -EIO;
+                spin_unlock_bh(&sc->rx.pcu_lock);
                 goto ps_restore;
         }
 
+        spin_unlock_bh(&sc->rx.pcu_lock);
+
         ath_update_txpow(sc);
         ath9k_hw_set_interrupts(ah, ah->imask);
 
@@ -613,7 +620,7 @@ void ath9k_tasklet(unsigned long data)
                 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
 
         if (status & rxmask) {
-                spin_lock_bh(&sc->rx.rxflushlock);
+                spin_lock_bh(&sc->rx.pcu_lock);
 
                 /* Check for high priority Rx first */
                 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
@@ -621,7 +628,7 @@ void ath9k_tasklet(unsigned long data)
                         ath_rx_tasklet(sc, 0, true);
 
                 ath_rx_tasklet(sc, 0, false);
-                spin_unlock_bh(&sc->rx.rxflushlock);
+                spin_unlock_bh(&sc->rx.pcu_lock);
         }
 
         if (status & ATH9K_INT_TX) {
@@ -876,6 +883,7 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
         if (!ah->curchan)
                 ah->curchan = ath_get_curchannel(sc, sc->hw);
 
+        spin_lock_bh(&sc->rx.pcu_lock);
         spin_lock_bh(&sc->sc_resetlock);
         r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (r) {
@@ -890,8 +898,10 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
         if (ath_startrecv(sc) != 0) {
                 ath_print(common, ATH_DBG_FATAL,
                           "Unable to restart recv logic\n");
+                spin_unlock_bh(&sc->rx.pcu_lock);
                 return;
         }
+        spin_unlock_bh(&sc->rx.pcu_lock);
 
         if (sc->sc_flags & SC_OP_BEACONS)
                 ath_beacon_config(sc, NULL);    /* restart beacons */
@@ -930,6 +940,9 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
         ath9k_hw_set_interrupts(ah, 0);
 
         ath_drain_all_txq(sc, false);   /* clear pending tx frames */
+
+        spin_lock_bh(&sc->rx.pcu_lock);
+
         ath_stoprecv(sc);               /* turn off frame recv */
         ath_flushrecv(sc);              /* flush recv queue */
 
@@ -947,6 +960,9 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
         spin_unlock_bh(&sc->sc_resetlock);
 
         ath9k_hw_phy_disable(ah);
+
+        spin_unlock_bh(&sc->rx.pcu_lock);
+
         ath9k_hw_configpcipowersave(ah, 1, 1);
         ath9k_ps_restore(sc);
         ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP);
@@ -966,6 +982,9 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
 
         ath9k_hw_set_interrupts(ah, 0);
         ath_drain_all_txq(sc, retry_tx);
+
+        spin_lock_bh(&sc->rx.pcu_lock);
+
         ath_stoprecv(sc);
         ath_flushrecv(sc);
 
@@ -980,6 +999,8 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
                 ath_print(common, ATH_DBG_FATAL,
                           "Unable to start recv logic\n");
 
+        spin_unlock_bh(&sc->rx.pcu_lock);
+
         /*
          * We may be doing a reset in response to a request
          * that changes the channel so update any state that
@@ -1142,6 +1163,7 @@ static int ath9k_start(struct ieee80211_hw *hw)
          * be followed by initialization of the appropriate bits
          * and then setup of the interrupt mask.
          */
+        spin_lock_bh(&sc->rx.pcu_lock);
         spin_lock_bh(&sc->sc_resetlock);
         r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
         if (r) {
@@ -1150,6 +1172,7 @@ static int ath9k_start(struct ieee80211_hw *hw)
                           "(freq %u MHz)\n", r,
                           curchan->center_freq);
                 spin_unlock_bh(&sc->sc_resetlock);
+                spin_unlock_bh(&sc->rx.pcu_lock);
                 goto mutex_unlock;
         }
         spin_unlock_bh(&sc->sc_resetlock);
@@ -1171,8 +1194,10 @@ static int ath9k_start(struct ieee80211_hw *hw)
                 ath_print(common, ATH_DBG_FATAL,
                           "Unable to start recv logic\n");
                 r = -EIO;
+                spin_unlock_bh(&sc->rx.pcu_lock);
                 goto mutex_unlock;
         }
+        spin_unlock_bh(&sc->rx.pcu_lock);
 
         /* Setup our intr mask. */
         ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
@@ -1371,12 +1396,14 @@ static void ath9k_stop(struct ieee80211_hw *hw)
          * before setting the invalid flag. */
         ath9k_hw_set_interrupts(ah, 0);
 
+        spin_lock_bh(&sc->rx.pcu_lock);
         if (!(sc->sc_flags & SC_OP_INVALID)) {
                 ath_drain_all_txq(sc, false);
                 ath_stoprecv(sc);
                 ath9k_hw_phy_disable(ah);
         } else
                 sc->rx.rxlink = NULL;
+        spin_unlock_bh(&sc->rx.pcu_lock);
 
         /* disable HAL and put h/w to sleep */
         ath9k_hw_disable(ah);
diff --git a/drivers/net/wireless/ath/ath9k/rc.c b/drivers/net/wireless/ath/ath9k/rc.c
index 0cee90cf8dc9..89978d71617f 100644
--- a/drivers/net/wireless/ath/ath9k/rc.c
+++ b/drivers/net/wireless/ath/ath9k/rc.c
@@ -527,7 +527,7 @@ static u8 ath_rc_setvalid_rates(struct ath_rate_priv *ath_rc_priv,
         for (i = 0; i < rateset->rs_nrates; i++) {
                 for (j = 0; j < rate_table->rate_cnt; j++) {
                         u32 phy = rate_table->info[j].phy;
-                        u16 rate_flags = rate_table->info[i].rate_flags;
+                        u16 rate_flags = rate_table->info[j].rate_flags;
                         u8 rate = rateset->rs_rates[i];
                         u8 dot11rate = rate_table->info[j].dot11rate;
 
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index fe73fc50082a..fddb0129bb57 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -297,19 +297,17 @@ static void ath_edma_start_recv(struct ath_softc *sc)
         ath_rx_addbuffer_edma(sc, ATH9K_RX_QUEUE_LP,
                               sc->rx.rx_edma[ATH9K_RX_QUEUE_LP].rx_fifo_hwsize);
 
-        spin_unlock_bh(&sc->rx.rxbuflock);
-
         ath_opmode_init(sc);
 
         ath9k_hw_startpcureceive(sc->sc_ah, (sc->sc_flags & SC_OP_OFFCHANNEL));
+
+        spin_unlock_bh(&sc->rx.rxbuflock);
 }
 
 static void ath_edma_stop_recv(struct ath_softc *sc)
 {
-        spin_lock_bh(&sc->rx.rxbuflock);
         ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_HP);
         ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_LP);
-        spin_unlock_bh(&sc->rx.rxbuflock);
 }
 
 int ath_rx_init(struct ath_softc *sc, int nbufs)
@@ -319,7 +317,7 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
         struct ath_buf *bf;
         int error = 0;
 
-        spin_lock_init(&sc->rx.rxflushlock);
+        spin_lock_init(&sc->rx.pcu_lock);
         sc->sc_flags &= ~SC_OP_RXFLUSH;
         spin_lock_init(&sc->rx.rxbuflock);
 
@@ -506,10 +504,11 @@ int ath_startrecv(struct ath_softc *sc)
         ath9k_hw_rxena(ah);
 
 start_recv:
-        spin_unlock_bh(&sc->rx.rxbuflock);
         ath_opmode_init(sc);
         ath9k_hw_startpcureceive(ah, (sc->sc_flags & SC_OP_OFFCHANNEL));
 
+        spin_unlock_bh(&sc->rx.rxbuflock);
+
         return 0;
 }
 
@@ -518,6 +517,7 @@ bool ath_stoprecv(struct ath_softc *sc)
         struct ath_hw *ah = sc->sc_ah;
         bool stopped;
 
+        spin_lock_bh(&sc->rx.rxbuflock);
         ath9k_hw_stoppcurecv(ah);
         ath9k_hw_setrxfilter(ah, 0);
         stopped = ath9k_hw_stopdmarecv(ah);
@@ -526,19 +526,18 @@ bool ath_stoprecv(struct ath_softc *sc)
                 ath_edma_stop_recv(sc);
         else
                 sc->rx.rxlink = NULL;
+        spin_unlock_bh(&sc->rx.rxbuflock);
 
         return stopped;
 }
 
 void ath_flushrecv(struct ath_softc *sc)
 {
-        spin_lock_bh(&sc->rx.rxflushlock);
         sc->sc_flags |= SC_OP_RXFLUSH;
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
                 ath_rx_tasklet(sc, 1, true);
         ath_rx_tasklet(sc, 1, false);
         sc->sc_flags &= ~SC_OP_RXFLUSH;
-        spin_unlock_bh(&sc->rx.rxflushlock);
 }
 
 static bool ath_beacon_dtim_pending_cab(struct sk_buff *skb)
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index 30ef2dfc1ed2..f2ade2402ce2 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -1089,15 +1089,6 @@ void ath_draintxq(struct ath_softc *sc, struct ath_txq *txq, bool retry_tx)
         txq->axq_tx_inprogress = false;
         spin_unlock_bh(&txq->axq_lock);
 
-        /* flush any pending frames if aggregation is enabled */
-        if (sc->sc_flags & SC_OP_TXAGGR) {
-                if (!retry_tx) {
-                        spin_lock_bh(&txq->axq_lock);
-                        ath_txq_drain_pending_buffers(sc, txq);
-                        spin_unlock_bh(&txq->axq_lock);
-                }
-        }
-
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
                 spin_lock_bh(&txq->axq_lock);
                 while (!list_empty(&txq->txq_fifo_pending)) {
@@ -1118,6 +1109,15 @@ void ath_draintxq(struct ath_softc *sc, struct ath_txq *txq, bool retry_tx)
                 }
                 spin_unlock_bh(&txq->axq_lock);
         }
+
+        /* flush any pending frames if aggregation is enabled */
+        if (sc->sc_flags & SC_OP_TXAGGR) {
+                if (!retry_tx) {
+                        spin_lock_bh(&txq->axq_lock);
+                        ath_txq_drain_pending_buffers(sc, txq);
+                        spin_unlock_bh(&txq->axq_lock);
+                }
+        }
 }
 
 void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
diff --git a/drivers/net/wireless/b43/sdio.c b/drivers/net/wireless/b43/sdio.c
index 45933cf8e8c2..9a55338d957f 100644
--- a/drivers/net/wireless/b43/sdio.c
+++ b/drivers/net/wireless/b43/sdio.c
@@ -175,7 +175,9 @@ static void b43_sdio_remove(struct sdio_func *func)
         struct b43_sdio *sdio = sdio_get_drvdata(func);
 
         ssb_bus_unregister(&sdio->ssb);
+        sdio_claim_host(func);
         sdio_disable_func(func);
+        sdio_release_host(func);
         kfree(sdio);
         sdio_set_drvdata(func, NULL);
 }
diff --git a/drivers/net/wireless/libertas/if_sdio.c b/drivers/net/wireless/libertas/if_sdio.c
index 296fd00a5129..e5685dc317a8 100644
--- a/drivers/net/wireless/libertas/if_sdio.c
+++ b/drivers/net/wireless/libertas/if_sdio.c
@@ -684,18 +684,40 @@ static int if_sdio_prog_firmware(struct if_sdio_card *card)
 
         lbs_deb_enter(LBS_DEB_SDIO);
 
+        /*
+         * Disable interrupts
+         */
+        sdio_claim_host(card->func);
+        sdio_writeb(card->func, 0x00, IF_SDIO_H_INT_MASK, &ret);
+        sdio_release_host(card->func);
+
         sdio_claim_host(card->func);
         scratch = if_sdio_read_scratch(card, &ret);
         sdio_release_host(card->func);
 
+        lbs_deb_sdio("firmware status = %#x\n", scratch);
+        lbs_deb_sdio("scratch ret = %d\n", ret);
+
         if (ret)
                 goto out;
 
-        lbs_deb_sdio("firmware status = %#x\n", scratch);
 
+        /*
+         * The manual clearly describes that FEDC is the right code to use
+         * to detect firmware presence, but for SD8686 it is not that simple.
+         * Scratch is also used to store the RX packet length, so we lose
+         * the FEDC value early on. So we use a non-zero check in order
+         * to validate firmware presence.
+         * Additionally, the SD8686 in the Gumstix always has the high scratch
+         * bit set, even when the firmware is not loaded. So we have to
+         * exclude that from the test.
+         */
         if (scratch == IF_SDIO_FIRMWARE_OK) {
                 lbs_deb_sdio("firmware already loaded\n");
                 goto success;
+        } else if ((card->model == MODEL_8686) && (scratch & 0x7fff)) {
+                lbs_deb_sdio("firmware may be running\n");
+                goto success;
         }
 
         ret = lbs_get_firmware(&card->func->dev, lbs_helper_name, lbs_fw_name,
@@ -709,10 +731,14 @@ static int if_sdio_prog_firmware(struct if_sdio_card *card)
         if (ret)
                 goto out;
 
+        lbs_deb_sdio("Helper firmware loaded\n");
+
         ret = if_sdio_prog_real(card, mainfw);
         if (ret)
                 goto out;
 
+        lbs_deb_sdio("Firmware loaded\n");
+
 success:
         sdio_claim_host(card->func);
         sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
@@ -1042,8 +1068,6 @@ static int if_sdio_probe(struct sdio_func *func,
         priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
         priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
 
-        priv->fw_ready = 1;
-
         sdio_claim_host(func);
 
         /*
@@ -1064,6 +1088,8 @@ static int if_sdio_probe(struct sdio_func *func,
         if (ret)
                 goto reclaim;
 
+        priv->fw_ready = 1;
+
         /*
          * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
          */