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