kernel: add a recent upstream commit (post-3.3) to the ssb update patch, required...

[openwrt.git] / package / mac80211 / patches / 300-pending_work.patch

diff --git a/package/mac80211/patches/300-pending_work.patch b/package/mac80211/patches/300-pending_work.patch
index 982e233..eb09e03 100644 (file)
--- a/package/mac80211/patches/300-pending_work.patch
+++ b/package/mac80211/patches/300-pending_work.patch
@@ -1,353 +1,1381 @@
+--- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c
++++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
+@@ -203,7 +203,7 @@ static void ar9002_hw_iqcalibrate(struct
+                       i);
+ 
+               ath_dbg(common, ATH_DBG_CALIBRATE,
+-                      "Orignal: Chn %diq_corr_meas = 0x%08x\n",
++                      "Original: Chn %d iq_corr_meas = 0x%08x\n",
+                       i, ah->totalIqCorrMeas[i]);
+ 
+               iqCorrNeg = 0;
+--- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
++++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
+@@ -226,7 +226,7 @@ static void ar9003_hw_iqcalibrate(struct
+                       i);
+ 
+               ath_dbg(common, ATH_DBG_CALIBRATE,
+-                      "Orignal: Chn %diq_corr_meas = 0x%08x\n",
++                      "Original: Chn %d iq_corr_meas = 0x%08x\n",
+                       i, ah->totalIqCorrMeas[i]);
+ 
+               iqCorrNeg = 0;
+--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
++++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
+@@ -808,7 +808,8 @@ void ath9k_htc_ani_work(struct work_stru
+       }
+ 
+       /* Verify whether we must check ANI */
+-      if ((timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
++      if (ah->config.enable_ani &&
++          (timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
+               aniflag = true;
+               common->ani.checkani_timer = timestamp;
+       }
+--- a/drivers/net/wireless/ath/ath9k/hw.c
++++ b/drivers/net/wireless/ath/ath9k/hw.c
+@@ -504,7 +504,7 @@ static int ath9k_hw_post_init(struct ath
+               return ecode;
+       }
+ 
+-      if (!AR_SREV_9100(ah) && !AR_SREV_9340(ah)) {
++      if (ah->config.enable_ani) {
+               ath9k_hw_ani_setup(ah);
+               ath9k_hw_ani_init(ah);
+       }
+@@ -610,6 +610,10 @@ static int __ath9k_hw_init(struct ath_hw
+       if (!AR_SREV_9300_20_OR_LATER(ah))
+               ah->ani_function &= ~ATH9K_ANI_MRC_CCK;
+ 
++      /* disable ANI for 9340 */
++      if (AR_SREV_9340(ah))
++              ah->config.enable_ani = false;
++
+       ath9k_hw_init_mode_regs(ah);
+ 
+       if (!ah->is_pciexpress)

 --- a/drivers/net/wireless/ath/ath9k/main.c
 +++ b/drivers/net/wireless/ath/ath9k/main.c
 --- a/drivers/net/wireless/ath/ath9k/main.c
 +++ b/drivers/net/wireless/ath/ath9k/main.c

-@@ -324,7 +324,6 @@ static void ath_paprd_activate(struct at
-       if (!caldata || !caldata->paprd_done)
-               return;
+@@ -118,7 +118,7 @@ void ath9k_ps_restore(struct ath_softc *
+       if (--sc->ps_usecount != 0)
+               goto unlock;

  
  

--      ath9k_ps_wakeup(sc);
-       ar9003_paprd_enable(ah, false);
-       for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
-               if (!(common->tx_chainmask & BIT(chain)))
-@@ -334,7 +333,6 @@ static void ath_paprd_activate(struct at
+-      if (sc->ps_idle)
++      if (sc->ps_idle && (sc->ps_flags & PS_WAIT_FOR_TX_ACK))
+               mode = ATH9K_PM_FULL_SLEEP;
+       else if (sc->ps_enabled &&
+                !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
+@@ -286,7 +286,7 @@ static bool ath_complete_reset(struct at
+                       ath_start_ani(common);

        }
  
        }
  

-       ar9003_paprd_enable(ah, true);
--      ath9k_ps_restore(sc);
- }
+-      if (ath9k_hw_ops(ah)->antdiv_comb_conf_get && sc->ant_rx != 3) {
++      if ((ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB) && sc->ant_rx != 3) {
+               struct ath_hw_antcomb_conf div_ant_conf;
+               u8 lna_conf;

  
  

- static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain)
-@@ -554,8 +552,11 @@ 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 if (!ah->paprd_table_write_done)
-+              else if (!ah->paprd_table_write_done) {
-+                      ath9k_ps_wakeup(sc);
-                       ath_paprd_activate(sc);
-+                      ath9k_ps_restore(sc);
-+              }
+@@ -332,7 +332,8 @@ static int ath_reset_internal(struct ath
+               hchan = ah->curchan;

        }
        }

- }

  
  

-@@ -1376,7 +1377,6 @@ static void ath9k_calculate_summary_stat
+-      if (fastcc && !ath9k_hw_check_alive(ah))
++      if (fastcc && (ah->chip_fullsleep ||
++          !ath9k_hw_check_alive(ah)))
+               fastcc = false;

  
  

-       ath9k_calculate_iter_data(hw, vif, &iter_data);
+       if (!ath_prepare_reset(sc, retry_tx, flush))
+@@ -561,7 +562,6 @@ void ath_ani_calibrate(unsigned long dat
+       /* Long calibration runs independently of short calibration. */
+       if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) {
+               longcal = true;
+-              ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
+               common->ani.longcal_timer = timestamp;
+       }

  
  

--      ath9k_ps_wakeup(sc);
-       /* Set BSSID mask. */
-       memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
-       ath_hw_setbssidmask(common);
-@@ -1411,7 +1411,6 @@ static void ath9k_calculate_summary_stat
+@@ -569,8 +569,6 @@ void ath_ani_calibrate(unsigned long dat
+       if (!common->ani.caldone) {
+               if ((timestamp - common->ani.shortcal_timer) >= short_cal_interval) {
+                       shortcal = true;
+-                      ath_dbg(common, ATH_DBG_ANI,
+-                              "shortcal @%lu\n", jiffies);
+                       common->ani.shortcal_timer = timestamp;
+                       common->ani.resetcal_timer = timestamp;
+               }
+@@ -584,8 +582,9 @@ void ath_ani_calibrate(unsigned long dat

        }
  
        }
  

-       ath9k_hw_set_interrupts(ah, ah->imask);
+       /* Verify whether we must check ANI */
+-      if ((timestamp - common->ani.checkani_timer) >=
+-           ah->config.ani_poll_interval) {
++      if (sc->sc_ah->config.enable_ani
++          && (timestamp - common->ani.checkani_timer) >=
++          ah->config.ani_poll_interval) {
+               aniflag = true;
+               common->ani.checkani_timer = timestamp;
+       }
+@@ -605,6 +604,11 @@ void ath_ani_calibrate(unsigned long dat
+                                               ah->rxchainmask, longcal);
+       }
+ 
++      ath_dbg(common, ATH_DBG_ANI,
++              "Calibration @%lu finished: %s %s %s, caldone: %s\n", jiffies,
++              longcal ? "long" : "", shortcal ? "short" : "",
++              aniflag ? "ani" : "", common->ani.caldone ? "true" : "false");
++
+       ath9k_ps_restore(sc);
+ 
+ set_timer:
+@@ -886,82 +890,6 @@ chip_reset:
+ #undef SCHED_INTR
+ }
+ 
+-static void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
+-{
+-      struct ath_hw *ah = sc->sc_ah;
+-      struct ath_common *common = ath9k_hw_common(ah);
+-      struct ieee80211_channel *channel = hw->conf.channel;
+-      int r;
+-
+-      ath9k_ps_wakeup(sc);
+-      spin_lock_bh(&sc->sc_pcu_lock);
+-      atomic_set(&ah->intr_ref_cnt, -1);
+-
+-      ath9k_hw_configpcipowersave(ah, false);
+-
+-      if (!ah->curchan)
+-              ah->curchan = ath9k_cmn_get_curchannel(sc->hw, ah);
+-
+-      r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
+-      if (r) {
+-              ath_err(common,
+-                      "Unable to reset channel (%u MHz), reset status %d\n",
+-                      channel->center_freq, r);
+-      }
+-
+-      ath_complete_reset(sc, true);
+-
+-      /* Enable LED */
+-      ath9k_hw_cfg_output(ah, ah->led_pin,
+-                          AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+-      ath9k_hw_set_gpio(ah, ah->led_pin, 0);
+-
+-      spin_unlock_bh(&sc->sc_pcu_lock);
+-
+-      ath9k_ps_restore(sc);
+-}
+-
+-void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
+-{
+-      struct ath_hw *ah = sc->sc_ah;
+-      struct ieee80211_channel *channel = hw->conf.channel;
+-      int r;
+-
+-      ath9k_ps_wakeup(sc);
+-
+-      ath_cancel_work(sc);
+-
+-      spin_lock_bh(&sc->sc_pcu_lock);
+-
+-      /*
+-       * Keep the LED on when the radio is disabled
+-       * during idle unassociated state.
+-       */
+-      if (!sc->ps_idle) {
+-              ath9k_hw_set_gpio(ah, ah->led_pin, 1);
+-              ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
+-      }
+-
+-      ath_prepare_reset(sc, false, true);
+-
+-      if (!ah->curchan)
+-              ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
+-
+-      r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
+-      if (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);
+-
+-      ath9k_hw_configpcipowersave(ah, true);
+-
+-      spin_unlock_bh(&sc->sc_pcu_lock);

 -      ath9k_ps_restore(sc);
 -      ath9k_ps_restore(sc);

+-}
+-
+ static int ath_reset(struct ath_softc *sc, bool retry_tx)
+ {
+       int r;
+@@ -1097,6 +1025,9 @@ static int ath9k_start(struct ieee80211_
+        * and then setup of the interrupt mask.
+        */
+       spin_lock_bh(&sc->sc_pcu_lock);
++
++      atomic_set(&ah->intr_ref_cnt, -1);
++
+       r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
+       if (r) {
+               ath_err(common,
+@@ -1138,6 +1069,18 @@ static int ath9k_start(struct ieee80211_
+               goto mutex_unlock;
+       }

  
  

-       /* Set up ANI */
-       if ((iter_data.naps + iter_data.nadhocs) > 0) {
-@@ -1457,6 +1456,7 @@ static int ath9k_add_interface(struct ie
-       struct ath_vif *avp = (void *)vif->drv_priv;
-       int ret = 0;
++      if (ah->led_pin >= 0) {
++              ath9k_hw_cfg_output(ah, ah->led_pin,
++                                  AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
++              ath9k_hw_set_gpio(ah, ah->led_pin, 0);
++      }
++
++      /*
++       * Reset key cache to sane defaults (all entries cleared) instead of
++       * semi-random values after suspend/resume.
++       */
++      ath9k_cmn_init_crypto(sc->sc_ah);
++
+       spin_unlock_bh(&sc->sc_pcu_lock);
+ 
+       if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
+@@ -1183,6 +1126,13 @@ static void ath9k_tx(struct ieee80211_hw
+               }
+       }
+ 
++      /*
++       * Cannot tx while the hardware is in full sleep, it first needs a full
++       * chip reset to recover from that
++       */
++      if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP))
++              goto exit;
++
+       if (unlikely(sc->sc_ah->power_mode != ATH9K_PM_AWAKE)) {
+               /*
+                * We are using PS-Poll and mac80211 can request TX while in
+@@ -1229,6 +1179,7 @@ static void ath9k_stop(struct ieee80211_
+       struct ath_softc *sc = hw->priv;
+       struct ath_hw *ah = sc->sc_ah;
+       struct ath_common *common = ath9k_hw_common(ah);
++      bool prev_idle;

  
  

-+      ath9k_ps_wakeup(sc);

        mutex_lock(&sc->mutex);
  
        mutex_lock(&sc->mutex);
  

-       switch (vif->type) {
-@@ -1503,6 +1503,7 @@ static int ath9k_add_interface(struct ie
-       ath9k_do_vif_add_setup(hw, vif);
- out:
-       mutex_unlock(&sc->mutex);
-+      ath9k_ps_restore(sc);
-       return ret;
- }
+@@ -1259,35 +1210,45 @@ static void ath9k_stop(struct ieee80211_
+        * before setting the invalid flag. */
+       ath9k_hw_disable_interrupts(ah);

  
  

-@@ -1517,6 +1518,7 @@ static int ath9k_change_interface(struct
+-      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->sc_pcu_lock);
++
++      /* we can now sync irq and kill any running tasklets, since we already
++       * disabled interrupts and not holding a spin lock */
++      synchronize_irq(sc->irq);
++      tasklet_kill(&sc->intr_tq);
++      tasklet_kill(&sc->bcon_tasklet);
++
++      prev_idle = sc->ps_idle;
++      sc->ps_idle = true;
++
++      spin_lock_bh(&sc->sc_pcu_lock);
++
++      if (ah->led_pin >= 0) {
++              ath9k_hw_set_gpio(ah, ah->led_pin, 1);
++              ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
++      }
++
++      ath_prepare_reset(sc, false, true);

  
  

-       ath_dbg(common, ATH_DBG_CONFIG, "Change Interface\n");
-       mutex_lock(&sc->mutex);
-+      ath9k_ps_wakeup(sc);
+       if (sc->rx.frag) {
+               dev_kfree_skb_any(sc->rx.frag);
+               sc->rx.frag = NULL;
+       }
+ 
+-      /* disable HAL and put h/w to sleep */
+-      ath9k_hw_disable(ah);
++      if (!ah->curchan)
++              ah->curchan = ath9k_cmn_get_curchannel(hw, ah);

  
  

-       /* See if new interface type is valid. */
-       if ((new_type == NL80211_IFTYPE_ADHOC) &&
-@@ -1546,6 +1548,7 @@ static int ath9k_change_interface(struct
+-      spin_unlock_bh(&sc->sc_pcu_lock);
++      ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
++      ath9k_hw_phy_disable(ah);

  
  

-       ath9k_do_vif_add_setup(hw, vif);
- out:
+-      /* we can now sync irq and kill any running tasklets, since we already
+-       * disabled interrupts and not holding a spin lock */
+-      synchronize_irq(sc->irq);
+-      tasklet_kill(&sc->intr_tq);
+-      tasklet_kill(&sc->bcon_tasklet);
++      ath9k_hw_configpcipowersave(ah, true);
+ 
+-      ath9k_ps_restore(sc);
++      spin_unlock_bh(&sc->sc_pcu_lock);
+ 
+-      sc->ps_idle = true;
+-      ath_radio_disable(sc, hw);

 +      ath9k_ps_restore(sc);
 +      ath9k_ps_restore(sc);

+ 
+       sc->sc_flags |= SC_OP_INVALID;
++      sc->ps_idle = prev_idle;
+ 

        mutex_unlock(&sc->mutex);
        mutex_unlock(&sc->mutex);

-       return ret;
- }
-@@ -1558,6 +1561,7 @@ static void ath9k_remove_interface(struc

  
  

-       ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
+@@ -1627,8 +1588,8 @@ static int ath9k_config(struct ieee80211
+       struct ath_hw *ah = sc->sc_ah;
+       struct ath_common *common = ath9k_hw_common(ah);
+       struct ieee80211_conf *conf = &hw->conf;
+-      bool disable_radio = false;

  
 +      ath9k_ps_wakeup(sc);
        mutex_lock(&sc->mutex);
  
  
 +      ath9k_ps_wakeup(sc);
        mutex_lock(&sc->mutex);
  

-       sc->nvifs--;
-@@ -1569,6 +1573,7 @@ static void ath9k_remove_interface(struc
-       ath9k_calculate_summary_state(hw, NULL);
+       /*
+@@ -1639,13 +1600,8 @@ static int ath9k_config(struct ieee80211
+        */
+       if (changed & IEEE80211_CONF_CHANGE_IDLE) {
+               sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
+-              if (!sc->ps_idle) {
+-                      ath_radio_enable(sc, hw);
+-                      ath_dbg(common, ATH_DBG_CONFIG,
+-                              "not-idle: enabling radio\n");
+-              } else {
+-                      disable_radio = true;
+-              }
++              if (sc->ps_idle)
++                      ath_cancel_work(sc);
+       }
+ 
+       /*
+@@ -1678,7 +1634,6 @@ static int ath9k_config(struct ieee80211
+ 
+       if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
+               struct ieee80211_channel *curchan = hw->conf.channel;
+-              struct ath9k_channel old_chan;
+               int pos = curchan->hw_value;
+               int old_pos = -1;
+               unsigned long flags;
+@@ -1704,11 +1659,8 @@ static int ath9k_config(struct ieee80211
+                * Preserve the current channel values, before updating
+                * the same channel
+                */
+-              if (old_pos == pos) {
+-                      memcpy(&old_chan, &sc->sc_ah->channels[pos],
+-                              sizeof(struct ath9k_channel));
+-                      ah->curchan = &old_chan;
+-              }
++              if (ah->curchan && (old_pos == pos))
++                      ath9k_hw_getnf(ah, ah->curchan);
+ 
+               ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
+                                         curchan, conf->channel_type);
+@@ -1752,18 +1704,12 @@ static int ath9k_config(struct ieee80211
+               ath_dbg(common, ATH_DBG_CONFIG,
+                       "Set power: %d\n", conf->power_level);
+               sc->config.txpowlimit = 2 * conf->power_level;
+-              ath9k_ps_wakeup(sc);
+               ath9k_cmn_update_txpow(ah, sc->curtxpow,
+                                      sc->config.txpowlimit, &sc->curtxpow);
+-              ath9k_ps_restore(sc);
+-      }
+-
+-      if (disable_radio) {
+-              ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
+-              ath_radio_disable(sc, hw);
+       }

  
        mutex_unlock(&sc->mutex);
 +      ath9k_ps_restore(sc);
  
        mutex_unlock(&sc->mutex);
 +      ath9k_ps_restore(sc);

+ 
+       return 0;

  }
  }

+@@ -2331,9 +2277,6 @@ static void ath9k_flush(struct ieee80211
+               return;
+       }

  
  

- static void ath9k_enable_ps(struct ath_softc *sc)
-@@ -1809,6 +1814,7 @@ static int ath9k_conf_tx(struct ieee8021
+-      if (drop)
+-              timeout = 1;
+-
+       for (j = 0; j < timeout; j++) {
+               bool npend = false;

  
  

-       txq = sc->tx.txq_map[queue];
+@@ -2351,21 +2294,22 @@ static void ath9k_flush(struct ieee80211
+               }

  
  

-+      ath9k_ps_wakeup(sc);
-       mutex_lock(&sc->mutex);
+               if (!npend)
+-                  goto out;
++                  break;
+       }

  
  

-       memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
-@@ -1832,6 +1838,7 @@ static int ath9k_conf_tx(struct ieee8021
-                       ath_beaconq_config(sc);
+-      ath9k_ps_wakeup(sc);
+-      spin_lock_bh(&sc->sc_pcu_lock);
+-      drain_txq = ath_drain_all_txq(sc, false);
+-      spin_unlock_bh(&sc->sc_pcu_lock);
++      if (drop) {
++              ath9k_ps_wakeup(sc);
++              spin_lock_bh(&sc->sc_pcu_lock);
++              drain_txq = ath_drain_all_txq(sc, false);
++              spin_unlock_bh(&sc->sc_pcu_lock);

  
  

-       mutex_unlock(&sc->mutex);
-+      ath9k_ps_restore(sc);
+-      if (!drain_txq)
+-              ath_reset(sc, false);
++              if (!drain_txq)
++                      ath_reset(sc, false);
+ 
+-      ath9k_ps_restore(sc);
+-      ieee80211_wake_queues(hw);
++              ath9k_ps_restore(sc);
++              ieee80211_wake_queues(hw);
++      }

  
  

-       return ret;
+-out:
+       ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
+       mutex_unlock(&sc->mutex);

  }
  }

-@@ -1908,6 +1915,7 @@ static void ath9k_bss_info_changed(struc
-       int slottime;
-       int error;
+--- a/drivers/net/wireless/ath/ath9k/pci.c
++++ b/drivers/net/wireless/ath/ath9k/pci.c
+@@ -307,12 +307,11 @@ static int ath_pci_suspend(struct device
+       struct ieee80211_hw *hw = pci_get_drvdata(pdev);
+       struct ath_softc *sc = hw->priv;

  
  

-+      ath9k_ps_wakeup(sc);
-       mutex_lock(&sc->mutex);
+-      ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 1);
+-
+       /* The device has to be moved to FULLSLEEP forcibly.
+        * Otherwise the chip never moved to full sleep,
+        * when no interface is up.
+        */
++      ath9k_hw_disable(sc->sc_ah);
+       ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);

  
  

-       if (changed & BSS_CHANGED_BSSID) {
-@@ -2008,6 +2016,7 @@ static void ath9k_bss_info_changed(struc
-       }
+       return 0;
+@@ -334,22 +333,6 @@ static int ath_pci_resume(struct device 
+       if ((val & 0x0000ff00) != 0)
+               pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);

  
  

-       mutex_unlock(&sc->mutex);
-+      ath9k_ps_restore(sc);
+-      ath9k_ps_wakeup(sc);
+-      /* Enable LED */
+-      ath9k_hw_cfg_output(sc->sc_ah, sc->sc_ah->led_pin,
+-                          AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+-      ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 0);
+-
+-        /*
+-         * Reset key cache to sane defaults (all entries cleared) instead of
+-         * semi-random values after suspend/resume.
+-         */
+-      ath9k_cmn_init_crypto(sc->sc_ah);
+-      ath9k_ps_restore(sc);
+-
+-      sc->ps_idle = true;
+-      ath_radio_disable(sc, hw);
+-
+       return 0;

  }
  
  }
  

- static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
---- a/drivers/net/wireless/ath/ath9k/beacon.c
-+++ b/drivers/net/wireless/ath/ath9k/beacon.c
-@@ -392,14 +392,6 @@ void ath_beacon_tasklet(unsigned long da
-       tsf += TU_TO_USEC(ah->config.sw_beacon_response_time);
-       tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF);
-       slot = (tsftu % (intval * ATH_BCBUF)) / intval;
--      /*
--       * Reverse the slot order to get slot 0 on the TBTT offset that does
--       * not require TSF adjustment and other slots adding
--       * slot/ATH_BCBUF * beacon_int to timestamp. For example, with
--       * ATH_BCBUF = 4, we process beacon slots as follows: 3 2 1 0 3 2 1 ..
--       * and slot 0 is at correct offset to TBTT.
--       */
--      slot = ATH_BCBUF - slot - 1;
-       vif = sc->beacon.bslot[slot];
- 
-       ath_dbg(common, ATH_DBG_BEACON,
-@@ -708,7 +700,7 @@ void ath_beacon_config(struct ath_softc 
-       if (cur_conf->dtim_period == 0)
-               cur_conf->dtim_period = 1;
- 
--      switch (iftype) {
-+      switch (sc->sc_ah->opmode) {
-       case NL80211_IFTYPE_AP:
-               ath_beacon_config_ap(sc, cur_conf);
-               break;
---- a/net/mac80211/rx.c
-+++ b/net/mac80211/rx.c
-@@ -1585,7 +1585,7 @@ ieee80211_drop_unencrypted_mgmt(struct i
+--- a/drivers/net/wireless/ath/ath9k/xmit.c
++++ b/drivers/net/wireless/ath/ath9k/xmit.c
+@@ -1954,7 +1954,7 @@ static void ath_tx_complete(struct ath_s
+               skb_pull(skb, padsize);
+       }
+ 
+-      if (sc->ps_flags & PS_WAIT_FOR_TX_ACK) {
++      if ((sc->ps_flags & PS_WAIT_FOR_TX_ACK) && !txq->axq_depth) {
+               sc->ps_flags &= ~PS_WAIT_FOR_TX_ACK;
+               ath_dbg(common, ATH_DBG_PS,
+                       "Going back to sleep after having received TX status (0x%lx)\n",
+--- a/include/linux/nl80211.h
++++ b/include/linux/nl80211.h
+@@ -2785,9 +2785,11 @@ enum nl80211_ap_sme_features {
+  * @NL80211_FEATURE_SK_TX_STATUS: This driver supports reflecting back
+  *    TX status to the socket error queue when requested with the
+  *    socket option.
++ * @NL80211_FEATURE_HT_IBSS: This driver supports IBSS with HT datarates.
+  */
+ enum nl80211_feature_flags {
+       NL80211_FEATURE_SK_TX_STATUS    = 1 << 0,
++      NL80211_FEATURE_HT_IBSS         = 1 << 1,
+ };
+ 
+ /**
+--- a/include/net/cfg80211.h
++++ b/include/net/cfg80211.h
+@@ -1149,6 +1149,7 @@ struct cfg80211_ibss_params {
+       u8 *ssid;
+       u8 *bssid;
+       struct ieee80211_channel *channel;
++      enum nl80211_channel_type channel_type;
+       u8 *ie;
+       u8 ssid_len, ie_len;
+       u16 beacon_interval;
+@@ -3270,6 +3271,16 @@ void cfg80211_report_obss_beacon(struct 
+                                const u8 *frame, size_t len,
+                                int freq, gfp_t gfp);
+ 
++/*
++ * cfg80211_can_beacon_sec_chan - test if ht40 on extension channel can be used
++ * @wiphy: the wiphy
++ * @chan: main channel
++ * @channel_type: HT mode
++ */
++int cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
++                               struct ieee80211_channel *chan,
++                               enum nl80211_channel_type channel_type);
++
+ /* Logging, debugging and troubleshooting/diagnostic helpers. */
+ 
+ /* wiphy_printk helpers, similar to dev_printk */
+--- a/net/mac80211/agg-rx.c
++++ b/net/mac80211/agg-rx.c
+@@ -185,6 +185,10 @@ static void ieee80211_send_addba_resp(st
+               memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
+       else if (sdata->vif.type == NL80211_IFTYPE_STATION)
+               memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
++      else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
++              memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
++      else if (sdata->vif.type == NL80211_IFTYPE_WDS)
++              memcpy(mgmt->bssid, da, ETH_ALEN);
+ 
+       mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
+                                         IEEE80211_STYPE_ACTION);
+--- a/net/mac80211/agg-tx.c
++++ b/net/mac80211/agg-tx.c
+@@ -55,6 +55,8 @@
+  * @ampdu_action function will be called with the action
+  * %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
+  * and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
++ * Note that the sta can get destroyed before the BA tear down is
++ * complete.
+  */
+ 
+ static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
+@@ -79,10 +81,13 @@ static void ieee80211_send_addba_request
+       memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
+       if (sdata->vif.type == NL80211_IFTYPE_AP ||
+           sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
+-          sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
++          sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
++          sdata->vif.type == NL80211_IFTYPE_WDS)
+               memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
+       else if (sdata->vif.type == NL80211_IFTYPE_STATION)
+               memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
++      else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
++              memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
+ 
+       mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
+                                         IEEE80211_STYPE_ACTION);
+@@ -319,6 +324,38 @@ ieee80211_wake_queue_agg(struct ieee8021
+       __release(agg_queue);

  }
  
  }
  

- static int
--__ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
-+__ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
++/*
++ * splice packets from the STA's pending to the local pending,
++ * requires a call to ieee80211_agg_splice_finish later
++ */
++static void __acquires(agg_queue)
++ieee80211_agg_splice_packets(struct ieee80211_local *local,
++                           struct tid_ampdu_tx *tid_tx, u16 tid)
++{
++      int queue = ieee80211_ac_from_tid(tid);
++      unsigned long flags;
++
++      ieee80211_stop_queue_agg(local, tid);
++
++      if (WARN(!tid_tx, "TID %d gone but expected when splicing aggregates"
++                        " from the pending queue\n", tid))
++              return;
++
++      if (!skb_queue_empty(&tid_tx->pending)) {
++              spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
++              /* copy over remaining packets */
++              skb_queue_splice_tail_init(&tid_tx->pending,
++                                         &local->pending[queue]);
++              spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
++      }
++}
++
++static void __releases(agg_queue)
++ieee80211_agg_splice_finish(struct ieee80211_local *local, u16 tid)
++{
++      ieee80211_wake_queue_agg(local, tid);
++}
++
+ void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)

  {
  {

-       struct ieee80211_sub_if_data *sdata = rx->sdata;
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
-@@ -1593,6 +1593,7 @@ __ieee80211_data_to_8023(struct ieee8021
-       struct ethhdr *ehdr;
-       int ret;
- 
-+      *port_control = false;
-       if (ieee80211_has_a4(hdr->frame_control) &&
-           sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
-               return -1;
-@@ -1611,11 +1612,13 @@ __ieee80211_data_to_8023(struct ieee8021
-               return -1;
- 
-       ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
--      if (ret < 0 || !check_port_control)
-+      if (ret < 0)
-               return ret;
- 
-       ehdr = (struct ethhdr *) rx->skb->data;
--      if (ehdr->h_proto != rx->sdata->control_port_protocol)
-+      if (ehdr->h_proto == rx->sdata->control_port_protocol)
-+              *port_control = true;
-+      else if (check_port_control)
-               return -1;
+       struct tid_ampdu_tx *tid_tx;
+@@ -330,19 +367,17 @@ void ieee80211_tx_ba_session_handle_star
+       tid_tx = rcu_dereference_protected_tid_tx(sta, tid);

  
  

-       return 0;
-@@ -1916,6 +1919,7 @@ ieee80211_rx_h_data(struct ieee80211_rx_
-       struct net_device *dev = sdata->dev;
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
-       __le16 fc = hdr->frame_control;
-+      bool port_control;
-       int err;
- 
-       if (unlikely(!ieee80211_is_data(hdr->frame_control)))
-@@ -1932,13 +1936,21 @@ ieee80211_rx_h_data(struct ieee80211_rx_
-           sdata->vif.type == NL80211_IFTYPE_AP)
-               return RX_DROP_MONITOR;
+       /*
+-       * While we're asking the driver about the aggregation,
+-       * stop the AC queue so that we don't have to worry
+-       * about frames that came in while we were doing that,
+-       * which would require us to put them to the AC pending
+-       * afterwards which just makes the code more complex.
++       * Start queuing up packets for this aggregation session.
++       * We're going to release them once the driver is OK with
++       * that.
+        */
+-      ieee80211_stop_queue_agg(local, tid);
+-
+       clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);

  
  

--      err = __ieee80211_data_to_8023(rx);
-+      err = __ieee80211_data_to_8023(rx, &port_control);
-       if (unlikely(err))
-               return RX_DROP_UNUSABLE;
+       /*
+-       * make sure no packets are being processed to get
+-       * valid starting sequence number
++       * Make sure no packets are being processed. This ensures that
++       * we have a valid starting sequence number and that in-flight
++       * packets have been flushed out and no packets for this TID
++       * will go into the driver during the ampdu_action call.
+        */
+       synchronize_net();

  
  

-       if (!ieee80211_frame_allowed(rx, fc))
-               return RX_DROP_MONITOR;
+@@ -356,10 +391,11 @@ void ieee80211_tx_ba_session_handle_star
+                                       " tid %d\n", tid);
+ #endif
+               spin_lock_bh(&sta->lock);
++              ieee80211_agg_splice_packets(local, tid_tx, tid);
+               ieee80211_assign_tid_tx(sta, tid, NULL);
++              ieee80211_agg_splice_finish(local, tid);
+               spin_unlock_bh(&sta->lock);
+ 
+-              ieee80211_wake_queue_agg(local, tid);
+ #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
+               kfree_rcu(tid_tx, rcu_head);
+ #else
+@@ -368,9 +404,6 @@ void ieee80211_tx_ba_session_handle_star
+               return;
+       }
+ 
+-      /* we can take packets again now */
+-      ieee80211_wake_queue_agg(local, tid);
+-
+       /* activate the timer for the recipient's addBA response */
+       mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);
+ #ifdef CONFIG_MAC80211_HT_DEBUG
+@@ -437,7 +470,9 @@ int ieee80211_start_tx_ba_session(struct
+       if (sdata->vif.type != NL80211_IFTYPE_STATION &&
+           sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
+           sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
+-          sdata->vif.type != NL80211_IFTYPE_AP)
++          sdata->vif.type != NL80211_IFTYPE_AP &&
++          sdata->vif.type != NL80211_IFTYPE_WDS &&
++          sdata->vif.type != NL80211_IFTYPE_ADHOC)
+               return -EINVAL;
+ 
+       if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
+@@ -448,6 +483,27 @@ int ieee80211_start_tx_ba_session(struct
+               return -EINVAL;
+       }

  
  

-+      if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
-+          unlikely(port_control) && sdata->bss) {
-+              sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
-+                                   u.ap);
-+              dev = sdata->dev;
-+              rx->sdata = sdata;
++      /*
++       * 802.11n-2009 11.5.1.1: If the initiating STA is an HT STA, is a
++       * member of an IBSS, and has no other existing Block Ack agreement
++       * with the recipient STA, then the initiating STA shall transmit a
++       * Probe Request frame to the recipient STA and shall not transmit an
++       * ADDBA Request frame unless it receives a Probe Response frame
++       * from the recipient within dot11ADDBAFailureTimeout.
++       *
++       * The probe request mechanism for ADDBA is currently not implemented,
++       * but we only build up Block Ack session with HT STAs. This information
++       * is set when we receive a bss info from a probe response or a beacon.
++       */
++      if (sta->sdata->vif.type == NL80211_IFTYPE_ADHOC &&
++          !sta->sta.ht_cap.ht_supported) {
++#ifdef CONFIG_MAC80211_HT_DEBUG
++              printk(KERN_DEBUG "BA request denied - IBSS STA %pM"
++                     "does not advertise HT support\n", pubsta->addr);
++#endif /* CONFIG_MAC80211_HT_DEBUG */
++              return -EINVAL;

 +      }
 +
 +      }
 +

-       rx->skb->dev = dev;
+       spin_lock_bh(&sta->lock);

  
  

-       dev->stats.rx_packets++;
---- a/drivers/net/wireless/ath/ath9k/recv.c
-+++ b/drivers/net/wireless/ath/ath9k/recv.c
-@@ -75,7 +75,6 @@ static void ath_rx_buf_link(struct ath_s
-               *sc->rx.rxlink = bf->bf_daddr;
- 
-       sc->rx.rxlink = &ds->ds_link;
--      ath9k_hw_rxena(ah);
+       /* we have tried too many times, receiver does not want A-MPDU */
+@@ -508,38 +564,6 @@ int ieee80211_start_tx_ba_session(struct

  }
  }

+ EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
+ 
+-/*
+- * splice packets from the STA's pending to the local pending,
+- * requires a call to ieee80211_agg_splice_finish later
+- */
+-static void __acquires(agg_queue)
+-ieee80211_agg_splice_packets(struct ieee80211_local *local,
+-                           struct tid_ampdu_tx *tid_tx, u16 tid)
+-{
+-      int queue = ieee80211_ac_from_tid(tid);
+-      unsigned long flags;
+-
+-      ieee80211_stop_queue_agg(local, tid);
+-
+-      if (WARN(!tid_tx, "TID %d gone but expected when splicing aggregates"
+-                        " from the pending queue\n", tid))
+-              return;
+-
+-      if (!skb_queue_empty(&tid_tx->pending)) {
+-              spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
+-              /* copy over remaining packets */
+-              skb_queue_splice_tail_init(&tid_tx->pending,
+-                                         &local->pending[queue]);
+-              spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
+-      }
+-}
+-
+-static void __releases(agg_queue)
+-ieee80211_agg_splice_finish(struct ieee80211_local *local, u16 tid)
+-{
+-      ieee80211_wake_queue_agg(local, tid);
+-}
+-
+ static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
+                                        struct sta_info *sta, u16 tid)
+ {
+--- a/net/mac80211/debugfs_sta.c
++++ b/net/mac80211/debugfs_sta.c
+@@ -63,11 +63,11 @@ static ssize_t sta_flags_read(struct fil
+       test_sta_flag(sta, WLAN_STA_##flg) ? #flg "\n" : ""

  
  

- static void ath_setdefantenna(struct ath_softc *sc, u32 antenna)
-@@ -426,9 +425,7 @@ u32 ath_calcrxfilter(struct ath_softc *s
-       else
-               rfilt |= ATH9K_RX_FILTER_BEACON;
+       int res = scnprintf(buf, sizeof(buf),
+-                          "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
++                          "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+                           TEST(AUTH), TEST(ASSOC), TEST(PS_STA),
+                           TEST(PS_DRIVER), TEST(AUTHORIZED),
+                           TEST(SHORT_PREAMBLE),
+-                          TEST(WME), TEST(WDS), TEST(CLEAR_PS_FILT),
++                          TEST(WME), TEST(CLEAR_PS_FILT),
+                           TEST(MFP), TEST(BLOCK_BA), TEST(PSPOLL),
+                           TEST(UAPSD), TEST(SP), TEST(TDLS_PEER),
+                           TEST(TDLS_PEER_AUTH));
+--- a/net/mac80211/ht.c
++++ b/net/mac80211/ht.c
+@@ -47,7 +47,9 @@ void ieee80211_apply_htcap_overrides(str
+       int i;
+ 
+       if (sdata->vif.type != NL80211_IFTYPE_STATION) {
+-              WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
++              /* AP interfaces call this code when adding new stations,
++               * so just silently ignore non station interfaces.
++               */
+               return;
+       }
+ 
+@@ -282,6 +284,8 @@ void ieee80211_send_delba(struct ieee802
+               memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
+       else if (sdata->vif.type == NL80211_IFTYPE_STATION)
+               memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
++      else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
++              memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);

  
  

--      if ((AR_SREV_9280_20_OR_LATER(sc->sc_ah) ||
--          AR_SREV_9285_12_OR_LATER(sc->sc_ah)) &&
--          (sc->sc_ah->opmode == NL80211_IFTYPE_AP) &&
-+      if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) ||
-           (sc->rx.rxfilter & FIF_PSPOLL))
-               rfilt |= ATH9K_RX_FILTER_PSPOLL;
+       mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
+                                         IEEE80211_STYPE_ACTION);
+--- a/net/mac80211/ibss.c
++++ b/net/mac80211/ibss.c
+@@ -77,6 +77,7 @@ static void __ieee80211_sta_join_ibss(st
+       struct cfg80211_bss *bss;
+       u32 bss_change;
+       u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
++      enum nl80211_channel_type channel_type;

  
  

-@@ -486,12 +483,12 @@ start_recv:
- bool ath_stoprecv(struct ath_softc *sc)
+       lockdep_assert_held(&ifibss->mtx);
+ 
+@@ -105,8 +106,16 @@ static void __ieee80211_sta_join_ibss(st
+ 
+       sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0;
+ 
+-      local->oper_channel = chan;
+-      WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT));
++      channel_type = ifibss->channel_type;
++      if (channel_type > NL80211_CHAN_HT20 &&
++          !cfg80211_can_beacon_sec_chan(local->hw.wiphy, chan, channel_type))
++              channel_type = NL80211_CHAN_HT20;
++      if (!ieee80211_set_channel_type(local, sdata, channel_type)) {
++              /* can only fail due to HT40+/- mismatch */
++              channel_type = NL80211_CHAN_HT20;
++              WARN_ON(!ieee80211_set_channel_type(local, sdata,
++                                                  NL80211_CHAN_HT20));
++      }
+       ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
+ 
+       sband = local->hw.wiphy->bands[chan->band];
+@@ -172,6 +181,19 @@ static void __ieee80211_sta_join_ibss(st
+               memcpy(skb_put(skb, ifibss->ie_len),
+                      ifibss->ie, ifibss->ie_len);
+ 
++      /* add HT capability and information IEs */
++      if (channel_type && sband->ht_cap.ht_supported) {
++              pos = skb_put(skb, 4 +
++                                 sizeof(struct ieee80211_ht_cap) +
++                                 sizeof(struct ieee80211_ht_info));
++              pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
++                                              sband->ht_cap.cap);
++              pos = ieee80211_ie_build_ht_info(pos,
++                                               &sband->ht_cap,
++                                               chan,
++                                               channel_type);
++      }
++
+       if (local->hw.queues >= 4) {
+               pos = skb_put(skb, 9);
+               *pos++ = WLAN_EID_VENDOR_SPECIFIC;
+@@ -195,6 +217,7 @@ static void __ieee80211_sta_join_ibss(st
+       bss_change |= BSS_CHANGED_BEACON;
+       bss_change |= BSS_CHANGED_BEACON_ENABLED;
+       bss_change |= BSS_CHANGED_BASIC_RATES;
++      bss_change |= BSS_CHANGED_HT;
+       bss_change |= BSS_CHANGED_IBSS;
+       sdata->vif.bss_conf.ibss_joined = true;
+       ieee80211_bss_info_change_notify(sdata, bss_change);
+@@ -268,6 +291,8 @@ static void ieee80211_rx_bss_info(struct
+       u64 beacon_timestamp, rx_timestamp;
+       u32 supp_rates = 0;
+       enum ieee80211_band band = rx_status->band;
++      struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
++      bool rates_updated = false;
+ 
+       if (elems->ds_params && elems->ds_params_len == 1)
+               freq = ieee80211_channel_to_frequency(elems->ds_params[0],
+@@ -307,7 +332,7 @@ static void ieee80211_rx_bss_info(struct
+                                               prev_rates,
+                                               sta->sta.supp_rates[band]);
+ #endif
+-                                      rate_control_rate_init(sta);
++                                      rates_updated = true;
+                               }
+                       } else
+                               sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid,
+@@ -318,6 +343,39 @@ static void ieee80211_rx_bss_info(struct
+               if (sta && elems->wmm_info)
+                       set_sta_flag(sta, WLAN_STA_WME);
+ 
++              if (sta && elems->ht_info_elem && elems->ht_cap_elem &&
++                  sdata->u.ibss.channel_type != NL80211_CHAN_NO_HT) {
++                      /* we both use HT */
++                      struct ieee80211_sta_ht_cap sta_ht_cap_new;
++                      enum nl80211_channel_type channel_type =
++                              ieee80211_ht_info_to_channel_type(
++                                                      elems->ht_info_elem);
++
++                      ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
++                                                        elems->ht_cap_elem,
++                                                        &sta_ht_cap_new);
++
++                      /*
++                       * fall back to HT20 if we don't use or use
++                       * the other extension channel
++                       */
++                      if ((channel_type == NL80211_CHAN_HT40MINUS ||
++                           channel_type == NL80211_CHAN_HT40PLUS) &&
++                          channel_type != sdata->u.ibss.channel_type)
++                              sta_ht_cap_new.cap &=
++                                      ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
++
++                      if (memcmp(&sta->sta.ht_cap, &sta_ht_cap_new,
++                                 sizeof(sta_ht_cap_new))) {
++                              memcpy(&sta->sta.ht_cap, &sta_ht_cap_new,
++                                     sizeof(sta_ht_cap_new));
++                              rates_updated = true;
++                      }
++              }
++
++              if (sta && rates_updated)
++                      rate_control_rate_init(sta);
++
+               rcu_read_unlock();
+       }
+ 
+@@ -896,12 +954,18 @@ int ieee80211_ibss_join(struct ieee80211
+                       struct cfg80211_ibss_params *params)

  {
  {

-       struct ath_hw *ah = sc->sc_ah;
--      bool stopped;
-+      bool stopped, reset = false;
- 
-       spin_lock_bh(&sc->rx.rxbuflock);
-       ath9k_hw_abortpcurecv(ah);
-       ath9k_hw_setrxfilter(ah, 0);
--      stopped = ath9k_hw_stopdmarecv(ah);
-+      stopped = ath9k_hw_stopdmarecv(ah, &reset);
- 
-       if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
-               ath_edma_stop_recv(sc);
-@@ -506,7 +503,7 @@ bool ath_stoprecv(struct ath_softc *sc)
-                       "confusing the DMA engine when we start RX up\n");
-               ATH_DBG_WARN_ON_ONCE(!stopped);
+       struct sk_buff *skb;
++      u32 changed = 0;
+ 
+       skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom +
+-                          36 /* bitrates */ +
+-                          34 /* SSID */ +
+-                          3  /* DS params */ +
+-                          4  /* IBSS params */ +
++                          sizeof(struct ieee80211_hdr_3addr) +
++                          12 /* struct ieee80211_mgmt.u.beacon */ +
++                          2 + IEEE80211_MAX_SSID_LEN /* max SSID */ +
++                          2 + 8 /* max Supported Rates */ +
++                          3 /* max DS params */ +
++                          4 /* IBSS params */ +
++                          2 + (IEEE80211_MAX_SUPP_RATES - 8) +
++                          2 + sizeof(struct ieee80211_ht_cap) +
++                          2 + sizeof(struct ieee80211_ht_info) +
+                           params->ie_len);
+       if (!skb)
+               return -ENOMEM;
+@@ -922,13 +986,15 @@ int ieee80211_ibss_join(struct ieee80211
+       sdata->vif.bss_conf.beacon_int = params->beacon_interval;
+ 
+       sdata->u.ibss.channel = params->channel;
++      sdata->u.ibss.channel_type = params->channel_type;
+       sdata->u.ibss.fixed_channel = params->channel_fixed;
+ 
+       /* fix ourselves to that channel now already */
+       if (params->channel_fixed) {
+               sdata->local->oper_channel = params->channel;
+-              WARN_ON(!ieee80211_set_channel_type(sdata->local, sdata,
+-                                                  NL80211_CHAN_NO_HT));
++              if (!ieee80211_set_channel_type(sdata->local, sdata,
++                                             params->channel_type))
++                      return -EINVAL;

        }
        }

--      return stopped;
-+      return stopped && !reset;
- }

  
  

- void ath_flushrecv(struct ath_softc *sc)
-@@ -1767,6 +1764,7 @@ requeue:
-               } else {
-                       list_move_tail(&bf->list, &sc->rx.rxbuf);
-                       ath_rx_buf_link(sc, bf);
-+                      ath9k_hw_rxena(ah);
-               }
-       } while (1);
+       if (params->ie) {
+@@ -951,6 +1017,23 @@ int ieee80211_ibss_join(struct ieee80211
+       ieee80211_recalc_idle(sdata->local);
+       mutex_unlock(&sdata->local->mtx);

  
  

---- a/drivers/net/wireless/ath/ath9k/hw.c
-+++ b/drivers/net/wireless/ath/ath9k/hw.c
-@@ -1249,15 +1249,6 @@ int ath9k_hw_reset(struct ath_hw *ah, st
-       ah->txchainmask = common->tx_chainmask;
-       ah->rxchainmask = common->rx_chainmask;
- 
--      if ((common->bus_ops->ath_bus_type != ATH_USB) && !ah->chip_fullsleep) {
--              ath9k_hw_abortpcurecv(ah);
--              if (!ath9k_hw_stopdmarecv(ah)) {
--                      ath_dbg(common, ATH_DBG_XMIT,
--                              "Failed to stop receive dma\n");
--                      bChannelChange = false;
++      /*
++       * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is
++       * reserved, but an HT STA shall protect HT transmissions as though
++       * the HT Protection field were set to non-HT mixed mode.
++       *
++       * In an IBSS, the RIFS Mode field of the HT Operation element is
++       * also reserved, but an HT STA shall operate as though this field
++       * were set to 1.
++       */
++
++      sdata->vif.bss_conf.ht_operation_mode |=
++                IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
++              | IEEE80211_HT_PARAM_RIFS_MODE;
++
++      changed |= BSS_CHANGED_HT;
++      ieee80211_bss_info_change_notify(sdata, changed);
++
+       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+ 
+       return 0;
+--- a/net/mac80211/ieee80211_i.h
++++ b/net/mac80211/ieee80211_i.h
+@@ -474,6 +474,7 @@ struct ieee80211_if_ibss {
+       u8 ssid_len, ie_len;
+       u8 *ie;
+       struct ieee80211_channel *channel;
++      enum nl80211_channel_type channel_type;
+ 
+       unsigned long ibss_join_req;
+       /* probe response/beacon for IBSS */
+--- a/net/mac80211/iface.c
++++ b/net/mac80211/iface.c
+@@ -178,7 +178,6 @@ static int ieee80211_do_open(struct net_
+ {
+       struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+       struct ieee80211_local *local = sdata->local;
+-      struct sta_info *sta;
+       u32 changed = 0;
+       int res;
+       u32 hw_reconf_flags = 0;
+@@ -309,27 +308,6 @@ static int ieee80211_do_open(struct net_
+ 
+       set_bit(SDATA_STATE_RUNNING, &sdata->state);
+ 
+-      if (sdata->vif.type == NL80211_IFTYPE_WDS) {
+-              /* Create STA entry for the WDS peer */
+-              sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
+-                                   GFP_KERNEL);
+-              if (!sta) {
+-                      res = -ENOMEM;
+-                      goto err_del_interface;

 -              }
 -              }

+-
+-              /* no atomic bitop required since STA is not live yet */
+-              set_sta_flag(sta, WLAN_STA_AUTHORIZED);
+-
+-              res = sta_info_insert(sta);
+-              if (res) {
+-                      /* STA has been freed */
+-                      goto err_del_interface;
+-              }
+-
+-              rate_control_rate_init(sta);

 -      }
 -
 -      }
 -

-       if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE))
-               return -EIO;
+       /*
+        * set_multicast_list will be invoked by the networking core
+        * which will check whether any increments here were done in
+@@ -356,8 +334,7 @@ static int ieee80211_do_open(struct net_
+       netif_tx_start_all_queues(dev);

  
  

---- a/drivers/net/wireless/ath/ath9k/mac.c
-+++ b/drivers/net/wireless/ath/ath9k/mac.c
-@@ -710,27 +710,46 @@ void ath9k_hw_abortpcurecv(struct ath_hw
+       return 0;
+- err_del_interface:
+-      drv_remove_interface(local, sdata);
++
+  err_stop:
+       if (!local->open_count)
+               drv_stop(local);
+@@ -719,6 +696,70 @@ static void ieee80211_if_setup(struct ne
+       dev->destructor = free_netdev;

  }
  }

- EXPORT_SYMBOL(ath9k_hw_abortpcurecv);

  
  

--bool ath9k_hw_stopdmarecv(struct ath_hw *ah)
-+bool ath9k_hw_stopdmarecv(struct ath_hw *ah, bool *reset)
++static void ieee80211_wds_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
++                                       struct sk_buff *skb)
++{
++      struct ieee80211_local *local = sdata->local;
++      struct ieee80211_rx_status *rx_status;
++      struct ieee802_11_elems elems;
++      struct ieee80211_mgmt *mgmt;
++      struct sta_info *sta;
++      size_t baselen;
++      u32 rates = 0;
++      u16 stype;
++      bool new = false;
++      enum ieee80211_band band = local->hw.conf.channel->band;
++      struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
++
++      rx_status = IEEE80211_SKB_RXCB(skb);
++      mgmt = (struct ieee80211_mgmt *) skb->data;
++      stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
++
++      if (stype != IEEE80211_STYPE_BEACON)
++              return;
++
++      baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
++      if (baselen > skb->len)
++              return;
++
++      ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
++                             skb->len - baselen, &elems);
++
++      rates = ieee80211_sta_get_rates(local, &elems, band);
++
++      rcu_read_lock();
++
++      sta = sta_info_get(sdata, sdata->u.wds.remote_addr);
++
++      if (!sta) {
++              rcu_read_unlock();
++              sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
++                                   GFP_KERNEL);
++              if (!sta)
++                      return;
++
++              new = true;
++      }
++
++      sta->last_rx = jiffies;
++      sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
++
++      if (elems.ht_cap_elem)
++              ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
++                              elems.ht_cap_elem, &sta->sta.ht_cap);
++
++      if (elems.wmm_param)
++              set_sta_flag(sta, WLAN_STA_WME);
++
++      if (new) {
++              set_sta_flag(sta, WLAN_STA_AUTHORIZED);
++              rate_control_rate_init(sta);
++              sta_info_insert_rcu(sta);
++      }
++
++      rcu_read_unlock();
++}
++
+ static void ieee80211_iface_work(struct work_struct *work)

  {
  {

- #define AH_RX_STOP_DMA_TIMEOUT 10000   /* usec */
-       struct ath_common *common = ath9k_hw_common(ah);
-+      u32 mac_status, last_mac_status = 0;
-       int i;
+       struct ieee80211_sub_if_data *sdata =
+@@ -823,6 +864,9 @@ static void ieee80211_iface_work(struct 
+                               break;
+                       ieee80211_mesh_rx_queued_mgmt(sdata, skb);
+                       break;
++              case NL80211_IFTYPE_WDS:
++                      ieee80211_wds_rx_queued_mgmt(sdata, skb);
++                      break;
+               default:
+                       WARN(1, "frame for unexpected interface type");
+                       break;
+--- a/net/mac80211/main.c
++++ b/net/mac80211/main.c
+@@ -574,7 +574,8 @@ struct ieee80211_hw *ieee80211_alloc_hw(
+                       WIPHY_FLAG_OFFCHAN_TX |
+                       WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;

  
  

-+      /* Enable access to the DMA observation bus */
-+      REG_WRITE(ah, AR_MACMISC,
-+                ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) |
-+                 (AR_MACMISC_MISC_OBS_BUS_1 <<
-+                  AR_MACMISC_MISC_OBS_BUS_MSB_S)));
-+
-       REG_WRITE(ah, AR_CR, AR_CR_RXD);
+-      wiphy->features = NL80211_FEATURE_SK_TX_STATUS;
++      wiphy->features = NL80211_FEATURE_SK_TX_STATUS |
++                        NL80211_FEATURE_HT_IBSS;

  
  

-       /* Wait for rx enable bit to go low */
-       for (i = AH_RX_STOP_DMA_TIMEOUT / AH_TIME_QUANTUM; i != 0; i--) {
-               if ((REG_READ(ah, AR_CR) & AR_CR_RXE) == 0)
+       if (!ops->set_key)
+               wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
+--- a/net/mac80211/rx.c
++++ b/net/mac80211/rx.c
+@@ -2237,7 +2237,9 @@ ieee80211_rx_h_action(struct ieee80211_r
+               if (sdata->vif.type != NL80211_IFTYPE_STATION &&
+                   sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
+                   sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
+-                  sdata->vif.type != NL80211_IFTYPE_AP)
++                  sdata->vif.type != NL80211_IFTYPE_AP &&
++                  sdata->vif.type != NL80211_IFTYPE_WDS &&
++                  sdata->vif.type != NL80211_IFTYPE_ADHOC)

                        break;
                        break;

+ 
+               /* verify action_code is present */
+@@ -2452,13 +2454,14 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_
+ 
+       if (!ieee80211_vif_is_mesh(&sdata->vif) &&
+           sdata->vif.type != NL80211_IFTYPE_ADHOC &&
+-          sdata->vif.type != NL80211_IFTYPE_STATION)
++          sdata->vif.type != NL80211_IFTYPE_STATION &&
++          sdata->vif.type != NL80211_IFTYPE_WDS)
+               return RX_DROP_MONITOR;
+ 
+       switch (stype) {
+       case cpu_to_le16(IEEE80211_STYPE_BEACON):
+       case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
+-              /* process for all: mesh, mlme, ibss */
++              /* process for all: mesh, mlme, ibss, wds */
+               break;
+       case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
+       case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
+@@ -2796,19 +2799,32 @@ static int prepare_for_handlers(struct i
+                               return 0;
+               } else if (!ieee80211_bssid_match(bssid,
+                                       sdata->vif.addr)) {
++                      /*
++                       * Accept public action frames even when the
++                       * BSSID doesn't match, this is used for P2P
++                       * and location updates. Note that mac80211
++                       * itself never looks at these frames.
++                       */
+                       if (!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
+-                          !ieee80211_is_beacon(hdr->frame_control) &&
+-                          !(ieee80211_is_action(hdr->frame_control) &&
+-                            sdata->vif.p2p))
++                          ieee80211_is_public_action(hdr, skb->len))
++                              return 1;
++                      if (!(status->rx_flags & IEEE80211_RX_IN_SCAN) &&
++                          !ieee80211_is_beacon(hdr->frame_control))
+                               return 0;
+                       status->rx_flags &= ~IEEE80211_RX_RA_MATCH;
+               }
+               break;
+       case NL80211_IFTYPE_WDS:
+-              if (bssid || !ieee80211_is_data(hdr->frame_control))
+-                      return 0;
+               if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2))
+                       return 0;

 +
 +

-+              if (!AR_SREV_9300_20_OR_LATER(ah)) {
-+                      mac_status = REG_READ(ah, AR_DMADBG_7) & 0x7f0;
-+                      if (mac_status == 0x1c0 && mac_status == last_mac_status) {
-+                              *reset = true;
-+                              break;
-+                      }
++              if (ieee80211_is_data(hdr->frame_control) ||
++                  ieee80211_is_action(hdr->frame_control)) {
++                      if (compare_ether_addr(sdata->vif.addr, hdr->addr1))
++                              return 0;
++              } else if (!ieee80211_is_beacon(hdr->frame_control))
++                      return 0;

 +
 +

-+                      last_mac_status = mac_status;
-+              }
+               break;
+       default:
+               /* should never get here */
+--- a/net/mac80211/sta_info.h
++++ b/net/mac80211/sta_info.h
+@@ -31,7 +31,6 @@
+  * @WLAN_STA_SHORT_PREAMBLE: Station is capable of receiving short-preamble
+  *    frames.
+  * @WLAN_STA_WME: Station is a QoS-STA.
+- * @WLAN_STA_WDS: Station is one of our WDS peers.
+  * @WLAN_STA_CLEAR_PS_FILT: Clear PS filter in hardware (using the
+  *    IEEE80211_TX_CTL_CLEAR_PS_FILT control flag) when the next
+  *    frame to this station is transmitted.
+@@ -60,7 +59,6 @@ enum ieee80211_sta_info_flags {
+       WLAN_STA_AUTHORIZED,
+       WLAN_STA_SHORT_PREAMBLE,
+       WLAN_STA_WME,
+-      WLAN_STA_WDS,
+       WLAN_STA_CLEAR_PS_FILT,
+       WLAN_STA_MFP,
+       WLAN_STA_BLOCK_BA,
+--- a/net/mac80211/util.c
++++ b/net/mac80211/util.c
+@@ -1612,6 +1612,11 @@ u8 *ieee80211_ie_build_ht_info(u8 *pos,
+       }
+       if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
+               ht_info->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;

 +
 +

-               udelay(AH_TIME_QUANTUM);
++      /*
++       * Note: According to 802.11n-2009 9.13.3.1, HT Protection field and
++       * RIFS Mode are reserved in IBSS mode, therefore keep them at 0
++       */
+       ht_info->operation_mode = 0x0000;
+       ht_info->stbc_param = 0x0000;
+ 
+--- a/net/wireless/chan.c
++++ b/net/wireless/chan.c
+@@ -6,6 +6,7 @@
+  * Copyright 2009     Johannes Berg <johannes@sipsolutions.net>
+  */
+ 
++#include <linux/export.h>
+ #include <net/cfg80211.h>
+ #include "core.h"
+ 
+@@ -44,9 +45,9 @@ rdev_freq_to_chan(struct cfg80211_regist
+       return chan;
+ }
+ 
+-static bool can_beacon_sec_chan(struct wiphy *wiphy,
+-                              struct ieee80211_channel *chan,
+-                              enum nl80211_channel_type channel_type)
++int cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
++                                struct ieee80211_channel *chan,
++                                enum nl80211_channel_type channel_type)
+ {
+       struct ieee80211_channel *sec_chan;
+       int diff;
+@@ -75,6 +76,7 @@ static bool can_beacon_sec_chan(struct w
+ 
+       return true;
+ }
++EXPORT_SYMBOL(cfg80211_can_beacon_sec_chan);
+ 
+ int cfg80211_set_freq(struct cfg80211_registered_device *rdev,
+                     struct wireless_dev *wdev, int freq,
+@@ -109,8 +111,8 @@ int cfg80211_set_freq(struct cfg80211_re
+               switch (channel_type) {
+               case NL80211_CHAN_HT40PLUS:
+               case NL80211_CHAN_HT40MINUS:
+-                      if (!can_beacon_sec_chan(&rdev->wiphy, chan,
+-                                               channel_type)) {
++                      if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, chan,
++                                                        channel_type)) {
+                               printk(KERN_DEBUG
+                                      "cfg80211: Secondary channel not "
+                                      "allowed to initiate communication\n");
+--- a/net/wireless/nl80211.c
++++ b/net/wireless/nl80211.c
+@@ -4684,13 +4684,41 @@ static int nl80211_join_ibss(struct sk_b
+               ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);

        }
  
        }
  

-       if (i == 0) {
-               ath_err(common,
--                      "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
-+                      "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x DMADBG_7=0x%08x\n",
-                       AH_RX_STOP_DMA_TIMEOUT / 1000,
-                       REG_READ(ah, AR_CR),
--                      REG_READ(ah, AR_DIAG_SW));
-+                      REG_READ(ah, AR_DIAG_SW),
-+                      REG_READ(ah, AR_DMADBG_7));
-               return false;
-       } else {
-               return true;
---- a/drivers/net/wireless/ath/ath9k/mac.h
-+++ b/drivers/net/wireless/ath/ath9k/mac.h
-@@ -695,7 +695,7 @@ bool ath9k_hw_setrxabort(struct ath_hw *
- void ath9k_hw_putrxbuf(struct ath_hw *ah, u32 rxdp);
- void ath9k_hw_startpcureceive(struct ath_hw *ah, bool is_scanning);
- void ath9k_hw_abortpcurecv(struct ath_hw *ah);
--bool ath9k_hw_stopdmarecv(struct ath_hw *ah);
-+bool ath9k_hw_stopdmarecv(struct ath_hw *ah, bool *reset);
- int ath9k_hw_beaconq_setup(struct ath_hw *ah);
- 
- /* Interrupt Handling */
+-      ibss.channel = ieee80211_get_channel(wiphy,
+-              nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
++      if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
++              enum nl80211_channel_type channel_type;
++
++              channel_type = nla_get_u32(
++                              info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
++              if (channel_type != NL80211_CHAN_NO_HT &&
++                  channel_type != NL80211_CHAN_HT20 &&
++                  channel_type != NL80211_CHAN_HT40MINUS &&
++                  channel_type != NL80211_CHAN_HT40PLUS)
++                      return -EINVAL;
++
++              if (channel_type != NL80211_CHAN_NO_HT &&
++                  !(wiphy->features & NL80211_FEATURE_HT_IBSS))
++                      return -EINVAL;
++
++              ibss.channel_type = channel_type;
++      } else {
++              ibss.channel_type = NL80211_CHAN_NO_HT;
++      }
++
++      ibss.channel = rdev_freq_to_chan(rdev,
++              nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
++              ibss.channel_type);
+       if (!ibss.channel ||
+           ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
+           ibss.channel->flags & IEEE80211_CHAN_DISABLED)
+               return -EINVAL;
+ 
++      /* Both channels should be able to initiate communication */
++      if ((ibss.channel_type == NL80211_CHAN_HT40PLUS ||
++           ibss.channel_type == NL80211_CHAN_HT40MINUS) &&
++          !cfg80211_can_beacon_sec_chan(&rdev->wiphy, ibss.channel,
++                                        ibss.channel_type))
++              return -EINVAL;
++
+       ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
+       ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
+ 
+--- a/include/linux/ieee80211.h
++++ b/include/linux/ieee80211.h
+@@ -1695,6 +1695,23 @@ static inline bool ieee80211_is_robust_m
+ }
+ 
+ /**
++ * ieee80211_is_public_action - check if frame is a public action frame
++ * @hdr: the frame
++ * @len: length of the frame
++ */
++static inline bool ieee80211_is_public_action(struct ieee80211_hdr *hdr,
++                                            size_t len)
++{
++      struct ieee80211_mgmt *mgmt = (void *)hdr;
++
++      if (len < 25)
++              return false;
++      if (!ieee80211_is_action(hdr->frame_control))
++              return false;
++      return mgmt->u.action.category == WLAN_CATEGORY_PUBLIC;
++}
++
++/**
+  * ieee80211_fhss_chan_to_freq - get channel frequency
+  * @channel: the FHSS channel
+  *
+--- a/net/mac80211/tx.c
++++ b/net/mac80211/tx.c
+@@ -1332,8 +1332,11 @@ static int invoke_tx_handlers(struct iee
+       if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL))
+               CALL_TXH(ieee80211_tx_h_rate_ctrl);
+ 
+-      if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION))
++      if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION)) {
++              __skb_queue_tail(&tx->skbs, tx->skb);
++              tx->skb = NULL;
+               goto txh_done;
++      }
+ 
+       CALL_TXH(ieee80211_tx_h_michael_mic_add);
+       CALL_TXH(ieee80211_tx_h_sequence);
+--- a/net/mac80211/sta_info.c
++++ b/net/mac80211/sta_info.c
+@@ -851,6 +851,7 @@ static int __must_check __sta_info_destr
+       struct ieee80211_sub_if_data *sdata;
+       unsigned long flags;
+       int ret, i, ac;
++      struct tid_ampdu_tx *tid_tx;
+ 
+       might_sleep();
+ 
+@@ -949,6 +950,30 @@ static int __must_check __sta_info_destr
+       }
+ #endif
+ 
++      /* There could be some memory leaks because of ampdu tx pending queue
++       * not being freed before destroying the station info.
++       *
++       * Make sure that such queues are purged before freeing the station
++       * info.
++       * TODO: We have to somehow postpone the full destruction
++       * until the aggregation stop completes. Refer
++       * http://thread.gmane.org/gmane.linux.kernel.wireless.general/81936
++       */
++      for (i = 0; i < STA_TID_NUM; i++) {
++              if (!sta->ampdu_mlme.tid_tx[i])
++                      continue;
++              tid_tx = sta->ampdu_mlme.tid_tx[i];
++              if (skb_queue_len(&tid_tx->pending)) {
++#ifdef CONFIG_MAC80211_HT_DEBUG
++                      wiphy_debug(local->hw.wiphy, "TX A-MPDU  purging %d "
++                              "packets for tid=%d\n",
++                              skb_queue_len(&tid_tx->pending), i);
++#endif /* CONFIG_MAC80211_HT_DEBUG */
++                      __skb_queue_purge(&tid_tx->pending);
++              }
++              kfree_rcu(tid_tx, rcu_head);
++      }
++
+       __sta_info_free(local, sta);
+ 
+       return 0;
+--- a/drivers/net/wireless/ath/ath9k/calib.c
++++ b/drivers/net/wireless/ath/ath9k/calib.c
+@@ -402,6 +402,7 @@ bool ath9k_hw_getnf(struct ath_hw *ah, s
+       ah->noise = ath9k_hw_getchan_noise(ah, chan);
+       return true;
+ }
++EXPORT_SYMBOL(ath9k_hw_getnf);
+ 
+ void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah,
+                                 struct ath9k_channel *chan)