package/kernel/mac80211/patches/300-pending_work.patch

   1 --- a/drivers/net/wireless/ath/ath10k/mac.c
   2 +++ b/drivers/net/wireless/ath/ath10k/mac.c
   3 @@ -1351,12 +1351,12 @@ static int ath10k_update_channel_list(st
   4                         ch->allow_vht = true;
   5
   6                         ch->allow_ibss =
   7 -                               !(channel->flags & IEEE80211_CHAN_NO_IBSS);
   8 +                               !(channel->flags & IEEE80211_CHAN_NO_IR);
   9
  10                         ch->ht40plus =
  11                                 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
  12
  13 -                       passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN;
  14 +                       passive = channel->flags & IEEE80211_CHAN_NO_IR;
  15                         ch->passive = passive;
  16
  17                         ch->freq = channel->center_freq;
  18 --- a/drivers/net/wireless/ath/ath9k/Kconfig
  19 +++ b/drivers/net/wireless/ath/ath9k/Kconfig
  20 @@ -90,7 +90,7 @@ config ATH9K_DFS_CERTIFIED
  21
  22  config ATH9K_TX99
  23         bool "Atheros ath9k TX99 testing support"
  24 -       depends on CFG80211_CERTIFICATION_ONUS
  25 +       depends on ATH9K_DEBUGFS && CFG80211_CERTIFICATION_ONUS
  26         default n
  27         ---help---
  28           Say N. This should only be enabled on systems undergoing
  29 @@ -108,6 +108,14 @@ config ATH9K_TX99
  30           be evaluated to meet the RF exposure limits set forth in the
  31           governmental SAR regulations.
  32
  33 +config ATH9K_WOW
  34 +       bool "Wake on Wireless LAN support (EXPERIMENTAL)"
  35 +       depends on ATH9K && PM
  36 +       default n
  37 +       ---help---
  38 +         This option enables Wake on Wireless LAN support for certain cards.
  39 +         Currently, AR9462 is supported.
  40 +
  41  config ATH9K_LEGACY_RATE_CONTROL
  42         bool "Atheros ath9k rate control"
  43         depends on ATH9K
  44 --- a/drivers/net/wireless/ath/ath9k/Makefile
  45 +++ b/drivers/net/wireless/ath/ath9k/Makefile
  46 @@ -13,9 +13,9 @@ ath9k-$(CPTCFG_ATH9K_PCI) += pci.o
  47  ath9k-$(CPTCFG_ATH9K_AHB) += ahb.o
  48  ath9k-$(CPTCFG_ATH9K_DEBUGFS) += debug.o
  49  ath9k-$(CPTCFG_ATH9K_DFS_DEBUGFS) += dfs_debug.o
  50 -ath9k-$(CPTCFG_ATH9K_DFS_CERTIFIED) += \
  51 -               dfs.o
  52 -ath9k-$(CONFIG_PM_SLEEP) += wow.o
  53 +ath9k-$(CPTCFG_ATH9K_DFS_CERTIFIED) += dfs.o
  54 +ath9k-$(CPTCFG_ATH9K_TX99) += tx99.o
  55 +ath9k-$(CPTCFG_ATH9K_WOW) += wow.o
  56
  57  obj-$(CPTCFG_ATH9K) += ath9k.o
  58
  59 @@ -41,6 +41,8 @@ ath9k_hw-y:=  \
  60                 ar9003_eeprom.o \
  61                 ar9003_paprd.o
  62
  63 +ath9k_hw-$(CPTCFG_ATH9K_WOW) += ar9003_wow.o
  64 +
  65  ath9k_hw-$(CPTCFG_ATH9K_BTCOEX_SUPPORT) += btcoex.o \
  66                                            ar9003_mci.o
  67  obj-$(CPTCFG_ATH9K_HW) += ath9k_hw.o
  68 --- a/drivers/net/wireless/ath/ath9k/ar9003_hw.c
  69 +++ b/drivers/net/wireless/ath/ath9k/ar9003_hw.c
  70 @@ -581,6 +581,13 @@ static void ar9003_tx_gain_table_mode6(s
  71                         ar9580_1p0_type6_tx_gain_table);
  72  }
  73
  74 +static void ar9003_tx_gain_table_mode7(struct ath_hw *ah)
  75 +{
  76 +       if (AR_SREV_9340(ah))
  77 +               INIT_INI_ARRAY(&ah->iniModesTxGain,
  78 +                              ar9340_cus227_tx_gain_table_1p0);
  79 +}
  80 +
  81  typedef void (*ath_txgain_tab)(struct ath_hw *ah);
  82
  83  static void ar9003_tx_gain_table_apply(struct ath_hw *ah)
  84 @@ -593,6 +600,7 @@ static void ar9003_tx_gain_table_apply(s
  85                 ar9003_tx_gain_table_mode4,
  86                 ar9003_tx_gain_table_mode5,
  87                 ar9003_tx_gain_table_mode6,
  88 +               ar9003_tx_gain_table_mode7,
  89         };
  90         int idx = ar9003_hw_get_tx_gain_idx(ah);
  91
  92 @@ -750,6 +758,9 @@ static void ar9003_hw_init_mode_gain_reg
  93  static void ar9003_hw_configpcipowersave(struct ath_hw *ah,
  94                                          bool power_off)
  95  {
  96 +       unsigned int i;
  97 +       struct ar5416IniArray *array;
  98 +
  99         /*
 100          * Increase L1 Entry Latency. Some WB222 boards don't have
 101          * this change in eeprom/OTP.
 102 @@ -775,18 +786,13 @@ static void ar9003_hw_configpcipowersave
 103          * Configire PCIE after Ini init. SERDES values now come from ini file
 104          * This enables PCIe low power mode.
 105          */
 106 -       if (ah->config.pcieSerDesWrite) {
 107 -               unsigned int i;
 108 -               struct ar5416IniArray *array;
 109 -
 110 -               array = power_off ? &ah->iniPcieSerdes :
 111 -                                   &ah->iniPcieSerdesLowPower;
 112 -
 113 -               for (i = 0; i < array->ia_rows; i++) {
 114 -                       REG_WRITE(ah,
 115 -                                 INI_RA(array, i, 0),
 116 -                                 INI_RA(array, i, 1));
 117 -               }
 118 +       array = power_off ? &ah->iniPcieSerdes :
 119 +               &ah->iniPcieSerdesLowPower;
 120 +
 121 +       for (i = 0; i < array->ia_rows; i++) {
 122 +               REG_WRITE(ah,
 123 +                         INI_RA(array, i, 0),
 124 +                         INI_RA(array, i, 1));
 125         }
 126  }
 127
 128 --- a/drivers/net/wireless/ath/ath9k/ar9340_initvals.h
 129 +++ b/drivers/net/wireless/ath/ath9k/ar9340_initvals.h
 130 @@ -1447,4 +1447,106 @@ static const u32 ar9340_1p0_soc_preamble
 131         {0x00007038, 0x000004c2},
 132  };
 133
 134 +static const u32 ar9340_cus227_tx_gain_table_1p0[][5] = {
 135 +       /* Addr      5G_HT20     5G_HT40     2G_HT40     2G_HT20   */
 136 +       {0x0000a2dc, 0x0380c7fc, 0x0380c7fc, 0x03aaa352, 0x03aaa352},
 137 +       {0x0000a2e0, 0x0000f800, 0x0000f800, 0x03ccc584, 0x03ccc584},
 138 +       {0x0000a2e4, 0x03ff0000, 0x03ff0000, 0x03f0f800, 0x03f0f800},
 139 +       {0x0000a2e8, 0x00000000, 0x00000000, 0x03ff0000, 0x03ff0000},
 140 +       {0x0000a410, 0x000050d9, 0x000050d9, 0x000050d9, 0x000050d9},
 141 +       {0x0000a500, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 142 +       {0x0000a504, 0x06000003, 0x06000003, 0x04000002, 0x04000002},
 143 +       {0x0000a508, 0x0a000020, 0x0a000020, 0x08000004, 0x08000004},
 144 +       {0x0000a50c, 0x10000023, 0x10000023, 0x0b000200, 0x0b000200},
 145 +       {0x0000a510, 0x16000220, 0x16000220, 0x0f000202, 0x0f000202},
 146 +       {0x0000a514, 0x1c000223, 0x1c000223, 0x11000400, 0x11000400},
 147 +       {0x0000a518, 0x21002220, 0x21002220, 0x15000402, 0x15000402},
 148 +       {0x0000a51c, 0x27002223, 0x27002223, 0x19000404, 0x19000404},
 149 +       {0x0000a520, 0x2c022220, 0x2c022220, 0x1b000603, 0x1b000603},
 150 +       {0x0000a524, 0x30022222, 0x30022222, 0x1f000a02, 0x1f000a02},
 151 +       {0x0000a528, 0x35022225, 0x35022225, 0x23000a04, 0x23000a04},
 152 +       {0x0000a52c, 0x3b02222a, 0x3b02222a, 0x26000a20, 0x26000a20},
 153 +       {0x0000a530, 0x3f02222c, 0x3f02222c, 0x2a000e20, 0x2a000e20},
 154 +       {0x0000a534, 0x4202242a, 0x4202242a, 0x2e000e22, 0x2e000e22},
 155 +       {0x0000a538, 0x4702244a, 0x4702244a, 0x31000e24, 0x31000e24},
 156 +       {0x0000a53c, 0x4b02244c, 0x4b02244c, 0x34001640, 0x34001640},
 157 +       {0x0000a540, 0x4e02246c, 0x4e02246c, 0x38001660, 0x38001660},
 158 +       {0x0000a544, 0x5302266c, 0x5302266c, 0x3b001861, 0x3b001861},
 159 +       {0x0000a548, 0x5702286c, 0x5702286c, 0x3e001a81, 0x3e001a81},
 160 +       {0x0000a54c, 0x5c02486b, 0x5c02486b, 0x42001a83, 0x42001a83},
 161 +       {0x0000a550, 0x61024a6c, 0x61024a6c, 0x44001c84, 0x44001c84},
 162 +       {0x0000a554, 0x66026a6c, 0x66026a6c, 0x48001ce3, 0x48001ce3},
 163 +       {0x0000a558, 0x6b026e6c, 0x6b026e6c, 0x4c001ce5, 0x4c001ce5},
 164 +       {0x0000a55c, 0x7002708c, 0x7002708c, 0x50001ce9, 0x50001ce9},
 165 +       {0x0000a560, 0x7302b08a, 0x7302b08a, 0x54001ceb, 0x54001ceb},
 166 +       {0x0000a564, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 167 +       {0x0000a568, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 168 +       {0x0000a56c, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 169 +       {0x0000a570, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 170 +       {0x0000a574, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 171 +       {0x0000a578, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 172 +       {0x0000a57c, 0x7702b08c, 0x7702b08c, 0x56001eec, 0x56001eec},
 173 +       {0x0000a580, 0x00800000, 0x00800000, 0x00800000, 0x00800000},
 174 +       {0x0000a584, 0x06800003, 0x06800003, 0x04800002, 0x04800002},
 175 +       {0x0000a588, 0x0a800020, 0x0a800020, 0x08800004, 0x08800004},
 176 +       {0x0000a58c, 0x10800023, 0x10800023, 0x0b800200, 0x0b800200},
 177 +       {0x0000a590, 0x16800220, 0x16800220, 0x0f800202, 0x0f800202},
 178 +       {0x0000a594, 0x1c800223, 0x1c800223, 0x11800400, 0x11800400},
 179 +       {0x0000a598, 0x21820220, 0x21820220, 0x15800402, 0x15800402},
 180 +       {0x0000a59c, 0x27820223, 0x27820223, 0x19800404, 0x19800404},
 181 +       {0x0000a5a0, 0x2b822220, 0x2b822220, 0x1b800603, 0x1b800603},
 182 +       {0x0000a5a4, 0x2f822222, 0x2f822222, 0x1f800a02, 0x1f800a02},
 183 +       {0x0000a5a8, 0x34822225, 0x34822225, 0x23800a04, 0x23800a04},
 184 +       {0x0000a5ac, 0x3a82222a, 0x3a82222a, 0x26800a20, 0x26800a20},
 185 +       {0x0000a5b0, 0x3e82222c, 0x3e82222c, 0x2a800e20, 0x2a800e20},
 186 +       {0x0000a5b4, 0x4282242a, 0x4282242a, 0x2e800e22, 0x2e800e22},
 187 +       {0x0000a5b8, 0x4782244a, 0x4782244a, 0x31800e24, 0x31800e24},
 188 +       {0x0000a5bc, 0x4b82244c, 0x4b82244c, 0x34801640, 0x34801640},
 189 +       {0x0000a5c0, 0x4e82246c, 0x4e82246c, 0x38801660, 0x38801660},
 190 +       {0x0000a5c4, 0x5382266c, 0x5382266c, 0x3b801861, 0x3b801861},
 191 +       {0x0000a5c8, 0x5782286c, 0x5782286c, 0x3e801a81, 0x3e801a81},
 192 +       {0x0000a5cc, 0x5c84286b, 0x5c84286b, 0x42801a83, 0x42801a83},
 193 +       {0x0000a5d0, 0x61842a6c, 0x61842a6c, 0x44801c84, 0x44801c84},
 194 +       {0x0000a5d4, 0x66862a6c, 0x66862a6c, 0x48801ce3, 0x48801ce3},
 195 +       {0x0000a5d8, 0x6b862e6c, 0x6b862e6c, 0x4c801ce5, 0x4c801ce5},
 196 +       {0x0000a5dc, 0x7086308c, 0x7086308c, 0x50801ce9, 0x50801ce9},
 197 +       {0x0000a5e0, 0x738a308a, 0x738a308a, 0x54801ceb, 0x54801ceb},
 198 +       {0x0000a5e4, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 199 +       {0x0000a5e8, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 200 +       {0x0000a5ec, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 201 +       {0x0000a5f0, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 202 +       {0x0000a5f4, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 203 +       {0x0000a5f8, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 204 +       {0x0000a5fc, 0x778a308c, 0x778a308c, 0x56801eec, 0x56801eec},
 205 +       {0x0000a600, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 206 +       {0x0000a604, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 207 +       {0x0000a608, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 208 +       {0x0000a60c, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 209 +       {0x0000a610, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
 210 +       {0x0000a614, 0x01404000, 0x01404000, 0x01404000, 0x01404000},
 211 +       {0x0000a618, 0x01404501, 0x01404501, 0x01404501, 0x01404501},
 212 +       {0x0000a61c, 0x02008802, 0x02008802, 0x02008501, 0x02008501},
 213 +       {0x0000a620, 0x0300cc03, 0x0300cc03, 0x0280ca03, 0x0280ca03},
 214 +       {0x0000a624, 0x0300cc03, 0x0300cc03, 0x03010c04, 0x03010c04},
 215 +       {0x0000a628, 0x0300cc03, 0x0300cc03, 0x04014c04, 0x04014c04},
 216 +       {0x0000a62c, 0x03810c03, 0x03810c03, 0x04015005, 0x04015005},
 217 +       {0x0000a630, 0x03810e04, 0x03810e04, 0x04015005, 0x04015005},
 218 +       {0x0000a634, 0x03810e04, 0x03810e04, 0x04015005, 0x04015005},
 219 +       {0x0000a638, 0x03810e04, 0x03810e04, 0x04015005, 0x04015005},
 220 +       {0x0000a63c, 0x03810e04, 0x03810e04, 0x04015005, 0x04015005},
 221 +       {0x0000b2dc, 0x0380c7fc, 0x0380c7fc, 0x03aaa352, 0x03aaa352},
 222 +       {0x0000b2e0, 0x0000f800, 0x0000f800, 0x03ccc584, 0x03ccc584},
 223 +       {0x0000b2e4, 0x03ff0000, 0x03ff0000, 0x03f0f800, 0x03f0f800},
 224 +       {0x0000b2e8, 0x00000000, 0x00000000, 0x03ff0000, 0x03ff0000},
 225 +       {0x00016044, 0x056db2db, 0x056db2db, 0x03b6d2e4, 0x03b6d2e4},
 226 +       {0x00016048, 0x24925666, 0x24925666, 0x8e481266, 0x8e481266},
 227 +       {0x00016280, 0x01000015, 0x01000015, 0x01001015, 0x01001015},
 228 +       {0x00016288, 0x30318000, 0x30318000, 0x00318000, 0x00318000},
 229 +       {0x00016444, 0x056db2db, 0x056db2db, 0x03b6d2e4, 0x03b6d2e4},
 230 +       {0x00016448, 0x24925666, 0x24925666, 0x8e481266, 0x8e481266},
 231 +       {0x0000a3a4, 0x00000011, 0x00000011, 0x00000011, 0x00000011},
 232 +       {0x0000a3a8, 0x3c3c3c3c, 0x3c3c3c3c, 0x3c3c3c3c, 0x3c3c3c3c},
 233 +       {0x0000a3ac, 0x30303030, 0x30303030, 0x30303030, 0x30303030},
 234 +};
 235 +
 236  #endif /* INITVALS_9340_H */
 237 --- a/drivers/net/wireless/ath/ath9k/ath9k.h
 238 +++ b/drivers/net/wireless/ath/ath9k/ath9k.h
 239 @@ -459,6 +459,7 @@ void ath_check_ani(struct ath_softc *sc)
 240  int ath_update_survey_stats(struct ath_softc *sc);
 241  void ath_update_survey_nf(struct ath_softc *sc, int channel);
 242  void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type);
 243 +void ath_ps_full_sleep(unsigned long data);
 244
 245  /**********/
 246  /* BTCOEX */
 247 @@ -570,6 +571,34 @@ static inline void ath_fill_led_pin(stru
 248  }
 249  #endif
 250
 251 +/************************/
 252 +/* Wake on Wireless LAN */
 253 +/************************/
 254 +
 255 +#ifdef CONFIG_ATH9K_WOW
 256 +void ath9k_init_wow(struct ieee80211_hw *hw);
 257 +int ath9k_suspend(struct ieee80211_hw *hw,
 258 +                 struct cfg80211_wowlan *wowlan);
 259 +int ath9k_resume(struct ieee80211_hw *hw);
 260 +void ath9k_set_wakeup(struct ieee80211_hw *hw, bool enabled);
 261 +#else
 262 +static inline void ath9k_init_wow(struct ieee80211_hw *hw)
 263 +{
 264 +}
 265 +static inline int ath9k_suspend(struct ieee80211_hw *hw,
 266 +                               struct cfg80211_wowlan *wowlan)
 267 +{
 268 +       return 0;
 269 +}
 270 +static inline int ath9k_resume(struct ieee80211_hw *hw)
 271 +{
 272 +       return 0;
 273 +}
 274 +static inline void ath9k_set_wakeup(struct ieee80211_hw *hw, bool enabled)
 275 +{
 276 +}
 277 +#endif /* CONFIG_ATH9K_WOW */
 278 +
 279  /*******************************/
 280  /* Antenna diversity/combining */
 281  /*******************************/
 282 @@ -723,6 +752,7 @@ struct ath_softc {
 283         struct work_struct hw_check_work;
 284         struct work_struct hw_reset_work;
 285         struct completion paprd_complete;
 286 +       wait_queue_head_t tx_wait;
 287
 288         unsigned int hw_busy_count;
 289         unsigned long sc_flags;
 290 @@ -759,6 +789,7 @@ struct ath_softc {
 291         struct delayed_work tx_complete_work;
 292         struct delayed_work hw_pll_work;
 293         struct timer_list rx_poll_timer;
 294 +       struct timer_list sleep_timer;
 295
 296  #ifdef CPTCFG_ATH9K_BTCOEX_SUPPORT
 297         struct ath_btcoex btcoex;
 298 @@ -783,7 +814,7 @@ struct ath_softc {
 299         bool tx99_state;
 300         s16 tx99_power;
 301
 302 -#ifdef CONFIG_PM_SLEEP
 303 +#ifdef CONFIG_ATH9K_WOW
 304         atomic_t wow_got_bmiss_intr;
 305         atomic_t wow_sleep_proc_intr; /* in the middle of WoW sleep ? */
 306         u32 wow_intr_before_sleep;
 307 @@ -946,10 +977,25 @@ struct fft_sample_ht20_40 {
 308         u8 data[SPECTRAL_HT20_40_NUM_BINS];
 309  } __packed;
 310
 311 -int ath9k_tx99_init(struct ath_softc *sc);
 312 -void ath9k_tx99_deinit(struct ath_softc *sc);
 313 +/********/
 314 +/* TX99 */
 315 +/********/
 316 +
 317 +#ifdef CONFIG_ATH9K_TX99
 318 +void ath9k_tx99_init_debug(struct ath_softc *sc);
 319  int ath9k_tx99_send(struct ath_softc *sc, struct sk_buff *skb,
 320                     struct ath_tx_control *txctl);
 321 +#else
 322 +static inline void ath9k_tx99_init_debug(struct ath_softc *sc)
 323 +{
 324 +}
 325 +static inline int ath9k_tx99_send(struct ath_softc *sc,
 326 +                                 struct sk_buff *skb,
 327 +                                 struct ath_tx_control *txctl)
 328 +{
 329 +       return 0;
 330 +}
 331 +#endif /* CONFIG_ATH9K_TX99 */
 332
 333  void ath9k_tasklet(unsigned long data);
 334  int ath_cabq_update(struct ath_softc *);
 335 @@ -966,6 +1012,9 @@ extern bool is_ath9k_unloaded;
 336
 337  u8 ath9k_parse_mpdudensity(u8 mpdudensity);
 338  irqreturn_t ath_isr(int irq, void *dev);
 339 +int ath_reset(struct ath_softc *sc);
 340 +void ath_cancel_work(struct ath_softc *sc);
 341 +void ath_restart_work(struct ath_softc *sc);
 342  int ath9k_init_device(u16 devid, struct ath_softc *sc,
 343                     const struct ath_bus_ops *bus_ops);
 344  void ath9k_deinit_device(struct ath_softc *sc);
 345 --- a/drivers/net/wireless/ath/ath9k/debug.c
 346 +++ b/drivers/net/wireless/ath/ath9k/debug.c
 347 @@ -1782,111 +1782,6 @@ void ath9k_deinit_debug(struct ath_softc
 348         }
 349  }
 350
 351 -static ssize_t read_file_tx99(struct file *file, char __user *user_buf,
 352 -                             size_t count, loff_t *ppos)
 353 -{
 354 -       struct ath_softc *sc = file->private_data;
 355 -       char buf[3];
 356 -       unsigned int len;
 357 -
 358 -       len = sprintf(buf, "%d\n", sc->tx99_state);
 359 -       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 360 -}
 361 -
 362 -static ssize_t write_file_tx99(struct file *file, const char __user *user_buf,
 363 -                              size_t count, loff_t *ppos)
 364 -{
 365 -       struct ath_softc *sc = file->private_data;
 366 -       struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 367 -       char buf[32];
 368 -       bool start;
 369 -       ssize_t len;
 370 -       int r;
 371 -
 372 -       if (sc->nvifs > 1)
 373 -               return -EOPNOTSUPP;
 374 -
 375 -       len = min(count, sizeof(buf) - 1);
 376 -       if (copy_from_user(buf, user_buf, len))
 377 -               return -EFAULT;
 378 -
 379 -       if (strtobool(buf, &start))
 380 -               return -EINVAL;
 381 -
 382 -       if (start == sc->tx99_state) {
 383 -               if (!start)
 384 -                       return count;
 385 -               ath_dbg(common, XMIT, "Resetting TX99\n");
 386 -               ath9k_tx99_deinit(sc);
 387 -       }
 388 -
 389 -       if (!start) {
 390 -               ath9k_tx99_deinit(sc);
 391 -               return count;
 392 -       }
 393 -
 394 -       r = ath9k_tx99_init(sc);
 395 -       if (r)
 396 -               return r;
 397 -
 398 -       return count;
 399 -}
 400 -
 401 -static const struct file_operations fops_tx99 = {
 402 -       .read = read_file_tx99,
 403 -       .write = write_file_tx99,
 404 -       .open = simple_open,
 405 -       .owner = THIS_MODULE,
 406 -       .llseek = default_llseek,
 407 -};
 408 -
 409 -static ssize_t read_file_tx99_power(struct file *file,
 410 -                                   char __user *user_buf,
 411 -                                   size_t count, loff_t *ppos)
 412 -{
 413 -       struct ath_softc *sc = file->private_data;
 414 -       char buf[32];
 415 -       unsigned int len;
 416 -
 417 -       len = sprintf(buf, "%d (%d dBm)\n",
 418 -                     sc->tx99_power,
 419 -                     sc->tx99_power / 2);
 420 -
 421 -       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 422 -}
 423 -
 424 -static ssize_t write_file_tx99_power(struct file *file,
 425 -                                    const char __user *user_buf,
 426 -                                    size_t count, loff_t *ppos)
 427 -{
 428 -       struct ath_softc *sc = file->private_data;
 429 -       int r;
 430 -       u8 tx_power;
 431 -
 432 -       r = kstrtou8_from_user(user_buf, count, 0, &tx_power);
 433 -       if (r)
 434 -               return r;
 435 -
 436 -       if (tx_power > MAX_RATE_POWER)
 437 -               return -EINVAL;
 438 -
 439 -       sc->tx99_power = tx_power;
 440 -
 441 -       ath9k_ps_wakeup(sc);
 442 -       ath9k_hw_tx99_set_txpower(sc->sc_ah, sc->tx99_power);
 443 -       ath9k_ps_restore(sc);
 444 -
 445 -       return count;
 446 -}
 447 -
 448 -static const struct file_operations fops_tx99_power = {
 449 -       .read = read_file_tx99_power,
 450 -       .write = write_file_tx99_power,
 451 -       .open = simple_open,
 452 -       .owner = THIS_MODULE,
 453 -       .llseek = default_llseek,
 454 -};
 455 -
 456  int ath9k_init_debug(struct ath_hw *ah)
 457  {
 458         struct ath_common *common = ath9k_hw_common(ah);
 459 @@ -1903,6 +1798,7 @@ int ath9k_init_debug(struct ath_hw *ah)
 460  #endif
 461
 462         ath9k_dfs_init_debug(sc);
 463 +       ath9k_tx99_init_debug(sc);
 464
 465         debugfs_create_file("dma", S_IRUSR, sc->debug.debugfs_phy, sc,
 466                             &fops_dma);
 467 @@ -1978,15 +1874,6 @@ int ath9k_init_debug(struct ath_hw *ah)
 468         debugfs_create_file("btcoex", S_IRUSR, sc->debug.debugfs_phy, sc,
 469                             &fops_btcoex);
 470  #endif
 471 -       if (config_enabled(CPTCFG_ATH9K_TX99) &&
 472 -           AR_SREV_9300_20_OR_LATER(ah)) {
 473 -               debugfs_create_file("tx99", S_IRUSR | S_IWUSR,
 474 -                                   sc->debug.debugfs_phy, sc,
 475 -                                   &fops_tx99);
 476 -               debugfs_create_file("tx99_power", S_IRUSR | S_IWUSR,
 477 -                                   sc->debug.debugfs_phy, sc,
 478 -                                   &fops_tx99_power);
 479 -       }
 480
 481         return 0;
 482  }
 483 --- a/drivers/net/wireless/ath/ath9k/hw.c
 484 +++ b/drivers/net/wireless/ath/ath9k/hw.c
 485 @@ -454,7 +454,6 @@ static void ath9k_hw_init_config(struct
 486         }
 487
 488         ah->config.rx_intr_mitigation = true;
 489 -       ah->config.pcieSerDesWrite = true;
 490
 491         /*
 492          * We need this for PCI devices only (Cardbus, PCI, miniPCI)
 493 --- a/drivers/net/wireless/ath/ath9k/hw.h
 494 +++ b/drivers/net/wireless/ath/ath9k/hw.h
 495 @@ -283,7 +283,6 @@ struct ath9k_ops_config {
 496         int additional_swba_backoff;
 497         int ack_6mb;
 498         u32 cwm_ignore_extcca;
 499 -       bool pcieSerDesWrite;
 500         u8 pcie_clock_req;
 501         u32 pcie_waen;
 502         u8 analog_shiftreg;
 503 @@ -920,7 +919,7 @@ struct ath_hw {
 504         /* Enterprise mode cap */
 505         u32 ent_mode;
 506
 507 -#ifdef CONFIG_PM_SLEEP
 508 +#ifdef CONFIG_ATH9K_WOW
 509         u32 wow_event_mask;
 510  #endif
 511         bool is_clk_25mhz;
 512 @@ -1126,7 +1125,7 @@ ath9k_hw_get_btcoex_scheme(struct ath_hw
 513  #endif /* CPTCFG_ATH9K_BTCOEX_SUPPORT */
 514
 515
 516 -#ifdef CONFIG_PM_SLEEP
 517 +#ifdef CONFIG_ATH9K_WOW
 518  const char *ath9k_hw_wow_event_to_string(u32 wow_event);
 519  void ath9k_hw_wow_apply_pattern(struct ath_hw *ah, u8 *user_pattern,
 520                                 u8 *user_mask, int pattern_count,
 521 --- a/drivers/net/wireless/ath/ath9k/init.c
 522 +++ b/drivers/net/wireless/ath/ath9k/init.c
 523 @@ -683,6 +683,7 @@ static int ath9k_init_softc(u16 devid, s
 524         common = ath9k_hw_common(ah);
 525         sc->dfs_detector = dfs_pattern_detector_init(common, NL80211_DFS_UNSET);
 526         sc->tx99_power = MAX_RATE_POWER + 1;
 527 +       init_waitqueue_head(&sc->tx_wait);
 528
 529         if (!pdata) {
 530                 ah->ah_flags |= AH_USE_EEPROM;
 531 @@ -730,6 +731,7 @@ static int ath9k_init_softc(u16 devid, s
 532         tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet,
 533                      (unsigned long)sc);
 534
 535 +       setup_timer(&sc->sleep_timer, ath_ps_full_sleep, (unsigned long)sc);
 536         INIT_WORK(&sc->hw_reset_work, ath_reset_work);
 537         INIT_WORK(&sc->hw_check_work, ath_hw_check);
 538         INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
 539 @@ -862,20 +864,11 @@ static const struct ieee80211_iface_comb
 540                 .max_interfaces = 1,
 541                 .num_different_channels = 1,
 542                 .beacon_int_infra_match = true,
 543 -               .radar_detect_widths =  BIT(NL80211_CHAN_NO_HT) |
 544 -                                       BIT(NL80211_CHAN_HT20),
 545 +               .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
 546 +                                       BIT(NL80211_CHAN_WIDTH_20),
 547         }
 548  };
 549
 550 -#ifdef CONFIG_PM
 551 -static const struct wiphy_wowlan_support ath9k_wowlan_support = {
 552 -       .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
 553 -       .n_patterns = MAX_NUM_USER_PATTERN,
 554 -       .pattern_min_len = 1,
 555 -       .pattern_max_len = MAX_PATTERN_SIZE,
 556 -};
 557 -#endif
 558 -
 559  void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
 560  {
 561         struct ath_hw *ah = sc->sc_ah;
 562 @@ -925,16 +918,6 @@ void ath9k_set_hw_capab(struct ath_softc
 563         hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_5_10_MHZ;
 564         hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
 565
 566 -#ifdef CONFIG_PM_SLEEP
 567 -       if ((ah->caps.hw_caps & ATH9K_HW_WOW_DEVICE_CAPABLE) &&
 568 -           (sc->driver_data & ATH9K_PCI_WOW) &&
 569 -           device_can_wakeup(sc->dev))
 570 -               hw->wiphy->wowlan = &ath9k_wowlan_support;
 571 -
 572 -       atomic_set(&sc->wow_sleep_proc_intr, -1);
 573 -       atomic_set(&sc->wow_got_bmiss_intr, -1);
 574 -#endif
 575 -
 576         hw->queues = 4;
 577         hw->max_rates = 4;
 578         hw->channel_change_time = 5000;
 579 @@ -960,6 +943,7 @@ void ath9k_set_hw_capab(struct ath_softc
 580                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 581                         &sc->sbands[IEEE80211_BAND_5GHZ];
 582
 583 +       ath9k_init_wow(hw);
 584         ath9k_reload_chainmask_settings(sc);
 585
 586         SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
 587 @@ -1058,6 +1042,7 @@ static void ath9k_deinit_softc(struct at
 588                 if (ATH_TXQ_SETUP(sc, i))
 589                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 590
 591 +       del_timer_sync(&sc->sleep_timer);
 592         ath9k_hw_deinit(sc->sc_ah);
 593         if (sc->dfs_detector != NULL)
 594                 sc->dfs_detector->exit(sc->dfs_detector);
 595 --- a/drivers/net/wireless/ath/ath9k/main.c
 596 +++ b/drivers/net/wireless/ath/ath9k/main.c
 597 @@ -82,6 +82,22 @@ static bool ath9k_setpower(struct ath_so
 598         return ret;
 599  }
 600
 601 +void ath_ps_full_sleep(unsigned long data)
 602 +{
 603 +       struct ath_softc *sc = (struct ath_softc *) data;
 604 +       struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 605 +       bool reset;
 606 +
 607 +       spin_lock(&common->cc_lock);
 608 +       ath_hw_cycle_counters_update(common);
 609 +       spin_unlock(&common->cc_lock);
 610 +
 611 +       ath9k_hw_setrxabort(sc->sc_ah, 1);
 612 +       ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
 613 +
 614 +       ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);
 615 +}
 616 +
 617  void ath9k_ps_wakeup(struct ath_softc *sc)
 618  {
 619         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 620 @@ -92,6 +108,7 @@ void ath9k_ps_wakeup(struct ath_softc *s
 621         if (++sc->ps_usecount != 1)
 622                 goto unlock;
 623
 624 +       del_timer_sync(&sc->sleep_timer);
 625         power_mode = sc->sc_ah->power_mode;
 626         ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
 627
 628 @@ -117,17 +134,17 @@ void ath9k_ps_restore(struct ath_softc *
 629         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 630         enum ath9k_power_mode mode;
 631         unsigned long flags;
 632 -       bool reset;
 633
 634         spin_lock_irqsave(&sc->sc_pm_lock, flags);
 635         if (--sc->ps_usecount != 0)
 636                 goto unlock;
 637
 638         if (sc->ps_idle) {
 639 -               ath9k_hw_setrxabort(sc->sc_ah, 1);
 640 -               ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
 641 -               mode = ATH9K_PM_FULL_SLEEP;
 642 -       } else if (sc->ps_enabled &&
 643 +               mod_timer(&sc->sleep_timer, jiffies + HZ / 10);
 644 +               goto unlock;
 645 +       }
 646 +
 647 +       if (sc->ps_enabled &&
 648                    !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
 649                                      PS_WAIT_FOR_CAB |
 650                                      PS_WAIT_FOR_PSPOLL_DATA |
 651 @@ -163,13 +180,13 @@ static void __ath_cancel_work(struct ath
 652  #endif
 653  }
 654
 655 -static void ath_cancel_work(struct ath_softc *sc)
 656 +void ath_cancel_work(struct ath_softc *sc)
 657  {
 658         __ath_cancel_work(sc);
 659         cancel_work_sync(&sc->hw_reset_work);
 660  }
 661
 662 -static void ath_restart_work(struct ath_softc *sc)
 663 +void ath_restart_work(struct ath_softc *sc)
 664  {
 665         ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
 666
 667 @@ -487,6 +504,8 @@ void ath9k_tasklet(unsigned long data)
 668                         ath_tx_edma_tasklet(sc);
 669                 else
 670                         ath_tx_tasklet(sc);
 671 +
 672 +               wake_up(&sc->tx_wait);
 673         }
 674
 675         ath9k_btcoex_handle_interrupt(sc, status);
 676 @@ -579,7 +598,8 @@ irqreturn_t ath_isr(int irq, void *dev)
 677
 678                 goto chip_reset;
 679         }
 680 -#ifdef CONFIG_PM_SLEEP
 681 +
 682 +#ifdef CONFIG_ATH9K_WOW
 683         if (status & ATH9K_INT_BMISS) {
 684                 if (atomic_read(&sc->wow_sleep_proc_intr) == 0) {
 685                         ath_dbg(common, ANY, "during WoW we got a BMISS\n");
 686 @@ -588,6 +608,8 @@ irqreturn_t ath_isr(int irq, void *dev)
 687                 }
 688         }
 689  #endif
 690 +
 691 +
 692         if (status & ATH9K_INT_SWBA)
 693                 tasklet_schedule(&sc->bcon_tasklet);
 694
 695 @@ -627,7 +649,7 @@ chip_reset:
 696  #undef SCHED_INTR
 697  }
 698
 699 -static int ath_reset(struct ath_softc *sc)
 700 +int ath_reset(struct ath_softc *sc)
 701  {
 702         int r;
 703
 704 @@ -1817,13 +1839,31 @@ static void ath9k_set_coverage_class(str
 705         mutex_unlock(&sc->mutex);
 706  }
 707
 708 +static bool ath9k_has_tx_pending(struct ath_softc *sc)
 709 +{
 710 +       int i, npend;
 711 +
 712 +       for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
 713 +               if (!ATH_TXQ_SETUP(sc, i))
 714 +                       continue;
 715 +
 716 +               if (!sc->tx.txq[i].axq_depth)
 717 +                       continue;
 718 +
 719 +               npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
 720 +               if (npend)
 721 +                       break;
 722 +       }
 723 +
 724 +       return !!npend;
 725 +}
 726 +
 727  static void ath9k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
 728  {
 729         struct ath_softc *sc = hw->priv;
 730         struct ath_hw *ah = sc->sc_ah;
 731         struct ath_common *common = ath9k_hw_common(ah);
 732 -       int timeout = 200; /* ms */
 733 -       int i, j;
 734 +       int timeout = HZ / 5; /* 200 ms */
 735         bool drain_txq;
 736
 737         mutex_lock(&sc->mutex);
 738 @@ -1841,25 +1881,9 @@ static void ath9k_flush(struct ieee80211
 739                 return;
 740         }
 741
 742 -       for (j = 0; j < timeout; j++) {
 743 -               bool npend = false;
 744 -
 745 -               if (j)
 746 -                       usleep_range(1000, 2000);
 747 -
 748 -               for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
 749 -                       if (!ATH_TXQ_SETUP(sc, i))
 750 -                               continue;
 751 -
 752 -                       npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
 753 -
 754 -                       if (npend)
 755 -                               break;
 756 -               }
 757 -
 758 -               if (!npend)
 759 -                   break;
 760 -       }
 761 +       if (wait_event_timeout(sc->tx_wait, !ath9k_has_tx_pending(sc),
 762 +                              timeout) > 0)
 763 +               drop = false;
 764
 765         if (drop) {
 766                 ath9k_ps_wakeup(sc);
 767 @@ -2021,333 +2045,6 @@ static int ath9k_get_antenna(struct ieee
 768         return 0;
 769  }
 770
 771 -#ifdef CONFIG_PM_SLEEP
 772 -
 773 -static void ath9k_wow_map_triggers(struct ath_softc *sc,
 774 -                                  struct cfg80211_wowlan *wowlan,
 775 -                                  u32 *wow_triggers)
 776 -{
 777 -       if (wowlan->disconnect)
 778 -               *wow_triggers |= AH_WOW_LINK_CHANGE |
 779 -                                AH_WOW_BEACON_MISS;
 780 -       if (wowlan->magic_pkt)
 781 -               *wow_triggers |= AH_WOW_MAGIC_PATTERN_EN;
 782 -
 783 -       if (wowlan->n_patterns)
 784 -               *wow_triggers |= AH_WOW_USER_PATTERN_EN;
 785 -
 786 -       sc->wow_enabled = *wow_triggers;
 787 -
 788 -}
 789 -
 790 -static void ath9k_wow_add_disassoc_deauth_pattern(struct ath_softc *sc)
 791 -{
 792 -       struct ath_hw *ah = sc->sc_ah;
 793 -       struct ath_common *common = ath9k_hw_common(ah);
 794 -       int pattern_count = 0;
 795 -       int i, byte_cnt;
 796 -       u8 dis_deauth_pattern[MAX_PATTERN_SIZE];
 797 -       u8 dis_deauth_mask[MAX_PATTERN_SIZE];
 798 -
 799 -       memset(dis_deauth_pattern, 0, MAX_PATTERN_SIZE);
 800 -       memset(dis_deauth_mask, 0, MAX_PATTERN_SIZE);
 801 -
 802 -       /*
 803 -        * Create Dissassociate / Deauthenticate packet filter
 804 -        *
 805 -        *     2 bytes        2 byte    6 bytes   6 bytes  6 bytes
 806 -        *  +--------------+----------+---------+--------+--------+----
 807 -        *  + Frame Control+ Duration +   DA    +  SA    +  BSSID +
 808 -        *  +--------------+----------+---------+--------+--------+----
 809 -        *
 810 -        * The above is the management frame format for disassociate/
 811 -        * deauthenticate pattern, from this we need to match the first byte
 812 -        * of 'Frame Control' and DA, SA, and BSSID fields
 813 -        * (skipping 2nd byte of FC and Duration feild.
 814 -        *
 815 -        * Disassociate pattern
 816 -        * --------------------
 817 -        * Frame control = 00 00 1010
 818 -        * DA, SA, BSSID = x:x:x:x:x:x
 819 -        * Pattern will be A0000000 | x:x:x:x:x:x | x:x:x:x:x:x
 820 -        *                          | x:x:x:x:x:x  -- 22 bytes
 821 -        *
 822 -        * Deauthenticate pattern
 823 -        * ----------------------
 824 -        * Frame control = 00 00 1100
 825 -        * DA, SA, BSSID = x:x:x:x:x:x
 826 -        * Pattern will be C0000000 | x:x:x:x:x:x | x:x:x:x:x:x
 827 -        *                          | x:x:x:x:x:x  -- 22 bytes
 828 -        */
 829 -
 830 -       /* Create Disassociate Pattern first */
 831 -
 832 -       byte_cnt = 0;
 833 -
 834 -       /* Fill out the mask with all FF's */
 835 -
 836 -       for (i = 0; i < MAX_PATTERN_MASK_SIZE; i++)
 837 -               dis_deauth_mask[i] = 0xff;
 838 -
 839 -       /* copy the first byte of frame control field */
 840 -       dis_deauth_pattern[byte_cnt] = 0xa0;
 841 -       byte_cnt++;
 842 -
 843 -       /* skip 2nd byte of frame control and Duration field */
 844 -       byte_cnt += 3;
 845 -
 846 -       /*
 847 -        * need not match the destination mac address, it can be a broadcast
 848 -        * mac address or an unicast to this station
 849 -        */
 850 -       byte_cnt += 6;
 851 -
 852 -       /* copy the source mac address */
 853 -       memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
 854 -
 855 -       byte_cnt += 6;
 856 -
 857 -       /* copy the bssid, its same as the source mac address */
 858 -
 859 -       memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
 860 -
 861 -       /* Create Disassociate pattern mask */
 862 -
 863 -       dis_deauth_mask[0] = 0xfe;
 864 -       dis_deauth_mask[1] = 0x03;
 865 -       dis_deauth_mask[2] = 0xc0;
 866 -
 867 -       ath_dbg(common, WOW, "Adding disassoc/deauth patterns for WoW\n");
 868 -
 869 -       ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
 870 -                                  pattern_count, byte_cnt);
 871 -
 872 -       pattern_count++;
 873 -       /*
 874 -        * for de-authenticate pattern, only the first byte of the frame
 875 -        * control field gets changed from 0xA0 to 0xC0
 876 -        */
 877 -       dis_deauth_pattern[0] = 0xC0;
 878 -
 879 -       ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
 880 -                                  pattern_count, byte_cnt);
 881 -
 882 -}
 883 -
 884 -static void ath9k_wow_add_pattern(struct ath_softc *sc,
 885 -                                 struct cfg80211_wowlan *wowlan)
 886 -{
 887 -       struct ath_hw *ah = sc->sc_ah;
 888 -       struct ath9k_wow_pattern *wow_pattern = NULL;
 889 -       struct cfg80211_pkt_pattern *patterns = wowlan->patterns;
 890 -       int mask_len;
 891 -       s8 i = 0;
 892 -
 893 -       if (!wowlan->n_patterns)
 894 -               return;
 895 -
 896 -       /*
 897 -        * Add the new user configured patterns
 898 -        */
 899 -       for (i = 0; i < wowlan->n_patterns; i++) {
 900 -
 901 -               wow_pattern = kzalloc(sizeof(*wow_pattern), GFP_KERNEL);
 902 -
 903 -               if (!wow_pattern)
 904 -                       return;
 905 -
 906 -               /*
 907 -                * TODO: convert the generic user space pattern to
 908 -                * appropriate chip specific/802.11 pattern.
 909 -                */
 910 -
 911 -               mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
 912 -               memset(wow_pattern->pattern_bytes, 0, MAX_PATTERN_SIZE);
 913 -               memset(wow_pattern->mask_bytes, 0, MAX_PATTERN_SIZE);
 914 -               memcpy(wow_pattern->pattern_bytes, patterns[i].pattern,
 915 -                      patterns[i].pattern_len);
 916 -               memcpy(wow_pattern->mask_bytes, patterns[i].mask, mask_len);
 917 -               wow_pattern->pattern_len = patterns[i].pattern_len;
 918 -
 919 -               /*
 920 -                * just need to take care of deauth and disssoc pattern,
 921 -                * make sure we don't overwrite them.
 922 -                */
 923 -
 924 -               ath9k_hw_wow_apply_pattern(ah, wow_pattern->pattern_bytes,
 925 -                                          wow_pattern->mask_bytes,
 926 -                                          i + 2,
 927 -                                          wow_pattern->pattern_len);
 928 -               kfree(wow_pattern);
 929 -
 930 -       }
 931 -
 932 -}
 933 -
 934 -static int ath9k_suspend(struct ieee80211_hw *hw,
 935 -                        struct cfg80211_wowlan *wowlan)
 936 -{
 937 -       struct ath_softc *sc = hw->priv;
 938 -       struct ath_hw *ah = sc->sc_ah;
 939 -       struct ath_common *common = ath9k_hw_common(ah);
 940 -       u32 wow_triggers_enabled = 0;
 941 -       int ret = 0;
 942 -
 943 -       mutex_lock(&sc->mutex);
 944 -
 945 -       ath_cancel_work(sc);
 946 -       ath_stop_ani(sc);
 947 -       del_timer_sync(&sc->rx_poll_timer);
 948 -
 949 -       if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
 950 -               ath_dbg(common, ANY, "Device not present\n");
 951 -               ret = -EINVAL;
 952 -               goto fail_wow;
 953 -       }
 954 -
 955 -       if (WARN_ON(!wowlan)) {
 956 -               ath_dbg(common, WOW, "None of the WoW triggers enabled\n");
 957 -               ret = -EINVAL;
 958 -               goto fail_wow;
 959 -       }
 960 -
 961 -       if (!device_can_wakeup(sc->dev)) {
 962 -               ath_dbg(common, WOW, "device_can_wakeup failed, WoW is not enabled\n");
 963 -               ret = 1;
 964 -               goto fail_wow;
 965 -       }
 966 -
 967 -       /*
 968 -        * none of the sta vifs are associated
 969 -        * and we are not currently handling multivif
 970 -        * cases, for instance we have to seperately
 971 -        * configure 'keep alive frame' for each
 972 -        * STA.
 973 -        */
 974 -
 975 -       if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
 976 -               ath_dbg(common, WOW, "None of the STA vifs are associated\n");
 977 -               ret = 1;
 978 -               goto fail_wow;
 979 -       }
 980 -
 981 -       if (sc->nvifs > 1) {
 982 -               ath_dbg(common, WOW, "WoW for multivif is not yet supported\n");
 983 -               ret = 1;
 984 -               goto fail_wow;
 985 -       }
 986 -
 987 -       ath9k_wow_map_triggers(sc, wowlan, &wow_triggers_enabled);
 988 -
 989 -       ath_dbg(common, WOW, "WoW triggers enabled 0x%x\n",
 990 -               wow_triggers_enabled);
 991 -
 992 -       ath9k_ps_wakeup(sc);
 993 -
 994 -       ath9k_stop_btcoex(sc);
 995 -
 996 -       /*
 997 -        * Enable wake up on recieving disassoc/deauth
 998 -        * frame by default.
 999 -        */
1000 -       ath9k_wow_add_disassoc_deauth_pattern(sc);
1001 -
1002 -       if (wow_triggers_enabled & AH_WOW_USER_PATTERN_EN)
1003 -               ath9k_wow_add_pattern(sc, wowlan);
1004 -
1005 -       spin_lock_bh(&sc->sc_pcu_lock);
1006 -       /*
1007 -        * To avoid false wake, we enable beacon miss interrupt only
1008 -        * when we go to sleep. We save the current interrupt mask
1009 -        * so we can restore it after the system wakes up
1010 -        */
1011 -       sc->wow_intr_before_sleep = ah->imask;
1012 -       ah->imask &= ~ATH9K_INT_GLOBAL;
1013 -       ath9k_hw_disable_interrupts(ah);
1014 -       ah->imask = ATH9K_INT_BMISS | ATH9K_INT_GLOBAL;
1015 -       ath9k_hw_set_interrupts(ah);
1016 -       ath9k_hw_enable_interrupts(ah);
1017 -
1018 -       spin_unlock_bh(&sc->sc_pcu_lock);
1019 -
1020 -       /*
1021 -        * we can now sync irq and kill any running tasklets, since we already
1022 -        * disabled interrupts and not holding a spin lock
1023 -        */
1024 -       synchronize_irq(sc->irq);
1025 -       tasklet_kill(&sc->intr_tq);
1026 -
1027 -       ath9k_hw_wow_enable(ah, wow_triggers_enabled);
1028 -
1029 -       ath9k_ps_restore(sc);
1030 -       ath_dbg(common, ANY, "WoW enabled in ath9k\n");
1031 -       atomic_inc(&sc->wow_sleep_proc_intr);
1032 -
1033 -fail_wow:
1034 -       mutex_unlock(&sc->mutex);
1035 -       return ret;
1036 -}
1037 -
1038 -static int ath9k_resume(struct ieee80211_hw *hw)
1039 -{
1040 -       struct ath_softc *sc = hw->priv;
1041 -       struct ath_hw *ah = sc->sc_ah;
1042 -       struct ath_common *common = ath9k_hw_common(ah);
1043 -       u32 wow_status;
1044 -
1045 -       mutex_lock(&sc->mutex);
1046 -
1047 -       ath9k_ps_wakeup(sc);
1048 -
1049 -       spin_lock_bh(&sc->sc_pcu_lock);
1050 -
1051 -       ath9k_hw_disable_interrupts(ah);
1052 -       ah->imask = sc->wow_intr_before_sleep;
1053 -       ath9k_hw_set_interrupts(ah);
1054 -       ath9k_hw_enable_interrupts(ah);
1055 -
1056 -       spin_unlock_bh(&sc->sc_pcu_lock);
1057 -
1058 -       wow_status = ath9k_hw_wow_wakeup(ah);
1059 -
1060 -       if (atomic_read(&sc->wow_got_bmiss_intr) == 0) {
1061 -               /*
1062 -                * some devices may not pick beacon miss
1063 -                * as the reason they woke up so we add
1064 -                * that here for that shortcoming.
1065 -                */
1066 -               wow_status |= AH_WOW_BEACON_MISS;
1067 -               atomic_dec(&sc->wow_got_bmiss_intr);
1068 -               ath_dbg(common, ANY, "Beacon miss interrupt picked up during WoW sleep\n");
1069 -       }
1070 -
1071 -       atomic_dec(&sc->wow_sleep_proc_intr);
1072 -
1073 -       if (wow_status) {
1074 -               ath_dbg(common, ANY, "Waking up due to WoW triggers %s with WoW status = %x\n",
1075 -                       ath9k_hw_wow_event_to_string(wow_status), wow_status);
1076 -       }
1077 -
1078 -       ath_restart_work(sc);
1079 -       ath9k_start_btcoex(sc);
1080 -
1081 -       ath9k_ps_restore(sc);
1082 -       mutex_unlock(&sc->mutex);
1083 -
1084 -       return 0;
1085 -}
1086 -
1087 -static void ath9k_set_wakeup(struct ieee80211_hw *hw, bool enabled)
1088 -{
1089 -       struct ath_softc *sc = hw->priv;
1090 -
1091 -       mutex_lock(&sc->mutex);
1092 -       device_init_wakeup(sc->dev, 1);
1093 -       device_set_wakeup_enable(sc->dev, enabled);
1094 -       mutex_unlock(&sc->mutex);
1095 -}
1096 -
1097 -#endif
1098  static void ath9k_sw_scan_start(struct ieee80211_hw *hw)
1099  {
1100         struct ath_softc *sc = hw->priv;
1101 @@ -2373,134 +2070,6 @@ static void ath9k_channel_switch_beacon(
1102         sc->csa_vif = vif;
1103  }
1104
1105 -static void ath9k_tx99_stop(struct ath_softc *sc)
1106 -{
1107 -       struct ath_hw *ah = sc->sc_ah;
1108 -       struct ath_common *common = ath9k_hw_common(ah);
1109 -
1110 -       ath_drain_all_txq(sc);
1111 -       ath_startrecv(sc);
1112 -
1113 -       ath9k_hw_set_interrupts(ah);
1114 -       ath9k_hw_enable_interrupts(ah);
1115 -
1116 -       ieee80211_wake_queues(sc->hw);
1117 -
1118 -       kfree_skb(sc->tx99_skb);
1119 -       sc->tx99_skb = NULL;
1120 -       sc->tx99_state = false;
1121 -
1122 -       ath9k_hw_tx99_stop(sc->sc_ah);
1123 -       ath_dbg(common, XMIT, "TX99 stopped\n");
1124 -}
1125 -
1126 -static struct sk_buff *ath9k_build_tx99_skb(struct ath_softc *sc)
1127 -{
1128 -       static u8 PN9Data[] = {0xff, 0x87, 0xb8, 0x59, 0xb7, 0xa1, 0xcc, 0x24,
1129 -                              0x57, 0x5e, 0x4b, 0x9c, 0x0e, 0xe9, 0xea, 0x50,
1130 -                              0x2a, 0xbe, 0xb4, 0x1b, 0xb6, 0xb0, 0x5d, 0xf1,
1131 -                              0xe6, 0x9a, 0xe3, 0x45, 0xfd, 0x2c, 0x53, 0x18,
1132 -                              0x0c, 0xca, 0xc9, 0xfb, 0x49, 0x37, 0xe5, 0xa8,
1133 -                              0x51, 0x3b, 0x2f, 0x61, 0xaa, 0x72, 0x18, 0x84,
1134 -                              0x02, 0x23, 0x23, 0xab, 0x63, 0x89, 0x51, 0xb3,
1135 -                              0xe7, 0x8b, 0x72, 0x90, 0x4c, 0xe8, 0xfb, 0xc0};
1136 -       u32 len = 1200;
1137 -       struct ieee80211_hw *hw = sc->hw;
1138 -       struct ieee80211_hdr *hdr;
1139 -       struct ieee80211_tx_info *tx_info;
1140 -       struct sk_buff *skb;
1141 -
1142 -       skb = alloc_skb(len, GFP_KERNEL);
1143 -       if (!skb)
1144 -               return NULL;
1145 -
1146 -       skb_put(skb, len);
1147 -
1148 -       memset(skb->data, 0, len);
1149 -
1150 -       hdr = (struct ieee80211_hdr *)skb->data;
1151 -       hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA);
1152 -       hdr->duration_id = 0;
1153 -
1154 -       memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN);
1155 -       memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
1156 -       memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);
1157 -
1158 -       hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
1159 -
1160 -       tx_info = IEEE80211_SKB_CB(skb);
1161 -       memset(tx_info, 0, sizeof(*tx_info));
1162 -       tx_info->band = hw->conf.chandef.chan->band;
1163 -       tx_info->flags = IEEE80211_TX_CTL_NO_ACK;
1164 -       tx_info->control.vif = sc->tx99_vif;
1165 -
1166 -       memcpy(skb->data + sizeof(*hdr), PN9Data, sizeof(PN9Data));
1167 -
1168 -       return skb;
1169 -}
1170 -
1171 -void ath9k_tx99_deinit(struct ath_softc *sc)
1172 -{
1173 -       ath_reset(sc);
1174 -
1175 -       ath9k_ps_wakeup(sc);
1176 -       ath9k_tx99_stop(sc);
1177 -       ath9k_ps_restore(sc);
1178 -}
1179 -
1180 -int ath9k_tx99_init(struct ath_softc *sc)
1181 -{
1182 -       struct ieee80211_hw *hw = sc->hw;
1183 -       struct ath_hw *ah = sc->sc_ah;
1184 -       struct ath_common *common = ath9k_hw_common(ah);
1185 -       struct ath_tx_control txctl;
1186 -       int r;
1187 -
1188 -       if (sc->sc_flags & SC_OP_INVALID) {
1189 -               ath_err(common,
1190 -                       "driver is in invalid state unable to use TX99");
1191 -               return -EINVAL;
1192 -       }
1193 -
1194 -       sc->tx99_skb = ath9k_build_tx99_skb(sc);
1195 -       if (!sc->tx99_skb)
1196 -               return -ENOMEM;
1197 -
1198 -       memset(&txctl, 0, sizeof(txctl));
1199 -       txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
1200 -
1201 -       ath_reset(sc);
1202 -
1203 -       ath9k_ps_wakeup(sc);
1204 -
1205 -       ath9k_hw_disable_interrupts(ah);
1206 -       atomic_set(&ah->intr_ref_cnt, -1);
1207 -       ath_drain_all_txq(sc);
1208 -       ath_stoprecv(sc);
1209 -
1210 -       sc->tx99_state = true;
1211 -
1212 -       ieee80211_stop_queues(hw);
1213 -
1214 -       if (sc->tx99_power == MAX_RATE_POWER + 1)
1215 -               sc->tx99_power = MAX_RATE_POWER;
1216 -
1217 -       ath9k_hw_tx99_set_txpower(ah, sc->tx99_power);
1218 -       r = ath9k_tx99_send(sc, sc->tx99_skb, &txctl);
1219 -       if (r) {
1220 -               ath_dbg(common, XMIT, "Failed to xmit TX99 skb\n");
1221 -               return r;
1222 -       }
1223 -
1224 -       ath_dbg(common, XMIT, "TX99 xmit started using %d ( %ddBm)\n",
1225 -               sc->tx99_power,
1226 -               sc->tx99_power / 2);
1227 -
1228 -       /* We leave the harware awake as it will be chugging on */
1229 -
1230 -       return 0;
1231 -}
1232 -
1233  struct ieee80211_ops ath9k_ops = {
1234         .tx                 = ath9k_tx,
1235         .start              = ath9k_start,
1236 @@ -2531,7 +2100,7 @@ struct ieee80211_ops ath9k_ops = {
1237         .set_antenna        = ath9k_set_antenna,
1238         .get_antenna        = ath9k_get_antenna,
1239
1240 -#ifdef CONFIG_PM_SLEEP
1241 +#ifdef CONFIG_ATH9K_WOW
1242         .suspend            = ath9k_suspend,
1243         .resume             = ath9k_resume,
1244         .set_wakeup         = ath9k_set_wakeup,
1245 --- a/drivers/net/wireless/ath/ath9k/wow.c
1246 +++ b/drivers/net/wireless/ath/ath9k/wow.c
1247 @@ -1,5 +1,5 @@
1248  /*
1249 - * Copyright (c) 2012 Qualcomm Atheros, Inc.
1250 + * Copyright (c) 2013 Qualcomm Atheros, Inc.
1251   *
1252   * Permission to use, copy, modify, and/or distribute this software for any
1253   * purpose with or without fee is hereby granted, provided that the above
1254 @@ -14,409 +14,348 @@
1255   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1256   */
1257
1258 -#include <linux/export.h>
1259  #include "ath9k.h"
1260 -#include "reg.h"
1261 -#include "hw-ops.h"
1262
1263 -const char *ath9k_hw_wow_event_to_string(u32 wow_event)
1264 +static const struct wiphy_wowlan_support ath9k_wowlan_support = {
1265 +       .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
1266 +       .n_patterns = MAX_NUM_USER_PATTERN,
1267 +       .pattern_min_len = 1,
1268 +       .pattern_max_len = MAX_PATTERN_SIZE,
1269 +};
1270 +
1271 +static void ath9k_wow_map_triggers(struct ath_softc *sc,
1272 +                                  struct cfg80211_wowlan *wowlan,
1273 +                                  u32 *wow_triggers)
1274  {
1275 -       if (wow_event & AH_WOW_MAGIC_PATTERN_EN)
1276 -               return "Magic pattern";
1277 -       if (wow_event & AH_WOW_USER_PATTERN_EN)
1278 -               return "User pattern";
1279 -       if (wow_event & AH_WOW_LINK_CHANGE)
1280 -               return "Link change";
1281 -       if (wow_event & AH_WOW_BEACON_MISS)
1282 -               return "Beacon miss";
1283 +       if (wowlan->disconnect)
1284 +               *wow_triggers |= AH_WOW_LINK_CHANGE |
1285 +                                AH_WOW_BEACON_MISS;
1286 +       if (wowlan->magic_pkt)
1287 +               *wow_triggers |= AH_WOW_MAGIC_PATTERN_EN;
1288 +
1289 +       if (wowlan->n_patterns)
1290 +               *wow_triggers |= AH_WOW_USER_PATTERN_EN;
1291 +
1292 +       sc->wow_enabled = *wow_triggers;
1293
1294 -       return  "unknown reason";
1295  }
1296 -EXPORT_SYMBOL(ath9k_hw_wow_event_to_string);
1297
1298 -static void ath9k_hw_set_powermode_wow_sleep(struct ath_hw *ah)
1299 +static void ath9k_wow_add_disassoc_deauth_pattern(struct ath_softc *sc)
1300  {
1301 +       struct ath_hw *ah = sc->sc_ah;
1302         struct ath_common *common = ath9k_hw_common(ah);
1303 +       int pattern_count = 0;
1304 +       int i, byte_cnt;
1305 +       u8 dis_deauth_pattern[MAX_PATTERN_SIZE];
1306 +       u8 dis_deauth_mask[MAX_PATTERN_SIZE];
1307
1308 -       REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV);
1309 +       memset(dis_deauth_pattern, 0, MAX_PATTERN_SIZE);
1310 +       memset(dis_deauth_mask, 0, MAX_PATTERN_SIZE);
1311
1312 -       /* set rx disable bit */
1313 -       REG_WRITE(ah, AR_CR, AR_CR_RXD);
1314 +       /*
1315 +        * Create Dissassociate / Deauthenticate packet filter
1316 +        *
1317 +        *     2 bytes        2 byte    6 bytes   6 bytes  6 bytes
1318 +        *  +--------------+----------+---------+--------+--------+----
1319 +        *  + Frame Control+ Duration +   DA    +  SA    +  BSSID +
1320 +        *  +--------------+----------+---------+--------+--------+----
1321 +        *
1322 +        * The above is the management frame format for disassociate/
1323 +        * deauthenticate pattern, from this we need to match the first byte
1324 +        * of 'Frame Control' and DA, SA, and BSSID fields
1325 +        * (skipping 2nd byte of FC and Duration feild.
1326 +        *
1327 +        * Disassociate pattern
1328 +        * --------------------
1329 +        * Frame control = 00 00 1010
1330 +        * DA, SA, BSSID = x:x:x:x:x:x
1331 +        * Pattern will be A0000000 | x:x:x:x:x:x | x:x:x:x:x:x
1332 +        *                          | x:x:x:x:x:x  -- 22 bytes
1333 +        *
1334 +        * Deauthenticate pattern
1335 +        * ----------------------
1336 +        * Frame control = 00 00 1100
1337 +        * DA, SA, BSSID = x:x:x:x:x:x
1338 +        * Pattern will be C0000000 | x:x:x:x:x:x | x:x:x:x:x:x
1339 +        *                          | x:x:x:x:x:x  -- 22 bytes
1340 +        */
1341
1342 -       if (!ath9k_hw_wait(ah, AR_CR, AR_CR_RXE, 0, AH_WAIT_TIMEOUT)) {
1343 -               ath_err(common, "Failed to stop Rx DMA in 10ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
1344 -                       REG_READ(ah, AR_CR), REG_READ(ah, AR_DIAG_SW));
1345 -               return;
1346 -       }
1347 +       /* Create Disassociate Pattern first */
1348
1349 -       REG_WRITE(ah, AR_RTC_FORCE_WAKE, AR_RTC_FORCE_WAKE_ON_INT);
1350 -}
1351 +       byte_cnt = 0;
1352
1353 -static void ath9k_wow_create_keep_alive_pattern(struct ath_hw *ah)
1354 -{
1355 -       struct ath_common *common = ath9k_hw_common(ah);
1356 -       u8 sta_mac_addr[ETH_ALEN], ap_mac_addr[ETH_ALEN];
1357 -       u32 ctl[13] = {0};
1358 -       u32 data_word[KAL_NUM_DATA_WORDS];
1359 -       u8 i;
1360 -       u32 wow_ka_data_word0;
1361 -
1362 -       memcpy(sta_mac_addr, common->macaddr, ETH_ALEN);
1363 -       memcpy(ap_mac_addr, common->curbssid, ETH_ALEN);
1364 -
1365 -       /* set the transmit buffer */
1366 -       ctl[0] = (KAL_FRAME_LEN | (MAX_RATE_POWER << 16));
1367 -       ctl[1] = 0;
1368 -       ctl[3] = 0xb;   /* OFDM_6M hardware value for this rate */
1369 -       ctl[4] = 0;
1370 -       ctl[7] = (ah->txchainmask) << 2;
1371 -       ctl[2] = 0xf << 16; /* tx_tries 0 */
1372 -
1373 -       for (i = 0; i < KAL_NUM_DESC_WORDS; i++)
1374 -               REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + i * 4), ctl[i]);
1375 -
1376 -       REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + i * 4), ctl[i]);
1377 -
1378 -       data_word[0] = (KAL_FRAME_TYPE << 2) | (KAL_FRAME_SUB_TYPE << 4) |
1379 -                      (KAL_TO_DS << 8) | (KAL_DURATION_ID << 16);
1380 -       data_word[1] = (ap_mac_addr[3] << 24) | (ap_mac_addr[2] << 16) |
1381 -                      (ap_mac_addr[1] << 8) | (ap_mac_addr[0]);
1382 -       data_word[2] = (sta_mac_addr[1] << 24) | (sta_mac_addr[0] << 16) |
1383 -                      (ap_mac_addr[5] << 8) | (ap_mac_addr[4]);
1384 -       data_word[3] = (sta_mac_addr[5] << 24) | (sta_mac_addr[4] << 16) |
1385 -                      (sta_mac_addr[3] << 8) | (sta_mac_addr[2]);
1386 -       data_word[4] = (ap_mac_addr[3] << 24) | (ap_mac_addr[2] << 16) |
1387 -                      (ap_mac_addr[1] << 8) | (ap_mac_addr[0]);
1388 -       data_word[5] = (ap_mac_addr[5] << 8) | (ap_mac_addr[4]);
1389 -
1390 -       if (AR_SREV_9462_20(ah)) {
1391 -               /* AR9462 2.0 has an extra descriptor word (time based
1392 -                * discard) compared to other chips */
1393 -               REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + (12 * 4)), 0);
1394 -               wow_ka_data_word0 = AR_WOW_TXBUF(13);
1395 -       } else {
1396 -               wow_ka_data_word0 = AR_WOW_TXBUF(12);
1397 -       }
1398 +       /* Fill out the mask with all FF's */
1399
1400 -       for (i = 0; i < KAL_NUM_DATA_WORDS; i++)
1401 -               REG_WRITE(ah, (wow_ka_data_word0 + i*4), data_word[i]);
1402 +       for (i = 0; i < MAX_PATTERN_MASK_SIZE; i++)
1403 +               dis_deauth_mask[i] = 0xff;
1404
1405 -}
1406 +       /* copy the first byte of frame control field */
1407 +       dis_deauth_pattern[byte_cnt] = 0xa0;
1408 +       byte_cnt++;
1409
1410 -void ath9k_hw_wow_apply_pattern(struct ath_hw *ah, u8 *user_pattern,
1411 -                               u8 *user_mask, int pattern_count,
1412 -                               int pattern_len)
1413 -{
1414 -       int i;
1415 -       u32 pattern_val, mask_val;
1416 -       u32 set, clr;
1417 +       /* skip 2nd byte of frame control and Duration field */
1418 +       byte_cnt += 3;
1419
1420 -       /* FIXME: should check count by querying the hardware capability */
1421 -       if (pattern_count >= MAX_NUM_PATTERN)
1422 -               return;
1423 +       /*
1424 +        * need not match the destination mac address, it can be a broadcast
1425 +        * mac address or an unicast to this station
1426 +        */
1427 +       byte_cnt += 6;
1428
1429 -       REG_SET_BIT(ah, AR_WOW_PATTERN, BIT(pattern_count));
1430 +       /* copy the source mac address */
1431 +       memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
1432
1433 -       /* set the registers for pattern */
1434 -       for (i = 0; i < MAX_PATTERN_SIZE; i += 4) {
1435 -               memcpy(&pattern_val, user_pattern, 4);
1436 -               REG_WRITE(ah, (AR_WOW_TB_PATTERN(pattern_count) + i),
1437 -                         pattern_val);
1438 -               user_pattern += 4;
1439 -       }
1440 +       byte_cnt += 6;
1441
1442 -       /* set the registers for mask */
1443 -       for (i = 0; i < MAX_PATTERN_MASK_SIZE; i += 4) {
1444 -               memcpy(&mask_val, user_mask, 4);
1445 -               REG_WRITE(ah, (AR_WOW_TB_MASK(pattern_count) + i), mask_val);
1446 -               user_mask += 4;
1447 -       }
1448 +       /* copy the bssid, its same as the source mac address */
1449
1450 -       /* set the pattern length to be matched
1451 -        *
1452 -        * AR_WOW_LENGTH1_REG1
1453 -        * bit 31:24 pattern 0 length
1454 -        * bit 23:16 pattern 1 length
1455 -        * bit 15:8 pattern 2 length
1456 -        * bit 7:0 pattern 3 length
1457 -        *
1458 -        * AR_WOW_LENGTH1_REG2
1459 -        * bit 31:24 pattern 4 length
1460 -        * bit 23:16 pattern 5 length
1461 -        * bit 15:8 pattern 6 length
1462 -        * bit 7:0 pattern 7 length
1463 -        *
1464 -        * the below logic writes out the new
1465 -        * pattern length for the corresponding
1466 -        * pattern_count, while masking out the
1467 -        * other fields
1468 -        */
1469 +       memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
1470
1471 -       ah->wow_event_mask |= BIT(pattern_count + AR_WOW_PAT_FOUND_SHIFT);
1472 +       /* Create Disassociate pattern mask */
1473
1474 -       if (pattern_count < 4) {
1475 -               /* Pattern 0-3 uses AR_WOW_LENGTH1 register */
1476 -               set = (pattern_len & AR_WOW_LENGTH_MAX) <<
1477 -                      AR_WOW_LEN1_SHIFT(pattern_count);
1478 -               clr = AR_WOW_LENGTH1_MASK(pattern_count);
1479 -               REG_RMW(ah, AR_WOW_LENGTH1, set, clr);
1480 -       } else {
1481 -               /* Pattern 4-7 uses AR_WOW_LENGTH2 register */
1482 -               set = (pattern_len & AR_WOW_LENGTH_MAX) <<
1483 -                      AR_WOW_LEN2_SHIFT(pattern_count);
1484 -               clr = AR_WOW_LENGTH2_MASK(pattern_count);
1485 -               REG_RMW(ah, AR_WOW_LENGTH2, set, clr);
1486 -       }
1487 +       dis_deauth_mask[0] = 0xfe;
1488 +       dis_deauth_mask[1] = 0x03;
1489 +       dis_deauth_mask[2] = 0xc0;
1490
1491 -}
1492 -EXPORT_SYMBOL(ath9k_hw_wow_apply_pattern);
1493 +       ath_dbg(common, WOW, "Adding disassoc/deauth patterns for WoW\n");
1494
1495 -u32 ath9k_hw_wow_wakeup(struct ath_hw *ah)
1496 -{
1497 -       u32 wow_status = 0;
1498 -       u32 val = 0, rval;
1499 +       ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
1500 +                                  pattern_count, byte_cnt);
1501
1502 +       pattern_count++;
1503         /*
1504 -        * read the WoW status register to know
1505 -        * the wakeup reason
1506 +        * for de-authenticate pattern, only the first byte of the frame
1507 +        * control field gets changed from 0xA0 to 0xC0
1508          */
1509 -       rval = REG_READ(ah, AR_WOW_PATTERN);
1510 -       val = AR_WOW_STATUS(rval);
1511 +       dis_deauth_pattern[0] = 0xC0;
1512
1513 -       /*
1514 -        * mask only the WoW events that we have enabled. Sometimes
1515 -        * we have spurious WoW events from the AR_WOW_PATTERN
1516 -        * register. This mask will clean it up.
1517 -        */
1518 +       ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
1519 +                                  pattern_count, byte_cnt);
1520
1521 -       val &= ah->wow_event_mask;
1522 +}
1523
1524 -       if (val) {
1525 -               if (val & AR_WOW_MAGIC_PAT_FOUND)
1526 -                       wow_status |= AH_WOW_MAGIC_PATTERN_EN;
1527 -               if (AR_WOW_PATTERN_FOUND(val))
1528 -                       wow_status |= AH_WOW_USER_PATTERN_EN;
1529 -               if (val & AR_WOW_KEEP_ALIVE_FAIL)
1530 -                       wow_status |= AH_WOW_LINK_CHANGE;
1531 -               if (val & AR_WOW_BEACON_FAIL)
1532 -                       wow_status |= AH_WOW_BEACON_MISS;
1533 -       }
1534 +static void ath9k_wow_add_pattern(struct ath_softc *sc,
1535 +                                 struct cfg80211_wowlan *wowlan)
1536 +{
1537 +       struct ath_hw *ah = sc->sc_ah;
1538 +       struct ath9k_wow_pattern *wow_pattern = NULL;
1539 +       struct cfg80211_pkt_pattern *patterns = wowlan->patterns;
1540 +       int mask_len;
1541 +       s8 i = 0;
1542 +
1543 +       if (!wowlan->n_patterns)
1544 +               return;
1545
1546         /*
1547 -        * set and clear WOW_PME_CLEAR registers for the chip to
1548 -        * generate next wow signal.
1549 -        * disable D3 before accessing other registers ?
1550 +        * Add the new user configured patterns
1551          */
1552 +       for (i = 0; i < wowlan->n_patterns; i++) {
1553
1554 -       /* do we need to check the bit value 0x01000000 (7-10) ?? */
1555 -       REG_RMW(ah, AR_PCIE_PM_CTRL, AR_PMCTRL_WOW_PME_CLR,
1556 -               AR_PMCTRL_PWR_STATE_D1D3);
1557 +               wow_pattern = kzalloc(sizeof(*wow_pattern), GFP_KERNEL);
1558
1559 -       /*
1560 -        * clear all events
1561 -        */
1562 -       REG_WRITE(ah, AR_WOW_PATTERN,
1563 -                 AR_WOW_CLEAR_EVENTS(REG_READ(ah, AR_WOW_PATTERN)));
1564 +               if (!wow_pattern)
1565 +                       return;
1566
1567 -       /*
1568 -        * restore the beacon threshold to init value
1569 -        */
1570 -       REG_WRITE(ah, AR_RSSI_THR, INIT_RSSI_THR);
1571 +               /*
1572 +                * TODO: convert the generic user space pattern to
1573 +                * appropriate chip specific/802.11 pattern.
1574 +                */
1575
1576 -       /*
1577 -        * Restore the way the PCI-E reset, Power-On-Reset, external
1578 -        * PCIE_POR_SHORT pins are tied to its original value.
1579 -        * Previously just before WoW sleep, we untie the PCI-E
1580 -        * reset to our Chip's Power On Reset so that any PCI-E
1581 -        * reset from the bus will not reset our chip
1582 -        */
1583 -       if (ah->is_pciexpress)
1584 -               ath9k_hw_configpcipowersave(ah, false);
1585 +               mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
1586 +               memset(wow_pattern->pattern_bytes, 0, MAX_PATTERN_SIZE);
1587 +               memset(wow_pattern->mask_bytes, 0, MAX_PATTERN_SIZE);
1588 +               memcpy(wow_pattern->pattern_bytes, patterns[i].pattern,
1589 +                      patterns[i].pattern_len);
1590 +               memcpy(wow_pattern->mask_bytes, patterns[i].mask, mask_len);
1591 +               wow_pattern->pattern_len = patterns[i].pattern_len;
1592 +
1593 +               /*
1594 +                * just need to take care of deauth and disssoc pattern,
1595 +                * make sure we don't overwrite them.
1596 +                */
1597 +
1598 +               ath9k_hw_wow_apply_pattern(ah, wow_pattern->pattern_bytes,
1599 +                                          wow_pattern->mask_bytes,
1600 +                                          i + 2,
1601 +                                          wow_pattern->pattern_len);
1602 +               kfree(wow_pattern);
1603
1604 -       ah->wow_event_mask = 0;
1605 +       }
1606
1607 -       return wow_status;
1608  }
1609 -EXPORT_SYMBOL(ath9k_hw_wow_wakeup);
1610
1611 -void ath9k_hw_wow_enable(struct ath_hw *ah, u32 pattern_enable)
1612 +int ath9k_suspend(struct ieee80211_hw *hw,
1613 +                 struct cfg80211_wowlan *wowlan)
1614  {
1615 -       u32 wow_event_mask;
1616 -       u32 set, clr;
1617 +       struct ath_softc *sc = hw->priv;
1618 +       struct ath_hw *ah = sc->sc_ah;
1619 +       struct ath_common *common = ath9k_hw_common(ah);
1620 +       u32 wow_triggers_enabled = 0;
1621 +       int ret = 0;
1622
1623 -       /*
1624 -        * wow_event_mask is a mask to the AR_WOW_PATTERN register to
1625 -        * indicate which WoW events we have enabled. The WoW events
1626 -        * are from the 'pattern_enable' in this function and
1627 -        * 'pattern_count' of ath9k_hw_wow_apply_pattern()
1628 -        */
1629 -       wow_event_mask = ah->wow_event_mask;
1630 +       mutex_lock(&sc->mutex);
1631
1632 -       /*
1633 -        * Untie Power-on-Reset from the PCI-E-Reset. When we are in
1634 -        * WOW sleep, we do want the Reset from the PCI-E to disturb
1635 -        * our hw state
1636 -        */
1637 -       if (ah->is_pciexpress) {
1638 -               /*
1639 -                * we need to untie the internal POR (power-on-reset)
1640 -                * to the external PCI-E reset. We also need to tie
1641 -                * the PCI-E Phy reset to the PCI-E reset.
1642 -                */
1643 -               set = AR_WA_RESET_EN | AR_WA_POR_SHORT;
1644 -               clr = AR_WA_UNTIE_RESET_EN | AR_WA_D3_L1_DISABLE;
1645 -               REG_RMW(ah, AR_WA, set, clr);
1646 +       ath_cancel_work(sc);
1647 +       ath_stop_ani(sc);
1648 +       del_timer_sync(&sc->rx_poll_timer);
1649 +
1650 +       if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
1651 +               ath_dbg(common, ANY, "Device not present\n");
1652 +               ret = -EINVAL;
1653 +               goto fail_wow;
1654         }
1655
1656 -       /*
1657 -        * set the power states appropriately and enable PME
1658 -        */
1659 -       set = AR_PMCTRL_HOST_PME_EN | AR_PMCTRL_PWR_PM_CTRL_ENA |
1660 -             AR_PMCTRL_AUX_PWR_DET | AR_PMCTRL_WOW_PME_CLR;
1661 +       if (WARN_ON(!wowlan)) {
1662 +               ath_dbg(common, WOW, "None of the WoW triggers enabled\n");
1663 +               ret = -EINVAL;
1664 +               goto fail_wow;
1665 +       }
1666
1667 -       /*
1668 -        * set and clear WOW_PME_CLEAR registers for the chip
1669 -        * to generate next wow signal.
1670 -        */
1671 -       REG_SET_BIT(ah, AR_PCIE_PM_CTRL, set);
1672 -       clr = AR_PMCTRL_WOW_PME_CLR;
1673 -       REG_CLR_BIT(ah, AR_PCIE_PM_CTRL, clr);
1674 +       if (!device_can_wakeup(sc->dev)) {
1675 +               ath_dbg(common, WOW, "device_can_wakeup failed, WoW is not enabled\n");
1676 +               ret = 1;
1677 +               goto fail_wow;
1678 +       }
1679
1680         /*
1681 -        * Setup for:
1682 -        *      - beacon misses
1683 -        *      - magic pattern
1684 -        *      - keep alive timeout
1685 -        *      - pattern matching
1686 +        * none of the sta vifs are associated
1687 +        * and we are not currently handling multivif
1688 +        * cases, for instance we have to seperately
1689 +        * configure 'keep alive frame' for each
1690 +        * STA.
1691          */
1692
1693 -       /*
1694 -        * Program default values for pattern backoff, aifs/slot/KAL count,
1695 -        * beacon miss timeout, KAL timeout, etc.
1696 -        */
1697 -       set = AR_WOW_BACK_OFF_SHIFT(AR_WOW_PAT_BACKOFF);
1698 -       REG_SET_BIT(ah, AR_WOW_PATTERN, set);
1699 +       if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
1700 +               ath_dbg(common, WOW, "None of the STA vifs are associated\n");
1701 +               ret = 1;
1702 +               goto fail_wow;
1703 +       }
1704 +
1705 +       if (sc->nvifs > 1) {
1706 +               ath_dbg(common, WOW, "WoW for multivif is not yet supported\n");
1707 +               ret = 1;
1708 +               goto fail_wow;
1709 +       }
1710
1711 -       set = AR_WOW_AIFS_CNT(AR_WOW_CNT_AIFS_CNT) |
1712 -             AR_WOW_SLOT_CNT(AR_WOW_CNT_SLOT_CNT) |
1713 -             AR_WOW_KEEP_ALIVE_CNT(AR_WOW_CNT_KA_CNT);
1714 -       REG_SET_BIT(ah, AR_WOW_COUNT, set);
1715 -
1716 -       if (pattern_enable & AH_WOW_BEACON_MISS)
1717 -               set = AR_WOW_BEACON_TIMO;
1718 -       /* We are not using beacon miss, program a large value */
1719 -       else
1720 -               set = AR_WOW_BEACON_TIMO_MAX;
1721 +       ath9k_wow_map_triggers(sc, wowlan, &wow_triggers_enabled);
1722
1723 -       REG_WRITE(ah, AR_WOW_BCN_TIMO, set);
1724 +       ath_dbg(common, WOW, "WoW triggers enabled 0x%x\n",
1725 +               wow_triggers_enabled);
1726
1727 -       /*
1728 -        * Keep alive timo in ms except AR9280
1729 -        */
1730 -       if (!pattern_enable)
1731 -               set = AR_WOW_KEEP_ALIVE_NEVER;
1732 -       else
1733 -               set = KAL_TIMEOUT * 32;
1734 +       ath9k_ps_wakeup(sc);
1735
1736 -       REG_WRITE(ah, AR_WOW_KEEP_ALIVE_TIMO, set);
1737 +       ath9k_stop_btcoex(sc);
1738
1739         /*
1740 -        * Keep alive delay in us. based on 'power on clock',
1741 -        * therefore in usec
1742 +        * Enable wake up on recieving disassoc/deauth
1743 +        * frame by default.
1744          */
1745 -       set = KAL_DELAY * 1000;
1746 -       REG_WRITE(ah, AR_WOW_KEEP_ALIVE_DELAY, set);
1747 +       ath9k_wow_add_disassoc_deauth_pattern(sc);
1748
1749 -       /*
1750 -        * Create keep alive pattern to respond to beacons
1751 -        */
1752 -       ath9k_wow_create_keep_alive_pattern(ah);
1753 +       if (wow_triggers_enabled & AH_WOW_USER_PATTERN_EN)
1754 +               ath9k_wow_add_pattern(sc, wowlan);
1755
1756 +       spin_lock_bh(&sc->sc_pcu_lock);
1757         /*
1758 -        * Configure MAC WoW Registers
1759 +        * To avoid false wake, we enable beacon miss interrupt only
1760 +        * when we go to sleep. We save the current interrupt mask
1761 +        * so we can restore it after the system wakes up
1762          */
1763 -       set = 0;
1764 -       /* Send keep alive timeouts anyway */
1765 -       clr = AR_WOW_KEEP_ALIVE_AUTO_DIS;
1766 -
1767 -       if (pattern_enable & AH_WOW_LINK_CHANGE)
1768 -               wow_event_mask |= AR_WOW_KEEP_ALIVE_FAIL;
1769 -       else
1770 -               set = AR_WOW_KEEP_ALIVE_FAIL_DIS;
1771 +       sc->wow_intr_before_sleep = ah->imask;
1772 +       ah->imask &= ~ATH9K_INT_GLOBAL;
1773 +       ath9k_hw_disable_interrupts(ah);
1774 +       ah->imask = ATH9K_INT_BMISS | ATH9K_INT_GLOBAL;
1775 +       ath9k_hw_set_interrupts(ah);
1776 +       ath9k_hw_enable_interrupts(ah);
1777
1778 -       set = AR_WOW_KEEP_ALIVE_FAIL_DIS;
1779 -       REG_RMW(ah, AR_WOW_KEEP_ALIVE, set, clr);
1780 +       spin_unlock_bh(&sc->sc_pcu_lock);
1781
1782         /*
1783 -        * we are relying on a bmiss failure. ensure we have
1784 -        * enough threshold to prevent false positives
1785 +        * we can now sync irq and kill any running tasklets, since we already
1786 +        * disabled interrupts and not holding a spin lock
1787          */
1788 -       REG_RMW_FIELD(ah, AR_RSSI_THR, AR_RSSI_THR_BM_THR,
1789 -                     AR_WOW_BMISSTHRESHOLD);
1790 +       synchronize_irq(sc->irq);
1791 +       tasklet_kill(&sc->intr_tq);
1792 +
1793 +       ath9k_hw_wow_enable(ah, wow_triggers_enabled);
1794
1795 -       set = 0;
1796 -       clr = 0;
1797 +       ath9k_ps_restore(sc);
1798 +       ath_dbg(common, ANY, "WoW enabled in ath9k\n");
1799 +       atomic_inc(&sc->wow_sleep_proc_intr);
1800
1801 -       if (pattern_enable & AH_WOW_BEACON_MISS) {
1802 -               set = AR_WOW_BEACON_FAIL_EN;
1803 -               wow_event_mask |= AR_WOW_BEACON_FAIL;
1804 -       } else {
1805 -               clr = AR_WOW_BEACON_FAIL_EN;
1806 +fail_wow:
1807 +       mutex_unlock(&sc->mutex);
1808 +       return ret;
1809 +}
1810 +
1811 +int ath9k_resume(struct ieee80211_hw *hw)
1812 +{
1813 +       struct ath_softc *sc = hw->priv;
1814 +       struct ath_hw *ah = sc->sc_ah;
1815 +       struct ath_common *common = ath9k_hw_common(ah);
1816 +       u32 wow_status;
1817 +
1818 +       mutex_lock(&sc->mutex);
1819 +
1820 +       ath9k_ps_wakeup(sc);
1821 +
1822 +       spin_lock_bh(&sc->sc_pcu_lock);
1823 +
1824 +       ath9k_hw_disable_interrupts(ah);
1825 +       ah->imask = sc->wow_intr_before_sleep;
1826 +       ath9k_hw_set_interrupts(ah);
1827 +       ath9k_hw_enable_interrupts(ah);
1828 +
1829 +       spin_unlock_bh(&sc->sc_pcu_lock);
1830 +
1831 +       wow_status = ath9k_hw_wow_wakeup(ah);
1832 +
1833 +       if (atomic_read(&sc->wow_got_bmiss_intr) == 0) {
1834 +               /*
1835 +                * some devices may not pick beacon miss
1836 +                * as the reason they woke up so we add
1837 +                * that here for that shortcoming.
1838 +                */
1839 +               wow_status |= AH_WOW_BEACON_MISS;
1840 +               atomic_dec(&sc->wow_got_bmiss_intr);
1841 +               ath_dbg(common, ANY, "Beacon miss interrupt picked up during WoW sleep\n");
1842         }
1843
1844 -       REG_RMW(ah, AR_WOW_BCN_EN, set, clr);
1845 +       atomic_dec(&sc->wow_sleep_proc_intr);
1846
1847 -       set = 0;
1848 -       clr = 0;
1849 -       /*
1850 -        * Enable the magic packet registers
1851 -        */
1852 -       if (pattern_enable & AH_WOW_MAGIC_PATTERN_EN) {
1853 -               set = AR_WOW_MAGIC_EN;
1854 -               wow_event_mask |= AR_WOW_MAGIC_PAT_FOUND;
1855 -       } else {
1856 -               clr = AR_WOW_MAGIC_EN;
1857 +       if (wow_status) {
1858 +               ath_dbg(common, ANY, "Waking up due to WoW triggers %s with WoW status = %x\n",
1859 +                       ath9k_hw_wow_event_to_string(wow_status), wow_status);
1860         }
1861 -       set |= AR_WOW_MAC_INTR_EN;
1862 -       REG_RMW(ah, AR_WOW_PATTERN, set, clr);
1863
1864 -       REG_WRITE(ah, AR_WOW_PATTERN_MATCH_LT_256B,
1865 -                 AR_WOW_PATTERN_SUPPORTED);
1866 +       ath_restart_work(sc);
1867 +       ath9k_start_btcoex(sc);
1868
1869 -       /*
1870 -        * Set the power states appropriately and enable PME
1871 -        */
1872 -       clr = 0;
1873 -       set = AR_PMCTRL_PWR_STATE_D1D3 | AR_PMCTRL_HOST_PME_EN |
1874 -             AR_PMCTRL_PWR_PM_CTRL_ENA;
1875 +       ath9k_ps_restore(sc);
1876 +       mutex_unlock(&sc->mutex);
1877
1878 -       clr = AR_PCIE_PM_CTRL_ENA;
1879 -       REG_RMW(ah, AR_PCIE_PM_CTRL, set, clr);
1880 +       return 0;
1881 +}
1882
1883 -       /*
1884 -        * this is needed to prevent the chip waking up
1885 -        * the host within 3-4 seconds with certain
1886 -        * platform/BIOS. The fix is to enable
1887 -        * D1 & D3 to match original definition and
1888 -        * also match the OTP value. Anyway this
1889 -        * is more related to SW WOW.
1890 -        */
1891 -       clr = AR_PMCTRL_PWR_STATE_D1D3;
1892 -       REG_CLR_BIT(ah, AR_PCIE_PM_CTRL, clr);
1893 +void ath9k_set_wakeup(struct ieee80211_hw *hw, bool enabled)
1894 +{
1895 +       struct ath_softc *sc = hw->priv;
1896
1897 -       set = AR_PMCTRL_PWR_STATE_D1D3_REAL;
1898 -       REG_SET_BIT(ah, AR_PCIE_PM_CTRL, set);
1899 +       mutex_lock(&sc->mutex);
1900 +       device_init_wakeup(sc->dev, 1);
1901 +       device_set_wakeup_enable(sc->dev, enabled);
1902 +       mutex_unlock(&sc->mutex);
1903 +}
1904
1905 -       REG_CLR_BIT(ah, AR_STA_ID1, AR_STA_ID1_PRESERVE_SEQNUM);
1906 +void ath9k_init_wow(struct ieee80211_hw *hw)
1907 +{
1908 +       struct ath_softc *sc = hw->priv;
1909
1910 -       /* to bring down WOW power low margin */
1911 -       set = BIT(13);
1912 -       REG_SET_BIT(ah, AR_PCIE_PHY_REG3, set);
1913 -       /* HW WoW */
1914 -       clr = BIT(5);
1915 -       REG_CLR_BIT(ah, AR_PCU_MISC_MODE3, clr);
1916 +       if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_WOW_DEVICE_CAPABLE) &&
1917 +           (sc->driver_data & ATH9K_PCI_WOW) &&
1918 +           device_can_wakeup(sc->dev))
1919 +               hw->wiphy->wowlan = &ath9k_wowlan_support;
1920
1921 -       ath9k_hw_set_powermode_wow_sleep(ah);
1922 -       ah->wow_event_mask = wow_event_mask;
1923 +       atomic_set(&sc->wow_sleep_proc_intr, -1);
1924 +       atomic_set(&sc->wow_got_bmiss_intr, -1);
1925  }
1926 -EXPORT_SYMBOL(ath9k_hw_wow_enable);
1927 --- a/drivers/net/wireless/ath/ath9k/xmit.c
1928 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
1929 @@ -1786,6 +1786,9 @@ bool ath_drain_all_txq(struct ath_softc
1930                 if (!ATH_TXQ_SETUP(sc, i))
1931                         continue;
1932
1933 +               if (!sc->tx.txq[i].axq_depth)
1934 +                       continue;
1935 +
1936                 if (ath9k_hw_numtxpending(ah, sc->tx.txq[i].axq_qnum))
1937                         npend |= BIT(i);
1938         }
1939 @@ -2749,6 +2752,8 @@ void ath_tx_node_cleanup(struct ath_soft
1940         }
1941  }
1942
1943 +#ifdef CONFIG_ATH9K_TX99
1944 +
1945  int ath9k_tx99_send(struct ath_softc *sc, struct sk_buff *skb,
1946                     struct ath_tx_control *txctl)
1947  {
1948 @@ -2791,3 +2796,5 @@ int ath9k_tx99_send(struct ath_softc *sc
1949
1950         return 0;
1951  }
1952 +
1953 +#endif /* CONFIG_ATH9K_TX99 */
1954 --- a/drivers/net/wireless/ath/regd.c
1955 +++ b/drivers/net/wireless/ath/regd.c
1956 @@ -37,17 +37,17 @@ static int __ath_regd_init(struct ath_re
1957
1958  /* We enable active scan on these a case by case basis by regulatory domain */
1959  #define ATH9K_2GHZ_CH12_13     REG_RULE(2467-10, 2472+10, 40, 0, 20,\
1960 -                                       NL80211_RRF_PASSIVE_SCAN)
1961 +                                       NL80211_RRF_NO_IR)
1962  #define ATH9K_2GHZ_CH14                REG_RULE(2484-10, 2484+10, 40, 0, 20,\
1963 -                               NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_OFDM)
1964 +                               NL80211_RRF_NO_IR | NL80211_RRF_NO_OFDM)
1965
1966  /* We allow IBSS on these on a case by case basis by regulatory domain */
1967  #define ATH9K_5GHZ_5150_5350   REG_RULE(5150-10, 5350+10, 80, 0, 30,\
1968 -                               NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
1969 +                               NL80211_RRF_NO_IR)
1970  #define ATH9K_5GHZ_5470_5850   REG_RULE(5470-10, 5850+10, 80, 0, 30,\
1971 -                               NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
1972 +                               NL80211_RRF_NO_IR)
1973  #define ATH9K_5GHZ_5725_5850   REG_RULE(5725-10, 5850+10, 80, 0, 30,\
1974 -                               NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
1975 +                               NL80211_RRF_NO_IR)
1976
1977  #define ATH9K_2GHZ_ALL         ATH9K_2GHZ_CH01_11, \
1978                                 ATH9K_2GHZ_CH12_13, \
1979 @@ -224,17 +224,16 @@ ath_reg_apply_beaconing_flags(struct wip
1980                                  * regulatory_hint().
1981                                  */
1982                                 if (!(reg_rule->flags &
1983 -                                   NL80211_RRF_NO_IBSS))
1984 +                                   NL80211_RRF_NO_IR))
1985                                         ch->flags &=
1986 -                                         ~IEEE80211_CHAN_NO_IBSS;
1987 +                                         ~IEEE80211_CHAN_NO_IR;
1988                                 if (!(reg_rule->flags &
1989 -                                   NL80211_RRF_PASSIVE_SCAN))
1990 +                                   NL80211_RRF_NO_IR))
1991                                         ch->flags &=
1992 -                                         ~IEEE80211_CHAN_PASSIVE_SCAN;
1993 +                                         ~IEEE80211_CHAN_NO_IR;
1994                         } else {
1995                                 if (ch->beacon_found)
1996 -                                       ch->flags &= ~(IEEE80211_CHAN_NO_IBSS |
1997 -                                         IEEE80211_CHAN_PASSIVE_SCAN);
1998 +                                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
1999                         }
2000                 }
2001         }
2002 @@ -260,11 +259,11 @@ ath_reg_apply_active_scan_flags(struct w
2003          */
2004         if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2005                 ch = &sband->channels[11]; /* CH 12 */
2006 -               if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2007 -                       ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2008 +               if (ch->flags & IEEE80211_CHAN_NO_IR)
2009 +                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2010                 ch = &sband->channels[12]; /* CH 13 */
2011 -               if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2012 -                       ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2013 +               if (ch->flags & IEEE80211_CHAN_NO_IR)
2014 +                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2015                 return;
2016         }
2017
2018 @@ -278,17 +277,17 @@ ath_reg_apply_active_scan_flags(struct w
2019         ch = &sband->channels[11]; /* CH 12 */
2020         reg_rule = freq_reg_info(wiphy, ch->center_freq);
2021         if (!IS_ERR(reg_rule)) {
2022 -               if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
2023 -                       if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2024 -                               ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2025 +               if (!(reg_rule->flags & NL80211_RRF_NO_IR))
2026 +                       if (ch->flags & IEEE80211_CHAN_NO_IR)
2027 +                               ch->flags &= ~IEEE80211_CHAN_NO_IR;
2028         }
2029
2030         ch = &sband->channels[12]; /* CH 13 */
2031         reg_rule = freq_reg_info(wiphy, ch->center_freq);
2032         if (!IS_ERR(reg_rule)) {
2033 -               if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
2034 -                       if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2035 -                               ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2036 +               if (!(reg_rule->flags & NL80211_RRF_NO_IR))
2037 +                       if (ch->flags & IEEE80211_CHAN_NO_IR)
2038 +                               ch->flags &= ~IEEE80211_CHAN_NO_IR;
2039         }
2040  }
2041
2042 @@ -320,8 +319,8 @@ static void ath_reg_apply_radar_flags(st
2043                  */
2044                 if (!(ch->flags & IEEE80211_CHAN_DISABLED))
2045                         ch->flags |= IEEE80211_CHAN_RADAR |
2046 -                                    IEEE80211_CHAN_NO_IBSS |
2047 -                                    IEEE80211_CHAN_PASSIVE_SCAN;
2048 +                                    IEEE80211_CHAN_NO_IR |
2049 +                                    IEEE80211_CHAN_NO_IR;
2050         }
2051  }
2052
2053 --- a/drivers/net/wireless/brcm80211/brcmfmac/p2p.c
2054 +++ b/drivers/net/wireless/brcm80211/brcmfmac/p2p.c
2055 @@ -812,7 +812,7 @@ static s32 brcmf_p2p_run_escan(struct br
2056                         struct ieee80211_channel *chan = request->channels[i];
2057
2058                         if (chan->flags & (IEEE80211_CHAN_RADAR |
2059 -                                          IEEE80211_CHAN_PASSIVE_SCAN))
2060 +                                          IEEE80211_CHAN_NO_IR))
2061                                 continue;
2062
2063                         chanspecs[i] = channel_to_chanspec(&p2p->cfg->d11inf,
2064 --- a/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
2065 +++ b/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
2066 @@ -202,9 +202,9 @@ static struct ieee80211_supported_band _
2067
2068  /* This is to override regulatory domains defined in cfg80211 module (reg.c)
2069   * By default world regulatory domain defined in reg.c puts the flags
2070 - * NL80211_RRF_PASSIVE_SCAN and NL80211_RRF_NO_IBSS for 5GHz channels (for
2071 - * 36..48 and 149..165). With respect to these flags, wpa_supplicant doesn't
2072 - * start p2p operations on 5GHz channels. All the changes in world regulatory
2073 + * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165).
2074 + * With respect to these flags, wpa_supplicant doesn't * start p2p
2075 + * operations on 5GHz channels. All the changes in world regulatory
2076   * domain are to be done here.
2077   */
2078  static const struct ieee80211_regdomain brcmf_regdom = {
2079 @@ -5197,10 +5197,10 @@ static s32 brcmf_construct_reginfo(struc
2080                                         if (channel & WL_CHAN_RADAR)
2081                                                 band_chan_arr[index].flags |=
2082                                                         (IEEE80211_CHAN_RADAR |
2083 -                                                       IEEE80211_CHAN_NO_IBSS);
2084 +                                                       IEEE80211_CHAN_NO_IR);
2085                                         if (channel & WL_CHAN_PASSIVE)
2086                                                 band_chan_arr[index].flags |=
2087 -                                                   IEEE80211_CHAN_PASSIVE_SCAN;
2088 +                                                   IEEE80211_CHAN_NO_IR;
2089                                 }
2090                         }
2091                         if (!update)
2092 --- a/drivers/net/wireless/brcm80211/brcmsmac/channel.c
2093 +++ b/drivers/net/wireless/brcm80211/brcmsmac/channel.c
2094 @@ -59,23 +59,20 @@
2095
2096  #define BRCM_2GHZ_2412_2462    REG_RULE(2412-10, 2462+10, 40, 0, 19, 0)
2097  #define BRCM_2GHZ_2467_2472    REG_RULE(2467-10, 2472+10, 20, 0, 19, \
2098 -                                        NL80211_RRF_PASSIVE_SCAN | \
2099 -                                        NL80211_RRF_NO_IBSS)
2100 +                                        NL80211_RRF_NO_IR)
2101
2102  #define BRCM_5GHZ_5180_5240    REG_RULE(5180-10, 5240+10, 40, 0, 21, \
2103 -                                        NL80211_RRF_PASSIVE_SCAN | \
2104 -                                        NL80211_RRF_NO_IBSS)
2105 +                                        NL80211_RRF_NO_IR)
2106  #define BRCM_5GHZ_5260_5320    REG_RULE(5260-10, 5320+10, 40, 0, 21, \
2107 -                                        NL80211_RRF_PASSIVE_SCAN | \
2108 +                                        NL80211_RRF_NO_IR | \
2109                                          NL80211_RRF_DFS | \
2110 -                                        NL80211_RRF_NO_IBSS)
2111 +                                        NL80211_RRF_NO_IR)
2112  #define BRCM_5GHZ_5500_5700    REG_RULE(5500-10, 5700+10, 40, 0, 21, \
2113 -                                        NL80211_RRF_PASSIVE_SCAN | \
2114 +                                        NL80211_RRF_NO_IR | \
2115                                          NL80211_RRF_DFS | \
2116 -                                        NL80211_RRF_NO_IBSS)
2117 +                                        NL80211_RRF_NO_IR)
2118  #define BRCM_5GHZ_5745_5825    REG_RULE(5745-10, 5825+10, 40, 0, 21, \
2119 -                                        NL80211_RRF_PASSIVE_SCAN | \
2120 -                                        NL80211_RRF_NO_IBSS)
2121 +                                        NL80211_RRF_NO_IR)
2122
2123  static const struct ieee80211_regdomain brcms_regdom_x2 = {
2124         .n_reg_rules = 6,
2125 @@ -395,7 +392,7 @@ brcms_c_channel_set_chanspec(struct brcm
2126                 brcms_c_set_gmode(wlc, wlc->protection->gmode_user, false);
2127
2128         brcms_b_set_chanspec(wlc->hw, chanspec,
2129 -                             !!(ch->flags & IEEE80211_CHAN_PASSIVE_SCAN),
2130 +                             !!(ch->flags & IEEE80211_CHAN_NO_IR),
2131                               &txpwr);
2132  }
2133
2134 @@ -657,8 +654,8 @@ static void brcms_reg_apply_radar_flags(
2135                  */
2136                 if (!(ch->flags & IEEE80211_CHAN_DISABLED))
2137                         ch->flags |= IEEE80211_CHAN_RADAR |
2138 -                                    IEEE80211_CHAN_NO_IBSS |
2139 -                                    IEEE80211_CHAN_PASSIVE_SCAN;
2140 +                                    IEEE80211_CHAN_NO_IR |
2141 +                                    IEEE80211_CHAN_NO_IR;
2142         }
2143  }
2144
2145 @@ -688,14 +685,13 @@ brcms_reg_apply_beaconing_flags(struct w
2146                                 if (IS_ERR(rule))
2147                                         continue;
2148
2149 -                               if (!(rule->flags & NL80211_RRF_NO_IBSS))
2150 -                                       ch->flags &= ~IEEE80211_CHAN_NO_IBSS;
2151 -                               if (!(rule->flags & NL80211_RRF_PASSIVE_SCAN))
2152 +                               if (!(rule->flags & NL80211_RRF_NO_IR))
2153 +                                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2154 +                               if (!(rule->flags & NL80211_RRF_NO_IR))
2155                                         ch->flags &=
2156 -                                               ~IEEE80211_CHAN_PASSIVE_SCAN;
2157 +                                               ~IEEE80211_CHAN_NO_IR;
2158                         } else if (ch->beacon_found) {
2159 -                               ch->flags &= ~(IEEE80211_CHAN_NO_IBSS |
2160 -                                              IEEE80211_CHAN_PASSIVE_SCAN);
2161 +                               ch->flags &= ~IEEE80211_CHAN_NO_IR;
2162                         }
2163                 }
2164         }
2165 --- a/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
2166 +++ b/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
2167 @@ -125,13 +125,13 @@ static struct ieee80211_channel brcms_2g
2168         CHAN2GHZ(10, 2457, IEEE80211_CHAN_NO_HT40PLUS),
2169         CHAN2GHZ(11, 2462, IEEE80211_CHAN_NO_HT40PLUS),
2170         CHAN2GHZ(12, 2467,
2171 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
2172 +                IEEE80211_CHAN_NO_IR |
2173                  IEEE80211_CHAN_NO_HT40PLUS),
2174         CHAN2GHZ(13, 2472,
2175 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
2176 +                IEEE80211_CHAN_NO_IR |
2177                  IEEE80211_CHAN_NO_HT40PLUS),
2178         CHAN2GHZ(14, 2484,
2179 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
2180 +                IEEE80211_CHAN_NO_IR |
2181                  IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS |
2182                  IEEE80211_CHAN_NO_OFDM)
2183  };
2184 @@ -144,51 +144,51 @@ static struct ieee80211_channel brcms_5g
2185         CHAN5GHZ(48, IEEE80211_CHAN_NO_HT40PLUS),
2186         /* UNII-2 */
2187         CHAN5GHZ(52,
2188 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2189 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2190 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2191 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2192         CHAN5GHZ(56,
2193 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2194 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2195 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2196 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2197         CHAN5GHZ(60,
2198 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2199 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2200 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2201 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2202         CHAN5GHZ(64,
2203 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2204 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2205 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2206 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2207         /* MID */
2208         CHAN5GHZ(100,
2209 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2210 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2211 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2212 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2213         CHAN5GHZ(104,
2214 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2215 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2216 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2217 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2218         CHAN5GHZ(108,
2219 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2220 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2221 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2222 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2223         CHAN5GHZ(112,
2224 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2225 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2226 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2227 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2228         CHAN5GHZ(116,
2229 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2230 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2231 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2232 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2233         CHAN5GHZ(120,
2234 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2235 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2236 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2237 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2238         CHAN5GHZ(124,
2239 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2240 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2241 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2242 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2243         CHAN5GHZ(128,
2244 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2245 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2246 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2247 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2248         CHAN5GHZ(132,
2249 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2250 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
2251 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2252 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS),
2253         CHAN5GHZ(136,
2254 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2255 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
2256 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2257 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS),
2258         CHAN5GHZ(140,
2259 -                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
2260 -                IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS |
2261 +                IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR |
2262 +                IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS |
2263                  IEEE80211_CHAN_NO_HT40MINUS),
2264         /* UNII-3 */
2265         CHAN5GHZ(149, IEEE80211_CHAN_NO_HT40MINUS),
2266 --- a/drivers/net/wireless/cw1200/scan.c
2267 +++ b/drivers/net/wireless/cw1200/scan.c
2268 @@ -197,9 +197,9 @@ void cw1200_scan_work(struct work_struct
2269                         if ((*it)->band != first->band)
2270                                 break;
2271                         if (((*it)->flags ^ first->flags) &
2272 -                                       IEEE80211_CHAN_PASSIVE_SCAN)
2273 +                                       IEEE80211_CHAN_NO_IR)
2274                                 break;
2275 -                       if (!(first->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
2276 +                       if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
2277                             (*it)->max_power != first->max_power)
2278                                 break;
2279                 }
2280 @@ -210,7 +210,7 @@ void cw1200_scan_work(struct work_struct
2281                 else
2282                         scan.max_tx_rate = WSM_TRANSMIT_RATE_1;
2283                 scan.num_probes =
2284 -                       (first->flags & IEEE80211_CHAN_PASSIVE_SCAN) ? 0 : 2;
2285 +                       (first->flags & IEEE80211_CHAN_NO_IR) ? 0 : 2;
2286                 scan.num_ssids = priv->scan.n_ssids;
2287                 scan.ssids = &priv->scan.ssids[0];
2288                 scan.num_channels = it - priv->scan.curr;
2289 @@ -233,7 +233,7 @@ void cw1200_scan_work(struct work_struct
2290                 }
2291                 for (i = 0; i < scan.num_channels; ++i) {
2292                         scan.ch[i].number = priv->scan.curr[i]->hw_value;
2293 -                       if (priv->scan.curr[i]->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
2294 +                       if (priv->scan.curr[i]->flags & IEEE80211_CHAN_NO_IR) {
2295                                 scan.ch[i].min_chan_time = 50;
2296                                 scan.ch[i].max_chan_time = 100;
2297                         } else {
2298 @@ -241,7 +241,7 @@ void cw1200_scan_work(struct work_struct
2299                                 scan.ch[i].max_chan_time = 25;
2300                         }
2301                 }
2302 -               if (!(first->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
2303 +               if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
2304                     priv->scan.output_power != first->max_power) {
2305                         priv->scan.output_power = first->max_power;
2306                         wsm_set_output_power(priv,
2307 --- a/drivers/net/wireless/ipw2x00/ipw2100.c
2308 +++ b/drivers/net/wireless/ipw2x00/ipw2100.c
2309 @@ -1934,10 +1934,10 @@ static int ipw2100_wdev_init(struct net_
2310                         bg_band->channels[i].max_power = geo->bg[i].max_power;
2311                         if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
2312                                 bg_band->channels[i].flags |=
2313 -                                       IEEE80211_CHAN_PASSIVE_SCAN;
2314 +                                       IEEE80211_CHAN_NO_IR;
2315                         if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
2316                                 bg_band->channels[i].flags |=
2317 -                                       IEEE80211_CHAN_NO_IBSS;
2318 +                                       IEEE80211_CHAN_NO_IR;
2319                         if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
2320                                 bg_band->channels[i].flags |=
2321                                         IEEE80211_CHAN_RADAR;
2322 --- a/drivers/net/wireless/ipw2x00/ipw2200.c
2323 +++ b/drivers/net/wireless/ipw2x00/ipw2200.c
2324 @@ -11472,10 +11472,10 @@ static int ipw_wdev_init(struct net_devi
2325                         bg_band->channels[i].max_power = geo->bg[i].max_power;
2326                         if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
2327                                 bg_band->channels[i].flags |=
2328 -                                       IEEE80211_CHAN_PASSIVE_SCAN;
2329 +                                       IEEE80211_CHAN_NO_IR;
2330                         if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
2331                                 bg_band->channels[i].flags |=
2332 -                                       IEEE80211_CHAN_NO_IBSS;
2333 +                                       IEEE80211_CHAN_NO_IR;
2334                         if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
2335                                 bg_band->channels[i].flags |=
2336                                         IEEE80211_CHAN_RADAR;
2337 @@ -11511,10 +11511,10 @@ static int ipw_wdev_init(struct net_devi
2338                         a_band->channels[i].max_power = geo->a[i].max_power;
2339                         if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
2340                                 a_band->channels[i].flags |=
2341 -                                       IEEE80211_CHAN_PASSIVE_SCAN;
2342 +                                       IEEE80211_CHAN_NO_IR;
2343                         if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
2344                                 a_band->channels[i].flags |=
2345 -                                       IEEE80211_CHAN_NO_IBSS;
2346 +                                       IEEE80211_CHAN_NO_IR;
2347                         if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
2348                                 a_band->channels[i].flags |=
2349                                         IEEE80211_CHAN_RADAR;
2350 --- a/drivers/net/wireless/iwlegacy/3945-mac.c
2351 +++ b/drivers/net/wireless/iwlegacy/3945-mac.c
2352 @@ -1595,7 +1595,7 @@ il3945_get_channels_for_scan(struct il_p
2353                  *  and use long active_dwell time.
2354                  */
2355                 if (!is_active || il_is_channel_passive(ch_info) ||
2356 -                   (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
2357 +                   (chan->flags & IEEE80211_CHAN_NO_IR)) {
2358                         scan_ch->type = 0;      /* passive */
2359                         if (IL_UCODE_API(il->ucode_ver) == 1)
2360                                 scan_ch->active_dwell =
2361 --- a/drivers/net/wireless/iwlegacy/4965-mac.c
2362 +++ b/drivers/net/wireless/iwlegacy/4965-mac.c
2363 @@ -805,7 +805,7 @@ il4965_get_channels_for_scan(struct il_p
2364                 }
2365
2366                 if (!is_active || il_is_channel_passive(ch_info) ||
2367 -                   (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN))
2368 +                   (chan->flags & IEEE80211_CHAN_NO_IR))
2369                         scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
2370                 else
2371                         scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
2372 --- a/drivers/net/wireless/iwlegacy/common.c
2373 +++ b/drivers/net/wireless/iwlegacy/common.c
2374 @@ -3447,10 +3447,10 @@ il_init_geos(struct il_priv *il)
2375
2376                 if (il_is_channel_valid(ch)) {
2377                         if (!(ch->flags & EEPROM_CHANNEL_IBSS))
2378 -                               geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
2379 +                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
2380
2381                         if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
2382 -                               geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
2383 +                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
2384
2385                         if (ch->flags & EEPROM_CHANNEL_RADAR)
2386                                 geo_ch->flags |= IEEE80211_CHAN_RADAR;
2387 --- a/drivers/net/wireless/iwlegacy/debug.c
2388 +++ b/drivers/net/wireless/iwlegacy/debug.c
2389 @@ -567,12 +567,12 @@ il_dbgfs_channels_read(struct file *file
2390                                       flags & IEEE80211_CHAN_RADAR ?
2391                                       " (IEEE 802.11h required)" : "",
2392                                       ((channels[i].
2393 -                                       flags & IEEE80211_CHAN_NO_IBSS) ||
2394 +                                       flags & IEEE80211_CHAN_NO_IR) ||
2395                                        (channels[i].
2396                                         flags & IEEE80211_CHAN_RADAR)) ? "" :
2397                                       ", IBSS",
2398                                       channels[i].
2399 -                                     flags & IEEE80211_CHAN_PASSIVE_SCAN ?
2400 +                                     flags & IEEE80211_CHAN_NO_IR ?
2401                                       "passive only" : "active/passive");
2402         }
2403         supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ);
2404 @@ -594,12 +594,12 @@ il_dbgfs_channels_read(struct file *file
2405                                       flags & IEEE80211_CHAN_RADAR ?
2406                                       " (IEEE 802.11h required)" : "",
2407                                       ((channels[i].
2408 -                                       flags & IEEE80211_CHAN_NO_IBSS) ||
2409 +                                       flags & IEEE80211_CHAN_NO_IR) ||
2410                                        (channels[i].
2411                                         flags & IEEE80211_CHAN_RADAR)) ? "" :
2412                                       ", IBSS",
2413                                       channels[i].
2414 -                                     flags & IEEE80211_CHAN_PASSIVE_SCAN ?
2415 +                                     flags & IEEE80211_CHAN_NO_IR ?
2416                                       "passive only" : "active/passive");
2417         }
2418         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2419 --- a/drivers/net/wireless/iwlwifi/dvm/debugfs.c
2420 +++ b/drivers/net/wireless/iwlwifi/dvm/debugfs.c
2421 @@ -352,12 +352,12 @@ static ssize_t iwl_dbgfs_channels_read(s
2422                                         channels[i].max_power,
2423                                         channels[i].flags & IEEE80211_CHAN_RADAR ?
2424                                         " (IEEE 802.11h required)" : "",
2425 -                                       ((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
2426 +                                       ((channels[i].flags & IEEE80211_CHAN_NO_IR)
2427                                         || (channels[i].flags &
2428                                         IEEE80211_CHAN_RADAR)) ? "" :
2429                                         ", IBSS",
2430                                         channels[i].flags &
2431 -                                       IEEE80211_CHAN_PASSIVE_SCAN ?
2432 +                                       IEEE80211_CHAN_NO_IR ?
2433                                         "passive only" : "active/passive");
2434         }
2435         supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
2436 @@ -375,12 +375,12 @@ static ssize_t iwl_dbgfs_channels_read(s
2437                                         channels[i].max_power,
2438                                         channels[i].flags & IEEE80211_CHAN_RADAR ?
2439                                         " (IEEE 802.11h required)" : "",
2440 -                                       ((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
2441 +                                       ((channels[i].flags & IEEE80211_CHAN_NO_IR)
2442                                         || (channels[i].flags &
2443                                         IEEE80211_CHAN_RADAR)) ? "" :
2444                                         ", IBSS",
2445                                         channels[i].flags &
2446 -                                       IEEE80211_CHAN_PASSIVE_SCAN ?
2447 +                                       IEEE80211_CHAN_NO_IR ?
2448                                         "passive only" : "active/passive");
2449         }
2450         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2451 --- a/drivers/net/wireless/iwlwifi/dvm/scan.c
2452 +++ b/drivers/net/wireless/iwlwifi/dvm/scan.c
2453 @@ -544,7 +544,7 @@ static int iwl_get_channels_for_scan(str
2454                 channel = chan->hw_value;
2455                 scan_ch->channel = cpu_to_le16(channel);
2456
2457 -               if (!is_active || (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN))
2458 +               if (!is_active || (chan->flags & IEEE80211_CHAN_NO_IR))
2459                         scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
2460                 else
2461                         scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
2462 --- a/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c
2463 +++ b/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c
2464 @@ -614,10 +614,10 @@ static int iwl_init_channel_map(struct d
2465                         channel->flags = IEEE80211_CHAN_NO_HT40;
2466
2467                         if (!(eeprom_ch->flags & EEPROM_CHANNEL_IBSS))
2468 -                               channel->flags |= IEEE80211_CHAN_NO_IBSS;
2469 +                               channel->flags |= IEEE80211_CHAN_NO_IR;
2470
2471                         if (!(eeprom_ch->flags & EEPROM_CHANNEL_ACTIVE))
2472 -                               channel->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
2473 +                               channel->flags |= IEEE80211_CHAN_NO_IR;
2474
2475                         if (eeprom_ch->flags & EEPROM_CHANNEL_RADAR)
2476                                 channel->flags |= IEEE80211_CHAN_RADAR;
2477 --- a/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c
2478 +++ b/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c
2479 @@ -223,10 +223,10 @@ static int iwl_init_channel_map(struct d
2480                         channel->flags |= IEEE80211_CHAN_NO_160MHZ;
2481
2482                 if (!(ch_flags & NVM_CHANNEL_IBSS))
2483 -                       channel->flags |= IEEE80211_CHAN_NO_IBSS;
2484 +                       channel->flags |= IEEE80211_CHAN_NO_IR;
2485
2486                 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
2487 -                       channel->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
2488 +                       channel->flags |= IEEE80211_CHAN_NO_IR;
2489
2490                 if (ch_flags & NVM_CHANNEL_RADAR)
2491                         channel->flags |= IEEE80211_CHAN_RADAR;
2492 --- a/drivers/net/wireless/iwlwifi/mvm/scan.c
2493 +++ b/drivers/net/wireless/iwlwifi/mvm/scan.c
2494 @@ -192,7 +192,7 @@ static void iwl_mvm_scan_fill_channels(s
2495         for (i = 0; i < cmd->channel_count; i++) {
2496                 chan->channel = cpu_to_le16(req->channels[i]->hw_value);
2497                 chan->type = cpu_to_le32(type);
2498 -               if (req->channels[i]->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2499 +               if (req->channels[i]->flags & IEEE80211_CHAN_NO_IR)
2500                         chan->type &= cpu_to_le32(~SCAN_CHANNEL_TYPE_ACTIVE);
2501                 chan->active_dwell = cpu_to_le16(active_dwell);
2502                 chan->passive_dwell = cpu_to_le16(passive_dwell);
2503 @@ -642,7 +642,7 @@ static void iwl_build_channel_cfg(struct
2504                 channels->iter_count[index] = cpu_to_le16(1);
2505                 channels->iter_interval[index] = 0;
2506
2507 -               if (!(s_band->channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN))
2508 +               if (!(s_band->channels[i].flags & IEEE80211_CHAN_NO_IR))
2509                         channels->type[index] |=
2510                                 cpu_to_le32(IWL_SCAN_OFFLOAD_CHANNEL_ACTIVE);
2511
2512 --- a/drivers/net/wireless/mac80211_hwsim.c
2513 +++ b/drivers/net/wireless/mac80211_hwsim.c
2514 @@ -159,7 +159,7 @@ static const struct ieee80211_regdomain
2515         .reg_rules = {
2516                 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
2517                 REG_RULE(5725-10, 5850+10, 40, 0, 30,
2518 -                       NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
2519 +                        NL80211_RRF_NO_IR),
2520         }
2521  };
2522
2523 @@ -1485,7 +1485,7 @@ static void hw_scan_work(struct work_str
2524                     req->channels[hwsim->scan_chan_idx]->center_freq);
2525
2526         hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
2527 -       if (hwsim->tmp_chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
2528 +       if (hwsim->tmp_chan->flags & IEEE80211_CHAN_NO_IR ||
2529             !req->n_ssids) {
2530                 dwell = 120;
2531         } else {
2532 --- a/drivers/net/wireless/mwifiex/cfg80211.c
2533 +++ b/drivers/net/wireless/mwifiex/cfg80211.c
2534 @@ -50,24 +50,24 @@ static const struct ieee80211_regdomain
2535                 REG_RULE(2412-10, 2462+10, 40, 3, 20, 0),
2536                 /* Channel 12 - 13 */
2537                 REG_RULE(2467-10, 2472+10, 20, 3, 20,
2538 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
2539 +                        NL80211_RRF_NO_IR),
2540                 /* Channel 14 */
2541                 REG_RULE(2484-10, 2484+10, 20, 3, 20,
2542 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
2543 +                        NL80211_RRF_NO_IR |
2544                          NL80211_RRF_NO_OFDM),
2545                 /* Channel 36 - 48 */
2546                 REG_RULE(5180-10, 5240+10, 40, 3, 20,
2547 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
2548 +                        NL80211_RRF_NO_IR),
2549                 /* Channel 149 - 165 */
2550                 REG_RULE(5745-10, 5825+10, 40, 3, 20,
2551 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
2552 +                        NL80211_RRF_NO_IR),
2553                 /* Channel 52 - 64 */
2554                 REG_RULE(5260-10, 5320+10, 40, 3, 30,
2555 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
2556 +                        NL80211_RRF_NO_IR |
2557                          NL80211_RRF_DFS),
2558                 /* Channel 100 - 140 */
2559                 REG_RULE(5500-10, 5700+10, 40, 3, 30,
2560 -                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
2561 +                        NL80211_RRF_NO_IR |
2562                          NL80211_RRF_DFS),
2563         }
2564  };
2565 @@ -1968,7 +1968,7 @@ mwifiex_cfg80211_scan(struct wiphy *wiph
2566                 user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
2567                 user_scan_cfg->chan_list[i].radio_type = chan->band;
2568
2569 -               if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2570 +               if (chan->flags & IEEE80211_CHAN_NO_IR)
2571                         user_scan_cfg->chan_list[i].scan_type =
2572                                                 MWIFIEX_SCAN_TYPE_PASSIVE;
2573                 else
2574 --- a/drivers/net/wireless/mwifiex/scan.c
2575 +++ b/drivers/net/wireless/mwifiex/scan.c
2576 @@ -515,14 +515,14 @@ mwifiex_scan_create_channel_list(struct
2577                                 scan_chan_list[chan_idx].max_scan_time =
2578                                         cpu_to_le16((u16) user_scan_in->
2579                                         chan_list[0].scan_time);
2580 -                       else if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2581 +                       else if (ch->flags & IEEE80211_CHAN_NO_IR)
2582                                 scan_chan_list[chan_idx].max_scan_time =
2583                                         cpu_to_le16(adapter->passive_scan_time);
2584                         else
2585                                 scan_chan_list[chan_idx].max_scan_time =
2586                                         cpu_to_le16(adapter->active_scan_time);
2587
2588 -                       if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2589 +                       if (ch->flags & IEEE80211_CHAN_NO_IR)
2590                                 scan_chan_list[chan_idx].chan_scan_mode_bitmap
2591                                         |= MWIFIEX_PASSIVE_SCAN;
2592                         else
2593 --- a/drivers/net/wireless/rt2x00/rt2x00lib.h
2594 +++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
2595 @@ -146,7 +146,7 @@ void rt2x00queue_remove_l2pad(struct sk_
2596   * @local: frame is not from mac80211
2597   */
2598  int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
2599 -                              bool local);
2600 +                              struct ieee80211_sta *sta, bool local);
2601
2602  /**
2603   * rt2x00queue_update_beacon - Send new beacon from mac80211
2604 --- a/drivers/net/wireless/rt2x00/rt2x00mac.c
2605 +++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
2606 @@ -90,7 +90,7 @@ static int rt2x00mac_tx_rts_cts(struct r
2607                                   frag_skb->data, data_length, tx_info,
2608                                   (struct ieee80211_rts *)(skb->data));
2609
2610 -       retval = rt2x00queue_write_tx_frame(queue, skb, true);
2611 +       retval = rt2x00queue_write_tx_frame(queue, skb, NULL, true);
2612         if (retval) {
2613                 dev_kfree_skb_any(skb);
2614                 rt2x00_warn(rt2x00dev, "Failed to send RTS/CTS frame\n");
2615 @@ -151,7 +151,7 @@ void rt2x00mac_tx(struct ieee80211_hw *h
2616                         goto exit_fail;
2617         }
2618
2619 -       if (unlikely(rt2x00queue_write_tx_frame(queue, skb, false)))
2620 +       if (unlikely(rt2x00queue_write_tx_frame(queue, skb, control->sta, false)))
2621                 goto exit_fail;
2622
2623         /*
2624 --- a/drivers/net/wireless/rt2x00/rt2x00queue.c
2625 +++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
2626 @@ -635,7 +635,7 @@ static void rt2x00queue_bar_check(struct
2627  }
2628
2629  int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
2630 -                              bool local)
2631 +                              struct ieee80211_sta *sta, bool local)
2632  {
2633         struct ieee80211_tx_info *tx_info;
2634         struct queue_entry *entry;
2635 @@ -649,7 +649,7 @@ int rt2x00queue_write_tx_frame(struct da
2636          * after that we are free to use the skb->cb array
2637          * for our information.
2638          */
2639 -       rt2x00queue_create_tx_descriptor(queue->rt2x00dev, skb, &txdesc, NULL);
2640 +       rt2x00queue_create_tx_descriptor(queue->rt2x00dev, skb, &txdesc, sta);
2641
2642         /*
2643          * All information is retrieved from the skb->cb array,
2644 --- a/drivers/net/wireless/rtl818x/rtl8187/dev.c
2645 +++ b/drivers/net/wireless/rtl818x/rtl8187/dev.c
2646 @@ -416,7 +416,7 @@ static int rtl8187_init_urbs(struct ieee
2647         struct rtl8187_rx_info *info;
2648         int ret = 0;
2649
2650 -       while (skb_queue_len(&priv->rx_queue) < 16) {
2651 +       while (skb_queue_len(&priv->rx_queue) < 32) {
2652                 skb = __dev_alloc_skb(RTL8187_MAX_RX, GFP_KERNEL);
2653                 if (!skb) {
2654                         ret = -ENOMEM;
2655 --- a/drivers/net/wireless/rtlwifi/base.c
2656 +++ b/drivers/net/wireless/rtlwifi/base.c
2657 @@ -1078,8 +1078,8 @@ u8 rtl_is_special_data(struct ieee80211_
2658
2659         ip = (struct iphdr *)((u8 *) skb->data + mac_hdr_len +
2660                               SNAP_SIZE + PROTOC_TYPE_SIZE);
2661 -       ether_type = *(u16 *) ((u8 *) skb->data + mac_hdr_len + SNAP_SIZE);
2662 -       /*      ether_type = ntohs(ether_type); */
2663 +       ether_type = be16_to_cpu(*(__be16 *)((u8 *)skb->data + mac_hdr_len +
2664 +                                            SNAP_SIZE));
2665
2666         if (ETH_P_IP == ether_type) {
2667                 if (IPPROTO_UDP == ip->protocol) {
2668 --- a/drivers/net/wireless/rtlwifi/regd.c
2669 +++ b/drivers/net/wireless/rtlwifi/regd.c
2670 @@ -59,30 +59,27 @@ static struct country_code_to_enum_rd al
2671   */
2672  #define RTL819x_2GHZ_CH12_13   \
2673         REG_RULE(2467-10, 2472+10, 40, 0, 20,\
2674 -       NL80211_RRF_PASSIVE_SCAN)
2675 +       NL80211_RRF_NO_IR)
2676
2677  #define RTL819x_2GHZ_CH14      \
2678         REG_RULE(2484-10, 2484+10, 40, 0, 20, \
2679 -       NL80211_RRF_PASSIVE_SCAN | \
2680 +       NL80211_RRF_NO_IR | \
2681         NL80211_RRF_NO_OFDM)
2682
2683  /* 5G chan 36 - chan 64*/
2684  #define RTL819x_5GHZ_5150_5350 \
2685         REG_RULE(5150-10, 5350+10, 40, 0, 30, \
2686 -       NL80211_RRF_PASSIVE_SCAN | \
2687 -       NL80211_RRF_NO_IBSS)
2688 +       NL80211_RRF_NO_IR)
2689
2690  /* 5G chan 100 - chan 165*/
2691  #define RTL819x_5GHZ_5470_5850 \
2692         REG_RULE(5470-10, 5850+10, 40, 0, 30, \
2693 -       NL80211_RRF_PASSIVE_SCAN | \
2694 -       NL80211_RRF_NO_IBSS)
2695 +       NL80211_RRF_NO_IR)
2696
2697  /* 5G chan 149 - chan 165*/
2698  #define RTL819x_5GHZ_5725_5850 \
2699         REG_RULE(5725-10, 5850+10, 40, 0, 30, \
2700 -       NL80211_RRF_PASSIVE_SCAN | \
2701 -       NL80211_RRF_NO_IBSS)
2702 +       NL80211_RRF_NO_IR)
2703
2704  #define RTL819x_5GHZ_ALL       \
2705         (RTL819x_5GHZ_5150_5350, RTL819x_5GHZ_5470_5850)
2706 @@ -185,16 +182,15 @@ static void _rtl_reg_apply_beaconing_fla
2707                                  *regulatory_hint().
2708                                  */
2709
2710 -                               if (!(reg_rule->flags & NL80211_RRF_NO_IBSS))
2711 -                                       ch->flags &= ~IEEE80211_CHAN_NO_IBSS;
2712 +                               if (!(reg_rule->flags & NL80211_RRF_NO_IR))
2713 +                                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2714                                 if (!(reg_rule->
2715 -                                    flags & NL80211_RRF_PASSIVE_SCAN))
2716 +                                    flags & NL80211_RRF_NO_IR))
2717                                         ch->flags &=
2718 -                                           ~IEEE80211_CHAN_PASSIVE_SCAN;
2719 +                                           ~IEEE80211_CHAN_NO_IR;
2720                         } else {
2721                                 if (ch->beacon_found)
2722 -                                       ch->flags &= ~(IEEE80211_CHAN_NO_IBSS |
2723 -                                                 IEEE80211_CHAN_PASSIVE_SCAN);
2724 +                                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2725                         }
2726                 }
2727         }
2728 @@ -219,11 +215,11 @@ static void _rtl_reg_apply_active_scan_f
2729          */
2730         if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2731                 ch = &sband->channels[11];      /* CH 12 */
2732 -               if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2733 -                       ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2734 +               if (ch->flags & IEEE80211_CHAN_NO_IR)
2735 +                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2736                 ch = &sband->channels[12];      /* CH 13 */
2737 -               if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2738 -                       ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2739 +               if (ch->flags & IEEE80211_CHAN_NO_IR)
2740 +                       ch->flags &= ~IEEE80211_CHAN_NO_IR;
2741                 return;
2742         }
2743
2744 @@ -237,17 +233,17 @@ static void _rtl_reg_apply_active_scan_f
2745         ch = &sband->channels[11];      /* CH 12 */
2746         reg_rule = freq_reg_info(wiphy, ch->center_freq);
2747         if (!IS_ERR(reg_rule)) {
2748 -               if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
2749 -                       if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2750 -                               ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2751 +               if (!(reg_rule->flags & NL80211_RRF_NO_IR))
2752 +                       if (ch->flags & IEEE80211_CHAN_NO_IR)
2753 +                               ch->flags &= ~IEEE80211_CHAN_NO_IR;
2754         }
2755
2756         ch = &sband->channels[12];      /* CH 13 */
2757         reg_rule = freq_reg_info(wiphy, ch->center_freq);
2758         if (!IS_ERR(reg_rule)) {
2759 -               if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
2760 -                       if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
2761 -                               ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
2762 +               if (!(reg_rule->flags & NL80211_RRF_NO_IR))
2763 +                       if (ch->flags & IEEE80211_CHAN_NO_IR)
2764 +                               ch->flags &= ~IEEE80211_CHAN_NO_IR;
2765         }
2766  }
2767
2768 @@ -284,8 +280,8 @@ static void _rtl_reg_apply_radar_flags(s
2769                  */
2770                 if (!(ch->flags & IEEE80211_CHAN_DISABLED))
2771                         ch->flags |= IEEE80211_CHAN_RADAR |
2772 -                           IEEE80211_CHAN_NO_IBSS |
2773 -                           IEEE80211_CHAN_PASSIVE_SCAN;
2774 +                           IEEE80211_CHAN_NO_IR |
2775 +                           IEEE80211_CHAN_NO_IR;
2776         }
2777  }
2778
2779 --- a/drivers/net/wireless/ti/wl12xx/scan.c
2780 +++ b/drivers/net/wireless/ti/wl12xx/scan.c
2781 @@ -47,7 +47,7 @@ static int wl1271_get_scan_channels(stru
2782                      * In active scans, we only scan channels not
2783                      * marked as passive.
2784                      */
2785 -                   (passive || !(flags & IEEE80211_CHAN_PASSIVE_SCAN))) {
2786 +                   (passive || !(flags & IEEE80211_CHAN_NO_IR))) {
2787                         wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
2788                                      req->channels[i]->band,
2789                                      req->channels[i]->center_freq);
2790 --- a/drivers/net/wireless/ti/wlcore/cmd.c
2791 +++ b/drivers/net/wireless/ti/wlcore/cmd.c
2792 @@ -1688,7 +1688,7 @@ int wlcore_cmd_regdomain_config_locked(s
2793
2794                         if (channel->flags & (IEEE80211_CHAN_DISABLED |
2795                                               IEEE80211_CHAN_RADAR |
2796 -                                             IEEE80211_CHAN_PASSIVE_SCAN))
2797 +                                             IEEE80211_CHAN_NO_IR))
2798                                 continue;
2799
2800                         ch_bit_idx = wlcore_get_reg_conf_ch_idx(b, ch);
2801 --- a/drivers/net/wireless/ti/wlcore/main.c
2802 +++ b/drivers/net/wireless/ti/wlcore/main.c
2803 @@ -91,8 +91,7 @@ static void wl1271_reg_notify(struct wip
2804                         continue;
2805
2806                 if (ch->flags & IEEE80211_CHAN_RADAR)
2807 -                       ch->flags |= IEEE80211_CHAN_NO_IBSS |
2808 -                                    IEEE80211_CHAN_PASSIVE_SCAN;
2809 +                       ch->flags |= IEEE80211_CHAN_NO_IR;
2810
2811         }
2812
2813 --- a/drivers/net/wireless/ti/wlcore/scan.c
2814 +++ b/drivers/net/wireless/ti/wlcore/scan.c
2815 @@ -189,14 +189,14 @@ wlcore_scan_get_channels(struct wl1271 *
2816                 flags = req_channels[i]->flags;
2817
2818                 if (force_passive)
2819 -                       flags |= IEEE80211_CHAN_PASSIVE_SCAN;
2820 +                       flags |= IEEE80211_CHAN_NO_IR;
2821
2822                 if ((req_channels[i]->band == band) &&
2823                     !(flags & IEEE80211_CHAN_DISABLED) &&
2824                     (!!(flags & IEEE80211_CHAN_RADAR) == radar) &&
2825                     /* if radar is set, we ignore the passive flag */
2826                     (radar ||
2827 -                    !!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
2828 +                    !!(flags & IEEE80211_CHAN_NO_IR) == passive)) {
2829
2830
2831                         if (flags & IEEE80211_CHAN_RADAR) {
2832 @@ -221,7 +221,7 @@ wlcore_scan_get_channels(struct wl1271 *
2833                             (band == IEEE80211_BAND_2GHZ) &&
2834                             (channels[j].channel >= 12) &&
2835                             (channels[j].channel <= 14) &&
2836 -                           (flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
2837 +                           (flags & IEEE80211_CHAN_NO_IR) &&
2838                             !force_passive) {
2839                                 /* pactive channels treated as DFS */
2840                                 channels[j].flags = SCAN_CHANNEL_FLAGS_DFS;
2841 @@ -244,7 +244,7 @@ wlcore_scan_get_channels(struct wl1271 *
2842                                      max_dwell_time_active,
2843                                      flags & IEEE80211_CHAN_RADAR ?
2844                                         ", DFS" : "",
2845 -                                    flags & IEEE80211_CHAN_PASSIVE_SCAN ?
2846 +                                    flags & IEEE80211_CHAN_NO_IR ?
2847                                         ", PASSIVE" : "");
2848                         j++;
2849                 }
2850 --- a/include/net/cfg80211.h
2851 +++ b/include/net/cfg80211.h
2852 @@ -91,9 +91,8 @@ enum ieee80211_band {
2853   * Channel flags set by the regulatory control code.
2854   *
2855   * @IEEE80211_CHAN_DISABLED: This channel is disabled.
2856 - * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted
2857 - *     on this channel.
2858 - * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel.
2859 + * @IEEE80211_CHAN_NO_IR: do not initiate radiation, this includes
2860 + *     sending probe requests or beaconing.
2861   * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
2862   * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel
2863   *     is not permitted.
2864 @@ -113,8 +112,8 @@ enum ieee80211_band {
2865   */
2866  enum ieee80211_channel_flags {
2867         IEEE80211_CHAN_DISABLED         = 1<<0,
2868 -       IEEE80211_CHAN_PASSIVE_SCAN     = 1<<1,
2869 -       IEEE80211_CHAN_NO_IBSS          = 1<<2,
2870 +       IEEE80211_CHAN_NO_IR            = 1<<1,
2871 +       /* hole at 1<<2 */
2872         IEEE80211_CHAN_RADAR            = 1<<3,
2873         IEEE80211_CHAN_NO_HT40PLUS      = 1<<4,
2874         IEEE80211_CHAN_NO_HT40MINUS     = 1<<5,
2875 @@ -4149,6 +4148,7 @@ void cfg80211_radar_event(struct wiphy *
2876  /**
2877   * cfg80211_cac_event - Channel availability check (CAC) event
2878   * @netdev: network device
2879 + * @chandef: chandef for the current channel
2880   * @event: type of event
2881   * @gfp: context flags
2882   *
2883 @@ -4157,6 +4157,7 @@ void cfg80211_radar_event(struct wiphy *
2884   * also by full-MAC drivers.
2885   */
2886  void cfg80211_cac_event(struct net_device *netdev,
2887 +                       const struct cfg80211_chan_def *chandef,
2888                         enum nl80211_radar_event event, gfp_t gfp);
2889
2890
2891 --- a/include/uapi/linux/nl80211.h
2892 +++ b/include/uapi/linux/nl80211.h
2893 @@ -1508,6 +1508,9 @@ enum nl80211_commands {
2894   *     to react to radar events, e.g. initiate a channel switch or leave the
2895   *     IBSS network.
2896   *
2897 + * @NL80211_ATTR_SUPPORT_5_10_MHZ: A flag indicating that the device supports
2898 + *     5 MHz and 10 MHz channel bandwidth.
2899 + *
2900   * @NL80211_ATTR_MAX: highest attribute number currently defined
2901   * @__NL80211_ATTR_AFTER_LAST: internal use
2902   */
2903 @@ -1824,6 +1827,8 @@ enum nl80211_attrs {
2904
2905         NL80211_ATTR_HANDLE_DFS,
2906
2907 +       NL80211_ATTR_SUPPORT_5_10_MHZ,
2908 +
2909         /* add attributes here, update the policy in nl80211.c */
2910
2911         __NL80211_ATTR_AFTER_LAST,
2912 @@ -2224,10 +2229,9 @@ enum nl80211_band_attr {
2913   * @NL80211_FREQUENCY_ATTR_FREQ: Frequency in MHz
2914   * @NL80211_FREQUENCY_ATTR_DISABLED: Channel is disabled in current
2915   *     regulatory domain.
2916 - * @NL80211_FREQUENCY_ATTR_PASSIVE_SCAN: Only passive scanning is
2917 - *     permitted on this channel in current regulatory domain.
2918 - * @NL80211_FREQUENCY_ATTR_NO_IBSS: IBSS networks are not permitted
2919 - *     on this channel in current regulatory domain.
2920 + * @NL80211_FREQUENCY_ATTR_NO_IR: no mechanisms that initiate radiation
2921 + *     are permitted on this channel, this includes sending probe
2922 + *     requests, or modes of operation that require beaconing.
2923   * @NL80211_FREQUENCY_ATTR_RADAR: Radar detection is mandatory
2924   *     on this channel in current regulatory domain.
2925   * @NL80211_FREQUENCY_ATTR_MAX_TX_POWER: Maximum transmission power in mBm
2926 @@ -2254,8 +2258,8 @@ enum nl80211_frequency_attr {
2927         __NL80211_FREQUENCY_ATTR_INVALID,
2928         NL80211_FREQUENCY_ATTR_FREQ,
2929         NL80211_FREQUENCY_ATTR_DISABLED,
2930 -       NL80211_FREQUENCY_ATTR_PASSIVE_SCAN,
2931 -       NL80211_FREQUENCY_ATTR_NO_IBSS,
2932 +       NL80211_FREQUENCY_ATTR_NO_IR,
2933 +       __NL80211_FREQUENCY_ATTR_NO_IBSS,
2934         NL80211_FREQUENCY_ATTR_RADAR,
2935         NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
2936         NL80211_FREQUENCY_ATTR_DFS_STATE,
2937 @@ -2271,6 +2275,9 @@ enum nl80211_frequency_attr {
2938  };
2939
2940  #define NL80211_FREQUENCY_ATTR_MAX_TX_POWER NL80211_FREQUENCY_ATTR_MAX_TX_POWER
2941 +#define NL80211_FREQUENCY_ATTR_PASSIVE_SCAN    NL80211_FREQUENCY_ATTR_NO_IR
2942 +#define NL80211_FREQUENCY_ATTR_NO_IBSS         NL80211_FREQUENCY_ATTR_NO_IR
2943 +#define NL80211_FREQUENCY_ATTR_NO_IR           NL80211_FREQUENCY_ATTR_NO_IR
2944
2945  /**
2946   * enum nl80211_bitrate_attr - bitrate attributes
2947 @@ -2413,8 +2420,9 @@ enum nl80211_sched_scan_match_attr {
2948   * @NL80211_RRF_DFS: DFS support is required to be used
2949   * @NL80211_RRF_PTP_ONLY: this is only for Point To Point links
2950   * @NL80211_RRF_PTMP_ONLY: this is only for Point To Multi Point links
2951 - * @NL80211_RRF_PASSIVE_SCAN: passive scan is required
2952 - * @NL80211_RRF_NO_IBSS: no IBSS is allowed
2953 + * @NL80211_RRF_NO_IR: no mechanisms that initiate radiation are allowed,
2954 + *     this includes probe requests or modes of operation that require
2955 + *     beaconing.
2956   */
2957  enum nl80211_reg_rule_flags {
2958         NL80211_RRF_NO_OFDM             = 1<<0,
2959 @@ -2424,10 +2432,17 @@ enum nl80211_reg_rule_flags {
2960         NL80211_RRF_DFS                 = 1<<4,
2961         NL80211_RRF_PTP_ONLY            = 1<<5,
2962         NL80211_RRF_PTMP_ONLY           = 1<<6,
2963 -       NL80211_RRF_PASSIVE_SCAN        = 1<<7,
2964 -       NL80211_RRF_NO_IBSS             = 1<<8,
2965 +       NL80211_RRF_NO_IR               = 1<<7,
2966 +       __NL80211_RRF_NO_IBSS           = 1<<8,
2967  };
2968
2969 +#define NL80211_RRF_PASSIVE_SCAN       NL80211_RRF_NO_IR
2970 +#define NL80211_RRF_NO_IBSS            NL80211_RRF_NO_IR
2971 +#define NL80211_RRF_NO_IR              NL80211_RRF_NO_IR
2972 +
2973 +/* For backport compatibility with older userspace */
2974 +#define NL80211_RRF_NO_IR_ALL          (NL80211_RRF_NO_IR | __NL80211_RRF_NO_IBSS)
2975 +
2976  /**
2977   * enum nl80211_dfs_regions - regulatory DFS regions
2978   *
2979 --- a/net/mac80211/cfg.c
2980 +++ b/net/mac80211/cfg.c
2981 @@ -1050,6 +1050,7 @@ static int ieee80211_stop_ap(struct wiph
2982         struct ieee80211_local *local = sdata->local;
2983         struct beacon_data *old_beacon;
2984         struct probe_resp *old_probe_resp;
2985 +       struct cfg80211_chan_def chandef;
2986
2987         old_beacon = rtnl_dereference(sdata->u.ap.beacon);
2988         if (!old_beacon)
2989 @@ -1091,8 +1092,10 @@ static int ieee80211_stop_ap(struct wiph
2990         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
2991
2992         if (sdata->wdev.cac_started) {
2993 +               chandef = sdata->vif.bss_conf.chandef;
2994                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
2995 -               cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
2996 +               cfg80211_cac_event(sdata->dev, &chandef,
2997 +                                  NL80211_RADAR_CAC_ABORTED,
2998                                    GFP_KERNEL);
2999         }
3000
3001 --- a/net/mac80211/iface.c
3002 +++ b/net/mac80211/iface.c
3003 @@ -749,6 +749,7 @@ static void ieee80211_do_stop(struct iee
3004         u32 hw_reconf_flags = 0;
3005         int i, flushed;
3006         struct ps_data *ps;
3007 +       struct cfg80211_chan_def chandef;
3008
3009         clear_bit(SDATA_STATE_RUNNING, &sdata->state);
3010
3011 @@ -828,11 +829,13 @@ static void ieee80211_do_stop(struct iee
3012         cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
3013
3014         if (sdata->wdev.cac_started) {
3015 +               chandef = sdata->vif.bss_conf.chandef;
3016                 WARN_ON(local->suspended);
3017                 mutex_lock(&local->iflist_mtx);
3018                 ieee80211_vif_release_channel(sdata);
3019                 mutex_unlock(&local->iflist_mtx);
3020 -               cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
3021 +               cfg80211_cac_event(sdata->dev, &chandef,
3022 +                                  NL80211_RADAR_CAC_ABORTED,
3023                                    GFP_KERNEL);
3024         }
3025
3026 @@ -1340,7 +1343,6 @@ static void ieee80211_setup_sdata(struct
3027                 sdata->vif.bss_conf.bssid = NULL;
3028                 break;
3029         case NL80211_IFTYPE_AP_VLAN:
3030 -               break;
3031         case NL80211_IFTYPE_P2P_DEVICE:
3032                 sdata->vif.bss_conf.bssid = sdata->vif.addr;
3033                 break;
3034 --- a/net/mac80211/mlme.c
3035 +++ b/net/mac80211/mlme.c
3036 @@ -1398,10 +1398,12 @@ void ieee80211_dfs_cac_timer_work(struct
3037         struct ieee80211_sub_if_data *sdata =
3038                 container_of(delayed_work, struct ieee80211_sub_if_data,
3039                              dfs_cac_timer_work);
3040 +       struct cfg80211_chan_def chandef = sdata->vif.bss_conf.chandef;
3041
3042         ieee80211_vif_release_channel(sdata);
3043 -
3044 -       cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_FINISHED, GFP_KERNEL);
3045 +       cfg80211_cac_event(sdata->dev, &chandef,
3046 +                          NL80211_RADAR_CAC_FINISHED,
3047 +                          GFP_KERNEL);
3048  }
3049
3050  /* MLME */
3051 --- a/net/mac80211/rx.c
3052 +++ b/net/mac80211/rx.c
3053 @@ -729,9 +729,7 @@ static void ieee80211_release_reorder_fr
3054         lockdep_assert_held(&tid_agg_rx->reorder_lock);
3055
3056         while (ieee80211_sn_less(tid_agg_rx->head_seq_num, head_seq_num)) {
3057 -               index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
3058 -                                        tid_agg_rx->ssn) %
3059 -                                                       tid_agg_rx->buf_size;
3060 +               index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
3061                 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
3062                                                 frames);
3063         }
3064 @@ -757,8 +755,7 @@ static void ieee80211_sta_reorder_releas
3065         lockdep_assert_held(&tid_agg_rx->reorder_lock);
3066
3067         /* release the buffer until next missing frame */
3068 -       index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
3069 -                                tid_agg_rx->ssn) % tid_agg_rx->buf_size;
3070 +       index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
3071         if (!tid_agg_rx->reorder_buf[index] &&
3072             tid_agg_rx->stored_mpdu_num) {
3073                 /*
3074 @@ -793,15 +790,11 @@ static void ieee80211_sta_reorder_releas
3075         } else while (tid_agg_rx->reorder_buf[index]) {
3076                 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
3077                                                 frames);
3078 -               index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
3079 -                                        tid_agg_rx->ssn) %
3080 -                                                       tid_agg_rx->buf_size;
3081 +               index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
3082         }
3083
3084         if (tid_agg_rx->stored_mpdu_num) {
3085 -               j = index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
3086 -                                            tid_agg_rx->ssn) %
3087 -                                                       tid_agg_rx->buf_size;
3088 +               j = index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
3089
3090                 for (; j != (index - 1) % tid_agg_rx->buf_size;
3091                      j = (j + 1) % tid_agg_rx->buf_size) {
3092 @@ -861,8 +854,7 @@ static bool ieee80211_sta_manage_reorder
3093
3094         /* Now the new frame is always in the range of the reordering buffer */
3095
3096 -       index = ieee80211_sn_sub(mpdu_seq_num,
3097 -                                tid_agg_rx->ssn) % tid_agg_rx->buf_size;
3098 +       index = mpdu_seq_num % tid_agg_rx->buf_size;
3099
3100         /* check if we already stored this frame */
3101         if (tid_agg_rx->reorder_buf[index]) {
3102 --- a/net/mac80211/scan.c
3103 +++ b/net/mac80211/scan.c
3104 @@ -526,7 +526,7 @@ static int __ieee80211_start_scan(struct
3105                 ieee80211_hw_config(local, 0);
3106
3107                 if ((req->channels[0]->flags &
3108 -                    IEEE80211_CHAN_PASSIVE_SCAN) ||
3109 +                    IEEE80211_CHAN_NO_IR) ||
3110                     !local->scan_req->n_ssids) {
3111                         next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
3112                 } else {
3113 @@ -572,7 +572,7 @@ ieee80211_scan_get_channel_time(struct i
3114          * TODO: channel switching also consumes quite some time,
3115          * add that delay as well to get a better estimation
3116          */
3117 -       if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
3118 +       if (chan->flags & IEEE80211_CHAN_NO_IR)
3119                 return IEEE80211_PASSIVE_CHANNEL_TIME;
3120         return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
3121  }
3122 @@ -696,7 +696,7 @@ static void ieee80211_scan_state_set_cha
3123          *
3124          * In any case, it is not necessary for a passive scan.
3125          */
3126 -       if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
3127 +       if (chan->flags & IEEE80211_CHAN_NO_IR ||
3128             !local->scan_req->n_ssids) {
3129                 *next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
3130                 local->next_scan_state = SCAN_DECISION;
3131 @@ -881,7 +881,7 @@ int ieee80211_request_ibss_scan(struct i
3132                                 struct ieee80211_channel *tmp_ch =
3133                                     &local->hw.wiphy->bands[band]->channels[i];
3134
3135 -                               if (tmp_ch->flags & (IEEE80211_CHAN_NO_IBSS |
3136 +                               if (tmp_ch->flags & (IEEE80211_CHAN_NO_IR |
3137                                                      IEEE80211_CHAN_DISABLED))
3138                                         continue;
3139
3140 @@ -895,7 +895,7 @@ int ieee80211_request_ibss_scan(struct i
3141
3142                 local->int_scan_req->n_channels = n_ch;
3143         } else {
3144 -               if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IBSS |
3145 +               if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IR |
3146                                                 IEEE80211_CHAN_DISABLED)))
3147                         goto unlock;
3148
3149 --- a/net/mac80211/tx.c
3150 +++ b/net/mac80211/tx.c
3151 @@ -1728,8 +1728,7 @@ netdev_tx_t ieee80211_monitor_start_xmit
3152          * radar detection by itself. We can do that later by adding a
3153          * monitor flag interfaces used for AP support.
3154          */
3155 -       if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
3156 -                           IEEE80211_CHAN_PASSIVE_SCAN)))
3157 +       if ((chan->flags & (IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_RADAR)))
3158                 goto fail_rcu;
3159
3160         ieee80211_xmit(sdata, skb, chan->band);
3161 --- a/net/mac80211/util.c
3162 +++ b/net/mac80211/util.c
3163 @@ -2259,14 +2259,17 @@ u64 ieee80211_calculate_rx_timestamp(str
3164  void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
3165  {
3166         struct ieee80211_sub_if_data *sdata;
3167 +       struct cfg80211_chan_def chandef;
3168
3169         mutex_lock(&local->iflist_mtx);
3170         list_for_each_entry(sdata, &local->interfaces, list) {
3171                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
3172
3173                 if (sdata->wdev.cac_started) {
3174 +                       chandef = sdata->vif.bss_conf.chandef;
3175                         ieee80211_vif_release_channel(sdata);
3176                         cfg80211_cac_event(sdata->dev,
3177 +                                          &chandef,
3178                                            NL80211_RADAR_CAC_ABORTED,
3179                                            GFP_KERNEL);
3180                 }
3181 --- a/net/wireless/chan.c
3182 +++ b/net/wireless/chan.c
3183 @@ -277,6 +277,32 @@ void cfg80211_set_dfs_state(struct wiphy
3184                                      width, dfs_state);
3185  }
3186
3187 +static u32 cfg80211_get_start_freq(u32 center_freq,
3188 +                                  u32 bandwidth)
3189 +{
3190 +       u32 start_freq;
3191 +
3192 +       if (bandwidth <= 20)
3193 +               start_freq = center_freq;
3194 +       else
3195 +               start_freq = center_freq - bandwidth/2 + 10;
3196 +
3197 +       return start_freq;
3198 +}
3199 +
3200 +static u32 cfg80211_get_end_freq(u32 center_freq,
3201 +                                u32 bandwidth)
3202 +{
3203 +       u32 end_freq;
3204 +
3205 +       if (bandwidth <= 20)
3206 +               end_freq = center_freq;
3207 +       else
3208 +               end_freq = center_freq + bandwidth/2 - 10;
3209 +
3210 +       return end_freq;
3211 +}
3212 +
3213  static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
3214                                             u32 center_freq,
3215                                             u32 bandwidth)
3216 @@ -284,13 +310,8 @@ static int cfg80211_get_chans_dfs_requir
3217         struct ieee80211_channel *c;
3218         u32 freq, start_freq, end_freq;
3219
3220 -       if (bandwidth <= 20) {
3221 -               start_freq = center_freq;
3222 -               end_freq = center_freq;
3223 -       } else {
3224 -               start_freq = center_freq - bandwidth/2 + 10;
3225 -               end_freq = center_freq + bandwidth/2 - 10;
3226 -       }
3227 +       start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
3228 +       end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
3229
3230         for (freq = start_freq; freq <= end_freq; freq += 20) {
3231                 c = ieee80211_get_channel(wiphy, freq);
3232 @@ -330,33 +351,159 @@ int cfg80211_chandef_dfs_required(struct
3233  }
3234  EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
3235
3236 -static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
3237 -                                       u32 center_freq, u32 bandwidth,
3238 -                                       u32 prohibited_flags)
3239 +static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
3240 +                                        u32 center_freq,
3241 +                                        u32 bandwidth)
3242  {
3243         struct ieee80211_channel *c;
3244         u32 freq, start_freq, end_freq;
3245 +       int count = 0;
3246
3247 -       if (bandwidth <= 20) {
3248 -               start_freq = center_freq;
3249 -               end_freq = center_freq;
3250 -       } else {
3251 -               start_freq = center_freq - bandwidth/2 + 10;
3252 -               end_freq = center_freq + bandwidth/2 - 10;
3253 +       start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
3254 +       end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
3255 +
3256 +       /*
3257 +        * Check entire range of channels for the bandwidth.
3258 +        * Check all channels are DFS channels (DFS_USABLE or
3259 +        * DFS_AVAILABLE). Return number of usable channels
3260 +        * (require CAC). Allow DFS and non-DFS channel mix.
3261 +        */
3262 +       for (freq = start_freq; freq <= end_freq; freq += 20) {
3263 +               c = ieee80211_get_channel(wiphy, freq);
3264 +               if (!c)
3265 +                       return -EINVAL;
3266 +
3267 +               if (c->flags & IEEE80211_CHAN_DISABLED)
3268 +                       return -EINVAL;
3269 +
3270 +               if (c->flags & IEEE80211_CHAN_RADAR) {
3271 +                       if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
3272 +                               return -EINVAL;
3273 +
3274 +                       if (c->dfs_state == NL80211_DFS_USABLE)
3275 +                               count++;
3276 +               }
3277 +       }
3278 +
3279 +       return count;
3280 +}
3281 +
3282 +bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
3283 +                                const struct cfg80211_chan_def *chandef)
3284 +{
3285 +       int width;
3286 +       int r1, r2 = 0;
3287 +
3288 +       if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3289 +               return false;
3290 +
3291 +       width = cfg80211_chandef_get_width(chandef);
3292 +       if (width < 0)
3293 +               return false;
3294 +
3295 +       r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
3296 +                                         width);
3297 +
3298 +       if (r1 < 0)
3299 +               return false;
3300 +
3301 +       switch (chandef->width) {
3302 +       case NL80211_CHAN_WIDTH_80P80:
3303 +               WARN_ON(!chandef->center_freq2);
3304 +               r2 = cfg80211_get_chans_dfs_usable(wiphy,
3305 +                                                  chandef->center_freq2,
3306 +                                                  width);
3307 +               if (r2 < 0)
3308 +                       return false;
3309 +               break;
3310 +       default:
3311 +               WARN_ON(chandef->center_freq2);
3312 +               break;
3313         }
3314
3315 +       return (r1 + r2 > 0);
3316 +}
3317 +
3318 +
3319 +static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
3320 +                                            u32 center_freq,
3321 +                                            u32 bandwidth)
3322 +{
3323 +       struct ieee80211_channel *c;
3324 +       u32 freq, start_freq, end_freq;
3325 +
3326 +       start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
3327 +       end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
3328 +
3329 +       /*
3330 +        * Check entire range of channels for the bandwidth.
3331 +        * If any channel in between is disabled or has not
3332 +        * had gone through CAC return false
3333 +        */
3334         for (freq = start_freq; freq <= end_freq; freq += 20) {
3335                 c = ieee80211_get_channel(wiphy, freq);
3336                 if (!c)
3337                         return false;
3338
3339 -               /* check for radar flags */
3340 -               if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) &&
3341 +               if (c->flags & IEEE80211_CHAN_DISABLED)
3342 +                       return false;
3343 +
3344 +               if ((c->flags & IEEE80211_CHAN_RADAR)  &&
3345                     (c->dfs_state != NL80211_DFS_AVAILABLE))
3346                         return false;
3347 +       }
3348 +
3349 +       return true;
3350 +}
3351 +
3352 +static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
3353 +                               const struct cfg80211_chan_def *chandef)
3354 +{
3355 +       int width;
3356 +       int r;
3357 +
3358 +       if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3359 +               return false;
3360
3361 -               /* check for the other flags */
3362 -               if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR)
3363 +       width = cfg80211_chandef_get_width(chandef);
3364 +       if (width < 0)
3365 +               return false;
3366 +
3367 +       r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
3368 +                                            width);
3369 +
3370 +       /* If any of channels unavailable for cf1 just return */
3371 +       if (!r)
3372 +               return r;
3373 +
3374 +       switch (chandef->width) {
3375 +       case NL80211_CHAN_WIDTH_80P80:
3376 +               WARN_ON(!chandef->center_freq2);
3377 +               r = cfg80211_get_chans_dfs_available(wiphy,
3378 +                                                    chandef->center_freq2,
3379 +                                                    width);
3380 +       default:
3381 +               WARN_ON(chandef->center_freq2);
3382 +               break;
3383 +       }
3384 +
3385 +       return r;
3386 +}
3387 +
3388 +
3389 +static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
3390 +                                       u32 center_freq, u32 bandwidth,
3391 +                                       u32 prohibited_flags)
3392 +{
3393 +       struct ieee80211_channel *c;
3394 +       u32 freq, start_freq, end_freq;
3395 +
3396 +       start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
3397 +       end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
3398 +
3399 +       for (freq = start_freq; freq <= end_freq; freq += 20) {
3400 +               c = ieee80211_get_channel(wiphy, freq);
3401 +               if (!c || c->flags & prohibited_flags)
3402                         return false;
3403         }
3404
3405 @@ -462,14 +609,19 @@ bool cfg80211_reg_can_beacon(struct wiph
3406                              struct cfg80211_chan_def *chandef)
3407  {
3408         bool res;
3409 +       u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
3410 +                              IEEE80211_CHAN_NO_IR |
3411 +                              IEEE80211_CHAN_RADAR;
3412
3413         trace_cfg80211_reg_can_beacon(wiphy, chandef);
3414
3415 -       res = cfg80211_chandef_usable(wiphy, chandef,
3416 -                                     IEEE80211_CHAN_DISABLED |
3417 -                                     IEEE80211_CHAN_PASSIVE_SCAN |
3418 -                                     IEEE80211_CHAN_NO_IBSS |
3419 -                                     IEEE80211_CHAN_RADAR);
3420 +       if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 &&
3421 +           cfg80211_chandef_dfs_available(wiphy, chandef)) {
3422 +               /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
3423 +               prohibited_flags = IEEE80211_CHAN_DISABLED;
3424 +       }
3425 +
3426 +       res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
3427
3428         trace_cfg80211_return_bool(res);
3429         return res;
3430 --- a/net/wireless/core.h
3431 +++ b/net/wireless/core.h
3432 @@ -382,6 +382,19 @@ int cfg80211_can_use_iftype_chan(struct
3433                                  enum cfg80211_chan_mode chanmode,
3434                                  u8 radar_detect);
3435
3436 +/**
3437 + * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable
3438 + * @wiphy: the wiphy to validate against
3439 + * @chandef: the channel definition to check
3440 + *
3441 + * Checks if chandef is usable and we can/need start CAC on such channel.
3442 + *
3443 + * Return: Return true if all channels available and at least
3444 + *        one channel require CAC (NL80211_DFS_USABLE)
3445 + */
3446 +bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
3447 +                                const struct cfg80211_chan_def *chandef);
3448 +
3449  void cfg80211_set_dfs_state(struct wiphy *wiphy,
3450                             const struct cfg80211_chan_def *chandef,
3451                             enum nl80211_dfs_state dfs_state);
3452 --- a/net/wireless/genregdb.awk
3453 +++ b/net/wireless/genregdb.awk
3454 @@ -107,10 +107,13 @@ active && /^[ \t]*\(/ {
3455                 } else if (flagarray[arg] == "PTMP-ONLY") {
3456                         flags = flags "\n\t\t\tNL80211_RRF_PTMP_ONLY | "
3457                 } else if (flagarray[arg] == "PASSIVE-SCAN") {
3458 -                       flags = flags "\n\t\t\tNL80211_RRF_PASSIVE_SCAN | "
3459 +                       flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
3460                 } else if (flagarray[arg] == "NO-IBSS") {
3461 -                       flags = flags "\n\t\t\tNL80211_RRF_NO_IBSS | "
3462 +                       flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
3463 +               } else if (flagarray[arg] == "NO-IR") {
3464 +                       flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
3465                 }
3466 +
3467         }
3468         flags = flags "0"
3469         printf "\t\tREG_RULE(%d, %d, %d, %d, %d, %s),\n", start, end, bw, gain, power, flags
3470 --- a/net/wireless/ibss.c
3471 +++ b/net/wireless/ibss.c
3472 @@ -274,7 +274,7 @@ int cfg80211_ibss_wext_join(struct cfg80
3473
3474                         for (i = 0; i < sband->n_channels; i++) {
3475                                 chan = &sband->channels[i];
3476 -                               if (chan->flags & IEEE80211_CHAN_NO_IBSS)
3477 +                               if (chan->flags & IEEE80211_CHAN_NO_IR)
3478                                         continue;
3479                                 if (chan->flags & IEEE80211_CHAN_DISABLED)
3480                                         continue;
3481 @@ -345,7 +345,7 @@ int cfg80211_ibss_wext_siwfreq(struct ne
3482                 chan = ieee80211_get_channel(wdev->wiphy, freq);
3483                 if (!chan)
3484                         return -EINVAL;
3485 -               if (chan->flags & IEEE80211_CHAN_NO_IBSS ||
3486 +               if (chan->flags & IEEE80211_CHAN_NO_IR ||
3487                     chan->flags & IEEE80211_CHAN_DISABLED)
3488                         return -EINVAL;
3489         }
3490 --- a/net/wireless/mesh.c
3491 +++ b/net/wireless/mesh.c
3492 @@ -141,8 +141,7 @@ int __cfg80211_join_mesh(struct cfg80211
3493
3494                         for (i = 0; i < sband->n_channels; i++) {
3495                                 chan = &sband->channels[i];
3496 -                               if (chan->flags & (IEEE80211_CHAN_NO_IBSS |
3497 -                                                  IEEE80211_CHAN_PASSIVE_SCAN |
3498 +                               if (chan->flags & (IEEE80211_CHAN_NO_IR |
3499                                                    IEEE80211_CHAN_DISABLED |
3500                                                    IEEE80211_CHAN_RADAR))
3501                                         continue;
3502 --- a/net/wireless/mlme.c
3503 +++ b/net/wireless/mlme.c
3504 @@ -763,12 +763,12 @@ void cfg80211_radar_event(struct wiphy *
3505  EXPORT_SYMBOL(cfg80211_radar_event);
3506
3507  void cfg80211_cac_event(struct net_device *netdev,
3508 +                       const struct cfg80211_chan_def *chandef,
3509                         enum nl80211_radar_event event, gfp_t gfp)
3510  {
3511         struct wireless_dev *wdev = netdev->ieee80211_ptr;
3512         struct wiphy *wiphy = wdev->wiphy;
3513         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3514 -       struct cfg80211_chan_def chandef;
3515         unsigned long timeout;
3516
3517         trace_cfg80211_cac_event(netdev, event);
3518 @@ -779,14 +779,12 @@ void cfg80211_cac_event(struct net_devic
3519         if (WARN_ON(!wdev->channel))
3520                 return;
3521
3522 -       cfg80211_chandef_create(&chandef, wdev->channel, NL80211_CHAN_NO_HT);
3523 -
3524         switch (event) {
3525         case NL80211_RADAR_CAC_FINISHED:
3526                 timeout = wdev->cac_start_time +
3527                           msecs_to_jiffies(IEEE80211_DFS_MIN_CAC_TIME_MS);
3528                 WARN_ON(!time_after_eq(jiffies, timeout));
3529 -               cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_AVAILABLE);
3530 +               cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE);
3531                 break;
3532         case NL80211_RADAR_CAC_ABORTED:
3533                 break;
3534 @@ -796,6 +794,6 @@ void cfg80211_cac_event(struct net_devic
3535         }
3536         wdev->cac_started = false;
3537
3538 -       nl80211_radar_notify(rdev, &chandef, event, netdev, gfp);
3539 +       nl80211_radar_notify(rdev, chandef, event, netdev, gfp);
3540  }
3541  EXPORT_SYMBOL(cfg80211_cac_event);
3542 --- a/net/wireless/nl80211.c
3543 +++ b/net/wireless/nl80211.c
3544 @@ -545,12 +545,12 @@ static int nl80211_msg_put_channel(struc
3545         if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
3546             nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
3547                 goto nla_put_failure;
3548 -       if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
3549 -           nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
3550 -               goto nla_put_failure;
3551 -       if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
3552 -           nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
3553 -               goto nla_put_failure;
3554 +       if (chan->flags & IEEE80211_CHAN_NO_IR) {
3555 +               if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
3556 +                       goto nla_put_failure;
3557 +               if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
3558 +                       goto nla_put_failure;
3559 +       }
3560         if (chan->flags & IEEE80211_CHAN_RADAR) {
3561                 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
3562                         goto nla_put_failure;
3563 @@ -1229,7 +1229,7 @@ static int nl80211_send_wiphy(struct cfg
3564                     nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
3565                         goto nla_put_failure;
3566                 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
3567 -                   nla_put_flag(msg, WIPHY_FLAG_SUPPORTS_5_10_MHZ))
3568 +                   nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_10_MHZ))
3569                         goto nla_put_failure;
3570
3571                 state->split_start++;
3572 @@ -2170,7 +2170,7 @@ static inline u64 wdev_id(struct wireles
3573  }
3574
3575  static int nl80211_send_chandef(struct sk_buff *msg,
3576 -                                struct cfg80211_chan_def *chandef)
3577 +                               const struct cfg80211_chan_def *chandef)
3578  {
3579         WARN_ON(!cfg80211_chandef_valid(chandef));
3580
3581 @@ -5653,7 +5653,7 @@ static int nl80211_start_radar_detection
3582         if (err == 0)
3583                 return -EINVAL;
3584
3585 -       if (chandef.chan->dfs_state != NL80211_DFS_USABLE)
3586 +       if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
3587                 return -EINVAL;
3588
3589         if (!rdev->ops->start_radar_detection)
3590 @@ -10882,7 +10882,7 @@ EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
3591
3592  void
3593  nl80211_radar_notify(struct cfg80211_registered_device *rdev,
3594 -                    struct cfg80211_chan_def *chandef,
3595 +                    const struct cfg80211_chan_def *chandef,
3596                      enum nl80211_radar_event event,
3597                      struct net_device *netdev, gfp_t gfp)
3598  {
3599 --- a/net/wireless/nl80211.h
3600 +++ b/net/wireless/nl80211.h
3601 @@ -70,7 +70,7 @@ int nl80211_send_mgmt(struct cfg80211_re
3602
3603  void
3604  nl80211_radar_notify(struct cfg80211_registered_device *rdev,
3605 -                    struct cfg80211_chan_def *chandef,
3606 +                    const struct cfg80211_chan_def *chandef,
3607                      enum nl80211_radar_event event,
3608                      struct net_device *netdev, gfp_t gfp);
3609
3610 --- a/net/wireless/reg.c
3611 +++ b/net/wireless/reg.c
3612 @@ -163,35 +163,29 @@ static const struct ieee80211_regdomain
3613                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
3614                 /* IEEE 802.11b/g, channels 12..13. */
3615                 REG_RULE(2467-10, 2472+10, 40, 6, 20,
3616 -                       NL80211_RRF_PASSIVE_SCAN |
3617 -                       NL80211_RRF_NO_IBSS),
3618 +                       NL80211_RRF_NO_IR),
3619                 /* IEEE 802.11 channel 14 - Only JP enables
3620                  * this and for 802.11b only */
3621                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
3622 -                       NL80211_RRF_PASSIVE_SCAN |
3623 -                       NL80211_RRF_NO_IBSS |
3624 +                       NL80211_RRF_NO_IR |
3625                         NL80211_RRF_NO_OFDM),
3626                 /* IEEE 802.11a, channel 36..48 */
3627                 REG_RULE(5180-10, 5240+10, 160, 6, 20,
3628 -                        NL80211_RRF_PASSIVE_SCAN |
3629 -                        NL80211_RRF_NO_IBSS),
3630 +                        NL80211_RRF_NO_IR),
3631
3632                 /* IEEE 802.11a, channel 52..64 - DFS required */
3633                 REG_RULE(5260-10, 5320+10, 160, 6, 20,
3634 -                       NL80211_RRF_PASSIVE_SCAN |
3635 -                       NL80211_RRF_NO_IBSS |
3636 +                       NL80211_RRF_NO_IR |
3637                         NL80211_RRF_DFS),
3638
3639                 /* IEEE 802.11a, channel 100..144 - DFS required */
3640                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
3641 -                       NL80211_RRF_PASSIVE_SCAN |
3642 -                       NL80211_RRF_NO_IBSS |
3643 +                       NL80211_RRF_NO_IR |
3644                         NL80211_RRF_DFS),
3645
3646                 /* IEEE 802.11a, channel 149..165 */
3647                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
3648 -                       NL80211_RRF_PASSIVE_SCAN |
3649 -                       NL80211_RRF_NO_IBSS),
3650 +                       NL80211_RRF_NO_IR),
3651
3652                 /* IEEE 802.11ad (60gHz), channels 1..3 */
3653                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
3654 @@ -698,10 +692,8 @@ regdom_intersect(const struct ieee80211_
3655  static u32 map_regdom_flags(u32 rd_flags)
3656  {
3657         u32 channel_flags = 0;
3658 -       if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
3659 -               channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
3660 -       if (rd_flags & NL80211_RRF_NO_IBSS)
3661 -               channel_flags |= IEEE80211_CHAN_NO_IBSS;
3662 +       if (rd_flags & NL80211_RRF_NO_IR_ALL)
3663 +               channel_flags |= IEEE80211_CHAN_NO_IR;
3664         if (rd_flags & NL80211_RRF_DFS)
3665                 channel_flags |= IEEE80211_CHAN_RADAR;
3666         if (rd_flags & NL80211_RRF_NO_OFDM)
3667 @@ -1066,13 +1058,8 @@ static void handle_reg_beacon(struct wip
3668         chan_before.center_freq = chan->center_freq;
3669         chan_before.flags = chan->flags;
3670
3671 -       if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
3672 -               chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
3673 -               channel_changed = true;
3674 -       }
3675 -
3676 -       if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
3677 -               chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
3678 +       if (chan->flags & IEEE80211_CHAN_NO_IR) {
3679 +               chan->flags &= ~IEEE80211_CHAN_NO_IR;
3680                 channel_changed = true;
3681         }
3682
3683 --- /dev/null
3684 +++ b/drivers/net/wireless/ath/ath9k/ar9003_wow.c
3685 @@ -0,0 +1,422 @@
3686 +/*
3687 + * Copyright (c) 2012 Qualcomm Atheros, Inc.
3688 + *
3689 + * Permission to use, copy, modify, and/or distribute this software for any
3690 + * purpose with or without fee is hereby granted, provided that the above
3691 + * copyright notice and this permission notice appear in all copies.
3692 + *
3693 + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
3694 + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
3695 + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
3696 + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
3697 + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
3698 + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
3699 + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
3700 + */
3701 +
3702 +#include <linux/export.h>
3703 +#include "ath9k.h"
3704 +#include "reg.h"
3705 +#include "hw-ops.h"
3706 +
3707 +const char *ath9k_hw_wow_event_to_string(u32 wow_event)
3708 +{
3709 +       if (wow_event & AH_WOW_MAGIC_PATTERN_EN)
3710 +               return "Magic pattern";
3711 +       if (wow_event & AH_WOW_USER_PATTERN_EN)
3712 +               return "User pattern";
3713 +       if (wow_event & AH_WOW_LINK_CHANGE)
3714 +               return "Link change";
3715 +       if (wow_event & AH_WOW_BEACON_MISS)
3716 +               return "Beacon miss";
3717 +
3718 +       return  "unknown reason";
3719 +}
3720 +EXPORT_SYMBOL(ath9k_hw_wow_event_to_string);
3721 +
3722 +static void ath9k_hw_set_powermode_wow_sleep(struct ath_hw *ah)
3723 +{
3724 +       struct ath_common *common = ath9k_hw_common(ah);
3725 +
3726 +       REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV);
3727 +
3728 +       /* set rx disable bit */
3729 +       REG_WRITE(ah, AR_CR, AR_CR_RXD);
3730 +
3731 +       if (!ath9k_hw_wait(ah, AR_CR, AR_CR_RXE, 0, AH_WAIT_TIMEOUT)) {
3732 +               ath_err(common, "Failed to stop Rx DMA in 10ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
3733 +                       REG_READ(ah, AR_CR), REG_READ(ah, AR_DIAG_SW));
3734 +               return;
3735 +       }
3736 +
3737 +       REG_WRITE(ah, AR_RTC_FORCE_WAKE, AR_RTC_FORCE_WAKE_ON_INT);
3738 +}
3739 +
3740 +static void ath9k_wow_create_keep_alive_pattern(struct ath_hw *ah)
3741 +{
3742 +       struct ath_common *common = ath9k_hw_common(ah);
3743 +       u8 sta_mac_addr[ETH_ALEN], ap_mac_addr[ETH_ALEN];
3744 +       u32 ctl[13] = {0};
3745 +       u32 data_word[KAL_NUM_DATA_WORDS];
3746 +       u8 i;
3747 +       u32 wow_ka_data_word0;
3748 +
3749 +       memcpy(sta_mac_addr, common->macaddr, ETH_ALEN);
3750 +       memcpy(ap_mac_addr, common->curbssid, ETH_ALEN);
3751 +
3752 +       /* set the transmit buffer */
3753 +       ctl[0] = (KAL_FRAME_LEN | (MAX_RATE_POWER << 16));
3754 +       ctl[1] = 0;
3755 +       ctl[3] = 0xb;   /* OFDM_6M hardware value for this rate */
3756 +       ctl[4] = 0;
3757 +       ctl[7] = (ah->txchainmask) << 2;
3758 +       ctl[2] = 0xf << 16; /* tx_tries 0 */
3759 +
3760 +       for (i = 0; i < KAL_NUM_DESC_WORDS; i++)
3761 +               REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + i * 4), ctl[i]);
3762 +
3763 +       REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + i * 4), ctl[i]);
3764 +
3765 +       data_word[0] = (KAL_FRAME_TYPE << 2) | (KAL_FRAME_SUB_TYPE << 4) |
3766 +                      (KAL_TO_DS << 8) | (KAL_DURATION_ID << 16);
3767 +       data_word[1] = (ap_mac_addr[3] << 24) | (ap_mac_addr[2] << 16) |
3768 +                      (ap_mac_addr[1] << 8) | (ap_mac_addr[0]);
3769 +       data_word[2] = (sta_mac_addr[1] << 24) | (sta_mac_addr[0] << 16) |
3770 +                      (ap_mac_addr[5] << 8) | (ap_mac_addr[4]);
3771 +       data_word[3] = (sta_mac_addr[5] << 24) | (sta_mac_addr[4] << 16) |
3772 +                      (sta_mac_addr[3] << 8) | (sta_mac_addr[2]);
3773 +       data_word[4] = (ap_mac_addr[3] << 24) | (ap_mac_addr[2] << 16) |
3774 +                      (ap_mac_addr[1] << 8) | (ap_mac_addr[0]);
3775 +       data_word[5] = (ap_mac_addr[5] << 8) | (ap_mac_addr[4]);
3776 +
3777 +       if (AR_SREV_9462_20(ah)) {
3778 +               /* AR9462 2.0 has an extra descriptor word (time based
3779 +                * discard) compared to other chips */
3780 +               REG_WRITE(ah, (AR_WOW_KA_DESC_WORD2 + (12 * 4)), 0);
3781 +               wow_ka_data_word0 = AR_WOW_TXBUF(13);
3782 +       } else {
3783 +               wow_ka_data_word0 = AR_WOW_TXBUF(12);
3784 +       }
3785 +
3786 +       for (i = 0; i < KAL_NUM_DATA_WORDS; i++)
3787 +               REG_WRITE(ah, (wow_ka_data_word0 + i*4), data_word[i]);
3788 +
3789 +}
3790 +
3791 +void ath9k_hw_wow_apply_pattern(struct ath_hw *ah, u8 *user_pattern,
3792 +                               u8 *user_mask, int pattern_count,
3793 +                               int pattern_len)
3794 +{
3795 +       int i;
3796 +       u32 pattern_val, mask_val;
3797 +       u32 set, clr;
3798 +
3799 +       /* FIXME: should check count by querying the hardware capability */
3800 +       if (pattern_count >= MAX_NUM_PATTERN)
3801 +               return;
3802 +
3803 +       REG_SET_BIT(ah, AR_WOW_PATTERN, BIT(pattern_count));
3804 +
3805 +       /* set the registers for pattern */
3806 +       for (i = 0; i < MAX_PATTERN_SIZE; i += 4) {
3807 +               memcpy(&pattern_val, user_pattern, 4);
3808 +               REG_WRITE(ah, (AR_WOW_TB_PATTERN(pattern_count) + i),
3809 +                         pattern_val);
3810 +               user_pattern += 4;
3811 +       }
3812 +
3813 +       /* set the registers for mask */
3814 +       for (i = 0; i < MAX_PATTERN_MASK_SIZE; i += 4) {
3815 +               memcpy(&mask_val, user_mask, 4);
3816 +               REG_WRITE(ah, (AR_WOW_TB_MASK(pattern_count) + i), mask_val);
3817 +               user_mask += 4;
3818 +       }
3819 +
3820 +       /* set the pattern length to be matched
3821 +        *
3822 +        * AR_WOW_LENGTH1_REG1
3823 +        * bit 31:24 pattern 0 length
3824 +        * bit 23:16 pattern 1 length
3825 +        * bit 15:8 pattern 2 length
3826 +        * bit 7:0 pattern 3 length
3827 +        *
3828 +        * AR_WOW_LENGTH1_REG2
3829 +        * bit 31:24 pattern 4 length
3830 +        * bit 23:16 pattern 5 length
3831 +        * bit 15:8 pattern 6 length
3832 +        * bit 7:0 pattern 7 length
3833 +        *
3834 +        * the below logic writes out the new
3835 +        * pattern length for the corresponding
3836 +        * pattern_count, while masking out the
3837 +        * other fields
3838 +        */
3839 +
3840 +       ah->wow_event_mask |= BIT(pattern_count + AR_WOW_PAT_FOUND_SHIFT);
3841 +
3842 +       if (pattern_count < 4) {
3843 +               /* Pattern 0-3 uses AR_WOW_LENGTH1 register */
3844 +               set = (pattern_len & AR_WOW_LENGTH_MAX) <<
3845 +                      AR_WOW_LEN1_SHIFT(pattern_count);
3846 +               clr = AR_WOW_LENGTH1_MASK(pattern_count);
3847 +               REG_RMW(ah, AR_WOW_LENGTH1, set, clr);
3848 +       } else {
3849 +               /* Pattern 4-7 uses AR_WOW_LENGTH2 register */
3850 +               set = (pattern_len & AR_WOW_LENGTH_MAX) <<
3851 +                      AR_WOW_LEN2_SHIFT(pattern_count);
3852 +               clr = AR_WOW_LENGTH2_MASK(pattern_count);
3853 +               REG_RMW(ah, AR_WOW_LENGTH2, set, clr);
3854 +       }
3855 +
3856 +}
3857 +EXPORT_SYMBOL(ath9k_hw_wow_apply_pattern);
3858 +
3859 +u32 ath9k_hw_wow_wakeup(struct ath_hw *ah)
3860 +{
3861 +       u32 wow_status = 0;
3862 +       u32 val = 0, rval;
3863 +
3864 +       /*
3865 +        * read the WoW status register to know
3866 +        * the wakeup reason
3867 +        */
3868 +       rval = REG_READ(ah, AR_WOW_PATTERN);
3869 +       val = AR_WOW_STATUS(rval);
3870 +
3871 +       /*
3872 +        * mask only the WoW events that we have enabled. Sometimes
3873 +        * we have spurious WoW events from the AR_WOW_PATTERN
3874 +        * register. This mask will clean it up.
3875 +        */
3876 +
3877 +       val &= ah->wow_event_mask;
3878 +
3879 +       if (val) {
3880 +               if (val & AR_WOW_MAGIC_PAT_FOUND)
3881 +                       wow_status |= AH_WOW_MAGIC_PATTERN_EN;
3882 +               if (AR_WOW_PATTERN_FOUND(val))
3883 +                       wow_status |= AH_WOW_USER_PATTERN_EN;
3884 +               if (val & AR_WOW_KEEP_ALIVE_FAIL)
3885 +                       wow_status |= AH_WOW_LINK_CHANGE;
3886 +               if (val & AR_WOW_BEACON_FAIL)
3887 +                       wow_status |= AH_WOW_BEACON_MISS;
3888 +       }
3889 +
3890 +       /*
3891 +        * set and clear WOW_PME_CLEAR registers for the chip to
3892 +        * generate next wow signal.
3893 +        * disable D3 before accessing other registers ?
3894 +        */
3895 +
3896 +       /* do we need to check the bit value 0x01000000 (7-10) ?? */
3897 +       REG_RMW(ah, AR_PCIE_PM_CTRL, AR_PMCTRL_WOW_PME_CLR,
3898 +               AR_PMCTRL_PWR_STATE_D1D3);
3899 +
3900 +       /*
3901 +        * clear all events
3902 +        */
3903 +       REG_WRITE(ah, AR_WOW_PATTERN,
3904 +                 AR_WOW_CLEAR_EVENTS(REG_READ(ah, AR_WOW_PATTERN)));
3905 +
3906 +       /*
3907 +        * restore the beacon threshold to init value
3908 +        */
3909 +       REG_WRITE(ah, AR_RSSI_THR, INIT_RSSI_THR);
3910 +
3911 +       /*
3912 +        * Restore the way the PCI-E reset, Power-On-Reset, external
3913 +        * PCIE_POR_SHORT pins are tied to its original value.
3914 +        * Previously just before WoW sleep, we untie the PCI-E
3915 +        * reset to our Chip's Power On Reset so that any PCI-E
3916 +        * reset from the bus will not reset our chip
3917 +        */
3918 +       if (ah->is_pciexpress)
3919 +               ath9k_hw_configpcipowersave(ah, false);
3920 +
3921 +       ah->wow_event_mask = 0;
3922 +
3923 +       return wow_status;
3924 +}
3925 +EXPORT_SYMBOL(ath9k_hw_wow_wakeup);
3926 +
3927 +void ath9k_hw_wow_enable(struct ath_hw *ah, u32 pattern_enable)
3928 +{
3929 +       u32 wow_event_mask;
3930 +       u32 set, clr;
3931 +
3932 +       /*
3933 +        * wow_event_mask is a mask to the AR_WOW_PATTERN register to
3934 +        * indicate which WoW events we have enabled. The WoW events
3935 +        * are from the 'pattern_enable' in this function and
3936 +        * 'pattern_count' of ath9k_hw_wow_apply_pattern()
3937 +        */
3938 +       wow_event_mask = ah->wow_event_mask;
3939 +
3940 +       /*
3941 +        * Untie Power-on-Reset from the PCI-E-Reset. When we are in
3942 +        * WOW sleep, we do want the Reset from the PCI-E to disturb
3943 +        * our hw state
3944 +        */
3945 +       if (ah->is_pciexpress) {
3946 +               /*
3947 +                * we need to untie the internal POR (power-on-reset)
3948 +                * to the external PCI-E reset. We also need to tie
3949 +                * the PCI-E Phy reset to the PCI-E reset.
3950 +                */
3951 +               set = AR_WA_RESET_EN | AR_WA_POR_SHORT;
3952 +               clr = AR_WA_UNTIE_RESET_EN | AR_WA_D3_L1_DISABLE;
3953 +               REG_RMW(ah, AR_WA, set, clr);
3954 +       }
3955 +
3956 +       /*
3957 +        * set the power states appropriately and enable PME
3958 +        */
3959 +       set = AR_PMCTRL_HOST_PME_EN | AR_PMCTRL_PWR_PM_CTRL_ENA |
3960 +             AR_PMCTRL_AUX_PWR_DET | AR_PMCTRL_WOW_PME_CLR;
3961 +
3962 +       /*
3963 +        * set and clear WOW_PME_CLEAR registers for the chip
3964 +        * to generate next wow signal.
3965 +        */
3966 +       REG_SET_BIT(ah, AR_PCIE_PM_CTRL, set);
3967 +       clr = AR_PMCTRL_WOW_PME_CLR;
3968 +       REG_CLR_BIT(ah, AR_PCIE_PM_CTRL, clr);
3969 +
3970 +       /*
3971 +        * Setup for:
3972 +        *      - beacon misses
3973 +        *      - magic pattern
3974 +        *      - keep alive timeout
3975 +        *      - pattern matching
3976 +        */
3977 +
3978 +       /*
3979 +        * Program default values for pattern backoff, aifs/slot/KAL count,
3980 +        * beacon miss timeout, KAL timeout, etc.
3981 +        */
3982 +       set = AR_WOW_BACK_OFF_SHIFT(AR_WOW_PAT_BACKOFF);
3983 +       REG_SET_BIT(ah, AR_WOW_PATTERN, set);
3984 +
3985 +       set = AR_WOW_AIFS_CNT(AR_WOW_CNT_AIFS_CNT) |
3986 +             AR_WOW_SLOT_CNT(AR_WOW_CNT_SLOT_CNT) |
3987 +             AR_WOW_KEEP_ALIVE_CNT(AR_WOW_CNT_KA_CNT);
3988 +       REG_SET_BIT(ah, AR_WOW_COUNT, set);
3989 +
3990 +       if (pattern_enable & AH_WOW_BEACON_MISS)
3991 +               set = AR_WOW_BEACON_TIMO;
3992 +       /* We are not using beacon miss, program a large value */
3993 +       else
3994 +               set = AR_WOW_BEACON_TIMO_MAX;
3995 +
3996 +       REG_WRITE(ah, AR_WOW_BCN_TIMO, set);
3997 +
3998 +       /*
3999 +        * Keep alive timo in ms except AR9280
4000 +        */
4001 +       if (!pattern_enable)
4002 +               set = AR_WOW_KEEP_ALIVE_NEVER;
4003 +       else
4004 +               set = KAL_TIMEOUT * 32;
4005 +
4006 +       REG_WRITE(ah, AR_WOW_KEEP_ALIVE_TIMO, set);
4007 +
4008 +       /*
4009 +        * Keep alive delay in us. based on 'power on clock',
4010 +        * therefore in usec
4011 +        */
4012 +       set = KAL_DELAY * 1000;
4013 +       REG_WRITE(ah, AR_WOW_KEEP_ALIVE_DELAY, set);
4014 +
4015 +       /*
4016 +        * Create keep alive pattern to respond to beacons
4017 +        */
4018 +       ath9k_wow_create_keep_alive_pattern(ah);
4019 +
4020 +       /*
4021 +        * Configure MAC WoW Registers
4022 +        */
4023 +       set = 0;
4024 +       /* Send keep alive timeouts anyway */
4025 +       clr = AR_WOW_KEEP_ALIVE_AUTO_DIS;
4026 +
4027 +       if (pattern_enable & AH_WOW_LINK_CHANGE)
4028 +               wow_event_mask |= AR_WOW_KEEP_ALIVE_FAIL;
4029 +       else
4030 +               set = AR_WOW_KEEP_ALIVE_FAIL_DIS;
4031 +
4032 +       set = AR_WOW_KEEP_ALIVE_FAIL_DIS;
4033 +       REG_RMW(ah, AR_WOW_KEEP_ALIVE, set, clr);
4034 +
4035 +       /*
4036 +        * we are relying on a bmiss failure. ensure we have
4037 +        * enough threshold to prevent false positives
4038 +        */
4039 +       REG_RMW_FIELD(ah, AR_RSSI_THR, AR_RSSI_THR_BM_THR,
4040 +                     AR_WOW_BMISSTHRESHOLD);
4041 +
4042 +       set = 0;
4043 +       clr = 0;
4044 +
4045 +       if (pattern_enable & AH_WOW_BEACON_MISS) {
4046 +               set = AR_WOW_BEACON_FAIL_EN;
4047 +               wow_event_mask |= AR_WOW_BEACON_FAIL;
4048 +       } else {
4049 +               clr = AR_WOW_BEACON_FAIL_EN;
4050 +       }
4051 +
4052 +       REG_RMW(ah, AR_WOW_BCN_EN, set, clr);
4053 +
4054 +       set = 0;
4055 +       clr = 0;
4056 +       /*
4057 +        * Enable the magic packet registers
4058 +        */
4059 +       if (pattern_enable & AH_WOW_MAGIC_PATTERN_EN) {
4060 +               set = AR_WOW_MAGIC_EN;
4061 +               wow_event_mask |= AR_WOW_MAGIC_PAT_FOUND;
4062 +       } else {
4063 +               clr = AR_WOW_MAGIC_EN;
4064 +       }
4065 +       set |= AR_WOW_MAC_INTR_EN;
4066 +       REG_RMW(ah, AR_WOW_PATTERN, set, clr);
4067 +
4068 +       REG_WRITE(ah, AR_WOW_PATTERN_MATCH_LT_256B,
4069 +                 AR_WOW_PATTERN_SUPPORTED);
4070 +
4071 +       /*
4072 +        * Set the power states appropriately and enable PME
4073 +        */
4074 +       clr = 0;
4075 +       set = AR_PMCTRL_PWR_STATE_D1D3 | AR_PMCTRL_HOST_PME_EN |
4076 +             AR_PMCTRL_PWR_PM_CTRL_ENA;
4077 +
4078 +       clr = AR_PCIE_PM_CTRL_ENA;
4079 +       REG_RMW(ah, AR_PCIE_PM_CTRL, set, clr);
4080 +
4081 +       /*
4082 +        * this is needed to prevent the chip waking up
4083 +        * the host within 3-4 seconds with certain
4084 +        * platform/BIOS. The fix is to enable
4085 +        * D1 & D3 to match original definition and
4086 +        * also match the OTP value. Anyway this
4087 +        * is more related to SW WOW.
4088 +        */
4089 +       clr = AR_PMCTRL_PWR_STATE_D1D3;
4090 +       REG_CLR_BIT(ah, AR_PCIE_PM_CTRL, clr);
4091 +
4092 +       set = AR_PMCTRL_PWR_STATE_D1D3_REAL;
4093 +       REG_SET_BIT(ah, AR_PCIE_PM_CTRL, set);
4094 +
4095 +       REG_CLR_BIT(ah, AR_STA_ID1, AR_STA_ID1_PRESERVE_SEQNUM);
4096 +
4097 +       /* to bring down WOW power low margin */
4098 +       set = BIT(13);
4099 +       REG_SET_BIT(ah, AR_PCIE_PHY_REG3, set);
4100 +       /* HW WoW */
4101 +       clr = BIT(5);
4102 +       REG_CLR_BIT(ah, AR_PCU_MISC_MODE3, clr);
4103 +
4104 +       ath9k_hw_set_powermode_wow_sleep(ah);
4105 +       ah->wow_event_mask = wow_event_mask;
4106 +}
4107 +EXPORT_SYMBOL(ath9k_hw_wow_enable);
4108 --- /dev/null
4109 +++ b/drivers/net/wireless/ath/ath9k/tx99.c
4110 @@ -0,0 +1,263 @@
4111 +/*
4112 + * Copyright (c) 2013 Qualcomm Atheros, Inc.
4113 + *
4114 + * Permission to use, copy, modify, and/or distribute this software for any
4115 + * purpose with or without fee is hereby granted, provided that the above
4116 + * copyright notice and this permission notice appear in all copies.
4117 + *
4118 + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
4119 + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
4120 + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
4121 + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
4122 + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
4123 + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
4124 + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
4125 + */
4126 +
4127 +#include "ath9k.h"
4128 +
4129 +static void ath9k_tx99_stop(struct ath_softc *sc)
4130 +{
4131 +       struct ath_hw *ah = sc->sc_ah;
4132 +       struct ath_common *common = ath9k_hw_common(ah);
4133 +
4134 +       ath_drain_all_txq(sc);
4135 +       ath_startrecv(sc);
4136 +
4137 +       ath9k_hw_set_interrupts(ah);
4138 +       ath9k_hw_enable_interrupts(ah);
4139 +
4140 +       ieee80211_wake_queues(sc->hw);
4141 +
4142 +       kfree_skb(sc->tx99_skb);
4143 +       sc->tx99_skb = NULL;
4144 +       sc->tx99_state = false;
4145 +
4146 +       ath9k_hw_tx99_stop(sc->sc_ah);
4147 +       ath_dbg(common, XMIT, "TX99 stopped\n");
4148 +}
4149 +
4150 +static struct sk_buff *ath9k_build_tx99_skb(struct ath_softc *sc)
4151 +{
4152 +       static u8 PN9Data[] = {0xff, 0x87, 0xb8, 0x59, 0xb7, 0xa1, 0xcc, 0x24,
4153 +                              0x57, 0x5e, 0x4b, 0x9c, 0x0e, 0xe9, 0xea, 0x50,
4154 +                              0x2a, 0xbe, 0xb4, 0x1b, 0xb6, 0xb0, 0x5d, 0xf1,
4155 +                              0xe6, 0x9a, 0xe3, 0x45, 0xfd, 0x2c, 0x53, 0x18,
4156 +                              0x0c, 0xca, 0xc9, 0xfb, 0x49, 0x37, 0xe5, 0xa8,
4157 +                              0x51, 0x3b, 0x2f, 0x61, 0xaa, 0x72, 0x18, 0x84,
4158 +                              0x02, 0x23, 0x23, 0xab, 0x63, 0x89, 0x51, 0xb3,
4159 +                              0xe7, 0x8b, 0x72, 0x90, 0x4c, 0xe8, 0xfb, 0xc0};
4160 +       u32 len = 1200;
4161 +       struct ieee80211_hw *hw = sc->hw;
4162 +       struct ieee80211_hdr *hdr;
4163 +       struct ieee80211_tx_info *tx_info;
4164 +       struct sk_buff *skb;
4165 +
4166 +       skb = alloc_skb(len, GFP_KERNEL);
4167 +       if (!skb)
4168 +               return NULL;
4169 +
4170 +       skb_put(skb, len);
4171 +
4172 +       memset(skb->data, 0, len);
4173 +
4174 +       hdr = (struct ieee80211_hdr *)skb->data;
4175 +       hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA);
4176 +       hdr->duration_id = 0;
4177 +
4178 +       memcpy(hdr->addr1, hw->wiphy->perm_addr, ETH_ALEN);
4179 +       memcpy(hdr->addr2, hw->wiphy->perm_addr, ETH_ALEN);
4180 +       memcpy(hdr->addr3, hw->wiphy->perm_addr, ETH_ALEN);
4181 +
4182 +       hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
4183 +
4184 +       tx_info = IEEE80211_SKB_CB(skb);
4185 +       memset(tx_info, 0, sizeof(*tx_info));
4186 +       tx_info->band = hw->conf.chandef.chan->band;
4187 +       tx_info->flags = IEEE80211_TX_CTL_NO_ACK;
4188 +       tx_info->control.vif = sc->tx99_vif;
4189 +
4190 +       memcpy(skb->data + sizeof(*hdr), PN9Data, sizeof(PN9Data));
4191 +
4192 +       return skb;
4193 +}
4194 +
4195 +static void ath9k_tx99_deinit(struct ath_softc *sc)
4196 +{
4197 +       ath_reset(sc);
4198 +
4199 +       ath9k_ps_wakeup(sc);
4200 +       ath9k_tx99_stop(sc);
4201 +       ath9k_ps_restore(sc);
4202 +}
4203 +
4204 +static int ath9k_tx99_init(struct ath_softc *sc)
4205 +{
4206 +       struct ieee80211_hw *hw = sc->hw;
4207 +       struct ath_hw *ah = sc->sc_ah;
4208 +       struct ath_common *common = ath9k_hw_common(ah);
4209 +       struct ath_tx_control txctl;
4210 +       int r;
4211 +
4212 +       if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
4213 +               ath_err(common,
4214 +                       "driver is in invalid state unable to use TX99");
4215 +               return -EINVAL;
4216 +       }
4217 +
4218 +       sc->tx99_skb = ath9k_build_tx99_skb(sc);
4219 +       if (!sc->tx99_skb)
4220 +               return -ENOMEM;
4221 +
4222 +       memset(&txctl, 0, sizeof(txctl));
4223 +       txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
4224 +
4225 +       ath_reset(sc);
4226 +
4227 +       ath9k_ps_wakeup(sc);
4228 +
4229 +       ath9k_hw_disable_interrupts(ah);
4230 +       atomic_set(&ah->intr_ref_cnt, -1);
4231 +       ath_drain_all_txq(sc);
4232 +       ath_stoprecv(sc);
4233 +
4234 +       sc->tx99_state = true;
4235 +
4236 +       ieee80211_stop_queues(hw);
4237 +
4238 +       if (sc->tx99_power == MAX_RATE_POWER + 1)
4239 +               sc->tx99_power = MAX_RATE_POWER;
4240 +
4241 +       ath9k_hw_tx99_set_txpower(ah, sc->tx99_power);
4242 +       r = ath9k_tx99_send(sc, sc->tx99_skb, &txctl);
4243 +       if (r) {
4244 +               ath_dbg(common, XMIT, "Failed to xmit TX99 skb\n");
4245 +               return r;
4246 +       }
4247 +
4248 +       ath_dbg(common, XMIT, "TX99 xmit started using %d ( %ddBm)\n",
4249 +               sc->tx99_power,
4250 +               sc->tx99_power / 2);
4251 +
4252 +       /* We leave the harware awake as it will be chugging on */
4253 +
4254 +       return 0;
4255 +}
4256 +
4257 +static ssize_t read_file_tx99(struct file *file, char __user *user_buf,
4258 +                             size_t count, loff_t *ppos)
4259 +{
4260 +       struct ath_softc *sc = file->private_data;
4261 +       char buf[3];
4262 +       unsigned int len;
4263 +
4264 +       len = sprintf(buf, "%d\n", sc->tx99_state);
4265 +       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
4266 +}
4267 +
4268 +static ssize_t write_file_tx99(struct file *file, const char __user *user_buf,
4269 +                              size_t count, loff_t *ppos)
4270 +{
4271 +       struct ath_softc *sc = file->private_data;
4272 +       struct ath_common *common = ath9k_hw_common(sc->sc_ah);
4273 +       char buf[32];
4274 +       bool start;
4275 +       ssize_t len;
4276 +       int r;
4277 +
4278 +       if (sc->nvifs > 1)
4279 +               return -EOPNOTSUPP;
4280 +
4281 +       len = min(count, sizeof(buf) - 1);
4282 +       if (copy_from_user(buf, user_buf, len))
4283 +               return -EFAULT;
4284 +
4285 +       if (strtobool(buf, &start))
4286 +               return -EINVAL;
4287 +
4288 +       if (start == sc->tx99_state) {
4289 +               if (!start)
4290 +                       return count;
4291 +               ath_dbg(common, XMIT, "Resetting TX99\n");
4292 +               ath9k_tx99_deinit(sc);
4293 +       }
4294 +
4295 +       if (!start) {
4296 +               ath9k_tx99_deinit(sc);
4297 +               return count;
4298 +       }
4299 +
4300 +       r = ath9k_tx99_init(sc);
4301 +       if (r)
4302 +               return r;
4303 +
4304 +       return count;
4305 +}
4306 +
4307 +static const struct file_operations fops_tx99 = {
4308 +       .read = read_file_tx99,
4309 +       .write = write_file_tx99,
4310 +       .open = simple_open,
4311 +       .owner = THIS_MODULE,
4312 +       .llseek = default_llseek,
4313 +};
4314 +
4315 +static ssize_t read_file_tx99_power(struct file *file,
4316 +                                   char __user *user_buf,
4317 +                                   size_t count, loff_t *ppos)
4318 +{
4319 +       struct ath_softc *sc = file->private_data;
4320 +       char buf[32];
4321 +       unsigned int len;
4322 +
4323 +       len = sprintf(buf, "%d (%d dBm)\n",
4324 +                     sc->tx99_power,
4325 +                     sc->tx99_power / 2);
4326 +
4327 +       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
4328 +}
4329 +
4330 +static ssize_t write_file_tx99_power(struct file *file,
4331 +                                    const char __user *user_buf,
4332 +                                    size_t count, loff_t *ppos)
4333 +{
4334 +       struct ath_softc *sc = file->private_data;
4335 +       int r;
4336 +       u8 tx_power;
4337 +
4338 +       r = kstrtou8_from_user(user_buf, count, 0, &tx_power);
4339 +       if (r)
4340 +               return r;
4341 +
4342 +       if (tx_power > MAX_RATE_POWER)
4343 +               return -EINVAL;
4344 +
4345 +       sc->tx99_power = tx_power;
4346 +
4347 +       ath9k_ps_wakeup(sc);
4348 +       ath9k_hw_tx99_set_txpower(sc->sc_ah, sc->tx99_power);
4349 +       ath9k_ps_restore(sc);
4350 +
4351 +       return count;
4352 +}
4353 +
4354 +static const struct file_operations fops_tx99_power = {
4355 +       .read = read_file_tx99_power,
4356 +       .write = write_file_tx99_power,
4357 +       .open = simple_open,
4358 +       .owner = THIS_MODULE,
4359 +       .llseek = default_llseek,
4360 +};
4361 +
4362 +void ath9k_tx99_init_debug(struct ath_softc *sc)
4363 +{
4364 +       if (!AR_SREV_9300_20_OR_LATER(sc->sc_ah))
4365 +               return;
4366 +
4367 +       debugfs_create_file("tx99", S_IRUSR | S_IWUSR,
4368 +                           sc->debug.debugfs_phy, sc,
4369 +                           &fops_tx99);
4370 +       debugfs_create_file("tx99_power", S_IRUSR | S_IWUSR,
4371 +                           sc->debug.debugfs_phy, sc,
4372 +                           &fops_tx99_power);
4373 +}