114 files changed, 4237 insertions, 2331 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 4a77d0d300a5..f16ce8f46934 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1080,6 +1080,12 @@ S:	Supported
 F:      Documentation/aoe/
 F:      drivers/block/aoe/
 
+ATHEROS ATH GENERIC UTILITIES
+M:      "Luis R. Rodriguez" <lrodriguez@atheros.com>
+L:      linux-wireless@vger.kernel.org
+S:      Supported
+F:      drivers/net/wireless/ath/*
+
 ATHEROS ATH5K WIRELESS DRIVER
 M:      Jiri Slaby <jirislaby@gmail.com>
 M:      Nick Kossifidis <mickflemm@gmail.com>
diff --git a/drivers/net/wireless/ath/ath.h b/drivers/net/wireless/ath/ath.h
index 26bdbeee424f..e43210c8585c 100644
--- a/drivers/net/wireless/ath/ath.h
+++ b/drivers/net/wireless/ath/ath.h
@@ -104,11 +104,6 @@ enum ath_cipher {
         ATH_CIPHER_MIC = 127
 };
 
-enum ath_drv_info {
-        AR7010_DEVICE           = BIT(0),
-        AR9287_DEVICE           = BIT(1),
-};
-
 /**
  * struct ath_ops - Register read/write operations
  *
@@ -131,6 +126,7 @@ struct ath_bus_ops {
         void (*read_cachesize)(struct ath_common *common, int *csz);
         bool (*eeprom_read)(struct ath_common *common, u32 off, u16 *data);
         void (*bt_coex_prep)(struct ath_common *common);
+        void (*extn_synch_en)(struct ath_common *common);
 };
 
 struct ath_common {
@@ -152,7 +148,6 @@ struct ath_common {
         u8 rx_chainmask;
 
         u32 rx_bufsize;
-        u32 driver_info;
 
         u32 keymax;
         DECLARE_BITMAP(keymap, ATH_KEYMAX);
@@ -186,4 +181,112 @@ bool ath_hw_keyreset(struct ath_common *common, u16 entry);
 void ath_hw_cycle_counters_update(struct ath_common *common);
 int32_t ath_hw_get_listen_time(struct ath_common *common);
 
+extern __attribute__ ((format (printf, 3, 4))) int
+ath_printk(const char *level, struct ath_common *common, const char *fmt, ...);
+
+#define ath_emerg(common, fmt, ...)                             \
+        ath_printk(KERN_EMERG, common, fmt, ##__VA_ARGS__)
+#define ath_alert(common, fmt, ...)                             \
+        ath_printk(KERN_ALERT, common, fmt, ##__VA_ARGS__)
+#define ath_crit(common, fmt, ...)                              \
+        ath_printk(KERN_CRIT, common, fmt, ##__VA_ARGS__)
+#define ath_err(common, fmt, ...)                               \
+        ath_printk(KERN_ERR, common, fmt, ##__VA_ARGS__)
+#define ath_warn(common, fmt, ...)                              \
+        ath_printk(KERN_WARNING, common, fmt, ##__VA_ARGS__)
+#define ath_notice(common, fmt, ...)                            \
+        ath_printk(KERN_NOTICE, common, fmt, ##__VA_ARGS__)
+#define ath_info(common, fmt, ...)                              \
+        ath_printk(KERN_INFO, common, fmt, ##__VA_ARGS__)
+
+/**
+ * enum ath_debug_level - atheros wireless debug level
+ *
+ * @ATH_DBG_RESET: reset processing
+ * @ATH_DBG_QUEUE: hardware queue management
+ * @ATH_DBG_EEPROM: eeprom processing
+ * @ATH_DBG_CALIBRATE: periodic calibration
+ * @ATH_DBG_INTERRUPT: interrupt processing
+ * @ATH_DBG_REGULATORY: regulatory processing
+ * @ATH_DBG_ANI: adaptive noise immunitive processing
+ * @ATH_DBG_XMIT: basic xmit operation
+ * @ATH_DBG_BEACON: beacon handling
+ * @ATH_DBG_CONFIG: configuration of the hardware
+ * @ATH_DBG_FATAL: fatal errors, this is the default, DBG_DEFAULT
+ * @ATH_DBG_PS: power save processing
+ * @ATH_DBG_HWTIMER: hardware timer handling
+ * @ATH_DBG_BTCOEX: bluetooth coexistance
+ * @ATH_DBG_BSTUCK: stuck beacons
+ * @ATH_DBG_ANY: enable all debugging
+ *
+ * The debug level is used to control the amount and type of debugging output
+ * we want to see. Each driver has its own method for enabling debugging and
+ * modifying debug level states -- but this is typically done through a
+ * module parameter 'debug' along with a respective 'debug' debugfs file
+ * entry.
+ */
+enum ATH_DEBUG {
+        ATH_DBG_RESET           = 0x00000001,
+        ATH_DBG_QUEUE           = 0x00000002,
+        ATH_DBG_EEPROM          = 0x00000004,
+        ATH_DBG_CALIBRATE       = 0x00000008,
+        ATH_DBG_INTERRUPT       = 0x00000010,
+        ATH_DBG_REGULATORY      = 0x00000020,
+        ATH_DBG_ANI             = 0x00000040,
+        ATH_DBG_XMIT            = 0x00000080,
+        ATH_DBG_BEACON          = 0x00000100,
+        ATH_DBG_CONFIG          = 0x00000200,
+        ATH_DBG_FATAL           = 0x00000400,
+        ATH_DBG_PS              = 0x00000800,
+        ATH_DBG_HWTIMER         = 0x00001000,
+        ATH_DBG_BTCOEX          = 0x00002000,
+        ATH_DBG_WMI             = 0x00004000,
+        ATH_DBG_BSTUCK          = 0x00008000,
+        ATH_DBG_ANY             = 0xffffffff
+};
+
+#define ATH_DBG_DEFAULT (ATH_DBG_FATAL)
+
+#ifdef CONFIG_ATH_DEBUG
+
+#define ath_dbg(common, dbg_mask, fmt, ...)                     \
+({                                                              \
+        int rtn;                                                \
+        if ((common)->debug_mask & dbg_mask)                    \
+                rtn = ath_printk(KERN_DEBUG, common, fmt,       \
+                                 ##__VA_ARGS__);                \
+        else                                                    \
+                rtn = 0;                                        \
+                                                                \
+        rtn;                                                    \
+})
+#define ATH_DBG_WARN(foo, arg...) WARN(foo, arg)
+#define ATH_DBG_WARN_ON_ONCE(foo) WARN_ON_ONCE(foo)
+
+#else
+
+static inline  __attribute__ ((format (printf, 3, 4))) int
+ath_dbg(struct ath_common *common, enum ATH_DEBUG dbg_mask,
+        const char *fmt, ...)
+{
+        return 0;
+}
+#define ATH_DBG_WARN(foo, arg...) do {} while (0)
+#define ATH_DBG_WARN_ON_ONCE(foo) ({                            \
+        int __ret_warn_once = !!(foo);                          \
+        unlikely(__ret_warn_once);                              \
+})
+
+#endif /* CONFIG_ATH_DEBUG */
+
+/** Returns string describing opmode, or NULL if unknown mode. */
+#ifdef CONFIG_ATH_DEBUG
+const char *ath_opmode_to_string(enum nl80211_iftype opmode);
+#else
+static inline const char *ath_opmode_to_string(enum nl80211_iftype opmode)
+{
+        return "UNKNOWN";
+}
+#endif
+
 #endif /* ATH_H */
diff --git a/drivers/net/wireless/ath/ath5k/base.c b/drivers/net/wireless/ath/ath5k/base.c
index 0a7071a6dd7a..4e3b97c3d7c2 100644
--- a/drivers/net/wireless/ath/ath5k/base.c
+++ b/drivers/net/wireless/ath/ath5k/base.c
@@ -60,7 +60,6 @@
 #include "reg.h"
 #include "debug.h"
 #include "ani.h"
-#include "../debug.h"
 
 static int modparam_nohwcrypt;
 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
@@ -76,7 +75,6 @@ MODULE_AUTHOR("Nick Kossifidis");
 MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");
 MODULE_SUPPORTED_DEVICE("Atheros 5xxx WLAN cards");
 MODULE_LICENSE("Dual BSD/GPL");
-MODULE_VERSION("0.6.0 (EXPERIMENTAL)");
 
 static int ath5k_init(struct ieee80211_hw *hw);
 static int ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
@@ -1881,7 +1879,8 @@ ath5k_beacon_send(struct ath5k_softc *sc)
                 sc->bmisscount = 0;
         }
 
-        if (sc->opmode == NL80211_IFTYPE_AP && sc->num_ap_vifs > 1) {
+        if ((sc->opmode == NL80211_IFTYPE_AP && sc->num_ap_vifs > 1) ||
+                        sc->opmode == NL80211_IFTYPE_MESH_POINT) {
                 u64 tsf = ath5k_hw_get_tsf64(ah);
                 u32 tsftu = TSF_TO_TU(tsf);
                 int slot = ((tsftu % sc->bintval) * ATH_BCBUF) / sc->bintval;
@@ -1913,8 +1912,9 @@ ath5k_beacon_send(struct ath5k_softc *sc)
                 /* NB: hw still stops DMA, so proceed */
         }
 
-        /* refresh the beacon for AP mode */
-        if (sc->opmode == NL80211_IFTYPE_AP)
+        /* refresh the beacon for AP or MESH mode */
+        if (sc->opmode == NL80211_IFTYPE_AP ||
+                        sc->opmode == NL80211_IFTYPE_MESH_POINT)
                 ath5k_beacon_update(sc->hw, vif);
 
         ath5k_hw_set_txdp(ah, sc->bhalq, bf->daddr);
@@ -2341,8 +2341,9 @@ ath5k_init_softc(struct ath5k_softc *sc, const struct ath_bus_ops *bus_ops)
         /* Initialize driver private data */
         SET_IEEE80211_DEV(hw, sc->dev);
         hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
-                    IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
-                    IEEE80211_HW_SIGNAL_DBM;
+                        IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
+                        IEEE80211_HW_SIGNAL_DBM |
+                        IEEE80211_HW_REPORTS_TX_ACK_STATUS;
 
         hw->wiphy->interface_modes =
                 BIT(NL80211_IFTYPE_AP) |
@@ -2653,7 +2654,7 @@ ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
                                                         bool skip_pcu)
 {
         struct ath5k_hw *ah = sc->ah;
-        int ret;
+        int ret, ani_mode;
 
         ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "resetting\n");
 
@@ -2661,9 +2662,17 @@ ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
         synchronize_irq(sc->irq);
         stop_tasklets(sc);
 
-        if (chan) {
-                ath5k_drain_tx_buffs(sc);
+        /* Save ani mode and disable ANI durring
+         * reset. If we don't we might get false
+         * PHY error interrupts. */
+        ani_mode = ah->ah_sc->ani_state.ani_mode;
+        ath5k_ani_init(ah, ATH5K_ANI_MODE_OFF);
 
+        /* We are going to empty hw queues
+         * so we should also free any remaining
+         * tx buffers */
+        ath5k_drain_tx_buffs(sc);
+        if (chan) {
                 sc->curchan = chan;
                 sc->curband = &sc->sbands[chan->band];
         }
@@ -2680,12 +2689,12 @@ ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
                 goto err;
         }
 
-        ath5k_ani_init(ah, ah->ah_sc->ani_state.ani_mode);
+        ath5k_ani_init(ah, ani_mode);
 
         ah->ah_cal_next_full = jiffies;
         ah->ah_cal_next_ani = jiffies;
         ah->ah_cal_next_nf = jiffies;
-        ewma_init(&ah->ah_beacon_rssi_avg, 1000, 8);
+        ewma_init(&ah->ah_beacon_rssi_avg, 1024, 8);
 
         /*
          * Change channels and update the h/w rate map if we're switching;
@@ -2790,33 +2799,46 @@ ath5k_init(struct ieee80211_hw *hw)
                 goto err_bhal;
         }
 
-        /* This order matches mac80211's queue priority, so we can
-         * directly use the mac80211 queue number without any mapping */
-        txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VO);
-        if (IS_ERR(txq)) {
-                ATH5K_ERR(sc, "can't setup xmit queue\n");
-                ret = PTR_ERR(txq);
-                goto err_queues;
-        }
-        txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VI);
-        if (IS_ERR(txq)) {
-                ATH5K_ERR(sc, "can't setup xmit queue\n");
-                ret = PTR_ERR(txq);
-                goto err_queues;
-        }
-        txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE);
-        if (IS_ERR(txq)) {
-                ATH5K_ERR(sc, "can't setup xmit queue\n");
-                ret = PTR_ERR(txq);
-                goto err_queues;
-        }
-        txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BK);
-        if (IS_ERR(txq)) {
-                ATH5K_ERR(sc, "can't setup xmit queue\n");
-                ret = PTR_ERR(txq);
-                goto err_queues;
+        /* 5211 and 5212 usually support 10 queues but we better rely on the
+         * capability information */
+        if (ah->ah_capabilities.cap_queues.q_tx_num >= 6) {
+                /* This order matches mac80211's queue priority, so we can
+                * directly use the mac80211 queue number without any mapping */
+                txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VO);
+                if (IS_ERR(txq)) {
+                        ATH5K_ERR(sc, "can't setup xmit queue\n");
+                        ret = PTR_ERR(txq);
+                        goto err_queues;
+                }
+                txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VI);
+                if (IS_ERR(txq)) {
+                        ATH5K_ERR(sc, "can't setup xmit queue\n");
+                        ret = PTR_ERR(txq);
+                        goto err_queues;
+                }
+                txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE);
+                if (IS_ERR(txq)) {
+                        ATH5K_ERR(sc, "can't setup xmit queue\n");
+                        ret = PTR_ERR(txq);
+                        goto err_queues;
+                }
+                txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BK);
+                if (IS_ERR(txq)) {
+                        ATH5K_ERR(sc, "can't setup xmit queue\n");
+                        ret = PTR_ERR(txq);
+                        goto err_queues;
+                }
+                hw->queues = 4;
+        } else {
+                /* older hardware (5210) can only support one data queue */
+                txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE);
+                if (IS_ERR(txq)) {
+                        ATH5K_ERR(sc, "can't setup xmit queue\n");
+                        ret = PTR_ERR(txq);
+                        goto err_queues;
+                }
+                hw->queues = 1;
         }
-        hw->queues = 4;
 
         tasklet_init(&sc->rxtq, ath5k_tasklet_rx, (unsigned long)sc);
         tasklet_init(&sc->txtq, ath5k_tasklet_tx, (unsigned long)sc);
@@ -2977,7 +2999,8 @@ static int ath5k_add_interface(struct ieee80211_hw *hw,
 
         /* Assign the vap/adhoc to a beacon xmit slot. */
         if ((avf->opmode == NL80211_IFTYPE_AP) ||
-            (avf->opmode == NL80211_IFTYPE_ADHOC)) {
+            (avf->opmode == NL80211_IFTYPE_ADHOC) ||
+            (avf->opmode == NL80211_IFTYPE_MESH_POINT)) {
                 int slot;
 
                 WARN_ON(list_empty(&sc->bcbuf));
@@ -2996,7 +3019,7 @@ static int ath5k_add_interface(struct ieee80211_hw *hw,
                 sc->bslot[avf->bslot] = vif;
                 if (avf->opmode == NL80211_IFTYPE_AP)
                         sc->num_ap_vifs++;
-                else
+                else if (avf->opmode == NL80211_IFTYPE_ADHOC)
                         sc->num_adhoc_vifs++;
         }
 
diff --git a/drivers/net/wireless/ath/ath5k/debug.c b/drivers/net/wireless/ath/ath5k/debug.c
index 5341dd2860d3..d2f84d76bb07 100644
--- a/drivers/net/wireless/ath/ath5k/debug.c
+++ b/drivers/net/wireless/ath/ath5k/debug.c
@@ -60,7 +60,6 @@
 
 #include "base.h"
 #include "debug.h"
-#include "../debug.h"
 
 static unsigned int ath5k_debug;
 module_param_named(debug, ath5k_debug, uint, 0);
diff --git a/drivers/net/wireless/ath/ath5k/dma.c b/drivers/net/wireless/ath/ath5k/dma.c
index 82541fec9f0e..0064be7ce5c9 100644
--- a/drivers/net/wireless/ath/ath5k/dma.c
+++ b/drivers/net/wireless/ath/ath5k/dma.c
@@ -72,7 +72,7 @@ static int ath5k_hw_stop_rx_dma(struct ath5k_hw *ah)
                         i--)
                 udelay(100);
 
-        if (i)
+        if (!i)
                 ATH5K_DBG(ah->ah_sc, ATH5K_DEBUG_DMA,
                                 "failed to stop RX DMA !\n");
 
diff --git a/drivers/net/wireless/ath/ath5k/pci.c b/drivers/net/wireless/ath/ath5k/pci.c
index 39f033128c5a..7f8c5b0e9d2a 100644
--- a/drivers/net/wireless/ath/ath5k/pci.c
+++ b/drivers/net/wireless/ath/ath5k/pci.c
@@ -45,6 +45,7 @@ static DEFINE_PCI_DEVICE_TABLE(ath5k_pci_id_table) = {
         { PCI_VDEVICE(ATHEROS, 0x001d) }, /* 2417 Nala */
         { 0 }
 };
+MODULE_DEVICE_TABLE(pci, ath5k_pci_id_table);
 
 /* return bus cachesize in 4B word units */
 static void ath5k_pci_read_cachesize(struct ath_common *common, int *csz)
diff --git a/drivers/net/wireless/ath/ath5k/phy.c b/drivers/net/wireless/ath/ath5k/phy.c
index df5cd0fd69d6..f84afb420bd8 100644
--- a/drivers/net/wireless/ath/ath5k/phy.c
+++ b/drivers/net/wireless/ath/ath5k/phy.c
@@ -2742,10 +2742,12 @@ ath5k_combine_pwr_to_pdadc_curves(struct ath5k_hw *ah,
 
 /* Write PDADC values on hw */
 static void
-ath5k_setup_pwr_to_pdadc_table(struct ath5k_hw *ah,
-                        u8 pdcurves, u8 *pdg_to_idx)
+ath5k_setup_pwr_to_pdadc_table(struct ath5k_hw *ah, u8 ee_mode)
 {
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
         u8 *pdadc_out = ah->ah_txpower.txp_pd_table;
+        u8 *pdg_to_idx = ee->ee_pdc_to_idx[ee_mode];
+        u8 pdcurves = ee->ee_pd_gains[ee_mode];
         u32 reg;
         u8 i;
 
@@ -2992,7 +2994,7 @@ ath5k_setup_channel_powertable(struct ath5k_hw *ah,
                                                 ee->ee_pd_gains[ee_mode]);
 
                 /* Write settings on hw */
-                ath5k_setup_pwr_to_pdadc_table(ah, pdg, pdg_curve_to_idx);
+                ath5k_setup_pwr_to_pdadc_table(ah, ee_mode);
 
                 /* Set txp.offset, note that table_min
                  * can be negative */
@@ -3114,12 +3116,6 @@ ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
                 return -EINVAL;
         }
 
-        /* Reset TX power values */
-        memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower));
-        ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER;
-        ah->ah_txpower.txp_min_pwr = 0;
-        ah->ah_txpower.txp_max_pwr = AR5K_TUNE_MAX_TXPOWER;
-
         /* Initialize TX power table */
         switch (ah->ah_radio) {
         case AR5K_RF5110:
@@ -3146,11 +3142,24 @@ ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
          * so there is no need to recalculate the powertable, we 'll
          * just use the cached one */
         if (!fast) {
+                /* Reset TX power values */
+                memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower));
+                ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER;
+                ah->ah_txpower.txp_min_pwr = 0;
+                ah->ah_txpower.txp_max_pwr = AR5K_TUNE_MAX_TXPOWER;
+
+                /* Calculate the powertable */
                 ret = ath5k_setup_channel_powertable(ah, channel,
                                                         ee_mode, type);
-                        if (ret)
-                                return ret;
-        }
+                if (ret)
+                        return ret;
+        /* Write cached table on hw */
+        } else if (type == AR5K_PWRTABLE_PWR_TO_PDADC)
+                ath5k_setup_pwr_to_pdadc_table(ah, ee_mode);
+        else
+                ath5k_setup_pcdac_table(ah);
+
+
 
         /* Limit max power if we have a CTL available */
         ath5k_get_max_ctl_power(ah, channel);
diff --git a/drivers/net/wireless/ath/ath5k/qcu.c b/drivers/net/wireless/ath/ath5k/qcu.c
index 1849eee8235c..2c9c9e793d4e 100644
--- a/drivers/net/wireless/ath/ath5k/qcu.c
+++ b/drivers/net/wireless/ath/ath5k/qcu.c
@@ -152,8 +152,8 @@ int ath5k_hw_setup_tx_queue(struct ath5k_hw *ah, enum ath5k_tx_queue queue_type,
         /*
          * Get queue by type
          */
-        /*5210 only has 2 queues*/
-        if (ah->ah_version == AR5K_AR5210) {
+        /* 5210 only has 2 queues */
+        if (ah->ah_capabilities.cap_queues.q_tx_num == 2) {
                 switch (queue_type) {
                 case AR5K_TX_QUEUE_DATA:
                         queue = AR5K_TX_QUEUE_ID_NOQCU_DATA;
diff --git a/drivers/net/wireless/ath/ath9k/ahb.c b/drivers/net/wireless/ath/ath9k/ahb.c
index 1a984b02e9e5..25a6e4417cdb 100644
--- a/drivers/net/wireless/ath/ath9k/ahb.c
+++ b/drivers/net/wireless/ath/ath9k/ahb.c
@@ -35,10 +35,9 @@ static bool ath_ahb_eeprom_read(struct ath_common *common, u32 off, u16 *data)
 
         pdata = (struct ath9k_platform_data *) pdev->dev.platform_data;
         if (off >= (ARRAY_SIZE(pdata->eeprom_data))) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "%s: flash read failed, offset %08x "
-                          "is out of range\n",
-                          __func__, off);
+                ath_err(common,
+                        "%s: flash read failed, offset %08x is out of range\n",
+                        __func__, off);
                 return false;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/ani.c b/drivers/net/wireless/ath/ath9k/ani.c
index 29a045da184b..2e31c775351f 100644
--- a/drivers/net/wireless/ath/ath9k/ani.c
+++ b/drivers/net/wireless/ath/ath9k/ani.c
@@ -135,8 +135,8 @@ static void ath9k_ani_restart(struct ath_hw *ah)
                 cck_base = AR_PHY_COUNTMAX - ah->config.cck_trig_high;
         }
 
-        ath_print(common, ATH_DBG_ANI,
-                  "Writing ofdmbase=%u   cckbase=%u\n", ofdm_base, cck_base);
+        ath_dbg(common, ATH_DBG_ANI,
+                "Writing ofdmbase=%u   cckbase=%u\n", ofdm_base, cck_base);
 
         ENABLE_REGWRITE_BUFFER(ah);
 
@@ -267,11 +267,11 @@ static void ath9k_hw_set_ofdm_nil(struct ath_hw *ah, u8 immunityLevel)
 
         aniState->noiseFloor = BEACON_RSSI(ah);
 
-        ath_print(common, ATH_DBG_ANI,
-                  "**** ofdmlevel %d=>%d, rssi=%d[lo=%d hi=%d]\n",
-                  aniState->ofdmNoiseImmunityLevel,
-                  immunityLevel, aniState->noiseFloor,
-                  aniState->rssiThrLow, aniState->rssiThrHigh);
+        ath_dbg(common, ATH_DBG_ANI,
+                "**** ofdmlevel %d=>%d, rssi=%d[lo=%d hi=%d]\n",
+                aniState->ofdmNoiseImmunityLevel,
+                immunityLevel, aniState->noiseFloor,
+                aniState->rssiThrLow, aniState->rssiThrHigh);
 
         aniState->ofdmNoiseImmunityLevel = immunityLevel;
 
@@ -334,11 +334,11 @@ static void ath9k_hw_set_cck_nil(struct ath_hw *ah, u_int8_t immunityLevel)
         const struct ani_cck_level_entry *entry_cck;
 
         aniState->noiseFloor = BEACON_RSSI(ah);
-        ath_print(common, ATH_DBG_ANI,
-                  "**** ccklevel %d=>%d, rssi=%d[lo=%d hi=%d]\n",
-                  aniState->cckNoiseImmunityLevel, immunityLevel,
-                  aniState->noiseFloor, aniState->rssiThrLow,
-                  aniState->rssiThrHigh);
+        ath_dbg(common, ATH_DBG_ANI,
+                "**** ccklevel %d=>%d, rssi=%d[lo=%d hi=%d]\n",
+                aniState->cckNoiseImmunityLevel, immunityLevel,
+                aniState->noiseFloor, aniState->rssiThrLow,
+                aniState->rssiThrHigh);
 
         if ((ah->opmode == NL80211_IFTYPE_STATION ||
              ah->opmode == NL80211_IFTYPE_ADHOC) &&
@@ -358,7 +358,7 @@ static void ath9k_hw_set_cck_nil(struct ath_hw *ah, u_int8_t immunityLevel)
                                      entry_cck->fir_step_level);
 
         /* Skip MRC CCK for pre AR9003 families */
-        if (!AR_SREV_9300_20_OR_LATER(ah))
+        if (!AR_SREV_9300_20_OR_LATER(ah) || AR_SREV_9485(ah))
                 return;
 
         if (aniState->mrcCCKOff == entry_cck->mrc_cck_on)
@@ -478,8 +478,8 @@ static void ath9k_ani_reset_old(struct ath_hw *ah, bool is_scanning)
 
         if (ah->opmode != NL80211_IFTYPE_STATION
             && ah->opmode != NL80211_IFTYPE_ADHOC) {
-                ath_print(common, ATH_DBG_ANI,
-                          "Reset ANI state opmode %u\n", ah->opmode);
+                ath_dbg(common, ATH_DBG_ANI,
+                        "Reset ANI state opmode %u\n", ah->opmode);
                 ah->stats.ast_ani_reset++;
 
                 if (ah->opmode == NL80211_IFTYPE_AP) {
@@ -584,16 +584,14 @@ void ath9k_ani_reset(struct ath_hw *ah, bool is_scanning)
                     ATH9K_ANI_OFDM_DEF_LEVEL ||
                     aniState->cckNoiseImmunityLevel !=
                     ATH9K_ANI_CCK_DEF_LEVEL) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "Restore defaults: opmode %u "
-                                  "chan %d Mhz/0x%x is_scanning=%d "
-                                  "ofdm:%d cck:%d\n",
-                                  ah->opmode,
-                                  chan->channel,
-                                  chan->channelFlags,
-                                  is_scanning,
-                                  aniState->ofdmNoiseImmunityLevel,
-                                  aniState->cckNoiseImmunityLevel);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "Restore defaults: opmode %u chan %d Mhz/0x%x is_scanning=%d ofdm:%d cck:%d\n",
+                                ah->opmode,
+                                chan->channel,
+                                chan->channelFlags,
+                                is_scanning,
+                                aniState->ofdmNoiseImmunityLevel,
+                                aniState->cckNoiseImmunityLevel);
 
                         ath9k_hw_set_ofdm_nil(ah, ATH9K_ANI_OFDM_DEF_LEVEL);
                         ath9k_hw_set_cck_nil(ah, ATH9K_ANI_CCK_DEF_LEVEL);
@@ -602,16 +600,14 @@ void ath9k_ani_reset(struct ath_hw *ah, bool is_scanning)
                 /*
                  * restore historical levels for this channel
                  */
-                ath_print(common, ATH_DBG_ANI,
-                          "Restore history: opmode %u "
-                          "chan %d Mhz/0x%x is_scanning=%d "
-                          "ofdm:%d cck:%d\n",
-                          ah->opmode,
-                          chan->channel,
-                          chan->channelFlags,
-                          is_scanning,
-                          aniState->ofdmNoiseImmunityLevel,
-                          aniState->cckNoiseImmunityLevel);
+                ath_dbg(common, ATH_DBG_ANI,
+                        "Restore history: opmode %u chan %d Mhz/0x%x is_scanning=%d ofdm:%d cck:%d\n",
+                        ah->opmode,
+                        chan->channel,
+                        chan->channelFlags,
+                        is_scanning,
+                        aniState->ofdmNoiseImmunityLevel,
+                        aniState->cckNoiseImmunityLevel);
 
                         ath9k_hw_set_ofdm_nil(ah,
                                               aniState->ofdmNoiseImmunityLevel);
@@ -666,19 +662,17 @@ static bool ath9k_hw_ani_read_counters(struct ath_hw *ah)
 
         if (!use_new_ani(ah) && (phyCnt1 < ofdm_base || phyCnt2 < cck_base)) {
                 if (phyCnt1 < ofdm_base) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "phyCnt1 0x%x, resetting "
-                                  "counter value to 0x%x\n",
-                                  phyCnt1, ofdm_base);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "phyCnt1 0x%x, resetting counter value to 0x%x\n",
+                                phyCnt1, ofdm_base);
                         REG_WRITE(ah, AR_PHY_ERR_1, ofdm_base);
                         REG_WRITE(ah, AR_PHY_ERR_MASK_1,
                                   AR_PHY_ERR_OFDM_TIMING);
                 }
                 if (phyCnt2 < cck_base) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "phyCnt2 0x%x, resetting "
-                                  "counter value to 0x%x\n",
-                                  phyCnt2, cck_base);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "phyCnt2 0x%x, resetting counter value to 0x%x\n",
+                                phyCnt2, cck_base);
                         REG_WRITE(ah, AR_PHY_ERR_2, cck_base);
                         REG_WRITE(ah, AR_PHY_ERR_MASK_2,
                                   AR_PHY_ERR_CCK_TIMING);
@@ -719,13 +713,12 @@ void ath9k_hw_ani_monitor(struct ath_hw *ah, struct ath9k_channel *chan)
         cckPhyErrRate =  aniState->cckPhyErrCount * 1000 /
                          aniState->listenTime;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "listenTime=%d OFDM:%d errs=%d/s CCK:%d "
-                  "errs=%d/s ofdm_turn=%d\n",
-                  aniState->listenTime,
-                  aniState->ofdmNoiseImmunityLevel,
-                  ofdmPhyErrRate, aniState->cckNoiseImmunityLevel,
-                  cckPhyErrRate, aniState->ofdmsTurn);
+        ath_dbg(common, ATH_DBG_ANI,
+                "listenTime=%d OFDM:%d errs=%d/s CCK:%d errs=%d/s ofdm_turn=%d\n",
+                aniState->listenTime,
+                aniState->ofdmNoiseImmunityLevel,
+                ofdmPhyErrRate, aniState->cckNoiseImmunityLevel,
+                cckPhyErrRate, aniState->ofdmsTurn);
 
         if (aniState->listenTime > 5 * ah->aniperiod) {
                 if (ofdmPhyErrRate <= ah->config.ofdm_trig_low &&
@@ -755,7 +748,7 @@ void ath9k_enable_mib_counters(struct ath_hw *ah)
 {
         struct ath_common *common = ath9k_hw_common(ah);
 
-        ath_print(common, ATH_DBG_ANI, "Enable MIB counters\n");
+        ath_dbg(common, ATH_DBG_ANI, "Enable MIB counters\n");
 
         ath9k_hw_update_mibstats(ah, &ah->ah_mibStats);
 
@@ -777,7 +770,7 @@ void ath9k_hw_disable_mib_counters(struct ath_hw *ah)
 {
         struct ath_common *common = ath9k_hw_common(ah);
 
-        ath_print(common, ATH_DBG_ANI, "Disable MIB counters\n");
+        ath_dbg(common, ATH_DBG_ANI, "Disable MIB counters\n");
 
         REG_WRITE(ah, AR_MIBC, AR_MIBC_FMC);
         ath9k_hw_update_mibstats(ah, &ah->ah_mibStats);
@@ -852,7 +845,7 @@ void ath9k_hw_ani_init(struct ath_hw *ah)
         struct ath_common *common = ath9k_hw_common(ah);
         int i;
 
-        ath_print(common, ATH_DBG_ANI, "Initialize ANI\n");
+        ath_dbg(common, ATH_DBG_ANI, "Initialize ANI\n");
 
         if (use_new_ani(ah)) {
                 ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH_NEW;
diff --git a/drivers/net/wireless/ath/ath9k/ar5008_phy.c b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
index 06e34d293dc8..059330aac645 100644
--- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
@@ -130,9 +130,8 @@ static void ar5008_hw_force_bias(struct ath_hw *ah, u16 synth_freq)
         /* pre-reverse this field */
         tmp_reg = ath9k_hw_reverse_bits(new_bias, 3);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Force rf_pwd_icsyndiv to %1d on %4d\n",
-                  new_bias, synth_freq);
+        ath_dbg(common, ATH_DBG_CONFIG, "Force rf_pwd_icsyndiv to %1d on %4d\n",
+                new_bias, synth_freq);
 
         /* swizzle rf_pwd_icsyndiv */
         ar5008_hw_phy_modify_rx_buffer(ah->analogBank6Data, tmp_reg, 3, 181, 3);
@@ -173,8 +172,7 @@ static int ar5008_hw_set_channel(struct ath_hw *ah, struct ath9k_channel *chan)
                         channelSel = ((freq - 704) * 2 - 3040) / 10;
                         bModeSynth = 1;
                 } else {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Invalid channel %u MHz\n", freq);
+                        ath_err(common, "Invalid channel %u MHz\n", freq);
                         return -EINVAL;
                 }
 
@@ -206,8 +204,7 @@ static int ar5008_hw_set_channel(struct ath_hw *ah, struct ath9k_channel *chan)
                 channelSel = ath9k_hw_reverse_bits((freq - 4800) / 5, 8);
                 aModeRefSel = ath9k_hw_reverse_bits(1, 2);
         } else {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Invalid channel %u MHz\n", freq);
+                ath_err(common, "Invalid channel %u MHz\n", freq);
                 return -EINVAL;
         }
 
@@ -448,8 +445,7 @@ static int ar5008_hw_rf_alloc_ext_banks(struct ath_hw *ah)
 #define ATH_ALLOC_BANK(bank, size) do { \
                 bank = kzalloc((sizeof(u32) * size), GFP_KERNEL); \
                 if (!bank) { \
-                        ath_print(common, ATH_DBG_FATAL, \
-                                  "Cannot allocate RF banks\n"); \
+                        ath_err(common, "Cannot allocate RF banks\n"); \
                         return -ENOMEM; \
                 } \
         } while (0);
@@ -879,8 +875,7 @@ static int ar5008_hw_process_ini(struct ath_hw *ah,
 
         /* Write analog registers */
         if (!ath9k_hw_set_rf_regs(ah, chan, freqIndex)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "ar5416SetRfRegs failed\n");
+                ath_err(ath9k_hw_common(ah), "ar5416SetRfRegs failed\n");
                 return -EIO;
         }
 
@@ -1058,10 +1053,9 @@ static bool ar5008_hw_ani_control_old(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(ah->totalSizeDesired)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "level out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned)ARRAY_SIZE(ah->totalSizeDesired));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(ah->totalSizeDesired));
                         return false;
                 }
 
@@ -1163,10 +1157,9 @@ static bool ar5008_hw_ani_control_old(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(firstep)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "level out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(firstep));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(firstep));
                         return false;
                 }
                 REG_RMW_FIELD(ah, AR_PHY_FIND_SIG,
@@ -1184,10 +1177,9 @@ static bool ar5008_hw_ani_control_old(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(cycpwrThr1)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "level out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(cycpwrThr1));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(cycpwrThr1));
                         return false;
                 }
                 REG_RMW_FIELD(ah, AR_PHY_TIMING5,
@@ -1203,25 +1195,22 @@ static bool ar5008_hw_ani_control_old(struct ath_hw *ah,
         case ATH9K_ANI_PRESENT:
                 break;
         default:
-                ath_print(common, ATH_DBG_ANI,
-                          "invalid cmd %u\n", cmd);
+                ath_dbg(common, ATH_DBG_ANI, "invalid cmd %u\n", cmd);
                 return false;
         }
 
-        ath_print(common, ATH_DBG_ANI, "ANI parameters:\n");
-        ath_print(common, ATH_DBG_ANI,
-                  "noiseImmunityLevel=%d, spurImmunityLevel=%d, "
-                  "ofdmWeakSigDetectOff=%d\n",
-                  aniState->noiseImmunityLevel,
-                  aniState->spurImmunityLevel,
-                  !aniState->ofdmWeakSigDetectOff);
-        ath_print(common, ATH_DBG_ANI,
-                  "cckWeakSigThreshold=%d, "
-                  "firstepLevel=%d, listenTime=%d\n",
-                  aniState->cckWeakSigThreshold,
-                  aniState->firstepLevel,
-                  aniState->listenTime);
-        ath_print(common, ATH_DBG_ANI,
+        ath_dbg(common, ATH_DBG_ANI, "ANI parameters:\n");
+        ath_dbg(common, ATH_DBG_ANI,
+                "noiseImmunityLevel=%d, spurImmunityLevel=%d, ofdmWeakSigDetectOff=%d\n",
+                aniState->noiseImmunityLevel,
+                aniState->spurImmunityLevel,
+                !aniState->ofdmWeakSigDetectOff);
+        ath_dbg(common, ATH_DBG_ANI,
+                "cckWeakSigThreshold=%d, firstepLevel=%d, listenTime=%d\n",
+                aniState->cckWeakSigThreshold,
+                aniState->firstepLevel,
+                aniState->listenTime);
+        ath_dbg(common, ATH_DBG_ANI,
                 "ofdmPhyErrCount=%d, cckPhyErrCount=%d\n\n",
                 aniState->ofdmPhyErrCount,
                 aniState->cckPhyErrCount);
@@ -1306,12 +1295,12 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
                                     AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW);
 
                 if (!on != aniState->ofdmWeakSigDetectOff) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: ofdm weak signal: %s=>%s\n",
-                                  chan->channel,
-                                  !aniState->ofdmWeakSigDetectOff ?
-                                        "on" : "off",
-                                  on ? "on" : "off");
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: ofdm weak signal: %s=>%s\n",
+                                chan->channel,
+                                !aniState->ofdmWeakSigDetectOff ?
+                                "on" : "off",
+                                on ? "on" : "off");
                         if (on)
                                 ah->stats.ast_ani_ofdmon++;
                         else
@@ -1324,11 +1313,9 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(firstep_table)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "ATH9K_ANI_FIRSTEP_LEVEL: level "
-                                  "out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(firstep_table));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "ATH9K_ANI_FIRSTEP_LEVEL: level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(firstep_table));
                         return false;
                 }
 
@@ -1363,24 +1350,22 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
                               AR_PHY_FIND_SIG_FIRSTEP_LOW, value2);
 
                 if (level != aniState->firstepLevel) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "firstep[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->firstepLevel,
-                                  level,
-                                  ATH9K_ANI_FIRSTEP_LVL_NEW,
-                                  value,
-                                  aniState->iniDef.firstep);
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "firstep_low[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->firstepLevel,
-                                  level,
-                                  ATH9K_ANI_FIRSTEP_LVL_NEW,
-                                  value2,
-                                  aniState->iniDef.firstepLow);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] firstep[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->firstepLevel,
+                                level,
+                                ATH9K_ANI_FIRSTEP_LVL_NEW,
+                                value,
+                                aniState->iniDef.firstep);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] firstep_low[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->firstepLevel,
+                                level,
+                                ATH9K_ANI_FIRSTEP_LVL_NEW,
+                                value2,
+                                aniState->iniDef.firstepLow);
                         if (level > aniState->firstepLevel)
                                 ah->stats.ast_ani_stepup++;
                         else if (level < aniState->firstepLevel)
@@ -1393,11 +1378,9 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(cycpwrThr1_table)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "ATH9K_ANI_SPUR_IMMUNITY_LEVEL: level "
-                                  "out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(cycpwrThr1_table));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "ATH9K_ANI_SPUR_IMMUNITY_LEVEL: level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(cycpwrThr1_table));
                         return false;
                 }
                 /*
@@ -1431,24 +1414,22 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
                               AR_PHY_EXT_TIMING5_CYCPWR_THR1, value2);
 
                 if (level != aniState->spurImmunityLevel) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "cycpwrThr1[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->spurImmunityLevel,
-                                  level,
-                                  ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
-                                  value,
-                                  aniState->iniDef.cycpwrThr1);
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "cycpwrThr1Ext[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->spurImmunityLevel,
-                                  level,
-                                  ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
-                                  value2,
-                                  aniState->iniDef.cycpwrThr1Ext);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] cycpwrThr1[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->spurImmunityLevel,
+                                level,
+                                ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
+                                value,
+                                aniState->iniDef.cycpwrThr1);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] cycpwrThr1Ext[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->spurImmunityLevel,
+                                level,
+                                ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
+                                value2,
+                                aniState->iniDef.cycpwrThr1Ext);
                         if (level > aniState->spurImmunityLevel)
                                 ah->stats.ast_ani_spurup++;
                         else if (level < aniState->spurImmunityLevel)
@@ -1467,22 +1448,19 @@ static bool ar5008_hw_ani_control_new(struct ath_hw *ah,
         case ATH9K_ANI_PRESENT:
                 break;
         default:
-                ath_print(common, ATH_DBG_ANI,
-                          "invalid cmd %u\n", cmd);
+                ath_dbg(common, ATH_DBG_ANI, "invalid cmd %u\n", cmd);
                 return false;
         }
 
-        ath_print(common, ATH_DBG_ANI,
-                  "ANI parameters: SI=%d, ofdmWS=%s FS=%d "
-                  "MRCcck=%s listenTime=%d "
-                  "ofdmErrs=%d cckErrs=%d\n",
-                  aniState->spurImmunityLevel,
-                  !aniState->ofdmWeakSigDetectOff ? "on" : "off",
-                  aniState->firstepLevel,
-                  !aniState->mrcCCKOff ? "on" : "off",
-                  aniState->listenTime,
-                  aniState->ofdmPhyErrCount,
-                  aniState->cckPhyErrCount);
+        ath_dbg(common, ATH_DBG_ANI,
+                "ANI parameters: SI=%d, ofdmWS=%s FS=%d MRCcck=%s listenTime=%d ofdmErrs=%d cckErrs=%d\n",
+                aniState->spurImmunityLevel,
+                !aniState->ofdmWeakSigDetectOff ? "on" : "off",
+                aniState->firstepLevel,
+                !aniState->mrcCCKOff ? "on" : "off",
+                aniState->listenTime,
+                aniState->ofdmPhyErrCount,
+                aniState->cckPhyErrCount);
         return true;
 }
 
@@ -1528,13 +1506,12 @@ static void ar5008_hw_ani_cache_ini_regs(struct ath_hw *ah)
 
         iniDef = &aniState->iniDef;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "ver %d.%d opmode %u chan %d Mhz/0x%x\n",
-                  ah->hw_version.macVersion,
-                  ah->hw_version.macRev,
-                  ah->opmode,
-                  chan->channel,
-                  chan->channelFlags);
+        ath_dbg(common, ATH_DBG_ANI, "ver %d.%d opmode %u chan %d Mhz/0x%x\n",
+                ah->hw_version.macVersion,
+                ah->hw_version.macRev,
+                ah->opmode,
+                chan->channel,
+                chan->channelFlags);
 
         val = REG_READ(ah, AR_PHY_SFCORR);
         iniDef->m1Thresh = MS(val, AR_PHY_SFCORR_M1_THRESH);
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_calib.c b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
index 15f62cd0cc38..01880aa13e36 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
@@ -39,18 +39,18 @@ static void ar9002_hw_setup_calibration(struct ath_hw *ah,
         switch (currCal->calData->calType) {
         case IQ_MISMATCH_CAL:
                 REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_IQ);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "starting IQ Mismatch Calibration\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "starting IQ Mismatch Calibration\n");
                 break;
         case ADC_GAIN_CAL:
                 REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_ADC_GAIN);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "starting ADC Gain Calibration\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "starting ADC Gain Calibration\n");
                 break;
         case ADC_DC_CAL:
                 REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_ADC_DC_PER);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "starting ADC DC Calibration\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "starting ADC DC Calibration\n");
                 break;
         }
 
@@ -107,11 +107,11 @@ static void ar9002_hw_iqcal_collect(struct ath_hw *ah)
                         REG_READ(ah, AR_PHY_CAL_MEAS_1(i));
                 ah->totalIqCorrMeas[i] +=
                         (int32_t) REG_READ(ah, AR_PHY_CAL_MEAS_2(i));
-                ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
-                          "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
-                          ah->cal_samples, i, ah->totalPowerMeasI[i],
-                          ah->totalPowerMeasQ[i],
-                          ah->totalIqCorrMeas[i]);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
+                        "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
+                        ah->cal_samples, i, ah->totalPowerMeasI[i],
+                        ah->totalPowerMeasQ[i],
+                        ah->totalIqCorrMeas[i]);
         }
 }
 
@@ -129,14 +129,13 @@ static void ar9002_hw_adc_gaincal_collect(struct ath_hw *ah)
                 ah->totalAdcQEvenPhase[i] +=
                         REG_READ(ah, AR_PHY_CAL_MEAS_3(i));
 
-                ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
-                          "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
-                          "oddq=0x%08x; evenq=0x%08x;\n",
-                          ah->cal_samples, i,
-                          ah->totalAdcIOddPhase[i],
-                          ah->totalAdcIEvenPhase[i],
-                          ah->totalAdcQOddPhase[i],
-                          ah->totalAdcQEvenPhase[i]);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
+                        "%d: Chn %d oddi=0x%08x; eveni=0x%08x; oddq=0x%08x; evenq=0x%08x;\n",
+                        ah->cal_samples, i,
+                        ah->totalAdcIOddPhase[i],
+                        ah->totalAdcIEvenPhase[i],
+                        ah->totalAdcQOddPhase[i],
+                        ah->totalAdcQEvenPhase[i]);
         }
 }
 
@@ -154,14 +153,13 @@ static void ar9002_hw_adc_dccal_collect(struct ath_hw *ah)
                 ah->totalAdcDcOffsetQEvenPhase[i] +=
                         (int32_t) REG_READ(ah, AR_PHY_CAL_MEAS_3(i));
 
-                ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
-                          "%d: Chn %d oddi=0x%08x; eveni=0x%08x; "
-                          "oddq=0x%08x; evenq=0x%08x;\n",
-                          ah->cal_samples, i,
-                          ah->totalAdcDcOffsetIOddPhase[i],
-                          ah->totalAdcDcOffsetIEvenPhase[i],
-                          ah->totalAdcDcOffsetQOddPhase[i],
-                          ah->totalAdcDcOffsetQEvenPhase[i]);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
+                        "%d: Chn %d oddi=0x%08x; eveni=0x%08x; oddq=0x%08x; evenq=0x%08x;\n",
+                        ah->cal_samples, i,
+                        ah->totalAdcDcOffsetIOddPhase[i],
+                        ah->totalAdcDcOffsetIEvenPhase[i],
+                        ah->totalAdcDcOffsetQOddPhase[i],
+                        ah->totalAdcDcOffsetQEvenPhase[i]);
         }
 }
 
@@ -178,13 +176,13 @@ static void ar9002_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                 powerMeasQ = ah->totalPowerMeasQ[i];
                 iqCorrMeas = ah->totalIqCorrMeas[i];
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Starting IQ Cal and Correction for Chain %d\n",
-                          i);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Starting IQ Cal and Correction for Chain %d\n",
+                        i);
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Orignal: Chn %diq_corr_meas = 0x%08x\n",
-                          i, ah->totalIqCorrMeas[i]);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Orignal: Chn %diq_corr_meas = 0x%08x\n",
+                        i, ah->totalIqCorrMeas[i]);
 
                 iqCorrNeg = 0;
 
@@ -193,12 +191,12 @@ static void ar9002_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         iqCorrNeg = 1;
                 }
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_i = 0x%08x\n", i, powerMeasI);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_q = 0x%08x\n", i, powerMeasQ);
-                ath_print(common, ATH_DBG_CALIBRATE, "iqCorrNeg is 0x%08x\n",
-                          iqCorrNeg);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_i = 0x%08x\n", i, powerMeasI);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_q = 0x%08x\n", i, powerMeasQ);
+                ath_dbg(common, ATH_DBG_CALIBRATE, "iqCorrNeg is 0x%08x\n",
+                        iqCorrNeg);
 
                 iCoffDenom = (powerMeasI / 2 + powerMeasQ / 2) / 128;
                 qCoffDenom = powerMeasQ / 64;
@@ -207,14 +205,14 @@ static void ar9002_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                     (qCoffDenom != 0)) {
                         iCoff = iqCorrMeas / iCoffDenom;
                         qCoff = powerMeasI / qCoffDenom - 64;
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d iCoff = 0x%08x\n", i, iCoff);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d qCoff = 0x%08x\n", i, qCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d iCoff = 0x%08x\n", i, iCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d qCoff = 0x%08x\n", i, qCoff);
 
                         iCoff = iCoff & 0x3f;
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "New: Chn %d iCoff = 0x%08x\n", i, iCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "New: Chn %d iCoff = 0x%08x\n", i, iCoff);
                         if (iqCorrNeg == 0x0)
                                 iCoff = 0x40 - iCoff;
 
@@ -223,9 +221,9 @@ static void ar9002_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         else if (qCoff <= -16)
                                 qCoff = -16;
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d : iCoff = 0x%x  qCoff = 0x%x\n",
-                                  i, iCoff, qCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d : iCoff = 0x%x  qCoff = 0x%x\n",
+                                i, iCoff, qCoff);
 
                         REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4(i),
                                       AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF,
@@ -233,9 +231,9 @@ static void ar9002_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4(i),
                                       AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF,
                                       qCoff);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "IQ Cal and Correction done for Chain %d\n",
-                                  i);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "IQ Cal and Correction done for Chain %d\n",
+                                i);
                 }
         }
 
@@ -255,21 +253,21 @@ static void ar9002_hw_adc_gaincal_calibrate(struct ath_hw *ah, u8 numChains)
                 qOddMeasOffset = ah->totalAdcQOddPhase[i];
                 qEvenMeasOffset = ah->totalAdcQEvenPhase[i];
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Starting ADC Gain Cal for Chain %d\n", i);
-
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_odd_i = 0x%08x\n", i,
-                          iOddMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_even_i = 0x%08x\n", i,
-                          iEvenMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_odd_q = 0x%08x\n", i,
-                          qOddMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_even_q = 0x%08x\n", i,
-                          qEvenMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Starting ADC Gain Cal for Chain %d\n", i);
+
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_odd_i = 0x%08x\n", i,
+                        iOddMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_even_i = 0x%08x\n", i,
+                        iEvenMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_odd_q = 0x%08x\n", i,
+                        qOddMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_even_q = 0x%08x\n", i,
+                        qEvenMeasOffset);
 
                 if (iOddMeasOffset != 0 && qEvenMeasOffset != 0) {
                         iGainMismatch =
@@ -279,20 +277,20 @@ static void ar9002_hw_adc_gaincal_calibrate(struct ath_hw *ah, u8 numChains)
                                 ((qOddMeasOffset * 32) /
                                  qEvenMeasOffset) & 0x3f;
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d gain_mismatch_i = 0x%08x\n", i,
-                                  iGainMismatch);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d gain_mismatch_q = 0x%08x\n", i,
-                                  qGainMismatch);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d gain_mismatch_i = 0x%08x\n", i,
+                                iGainMismatch);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d gain_mismatch_q = 0x%08x\n", i,
+                                qGainMismatch);
 
                         val = REG_READ(ah, AR_PHY_NEW_ADC_DC_GAIN_CORR(i));
                         val &= 0xfffff000;
                         val |= (qGainMismatch) | (iGainMismatch << 6);
                         REG_WRITE(ah, AR_PHY_NEW_ADC_DC_GAIN_CORR(i), val);
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "ADC Gain Cal done for Chain %d\n", i);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "ADC Gain Cal done for Chain %d\n", i);
                 }
         }
 
@@ -317,41 +315,41 @@ static void ar9002_hw_adc_dccal_calibrate(struct ath_hw *ah, u8 numChains)
                 qOddMeasOffset = ah->totalAdcDcOffsetQOddPhase[i];
                 qEvenMeasOffset = ah->totalAdcDcOffsetQEvenPhase[i];
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                           "Starting ADC DC Offset Cal for Chain %d\n", i);
-
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_odd_i = %d\n", i,
-                          iOddMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_even_i = %d\n", i,
-                          iEvenMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_odd_q = %d\n", i,
-                          qOddMeasOffset);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_even_q = %d\n", i,
-                          qEvenMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Starting ADC DC Offset Cal for Chain %d\n", i);
+
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_odd_i = %d\n", i,
+                        iOddMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_even_i = %d\n", i,
+                        iEvenMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_odd_q = %d\n", i,
+                        qOddMeasOffset);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_even_q = %d\n", i,
+                        qEvenMeasOffset);
 
                 iDcMismatch = (((iEvenMeasOffset - iOddMeasOffset) * 2) /
                                numSamples) & 0x1ff;
                 qDcMismatch = (((qOddMeasOffset - qEvenMeasOffset) * 2) /
                                numSamples) & 0x1ff;
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d dc_offset_mismatch_i = 0x%08x\n", i,
-                          iDcMismatch);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d dc_offset_mismatch_q = 0x%08x\n", i,
-                          qDcMismatch);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d dc_offset_mismatch_i = 0x%08x\n", i,
+                        iDcMismatch);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d dc_offset_mismatch_q = 0x%08x\n", i,
+                        qDcMismatch);
 
                 val = REG_READ(ah, AR_PHY_NEW_ADC_DC_GAIN_CORR(i));
                 val &= 0xc0000fff;
                 val |= (qDcMismatch << 12) | (iDcMismatch << 21);
                 REG_WRITE(ah, AR_PHY_NEW_ADC_DC_GAIN_CORR(i), val);
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "ADC DC Offset Cal done for Chain %d\n", i);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "ADC DC Offset Cal done for Chain %d\n", i);
         }
 
         REG_WRITE(ah, AR_PHY_NEW_ADC_DC_GAIN_CORR(0),
@@ -540,7 +538,7 @@ static inline void ar9285_hw_pa_cal(struct ath_hw *ah, bool is_reset)
                 { 0x7838, 0 },
         };
 
-        ath_print(common, ATH_DBG_CALIBRATE, "Running PA Calibration\n");
+        ath_dbg(common, ATH_DBG_CALIBRATE, "Running PA Calibration\n");
 
         /* PA CAL is not needed for high power solution */
         if (ah->eep_ops->get_eeprom(ah, EEP_TXGAIN_TYPE) ==
@@ -721,9 +719,8 @@ static bool ar9285_hw_cl_cal(struct ath_hw *ah, struct ath9k_channel *chan)
                 REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL);
                 if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
                                   AR_PHY_AGC_CONTROL_CAL, 0, AH_WAIT_TIMEOUT)) {
-                        ath_print(common, ATH_DBG_CALIBRATE, "offset "
-                                  "calibration failed to complete in "
-                                  "1ms; noisy ??\n");
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "offset calibration failed to complete in 1ms; noisy environment?\n");
                         return false;
                 }
                 REG_CLR_BIT(ah, AR_PHY_TURBO, AR_PHY_FC_DYN2040_EN);
@@ -736,8 +733,8 @@ static bool ar9285_hw_cl_cal(struct ath_hw *ah, struct ath9k_channel *chan)
         REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL);
         if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL,
                           0, AH_WAIT_TIMEOUT)) {
-                ath_print(common, ATH_DBG_CALIBRATE, "offset calibration "
-                          "failed to complete in 1ms; noisy ??\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "offset calibration failed to complete in 1ms; noisy environment?\n");
                 return false;
         }
 
@@ -829,9 +826,8 @@ static bool ar9002_hw_init_cal(struct ath_hw *ah, struct ath9k_channel *chan)
                 if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
                                    AR_PHY_AGC_CONTROL_CAL,
                                    0, AH_WAIT_TIMEOUT)) {
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "offset calibration failed to "
-                                  "complete in 1ms; noisy environment?\n");
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "offset calibration failed to complete in 1ms; noisy environment?\n");
                         return false;
                 }
 
@@ -866,19 +862,19 @@ static bool ar9002_hw_init_cal(struct ath_hw *ah, struct ath9k_channel *chan)
 
                         INIT_CAL(&ah->adcgain_caldata);
                         INSERT_CAL(ah, &ah->adcgain_caldata);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "enabling ADC Gain Calibration.\n");
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "enabling ADC Gain Calibration.\n");
 
                         INIT_CAL(&ah->adcdc_caldata);
                         INSERT_CAL(ah, &ah->adcdc_caldata);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "enabling ADC DC Calibration.\n");
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "enabling ADC DC Calibration.\n");
                 }
 
                 INIT_CAL(&ah->iq_caldata);
                 INSERT_CAL(ah, &ah->iq_caldata);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "enabling IQ Calibration.\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "enabling IQ Calibration.\n");
 
                 ah->cal_list_curr = ah->cal_list;
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_hw.c b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
index 48261b7252d0..7d5cb204f938 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_hw.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
@@ -494,9 +494,9 @@ int ar9002_hw_rf_claim(struct ath_hw *ah)
         case AR_RAD2122_SREV_MAJOR:
                 break;
         default:
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Radio Chip Rev 0x%02X not supported\n",
-                          val & AR_RADIO_SREV_MAJOR);
+                ath_err(ath9k_hw_common(ah),
+                        "Radio Chip Rev 0x%02X not supported\n",
+                        val & AR_RADIO_SREV_MAJOR);
                 return -EOPNOTSUPP;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_mac.c b/drivers/net/wireless/ath/ath9k/ar9002_mac.c
index f0268e5eab34..f3f9c589158e 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_mac.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_mac.c
@@ -111,8 +111,8 @@ static bool ar9002_hw_get_isr(struct ath_hw *ah, enum ath9k_int *masked)
                 }
 
                 if (isr & AR_ISR_RXORN) {
-                        ath_print(common, ATH_DBG_INTERRUPT,
-                                  "receive FIFO overrun interrupt\n");
+                        ath_dbg(common, ATH_DBG_INTERRUPT,
+                                "receive FIFO overrun interrupt\n");
                 }
 
                 *masked |= mask2;
@@ -147,25 +147,25 @@ static bool ar9002_hw_get_isr(struct ath_hw *ah, enum ath9k_int *masked)
 
                 if (fatal_int) {
                         if (sync_cause & AR_INTR_SYNC_HOST1_FATAL) {
-                                ath_print(common, ATH_DBG_ANY,
-                                          "received PCI FATAL interrupt\n");
+                                ath_dbg(common, ATH_DBG_ANY,
+                                        "received PCI FATAL interrupt\n");
                         }
                         if (sync_cause & AR_INTR_SYNC_HOST1_PERR) {
-                                ath_print(common, ATH_DBG_ANY,
-                                          "received PCI PERR interrupt\n");
+                                ath_dbg(common, ATH_DBG_ANY,
+                                        "received PCI PERR interrupt\n");
                         }
                         *masked |= ATH9K_INT_FATAL;
                 }
                 if (sync_cause & AR_INTR_SYNC_RADM_CPL_TIMEOUT) {
-                        ath_print(common, ATH_DBG_INTERRUPT,
-                                  "AR_INTR_SYNC_RADM_CPL_TIMEOUT\n");
+                        ath_dbg(common, ATH_DBG_INTERRUPT,
+                                "AR_INTR_SYNC_RADM_CPL_TIMEOUT\n");
                         REG_WRITE(ah, AR_RC, AR_RC_HOSTIF);
                         REG_WRITE(ah, AR_RC, 0);
                         *masked |= ATH9K_INT_FATAL;
                 }
                 if (sync_cause & AR_INTR_SYNC_LOCAL_TIMEOUT) {
-                        ath_print(common, ATH_DBG_INTERRUPT,
-                                  "AR_INTR_SYNC_LOCAL_TIMEOUT\n");
+                        ath_dbg(common, ATH_DBG_INTERRUPT,
+                                "AR_INTR_SYNC_LOCAL_TIMEOUT\n");
                 }
 
                 REG_WRITE(ah, AR_INTR_SYNC_CAUSE_CLR, sync_cause);
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_calib.c b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
index 4c94c9ed5f81..7c3334bd396e 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
@@ -18,6 +18,16 @@
 #include "hw-ops.h"
 #include "ar9003_phy.h"
 
+#define MPASS   3
+#define MAX_MEASUREMENT 8
+#define MAX_DIFFERENCE  10
+
+struct coeff {
+        int mag_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT][MPASS];
+        int phs_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT][MPASS];
+        int iqc_coeff[2];
+};
+
 enum ar9003_cal_types {
         IQ_MISMATCH_CAL = BIT(0),
         TEMP_COMP_CAL = BIT(1),
@@ -40,8 +50,8 @@ static void ar9003_hw_setup_calibration(struct ath_hw *ah,
                 currCal->calData->calCountMax);
                 REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_IQ);
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "starting IQ Mismatch Calibration\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "starting IQ Mismatch Calibration\n");
 
                 /* Kick-off cal */
                 REG_SET_BIT(ah, AR_PHY_TIMING4, AR_PHY_TIMING4_DO_CAL);
@@ -52,8 +62,8 @@ static void ar9003_hw_setup_calibration(struct ath_hw *ah,
                 REG_RMW_FIELD(ah, AR_PHY_65NM_CH0_THERM,
                               AR_PHY_65NM_CH0_THERM_START, 1);
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "starting Temperature Compensation Calibration\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "starting Temperature Compensation Calibration\n");
                 break;
         }
 }
@@ -181,11 +191,11 @@ static void ar9003_hw_iqcal_collect(struct ath_hw *ah)
                         REG_READ(ah, AR_PHY_CAL_MEAS_1(i));
                 ah->totalIqCorrMeas[i] +=
                         (int32_t) REG_READ(ah, AR_PHY_CAL_MEAS_2(i));
-                ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
-                          "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
-                          ah->cal_samples, i, ah->totalPowerMeasI[i],
-                          ah->totalPowerMeasQ[i],
-                          ah->totalIqCorrMeas[i]);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
+                        "%d: Chn %d pmi=0x%08x;pmq=0x%08x;iqcm=0x%08x;\n",
+                        ah->cal_samples, i, ah->totalPowerMeasI[i],
+                        ah->totalPowerMeasQ[i],
+                        ah->totalIqCorrMeas[i]);
         }
 }
 
@@ -207,13 +217,13 @@ static void ar9003_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                 powerMeasQ = ah->totalPowerMeasQ[i];
                 iqCorrMeas = ah->totalIqCorrMeas[i];
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Starting IQ Cal and Correction for Chain %d\n",
-                          i);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Starting IQ Cal and Correction for Chain %d\n",
+                        i);
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Orignal: Chn %diq_corr_meas = 0x%08x\n",
-                          i, ah->totalIqCorrMeas[i]);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Orignal: Chn %diq_corr_meas = 0x%08x\n",
+                        i, ah->totalIqCorrMeas[i]);
 
                 iqCorrNeg = 0;
 
@@ -222,12 +232,12 @@ static void ar9003_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         iqCorrNeg = 1;
                 }
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_i = 0x%08x\n", i, powerMeasI);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Chn %d pwr_meas_q = 0x%08x\n", i, powerMeasQ);
-                ath_print(common, ATH_DBG_CALIBRATE, "iqCorrNeg is 0x%08x\n",
-                          iqCorrNeg);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_i = 0x%08x\n", i, powerMeasI);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Chn %d pwr_meas_q = 0x%08x\n", i, powerMeasQ);
+                ath_dbg(common, ATH_DBG_CALIBRATE, "iqCorrNeg is 0x%08x\n",
+                        iqCorrNeg);
 
                 iCoffDenom = (powerMeasI / 2 + powerMeasQ / 2) / 256;
                 qCoffDenom = powerMeasQ / 64;
@@ -235,10 +245,10 @@ static void ar9003_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                 if ((iCoffDenom != 0) && (qCoffDenom != 0)) {
                         iCoff = iqCorrMeas / iCoffDenom;
                         qCoff = powerMeasI / qCoffDenom - 64;
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d iCoff = 0x%08x\n", i, iCoff);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d qCoff = 0x%08x\n", i, qCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d iCoff = 0x%08x\n", i, iCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d qCoff = 0x%08x\n", i, qCoff);
 
                         /* Force bounds on iCoff */
                         if (iCoff >= 63)
@@ -259,14 +269,13 @@ static void ar9003_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         iCoff = iCoff & 0x7f;
                         qCoff = qCoff & 0x7f;
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Chn %d : iCoff = 0x%x  qCoff = 0x%x\n",
-                                  i, iCoff, qCoff);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Register offset (0x%04x) "
-                                  "before update = 0x%x\n",
-                                  offset_array[i],
-                                  REG_READ(ah, offset_array[i]));
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Chn %d : iCoff = 0x%x  qCoff = 0x%x\n",
+                                i, iCoff, qCoff);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Register offset (0x%04x) before update = 0x%x\n",
+                                offset_array[i],
+                                REG_READ(ah, offset_array[i]));
 
                         REG_RMW_FIELD(ah, offset_array[i],
                                       AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF,
@@ -274,33 +283,29 @@ static void ar9003_hw_iqcalibrate(struct ath_hw *ah, u8 numChains)
                         REG_RMW_FIELD(ah, offset_array[i],
                                       AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF,
                                       qCoff);
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Register offset (0x%04x) QI COFF "
-                                  "(bitfields 0x%08x) after update = 0x%x\n",
-                                  offset_array[i],
-                                  AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF,
-                                  REG_READ(ah, offset_array[i]));
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Register offset (0x%04x) QQ COFF "
-                                  "(bitfields 0x%08x) after update = 0x%x\n",
-                                  offset_array[i],
-                                  AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF,
-                                  REG_READ(ah, offset_array[i]));
-
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "IQ Cal and Correction done for Chain %d\n",
-                                  i);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Register offset (0x%04x) QI COFF (bitfields 0x%08x) after update = 0x%x\n",
+                                offset_array[i],
+                                AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF,
+                                REG_READ(ah, offset_array[i]));
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Register offset (0x%04x) QQ COFF (bitfields 0x%08x) after update = 0x%x\n",
+                                offset_array[i],
+                                AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF,
+                                REG_READ(ah, offset_array[i]));
+
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "IQ Cal and Correction done for Chain %d\n", i);
                 }
         }
 
         REG_SET_BIT(ah, AR_PHY_RX_IQCAL_CORR_B0,
                     AR_PHY_RX_IQCAL_CORR_IQCORR_ENABLE);
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "IQ Cal and Correction (offset 0x%04x) enabled "
-                  "(bit position 0x%08x). New Value 0x%08x\n",
-                  (unsigned) (AR_PHY_RX_IQCAL_CORR_B0),
-                  AR_PHY_RX_IQCAL_CORR_IQCORR_ENABLE,
-                  REG_READ(ah, AR_PHY_RX_IQCAL_CORR_B0));
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "IQ Cal and Correction (offset 0x%04x) enabled (bit position 0x%08x). New Value 0x%08x\n",
+                (unsigned) (AR_PHY_RX_IQCAL_CORR_B0),
+                AR_PHY_RX_IQCAL_CORR_IQCORR_ENABLE,
+                REG_READ(ah, AR_PHY_RX_IQCAL_CORR_B0));
 }
 
 static const struct ath9k_percal_data iq_cal_single_sample = {
@@ -340,7 +345,7 @@ static bool ar9003_hw_solve_iq_cal(struct ath_hw *ah,
         f2 = (f1 * f1 + f3 * f3) / result_shift;
 
         if (!f2) {
-                ath_print(common, ATH_DBG_CALIBRATE, "Divide by 0\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE, "Divide by 0\n");
                 return false;
         }
 
@@ -461,11 +466,14 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
 
         if ((i2_p_q2_a0_d0 == 0) || (i2_p_q2_a0_d1 == 0) ||
             (i2_p_q2_a1_d0 == 0) || (i2_p_q2_a1_d1 == 0)) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Divide by 0:\na0_d0=%d\n"
-                          "a0_d1=%d\na2_d0=%d\na1_d1=%d\n",
-                          i2_p_q2_a0_d0, i2_p_q2_a0_d1,
-                          i2_p_q2_a1_d0, i2_p_q2_a1_d1);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Divide by 0:\n"
+                        "a0_d0=%d\n"
+                        "a0_d1=%d\n"
+                        "a2_d0=%d\n"
+                        "a1_d1=%d\n",
+                        i2_p_q2_a0_d0, i2_p_q2_a0_d1,
+                        i2_p_q2_a1_d0, i2_p_q2_a1_d1);
                 return false;
         }
 
@@ -498,9 +506,9 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
         mag2 = ar9003_hw_find_mag_approx(ah, cos_2phi_2, sin_2phi_2);
 
         if ((mag1 == 0) || (mag2 == 0)) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Divide by 0: mag1=%d, mag2=%d\n",
-                          mag1, mag2);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Divide by 0: mag1=%d, mag2=%d\n",
+                        mag1, mag2);
                 return false;
         }
 
@@ -517,8 +525,8 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
                              mag_a0_d0, phs_a0_d0,
                              mag_a1_d0,
                              phs_a1_d0, solved_eq)) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Call to ar9003_hw_solve_iq_cal() failed.\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Call to ar9003_hw_solve_iq_cal() failed.\n");
                 return false;
         }
 
@@ -527,14 +535,14 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
         mag_rx = solved_eq[2];
         phs_rx = solved_eq[3];
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "chain %d: mag mismatch=%d phase mismatch=%d\n",
-                  chain_idx, mag_tx/res_scale, phs_tx/res_scale);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "chain %d: mag mismatch=%d phase mismatch=%d\n",
+                chain_idx, mag_tx/res_scale, phs_tx/res_scale);
 
         if (res_scale == mag_tx) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Divide by 0: mag_tx=%d, res_scale=%d\n",
-                          mag_tx, res_scale);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Divide by 0: mag_tx=%d, res_scale=%d\n",
+                        mag_tx, res_scale);
                 return false;
         }
 
@@ -545,9 +553,9 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
         q_q_coff = (mag_corr_tx * 128 / res_scale);
         q_i_coff = (phs_corr_tx * 256 / res_scale);
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "tx chain %d: mag corr=%d  phase corr=%d\n",
-                  chain_idx, q_q_coff, q_i_coff);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "tx chain %d: mag corr=%d  phase corr=%d\n",
+                chain_idx, q_q_coff, q_i_coff);
 
         if (q_i_coff < -63)
                 q_i_coff = -63;
@@ -560,14 +568,14 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
 
         iqc_coeff[0] = (q_q_coff * 128) + q_i_coff;
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "tx chain %d: iq corr coeff=%x\n",
-                  chain_idx, iqc_coeff[0]);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "tx chain %d: iq corr coeff=%x\n",
+                chain_idx, iqc_coeff[0]);
 
         if (-mag_rx == res_scale) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Divide by 0: mag_rx=%d, res_scale=%d\n",
-                          mag_rx, res_scale);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Divide by 0: mag_rx=%d, res_scale=%d\n",
+                        mag_rx, res_scale);
                 return false;
         }
 
@@ -578,9 +586,9 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
         q_q_coff = (mag_corr_rx * 128 / res_scale);
         q_i_coff = (phs_corr_rx * 256 / res_scale);
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "rx chain %d: mag corr=%d  phase corr=%d\n",
-                  chain_idx, q_q_coff, q_i_coff);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "rx chain %d: mag corr=%d  phase corr=%d\n",
+                chain_idx, q_q_coff, q_i_coff);
 
         if (q_i_coff < -63)
                 q_i_coff = -63;
@@ -593,9 +601,9 @@ static bool ar9003_hw_calc_iq_corr(struct ath_hw *ah,
 
         iqc_coeff[1] = (q_q_coff * 128) + q_i_coff;
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "rx chain %d: iq corr coeff=%x\n",
-                  chain_idx, iqc_coeff[1]);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "rx chain %d: iq corr coeff=%x\n",
+                chain_idx, iqc_coeff[1]);
 
         return true;
 }
@@ -608,11 +616,6 @@ static void ar9003_hw_tx_iq_cal(struct ath_hw *ah)
                 AR_PHY_TX_IQCAL_STATUS_B1,
                 AR_PHY_TX_IQCAL_STATUS_B2,
         };
-        static const u32 tx_corr_coeff[AR9300_MAX_CHAINS] = {
-                AR_PHY_TX_IQCAL_CORR_COEFF_01_B0,
-                AR_PHY_TX_IQCAL_CORR_COEFF_01_B1,
-                AR_PHY_TX_IQCAL_CORR_COEFF_01_B2,
-        };
         static const u32 rx_corr[AR9300_MAX_CHAINS] = {
                 AR_PHY_RX_IQCAL_CORR_B0,
                 AR_PHY_RX_IQCAL_CORR_B1,
@@ -623,11 +626,16 @@ static void ar9003_hw_tx_iq_cal(struct ath_hw *ah)
                 AR_PHY_CHAN_INFO_TAB_1,
                 AR_PHY_CHAN_INFO_TAB_2,
         };
+        u32 tx_corr_coeff[AR9300_MAX_CHAINS];
         s32 iq_res[6];
         s32 iqc_coeff[2];
         s32 i, j;
         u32 num_chains = 0;
 
+        tx_corr_coeff[0] = AR_PHY_TX_IQCAL_CORR_COEFF_B0(0);
+        tx_corr_coeff[1] = AR_PHY_TX_IQCAL_CORR_COEFF_B1(0);
+        tx_corr_coeff[2] = AR_PHY_TX_IQCAL_CORR_COEFF_B2(0);
+
         for (i = 0; i < AR9300_MAX_CHAINS; i++) {
                 if (ah->txchainmask & (1 << i))
                         num_chains++;
@@ -643,19 +651,19 @@ static void ar9003_hw_tx_iq_cal(struct ath_hw *ah)
         if (!ath9k_hw_wait(ah, AR_PHY_TX_IQCAL_START,
                            AR_PHY_TX_IQCAL_START_DO_CAL,
                            0, AH_WAIT_TIMEOUT)) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Tx IQ Cal not complete.\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Tx IQ Cal not complete.\n");
                 goto TX_IQ_CAL_FAILED;
         }
 
         for (i = 0; i < num_chains; i++) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Doing Tx IQ Cal for chain %d.\n", i);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Doing Tx IQ Cal for chain %d.\n", i);
 
                 if (REG_READ(ah, txiqcal_status[i]) &
                              AR_PHY_TX_IQCAL_STATUS_FAILED) {
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Tx IQ Cal failed for chain %d.\n", i);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Tx IQ Cal failed for chain %d.\n", i);
                         goto TX_IQ_CAL_FAILED;
                 }
 
@@ -677,20 +685,20 @@ static void ar9003_hw_tx_iq_cal(struct ath_hw *ah)
                                                           chan_info_tab[i] +
                                                           offset);
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "IQ RES[%d]=0x%x IQ_RES[%d]=0x%x\n",
-                                  idx, iq_res[idx], idx+1, iq_res[idx+1]);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "IQ RES[%d]=0x%x IQ_RES[%d]=0x%x\n",
+                                idx, iq_res[idx], idx+1, iq_res[idx+1]);
                 }
 
                 if (!ar9003_hw_calc_iq_corr(ah, i, iq_res, iqc_coeff)) {
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "Failed in calculation of IQ correction.\n");
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "Failed in calculation of IQ correction.\n");
                         goto TX_IQ_CAL_FAILED;
                 }
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "IQ_COEFF[0] = 0x%x IQ_COEFF[1] = 0x%x\n",
-                          iqc_coeff[0], iqc_coeff[1]);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "IQ_COEFF[0] = 0x%x IQ_COEFF[1] = 0x%x\n",
+                        iqc_coeff[0], iqc_coeff[1]);
 
                 REG_RMW_FIELD(ah, tx_corr_coeff[i],
                               AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE,
@@ -711,9 +719,232 @@ static void ar9003_hw_tx_iq_cal(struct ath_hw *ah)
         return;
 
 TX_IQ_CAL_FAILED:
-        ath_print(common, ATH_DBG_CALIBRATE, "Tx IQ Cal failed\n");
+        ath_dbg(common, ATH_DBG_CALIBRATE, "Tx IQ Cal failed\n");
+}
+
+static bool ar9003_hw_compute_closest_pass_and_avg(int *mp_coeff, int *mp_avg)
+{
+        int diff[MPASS];
+
+        diff[0] = abs(mp_coeff[0] - mp_coeff[1]);
+        diff[1] = abs(mp_coeff[1] - mp_coeff[2]);
+        diff[2] = abs(mp_coeff[2] - mp_coeff[0]);
+
+        if (diff[0] > MAX_MEASUREMENT &&
+            diff[1] > MAX_MEASUREMENT &&
+            diff[2] > MAX_MEASUREMENT)
+                return false;
+
+        if (diff[0] <= diff[1] && diff[0] <= diff[2])
+                *mp_avg = (mp_coeff[0] + mp_coeff[1]) / 2;
+        else if (diff[1] <= diff[2])
+                *mp_avg = (mp_coeff[1] + mp_coeff[2]) / 2;
+        else
+                *mp_avg = (mp_coeff[2] + mp_coeff[0]) / 2;
+
+        return true;
 }
 
+static void ar9003_hw_tx_iqcal_load_avg_2_passes(struct ath_hw *ah,
+                                                 u8 num_chains,
+                                                 struct coeff *coeff)
+{
+        struct ath_common *common = ath9k_hw_common(ah);
+        int i, im, nmeasurement;
+        int magnitude, phase;
+        u32 tx_corr_coeff[MAX_MEASUREMENT][AR9300_MAX_CHAINS];
+
+        memset(tx_corr_coeff, 0, sizeof(tx_corr_coeff));
+        for (i = 0; i < MAX_MEASUREMENT / 2; i++) {
+                tx_corr_coeff[i * 2][0] = tx_corr_coeff[(i * 2) + 1][0] =
+                                        AR_PHY_TX_IQCAL_CORR_COEFF_B0(i);
+                if (!AR_SREV_9485(ah)) {
+                        tx_corr_coeff[i * 2][1] =
+                        tx_corr_coeff[(i * 2) + 1][1] =
+                                        AR_PHY_TX_IQCAL_CORR_COEFF_B1(i);
+
+                        tx_corr_coeff[i * 2][2] =
+                        tx_corr_coeff[(i * 2) + 1][2] =
+                                        AR_PHY_TX_IQCAL_CORR_COEFF_B2(i);
+                }
+        }
+
+        /* Load the average of 2 passes */
+        for (i = 0; i < num_chains; i++) {
+                if (AR_SREV_9485(ah))
+                        nmeasurement = REG_READ_FIELD(ah,
+                                        AR_PHY_TX_IQCAL_STATUS_B0_9485,
+                                        AR_PHY_CALIBRATED_GAINS_0);
+                else
+                        nmeasurement = REG_READ_FIELD(ah,
+                                        AR_PHY_TX_IQCAL_STATUS_B0,
+                                        AR_PHY_CALIBRATED_GAINS_0);
+
+                if (nmeasurement > MAX_MEASUREMENT)
+                        nmeasurement = MAX_MEASUREMENT;
+
+                for (im = 0; im < nmeasurement; im++) {
+                        /*
+                         * Determine which 2 passes are closest and compute avg
+                         * magnitude
+                         */
+                        if (!ar9003_hw_compute_closest_pass_and_avg(coeff->mag_coeff[i][im],
+                                                                    &magnitude))
+                                goto disable_txiqcal;
+
+                        /*
+                         * Determine which 2 passes are closest and compute avg
+                         * phase
+                         */
+                        if (!ar9003_hw_compute_closest_pass_and_avg(coeff->phs_coeff[i][im],
+                                                                    &phase))
+                                goto disable_txiqcal;
+
+                        coeff->iqc_coeff[0] = (magnitude & 0x7f) |
+                                              ((phase & 0x7f) << 7);
+
+                        if ((im % 2) == 0)
+                                REG_RMW_FIELD(ah, tx_corr_coeff[im][i],
+                                        AR_PHY_TX_IQCAL_CORR_COEFF_00_COEFF_TABLE,
+                                        coeff->iqc_coeff[0]);
+                        else
+                                REG_RMW_FIELD(ah, tx_corr_coeff[im][i],
+                                        AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE,
+                                        coeff->iqc_coeff[0]);
+                }
+        }
+
+        REG_RMW_FIELD(ah, AR_PHY_TX_IQCAL_CONTROL_3,
+                      AR_PHY_TX_IQCAL_CONTROL_3_IQCORR_EN, 0x1);
+        REG_RMW_FIELD(ah, AR_PHY_RX_IQCAL_CORR_B0,
+                      AR_PHY_RX_IQCAL_CORR_B0_LOOPBACK_IQCORR_EN, 0x1);
+
+        return;
+
+disable_txiqcal:
+        REG_RMW_FIELD(ah, AR_PHY_TX_IQCAL_CONTROL_3,
+                      AR_PHY_TX_IQCAL_CONTROL_3_IQCORR_EN, 0x0);
+        REG_RMW_FIELD(ah, AR_PHY_RX_IQCAL_CORR_B0,
+                      AR_PHY_RX_IQCAL_CORR_B0_LOOPBACK_IQCORR_EN, 0x0);
+
+        ath_dbg(common, ATH_DBG_CALIBRATE, "TX IQ Cal disabled\n");
+}
+
+static void ar9003_hw_tx_iq_cal_run(struct ath_hw *ah)
+{
+        u8 tx_gain_forced;
+
+        REG_RMW_FIELD(ah, AR_PHY_TX_IQCAL_CONTROL_1_9485,
+                      AR_PHY_TX_IQCAQL_CONTROL_1_IQCORR_I_Q_COFF_DELPT, DELPT);
+        tx_gain_forced = REG_READ_FIELD(ah, AR_PHY_TX_FORCED_GAIN,
+                                        AR_PHY_TXGAIN_FORCE);
+        if (tx_gain_forced)
+                REG_RMW_FIELD(ah, AR_PHY_TX_FORCED_GAIN,
+                              AR_PHY_TXGAIN_FORCE, 0);
+
+        REG_RMW_FIELD(ah, AR_PHY_TX_IQCAL_START_9485,
+                      AR_PHY_TX_IQCAL_START_DO_CAL_9485, 1);
+}
+
+static void ar9003_hw_tx_iq_cal_post_proc(struct ath_hw *ah)
+{
+        struct ath_common *common = ath9k_hw_common(ah);
+        const u32 txiqcal_status[AR9300_MAX_CHAINS] = {
+                AR_PHY_TX_IQCAL_STATUS_B0_9485,
+                AR_PHY_TX_IQCAL_STATUS_B1,
+                AR_PHY_TX_IQCAL_STATUS_B2,
+        };
+        const u_int32_t chan_info_tab[] = {
+                AR_PHY_CHAN_INFO_TAB_0,
+                AR_PHY_CHAN_INFO_TAB_1,
+                AR_PHY_CHAN_INFO_TAB_2,
+        };
+        struct coeff coeff;
+        s32 iq_res[6];
+        u8 num_chains = 0;
+        int i, ip, im, j;
+        int nmeasurement;
+
+        for (i = 0; i < AR9300_MAX_CHAINS; i++) {
+                if (ah->txchainmask & (1 << i))
+                        num_chains++;
+        }
+
+        for (ip = 0; ip < MPASS; ip++) {
+                for (i = 0; i < num_chains; i++) {
+                        nmeasurement = REG_READ_FIELD(ah,
+                                        AR_PHY_TX_IQCAL_STATUS_B0_9485,
+                                        AR_PHY_CALIBRATED_GAINS_0);
+                        if (nmeasurement > MAX_MEASUREMENT)
+                                nmeasurement = MAX_MEASUREMENT;
+
+                        for (im = 0; im < nmeasurement; im++) {
+                                ath_dbg(common, ATH_DBG_CALIBRATE,
+                                        "Doing Tx IQ Cal for chain %d.\n", i);
+
+                                if (REG_READ(ah, txiqcal_status[i]) &
+                                    AR_PHY_TX_IQCAL_STATUS_FAILED) {
+                                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                        "Tx IQ Cal failed for chain %d.\n", i);
+                                        goto tx_iqcal_fail;
+                                }
+
+                                for (j = 0; j < 3; j++) {
+                                        u32 idx = 2 * j, offset = 4 * (3 * im + j);
+
+                                        REG_RMW_FIELD(ah,
+                                                AR_PHY_CHAN_INFO_MEMORY,
+                                                AR_PHY_CHAN_INFO_TAB_S2_READ,
+                                                0);
+
+                                        /* 32 bits */
+                                        iq_res[idx] = REG_READ(ah,
+                                                        chan_info_tab[i] +
+                                                        offset);
+
+                                        REG_RMW_FIELD(ah,
+                                                AR_PHY_CHAN_INFO_MEMORY,
+                                                AR_PHY_CHAN_INFO_TAB_S2_READ,
+                                                1);
+
+                                        /* 16 bits */
+                                        iq_res[idx + 1] = 0xffff & REG_READ(ah,
+                                                          chan_info_tab[i] + offset);
+
+                                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                                "IQ RES[%d]=0x%x"
+                                                "IQ_RES[%d]=0x%x\n",
+                                                idx, iq_res[idx], idx + 1,
+                                                iq_res[idx + 1]);
+                                }
+
+                                if (!ar9003_hw_calc_iq_corr(ah, i, iq_res,
+                                                            coeff.iqc_coeff)) {
+                                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                         "Failed in calculation of IQ correction.\n");
+                                        goto tx_iqcal_fail;
+                                }
+
+                                coeff.mag_coeff[i][im][ip] =
+                                                coeff.iqc_coeff[0] & 0x7f;
+                                coeff.phs_coeff[i][im][ip] =
+                                                (coeff.iqc_coeff[0] >> 7) & 0x7f;
+
+                                if (coeff.mag_coeff[i][im][ip] > 63)
+                                        coeff.mag_coeff[i][im][ip] -= 128;
+                                if (coeff.phs_coeff[i][im][ip] > 63)
+                                        coeff.phs_coeff[i][im][ip] -= 128;
+                        }
+                }
+        }
+        ar9003_hw_tx_iqcal_load_avg_2_passes(ah, num_chains, &coeff);
+
+        return;
+
+tx_iqcal_fail:
+        ath_dbg(common, ATH_DBG_CALIBRATE, "Tx IQ Cal failed\n");
+        return;
+}
 static bool ar9003_hw_init_cal(struct ath_hw *ah,
                                struct ath9k_channel *chan)
 {
@@ -721,9 +952,11 @@ static bool ar9003_hw_init_cal(struct ath_hw *ah,
         int val;
 
         val = REG_READ(ah, AR_ENT_OTP);
-        ath_print(common, ATH_DBG_CALIBRATE, "ath9k: AR_ENT_OTP 0x%x\n", val);
+        ath_dbg(common, ATH_DBG_CALIBRATE, "ath9k: AR_ENT_OTP 0x%x\n", val);
 
-        if (val & AR_ENT_OTP_CHAIN2_DISABLE)
+        if (AR_SREV_9485(ah))
+                ar9003_hw_set_chain_masks(ah, 0x1, 0x1);
+        else if (val & AR_ENT_OTP_CHAIN2_DISABLE)
                 ar9003_hw_set_chain_masks(ah, 0x3, 0x3);
         else
                 /*
@@ -733,7 +966,11 @@ static bool ar9003_hw_init_cal(struct ath_hw *ah,
                 ar9003_hw_set_chain_masks(ah, 0x7, 0x7);
 
         /* Do Tx IQ Calibration */
-        ar9003_hw_tx_iq_cal(ah);
+        if (AR_SREV_9485(ah))
+                ar9003_hw_tx_iq_cal_run(ah);
+        else
+                ar9003_hw_tx_iq_cal(ah);
+
         REG_WRITE(ah, AR_PHY_ACTIVE, AR_PHY_ACTIVE_DIS);
         udelay(5);
         REG_WRITE(ah, AR_PHY_ACTIVE, AR_PHY_ACTIVE_EN);
@@ -746,12 +983,14 @@ static bool ar9003_hw_init_cal(struct ath_hw *ah,
         /* Poll for offset calibration complete */
         if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL,
                            0, AH_WAIT_TIMEOUT)) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "offset calibration failed to "
-                          "complete in 1ms; noisy environment?\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "offset calibration failed to complete in 1ms; noisy environment?\n");
                 return false;
         }
 
+        if (AR_SREV_9485(ah))
+                ar9003_hw_tx_iq_cal_post_proc(ah);
+
         /* Revert chainmasks to their original values before NF cal */
         ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask);
 
@@ -764,15 +1003,15 @@ static bool ar9003_hw_init_cal(struct ath_hw *ah,
         if (ah->supp_cals & IQ_MISMATCH_CAL) {
                 INIT_CAL(&ah->iq_caldata);
                 INSERT_CAL(ah, &ah->iq_caldata);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "enabling IQ Calibration.\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "enabling IQ Calibration.\n");
         }
 
         if (ah->supp_cals & TEMP_COMP_CAL) {
                 INIT_CAL(&ah->tempCompCalData);
                 INSERT_CAL(ah, &ah->tempCompCalData);
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "enabling Temperature Compensation Calibration.\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "enabling Temperature Compensation Calibration.\n");
         }
 
         /* Initialize current pointer to first element in list */
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
index 73a8014cacb2..a16b3dae5b34 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
@@ -3035,6 +3035,8 @@ static u32 ath9k_hw_ar9300_get_eeprom(struct ath_hw *ah,
                 return !!(pBase->featureEnable & BIT(5));
         case EEP_CHAIN_MASK_REDUCE:
                 return (pBase->miscConfiguration >> 0x3) & 0x1;
+        case EEP_ANT_DIV_CTL1:
+                return le32_to_cpu(eep->base_ext1.ant_div_control);
         default:
                 return 0;
         }
@@ -3073,8 +3075,8 @@ static bool ar9300_read_eeprom(struct ath_hw *ah, int address, u8 *buffer,
         int i;
 
         if ((address < 0) || ((address + count) / 2 > AR9300_EEPROM_SIZE - 1)) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "eeprom address not in range\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "eeprom address not in range\n");
                 return false;
         }
 
@@ -3105,8 +3107,8 @@ static bool ar9300_read_eeprom(struct ath_hw *ah, int address, u8 *buffer,
         return true;
 
 error:
-        ath_print(common, ATH_DBG_EEPROM,
-                  "unable to read eeprom region at offset %d\n", address);
+        ath_dbg(common, ATH_DBG_EEPROM,
+                "unable to read eeprom region at offset %d\n", address);
         return false;
 }
 
@@ -3190,17 +3192,15 @@ static bool ar9300_uncompress_block(struct ath_hw *ah,
                 length &= 0xff;
 
                 if (length > 0 && spot >= 0 && spot+length <= mdataSize) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Restore at %d: spot=%d "
-                                  "offset=%d length=%d\n",
-                                   it, spot, offset, length);
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Restore at %d: spot=%d offset=%d length=%d\n",
+                                it, spot, offset, length);
                         memcpy(&mptr[spot], &block[it+2], length);
                         spot += length;
                 } else if (length > 0) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Bad restore at %d: spot=%d "
-                                  "offset=%d length=%d\n",
-                                  it, spot, offset, length);
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Bad restore at %d: spot=%d offset=%d length=%d\n",
+                                it, spot, offset, length);
                         return false;
                 }
         }
@@ -3221,14 +3221,15 @@ static int ar9300_compress_decision(struct ath_hw *ah,
         switch (code) {
         case _CompressNone:
                 if (length != mdata_size) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "EEPROM structure size mismatch"
-                                  "memory=%d eeprom=%d\n", mdata_size, length);
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "EEPROM structure size mismatch memory=%d eeprom=%d\n",
+                                mdata_size, length);
                         return -1;
                 }
                 memcpy(mptr, (u8 *) (word + COMP_HDR_LEN), length);
-                ath_print(common, ATH_DBG_EEPROM, "restored eeprom %d:"
-                          " uncompressed, length %d\n", it, length);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "restored eeprom %d: uncompressed, length %d\n",
+                        it, length);
                 break;
         case _CompressBlock:
                 if (reference == 0) {
@@ -3236,22 +3237,22 @@ static int ar9300_compress_decision(struct ath_hw *ah,
                 } else {
                         eep = ar9003_eeprom_struct_find_by_id(reference);
                         if (eep == NULL) {
-                                ath_print(common, ATH_DBG_EEPROM,
-                                          "cant find reference eeprom"
-                                          "struct %d\n", reference);
+                                ath_dbg(common, ATH_DBG_EEPROM,
+                                        "cant find reference eeprom struct %d\n",
+                                        reference);
                                 return -1;
                         }
                         memcpy(mptr, eep, mdata_size);
                 }
-                ath_print(common, ATH_DBG_EEPROM,
-                          "restore eeprom %d: block, reference %d,"
-                          " length %d\n", it, reference, length);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "restore eeprom %d: block, reference %d, length %d\n",
+                        it, reference, length);
                 ar9300_uncompress_block(ah, mptr, mdata_size,
                                         (u8 *) (word + COMP_HDR_LEN), length);
                 break;
         default:
-                ath_print(common, ATH_DBG_EEPROM, "unknown compression"
-                          " code %d\n", code);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "unknown compression code %d\n", code);
                 return -1;
         }
         return 0;
@@ -3321,27 +3322,30 @@ static int ar9300_eeprom_restore_internal(struct ath_hw *ah,
         memcpy(mptr, &ar9300_default, mdata_size);
 
         read = ar9300_read_eeprom;
-        cptr = AR9300_BASE_ADDR;
-        ath_print(common, ATH_DBG_EEPROM,
+        if (AR_SREV_9485(ah))
+                cptr = AR9300_BASE_ADDR_4K;
+        else
+                cptr = AR9300_BASE_ADDR;
+        ath_dbg(common, ATH_DBG_EEPROM,
                 "Trying EEPROM accesss at Address 0x%04x\n", cptr);
         if (ar9300_check_eeprom_header(ah, read, cptr))
                 goto found;
 
         cptr = AR9300_BASE_ADDR_512;
-        ath_print(common, ATH_DBG_EEPROM,
+        ath_dbg(common, ATH_DBG_EEPROM,
                 "Trying EEPROM accesss at Address 0x%04x\n", cptr);
         if (ar9300_check_eeprom_header(ah, read, cptr))
                 goto found;
 
         read = ar9300_read_otp;
         cptr = AR9300_BASE_ADDR;
-        ath_print(common, ATH_DBG_EEPROM,
+        ath_dbg(common, ATH_DBG_EEPROM,
                 "Trying OTP accesss at Address 0x%04x\n", cptr);
         if (ar9300_check_eeprom_header(ah, read, cptr))
                 goto found;
 
         cptr = AR9300_BASE_ADDR_512;
-        ath_print(common, ATH_DBG_EEPROM,
+        ath_dbg(common, ATH_DBG_EEPROM,
                 "Trying OTP accesss at Address 0x%04x\n", cptr);
         if (ar9300_check_eeprom_header(ah, read, cptr))
                 goto found;
@@ -3349,7 +3353,7 @@ static int ar9300_eeprom_restore_internal(struct ath_hw *ah,
         goto fail;
 
 found:
-        ath_print(common, ATH_DBG_EEPROM, "Found valid EEPROM data");
+        ath_dbg(common, ATH_DBG_EEPROM, "Found valid EEPROM data\n");
 
         for (it = 0; it < MSTATE; it++) {
                 if (!read(ah, cptr, word, COMP_HDR_LEN))
@@ -3360,13 +3364,13 @@ found:
 
                 ar9300_comp_hdr_unpack(word, &code, &reference,
                                        &length, &major, &minor);
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Found block at %x: code=%d ref=%d"
-                          "length=%d major=%d minor=%d\n", cptr, code,
-                          reference, length, major, minor);
-                if (length >= 1024) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Skipping bad header\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Found block at %x: code=%d ref=%d length=%d major=%d minor=%d\n",
+                        cptr, code, reference, length, major, minor);
+                if ((!AR_SREV_9485(ah) && length >= 1024) ||
+                    (AR_SREV_9485(ah) && length >= (4 * 1024))) {
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Skipping bad header\n");
                         cptr -= COMP_HDR_LEN;
                         continue;
                 }
@@ -3376,14 +3380,14 @@ found:
                 checksum = ar9300_comp_cksum(&word[COMP_HDR_LEN], length);
                 mchecksum = word[COMP_HDR_LEN + osize] |
                     (word[COMP_HDR_LEN + osize + 1] << 8);
-                ath_print(common, ATH_DBG_EEPROM,
-                          "checksum %x %x\n", checksum, mchecksum);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "checksum %x %x\n", checksum, mchecksum);
                 if (checksum == mchecksum) {
                         ar9300_compress_decision(ah, it, code, reference, mptr,
                                                  word, length, mdata_size);
                 } else {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "skipping block with bad checksum\n");
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "skipping block with bad checksum\n");
                 }
                 cptr -= (COMP_HDR_LEN + osize + COMP_CKSUM_LEN);
         }
@@ -3449,9 +3453,15 @@ static s32 ar9003_hw_xpa_bias_level_get(struct ath_hw *ah, bool is2ghz)
 static void ar9003_hw_xpa_bias_level_apply(struct ath_hw *ah, bool is2ghz)
 {
         int bias = ar9003_hw_xpa_bias_level_get(ah, is2ghz);
-        REG_RMW_FIELD(ah, AR_CH0_TOP, AR_CH0_TOP_XPABIASLVL, bias);
-        REG_RMW_FIELD(ah, AR_CH0_THERM, AR_CH0_THERM_XPABIASLVL_MSB, bias >> 2);
-        REG_RMW_FIELD(ah, AR_CH0_THERM, AR_CH0_THERM_XPASHORT2GND, 1);
+
+        if (AR_SREV_9485(ah))
+                REG_RMW_FIELD(ah, AR_CH0_TOP2, AR_CH0_TOP2_XPABIASLVL, bias);
+        else {
+                REG_RMW_FIELD(ah, AR_CH0_TOP, AR_CH0_TOP_XPABIASLVL, bias);
+                REG_RMW_FIELD(ah, AR_CH0_THERM, AR_CH0_THERM_XPABIASLVL_MSB,
+                              bias >> 2);
+                REG_RMW_FIELD(ah, AR_CH0_THERM, AR_CH0_THERM_XPASHORT2GND, 1);
+        }
 }
 
 static u32 ar9003_hw_ant_ctrl_common_get(struct ath_hw *ah, bool is2ghz)
@@ -3506,11 +3516,25 @@ static void ar9003_hw_ant_ctrl_apply(struct ath_hw *ah, bool is2ghz)
         value = ar9003_hw_ant_ctrl_chain_get(ah, 0, is2ghz);
         REG_RMW_FIELD(ah, AR_PHY_SWITCH_CHAIN_0, AR_SWITCH_TABLE_ALL, value);
 
-        value = ar9003_hw_ant_ctrl_chain_get(ah, 1, is2ghz);
-        REG_RMW_FIELD(ah, AR_PHY_SWITCH_CHAIN_1, AR_SWITCH_TABLE_ALL, value);
+        if (!AR_SREV_9485(ah)) {
+                value = ar9003_hw_ant_ctrl_chain_get(ah, 1, is2ghz);
+                REG_RMW_FIELD(ah, AR_PHY_SWITCH_CHAIN_1, AR_SWITCH_TABLE_ALL,
+                              value);
+
+                value = ar9003_hw_ant_ctrl_chain_get(ah, 2, is2ghz);
+                REG_RMW_FIELD(ah, AR_PHY_SWITCH_CHAIN_2, AR_SWITCH_TABLE_ALL,
+                              value);
+        }
 
-        value = ar9003_hw_ant_ctrl_chain_get(ah, 2, is2ghz);
-        REG_RMW_FIELD(ah, AR_PHY_SWITCH_CHAIN_2, AR_SWITCH_TABLE_ALL, value);
+        if (AR_SREV_9485(ah)) {
+                value = ath9k_hw_ar9300_get_eeprom(ah, EEP_ANT_DIV_CTL1);
+                REG_RMW_FIELD(ah, AR_PHY_MC_GAIN_CTRL, AR_ANT_DIV_CTRL_ALL,
+                              value);
+                REG_RMW_FIELD(ah, AR_PHY_MC_GAIN_CTRL, AR_ANT_DIV_ENABLE,
+                              value >> 6);
+                REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, AR_FAST_DIV_ENABLE,
+                              value >> 7);
+        }
 }
 
 static void ar9003_hw_drive_strength_apply(struct ath_hw *ah)
@@ -3630,28 +3654,101 @@ static void ar9003_hw_atten_apply(struct ath_hw *ah, struct ath9k_channel *chan)
         }
 }
 
+static bool is_pmu_set(struct ath_hw *ah, u32 pmu_reg, int pmu_set)
+{
+        int timeout = 100;
+
+        while (pmu_set != REG_READ(ah, pmu_reg)) {
+                if (timeout-- == 0)
+                        return false;
+                REG_WRITE(ah, pmu_reg, pmu_set);
+                udelay(10);
+        }
+
+        return true;
+}
+
 static void ar9003_hw_internal_regulator_apply(struct ath_hw *ah)
 {
         int internal_regulator =
                 ath9k_hw_ar9300_get_eeprom(ah, EEP_INTERNAL_REGULATOR);
 
         if (internal_regulator) {
-                /* Internal regulator is ON. Write swreg register. */
-                int swreg = ath9k_hw_ar9300_get_eeprom(ah, EEP_SWREG);
-                REG_WRITE(ah, AR_RTC_REG_CONTROL1,
-                REG_READ(ah, AR_RTC_REG_CONTROL1) &
-                         (~AR_RTC_REG_CONTROL1_SWREG_PROGRAM));
-                REG_WRITE(ah, AR_RTC_REG_CONTROL0, swreg);
-                /* Set REG_CONTROL1.SWREG_PROGRAM */
-                REG_WRITE(ah, AR_RTC_REG_CONTROL1,
-                          REG_READ(ah,
-                                   AR_RTC_REG_CONTROL1) |
-                                   AR_RTC_REG_CONTROL1_SWREG_PROGRAM);
+                if (AR_SREV_9485(ah)) {
+                        int reg_pmu_set;
+
+                        reg_pmu_set = REG_READ(ah, AR_PHY_PMU2) & ~AR_PHY_PMU2_PGM;
+                        REG_WRITE(ah, AR_PHY_PMU2, reg_pmu_set);
+                        if (!is_pmu_set(ah, AR_PHY_PMU2, reg_pmu_set))
+                                return;
+
+                        reg_pmu_set = (5 << 1) | (7 << 4) | (1 << 8) |
+                                      (7 << 14) | (6 << 17) | (1 << 20) |
+                                      (3 << 24) | (1 << 28);
+
+                        REG_WRITE(ah, AR_PHY_PMU1, reg_pmu_set);
+                        if (!is_pmu_set(ah, AR_PHY_PMU1, reg_pmu_set))
+                                return;
+
+                        reg_pmu_set = (REG_READ(ah, AR_PHY_PMU2) & ~0xFFC00000)
+                                        | (4 << 26);
+                        REG_WRITE(ah, AR_PHY_PMU2, reg_pmu_set);
+                        if (!is_pmu_set(ah, AR_PHY_PMU2, reg_pmu_set))
+                                return;
+
+                        reg_pmu_set = (REG_READ(ah, AR_PHY_PMU2) & ~0x00200000)
+                                        | (1 << 21);
+                        REG_WRITE(ah, AR_PHY_PMU2, reg_pmu_set);
+                        if (!is_pmu_set(ah, AR_PHY_PMU2, reg_pmu_set))
+                                return;
+                } else {
+                        /* Internal regulator is ON. Write swreg register. */
+                        int swreg = ath9k_hw_ar9300_get_eeprom(ah, EEP_SWREG);
+                        REG_WRITE(ah, AR_RTC_REG_CONTROL1,
+                                  REG_READ(ah, AR_RTC_REG_CONTROL1) &
+                                  (~AR_RTC_REG_CONTROL1_SWREG_PROGRAM));
+                        REG_WRITE(ah, AR_RTC_REG_CONTROL0, swreg);
+                        /* Set REG_CONTROL1.SWREG_PROGRAM */
+                        REG_WRITE(ah, AR_RTC_REG_CONTROL1,
+                                  REG_READ(ah,
+                                           AR_RTC_REG_CONTROL1) |
+                                           AR_RTC_REG_CONTROL1_SWREG_PROGRAM);
+                }
         } else {
-                REG_WRITE(ah, AR_RTC_SLEEP_CLK,
-                          (REG_READ(ah,
-                                    AR_RTC_SLEEP_CLK) |
-                                    AR_RTC_FORCE_SWREG_PRD));
+                if (AR_SREV_9485(ah)) {
+                        REG_RMW_FIELD(ah, AR_PHY_PMU2, AR_PHY_PMU2_PGM, 0);
+                        while (REG_READ_FIELD(ah, AR_PHY_PMU2,
+                                              AR_PHY_PMU2_PGM))
+                                udelay(10);
+
+                        REG_RMW_FIELD(ah, AR_PHY_PMU1, AR_PHY_PMU1_PWD, 0x1);
+                        while (!REG_READ_FIELD(ah, AR_PHY_PMU1,
+                                               AR_PHY_PMU1_PWD))
+                                udelay(10);
+                        REG_RMW_FIELD(ah, AR_PHY_PMU2, AR_PHY_PMU2_PGM, 0x1);
+                        while (!REG_READ_FIELD(ah, AR_PHY_PMU2,
+                                              AR_PHY_PMU2_PGM))
+                                udelay(10);
+                } else
+                        REG_WRITE(ah, AR_RTC_SLEEP_CLK,
+                                  (REG_READ(ah,
+                                   AR_RTC_SLEEP_CLK) |
+                                   AR_RTC_FORCE_SWREG_PRD));
+        }
+
+}
+
+static void ar9003_hw_apply_tuning_caps(struct ath_hw *ah)
+{
+        struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep;
+        u8 tuning_caps_param = eep->baseEepHeader.params_for_tuning_caps[0];
+
+        if (eep->baseEepHeader.featureEnable & 0x40) {
+                tuning_caps_param &= 0x7f;
+                REG_RMW_FIELD(ah, AR_CH0_XTAL, AR_CH0_XTAL_CAPINDAC,
+                              tuning_caps_param);
+                REG_RMW_FIELD(ah, AR_CH0_XTAL, AR_CH0_XTAL_CAPOUTDAC,
+                              tuning_caps_param);
         }
 }
 
@@ -3663,6 +3760,8 @@ static void ath9k_hw_ar9300_set_board_values(struct ath_hw *ah,
         ar9003_hw_drive_strength_apply(ah);
         ar9003_hw_atten_apply(ah, chan);
         ar9003_hw_internal_regulator_apply(ah);
+        if (AR_SREV_9485(ah))
+                ar9003_hw_apply_tuning_caps(ah);
 }
 
 static void ath9k_hw_ar9300_set_addac(struct ath_hw *ah,
@@ -4092,22 +4191,9 @@ static void ar9003_hw_set_target_power_eeprom(struct ath_hw *ah, u16 freq,
             ar9003_hw_eeprom_get_ht40_tgt_pwr(ah, HT_TARGET_RATE_23, freq,
                                               is2GHz) + ht40PowerIncForPdadc;
 
-        while (i < ar9300RateSize) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x\n", i, targetPowerValT2[i]);
-                i++;
+        for (i = 0; i < ar9300RateSize; i++) {
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "TPC[%02d] 0x%08x\n", i, targetPowerValT2[i]);
         }
 }
 
@@ -4126,18 +4212,17 @@ static int ar9003_hw_cal_pier_get(struct ath_hw *ah,
         struct ath_common *common = ath9k_hw_common(ah);
 
         if (ichain >= AR9300_MAX_CHAINS) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Invalid chain index, must be less than %d\n",
-                          AR9300_MAX_CHAINS);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Invalid chain index, must be less than %d\n",
+                        AR9300_MAX_CHAINS);
                 return -1;
         }
 
         if (mode) {             /* 5GHz */
                 if (ipier >= AR9300_NUM_5G_CAL_PIERS) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Invalid 5GHz cal pier index, must "
-                                  "be less than %d\n",
-                                  AR9300_NUM_5G_CAL_PIERS);
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Invalid 5GHz cal pier index, must be less than %d\n",
+                                AR9300_NUM_5G_CAL_PIERS);
                         return -1;
                 }
                 pCalPier = &(eep->calFreqPier5G[ipier]);
@@ -4145,9 +4230,9 @@ static int ar9003_hw_cal_pier_get(struct ath_hw *ah,
                 is2GHz = 0;
         } else {
                 if (ipier >= AR9300_NUM_2G_CAL_PIERS) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Invalid 2GHz cal pier index, must "
-                                  "be less than %d\n", AR9300_NUM_2G_CAL_PIERS);
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Invalid 2GHz cal pier index, must be less than %d\n",
+                                AR9300_NUM_2G_CAL_PIERS);
                         return -1;
                 }
 
@@ -4176,23 +4261,27 @@ static int ar9003_hw_power_control_override(struct ath_hw *ah,
         REG_RMW(ah, AR_PHY_TPC_11_B0,
                 (correction[0] << AR_PHY_TPC_OLPC_GAIN_DELTA_S),
                 AR_PHY_TPC_OLPC_GAIN_DELTA);
-        REG_RMW(ah, AR_PHY_TPC_11_B1,
-                (correction[1] << AR_PHY_TPC_OLPC_GAIN_DELTA_S),
-                AR_PHY_TPC_OLPC_GAIN_DELTA);
-        REG_RMW(ah, AR_PHY_TPC_11_B2,
-                (correction[2] << AR_PHY_TPC_OLPC_GAIN_DELTA_S),
-                AR_PHY_TPC_OLPC_GAIN_DELTA);
+        if (ah->caps.tx_chainmask & BIT(1))
+                REG_RMW(ah, AR_PHY_TPC_11_B1,
+                        (correction[1] << AR_PHY_TPC_OLPC_GAIN_DELTA_S),
+                        AR_PHY_TPC_OLPC_GAIN_DELTA);
+        if (ah->caps.tx_chainmask & BIT(2))
+                REG_RMW(ah, AR_PHY_TPC_11_B2,
+                        (correction[2] << AR_PHY_TPC_OLPC_GAIN_DELTA_S),
+                        AR_PHY_TPC_OLPC_GAIN_DELTA);
 
         /* enable open loop power control on chip */
         REG_RMW(ah, AR_PHY_TPC_6_B0,
                 (3 << AR_PHY_TPC_6_ERROR_EST_MODE_S),
                 AR_PHY_TPC_6_ERROR_EST_MODE);
-        REG_RMW(ah, AR_PHY_TPC_6_B1,
-                (3 << AR_PHY_TPC_6_ERROR_EST_MODE_S),
-                AR_PHY_TPC_6_ERROR_EST_MODE);
-        REG_RMW(ah, AR_PHY_TPC_6_B2,
-                (3 << AR_PHY_TPC_6_ERROR_EST_MODE_S),
-                AR_PHY_TPC_6_ERROR_EST_MODE);
+        if (ah->caps.tx_chainmask & BIT(1))
+                REG_RMW(ah, AR_PHY_TPC_6_B1,
+                        (3 << AR_PHY_TPC_6_ERROR_EST_MODE_S),
+                        AR_PHY_TPC_6_ERROR_EST_MODE);
+        if (ah->caps.tx_chainmask & BIT(2))
+                REG_RMW(ah, AR_PHY_TPC_6_B2,
+                        (3 << AR_PHY_TPC_6_ERROR_EST_MODE_S),
+                        AR_PHY_TPC_6_ERROR_EST_MODE);
 
         /*
          * enable temperature compensation
@@ -4297,11 +4386,11 @@ static int ar9003_hw_calibration_apply(struct ath_hw *ah, int frequency)
 
         /* interpolate  */
         for (ichain = 0; ichain < AR9300_MAX_CHAINS; ichain++) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "ch=%d f=%d low=%d %d h=%d %d\n",
-                          ichain, frequency, lfrequency[ichain],
-                          lcorrection[ichain], hfrequency[ichain],
-                          hcorrection[ichain]);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "ch=%d f=%d low=%d %d h=%d %d\n",
+                        ichain, frequency, lfrequency[ichain],
+                        lcorrection[ichain], hfrequency[ichain],
+                        hcorrection[ichain]);
                 /* they're the same, so just pick one */
                 if (hfrequency[ichain] == lfrequency[ichain]) {
                         correction[ichain] = lcorrection[ichain];
@@ -4353,9 +4442,9 @@ static int ar9003_hw_calibration_apply(struct ath_hw *ah, int frequency)
         ar9003_hw_power_control_override(ah, frequency, correction, voltage,
                                          temperature);
 
-        ath_print(common, ATH_DBG_EEPROM,
-                  "for frequency=%d, calibration correction = %d %d %d\n",
-                  frequency, correction[0], correction[1], correction[2]);
+        ath_dbg(common, ATH_DBG_EEPROM,
+                "for frequency=%d, calibration correction = %d %d %d\n",
+                frequency, correction[0], correction[1], correction[2]);
 
         return 0;
 }
@@ -4560,11 +4649,10 @@ static void ar9003_hw_set_power_per_rate_table(struct ath_hw *ah,
                 else
                         freq = centers.ctl_center;
 
-                ath_print(common, ATH_DBG_REGULATORY,
-                          "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, "
-                          "EXT_ADDITIVE %d\n",
-                          ctlMode, numCtlModes, isHt40CtlMode,
-                          (pCtlMode[ctlMode] & EXT_ADDITIVE));
+                ath_dbg(common, ATH_DBG_REGULATORY,
+                        "LOOP-Mode ctlMode %d < %d, isHt40CtlMode %d, EXT_ADDITIVE %d\n",
+                        ctlMode, numCtlModes, isHt40CtlMode,
+                        (pCtlMode[ctlMode] & EXT_ADDITIVE));
 
                 /* walk through each CTL index stored in EEPROM */
                 if (is2ghz) {
@@ -4576,12 +4664,10 @@ static void ar9003_hw_set_power_per_rate_table(struct ath_hw *ah,
                 }
 
                 for (i = 0; (i < ctlNum) && ctlIndex[i]; i++) {
-                        ath_print(common, ATH_DBG_REGULATORY,
-                                  "LOOP-Ctlidx %d: cfgCtl 0x%2.2x "
-                                  "pCtlMode 0x%2.2x ctlIndex 0x%2.2x "
-                                  "chan %dn",
-                                  i, cfgCtl, pCtlMode[ctlMode], ctlIndex[i],
-                                  chan->channel);
+                        ath_dbg(common, ATH_DBG_REGULATORY,
+                                "LOOP-Ctlidx %d: cfgCtl 0x%2.2x pCtlMode 0x%2.2x ctlIndex 0x%2.2x chan %d\n",
+                                i, cfgCtl, pCtlMode[ctlMode], ctlIndex[i],
+                                chan->channel);
 
                                 /*
                                  * compare test group from regulatory
@@ -4620,11 +4706,10 @@ static void ar9003_hw_set_power_per_rate_table(struct ath_hw *ah,
 
                         minCtlPower = (u8)min(twiceMaxEdgePower, scaledPower);
 
-                        ath_print(common, ATH_DBG_REGULATORY,
-                                  "SEL-Min ctlMode %d pCtlMode %d 2xMaxEdge %d "
-                                  "sP %d minCtlPwr %d\n",
-                                  ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
-                                  scaledPower, minCtlPower);
+                        ath_dbg(common, ATH_DBG_REGULATORY,
+                                "SEL-Min ctlMode %d pCtlMode %d 2xMaxEdge %d sP %d minCtlPwr %d\n",
+                                ctlMode, pCtlMode[ctlMode], twiceMaxEdgePower,
+                                scaledPower, minCtlPower);
 
                         /* Apply ctl mode to correct target power set */
                         switch (pCtlMode[ctlMode]) {
@@ -4699,18 +4784,8 @@ static void ath9k_hw_ar9300_set_txpower(struct ath_hw *ah,
                 return;
 
         for (i = 0; i < ar9300RateSize; i++) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x ", i, targetPowerValT2[i]);
-                i++;
-                ath_print(common, ATH_DBG_EEPROM,
-                          "TPC[%02d] 0x%08x\n\n", i, targetPowerValT2[i]);
-                i++;
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "TPC[%02d] 0x%08x\n", i, targetPowerValT2[i]);
         }
 
         /*
@@ -4758,6 +4833,16 @@ s32 ar9003_hw_get_rx_gain_idx(struct ath_hw *ah)
         return (eep->baseEepHeader.txrxgain) & 0xf; /* bits 3:0 */
 }
 
+u8 *ar9003_get_spur_chan_ptr(struct ath_hw *ah, bool is_2ghz)
+{
+        struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep;
+
+        if (is_2ghz)
+                return eep->modalHeader2G.spurChans;
+        else
+                return eep->modalHeader5G.spurChans;
+}
+
 const struct eeprom_ops eep_ar9300_ops = {
         .check_eeprom = ath9k_hw_ar9300_check_eeprom,
         .get_eeprom = ath9k_hw_ar9300_get_eeprom,
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
index 9c1463307f0c..33503217dab3 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
@@ -78,6 +78,7 @@
 #define AR9300_EEPROM_SIZE (16*1024)
 #define FIXED_CCA_THRESHOLD 15
 
+#define AR9300_BASE_ADDR_4K 0xfff
 #define AR9300_BASE_ADDR 0x3ff
 #define AR9300_BASE_ADDR_512 0x1ff
 
@@ -342,4 +343,5 @@ struct ar9300_eeprom {
 s32 ar9003_hw_get_tx_gain_idx(struct ath_hw *ah);
 s32 ar9003_hw_get_rx_gain_idx(struct ath_hw *ah);
 
+u8 *ar9003_get_spur_chan_ptr(struct ath_hw *ah, bool is_2ghz);
 #endif
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_hw.c b/drivers/net/wireless/ath/ath9k/ar9003_hw.c
index c2a057156bfa..21a5bfe354a0 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_hw.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_hw.c
@@ -17,6 +17,7 @@
 #include "hw.h"
 #include "ar9003_mac.h"
 #include "ar9003_2p2_initvals.h"
+#include "ar9485_initvals.h"
 
 /* General hardware code for the AR9003 hadware family */
 
@@ -24,6 +25,7 @@ static bool ar9003_hw_macversion_supported(u32 macversion)
 {
         switch (macversion) {
         case AR_SREV_VERSION_9300:
+        case AR_SREV_VERSION_9485:
                 return true;
         default:
                 break;
@@ -38,72 +40,134 @@ static bool ar9003_hw_macversion_supported(u32 macversion)
  */
 static void ar9003_hw_init_mode_regs(struct ath_hw *ah)
 {
-        /* mac */
-        INIT_INI_ARRAY(&ah->iniMac[ATH_INI_PRE], NULL, 0, 0);
-        INIT_INI_ARRAY(&ah->iniMac[ATH_INI_CORE],
-                       ar9300_2p2_mac_core,
-                       ARRAY_SIZE(ar9300_2p2_mac_core), 2);
-        INIT_INI_ARRAY(&ah->iniMac[ATH_INI_POST],
-                       ar9300_2p2_mac_postamble,
-                       ARRAY_SIZE(ar9300_2p2_mac_postamble), 5);
-
-        /* bb */
-        INIT_INI_ARRAY(&ah->iniBB[ATH_INI_PRE], NULL, 0, 0);
-        INIT_INI_ARRAY(&ah->iniBB[ATH_INI_CORE],
-                       ar9300_2p2_baseband_core,
-                       ARRAY_SIZE(ar9300_2p2_baseband_core), 2);
-        INIT_INI_ARRAY(&ah->iniBB[ATH_INI_POST],
-                       ar9300_2p2_baseband_postamble,
-                       ARRAY_SIZE(ar9300_2p2_baseband_postamble), 5);
-
-        /* radio */
-        INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_PRE], NULL, 0, 0);
-        INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_CORE],
-                       ar9300_2p2_radio_core,
-                       ARRAY_SIZE(ar9300_2p2_radio_core), 2);
-        INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_POST],
-                       ar9300_2p2_radio_postamble,
-                       ARRAY_SIZE(ar9300_2p2_radio_postamble), 5);
-
-        /* soc */
-        INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_PRE],
-                       ar9300_2p2_soc_preamble,
-                       ARRAY_SIZE(ar9300_2p2_soc_preamble), 2);
-        INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_CORE], NULL, 0, 0);
-        INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_POST],
-                       ar9300_2p2_soc_postamble,
-                       ARRAY_SIZE(ar9300_2p2_soc_postamble), 5);
-
-        /* rx/tx gain */
-        INIT_INI_ARRAY(&ah->iniModesRxGain,
-                       ar9300Common_rx_gain_table_2p2,
-                       ARRAY_SIZE(ar9300Common_rx_gain_table_2p2), 2);
-        INIT_INI_ARRAY(&ah->iniModesTxGain,
-                       ar9300Modes_lowest_ob_db_tx_gain_table_2p2,
-                       ARRAY_SIZE(ar9300Modes_lowest_ob_db_tx_gain_table_2p2),
-                       5);
-
-        /* Load PCIE SERDES settings from INI */
-
-        /* Awake Setting */
-
-        INIT_INI_ARRAY(&ah->iniPcieSerdes,
-                       ar9300PciePhy_pll_on_clkreq_disable_L1_2p2,
-                       ARRAY_SIZE(ar9300PciePhy_pll_on_clkreq_disable_L1_2p2),
-                       2);
-
-        /* Sleep Setting */
-
-        INIT_INI_ARRAY(&ah->iniPcieSerdesLowPower,
-                       ar9300PciePhy_clkreq_enable_L1_2p2,
-                       ARRAY_SIZE(ar9300PciePhy_clkreq_enable_L1_2p2),
-                       2);
-
-        /* Fast clock modal settings */
-        INIT_INI_ARRAY(&ah->iniModesAdditional,
-                       ar9300Modes_fast_clock_2p2,
-                       ARRAY_SIZE(ar9300Modes_fast_clock_2p2),
-                       3);
+        if (AR_SREV_9485(ah)) {
+                /* mac */
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_PRE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_CORE],
+                                ar9485_1_0_mac_core,
+                                ARRAY_SIZE(ar9485_1_0_mac_core), 2);
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_POST],
+                                ar9485_1_0_mac_postamble,
+                                ARRAY_SIZE(ar9485_1_0_mac_postamble), 5);
+
+                /* bb */
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_PRE], ar9485_1_0,
+                                ARRAY_SIZE(ar9485_1_0), 2);
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_CORE],
+                                ar9485_1_0_baseband_core,
+                                ARRAY_SIZE(ar9485_1_0_baseband_core), 2);
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_POST],
+                                ar9485_1_0_baseband_postamble,
+                                ARRAY_SIZE(ar9485_1_0_baseband_postamble), 5);
+
+                /* radio */
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_PRE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_CORE],
+                                ar9485_1_0_radio_core,
+                                ARRAY_SIZE(ar9485_1_0_radio_core), 2);
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_POST],
+                                ar9485_1_0_radio_postamble,
+                                ARRAY_SIZE(ar9485_1_0_radio_postamble), 2);
+
+                /* soc */
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_PRE],
+                                ar9485_1_0_soc_preamble,
+                                ARRAY_SIZE(ar9485_1_0_soc_preamble), 2);
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_CORE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_POST], NULL, 0, 0);
+
+                /* rx/tx gain */
+                INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                ar9485Common_rx_gain_1_0,
+                                ARRAY_SIZE(ar9485Common_rx_gain_1_0), 2);
+                INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                ar9485Modes_lowest_ob_db_tx_gain_1_0,
+                                ARRAY_SIZE(ar9485Modes_lowest_ob_db_tx_gain_1_0),
+                                5);
+
+                /* Load PCIE SERDES settings from INI */
+
+                /* Awake Setting */
+
+                INIT_INI_ARRAY(&ah->iniPcieSerdes,
+                                ar9485_1_0_pcie_phy_pll_on_clkreq_disable_L1,
+                                ARRAY_SIZE(ar9485_1_0_pcie_phy_pll_on_clkreq_disable_L1),
+                                2);
+
+                /* Sleep Setting */
+
+                INIT_INI_ARRAY(&ah->iniPcieSerdesLowPower,
+                                ar9485_1_0_pcie_phy_pll_on_clkreq_enable_L1,
+                                ARRAY_SIZE(ar9485_1_0_pcie_phy_pll_on_clkreq_enable_L1),
+                                2);
+        } else {
+                /* mac */
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_PRE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_CORE],
+                                ar9300_2p2_mac_core,
+                                ARRAY_SIZE(ar9300_2p2_mac_core), 2);
+                INIT_INI_ARRAY(&ah->iniMac[ATH_INI_POST],
+                                ar9300_2p2_mac_postamble,
+                                ARRAY_SIZE(ar9300_2p2_mac_postamble), 5);
+
+                /* bb */
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_PRE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_CORE],
+                                ar9300_2p2_baseband_core,
+                                ARRAY_SIZE(ar9300_2p2_baseband_core), 2);
+                INIT_INI_ARRAY(&ah->iniBB[ATH_INI_POST],
+                                ar9300_2p2_baseband_postamble,
+                                ARRAY_SIZE(ar9300_2p2_baseband_postamble), 5);
+
+                /* radio */
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_PRE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_CORE],
+                                ar9300_2p2_radio_core,
+                                ARRAY_SIZE(ar9300_2p2_radio_core), 2);
+                INIT_INI_ARRAY(&ah->iniRadio[ATH_INI_POST],
+                                ar9300_2p2_radio_postamble,
+                                ARRAY_SIZE(ar9300_2p2_radio_postamble), 5);
+
+                /* soc */
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_PRE],
+                                ar9300_2p2_soc_preamble,
+                                ARRAY_SIZE(ar9300_2p2_soc_preamble), 2);
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_CORE], NULL, 0, 0);
+                INIT_INI_ARRAY(&ah->iniSOC[ATH_INI_POST],
+                                ar9300_2p2_soc_postamble,
+                                ARRAY_SIZE(ar9300_2p2_soc_postamble), 5);
+
+                /* rx/tx gain */
+                INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                ar9300Common_rx_gain_table_2p2,
+                                ARRAY_SIZE(ar9300Common_rx_gain_table_2p2), 2);
+                INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                ar9300Modes_lowest_ob_db_tx_gain_table_2p2,
+                                ARRAY_SIZE(ar9300Modes_lowest_ob_db_tx_gain_table_2p2),
+                                5);
+
+                /* Load PCIE SERDES settings from INI */
+
+                /* Awake Setting */
+
+                INIT_INI_ARRAY(&ah->iniPcieSerdes,
+                                ar9300PciePhy_pll_on_clkreq_disable_L1_2p2,
+                                ARRAY_SIZE(ar9300PciePhy_pll_on_clkreq_disable_L1_2p2),
+                                2);
+
+                /* Sleep Setting */
+
+                INIT_INI_ARRAY(&ah->iniPcieSerdesLowPower,
+                                ar9300PciePhy_clkreq_enable_L1_2p2,
+                                ARRAY_SIZE(ar9300PciePhy_clkreq_enable_L1_2p2),
+                                2);
+
+                /* Fast clock modal settings */
+                INIT_INI_ARRAY(&ah->iniModesAdditional,
+                                ar9300Modes_fast_clock_2p2,
+                                ARRAY_SIZE(ar9300Modes_fast_clock_2p2),
+                                3);
+        }
 }
 
 static void ar9003_tx_gain_table_apply(struct ath_hw *ah)
@@ -111,22 +175,52 @@ static void ar9003_tx_gain_table_apply(struct ath_hw *ah)
         switch (ar9003_hw_get_tx_gain_idx(ah)) {
         case 0:
         default:
-                INIT_INI_ARRAY(&ah->iniModesTxGain,
-                               ar9300Modes_lowest_ob_db_tx_gain_table_2p2,
-                               ARRAY_SIZE(ar9300Modes_lowest_ob_db_tx_gain_table_2p2),
-                               5);
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9485Modes_lowest_ob_db_tx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Modes_lowest_ob_db_tx_gain_1_0),
+                                       5);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9300Modes_lowest_ob_db_tx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Modes_lowest_ob_db_tx_gain_table_2p2),
+                                       5);
                 break;
         case 1:
-                INIT_INI_ARRAY(&ah->iniModesTxGain,
-                               ar9300Modes_high_ob_db_tx_gain_table_2p2,
-                               ARRAY_SIZE(ar9300Modes_high_ob_db_tx_gain_table_2p2),
-                               5);
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9485Modes_high_ob_db_tx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Modes_lowest_ob_db_tx_gain_1_0),
+                                       5);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9300Modes_high_ob_db_tx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Modes_high_ob_db_tx_gain_table_2p2),
+                                       5);
                 break;
         case 2:
-                INIT_INI_ARRAY(&ah->iniModesTxGain,
-                               ar9300Modes_low_ob_db_tx_gain_table_2p2,
-                               ARRAY_SIZE(ar9300Modes_low_ob_db_tx_gain_table_2p2),
-                               5);
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9485Modes_low_ob_db_tx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Modes_lowest_ob_db_tx_gain_1_0),
+                                       5);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9300Modes_low_ob_db_tx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Modes_low_ob_db_tx_gain_table_2p2),
+                                       5);
+                break;
+        case 3:
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9485Modes_high_power_tx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Modes_high_power_tx_gain_1_0),
+                                       5);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                                       ar9300Modes_high_power_tx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Modes_high_power_tx_gain_table_2p2),
+                                       5);
                 break;
         }
 }
@@ -136,16 +230,28 @@ static void ar9003_rx_gain_table_apply(struct ath_hw *ah)
         switch (ar9003_hw_get_rx_gain_idx(ah)) {
         case 0:
         default:
-                INIT_INI_ARRAY(&ah->iniModesRxGain,
-                               ar9300Common_rx_gain_table_2p2,
-                               ARRAY_SIZE(ar9300Common_rx_gain_table_2p2),
-                               2);
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                       ar9485Common_rx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Common_rx_gain_1_0),
+                                       2);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                       ar9300Common_rx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Common_rx_gain_table_2p2),
+                                       2);
                 break;
         case 1:
-                INIT_INI_ARRAY(&ah->iniModesRxGain,
-                               ar9300Common_wo_xlna_rx_gain_table_2p2,
-                               ARRAY_SIZE(ar9300Common_wo_xlna_rx_gain_table_2p2),
-                               2);
+                if (AR_SREV_9485(ah))
+                        INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                       ar9485Common_wo_xlna_rx_gain_1_0,
+                                       ARRAY_SIZE(ar9485Common_wo_xlna_rx_gain_1_0),
+                                       2);
+                else
+                        INIT_INI_ARRAY(&ah->iniModesRxGain,
+                                       ar9300Common_wo_xlna_rx_gain_table_2p2,
+                                       ARRAY_SIZE(ar9300Common_wo_xlna_rx_gain_table_2p2),
+                                       2);
                 break;
         }
 }
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_mac.c b/drivers/net/wireless/ath/ath9k/ar9003_mac.c
index f5896aa30005..bfba6a2b741d 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_mac.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_mac.c
@@ -182,8 +182,8 @@ static bool ar9003_hw_get_isr(struct ath_hw *ah, enum ath9k_int *masked)
                 }
 
                 if (sync_cause & AR_INTR_SYNC_LOCAL_TIMEOUT)
-                        ath_print(common, ATH_DBG_INTERRUPT,
-                                  "AR_INTR_SYNC_LOCAL_TIMEOUT\n");
+                        ath_dbg(common, ATH_DBG_INTERRUPT,
+                                "AR_INTR_SYNC_LOCAL_TIMEOUT\n");
 
                 REG_WRITE(ah, AR_INTR_SYNC_CAUSE_CLR, sync_cause);
                 (void) REG_READ(ah, AR_INTR_SYNC_CAUSE_CLR);
@@ -249,8 +249,8 @@ static int ar9003_hw_proc_txdesc(struct ath_hw *ah, void *ds,
 
         if ((MS(ads->ds_info, AR_DescId) != ATHEROS_VENDOR_ID) ||
             (MS(ads->ds_info, AR_TxRxDesc) != 1)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_XMIT,
-                          "Tx Descriptor error %x\n", ads->ds_info);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_XMIT,
+                        "Tx Descriptor error %x\n", ads->ds_info);
                 memset(ads, 0, sizeof(*ads));
                 return -EIO;
         }
@@ -658,10 +658,10 @@ void ath9k_hw_reset_txstatus_ring(struct ath_hw *ah)
         memset((void *) ah->ts_ring, 0,
                 ah->ts_size * sizeof(struct ar9003_txs));
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_XMIT,
-                  "TS Start 0x%x End 0x%x Virt %p, Size %d\n",
-                   ah->ts_paddr_start, ah->ts_paddr_end,
-                   ah->ts_ring, ah->ts_size);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_XMIT,
+                "TS Start 0x%x End 0x%x Virt %p, Size %d\n",
+                ah->ts_paddr_start, ah->ts_paddr_end,
+                ah->ts_ring, ah->ts_size);
 
         REG_WRITE(ah, AR_Q_STATUS_RING_START, ah->ts_paddr_start);
         REG_WRITE(ah, AR_Q_STATUS_RING_END, ah->ts_paddr_end);
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_paprd.c b/drivers/net/wireless/ath/ath9k/ar9003_paprd.c
index 850bc9866c19..74cff4365c43 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_paprd.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_paprd.c
@@ -21,10 +21,12 @@ void ar9003_paprd_enable(struct ath_hw *ah, bool val)
 {
         REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B0,
                       AR_PHY_PAPRD_CTRL0_PAPRD_ENABLE, !!val);
-        REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B1,
-                      AR_PHY_PAPRD_CTRL0_PAPRD_ENABLE, !!val);
-        REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B2,
-                      AR_PHY_PAPRD_CTRL0_PAPRD_ENABLE, !!val);
+        if (ah->caps.tx_chainmask & BIT(1))
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B1,
+                              AR_PHY_PAPRD_CTRL0_PAPRD_ENABLE, !!val);
+        if (ah->caps.tx_chainmask & BIT(2))
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B2,
+                              AR_PHY_PAPRD_CTRL0_PAPRD_ENABLE, !!val);
 }
 EXPORT_SYMBOL(ar9003_paprd_enable);
 
@@ -57,7 +59,8 @@ static void ar9003_paprd_setup_single_table(struct ath_hw *ah)
         REG_RMW_FIELD(ah, AR_PHY_PAPRD_AM2PM, AR_PHY_PAPRD_AM2PM_MASK, am_mask);
         REG_RMW_FIELD(ah, AR_PHY_PAPRD_HT40, AR_PHY_PAPRD_HT40_MASK, ht40_mask);
 
-        for (i = 0; i < 3; i++) {
+
+        for (i = 0; i < ah->caps.max_txchains; i++) {
                 REG_RMW_FIELD(ah, ctrl0[i],
                               AR_PHY_PAPRD_CTRL0_USE_SINGLE_TABLE_MASK, 1);
                 REG_RMW_FIELD(ah, ctrl1[i],
@@ -102,8 +105,14 @@ static void ar9003_paprd_setup_single_table(struct ath_hw *ah)
                       AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_NUM_CORR_STAGES, 7);
         REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3,
                       AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_MIN_LOOPBACK_DEL, 1);
-        REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3,
-                      AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP, -6);
+        if (AR_SREV_9485(ah))
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3,
+                              AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP,
+                              -3);
+        else
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3,
+                              AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP,
+                              -6);
         REG_RMW_FIELD(ah, AR_PHY_PAPRD_TRAINER_CNTL3,
                       AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_ADC_DESIRED_SIZE,
                       -15);
@@ -620,13 +629,15 @@ void ar9003_paprd_populate_single_table(struct ath_hw *ah,
                       AR_PHY_PAPRD_CTRL1_PAPRD_POWER_AT_AM2AM_CAL,
                       training_power);
 
-        REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL1_B1,
-                      AR_PHY_PAPRD_CTRL1_PAPRD_POWER_AT_AM2AM_CAL,
-                      training_power);
+        if (ah->caps.tx_chainmask & BIT(1))
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL1_B1,
+                              AR_PHY_PAPRD_CTRL1_PAPRD_POWER_AT_AM2AM_CAL,
+                              training_power);
 
-        REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL1_B2,
-                      AR_PHY_PAPRD_CTRL1_PAPRD_POWER_AT_AM2AM_CAL,
-                      training_power);
+        if (ah->caps.tx_chainmask & BIT(2))
+                REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL1_B2,
+                              AR_PHY_PAPRD_CTRL1_PAPRD_POWER_AT_AM2AM_CAL,
+                              training_power);
 }
 EXPORT_SYMBOL(ar9003_paprd_populate_single_table);
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.c b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
index b34a9e91edd8..da4a571304da 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
@@ -75,7 +75,10 @@ static int ar9003_hw_set_channel(struct ath_hw *ah, struct ath9k_channel *chan)
         freq = centers.synth_center;
 
         if (freq < 4800) {     /* 2 GHz, fractional mode */
-                channelSel = CHANSEL_2G(freq);
+                if (AR_SREV_9485(ah))
+                        channelSel = CHANSEL_2G_9485(freq);
+                else
+                        channelSel = CHANSEL_2G(freq);
                 /* Set to 2G mode */
                 bMode = 1;
         } else {
@@ -131,21 +134,50 @@ static void ar9003_hw_spur_mitigate_mrc_cck(struct ath_hw *ah,
         static const u32 spur_freq[4] = { 2420, 2440, 2464, 2480 };
         int cur_bb_spur, negative = 0, cck_spur_freq;
         int i;
+        int range, max_spur_cnts, synth_freq;
+        u8 *spur_fbin_ptr = NULL;
 
         /*
          * Need to verify range +/- 10 MHz in control channel, otherwise spur
          * is out-of-band and can be ignored.
          */
 
-        for (i = 0; i < 4; i++) {
+        if (AR_SREV_9485(ah)) {
+                spur_fbin_ptr = ar9003_get_spur_chan_ptr(ah,
+                                                         IS_CHAN_2GHZ(chan));
+                if (spur_fbin_ptr[0] == 0) /* No spur */
+                        return;
+                max_spur_cnts = 5;
+                if (IS_CHAN_HT40(chan)) {
+                        range = 19;
+                        if (REG_READ_FIELD(ah, AR_PHY_GEN_CTRL,
+                                           AR_PHY_GC_DYN2040_PRI_CH) == 0)
+                                synth_freq = chan->channel + 10;
+                        else
+                                synth_freq = chan->channel - 10;
+                } else {
+                        range = 10;
+                        synth_freq = chan->channel;
+                }
+        } else {
+                range = 10;
+                max_spur_cnts = 4;
+                synth_freq = chan->channel;
+        }
+
+        for (i = 0; i < max_spur_cnts; i++) {
                 negative = 0;
-                cur_bb_spur = spur_freq[i] - chan->channel;
+                if (AR_SREV_9485(ah))
+                        cur_bb_spur = FBIN2FREQ(spur_fbin_ptr[i],
+                                        IS_CHAN_2GHZ(chan)) - synth_freq;
+                else
+                        cur_bb_spur = spur_freq[i] - synth_freq;
 
                 if (cur_bb_spur < 0) {
                         negative = 1;
                         cur_bb_spur = -cur_bb_spur;
                 }
-                if (cur_bb_spur < 10) {
+                if (cur_bb_spur < range) {
                         cck_spur_freq = (int)((cur_bb_spur << 19) / 11);
 
                         if (negative == 1)
@@ -824,12 +856,12 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                                     AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW);
 
                 if (!on != aniState->ofdmWeakSigDetectOff) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: ofdm weak signal: %s=>%s\n",
-                                  chan->channel,
-                                  !aniState->ofdmWeakSigDetectOff ?
-                                        "on" : "off",
-                                  on ? "on" : "off");
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: ofdm weak signal: %s=>%s\n",
+                                chan->channel,
+                                !aniState->ofdmWeakSigDetectOff ?
+                                "on" : "off",
+                                on ? "on" : "off");
                         if (on)
                                 ah->stats.ast_ani_ofdmon++;
                         else
@@ -842,11 +874,9 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(firstep_table)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "ATH9K_ANI_FIRSTEP_LEVEL: level "
-                                  "out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(firstep_table));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "ATH9K_ANI_FIRSTEP_LEVEL: level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(firstep_table));
                         return false;
                 }
 
@@ -881,24 +911,22 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                               AR_PHY_FIND_SIG_LOW_FIRSTEP_LOW, value2);
 
                 if (level != aniState->firstepLevel) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "firstep[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->firstepLevel,
-                                  level,
-                                  ATH9K_ANI_FIRSTEP_LVL_NEW,
-                                  value,
-                                  aniState->iniDef.firstep);
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "firstep_low[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->firstepLevel,
-                                  level,
-                                  ATH9K_ANI_FIRSTEP_LVL_NEW,
-                                  value2,
-                                  aniState->iniDef.firstepLow);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] firstep[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->firstepLevel,
+                                level,
+                                ATH9K_ANI_FIRSTEP_LVL_NEW,
+                                value,
+                                aniState->iniDef.firstep);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] firstep_low[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->firstepLevel,
+                                level,
+                                ATH9K_ANI_FIRSTEP_LVL_NEW,
+                                value2,
+                                aniState->iniDef.firstepLow);
                         if (level > aniState->firstepLevel)
                                 ah->stats.ast_ani_stepup++;
                         else if (level < aniState->firstepLevel)
@@ -911,11 +939,9 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                 u32 level = param;
 
                 if (level >= ARRAY_SIZE(cycpwrThr1_table)) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "ATH9K_ANI_SPUR_IMMUNITY_LEVEL: level "
-                                  "out of range (%u > %u)\n",
-                                  level,
-                                  (unsigned) ARRAY_SIZE(cycpwrThr1_table));
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "ATH9K_ANI_SPUR_IMMUNITY_LEVEL: level out of range (%u > %zu)\n",
+                                level, ARRAY_SIZE(cycpwrThr1_table));
                         return false;
                 }
                 /*
@@ -949,24 +975,22 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                               AR_PHY_EXT_CYCPWR_THR1, value2);
 
                 if (level != aniState->spurImmunityLevel) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "cycpwrThr1[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->spurImmunityLevel,
-                                  level,
-                                  ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
-                                  value,
-                                  aniState->iniDef.cycpwrThr1);
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: level %d=>%d[def:%d] "
-                                  "cycpwrThr1Ext[level]=%d ini=%d\n",
-                                  chan->channel,
-                                  aniState->spurImmunityLevel,
-                                  level,
-                                  ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
-                                  value2,
-                                  aniState->iniDef.cycpwrThr1Ext);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] cycpwrThr1[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->spurImmunityLevel,
+                                level,
+                                ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
+                                value,
+                                aniState->iniDef.cycpwrThr1);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: level %d=>%d[def:%d] cycpwrThr1Ext[level]=%d ini=%d\n",
+                                chan->channel,
+                                aniState->spurImmunityLevel,
+                                level,
+                                ATH9K_ANI_SPUR_IMMUNE_LVL_NEW,
+                                value2,
+                                aniState->iniDef.cycpwrThr1Ext);
                         if (level > aniState->spurImmunityLevel)
                                 ah->stats.ast_ani_spurup++;
                         else if (level < aniState->spurImmunityLevel)
@@ -986,11 +1010,11 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
                 REG_RMW_FIELD(ah, AR_PHY_MRC_CCK_CTRL,
                               AR_PHY_MRC_CCK_MUX_REG, is_on);
                 if (!is_on != aniState->mrcCCKOff) {
-                        ath_print(common, ATH_DBG_ANI,
-                                  "** ch %d: MRC CCK: %s=>%s\n",
-                                  chan->channel,
-                                  !aniState->mrcCCKOff ? "on" : "off",
-                                  is_on ? "on" : "off");
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "** ch %d: MRC CCK: %s=>%s\n",
+                                chan->channel,
+                                !aniState->mrcCCKOff ? "on" : "off",
+                                is_on ? "on" : "off");
                 if (is_on)
                         ah->stats.ast_ani_ccklow++;
                 else
@@ -1002,22 +1026,19 @@ static bool ar9003_hw_ani_control(struct ath_hw *ah,
         case ATH9K_ANI_PRESENT:
                 break;
         default:
-                ath_print(common, ATH_DBG_ANI,
-                          "invalid cmd %u\n", cmd);
+                ath_dbg(common, ATH_DBG_ANI, "invalid cmd %u\n", cmd);
                 return false;
         }
 
-        ath_print(common, ATH_DBG_ANI,
-                  "ANI parameters: SI=%d, ofdmWS=%s FS=%d "
-                  "MRCcck=%s listenTime=%d "
-                  "ofdmErrs=%d cckErrs=%d\n",
-                  aniState->spurImmunityLevel,
-                  !aniState->ofdmWeakSigDetectOff ? "on" : "off",
-                  aniState->firstepLevel,
-                  !aniState->mrcCCKOff ? "on" : "off",
-                  aniState->listenTime,
-                  aniState->ofdmPhyErrCount,
-                  aniState->cckPhyErrCount);
+        ath_dbg(common, ATH_DBG_ANI,
+                "ANI parameters: SI=%d, ofdmWS=%s FS=%d MRCcck=%s listenTime=%d ofdmErrs=%d cckErrs=%d\n",
+                aniState->spurImmunityLevel,
+                !aniState->ofdmWeakSigDetectOff ? "on" : "off",
+                aniState->firstepLevel,
+                !aniState->mrcCCKOff ? "on" : "off",
+                aniState->listenTime,
+                aniState->ofdmPhyErrCount,
+                aniState->cckPhyErrCount);
         return true;
 }
 
@@ -1074,13 +1095,13 @@ static void ar9003_hw_ani_cache_ini_regs(struct ath_hw *ah)
         aniState = &ah->curchan->ani;
         iniDef = &aniState->iniDef;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "ver %d.%d opmode %u chan %d Mhz/0x%x\n",
-                  ah->hw_version.macVersion,
-                  ah->hw_version.macRev,
-                  ah->opmode,
-                  chan->channel,
-                  chan->channelFlags);
+        ath_dbg(common, ATH_DBG_ANI,
+                "ver %d.%d opmode %u chan %d Mhz/0x%x\n",
+                ah->hw_version.macVersion,
+                ah->hw_version.macRev,
+                ah->opmode,
+                chan->channel,
+                chan->channelFlags);
 
         val = REG_READ(ah, AR_PHY_SFCORR);
         iniDef->m1Thresh = MS(val, AR_PHY_SFCORR_M1_THRESH);
@@ -1216,7 +1237,7 @@ void ar9003_hw_bb_watchdog_config(struct ath_hw *ah)
                           ~(AR_PHY_WATCHDOG_NON_IDLE_ENABLE |
                             AR_PHY_WATCHDOG_IDLE_ENABLE));
 
-                ath_print(common, ATH_DBG_RESET, "Disabled BB Watchdog\n");
+                ath_dbg(common, ATH_DBG_RESET, "Disabled BB Watchdog\n");
                 return;
         }
 
@@ -1252,9 +1273,9 @@ void ar9003_hw_bb_watchdog_config(struct ath_hw *ah)
                   AR_PHY_WATCHDOG_IDLE_MASK |
                   (AR_PHY_WATCHDOG_NON_IDLE_MASK & (idle_count << 2)));
 
-        ath_print(common, ATH_DBG_RESET,
-                  "Enabled BB Watchdog timeout (%u ms)\n",
-                  idle_tmo_ms);
+        ath_dbg(common, ATH_DBG_RESET,
+                "Enabled BB Watchdog timeout (%u ms)\n",
+                idle_tmo_ms);
 }
 
 void ar9003_hw_bb_watchdog_read(struct ath_hw *ah)
@@ -1282,37 +1303,35 @@ void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw *ah)
                 return;
 
         status = ah->bb_watchdog_last_status;
-        ath_print(common, ATH_DBG_RESET,
-                  "\n==== BB update: BB status=0x%08x ====\n", status);
-        ath_print(common, ATH_DBG_RESET,
-                  "** BB state: wd=%u det=%u rdar=%u rOFDM=%d "
-                  "rCCK=%u tOFDM=%u tCCK=%u agc=%u src=%u **\n",
-                  MS(status, AR_PHY_WATCHDOG_INFO),
-                  MS(status, AR_PHY_WATCHDOG_DET_HANG),
-                  MS(status, AR_PHY_WATCHDOG_RADAR_SM),
-                  MS(status, AR_PHY_WATCHDOG_RX_OFDM_SM),
-                  MS(status, AR_PHY_WATCHDOG_RX_CCK_SM),
-                  MS(status, AR_PHY_WATCHDOG_TX_OFDM_SM),
-                  MS(status, AR_PHY_WATCHDOG_TX_CCK_SM),
-                  MS(status, AR_PHY_WATCHDOG_AGC_SM),
-                  MS(status,AR_PHY_WATCHDOG_SRCH_SM));
-
-        ath_print(common, ATH_DBG_RESET,
-                  "** BB WD cntl: cntl1=0x%08x cntl2=0x%08x **\n",
-                  REG_READ(ah, AR_PHY_WATCHDOG_CTL_1),
-                  REG_READ(ah, AR_PHY_WATCHDOG_CTL_2));
-        ath_print(common, ATH_DBG_RESET,
-                  "** BB mode: BB_gen_controls=0x%08x **\n",
-                  REG_READ(ah, AR_PHY_GEN_CTRL));
+        ath_dbg(common, ATH_DBG_RESET,
+                "\n==== BB update: BB status=0x%08x ====\n", status);
+        ath_dbg(common, ATH_DBG_RESET,
+                "** BB state: wd=%u det=%u rdar=%u rOFDM=%d rCCK=%u tOFDM=%u tCCK=%u agc=%u src=%u **\n",
+                MS(status, AR_PHY_WATCHDOG_INFO),
+                MS(status, AR_PHY_WATCHDOG_DET_HANG),
+                MS(status, AR_PHY_WATCHDOG_RADAR_SM),
+                MS(status, AR_PHY_WATCHDOG_RX_OFDM_SM),
+                MS(status, AR_PHY_WATCHDOG_RX_CCK_SM),
+                MS(status, AR_PHY_WATCHDOG_TX_OFDM_SM),
+                MS(status, AR_PHY_WATCHDOG_TX_CCK_SM),
+                MS(status, AR_PHY_WATCHDOG_AGC_SM),
+                MS(status, AR_PHY_WATCHDOG_SRCH_SM));
+
+        ath_dbg(common, ATH_DBG_RESET,
+                "** BB WD cntl: cntl1=0x%08x cntl2=0x%08x **\n",
+                REG_READ(ah, AR_PHY_WATCHDOG_CTL_1),
+                REG_READ(ah, AR_PHY_WATCHDOG_CTL_2));
+        ath_dbg(common, ATH_DBG_RESET,
+                "** BB mode: BB_gen_controls=0x%08x **\n",
+                REG_READ(ah, AR_PHY_GEN_CTRL));
 
 #define PCT(_field) (common->cc_survey._field * 100 / common->cc_survey.cycles)
         if (common->cc_survey.cycles)
-                ath_print(common, ATH_DBG_RESET,
-                          "** BB busy times: rx_clear=%d%%, "
-                          "rx_frame=%d%%, tx_frame=%d%% **\n",
-                          PCT(rx_busy), PCT(rx_frame), PCT(tx_frame));
+                ath_dbg(common, ATH_DBG_RESET,
+                        "** BB busy times: rx_clear=%d%%, rx_frame=%d%%, tx_frame=%d%% **\n",
+                        PCT(rx_busy), PCT(rx_frame), PCT(tx_frame));
 
-        ath_print(common, ATH_DBG_RESET,
-                  "==== BB update: done ====\n\n");
+        ath_dbg(common, ATH_DBG_RESET,
+                "==== BB update: done ====\n\n");
 }
 EXPORT_SYMBOL(ar9003_hw_bb_watchdog_dbg_info);
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.h b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
index 3394dfe52b42..6f811c7ada05 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
@@ -260,7 +260,13 @@
 #define AR_PHY_CCA_0            (AR_AGC_BASE + 0x1c)
 #define AR_PHY_EXT_CCA0         (AR_AGC_BASE + 0x20)
 #define AR_PHY_RESTART          (AR_AGC_BASE + 0x24)
+
 #define AR_PHY_MC_GAIN_CTRL     (AR_AGC_BASE + 0x28)
+#define AR_ANT_DIV_CTRL_ALL     0x7e000000
+#define AR_ANT_DIV_CTRL_ALL_S   25
+#define AR_ANT_DIV_ENABLE       0x1000000
+#define AR_ANT_DIV_ENABLE_S     24
+
 #define AR_PHY_EXTCHN_PWRTHR1   (AR_AGC_BASE + 0x2c)
 #define AR_PHY_EXT_CHN_WIN      (AR_AGC_BASE + 0x30)
 #define AR_PHY_20_40_DET_THR    (AR_AGC_BASE + 0x34)
@@ -271,7 +277,11 @@
 #define AR_PHY_RX_GAIN_BOUNDS_2 (AR_AGC_BASE + 0x48)
 #define AR_PHY_RSSI_0           (AR_AGC_BASE + 0x180)
 #define AR_PHY_SPUR_CCK_REP0    (AR_AGC_BASE + 0x184)
+
 #define AR_PHY_CCK_DETECT       (AR_AGC_BASE + 0x1c0)
+#define AR_FAST_DIV_ENABLE      0x2000
+#define AR_FAST_DIV_ENABLE_S    13
+
 #define AR_PHY_DAG_CTRLCCK      (AR_AGC_BASE + 0x1c4)
 #define AR_PHY_IQCORR_CTRL_CCK  (AR_AGC_BASE + 0x1c8)
 
@@ -536,10 +546,18 @@
 
 #define AR_PHY_TXGAIN_TABLE      (AR_SM_BASE + 0x300)
 
+#define AR_PHY_TX_IQCAL_START_9485              (AR_SM_BASE + 0x3c4)
+#define AR_PHY_TX_IQCAL_START_DO_CAL_9485       0x80000000
+#define AR_PHY_TX_IQCAL_START_DO_CAL_9485_S     31
+#define AR_PHY_TX_IQCAL_CONTROL_1_9485          (AR_SM_BASE + 0x3c8)
+#define AR_PHY_TX_IQCAL_STATUS_B0_9485          (AR_SM_BASE + 0x3f0)
+
 #define AR_PHY_TX_IQCAL_CONTROL_1   (AR_SM_BASE + 0x448)
 #define AR_PHY_TX_IQCAL_START       (AR_SM_BASE + 0x440)
 #define AR_PHY_TX_IQCAL_STATUS_B0   (AR_SM_BASE + 0x48c)
-#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B0    (AR_SM_BASE + 0x450)
+#define AR_PHY_TX_IQCAL_CORR_COEFF_B0(_i)    (AR_SM_BASE + \
+                                             (AR_SREV_9485(ah) ? \
+                                              0x3d0 : 0x450) + ((_i) << 2))
 
 #define AR_PHY_WATCHDOG_STATUS      (AR_SM_BASE + 0x5c0)
 #define AR_PHY_WATCHDOG_CTL_1       (AR_SM_BASE + 0x5c4)
@@ -568,7 +586,7 @@
 #define AR_PHY_65NM_CH0_BIAS2       0x160c4
 #define AR_PHY_65NM_CH0_BIAS4       0x160cc
 #define AR_PHY_65NM_CH0_RXTX4       0x1610c
-#define AR_PHY_65NM_CH0_THERM       0x16290
+#define AR_PHY_65NM_CH0_THERM       (AR_SREV_9485(ah) ? 0x1628c : 0x16290)
 
 #define AR_PHY_65NM_CH0_THERM_LOCAL   0x80000000
 #define AR_PHY_65NM_CH0_THERM_LOCAL_S 31
@@ -584,6 +602,24 @@
 #define AR_PHY_65NM_CH2_RXTX1       0x16900
 #define AR_PHY_65NM_CH2_RXTX2       0x16904
 
+#define AR_CH0_TOP2 (AR_SREV_9485(ah) ? 0x00016284 : 0x0001628c)
+#define AR_CH0_TOP2_XPABIASLVL          0xf000
+#define AR_CH0_TOP2_XPABIASLVL_S        12
+
+#define AR_CH0_XTAL             (AR_SREV_9485(ah) ? 0x16290 : 0x16294)
+#define AR_CH0_XTAL_CAPINDAC    0x7f000000
+#define AR_CH0_XTAL_CAPINDAC_S  24
+#define AR_CH0_XTAL_CAPOUTDAC   0x00fe0000
+#define AR_CH0_XTAL_CAPOUTDAC_S 17
+
+#define AR_PHY_PMU1             0x16c40
+#define AR_PHY_PMU1_PWD         0x1
+#define AR_PHY_PMU1_PWD_S       0
+
+#define AR_PHY_PMU2             0x16c44
+#define AR_PHY_PMU2_PGM         0x00200000
+#define AR_PHY_PMU2_PGM_S       21
+
 #define AR_PHY_RX1DB_BIQUAD_LONG_SHIFT          0x00380000
 #define AR_PHY_RX1DB_BIQUAD_LONG_SHIFT_S        19
 #define AR_PHY_RX6DB_BIQUAD_LONG_SHIFT          0x00c00000
@@ -683,6 +719,7 @@
 #define AR_PHY_TPCGR1_FORCED_DAC_GAIN_S 1
 #define AR_PHY_TPCGR1_FORCE_DAC_GAIN    0x00000001
 #define AR_PHY_TXGAIN_FORCE               0x00000001
+#define AR_PHY_TXGAIN_FORCE_S             0
 #define AR_PHY_TXGAIN_FORCED_PADVGNRA     0x00003c00
 #define AR_PHY_TXGAIN_FORCED_PADVGNRA_S   10
 #define AR_PHY_TXGAIN_FORCED_PADVGNRB     0x0003c000
@@ -725,8 +762,13 @@
 #define AR_PHY_TX_IQCAL_START_DO_CAL_S      0
 
 #define AR_PHY_TX_IQCAL_STATUS_FAILED    0x00000001
-#define AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE      0x00003fff
-#define AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE_S    0
+#define AR_PHY_CALIBRATED_GAINS_0        0x3e
+#define AR_PHY_CALIBRATED_GAINS_0_S      1
+
+#define AR_PHY_TX_IQCAL_CORR_COEFF_00_COEFF_TABLE      0x00003fff
+#define AR_PHY_TX_IQCAL_CORR_COEFF_00_COEFF_TABLE_S    0
+#define AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE      0x0fffc000
+#define AR_PHY_TX_IQCAL_CORR_COEFF_01_COEFF_TABLE_S    14
 
 #define AR_PHY_65NM_CH0_RXTX4_THERM_ON          0x10000000
 #define AR_PHY_65NM_CH0_RXTX4_THERM_ON_S        28
@@ -785,7 +827,7 @@
 #define AR_PHY_TPC_11_B1         (AR_SM1_BASE + 0x220)
 #define AR_PHY_PDADC_TAB_1       (AR_SM1_BASE + 0x240)
 #define AR_PHY_TX_IQCAL_STATUS_B1   (AR_SM1_BASE + 0x48c)
-#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B1    (AR_SM1_BASE + 0x450)
+#define AR_PHY_TX_IQCAL_CORR_COEFF_B1(_i)    (AR_SM_BASE + 0x450 + ((_i) << 2))
 
 /*
  * Channel 2 Register Map
@@ -838,7 +880,7 @@
 #define AR_PHY_TPC_11_B2         (AR_SM2_BASE + 0x220)
 #define AR_PHY_PDADC_TAB_2       (AR_SM2_BASE + 0x240)
 #define AR_PHY_TX_IQCAL_STATUS_B2   (AR_SM2_BASE + 0x48c)
-#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B2    (AR_SM2_BASE + 0x450)
+#define AR_PHY_TX_IQCAL_CORR_COEFF_B2(_i)    (AR_SM2_BASE + 0x450 + ((_i) << 2))
 
 #define AR_PHY_TX_IQCAL_STATUS_B2_FAILED    0x00000001
 
@@ -945,7 +987,9 @@
 #define AR_PHY_PAPRD_CTRL1_PAPRD_MAG_SCALE_FACT         0x0ffe0000
 #define AR_PHY_PAPRD_CTRL1_PAPRD_MAG_SCALE_FACT_S       17
 
-#define AR_PHY_PAPRD_TRAINER_CNTL1                              (AR_SM_BASE + 0x490)
+#define AR_PHY_PAPRD_TRAINER_CNTL1                              (AR_SM_BASE + \
+                                                                 (AR_SREV_9485(ah) ? \
+                                                                  0x580 : 0x490))
 #define AR_PHY_PAPRD_TRAINER_CNTL1_CF_CF_PAPRD_TRAIN_ENABLE     0x00000001
 #define AR_PHY_PAPRD_TRAINER_CNTL1_CF_CF_PAPRD_TRAIN_ENABLE_S   0
 #define AR_PHY_PAPRD_TRAINER_CNTL1_CF_PAPRD_AGC2_SETTLING       0x0000007e
@@ -961,11 +1005,15 @@
 #define AR_PHY_PAPRD_TRAINER_CNTL1_CF_PAPRD_LB_SKIP             0x0003f000
 #define AR_PHY_PAPRD_TRAINER_CNTL1_CF_PAPRD_LB_SKIP_S           12
 
-#define AR_PHY_PAPRD_TRAINER_CNTL2                              (AR_SM_BASE + 0x494)
+#define AR_PHY_PAPRD_TRAINER_CNTL2                              (AR_SM_BASE + \
+                                                                 (AR_SREV_9485(ah) ? \
+                                                                  0x584 : 0x494))
 #define AR_PHY_PAPRD_TRAINER_CNTL2_CF_PAPRD_INIT_RX_BB_GAIN     0xFFFFFFFF
 #define AR_PHY_PAPRD_TRAINER_CNTL2_CF_PAPRD_INIT_RX_BB_GAIN_S   0
 
-#define AR_PHY_PAPRD_TRAINER_CNTL3                              (AR_SM_BASE + 0x498)
+#define AR_PHY_PAPRD_TRAINER_CNTL3                              (AR_SM_BASE + \
+                                                                 (AR_SREV_9485(ah) ? \
+                                                                  0x588 : 0x498))
 #define AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_ADC_DESIRED_SIZE    0x0000003f
 #define AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_ADC_DESIRED_SIZE_S  0
 #define AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_QUICK_DROP          0x00000fc0
@@ -981,7 +1029,9 @@
 #define AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_BBTXMIX_DISABLE     0x20000000
 #define AR_PHY_PAPRD_TRAINER_CNTL3_CF_PAPRD_BBTXMIX_DISABLE_S   29
 
-#define AR_PHY_PAPRD_TRAINER_CNTL4                              (AR_SM_BASE + 0x49c)
+#define AR_PHY_PAPRD_TRAINER_CNTL4                              (AR_SM_BASE + \
+                                                                 (AR_SREV_9485(ah) ? \
+                                                                  0x58c : 0x49c))
 #define AR_PHY_PAPRD_TRAINER_CNTL4_CF_PAPRD_NUM_TRAIN_SAMPLES   0x03ff0000
 #define AR_PHY_PAPRD_TRAINER_CNTL4_CF_PAPRD_NUM_TRAIN_SAMPLES_S 16
 #define AR_PHY_PAPRD_TRAINER_CNTL4_CF_PAPRD_SAFETY_DELTA        0x0000f000
diff --git a/drivers/net/wireless/ath/ath9k/ar9485_initvals.h b/drivers/net/wireless/ath/ath9k/ar9485_initvals.h
new file mode 100644
index 000000000000..70de3d89a7b5
--- /dev/null
+++ b/drivers/net/wireless/ath/ath9k/ar9485_initvals.h
@@ -0,0 +1,943 @@
+/*
+ * Copyright (c) 2010 Atheros Communications Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef INITVALS_9485_H
+#define INITVALS_9485_H
+
+static const u32 ar9485Common_1_0[][2] = {
+        /*   Addr     allmodes */
+        {0x00007010, 0x00000022},
+        {0x00007020, 0x00000000},
+        {0x00007034, 0x00000002},
+        {0x00007038, 0x000004c2},
+};
+
+static const u32 ar9485_1_0_mac_postamble[][5] = {
+        /* Addr     5G_HT20     5G_HT40     2G_HT40     2G_HT20    */
+        {0x00001030, 0x00000230, 0x00000460, 0x000002c0, 0x00000160},
+        {0x00001070, 0x00000168, 0x000002d0, 0x00000318, 0x0000018c},
+        {0x000010b0, 0x00000e60, 0x00001cc0, 0x00007c70, 0x00003e38},
+        {0x00008014, 0x03e803e8, 0x07d007d0, 0x10801600, 0x08400b00},
+        {0x0000801c, 0x128d8027, 0x128d804f, 0x12e00057, 0x12e0002b},
+        {0x00008120, 0x08f04800, 0x08f04800, 0x08f04810, 0x08f04810},
+        {0x000081d0, 0x00003210, 0x00003210, 0x0000320a, 0x0000320a},
+        {0x00008318, 0x00003e80, 0x00007d00, 0x00006880, 0x00003440},
+};
+
+static const u32 ar9485_1_0_pcie_phy_pll_on_clkreq_disable_L1[][2] = {
+        /*   Addr     allmodes */
+        {0x00018c00, 0x10212e5e},
+        {0x00018c04, 0x000801d8},
+        {0x00018c08, 0x0000580c},
+};
+
+static const u32 ar9485Common_wo_xlna_rx_gain_1_0[][2] = {
+        /*   Addr     allmodes */
+        {0x0000a000, 0x00010000},
+        {0x0000a004, 0x00030002},
+        {0x0000a008, 0x00050004},
+        {0x0000a00c, 0x00810080},
+        {0x0000a010, 0x01800082},
+        {0x0000a014, 0x01820181},
+        {0x0000a018, 0x01840183},
+        {0x0000a01c, 0x01880185},
+        {0x0000a020, 0x018a0189},
+        {0x0000a024, 0x02850284},
+        {0x0000a028, 0x02890288},
+        {0x0000a02c, 0x03850384},
+        {0x0000a030, 0x03890388},
+        {0x0000a034, 0x038b038a},
+        {0x0000a038, 0x038d038c},
+        {0x0000a03c, 0x03910390},
+        {0x0000a040, 0x03930392},
+        {0x0000a044, 0x03950394},
+        {0x0000a048, 0x00000396},
+        {0x0000a04c, 0x00000000},
+        {0x0000a050, 0x00000000},
+        {0x0000a054, 0x00000000},
+        {0x0000a058, 0x00000000},
+        {0x0000a05c, 0x00000000},
+        {0x0000a060, 0x00000000},
+        {0x0000a064, 0x00000000},
+        {0x0000a068, 0x00000000},
+        {0x0000a06c, 0x00000000},
+        {0x0000a070, 0x00000000},
+        {0x0000a074, 0x00000000},
+        {0x0000a078, 0x00000000},
+        {0x0000a07c, 0x00000000},
+        {0x0000a080, 0x28282828},
+        {0x0000a084, 0x28282828},
+        {0x0000a088, 0x28282828},
+        {0x0000a08c, 0x28282828},
+        {0x0000a090, 0x28282828},
+        {0x0000a094, 0x21212128},
+        {0x0000a098, 0x171c1c1c},
+        {0x0000a09c, 0x02020212},
+        {0x0000a0a0, 0x00000202},
+        {0x0000a0a4, 0x00000000},
+        {0x0000a0a8, 0x00000000},
+        {0x0000a0ac, 0x00000000},
+        {0x0000a0b0, 0x00000000},
+        {0x0000a0b4, 0x00000000},
+        {0x0000a0b8, 0x00000000},
+        {0x0000a0bc, 0x00000000},
+        {0x0000a0c0, 0x001f0000},
+        {0x0000a0c4, 0x111f1100},
+        {0x0000a0c8, 0x111d111e},
+        {0x0000a0cc, 0x111b111c},
+        {0x0000a0d0, 0x22032204},
+        {0x0000a0d4, 0x22012202},
+        {0x0000a0d8, 0x221f2200},
+        {0x0000a0dc, 0x221d221e},
+        {0x0000a0e0, 0x33013302},
+        {0x0000a0e4, 0x331f3300},
+        {0x0000a0e8, 0x4402331e},
+        {0x0000a0ec, 0x44004401},
+        {0x0000a0f0, 0x441e441f},
+        {0x0000a0f4, 0x55015502},
+        {0x0000a0f8, 0x551f5500},
+        {0x0000a0fc, 0x6602551e},
+        {0x0000a100, 0x66006601},
+        {0x0000a104, 0x661e661f},
+        {0x0000a108, 0x7703661d},
+        {0x0000a10c, 0x77017702},
+        {0x0000a110, 0x00007700},
+        {0x0000a114, 0x00000000},
+        {0x0000a118, 0x00000000},
+        {0x0000a11c, 0x00000000},
+        {0x0000a120, 0x00000000},
+        {0x0000a124, 0x00000000},
+        {0x0000a128, 0x00000000},
+        {0x0000a12c, 0x00000000},
+        {0x0000a130, 0x00000000},
+        {0x0000a134, 0x00000000},
+        {0x0000a138, 0x00000000},
+        {0x0000a13c, 0x00000000},
+        {0x0000a140, 0x001f0000},
+        {0x0000a144, 0x111f1100},
+        {0x0000a148, 0x111d111e},
+        {0x0000a14c, 0x111b111c},
+        {0x0000a150, 0x22032204},
+        {0x0000a154, 0x22012202},
+        {0x0000a158, 0x221f2200},
+        {0x0000a15c, 0x221d221e},
+        {0x0000a160, 0x33013302},
+        {0x0000a164, 0x331f3300},
+        {0x0000a168, 0x4402331e},
+        {0x0000a16c, 0x44004401},
+        {0x0000a170, 0x441e441f},
+        {0x0000a174, 0x55015502},
+        {0x0000a178, 0x551f5500},
+        {0x0000a17c, 0x6602551e},
+        {0x0000a180, 0x66006601},
+        {0x0000a184, 0x661e661f},
+        {0x0000a188, 0x7703661d},
+        {0x0000a18c, 0x77017702},
+        {0x0000a190, 0x00007700},
+        {0x0000a194, 0x00000000},
+        {0x0000a198, 0x00000000},
+        {0x0000a19c, 0x00000000},
+        {0x0000a1a0, 0x00000000},
+        {0x0000a1a4, 0x00000000},
+        {0x0000a1a8, 0x00000000},
+        {0x0000a1ac, 0x00000000},
+        {0x0000a1b0, 0x00000000},
+        {0x0000a1b4, 0x00000000},
+        {0x0000a1b8, 0x00000000},
+        {0x0000a1bc, 0x00000000},
+        {0x0000a1c0, 0x00000000},
+        {0x0000a1c4, 0x00000000},
+        {0x0000a1c8, 0x00000000},
+        {0x0000a1cc, 0x00000000},
+        {0x0000a1d0, 0x00000000},
+        {0x0000a1d4, 0x00000000},
+        {0x0000a1d8, 0x00000000},
+        {0x0000a1dc, 0x00000000},
+        {0x0000a1e0, 0x00000000},
+        {0x0000a1e4, 0x00000000},
+        {0x0000a1e8, 0x00000000},
+        {0x0000a1ec, 0x00000000},
+        {0x0000a1f0, 0x00000396},
+        {0x0000a1f4, 0x00000396},
+        {0x0000a1f8, 0x00000396},
+        {0x0000a1fc, 0x00000296},
+};
+
+static const u32 ar9485Modes_high_power_tx_gain_1_0[][5] = {
+        /*   Addr      5G_HT20     5G_HT40     2G_HT40     2G_HT20 */
+        {0x0000a410, 0x000050d9, 0x000050d9, 0x000050d8, 0x000050d8},
+        {0x0000a500, 0x00022200, 0x00022200, 0x00000000, 0x00000000},
+        {0x0000a504, 0x05062002, 0x05062002, 0x04000002, 0x04000002},
+        {0x0000a508, 0x0c002e00, 0x0c002e00, 0x08000004, 0x08000004},
+        {0x0000a50c, 0x11062202, 0x11062202, 0x0d000200, 0x0d000200},
+        {0x0000a510, 0x17022e00, 0x17022e00, 0x11000202, 0x11000202},
+        {0x0000a514, 0x1d000ec2, 0x1d000ec2, 0x15000400, 0x15000400},
+        {0x0000a518, 0x25020ec0, 0x25020ec0, 0x19000402, 0x19000402},
+        {0x0000a51c, 0x2b020ec3, 0x2b020ec3, 0x1d000404, 0x1d000404},
+        {0x0000a520, 0x2f001f04, 0x2f001f04, 0x21000603, 0x21000603},
+        {0x0000a524, 0x35001fc4, 0x35001fc4, 0x25000605, 0x25000605},
+        {0x0000a528, 0x3c022f04, 0x3c022f04, 0x2a000a03, 0x2a000a03},
+        {0x0000a52c, 0x41023e85, 0x41023e85, 0x2c000a04, 0x2c000a04},
+        {0x0000a530, 0x48023ec6, 0x48023ec6, 0x2e000a20, 0x2e000a20},
+        {0x0000a534, 0x4d023f01, 0x4d023f01, 0x34000e20, 0x34000e20},
+        {0x0000a538, 0x53023f4b, 0x53023f4b, 0x38000e22, 0x38000e22},
+        {0x0000a53c, 0x5a027f09, 0x5a027f09, 0x3c000e24, 0x3c000e24},
+        {0x0000a540, 0x5f027fc9, 0x5f027fc9, 0x40000e26, 0x40000e26},
+        {0x0000a544, 0x6502feca, 0x6502feca, 0x43001640, 0x43001640},
+        {0x0000a548, 0x6b02ff4a, 0x6b02ff4a, 0x46001660, 0x46001660},
+        {0x0000a54c, 0x7203feca, 0x7203feca, 0x49001861, 0x49001861},
+        {0x0000a550, 0x7703ff0b, 0x7703ff0b, 0x4c001a81, 0x4c001a81},
+        {0x0000a554, 0x7d06ffcb, 0x7d06ffcb, 0x4f001a83, 0x4f001a83},
+        {0x0000a558, 0x8407ff0b, 0x8407ff0b, 0x54001c85, 0x54001c85},
+        {0x0000a55c, 0x8907ffcb, 0x8907ffcb, 0x58001ce5, 0x58001ce5},
+        {0x0000a560, 0x900fff0b, 0x900fff0b, 0x5b001ce9, 0x5b001ce9},
+        {0x0000a564, 0x960fffcb, 0x960fffcb, 0x60001eeb, 0x60001eeb},
+        {0x0000a568, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a56c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a570, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a574, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a578, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a57c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x00016044, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db},
+};
+
+static const u32 ar9485_1_0[][2] = {
+        /*  Addr      allmodes */
+        {0x0000a580, 0x00000000},
+        {0x0000a584, 0x00000000},
+        {0x0000a588, 0x00000000},
+        {0x0000a58c, 0x00000000},
+        {0x0000a590, 0x00000000},
+        {0x0000a594, 0x00000000},
+        {0x0000a598, 0x00000000},
+        {0x0000a59c, 0x00000000},
+        {0x0000a5a0, 0x00000000},
+        {0x0000a5a4, 0x00000000},
+        {0x0000a5a8, 0x00000000},
+        {0x0000a5ac, 0x00000000},
+        {0x0000a5b0, 0x00000000},
+        {0x0000a5b4, 0x00000000},
+        {0x0000a5b8, 0x00000000},
+        {0x0000a5bc, 0x00000000},
+};
+
+static const u32 ar9485_1_0_radio_core[][2] = {
+        /*   Addr     allmodes */
+        {0x00016000, 0x36db6db6},
+        {0x00016004, 0x6db6db40},
+        {0x00016008, 0x73800000},
+        {0x0001600c, 0x00000000},
+        {0x00016040, 0x7f80fff8},
+        {0x00016048, 0x6c92426e},
+        {0x0001604c, 0x000f0278},
+        {0x00016050, 0x6db6db6c},
+        {0x00016054, 0x6db60000},
+        {0x00016080, 0x00080000},
+        {0x00016084, 0x0e48048c},
+        {0x00016088, 0x14214514},
+        {0x0001608c, 0x119f081e},
+        {0x00016090, 0x24926490},
+        {0x00016098, 0xd28b3330},
+        {0x000160a0, 0xc2108ffe},
+        {0x000160a4, 0x812fc370},
+        {0x000160a8, 0x423c8000},
+        {0x000160b4, 0x92480040},
+        {0x000160c0, 0x006db6db},
+        {0x000160c4, 0x0186db60},
+        {0x000160c8, 0x6db6db6c},
+        {0x000160cc, 0x6de6fbe0},
+        {0x000160d0, 0xf7dfcf3c},
+        {0x00016100, 0x04cb0001},
+        {0x00016104, 0xfff80015},
+        {0x00016108, 0x00080010},
+        {0x00016144, 0x01884080},
+        {0x00016148, 0x00008040},
+        {0x00016180, 0x08453333},
+        {0x00016184, 0x18e82f01},
+        {0x00016188, 0x00000000},
+        {0x0001618c, 0x00000000},
+        {0x00016240, 0x08400000},
+        {0x00016244, 0x1bf90f00},
+        {0x00016248, 0x00000000},
+        {0x0001624c, 0x00000000},
+        {0x00016280, 0x01000015},
+        {0x00016284, 0x00d30000},
+        {0x00016288, 0x00318000},
+        {0x0001628c, 0x50000000},
+        {0x00016290, 0x4b96210f},
+        {0x00016380, 0x00000000},
+        {0x00016384, 0x00000000},
+        {0x00016388, 0x00800700},
+        {0x0001638c, 0x00800700},
+        {0x00016390, 0x00800700},
+        {0x00016394, 0x00000000},
+        {0x00016398, 0x00000000},
+        {0x0001639c, 0x00000000},
+        {0x000163a0, 0x00000001},
+        {0x000163a4, 0x00000001},
+        {0x000163a8, 0x00000000},
+        {0x000163ac, 0x00000000},
+        {0x000163b0, 0x00000000},
+        {0x000163b4, 0x00000000},
+        {0x000163b8, 0x00000000},
+        {0x000163bc, 0x00000000},
+        {0x000163c0, 0x000000a0},
+        {0x000163c4, 0x000c0000},
+        {0x000163c8, 0x14021402},
+        {0x000163cc, 0x00001402},
+        {0x000163d0, 0x00000000},
+        {0x000163d4, 0x00000000},
+        {0x00016c40, 0x1319c178},
+        {0x00016c44, 0x10000000},
+};
+
+static const u32 ar9485Modes_lowest_ob_db_tx_gain_1_0[][5] = {
+        /*  Addr       5G_HT20     5G_HT40     2G_HT40     2G_HT20 */
+        {0x0000a410, 0x000050d9, 0x000050d9, 0x000050d8, 0x000050d8},
+        {0x0000a500, 0x00022200, 0x00022200, 0x00000000, 0x00000000},
+        {0x0000a504, 0x05062002, 0x05062002, 0x04000002, 0x04000002},
+        {0x0000a508, 0x0c002e00, 0x0c002e00, 0x08000004, 0x08000004},
+        {0x0000a50c, 0x11062202, 0x11062202, 0x0d000200, 0x0d000200},
+        {0x0000a510, 0x17022e00, 0x17022e00, 0x11000202, 0x11000202},
+        {0x0000a514, 0x1d000ec2, 0x1d000ec2, 0x15000400, 0x15000400},
+        {0x0000a518, 0x25020ec0, 0x25020ec0, 0x19000402, 0x19000402},
+        {0x0000a51c, 0x2b020ec3, 0x2b020ec3, 0x1d000404, 0x1d000404},
+        {0x0000a520, 0x2f001f04, 0x2f001f04, 0x21000603, 0x21000603},
+        {0x0000a524, 0x35001fc4, 0x35001fc4, 0x25000605, 0x25000605},
+        {0x0000a528, 0x3c022f04, 0x3c022f04, 0x2a000a03, 0x2a000a03},
+        {0x0000a52c, 0x41023e85, 0x41023e85, 0x2c000a04, 0x2c000a04},
+        {0x0000a530, 0x48023ec6, 0x48023ec6, 0x2e000a20, 0x2e000a20},
+        {0x0000a534, 0x4d023f01, 0x4d023f01, 0x34000e20, 0x34000e20},
+        {0x0000a538, 0x53023f4b, 0x53023f4b, 0x38000e22, 0x38000e22},
+        {0x0000a53c, 0x5a027f09, 0x5a027f09, 0x3c000e24, 0x3c000e24},
+        {0x0000a540, 0x5f027fc9, 0x5f027fc9, 0x40000e26, 0x40000e26},
+        {0x0000a544, 0x6502feca, 0x6502feca, 0x43001640, 0x43001640},
+        {0x0000a548, 0x6b02ff4a, 0x6b02ff4a, 0x46001660, 0x46001660},
+        {0x0000a54c, 0x7203feca, 0x7203feca, 0x49001861, 0x49001861},
+        {0x0000a550, 0x7703ff0b, 0x7703ff0b, 0x4c001a81, 0x4c001a81},
+        {0x0000a554, 0x7d06ffcb, 0x7d06ffcb, 0x4f001a83, 0x4f001a83},
+        {0x0000a558, 0x8407ff0b, 0x8407ff0b, 0x54001c85, 0x54001c85},
+        {0x0000a55c, 0x8907ffcb, 0x8907ffcb, 0x58001ce5, 0x58001ce5},
+        {0x0000a560, 0x900fff0b, 0x900fff0b, 0x5b001ce9, 0x5b001ce9},
+        {0x0000a564, 0x960fffcb, 0x960fffcb, 0x60001eeb, 0x60001eeb},
+        {0x0000a568, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a56c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a570, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a574, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a578, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a57c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x00016044, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db},
+};
+
+static const u32 ar9485_1_0_baseband_core[][2] = {
+        /* Addr      allmodes  */
+        {0x00009800, 0xafe68e30},
+        {0x00009804, 0xfd14e000},
+        {0x00009808, 0x9c0a8f6b},
+        {0x0000980c, 0x04800000},
+        {0x00009814, 0x9280c00a},
+        {0x00009818, 0x00000000},
+        {0x0000981c, 0x00020028},
+        {0x00009834, 0x5f3ca3de},
+        {0x00009838, 0x0108ecff},
+        {0x0000983c, 0x14750600},
+        {0x00009880, 0x201fff00},
+        {0x00009884, 0x00001042},
+        {0x000098a4, 0x00200400},
+        {0x000098b0, 0x52440bbe},
+        {0x000098bc, 0x00000002},
+        {0x000098d0, 0x004b6a8e},
+        {0x000098d4, 0x00000820},
+        {0x000098dc, 0x00000000},
+        {0x000098f0, 0x00000000},
+        {0x000098f4, 0x00000000},
+        {0x00009c04, 0x00000000},
+        {0x00009c08, 0x03200000},
+        {0x00009c0c, 0x00000000},
+        {0x00009c10, 0x00000000},
+        {0x00009c14, 0x00046384},
+        {0x00009c18, 0x05b6b440},
+        {0x00009c1c, 0x00b6b440},
+        {0x00009d00, 0xc080a333},
+        {0x00009d04, 0x40206c10},
+        {0x00009d08, 0x009c4060},
+        {0x00009d0c, 0x1883800a},
+        {0x00009d10, 0x01834061},
+        {0x00009d14, 0x00c00400},
+        {0x00009d18, 0x00000000},
+        {0x00009d1c, 0x00000000},
+        {0x00009e08, 0x0038233c},
+        {0x00009e24, 0x990bb515},
+        {0x00009e28, 0x0a6f0000},
+        {0x00009e30, 0x06336f77},
+        {0x00009e34, 0x6af6532f},
+        {0x00009e38, 0x0cc80c00},
+        {0x00009e40, 0x0d261820},
+        {0x00009e4c, 0x00001004},
+        {0x00009e50, 0x00ff03f1},
+        {0x00009fc0, 0x80be4788},
+        {0x00009fc4, 0x0001efb5},
+        {0x00009fcc, 0x40000014},
+        {0x0000a20c, 0x00000000},
+        {0x0000a210, 0x00000000},
+        {0x0000a220, 0x00000000},
+        {0x0000a224, 0x00000000},
+        {0x0000a228, 0x10002310},
+        {0x0000a23c, 0x00000000},
+        {0x0000a244, 0x0c000000},
+        {0x0000a2a0, 0x00000001},
+        {0x0000a2c0, 0x00000001},
+        {0x0000a2c8, 0x00000000},
+        {0x0000a2cc, 0x18c43433},
+        {0x0000a2d4, 0x00000000},
+        {0x0000a2dc, 0x00000000},
+        {0x0000a2e0, 0x00000000},
+        {0x0000a2e4, 0x00000000},
+        {0x0000a2e8, 0x00000000},
+        {0x0000a2ec, 0x00000000},
+        {0x0000a2f0, 0x00000000},
+        {0x0000a2f4, 0x00000000},
+        {0x0000a2f8, 0x00000000},
+        {0x0000a344, 0x00000000},
+        {0x0000a34c, 0x00000000},
+        {0x0000a350, 0x0000a000},
+        {0x0000a364, 0x00000000},
+        {0x0000a370, 0x00000000},
+        {0x0000a390, 0x00000001},
+        {0x0000a394, 0x00000444},
+        {0x0000a398, 0x001f0e0f},
+        {0x0000a39c, 0x0075393f},
+        {0x0000a3a0, 0xb79f6427},
+        {0x0000a3a4, 0x00000000},
+        {0x0000a3a8, 0xaaaaaaaa},
+        {0x0000a3ac, 0x3c466478},
+        {0x0000a3c0, 0x20202020},
+        {0x0000a3c4, 0x22222220},
+        {0x0000a3c8, 0x20200020},
+        {0x0000a3cc, 0x20202020},
+        {0x0000a3d0, 0x20202020},
+        {0x0000a3d4, 0x20202020},
+        {0x0000a3d8, 0x20202020},
+        {0x0000a3dc, 0x20202020},
+        {0x0000a3e0, 0x20202020},
+        {0x0000a3e4, 0x20202020},
+        {0x0000a3e8, 0x20202020},
+        {0x0000a3ec, 0x20202020},
+        {0x0000a3f0, 0x00000000},
+        {0x0000a3f4, 0x00000006},
+        {0x0000a3f8, 0x0cdbd380},
+        {0x0000a3fc, 0x000f0f01},
+        {0x0000a400, 0x8fa91f01},
+        {0x0000a404, 0x00000000},
+        {0x0000a408, 0x0e79e5c6},
+        {0x0000a40c, 0x00820820},
+        {0x0000a414, 0x1ce739ce},
+        {0x0000a418, 0x2d0011ce},
+        {0x0000a41c, 0x1ce739ce},
+        {0x0000a420, 0x000001ce},
+        {0x0000a424, 0x1ce739ce},
+        {0x0000a428, 0x000001ce},
+        {0x0000a42c, 0x1ce739ce},
+        {0x0000a430, 0x1ce739ce},
+        {0x0000a434, 0x00000000},
+        {0x0000a438, 0x00001801},
+        {0x0000a43c, 0x00000000},
+        {0x0000a440, 0x00000000},
+        {0x0000a444, 0x00000000},
+        {0x0000a448, 0x04000000},
+        {0x0000a44c, 0x00000001},
+        {0x0000a450, 0x00010000},
+        {0x0000a458, 0x00000000},
+        {0x0000a5c4, 0x3fad9d74},
+        {0x0000a5c8, 0x0048060a},
+        {0x0000a5cc, 0x00000637},
+        {0x0000a760, 0x03020100},
+        {0x0000a764, 0x09080504},
+        {0x0000a768, 0x0d0c0b0a},
+        {0x0000a76c, 0x13121110},
+        {0x0000a770, 0x31301514},
+        {0x0000a774, 0x35343332},
+        {0x0000a778, 0x00000036},
+        {0x0000a780, 0x00000838},
+        {0x0000a7c0, 0x00000000},
+        {0x0000a7c4, 0xfffffffc},
+        {0x0000a7c8, 0x00000000},
+        {0x0000a7cc, 0x00000000},
+        {0x0000a7d0, 0x00000000},
+        {0x0000a7d4, 0x00000004},
+        {0x0000a7dc, 0x00000001},
+};
+
+static const u32 ar9485Modes_high_ob_db_tx_gain_1_0[][5] = {
+        /* Addr        5G_HT20     5G_HT40     2G_HT40    2G_HT20  */
+        {0x0000a410, 0x000050d9, 0x000050d9, 0x000050d8, 0x000050d8},
+        {0x0000a500, 0x00022200, 0x00022200, 0x00000000, 0x00000000},
+        {0x0000a504, 0x05062002, 0x05062002, 0x04000002, 0x04000002},
+        {0x0000a508, 0x0c002e00, 0x0c002e00, 0x08000004, 0x08000004},
+        {0x0000a50c, 0x11062202, 0x11062202, 0x0d000200, 0x0d000200},
+        {0x0000a510, 0x17022e00, 0x17022e00, 0x11000202, 0x11000202},
+        {0x0000a514, 0x1d000ec2, 0x1d000ec2, 0x15000400, 0x15000400},
+        {0x0000a518, 0x25020ec0, 0x25020ec0, 0x19000402, 0x19000402},
+        {0x0000a51c, 0x2b020ec3, 0x2b020ec3, 0x1d000404, 0x1d000404},
+        {0x0000a520, 0x2f001f04, 0x2f001f04, 0x21000603, 0x21000603},
+        {0x0000a524, 0x35001fc4, 0x35001fc4, 0x25000605, 0x25000605},
+        {0x0000a528, 0x3c022f04, 0x3c022f04, 0x2a000a03, 0x2a000a03},
+        {0x0000a52c, 0x41023e85, 0x41023e85, 0x2c000a04, 0x2c000a04},
+        {0x0000a530, 0x48023ec6, 0x48023ec6, 0x2e000a20, 0x2e000a20},
+        {0x0000a534, 0x4d023f01, 0x4d023f01, 0x34000e20, 0x34000e20},
+        {0x0000a538, 0x53023f4b, 0x53023f4b, 0x38000e22, 0x38000e22},
+        {0x0000a53c, 0x5a027f09, 0x5a027f09, 0x3c000e24, 0x3c000e24},
+        {0x0000a540, 0x5f027fc9, 0x5f027fc9, 0x40000e26, 0x40000e26},
+        {0x0000a544, 0x6502feca, 0x6502feca, 0x43001640, 0x43001640},
+        {0x0000a548, 0x6b02ff4a, 0x6b02ff4a, 0x46001660, 0x46001660},
+        {0x0000a54c, 0x7203feca, 0x7203feca, 0x49001861, 0x49001861},
+        {0x0000a550, 0x7703ff0b, 0x7703ff0b, 0x4c001a81, 0x4c001a81},
+        {0x0000a554, 0x7d06ffcb, 0x7d06ffcb, 0x4f001a83, 0x4f001a83},
+        {0x0000a558, 0x8407ff0b, 0x8407ff0b, 0x54001c85, 0x54001c85},
+        {0x0000a55c, 0x8907ffcb, 0x8907ffcb, 0x58001ce5, 0x58001ce5},
+        {0x0000a560, 0x900fff0b, 0x900fff0b, 0x5b001ce9, 0x5b001ce9},
+        {0x0000a564, 0x960fffcb, 0x960fffcb, 0x60001eeb, 0x60001eeb},
+        {0x0000a568, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a56c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a570, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a574, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a578, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a57c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x00016044, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db},
+};
+
+static const u32 ar9485Common_rx_gain_1_0[][2] = {
+        /* Addr      allmodes  */
+        {0x0000a000, 0x00010000},
+        {0x0000a004, 0x00030002},
+        {0x0000a008, 0x00050004},
+        {0x0000a00c, 0x00810080},
+        {0x0000a010, 0x01800082},
+        {0x0000a014, 0x01820181},
+        {0x0000a018, 0x01840183},
+        {0x0000a01c, 0x01880185},
+        {0x0000a020, 0x018a0189},
+        {0x0000a024, 0x02850284},
+        {0x0000a028, 0x02890288},
+        {0x0000a02c, 0x03850384},
+        {0x0000a030, 0x03890388},
+        {0x0000a034, 0x038b038a},
+        {0x0000a038, 0x038d038c},
+        {0x0000a03c, 0x03910390},
+        {0x0000a040, 0x03930392},
+        {0x0000a044, 0x03950394},
+        {0x0000a048, 0x00000396},
+        {0x0000a04c, 0x00000000},
+        {0x0000a050, 0x00000000},
+        {0x0000a054, 0x00000000},
+        {0x0000a058, 0x00000000},
+        {0x0000a05c, 0x00000000},
+        {0x0000a060, 0x00000000},
+        {0x0000a064, 0x00000000},
+        {0x0000a068, 0x00000000},
+        {0x0000a06c, 0x00000000},
+        {0x0000a070, 0x00000000},
+        {0x0000a074, 0x00000000},
+        {0x0000a078, 0x00000000},
+        {0x0000a07c, 0x00000000},
+        {0x0000a080, 0x28282828},
+        {0x0000a084, 0x28282828},
+        {0x0000a088, 0x28282828},
+        {0x0000a08c, 0x28282828},
+        {0x0000a090, 0x28282828},
+        {0x0000a094, 0x21212128},
+        {0x0000a098, 0x171c1c1c},
+        {0x0000a09c, 0x02020212},
+        {0x0000a0a0, 0x00000202},
+        {0x0000a0a4, 0x00000000},
+        {0x0000a0a8, 0x00000000},
+        {0x0000a0ac, 0x00000000},
+        {0x0000a0b0, 0x00000000},
+        {0x0000a0b4, 0x00000000},
+        {0x0000a0b8, 0x00000000},
+        {0x0000a0bc, 0x00000000},
+        {0x0000a0c0, 0x001f0000},
+        {0x0000a0c4, 0x111f1100},
+        {0x0000a0c8, 0x111d111e},
+        {0x0000a0cc, 0x111b111c},
+        {0x0000a0d0, 0x22032204},
+        {0x0000a0d4, 0x22012202},
+        {0x0000a0d8, 0x221f2200},
+        {0x0000a0dc, 0x221d221e},
+        {0x0000a0e0, 0x33013302},
+        {0x0000a0e4, 0x331f3300},
+        {0x0000a0e8, 0x4402331e},
+        {0x0000a0ec, 0x44004401},
+        {0x0000a0f0, 0x441e441f},
+        {0x0000a0f4, 0x55015502},
+        {0x0000a0f8, 0x551f5500},
+        {0x0000a0fc, 0x6602551e},
+        {0x0000a100, 0x66006601},
+        {0x0000a104, 0x661e661f},
+        {0x0000a108, 0x7703661d},
+        {0x0000a10c, 0x77017702},
+        {0x0000a110, 0x00007700},
+        {0x0000a114, 0x00000000},
+        {0x0000a118, 0x00000000},
+        {0x0000a11c, 0x00000000},
+        {0x0000a120, 0x00000000},
+        {0x0000a124, 0x00000000},
+        {0x0000a128, 0x00000000},
+        {0x0000a12c, 0x00000000},
+        {0x0000a130, 0x00000000},
+        {0x0000a134, 0x00000000},
+        {0x0000a138, 0x00000000},
+        {0x0000a13c, 0x00000000},
+        {0x0000a140, 0x001f0000},
+        {0x0000a144, 0x111f1100},
+        {0x0000a148, 0x111d111e},
+        {0x0000a14c, 0x111b111c},
+        {0x0000a150, 0x22032204},
+        {0x0000a154, 0x22012202},
+        {0x0000a158, 0x221f2200},
+        {0x0000a15c, 0x221d221e},
+        {0x0000a160, 0x33013302},
+        {0x0000a164, 0x331f3300},
+        {0x0000a168, 0x4402331e},
+        {0x0000a16c, 0x44004401},
+        {0x0000a170, 0x441e441f},
+        {0x0000a174, 0x55015502},
+        {0x0000a178, 0x551f5500},
+        {0x0000a17c, 0x6602551e},
+        {0x0000a180, 0x66006601},
+        {0x0000a184, 0x661e661f},
+        {0x0000a188, 0x7703661d},
+        {0x0000a18c, 0x77017702},
+        {0x0000a190, 0x00007700},
+        {0x0000a194, 0x00000000},
+        {0x0000a198, 0x00000000},
+        {0x0000a19c, 0x00000000},
+        {0x0000a1a0, 0x00000000},
+        {0x0000a1a4, 0x00000000},
+        {0x0000a1a8, 0x00000000},
+        {0x0000a1ac, 0x00000000},
+        {0x0000a1b0, 0x00000000},
+        {0x0000a1b4, 0x00000000},
+        {0x0000a1b8, 0x00000000},
+        {0x0000a1bc, 0x00000000},
+        {0x0000a1c0, 0x00000000},
+        {0x0000a1c4, 0x00000000},
+        {0x0000a1c8, 0x00000000},
+        {0x0000a1cc, 0x00000000},
+        {0x0000a1d0, 0x00000000},
+        {0x0000a1d4, 0x00000000},
+        {0x0000a1d8, 0x00000000},
+        {0x0000a1dc, 0x00000000},
+        {0x0000a1e0, 0x00000000},
+        {0x0000a1e4, 0x00000000},
+        {0x0000a1e8, 0x00000000},
+        {0x0000a1ec, 0x00000000},
+        {0x0000a1f0, 0x00000396},
+        {0x0000a1f4, 0x00000396},
+        {0x0000a1f8, 0x00000396},
+        {0x0000a1fc, 0x00000296},
+};
+
+static const u32 ar9485_1_0_pcie_phy_pll_on_clkreq_enable_L1[][2] = {
+        /*   Addr    allmodes  */
+        {0x00018c00, 0x10252e5e},
+        {0x00018c04, 0x000801d8},
+        {0x00018c08, 0x0000580c},
+};
+
+static const u32 ar9485_1_0_pcie_phy_clkreq_enable_L1[][2] = {
+        /*  Addr    allmodes   */
+        {0x00018c00, 0x10253e5e},
+        {0x00018c04, 0x000801d8},
+        {0x00018c08, 0x0000580c},
+};
+
+static const u32 ar9485_1_0_soc_preamble[][2] = {
+        /*   Addr     allmodes */
+        {0x000040a4, 0x00a0c9c9},
+        {0x00007048, 0x00000004},
+};
+
+static const u32 ar9485_fast_clock_1_0_baseband_postamble[][3] = {
+        /*   Addr      5G_HT20     5G_HT40 */
+        {0x00009e00, 0x03721821, 0x03721821},
+        {0x0000a230, 0x0000400b, 0x00004016},
+        {0x0000a254, 0x00000898, 0x00001130},
+};
+
+static const u32 ar9485_1_0_baseband_postamble[][5] = {
+        /* Addr        5G_HT20     5G_HT40     2G_HT40     2G_HT20 */
+        {0x00009810, 0xd00a8005, 0xd00a8005, 0xd00a8005, 0xd00a8005},
+        {0x00009820, 0x206a002e, 0x206a002e, 0x206a002e, 0x206a002e},
+        {0x00009824, 0x5ac640d0, 0x5ac640d0, 0x5ac640d0, 0x5ac640d0},
+        {0x00009828, 0x06903081, 0x06903081, 0x06903881, 0x06903881},
+        {0x0000982c, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4},
+        {0x00009830, 0x0000059c, 0x0000059c, 0x0000059c, 0x0000059c},
+        {0x00009c00, 0x00000044, 0x00000044, 0x00000044, 0x00000044},
+        {0x00009e00, 0x0372161e, 0x0372161e, 0x037216a0, 0x037216a0},
+        {0x00009e04, 0x00182020, 0x00182020, 0x00182020, 0x00182020},
+        {0x00009e0c, 0x6c4000e2, 0x6d4000e2, 0x6d4000e2, 0x6c4000e2},
+        {0x00009e10, 0x7ec88d2e, 0x7ec88d2e, 0x7ec80d2e, 0x7ec80d2e},
+        {0x00009e14, 0x31395d5e, 0x3139605e, 0x3139605e, 0x31395d5e},
+        {0x00009e18, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
+        {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
+        {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946222, 0xcf946222},
+        {0x00009e44, 0x02321e27, 0x02321e27, 0x02282324, 0x02282324},
+        {0x00009e48, 0x5030201a, 0x5030201a, 0x50302010, 0x50302010},
+        {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
+        {0x0000a204, 0x01303fc0, 0x01303fc4, 0x01303fc4, 0x01303fc0},
+        {0x0000a208, 0x00000104, 0x00000104, 0x00000004, 0x00000004},
+        {0x0000a230, 0x0000400a, 0x00004014, 0x00004016, 0x0000400b},
+        {0x0000a234, 0x10000fff, 0x10000fff, 0x10000fff, 0x10000fff},
+        {0x0000a238, 0xffb81018, 0xffb81018, 0xffb81018, 0xffb81018},
+        {0x0000a250, 0x00000000, 0x00000000, 0x00000210, 0x00000108},
+        {0x0000a254, 0x000007d0, 0x00000fa0, 0x00001130, 0x00000898},
+        {0x0000a258, 0x02020002, 0x02020002, 0x02020002, 0x02020002},
+        {0x0000a25c, 0x01000e0e, 0x01000e0e, 0x01000e0e, 0x01000e0e},
+        {0x0000a260, 0x3a021501, 0x3a021501, 0x3a021501, 0x3a021501},
+        {0x0000a264, 0x00000e0e, 0x00000e0e, 0x00000e0e, 0x00000e0e},
+        {0x0000a280, 0x00000007, 0x00000007, 0x0000000b, 0x0000000b},
+        {0x0000a284, 0x00000000, 0x00000000, 0x000002a0, 0x000002a0},
+        {0x0000a288, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x0000a28c, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2d0, 0x00071981, 0x00071981, 0x00071981, 0x00071982},
+        {0x0000a2d8, 0xf999a83a, 0xf999a83a, 0xf999a83a, 0xf999a83a},
+        {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x0000be04, 0x00802020, 0x00802020, 0x00802020, 0x00802020},
+        {0x0000be18, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
+};
+
+static const u32 ar9485Modes_low_ob_db_tx_gain_1_0[][5] = {
+        /*  Addr      5G_HT20    5G_HT40     2G_HT40     2G_HT20   */
+        {0x0000a410, 0x000050d9, 0x000050d9, 0x000050d8, 0x000050d8},
+        {0x0000a500, 0x00022200, 0x00022200, 0x00000000, 0x00000000},
+        {0x0000a504, 0x05062002, 0x05062002, 0x04000002, 0x04000002},
+        {0x0000a508, 0x0c002e00, 0x0c002e00, 0x08000004, 0x08000004},
+        {0x0000a50c, 0x11062202, 0x11062202, 0x0d000200, 0x0d000200},
+        {0x0000a510, 0x17022e00, 0x17022e00, 0x11000202, 0x11000202},
+        {0x0000a514, 0x1d000ec2, 0x1d000ec2, 0x15000400, 0x15000400},
+        {0x0000a518, 0x25020ec0, 0x25020ec0, 0x19000402, 0x19000402},
+        {0x0000a51c, 0x2b020ec3, 0x2b020ec3, 0x1d000404, 0x1d000404},
+        {0x0000a520, 0x2f001f04, 0x2f001f04, 0x21000603, 0x21000603},
+        {0x0000a524, 0x35001fc4, 0x35001fc4, 0x25000605, 0x25000605},
+        {0x0000a528, 0x3c022f04, 0x3c022f04, 0x2a000a03, 0x2a000a03},
+        {0x0000a52c, 0x41023e85, 0x41023e85, 0x2c000a04, 0x2c000a04},
+        {0x0000a530, 0x48023ec6, 0x48023ec6, 0x2e000a20, 0x2e000a20},
+        {0x0000a534, 0x4d023f01, 0x4d023f01, 0x34000e20, 0x34000e20},
+        {0x0000a538, 0x53023f4b, 0x53023f4b, 0x38000e22, 0x38000e22},
+        {0x0000a53c, 0x5a027f09, 0x5a027f09, 0x3c000e24, 0x3c000e24},
+        {0x0000a540, 0x5f027fc9, 0x5f027fc9, 0x40000e26, 0x40000e26},
+        {0x0000a544, 0x6502feca, 0x6502feca, 0x43001640, 0x43001640},
+        {0x0000a548, 0x6b02ff4a, 0x6b02ff4a, 0x46001660, 0x46001660},
+        {0x0000a54c, 0x7203feca, 0x7203feca, 0x49001861, 0x49001861},
+        {0x0000a550, 0x7703ff0b, 0x7703ff0b, 0x4c001a81, 0x4c001a81},
+        {0x0000a554, 0x7d06ffcb, 0x7d06ffcb, 0x4f001a83, 0x4f001a83},
+        {0x0000a558, 0x8407ff0b, 0x8407ff0b, 0x54001c85, 0x54001c85},
+        {0x0000a55c, 0x8907ffcb, 0x8907ffcb, 0x58001ce5, 0x58001ce5},
+        {0x0000a560, 0x900fff0b, 0x900fff0b, 0x5b001ce9, 0x5b001ce9},
+        {0x0000a564, 0x960fffcb, 0x960fffcb, 0x60001eeb, 0x60001eeb},
+        {0x0000a568, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a56c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a570, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a574, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a578, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x0000a57c, 0x9c1fff0b, 0x9c1fff0b, 0x60001eeb, 0x60001eeb},
+        {0x00016044, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db, 0x05b6b2db},
+};
+
+static const u32 ar9485_1_0_pcie_phy_clkreq_disable_L1[][2] = {
+        /*   Addr     allmodes */
+        {0x00018c00, 0x10213e5e},
+        {0x00018c04, 0x000801d8},
+        {0x00018c08, 0x0000580c},
+};
+
+static const u32 ar9485_1_0_radio_postamble[][2] = {
+        /*   Addr     allmodes */
+        {0x0001609c, 0x0b283f31},
+        {0x000160ac, 0x24611800},
+        {0x000160b0, 0x03284f3e},
+        {0x0001610c, 0x00170000},
+        {0x00016140, 0x10804008},
+};
+
+static const u32 ar9485_1_0_mac_core[][2] = {
+        /*  Addr      allmodes */
+        {0x00000008, 0x00000000},
+        {0x00000030, 0x00020085},
+        {0x00000034, 0x00000005},
+        {0x00000040, 0x00000000},
+        {0x00000044, 0x00000000},
+        {0x00000048, 0x00000008},
+        {0x0000004c, 0x00000010},
+        {0x00000050, 0x00000000},
+        {0x00001040, 0x002ffc0f},
+        {0x00001044, 0x002ffc0f},
+        {0x00001048, 0x002ffc0f},
+        {0x0000104c, 0x002ffc0f},
+        {0x00001050, 0x002ffc0f},
+        {0x00001054, 0x002ffc0f},
+        {0x00001058, 0x002ffc0f},
+        {0x0000105c, 0x002ffc0f},
+        {0x00001060, 0x002ffc0f},
+        {0x00001064, 0x002ffc0f},
+        {0x000010f0, 0x00000100},
+        {0x00001270, 0x00000000},
+        {0x000012b0, 0x00000000},
+        {0x000012f0, 0x00000000},
+        {0x0000143c, 0x00000000},
+        {0x0000147c, 0x00000000},
+        {0x00008000, 0x00000000},
+        {0x00008004, 0x00000000},
+        {0x00008008, 0x00000000},
+        {0x0000800c, 0x00000000},
+        {0x00008018, 0x00000000},
+        {0x00008020, 0x00000000},
+        {0x00008038, 0x00000000},
+        {0x0000803c, 0x00000000},
+        {0x00008040, 0x00000000},
+        {0x00008044, 0x00000000},
+        {0x00008048, 0x00000000},
+        {0x0000804c, 0xffffffff},
+        {0x00008054, 0x00000000},
+        {0x00008058, 0x00000000},
+        {0x0000805c, 0x000fc78f},
+        {0x00008060, 0x0000000f},
+        {0x00008064, 0x00000000},
+        {0x00008070, 0x00000310},
+        {0x00008074, 0x00000020},
+        {0x00008078, 0x00000000},
+        {0x0000809c, 0x0000000f},
+        {0x000080a0, 0x00000000},
+        {0x000080a4, 0x02ff0000},
+        {0x000080a8, 0x0e070605},
+        {0x000080ac, 0x0000000d},
+        {0x000080b0, 0x00000000},
+        {0x000080b4, 0x00000000},
+        {0x000080b8, 0x00000000},
+        {0x000080bc, 0x00000000},
+        {0x000080c0, 0x2a800000},
+        {0x000080c4, 0x06900168},
+        {0x000080c8, 0x13881c20},
+        {0x000080cc, 0x01f40000},
+        {0x000080d0, 0x00252500},
+        {0x000080d4, 0x00a00000},
+        {0x000080d8, 0x00400000},
+        {0x000080dc, 0x00000000},
+        {0x000080e0, 0xffffffff},
+        {0x000080e4, 0x0000ffff},
+        {0x000080e8, 0x3f3f3f3f},
+        {0x000080ec, 0x00000000},
+        {0x000080f0, 0x00000000},
+        {0x000080f4, 0x00000000},
+        {0x000080fc, 0x00020000},
+        {0x00008100, 0x00000000},
+        {0x00008108, 0x00000052},
+        {0x0000810c, 0x00000000},
+        {0x00008110, 0x00000000},
+        {0x00008114, 0x000007ff},
+        {0x00008118, 0x000000aa},
+        {0x0000811c, 0x00003210},
+        {0x00008124, 0x00000000},
+        {0x00008128, 0x00000000},
+        {0x0000812c, 0x00000000},
+        {0x00008130, 0x00000000},
+        {0x00008134, 0x00000000},
+        {0x00008138, 0x00000000},
+        {0x0000813c, 0x0000ffff},
+        {0x00008144, 0xffffffff},
+        {0x00008168, 0x00000000},
+        {0x0000816c, 0x00000000},
+        {0x00008170, 0x18486200},
+        {0x00008174, 0x33332210},
+        {0x00008178, 0x00000000},
+        {0x0000817c, 0x00020000},
+        {0x000081c0, 0x00000000},
+        {0x000081c4, 0x33332210},
+        {0x000081c8, 0x00000000},
+        {0x000081cc, 0x00000000},
+        {0x000081d4, 0x00000000},
+        {0x000081ec, 0x00000000},
+        {0x000081f0, 0x00000000},
+        {0x000081f4, 0x00000000},
+        {0x000081f8, 0x00000000},
+        {0x000081fc, 0x00000000},
+        {0x00008240, 0x00100000},
+        {0x00008244, 0x0010f400},
+        {0x00008248, 0x00000800},
+        {0x0000824c, 0x0001e800},
+        {0x00008250, 0x00000000},
+        {0x00008254, 0x00000000},
+        {0x00008258, 0x00000000},
+        {0x0000825c, 0x40000000},
+        {0x00008260, 0x00080922},
+        {0x00008264, 0x9ca00010},
+        {0x00008268, 0xffffffff},
+        {0x0000826c, 0x0000ffff},
+        {0x00008270, 0x00000000},
+        {0x00008274, 0x40000000},
+        {0x00008278, 0x003e4180},
+        {0x0000827c, 0x00000004},
+        {0x00008284, 0x0000002c},
+        {0x00008288, 0x0000002c},
+        {0x0000828c, 0x000000ff},
+        {0x00008294, 0x00000000},
+        {0x00008298, 0x00000000},
+        {0x0000829c, 0x00000000},
+        {0x00008300, 0x00000140},
+        {0x00008314, 0x00000000},
+        {0x0000831c, 0x0000010d},
+        {0x00008328, 0x00000000},
+        {0x0000832c, 0x00000007},
+        {0x00008330, 0x00000302},
+        {0x00008334, 0x00000700},
+        {0x00008338, 0x00ff0000},
+        {0x0000833c, 0x02400000},
+        {0x00008340, 0x000107ff},
+        {0x00008344, 0xa248105b},
+        {0x00008348, 0x008f0000},
+        {0x0000835c, 0x00000000},
+        {0x00008360, 0xffffffff},
+        {0x00008364, 0xffffffff},
+        {0x00008368, 0x00000000},
+        {0x00008370, 0x00000000},
+        {0x00008374, 0x000000ff},
+        {0x00008378, 0x00000000},
+        {0x0000837c, 0x00000000},
+        {0x00008380, 0xffffffff},
+        {0x00008384, 0xffffffff},
+        {0x00008390, 0xffffffff},
+        {0x00008394, 0xffffffff},
+        {0x00008398, 0x00000000},
+        {0x0000839c, 0x00000000},
+        {0x000083a0, 0x00000000},
+        {0x000083a4, 0x0000fa14},
+        {0x000083a8, 0x000f0c00},
+        {0x000083ac, 0x33332210},
+        {0x000083b0, 0x33332210},
+        {0x000083b4, 0x33332210},
+        {0x000083b8, 0x33332210},
+        {0x000083bc, 0x00000000},
+        {0x000083c0, 0x00000000},
+        {0x000083c4, 0x00000000},
+        {0x000083c8, 0x00000000},
+        {0x000083cc, 0x00000200},
+        {0x000083d0, 0x000301ff},
+};
+#endif
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index 4210a9306955..9b5501f90010 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -311,7 +311,7 @@ void ath_rx_cleanup(struct ath_softc *sc);
 int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp);
 struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype);
 void ath_tx_cleanupq(struct ath_softc *sc, struct ath_txq *txq);
-void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx);
+bool ath_drain_all_txq(struct ath_softc *sc, bool retry_tx);
 void ath_draintxq(struct ath_softc *sc,
                      struct ath_txq *txq, bool retry_tx);
 void ath_tx_node_init(struct ath_softc *sc, struct ath_node *an);
diff --git a/drivers/net/wireless/ath/ath9k/beacon.c b/drivers/net/wireless/ath/ath9k/beacon.c
index 47bedd82e9a9..5e108c086904 100644
--- a/drivers/net/wireless/ath/ath9k/beacon.c
+++ b/drivers/net/wireless/ath/ath9k/beacon.c
@@ -46,8 +46,8 @@ int ath_beaconq_config(struct ath_softc *sc)
         }
 
         if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to update h/w beacon queue parameters\n");
+                ath_err(common,
+                        "Unable to update h/w beacon queue parameters\n");
                 return 0;
         } else {
                 ath9k_hw_resettxqueue(ah, sc->beacon.beaconq);
@@ -120,11 +120,11 @@ static void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
         memset(&txctl, 0, sizeof(struct ath_tx_control));
         txctl.txq = sc->beacon.cabq;
 
-        ath_print(common, ATH_DBG_XMIT,
-                  "transmitting CABQ packet, skb: %p\n", skb);
+        ath_dbg(common, ATH_DBG_XMIT,
+                "transmitting CABQ packet, skb: %p\n", skb);
 
         if (ath_tx_start(hw, skb, &txctl) != 0) {
-                ath_print(common, ATH_DBG_XMIT, "CABQ TX failed\n");
+                ath_dbg(common, ATH_DBG_XMIT, "CABQ TX failed\n");
                 dev_kfree_skb_any(skb);
         }
 }
@@ -189,8 +189,7 @@ static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
                 dev_kfree_skb_any(skb);
                 bf->bf_mpdu = NULL;
                 bf->bf_buf_addr = 0;
-                ath_print(common, ATH_DBG_FATAL,
-                          "dma_mapping_error on beaconing\n");
+                ath_err(common, "dma_mapping_error on beaconing\n");
                 return NULL;
         }
 
@@ -210,8 +209,8 @@ static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
 
         if (skb && cabq_depth) {
                 if (sc->nvifs > 1) {
-                        ath_print(common, ATH_DBG_BEACON,
-                                  "Flushing previous cabq traffic\n");
+                        ath_dbg(common, ATH_DBG_BEACON,
+                                "Flushing previous cabq traffic\n");
                         ath_draintxq(sc, cabq, false);
                 }
         }
@@ -283,7 +282,7 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
         /* NB: the beacon data buffer must be 32-bit aligned. */
         skb = ieee80211_beacon_get(sc->hw, vif);
         if (skb == NULL) {
-                ath_print(common, ATH_DBG_BEACON, "cannot get skb\n");
+                ath_dbg(common, ATH_DBG_BEACON, "cannot get skb\n");
                 return -ENOMEM;
         }
 
@@ -307,10 +306,9 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
                 tsfadjust = intval * avp->av_bslot / ATH_BCBUF;
                 avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust));
 
-                ath_print(common, ATH_DBG_BEACON,
-                          "stagger beacons, bslot %d intval "
-                          "%u tsfadjust %llu\n",
-                          avp->av_bslot, intval, (unsigned long long)tsfadjust);
+                ath_dbg(common, ATH_DBG_BEACON,
+                        "stagger beacons, bslot %d intval %u tsfadjust %llu\n",
+                        avp->av_bslot, intval, (unsigned long long)tsfadjust);
 
                 ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp =
                         avp->tsf_adjust;
@@ -324,8 +322,7 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
                 dev_kfree_skb_any(skb);
                 bf->bf_mpdu = NULL;
                 bf->bf_buf_addr = 0;
-                ath_print(common, ATH_DBG_FATAL,
-                          "dma_mapping_error on beacon alloc\n");
+                ath_err(common, "dma_mapping_error on beacon alloc\n");
                 return -ENOMEM;
         }
 
@@ -382,13 +379,13 @@ void ath_beacon_tasklet(unsigned long data)
                 sc->beacon.bmisscnt++;
 
                 if (sc->beacon.bmisscnt < BSTUCK_THRESH) {
-                        ath_print(common, ATH_DBG_BSTUCK,
-                                  "missed %u consecutive beacons\n",
-                                  sc->beacon.bmisscnt);
+                        ath_dbg(common, ATH_DBG_BSTUCK,
+                                "missed %u consecutive beacons\n",
+                                sc->beacon.bmisscnt);
                         ath9k_hw_bstuck_nfcal(ah);
                 } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) {
-                        ath_print(common, ATH_DBG_BSTUCK,
-                                  "beacon is officially stuck\n");
+                        ath_dbg(common, ATH_DBG_BSTUCK,
+                                "beacon is officially stuck\n");
                         sc->sc_flags |= SC_OP_TSF_RESET;
                         ath_reset(sc, true);
                 }
@@ -397,9 +394,9 @@ void ath_beacon_tasklet(unsigned long data)
         }
 
         if (sc->beacon.bmisscnt != 0) {
-                ath_print(common, ATH_DBG_BSTUCK,
-                          "resume beacon xmit after %u misses\n",
-                          sc->beacon.bmisscnt);
+                ath_dbg(common, ATH_DBG_BSTUCK,
+                        "resume beacon xmit after %u misses\n",
+                        sc->beacon.bmisscnt);
                 sc->beacon.bmisscnt = 0;
         }
 
@@ -425,9 +422,9 @@ void ath_beacon_tasklet(unsigned long data)
         vif = sc->beacon.bslot[slot];
         aphy = sc->beacon.bslot_aphy[slot];
 
-        ath_print(common, ATH_DBG_BEACON,
-                  "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
-                  slot, tsf, tsftu, intval, vif);
+        ath_dbg(common, ATH_DBG_BEACON,
+                "slot %d [tsf %llu tsftu %u intval %u] vif %p\n",
+                slot, tsf, tsftu, intval, vif);
 
         bfaddr = 0;
         if (vif) {
@@ -469,8 +466,8 @@ void ath_beacon_tasklet(unsigned long data)
                  * are still pending on the queue.
                  */
                 if (!ath9k_hw_stoptxdma(ah, sc->beacon.beaconq)) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                "beacon queue %u did not stop?\n", sc->beacon.beaconq);
+                        ath_err(common, "beacon queue %u did not stop?\n",
+                                sc->beacon.beaconq);
                 }
 
                 /* NB: cabq traffic should already be queued and primed */
@@ -556,8 +553,8 @@ static void ath_beacon_config_sta(struct ath_softc *sc,
 
         /* No need to configure beacon if we are not associated */
         if (!common->curaid) {
-                ath_print(common, ATH_DBG_BEACON,
-                         "STA is not yet associated..skipping beacon config\n");
+                ath_dbg(common, ATH_DBG_BEACON,
+                        "STA is not yet associated..skipping beacon config\n");
                 return;
         }
 
@@ -650,11 +647,11 @@ static void ath_beacon_config_sta(struct ath_softc *sc,
         /* TSF out of range threshold fixed at 1 second */
         bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
 
-        ath_print(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
-        ath_print(common, ATH_DBG_BEACON,
-                  "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
-                  bs.bs_bmissthreshold, bs.bs_sleepduration,
-                  bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
+        ath_dbg(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
+        ath_dbg(common, ATH_DBG_BEACON,
+                "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
+                bs.bs_bmissthreshold, bs.bs_sleepduration,
+                bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
 
         /* Set the computed STA beacon timers */
 
@@ -690,9 +687,9 @@ static void ath_beacon_config_adhoc(struct ath_softc *sc,
                 nexttbtt += intval;
         } while (nexttbtt < tsftu);
 
-        ath_print(common, ATH_DBG_BEACON,
-                  "IBSS nexttbtt %u intval %u (%u)\n",
-                  nexttbtt, intval, conf->beacon_interval);
+        ath_dbg(common, ATH_DBG_BEACON,
+                "IBSS nexttbtt %u intval %u (%u)\n",
+                nexttbtt, intval, conf->beacon_interval);
 
         /*
          * In IBSS mode enable the beacon timers but only enable SWBA interrupts
@@ -755,8 +752,8 @@ void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
                 ath_beacon_config_sta(sc, cur_conf);
                 break;
         default:
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Unsupported beaconing mode\n");
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Unsupported beaconing mode\n");
                 return;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/calib.c b/drivers/net/wireless/ath/ath9k/calib.c
index 6d509484b5f6..b68a1acbddd0 100644
--- a/drivers/net/wireless/ath/ath9k/calib.c
+++ b/drivers/net/wireless/ath/ath9k/calib.c
@@ -97,12 +97,12 @@ static void ath9k_hw_update_nfcal_hist_buffer(struct ath_hw *ah,
                 if (h[i].privNF > limit->max) {
                         high_nf_mid = true;
 
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "NFmid[%d] (%d) > MAX (%d), %s\n",
-                                  i, h[i].privNF, limit->max,
-                                  (cal->nfcal_interference ?
-                                   "not corrected (due to interference)" :
-                                   "correcting to MAX"));
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "NFmid[%d] (%d) > MAX (%d), %s\n",
+                                i, h[i].privNF, limit->max,
+                                (cal->nfcal_interference ?
+                                 "not corrected (due to interference)" :
+                                 "correcting to MAX"));
 
                         /*
                          * Normally we limit the average noise floor by the
@@ -180,18 +180,18 @@ bool ath9k_hw_reset_calvalid(struct ath_hw *ah)
                 return true;
 
         if (currCal->calState != CAL_DONE) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "Calibration state incorrect, %d\n",
-                          currCal->calState);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Calibration state incorrect, %d\n",
+                        currCal->calState);
                 return true;
         }
 
         if (!(ah->supp_cals & currCal->calData->calType))
                 return true;
 
-        ath_print(common, ATH_DBG_CALIBRATE,
-                  "Resetting Cal %d state for channel %u\n",
-                  currCal->calData->calType, conf->channel->center_freq);
+        ath_dbg(common, ATH_DBG_CALIBRATE,
+                "Resetting Cal %d state for channel %u\n",
+                currCal->calData->calType, conf->channel->center_freq);
 
         ah->caldata->CalValid &= ~currCal->calData->calType;
         currCal->calState = CAL_WAITING;
@@ -279,9 +279,9 @@ void ath9k_hw_loadnf(struct ath_hw *ah, struct ath9k_channel *chan)
          * noisefloor until the next calibration timer.
          */
         if (j == 1000) {
-                ath_print(common, ATH_DBG_ANY, "Timeout while waiting for nf "
-                          "to load: AR_PHY_AGC_CONTROL=0x%x\n",
-                          REG_READ(ah, AR_PHY_AGC_CONTROL));
+                ath_dbg(common, ATH_DBG_ANY,
+                        "Timeout while waiting for nf to load: AR_PHY_AGC_CONTROL=0x%x\n",
+                        REG_READ(ah, AR_PHY_AGC_CONTROL));
                 return;
         }
 
@@ -318,19 +318,19 @@ static void ath9k_hw_nf_sanitize(struct ath_hw *ah, s16 *nf)
                 if (!nf[i])
                         continue;
 
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "NF calibrated [%s] [chain %d] is %d\n",
-                          (i >= 3 ? "ext" : "ctl"), i % 3, nf[i]);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "NF calibrated [%s] [chain %d] is %d\n",
+                        (i >= 3 ? "ext" : "ctl"), i % 3, nf[i]);
 
                 if (nf[i] > ATH9K_NF_TOO_HIGH) {
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "NF[%d] (%d) > MAX (%d), correcting to MAX",
-                                  i, nf[i], ATH9K_NF_TOO_HIGH);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "NF[%d] (%d) > MAX (%d), correcting to MAX\n",
+                                i, nf[i], ATH9K_NF_TOO_HIGH);
                         nf[i] = limit->max;
                 } else if (nf[i] < limit->min) {
-                        ath_print(common, ATH_DBG_CALIBRATE,
-                                  "NF[%d] (%d) < MIN (%d), correcting to NOM",
-                                  i, nf[i], limit->min);
+                        ath_dbg(common, ATH_DBG_CALIBRATE,
+                                "NF[%d] (%d) < MIN (%d), correcting to NOM\n",
+                                i, nf[i], limit->min);
                         nf[i] = limit->nominal;
                 }
         }
@@ -347,8 +347,8 @@ bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan)
 
         chan->channelFlags &= (~CHANNEL_CW_INT);
         if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "NF did not complete in calibration window\n");
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "NF did not complete in calibration window\n");
                 return false;
         }
 
@@ -357,10 +357,9 @@ bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan)
         nf = nfarray[0];
         if (ath9k_hw_get_nf_thresh(ah, c->band, &nfThresh)
             && nf > nfThresh) {
-                ath_print(common, ATH_DBG_CALIBRATE,
-                          "noise floor failed detected; "
-                          "detected %d, threshold %d\n",
-                          nf, nfThresh);
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "noise floor failed detected; detected %d, threshold %d\n",
+                        nf, nfThresh);
                 chan->channelFlags |= CHANNEL_CW_INT;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/common.c b/drivers/net/wireless/ath/ath9k/common.c
index 48b07c319a7f..df1998d48253 100644
--- a/drivers/net/wireless/ath/ath9k/common.c
+++ b/drivers/net/wireless/ath/ath9k/common.c
@@ -180,8 +180,8 @@ void ath9k_cmn_btcoex_bt_stomp(struct ath_common *common,
                                            AR_STOMP_NONE_WLAN_WGHT);
                 break;
         default:
-                ath_print(common, ATH_DBG_BTCOEX,
-                          "Invalid Stomptype\n");
+                ath_dbg(common, ATH_DBG_BTCOEX,
+                        "Invalid Stomptype\n");
                 break;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/common.h b/drivers/net/wireless/ath/ath9k/common.h
index 4c04ee85ff0e..a126bddebb0a 100644
--- a/drivers/net/wireless/ath/ath9k/common.h
+++ b/drivers/net/wireless/ath/ath9k/common.h
@@ -17,7 +17,6 @@
 #include <net/mac80211.h>
 
 #include "../ath.h"
-#include "../debug.h"
 
 #include "hw.h"
 #include "hw-ops.h"
diff --git a/drivers/net/wireless/ath/ath9k/eeprom.c b/drivers/net/wireless/ath/ath9k/eeprom.c
index 2bbf94d0191e..fda533cfd881 100644
--- a/drivers/net/wireless/ath/ath9k/eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom.c
@@ -273,8 +273,8 @@ void ath9k_hw_update_regulatory_maxpower(struct ath_hw *ah)
                 regulatory->max_power_level += INCREASE_MAXPOW_BY_THREE_CHAIN;
                 break;
         default:
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Invalid chainmask configuration\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Invalid chainmask configuration\n");
                 break;
         }
 }
diff --git a/drivers/net/wireless/ath/ath9k/eeprom_4k.c b/drivers/net/wireless/ath/ath9k/eeprom_4k.c
index c2481b3ac7e6..939fc7af86f8 100644
--- a/drivers/net/wireless/ath/ath9k/eeprom_4k.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_4k.c
@@ -37,14 +37,14 @@ static bool ath9k_hw_4k_fill_eeprom(struct ath_hw *ah)
         eep_start_loc = 64;
 
         if (!ath9k_hw_use_flash(ah)) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Reading from EEPROM, not flash\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Reading from EEPROM, not flash\n");
         }
 
         for (addr = 0; addr < SIZE_EEPROM_4K; addr++) {
                 if (!ath9k_hw_nvram_read(common, addr + eep_start_loc, eep_data)) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Unable to read eeprom region\n");
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Unable to read eeprom region\n");
                         return false;
                 }
                 eep_data++;
@@ -69,13 +69,12 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
         if (!ath9k_hw_use_flash(ah)) {
                 if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET,
                                          &magic)) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Reading Magic # failed\n");
+                        ath_err(common, "Reading Magic # failed\n");
                         return false;
                 }
 
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Read Magic = 0x%04X\n", magic);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Read Magic = 0x%04X\n", magic);
 
                 if (magic != AR5416_EEPROM_MAGIC) {
                         magic2 = swab16(magic);
@@ -90,16 +89,15 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
                                         eepdata++;
                                 }
                         } else {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "Invalid EEPROM Magic. "
-                                          "endianness mismatch.\n");
+                                ath_err(common,
+                                        "Invalid EEPROM Magic. Endianness mismatch.\n");
                                 return -EINVAL;
                         }
                 }
         }
 
-        ath_print(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
-                  need_swap ? "True" : "False");
+        ath_dbg(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
+                need_swap ? "True" : "False");
 
         if (need_swap)
                 el = swab16(ah->eeprom.map4k.baseEepHeader.length);
@@ -120,8 +118,8 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
                 u32 integer;
                 u16 word;
 
-                ath_print(common, ATH_DBG_EEPROM,
-                          "EEPROM Endianness is not native.. Changing\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "EEPROM Endianness is not native.. Changing\n");
 
                 word = swab16(eep->baseEepHeader.length);
                 eep->baseEepHeader.length = word;
@@ -163,9 +161,8 @@ static int ath9k_hw_4k_check_eeprom(struct ath_hw *ah)
 
         if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
             ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
-                          sum, ah->eep_ops->get_eeprom_ver(ah));
+                ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+                        sum, ah->eep_ops->get_eeprom_ver(ah));
                 return -EINVAL;
         }
 
@@ -488,21 +485,20 @@ static void ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
                                         ((pdadcValues[4 * j + 3] & 0xFF) << 24);
                                 REG_WRITE(ah, regOffset, reg32);
 
-                                ath_print(common, ATH_DBG_EEPROM,
-                                          "PDADC (%d,%4x): %4.4x %8.8x\n",
-                                          i, regChainOffset, regOffset,
-                                          reg32);
-                                ath_print(common, ATH_DBG_EEPROM,
-                                          "PDADC: Chain %d | "
-                                          "PDADC %3d Value %3d | "
-                                          "PDADC %3d Value %3d | "
-                                          "PDADC %3d Value %3d | "
-                                          "PDADC %3d Value %3d |\n",
-                                          i, 4 * j, pdadcValues[4 * j],
-                                          4 * j + 1, pdadcValues[4 * j + 1],
-                                          4 * j + 2, pdadcValues[4 * j + 2],
-                                          4 * j + 3,
-                                          pdadcValues[4 * j + 3]);
+                                ath_dbg(common, ATH_DBG_EEPROM,
+                                        "PDADC (%d,%4x): %4.4x %8.8x\n",
+                                        i, regChainOffset, regOffset,
+                                        reg32);
+                                ath_dbg(common, ATH_DBG_EEPROM,
+                                        "PDADC: Chain %d | "
+                                        "PDADC %3d Value %3d | "
+                                        "PDADC %3d Value %3d | "
+                                        "PDADC %3d Value %3d | "
+                                        "PDADC %3d Value %3d |\n",
+                                        i, 4 * j, pdadcValues[4 * j],
+                                        4 * j + 1, pdadcValues[4 * j + 1],
+                                        4 * j + 2, pdadcValues[4 * j + 2],
+                                        4 * j + 3, pdadcValues[4 * j + 3]);
 
                                 regOffset += 4;
                         }
@@ -1181,17 +1177,17 @@ static u16 ath9k_hw_4k_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
 
         u16 spur_val = AR_NO_SPUR;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "Getting spur idx %d is2Ghz. %d val %x\n",
-                  i, is2GHz, ah->config.spurchans[i][is2GHz]);
+        ath_dbg(common, ATH_DBG_ANI,
+                "Getting spur idx:%d is2Ghz:%d val:%x\n",
+                i, is2GHz, ah->config.spurchans[i][is2GHz]);
 
         switch (ah->config.spurmode) {
         case SPUR_DISABLE:
                 break;
         case SPUR_ENABLE_IOCTL:
                 spur_val = ah->config.spurchans[i][is2GHz];
-                ath_print(common, ATH_DBG_ANI,
-                          "Getting spur val from new loc. %d\n", spur_val);
+                ath_dbg(common, ATH_DBG_ANI,
+                        "Getting spur val from new loc. %d\n", spur_val);
                 break;
         case SPUR_ENABLE_EEPROM:
                 spur_val = EEP_MAP4K_SPURCHAN;
diff --git a/drivers/net/wireless/ath/ath9k/eeprom_9287.c b/drivers/net/wireless/ath/ath9k/eeprom_9287.c
index bcb9ed39c047..065402f2e402 100644
--- a/drivers/net/wireless/ath/ath9k/eeprom_9287.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_9287.c
@@ -37,21 +37,21 @@ static bool ath9k_hw_ar9287_fill_eeprom(struct ath_hw *ah)
         int addr, eep_start_loc;
         eep_data = (u16 *)eep;
 
-        if (!common->driver_info)
-                eep_start_loc = AR9287_EEP_START_LOC;
-        else
+        if (common->bus_ops->ath_bus_type == ATH_USB)
                 eep_start_loc = AR9287_HTC_EEP_START_LOC;
+        else
+                eep_start_loc = AR9287_EEP_START_LOC;
 
         if (!ath9k_hw_use_flash(ah)) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Reading from EEPROM, not flash\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Reading from EEPROM, not flash\n");
         }
 
         for (addr = 0; addr < NUM_EEP_WORDS; addr++) {
                 if (!ath9k_hw_nvram_read(common, addr + eep_start_loc,
                                          eep_data)) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "Unable to read eeprom region\n");
+                        ath_dbg(common, ATH_DBG_EEPROM,
+                                "Unable to read eeprom region\n");
                         return false;
                 }
                 eep_data++;
@@ -72,13 +72,12 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
         if (!ath9k_hw_use_flash(ah)) {
                 if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET,
                                          &magic)) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Reading Magic # failed\n");
+                        ath_err(common, "Reading Magic # failed\n");
                         return false;
                 }
 
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Read Magic = 0x%04X\n", magic);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Read Magic = 0x%04X\n", magic);
 
                 if (magic != AR5416_EEPROM_MAGIC) {
                         magic2 = swab16(magic);
@@ -93,16 +92,15 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
                                         eepdata++;
                                 }
                         } else {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "Invalid EEPROM Magic. "
-                                          "Endianness mismatch.\n");
+                                ath_err(common,
+                                        "Invalid EEPROM Magic. Endianness mismatch.\n");
                                 return -EINVAL;
                         }
                 }
         }
 
-        ath_print(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
-                  need_swap ? "True" : "False");
+        ath_dbg(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
+                need_swap ? "True" : "False");
 
         if (need_swap)
                 el = swab16(ah->eeprom.map9287.baseEepHeader.length);
@@ -160,9 +158,8 @@ static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
 
         if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR9287_EEP_VER
             || ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
-                           sum, ah->eep_ops->get_eeprom_ver(ah));
+                ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+                        sum, ah->eep_ops->get_eeprom_ver(ah));
                 return -EINVAL;
         }
 
@@ -1152,17 +1149,17 @@ static u16 ath9k_hw_ar9287_get_spur_channel(struct ath_hw *ah,
         struct ath_common *common = ath9k_hw_common(ah);
         u16 spur_val = AR_NO_SPUR;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "Getting spur idx %d is2Ghz. %d val %x\n",
-                  i, is2GHz, ah->config.spurchans[i][is2GHz]);
+        ath_dbg(common, ATH_DBG_ANI,
+                "Getting spur idx:%d is2Ghz:%d val:%x\n",
+                i, is2GHz, ah->config.spurchans[i][is2GHz]);
 
         switch (ah->config.spurmode) {
         case SPUR_DISABLE:
                 break;
         case SPUR_ENABLE_IOCTL:
                 spur_val = ah->config.spurchans[i][is2GHz];
-                ath_print(common, ATH_DBG_ANI,
-                          "Getting spur val from new loc. %d\n", spur_val);
+                ath_dbg(common, ATH_DBG_ANI,
+                        "Getting spur val from new loc. %d\n", spur_val);
                 break;
         case SPUR_ENABLE_EEPROM:
                 spur_val = EEP_MAP9287_SPURCHAN;
diff --git a/drivers/net/wireless/ath/ath9k/eeprom_def.c b/drivers/net/wireless/ath/ath9k/eeprom_def.c
index 45f70b2404a1..5bfa031545f4 100644
--- a/drivers/net/wireless/ath/ath9k/eeprom_def.c
+++ b/drivers/net/wireless/ath/ath9k/eeprom_def.c
@@ -96,8 +96,8 @@ static bool ath9k_hw_def_fill_eeprom(struct ath_hw *ah)
         for (addr = 0; addr < SIZE_EEPROM_DEF; addr++) {
                 if (!ath9k_hw_nvram_read(common, addr + ar5416_eep_start_loc,
                                          eep_data)) {
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                  "Unable to read eeprom region\n");
+                        ath_err(ath9k_hw_common(ah),
+                                "Unable to read eeprom region\n");
                         return false;
                 }
                 eep_data++;
@@ -117,13 +117,13 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
         int i, addr, size;
 
         if (!ath9k_hw_nvram_read(common, AR5416_EEPROM_MAGIC_OFFSET, &magic)) {
-                ath_print(common, ATH_DBG_FATAL, "Reading Magic # failed\n");
+                ath_err(common, "Reading Magic # failed\n");
                 return false;
         }
 
         if (!ath9k_hw_use_flash(ah)) {
-                ath_print(common, ATH_DBG_EEPROM,
-                          "Read Magic = 0x%04X\n", magic);
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "Read Magic = 0x%04X\n", magic);
 
                 if (magic != AR5416_EEPROM_MAGIC) {
                         magic2 = swab16(magic);
@@ -139,16 +139,15 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
                                         eepdata++;
                                 }
                         } else {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "Invalid EEPROM Magic. "
-                                          "Endianness mismatch.\n");
+                                ath_err(common,
+                                        "Invalid EEPROM Magic. Endianness mismatch.\n");
                                 return -EINVAL;
                         }
                 }
         }
 
-        ath_print(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
-                  need_swap ? "True" : "False");
+        ath_dbg(common, ATH_DBG_EEPROM, "need_swap = %s.\n",
+                need_swap ? "True" : "False");
 
         if (need_swap)
                 el = swab16(ah->eeprom.def.baseEepHeader.length);
@@ -169,8 +168,8 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
                 u32 integer, j;
                 u16 word;
 
-                ath_print(common, ATH_DBG_EEPROM,
-                          "EEPROM Endianness is not native.. Changing.\n");
+                ath_dbg(common, ATH_DBG_EEPROM,
+                        "EEPROM Endianness is not native.. Changing.\n");
 
                 word = swab16(eep->baseEepHeader.length);
                 eep->baseEepHeader.length = word;
@@ -216,8 +215,7 @@ static int ath9k_hw_def_check_eeprom(struct ath_hw *ah)
 
         if (sum != 0xffff || ah->eep_ops->get_eeprom_ver(ah) != AR5416_EEP_VER ||
             ah->eep_ops->get_eeprom_rev(ah) < AR5416_EEP_NO_BACK_VER) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
+                ath_err(common, "Bad EEPROM checksum 0x%x or revision 0x%04x\n",
                         sum, ah->eep_ops->get_eeprom_ver(ah));
                 return -EINVAL;
         }
@@ -966,20 +964,19 @@ static void ath9k_hw_set_def_power_cal_table(struct ath_hw *ah,
                                         ((pdadcValues[4 * j + 3] & 0xFF) << 24);
                                 REG_WRITE(ah, regOffset, reg32);
 
-                                ath_print(common, ATH_DBG_EEPROM,
-                                          "PDADC (%d,%4x): %4.4x %8.8x\n",
-                                          i, regChainOffset, regOffset,
-                                          reg32);
-                                ath_print(common, ATH_DBG_EEPROM,
-                                          "PDADC: Chain %d | PDADC %3d "
-                                          "Value %3d | PDADC %3d Value %3d | "
-                                          "PDADC %3d Value %3d | PDADC %3d "
-                                          "Value %3d |\n",
-                                          i, 4 * j, pdadcValues[4 * j],
-                                          4 * j + 1, pdadcValues[4 * j + 1],
-                                          4 * j + 2, pdadcValues[4 * j + 2],
-                                          4 * j + 3,
-                                          pdadcValues[4 * j + 3]);
+                                ath_dbg(common, ATH_DBG_EEPROM,
+                                        "PDADC (%d,%4x): %4.4x %8.8x\n",
+                                        i, regChainOffset, regOffset,
+                                        reg32);
+                                ath_dbg(common, ATH_DBG_EEPROM,
+                                        "PDADC: Chain %d | PDADC %3d "
+                                        "Value %3d | PDADC %3d Value %3d | "
+                                        "PDADC %3d Value %3d | PDADC %3d "
+                                        "Value %3d |\n",
+                                        i, 4 * j, pdadcValues[4 * j],
+                                        4 * j + 1, pdadcValues[4 * j + 1],
+                                        4 * j + 2, pdadcValues[4 * j + 2],
+                                        4 * j + 3, pdadcValues[4 * j + 3]);
 
                                 regOffset += 4;
                         }
@@ -1066,15 +1063,19 @@ static void ath9k_hw_set_def_power_per_rate_table(struct ath_hw *ah,
         case 1:
                 break;
         case 2:
-                scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
+                if (scaledPower > REDUCE_SCALED_POWER_BY_TWO_CHAIN)
+                        scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
+                else
+                        scaledPower = 0;
                 break;
         case 3:
-                scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
+                if (scaledPower > REDUCE_SCALED_POWER_BY_THREE_CHAIN)
+                        scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
+                else
+                        scaledPower = 0;
                 break;
         }
 
-        scaledPower = max((u16)0, scaledPower);
-
         if (IS_CHAN_2GHZ(chan)) {
                 numCtlModes = ARRAY_SIZE(ctlModesFor11g) -
                         SUB_NUM_CTL_MODES_AT_2G_40;
@@ -1319,8 +1320,8 @@ static void ath9k_hw_def_set_txpower(struct ath_hw *ah,
                 regulatory->max_power_level += INCREASE_MAXPOW_BY_THREE_CHAIN;
                 break;
         default:
-                ath_print(ath9k_hw_common(ah), ATH_DBG_EEPROM,
-                          "Invalid chainmask configuration\n");
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_EEPROM,
+                        "Invalid chainmask configuration\n");
                 break;
         }
 
@@ -1461,17 +1462,17 @@ static u16 ath9k_hw_def_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
 
         u16 spur_val = AR_NO_SPUR;
 
-        ath_print(common, ATH_DBG_ANI,
-                  "Getting spur idx %d is2Ghz. %d val %x\n",
-                  i, is2GHz, ah->config.spurchans[i][is2GHz]);
+        ath_dbg(common, ATH_DBG_ANI,
+                "Getting spur idx:%d is2Ghz:%d val:%x\n",
+                i, is2GHz, ah->config.spurchans[i][is2GHz]);
 
         switch (ah->config.spurmode) {
         case SPUR_DISABLE:
                 break;
         case SPUR_ENABLE_IOCTL:
                 spur_val = ah->config.spurchans[i][is2GHz];
-                ath_print(common, ATH_DBG_ANI,
-                          "Getting spur val from new loc. %d\n", spur_val);
+                ath_dbg(common, ATH_DBG_ANI,
+                        "Getting spur val from new loc. %d\n", spur_val);
                 break;
         case SPUR_ENABLE_EEPROM:
                 spur_val = EEP_DEF_SPURCHAN;
diff --git a/drivers/net/wireless/ath/ath9k/gpio.c b/drivers/net/wireless/ath/ath9k/gpio.c
index 6a1a482f9dc3..133764069246 100644
--- a/drivers/net/wireless/ath/ath9k/gpio.c
+++ b/drivers/net/wireless/ath/ath9k/gpio.c
@@ -103,8 +103,8 @@ static int ath_register_led(struct ath_softc *sc, struct ath_led *led,
 
         ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &led->led_cdev);
         if (ret)
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "Failed to register led:%s", led->name);
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "Failed to register led:%s", led->name);
         else
                 led->registered = 1;
         return ret;
@@ -236,13 +236,13 @@ static void ath_detect_bt_priority(struct ath_softc *sc)
                 sc->sc_flags &= ~(SC_OP_BT_PRIORITY_DETECTED | SC_OP_BT_SCAN);
                 /* Detect if colocated bt started scanning */
                 if (btcoex->bt_priority_cnt >= ATH_BT_CNT_SCAN_THRESHOLD) {
-                        ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_BTCOEX,
-                                  "BT scan detected");
+                        ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_BTCOEX,
+                                "BT scan detected\n");
                         sc->sc_flags |= (SC_OP_BT_SCAN |
                                          SC_OP_BT_PRIORITY_DETECTED);
                 } else if (btcoex->bt_priority_cnt >= ATH_BT_CNT_THRESHOLD) {
-                        ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_BTCOEX,
-                                  "BT priority traffic detected");
+                        ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_BTCOEX,
+                                "BT priority traffic detected\n");
                         sc->sc_flags |= SC_OP_BT_PRIORITY_DETECTED;
                 }
 
@@ -331,8 +331,8 @@ static void ath_btcoex_no_stomp_timer(void *arg)
         struct ath_common *common = ath9k_hw_common(ah);
         bool is_btscan = sc->sc_flags & SC_OP_BT_SCAN;
 
-        ath_print(common, ATH_DBG_BTCOEX,
-                  "no stomp timer running\n");
+        ath_dbg(common, ATH_DBG_BTCOEX,
+                "no stomp timer running\n");
 
         spin_lock_bh(&btcoex->btcoex_lock);
 
@@ -378,8 +378,8 @@ void ath9k_btcoex_timer_resume(struct ath_softc *sc)
         struct ath_btcoex *btcoex = &sc->btcoex;
         struct ath_hw *ah = sc->sc_ah;
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
-                  "Starting btcoex timers");
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
+                "Starting btcoex timers\n");
 
         /* make sure duty cycle timer is also stopped when resuming */
         if (btcoex->hw_timer_enabled)
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 8946e8ad1b85..d0918bd23b8e 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -28,16 +28,7 @@ MODULE_FIRMWARE(FIRMWARE_AR9271);
 static struct usb_device_id ath9k_hif_usb_ids[] = {
         { USB_DEVICE(0x0cf3, 0x9271) }, /* Atheros */
         { USB_DEVICE(0x0cf3, 0x1006) }, /* Atheros */
-        { USB_DEVICE(0x0cf3, 0x7010),
-                .driver_info = AR7010_DEVICE },
-                                        /* Atheros */
-        { USB_DEVICE(0x0cf3, 0x7015),
-                .driver_info = AR7010_DEVICE | AR9287_DEVICE },
-                                        /* Atheros */
         { USB_DEVICE(0x0846, 0x9030) }, /* Netgear N150 */
-        { USB_DEVICE(0x0846, 0x9018),
-                .driver_info = AR7010_DEVICE },
-                                        /* Netgear WNDA3200 */
         { USB_DEVICE(0x07D1, 0x3A10) }, /* Dlink Wireless 150 */
         { USB_DEVICE(0x13D3, 0x3327) }, /* Azurewave */
         { USB_DEVICE(0x13D3, 0x3328) }, /* Azurewave */
@@ -46,13 +37,20 @@ static struct usb_device_id ath9k_hif_usb_ids[] = {
         { USB_DEVICE(0x13D3, 0x3349) }, /* Azurewave */
         { USB_DEVICE(0x13D3, 0x3350) }, /* Azurewave */
         { USB_DEVICE(0x04CA, 0x4605) }, /* Liteon */
-        { USB_DEVICE(0x083A, 0xA704),
-                .driver_info = AR7010_DEVICE },
-                                        /* SMC Networks */
         { USB_DEVICE(0x040D, 0x3801) }, /* VIA */
+
+        { USB_DEVICE(0x0cf3, 0x7015),
+          .driver_info = AR9287_USB },  /* Atheros */
         { USB_DEVICE(0x1668, 0x1200),
-                .driver_info = AR7010_DEVICE | AR9287_DEVICE },
-                                        /* Verizon */
+          .driver_info = AR9287_USB },  /* Verizon */
+
+        { USB_DEVICE(0x0cf3, 0x7010),
+          .driver_info = AR9280_USB },  /* Atheros */
+        { USB_DEVICE(0x0846, 0x9018),
+          .driver_info = AR9280_USB },  /* Netgear WNDA3200 */
+        { USB_DEVICE(0x083A, 0xA704),
+          .driver_info = AR9280_USB },  /* SMC Networks */
+
         { },
 };
 
@@ -818,7 +816,7 @@ static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev,
         }
         kfree(buf);
 
-        if (drv_info & AR7010_DEVICE)
+        if (IS_AR7010_DEVICE(drv_info))
                 firm_offset = AR7010_FIRMWARE_TEXT;
         else
                 firm_offset = AR9271_FIRMWARE_TEXT;
@@ -887,9 +885,9 @@ static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev, u32 drv_info)
 
         return 0;
 
-err_fw_download:
-        ath9k_hif_usb_dealloc_urbs(hif_dev);
 err_urb:
+        ath9k_hif_usb_dealloc_urbs(hif_dev);
+err_fw_download:
         release_firmware(hif_dev->firmware);
 err_fw_req:
         hif_dev->firmware = NULL;
@@ -934,7 +932,7 @@ static int ath9k_hif_usb_probe(struct usb_interface *interface,
 
         /* Find out which firmware to load */
 
-        if (id->driver_info & AR7010_DEVICE)
+        if (IS_AR7010_DEVICE(id->driver_info))
                 if (le16_to_cpu(udev->descriptor.bcdDevice) == 0x0202)
                         hif_dev->fw_name = FIRMWARE_AR7010_1_1;
                 else
@@ -1017,6 +1015,13 @@ static int ath9k_hif_usb_suspend(struct usb_interface *interface,
 {
         struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
 
+        /*
+         * The device has to be set to FULLSLEEP mode in case no
+         * interface is up.
+         */
+        if (!(hif_dev->flags & HIF_USB_START))
+                ath9k_htc_suspend(hif_dev->htc_handle);
+
         ath9k_hif_usb_dealloc_urbs(hif_dev);
 
         return 0;
@@ -1034,7 +1039,7 @@ static int ath9k_hif_usb_resume(struct usb_interface *interface)
 
         if (hif_dev->firmware) {
                 ret = ath9k_hif_usb_download_fw(hif_dev,
-                                htc_handle->drv_priv->ah->common.driver_info);
+                                htc_handle->drv_priv->ah->hw_version.usbdev);
                 if (ret)
                         goto fail_resume;
         } else {
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.h b/drivers/net/wireless/ath/ath9k/hif_usb.h
index 2daf97b11c08..e4a5e2e79541 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.h
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.h
@@ -17,6 +17,8 @@
 #ifndef HTC_USB_H
 #define HTC_USB_H
 
+#define IS_AR7010_DEVICE(_v) (((_v) == AR9280_USB) || ((_v) == AR9287_USB))
+
 #define AR9271_FIRMWARE       0x501000
 #define AR9271_FIRMWARE_TEXT  0x903000
 #define AR7010_FIRMWARE_TEXT  0x906000
diff --git a/drivers/net/wireless/ath/ath9k/htc.h b/drivers/net/wireless/ath/ath9k/htc.h
index afe39a911906..fdf9d5fe8cc0 100644
--- a/drivers/net/wireless/ath/ath9k/htc.h
+++ b/drivers/net/wireless/ath/ath9k/htc.h
@@ -455,6 +455,8 @@ u32 ath9k_htc_calcrxfilter(struct ath9k_htc_priv *priv);
 void ath9k_htc_ps_wakeup(struct ath9k_htc_priv *priv);
 void ath9k_htc_ps_restore(struct ath9k_htc_priv *priv);
 void ath9k_ps_work(struct work_struct *work);
+bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
+                        enum ath9k_power_mode mode);
 
 void ath9k_start_rfkill_poll(struct ath9k_htc_priv *priv);
 void ath9k_init_leds(struct ath9k_htc_priv *priv);
@@ -464,6 +466,7 @@ int ath9k_htc_probe_device(struct htc_target *htc_handle, struct device *dev,
                            u16 devid, char *product, u32 drv_info);
 void ath9k_htc_disconnect_device(struct htc_target *htc_handle, bool hotunplug);
 #ifdef CONFIG_PM
+void ath9k_htc_suspend(struct htc_target *htc_handle);
 int ath9k_htc_resume(struct htc_target *htc_handle);
 #endif
 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c b/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
index 1b72aa482ac7..87cc65a78a3f 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_beacon.c
@@ -123,11 +123,11 @@ static void ath9k_htc_beacon_config_sta(struct ath9k_htc_priv *priv,
         /* TSF out of range threshold fixed at 1 second */
         bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;
 
-        ath_print(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
-        ath_print(common, ATH_DBG_BEACON,
-                  "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
-                  bs.bs_bmissthreshold, bs.bs_sleepduration,
-                  bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
+        ath_dbg(common, ATH_DBG_BEACON, "tsf: %llu tsftu: %u\n", tsf, tsftu);
+        ath_dbg(common, ATH_DBG_BEACON,
+                "bmiss: %u sleep: %u cfp-period: %u maxdur: %u next: %u\n",
+                bs.bs_bmissthreshold, bs.bs_sleepduration,
+                bs.bs_cfpperiod, bs.bs_cfpmaxduration, bs.bs_cfpnext);
 
         /* Set the computed STA beacon timers */
 
@@ -154,9 +154,9 @@ static void ath9k_htc_beacon_config_adhoc(struct ath9k_htc_priv *priv,
         if (priv->op_flags & OP_ENABLE_BEACON)
                 imask |= ATH9K_INT_SWBA;
 
-        ath_print(common, ATH_DBG_BEACON,
-                  "IBSS Beacon config, intval: %d, imask: 0x%x\n",
-                  bss_conf->beacon_interval, imask);
+        ath_dbg(common, ATH_DBG_BEACON,
+                "IBSS Beacon config, intval: %d, imask: 0x%x\n",
+                bss_conf->beacon_interval, imask);
 
         WMI_CMD(WMI_DISABLE_INTR_CMDID);
         ath9k_hw_beaconinit(priv->ah, nexttbtt, intval);
@@ -246,8 +246,8 @@ void ath9k_htc_beaconq_config(struct ath9k_htc_priv *priv)
         qi.tqi_cwmax = qi_be.tqi_cwmax;
 
         if (!ath9k_hw_set_txq_props(ah, priv->beaconq, &qi)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Unable to update beacon queue %u!\n", qnum);
+                ath_err(ath9k_hw_common(ah),
+                        "Unable to update beacon queue %u!\n", qnum);
         } else {
                 ath9k_hw_resettxqueue(ah, priv->beaconq);
         }
@@ -278,8 +278,8 @@ void ath9k_htc_beacon_config(struct ath9k_htc_priv *priv,
                 ath9k_htc_beacon_config_adhoc(priv, cur_conf);
                 break;
         default:
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Unsupported beaconing mode\n");
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Unsupported beaconing mode\n");
                 return;
         }
 }
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c b/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
index 50eec9a3b88c..283ff97ed446 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
@@ -20,13 +20,13 @@ static void ath_detect_bt_priority(struct ath9k_htc_priv *priv)
                 priv->op_flags &= ~(OP_BT_PRIORITY_DETECTED | OP_BT_SCAN);
                 /* Detect if colocated bt started scanning */
                 if (btcoex->bt_priority_cnt >= ATH_BT_CNT_SCAN_THRESHOLD) {
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
-                                  "BT scan detected");
+                        ath_dbg(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
+                                "BT scan detected\n");
                         priv->op_flags |= (OP_BT_SCAN |
                                          OP_BT_PRIORITY_DETECTED);
                 } else if (btcoex->bt_priority_cnt >= ATH_BT_CNT_THRESHOLD) {
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
-                                    "BT priority traffic detected");
+                        ath_dbg(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
+                                "BT priority traffic detected\n");
                         priv->op_flags |= OP_BT_PRIORITY_DETECTED;
                 }
 
@@ -83,8 +83,8 @@ static void ath_btcoex_duty_cycle_work(struct work_struct *work)
         struct ath_common *common = ath9k_hw_common(ah);
         bool is_btscan = priv->op_flags & OP_BT_SCAN;
 
-        ath_print(common, ATH_DBG_BTCOEX,
-                  "time slice work for bt and wlan\n");
+        ath_dbg(common, ATH_DBG_BTCOEX,
+                "time slice work for bt and wlan\n");
 
         if (btcoex->bt_stomp_type == ATH_BTCOEX_STOMP_LOW || is_btscan)
                 ath9k_cmn_btcoex_bt_stomp(common, ATH_BTCOEX_STOMP_NONE);
@@ -114,8 +114,7 @@ void ath_htc_resume_btcoex_work(struct ath9k_htc_priv *priv)
         struct ath_btcoex *btcoex = &priv->btcoex;
         struct ath_hw *ah = priv->ah;
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_BTCOEX,
-                  "Starting btcoex work");
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_BTCOEX, "Starting btcoex work\n");
 
         btcoex->bt_priority_cnt = 0;
         btcoex->bt_priority_time = jiffies;
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_init.c b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
index 071d0c974747..0f6be350fd3c 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
@@ -246,7 +246,7 @@ static int ath9k_init_htc_services(struct ath9k_htc_priv *priv, u16 devid,
          * the HIF layer, shouldn't matter much.
          */
 
-        if (drv_info & AR7010_DEVICE)
+        if (IS_AR7010_DEVICE(drv_info))
                 priv->htc->credits = 45;
         else
                 priv->htc->credits = 33;
@@ -288,9 +288,9 @@ static unsigned int ath9k_regread(void *hw_priv, u32 reg_offset)
                           (u8 *) &val, sizeof(val),
                           100);
         if (unlikely(r)) {
-                ath_print(common, ATH_DBG_WMI,
-                          "REGISTER READ FAILED: (0x%04x, %d)\n",
-                           reg_offset, r);
+                ath_dbg(common, ATH_DBG_WMI,
+                        "REGISTER READ FAILED: (0x%04x, %d)\n",
+                        reg_offset, r);
                 return -EIO;
         }
 
@@ -313,9 +313,9 @@ static void ath9k_regwrite_single(void *hw_priv, u32 val, u32 reg_offset)
                           (u8 *) &val, sizeof(val),
                           100);
         if (unlikely(r)) {
-                ath_print(common, ATH_DBG_WMI,
-                          "REGISTER WRITE FAILED:(0x%04x, %d)\n",
-                          reg_offset, r);
+                ath_dbg(common, ATH_DBG_WMI,
+                        "REGISTER WRITE FAILED:(0x%04x, %d)\n",
+                        reg_offset, r);
         }
 }
 
@@ -345,9 +345,9 @@ static void ath9k_regwrite_buffer(void *hw_priv, u32 val, u32 reg_offset)
                           (u8 *) &rsp_status, sizeof(rsp_status),
                           100);
                 if (unlikely(r)) {
-                        ath_print(common, ATH_DBG_WMI,
-                                  "REGISTER WRITE FAILED, multi len: %d\n",
-                                  priv->wmi->multi_write_idx);
+                        ath_dbg(common, ATH_DBG_WMI,
+                                "REGISTER WRITE FAILED, multi len: %d\n",
+                                priv->wmi->multi_write_idx);
                 }
                 priv->wmi->multi_write_idx = 0;
         }
@@ -395,9 +395,9 @@ static void ath9k_regwrite_flush(void *hw_priv)
                           (u8 *) &rsp_status, sizeof(rsp_status),
                           100);
                 if (unlikely(r)) {
-                        ath_print(common, ATH_DBG_WMI,
-                                  "REGISTER WRITE FAILED, multi len: %d\n",
-                                  priv->wmi->multi_write_idx);
+                        ath_dbg(common, ATH_DBG_WMI,
+                                "REGISTER WRITE FAILED, multi len: %d\n",
+                                priv->wmi->multi_write_idx);
                 }
                 priv->wmi->multi_write_idx = 0;
         }
@@ -469,9 +469,9 @@ static void setup_ht_cap(struct ath9k_htc_priv *priv,
         tx_streams = ath9k_cmn_count_streams(common->tx_chainmask, 2);
         rx_streams = ath9k_cmn_count_streams(common->rx_chainmask, 2);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "TX streams %d, RX streams: %d\n",
-                  tx_streams, rx_streams);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "TX streams %d, RX streams: %d\n",
+                tx_streams, rx_streams);
 
         if (tx_streams != rx_streams) {
                 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
@@ -495,37 +495,31 @@ static int ath9k_init_queues(struct ath9k_htc_priv *priv)
 
         priv->beaconq = ath9k_hw_beaconq_setup(priv->ah);
         if (priv->beaconq == -1) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup BEACON xmit queue\n");
+                ath_err(common, "Unable to setup BEACON xmit queue\n");
                 goto err;
         }
 
         priv->cabq = ath9k_htc_cabq_setup(priv);
         if (priv->cabq == -1) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup CAB xmit queue\n");
+                ath_err(common, "Unable to setup CAB xmit queue\n");
                 goto err;
         }
 
         if (!ath9k_htc_txq_setup(priv, WME_AC_BE)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup xmit queue for BE traffic\n");
+                ath_err(common, "Unable to setup xmit queue for BE traffic\n");
                 goto err;
         }
 
         if (!ath9k_htc_txq_setup(priv, WME_AC_BK)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup xmit queue for BK traffic\n");
+                ath_err(common, "Unable to setup xmit queue for BK traffic\n");
                 goto err;
         }
         if (!ath9k_htc_txq_setup(priv, WME_AC_VI)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup xmit queue for VI traffic\n");
+                ath_err(common, "Unable to setup xmit queue for VI traffic\n");
                 goto err;
         }
         if (!ath9k_htc_txq_setup(priv, WME_AC_VO)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to setup xmit queue for VO traffic\n");
+                ath_err(common, "Unable to setup xmit queue for VO traffic\n");
                 goto err;
         }
 
@@ -543,9 +537,9 @@ static void ath9k_init_crypto(struct ath9k_htc_priv *priv)
         /* Get the hardware key cache size. */
         common->keymax = priv->ah->caps.keycache_size;
         if (common->keymax > ATH_KEYMAX) {
-                ath_print(common, ATH_DBG_ANY,
-                          "Warning, using only %u entries in %u key cache\n",
-                          ATH_KEYMAX, common->keymax);
+                ath_dbg(common, ATH_DBG_ANY,
+                        "Warning, using only %u entries in %u key cache\n",
+                        ATH_KEYMAX, common->keymax);
                 common->keymax = ATH_KEYMAX;
         }
 
@@ -636,6 +630,7 @@ static int ath9k_init_priv(struct ath9k_htc_priv *priv,
 
         ah->hw_version.devid = devid;
         ah->hw_version.subsysid = 0; /* FIXME */
+        ah->hw_version.usbdev = drv_info;
         ah->ah_flags |= AH_USE_EEPROM;
         priv->ah = ah;
 
@@ -646,7 +641,6 @@ static int ath9k_init_priv(struct ath9k_htc_priv *priv,
         common->hw = priv->hw;
         common->priv = priv;
         common->debug_mask = ath9k_debug;
-        common->driver_info = drv_info;
 
         spin_lock_init(&priv->wmi->wmi_lock);
         spin_lock_init(&priv->beacon_lock);
@@ -670,16 +664,15 @@ static int ath9k_init_priv(struct ath9k_htc_priv *priv,
 
         ret = ath9k_hw_init(ah);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to initialize hardware; "
-                          "initialization status: %d\n", ret);
+                ath_err(common,
+                        "Unable to initialize hardware; initialization status: %d\n",
+                        ret);
                 goto err_hw;
         }
 
         ret = ath9k_htc_init_debug(ah);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to create debugfs files\n");
+                ath_err(common, "Unable to create debugfs files\n");
                 goto err_debug;
         }
 
@@ -721,7 +714,8 @@ static void ath9k_set_hw_capab(struct ath9k_htc_priv *priv,
                 IEEE80211_HW_HAS_RATE_CONTROL |
                 IEEE80211_HW_RX_INCLUDES_FCS |
                 IEEE80211_HW_SUPPORTS_PS |
-                IEEE80211_HW_PS_NULLFUNC_STACK;
+                IEEE80211_HW_PS_NULLFUNC_STACK |
+                IEEE80211_HW_NEED_DTIM_PERIOD;
 
         hw->wiphy->interface_modes =
                 BIT(NL80211_IFTYPE_STATION) |
@@ -888,6 +882,12 @@ void ath9k_htc_disconnect_device(struct htc_target *htc_handle, bool hotunplug)
 }
 
 #ifdef CONFIG_PM
+
+void ath9k_htc_suspend(struct htc_target *htc_handle)
+{
+        ath9k_htc_setpower(htc_handle->drv_priv, ATH9K_PM_FULL_SLEEP);
+}
+
 int ath9k_htc_resume(struct htc_target *htc_handle)
 {
         struct ath9k_htc_priv *priv = htc_handle->drv_priv;
@@ -898,7 +898,7 @@ int ath9k_htc_resume(struct htc_target *htc_handle)
                 return ret;
 
         ret = ath9k_init_htc_services(priv, priv->ah->hw_version.devid,
-                                      priv->ah->common.driver_info);
+                                      priv->ah->hw_version.usbdev);
         return ret;
 }
 #endif
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_main.c b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
index 8266ce1f02e3..20ea75a44e52 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
@@ -63,8 +63,8 @@ static enum htc_phymode ath9k_htc_get_curmode(struct ath9k_htc_priv *priv,
         return mode;
 }
 
-static bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
-                               enum ath9k_power_mode mode)
+bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
+                        enum ath9k_power_mode mode)
 {
         bool ret;
 
@@ -143,18 +143,18 @@ static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv,
         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
         WMI_CMD(WMI_STOP_RECV_CMDID);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n",
-                  priv->ah->curchan->channel,
-                  channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf),
-                  fastcc);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n",
+                priv->ah->curchan->channel,
+                channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf),
+                fastcc);
 
         caldata = &priv->caldata[channel->hw_value];
         ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset channel (%u Mhz) "
-                          "reset status %d\n", channel->center_freq, ret);
+                ath_err(common,
+                        "Unable to reset channel (%u Mhz) reset status %d\n",
+                        channel->center_freq, ret);
                 goto err;
         }
 
@@ -263,15 +263,16 @@ static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
         if (ret) {
                 if (sta)
-                        ath_print(common, ATH_DBG_FATAL,
-                          "Unable to add station entry for: %pM\n", sta->addr);
+                        ath_err(common,
+                                "Unable to add station entry for: %pM\n",
+                                sta->addr);
                 return ret;
         }
 
         if (sta)
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Added a station entry for: %pM (idx: %d)\n",
-                          sta->addr, tsta.sta_index);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Added a station entry for: %pM (idx: %d)\n",
+                        sta->addr, tsta.sta_index);
 
         priv->nstations++;
         return 0;
@@ -296,16 +297,16 @@ static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
         if (ret) {
                 if (sta)
-                        ath_print(common, ATH_DBG_FATAL,
-                          "Unable to remove station entry for: %pM\n",
-                          sta->addr);
+                        ath_err(common,
+                                "Unable to remove station entry for: %pM\n",
+                                sta->addr);
                 return ret;
         }
 
         if (sta)
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Removed a station entry for: %pM (idx: %d)\n",
-                          sta->addr, sta_idx);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Removed a station entry for: %pM (idx: %d)\n",
+                        sta->addr, sta_idx);
 
         priv->nstations--;
         return 0;
@@ -390,8 +391,8 @@ static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
 
         WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to initialize Rate information on target\n");
+                ath_err(common,
+                        "Unable to initialize Rate information on target\n");
         }
 
         return ret;
@@ -408,9 +409,9 @@ static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
         ath9k_htc_setup_rate(priv, sta, &trate);
         ret = ath9k_htc_send_rate_cmd(priv, &trate);
         if (!ret)
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Updated target sta: %pM, rate caps: 0x%X\n",
-                          sta->addr, be32_to_cpu(trate.capflags));
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Updated target sta: %pM, rate caps: 0x%X\n",
+                        sta->addr, be32_to_cpu(trate.capflags));
 }
 
 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
@@ -435,9 +436,9 @@ static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
 
         ret = ath9k_htc_send_rate_cmd(priv, &trate);
         if (!ret)
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Updated target sta: %pM, rate caps: 0x%X\n",
-                          bss_conf->bssid, be32_to_cpu(trate.capflags));
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Updated target sta: %pM, rate caps: 0x%X\n",
+                        bss_conf->bssid, be32_to_cpu(trate.capflags));
 }
 
 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
@@ -464,14 +465,14 @@ static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
 
         WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
         if (ret)
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Unable to %s TX aggregation for (%pM, %d)\n",
-                          (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Unable to %s TX aggregation for (%pM, %d)\n",
+                        (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
         else
-                ath_print(common, ATH_DBG_CONFIG,
-                          "%s TX aggregation for (%pM, %d)\n",
-                          (aggr.aggr_enable) ? "Starting" : "Stopping",
-                          sta->addr, tid);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "%s TX aggregation for (%pM, %d)\n",
+                        (aggr.aggr_enable) ? "Starting" : "Stopping",
+                        sta->addr, tid);
 
         spin_lock_bh(&priv->tx_lock);
         ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
@@ -724,7 +725,7 @@ void ath9k_ani_work(struct work_struct *work)
         /* Long calibration runs independently of short calibration. */
         if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
                 longcal = true;
-                ath_print(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
+                ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
                 common->ani.longcal_timer = timestamp;
         }
 
@@ -733,8 +734,8 @@ void ath9k_ani_work(struct work_struct *work)
                 if ((timestamp - common->ani.shortcal_timer) >=
                     short_cal_interval) {
                         shortcal = true;
-                        ath_print(common, ATH_DBG_ANI,
-                                  "shortcal @%lu\n", jiffies);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "shortcal @%lu\n", jiffies);
                         common->ani.shortcal_timer = timestamp;
                         common->ani.resetcal_timer = timestamp;
                 }
@@ -895,8 +896,8 @@ static int ath9k_register_led(struct ath9k_htc_priv *priv, struct ath_led *led,
 
         ret = led_classdev_register(wiphy_dev(priv->hw->wiphy), &led->led_cdev);
         if (ret)
-                ath_print(ath9k_hw_common(priv->ah), ATH_DBG_FATAL,
-                          "Failed to register led:%s", led->name);
+                ath_err(ath9k_hw_common(priv->ah),
+                        "Failed to register led:%s", led->name);
         else
                 led->registered = 1;
 
@@ -1024,9 +1025,9 @@ static void ath9k_htc_radio_enable(struct ieee80211_hw *hw)
         /* Reset the HW */
         ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset hardware; reset status %d "
-                          "(freq %u MHz)\n", ret, ah->curchan->channel);
+                ath_err(common,
+                        "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                        ret, ah->curchan->channel);
         }
 
         ath_update_txpow(priv);
@@ -1087,9 +1088,9 @@ static void ath9k_htc_radio_disable(struct ieee80211_hw *hw)
         /* Reset the HW */
         ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset hardware; reset status %d "
-                          "(freq %u MHz)\n", ret, ah->curchan->channel);
+                ath_err(common,
+                        "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                        ret, ah->curchan->channel);
         }
 
         /* Disable the PHY */
@@ -1124,15 +1125,15 @@ static int ath9k_htc_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
         ret = ath9k_htc_tx_start(priv, skb);
         if (ret != 0) {
                 if (ret == -ENOMEM) {
-                        ath_print(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
-                                  "Stopping TX queues\n");
+                        ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
+                                "Stopping TX queues\n");
                         ieee80211_stop_queues(hw);
                         spin_lock_bh(&priv->tx_lock);
                         priv->tx_queues_stop = true;
                         spin_unlock_bh(&priv->tx_lock);
                 } else {
-                        ath_print(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
-                                  "Tx failed");
+                        ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
+                                "Tx failed\n");
                 }
                 goto fail_tx;
         }
@@ -1158,9 +1159,9 @@ static int ath9k_htc_start(struct ieee80211_hw *hw)
 
         mutex_lock(&priv->mutex);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Starting driver with initial channel: %d MHz\n",
-                  curchan->center_freq);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Starting driver with initial channel: %d MHz\n",
+                curchan->center_freq);
 
         /* Ensure that HW is awake before flushing RX */
         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
@@ -1175,9 +1176,9 @@ static int ath9k_htc_start(struct ieee80211_hw *hw)
         ath9k_hw_htc_resetinit(ah);
         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset hardware; reset status %d "
-                          "(freq %u MHz)\n", ret, curchan->center_freq);
+                ath_err(common,
+                        "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                        ret, curchan->center_freq);
                 mutex_unlock(&priv->mutex);
                 return ret;
         }
@@ -1223,7 +1224,7 @@ static void ath9k_htc_stop(struct ieee80211_hw *hw)
         mutex_lock(&priv->mutex);
 
         if (priv->op_flags & OP_INVALID) {
-                ath_print(common, ATH_DBG_ANY, "Device not present\n");
+                ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
                 mutex_unlock(&priv->mutex);
                 return;
         }
@@ -1243,11 +1244,10 @@ static void ath9k_htc_stop(struct ieee80211_hw *hw)
         /* Remove monitor interface here */
         if (ah->opmode == NL80211_IFTYPE_MONITOR) {
                 if (ath9k_htc_remove_monitor_interface(priv))
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Unable to remove monitor interface\n");
+                        ath_err(common, "Unable to remove monitor interface\n");
                 else
-                        ath_print(common, ATH_DBG_CONFIG,
-                                  "Monitor interface removed\n");
+                        ath_dbg(common, ATH_DBG_CONFIG,
+                                "Monitor interface removed\n");
         }
 
         if (ah->btcoex_hw.enabled) {
@@ -1264,7 +1264,7 @@ static void ath9k_htc_stop(struct ieee80211_hw *hw)
 
         priv->op_flags |= OP_INVALID;
 
-        ath_print(common, ATH_DBG_CONFIG, "Driver halt\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
         mutex_unlock(&priv->mutex);
 }
 
@@ -1298,14 +1298,14 @@ static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
                 hvif.opmode = cpu_to_be32(HTC_M_IBSS);
                 break;
         default:
-                ath_print(common, ATH_DBG_FATAL,
+                ath_err(common,
                         "Interface type %d not yet supported\n", vif->type);
                 ret = -EOPNOTSUPP;
                 goto out;
         }
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Attach a VIF of type: %d\n", vif->type);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Attach a VIF of type: %d\n", vif->type);
 
         priv->ah->opmode = vif->type;
 
@@ -1328,8 +1328,8 @@ static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
 
         ret = ath9k_htc_update_cap_target(priv);
         if (ret)
-                ath_print(common, ATH_DBG_CONFIG, "Failed to update"
-                          " capability in target \n");
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Failed to update capability in target\n");
 
         priv->vif = vif;
 out:
@@ -1349,7 +1349,7 @@ static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
         int ret = 0;
         u8 cmd_rsp;
 
-        ath_print(common, ATH_DBG_CONFIG, "Detach Interface\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
 
         mutex_lock(&priv->mutex);
         ath9k_htc_ps_wakeup(priv);
@@ -1386,8 +1386,8 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
                 mutex_unlock(&priv->htc_pm_lock);
 
                 if (enable_radio) {
-                        ath_print(common, ATH_DBG_CONFIG,
-                                  "not-idle: enabling radio\n");
+                        ath_dbg(common, ATH_DBG_CONFIG,
+                                "not-idle: enabling radio\n");
                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
                         ath9k_htc_radio_enable(hw);
                 }
@@ -1397,21 +1397,21 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
                 struct ieee80211_channel *curchan = hw->conf.channel;
                 int pos = curchan->hw_value;
 
-                ath_print(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
-                          curchan->center_freq);
+                ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
+                        curchan->center_freq);
 
                 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
                                           hw->conf.channel,
                                           hw->conf.channel_type);
 
                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Unable to set channel\n");
+                        ath_err(common, "Unable to set channel\n");
                         mutex_unlock(&priv->mutex);
                         return -EINVAL;
                 }
 
         }
+
         if (changed & IEEE80211_CONF_CHANGE_PS) {
                 if (conf->flags & IEEE80211_CONF_PS) {
                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
@@ -1423,14 +1423,18 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
                 }
         }
 
+        if (changed & IEEE80211_CONF_CHANGE_POWER) {
+                priv->txpowlimit = 2 * conf->power_level;
+                ath_update_txpow(priv);
+        }
+
         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
                 if (conf->flags & IEEE80211_CONF_MONITOR) {
                         if (ath9k_htc_add_monitor_interface(priv))
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "Failed to set monitor mode\n");
+                                ath_err(common, "Failed to set monitor mode\n");
                         else
-                                ath_print(common, ATH_DBG_CONFIG,
-                                          "HW opmode set to Monitor mode\n");
+                                ath_dbg(common, ATH_DBG_CONFIG,
+                                        "HW opmode set to Monitor mode\n");
                 }
         }
 
@@ -1442,8 +1446,8 @@ static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
                 }
                 mutex_unlock(&priv->htc_pm_lock);
 
-                ath_print(common, ATH_DBG_CONFIG,
-                          "idle: disabling radio\n");
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "idle: disabling radio\n");
                 ath9k_htc_radio_disable(hw);
         }
 
@@ -1480,8 +1484,8 @@ static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
         rfilt = ath9k_htc_calcrxfilter(priv);
         ath9k_hw_setrxfilter(priv->ah, rfilt);
 
-        ath_print(ath9k_hw_common(priv->ah), ATH_DBG_CONFIG,
-                  "Set HW RX filter: 0x%x\n", rfilt);
+        ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_CONFIG,
+                "Set HW RX filter: 0x%x\n", rfilt);
 
         ath9k_htc_ps_restore(priv);
         mutex_unlock(&priv->mutex);
@@ -1544,15 +1548,14 @@ static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, u16 queue,
 
         qnum = get_hw_qnum(queue, priv->hwq_map);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Configure tx [queue/hwq] [%d/%d],  "
-                  "aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
-                  queue, qnum, params->aifs, params->cw_min,
-                  params->cw_max, params->txop);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
+                queue, qnum, params->aifs, params->cw_min,
+                params->cw_max, params->txop);
 
         ret = ath_htc_txq_update(priv, qnum, &qi);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
+                ath_err(common, "TXQ Update failed\n");
                 goto out;
         }
 
@@ -1580,7 +1583,7 @@ static int ath9k_htc_set_key(struct ieee80211_hw *hw,
                 return -ENOSPC;
 
         mutex_lock(&priv->mutex);
-        ath_print(common, ATH_DBG_CONFIG, "Set HW Key\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
         ath9k_htc_ps_wakeup(priv);
 
         switch (cmd) {
@@ -1626,7 +1629,7 @@ static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
         if (changed & BSS_CHANGED_ASSOC) {
                 common->curaid = bss_conf->assoc ?
                                  bss_conf->aid : 0;
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
                         bss_conf->assoc);
 
                 if (bss_conf->assoc) {
@@ -1643,9 +1646,9 @@ static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
                 ath9k_hw_write_associd(ah);
 
-                ath_print(common, ATH_DBG_CONFIG,
-                          "BSSID: %pM aid: 0x%x\n",
-                          common->curbssid, common->curaid);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "BSSID: %pM aid: 0x%x\n",
+                        common->curbssid, common->curaid);
         }
 
         if ((changed & BSS_CHANGED_BEACON_INT) ||
@@ -1663,8 +1666,8 @@ static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
-                          bss_conf->use_short_preamble);
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
+                        bss_conf->use_short_preamble);
                 if (bss_conf->use_short_preamble)
                         priv->op_flags |= OP_PREAMBLE_SHORT;
                 else
@@ -1672,8 +1675,8 @@ static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
-                          bss_conf->use_cts_prot);
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
+                        bss_conf->use_cts_prot);
                 if (bss_conf->use_cts_prot &&
                     hw->conf.channel->band != IEEE80211_BAND_5GHZ)
                         priv->op_flags |= OP_PROTECT_ENABLE;
@@ -1764,8 +1767,7 @@ static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
                 spin_unlock_bh(&priv->tx_lock);
                 break;
         default:
-                ath_print(ath9k_hw_common(priv->ah), ATH_DBG_FATAL,
-                          "Unknown AMPDU action\n");
+                ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
         }
 
         return ret;
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
index 77958675b55f..31fad82239b3 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
@@ -69,8 +69,8 @@ int ath_htc_txq_update(struct ath9k_htc_priv *priv, int qnum,
         qi.tqi_readyTime = qinfo->tqi_readyTime;
 
         if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Unable to update hardware queue %u!\n", qnum);
+                ath_err(ath9k_hw_common(ah),
+                        "Unable to update hardware queue %u!\n", qnum);
                 error = -EIO;
         } else {
                 ath9k_hw_resettxqueue(ah, qnum);
@@ -270,8 +270,8 @@ void ath9k_tx_tasklet(unsigned long data)
         if (priv->tx_queues_stop) {
                 priv->tx_queues_stop = false;
                 spin_unlock_bh(&priv->tx_lock);
-                ath_print(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
-                          "Waking up TX queues\n");
+                ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
+                        "Waking up TX queues\n");
                 ieee80211_wake_queues(priv->hw);
                 return;
         }
@@ -296,8 +296,7 @@ void ath9k_htc_txep(void *drv_priv, struct sk_buff *skb,
                    (ep_id == priv->data_vo_ep)) {
                 skb_pull(skb, sizeof(struct tx_frame_hdr));
         } else {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unsupported TX EPID: %d\n", ep_id);
+                ath_err(common, "Unsupported TX EPID: %d\n", ep_id);
                 dev_kfree_skb_any(skb);
                 return;
         }
@@ -337,9 +336,8 @@ bool ath9k_htc_txq_setup(struct ath9k_htc_priv *priv, int subtype)
                 return false;
 
         if (qnum >= ARRAY_SIZE(priv->hwq_map)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "qnum %u out of range, max %u!\n",
-                          qnum, (unsigned int)ARRAY_SIZE(priv->hwq_map));
+                ath_err(common, "qnum %u out of range, max %zu!\n",
+                        qnum, ARRAY_SIZE(priv->hwq_map));
                 ath9k_hw_releasetxqueue(ah, qnum);
                 return false;
         }
@@ -490,8 +488,7 @@ static bool ath9k_rx_prepare(struct ath9k_htc_priv *priv,
         __le16 fc;
 
         if (skb->len <= HTC_RX_FRAME_HEADER_SIZE) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Corrupted RX frame, dropping\n");
+                ath_err(common, "Corrupted RX frame, dropping\n");
                 goto rx_next;
         }
 
@@ -499,10 +496,9 @@ static bool ath9k_rx_prepare(struct ath9k_htc_priv *priv,
 
         if (be16_to_cpu(rxstatus->rs_datalen) -
             (skb->len - HTC_RX_FRAME_HEADER_SIZE) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Corrupted RX data len, dropping "
-                          "(dlen: %d, skblen: %d)\n",
-                          rxstatus->rs_datalen, skb->len);
+                ath_err(common,
+                        "Corrupted RX data len, dropping (dlen: %d, skblen: %d)\n",
+                        rxstatus->rs_datalen, skb->len);
                 goto rx_next;
         }
 
@@ -685,8 +681,8 @@ void ath9k_htc_rxep(void *drv_priv, struct sk_buff *skb,
         spin_unlock(&priv->rx.rxbuflock);
 
         if (rxbuf == NULL) {
-                ath_print(common, ATH_DBG_ANY,
-                          "No free RX buffer\n");
+                ath_dbg(common, ATH_DBG_ANY,
+                        "No free RX buffer\n");
                 goto err;
         }
 
@@ -728,8 +724,7 @@ int ath9k_rx_init(struct ath9k_htc_priv *priv)
         for (i = 0; i < ATH9K_HTC_RXBUF; i++) {
                 rxbuf = kzalloc(sizeof(struct ath9k_htc_rxbuf), GFP_KERNEL);
                 if (rxbuf == NULL) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Unable to allocate RX buffers\n");
+                        ath_err(common, "Unable to allocate RX buffers\n");
                         goto err;
                 }
                 list_add_tail(&rxbuf->list, &priv->rx.rxbuf);
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 9b1ee7fc05c1..516227fa668e 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -129,9 +129,9 @@ bool ath9k_hw_wait(struct ath_hw *ah, u32 reg, u32 mask, u32 val, u32 timeout)
                 udelay(AH_TIME_QUANTUM);
         }
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_ANY,
-                  "timeout (%d us) on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n",
-                  timeout, reg, REG_READ(ah, reg), mask, val);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_ANY,
+                "timeout (%d us) on reg 0x%x: 0x%08x & 0x%08x != 0x%08x\n",
+                timeout, reg, REG_READ(ah, reg), mask, val);
 
         return false;
 }
@@ -211,8 +211,8 @@ u16 ath9k_hw_computetxtime(struct ath_hw *ah,
                 }
                 break;
         default:
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Unknown phy %u (rate ix %u)\n", phy, rateix);
+                ath_err(ath9k_hw_common(ah),
+                        "Unknown phy %u (rate ix %u)\n", phy, rateix);
                 txTime = 0;
                 break;
         }
@@ -331,11 +331,9 @@ static bool ath9k_hw_chip_test(struct ath_hw *ah)
                         REG_WRITE(ah, addr, wrData);
                         rdData = REG_READ(ah, addr);
                         if (rdData != wrData) {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "address test failed "
-                                          "addr: 0x%08x - wr:0x%08x != "
-                                          "rd:0x%08x\n",
-                                          addr, wrData, rdData);
+                                ath_err(common,
+                                        "address test failed addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
+                                        addr, wrData, rdData);
                                 return false;
                         }
                 }
@@ -344,11 +342,9 @@ static bool ath9k_hw_chip_test(struct ath_hw *ah)
                         REG_WRITE(ah, addr, wrData);
                         rdData = REG_READ(ah, addr);
                         if (wrData != rdData) {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "address test failed "
-                                          "addr: 0x%08x - wr:0x%08x != "
-                                          "rd:0x%08x\n",
-                                          addr, wrData, rdData);
+                                ath_err(common,
+                                        "address test failed addr: 0x%08x - wr:0x%08x != rd:0x%08x\n",
+                                        addr, wrData, rdData);
                                 return false;
                         }
                 }
@@ -469,16 +465,15 @@ static int ath9k_hw_post_init(struct ath_hw *ah)
         if (ecode != 0)
                 return ecode;
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_CONFIG,
-                  "Eeprom VER: %d, REV: %d\n",
-                  ah->eep_ops->get_eeprom_ver(ah),
-                  ah->eep_ops->get_eeprom_rev(ah));
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_CONFIG,
+                "Eeprom VER: %d, REV: %d\n",
+                ah->eep_ops->get_eeprom_ver(ah),
+                ah->eep_ops->get_eeprom_rev(ah));
 
         ecode = ath9k_hw_rf_alloc_ext_banks(ah);
         if (ecode) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Failed allocating banks for "
-                          "external radio\n");
+                ath_err(ath9k_hw_common(ah),
+                        "Failed allocating banks for external radio\n");
                 ath9k_hw_rf_free_ext_banks(ah);
                 return ecode;
         }
@@ -509,8 +504,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
                 ah->hw_version.macVersion = AR_SREV_VERSION_9100;
 
         if (!ath9k_hw_set_reset_reg(ah, ATH9K_RESET_POWER_ON)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Couldn't reset chip\n");
+                ath_err(common, "Couldn't reset chip\n");
                 return -EIO;
         }
 
@@ -520,7 +514,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
         ath9k_hw_attach_ops(ah);
 
         if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE)) {
-                ath_print(common, ATH_DBG_FATAL, "Couldn't wakeup chip\n");
+                ath_err(common, "Couldn't wakeup chip\n");
                 return -EIO;
         }
 
@@ -536,7 +530,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
                 }
         }
 
-        ath_print(common, ATH_DBG_RESET, "serialize_regmode is %d\n",
+        ath_dbg(common, ATH_DBG_RESET, "serialize_regmode is %d\n",
                 ah->config.serialize_regmode);
 
         if (AR_SREV_9285(ah) || AR_SREV_9271(ah))
@@ -545,10 +539,9 @@ static int __ath9k_hw_init(struct ath_hw *ah)
                 ah->config.max_txtrig_level = MAX_TX_FIFO_THRESHOLD;
 
         if (!ath9k_hw_macversion_supported(ah)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Mac Chip Rev 0x%02x.%x is not supported by "
-                          "this driver\n", ah->hw_version.macVersion,
-                          ah->hw_version.macRev);
+                ath_err(common,
+                        "Mac Chip Rev 0x%02x.%x is not supported by this driver\n",
+                        ah->hw_version.macVersion, ah->hw_version.macRev);
                 return -EOPNOTSUPP;
         }
 
@@ -594,8 +587,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
 
         r = ath9k_hw_init_macaddr(ah);
         if (r) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Failed to initialize MAC address\n");
+                ath_err(common, "Failed to initialize MAC address\n");
                 return r;
         }
 
@@ -629,21 +621,21 @@ int ath9k_hw_init(struct ath_hw *ah)
         case AR9287_DEVID_PCIE:
         case AR2427_DEVID_PCIE:
         case AR9300_DEVID_PCIE:
+        case AR9300_DEVID_AR9485_PCIE:
                 break;
         default:
                 if (common->bus_ops->ath_bus_type == ATH_USB)
                         break;
-                ath_print(common, ATH_DBG_FATAL,
-                          "Hardware device ID 0x%04x not supported\n",
-                          ah->hw_version.devid);
+                ath_err(common, "Hardware device ID 0x%04x not supported\n",
+                        ah->hw_version.devid);
                 return -EOPNOTSUPP;
         }
 
         ret = __ath9k_hw_init(ah);
         if (ret) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to initialize hardware; "
-                          "initialization status: %d\n", ret);
+                ath_err(common,
+                        "Unable to initialize hardware; initialization status: %d\n",
+                        ret);
                 return ret;
         }
 
@@ -675,7 +667,12 @@ static void ath9k_hw_init_qos(struct ath_hw *ah)
 static void ath9k_hw_init_pll(struct ath_hw *ah,
                               struct ath9k_channel *chan)
 {
-        u32 pll = ath9k_hw_compute_pll_control(ah, chan);
+        u32 pll;
+
+        if (AR_SREV_9485(ah))
+                REG_WRITE(ah, AR_RTC_PLL_CONTROL2, 0x886666);
+
+        pll = ath9k_hw_compute_pll_control(ah, chan);
 
         REG_WRITE(ah, AR_RTC_PLL_CONTROL, pll);
 
@@ -767,8 +764,8 @@ static void ath9k_hw_set_cts_timeout(struct ath_hw *ah, u32 us)
 static bool ath9k_hw_set_global_txtimeout(struct ath_hw *ah, u32 tu)
 {
         if (tu > 0xFFFF) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_XMIT,
-                          "bad global tx timeout %u\n", tu);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_XMIT,
+                        "bad global tx timeout %u\n", tu);
                 ah->globaltxtimeout = (u32) -1;
                 return false;
         } else {
@@ -785,8 +782,8 @@ void ath9k_hw_init_global_settings(struct ath_hw *ah)
         int slottime;
         int sifstime;
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_RESET, "ah->misc_mode 0x%x\n",
-                  ah->misc_mode);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_RESET, "ah->misc_mode 0x%x\n",
+                ah->misc_mode);
 
         if (ah->misc_mode != 0)
                 REG_WRITE(ah, AR_PCU_MISC,
@@ -1029,8 +1026,8 @@ static bool ath9k_hw_set_reset(struct ath_hw *ah, int type)
 
         REG_WRITE(ah, AR_RTC_RC, 0);
         if (!ath9k_hw_wait(ah, AR_RTC_RC, AR_RTC_RC_M, 0, AH_WAIT_TIMEOUT)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_RESET,
-                          "RTC stuck in MAC reset\n");
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_RESET,
+                        "RTC stuck in MAC reset\n");
                 return false;
         }
 
@@ -1076,8 +1073,8 @@ static bool ath9k_hw_set_reset_power_on(struct ath_hw *ah)
                            AR_RTC_STATUS_M,
                            AR_RTC_STATUS_ON,
                            AH_WAIT_TIMEOUT)) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_RESET,
-                          "RTC not waking up\n");
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_RESET,
+                        "RTC not waking up\n");
                 return false;
         }
 
@@ -1137,16 +1134,14 @@ static bool ath9k_hw_channel_change(struct ath_hw *ah,
 
         for (qnum = 0; qnum < AR_NUM_QCU; qnum++) {
                 if (ath9k_hw_numtxpending(ah, qnum)) {
-                        ath_print(common, ATH_DBG_QUEUE,
-                                  "Transmit frames pending on "
-                                  "queue %d\n", qnum);
+                        ath_dbg(common, ATH_DBG_QUEUE,
+                                "Transmit frames pending on queue %d\n", qnum);
                         return false;
                 }
         }
 
         if (!ath9k_hw_rfbus_req(ah)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Could not kill baseband RX\n");
+                ath_err(common, "Could not kill baseband RX\n");
                 return false;
         }
 
@@ -1154,8 +1149,7 @@ static bool ath9k_hw_channel_change(struct ath_hw *ah,
 
         r = ath9k_hw_rf_set_freq(ah, chan);
         if (r) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Failed to set channel\n");
+                ath_err(common, "Failed to set channel\n");
                 return false;
         }
         ath9k_hw_set_clockrate(ah);
@@ -1222,7 +1216,7 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
         if (!ah->chip_fullsleep) {
                 ath9k_hw_abortpcurecv(ah);
                 if (!ath9k_hw_stopdmarecv(ah)) {
-                        ath_print(common, ATH_DBG_XMIT,
+                        ath_dbg(common, ATH_DBG_XMIT,
                                 "Failed to stop receive dma\n");
                         bChannelChange = false;
                 }
@@ -1287,7 +1281,7 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
         }
 
         if (!ath9k_hw_chip_reset(ah, chan)) {
-                ath_print(common, ATH_DBG_FATAL, "Chip reset failed\n");
+                ath_err(common, "Chip reset failed\n");
                 return -EINVAL;
         }
 
@@ -1434,13 +1428,13 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
                 u32 mask;
                 mask = REG_READ(ah, AR_CFG);
                 if (mask & (AR_CFG_SWRB | AR_CFG_SWTB | AR_CFG_SWRG)) {
-                        ath_print(common, ATH_DBG_RESET,
+                        ath_dbg(common, ATH_DBG_RESET,
                                 "CFG Byte Swap Set 0x%x\n", mask);
                 } else {
                         mask =
                                 INIT_CONFIG_STATUS | AR_CFG_SWRB | AR_CFG_SWTB;
                         REG_WRITE(ah, AR_CFG, mask);
-                        ath_print(common, ATH_DBG_RESET,
+                        ath_dbg(common, ATH_DBG_RESET,
                                 "Setting CFG 0x%x\n", REG_READ(ah, AR_CFG));
                 }
         } else {
@@ -1568,9 +1562,9 @@ static bool ath9k_hw_set_power_awake(struct ath_hw *ah, int setChip)
                                     AR_RTC_FORCE_WAKE_EN);
                 }
                 if (i == 0) {
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                  "Failed to wakeup in %uus\n",
-                                  POWER_UP_TIME / 20);
+                        ath_err(ath9k_hw_common(ah),
+                                "Failed to wakeup in %uus\n",
+                                POWER_UP_TIME / 20);
                         return false;
                 }
         }
@@ -1594,8 +1588,8 @@ bool ath9k_hw_setpower(struct ath_hw *ah, enum ath9k_power_mode mode)
         if (ah->power_mode == mode)
                 return status;
 
-        ath_print(common, ATH_DBG_RESET, "%s -> %s\n",
-                  modes[ah->power_mode], modes[mode]);
+        ath_dbg(common, ATH_DBG_RESET, "%s -> %s\n",
+                modes[ah->power_mode], modes[mode]);
 
         switch (mode) {
         case ATH9K_PM_AWAKE:
@@ -1609,12 +1603,18 @@ bool ath9k_hw_setpower(struct ath_hw *ah, enum ath9k_power_mode mode)
                 ath9k_set_power_network_sleep(ah, setChip);
                 break;
         default:
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unknown power mode %u\n", mode);
+                ath_err(common, "Unknown power mode %u\n", mode);
                 return false;
         }
         ah->power_mode = mode;
 
+        /*
+         * XXX: If this warning never comes up after a while then
+         * simply keep the ATH_DBG_WARN_ON_ONCE() but make
+         * ath9k_hw_setpower() return type void.
+         */
+        ATH_DBG_WARN_ON_ONCE(!status);
+
         return status;
 }
 EXPORT_SYMBOL(ath9k_hw_setpower);
@@ -1669,9 +1669,9 @@ void ath9k_hw_beaconinit(struct ath_hw *ah, u32 next_beacon, u32 beacon_period)
                         flags |= AR_TBTT_TIMER_EN;
                         break;
                 }
-                ath_print(ath9k_hw_common(ah), ATH_DBG_BEACON,
-                          "%s: unsupported opmode: %d\n",
-                          __func__, ah->opmode);
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_BEACON,
+                        "%s: unsupported opmode: %d\n",
+                        __func__, ah->opmode);
                 return;
                 break;
         }
@@ -1727,10 +1727,10 @@ void ath9k_hw_set_sta_beacon_timers(struct ath_hw *ah,
         else
                 nextTbtt = bs->bs_nexttbtt;
 
-        ath_print(common, ATH_DBG_BEACON, "next DTIM %d\n", bs->bs_nextdtim);
-        ath_print(common, ATH_DBG_BEACON, "next beacon %d\n", nextTbtt);
-        ath_print(common, ATH_DBG_BEACON, "beacon period %d\n", beaconintval);
-        ath_print(common, ATH_DBG_BEACON, "DTIM period %d\n", dtimperiod);
+        ath_dbg(common, ATH_DBG_BEACON, "next DTIM %d\n", bs->bs_nextdtim);
+        ath_dbg(common, ATH_DBG_BEACON, "next beacon %d\n", nextTbtt);
+        ath_dbg(common, ATH_DBG_BEACON, "beacon period %d\n", beaconintval);
+        ath_dbg(common, ATH_DBG_BEACON, "DTIM period %d\n", dtimperiod);
 
         ENABLE_REGWRITE_BUFFER(ah);
 
@@ -1776,7 +1776,7 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
         struct ath_btcoex_hw *btcoex_hw = &ah->btcoex_hw;
 
         u16 capField = 0, eeval;
-        u8 ant_div_ctl1;
+        u8 ant_div_ctl1, tx_chainmask, rx_chainmask;
 
         eeval = ah->eep_ops->get_eeprom(ah, EEP_REG_0);
         regulatory->current_rd = eeval;
@@ -1795,14 +1795,14 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
                         regulatory->current_rd += 5;
                 else if (regulatory->current_rd == 0x41)
                         regulatory->current_rd = 0x43;
-                ath_print(common, ATH_DBG_REGULATORY,
-                          "regdomain mapped to 0x%x\n", regulatory->current_rd);
+                ath_dbg(common, ATH_DBG_REGULATORY,
+                        "regdomain mapped to 0x%x\n", regulatory->current_rd);
         }
 
         eeval = ah->eep_ops->get_eeprom(ah, EEP_OP_MODE);
         if ((eeval & (AR5416_OPFLAGS_11G | AR5416_OPFLAGS_11A)) == 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "no band has been marked as supported in EEPROM.\n");
+                ath_err(common,
+                        "no band has been marked as supported in EEPROM\n");
                 return -EINVAL;
         }
 
@@ -1940,8 +1940,10 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
         }
 
         if (AR_SREV_9300_20_OR_LATER(ah)) {
-                pCap->hw_caps |= ATH9K_HW_CAP_EDMA | ATH9K_HW_CAP_LDPC |
-                                 ATH9K_HW_CAP_FASTCLOCK;
+                pCap->hw_caps |= ATH9K_HW_CAP_EDMA | ATH9K_HW_CAP_FASTCLOCK;
+                if (!AR_SREV_9485(ah))
+                        pCap->hw_caps |= ATH9K_HW_CAP_LDPC;
+
                 pCap->rx_hp_qdepth = ATH9K_HW_RX_HP_QDEPTH;
                 pCap->rx_lp_qdepth = ATH9K_HW_RX_LP_QDEPTH;
                 pCap->rx_status_len = sizeof(struct ar9003_rxs);
@@ -1981,6 +1983,23 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
 
 
 
+        if (AR_SREV_9485_10(ah)) {
+                pCap->pcie_lcr_extsync_en = true;
+                pCap->pcie_lcr_offset = 0x80;
+        }
+
+        tx_chainmask = pCap->tx_chainmask;
+        rx_chainmask = pCap->rx_chainmask;
+        while (tx_chainmask || rx_chainmask) {
+                if (tx_chainmask & BIT(0))
+                        pCap->max_txchains++;
+                if (rx_chainmask & BIT(0))
+                        pCap->max_rxchains++;
+
+                tx_chainmask >>= 1;
+                rx_chainmask >>= 1;
+        }
+
         return 0;
 }
 
@@ -2257,8 +2276,8 @@ void ath9k_hw_reset_tsf(struct ath_hw *ah)
 {
         if (!ath9k_hw_wait(ah, AR_SLP32_MODE, AR_SLP32_TSF_WRITE_STATUS, 0,
                            AH_TSF_WRITE_TIMEOUT))
-                ath_print(ath9k_hw_common(ah), ATH_DBG_RESET,
-                          "AR_SLP32_TSF_WRITE_STATUS limit exceeded\n");
+                ath_dbg(ath9k_hw_common(ah), ATH_DBG_RESET,
+                        "AR_SLP32_TSF_WRITE_STATUS limit exceeded\n");
 
         REG_WRITE(ah, AR_RESET_TSF, AR_RESET_TSF_ONCE);
 }
@@ -2348,9 +2367,9 @@ struct ath_gen_timer *ath_gen_timer_alloc(struct ath_hw *ah,
         timer = kzalloc(sizeof(struct ath_gen_timer), GFP_KERNEL);
 
         if (timer == NULL) {
-                ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                          "Failed to allocate memory"
-                          "for hw timer[%d]\n", timer_index);
+                ath_err(ath9k_hw_common(ah),
+                        "Failed to allocate memory for hw timer[%d]\n",
+                        timer_index);
                 return NULL;
         }
 
@@ -2379,9 +2398,9 @@ void ath9k_hw_gen_timer_start(struct ath_hw *ah,
 
         tsf = ath9k_hw_gettsf32(ah);
 
-        ath_print(ath9k_hw_common(ah), ATH_DBG_HWTIMER,
-                  "curent tsf %x period %x"
-                  "timer_next %x\n", tsf, timer_period, timer_next);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_HWTIMER,
+                "current tsf %x period %x timer_next %x\n",
+                tsf, timer_period, timer_next);
 
         /*
          * Pull timer_next forward if the current TSF already passed it
@@ -2461,8 +2480,8 @@ void ath_gen_timer_isr(struct ath_hw *ah)
                 index = rightmost_index(timer_table, &thresh_mask);
                 timer = timer_table->timers[index];
                 BUG_ON(!timer);
-                ath_print(common, ATH_DBG_HWTIMER,
-                          "TSF overflow for Gen timer %d\n", index);
+                ath_dbg(common, ATH_DBG_HWTIMER,
+                        "TSF overflow for Gen timer %d\n", index);
                 timer->overflow(timer->arg);
         }
 
@@ -2470,8 +2489,8 @@ void ath_gen_timer_isr(struct ath_hw *ah)
                 index = rightmost_index(timer_table, &trigger_mask);
                 timer = timer_table->timers[index];
                 BUG_ON(!timer);
-                ath_print(common, ATH_DBG_HWTIMER,
-                          "Gen timer[%d] trigger\n", index);
+                ath_dbg(common, ATH_DBG_HWTIMER,
+                        "Gen timer[%d] trigger\n", index);
                 timer->trigger(timer->arg);
         }
 }
diff --git a/drivers/net/wireless/ath/ath9k/hw.h b/drivers/net/wireless/ath/ath9k/hw.h
index 5fcfa48a45df..d83cc3b4685b 100644
--- a/drivers/net/wireless/ath/ath9k/hw.h
+++ b/drivers/net/wireless/ath/ath9k/hw.h
@@ -30,7 +30,6 @@
 #include "btcoex.h"
 
 #include "../regd.h"
-#include "../debug.h"
 
 #define ATHEROS_VENDOR_ID       0x168c
 
@@ -44,6 +43,7 @@
 #define AR9287_DEVID_PCI        0x002d
 #define AR9287_DEVID_PCIE       0x002e
 #define AR9300_DEVID_PCIE       0x0030
+#define AR9300_DEVID_AR9485_PCIE 0x0032
 
 #define AR5416_AR9100_DEVID     0x000b
 
@@ -199,6 +199,8 @@ struct ath9k_hw_capabilities {
         u16 rts_aggr_limit;
         u8 tx_chainmask;
         u8 rx_chainmask;
+        u8 max_txchains;
+        u8 max_rxchains;
         u16 tx_triglevel_max;
         u16 reg_cap;
         u8 num_gpio_pins;
@@ -209,6 +211,8 @@ struct ath9k_hw_capabilities {
         u8 rx_status_len;
         u8 tx_desc_len;
         u8 txs_len;
+        u16 pcie_lcr_offset;
+        bool pcie_lcr_extsync_en;
 };
 
 struct ath9k_ops_config {
@@ -442,6 +446,7 @@ struct ath9k_hw_version {
         u16 analog5GhzRev;
         u16 analog2GhzRev;
         u16 subsysid;
+        enum ath_usb_dev usbdev;
 };
 
 /* Generic TSF timer definitions */
diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index 918308a28410..b2983ce19dfb 100644
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -210,7 +210,9 @@ static void setup_ht_cap(struct ath_softc *sc,
         ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
         ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
 
-        if (AR_SREV_9300_20_OR_LATER(ah))
+        if (AR_SREV_9485(ah))
+                max_streams = 1;
+        else if (AR_SREV_9300_20_OR_LATER(ah))
                 max_streams = 3;
         else
                 max_streams = 2;
@@ -226,9 +228,9 @@ static void setup_ht_cap(struct ath_softc *sc,
         tx_streams = ath9k_cmn_count_streams(common->tx_chainmask, max_streams);
         rx_streams = ath9k_cmn_count_streams(common->rx_chainmask, max_streams);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "TX streams %d, RX streams: %d\n",
-                  tx_streams, rx_streams);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "TX streams %d, RX streams: %d\n",
+                tx_streams, rx_streams);
 
         if (tx_streams != rx_streams) {
                 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
@@ -271,8 +273,8 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
         struct ath_buf *bf;
         int i, bsize, error, desc_len;
 
-        ath_print(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
-                  name, nbuf, ndesc);
+        ath_dbg(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
+                name, nbuf, ndesc);
 
         INIT_LIST_HEAD(head);
 
@@ -283,8 +285,7 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 
         /* ath_desc must be a multiple of DWORDs */
         if ((desc_len % 4) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "ath_desc not DWORD aligned\n");
+                ath_err(common, "ath_desc not DWORD aligned\n");
                 BUG_ON((desc_len % 4) != 0);
                 error = -ENOMEM;
                 goto fail;
@@ -318,9 +319,9 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
                 goto fail;
         }
         ds = (u8 *) dd->dd_desc;
-        ath_print(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
-                  name, ds, (u32) dd->dd_desc_len,
-                  ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
+        ath_dbg(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
+                name, ds, (u32) dd->dd_desc_len,
+                ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
 
         /* allocate buffers */
         bsize = sizeof(struct ath_buf) * nbuf;
@@ -374,9 +375,9 @@ static void ath9k_init_crypto(struct ath_softc *sc)
         /* Get the hardware key cache size. */
         common->keymax = sc->sc_ah->caps.keycache_size;
         if (common->keymax > ATH_KEYMAX) {
-                ath_print(common, ATH_DBG_ANY,
-                          "Warning, using only %u entries in %u key cache\n",
-                          ATH_KEYMAX, common->keymax);
+                ath_dbg(common, ATH_DBG_ANY,
+                        "Warning, using only %u entries in %u key cache\n",
+                        ATH_KEYMAX, common->keymax);
                 common->keymax = ATH_KEYMAX;
         }
 
@@ -641,7 +642,8 @@ void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
                 IEEE80211_HW_SUPPORTS_PS |
                 IEEE80211_HW_PS_NULLFUNC_STACK |
                 IEEE80211_HW_SPECTRUM_MGMT |
-                IEEE80211_HW_REPORTS_TX_ACK_STATUS;
+                IEEE80211_HW_REPORTS_TX_ACK_STATUS |
+                IEEE80211_HW_NEED_DTIM_PERIOD;
 
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
                  hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
@@ -736,8 +738,7 @@ int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
 
         error = ath9k_init_debug(ah);
         if (error) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to create debugfs files\n");
+                ath_err(common, "Unable to create debugfs files\n");
                 goto error_world;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/mac.c b/drivers/net/wireless/ath/ath9k/mac.c
index b04b37b1124b..e3d2ebf00e2e 100644
--- a/drivers/net/wireless/ath/ath9k/mac.c
+++ b/drivers/net/wireless/ath/ath9k/mac.c
@@ -20,11 +20,11 @@
 static void ath9k_hw_set_txq_interrupts(struct ath_hw *ah,
                                         struct ath9k_tx_queue_info *qi)
 {
-        ath_print(ath9k_hw_common(ah), ATH_DBG_INTERRUPT,
-                  "tx ok 0x%x err 0x%x desc 0x%x eol 0x%x urn 0x%x\n",
-                  ah->txok_interrupt_mask, ah->txerr_interrupt_mask,
-                  ah->txdesc_interrupt_mask, ah->txeol_interrupt_mask,
-                  ah->txurn_interrupt_mask);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_INTERRUPT,
+                "tx ok 0x%x err 0x%x desc 0x%x eol 0x%x urn 0x%x\n",
+                ah->txok_interrupt_mask, ah->txerr_interrupt_mask,
+                ah->txdesc_interrupt_mask, ah->txeol_interrupt_mask,
+                ah->txurn_interrupt_mask);
 
         ENABLE_REGWRITE_BUFFER(ah);
 
@@ -56,8 +56,8 @@ EXPORT_SYMBOL(ath9k_hw_puttxbuf);
 
 void ath9k_hw_txstart(struct ath_hw *ah, u32 q)
 {
-        ath_print(ath9k_hw_common(ah), ATH_DBG_QUEUE,
-                  "Enable TXE on queue: %u\n", q);
+        ath_dbg(ath9k_hw_common(ah), ATH_DBG_QUEUE,
+                "Enable TXE on queue: %u\n", q);
         REG_WRITE(ah, AR_Q_TXE, 1 << q);
 }
 EXPORT_SYMBOL(ath9k_hw_txstart);
@@ -154,15 +154,15 @@ bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
         u32 wait_time = ATH9K_TX_STOP_DMA_TIMEOUT / ATH9K_TIME_QUANTUM;
 
         if (q >= pCap->total_queues) {
-                ath_print(common, ATH_DBG_QUEUE, "Stopping TX DMA, "
-                          "invalid queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Stopping TX DMA, invalid queue: %u\n", q);
                 return false;
         }
 
         qi = &ah->txq[q];
         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_QUEUE, "Stopping TX DMA, "
-                          "inactive queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Stopping TX DMA, inactive queue: %u\n", q);
                 return false;
         }
 
@@ -175,9 +175,9 @@ bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
         }
 
         if (ath9k_hw_numtxpending(ah, q)) {
-                ath_print(common, ATH_DBG_QUEUE,
-                          "%s: Num of pending TX Frames %d on Q %d\n",
-                          __func__, ath9k_hw_numtxpending(ah, q), q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "%s: Num of pending TX Frames %d on Q %d\n",
+                        __func__, ath9k_hw_numtxpending(ah, q), q);
 
                 for (j = 0; j < 2; j++) {
                         tsfLow = REG_READ(ah, AR_TSF_L32);
@@ -191,9 +191,9 @@ bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
                         if ((REG_READ(ah, AR_TSF_L32) >> 10) == (tsfLow >> 10))
                                 break;
 
-                        ath_print(common, ATH_DBG_QUEUE,
-                                  "TSF has moved while trying to set "
-                                  "quiet time TSF: 0x%08x\n", tsfLow);
+                        ath_dbg(common, ATH_DBG_QUEUE,
+                                "TSF has moved while trying to set quiet time TSF: 0x%08x\n",
+                                tsfLow);
                 }
 
                 REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
@@ -204,9 +204,8 @@ bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
                 wait = wait_time;
                 while (ath9k_hw_numtxpending(ah, q)) {
                         if ((--wait) == 0) {
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "Failed to stop TX DMA in 100 "
-                                          "msec after killing last frame\n");
+                                ath_err(common,
+                                        "Failed to stop TX DMA in 100 msec after killing last frame\n");
                                 break;
                         }
                         udelay(ATH9K_TIME_QUANTUM);
@@ -239,19 +238,19 @@ bool ath9k_hw_set_txq_props(struct ath_hw *ah, int q,
         struct ath9k_tx_queue_info *qi;
 
         if (q >= pCap->total_queues) {
-                ath_print(common, ATH_DBG_QUEUE, "Set TXQ properties, "
-                          "invalid queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Set TXQ properties, invalid queue: %u\n", q);
                 return false;
         }
 
         qi = &ah->txq[q];
         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_QUEUE, "Set TXQ properties, "
-                          "inactive queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Set TXQ properties, inactive queue: %u\n", q);
                 return false;
         }
 
-        ath_print(common, ATH_DBG_QUEUE, "Set queue properties for: %u\n", q);
+        ath_dbg(common, ATH_DBG_QUEUE, "Set queue properties for: %u\n", q);
 
         qi->tqi_ver = qinfo->tqi_ver;
         qi->tqi_subtype = qinfo->tqi_subtype;
@@ -310,15 +309,15 @@ bool ath9k_hw_get_txq_props(struct ath_hw *ah, int q,
         struct ath9k_tx_queue_info *qi;
 
         if (q >= pCap->total_queues) {
-                ath_print(common, ATH_DBG_QUEUE, "Get TXQ properties, "
-                          "invalid queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Get TXQ properties, invalid queue: %u\n", q);
                 return false;
         }
 
         qi = &ah->txq[q];
         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_QUEUE, "Get TXQ properties, "
-                          "inactive queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Get TXQ properties, inactive queue: %u\n", q);
                 return false;
         }
 
@@ -368,23 +367,20 @@ int ath9k_hw_setuptxqueue(struct ath_hw *ah, enum ath9k_tx_queue type,
                             ATH9K_TX_QUEUE_INACTIVE)
                                 break;
                 if (q == pCap->total_queues) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "No available TX queue\n");
+                        ath_err(common, "No available TX queue\n");
                         return -1;
                 }
                 break;
         default:
-                ath_print(common, ATH_DBG_FATAL,
-                          "Invalid TX queue type: %u\n", type);
+                ath_err(common, "Invalid TX queue type: %u\n", type);
                 return -1;
         }
 
-        ath_print(common, ATH_DBG_QUEUE, "Setup TX queue: %u\n", q);
+        ath_dbg(common, ATH_DBG_QUEUE, "Setup TX queue: %u\n", q);
 
         qi = &ah->txq[q];
         if (qi->tqi_type != ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "TX queue: %u already active\n", q);
+                ath_err(common, "TX queue: %u already active\n", q);
                 return -1;
         }
         memset(qi, 0, sizeof(struct ath9k_tx_queue_info));
@@ -416,18 +412,18 @@ bool ath9k_hw_releasetxqueue(struct ath_hw *ah, u32 q)
         struct ath9k_tx_queue_info *qi;
 
         if (q >= pCap->total_queues) {
-                ath_print(common, ATH_DBG_QUEUE, "Release TXQ, "
-                          "invalid queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Release TXQ, invalid queue: %u\n", q);
                 return false;
         }
         qi = &ah->txq[q];
         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_QUEUE, "Release TXQ, "
-                          "inactive queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Release TXQ, inactive queue: %u\n", q);
                 return false;
         }
 
-        ath_print(common, ATH_DBG_QUEUE, "Release TX queue: %u\n", q);
+        ath_dbg(common, ATH_DBG_QUEUE, "Release TX queue: %u\n", q);
 
         qi->tqi_type = ATH9K_TX_QUEUE_INACTIVE;
         ah->txok_interrupt_mask &= ~(1 << q);
@@ -450,19 +446,19 @@ bool ath9k_hw_resettxqueue(struct ath_hw *ah, u32 q)
         u32 cwMin, chanCwMin, value;
 
         if (q >= pCap->total_queues) {
-                ath_print(common, ATH_DBG_QUEUE, "Reset TXQ, "
-                          "invalid queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Reset TXQ, invalid queue: %u\n", q);
                 return false;
         }
 
         qi = &ah->txq[q];
         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
-                ath_print(common, ATH_DBG_QUEUE, "Reset TXQ, "
-                          "inactive queue: %u\n", q);
+                ath_dbg(common, ATH_DBG_QUEUE,
+                        "Reset TXQ, inactive queue: %u\n", q);
                 return true;
         }
 
-        ath_print(common, ATH_DBG_QUEUE, "Reset TX queue: %u\n", q);
+        ath_dbg(common, ATH_DBG_QUEUE, "Reset TX queue: %u\n", q);
 
         if (qi->tqi_cwmin == ATH9K_TXQ_USEDEFAULT) {
                 if (chan && IS_CHAN_B(chan))
@@ -702,8 +698,7 @@ int ath9k_hw_rxprocdesc(struct ath_hw *ah, struct ath_desc *ds,
                         rs->rs_phyerr = phyerr;
                 } else if (ads.ds_rxstatus8 & AR_DecryptCRCErr)
                         rs->rs_status |= ATH9K_RXERR_DECRYPT;
-                else if ((ads.ds_rxstatus8 & AR_MichaelErr) &&
-                         rs->rs_keyix != ATH9K_RXKEYIX_INVALID)
+                else if (ads.ds_rxstatus8 & AR_MichaelErr)
                         rs->rs_status |= ATH9K_RXERR_MIC;
                 else if (ads.ds_rxstatus8 & AR_KeyMiss)
                         rs->rs_status |= ATH9K_RXERR_DECRYPT;
@@ -735,9 +730,9 @@ bool ath9k_hw_setrxabort(struct ath_hw *ah, bool set)
                                      AR_DIAG_RX_ABORT));
 
                         reg = REG_READ(ah, AR_OBS_BUS_1);
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
-                                  "RX failed to go idle in 10 ms RXSM=0x%x\n",
-                                  reg);
+                        ath_err(ath9k_hw_common(ah),
+                                "RX failed to go idle in 10 ms RXSM=0x%x\n",
+                                reg);
 
                         return false;
                 }
@@ -791,12 +786,11 @@ bool ath9k_hw_stopdmarecv(struct ath_hw *ah)
         }
 
         if (i == 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "DMA failed to stop in %d ms "
-                          "AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
-                          AH_RX_STOP_DMA_TIMEOUT / 1000,
-                          REG_READ(ah, AR_CR),
-                          REG_READ(ah, AR_DIAG_SW));
+                ath_err(common,
+                        "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
+                        AH_RX_STOP_DMA_TIMEOUT / 1000,
+                        REG_READ(ah, AR_CR),
+                        REG_READ(ah, AR_DIAG_SW));
                 return false;
         } else {
                 return true;
@@ -844,7 +838,7 @@ void ath9k_hw_disable_interrupts(struct ath_hw *ah)
 {
         struct ath_common *common = ath9k_hw_common(ah);
 
-        ath_print(common, ATH_DBG_INTERRUPT, "disable IER\n");
+        ath_dbg(common, ATH_DBG_INTERRUPT, "disable IER\n");
         REG_WRITE(ah, AR_IER, AR_IER_DISABLE);
         (void) REG_READ(ah, AR_IER);
         if (!AR_SREV_9100(ah)) {
@@ -864,7 +858,7 @@ void ath9k_hw_enable_interrupts(struct ath_hw *ah)
         if (!(ah->imask & ATH9K_INT_GLOBAL))
                 return;
 
-        ath_print(common, ATH_DBG_INTERRUPT, "enable IER\n");
+        ath_dbg(common, ATH_DBG_INTERRUPT, "enable IER\n");
         REG_WRITE(ah, AR_IER, AR_IER_ENABLE);
         if (!AR_SREV_9100(ah)) {
                 REG_WRITE(ah, AR_INTR_ASYNC_ENABLE,
@@ -877,8 +871,8 @@ void ath9k_hw_enable_interrupts(struct ath_hw *ah)
                 REG_WRITE(ah, AR_INTR_SYNC_MASK,
                           AR_INTR_SYNC_DEFAULT);
         }
-        ath_print(common, ATH_DBG_INTERRUPT, "AR_IMR 0x%x IER 0x%x\n",
-                  REG_READ(ah, AR_IMR), REG_READ(ah, AR_IER));
+        ath_dbg(common, ATH_DBG_INTERRUPT, "AR_IMR 0x%x IER 0x%x\n",
+                REG_READ(ah, AR_IMR), REG_READ(ah, AR_IER));
 }
 EXPORT_SYMBOL(ath9k_hw_enable_interrupts);
 
@@ -892,7 +886,7 @@ void ath9k_hw_set_interrupts(struct ath_hw *ah, enum ath9k_int ints)
         if (!(ints & ATH9K_INT_GLOBAL))
                 ath9k_hw_enable_interrupts(ah);
 
-        ath_print(common, ATH_DBG_INTERRUPT, "0x%x => 0x%x\n", omask, ints);
+        ath_dbg(common, ATH_DBG_INTERRUPT, "0x%x => 0x%x\n", omask, ints);
 
         /* TODO: global int Ref count */
         mask = ints & ATH9K_INT_COMMON;
@@ -953,7 +947,7 @@ void ath9k_hw_set_interrupts(struct ath_hw *ah, enum ath9k_int ints)
                         mask2 |= AR_IMR_S2_CST;
         }
 
-        ath_print(common, ATH_DBG_INTERRUPT, "new IMR 0x%x\n", mask);
+        ath_dbg(common, ATH_DBG_INTERRUPT, "new IMR 0x%x\n", mask);
         REG_WRITE(ah, AR_IMR, mask);
         ah->imrs2_reg &= ~(AR_IMR_S2_TIM | AR_IMR_S2_DTIM | AR_IMR_S2_DTIMSYNC |
                            AR_IMR_S2_CABEND | AR_IMR_S2_CABTO |
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index f026a031713b..daa3c9feca66 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -246,9 +246,10 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
          * the relevant bits of the h/w.
          */
         ath9k_hw_disable_interrupts(ah);
-        ath_drain_all_txq(sc, false);
+        stopped = ath_drain_all_txq(sc, false);
 
-        stopped = ath_stoprecv(sc);
+        if (!ath_stoprecv(sc))
+                stopped = false;
 
         /* XXX: do not flush receive queue here. We don't want
          * to flush data frames already in queue because of
@@ -260,24 +261,22 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
         if (!(sc->sc_flags & SC_OP_OFFCHANNEL))
                 caldata = &aphy->caldata;
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "(%u MHz) -> (%u MHz), conf_is_ht40: %d fastcc: %d\n",
-                  sc->sc_ah->curchan->channel,
-                  channel->center_freq, conf_is_ht40(conf),
-                  fastcc);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "(%u MHz) -> (%u MHz), conf_is_ht40: %d fastcc: %d\n",
+                sc->sc_ah->curchan->channel,
+                channel->center_freq, conf_is_ht40(conf),
+                fastcc);
 
         r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
         if (r) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset channel (%u MHz), "
-                          "reset status %d\n",
-                          channel->center_freq, r);
+                ath_err(common,
+                        "Unable to reset channel (%u MHz), reset status %d\n",
+                        channel->center_freq, r);
                 goto ps_restore;
         }
 
         if (ath_startrecv(sc) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to restart recv logic\n");
+                ath_err(common, "Unable to restart recv logic\n");
                 r = -EIO;
                 goto ps_restore;
         }
@@ -389,10 +388,9 @@ void ath_paprd_calibrate(struct work_struct *work)
                                 msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
                 sc->paprd_pending = false;
                 if (!time_left) {
-                        ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
-                                  "Timeout waiting for paprd training on "
-                                  "TX chain %d\n",
-                                  chain);
+                        ath_dbg(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
+                                "Timeout waiting for paprd training on TX chain %d\n",
+                                chain);
                         goto fail_paprd;
                 }
 
@@ -451,7 +449,7 @@ void ath_ani_calibrate(unsigned long data)
         /* Long calibration runs independently of short calibration. */
         if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
                 longcal = true;
-                ath_print(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
+                ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
                 common->ani.longcal_timer = timestamp;
         }
 
@@ -459,8 +457,8 @@ void ath_ani_calibrate(unsigned long data)
         if (!common->ani.caldone) {
                 if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
                         shortcal = true;
-                        ath_print(common, ATH_DBG_ANI,
-                                  "shortcal @%lu\n", jiffies);
+                        ath_dbg(common, ATH_DBG_ANI,
+                                "shortcal @%lu\n", jiffies);
                         common->ani.shortcal_timer = timestamp;
                         common->ani.resetcal_timer = timestamp;
                 }
@@ -544,10 +542,10 @@ void ath_update_chainmask(struct ath_softc *sc, int is_ht)
                 common->rx_chainmask = 1;
         }
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "tx chmask: %d, rx chmask: %d\n",
-                  common->tx_chainmask,
-                  common->rx_chainmask);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "tx chmask: %d, rx chmask: %d\n",
+                common->tx_chainmask,
+                common->rx_chainmask);
 }
 
 static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta)
@@ -643,8 +641,8 @@ void ath9k_tasklet(unsigned long data)
                  * TSF sync does not look correct; remain awake to sync with
                  * the next Beacon.
                  */
-                ath_print(common, ATH_DBG_PS,
-                          "TSFOOR - Sync with next Beacon\n");
+                ath_dbg(common, ATH_DBG_PS,
+                        "TSFOOR - Sync with next Beacon\n");
                 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
         }
 
@@ -768,6 +766,8 @@ irqreturn_t ath_isr(int irq, void *dev)
 
         if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
                 if (status & ATH9K_INT_TIM_TIMER) {
+                        if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
+                                goto chip_reset;
                         /* Clear RxAbort bit so that we can
                          * receive frames */
                         ath9k_setpower(sc, ATH9K_PM_AWAKE);
@@ -842,9 +842,9 @@ static void ath9k_bss_assoc_info(struct ath_softc *sc,
         struct ath_common *common = ath9k_hw_common(ah);
 
         if (bss_conf->assoc) {
-                ath_print(common, ATH_DBG_CONFIG,
-                          "Bss Info ASSOC %d, bssid: %pM\n",
-                           bss_conf->aid, common->curbssid);
+                ath_dbg(common, ATH_DBG_CONFIG,
+                        "Bss Info ASSOC %d, bssid: %pM\n",
+                        bss_conf->aid, common->curbssid);
 
                 /* New association, store aid */
                 common->curaid = bss_conf->aid;
@@ -867,7 +867,7 @@ static void ath9k_bss_assoc_info(struct ath_softc *sc,
                 sc->sc_flags |= SC_OP_ANI_RUN;
                 ath_start_ani(common);
         } else {
-                ath_print(common, ATH_DBG_CONFIG, "Bss Info DISASSOC\n");
+                ath_dbg(common, ATH_DBG_CONFIG, "Bss Info DISASSOC\n");
                 common->curaid = 0;
                 /* Stop ANI */
                 sc->sc_flags &= ~SC_OP_ANI_RUN;
@@ -892,16 +892,14 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
 
         r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (r) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset channel (%u MHz), "
-                          "reset status %d\n",
-                          channel->center_freq, r);
+                ath_err(common,
+                        "Unable to reset channel (%u MHz), reset status %d\n",
+                        channel->center_freq, r);
         }
 
         ath_update_txpow(sc);
         if (ath_startrecv(sc) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to restart recv logic\n");
+                ath_err(common, "Unable to restart recv logic\n");
                 spin_unlock_bh(&sc->sc_pcu_lock);
                 return;
         }
@@ -955,10 +953,9 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
 
         r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (r) {
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "Unable to reset channel (%u MHz), "
-                          "reset status %d\n",
-                          channel->center_freq, r);
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "Unable to reset channel (%u MHz), reset status %d\n",
+                        channel->center_freq, r);
         }
 
         ath9k_hw_phy_disable(ah);
@@ -993,12 +990,11 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
 
         r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
         if (r)
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset hardware; reset status %d\n", r);
+                ath_err(common,
+                        "Unable to reset hardware; reset status %d\n", r);
 
         if (ath_startrecv(sc) != 0)
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to start recv logic\n");
+                ath_err(common, "Unable to start recv logic\n");
 
         /*
          * We may be doing a reset in response to a request
@@ -1070,9 +1066,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
         struct ath9k_channel *init_channel;
         int r;
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Starting driver with initial channel: %d MHz\n",
-                  curchan->center_freq);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Starting driver with initial channel: %d MHz\n",
+                curchan->center_freq);
 
         mutex_lock(&sc->mutex);
 
@@ -1116,10 +1112,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
         spin_lock_bh(&sc->sc_pcu_lock);
         r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
         if (r) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to reset hardware; reset status %d "
-                          "(freq %u MHz)\n", r,
-                          curchan->center_freq);
+                ath_err(common,
+                        "Unable to reset hardware; reset status %d (freq %u MHz)\n",
+                        r, curchan->center_freq);
                 spin_unlock_bh(&sc->sc_pcu_lock);
                 goto mutex_unlock;
         }
@@ -1138,8 +1133,7 @@ static int ath9k_start(struct ieee80211_hw *hw)
          * here except setup the interrupt mask.
          */
         if (ath_startrecv(sc) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to start recv logic\n");
+                ath_err(common, "Unable to start recv logic\n");
                 r = -EIO;
                 spin_unlock_bh(&sc->sc_pcu_lock);
                 goto mutex_unlock;
@@ -1188,6 +1182,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
 
         pm_qos_update_request(&sc->pm_qos_req, 55);
 
+        if (ah->caps.pcie_lcr_extsync_en && common->bus_ops->extn_synch_en)
+                common->bus_ops->extn_synch_en(common);
+
 mutex_unlock:
         mutex_unlock(&sc->mutex);
 
@@ -1204,9 +1201,9 @@ static int ath9k_tx(struct ieee80211_hw *hw,
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 
         if (aphy->state != ATH_WIPHY_ACTIVE && aphy->state != ATH_WIPHY_SCAN) {
-                ath_print(common, ATH_DBG_XMIT,
-                          "ath9k: %s: TX in unexpected wiphy state "
-                          "%d\n", wiphy_name(hw->wiphy), aphy->state);
+                ath_dbg(common, ATH_DBG_XMIT,
+                        "ath9k: %s: TX in unexpected wiphy state %d\n",
+                        wiphy_name(hw->wiphy), aphy->state);
                 goto exit;
         }
 
@@ -1218,8 +1215,8 @@ static int ath9k_tx(struct ieee80211_hw *hw,
                 if (ieee80211_is_data(hdr->frame_control) &&
                     !ieee80211_is_nullfunc(hdr->frame_control) &&
                     !ieee80211_has_pm(hdr->frame_control)) {
-                        ath_print(common, ATH_DBG_PS, "Add PM=1 for a TX frame "
-                                  "while in PS mode\n");
+                        ath_dbg(common, ATH_DBG_PS,
+                                "Add PM=1 for a TX frame while in PS mode\n");
                         hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
                 }
         }
@@ -1234,12 +1231,12 @@ static int ath9k_tx(struct ieee80211_hw *hw,
                 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
                         ath9k_hw_setrxabort(sc->sc_ah, 0);
                 if (ieee80211_is_pspoll(hdr->frame_control)) {
-                        ath_print(common, ATH_DBG_PS,
-                                  "Sending PS-Poll to pick a buffered frame\n");
+                        ath_dbg(common, ATH_DBG_PS,
+                                "Sending PS-Poll to pick a buffered frame\n");
                         sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
                 } else {
-                        ath_print(common, ATH_DBG_PS,
-                                  "Wake up to complete TX\n");
+                        ath_dbg(common, ATH_DBG_PS,
+                                "Wake up to complete TX\n");
                         sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
                 }
                 /*
@@ -1253,10 +1250,10 @@ static int ath9k_tx(struct ieee80211_hw *hw,
         memset(&txctl, 0, sizeof(struct ath_tx_control));
         txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
 
-        ath_print(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
+        ath_dbg(common, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
 
         if (ath_tx_start(hw, skb, &txctl) != 0) {
-                ath_print(common, ATH_DBG_XMIT, "TX failed\n");
+                ath_dbg(common, ATH_DBG_XMIT, "TX failed\n");
                 goto exit;
         }
 
@@ -1296,7 +1293,7 @@ static void ath9k_stop(struct ieee80211_hw *hw)
         }
 
         if (sc->sc_flags & SC_OP_INVALID) {
-                ath_print(common, ATH_DBG_ANY, "Device not present\n");
+                ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
                 mutex_unlock(&sc->mutex);
                 return;
         }
@@ -1345,7 +1342,7 @@ static void ath9k_stop(struct ieee80211_hw *hw)
 
         mutex_unlock(&sc->mutex);
 
-        ath_print(common, ATH_DBG_CONFIG, "Driver halt\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
 }
 
 static int ath9k_add_interface(struct ieee80211_hw *hw,
@@ -1378,14 +1375,14 @@ static int ath9k_add_interface(struct ieee80211_hw *hw,
                 ic_opmode = vif->type;
                 break;
         default:
-                ath_print(common, ATH_DBG_FATAL,
-                        "Interface type %d not yet supported\n", vif->type);
+                ath_err(common, "Interface type %d not yet supported\n",
+                        vif->type);
                 ret = -EOPNOTSUPP;
                 goto out;
         }
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Attach a VIF of type: %d\n", ic_opmode);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Attach a VIF of type: %d\n", ic_opmode);
 
         /* Set the VIF opmode */
         avp->av_opmode = ic_opmode;
@@ -1438,10 +1435,8 @@ static void ath9k_remove_interface(struct ieee80211_hw *hw,
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath_vif *avp = (void *)vif->drv_priv;
-        bool bs_valid = false;
-        int i;
 
-        ath_print(common, ATH_DBG_CONFIG, "Detach Interface\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
 
         mutex_lock(&sc->mutex);
 
@@ -1453,26 +1448,21 @@ static void ath9k_remove_interface(struct ieee80211_hw *hw,
         if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) ||
             (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC) ||
             (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT)) {
+                /* Disable SWBA interrupt */
+                sc->sc_ah->imask &= ~ATH9K_INT_SWBA;
                 ath9k_ps_wakeup(sc);
+                ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_ah->imask);
                 ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
                 ath9k_ps_restore(sc);
+                tasklet_kill(&sc->bcon_tasklet);
         }
 
         ath_beacon_return(sc, avp);
         sc->sc_flags &= ~SC_OP_BEACONS;
 
-        for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++) {
-                if (sc->beacon.bslot[i] == vif) {
-                        printk(KERN_DEBUG "%s: vif had allocated beacon "
-                               "slot\n", __func__);
-                        sc->beacon.bslot[i] = NULL;
-                        sc->beacon.bslot_aphy[i] = NULL;
-                } else if (sc->beacon.bslot[i])
-                        bs_valid = true;
-        }
-        if (!bs_valid && (sc->sc_ah->imask & ATH9K_INT_SWBA)) {
-                /* Disable SWBA interrupt */
-                sc->sc_ah->imask &= ~ATH9K_INT_SWBA;
+        if (sc->nbcnvifs) {
+                /* Re-enable SWBA interrupt */
+                sc->sc_ah->imask |= ATH9K_INT_SWBA;
                 ath9k_ps_wakeup(sc);
                 ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_ah->imask);
                 ath9k_ps_restore(sc);
@@ -1556,8 +1546,8 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                 if (enable_radio) {
                         sc->ps_idle = false;
                         ath_radio_enable(sc, hw);
-                        ath_print(common, ATH_DBG_CONFIG,
-                                  "not-idle: enabling radio\n");
+                        ath_dbg(common, ATH_DBG_CONFIG,
+                                "not-idle: enabling radio\n");
                 }
         }
 
@@ -1579,12 +1569,12 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
 
         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
                 if (conf->flags & IEEE80211_CONF_MONITOR) {
-                        ath_print(common, ATH_DBG_CONFIG,
-                                  "Monitor mode is enabled\n");
+                        ath_dbg(common, ATH_DBG_CONFIG,
+                                "Monitor mode is enabled\n");
                         sc->sc_ah->is_monitoring = true;
                 } else {
-                        ath_print(common, ATH_DBG_CONFIG,
-                                  "Monitor mode is disabled\n");
+                        ath_dbg(common, ATH_DBG_CONFIG,
+                                "Monitor mode is disabled\n");
                         sc->sc_ah->is_monitoring = false;
                 }
         }
@@ -1616,8 +1606,8 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                         goto skip_chan_change;
                 }
 
-                ath_print(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
-                          curchan->center_freq);
+                ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
+                        curchan->center_freq);
 
                 /* XXX: remove me eventualy */
                 ath9k_update_ichannel(sc, hw, &sc->sc_ah->channels[pos]);
@@ -1650,8 +1640,7 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                 }
 
                 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Unable to set channel\n");
+                        ath_err(common, "Unable to set channel\n");
                         mutex_unlock(&sc->mutex);
                         return -EINVAL;
                 }
@@ -1676,7 +1665,7 @@ skip_chan_change:
         spin_unlock_bh(&sc->wiphy_lock);
 
         if (disable_radio) {
-                ath_print(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
+                ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
                 sc->ps_idle = true;
                 ath_radio_disable(sc, hw);
         }
@@ -1715,8 +1704,8 @@ static void ath9k_configure_filter(struct ieee80211_hw *hw,
         ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
         ath9k_ps_restore(sc);
 
-        ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
-                  "Set HW RX filter: 0x%x\n", rfilt);
+        ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
+                "Set HW RX filter: 0x%x\n", rfilt);
 }
 
 static int ath9k_sta_add(struct ieee80211_hw *hw,
@@ -1767,15 +1756,14 @@ static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
         qi.tqi_cwmax = params->cw_max;
         qi.tqi_burstTime = params->txop;
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Configure tx [queue/halq] [%d/%d],  "
-                  "aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
-                  queue, txq->axq_qnum, params->aifs, params->cw_min,
-                  params->cw_max, params->txop);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
+                queue, txq->axq_qnum, params->aifs, params->cw_min,
+                params->cw_max, params->txop);
 
         ret = ath_txq_update(sc, txq->axq_qnum, &qi);
         if (ret)
-                ath_print(common, ATH_DBG_FATAL, "TXQ Update failed\n");
+                ath_err(common, "TXQ Update failed\n");
 
         if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)
                 if (queue == WME_AC_BE && !ret)
@@ -1802,7 +1790,7 @@ static int ath9k_set_key(struct ieee80211_hw *hw,
 
         mutex_lock(&sc->mutex);
         ath9k_ps_wakeup(sc);
-        ath_print(common, ATH_DBG_CONFIG, "Set HW Key\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
 
         switch (cmd) {
         case SET_KEY:
@@ -1861,9 +1849,8 @@ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
                 if (vif->type == NL80211_IFTYPE_ADHOC)
                         ath_update_chainmask(sc, 0);
 
-                ath_print(common, ATH_DBG_CONFIG,
-                          "BSSID: %pM aid: 0x%x\n",
-                          common->curbssid, common->curaid);
+                ath_dbg(common, ATH_DBG_CONFIG, "BSSID: %pM aid: 0x%x\n",
+                        common->curbssid, common->curaid);
 
                 /* need to reconfigure the beacon */
                 sc->sc_flags &= ~SC_OP_BEACONS ;
@@ -1919,8 +1906,8 @@ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
-                          bss_conf->use_short_preamble);
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
+                        bss_conf->use_short_preamble);
                 if (bss_conf->use_short_preamble)
                         sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
                 else
@@ -1928,8 +1915,8 @@ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
-                          bss_conf->use_cts_prot);
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
+                        bss_conf->use_cts_prot);
                 if (bss_conf->use_cts_prot &&
                     hw->conf.channel->band != IEEE80211_BAND_5GHZ)
                         sc->sc_flags |= SC_OP_PROTECT_ENABLE;
@@ -1938,7 +1925,7 @@ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_ASSOC) {
-                ath_print(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
+                ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
                         bss_conf->assoc);
                 ath9k_bss_assoc_info(sc, hw, vif, bss_conf);
         }
@@ -2024,8 +2011,7 @@ static int ath9k_ampdu_action(struct ieee80211_hw *hw,
                 ath9k_ps_restore(sc);
                 break;
         default:
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "Unknown AMPDU action\n");
+                ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
         }
 
         local_bh_enable();
diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c
index 09f69a9617f4..747b2871e48f 100644
--- a/drivers/net/wireless/ath/ath9k/pci.c
+++ b/drivers/net/wireless/ath/ath9k/pci.c
@@ -30,6 +30,7 @@ static DEFINE_PCI_DEVICE_TABLE(ath_pci_id_table) = {
         { PCI_VDEVICE(ATHEROS, 0x002D) }, /* PCI   */
         { PCI_VDEVICE(ATHEROS, 0x002E) }, /* PCI-E */
         { PCI_VDEVICE(ATHEROS, 0x0030) }, /* PCI-E  AR9300 */
+        { PCI_VDEVICE(ATHEROS, 0x0032) }, /* PCI-E  AR9485 */
         { 0 }
 };
 
@@ -59,10 +60,9 @@ static bool ath_pci_eeprom_read(struct ath_common *common, u32 off, u16 *data)
 
         if (pdata) {
                 if (off >= (ARRAY_SIZE(pdata->eeprom_data))) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "%s: eeprom read failed, offset %08x "
-                                  "is out of range\n",
-                                  __func__, off);
+                        ath_err(common,
+                                "%s: eeprom read failed, offset %08x is out of range\n",
+                                __func__, off);
                 }
 
                 *data = pdata->eeprom_data[off];
@@ -104,11 +104,23 @@ static void ath_pci_bt_coex_prep(struct ath_common *common)
         pci_write_config_byte(pdev, ATH_PCIE_CAP_LINK_CTRL, aspm);
 }
 
+static void ath_pci_extn_synch_enable(struct ath_common *common)
+{
+        struct ath_softc *sc = (struct ath_softc *) common->priv;
+        struct pci_dev *pdev = to_pci_dev(sc->dev);
+        u8 lnkctl;
+
+        pci_read_config_byte(pdev, sc->sc_ah->caps.pcie_lcr_offset, &lnkctl);
+        lnkctl |= PCI_EXP_LNKCTL_ES;
+        pci_write_config_byte(pdev, sc->sc_ah->caps.pcie_lcr_offset, lnkctl);
+}
+
 static const struct ath_bus_ops ath_pci_bus_ops = {
         .ath_bus_type = ATH_PCI,
         .read_cachesize = ath_pci_read_cachesize,
         .eeprom_read = ath_pci_eeprom_read,
         .bt_coex_prep = ath_pci_bt_coex_prep,
+        .extn_synch_en = ath_pci_extn_synch_enable,
 };
 
 static int ath_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/net/wireless/ath/ath9k/phy.h b/drivers/net/wireless/ath/ath9k/phy.h
index 17969af842f6..5e3d7496986e 100644
--- a/drivers/net/wireless/ath/ath9k/phy.h
+++ b/drivers/net/wireless/ath/ath9k/phy.h
@@ -19,6 +19,7 @@
 
 #define CHANSEL_DIV             15
 #define CHANSEL_2G(_freq)       (((_freq) * 0x10000) / CHANSEL_DIV)
+#define CHANSEL_2G_9485(_freq)  ((((_freq) * 0x10000) - 215) / CHANSEL_DIV)
 #define CHANSEL_5G(_freq)       (((_freq) * 0x8000) / CHANSEL_DIV)
 
 #define AR_PHY_BASE     0x9800
diff --git a/drivers/net/wireless/ath/ath9k/rc.c b/drivers/net/wireless/ath/ath9k/rc.c
index 3e6ea3bc3d89..2061a755a026 100644
--- a/drivers/net/wireless/ath/ath9k/rc.c
+++ b/drivers/net/wireless/ath/ath9k/rc.c
@@ -1184,7 +1184,7 @@ struct ath_rate_table *ath_choose_rate_table(struct ath_softc *sc,
                         return &ar5416_11na_ratetable;
                 return &ar5416_11a_ratetable;
         default:
-                ath_print(common, ATH_DBG_CONFIG, "Invalid band\n");
+                ath_dbg(common, ATH_DBG_CONFIG, "Invalid band\n");
                 return NULL;
         }
 }
@@ -1259,9 +1259,9 @@ static void ath_rc_init(struct ath_softc *sc,
         ath_rc_priv->rate_max_phy = ath_rc_priv->valid_rate_index[k-4];
         ath_rc_priv->rate_table = rate_table;
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "RC Initialized with capabilities: 0x%x\n",
-                  ath_rc_priv->ht_cap);
+        ath_dbg(common, ATH_DBG_CONFIG,
+                "RC Initialized with capabilities: 0x%x\n",
+                ath_rc_priv->ht_cap);
 }
 
 static u8 ath_rc_build_ht_caps(struct ath_softc *sc, struct ieee80211_sta *sta,
@@ -1463,9 +1463,9 @@ static void ath_rate_update(void *priv, struct ieee80211_supported_band *sband,
                                                    oper_cw40, oper_sgi);
                         ath_rc_init(sc, priv_sta, sband, sta, rate_table);
 
-                        ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
-                                  "Operating HT Bandwidth changed to: %d\n",
-                                  sc->hw->conf.channel_type);
+                        ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
+                                "Operating HT Bandwidth changed to: %d\n",
+                                sc->hw->conf.channel_type);
                 }
         }
 }
@@ -1576,8 +1576,8 @@ static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp
 
         rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp);
         if (!rate_priv) {
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "Unable to allocate private rc structure\n");
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "Unable to allocate private rc structure\n");
                 return NULL;
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index 262c81595f6d..00ebed3f9158 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -165,7 +165,7 @@ static void ath_rx_addbuffer_edma(struct ath_softc *sc,
         u32 nbuf = 0;
 
         if (list_empty(&sc->rx.rxbuf)) {
-                ath_print(common, ATH_DBG_QUEUE, "No free rx buf available\n");
+                ath_dbg(common, ATH_DBG_QUEUE, "No free rx buf available\n");
                 return;
         }
 
@@ -269,7 +269,7 @@ static int ath_rx_edma_init(struct ath_softc *sc, int nbufs)
                                 dev_kfree_skb_any(skb);
                                 bf->bf_mpdu = NULL;
                                 bf->bf_buf_addr = 0;
-                                ath_print(common, ATH_DBG_FATAL,
+                                ath_err(common,
                                         "dma_mapping_error() on RX init\n");
                                 error = -ENOMEM;
                                 goto rx_init_fail;
@@ -327,17 +327,17 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
                 common->rx_bufsize = roundup(IEEE80211_MAX_MPDU_LEN,
                                 min(common->cachelsz, (u16)64));
 
-                ath_print(common, ATH_DBG_CONFIG, "cachelsz %u rxbufsize %u\n",
-                                common->cachelsz, common->rx_bufsize);
+                ath_dbg(common, ATH_DBG_CONFIG, "cachelsz %u rxbufsize %u\n",
+                        common->cachelsz, common->rx_bufsize);
 
                 /* Initialize rx descriptors */
 
                 error = ath_descdma_setup(sc, &sc->rx.rxdma, &sc->rx.rxbuf,
                                 "rx", nbufs, 1, 0);
                 if (error != 0) {
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "failed to allocate rx descriptors: %d\n",
-                                  error);
+                        ath_err(common,
+                                "failed to allocate rx descriptors: %d\n",
+                                error);
                         goto err;
                 }
 
@@ -358,8 +358,8 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
                                 dev_kfree_skb_any(skb);
                                 bf->bf_mpdu = NULL;
                                 bf->bf_buf_addr = 0;
-                                ath_print(common, ATH_DBG_FATAL,
-                                          "dma_mapping_error() on RX init\n");
+                                ath_err(common,
+                                        "dma_mapping_error() on RX init\n");
                                 error = -ENOMEM;
                                 goto err;
                         }
@@ -528,8 +528,12 @@ bool ath_stoprecv(struct ath_softc *sc)
                 sc->rx.rxlink = NULL;
         spin_unlock_bh(&sc->rx.rxbuflock);
 
-        ATH_DBG_WARN(!stopped, "Could not stop RX, we could be "
-                     "confusing the DMA engine when we start RX up\n");
+        if (unlikely(!stopped)) {
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "Could not stop RX, we could be "
+                        "confusing the DMA engine when we start RX up\n");
+                ATH_DBG_WARN_ON_ONCE(!stopped);
+        }
         return stopped;
 }
 
@@ -590,9 +594,8 @@ static void ath_rx_ps_beacon(struct ath_softc *sc, struct sk_buff *skb)
 
         if (sc->ps_flags & PS_BEACON_SYNC) {
                 sc->ps_flags &= ~PS_BEACON_SYNC;
-                ath_print(common, ATH_DBG_PS,
-                          "Reconfigure Beacon timers based on "
-                          "timestamp from the AP\n");
+                ath_dbg(common, ATH_DBG_PS,
+                        "Reconfigure Beacon timers based on timestamp from the AP\n");
                 ath_beacon_config(sc, NULL);
         }
 
@@ -604,8 +607,8 @@ static void ath_rx_ps_beacon(struct ath_softc *sc, struct sk_buff *skb)
                  * a backup trigger for returning into NETWORK SLEEP state,
                  * so we are waiting for it as well.
                  */
-                ath_print(common, ATH_DBG_PS, "Received DTIM beacon indicating "
-                          "buffered broadcast/multicast frame(s)\n");
+                ath_dbg(common, ATH_DBG_PS,
+                        "Received DTIM beacon indicating buffered broadcast/multicast frame(s)\n");
                 sc->ps_flags |= PS_WAIT_FOR_CAB | PS_WAIT_FOR_BEACON;
                 return;
         }
@@ -617,8 +620,8 @@ static void ath_rx_ps_beacon(struct ath_softc *sc, struct sk_buff *skb)
                  * been delivered.
                  */
                 sc->ps_flags &= ~PS_WAIT_FOR_CAB;
-                ath_print(common, ATH_DBG_PS,
-                          "PS wait for CAB frames timed out\n");
+                ath_dbg(common, ATH_DBG_PS,
+                        "PS wait for CAB frames timed out\n");
         }
 }
 
@@ -643,15 +646,14 @@ static void ath_rx_ps(struct ath_softc *sc, struct sk_buff *skb)
                  * point.
                  */
                 sc->ps_flags &= ~(PS_WAIT_FOR_CAB | PS_WAIT_FOR_BEACON);
-                ath_print(common, ATH_DBG_PS,
-                          "All PS CAB frames received, back to sleep\n");
+                ath_dbg(common, ATH_DBG_PS,
+                        "All PS CAB frames received, back to sleep\n");
         } else if ((sc->ps_flags & PS_WAIT_FOR_PSPOLL_DATA) &&
                    !is_multicast_ether_addr(hdr->addr1) &&
                    !ieee80211_has_morefrags(hdr->frame_control)) {
                 sc->ps_flags &= ~PS_WAIT_FOR_PSPOLL_DATA;
-                ath_print(common, ATH_DBG_PS,
-                          "Going back to sleep after having received "
-                          "PS-Poll data (0x%lx)\n",
+                ath_dbg(common, ATH_DBG_PS,
+                        "Going back to sleep after having received PS-Poll data (0x%lx)\n",
                         sc->ps_flags & (PS_WAIT_FOR_BEACON |
                                         PS_WAIT_FOR_CAB |
                                         PS_WAIT_FOR_PSPOLL_DATA |
@@ -660,8 +662,7 @@ static void ath_rx_ps(struct ath_softc *sc, struct sk_buff *skb)
 }
 
 static void ath_rx_send_to_mac80211(struct ieee80211_hw *hw,
-                                    struct ath_softc *sc, struct sk_buff *skb,
-                                    struct ieee80211_rx_status *rxs)
+                                    struct ath_softc *sc, struct sk_buff *skb)
 {
         struct ieee80211_hdr *hdr;
 
@@ -840,6 +841,10 @@ static bool ath9k_rx_accept(struct ath_common *common,
                             struct ath_rx_status *rx_stats,
                             bool *decrypt_error)
 {
+#define is_mc_or_valid_tkip_keyix ((is_mc ||                    \
+                (rx_stats->rs_keyix != ATH9K_RXKEYIX_INVALID && \
+                test_bit(rx_stats->rs_keyix, common->tkip_keymap))))
+
         struct ath_hw *ah = common->ah;
         __le16 fc;
         u8 rx_status_len = ah->caps.rx_status_len;
@@ -881,15 +886,18 @@ static bool ath9k_rx_accept(struct ath_common *common,
                 if (rx_stats->rs_status & ATH9K_RXERR_DECRYPT) {
                         *decrypt_error = true;
                 } else if (rx_stats->rs_status & ATH9K_RXERR_MIC) {
+                        bool is_mc;
                         /*
                          * The MIC error bit is only valid if the frame
                          * is not a control frame or fragment, and it was
                          * decrypted using a valid TKIP key.
                          */
+                        is_mc = !!is_multicast_ether_addr(hdr->addr1);
+
                         if (!ieee80211_is_ctl(fc) &&
                             !ieee80211_has_morefrags(fc) &&
                             !(le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG) &&
-                            test_bit(rx_stats->rs_keyix, common->tkip_keymap))
+                            is_mc_or_valid_tkip_keyix)
                                 rxs->flag |= RX_FLAG_MMIC_ERROR;
                         else
                                 rx_stats->rs_status &= ~ATH9K_RXERR_MIC;
@@ -953,8 +961,9 @@ static int ath9k_process_rate(struct ath_common *common,
          * No valid hardware bitrate found -- we should not get here
          * because hardware has already validated this frame as OK.
          */
-        ath_print(common, ATH_DBG_XMIT, "unsupported hw bitrate detected "
-                  "0x%02x using 1 Mbit\n", rx_stats->rs_rate);
+        ath_dbg(common, ATH_DBG_XMIT,
+                "unsupported hw bitrate detected 0x%02x using 1 Mbit\n",
+                rx_stats->rs_rate);
 
         return -EINVAL;
 }
@@ -1618,7 +1627,7 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
         /*
-         * The hw can techncically differ from common->hw when using ath9k
+         * The hw can technically differ from common->hw when using ath9k
          * virtual wiphy so to account for that we iterate over the active
          * wiphys and find the appropriate wiphy and therefore hw.
          */
@@ -1725,9 +1734,8 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
                         dev_kfree_skb_any(requeue_skb);
                         bf->bf_mpdu = NULL;
                         bf->bf_buf_addr = 0;
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "dma_mapping_error() on RX\n");
-                        ath_rx_send_to_mac80211(hw, sc, skb, rxs);
+                        ath_err(common, "dma_mapping_error() on RX\n");
+                        ath_rx_send_to_mac80211(hw, sc, skb);
                         break;
                 }
 
@@ -1743,17 +1751,18 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
                 }
 
                 spin_lock_irqsave(&sc->sc_pm_lock, flags);
-                if (unlikely(ath9k_check_auto_sleep(sc) ||
-                             (sc->ps_flags & (PS_WAIT_FOR_BEACON |
+
+                if ((sc->ps_flags & (PS_WAIT_FOR_BEACON |
                                               PS_WAIT_FOR_CAB |
-                                              PS_WAIT_FOR_PSPOLL_DATA))))
+                                              PS_WAIT_FOR_PSPOLL_DATA)) ||
+                                        unlikely(ath9k_check_auto_sleep(sc)))
                         ath_rx_ps(sc, skb);
                 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 
                 if (ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
                         ath_ant_comb_scan(sc, &rs);
 
-                ath_rx_send_to_mac80211(hw, sc, skb, rxs);
+                ath_rx_send_to_mac80211(hw, sc, skb);
 
 requeue:
                 if (edma) {
diff --git a/drivers/net/wireless/ath/ath9k/reg.h b/drivers/net/wireless/ath/ath9k/reg.h
index c2472edab5e0..4df5659c6c16 100644
--- a/drivers/net/wireless/ath/ath9k/reg.h
+++ b/drivers/net/wireless/ath/ath9k/reg.h
@@ -787,6 +787,8 @@
 #define AR_SREV_REVISION_9271_11        1
 #define AR_SREV_VERSION_9300            0x1c0
 #define AR_SREV_REVISION_9300_20        2 /* 2.0 and 2.1 */
+#define AR_SREV_VERSION_9485            0x240
+#define AR_SREV_REVISION_9485_10        0
 
 #define AR_SREV_5416(_ah) \
         (((_ah)->hw_version.macVersion == AR_SREV_VERSION_5416_PCI) || \
@@ -859,12 +861,24 @@
          (((_ah)->hw_version.macVersion == AR_SREV_VERSION_9300) && \
           ((_ah)->hw_version.macRev >= AR_SREV_REVISION_9300_20)))
 
+#define AR_SREV_9485(_ah) \
+        (((_ah)->hw_version.macVersion == AR_SREV_VERSION_9485))
+#define AR_SREV_9485_10(_ah) \
+        (AR_SREV_9485(_ah) && \
+         ((_ah)->hw_version.macRev == AR_SREV_REVISION_9485_10))
+
 #define AR_SREV_9285E_20(_ah) \
     (AR_SREV_9285_12_OR_LATER(_ah) && \
      ((REG_READ(_ah, AR_AN_SYNTH9) & 0x7) == 0x1))
 
+enum ath_usb_dev {
+        AR9280_USB = 1, /* AR7010 + AR9280, UB94 */
+        AR9287_USB = 2, /* AR7010 + AR9287, UB95 */
+};
+
 #define AR_DEVID_7010(_ah) \
-        ((_ah)->common.driver_info & AR7010_DEVICE)
+        (((_ah)->hw_version.usbdev == AR9280_USB) || \
+         ((_ah)->hw_version.usbdev == AR9287_USB))
 
 #define AR_RADIO_SREV_MAJOR                   0xf0
 #define AR_RAD5133_SREV_MAJOR                 0xc0
@@ -1106,6 +1120,8 @@ enum {
 #define AR_RTC_PLL_CONTROL \
         ((AR_SREV_9100(ah)) ? (AR_RTC_BASE + 0x0014) : 0x7014)
 
+#define AR_RTC_PLL_CONTROL2     0x703c
+
 #define AR_RTC_PLL_DIV          0x0000001f
 #define AR_RTC_PLL_DIV_S        0
 #define AR_RTC_PLL_DIV2         0x00000020
diff --git a/drivers/net/wireless/ath/ath9k/virtual.c b/drivers/net/wireless/ath/ath9k/virtual.c
index d5442c3745cc..fbfbc8239971 100644
--- a/drivers/net/wireless/ath/ath9k/virtual.c
+++ b/drivers/net/wireless/ath/ath9k/virtual.c
@@ -656,10 +656,9 @@ void ath9k_set_wiphy_idle(struct ath_wiphy *aphy, bool idle)
         struct ath_softc *sc = aphy->sc;
 
         aphy->idle = idle;
-        ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
-                  "Marking %s as %s\n",
-                  wiphy_name(aphy->hw->wiphy),
-                  idle ? "idle" : "not-idle");
+        ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
+                "Marking %s as %sidle\n",
+                wiphy_name(aphy->hw->wiphy), idle ? "" : "not-");
 }
 /* Only bother starting a queue on an active virtual wiphy */
 bool ath_mac80211_start_queue(struct ath_softc *sc, u16 skb_queue)
diff --git a/drivers/net/wireless/ath/ath9k/wmi.c b/drivers/net/wireless/ath/ath9k/wmi.c
index 93a8bda09c25..8f42ea78198c 100644
--- a/drivers/net/wireless/ath/ath9k/wmi.c
+++ b/drivers/net/wireless/ath/ath9k/wmi.c
@@ -125,7 +125,7 @@ void ath9k_wmi_tasklet(unsigned long data)
         struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data;
         struct ath_common *common = ath9k_hw_common(priv->ah);
 
-        ath_print(common, ATH_DBG_WMI, "SWBA Event received\n");
+        ath_dbg(common, ATH_DBG_WMI, "SWBA Event received\n");
 
         ath9k_htc_swba(priv, priv->wmi->beacon_pending);
 
@@ -286,9 +286,9 @@ int ath9k_wmi_cmd(struct wmi *wmi, enum wmi_cmd_id cmd_id,
 
         time_left = wait_for_completion_timeout(&wmi->cmd_wait, timeout);
         if (!time_left) {
-                ath_print(common, ATH_DBG_WMI,
-                          "Timeout waiting for WMI command: %s\n",
-                          wmi_cmd_to_name(cmd_id));
+                ath_dbg(common, ATH_DBG_WMI,
+                        "Timeout waiting for WMI command: %s\n",
+                        wmi_cmd_to_name(cmd_id));
                 mutex_unlock(&wmi->op_mutex);
                 return -ETIMEDOUT;
         }
@@ -298,8 +298,8 @@ int ath9k_wmi_cmd(struct wmi *wmi, enum wmi_cmd_id cmd_id,
         return 0;
 
 out:
-        ath_print(common, ATH_DBG_WMI,
-                  "WMI failure for: %s\n", wmi_cmd_to_name(cmd_id));
+        ath_dbg(common, ATH_DBG_WMI,
+                "WMI failure for: %s\n", wmi_cmd_to_name(cmd_id));
         mutex_unlock(&wmi->op_mutex);
         kfree_skb(skb);
 
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index 821d3679c6ff..43c0109f202c 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -985,9 +985,8 @@ struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype)
                 return NULL;
         }
         if (qnum >= ARRAY_SIZE(sc->tx.txq)) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "qnum %u out of range, max %u!\n",
-                          qnum, (unsigned int)ARRAY_SIZE(sc->tx.txq));
+                ath_err(common, "qnum %u out of range, max %zu!\n",
+                        qnum, ARRAY_SIZE(sc->tx.txq));
                 ath9k_hw_releasetxqueue(ah, qnum);
                 return NULL;
         }
@@ -1038,8 +1037,8 @@ int ath_txq_update(struct ath_softc *sc, int qnum,
         qi.tqi_readyTime = qinfo->tqi_readyTime;
 
         if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "Unable to update hardware queue %u!\n", qnum);
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "Unable to update hardware queue %u!\n", qnum);
                 error = -EIO;
         } else {
                 ath9k_hw_resettxqueue(ah, qnum);
@@ -1172,7 +1171,7 @@ void ath_draintxq(struct ath_softc *sc, struct ath_txq *txq, bool retry_tx)
         }
 }
 
-void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
+bool ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
 {
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
@@ -1180,7 +1179,7 @@ void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
         int i, npend = 0;
 
         if (sc->sc_flags & SC_OP_INVALID)
-                return;
+                return true;
 
         /* Stop beacon queue */
         ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
@@ -1194,23 +1193,15 @@ void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
                 }
         }
 
-        if (npend) {
-                int r;
-
-                ath_print(common, ATH_DBG_FATAL,
-                          "Failed to stop TX DMA. Resetting hardware!\n");
-
-                r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
-                if (r)
-                        ath_print(common, ATH_DBG_FATAL,
-                                  "Unable to reset hardware; reset status %d\n",
-                                  r);
-        }
+        if (npend)
+                ath_err(common, "Failed to stop TX DMA!\n");
 
         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
                 if (ATH_TXQ_SETUP(sc, i))
                         ath_draintxq(sc, &sc->tx.txq[i], retry_tx);
         }
+
+        return !npend;
 }
 
 void ath_tx_cleanupq(struct ath_softc *sc, struct ath_txq *txq)
@@ -1287,8 +1278,8 @@ static void ath_tx_txqaddbuf(struct ath_softc *sc, struct ath_txq *txq,
 
         bf = list_first_entry(head, struct ath_buf, list);
 
-        ath_print(common, ATH_DBG_QUEUE,
-                  "qnum: %d, txq depth: %d\n", txq->axq_qnum, txq->axq_depth);
+        ath_dbg(common, ATH_DBG_QUEUE,
+                "qnum: %d, txq depth: %d\n", txq->axq_qnum, txq->axq_depth);
 
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
                 if (txq->axq_depth >= ATH_TXFIFO_DEPTH) {
@@ -1296,32 +1287,29 @@ static void ath_tx_txqaddbuf(struct ath_softc *sc, struct ath_txq *txq,
                         return;
                 }
                 if (!list_empty(&txq->txq_fifo[txq->txq_headidx]))
-                        ath_print(common, ATH_DBG_XMIT,
-                                  "Initializing tx fifo %d which "
-                                  "is non-empty\n",
-                                  txq->txq_headidx);
+                        ath_dbg(common, ATH_DBG_XMIT,
+                                "Initializing tx fifo %d which is non-empty\n",
+                                txq->txq_headidx);
                 INIT_LIST_HEAD(&txq->txq_fifo[txq->txq_headidx]);
                 list_splice_init(head, &txq->txq_fifo[txq->txq_headidx]);
                 INCR(txq->txq_headidx, ATH_TXFIFO_DEPTH);
                 ath9k_hw_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
-                ath_print(common, ATH_DBG_XMIT,
-                          "TXDP[%u] = %llx (%p)\n",
-                          txq->axq_qnum, ito64(bf->bf_daddr), bf->bf_desc);
+                ath_dbg(common, ATH_DBG_XMIT, "TXDP[%u] = %llx (%p)\n",
+                        txq->axq_qnum, ito64(bf->bf_daddr), bf->bf_desc);
         } else {
                 list_splice_tail_init(head, &txq->axq_q);
 
                 if (txq->axq_link == NULL) {
                         ath9k_hw_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
-                        ath_print(common, ATH_DBG_XMIT,
-                                        "TXDP[%u] = %llx (%p)\n",
-                                        txq->axq_qnum, ito64(bf->bf_daddr),
-                                        bf->bf_desc);
+                        ath_dbg(common, ATH_DBG_XMIT, "TXDP[%u] = %llx (%p)\n",
+                                txq->axq_qnum, ito64(bf->bf_daddr),
+                                bf->bf_desc);
                 } else {
                         *txq->axq_link = bf->bf_daddr;
-                        ath_print(common, ATH_DBG_XMIT,
-                                        "link[%u] (%p)=%llx (%p)\n",
-                                        txq->axq_qnum, txq->axq_link,
-                                        ito64(bf->bf_daddr), bf->bf_desc);
+                        ath_dbg(common, ATH_DBG_XMIT,
+                                "link[%u] (%p)=%llx (%p)\n",
+                                txq->axq_qnum, txq->axq_link,
+                                ito64(bf->bf_daddr), bf->bf_desc);
                 }
                 ath9k_hw_get_desc_link(ah, bf->bf_lastbf->bf_desc,
                                        &txq->axq_link);
@@ -1648,7 +1636,7 @@ static struct ath_buf *ath_tx_setup_buffer(struct ieee80211_hw *hw,
 
         bf = ath_tx_get_buffer(sc);
         if (!bf) {
-                ath_print(common, ATH_DBG_XMIT, "TX buffers are full\n");
+                ath_dbg(common, ATH_DBG_XMIT, "TX buffers are full\n");
                 return NULL;
         }
 
@@ -1663,8 +1651,8 @@ static struct ath_buf *ath_tx_setup_buffer(struct ieee80211_hw *hw,
         if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) {
                 bf->bf_mpdu = NULL;
                 bf->bf_buf_addr = 0;
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "dma_mapping_error() on TX\n");
+                ath_err(ath9k_hw_common(sc->sc_ah),
+                        "dma_mapping_error() on TX\n");
                 ath_tx_return_buffer(sc, bf);
                 return NULL;
         }
@@ -1745,7 +1733,10 @@ int ath_tx_start(struct ieee80211_hw *hw, struct sk_buff *skb,
         int frmlen = skb->len + FCS_LEN;
         int q;
 
-        txctl->an = (struct ath_node *)sta->drv_priv;
+        /* NOTE:  sta can be NULL according to net/mac80211.h */
+        if (sta)
+                txctl->an = (struct ath_node *)sta->drv_priv;
+
         if (info->control.hw_key)
                 frmlen += info->control.hw_key->icv_len;
 
@@ -1811,7 +1802,7 @@ static void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
         struct ieee80211_hdr * hdr = (struct ieee80211_hdr *)skb->data;
         int q, padpos, padsize;
 
-        ath_print(common, ATH_DBG_XMIT, "TX complete: skb: %p\n", skb);
+        ath_dbg(common, ATH_DBG_XMIT, "TX complete: skb: %p\n", skb);
 
         if (aphy)
                 hw = aphy->hw;
@@ -1837,9 +1828,8 @@ static void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
 
         if (sc->ps_flags & PS_WAIT_FOR_TX_ACK) {
                 sc->ps_flags &= ~PS_WAIT_FOR_TX_ACK;
-                ath_print(common, ATH_DBG_PS,
-                          "Going back to sleep after having "
-                          "received TX status (0x%lx)\n",
+                ath_dbg(common, ATH_DBG_PS,
+                        "Going back to sleep after having received TX status (0x%lx)\n",
                         sc->ps_flags & (PS_WAIT_FOR_BEACON |
                                         PS_WAIT_FOR_CAB |
                                         PS_WAIT_FOR_PSPOLL_DATA |
@@ -1988,9 +1978,9 @@ static void ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq)
         int status;
         int qnum;
 
-        ath_print(common, ATH_DBG_QUEUE, "tx queue %d (%x), link %p\n",
-                  txq->axq_qnum, ath9k_hw_gettxbuf(sc->sc_ah, txq->axq_qnum),
-                  txq->axq_link);
+        ath_dbg(common, ATH_DBG_QUEUE, "tx queue %d (%x), link %p\n",
+                txq->axq_qnum, ath9k_hw_gettxbuf(sc->sc_ah, txq->axq_qnum),
+                txq->axq_link);
 
         for (;;) {
                 spin_lock_bh(&txq->axq_lock);
@@ -2105,8 +2095,8 @@ static void ath_tx_complete_poll_work(struct work_struct *work)
                 }
 
         if (needreset) {
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_RESET,
-                          "tx hung, resetting the chip\n");
+                ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_RESET,
+                        "tx hung, resetting the chip\n");
                 ath9k_ps_wakeup(sc);
                 ath_reset(sc, true);
                 ath9k_ps_restore(sc);
@@ -2148,8 +2138,8 @@ void ath_tx_edma_tasklet(struct ath_softc *sc)
                 if (status == -EINPROGRESS)
                         break;
                 if (status == -EIO) {
-                        ath_print(common, ATH_DBG_XMIT,
-                                  "Error processing tx status\n");
+                        ath_dbg(common, ATH_DBG_XMIT,
+                                "Error processing tx status\n");
                         break;
                 }
 
@@ -2260,16 +2250,16 @@ int ath_tx_init(struct ath_softc *sc, int nbufs)
         error = ath_descdma_setup(sc, &sc->tx.txdma, &sc->tx.txbuf,
                                   "tx", nbufs, 1, 1);
         if (error != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Failed to allocate tx descriptors: %d\n", error);
+                ath_err(common,
+                        "Failed to allocate tx descriptors: %d\n", error);
                 goto err;
         }
 
         error = ath_descdma_setup(sc, &sc->beacon.bdma, &sc->beacon.bbuf,
                                   "beacon", ATH_BCBUF, 1, 1);
         if (error != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Failed to allocate beacon descriptors: %d\n", error);
+                ath_err(common,
+                        "Failed to allocate beacon descriptors: %d\n", error);
                 goto err;
         }
 
diff --git a/drivers/net/wireless/ath/debug.c b/drivers/net/wireless/ath/debug.c
index a9600ba8ceaa..5367b1086e09 100644
--- a/drivers/net/wireless/ath/debug.c
+++ b/drivers/net/wireless/ath/debug.c
@@ -15,26 +15,6 @@
  */
 
 #include "ath.h"
-#include "debug.h"
-
-void ath_print(struct ath_common *common, int dbg_mask, const char *fmt, ...)
-{
-        struct va_format vaf;
-        va_list args;
-
-        if (likely(!(common->debug_mask & dbg_mask)))
-                return;
-
-        va_start(args, fmt);
-
-        vaf.fmt = fmt;
-        vaf.va = &args;
-
-        printk(KERN_DEBUG "ath: %pV", &vaf);
-
-        va_end(args);
-}
-EXPORT_SYMBOL(ath_print);
 
 const char *ath_opmode_to_string(enum nl80211_iftype opmode)
 {
diff --git a/drivers/net/wireless/ath/debug.h b/drivers/net/wireless/ath/debug.h
deleted file mode 100644
index f207007ee391..000000000000
--- a/drivers/net/wireless/ath/debug.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (c) 2008-2009 Atheros Communications Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef ATH_DEBUG_H
-#define ATH_DEBUG_H
-
-#include "ath.h"
-
-/**
- * enum ath_debug_level - atheros wireless debug level
- *
- * @ATH_DBG_RESET: reset processing
- * @ATH_DBG_QUEUE: hardware queue management
- * @ATH_DBG_EEPROM: eeprom processing
- * @ATH_DBG_CALIBRATE: periodic calibration
- * @ATH_DBG_INTERRUPT: interrupt processing
- * @ATH_DBG_REGULATORY: regulatory processing
- * @ATH_DBG_ANI: adaptive noise immunitive processing
- * @ATH_DBG_XMIT: basic xmit operation
- * @ATH_DBG_BEACON: beacon handling
- * @ATH_DBG_CONFIG: configuration of the hardware
- * @ATH_DBG_FATAL: fatal errors, this is the default, DBG_DEFAULT
- * @ATH_DBG_PS: power save processing
- * @ATH_DBG_HWTIMER: hardware timer handling
- * @ATH_DBG_BTCOEX: bluetooth coexistance
- * @ATH_DBG_BSTUCK: stuck beacons
- * @ATH_DBG_ANY: enable all debugging
- *
- * The debug level is used to control the amount and type of debugging output
- * we want to see. Each driver has its own method for enabling debugging and
- * modifying debug level states -- but this is typically done through a
- * module parameter 'debug' along with a respective 'debug' debugfs file
- * entry.
- */
-enum ATH_DEBUG {
-        ATH_DBG_RESET           = 0x00000001,
-        ATH_DBG_QUEUE           = 0x00000002,
-        ATH_DBG_EEPROM          = 0x00000004,
-        ATH_DBG_CALIBRATE       = 0x00000008,
-        ATH_DBG_INTERRUPT       = 0x00000010,
-        ATH_DBG_REGULATORY      = 0x00000020,
-        ATH_DBG_ANI             = 0x00000040,
-        ATH_DBG_XMIT            = 0x00000080,
-        ATH_DBG_BEACON          = 0x00000100,
-        ATH_DBG_CONFIG          = 0x00000200,
-        ATH_DBG_FATAL           = 0x00000400,
-        ATH_DBG_PS              = 0x00000800,
-        ATH_DBG_HWTIMER         = 0x00001000,
-        ATH_DBG_BTCOEX          = 0x00002000,
-        ATH_DBG_WMI             = 0x00004000,
-        ATH_DBG_BSTUCK          = 0x00008000,
-        ATH_DBG_ANY             = 0xffffffff
-};
-
-#define ATH_DBG_DEFAULT (ATH_DBG_FATAL)
-
-#ifdef CONFIG_ATH_DEBUG
-void ath_print(struct ath_common *common, int dbg_mask, const char *fmt, ...)
-        __attribute__ ((format (printf, 3, 4)));
-#define ATH_DBG_WARN(foo, arg...) WARN(foo, arg)
-#else
-static inline void __attribute__ ((format (printf, 3, 4)))
-ath_print(struct ath_common *common, int dbg_mask, const char *fmt, ...)
-{
-}
-#define ATH_DBG_WARN(foo, arg)
-#endif /* CONFIG_ATH_DEBUG */
-
-/** Returns string describing opmode, or NULL if unknown mode. */
-#ifdef CONFIG_ATH_DEBUG
-const char *ath_opmode_to_string(enum nl80211_iftype opmode);
-#else
-static inline const char *ath_opmode_to_string(enum nl80211_iftype opmode)
-{
-        return "UNKNOWN";
-}
-#endif
-
-#endif /* ATH_DEBUG_H */
diff --git a/drivers/net/wireless/ath/key.c b/drivers/net/wireless/ath/key.c
index 62e3dac8f92a..29a2961af5fc 100644
--- a/drivers/net/wireless/ath/key.c
+++ b/drivers/net/wireless/ath/key.c
@@ -20,7 +20,6 @@
 
 #include "ath.h"
 #include "reg.h"
-#include "debug.h"
 
 #define REG_READ                        (common->ops->read)
 #define REG_WRITE(_ah, _reg, _val)      (common->ops->write)(_ah, _val, _reg)
@@ -37,8 +36,7 @@ bool ath_hw_keyreset(struct ath_common *common, u16 entry)
         void *ah = common->ah;
 
         if (entry >= common->keymax) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "keychache entry %u out of range\n", entry);
+                ath_err(common, "keycache entry %u out of range\n", entry);
                 return false;
         }
 
@@ -75,8 +73,7 @@ static bool ath_hw_keysetmac(struct ath_common *common,
         void *ah = common->ah;
 
         if (entry >= common->keymax) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "keychache entry %u out of range\n", entry);
+                ath_err(common, "keycache entry %u out of range\n", entry);
                 return false;
         }
 
@@ -117,8 +114,7 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
         u32 keyType;
 
         if (entry >= common->keymax) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "keycache entry %u out of range\n", entry);
+                ath_err(common, "keycache entry %u out of range\n", entry);
                 return false;
         }
 
@@ -128,8 +124,8 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
                 break;
         case ATH_CIPHER_AES_CCM:
                 if (!(common->crypt_caps & ATH_CRYPT_CAP_CIPHER_AESCCM)) {
-                        ath_print(common, ATH_DBG_ANY,
-                                  "AES-CCM not supported by this mac rev\n");
+                        ath_dbg(common, ATH_DBG_ANY,
+                                "AES-CCM not supported by this mac rev\n");
                         return false;
                 }
                 keyType = AR_KEYTABLE_TYPE_CCM;
@@ -137,15 +133,15 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
         case ATH_CIPHER_TKIP:
                 keyType = AR_KEYTABLE_TYPE_TKIP;
                 if (entry + 64 >= common->keymax) {
-                        ath_print(common, ATH_DBG_ANY,
-                                  "entry %u inappropriate for TKIP\n", entry);
+                        ath_dbg(common, ATH_DBG_ANY,
+                                "entry %u inappropriate for TKIP\n", entry);
                         return false;
                 }
                 break;
         case ATH_CIPHER_WEP:
                 if (k->kv_len < WLAN_KEY_LEN_WEP40) {
-                        ath_print(common, ATH_DBG_ANY,
-                                  "WEP key length %u too small\n", k->kv_len);
+                        ath_dbg(common, ATH_DBG_ANY,
+                                "WEP key length %u too small\n", k->kv_len);
                         return false;
                 }
                 if (k->kv_len <= WLAN_KEY_LEN_WEP40)
@@ -159,8 +155,7 @@ static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
                 keyType = AR_KEYTABLE_TYPE_CLR;
                 break;
         default:
-                ath_print(common, ATH_DBG_FATAL,
-                          "cipher %u not supported\n", k->kv_type);
+                ath_err(common, "cipher %u not supported\n", k->kv_type);
                 return false;
         }
 
@@ -341,8 +336,7 @@ static int ath_setkey_tkip(struct ath_common *common, u16 keyix, const u8 *key,
         memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));
         if (!ath_hw_set_keycache_entry(common, keyix, hk, NULL)) {
                 /* TX MIC entry failed. No need to proceed further */
-                ath_print(common, ATH_DBG_FATAL,
-                          "Setting TX MIC Key Failed\n");
+                ath_err(common, "Setting TX MIC Key Failed\n");
                 return 0;
         }
 
diff --git a/drivers/net/wireless/ath/main.c b/drivers/net/wireless/ath/main.c
index 487193f1de1a..c325202fdc5f 100644
--- a/drivers/net/wireless/ath/main.c
+++ b/drivers/net/wireless/ath/main.c
@@ -56,3 +56,23 @@ struct sk_buff *ath_rxbuf_alloc(struct ath_common *common,
         return skb;
 }
 EXPORT_SYMBOL(ath_rxbuf_alloc);
+
+int ath_printk(const char *level, struct ath_common *common,
+               const char *fmt, ...)
+{
+        struct va_format vaf;
+        va_list args;
+        int rtn;
+
+        va_start(args, fmt);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        rtn = printk("%sath: %pV", level, &vaf);
+
+        va_end(args);
+
+        return rtn;
+}
+EXPORT_SYMBOL(ath_printk);
diff --git a/drivers/net/wireless/b43/Kconfig b/drivers/net/wireless/b43/Kconfig
index 0a00d42642cd..47033f6a1c2b 100644
--- a/drivers/net/wireless/b43/Kconfig
+++ b/drivers/net/wireless/b43/Kconfig
@@ -86,15 +86,16 @@ config B43_PIO
         select SSB_BLOCKIO
         default y
 
-config B43_NPHY
-        bool "Pre IEEE 802.11n support (BROKEN)"
-        depends on B43 && EXPERIMENTAL && BROKEN
+config B43_PHY_N
+        bool "Support for 802.11n (N-PHY) devices (EXPERIMENTAL)"
+        depends on B43 && EXPERIMENTAL
         ---help---
-          Support for the IEEE 802.11n draft.
+          Support for the N-PHY.
 
-          THIS IS BROKEN AND DOES NOT WORK YET.
+          This enables support for devices with N-PHY revision up to 2.
 
-          SAY N.
+          Say N if you expect high stability and performance. Saying Y will not
+          affect other devices support and may provide support for basic needs.
 
 config B43_PHY_LP
         bool "Support for low-power (LP-PHY) devices (EXPERIMENTAL)"
diff --git a/drivers/net/wireless/b43/Makefile b/drivers/net/wireless/b43/Makefile
index 69d4af09a6cb..cef334a8c669 100644
--- a/drivers/net/wireless/b43/Makefile
+++ b/drivers/net/wireless/b43/Makefile
@@ -1,12 +1,12 @@
 b43-y                           += main.o
 b43-y                           += tables.o
-b43-$(CONFIG_B43_NPHY)          += tables_nphy.o
-b43-$(CONFIG_B43_NPHY)          += radio_2055.o
-b43-$(CONFIG_B43_NPHY)          += radio_2056.o
+b43-$(CONFIG_B43_PHY_N)         += tables_nphy.o
+b43-$(CONFIG_B43_PHY_N)         += radio_2055.o
+b43-$(CONFIG_B43_PHY_N)         += radio_2056.o
 b43-y                           += phy_common.o
 b43-y                           += phy_g.o
 b43-y                           += phy_a.o
-b43-$(CONFIG_B43_NPHY)          += phy_n.o
+b43-$(CONFIG_B43_PHY_N)         += phy_n.o
 b43-$(CONFIG_B43_PHY_LP)        += phy_lp.o
 b43-$(CONFIG_B43_PHY_LP)        += tables_lpphy.o
 b43-y                           += sysfs.o
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index fa4880366586..9ae3f619e98d 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -1150,6 +1150,12 @@ void b43_wireless_core_reset(struct b43_wldev *dev, u32 flags)
 
         flags |= B43_TMSLOW_PHYCLKEN;
         flags |= B43_TMSLOW_PHYRESET;
+        if (dev->phy.type == B43_PHYTYPE_N) {
+                if (b43_channel_type_is_40mhz(dev->phy.channel_type))
+                        flags |= B43_TMSLOW_PHYCLKSPEED_160MHZ;
+                else
+                        flags |= B43_TMSLOW_PHYCLKSPEED_80MHZ;
+        }
         ssb_device_enable(dev->dev, flags);
         msleep(2);              /* Wait for the PLL to turn on. */
 
@@ -4046,9 +4052,9 @@ static int b43_phy_versioning(struct b43_wldev *dev)
                 if (phy_rev > 9)
                         unsupported = 1;
                 break;
-#ifdef CONFIG_B43_NPHY
+#ifdef CONFIG_B43_PHY_N
         case B43_PHYTYPE_N:
-                if (phy_rev > 4)
+                if (phy_rev > 2)
                         unsupported = 1;
                 break;
 #endif
@@ -5091,7 +5097,7 @@ static void b43_print_driverinfo(void)
 #ifdef CONFIG_B43_PCMCIA
         feat_pcmcia = "M";
 #endif
-#ifdef CONFIG_B43_NPHY
+#ifdef CONFIG_B43_PHY_N
         feat_nphy = "N";
 #endif
 #ifdef CONFIG_B43_LEDS
diff --git a/drivers/net/wireless/b43/phy_common.c b/drivers/net/wireless/b43/phy_common.c
index fa7f83fc8db9..b5c5ce94d3fd 100644
--- a/drivers/net/wireless/b43/phy_common.c
+++ b/drivers/net/wireless/b43/phy_common.c
@@ -50,7 +50,7 @@ int b43_phy_allocate(struct b43_wldev *dev)
                 phy->ops = &b43_phyops_g;
                 break;
         case B43_PHYTYPE_N:
-#ifdef CONFIG_B43_NPHY
+#ifdef CONFIG_B43_PHY_N
                 phy->ops = &b43_phyops_n;
 #endif
                 break;
@@ -231,6 +231,7 @@ void b43_radio_maskset(struct b43_wldev *dev, u16 offset, u16 mask, u16 set)
 u16 b43_phy_read(struct b43_wldev *dev, u16 reg)
 {
         assert_mac_suspended(dev);
+        dev->phy.writes_counter = 0;
         return dev->phy.ops->phy_read(dev, reg);
 }
 
@@ -238,6 +239,10 @@ void b43_phy_write(struct b43_wldev *dev, u16 reg, u16 value)
 {
         assert_mac_suspended(dev);
         dev->phy.ops->phy_write(dev, reg, value);
+        if (++dev->phy.writes_counter == B43_MAX_WRITES_IN_ROW) {
+                b43_read16(dev, B43_MMIO_PHY_VER);
+                dev->phy.writes_counter = 0;
+        }
 }
 
 void b43_phy_copy(struct b43_wldev *dev, u16 destreg, u16 srcreg)
@@ -424,6 +429,13 @@ void b43_phyop_switch_analog_generic(struct b43_wldev *dev, bool on)
         b43_write16(dev, B43_MMIO_PHY0, on ? 0 : 0xF4);
 }
 
+
+bool b43_channel_type_is_40mhz(enum nl80211_channel_type channel_type)
+{
+        return (channel_type == NL80211_CHAN_HT40MINUS ||
+                channel_type == NL80211_CHAN_HT40PLUS);
+}
+
 /* http://bcm-v4.sipsolutions.net/802.11/PHY/Cordic */
 struct b43_c32 b43_cordic(int theta)
 {
diff --git a/drivers/net/wireless/b43/phy_common.h b/drivers/net/wireless/b43/phy_common.h
index 0e6194228845..2401bee8b081 100644
--- a/drivers/net/wireless/b43/phy_common.h
+++ b/drivers/net/wireless/b43/phy_common.h
@@ -39,6 +39,9 @@ struct b43_c32 { s32 i, q; };
 #define B43_PHYVER_TYPE_SHIFT           8
 #define B43_PHYVER_VERSION              0x00FF
 
+/* PHY writes need to be flushed if we reach limit */
+#define B43_MAX_WRITES_IN_ROW           24
+
 /**
  * enum b43_interference_mitigation - Interference Mitigation mode
  *
@@ -232,6 +235,9 @@ struct b43_phy {
         /* PHY revision number. */
         u8 rev;
 
+        /* Count writes since last read */
+        u8 writes_counter;
+
         /* Radio versioning */
         u16 radio_manuf;        /* Radio manufacturer */
         u16 radio_ver;          /* Radio version */
@@ -430,6 +436,8 @@ int b43_phy_shm_tssi_read(struct b43_wldev *dev, u16 shm_offset);
  */
 void b43_phyop_switch_analog_generic(struct b43_wldev *dev, bool on);
 
+bool b43_channel_type_is_40mhz(enum nl80211_channel_type channel_type);
+
 struct b43_c32 b43_cordic(int theta);
 
 #endif /* LINUX_B43_PHY_COMMON_H_ */
diff --git a/drivers/net/wireless/b43/phy_n.c b/drivers/net/wireless/b43/phy_n.c
index 905f1d7bac20..61875c888278 100644
--- a/drivers/net/wireless/b43/phy_n.c
+++ b/drivers/net/wireless/b43/phy_n.c
@@ -88,13 +88,6 @@ static void b43_nphy_rf_control_override(struct b43_wldev *dev, u16 field,
 static void b43_nphy_rf_control_intc_override(struct b43_wldev *dev, u8 field,
                                                 u16 value, u8 core);
 
-static inline bool b43_channel_type_is_40mhz(
-                                        enum nl80211_channel_type channel_type)
-{
-        return (channel_type == NL80211_CHAN_HT40MINUS ||
-                channel_type == NL80211_CHAN_HT40PLUS);
-}
-
 void b43_nphy_set_rxantenna(struct b43_wldev *dev, int antenna)
 {//TODO
 }
@@ -258,7 +251,8 @@ static void b43_nphy_tx_power_fix(struct b43_wldev *dev)
 
         for (i = 0; i < 2; i++) {
                 if (dev->phy.rev >= 3) {
-                        /* TODO */
+                        /* FIXME: support 5GHz */
+                        txgain = b43_ntab_tx_gain_rev3plus_2ghz[txpi[i]];
                         radio_gain = (txgain >> 16) & 0x1FFFF;
                 } else {
                         txgain = b43_ntab_tx_gain_rev0_1_2[txpi[i]];
@@ -613,6 +607,8 @@ static void b43_nphy_rx_iq_coeffs(struct b43_wldev *dev, bool write,
         }
 }
 
+#if 0
+/* Ready but not used anywhere */
 /* http://bcm-v4.sipsolutions.net/802.11/PHY/N/RxCalPhyCleanup */
 static void b43_nphy_rx_cal_phy_cleanup(struct b43_wldev *dev, u8 core)
 {
@@ -694,6 +690,7 @@ static void b43_nphy_rx_cal_phy_setup(struct b43_wldev *dev, u8 core)
         b43_nphy_rf_control_intc_override(dev, 1, rxval, (core + 1));
         b43_nphy_rf_control_intc_override(dev, 1, txval, (2 - core));
 }
+#endif
 
 /* http://bcm-v4.sipsolutions.net/802.11/PHY/N/CalcRxIqComp */
 static void b43_nphy_calc_rx_iq_comp(struct b43_wldev *dev, u8 mask)
@@ -3088,7 +3085,7 @@ static int b43_nphy_rev2_cal_rx_iq(struct b43_wldev *dev,
         u8 rfctl[2];
         u8 afectl_core;
         u16 tmp[6];
-        u16 cur_hpf1, cur_hpf2, cur_lna;
+        u16 uninitialized_var(cur_hpf1), uninitialized_var(cur_hpf2), cur_lna;
         u32 real, imag;
         enum ieee80211_band band;
 
@@ -3518,7 +3515,6 @@ int b43_phy_initn(struct b43_wldev *dev)
         if (phy->rev >= 3)
                 b43_nphy_spur_workaround(dev);
 
-        b43err(dev->wl, "IEEE 802.11n devices are not supported, yet.\n");
         return 0;
 }
 
@@ -3705,6 +3701,15 @@ static void b43_nphy_op_write(struct b43_wldev *dev, u16 reg, u16 value)
         b43_write16(dev, B43_MMIO_PHY_DATA, value);
 }
 
+static void b43_nphy_op_maskset(struct b43_wldev *dev, u16 reg, u16 mask,
+                                 u16 set)
+{
+        check_phyreg(dev, reg);
+        b43_write16(dev, B43_MMIO_PHY_CONTROL, reg);
+        b43_write16(dev, B43_MMIO_PHY_DATA,
+                    (b43_read16(dev, B43_MMIO_PHY_DATA) & mask) | set);
+}
+
 static u16 b43_nphy_op_radio_read(struct b43_wldev *dev, u16 reg)
 {
         /* Register 1 is a 32-bit register. */
@@ -3799,6 +3804,7 @@ const struct b43_phy_operations b43_phyops_n = {
         .init                   = b43_nphy_op_init,
         .phy_read               = b43_nphy_op_read,
         .phy_write              = b43_nphy_op_write,
+        .phy_maskset            = b43_nphy_op_maskset,
         .radio_read             = b43_nphy_op_radio_read,
         .radio_write            = b43_nphy_op_radio_write,
         .software_rfkill        = b43_nphy_op_software_rfkill,
diff --git a/drivers/net/wireless/b43/tables_nphy.c b/drivers/net/wireless/b43/tables_nphy.c
index d60db078eae2..df61c1610e39 100644
--- a/drivers/net/wireless/b43/tables_nphy.c
+++ b/drivers/net/wireless/b43/tables_nphy.c
@@ -28,41 +28,41 @@
 #include "phy_n.h"
 
 static const u8 b43_ntab_adjustpower0[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
-        0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
-        0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
-        0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
-        0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09,
-        0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B,
-        0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
-        0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
-        0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
-        0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
-        0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
-        0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
-        0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19,
-        0x1A, 0x1A, 0x1A, 0x1A, 0x1B, 0x1B, 0x1B, 0x1B,
-        0x1C, 0x1C, 0x1C, 0x1C, 0x1D, 0x1D, 0x1D, 0x1D,
-        0x1E, 0x1E, 0x1E, 0x1E, 0x1F, 0x1F, 0x1F, 0x1F,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static const u8 b43_ntab_adjustpower1[] = {
-        0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
-        0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
-        0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
-        0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
-        0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09,
-        0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B,
-        0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
-        0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
-        0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
-        0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
-        0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
-        0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
-        0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19,
-        0x1A, 0x1A, 0x1A, 0x1A, 0x1B, 0x1B, 0x1B, 0x1B,
-        0x1C, 0x1C, 0x1C, 0x1C, 0x1D, 0x1D, 0x1D, 0x1D,
-        0x1E, 0x1E, 0x1E, 0x1E, 0x1F, 0x1F, 0x1F, 0x1F,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static const u16 b43_ntab_bdi[] = {
@@ -130,8 +130,8 @@ static const u32 b43_ntab_framestruct[] = {
         0x09804506, 0x00100030, 0x09804507, 0x00100030,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
-        0x08004A0C, 0x00100008, 0x01000A0D, 0x00100028,
-        0x0980450E, 0x00100038, 0x0980450F, 0x00100038,
+        0x08004A0C, 0x00100004, 0x01000A0D, 0x00100024,
+        0x0980450E, 0x00100034, 0x0980450F, 0x00100034,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000A04, 0x00100000, 0x11008A05, 0x00100020,
@@ -202,13 +202,13 @@ static const u32 b43_ntab_framestruct[] = {
         0x53028A06, 0x01900060, 0x53028A07, 0x01900060,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
-        0x4002140C, 0x000F4810, 0x6203140D, 0x00100050,
-        0x53028A0E, 0x01900070, 0x53028A0F, 0x01900070,
+        0x4002140C, 0x000F4808, 0x6203140D, 0x00100048,
+        0x53028A0E, 0x01900068, 0x53028A0F, 0x01900068,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
-        0x00000A0C, 0x00100008, 0x11008A0D, 0x00100028,
-        0x1980C50E, 0x00100038, 0x2181050E, 0x00100038,
-        0x2181050E, 0x00100038, 0x0180050C, 0x00100038,
+        0x00000A0C, 0x00100004, 0x11008A0D, 0x00100024,
+        0x1980C50E, 0x00100034, 0x2181050E, 0x00100034,
+        0x2181050E, 0x00100034, 0x0180050C, 0x00100038,
         0x1180850D, 0x00100038, 0x1181850D, 0x00100038,
         0x2981450F, 0x01100038, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
@@ -238,9 +238,9 @@ static const u32 b43_ntab_framestruct[] = {
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
-        0x4002140C, 0x00100010, 0x0200140D, 0x00100050,
-        0x0B004A0E, 0x01900070, 0x13008A0E, 0x01900070,
-        0x13008A0E, 0x01900070, 0x43020A0C, 0x00100070,
+        0x4002140C, 0x00100008, 0x0200140D, 0x00100048,
+        0x0B004A0E, 0x01900068, 0x13008A0E, 0x01900068,
+        0x13008A0E, 0x01900068, 0x43020A0C, 0x00100070,
         0x1B00CA0D, 0x00100070, 0x1B014A0D, 0x00100070,
         0x23010A0F, 0x01500070, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000,
@@ -337,73 +337,73 @@ static const u32 b43_ntab_framestruct[] = {
 };
 
 static const u32 b43_ntab_gainctl0[] = {
-        0x007F003F, 0x007E013F, 0x007D023E, 0x007C033E,
-        0x007B043D, 0x007A053D, 0x0079063C, 0x0078073C,
-        0x0077083B, 0x0076093B, 0x00750A3A, 0x00740B3A,
-        0x00730C39, 0x00720D39, 0x00710E38, 0x00700F38,
-        0x006F0037, 0x006E0137, 0x006D0236, 0x006C0336,
-        0x006B0435, 0x006A0535, 0x00690634, 0x00680734,
-        0x00670833, 0x00660933, 0x00650A32, 0x00640B32,
-        0x00630C31, 0x00620D31, 0x00610E30, 0x00600F30,
-        0x005F002F, 0x005E012F, 0x005D022E, 0x005C032E,
-        0x005B042D, 0x005A052D, 0x0059062C, 0x0058072C,
-        0x0057082B, 0x0056092B, 0x00550A2A, 0x00540B2A,
-        0x00530C29, 0x00520D29, 0x00510E28, 0x00500F28,
-        0x004F0027, 0x004E0127, 0x004D0226, 0x004C0326,
-        0x004B0425, 0x004A0525, 0x00490624, 0x00480724,
-        0x00470823, 0x00460923, 0x00450A22, 0x00440B22,
-        0x00430C21, 0x00420D21, 0x00410E20, 0x00400F20,
-        0x003F001F, 0x003E011F, 0x003D021E, 0x003C031E,
-        0x003B041D, 0x003A051D, 0x0039061C, 0x0038071C,
-        0x0037081B, 0x0036091B, 0x00350A1A, 0x00340B1A,
-        0x00330C19, 0x00320D19, 0x00310E18, 0x00300F18,
-        0x002F0017, 0x002E0117, 0x002D0216, 0x002C0316,
-        0x002B0415, 0x002A0515, 0x00290614, 0x00280714,
-        0x00270813, 0x00260913, 0x00250A12, 0x00240B12,
-        0x00230C11, 0x00220D11, 0x00210E10, 0x00200F10,
-        0x001F000F, 0x001E010F, 0x001D020E, 0x001C030E,
-        0x001B040D, 0x001A050D, 0x0019060C, 0x0018070C,
-        0x0017080B, 0x0016090B, 0x00150A0A, 0x00140B0A,
-        0x00130C09, 0x00120D09, 0x00110E08, 0x00100F08,
-        0x000F0007, 0x000E0107, 0x000D0206, 0x000C0306,
-        0x000B0405, 0x000A0505, 0x00090604, 0x00080704,
-        0x00070803, 0x00060903, 0x00050A02, 0x00040B02,
-        0x00030C01, 0x00020D01, 0x00010E00, 0x00000F00,
+        0x03CC2B44, 0x03CC2B42, 0x03CC2B40, 0x03CC2B3E,
+        0x03CC2B3D, 0x03CC2B3B, 0x03C82B44, 0x03C82B42,
+        0x03C82B40, 0x03C82B3E, 0x03C82B3D, 0x03C82B3B,
+        0x03C82B39, 0x03C82B38, 0x03C82B36, 0x03C82B34,
+        0x03C42B44, 0x03C42B42, 0x03C42B40, 0x03C42B3E,
+        0x03C42B3D, 0x03C42B3B, 0x03C42B39, 0x03C42B38,
+        0x03C42B36, 0x03C42B34, 0x03C42B33, 0x03C42B32,
+        0x03C42B30, 0x03C42B2F, 0x03C42B2D, 0x03C02B44,
+        0x03C02B42, 0x03C02B40, 0x03C02B3E, 0x03C02B3D,
+        0x03C02B3B, 0x03C02B39, 0x03C02B38, 0x03C02B36,
+        0x03C02B34, 0x03B02B44, 0x03B02B42, 0x03B02B40,
+        0x03B02B3E, 0x03B02B3D, 0x03B02B3B, 0x03B02B39,
+        0x03B02B38, 0x03B02B36, 0x03B02B34, 0x03B02B33,
+        0x03B02B32, 0x03B02B30, 0x03B02B2F, 0x03B02B2D,
+        0x03A02B44, 0x03A02B42, 0x03A02B40, 0x03A02B3E,
+        0x03A02B3D, 0x03A02B3B, 0x03A02B39, 0x03A02B38,
+        0x03A02B36, 0x03A02B34, 0x03902B44, 0x03902B42,
+        0x03902B40, 0x03902B3E, 0x03902B3D, 0x03902B3B,
+        0x03902B39, 0x03902B38, 0x03902B36, 0x03902B34,
+        0x03902B33, 0x03902B32, 0x03902B30, 0x03802B44,
+        0x03802B42, 0x03802B40, 0x03802B3E, 0x03802B3D,
+        0x03802B3B, 0x03802B39, 0x03802B38, 0x03802B36,
+        0x03802B34, 0x03802B33, 0x03802B32, 0x03802B30,
+        0x03802B2F, 0x03802B2D, 0x03802B2C, 0x03802B2B,
+        0x03802B2A, 0x03802B29, 0x03802B27, 0x03802B26,
+        0x03802B25, 0x03802B24, 0x03802B23, 0x03802B22,
+        0x03802B21, 0x03802B20, 0x03802B1F, 0x03802B1E,
+        0x03802B1E, 0x03802B1D, 0x03802B1C, 0x03802B1B,
+        0x03802B1A, 0x03802B1A, 0x03802B19, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x00002B00,
 };
 
 static const u32 b43_ntab_gainctl1[] = {
-        0x007F003F, 0x007E013F, 0x007D023E, 0x007C033E,
-        0x007B043D, 0x007A053D, 0x0079063C, 0x0078073C,
-        0x0077083B, 0x0076093B, 0x00750A3A, 0x00740B3A,
-        0x00730C39, 0x00720D39, 0x00710E38, 0x00700F38,
-        0x006F0037, 0x006E0137, 0x006D0236, 0x006C0336,
-        0x006B0435, 0x006A0535, 0x00690634, 0x00680734,
-        0x00670833, 0x00660933, 0x00650A32, 0x00640B32,
-        0x00630C31, 0x00620D31, 0x00610E30, 0x00600F30,
-        0x005F002F, 0x005E012F, 0x005D022E, 0x005C032E,
-        0x005B042D, 0x005A052D, 0x0059062C, 0x0058072C,
-        0x0057082B, 0x0056092B, 0x00550A2A, 0x00540B2A,
-        0x00530C29, 0x00520D29, 0x00510E28, 0x00500F28,
-        0x004F0027, 0x004E0127, 0x004D0226, 0x004C0326,
-        0x004B0425, 0x004A0525, 0x00490624, 0x00480724,
-        0x00470823, 0x00460923, 0x00450A22, 0x00440B22,
-        0x00430C21, 0x00420D21, 0x00410E20, 0x00400F20,
-        0x003F001F, 0x003E011F, 0x003D021E, 0x003C031E,
-        0x003B041D, 0x003A051D, 0x0039061C, 0x0038071C,
-        0x0037081B, 0x0036091B, 0x00350A1A, 0x00340B1A,
-        0x00330C19, 0x00320D19, 0x00310E18, 0x00300F18,
-        0x002F0017, 0x002E0117, 0x002D0216, 0x002C0316,
-        0x002B0415, 0x002A0515, 0x00290614, 0x00280714,
-        0x00270813, 0x00260913, 0x00250A12, 0x00240B12,
-        0x00230C11, 0x00220D11, 0x00210E10, 0x00200F10,
-        0x001F000F, 0x001E010F, 0x001D020E, 0x001C030E,
-        0x001B040D, 0x001A050D, 0x0019060C, 0x0018070C,
-        0x0017080B, 0x0016090B, 0x00150A0A, 0x00140B0A,
-        0x00130C09, 0x00120D09, 0x00110E08, 0x00100F08,
-        0x000F0007, 0x000E0107, 0x000D0206, 0x000C0306,
-        0x000B0405, 0x000A0505, 0x00090604, 0x00080704,
-        0x00070803, 0x00060903, 0x00050A02, 0x00040B02,
-        0x00030C01, 0x00020D01, 0x00010E00, 0x00000F00,
+        0x03CC2B44, 0x03CC2B42, 0x03CC2B40, 0x03CC2B3E,
+        0x03CC2B3D, 0x03CC2B3B, 0x03C82B44, 0x03C82B42,
+        0x03C82B40, 0x03C82B3E, 0x03C82B3D, 0x03C82B3B,
+        0x03C82B39, 0x03C82B38, 0x03C82B36, 0x03C82B34,
+        0x03C42B44, 0x03C42B42, 0x03C42B40, 0x03C42B3E,
+        0x03C42B3D, 0x03C42B3B, 0x03C42B39, 0x03C42B38,
+        0x03C42B36, 0x03C42B34, 0x03C42B33, 0x03C42B32,
+        0x03C42B30, 0x03C42B2F, 0x03C42B2D, 0x03C02B44,
+        0x03C02B42, 0x03C02B40, 0x03C02B3E, 0x03C02B3D,
+        0x03C02B3B, 0x03C02B39, 0x03C02B38, 0x03C02B36,
+        0x03C02B34, 0x03B02B44, 0x03B02B42, 0x03B02B40,
+        0x03B02B3E, 0x03B02B3D, 0x03B02B3B, 0x03B02B39,
+        0x03B02B38, 0x03B02B36, 0x03B02B34, 0x03B02B33,
+        0x03B02B32, 0x03B02B30, 0x03B02B2F, 0x03B02B2D,
+        0x03A02B44, 0x03A02B42, 0x03A02B40, 0x03A02B3E,
+        0x03A02B3D, 0x03A02B3B, 0x03A02B39, 0x03A02B38,
+        0x03A02B36, 0x03A02B34, 0x03902B44, 0x03902B42,
+        0x03902B40, 0x03902B3E, 0x03902B3D, 0x03902B3B,
+        0x03902B39, 0x03902B38, 0x03902B36, 0x03902B34,
+        0x03902B33, 0x03902B32, 0x03902B30, 0x03802B44,
+        0x03802B42, 0x03802B40, 0x03802B3E, 0x03802B3D,
+        0x03802B3B, 0x03802B39, 0x03802B38, 0x03802B36,
+        0x03802B34, 0x03802B33, 0x03802B32, 0x03802B30,
+        0x03802B2F, 0x03802B2D, 0x03802B2C, 0x03802B2B,
+        0x03802B2A, 0x03802B29, 0x03802B27, 0x03802B26,
+        0x03802B25, 0x03802B24, 0x03802B23, 0x03802B22,
+        0x03802B21, 0x03802B20, 0x03802B1F, 0x03802B1E,
+        0x03802B1E, 0x03802B1D, 0x03802B1C, 0x03802B1B,
+        0x03802B1A, 0x03802B1A, 0x03802B19, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x03802B18,
+        0x03802B18, 0x03802B18, 0x03802B18, 0x00002B00,
 };
 
 static const u32 b43_ntab_intlevel[] = {
@@ -1811,9 +1811,7 @@ void b43_ntab_write_bulk(struct b43_wldev *dev, u32 offset,
 }
 
 #define ntab_upload(dev, offset, data) do { \
-                unsigned int i;                                         \
-                for (i = 0; i < (offset##_SIZE); i++)                   \
-                        b43_ntab_write(dev, (offset) + i, (data)[i]);   \
+                b43_ntab_write_bulk(dev, offset, offset##_SIZE, data);  \
         } while (0)
 
 void b43_nphy_rev0_1_2_tables_init(struct b43_wldev *dev)
@@ -1825,18 +1823,18 @@ void b43_nphy_rev0_1_2_tables_init(struct b43_wldev *dev)
         ntab_upload(dev, B43_NTAB_TDTRN, b43_ntab_tdtrn);
         ntab_upload(dev, B43_NTAB_INTLEVEL, b43_ntab_intlevel);
         ntab_upload(dev, B43_NTAB_PILOT, b43_ntab_pilot);
-        ntab_upload(dev, B43_NTAB_PILOTLT, b43_ntab_pilotlt);
         ntab_upload(dev, B43_NTAB_TDI20A0, b43_ntab_tdi20a0);
         ntab_upload(dev, B43_NTAB_TDI20A1, b43_ntab_tdi20a1);
         ntab_upload(dev, B43_NTAB_TDI40A0, b43_ntab_tdi40a0);
         ntab_upload(dev, B43_NTAB_TDI40A1, b43_ntab_tdi40a1);
-        ntab_upload(dev, B43_NTAB_BDI, b43_ntab_bdi);
         ntab_upload(dev, B43_NTAB_CHANEST, b43_ntab_channelest);
         ntab_upload(dev, B43_NTAB_MCS, b43_ntab_mcs);
-
-        /* Volatile tables */
         ntab_upload(dev, B43_NTAB_NOISEVAR10, b43_ntab_noisevar10);
         ntab_upload(dev, B43_NTAB_NOISEVAR11, b43_ntab_noisevar11);
+
+        /* Volatile tables */
+        ntab_upload(dev, B43_NTAB_BDI, b43_ntab_bdi);
+        ntab_upload(dev, B43_NTAB_PILOTLT, b43_ntab_pilotlt);
         ntab_upload(dev, B43_NTAB_C0_ESTPLT, b43_ntab_estimatepowerlt0);
         ntab_upload(dev, B43_NTAB_C1_ESTPLT, b43_ntab_estimatepowerlt1);
         ntab_upload(dev, B43_NTAB_C0_ADJPLT, b43_ntab_adjustpower0);
diff --git a/drivers/net/wireless/iwlwifi/iwl-1000.c b/drivers/net/wireless/iwlwifi/iwl-1000.c
index fb3e3713bae4..3c983e426f25 100644
--- a/drivers/net/wireless/iwlwifi/iwl-1000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-1000.c
@@ -228,7 +228,6 @@ static struct iwl_lib_ops iwl1000_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
         .check_ack_health = iwl_good_ack_health,
         .txfifo_flush = iwlagn_txfifo_flush,
@@ -262,7 +261,7 @@ static struct iwl_base_params iwl1000_base_params = {
         .support_ct_kill_exit = true,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_EXT_LONG_THRESHOLD_DEF,
         .chain_noise_scale = 1000,
-        .monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
+        .wd_timeout = IWL_DEF_WD_TIMEOUT,
         .max_event_log_size = 128,
         .ucode_tracing = true,
         .sensitivity_calib_by_driver = true,
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index d39f449a9bb0..a9b852be4509 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -325,6 +325,7 @@ static void iwl3945_rx_reply_tx(struct iwl_priv *priv,
                 return;
         }
 
+        txq->time_stamp = jiffies;
         info = IEEE80211_SKB_CB(txq->txb[txq->q.read_ptr].skb);
         ieee80211_tx_info_clear_status(info);
 
@@ -1784,6 +1785,9 @@ int iwl3945_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
         int rc = 0;
         bool new_assoc = !!(staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK);
 
+        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
+                return -EINVAL;
+
         if (!iwl_is_alive(priv))
                 return -1;
 
@@ -2730,7 +2734,6 @@ static struct iwl_lib_ops iwl3945_lib = {
         .isr_ops = {
                 .isr = iwl_isr_legacy,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl3945_good_plcp_health,
 
         .debugfs_ops = {
@@ -2773,7 +2776,7 @@ static struct iwl_base_params iwl3945_base_params = {
         .led_compensation = 64,
         .broken_powersave = true,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF,
-        .monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
+        .wd_timeout = IWL_DEF_WD_TIMEOUT,
         .max_event_log_size = 512,
         .tx_power_by_driver = true,
 };
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c
index 6788ceb37686..3f1e5f1bf847 100644
--- a/drivers/net/wireless/iwlwifi/iwl-4965.c
+++ b/drivers/net/wireless/iwlwifi/iwl-4965.c
@@ -2198,6 +2198,7 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv,
                 return;
         }
 
+        txq->time_stamp = jiffies;
         info = IEEE80211_SKB_CB(txq->txb[txq->q.read_ptr].skb);
         memset(&info->status, 0, sizeof(info->status));
 
@@ -2554,7 +2555,6 @@ static struct iwl_lib_ops iwl4965_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
 };
 
@@ -2609,7 +2609,7 @@ static struct iwl_base_params iwl4965_base_params = {
         .led_compensation = 61,
         .chain_noise_num_beacons = IWL4965_CAL_NUM_BEACONS,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
-        .monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
+        .wd_timeout = IWL_DEF_WD_TIMEOUT,
         .temperature_kelvin = true,
         .max_event_log_size = 512,
         .tx_power_by_driver = true,
diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
index cf74edb82a70..8435e5a4e69d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
@@ -402,7 +402,6 @@ static struct iwl_lib_ops iwl5000_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
         .check_ack_health = iwl_good_ack_health,
         .txfifo_flush = iwlagn_txfifo_flush,
@@ -472,7 +471,6 @@ static struct iwl_lib_ops iwl5150_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
         .check_ack_health = iwl_good_ack_health,
         .txfifo_flush = iwlagn_txfifo_flush,
@@ -511,7 +509,7 @@ static struct iwl_base_params iwl5000_base_params = {
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF,
         .chain_noise_scale = 1000,
-        .monitor_recover_period = IWL_LONG_MONITORING_PERIOD,
+        .wd_timeout = IWL_LONG_WD_TIMEOUT,
         .max_event_log_size = 512,
         .ucode_tracing = true,
         .sensitivity_calib_by_driver = true,
diff --git a/drivers/net/wireless/iwlwifi/iwl-6000.c b/drivers/net/wireless/iwlwifi/iwl-6000.c
index ec41f2725292..808942cc2991 100644
--- a/drivers/net/wireless/iwlwifi/iwl-6000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-6000.c
@@ -339,7 +339,6 @@ static struct iwl_lib_ops iwl6000_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
         .check_ack_health = iwl_good_ack_health,
         .txfifo_flush = iwlagn_txfifo_flush,
@@ -412,7 +411,6 @@ static struct iwl_lib_ops iwl6000g2b_lib = {
                 .bt_stats_read = iwl_ucode_bt_stats_read,
                 .reply_tx_error = iwl_reply_tx_error_read,
         },
-        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl_good_plcp_health,
         .check_ack_health = iwl_good_ack_health,
         .txfifo_flush = iwlagn_txfifo_flush,
@@ -482,7 +480,7 @@ static struct iwl_base_params iwl6000_base_params = {
         .support_ct_kill_exit = true,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
         .chain_noise_scale = 1000,
-        .monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
+        .wd_timeout = IWL_DEF_WD_TIMEOUT,
         .max_event_log_size = 512,
         .ucode_tracing = true,
         .sensitivity_calib_by_driver = true,
@@ -506,7 +504,7 @@ static struct iwl_base_params iwl6050_base_params = {
         .support_ct_kill_exit = true,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
         .chain_noise_scale = 1500,
-        .monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
+        .wd_timeout = IWL_DEF_WD_TIMEOUT,
         .max_event_log_size = 1024,
         .ucode_tracing = true,
         .sensitivity_calib_by_driver = true,
@@ -529,7 +527,7 @@ static struct iwl_base_params iwl6000_coex_base_params = {
         .support_ct_kill_exit = true,
         .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
         .chain_noise_scale = 1000,
-        .monitor_recover_period = IWL_LONG_MONITORING_PERIOD,
+        .wd_timeout = IWL_LONG_WD_TIMEOUT,
         .max_event_log_size = 512,
         .ucode_tracing = true,
         .sensitivity_calib_by_driver = true,
@@ -552,7 +550,7 @@ static struct iwl_bt_params iwl6000_bt_params = {
         .bt_sco_disable = true,
 };
 
-struct iwl_cfg iwl6000g2a_2agn_cfg = {
+struct iwl_cfg iwl6005_2agn_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6205 AGN",
         .fw_name_pre = IWL6000G2A_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -568,7 +566,7 @@ struct iwl_cfg iwl6000g2a_2agn_cfg = {
         .led_mode = IWL_LED_RF_STATE,
 };
 
-struct iwl_cfg iwl6000g2a_2abg_cfg = {
+struct iwl_cfg iwl6005_2abg_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6205 ABG",
         .fw_name_pre = IWL6000G2A_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -583,7 +581,7 @@ struct iwl_cfg iwl6000g2a_2abg_cfg = {
         .led_mode = IWL_LED_RF_STATE,
 };
 
-struct iwl_cfg iwl6000g2a_2bg_cfg = {
+struct iwl_cfg iwl6005_2bg_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6205 BG",
         .fw_name_pre = IWL6000G2A_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -598,7 +596,7 @@ struct iwl_cfg iwl6000g2a_2bg_cfg = {
         .led_mode = IWL_LED_RF_STATE,
 };
 
-struct iwl_cfg iwl6000g2b_2agn_cfg = {
+struct iwl_cfg iwl6030_2agn_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6230 AGN",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -618,7 +616,7 @@ struct iwl_cfg iwl6000g2b_2agn_cfg = {
         .scan_tx_antennas[IEEE80211_BAND_2GHZ] = ANT_A,
 };
 
-struct iwl_cfg iwl6000g2b_2abg_cfg = {
+struct iwl_cfg iwl6030_2abg_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6230 ABG",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -637,7 +635,7 @@ struct iwl_cfg iwl6000g2b_2abg_cfg = {
         .scan_tx_antennas[IEEE80211_BAND_2GHZ] = ANT_A,
 };
 
-struct iwl_cfg iwl6000g2b_2bgn_cfg = {
+struct iwl_cfg iwl6030_2bgn_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6230 BGN",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -657,7 +655,7 @@ struct iwl_cfg iwl6000g2b_2bgn_cfg = {
         .scan_tx_antennas[IEEE80211_BAND_2GHZ] = ANT_A,
 };
 
-struct iwl_cfg iwl6000g2b_2bg_cfg = {
+struct iwl_cfg iwl6030_2bg_cfg = {
         .name = "Intel(R) Centrino(R) Advanced-N 6230 BG",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -676,7 +674,7 @@ struct iwl_cfg iwl6000g2b_2bg_cfg = {
         .scan_tx_antennas[IEEE80211_BAND_2GHZ] = ANT_A,
 };
 
-struct iwl_cfg iwl6000g2b_bgn_cfg = {
+struct iwl_cfg iwl1030_bgn_cfg = {
         .name = "Intel(R) Centrino(R) Wireless-N 1030 BGN",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -696,7 +694,7 @@ struct iwl_cfg iwl6000g2b_bgn_cfg = {
         .scan_tx_antennas[IEEE80211_BAND_2GHZ] = ANT_A,
 };
 
-struct iwl_cfg iwl6000g2b_bg_cfg = {
+struct iwl_cfg iwl1030_bg_cfg = {
         .name = "Intel(R) Centrino(R) Wireless-N 1030 BG",
         .fw_name_pre = IWL6000G2B_FW_PRE,
         .ucode_api_max = IWL6000G2_UCODE_API_MAX,
@@ -782,7 +780,7 @@ struct iwl_cfg iwl6050_2agn_cfg = {
         .led_mode = IWL_LED_BLINK,
 };
 
-struct iwl_cfg iwl6050g2_bgn_cfg = {
+struct iwl_cfg iwl6150_bgn_cfg = {
         .name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BGN",
         .fw_name_pre = IWL6050_FW_PRE,
         .ucode_api_max = IWL6050_UCODE_API_MAX,
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
index 407f0bb8422a..d941910e7ef4 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
@@ -405,6 +405,7 @@ static void iwlagn_rx_reply_tx(struct iwl_priv *priv,
                 return;
         }
 
+        txq->time_stamp = jiffies;
         info = IEEE80211_SKB_CB(txq->txb[txq->q.read_ptr].skb);
         memset(&info->status, 0, sizeof(info->status));
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c b/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
index 203ee60a82b4..4865b82355d7 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
@@ -130,6 +130,9 @@ int iwlagn_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
 
         lockdep_assert_held(&priv->mutex);
 
+        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
+                return -EINVAL;
+
         if (!iwl_is_alive(priv))
                 return -EBUSY;
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c b/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
index 0bdd2bb0bbd3..24dabcd2a36c 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
@@ -531,6 +531,10 @@ int iwlagn_alive_notify(struct iwl_priv *priv)
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
+        /* Enable L1-Active */
+        iwl_clear_bits_prph(priv, APMG_PCIDEV_STT_REG,
+                          APMG_PCIDEV_STT_VAL_L1_ACT_DIS);
+
         iwlagn_send_wimax_coex(priv);
 
         iwlagn_set_Xtal_calib(priv);
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 50cee2b5a6b7..d4075476670a 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -2502,7 +2502,7 @@ int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
                 return pos;
         }
 
-        /* enable/disable bt channel announcement */
+        /* enable/disable bt channel inhibition */
         priv->bt_ch_announce = iwlagn_bt_ch_announce;
 
 #ifdef CONFIG_IWLWIFI_DEBUG
@@ -2654,13 +2654,8 @@ static void iwl_alive_start(struct iwl_priv *priv)
         /* After the ALIVE response, we can send host commands to the uCode */
         set_bit(STATUS_ALIVE, &priv->status);
 
-        if (priv->cfg->ops->lib->recover_from_tx_stall) {
-                /* Enable timer to monitor the driver queues */
-                mod_timer(&priv->monitor_recover,
-                        jiffies +
-                        msecs_to_jiffies(
-                          priv->cfg->base_params->monitor_recover_period));
-        }
+        /* Enable watchdog to monitor the driver tx queues */
+        iwl_setup_watchdog(priv);
 
         if (iwl_is_rfkill(priv))
                 return;
@@ -2755,8 +2750,7 @@ static void __iwl_down(struct iwl_priv *priv)
 
         /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
          * to prevent rearm timer */
-        if (priv->cfg->ops->lib->recover_from_tx_stall)
-                del_timer_sync(&priv->monitor_recover);
+        del_timer_sync(&priv->watchdog);
 
         iwl_clear_ucode_stations(priv, NULL);
         iwl_dealloc_bcast_stations(priv);
@@ -3742,12 +3736,9 @@ static void iwl_setup_deferred_work(struct iwl_priv *priv)
         priv->ucode_trace.data = (unsigned long)priv;
         priv->ucode_trace.function = iwl_bg_ucode_trace;
 
-        if (priv->cfg->ops->lib->recover_from_tx_stall) {
-                init_timer(&priv->monitor_recover);
-                priv->monitor_recover.data = (unsigned long)priv;
-                priv->monitor_recover.function =
-                        priv->cfg->ops->lib->recover_from_tx_stall;
-        }
+        init_timer(&priv->watchdog);
+        priv->watchdog.data = (unsigned long)priv;
+        priv->watchdog.function = iwl_bg_watchdog;
 
         if (!priv->cfg->base_params->use_isr_legacy)
                 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
@@ -4044,8 +4035,10 @@ static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 (iwlagn_ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
                 true : false;
 
-        /* enable/disable bt channel announcement */
+        /* enable/disable bt channel inhibition */
         priv->bt_ch_announce = iwlagn_bt_ch_announce;
+        IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
+                       (priv->bt_ch_announce) ? "On" : "Off");
 
         if (iwl_alloc_traffic_mem(priv))
                 IWL_ERR(priv, "Not enough memory to generate traffic log\n");
@@ -4419,31 +4412,31 @@ static DEFINE_PCI_DEVICE_TABLE(iwl_hw_card_ids) = {
         {IWL_PCI_DEVICE(0x4239, 0x1316, iwl6000i_2abg_cfg)},
 
 /* 6x00 Series Gen2a */
-        {IWL_PCI_DEVICE(0x0082, 0x1301, iwl6000g2a_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0082, 0x1306, iwl6000g2a_2abg_cfg)},
-        {IWL_PCI_DEVICE(0x0082, 0x1307, iwl6000g2a_2bg_cfg)},
-        {IWL_PCI_DEVICE(0x0082, 0x1321, iwl6000g2a_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0082, 0x1326, iwl6000g2a_2abg_cfg)},
-        {IWL_PCI_DEVICE(0x0085, 0x1311, iwl6000g2a_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0085, 0x1316, iwl6000g2a_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x0082, 0x1301, iwl6005_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0082, 0x1306, iwl6005_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x0082, 0x1307, iwl6005_2bg_cfg)},
+        {IWL_PCI_DEVICE(0x0082, 0x1321, iwl6005_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0082, 0x1326, iwl6005_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x0085, 0x1311, iwl6005_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0085, 0x1316, iwl6005_2abg_cfg)},
 
 /* 6x00 Series Gen2b */
-        {IWL_PCI_DEVICE(0x008A, 0x5305, iwl6000g2b_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x008A, 0x5307, iwl6000g2b_bg_cfg)},
-        {IWL_PCI_DEVICE(0x008A, 0x5325, iwl6000g2b_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x008A, 0x5327, iwl6000g2b_bg_cfg)},
-        {IWL_PCI_DEVICE(0x008B, 0x5315, iwl6000g2b_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x008B, 0x5317, iwl6000g2b_bg_cfg)},
-        {IWL_PCI_DEVICE(0x0090, 0x5211, iwl6000g2b_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0090, 0x5215, iwl6000g2b_2bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0090, 0x5216, iwl6000g2b_2abg_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5201, iwl6000g2b_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5205, iwl6000g2b_2bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5206, iwl6000g2b_2abg_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5207, iwl6000g2b_2bg_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5221, iwl6000g2b_2agn_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5225, iwl6000g2b_2bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0091, 0x5226, iwl6000g2b_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x008A, 0x5305, iwl1030_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x008A, 0x5307, iwl1030_bg_cfg)},
+        {IWL_PCI_DEVICE(0x008A, 0x5325, iwl1030_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x008A, 0x5327, iwl1030_bg_cfg)},
+        {IWL_PCI_DEVICE(0x008B, 0x5315, iwl1030_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x008B, 0x5317, iwl1030_bg_cfg)},
+        {IWL_PCI_DEVICE(0x0090, 0x5211, iwl6030_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0090, 0x5215, iwl6030_2bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0090, 0x5216, iwl6030_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5201, iwl6030_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5205, iwl6030_2bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5206, iwl6030_2abg_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5207, iwl6030_2bg_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5221, iwl6030_2agn_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5225, iwl6030_2bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0091, 0x5226, iwl6030_2abg_cfg)},
 
 /* 6x50 WiFi/WiMax Series */
         {IWL_PCI_DEVICE(0x0087, 0x1301, iwl6050_2agn_cfg)},
@@ -4454,12 +4447,12 @@ static DEFINE_PCI_DEVICE_TABLE(iwl_hw_card_ids) = {
         {IWL_PCI_DEVICE(0x0089, 0x1316, iwl6050_2abg_cfg)},
 
 /* 6x50 WiFi/WiMax Series Gen2 */
-        {IWL_PCI_DEVICE(0x0885, 0x1305, iwl6050g2_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0885, 0x1306, iwl6050g2_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0885, 0x1325, iwl6050g2_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0885, 0x1326, iwl6050g2_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0886, 0x1315, iwl6050g2_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0886, 0x1316, iwl6050g2_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0885, 0x1305, iwl6150_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0885, 0x1306, iwl6150_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0885, 0x1325, iwl6150_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0885, 0x1326, iwl6150_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0886, 0x1315, iwl6150_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0886, 0x1316, iwl6150_bgn_cfg)},
 
 /* 1000 Series WiFi */
         {IWL_PCI_DEVICE(0x0083, 0x1205, iwl1000_bgn_cfg)},
@@ -4588,6 +4581,6 @@ module_param_named(antenna_coupling, iwlagn_ant_coupling, int, S_IRUGO);
 MODULE_PARM_DESC(antenna_coupling,
                  "specify antenna coupling in dB (defualt: 0 dB)");
 
-module_param_named(bt_ch_announce, iwlagn_bt_ch_announce, bool, S_IRUGO);
-MODULE_PARM_DESC(bt_ch_announce,
-                 "Enable BT channel announcement mode (default: enable)");
+module_param_named(bt_ch_inhibition, iwlagn_bt_ch_announce, bool, S_IRUGO);
+MODULE_PARM_DESC(bt_ch_inhibition,
+                 "Disable BT channel inhibition (default: enable)");
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.h b/drivers/net/wireless/iwlwifi/iwl-agn.h
index 28837a185a28..da303585f801 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.h
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.h
@@ -74,22 +74,22 @@ extern struct iwl_cfg iwl5100_bgn_cfg;
 extern struct iwl_cfg iwl5100_abg_cfg;
 extern struct iwl_cfg iwl5150_agn_cfg;
 extern struct iwl_cfg iwl5150_abg_cfg;
-extern struct iwl_cfg iwl6000g2a_2agn_cfg;
-extern struct iwl_cfg iwl6000g2a_2abg_cfg;
-extern struct iwl_cfg iwl6000g2a_2bg_cfg;
-extern struct iwl_cfg iwl6000g2b_bgn_cfg;
-extern struct iwl_cfg iwl6000g2b_bg_cfg;
-extern struct iwl_cfg iwl6000g2b_2agn_cfg;
-extern struct iwl_cfg iwl6000g2b_2abg_cfg;
-extern struct iwl_cfg iwl6000g2b_2bgn_cfg;
-extern struct iwl_cfg iwl6000g2b_2bg_cfg;
+extern struct iwl_cfg iwl6005_2agn_cfg;
+extern struct iwl_cfg iwl6005_2abg_cfg;
+extern struct iwl_cfg iwl6005_2bg_cfg;
+extern struct iwl_cfg iwl1030_bgn_cfg;
+extern struct iwl_cfg iwl1030_bg_cfg;
+extern struct iwl_cfg iwl6030_2agn_cfg;
+extern struct iwl_cfg iwl6030_2abg_cfg;
+extern struct iwl_cfg iwl6030_2bgn_cfg;
+extern struct iwl_cfg iwl6030_2bg_cfg;
 extern struct iwl_cfg iwl6000i_2agn_cfg;
 extern struct iwl_cfg iwl6000i_2abg_cfg;
 extern struct iwl_cfg iwl6000i_2bg_cfg;
 extern struct iwl_cfg iwl6000_3agn_cfg;
 extern struct iwl_cfg iwl6050_2agn_cfg;
 extern struct iwl_cfg iwl6050_2abg_cfg;
-extern struct iwl_cfg iwl6050g2_bgn_cfg;
+extern struct iwl_cfg iwl6150_bgn_cfg;
 extern struct iwl_cfg iwl1000_bgn_cfg;
 extern struct iwl_cfg iwl1000_bg_cfg;
 extern struct iwl_cfg iwl100_bgn_cfg;
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index c41f5a878210..d62b92518417 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -1894,77 +1894,58 @@ int iwl_mac_change_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 }
 EXPORT_SYMBOL(iwl_mac_change_interface);
 
-/**
- * iwl_bg_monitor_recover - Timer callback to check for stuck queue and recover
- *
- * During normal condition (no queue is stuck), the timer is continually set to
- * execute every monitor_recover_period milliseconds after the last timer
- * expired.  When the queue read_ptr is at the same place, the timer is
- * shorten to 100mSecs.  This is
- *      1) to reduce the chance that the read_ptr may wrap around (not stuck)
- *      2) to detect the stuck queues quicker before the station and AP can
- *      disassociate each other.
- *
- * This function monitors all the tx queues and recover from it if any
- * of the queues are stuck.
- * 1. It first check the cmd queue for stuck conditions.  If it is stuck,
- *      it will recover by resetting the firmware and return.
- * 2. Then, it checks for station association.  If it associates it will check
- *      other queues.  If any queue is stuck, it will recover by resetting
- *      the firmware.
- * Note: It the number of times the queue read_ptr to be at the same place to
- *      be MAX_REPEAT+1 in order to consider to be stuck.
- */
 /*
- * The maximum number of times the read pointer of the tx queue at the
- * same place without considering to be stuck.
+ * On every watchdog tick we check (latest) time stamp. If it does not
+ * change during timeout period and queue is not empty we reset firmware.
  */
-#define MAX_REPEAT      (2)
 static int iwl_check_stuck_queue(struct iwl_priv *priv, int cnt)
 {
-        struct iwl_tx_queue *txq;
-        struct iwl_queue *q;
+        struct iwl_tx_queue *txq = &priv->txq[cnt];
+        struct iwl_queue *q = &txq->q;
+        unsigned long timeout;
+        int ret;
 
-        txq = &priv->txq[cnt];
-        q = &txq->q;
-        /* queue is empty, skip */
-        if (q->read_ptr == q->write_ptr)
+        if (q->read_ptr == q->write_ptr) {
+                txq->time_stamp = jiffies;
                 return 0;
+        }
 
-        if (q->read_ptr == q->last_read_ptr) {
-                /* a queue has not been read from last time */
-                if (q->repeat_same_read_ptr > MAX_REPEAT) {
-                        IWL_ERR(priv,
-                                "queue %d stuck %d time. Fw reload.\n",
-                                q->id, q->repeat_same_read_ptr);
-                        q->repeat_same_read_ptr = 0;
-                        iwl_force_reset(priv, IWL_FW_RESET, false);
-                } else {
-                        q->repeat_same_read_ptr++;
-                        IWL_DEBUG_RADIO(priv,
-                                        "queue %d, not read %d time\n",
-                                        q->id,
-                                        q->repeat_same_read_ptr);
-                        mod_timer(&priv->monitor_recover,
-                                jiffies + msecs_to_jiffies(
-                                IWL_ONE_HUNDRED_MSECS));
-                        return 1;
-                }
-        } else {
-                q->last_read_ptr = q->read_ptr;
-                q->repeat_same_read_ptr = 0;
+        timeout = txq->time_stamp +
+                  msecs_to_jiffies(priv->cfg->base_params->wd_timeout);
+
+        if (time_after(jiffies, timeout)) {
+                IWL_ERR(priv, "Queue %d stuck for %u ms.\n",
+                                q->id, priv->cfg->base_params->wd_timeout);
+                ret = iwl_force_reset(priv, IWL_FW_RESET, false);
+                return (ret == -EAGAIN) ? 0 : 1;
         }
+
         return 0;
 }
 
-void iwl_bg_monitor_recover(unsigned long data)
+/*
+ * Making watchdog tick be a quarter of timeout assure we will
+ * discover the queue hung between timeout and 1.25*timeout
+ */
+#define IWL_WD_TICK(timeout) ((timeout) / 4)
+
+/*
+ * Watchdog timer callback, we check each tx queue for stuck, if if hung
+ * we reset the firmware. If everything is fine just rearm the timer.
+ */
+void iwl_bg_watchdog(unsigned long data)
 {
         struct iwl_priv *priv = (struct iwl_priv *)data;
         int cnt;
+        unsigned long timeout;
 
         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
                 return;
 
+        timeout = priv->cfg->base_params->wd_timeout;
+        if (timeout == 0)
+                return;
+
         /* monitor and check for stuck cmd queue */
         if (iwl_check_stuck_queue(priv, priv->cmd_queue))
                 return;
@@ -1979,17 +1960,23 @@ void iwl_bg_monitor_recover(unsigned long data)
                                 return;
                 }
         }
-        if (priv->cfg->base_params->monitor_recover_period) {
-                /*
-                 * Reschedule the timer to occur in
-                 * priv->cfg->base_params->monitor_recover_period
-                 */
-                mod_timer(&priv->monitor_recover, jiffies + msecs_to_jiffies(
-                          priv->cfg->base_params->monitor_recover_period));
-        }
+
+        mod_timer(&priv->watchdog, jiffies +
+                  msecs_to_jiffies(IWL_WD_TICK(timeout)));
 }
-EXPORT_SYMBOL(iwl_bg_monitor_recover);
+EXPORT_SYMBOL(iwl_bg_watchdog);
+
+void iwl_setup_watchdog(struct iwl_priv *priv)
+{
+        unsigned int timeout = priv->cfg->base_params->wd_timeout;
 
+        if (timeout)
+                mod_timer(&priv->watchdog,
+                          jiffies + msecs_to_jiffies(IWL_WD_TICK(timeout)));
+        else
+                del_timer(&priv->watchdog);
+}
+EXPORT_SYMBOL(iwl_setup_watchdog);
 
 /*
  * extended beacon time format
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.h b/drivers/net/wireless/iwlwifi/iwl-core.h
index 808be731ecb7..568920ac982d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.h
+++ b/drivers/net/wireless/iwlwifi/iwl-core.h
@@ -210,8 +210,6 @@ struct iwl_lib_ops {
 
         /* temperature */
         struct iwl_temp_ops temp_ops;
-        /* recover from tx queue stall */
-        void (*recover_from_tx_stall)(unsigned long data);
         /* check for plcp health */
         bool (*check_plcp_health)(struct iwl_priv *priv,
                                         struct iwl_rx_packet *pkt);
@@ -280,7 +278,7 @@ struct iwl_mod_params {
  * @plcp_delta_threshold: plcp error rate threshold used to trigger
  *      radio tuning when there is a high receiving plcp error rate
  * @chain_noise_scale: default chain noise scale used for gain computation
- * @monitor_recover_period: default timer used to check stuck queues
+ * @wd_timeout: TX queues watchdog timeout
  * @temperature_kelvin: temperature report by uCode in kelvin
  * @max_event_log_size: size of event log buffer size for ucode event logging
  * @tx_power_by_driver: tx power calibration performed by driver
@@ -315,8 +313,7 @@ struct iwl_base_params {
         const bool support_wimax_coexist;
         u8 plcp_delta_threshold;
         s32 chain_noise_scale;
-        /* timer period for monitor the driver queues */
-        u32 monitor_recover_period;
+        unsigned int wd_timeout;
         bool temperature_kelvin;
         u32 max_event_log_size;
         const bool tx_power_by_driver;
@@ -546,6 +543,7 @@ int iwl_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
 void iwl_tx_queue_reset(struct iwl_priv *priv, struct iwl_tx_queue *txq,
                         int slots_num, u32 txq_id);
 void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id);
+void iwl_setup_watchdog(struct iwl_priv *priv);
 /*****************************************************
  * TX power
  ****************************************************/
@@ -625,7 +623,7 @@ static inline u16 iwl_pcie_link_ctl(struct iwl_priv *priv)
         return pci_lnk_ctl;
 }
 
-void iwl_bg_monitor_recover(unsigned long data);
+void iwl_bg_watchdog(unsigned long data);
 u32 iwl_usecs_to_beacons(struct iwl_priv *priv, u32 usec, u32 beacon_interval);
 __le32 iwl_add_beacon_time(struct iwl_priv *priv, u32 base,
                            u32 addon, u32 beacon_interval);
diff --git a/drivers/net/wireless/iwlwifi/iwl-debugfs.c b/drivers/net/wireless/iwlwifi/iwl-debugfs.c
index 3cc58420d445..d36836376e6b 100644
--- a/drivers/net/wireless/iwlwifi/iwl-debugfs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-debugfs.c
@@ -1534,32 +1534,26 @@ static ssize_t iwl_dbgfs_ucode_bt_stats_read(struct file *file,
                         user_buf, count, ppos);
 }
 
-static ssize_t iwl_dbgfs_monitor_period_write(struct file *file,
+static ssize_t iwl_dbgfs_wd_timeout_write(struct file *file,
                                         const char __user *user_buf,
                                         size_t count, loff_t *ppos) {
 
         struct iwl_priv *priv = file->private_data;
         char buf[8];
         int buf_size;
-        int period;
+        int timeout;
 
         memset(buf, 0, sizeof(buf));
         buf_size = min(count, sizeof(buf) -  1);
         if (copy_from_user(buf, user_buf, buf_size))
                 return -EFAULT;
-        if (sscanf(buf, "%d", &period) != 1)
+        if (sscanf(buf, "%d", &timeout) != 1)
                 return -EINVAL;
-        if (period < 0 || period > IWL_MAX_MONITORING_PERIOD)
-                priv->cfg->base_params->monitor_recover_period =
-                        IWL_DEF_MONITORING_PERIOD;
-        else
-                priv->cfg->base_params->monitor_recover_period = period;
+        if (timeout < 0 || timeout > IWL_MAX_WD_TIMEOUT)
+                timeout = IWL_DEF_WD_TIMEOUT;
 
-        if (priv->cfg->base_params->monitor_recover_period)
-                mod_timer(&priv->monitor_recover, jiffies + msecs_to_jiffies(
-                          priv->cfg->base_params->monitor_recover_period));
-        else
-                del_timer_sync(&priv->monitor_recover);
+        priv->cfg->base_params->wd_timeout = timeout;
+        iwl_setup_watchdog(priv);
         return count;
 }
 
@@ -1686,7 +1680,7 @@ DEBUGFS_READ_FILE_OPS(rxon_flags);
 DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
 DEBUGFS_WRITE_FILE_OPS(txfifo_flush);
 DEBUGFS_READ_FILE_OPS(ucode_bt_stats);
-DEBUGFS_WRITE_FILE_OPS(monitor_period);
+DEBUGFS_WRITE_FILE_OPS(wd_timeout);
 DEBUGFS_READ_FILE_OPS(bt_traffic);
 DEBUGFS_READ_WRITE_FILE_OPS(protection_mode);
 DEBUGFS_READ_FILE_OPS(reply_tx_error);
@@ -1763,7 +1757,7 @@ int iwl_dbgfs_register(struct iwl_priv *priv, const char *name)
         DEBUGFS_ADD_FILE(reply_tx_error, dir_debug, S_IRUSR);
         DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
         DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
-        DEBUGFS_ADD_FILE(monitor_period, dir_debug, S_IWUSR);
+        DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR);
         if (priv->cfg->bt_params && priv->cfg->bt_params->advanced_bt_coexist)
                 DEBUGFS_ADD_FILE(bt_traffic, dir_debug, S_IRUSR);
         if (priv->cfg->base_params->sensitivity_calib_by_driver)
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h
index ea81ced13756..836f1816b110 100644
--- a/drivers/net/wireless/iwlwifi/iwl-dev.h
+++ b/drivers/net/wireless/iwlwifi/iwl-dev.h
@@ -129,9 +129,6 @@ struct iwl_queue {
         int write_ptr;       /* 1-st empty entry (index) host_w*/
         int read_ptr;         /* last used entry (index) host_r*/
         /* use for monitoring and recovering the stuck queue */
-        int last_read_ptr;      /* storing the last read_ptr */
-        /* number of time read_ptr and last_read_ptr are the same */
-        u8 repeat_same_read_ptr;
         dma_addr_t dma_addr;   /* physical addr for BD's */
         int n_window;          /* safe queue window */
         u32 id;
@@ -155,6 +152,7 @@ struct iwl_tx_info {
  * @meta: array of meta data for each command/tx buffer
  * @dma_addr_cmd: physical address of cmd/tx buffer array
  * @txb: array of per-TFD driver data
+ * @time_stamp: time (in jiffies) of last read_ptr change
  * @need_update: indicates need to update read/write index
  * @sched_retry: indicates queue is high-throughput aggregation (HT AGG) enabled
  *
@@ -170,6 +168,7 @@ struct iwl_tx_queue {
         struct iwl_device_cmd **cmd;
         struct iwl_cmd_meta *meta;
         struct iwl_tx_info *txb;
+        unsigned long time_stamp;
         u8 need_update;
         u8 sched_retry;
         u8 active;
@@ -1104,11 +1103,10 @@ struct iwl_event_log {
 #define IWL_DELAY_NEXT_FORCE_RF_RESET  (HZ*3)
 #define IWL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5)
 
-/* timer constants use to monitor and recover stuck tx queues in mSecs */
-#define IWL_DEF_MONITORING_PERIOD       (1000)
-#define IWL_LONG_MONITORING_PERIOD      (5000)
-#define IWL_ONE_HUNDRED_MSECS   (100)
-#define IWL_MAX_MONITORING_PERIOD       (60000)
+/* TX queue watchdog timeouts in mSecs */
+#define IWL_DEF_WD_TIMEOUT      (2000)
+#define IWL_LONG_WD_TIMEOUT     (10000)
+#define IWL_MAX_WD_TIMEOUT      (120000)
 
 /* BT Antenna Coupling Threshold (dB) */
 #define IWL_BT_ANTENNA_COUPLING_THRESHOLD       (35)
@@ -1544,7 +1542,7 @@ struct iwl_priv {
         struct work_struct run_time_calib_work;
         struct timer_list statistics_periodic;
         struct timer_list ucode_trace;
-        struct timer_list monitor_recover;
+        struct timer_list watchdog;
         bool hw_ready;
 
         struct iwl_event_log event_log;
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 0a67b2fa52a1..4776323b1eba 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -647,6 +647,7 @@ void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
         memcpy(&lq, priv->stations[sta_id].lq, sizeof(lq));
 
         active = priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE;
+        priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
         spin_unlock_irqrestore(&priv->sta_lock, flags);
 
         if (active) {
@@ -657,6 +658,10 @@ void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
                         IWL_ERR(priv, "failed to remove STA %pM (%d)\n",
                                 priv->stations[sta_id].sta.sta.addr, ret);
         }
+        spin_lock_irqsave(&priv->sta_lock, flags);
+        priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
+        spin_unlock_irqrestore(&priv->sta_lock, flags);
+
         ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
         if (ret)
                 IWL_ERR(priv, "failed to re-add STA %pM (%d)\n",
@@ -777,6 +782,14 @@ int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
         if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
                 return -EINVAL;
 
+
+        spin_lock_irqsave(&priv->sta_lock, flags_spin);
+        if (!(priv->stations[lq->sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
+                spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
+                return -EINVAL;
+        }
+        spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
+
         iwl_dump_lq_cmd(priv, lq);
         BUG_ON(init && (cmd.flags & CMD_ASYNC));
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-tx.c b/drivers/net/wireless/iwlwifi/iwl-tx.c
index 90659bcf5804..073b6ce6141c 100644
--- a/drivers/net/wireless/iwlwifi/iwl-tx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-tx.c
@@ -263,8 +263,6 @@ static int iwl_queue_init(struct iwl_priv *priv, struct iwl_queue *q,
                 q->high_mark = 2;
 
         q->write_ptr = q->read_ptr = 0;
-        q->last_read_ptr = 0;
-        q->repeat_same_read_ptr = 0;
 
         return 0;
 }
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 8eb1393506bc..371abbf60eac 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -2509,13 +2509,8 @@ static void iwl3945_alive_start(struct iwl_priv *priv)
         /* After the ALIVE response, we can send commands to 3945 uCode */
         set_bit(STATUS_ALIVE, &priv->status);
 
-        if (priv->cfg->ops->lib->recover_from_tx_stall) {
-                /* Enable timer to monitor the driver queues */
-                mod_timer(&priv->monitor_recover,
-                        jiffies +
-                        msecs_to_jiffies(
-                          priv->cfg->base_params->monitor_recover_period));
-        }
+        /* Enable watchdog to monitor the driver tx queues */
+        iwl_setup_watchdog(priv);
 
         if (iwl_is_rfkill(priv))
                 return;
@@ -2572,8 +2567,7 @@ static void __iwl3945_down(struct iwl_priv *priv)
 
         /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
          * to prevent rearm timer */
-        if (priv->cfg->ops->lib->recover_from_tx_stall)
-                del_timer_sync(&priv->monitor_recover);
+        del_timer_sync(&priv->watchdog);
 
         /* Station information will now be cleared in device */
         iwl_clear_ucode_stations(priv, NULL);
@@ -3775,12 +3769,9 @@ static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
 
         iwl3945_hw_setup_deferred_work(priv);
 
-        if (priv->cfg->ops->lib->recover_from_tx_stall) {
-                init_timer(&priv->monitor_recover);
-                priv->monitor_recover.data = (unsigned long)priv;
-                priv->monitor_recover.function =
-                        priv->cfg->ops->lib->recover_from_tx_stall;
-        }
+        init_timer(&priv->watchdog);
+        priv->watchdog.data = (unsigned long)priv;
+        priv->watchdog.function = iwl_bg_watchdog;
 
         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
                      iwl3945_irq_tasklet, (unsigned long)priv);
@@ -3861,6 +3852,13 @@ static int iwl3945_init_drv(struct iwl_priv *priv)
         priv->iw_mode = NL80211_IFTYPE_STATION;
         priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
 
+        /* initialize force reset */
+        priv->force_reset[IWL_RF_RESET].reset_duration =
+                IWL_DELAY_NEXT_FORCE_RF_RESET;
+        priv->force_reset[IWL_FW_RESET].reset_duration =
+                IWL_DELAY_NEXT_FORCE_FW_RELOAD;
+
+
         priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
         priv->tx_power_next = IWL_DEFAULT_TX_POWER;
 
diff --git a/drivers/net/wireless/orinoco/main.c b/drivers/net/wireless/orinoco/main.c
index fa0cf744958f..f3d396e7544b 100644
--- a/drivers/net/wireless/orinoco/main.c
+++ b/drivers/net/wireless/orinoco/main.c
@@ -1811,6 +1811,12 @@ static int __orinoco_commit(struct orinoco_private *priv)
         struct net_device *dev = priv->ndev;
         int err = 0;
 
+        /* If we've called commit, we are reconfiguring or bringing the
+         * interface up. Maintaining countermeasures across this would
+         * be confusing, so note that we've disabled them. The port will
+         * be enabled later in orinoco_commit or __orinoco_up. */
+        priv->tkip_cm_active = 0;
+
         err = orinoco_hw_program_rids(priv);
 
         /* FIXME: what about netif_tx_lock */
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index 71b3d68b9403..32954c4b243a 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -151,20 +151,20 @@ orinoco_cs_config(struct pcmcia_device *link)
                 goto failed;
         }
 
-        ret = pcmcia_request_irq(link, orinoco_interrupt);
-        if (ret)
-                goto failed;
-
-        /* We initialize the hermes structure before completing PCMCIA
-         * configuration just in case the interrupt handler gets
-         * called. */
         mem = ioport_map(link->resource[0]->start,
                         resource_size(link->resource[0]));
         if (!mem)
                 goto failed;
 
+        /* We initialize the hermes structure before completing PCMCIA
+         * configuration just in case the interrupt handler gets
+         * called. */
         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 
+        ret = pcmcia_request_irq(link, orinoco_interrupt);
+        if (ret)
+                goto failed;
+
         ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
diff --git a/drivers/net/wireless/orinoco/spectrum_cs.c b/drivers/net/wireless/orinoco/spectrum_cs.c
index fb859a5ad2eb..db34c282e59b 100644
--- a/drivers/net/wireless/orinoco/spectrum_cs.c
+++ b/drivers/net/wireless/orinoco/spectrum_cs.c
@@ -214,21 +214,21 @@ spectrum_cs_config(struct pcmcia_device *link)
                 goto failed;
         }
 
-        ret = pcmcia_request_irq(link, orinoco_interrupt);
-        if (ret)
-                goto failed;
-
-        /* We initialize the hermes structure before completing PCMCIA
-         * configuration just in case the interrupt handler gets
-         * called. */
         mem = ioport_map(link->resource[0]->start,
                         resource_size(link->resource[0]));
         if (!mem)
                 goto failed;
 
+        /* We initialize the hermes structure before completing PCMCIA
+         * configuration just in case the interrupt handler gets
+         * called. */
         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
         hw->eeprom_pda = true;
 
+        ret = pcmcia_request_irq(link, orinoco_interrupt);
+        if (ret)
+                goto failed;
+
         ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
diff --git a/drivers/net/wireless/orinoco/wext.c b/drivers/net/wireless/orinoco/wext.c
index 93505f93bf97..e793679e2e19 100644
--- a/drivers/net/wireless/orinoco/wext.c
+++ b/drivers/net/wireless/orinoco/wext.c
@@ -893,6 +893,14 @@ static int orinoco_ioctl_set_auth(struct net_device *dev,
                  */
                 break;
 
+        case IW_AUTH_MFP:
+                /* Management Frame Protection not supported.
+                 * Only fail if set to required.
+                 */
+                if (param->value == IW_AUTH_MFP_REQUIRED)
+                        ret = -EINVAL;
+                break;
+
         case IW_AUTH_KEY_MGMT:
                 /* wl_lkm implies value 2 == PSK for Hermes I
                  * which ties in with WEXT
@@ -911,10 +919,10 @@ static int orinoco_ioctl_set_auth(struct net_device *dev,
                  */
                 if (param->value) {
                         priv->tkip_cm_active = 1;
-                        ret = hermes_enable_port(hw, 0);
+                        ret = hermes_disable_port(hw, 0);
                 } else {
                         priv->tkip_cm_active = 0;
-                        ret = hermes_disable_port(hw, 0);
+                        ret = hermes_enable_port(hw, 0);
                 }
                 break;
 
diff --git a/include/linux/average.h b/include/linux/average.h
index 7706e40f95fa..c6028fd742c1 100644
--- a/include/linux/average.h
+++ b/include/linux/average.h
@@ -1,8 +1,6 @@
 #ifndef _LINUX_AVERAGE_H
 #define _LINUX_AVERAGE_H
 
-#include <linux/kernel.h>
-
 /* Exponentially weighted moving average (EWMA) */
 
 /* For more documentation see lib/average.c */
@@ -26,7 +24,7 @@ extern struct ewma *ewma_add(struct ewma *avg, unsigned long val);
  */
 static inline unsigned long ewma_read(const struct ewma *avg)
 {
-        return DIV_ROUND_CLOSEST(avg->internal, avg->factor);
+        return avg->internal >> avg->factor;
 }
 
 #endif /* _LINUX_AVERAGE_H */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index ed5a03cbe184..351c0ab4e284 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1223,6 +1223,9 @@ enum ieee80211_eid {
         WLAN_EID_BSS_AC_ACCESS_DELAY = 68,
         WLAN_EID_RRM_ENABLED_CAPABILITIES = 70,
         WLAN_EID_MULTIPLE_BSSID = 71,
+        WLAN_EID_BSS_COEX_2040 = 72,
+        WLAN_EID_OVERLAP_BSS_SCAN_PARAM = 74,
+        WLAN_EID_EXT_CAPABILITY = 127,
 
         WLAN_EID_MOBILITY_DOMAIN = 54,
         WLAN_EID_FAST_BSS_TRANSITION = 55,
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 5cfa579df476..380421253d16 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -394,6 +394,11 @@
  *
  * @NL80211_CMD_SET_WDS_PEER: Set the MAC address of the peer on a WDS interface.
  *
+ * @NL80211_CMD_JOIN_MESH: Join a mesh. The mesh ID must be given, and initial
+ *      mesh config parameters may be given.
+ * @NL80211_CMD_LEAVE_MESH: Leave the mesh network -- no special arguments, the
+ *      network is determined by the network interface.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -500,6 +505,9 @@ enum nl80211_commands {
 
         NL80211_CMD_FRAME_WAIT_CANCEL,
 
+        NL80211_CMD_JOIN_MESH,
+        NL80211_CMD_LEAVE_MESH,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -841,6 +849,8 @@ enum nl80211_commands {
  *      flag isn't set, the frame will be rejected. This is also used as an
  *      nl80211 capability flag.
  *
+ * @NL80211_ATTR_BSS_HTOPMODE: HT operation mode (u16)
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -1017,6 +1027,8 @@ enum nl80211_attrs {
 
         NL80211_ATTR_OFFCHANNEL_TX_OK,
 
+        NL80211_ATTR_BSS_HT_OPMODE,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -1183,6 +1195,7 @@ enum nl80211_rate_info {
  *      station)
  * @NL80211_STA_INFO_TX_RETRIES: total retries (u32, to this station)
  * @NL80211_STA_INFO_TX_FAILED: total failed packets (u32, to this station)
+ * @NL80211_STA_INFO_SIGNAL_AVG: signal strength average (u8, dBm)
  */
 enum nl80211_sta_info {
         __NL80211_STA_INFO_INVALID,
@@ -1198,6 +1211,7 @@ enum nl80211_sta_info {
         NL80211_STA_INFO_TX_PACKETS,
         NL80211_STA_INFO_TX_RETRIES,
         NL80211_STA_INFO_TX_FAILED,
+        NL80211_STA_INFO_SIGNAL_AVG,
 
         /* keep last */
         __NL80211_STA_INFO_AFTER_LAST,
@@ -1547,6 +1561,9 @@ enum nl80211_mntr_flags {
  * @NL80211_MESHCONF_TTL: specifies the value of TTL field set at a source mesh
  * point.
  *
+ * @NL80211_MESHCONF_ELEMENT_TTL: specifies the value of TTL field set at a
+ * source mesh point for path selection elements.
+ *
  * @NL80211_MESHCONF_AUTO_OPEN_PLINKS: whether we should automatically
  * open peer links when we detect compatible mesh peers.
  *
@@ -1593,6 +1610,7 @@ enum nl80211_meshconf_params {
         NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
         NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
         NL80211_MESHCONF_HWMP_ROOTMODE,
+        NL80211_MESHCONF_ELEMENT_TTL,
 
         /* keep last */
         __NL80211_MESHCONF_ATTR_AFTER_LAST,
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 6b2af7aeddd3..0d5979924be3 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -258,13 +258,9 @@ struct ieee80211_supported_band {
 
 /**
  * struct vif_params - describes virtual interface parameters
- * @mesh_id: mesh ID to use
- * @mesh_id_len: length of the mesh ID
  * @use_4addr: use 4-address frames
  */
 struct vif_params {
-       u8 *mesh_id;
-       int mesh_id_len;
        int use_4addr;
 };
 
@@ -424,6 +420,7 @@ struct station_parameters {
  * @STATION_INFO_TX_RETRIES: @tx_retries filled
  * @STATION_INFO_TX_FAILED: @tx_failed filled
  * @STATION_INFO_RX_DROP_MISC: @rx_dropped_misc filled
+ * @STATION_INFO_SIGNAL_AVG: @signal_avg filled
  */
 enum station_info_flags {
         STATION_INFO_INACTIVE_TIME      = 1<<0,
@@ -439,6 +436,7 @@ enum station_info_flags {
         STATION_INFO_TX_RETRIES         = 1<<10,
         STATION_INFO_TX_FAILED          = 1<<11,
         STATION_INFO_RX_DROP_MISC       = 1<<12,
+        STATION_INFO_SIGNAL_AVG         = 1<<13,
 };
 
 /**
@@ -485,6 +483,7 @@ struct rate_info {
  * @plid: mesh peer link id
  * @plink_state: mesh peer link state
  * @signal: signal strength of last received packet in dBm
+ * @signal_avg: signal strength average in dBm
  * @txrate: current unicast bitrate to this station
  * @rx_packets: packets received from this station
  * @tx_packets: packets transmitted to this station
@@ -505,6 +504,7 @@ struct station_info {
         u16 plid;
         u8 plink_state;
         s8 signal;
+        s8 signal_avg;
         struct rate_info txrate;
         u32 rx_packets;
         u32 tx_packets;
@@ -605,6 +605,8 @@ struct mpath_info {
  *      (or NULL for no change)
  * @basic_rates_len: number of basic rates
  * @ap_isolate: do not forward packets between connected stations
+ * @ht_opmode: HT Operation mode
+ *      (u16 = opmode, -1 = do not change)
  */
 struct bss_parameters {
         int use_cts_prot;
@@ -613,8 +615,14 @@ struct bss_parameters {
         u8 *basic_rates;
         u8 basic_rates_len;
         int ap_isolate;
+        int ht_opmode;
 };
 
+/*
+ * struct mesh_config - 802.11s mesh configuration
+ *
+ * These parameters can be changed while the mesh is active.
+ */
 struct mesh_config {
         /* Timeouts in ms */
         /* Mesh plink management parameters */
@@ -624,6 +632,8 @@ struct mesh_config {
         u16 dot11MeshMaxPeerLinks;
         u8  dot11MeshMaxRetries;
         u8  dot11MeshTTL;
+        /* ttl used in path selection information elements */
+        u8  element_ttl;
         bool auto_open_plinks;
         /* HWMP parameters */
         u8  dot11MeshHWMPmaxPREQretries;
@@ -636,6 +646,18 @@ struct mesh_config {
 };
 
 /**
+ * struct mesh_setup - 802.11s mesh setup configuration
+ * @mesh_id: the mesh ID
+ * @mesh_id_len: length of the mesh ID, at least 1 and at most 32 bytes
+ *
+ * These parameters are fixed when the mesh is created.
+ */
+struct mesh_setup {
+        const u8 *mesh_id;
+        u8 mesh_id_len;
+};
+
+/**
  * struct ieee80211_txq_params - TX queue parameters
  * @queue: TX queue identifier (NL80211_TXQ_Q_*)
  * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled
@@ -1031,7 +1053,8 @@ struct cfg80211_pmksa {
  *
  * @add_virtual_intf: create a new virtual interface with the given name,
  *      must set the struct wireless_dev's iftype. Beware: You must create
- *      the new netdev in the wiphy's network namespace!
+ *      the new netdev in the wiphy's network namespace! Returns the netdev,
+ *      or an ERR_PTR.
  *
  * @del_virtual_intf: remove the virtual interface determined by ifindex.
  *
@@ -1075,7 +1098,7 @@ struct cfg80211_pmksa {
  *
  * @get_mesh_params: Put the current mesh parameters into *params
  *
- * @set_mesh_params: Set mesh parameters.
+ * @update_mesh_params: Update mesh parameters on a running mesh.
  *      The mask is a bitfield which tells us which parameters to
  *      set, and which to leave alone.
  *
@@ -1166,9 +1189,11 @@ struct cfg80211_ops {
         int     (*suspend)(struct wiphy *wiphy);
         int     (*resume)(struct wiphy *wiphy);
 
-        int     (*add_virtual_intf)(struct wiphy *wiphy, char *name,
-                                    enum nl80211_iftype type, u32 *flags,
-                                    struct vif_params *params);
+        struct net_device * (*add_virtual_intf)(struct wiphy *wiphy,
+                                                char *name,
+                                                enum nl80211_iftype type,
+                                                u32 *flags,
+                                                struct vif_params *params);
         int     (*del_virtual_intf)(struct wiphy *wiphy, struct net_device *dev);
         int     (*change_virtual_intf)(struct wiphy *wiphy,
                                        struct net_device *dev,
@@ -1224,9 +1249,14 @@ struct cfg80211_ops {
         int     (*get_mesh_params)(struct wiphy *wiphy,
                                 struct net_device *dev,
                                 struct mesh_config *conf);
-        int     (*set_mesh_params)(struct wiphy *wiphy,
-                                struct net_device *dev,
-                                const struct mesh_config *nconf, u32 mask);
+        int     (*update_mesh_params)(struct wiphy *wiphy,
+                                      struct net_device *dev, u32 mask,
+                                      const struct mesh_config *nconf);
+        int     (*join_mesh)(struct wiphy *wiphy, struct net_device *dev,
+                             const struct mesh_config *conf,
+                             const struct mesh_setup *setup);
+        int     (*leave_mesh)(struct wiphy *wiphy, struct net_device *dev);
+
         int     (*change_bss)(struct wiphy *wiphy, struct net_device *dev,
                               struct bss_parameters *params);
 
@@ -1642,6 +1672,8 @@ struct cfg80211_cached_keys;
  * @bssid: (private) Used by the internal configuration code
  * @ssid: (private) Used by the internal configuration code
  * @ssid_len: (private) Used by the internal configuration code
+ * @mesh_id_len: (private) Used by the internal configuration code
+ * @mesh_id_up_len: (private) Used by the internal configuration code
  * @wext: (private) Used by the internal wireless extensions compat code
  * @use_4addr: indicates 4addr mode is used on this interface, must be
  *      set by driver (if supported) on add_interface BEFORE registering the
@@ -1671,7 +1703,7 @@ struct wireless_dev {
 
         /* currently used for IBSS and SME - might be rearranged later */
         u8 ssid[IEEE80211_MAX_SSID_LEN];
-        u8 ssid_len;
+        u8 ssid_len, mesh_id_len, mesh_id_up_len;
         enum {
                 CFG80211_SME_IDLE,
                 CFG80211_SME_CONNECTING,
diff --git a/lib/average.c b/lib/average.c
index f1d1b4660c42..5576c2841496 100644
--- a/lib/average.c
+++ b/lib/average.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/average.h>
 #include <linux/bug.h>
+#include <linux/log2.h>
 
 /**
  * DOC: Exponentially Weighted Moving Average (EWMA)
@@ -24,18 +25,21 @@
  * ewma_init() - Initialize EWMA parameters
  * @avg: Average structure
  * @factor: Factor to use for the scaled up internal value. The maximum value
- *      of averages can be ULONG_MAX/(factor*weight).
+ *      of averages can be ULONG_MAX/(factor*weight). For performance reasons
+ *      factor has to be a power of 2.
  * @weight: Exponential weight, or decay rate. This defines how fast the
- *      influence of older values decreases. Has to be bigger than 1.
+ *      influence of older values decreases. For performance reasons weight has
+ *      to be a power of 2.
  *
  * Initialize the EWMA parameters for a given struct ewma @avg.
  */
 void ewma_init(struct ewma *avg, unsigned long factor, unsigned long weight)
 {
-        WARN_ON(weight <= 1 || factor == 0);
+        WARN_ON(!is_power_of_2(weight) || !is_power_of_2(factor));
+
+        avg->weight = ilog2(weight);
+        avg->factor = ilog2(factor);
         avg->internal = 0;
-        avg->weight = weight;
-        avg->factor = factor;
 }
 EXPORT_SYMBOL(ewma_init);
 
@@ -49,9 +53,9 @@ EXPORT_SYMBOL(ewma_init);
 struct ewma *ewma_add(struct ewma *avg, unsigned long val)
 {
         avg->internal = avg->internal  ?
-                (((avg->internal * (avg->weight - 1)) +
-                        (val * avg->factor)) / avg->weight) :
-                (val * avg->factor);
+                (((avg->internal << avg->weight) - avg->internal) +
+                        (val << avg->factor)) >> avg->weight :
+                (val << avg->factor);
         return avg;
 }
 EXPORT_SYMBOL(ewma_add);
diff --git a/net/mac80211/Kconfig b/net/mac80211/Kconfig
index 4d6f8653ec88..798d9b9462e2 100644
--- a/net/mac80211/Kconfig
+++ b/net/mac80211/Kconfig
@@ -6,6 +6,7 @@ config MAC80211
         select CRYPTO_ARC4
         select CRYPTO_AES
         select CRC32
+        select AVERAGE
         ---help---
           This option enables the hardware independent IEEE 802.11
           networking stack.
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index db134b500caa..c30b8b72eedb 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -19,9 +19,10 @@
 #include "rate.h"
 #include "mesh.h"
 
-static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
-                               enum nl80211_iftype type, u32 *flags,
-                               struct vif_params *params)
+static struct net_device *ieee80211_add_iface(struct wiphy *wiphy, char *name,
+                                              enum nl80211_iftype type,
+                                              u32 *flags,
+                                              struct vif_params *params)
 {
         struct ieee80211_local *local = wiphy_priv(wiphy);
         struct net_device *dev;
@@ -29,12 +30,15 @@ static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
         int err;
 
         err = ieee80211_if_add(local, name, &dev, type, params);
-        if (err || type != NL80211_IFTYPE_MONITOR || !flags)
-                return err;
+        if (err)
+                return ERR_PTR(err);
 
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-        sdata->u.mntr_flags = *flags;
-        return 0;
+        if (type == NL80211_IFTYPE_MONITOR && flags) {
+                sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+                sdata->u.mntr_flags = *flags;
+        }
+
+        return dev;
 }
 
 static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev)
@@ -56,11 +60,6 @@ static int ieee80211_change_iface(struct wiphy *wiphy,
         if (ret)
                 return ret;
 
-        if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)
-                ieee80211_sdata_set_mesh_id(sdata,
-                                            params->mesh_id_len,
-                                            params->mesh_id);
-
         if (type == NL80211_IFTYPE_AP_VLAN &&
             params && params->use_4addr == 0)
                 rcu_assign_pointer(sdata->u.vlan.sta, NULL);
@@ -343,8 +342,9 @@ static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
 
         if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
             (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
-                sinfo->filled |= STATION_INFO_SIGNAL;
+                sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
                 sinfo->signal = (s8)sta->last_signal;
+                sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
         }
 
         sinfo->txrate.flags = 0;
@@ -999,9 +999,9 @@ static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
         return (mask >> (parm-1)) & 0x1;
 }
 
-static int ieee80211_set_mesh_params(struct wiphy *wiphy,
-                                struct net_device *dev,
-                                const struct mesh_config *nconf, u32 mask)
+static int ieee80211_update_mesh_params(struct wiphy *wiphy,
+                                        struct net_device *dev, u32 mask,
+                                        const struct mesh_config *nconf)
 {
         struct mesh_config *conf;
         struct ieee80211_sub_if_data *sdata;
@@ -1024,6 +1024,8 @@ static int ieee80211_set_mesh_params(struct wiphy *wiphy,
                 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
         if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
                 conf->dot11MeshTTL = nconf->dot11MeshTTL;
+        if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
+                conf->dot11MeshTTL = nconf->element_ttl;
         if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
                 conf->auto_open_plinks = nconf->auto_open_plinks;
         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
@@ -1050,6 +1052,30 @@ static int ieee80211_set_mesh_params(struct wiphy *wiphy,
         return 0;
 }
 
+static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
+                               const struct mesh_config *conf,
+                               const struct mesh_setup *setup)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
+
+        memcpy(&sdata->u.mesh.mshcfg, conf, sizeof(struct mesh_config));
+        ifmsh->mesh_id_len = setup->mesh_id_len;
+        memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
+
+        ieee80211_start_mesh(sdata);
+
+        return 0;
+}
+
+static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        ieee80211_stop_mesh(sdata);
+
+        return 0;
+}
 #endif
 
 static int ieee80211_change_bss(struct wiphy *wiphy,
@@ -1108,6 +1134,12 @@ static int ieee80211_change_bss(struct wiphy *wiphy,
                         sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
         }
 
+        if (params->ht_opmode >= 0) {
+                sdata->vif.bss_conf.ht_operation_mode =
+                        (u16) params->ht_opmode;
+                changed |= BSS_CHANGED_HT;
+        }
+
         ieee80211_bss_info_change_notify(sdata, changed);
 
         return 0;
@@ -1754,8 +1786,10 @@ struct cfg80211_ops mac80211_config_ops = {
         .change_mpath = ieee80211_change_mpath,
         .get_mpath = ieee80211_get_mpath,
         .dump_mpath = ieee80211_dump_mpath,
-        .set_mesh_params = ieee80211_set_mesh_params,
+        .update_mesh_params = ieee80211_update_mesh_params,
         .get_mesh_params = ieee80211_get_mesh_params,
+        .join_mesh = ieee80211_join_mesh,
+        .leave_mesh = ieee80211_leave_mesh,
 #endif
         .change_bss = ieee80211_change_bss,
         .set_txq_params = ieee80211_set_txq_params,
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index cbdf36d7841c..2dabdf7680d0 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -251,6 +251,7 @@ IEEE80211_IF_FILE(dot11MeshConfirmTimeout,
 IEEE80211_IF_FILE(dot11MeshHoldingTimeout,
                 u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC);
 IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC);
+IEEE80211_IF_FILE(element_ttl, u.mesh.mshcfg.element_ttl, DEC);
 IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC);
 IEEE80211_IF_FILE(dot11MeshMaxPeerLinks,
                 u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC);
@@ -355,6 +356,7 @@ static void add_mesh_config(struct ieee80211_sub_if_data *sdata)
         MESHPARAMS_ADD(dot11MeshConfirmTimeout);
         MESHPARAMS_ADD(dot11MeshHoldingTimeout);
         MESHPARAMS_ADD(dot11MeshTTL);
+        MESHPARAMS_ADD(element_ttl);
         MESHPARAMS_ADD(auto_open_plinks);
         MESHPARAMS_ADD(dot11MeshMaxPeerLinks);
         MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout);
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 66b0b52b828d..72499fe5fc36 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -357,6 +357,7 @@ struct ieee80211_if_managed {
         unsigned long beacon_timeout;
         unsigned long probe_timeout;
         int probe_send_count;
+        bool nullfunc_failed;
 
         struct mutex mtx;
         struct cfg80211_bss *associated;
@@ -608,19 +609,6 @@ struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
         return container_of(p, struct ieee80211_sub_if_data, vif);
 }
 
-static inline void
-ieee80211_sdata_set_mesh_id(struct ieee80211_sub_if_data *sdata,
-                            u8 mesh_id_len, u8 *mesh_id)
-{
-#ifdef CONFIG_MAC80211_MESH
-        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
-        ifmsh->mesh_id_len = mesh_id_len;
-        memcpy(ifmsh->mesh_id, mesh_id, mesh_id_len);
-#else
-        WARN_ON(1);
-#endif
-}
-
 enum sdata_queue_type {
         IEEE80211_SDATA_QUEUE_TYPE_FRAME        = 0,
         IEEE80211_SDATA_QUEUE_AGG_START         = 1,
@@ -1271,7 +1259,7 @@ void ieee80211_send_nullfunc(struct ieee80211_local *local,
 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
                              struct ieee80211_hdr *hdr);
 void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
-                             struct ieee80211_hdr *hdr);
+                             struct ieee80211_hdr *hdr, bool ack);
 void ieee80211_beacon_connection_loss_work(struct work_struct *work);
 
 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 7aa85591dbe7..f0f11bb794af 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -197,11 +197,6 @@ static int ieee80211_do_open(struct net_device *dev, bool coming_up)
                 sdata->bss = &sdata->u.ap;
                 break;
         case NL80211_IFTYPE_MESH_POINT:
-                if (!ieee80211_vif_is_mesh(&sdata->vif))
-                        break;
-                /* mesh ifaces must set allmulti to forward mcast traffic */
-                atomic_inc(&local->iff_allmultis);
-                break;
         case NL80211_IFTYPE_STATION:
         case NL80211_IFTYPE_MONITOR:
         case NL80211_IFTYPE_ADHOC:
@@ -273,12 +268,7 @@ static int ieee80211_do_open(struct net_device *dev, bool coming_up)
                                 goto err_stop;
                 }
 
-                if (ieee80211_vif_is_mesh(&sdata->vif)) {
-                        local->fif_other_bss++;
-                        ieee80211_configure_filter(local);
-
-                        ieee80211_start_mesh(sdata);
-                } else if (sdata->vif.type == NL80211_IFTYPE_AP) {
+                if (sdata->vif.type == NL80211_IFTYPE_AP) {
                         local->fif_pspoll++;
                         local->fif_probe_req++;
 
@@ -503,18 +493,6 @@ static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
                 ieee80211_adjust_monitor_flags(sdata, -1);
                 ieee80211_configure_filter(local);
                 break;
-        case NL80211_IFTYPE_MESH_POINT:
-                if (ieee80211_vif_is_mesh(&sdata->vif)) {
-                        /* other_bss and allmulti are always set on mesh
-                         * ifaces */
-                        local->fif_other_bss--;
-                        atomic_dec(&local->iff_allmultis);
-
-                        ieee80211_configure_filter(local);
-
-                        ieee80211_stop_mesh(sdata);
-                }
-                /* fall through */
         default:
                 flush_work(&sdata->work);
                 /*
@@ -1204,12 +1182,6 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
         if (ret)
                 goto fail;
 
-        if (ieee80211_vif_is_mesh(&sdata->vif) &&
-            params && params->mesh_id_len)
-                ieee80211_sdata_set_mesh_id(sdata,
-                                            params->mesh_id_len,
-                                            params->mesh_id);
-
         mutex_lock(&local->iflist_mtx);
         list_add_tail_rcu(&sdata->list, &local->interfaces);
         mutex_unlock(&local->iflist_mtx);
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index 107a0cbe52ac..973fee9f7d69 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -245,9 +245,12 @@ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
                                 sdata->vif.bss_conf.enable_beacon =
                                         !!sdata->u.ibss.presp;
                                 break;
+#ifdef CONFIG_MAC80211_MESH
                         case NL80211_IFTYPE_MESH_POINT:
-                                sdata->vif.bss_conf.enable_beacon = true;
+                                sdata->vif.bss_conf.enable_beacon =
+                                        !!sdata->u.mesh.mesh_id_len;
                                 break;
+#endif
                         default:
                                 /* not reached */
                                 WARN_ON(1);
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index c8a4f19ed13b..63e1188d5062 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -513,6 +513,11 @@ void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
         struct ieee80211_local *local = sdata->local;
 
+        local->fif_other_bss++;
+        /* mesh ifaces must set allmulti to forward mcast traffic */
+        atomic_inc(&local->iff_allmultis);
+        ieee80211_configure_filter(local);
+
         set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
         ieee80211_mesh_root_setup(ifmsh);
         ieee80211_queue_work(&local->hw, &sdata->work);
@@ -524,6 +529,13 @@ void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
 
 void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
 {
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
+
+        ifmsh->mesh_id_len = 0;
+        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
+        sta_info_flush(local, NULL);
+
         del_timer_sync(&sdata->u.mesh.housekeeping_timer);
         del_timer_sync(&sdata->u.mesh.mesh_path_root_timer);
         /*
@@ -534,6 +546,10 @@ void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
          * it no longer is.
          */
         cancel_work_sync(&sdata->work);
+
+        local->fif_other_bss--;
+        atomic_dec(&local->iff_allmultis);
+        ieee80211_configure_filter(local);
 }
 
 static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
@@ -663,26 +679,6 @@ void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
                     ieee80211_mesh_housekeeping_timer,
                     (unsigned long) sdata);
 
-        ifmsh->mshcfg.dot11MeshRetryTimeout = MESH_RET_T;
-        ifmsh->mshcfg.dot11MeshConfirmTimeout = MESH_CONF_T;
-        ifmsh->mshcfg.dot11MeshHoldingTimeout = MESH_HOLD_T;
-        ifmsh->mshcfg.dot11MeshMaxRetries = MESH_MAX_RETR;
-        ifmsh->mshcfg.dot11MeshTTL = MESH_TTL;
-        ifmsh->mshcfg.auto_open_plinks = true;
-        ifmsh->mshcfg.dot11MeshMaxPeerLinks =
-                MESH_MAX_ESTAB_PLINKS;
-        ifmsh->mshcfg.dot11MeshHWMPactivePathTimeout =
-                MESH_PATH_TIMEOUT;
-        ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval =
-                MESH_PREQ_MIN_INT;
-        ifmsh->mshcfg.dot11MeshHWMPnetDiameterTraversalTime =
-                MESH_DIAM_TRAVERSAL_TIME;
-        ifmsh->mshcfg.dot11MeshHWMPmaxPREQretries =
-                MESH_MAX_PREQ_RETRIES;
-        ifmsh->mshcfg.path_refresh_time =
-                MESH_PATH_REFRESH_TIME;
-        ifmsh->mshcfg.min_discovery_timeout =
-                MESH_MIN_DISCOVERY_TIMEOUT;
         ifmsh->accepting_plinks = true;
         ifmsh->preq_id = 0;
         ifmsh->sn = 0;
diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index 58e741128968..039d7fa0af74 100644
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -175,33 +175,10 @@ struct mesh_rmc {
  */
 #define MESH_CFG_CMP_LEN        (IEEE80211_MESH_CONFIG_LEN - 2)
 
-/* Default values, timeouts in ms */
-#define MESH_TTL                31
-#define MESH_MAX_RETR           3
-#define MESH_RET_T              100
-#define MESH_CONF_T             100
-#define MESH_HOLD_T             100
-
-#define MESH_PATH_TIMEOUT       5000
-/* Minimum interval between two consecutive PREQs originated by the same
- * interface
- */
-#define MESH_PREQ_MIN_INT       10
-#define MESH_DIAM_TRAVERSAL_TIME 50
-/* A path will be refreshed if it is used PATH_REFRESH_TIME milliseconds before
- * timing out.  This way it will remain ACTIVE and no data frames will be
- * unnecesarily held in the pending queue.
- */
-#define MESH_PATH_REFRESH_TIME                  1000
-#define MESH_MIN_DISCOVERY_TIMEOUT (2 * MESH_DIAM_TRAVERSAL_TIME)
 #define MESH_DEFAULT_BEACON_INTERVAL            1000    /* in 1024 us units */
 
-#define MESH_MAX_PREQ_RETRIES 4
 #define MESH_PATH_EXPIRE (600 * HZ)
 
-/* Default maximum number of established plinks per interface */
-#define MESH_MAX_ESTAB_PLINKS   32
-
 /* Default maximum number of plinks per interface */
 #define MESH_MAX_PLINKS         256
 
diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c
index 829e08a657d0..5bf64d7112b3 100644
--- a/net/mac80211/mesh_hwmp.c
+++ b/net/mac80211/mesh_hwmp.c
@@ -232,7 +232,7 @@ int mesh_path_error_tx(u8 ttl, u8 *target, __le32 target_sn,
         *pos++ = WLAN_EID_PERR;
         *pos++ = ie_len;
         /* ttl */
-        *pos++ = MESH_TTL;
+        *pos++ = ttl;
         /* number of destinations */
         *pos++ = 1;
         /*
@@ -522,7 +522,7 @@ static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
 
         if (reply) {
                 lifetime = PREQ_IE_LIFETIME(preq_elem);
-                ttl = ifmsh->mshcfg.dot11MeshTTL;
+                ttl = ifmsh->mshcfg.element_ttl;
                 if (ttl != 0) {
                         mhwmp_dbg("replying to the PREQ\n");
                         mesh_path_sel_frame_tx(MPATH_PREP, 0, target_addr,
@@ -877,7 +877,7 @@ void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata)
                 sdata->u.mesh.last_sn_update = jiffies;
         }
         lifetime = default_lifetime(sdata);
-        ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
+        ttl = sdata->u.mesh.mshcfg.element_ttl;
         if (ttl == 0) {
                 sdata->u.mesh.mshstats.dropped_frames_ttl++;
                 spin_unlock_bh(&mpath->state_lock);
@@ -1013,5 +1013,6 @@ mesh_path_tx_root_frame(struct ieee80211_sub_if_data *sdata)
         mesh_path_sel_frame_tx(MPATH_RANN, 0, sdata->vif.addr,
                                cpu_to_le32(++ifmsh->sn),
                                0, NULL, 0, broadcast_addr,
-                               0, MESH_TTL, 0, 0, 0, sdata);
+                               0, sdata->u.mesh.mshcfg.element_ttl,
+                               0, 0, 0, sdata);
 }
diff --git a/net/mac80211/mesh_pathtbl.c b/net/mac80211/mesh_pathtbl.c
index 349e466cf08b..8d65b47d9837 100644
--- a/net/mac80211/mesh_pathtbl.c
+++ b/net/mac80211/mesh_pathtbl.c
@@ -467,8 +467,8 @@ void mesh_plink_broken(struct sta_info *sta)
                         mpath->flags &= ~MESH_PATH_ACTIVE;
                         ++mpath->sn;
                         spin_unlock_bh(&mpath->state_lock);
-                        mesh_path_error_tx(MESH_TTL, mpath->dst,
-                                        cpu_to_le32(mpath->sn),
+                        mesh_path_error_tx(sdata->u.mesh.mshcfg.element_ttl,
+                                        mpath->dst, cpu_to_le32(mpath->sn),
                                         cpu_to_le16(PERR_RCODE_DEST_UNREACH),
                                         bcast, sdata);
                 } else
@@ -614,7 +614,8 @@ void mesh_path_discard_frame(struct sk_buff *skb,
                 mpath = mesh_path_lookup(da, sdata);
                 if (mpath)
                         sn = ++mpath->sn;
-                mesh_path_error_tx(MESH_TTL, skb->data, cpu_to_le32(sn),
+                mesh_path_error_tx(sdata->u.mesh.mshcfg.element_ttl, skb->data,
+                                   cpu_to_le32(sn),
                                    cpu_to_le16(PERR_RCODE_NO_ROUTE), ra, sdata);
         }
 
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 794807914940..45fbb9e33746 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -625,11 +625,12 @@ void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
                         /*
                          * Go to full PSM if the user configures a very low
                          * latency requirement.
-                         * The 2 second value is there for compatibility until
-                         * the PM_QOS_NETWORK_LATENCY is configured with real
-                         * values.
+                         * The 2000 second value is there for compatibility
+                         * until the PM_QOS_NETWORK_LATENCY is configured
+                         * with real values.
                          */
-                        if (latency > 1900000000 && latency != 2000000000)
+                        if (latency > (1900 * USEC_PER_MSEC) &&
+                            latency != (2000 * USEC_PER_SEC))
                                 timeout = 0;
                         else
                                 timeout = 100;
@@ -1065,17 +1066,20 @@ static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
 }
 
 void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
-                             struct ieee80211_hdr *hdr)
+                             struct ieee80211_hdr *hdr, bool ack)
 {
-        if (!ieee80211_is_data(hdr->frame_control) &&
-            !ieee80211_is_nullfunc(hdr->frame_control))
+        if (!ieee80211_is_data(hdr->frame_control))
             return;
 
-        ieee80211_sta_reset_conn_monitor(sdata);
+        if (ack)
+                ieee80211_sta_reset_conn_monitor(sdata);
 
         if (ieee80211_is_nullfunc(hdr->frame_control) &&
             sdata->u.mgd.probe_send_count > 0) {
-                sdata->u.mgd.probe_send_count = 0;
+                if (ack)
+                        sdata->u.mgd.probe_send_count = 0;
+                else
+                        sdata->u.mgd.nullfunc_failed = true;
                 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
         }
 }
@@ -1102,9 +1106,10 @@ static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
          * anymore. The timeout will be reset if the frame is ACKed by
          * the AP.
          */
-        if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
+        if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
+                ifmgd->nullfunc_failed = false;
                 ieee80211_send_nullfunc(sdata->local, sdata, 0);
-        else {
+        } else {
                 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
                 ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid[1], NULL, 0);
         }
@@ -1913,6 +1918,31 @@ static void ieee80211_sta_timer(unsigned long data)
         ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
+static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
+                                          u8 *bssid)
+{
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
+                          IEEE80211_STA_BEACON_POLL);
+
+        ieee80211_set_disassoc(sdata, true, true);
+        mutex_unlock(&ifmgd->mtx);
+        mutex_lock(&local->mtx);
+        ieee80211_recalc_idle(local);
+        mutex_unlock(&local->mtx);
+        /*
+         * must be outside lock due to cfg80211,
+         * but that's not a problem.
+         */
+        ieee80211_send_deauth_disassoc(sdata, bssid,
+                        IEEE80211_STYPE_DEAUTH,
+                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
+                        NULL, true);
+        mutex_lock(&ifmgd->mtx);
+}
+
 void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_local *local = sdata->local;
@@ -1937,11 +1967,37 @@ void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
                 /* ACK received for nullfunc probing frame */
                 if (!ifmgd->probe_send_count)
                         ieee80211_reset_ap_probe(sdata);
-
-                else if (time_is_after_jiffies(ifmgd->probe_timeout))
+                else if (ifmgd->nullfunc_failed) {
+                        if (ifmgd->probe_send_count < max_tries) {
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+                                wiphy_debug(local->hw.wiphy,
+                                            "%s: No ack for nullfunc frame to"
+                                            " AP %pM, try %d\n",
+                                            sdata->name, bssid,
+                                            ifmgd->probe_send_count);
+#endif
+                                ieee80211_mgd_probe_ap_send(sdata);
+                        } else {
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+                                wiphy_debug(local->hw.wiphy,
+                                            "%s: No ack for nullfunc frame to"
+                                            " AP %pM, disconnecting.\n",
+                                            sdata->name, bssid);
+#endif
+                                ieee80211_sta_connection_lost(sdata, bssid);
+                        }
+                } else if (time_is_after_jiffies(ifmgd->probe_timeout))
                         run_again(ifmgd, ifmgd->probe_timeout);
-
-                else if (ifmgd->probe_send_count < max_tries) {
+                else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+                        wiphy_debug(local->hw.wiphy,
+                                    "%s: Failed to send nullfunc to AP %pM"
+                                    " after %dms, disconnecting.\n",
+                                    sdata->name,
+                                    bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
+#endif
+                        ieee80211_sta_connection_lost(sdata, bssid);
+                } else if (ifmgd->probe_send_count < max_tries) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
                         wiphy_debug(local->hw.wiphy,
                                     "%s: No probe response from AP %pM"
@@ -1956,27 +2012,13 @@ void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
                          * We actually lost the connection ... or did we?
                          * Let's make sure!
                          */
-                        ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
-                                          IEEE80211_STA_BEACON_POLL);
                         wiphy_debug(local->hw.wiphy,
                                     "%s: No probe response from AP %pM"
                                     " after %dms, disconnecting.\n",
                                     sdata->name,
                                     bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
-                        ieee80211_set_disassoc(sdata, true, true);
-                        mutex_unlock(&ifmgd->mtx);
-                        mutex_lock(&local->mtx);
-                        ieee80211_recalc_idle(local);
-                        mutex_unlock(&local->mtx);
-                        /*
-                         * must be outside lock due to cfg80211,
-                         * but that's not a problem.
-                         */
-                        ieee80211_send_deauth_disassoc(sdata, bssid,
-                                        IEEE80211_STYPE_DEAUTH,
-                                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
-                                        NULL, true);
-                        mutex_lock(&ifmgd->mtx);
+
+                        ieee80211_sta_connection_lost(sdata, bssid);
                 }
         }
 
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 6289525c0998..2fe8f5f86499 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -1163,6 +1163,7 @@ ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
         sta->rx_fragments++;
         sta->rx_bytes += rx->skb->len;
         sta->last_signal = status->signal;
+        ewma_add(&sta->avg_signal, -status->signal);
 
         /*
          * Change STA power saving mode only at the end of a frame
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index eff58571fd7e..c426504ed1cf 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -244,6 +244,8 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
         sta->local = local;
         sta->sdata = sdata;
 
+        ewma_init(&sta->avg_signal, 1024, 8);
+
         if (sta_prepare_rate_control(local, sta, gfp)) {
                 kfree(sta);
                 return NULL;
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index 05f11302443b..fdca52cf88de 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -13,6 +13,7 @@
 #include <linux/types.h>
 #include <linux/if_ether.h>
 #include <linux/workqueue.h>
+#include <linux/average.h>
 #include "key.h"
 
 /**
@@ -223,6 +224,7 @@ enum plink_state {
  * @rx_fragments: number of received MPDUs
  * @rx_dropped: number of dropped MPDUs from this STA
  * @last_signal: signal of last received frame from this STA
+ * @avg_signal: moving average of signal of received frames from this STA
  * @last_seq_ctrl: last received seq/frag number from this STA (per RX queue)
  * @tx_filtered_count: number of frames the hardware filtered for this STA
  * @tx_retry_failed: number of frames that failed retry
@@ -291,6 +293,7 @@ struct sta_info {
         unsigned long rx_fragments;
         unsigned long rx_dropped;
         int last_signal;
+        struct ewma avg_signal;
         __le16 last_seq_ctrl[NUM_RX_DATA_QUEUES];
 
         /* Updated from TX status path only, no locking requirements */
diff --git a/net/mac80211/status.c b/net/mac80211/status.c
index 4958710a7d92..38a797217a91 100644
--- a/net/mac80211/status.c
+++ b/net/mac80211/status.c
@@ -155,10 +155,6 @@ static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
 
                 ieee80211_queue_work(&local->hw, &local->recalc_smps);
         }
-
-        if ((sdata->vif.type == NL80211_IFTYPE_STATION) &&
-            (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
-                ieee80211_sta_tx_notify(sdata, (void *) skb->data);
 }
 
 /*
@@ -186,6 +182,7 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
         int retry_count = -1, i;
         int rates_idx = -1;
         bool send_to_cooked;
+        bool acked;
 
         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
                 /* the HW cannot have attempted that rate */
@@ -211,8 +208,8 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
                 if (memcmp(hdr->addr2, sta->sdata->vif.addr, ETH_ALEN))
                         continue;
 
-                if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
-                    test_sta_flags(sta, WLAN_STA_PS_STA)) {
+                acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
+                if (!acked && test_sta_flags(sta, WLAN_STA_PS_STA)) {
                         /*
                          * The STA is in power save mode, so assume
                          * that this TX packet failed because of that.
@@ -244,7 +241,7 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
                         rcu_read_unlock();
                         return;
                 } else {
-                        if (!(info->flags & IEEE80211_TX_STAT_ACK))
+                        if (!acked)
                                 sta->tx_retry_failed++;
                         sta->tx_retry_count += retry_count;
                 }
@@ -253,10 +250,13 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
                 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
                         ieee80211s_update_metric(local, sta, skb);
 
-                if (!(info->flags & IEEE80211_TX_CTL_INJECTED) &&
-                    (info->flags & IEEE80211_TX_STAT_ACK))
+                if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
                         ieee80211_frame_acked(sta, skb);
 
+                if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
+                    (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
+                        ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data, acked);
+
                 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
                         if (info->flags & IEEE80211_TX_STAT_ACK) {
                                 if (sta->lost_packets)
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 2ba742656825..0ee56bb0ea7e 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -666,10 +666,11 @@ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
         if (unlikely(info->control.rates[0].idx < 0))
                 return TX_DROP;
 
-        if (txrc.reported_rate.idx < 0)
+        if (txrc.reported_rate.idx < 0) {
                 txrc.reported_rate = info->control.rates[0];
-
-        if (tx->sta)
+                if (tx->sta && ieee80211_is_data(hdr->frame_control))
+                        tx->sta->last_tx_rate = txrc.reported_rate;
+        } else if (tx->sta)
                 tx->sta->last_tx_rate = txrc.reported_rate;
 
         if (unlikely(!info->control.rates[0].count))
@@ -1745,15 +1746,13 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
         int nh_pos, h_pos;
         struct sta_info *sta = NULL;
         u32 sta_flags = 0;
+        struct sk_buff *tmp_skb;
 
         if (unlikely(skb->len < ETH_HLEN)) {
                 ret = NETDEV_TX_OK;
                 goto fail;
         }
 
-        nh_pos = skb_network_header(skb) - skb->data;
-        h_pos = skb_transport_header(skb) - skb->data;
-
         /* convert Ethernet header to proper 802.11 header (based on
          * operation mode) */
         ethertype = (skb->data[12] << 8) | skb->data[13];
@@ -1926,6 +1925,20 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
                 goto fail;
         }
 
+        /*
+         * If the skb is shared we need to obtain our own copy.
+         */
+        if (skb_shared(skb)) {
+                tmp_skb = skb;
+                skb = skb_copy(skb, GFP_ATOMIC);
+                kfree_skb(tmp_skb);
+
+                if (!skb) {
+                        ret = NETDEV_TX_OK;
+                        goto fail;
+                }
+        }
+
         hdr.frame_control = fc;
         hdr.duration_id = 0;
         hdr.seq_ctrl = 0;
@@ -1944,6 +1957,9 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
                 encaps_len = 0;
         }
 
+        nh_pos = skb_network_header(skb) - skb->data;
+        h_pos = skb_transport_header(skb) - skb->data;
+
         skb_pull(skb, skip_header_bytes);
         nh_pos -= skip_header_bytes;
         h_pos -= skip_header_bytes;
diff --git a/net/mac80211/work.c b/net/mac80211/work.c
index 2b5c3f267198..de43753076d2 100644
--- a/net/mac80211/work.c
+++ b/net/mac80211/work.c
@@ -458,8 +458,9 @@ ieee80211_direct_probe(struct ieee80211_work *wk)
                 return WORK_ACT_TIMEOUT;
         }
 
-        printk(KERN_DEBUG "%s: direct probe to %pM (try %d)\n",
-                        sdata->name, wk->filter_ta, wk->probe_auth.tries);
+        printk(KERN_DEBUG "%s: direct probe to %pM (try %d/%i)\n",
+               sdata->name, wk->filter_ta, wk->probe_auth.tries,
+               IEEE80211_AUTH_MAX_TRIES);
 
         /*
          * Direct probe is sent to broadcast address as some APs
diff --git a/net/wireless/Makefile b/net/wireless/Makefile
index e77e508126fa..55a28ab21db9 100644
--- a/net/wireless/Makefile
+++ b/net/wireless/Makefile
@@ -10,7 +10,7 @@ obj-$(CONFIG_WEXT_SPY) += wext-spy.o
 obj-$(CONFIG_WEXT_PRIV) += wext-priv.o
 
 cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o
-cfg80211-y += mlme.o ibss.o sme.o chan.o ethtool.o
+cfg80211-y += mlme.o ibss.o sme.o chan.o ethtool.o mesh.o
 cfg80211-$(CONFIG_CFG80211_DEBUGFS) += debugfs.o
 cfg80211-$(CONFIG_CFG80211_WEXT) += wext-compat.o wext-sme.o
 cfg80211-$(CONFIG_CFG80211_INTERNAL_REGDB) += regdb.o
diff --git a/net/wireless/core.c b/net/wireless/core.c
index 630bcf0a2f04..79772fcc37bc 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -332,6 +332,7 @@ struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
         WARN_ON(ops->add_station && !ops->del_station);
         WARN_ON(ops->add_mpath && !ops->del_mpath);
+        WARN_ON(ops->join_mesh && !ops->leave_mesh);
 
         alloc_size = sizeof(*rdev) + sizeof_priv;
 
@@ -752,6 +753,9 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                         cfg80211_mlme_down(rdev, dev);
                         wdev_unlock(wdev);
                         break;
+                case NL80211_IFTYPE_MESH_POINT:
+                        cfg80211_leave_mesh(rdev, dev);
+                        break;
                 default:
                         break;
                 }
@@ -775,20 +779,27 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                 }
                 cfg80211_lock_rdev(rdev);
                 mutex_lock(&rdev->devlist_mtx);
-#ifdef CONFIG_CFG80211_WEXT
                 wdev_lock(wdev);
                 switch (wdev->iftype) {
+#ifdef CONFIG_CFG80211_WEXT
                 case NL80211_IFTYPE_ADHOC:
                         cfg80211_ibss_wext_join(rdev, wdev);
                         break;
                 case NL80211_IFTYPE_STATION:
                         cfg80211_mgd_wext_connect(rdev, wdev);
                         break;
+#endif
+                case NL80211_IFTYPE_MESH_POINT:
+                        /* backward compat code ... */
+                        if (wdev->mesh_id_up_len)
+                                __cfg80211_join_mesh(rdev, dev, wdev->ssid,
+                                                     wdev->mesh_id_up_len,
+                                                     &default_mesh_config);
+                        break;
                 default:
                         break;
                 }
                 wdev_unlock(wdev);
-#endif
                 rdev->opencount++;
                 mutex_unlock(&rdev->devlist_mtx);
                 cfg80211_unlock_rdev(rdev);
diff --git a/net/wireless/core.h b/net/wireless/core.h
index ee80ad8dc655..743203bb61ac 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -285,6 +285,19 @@ void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid);
 int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
                             struct wireless_dev *wdev);
 
+/* mesh */
+extern const struct mesh_config default_mesh_config;
+int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                         struct net_device *dev,
+                         const u8 *mesh_id, u8 mesh_id_len,
+                         const struct mesh_config *conf);
+int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       const u8 *mesh_id, u8 mesh_id_len,
+                       const struct mesh_config *conf);
+int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev);
+
 /* MLME */
 int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
                          struct net_device *dev,
diff --git a/net/wireless/mesh.c b/net/wireless/mesh.c
new file mode 100644
index 000000000000..e0b9747fe50a
--- /dev/null
+++ b/net/wireless/mesh.c
@@ -0,0 +1,140 @@
+#include <linux/ieee80211.h>
+#include <net/cfg80211.h>
+#include "core.h"
+
+/* Default values, timeouts in ms */
+#define MESH_TTL                31
+#define MESH_DEFAULT_ELEMENT_TTL 31
+#define MESH_MAX_RETR           3
+#define MESH_RET_T              100
+#define MESH_CONF_T             100
+#define MESH_HOLD_T             100
+
+#define MESH_PATH_TIMEOUT       5000
+
+/*
+ * Minimum interval between two consecutive PREQs originated by the same
+ * interface
+ */
+#define MESH_PREQ_MIN_INT       10
+#define MESH_DIAM_TRAVERSAL_TIME 50
+
+/*
+ * A path will be refreshed if it is used PATH_REFRESH_TIME milliseconds
+ * before timing out.  This way it will remain ACTIVE and no data frames
+ * will be unnecessarily held in the pending queue.
+ */
+#define MESH_PATH_REFRESH_TIME                  1000
+#define MESH_MIN_DISCOVERY_TIMEOUT (2 * MESH_DIAM_TRAVERSAL_TIME)
+
+/* Default maximum number of established plinks per interface */
+#define MESH_MAX_ESTAB_PLINKS   32
+
+#define MESH_MAX_PREQ_RETRIES   4
+
+
+const struct mesh_config default_mesh_config = {
+        .dot11MeshRetryTimeout = MESH_RET_T,
+        .dot11MeshConfirmTimeout = MESH_CONF_T,
+        .dot11MeshHoldingTimeout = MESH_HOLD_T,
+        .dot11MeshMaxRetries = MESH_MAX_RETR,
+        .dot11MeshTTL = MESH_TTL,
+        .element_ttl = MESH_DEFAULT_ELEMENT_TTL,
+        .auto_open_plinks = true,
+        .dot11MeshMaxPeerLinks = MESH_MAX_ESTAB_PLINKS,
+        .dot11MeshHWMPactivePathTimeout = MESH_PATH_TIMEOUT,
+        .dot11MeshHWMPpreqMinInterval = MESH_PREQ_MIN_INT,
+        .dot11MeshHWMPnetDiameterTraversalTime = MESH_DIAM_TRAVERSAL_TIME,
+        .dot11MeshHWMPmaxPREQretries = MESH_MAX_PREQ_RETRIES,
+        .path_refresh_time = MESH_PATH_REFRESH_TIME,
+        .min_discovery_timeout = MESH_MIN_DISCOVERY_TIMEOUT,
+};
+
+
+int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                         struct net_device *dev,
+                         const u8 *mesh_id, u8 mesh_id_len,
+                         const struct mesh_config *conf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_setup setup = {
+                .mesh_id = mesh_id,
+                .mesh_id_len = mesh_id_len,
+        };
+        int err;
+
+        BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);
+
+        ASSERT_WDEV_LOCK(wdev);
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (wdev->mesh_id_len)
+                return -EALREADY;
+
+        if (!mesh_id_len)
+                return -EINVAL;
+
+        if (!rdev->ops->join_mesh)
+                return -EOPNOTSUPP;
+
+        err = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, &setup);
+        if (!err) {
+                memcpy(wdev->ssid, mesh_id, mesh_id_len);
+                wdev->mesh_id_len = mesh_id_len;
+        }
+
+        return err;
+}
+
+int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       const u8 *mesh_id, u8 mesh_id_len,
+                       const struct mesh_config *conf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        wdev_lock(wdev);
+        err = __cfg80211_join_mesh(rdev, dev, mesh_id, mesh_id_len, conf);
+        wdev_unlock(wdev);
+
+        return err;
+}
+
+static int __cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                                 struct net_device *dev)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        ASSERT_WDEV_LOCK(wdev);
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (!rdev->ops->leave_mesh)
+                return -EOPNOTSUPP;
+
+        if (!wdev->mesh_id_len)
+                return -ENOTCONN;
+
+        err = rdev->ops->leave_mesh(&rdev->wiphy, dev);
+        if (!err)
+                wdev->mesh_id_len = 0;
+        return err;
+}
+
+int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        wdev_lock(wdev);
+        err = __cfg80211_leave_mesh(rdev, dev);
+        wdev_unlock(wdev);
+
+        return err;
+}
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 960be4e650f0..c3f80e565365 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -121,6 +121,7 @@ static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
         [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
         [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
                                            .len = NL80211_MAX_SUPP_RATES },
+        [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
 
         [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
 
@@ -661,13 +662,14 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         CMD(add_beacon, NEW_BEACON);
         CMD(add_station, NEW_STATION);
         CMD(add_mpath, NEW_MPATH);
-        CMD(set_mesh_params, SET_MESH_PARAMS);
+        CMD(update_mesh_params, SET_MESH_PARAMS);
         CMD(change_bss, SET_BSS);
         CMD(auth, AUTHENTICATE);
         CMD(assoc, ASSOCIATE);
         CMD(deauth, DEAUTHENTICATE);
         CMD(disassoc, DISASSOCIATE);
         CMD(join_ibss, JOIN_IBSS);
+        CMD(join_mesh, JOIN_MESH);
         CMD(set_pmksa, SET_PMKSA);
         CMD(del_pmksa, DEL_PMKSA);
         CMD(flush_pmksa, FLUSH_PMKSA);
@@ -1324,11 +1326,21 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
         }
 
         if (info->attrs[NL80211_ATTR_MESH_ID]) {
+                struct wireless_dev *wdev = dev->ieee80211_ptr;
+
                 if (ntype != NL80211_IFTYPE_MESH_POINT)
                         return -EINVAL;
-                params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
-                params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
-                change = true;
+                if (netif_running(dev))
+                        return -EBUSY;
+
+                wdev_lock(wdev);
+                BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
+                             IEEE80211_MAX_MESH_ID_LEN);
+                wdev->mesh_id_up_len =
+                        nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
+                memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                       wdev->mesh_id_up_len);
+                wdev_unlock(wdev);
         }
 
         if (info->attrs[NL80211_ATTR_4ADDR]) {
@@ -1368,6 +1380,7 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
         struct vif_params params;
+        struct net_device *dev;
         int err;
         enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
         u32 flags;
@@ -1387,12 +1400,6 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
             !(rdev->wiphy.interface_modes & (1 << type)))
                 return -EOPNOTSUPP;
 
-        if (type == NL80211_IFTYPE_MESH_POINT &&
-            info->attrs[NL80211_ATTR_MESH_ID]) {
-                params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
-                params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
-        }
-
         if (info->attrs[NL80211_ATTR_4ADDR]) {
                 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
                 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
@@ -1403,11 +1410,27 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
         err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
                                   info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
                                   &flags);
-        err = rdev->ops->add_virtual_intf(&rdev->wiphy,
+        dev = rdev->ops->add_virtual_intf(&rdev->wiphy,
                 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
                 type, err ? NULL : &flags, &params);
+        if (IS_ERR(dev))
+                return PTR_ERR(dev);
 
-        return err;
+        if (type == NL80211_IFTYPE_MESH_POINT &&
+            info->attrs[NL80211_ATTR_MESH_ID]) {
+                struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+                wdev_lock(wdev);
+                BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
+                             IEEE80211_MAX_MESH_ID_LEN);
+                wdev->mesh_id_up_len =
+                        nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
+                memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                       wdev->mesh_id_up_len);
+                wdev_unlock(wdev);
+        }
+
+        return 0;
 }
 
 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
@@ -1874,6 +1897,9 @@ static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
         if (sinfo->filled & STATION_INFO_SIGNAL)
                 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
                            sinfo->signal);
+        if (sinfo->filled & STATION_INFO_SIGNAL_AVG)
+                NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL_AVG,
+                           sinfo->signal_avg);
         if (sinfo->filled & STATION_INFO_TX_BITRATE) {
                 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
                 if (!txrate)
@@ -2437,6 +2463,7 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
         params.use_short_preamble = -1;
         params.use_short_slot_time = -1;
         params.ap_isolate = -1;
+        params.ht_opmode = -1;
 
         if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
                 params.use_cts_prot =
@@ -2455,6 +2482,9 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
         }
         if (info->attrs[NL80211_ATTR_AP_ISOLATE])
                 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
+        if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
+                params.ht_opmode =
+                        nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
 
         if (!rdev->ops->change_bss)
                 return -EOPNOTSUPP;
@@ -2540,21 +2570,32 @@ static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
 }
 
 static int nl80211_get_mesh_params(struct sk_buff *skb,
-        struct genl_info *info)
+                                   struct genl_info *info)
 {
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
-        struct mesh_config cur_params;
-        int err;
         struct net_device *dev = info->user_ptr[1];
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_config cur_params;
+        int err = 0;
         void *hdr;
         struct nlattr *pinfoattr;
         struct sk_buff *msg;
 
+        if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
         if (!rdev->ops->get_mesh_params)
                 return -EOPNOTSUPP;
 
-        /* Get the mesh params */
-        err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
+        wdev_lock(wdev);
+        /* If not connected, get default parameters */
+        if (!wdev->mesh_id_len)
+                memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
+        else
+                err = rdev->ops->get_mesh_params(&rdev->wiphy, dev,
+                                                 &cur_params);
+        wdev_unlock(wdev);
+
         if (err)
                 return err;
 
@@ -2582,6 +2623,8 @@ static int nl80211_get_mesh_params(struct sk_buff *skb,
                         cur_params.dot11MeshMaxRetries);
         NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
                         cur_params.dot11MeshTTL);
+        NLA_PUT_U8(msg, NL80211_MESHCONF_ELEMENT_TTL,
+                        cur_params.element_ttl);
         NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
                         cur_params.auto_open_plinks);
         NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
@@ -2608,14 +2651,6 @@ static int nl80211_get_mesh_params(struct sk_buff *skb,
         return -ENOBUFS;
 }
 
-#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
-do {\
-        if (table[attr_num]) {\
-                cfg.param = nla_fn(table[attr_num]); \
-                mask |= (1 << (attr_num - 1)); \
-        } \
-} while (0);\
-
 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
         [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
         [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
@@ -2623,6 +2658,7 @@ static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_A
         [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
         [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
         [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
+        [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
         [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
 
         [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
@@ -2633,31 +2669,34 @@ static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_A
         [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
 };
 
-static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
+static int nl80211_parse_mesh_params(struct genl_info *info,
+                                     struct mesh_config *cfg,
+                                     u32 *mask_out)
 {
-        u32 mask;
-        struct cfg80211_registered_device *rdev = info->user_ptr[0];
-        struct net_device *dev = info->user_ptr[1];
-        struct mesh_config cfg;
         struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
-        struct nlattr *parent_attr;
+        u32 mask = 0;
+
+#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
+do {\
+        if (table[attr_num]) {\
+                cfg->param = nla_fn(table[attr_num]); \
+                mask |= (1 << (attr_num - 1)); \
+        } \
+} while (0);\
+
 
-        parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
-        if (!parent_attr)
+        if (!info->attrs[NL80211_ATTR_MESH_PARAMS])
                 return -EINVAL;
         if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
-                        parent_attr, nl80211_meshconf_params_policy))
+                             info->attrs[NL80211_ATTR_MESH_PARAMS],
+                             nl80211_meshconf_params_policy))
                 return -EINVAL;
 
-        if (!rdev->ops->set_mesh_params)
-                return -EOPNOTSUPP;
-
         /* This makes sure that there aren't more than 32 mesh config
          * parameters (otherwise our bitfield scheme would not work.) */
         BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
 
         /* Fill in the params struct */
-        mask = 0;
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
                         mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
@@ -2670,6 +2709,8 @@ static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
                         mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
                         mask, NL80211_MESHCONF_TTL, nla_get_u8);
+        FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl,
+                        mask, NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
                         mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
@@ -2695,11 +2736,45 @@ static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
                         NL80211_MESHCONF_HWMP_ROOTMODE,
                         nla_get_u8);
 
-        /* Apply changes */
-        return rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
-}
+        if (mask_out)
+                *mask_out = mask;
+        return 0;
 
 #undef FILL_IN_MESH_PARAM_IF_SET
+}
+
+static int nl80211_update_mesh_params(struct sk_buff *skb,
+                                      struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct mesh_config cfg;
+        u32 mask;
+        int err;
+
+        if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
+                return -EOPNOTSUPP;
+
+        if (!rdev->ops->update_mesh_params)
+                return -EOPNOTSUPP;
+
+        err = nl80211_parse_mesh_params(info, &cfg, &mask);
+        if (err)
+                return err;
+
+        wdev_lock(wdev);
+        if (!wdev->mesh_id_len)
+                err = -ENOLINK;
+
+        if (!err)
+                err = rdev->ops->update_mesh_params(&rdev->wiphy, dev,
+                                                    mask, &cfg);
+
+        wdev_unlock(wdev);
+
+        return err;
+}
 
 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
 {
@@ -4482,6 +4557,41 @@ out:
         return err;
 }
 
+static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+        struct mesh_config cfg;
+        int err;
+
+        /* start with default */
+        memcpy(&cfg, &default_mesh_config, sizeof(cfg));
+
+        if (info->attrs[NL80211_ATTR_MESH_PARAMS]) {
+                /* and parse parameters if given */
+                err = nl80211_parse_mesh_params(info, &cfg, NULL);
+                if (err)
+                        return err;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MESH_ID] ||
+            !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
+                return -EINVAL;
+
+        return cfg80211_join_mesh(rdev, dev,
+                                  nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
+                                  nla_len(info->attrs[NL80211_ATTR_MESH_ID]),
+                                  &cfg);
+}
+
+static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+
+        return cfg80211_leave_mesh(rdev, dev);
+}
+
 #define NL80211_FLAG_NEED_WIPHY         0x01
 #define NL80211_FLAG_NEED_NETDEV        0x02
 #define NL80211_FLAG_NEED_RTNL          0x04
@@ -4746,10 +4856,10 @@ static struct genl_ops nl80211_ops[] = {
         },
         {
                 .cmd = NL80211_CMD_SET_MESH_PARAMS,
-                .doit = nl80211_set_mesh_params,
+                .doit = nl80211_update_mesh_params,
                 .policy = nl80211_policy,
                 .flags = GENL_ADMIN_PERM,
-                .internal_flags = NL80211_FLAG_NEED_NETDEV |
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
                                   NL80211_FLAG_NEED_RTNL,
         },
         {
@@ -4964,6 +5074,22 @@ static struct genl_ops nl80211_ops[] = {
                 .internal_flags = NL80211_FLAG_NEED_NETDEV |
                                   NL80211_FLAG_NEED_RTNL,
         },
+        {
+                .cmd = NL80211_CMD_JOIN_MESH,
+                .doit = nl80211_join_mesh,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
+                                  NL80211_FLAG_NEED_RTNL,
+        },
+        {
+                .cmd = NL80211_CMD_LEAVE_MESH,
+                .doit = nl80211_leave_mesh,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
+                                  NL80211_FLAG_NEED_RTNL,
+        },
 };
 
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
diff --git a/net/wireless/util.c b/net/wireless/util.c
index fee020b15a4e..4de624ca4c63 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -792,6 +792,7 @@ int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
 
         if (ntype != otype) {
                 dev->ieee80211_ptr->use_4addr = false;
+                dev->ieee80211_ptr->mesh_id_up_len = 0;
 
                 switch (otype) {
                 case NL80211_IFTYPE_ADHOC: