1 files changed, 272 insertions, 316 deletions

diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index c0c3464d3a86..8a1691db166d 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -23,7 +23,7 @@ static void ath_update_txpow(struct ath_softc *sc)
         struct ath_hw *ah = sc->sc_ah;
 
         if (sc->curtxpow != sc->config.txpowlimit) {
-                ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit);
+                ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit, false);
                 /* read back in case value is clamped */
                 sc->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
         }
@@ -234,6 +234,8 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
 
         ath9k_ps_wakeup(sc);
 
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         /*
          * This is only performed if the channel settings have
          * actually changed.
@@ -243,11 +245,9 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
          * hardware at the new frequency, and then re-enable
          * the relevant bits of the h/w.
          */
-        ath9k_hw_set_interrupts(ah, 0);
+        ath9k_hw_disable_interrupts(ah);
         stopped = ath_drain_all_txq(sc, false);
 
-        spin_lock_bh(&sc->rx.pcu_lock);
-
         if (!ath_stoprecv(sc))
                 stopped = false;
 
@@ -261,36 +261,26 @@ 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);
-
-        spin_lock_bh(&sc->sc_resetlock);
+        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);
-                spin_unlock_bh(&sc->sc_resetlock);
-                spin_unlock_bh(&sc->rx.pcu_lock);
+                ath_err(common,
+                        "Unable to reset channel (%u MHz), reset status %d\n",
+                        channel->center_freq, r);
                 goto ps_restore;
         }
-        spin_unlock_bh(&sc->sc_resetlock);
 
         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;
-                spin_unlock_bh(&sc->rx.pcu_lock);
                 goto ps_restore;
         }
 
-        spin_unlock_bh(&sc->rx.pcu_lock);
-
         ath_update_txpow(sc);
         ath9k_hw_set_interrupts(ah, ah->imask);
 
@@ -301,6 +291,8 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
         }
 
  ps_restore:
+        spin_unlock_bh(&sc->sc_pcu_lock);
+
         ath9k_ps_restore(sc);
         return r;
 }
@@ -328,6 +320,42 @@ static void ath_paprd_activate(struct ath_softc *sc)
         ath9k_ps_restore(sc);
 }
 
+static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain)
+{
+        struct ieee80211_hw *hw = sc->hw;
+        struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
+        struct ath_tx_control txctl;
+        int time_left;
+
+        memset(&txctl, 0, sizeof(txctl));
+        txctl.txq = sc->tx.txq_map[WME_AC_BE];
+
+        memset(tx_info, 0, sizeof(*tx_info));
+        tx_info->band = hw->conf.channel->band;
+        tx_info->flags |= IEEE80211_TX_CTL_NO_ACK;
+        tx_info->control.rates[0].idx = 0;
+        tx_info->control.rates[0].count = 1;
+        tx_info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
+        tx_info->control.rates[1].idx = -1;
+
+        init_completion(&sc->paprd_complete);
+        sc->paprd_pending = true;
+        txctl.paprd = BIT(chain);
+        if (ath_tx_start(hw, skb, &txctl) != 0)
+                return false;
+
+        time_left = wait_for_completion_timeout(&sc->paprd_complete,
+                        msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
+        sc->paprd_pending = false;
+
+        if (!time_left)
+                ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CALIBRATE,
+                        "Timeout waiting for paprd training on TX chain %d\n",
+                        chain);
+
+        return !!time_left;
+}
+
 void ath_paprd_calibrate(struct work_struct *work)
 {
         struct ath_softc *sc = container_of(work, struct ath_softc, paprd_work);
@@ -335,28 +363,23 @@ void ath_paprd_calibrate(struct work_struct *work)
         struct ath_hw *ah = sc->sc_ah;
         struct ieee80211_hdr *hdr;
         struct sk_buff *skb = NULL;
-        struct ieee80211_tx_info *tx_info;
-        int band = hw->conf.channel->band;
-        struct ieee80211_supported_band *sband = &sc->sbands[band];
-        struct ath_tx_control txctl;
         struct ath9k_hw_cal_data *caldata = ah->caldata;
         struct ath_common *common = ath9k_hw_common(ah);
-        int qnum, ftype;
+        int ftype;
         int chain_ok = 0;
         int chain;
         int len = 1800;
-        int time_left;
-        int i;
 
         if (!caldata)
                 return;
 
+        if (ar9003_paprd_init_table(ah) < 0)
+                return;
+
         skb = alloc_skb(len, GFP_KERNEL);
         if (!skb)
                 return;
 
-        tx_info = IEEE80211_SKB_CB(skb);
-
         skb_put(skb, len);
         memset(skb->data, 0, len);
         hdr = (struct ieee80211_hdr *)skb->data;
@@ -367,40 +390,25 @@ void ath_paprd_calibrate(struct work_struct *work)
         memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
         memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);
 
-        memset(&txctl, 0, sizeof(txctl));
-        qnum = sc->tx.hwq_map[WME_AC_BE];
-        txctl.txq = &sc->tx.txq[qnum];
-
         ath9k_ps_wakeup(sc);
-        ar9003_paprd_init_table(ah);
         for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
                 if (!(common->tx_chainmask & BIT(chain)))
                         continue;
 
                 chain_ok = 0;
-                memset(tx_info, 0, sizeof(*tx_info));
-                tx_info->band = band;
 
-                for (i = 0; i < 4; i++) {
-                        tx_info->control.rates[i].idx = sband->n_bitrates - 1;
-                        tx_info->control.rates[i].count = 6;
-                }
+                ath_dbg(common, ATH_DBG_CALIBRATE,
+                        "Sending PAPRD frame for thermal measurement "
+                        "on chain %d\n", chain);
+                if (!ath_paprd_send_frame(sc, skb, chain))
+                        goto fail_paprd;
 
-                init_completion(&sc->paprd_complete);
                 ar9003_paprd_setup_gain_table(ah, chain);
-                txctl.paprd = BIT(chain);
-                if (ath_tx_start(hw, skb, &txctl) != 0)
-                        break;
 
-                time_left = wait_for_completion_timeout(&sc->paprd_complete,
-                                msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
-                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(common, ATH_DBG_CALIBRATE,
+                        "Sending PAPRD training frame on chain %d\n", chain);
+                if (!ath_paprd_send_frame(sc, skb, chain))
                         goto fail_paprd;
-                }
 
                 if (!ar9003_paprd_is_done(ah))
                         break;
@@ -457,7 +465,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;
         }
 
@@ -465,8 +473,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;
                 }
@@ -525,49 +533,25 @@ set_timer:
         if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
                 if (!ah->caldata->paprd_done)
                         ieee80211_queue_work(sc->hw, &sc->paprd_work);
-                else
+                else if (!ah->paprd_table_write_done)
                         ath_paprd_activate(sc);
         }
 }
 
-/*
- * Update tx/rx chainmask. For legacy association,
- * hard code chainmask to 1x1, for 11n association, use
- * the chainmask configuration, for bt coexistence, use
- * the chainmask configuration even in legacy mode.
- */
-void ath_update_chainmask(struct ath_softc *sc, int is_ht)
-{
-        struct ath_hw *ah = sc->sc_ah;
-        struct ath_common *common = ath9k_hw_common(ah);
-
-        if ((sc->sc_flags & SC_OP_OFFCHANNEL) || is_ht ||
-            (ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE)) {
-                common->tx_chainmask = ah->caps.tx_chainmask;
-                common->rx_chainmask = ah->caps.rx_chainmask;
-        } else {
-                common->tx_chainmask = 1;
-                common->rx_chainmask = 1;
-        }
-
-        ath_print(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)
 {
         struct ath_node *an;
-
+        struct ath_hw *ah = sc->sc_ah;
         an = (struct ath_node *)sta->drv_priv;
 
+        if ((ah->caps.hw_caps) & ATH9K_HW_CAP_APM)
+                sc->sc_flags |= SC_OP_ENABLE_APM;
+
         if (sc->sc_flags & SC_OP_TXAGGR) {
                 ath_tx_node_init(sc, an);
                 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
                                      sta->ht_cap.ampdu_factor);
                 an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
-                an->last_rssi = ATH_RSSI_DUMMY_MARKER;
         }
 }
 
@@ -615,6 +599,8 @@ void ath9k_tasklet(unsigned long data)
                 return;
         }
 
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         if (!ath9k_hw_check_alive(ah))
                 ieee80211_queue_work(sc->hw, &sc->hw_check_work);
 
@@ -625,15 +611,12 @@ void ath9k_tasklet(unsigned long data)
                 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
 
         if (status & rxmask) {
-                spin_lock_bh(&sc->rx.pcu_lock);
-
                 /* Check for high priority Rx first */
                 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
                     (status & ATH9K_INT_RXHP))
                         ath_rx_tasklet(sc, 0, true);
 
                 ath_rx_tasklet(sc, 0, false);
-                spin_unlock_bh(&sc->rx.pcu_lock);
         }
 
         if (status & ATH9K_INT_TX) {
@@ -648,8 +631,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;
         }
 
@@ -658,7 +641,9 @@ void ath9k_tasklet(unsigned long data)
                         ath_gen_timer_isr(sc->sc_ah);
 
         /* re-enable hardware interrupt */
-        ath9k_hw_set_interrupts(ah, ah->imask);
+        ath9k_hw_enable_interrupts(ah);
+
+        spin_unlock_bh(&sc->sc_pcu_lock);
         ath9k_ps_restore(sc);
 }
 
@@ -757,7 +742,7 @@ irqreturn_t ath_isr(int irq, void *dev)
                  * interrupt; otherwise it will continue to
                  * fire.
                  */
-                ath9k_hw_set_interrupts(ah, 0);
+                ath9k_hw_disable_interrupts(ah);
                 /*
                  * Let the hal handle the event. We assume
                  * it will clear whatever condition caused
@@ -766,11 +751,13 @@ irqreturn_t ath_isr(int irq, void *dev)
                 spin_lock(&common->cc_lock);
                 ath9k_hw_proc_mib_event(ah);
                 spin_unlock(&common->cc_lock);
-                ath9k_hw_set_interrupts(ah, ah->imask);
+                ath9k_hw_enable_interrupts(ah);
         }
 
         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);
@@ -783,8 +770,8 @@ chip_reset:
         ath_debug_stat_interrupt(sc, status);
 
         if (sched) {
-                /* turn off every interrupt except SWBA */
-                ath9k_hw_set_interrupts(ah, (ah->imask & ATH9K_INT_SWBA));
+                /* turn off every interrupt */
+                ath9k_hw_disable_interrupts(ah);
                 tasklet_schedule(&sc->intr_tq);
         }
 
@@ -836,16 +823,18 @@ static u32 ath_get_extchanmode(struct ath_softc *sc,
 }
 
 static void ath9k_bss_assoc_info(struct ath_softc *sc,
+                                 struct ieee80211_hw *hw,
                                  struct ieee80211_vif *vif,
                                  struct ieee80211_bss_conf *bss_conf)
 {
+        struct ath_wiphy *aphy = hw->priv;
         struct ath_hw *ah = sc->sc_ah;
         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;
@@ -862,12 +851,13 @@ static void ath9k_bss_assoc_info(struct ath_softc *sc,
                 ath_beacon_config(sc, vif);
 
                 /* Reset rssi stats */
+                aphy->last_rssi = ATH_RSSI_DUMMY_MARKER;
                 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
 
                 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;
@@ -883,31 +873,25 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
         int r;
 
         ath9k_ps_wakeup(sc);
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         ath9k_hw_configpcipowersave(ah, 0, 0);
 
         if (!ah->curchan)
                 ah->curchan = ath_get_curchannel(sc, sc->hw);
 
-        spin_lock_bh(&sc->rx.pcu_lock);
-        spin_lock_bh(&sc->sc_resetlock);
         r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
         if (r) {
-                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);
         }
-        spin_unlock_bh(&sc->sc_resetlock);
 
         ath_update_txpow(sc);
         if (ath_startrecv(sc) != 0) {
-                ath_print(common, ATH_DBG_FATAL,
-                          "Unable to restart recv logic\n");
-                spin_unlock_bh(&sc->rx.pcu_lock);
-                return;
+                ath_err(common, "Unable to restart recv logic\n");
+                goto out;
         }
-        spin_unlock_bh(&sc->rx.pcu_lock);
-
         if (sc->sc_flags & SC_OP_BEACONS)
                 ath_beacon_config(sc, NULL);    /* restart beacons */
 
@@ -920,6 +904,9 @@ void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
         ath9k_hw_set_gpio(ah, ah->led_pin, 0);
 
         ieee80211_wake_queues(hw);
+out:
+        spin_unlock_bh(&sc->sc_pcu_lock);
+
         ath9k_ps_restore(sc);
 }
 
@@ -930,6 +917,8 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
         int r;
 
         ath9k_ps_wakeup(sc);
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         ieee80211_stop_queues(hw);
 
         /*
@@ -942,34 +931,30 @@ void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
         }
 
         /* Disable interrupts */
-        ath9k_hw_set_interrupts(ah, 0);
+        ath9k_hw_disable_interrupts(ah);
 
         ath_drain_all_txq(sc, false);   /* clear pending tx frames */
 
-        spin_lock_bh(&sc->rx.pcu_lock);
-
         ath_stoprecv(sc);               /* turn off frame recv */
         ath_flushrecv(sc);              /* flush recv queue */
 
         if (!ah->curchan)
                 ah->curchan = ath_get_curchannel(sc, hw);
 
-        spin_lock_bh(&sc->sc_resetlock);
         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);
         }
-        spin_unlock_bh(&sc->sc_resetlock);
 
         ath9k_hw_phy_disable(ah);
 
-        spin_unlock_bh(&sc->rx.pcu_lock);
-
         ath9k_hw_configpcipowersave(ah, 1, 1);
+
+        spin_unlock_bh(&sc->sc_pcu_lock);
         ath9k_ps_restore(sc);
+
         ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP);
 }
 
@@ -983,28 +968,23 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
         /* Stop ANI */
         del_timer_sync(&common->ani.timer);
 
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         ieee80211_stop_queues(hw);
 
-        ath9k_hw_set_interrupts(ah, 0);
+        ath9k_hw_disable_interrupts(ah);
         ath_drain_all_txq(sc, retry_tx);
 
-        spin_lock_bh(&sc->rx.pcu_lock);
-
         ath_stoprecv(sc);
         ath_flushrecv(sc);
 
-        spin_lock_bh(&sc->sc_resetlock);
         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);
-        spin_unlock_bh(&sc->sc_resetlock);
+                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");
-
-        spin_unlock_bh(&sc->rx.pcu_lock);
+                ath_err(common, "Unable to start recv logic\n");
 
         /*
          * We may be doing a reset in response to a request
@@ -1030,6 +1010,7 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
         }
 
         ieee80211_wake_queues(hw);
+        spin_unlock_bh(&sc->sc_pcu_lock);
 
         /* Start ANI */
         ath_start_ani(common);
@@ -1037,56 +1018,6 @@ int ath_reset(struct ath_softc *sc, bool retry_tx)
         return r;
 }
 
-static int ath_get_hal_qnum(u16 queue, struct ath_softc *sc)
-{
-        int qnum;
-
-        switch (queue) {
-        case 0:
-                qnum = sc->tx.hwq_map[WME_AC_VO];
-                break;
-        case 1:
-                qnum = sc->tx.hwq_map[WME_AC_VI];
-                break;
-        case 2:
-                qnum = sc->tx.hwq_map[WME_AC_BE];
-                break;
-        case 3:
-                qnum = sc->tx.hwq_map[WME_AC_BK];
-                break;
-        default:
-                qnum = sc->tx.hwq_map[WME_AC_BE];
-                break;
-        }
-
-        return qnum;
-}
-
-int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc)
-{
-        int qnum;
-
-        switch (queue) {
-        case WME_AC_VO:
-                qnum = 0;
-                break;
-        case WME_AC_VI:
-                qnum = 1;
-                break;
-        case WME_AC_BE:
-                qnum = 2;
-                break;
-        case WME_AC_BK:
-                qnum = 3;
-                break;
-        default:
-                qnum = -1;
-                break;
-        }
-
-        return qnum;
-}
-
 /* XXX: Remove me once we don't depend on ath9k_channel for all
  * this redundant data */
 void ath9k_update_ichannel(struct ath_softc *sc, struct ieee80211_hw *hw,
@@ -1125,9 +1056,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);
 
@@ -1168,19 +1099,15 @@ static int ath9k_start(struct ieee80211_hw *hw)
          * be followed by initialization of the appropriate bits
          * and then setup of the interrupt mask.
          */
-        spin_lock_bh(&sc->rx.pcu_lock);
-        spin_lock_bh(&sc->sc_resetlock);
+        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);
-                spin_unlock_bh(&sc->sc_resetlock);
-                spin_unlock_bh(&sc->rx.pcu_lock);
+                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;
         }
-        spin_unlock_bh(&sc->sc_resetlock);
 
         /*
          * This is needed only to setup initial state
@@ -1196,13 +1123,12 @@ 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->rx.pcu_lock);
+                spin_unlock_bh(&sc->sc_pcu_lock);
                 goto mutex_unlock;
         }
-        spin_unlock_bh(&sc->rx.pcu_lock);
+        spin_unlock_bh(&sc->sc_pcu_lock);
 
         /* Setup our intr mask. */
         ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
@@ -1244,7 +1170,14 @@ static int ath9k_start(struct ieee80211_hw *hw)
                         ath9k_btcoex_timer_resume(sc);
         }
 
-        pm_qos_update_request(&sc->pm_qos_req, 55);
+        /* User has the option to provide pm-qos value as a module
+         * parameter rather than using the default value of
+         * 'ATH9K_PM_QOS_DEFAULT_VALUE'.
+         */
+        pm_qos_update_request(&sc->pm_qos_req, ath9k_pm_qos_value);
+
+        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);
@@ -1255,19 +1188,16 @@ mutex_unlock:
 static int ath9k_tx(struct ieee80211_hw *hw,
                     struct sk_buff *skb)
 {
-        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct ath_wiphy *aphy = hw->priv;
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath_tx_control txctl;
-        int padpos, padsize;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
-        int qnum;
 
         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;
         }
 
@@ -1279,8 +1209,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);
                 }
         }
@@ -1295,12 +1225,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;
                 }
                 /*
@@ -1312,36 +1242,12 @@ 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)];
 
-        /*
-         * As a temporary workaround, assign seq# here; this will likely need
-         * to be cleaned up to work better with Beacon transmission and virtual
-         * BSSes.
-         */
-        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
-                if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
-                        sc->tx.seq_no += 0x10;
-                hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
-                hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
-        }
-
-        /* Add the padding after the header if this is not already done */
-        padpos = ath9k_cmn_padpos(hdr->frame_control);
-        padsize = padpos & 3;
-        if (padsize && skb->len>padpos) {
-                if (skb_headroom(skb) < padsize)
-                        return -1;
-                skb_push(skb, padsize);
-                memmove(skb->data, skb->data + padsize, padpos);
-        }
-
-        qnum = ath_get_hal_qnum(skb_get_queue_mapping(skb), sc);
-        txctl.txq = &sc->tx.txq[qnum];
-
-        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;
         }
 
@@ -1381,7 +1287,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;
         }
@@ -1400,26 +1306,29 @@ static void ath9k_stop(struct ieee80211_hw *hw)
                         ath9k_btcoex_timer_pause(sc);
         }
 
+        spin_lock_bh(&sc->sc_pcu_lock);
+
         /* make sure h/w will not generate any interrupt
          * before setting the invalid flag. */
-        ath9k_hw_set_interrupts(ah, 0);
+        ath9k_hw_disable_interrupts(ah);
 
-        spin_lock_bh(&sc->rx.pcu_lock);
         if (!(sc->sc_flags & SC_OP_INVALID)) {
                 ath_drain_all_txq(sc, false);
                 ath_stoprecv(sc);
                 ath9k_hw_phy_disable(ah);
         } else
                 sc->rx.rxlink = NULL;
-        spin_unlock_bh(&sc->rx.pcu_lock);
 
         /* disable HAL and put h/w to sleep */
         ath9k_hw_disable(ah);
         ath9k_hw_configpcipowersave(ah, 1, 1);
+
+        spin_unlock_bh(&sc->sc_pcu_lock);
+
         ath9k_ps_restore(sc);
 
-        /* Finally, put the chip in FULL SLEEP mode */
-        ath9k_setpower(sc, ATH9K_PM_FULL_SLEEP);
+        sc->ps_idle = true;
+        ath_radio_disable(sc, hw);
 
         sc->sc_flags |= SC_OP_INVALID;
 
@@ -1427,7 +1336,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,
@@ -1460,14 +1369,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;
@@ -1513,15 +1422,80 @@ out:
         return ret;
 }
 
+static void ath9k_reclaim_beacon(struct ath_softc *sc,
+                                 struct ieee80211_vif *vif)
+{
+        struct ath_vif *avp = (void *)vif->drv_priv;
+
+        /* 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);
+        tasklet_kill(&sc->bcon_tasklet);
+        ath9k_ps_restore(sc);
+
+        ath_beacon_return(sc, avp);
+        sc->sc_flags &= ~SC_OP_BEACONS;
+
+        if (sc->nbcnvifs > 0) {
+                /* Re-enable beaconing */
+                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);
+        }
+}
+
+static int ath9k_change_interface(struct ieee80211_hw *hw,
+                                  struct ieee80211_vif *vif,
+                                  enum nl80211_iftype new_type,
+                                  bool p2p)
+{
+        struct ath_wiphy *aphy = hw->priv;
+        struct ath_softc *sc = aphy->sc;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+
+        ath_dbg(common, ATH_DBG_CONFIG, "Change Interface\n");
+        mutex_lock(&sc->mutex);
+
+        switch (new_type) {
+        case NL80211_IFTYPE_AP:
+        case NL80211_IFTYPE_ADHOC:
+                if (sc->nbcnvifs >= ATH_BCBUF) {
+                        ath_err(common, "No beacon slot available\n");
+                        return -ENOBUFS;
+                }
+                break;
+        case NL80211_IFTYPE_STATION:
+                /* Stop ANI */
+                sc->sc_flags &= ~SC_OP_ANI_RUN;
+                del_timer_sync(&common->ani.timer);
+                if ((vif->type == NL80211_IFTYPE_AP) ||
+                    (vif->type == NL80211_IFTYPE_ADHOC))
+                        ath9k_reclaim_beacon(sc, vif);
+                break;
+        default:
+                ath_err(common, "Interface type %d not yet supported\n",
+                                vif->type);
+                mutex_unlock(&sc->mutex);
+                return -ENOTSUPP;
+        }
+        vif->type = new_type;
+        vif->p2p = p2p;
+
+        mutex_unlock(&sc->mutex);
+        return 0;
+}
+
 static void ath9k_remove_interface(struct ieee80211_hw *hw,
                                    struct ieee80211_vif *vif)
 {
         struct ath_wiphy *aphy = hw->priv;
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
-        struct ath_vif *avp = (void *)vif->drv_priv;
 
-        ath_print(common, ATH_DBG_CONFIG, "Detach Interface\n");
+        ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
 
         mutex_lock(&sc->mutex);
 
@@ -1532,26 +1506,8 @@ static void ath9k_remove_interface(struct ieee80211_hw *hw,
         /* Reclaim beacon resources */
         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;
-
-        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);
-        }
+            (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT))
+                ath9k_reclaim_beacon(sc, vif);
 
         sc->nvifs--;
 
@@ -1631,8 +1587,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");
                 }
         }
 
@@ -1654,12 +1610,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;
                 }
         }
@@ -1691,14 +1647,12 @@ 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]);
 
-                ath_update_chainmask(sc, conf_is_ht(conf));
-
                 /* update survey stats for the old channel before switching */
                 spin_lock_irqsave(&common->cc_lock, flags);
                 ath_update_survey_stats(sc);
@@ -1725,8 +1679,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;
                 }
@@ -1751,7 +1704,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);
         }
@@ -1790,8 +1743,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,
@@ -1824,12 +1777,15 @@ static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
         struct ath_wiphy *aphy = hw->priv;
         struct ath_softc *sc = aphy->sc;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        struct ath_txq *txq;
         struct ath9k_tx_queue_info qi;
-        int ret = 0, qnum;
+        int ret = 0;
 
         if (queue >= WME_NUM_AC)
                 return 0;
 
+        txq = sc->tx.txq_map[queue];
+
         mutex_lock(&sc->mutex);
 
         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
@@ -1838,20 +1794,18 @@ static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue,
         qi.tqi_cwmin = params->cw_min;
         qi.tqi_cwmax = params->cw_max;
         qi.tqi_burstTime = params->txop;
-        qnum = ath_get_hal_qnum(queue, sc);
 
-        ath_print(common, ATH_DBG_CONFIG,
-                  "Configure tx [queue/halq] [%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/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, qnum, &qi);
+        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 ((qnum == sc->tx.hwq_map[WME_AC_BE]) && !ret)
+                if (queue == WME_AC_BE && !ret)
                         ath_beaconq_config(sc);
 
         mutex_unlock(&sc->mutex);
@@ -1875,7 +1829,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:
@@ -1930,13 +1884,8 @@ static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
                 /* Set aggregation protection mode parameters */
                 sc->config.ath_aggr_prot = 0;
 
-                /* Only legacy IBSS for now */
-                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 ;
@@ -1992,8 +1941,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
@@ -2001,8 +1950,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;
@@ -2011,9 +1960,9 @@ 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, vif, bss_conf);
+                ath9k_bss_assoc_info(sc, hw, vif, bss_conf);
         }
 
         mutex_unlock(&sc->mutex);
@@ -2026,7 +1975,9 @@ static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
         struct ath_softc *sc = aphy->sc;
 
         mutex_lock(&sc->mutex);
+        ath9k_ps_wakeup(sc);
         tsf = ath9k_hw_gettsf64(sc->sc_ah);
+        ath9k_ps_restore(sc);
         mutex_unlock(&sc->mutex);
 
         return tsf;
@@ -2038,7 +1989,9 @@ static void ath9k_set_tsf(struct ieee80211_hw *hw, u64 tsf)
         struct ath_softc *sc = aphy->sc;
 
         mutex_lock(&sc->mutex);
+        ath9k_ps_wakeup(sc);
         ath9k_hw_settsf64(sc->sc_ah, tsf);
+        ath9k_ps_restore(sc);
         mutex_unlock(&sc->mutex);
 }
 
@@ -2076,6 +2029,9 @@ static int ath9k_ampdu_action(struct ieee80211_hw *hw,
         case IEEE80211_AMPDU_RX_STOP:
                 break;
         case IEEE80211_AMPDU_TX_START:
+                if (!(sc->sc_flags & SC_OP_TXAGGR))
+                        return -EOPNOTSUPP;
+
                 ath9k_ps_wakeup(sc);
                 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
                 if (!ret)
@@ -2094,8 +2050,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();
@@ -2195,6 +2150,7 @@ struct ieee80211_ops ath9k_ops = {
         .start              = ath9k_start,
         .stop               = ath9k_stop,
         .add_interface      = ath9k_add_interface,
+        .change_interface   = ath9k_change_interface,
         .remove_interface   = ath9k_remove_interface,
         .config             = ath9k_config,
         .configure_filter   = ath9k_configure_filter,