f8d7f2607d7e92585ff43ffcf0e1482fe7e6a5b8
[openwrt.git] / package / kernel / mac80211 / patches / 300-pending_work.patch
1 commit d5d87a37bbd6066b2c3c5d0bd0fe2a6e2ea45cc5
2 Author: Felix Fietkau <nbd@openwrt.org>
3 Date:   Fri Feb 21 11:39:59 2014 +0100
4
5     ath9k: list more reset causes in debugfs
6     
7     Number of MAC hangs and stuck beacons were missing
8     
9     Signed-off-by: Felix Fietkau <nbd@openwrt.org>
10
11 commit d84856012e0f10fe598a5ad3b7b869397a089e07
12 Author: Johannes Berg <johannes.berg@intel.com>
13 Date:   Thu Feb 20 11:19:58 2014 +0100
14
15     mac80211: fix station wakeup powersave race
16     
17     Consider the following (relatively unlikely) scenario:
18      1) station goes to sleep while frames are buffered in driver
19      2) driver blocks wakeup (until no more frames are buffered)
20      3) station wakes up again
21      4) driver unblocks wakeup
22     
23     In this case, the current mac80211 code will do the following:
24      1) WLAN_STA_PS_STA set
25      2) WLAN_STA_PS_DRIVER set
26      3) - nothing -
27      4) WLAN_STA_PS_DRIVER cleared
28     
29     As a result, no frames will be delivered to the client, even
30     though it is awake, until it sends another frame to us that
31     triggers ieee80211_sta_ps_deliver_wakeup() in sta_ps_end().
32     
33     Since we now take the PS spinlock, we can fix this while at
34     the same time removing the complexity with the pending skb
35     queue function. This was broken since my commit 50a9432daeec
36     ("mac80211: fix powersaving clients races") due to removing
37     the clearing of WLAN_STA_PS_STA in the RX path.
38     
39     While at it, fix a cleanup path issue when a station is
40     removed while the driver is still blocking its wakeup.
41     
42     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
43
44 commit 798f2786602cbe93e6b928299614aa36ebf50692
45 Author: Johannes Berg <johannes.berg@intel.com>
46 Date:   Mon Feb 17 20:49:03 2014 +0100
47
48     mac80211: insert stations before adding to driver
49     
50     There's a race condition in mac80211 because we add stations
51     to the internal lists after adding them to the driver, which
52     means that (for example) the following can happen:
53      1. a station connects and is added
54      2. first, it is added to the driver
55      3. then, it is added to the mac80211 lists
56     
57     If the station goes to sleep between steps 2 and 3, and the
58     firmware/hardware records it as being asleep, mac80211 will
59     never instruct the driver to wake it up again as it never
60     realized it went to sleep since the RX path discarded the
61     frame as a "spurious class 3 frame", no station entry was
62     present yet.
63     
64     Fix this by adding the station in software first, and only
65     then adding it to the driver. That way, any state that the
66     driver changes will be reflected properly in mac80211's
67     station state. The problematic part is the roll-back if the
68     driver fails to add the station, in that case a bit more is
69     needed. To not make that overly complex prevent starting BA
70     sessions in the meantime.
71     
72     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
73
74 commit b9ba6a520cb07ab3aa7aaaf9ce4a0bc7a6bc06fe
75 Author: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
76 Date:   Thu Feb 20 09:22:11 2014 +0200
77
78     mac80211: fix AP powersave TX vs. wakeup race
79     
80     There is a race between the TX path and the STA wakeup: while
81     a station is sleeping, mac80211 buffers frames until it wakes
82     up, then the frames are transmitted. However, the RX and TX
83     path are concurrent, so the packet indicating wakeup can be
84     processed while a packet is being transmitted.
85     
86     This can lead to a situation where the buffered frames list
87     is emptied on the one side, while a frame is being added on
88     the other side, as the station is still seen as sleeping in
89     the TX path.
90     
91     As a result, the newly added frame will not be send anytime
92     soon. It might be sent much later (and out of order) when the
93     station goes to sleep and wakes up the next time.
94     
95     Additionally, it can lead to the crash below.
96     
97     Fix all this by synchronising both paths with a new lock.
98     Both path are not fastpath since they handle PS situations.
99     
100     In a later patch we'll remove the extra skb queue locks to
101     reduce locking overhead.
102     
103     BUG: unable to handle kernel
104     NULL pointer dereference at 000000b0
105     IP: [<ff6f1791>] ieee80211_report_used_skb+0x11/0x3e0 [mac80211]
106     *pde = 00000000
107     Oops: 0000 [#1] SMP DEBUG_PAGEALLOC
108     EIP: 0060:[<ff6f1791>] EFLAGS: 00210282 CPU: 1
109     EIP is at ieee80211_report_used_skb+0x11/0x3e0 [mac80211]
110     EAX: e5900da0 EBX: 00000000 ECX: 00000001 EDX: 00000000
111     ESI: e41d00c0 EDI: e5900da0 EBP: ebe458e4 ESP: ebe458b0
112      DS: 007b ES: 007b FS: 00d8 GS: 00e0 SS: 0068
113     CR0: 8005003b CR2: 000000b0 CR3: 25a78000 CR4: 000407d0
114     DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
115     DR6: ffff0ff0 DR7: 00000400
116     Process iperf (pid: 3934, ti=ebe44000 task=e757c0b0 task.ti=ebe44000)
117     iwlwifi 0000:02:00.0: I iwl_pcie_enqueue_hcmd Sending command LQ_CMD (#4e), seq: 0x0903, 92 bytes at 3[3]:9
118     Stack:
119      e403b32c ebe458c4 00200002 00200286 e403b338 ebe458cc c10960bb e5900da0
120      ff76a6ec ebe458d8 00000000 e41d00c0 e5900da0 ebe458f0 ff6f1b75 e403b210
121      ebe4598c ff723dc1 00000000 ff76a6ec e597c978 e403b758 00000002 00000002
122     Call Trace:
123      [<ff6f1b75>] ieee80211_free_txskb+0x15/0x20 [mac80211]
124      [<ff723dc1>] invoke_tx_handlers+0x1661/0x1780 [mac80211]
125      [<ff7248a5>] ieee80211_tx+0x75/0x100 [mac80211]
126      [<ff7249bf>] ieee80211_xmit+0x8f/0xc0 [mac80211]
127      [<ff72550e>] ieee80211_subif_start_xmit+0x4fe/0xe20 [mac80211]
128      [<c149ef70>] dev_hard_start_xmit+0x450/0x950
129      [<c14b9aa9>] sch_direct_xmit+0xa9/0x250
130      [<c14b9c9b>] __qdisc_run+0x4b/0x150
131      [<c149f732>] dev_queue_xmit+0x2c2/0xca0
132     
133     Cc: stable@vger.kernel.org
134     Reported-by: Yaara Rozenblum <yaara.rozenblum@intel.com>
135     Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
136     Reviewed-by: Stanislaw Gruszka <sgruszka@redhat.com>
137     [reword commit log, use a separate lock]
138     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
139
140 commit 80e419de0dff38436b30d363311c625766193f86
141 Author: Inbal Hacohen <Inbal.Hacohen@intel.com>
142 Date:   Wed Feb 12 09:32:27 2014 +0200
143
144     cfg80211: bugfix in regulatory user hint process
145     
146     After processing hint_user, we would want to schedule the
147     timeout work only if we are actually waiting to CRDA. This happens
148     when the status is not "IGNORE" nor "ALREADY_SET".
149     
150     Signed-off-by: Inbal Hacohen <Inbal.Hacohen@intel.com>
151     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
152
153 commit 6514c93afede55284e2cb63359aadedb85884c80
154 Author: Jouni Malinen <jouni@qca.qualcomm.com>
155 Date:   Tue Feb 18 20:41:08 2014 +0200
156
157     ath9k: Enable U-APSD AP mode support
158     
159     mac80211 handles the actual operations, so ath9k can just indicate
160     support for this. Based on initial tests, this combination seems to
161     work fine.
162     
163     Signed-off-by: Jouni Malinen <jouni@qca.qualcomm.com>
164
165 commit a63caf0a357ad5c1f08d6b7827dc76c451445017
166 Author: Stanislaw Gruszka <sgruszka@redhat.com>
167 Date:   Wed Feb 19 13:15:17 2014 +0100
168
169     ath9k: protect tid->sched check
170     
171     We check tid->sched without a lock taken on ath_tx_aggr_sleep(). That
172     is race condition which can result of doing list_del(&tid->list) twice
173     (second time with poisoned list node) and cause crash like shown below:
174     
175     [424271.637220] BUG: unable to handle kernel paging request at 00100104
176     [424271.637328] IP: [<f90fc072>] ath_tx_aggr_sleep+0x62/0xe0 [ath9k]
177     ...
178     [424271.639953] Call Trace:
179     [424271.639998]  [<f90f6900>] ? ath9k_get_survey+0x110/0x110 [ath9k]
180     [424271.640083]  [<f90f6942>] ath9k_sta_notify+0x42/0x50 [ath9k]
181     [424271.640177]  [<f809cfef>] sta_ps_start+0x8f/0x1c0 [mac80211]
182     [424271.640258]  [<c10f730e>] ? free_compound_page+0x2e/0x40
183     [424271.640346]  [<f809e915>] ieee80211_rx_handlers+0x9d5/0x2340 [mac80211]
184     [424271.640437]  [<c112f048>] ? kmem_cache_free+0x1d8/0x1f0
185     [424271.640510]  [<c1345a84>] ? kfree_skbmem+0x34/0x90
186     [424271.640578]  [<c10fc23c>] ? put_page+0x2c/0x40
187     [424271.640640]  [<c1345a84>] ? kfree_skbmem+0x34/0x90
188     [424271.640706]  [<c1345a84>] ? kfree_skbmem+0x34/0x90
189     [424271.640787]  [<f809dde3>] ? ieee80211_rx_handlers_result+0x73/0x1d0 [mac80211]
190     [424271.640897]  [<f80a07a0>] ieee80211_prepare_and_rx_handle+0x520/0xad0 [mac80211]
191     [424271.641009]  [<f809e22d>] ? ieee80211_rx_handlers+0x2ed/0x2340 [mac80211]
192     [424271.641104]  [<c13846ce>] ? ip_output+0x7e/0xd0
193     [424271.641182]  [<f80a1057>] ieee80211_rx+0x307/0x7c0 [mac80211]
194     [424271.641266]  [<f90fa6ee>] ath_rx_tasklet+0x88e/0xf70 [ath9k]
195     [424271.641358]  [<f80a0f2c>] ? ieee80211_rx+0x1dc/0x7c0 [mac80211]
196     [424271.641445]  [<f90f82db>] ath9k_tasklet+0xcb/0x130 [ath9k]
197     
198     Bug report:
199     https://bugzilla.kernel.org/show_bug.cgi?id=70551
200     
201     Reported-and-tested-by: Max Sydorenko <maxim.stargazer@gmail.com>
202     Cc: stable@vger.kernel.org
203     Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
204
205 commit 82ed9e3ccc02797df2ffe4b78127c4cd5f799a41
206 Author: Felix Fietkau <nbd@openwrt.org>
207 Date:   Tue Feb 11 15:54:13 2014 +0100
208
209     mac80211: send control port protocol frames to the VO queue
210     
211     Improves reliability of wifi connections with WPA, since authentication
212     frames are prioritized over normal traffic and also typically exempt
213     from aggregation.
214     
215     Cc: stable@vger.kernel.org
216     Signed-off-by: Felix Fietkau <nbd@openwrt.org>
217
218 commit d4426800f71e972feaa33e04c5801fc730627bdd
219 Author: Stanislaw Gruszka <stf_xl@wp.pl>
220 Date:   Mon Feb 10 22:38:28 2014 +0100
221
222     rtl8187: fix regression on MIPS without coherent DMA
223     
224     This patch fixes regression caused by commit a16dad77634 "MIPS: Fix
225     potencial corruption". That commit fixes one corruption scenario in
226     cost of adding another one, which actually start to cause crashes
227     on Yeeloong laptop when rtl8187 driver is used.
228     
229     For correct DMA read operation on machines without DMA coherence, kernel
230     have to invalidate cache, such it will refill later with new data that
231     device wrote to memory, when that data is needed to process. We can only
232     invalidate full cache line. Hence when cache line includes both dma
233     buffer and some other data (written in cache, but not yet in main
234     memory), the other data can not hit memory due to invalidation. That
235     happen on rtl8187 where struct rtl8187_priv fields are located just
236     before and after small buffers that are passed to USB layer and DMA
237     is performed on them.
238     
239     To fix the problem we align buffers and reserve space after them to make
240     them match cache line.
241     
242     This patch does not resolve all possible MIPS problems entirely, for
243     that we have to assure that we always map cache aligned buffers for DMA,
244     what can be complex or even not possible. But patch fixes visible and
245     reproducible regression and seems other possible corruptions do not
246     happen in practice, since Yeeloong laptop works stable without rtl8187
247     driver.
248     
249     Bug report:
250     https://bugzilla.kernel.org/show_bug.cgi?id=54391
251     
252     Reported-by: Petr Pisar <petr.pisar@atlas.cz>
253     Bisected-by: Tom Li <biergaizi2009@gmail.com>
254     Reported-and-tested-by: Tom Li <biergaizi2009@gmail.com>
255     Cc: stable@vger.kernel.org
256     Signed-off-by: Stanislaw Gruszka <stf_xl@wp.pl>
257
258 commit e2f141d67ad1e7fe10aaab61811e8a409dfb2442
259 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
260 Date:   Fri Feb 7 10:29:55 2014 +0530
261
262     ath9k: Calculate IQ-CAL median
263     
264     This patch adds a routine to calculate the median IQ correction
265     values for AR955x, which is used for outlier detection.
266     The normal method which is used for all other chips is
267     bypassed for AR955x.
268     
269     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
270
271 commit c52a6fce0820c8d0687443ab86058ae03b478c8f
272 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
273 Date:   Fri Feb 7 10:29:54 2014 +0530
274
275     ath9k: Expand the IQ coefficient array
276     
277     This will be used for storing data for mutiple
278     IQ calibration runs, for AR955x.
279     
280     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
281
282 commit 034969ff5c2b6431d10e07c1938f0b916da85cc3
283 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
284 Date:   Fri Feb 7 10:29:53 2014 +0530
285
286     ath9k: Modify IQ calibration for AR955x
287     
288     IQ calibration post-processing for AR955x is different
289     from other chips - instead of just doing it as part
290     of AGC calibration once, it is triggered 3 times and
291     a median is determined. This patch adds initial support
292     for changing the calibration behavior for AR955x.
293     
294     Also, to simplify things, a helper routine to issue/poll
295     AGC calibration is used.
296     
297     For non-AR955x chips, the iqcal_idx (which will be used
298     in subsequent patches) is set to zero.
299     
300     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
301
302 commit 9b1ed6454e6f3511f24266be99b4e403f243f6a8
303 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
304 Date:   Fri Feb 7 10:29:52 2014 +0530
305
306     ath9k: Fix magnitude/phase calculation
307     
308     Incorrect values are programmed in the registers
309     containing the IQ correction coefficients by the IQ-CAL
310     post-processing code. Fix this.
311     
312     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
313
314 commit 36f93484f96f79171dcecb67c5ef0c3de22531a6
315 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
316 Date:   Fri Feb 7 10:29:51 2014 +0530
317
318     ath9k: Rename ar9003_hw_tx_iqcal_load_avg_2_passes
319     
320     Use ar9003_hw_tx_iq_cal_outlier_detection instead.
321     
322     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
323
324 commit 3af09a7f5d21dd5fd15b973ce6a91a575da30417
325 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
326 Date:   Fri Feb 7 10:29:50 2014 +0530
327
328     ath9k: Check explicitly for IQ calibration
329     
330     In chips like AR955x, the initvals contain the information
331     whether IQ calibration is to be done in the HW when an
332     AGC calibration is triggered. Check if IQ-CAL is enabled
333     in the initvals before flagging 'txiqcal_done' as true.
334     
335     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
336
337 commit cb4969634b93c4643a32cc3fbd27d2b288b25771
338 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
339 Date:   Fri Feb 7 10:29:49 2014 +0530
340
341     ath9k: Fix IQ cal post processing for SoC
342     
343     Calibration data is not reused for SoC chips, so
344     call ar9003_hw_tx_iq_cal_post_proc() with the correct
345     argument. The 'is_reusable' flag is currently used
346     only for PC-OEM chips, but it makes things clearer to
347     specify it explicity.
348     
349     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
350
351 commit e138e0ef9560c46ce93dbb22a728a57888e94d1c
352 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
353 Date:   Mon Feb 3 13:31:37 2014 +0530
354
355     ath9k: Fix TX power calculation
356     
357     The commit, "ath9k_hw: Fix incorrect Tx control power in AR9003 template"
358     fixed the incorrect values in the eeprom templates, but if
359     boards have already been calibrated with incorrect values,
360     they would still be using the wrong TX power. Fix this by assigning
361     a default value in such cases.
362     
363     Cc: Rajkumar Manoharan <rmanohar@qti.qualcomm.com>
364     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
365
366 commit b9f268b5b01331c3c82179abca551429450e9417
367 Author: Michal Kazior <michal.kazior@tieto.com>
368 Date:   Wed Jan 29 14:22:27 2014 +0100
369
370     cfg80211: consider existing DFS interfaces
371     
372     It was possible to break interface combinations in
373     the following way:
374     
375      combo 1: iftype = AP, num_ifaces = 2, num_chans = 2,
376      combo 2: iftype = AP, num_ifaces = 1, num_chans = 1, radar = HT20
377     
378     With the above interface combinations it was
379     possible to:
380     
381      step 1. start AP on DFS channel by matching combo 2
382      step 2. start AP on non-DFS channel by matching combo 1
383     
384     This was possible beacuse (step 2) did not consider
385     if other interfaces require radar detection.
386     
387     The patch changes how cfg80211 tracks channels -
388     instead of channel itself now a complete chandef
389     is stored.
390     
391     Signed-off-by: Michal Kazior <michal.kazior@tieto.com>
392     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
393
394 commit bc9c62f5f511cc395c62dbf4cdd437f23db53b28
395 Author: Antonio Quartulli <antonio@open-mesh.com>
396 Date:   Wed Jan 29 17:53:43 2014 +0100
397
398     cfg80211: fix channel configuration in IBSS join
399     
400     When receiving an IBSS_JOINED event select the BSS object
401     based on the {bssid, channel} couple rather than the bssid
402     only.
403     With the current approach if another cell having the same
404     BSSID (but using a different channel) exists then cfg80211
405     picks up the wrong BSS object.
406     The result is a mismatching channel configuration between
407     cfg80211 and the driver, that can lead to any sort of
408     problem.
409     
410     The issue can be triggered by having an IBSS sitting on
411     given channel and then asking the driver to create a new
412     cell using the same BSSID but with a different frequency.
413     By passing the channel to cfg80211_get_bss() we can solve
414     this ambiguity and retrieve/create the correct BSS object.
415     All the users of cfg80211_ibss_joined() have been changed
416     accordingly.
417     
418     Moreover WARN when cfg80211_ibss_joined() gets a NULL
419     channel as argument and remove a bogus call of the same
420     function in ath6kl (it does not make sense to call
421     cfg80211_ibss_joined() with a zero BSSID on ibss-leave).
422     
423     Cc: Kalle Valo <kvalo@qca.qualcomm.com>
424     Cc: Arend van Spriel <arend@broadcom.com>
425     Cc: Bing Zhao <bzhao@marvell.com>
426     Cc: Jussi Kivilinna <jussi.kivilinna@iki.fi>
427     Cc: libertas-dev@lists.infradead.org
428     Acked-by: Kalle Valo <kvalo@qca.qualcomm.com>
429     Signed-off-by: Antonio Quartulli <antonio@open-mesh.com>
430     [minor code cleanup in ath6kl]
431     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
432
433 commit 7e0c41cb41f215aba2c39b1c237bb4d42ec49a85
434 Author: Johannes Berg <johannes.berg@intel.com>
435 Date:   Fri Jan 24 14:41:44 2014 +0100
436
437     mac80211: fix bufferable MMPDU RX handling
438     
439     Action, disassoc and deauth frames are bufferable, and as such don't
440     have the PM bit in the frame control field reserved which means we
441     need to react to the bit when receiving in such a frame.
442     
443     Fix this by introducing a new helper ieee80211_is_bufferable_mmpdu()
444     and using it for the RX path that currently ignores the PM bit in
445     any non-data frames for doze->wake transitions, but listens to it in
446     all frames for wake->doze transitions, both of which are wrong.
447     
448     Also use the new helper in the TX path to clean up the code.
449     
450     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
451
452 commit fc0df6d2343636e3f48a069330d5b972e3d8659d
453 Author: Janusz Dziedzic <janusz.dziedzic@tieto.com>
454 Date:   Fri Jan 24 14:29:21 2014 +0100
455
456     cfg80211: set preset_chandef after channel switch
457     
458     Set preset_chandef in channel switch notification.
459     In other case we will have old preset_chandef.
460     
461     Signed-off-by: Janusz Dziedzic <janusz.dziedzic@tieto.com>
462     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
463
464 commit cdec895e2344987ff171cece96e25d7407a3ebf6
465 Author: Simon Wunderlich <simon@open-mesh.com>
466 Date:   Fri Jan 24 23:48:29 2014 +0100
467
468     mac80211: send ibss probe responses with noack flag
469     
470     Responding to probe requests for scanning clients will often create
471     excessive retries, as it happens quite often that the scanning client
472     already left the channel. Therefore do it like hostapd and send probe
473     responses for wildcard SSID only once by using the noack flag.
474     
475     Signed-off-by: Simon Wunderlich <simon@open-mesh.com>
476     [fix typo & 'wildcard SSID' in commit log]
477     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
478
479 commit 0b865d1e6b9c05052adae9315df7cb195dc60c3b
480 Author: Luciano Coelho <luciano.coelho@intel.com>
481 Date:   Tue Jan 28 17:09:08 2014 +0200
482
483     mac80211: ibss: remove unnecessary call to release channel
484     
485     The ieee80211_vif_use_channel() function calls
486     ieee80211_vif_release_channel(), so there's no need to call it
487     explicitly in __ieee80211_sta_join_ibss().
488     
489     Signed-off-by: Luciano Coelho <luciano.coelho@intel.com>
490     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
491
492 commit e1b6c17e971f0a51ff86c2dac2584c63cd999cd7
493 Author: Michal Kazior <michal.kazior@tieto.com>
494 Date:   Wed Jan 29 07:56:21 2014 +0100
495
496     mac80211: add missing CSA locking
497     
498     The patch adds a missing sdata lock and adds a few
499     lockdeps for easier maintenance.
500     
501     Signed-off-by: Michal Kazior <michal.kazior@tieto.com>
502     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
503
504 commit ad17ba7d14d225b109b73c177cd446afb8050598
505 Author: Michal Kazior <michal.kazior@tieto.com>
506 Date:   Wed Jan 29 07:56:20 2014 +0100
507
508     mac80211: fix sdata->radar_required locking
509     
510     radar_required setting wasn't protected by
511     local->mtx in some places. This should prevent
512     from scanning/radar detection/roc colliding.
513     
514     Signed-off-by: Michal Kazior <michal.kazior@tieto.com>
515     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
516
517 commit 5fcd5f1808813a3d9e502fd756e01bee8a79c85d
518 Author: Michal Kazior <michal.kazior@tieto.com>
519 Date:   Wed Jan 29 07:56:19 2014 +0100
520
521     mac80211: move csa_active setting in STA CSA
522     
523     The sdata->vif.csa_active could be left set after,
524     e.g. channel context constraints check fail in STA
525     mode leaving the interface in a strange state for
526     a brief period of time until it is disconnected.
527     This was harmless but ugly.
528     
529     Signed-off-by: Michal Kazior <michal.kazior@tieto.com>
530     Reviewed-by: Luciano Coelho <luciano.coelho@intel.com>
531     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
532
533 commit e486da4b7eed71821c6b4c1bb9ac62ffd3ab13e9
534 Author: Michal Kazior <michal.kazior@tieto.com>
535 Date:   Wed Jan 29 07:56:18 2014 +0100
536
537     mac80211: fix possible memory leak on AP CSA failure
538     
539     If CSA for AP interface failed and the interface
540     was not stopped afterwards another CSA request
541     would leak sdata->u.ap.next_beacon.
542     
543     Signed-off-by: Michal Kazior <michal.kazior@tieto.com>
544     Reviewed-by: Luciano Coelho <luciano.coelho@intel.com>
545     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
546
547 commit 3a77ba08940682bf3d52cf14f980337324af9d4a
548 Author: Johannes Berg <johannes.berg@intel.com>
549 Date:   Sat Feb 1 00:33:29 2014 +0100
550
551     mac80211: fix fragmentation code, particularly for encryption
552     
553     The "new" fragmentation code (since my rewrite almost 5 years ago)
554     erroneously sets skb->len rather than using skb_trim() to adjust
555     the length of the first fragment after copying out all the others.
556     This leaves the skb tail pointer pointing to after where the data
557     originally ended, and thus causes the encryption MIC to be written
558     at that point, rather than where it belongs: immediately after the
559     data.
560     
561     The impact of this is that if software encryption is done, then
562      a) encryption doesn't work for the first fragment, the connection
563         becomes unusable as the first fragment will never be properly
564         verified at the receiver, the MIC is practically guaranteed to
565         be wrong
566      b) we leak up to 8 bytes of plaintext (!) of the packet out into
567         the air
568     
569     This is only mitigated by the fact that many devices are capable
570     of doing encryption in hardware, in which case this can't happen
571     as the tail pointer is irrelevant in that case. Additionally,
572     fragmentation is not used very frequently and would normally have
573     to be configured manually.
574     
575     Fix this by using skb_trim() properly.
576     
577     Cc: stable@vger.kernel.org
578     Fixes: 2de8e0d999b8 ("mac80211: rewrite fragmentation")
579     Reported-by: Jouni Malinen <j@w1.fi>
580     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
581
582 commit de5f242e0c10e841017e37eb8c38974a642dbca8
583 Author: Sujith Manoharan <c_manoha@qca.qualcomm.com>
584 Date:   Tue Jan 28 06:21:59 2014 +0530
585
586     ath9k: Fix build error on ARM
587     
588     Use mdelay instead of udelay to fix this error:
589     
590     ERROR: "__bad_udelay" [drivers/net/wireless/ath/ath9k/ath9k_hw.ko] undefined!
591     make[1]: *** [__modpost] Error 1
592     make: *** [modules] Error 2
593     
594     Reported-by: Josh Boyer <jwboyer@fedoraproject.org>
595     Signed-off-by: Sujith Manoharan <c_manoha@qca.qualcomm.com>
596
597 commit 8e3ea7a51dfc61810fcefd947f6edcf61125252a
598 Author: Geert Uytterhoeven <geert@linux-m68k.org>
599 Date:   Sun Jan 26 11:53:21 2014 +0100
600
601     ath9k: Fix uninitialized variable in ath9k_has_tx_pending()
602     
603     drivers/net/wireless/ath/ath9k/main.c: In function ‘ath9k_has_tx_pending’:
604     drivers/net/wireless/ath/ath9k/main.c:1869: warning: ‘npend’ may be used uninitialized in this function
605     
606     Introduced by commit 10e2318103f5941aa70c318afe34bc41f1b98529 ("ath9k:
607     optimize ath9k_flush").
608     
609     Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
610
611 commit a4a634a6937ebdd827fa58e8fcdb8ca49a3769f6
612 Author: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
613 Date:   Mon Jan 27 11:07:42 2014 +0200
614
615     mac80211: release the channel in error path in start_ap
616     
617     When the driver cannot start the AP or when the assignement
618     of the beacon goes wrong, we need to unassign the vif.
619     
620     Cc: stable@vger.kernel.org
621     Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
622     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
623
624 commit dfb6889a75c601aedb7450b7e606668e77da6679
625 Author: Johannes Berg <johannes.berg@intel.com>
626 Date:   Wed Jan 22 11:14:19 2014 +0200
627
628     cfg80211: send scan results from work queue
629     
630     Due to the previous commit, when a scan finishes, it is in theory
631     possible to hit the following sequence:
632      1. interface starts being removed
633      2. scan is cancelled by driver and cfg80211 is notified
634      3. scan done work is scheduled
635      4. interface is removed completely, rdev->scan_req is freed,
636         event sent to userspace but scan done work remains pending
637      5. new scan is requested on another virtual interface
638      6. scan done work runs, freeing the still-running scan
639     
640     To fix this situation, hang on to the scan done message and block
641     new scans while that is the case, and only send the message from
642     the work function, regardless of whether the scan_req is already
643     freed from interface removal. This makes step 5 above impossible
644     and changes step 6 to be
645      5. scan done work runs, sending the scan done message
646     
647     As this can't work for wext, so we send the message immediately,
648     but this shouldn't be an issue since we still return -EBUSY.
649     
650     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
651
652 commit 45b7ab41fc08627d9a8428cb413d5d84662a9707
653 Author: Johannes Berg <johannes.berg@intel.com>
654 Date:   Wed Jan 22 11:14:18 2014 +0200
655
656     cfg80211: fix scan done race
657     
658     When an interface/wdev is removed, any ongoing scan should be
659     cancelled by the driver. This will make it call cfg80211, which
660     only queues a work struct. If interface/wdev removal is quick
661     enough, this can leave the scan request pending and processed
662     only after the interface is gone, causing a use-after-free.
663     
664     Fix this by making sure the scan request is not pending after
665     the interface is destroyed. We can't flush or cancel the work
666     item due to locking concerns, but when it'll run it shouldn't
667     find anything to do. This leaves a potential issue, if a new
668     scan gets requested before the work runs, it prematurely stops
669     the running scan, potentially causing another crash. I'll fix
670     that in the next patch.
671     
672     This was particularly observed with P2P_DEVICE wdevs, likely
673     because freeing them is quicker than freeing netdevs.
674     
675     Reported-by: Andrei Otcheretianski <andrei.otcheretianski@intel.com>
676     Fixes: 4a58e7c38443 ("cfg80211: don't "leak" uncompleted scans")
677     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
678
679 commit ae04fa489ab31b5a10d3cc8399f52761175d4321
680 Author: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
681 Date:   Thu Jan 23 14:28:16 2014 +0200
682
683     mac80211: avoid deadlock revealed by lockdep
684     
685     sdata->u.ap.request_smps_work can’t be flushed synchronously
686     under wdev_lock(wdev) since ieee80211_request_smps_ap_work
687     itself locks the same lock.
688     While at it, reset the driver_smps_mode when the ap is
689     stopped to its default: OFF.
690     
691     This solves:
692     
693     ======================================================
694     [ INFO: possible circular locking dependency detected ]
695     3.12.0-ipeer+ #2 Tainted: G           O
696     -------------------------------------------------------
697     rmmod/2867 is trying to acquire lock:
698       ((&sdata->u.ap.request_smps_work)){+.+...}, at: [<c105b8d0>] flush_work+0x0/0x90
699     
700     but task is already holding lock:
701       (&wdev->mtx){+.+.+.}, at: [<f9b32626>] cfg80211_stop_ap+0x26/0x230 [cfg80211]
702     
703     which lock already depends on the new lock.
704     
705     the existing dependency chain (in reverse order) is:
706     
707     -> #1 (&wdev->mtx){+.+.+.}:
708             [<c10aefa9>] lock_acquire+0x79/0xe0
709             [<c1607a1a>] mutex_lock_nested+0x4a/0x360
710             [<fb06288b>] ieee80211_request_smps_ap_work+0x2b/0x50 [mac80211]
711             [<c105cdd8>] process_one_work+0x198/0x450
712             [<c105d469>] worker_thread+0xf9/0x320
713             [<c10669ff>] kthread+0x9f/0xb0
714             [<c1613397>] ret_from_kernel_thread+0x1b/0x28
715     
716     -> #0 ((&sdata->u.ap.request_smps_work)){+.+...}:
717             [<c10ae9df>] __lock_acquire+0x183f/0x1910
718             [<c10aefa9>] lock_acquire+0x79/0xe0
719             [<c105b917>] flush_work+0x47/0x90
720             [<c105d867>] __cancel_work_timer+0x67/0xe0
721             [<c105d90f>] cancel_work_sync+0xf/0x20
722             [<fb0765cc>] ieee80211_stop_ap+0x8c/0x340 [mac80211]
723             [<f9b3268c>] cfg80211_stop_ap+0x8c/0x230 [cfg80211]
724             [<f9b0d8f9>] cfg80211_leave+0x79/0x100 [cfg80211]
725             [<f9b0da72>] cfg80211_netdev_notifier_call+0xf2/0x4f0 [cfg80211]
726             [<c160f2c9>] notifier_call_chain+0x59/0x130
727             [<c106c6de>] __raw_notifier_call_chain+0x1e/0x30
728             [<c106c70f>] raw_notifier_call_chain+0x1f/0x30
729             [<c14f8213>] call_netdevice_notifiers_info+0x33/0x70
730             [<c14f8263>] call_netdevice_notifiers+0x13/0x20
731             [<c14f82a4>] __dev_close_many+0x34/0xb0
732             [<c14f83fe>] dev_close_many+0x6e/0xc0
733             [<c14f9c77>] rollback_registered_many+0xa7/0x1f0
734             [<c14f9dd4>] unregister_netdevice_many+0x14/0x60
735             [<fb06f4d9>] ieee80211_remove_interfaces+0xe9/0x170 [mac80211]
736             [<fb055116>] ieee80211_unregister_hw+0x56/0x110 [mac80211]
737             [<fa3e9396>] iwl_op_mode_mvm_stop+0x26/0xe0 [iwlmvm]
738             [<f9b9d8ca>] _iwl_op_mode_stop+0x3a/0x70 [iwlwifi]
739             [<f9b9d96f>] iwl_opmode_deregister+0x6f/0x90 [iwlwifi]
740             [<fa405179>] __exit_compat+0xd/0x19 [iwlmvm]
741             [<c10b8bf9>] SyS_delete_module+0x179/0x2b0
742             [<c1613421>] sysenter_do_call+0x12/0x32
743     
744     Fixes: 687da132234f ("mac80211: implement SMPS for AP")
745     Cc: <stable@vger.kernel.org> [3.13]
746     Reported-by: Ilan Peer <ilan.peer@intel.com>
747     Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
748     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
749
750 commit 178b205e96217164fd7c30113464250d0b6f5eca
751 Author: Johannes Berg <johannes.berg@intel.com>
752 Date:   Thu Jan 23 16:32:29 2014 +0100
753
754     cfg80211: re-enable 5/10 MHz support
755     
756     Unfortunately I forgot this during the merge window, but the
757     patch seems small enough to go in as a fix. The userspace API
758     bug that was the reason for disabling it has long been fixed.
759     
760     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
761
762 commit 110a1c79acda14edc83b7c8dc5af9c7ddd23eb61
763 Author: Pontus Fuchs <pontus.fuchs@gmail.com>
764 Date:   Thu Jan 16 15:00:40 2014 +0100
765
766     nl80211: Reset split_start when netlink skb is exhausted
767     
768     When the netlink skb is exhausted split_start is left set. In the
769     subsequent retry, with a larger buffer, the dump is continued from the
770     failing point instead of from the beginning.
771     
772     This was causing my rt28xx based USB dongle to now show up when
773     running "iw list" with an old iw version without split dump support.
774     
775     Cc: stable@vger.kernel.org
776     Fixes: 3713b4e364ef ("nl80211: allow splitting wiphy information in dumps")
777     Signed-off-by: Pontus Fuchs <pontus.fuchs@gmail.com>
778     [avoid the entire workaround when state->split is set]
779     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
780
781 commit b4c31b45ffc7ef110fa9ecc34d7878fe7c5b9da4
782 Author: Eliad Peller <eliad@wizery.com>
783 Date:   Sun Jan 12 11:06:37 2014 +0200
784
785     mac80211: move roc cookie assignment earlier
786     
787     ieee80211_start_roc_work() might add a new roc
788     to existing roc, and tell cfg80211 it has already
789     started.
790     
791     However, this might happen before the roc cookie
792     was set, resulting in REMAIN_ON_CHANNEL (started)
793     event with null cookie. Consequently, it can make
794     wpa_supplicant go out of sync.
795     
796     Fix it by setting the roc cookie earlier.
797     
798     Cc: stable@vger.kernel.org
799     Signed-off-by: Eliad Peller <eliad@wizery.com>
800     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
801
802 commit cfdc9157bfd7bcf88ab4dae08873a9907eba984c
803 Author: Johannes Berg <johannes.berg@intel.com>
804 Date:   Fri Jan 24 14:06:29 2014 +0100
805
806     nl80211: send event when AP operation is stopped
807     
808     There are a few cases, e.g. suspend, where an AP interface is
809     stopped by the kernel rather than by userspace request, most
810     commonly when suspending. To let userspace know about this,
811     send the NL80211_CMD_STOP_AP command as an event every time
812     an AP interface is stopped. This also happens when userspace
813     did in fact request the AP stop, but that's not a problem.
814     
815     For full-MAC drivers this may need to be extended to also
816     cover cases where the device stopped the AP operation for
817     some reason, this a bit more complicated because then all
818     cfg80211 state also needs to be reset; such API is not part
819     of this patch.
820     
821     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
822
823 commit d5d567eda7704f190379ca852a8f9a4112e3eee3
824 Author: Johannes Berg <johannes.berg@intel.com>
825 Date:   Thu Jan 23 16:20:29 2014 +0100
826
827     mac80211: add length check in ieee80211_is_robust_mgmt_frame()
828     
829     A few places weren't checking that the frame passed to the
830     function actually has enough data even though the function
831     clearly documents it must have a payload byte. Make this
832     safer by changing the function to take an skb and checking
833     the length inside. The old version is preserved for now as
834     the rtl* drivers use it and don't have a correct skb.
835     
836     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
837
838 commit f8f6d212a047fc65c7d3442dfc038f65517236fc
839 Author: Johannes Berg <johannes.berg@intel.com>
840 Date:   Fri Jan 24 10:53:53 2014 +0100
841
842     nl80211: fix scheduled scan RSSI matchset attribute confusion
843     
844     The scheduled scan matchsets were intended to be a list of filters,
845     with the found BSS having to pass at least one of them to be passed
846     to the host. When the RSSI attribute was added, however, this was
847     broken and currently wpa_supplicant adds that attribute in its own
848     matchset; however, it doesn't intend that to mean that anything
849     that passes the RSSI filter should be passed to the host, instead
850     it wants it to mean that everything needs to also have higher RSSI.
851     
852     This is semantically problematic because we have a list of filters
853     like [ SSID1, SSID2, SSID3, RSSI ] with no real indication which
854     one should be OR'ed and which one AND'ed.
855     
856     To fix this, move the RSSI filter attribute into each matchset. As
857     we need to stay backward compatible, treat a matchset with only the
858     RSSI attribute as a "default RSSI filter" for all other matchsets,
859     but only if there are other matchsets (an RSSI-only matchset by
860     itself is still desirable.)
861     
862     To make driver implementation easier, keep a global min_rssi_thold
863     for the entire request as well. The only affected driver is ath6kl.
864     
865     I found this when I looked into the code after Raja Mani submitted
866     a patch fixing the n_match_sets calculation to disregard the RSSI,
867     but that patch didn't address the semantic issue.
868     
869     Reported-by: Raja Mani <rmani@qti.qualcomm.com>
870     Acked-by: Luciano Coelho <luciano.coelho@intel.com>
871     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
872
873 commit de553e8545e65a6dc4e45f43df7e1443d4291922
874 Author: Johannes Berg <johannes.berg@intel.com>
875 Date:   Fri Jan 24 10:17:47 2014 +0100
876
877     nl80211: check nla_parse() return values
878     
879     If there's a policy, then nla_parse() return values must be
880     checked, otherwise the policy is useless and there's nothing
881     that ensures the attributes are actually what we expect them
882     to be.
883     
884     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
885
886 commit 652204a0733e9e1c54661d6f9d36e2e1e3b22bb1
887 Author: Karl Beldan <karl.beldan@rivierawaves.com>
888 Date:   Thu Jan 23 20:06:34 2014 +0100
889
890     mac80211: send {ADD,DEL}BA on AC_VO like other mgmt frames, as per spec
891     
892     ATM, {ADD,DEL}BA and BAR frames are sent on the AC matching the TID of
893     the BA parameters. In the discussion [1] about this patch, Johannes
894     recalled that it fixed some races with the DELBA and indeed this
895     behavior was introduced in [2].
896     While [2] is right for the BARs, the part queueing the {ADD,DEL}BAs on
897     their BA params TID AC violates the spec and is more a workaround for
898     some drivers. Helmut expressed some concerns wrt such drivers, in
899     particular DELBAs in rt2x00.
900     
901     ATM, DELBAs are sent after a driver has called (hence "purposely")
902     ieee80211_start_tx_ba_cb_irqsafe and Johannes and Emmanuel gave some
903     details wrt intentions behind the split of the IEEE80211_AMPDU_TX_STOP_*
904     given to the driver ampdu_action supposed to call this function, which
905     could prove handy to people trying to do the right thing in faulty
906     drivers (if their fw/hw don't get in their way).
907     
908     [1] http://mid.gmane.org/1390391564-18481-1-git-send-email-karl.beldan@gmail.com
909     [2] Commit: cf6bb79ad828 ("mac80211: Use appropriate TID for sending BAR, ADDBA and DELBA frames")
910     
911     Signed-off-by: Karl Beldan <karl.beldan@rivierawaves.com>
912     Cc: Helmut Schaa <helmut.schaa@googlemail.com>
913     Cc: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
914     Signed-off-by: Johannes Berg <johannes.berg@intel.com>
915 --- a/drivers/net/wireless/ath/ath6kl/cfg80211.c
916 +++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c
917 @@ -790,7 +790,7 @@ void ath6kl_cfg80211_connect_event(struc
918         if (nw_type & ADHOC_NETWORK) {
919                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n",
920                            nw_type & ADHOC_CREATOR ? "creator" : "joiner");
921 -               cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
922 +               cfg80211_ibss_joined(vif->ndev, bssid, chan, GFP_KERNEL);
923                 cfg80211_put_bss(ar->wiphy, bss);
924                 return;
925         }
926 @@ -861,13 +861,9 @@ void ath6kl_cfg80211_disconnect_event(st
927         }
928  
929         if (vif->nw_type & ADHOC_NETWORK) {
930 -               if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
931 +               if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC)
932                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
933                                    "%s: ath6k not in ibss mode\n", __func__);
934 -                       return;
935 -               }
936 -               memset(bssid, 0, ETH_ALEN);
937 -               cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
938                 return;
939         }
940  
941 @@ -3256,6 +3252,15 @@ static int ath6kl_cfg80211_sscan_start(s
942         struct ath6kl_vif *vif = netdev_priv(dev);
943         u16 interval;
944         int ret, rssi_thold;
945 +       int n_match_sets = request->n_match_sets;
946 +
947 +       /*
948 +        * If there's a matchset w/o an SSID, then assume it's just for
949 +        * the RSSI (nothing else is currently supported) and ignore it.
950 +        * The device only supports a global RSSI filter that we set below.
951 +        */
952 +       if (n_match_sets == 1 && !request->match_sets[0].ssid.ssid_len)
953 +               n_match_sets = 0;
954  
955         if (ar->state != ATH6KL_STATE_ON)
956                 return -EIO;
957 @@ -3268,11 +3273,11 @@ static int ath6kl_cfg80211_sscan_start(s
958         ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
959                                       request->n_ssids,
960                                       request->match_sets,
961 -                                     request->n_match_sets);
962 +                                     n_match_sets);
963         if (ret < 0)
964                 return ret;
965  
966 -       if (!request->n_match_sets) {
967 +       if (!n_match_sets) {
968                 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
969                                                ALL_BSS_FILTER, 0);
970                 if (ret < 0)
971 @@ -3286,12 +3291,12 @@ static int ath6kl_cfg80211_sscan_start(s
972  
973         if (test_bit(ATH6KL_FW_CAPABILITY_RSSI_SCAN_THOLD,
974                      ar->fw_capabilities)) {
975 -               if (request->rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF)
976 +               if (request->min_rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF)
977                         rssi_thold = 0;
978 -               else if (request->rssi_thold < -127)
979 +               else if (request->min_rssi_thold < -127)
980                         rssi_thold = -127;
981                 else
982 -                       rssi_thold = request->rssi_thold;
983 +                       rssi_thold = request->min_rssi_thold;
984  
985                 ret = ath6kl_wmi_set_rssi_filter_cmd(ar->wmi, vif->fw_vif_idx,
986                                                      rssi_thold);
987 --- a/drivers/net/wireless/ath/ath9k/hw.c
988 +++ b/drivers/net/wireless/ath/ath9k/hw.c
989 @@ -1316,7 +1316,7 @@ static bool ath9k_hw_set_reset(struct at
990         if (AR_SREV_9300_20_OR_LATER(ah))
991                 udelay(50);
992         else if (AR_SREV_9100(ah))
993 -               udelay(10000);
994 +               mdelay(10);
995         else
996                 udelay(100);
997  
998 @@ -2051,9 +2051,8 @@ static bool ath9k_hw_set_power_awake(str
999  
1000         REG_SET_BIT(ah, AR_RTC_FORCE_WAKE,
1001                     AR_RTC_FORCE_WAKE_EN);
1002 -
1003         if (AR_SREV_9100(ah))
1004 -               udelay(10000);
1005 +               mdelay(10);
1006         else
1007                 udelay(50);
1008  
1009 --- a/drivers/net/wireless/ath/ath9k/main.c
1010 +++ b/drivers/net/wireless/ath/ath9k/main.c
1011 @@ -1866,7 +1866,7 @@ static void ath9k_set_coverage_class(str
1012  
1013  static bool ath9k_has_tx_pending(struct ath_softc *sc)
1014  {
1015 -       int i, npend;
1016 +       int i, npend = 0;
1017  
1018         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1019                 if (!ATH_TXQ_SETUP(sc, i))
1020 --- a/drivers/net/wireless/iwlwifi/mvm/scan.c
1021 +++ b/drivers/net/wireless/iwlwifi/mvm/scan.c
1022 @@ -595,6 +595,9 @@ static void iwl_scan_offload_build_ssid(
1023          * config match list.
1024          */
1025         for (i = 0; i < req->n_match_sets && i < PROBE_OPTION_MAX; i++) {
1026 +               /* skip empty SSID matchsets */
1027 +               if (!req->match_sets[i].ssid.ssid_len)
1028 +                       continue;
1029                 scan->direct_scan[i].id = WLAN_EID_SSID;
1030                 scan->direct_scan[i].len = req->match_sets[i].ssid.ssid_len;
1031                 memcpy(scan->direct_scan[i].ssid, req->match_sets[i].ssid.ssid,
1032 --- a/drivers/net/wireless/rtlwifi/rtl8188ee/trx.c
1033 +++ b/drivers/net/wireless/rtlwifi/rtl8188ee/trx.c
1034 @@ -452,7 +452,7 @@ bool rtl88ee_rx_query_desc(struct ieee80
1035                         /* During testing, hdr was NULL */
1036                         return false;
1037                 }
1038 -               if ((ieee80211_is_robust_mgmt_frame(hdr)) &&
1039 +               if ((_ieee80211_is_robust_mgmt_frame(hdr)) &&
1040                     (ieee80211_has_protected(hdr->frame_control)))
1041                         rx_status->flag &= ~RX_FLAG_DECRYPTED;
1042                 else
1043 --- a/drivers/net/wireless/rtlwifi/rtl8192ce/trx.c
1044 +++ b/drivers/net/wireless/rtlwifi/rtl8192ce/trx.c
1045 @@ -393,7 +393,7 @@ bool rtl92ce_rx_query_desc(struct ieee80
1046                         /* In testing, hdr was NULL here */
1047                         return false;
1048                 }
1049 -               if ((ieee80211_is_robust_mgmt_frame(hdr)) &&
1050 +               if ((_ieee80211_is_robust_mgmt_frame(hdr)) &&
1051                     (ieee80211_has_protected(hdr->frame_control)))
1052                         rx_status->flag &= ~RX_FLAG_DECRYPTED;
1053                 else
1054 --- a/drivers/net/wireless/rtlwifi/rtl8192se/trx.c
1055 +++ b/drivers/net/wireless/rtlwifi/rtl8192se/trx.c
1056 @@ -310,7 +310,7 @@ bool rtl92se_rx_query_desc(struct ieee80
1057                         /* during testing, hdr was NULL here */
1058                         return false;
1059                 }
1060 -               if ((ieee80211_is_robust_mgmt_frame(hdr)) &&
1061 +               if ((_ieee80211_is_robust_mgmt_frame(hdr)) &&
1062                         (ieee80211_has_protected(hdr->frame_control)))
1063                         rx_status->flag &= ~RX_FLAG_DECRYPTED;
1064                 else
1065 --- a/drivers/net/wireless/rtlwifi/rtl8723ae/trx.c
1066 +++ b/drivers/net/wireless/rtlwifi/rtl8723ae/trx.c
1067 @@ -334,7 +334,7 @@ bool rtl8723ae_rx_query_desc(struct ieee
1068                         /* during testing, hdr could be NULL here */
1069                         return false;
1070                 }
1071 -               if ((ieee80211_is_robust_mgmt_frame(hdr)) &&
1072 +               if ((_ieee80211_is_robust_mgmt_frame(hdr)) &&
1073                         (ieee80211_has_protected(hdr->frame_control)))
1074                         rx_status->flag &= ~RX_FLAG_DECRYPTED;
1075                 else
1076 --- a/include/linux/ieee80211.h
1077 +++ b/include/linux/ieee80211.h
1078 @@ -597,6 +597,20 @@ static inline int ieee80211_is_qos_nullf
1079  }
1080  
1081  /**
1082 + * ieee80211_is_bufferable_mmpdu - check if frame is bufferable MMPDU
1083 + * @fc: frame control field in little-endian byteorder
1084 + */
1085 +static inline bool ieee80211_is_bufferable_mmpdu(__le16 fc)
1086 +{
1087 +       /* IEEE 802.11-2012, definition of "bufferable management frame";
1088 +        * note that this ignores the IBSS special case. */
1089 +       return ieee80211_is_mgmt(fc) &&
1090 +              (ieee80211_is_action(fc) ||
1091 +               ieee80211_is_disassoc(fc) ||
1092 +               ieee80211_is_deauth(fc));
1093 +}
1094 +
1095 +/**
1096   * ieee80211_is_first_frag - check if IEEE80211_SCTL_FRAG is not set
1097   * @seq_ctrl: frame sequence control bytes in little-endian byteorder
1098   */
1099 @@ -2192,10 +2206,10 @@ static inline u8 *ieee80211_get_DA(struc
1100  }
1101  
1102  /**
1103 - * ieee80211_is_robust_mgmt_frame - check if frame is a robust management frame
1104 + * _ieee80211_is_robust_mgmt_frame - check if frame is a robust management frame
1105   * @hdr: the frame (buffer must include at least the first octet of payload)
1106   */
1107 -static inline bool ieee80211_is_robust_mgmt_frame(struct ieee80211_hdr *hdr)
1108 +static inline bool _ieee80211_is_robust_mgmt_frame(struct ieee80211_hdr *hdr)
1109  {
1110         if (ieee80211_is_disassoc(hdr->frame_control) ||
1111             ieee80211_is_deauth(hdr->frame_control))
1112 @@ -2224,6 +2238,17 @@ static inline bool ieee80211_is_robust_m
1113  }
1114  
1115  /**
1116 + * ieee80211_is_robust_mgmt_frame - check if skb contains a robust mgmt frame
1117 + * @skb: the skb containing the frame, length will be checked
1118 + */
1119 +static inline bool ieee80211_is_robust_mgmt_frame(struct sk_buff *skb)
1120 +{
1121 +       if (skb->len < 25)
1122 +               return false;
1123 +       return _ieee80211_is_robust_mgmt_frame((void *)skb->data);
1124 +}
1125 +
1126 +/**
1127   * ieee80211_is_public_action - check if frame is a public action frame
1128   * @hdr: the frame
1129   * @len: length of the frame
1130 --- a/include/net/cfg80211.h
1131 +++ b/include/net/cfg80211.h
1132 @@ -1395,9 +1395,11 @@ struct cfg80211_scan_request {
1133   * struct cfg80211_match_set - sets of attributes to match
1134   *
1135   * @ssid: SSID to be matched
1136 + * @rssi_thold: don't report scan results below this threshold (in s32 dBm)
1137   */
1138  struct cfg80211_match_set {
1139         struct cfg80211_ssid ssid;
1140 +       s32 rssi_thold;
1141  };
1142  
1143  /**
1144 @@ -1420,7 +1422,8 @@ struct cfg80211_match_set {
1145   * @dev: the interface
1146   * @scan_start: start time of the scheduled scan
1147   * @channels: channels to scan
1148 - * @rssi_thold: don't report scan results below this threshold (in s32 dBm)
1149 + * @min_rssi_thold: for drivers only supporting a single threshold, this
1150 + *     contains the minimum over all matchsets
1151   */
1152  struct cfg80211_sched_scan_request {
1153         struct cfg80211_ssid *ssids;
1154 @@ -1433,7 +1436,7 @@ struct cfg80211_sched_scan_request {
1155         u32 flags;
1156         struct cfg80211_match_set *match_sets;
1157         int n_match_sets;
1158 -       s32 rssi_thold;
1159 +       s32 min_rssi_thold;
1160  
1161         /* internal */
1162         struct wiphy *wiphy;
1163 @@ -3130,8 +3133,8 @@ struct cfg80211_cached_keys;
1164   * @identifier: (private) Identifier used in nl80211 to identify this
1165   *     wireless device if it has no netdev
1166   * @current_bss: (private) Used by the internal configuration code
1167 - * @channel: (private) Used by the internal configuration code to track
1168 - *     the user-set AP, monitor and WDS channel
1169 + * @chandef: (private) Used by the internal configuration code to track
1170 + *     the user-set channel definition.
1171   * @preset_chandef: (private) Used by the internal configuration code to
1172   *     track the channel to be used for AP later
1173   * @bssid: (private) Used by the internal configuration code
1174 @@ -3195,9 +3198,7 @@ struct wireless_dev {
1175  
1176         struct cfg80211_internal_bss *current_bss; /* associated / joined */
1177         struct cfg80211_chan_def preset_chandef;
1178 -
1179 -       /* for AP and mesh channel tracking */
1180 -       struct ieee80211_channel *channel;
1181 +       struct cfg80211_chan_def chandef;
1182  
1183         bool ibss_fixed;
1184         bool ibss_dfs_possible;
1185 @@ -3879,6 +3880,7 @@ void cfg80211_michael_mic_failure(struct
1186   *
1187   * @dev: network device
1188   * @bssid: the BSSID of the IBSS joined
1189 + * @channel: the channel of the IBSS joined
1190   * @gfp: allocation flags
1191   *
1192   * This function notifies cfg80211 that the device joined an IBSS or
1193 @@ -3888,7 +3890,8 @@ void cfg80211_michael_mic_failure(struct
1194   * with the locally generated beacon -- this guarantees that there is
1195   * always a scan result for this IBSS. cfg80211 will handle the rest.
1196   */
1197 -void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp);
1198 +void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
1199 +                         struct ieee80211_channel *channel, gfp_t gfp);
1200  
1201  /**
1202   * cfg80211_notify_new_candidate - notify cfg80211 of a new mesh peer candidate
1203 --- a/include/uapi/linux/nl80211.h
1204 +++ b/include/uapi/linux/nl80211.h
1205 @@ -2442,9 +2442,15 @@ enum nl80211_reg_rule_attr {
1206   * enum nl80211_sched_scan_match_attr - scheduled scan match attributes
1207   * @__NL80211_SCHED_SCAN_MATCH_ATTR_INVALID: attribute number 0 is reserved
1208   * @NL80211_SCHED_SCAN_MATCH_ATTR_SSID: SSID to be used for matching,
1209 - * only report BSS with matching SSID.
1210 + *     only report BSS with matching SSID.
1211   * @NL80211_SCHED_SCAN_MATCH_ATTR_RSSI: RSSI threshold (in dBm) for reporting a
1212 - *     BSS in scan results. Filtering is turned off if not specified.
1213 + *     BSS in scan results. Filtering is turned off if not specified. Note that
1214 + *     if this attribute is in a match set of its own, then it is treated as
1215 + *     the default value for all matchsets with an SSID, rather than being a
1216 + *     matchset of its own without an RSSI filter. This is due to problems with
1217 + *     how this API was implemented in the past. Also, due to the same problem,
1218 + *     the only way to create a matchset with only an RSSI filter (with this
1219 + *     attribute) is if there's only a single matchset with the RSSI attribute.
1220   * @NL80211_SCHED_SCAN_MATCH_ATTR_MAX: highest scheduled scan filter
1221   *     attribute number currently defined
1222   * @__NL80211_SCHED_SCAN_MATCH_ATTR_AFTER_LAST: internal use
1223 --- a/net/mac80211/agg-tx.c
1224 +++ b/net/mac80211/agg-tx.c
1225 @@ -107,7 +107,7 @@ static void ieee80211_send_addba_request
1226         mgmt->u.action.u.addba_req.start_seq_num =
1227                                         cpu_to_le16(start_seq_num << 4);
1228  
1229 -       ieee80211_tx_skb_tid(sdata, skb, tid);
1230 +       ieee80211_tx_skb(sdata, skb);
1231  }
1232  
1233  void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
1234 --- a/net/mac80211/cfg.c
1235 +++ b/net/mac80211/cfg.c
1236 @@ -970,9 +970,9 @@ static int ieee80211_start_ap(struct wip
1237         /* TODO: make hostapd tell us what it wants */
1238         sdata->smps_mode = IEEE80211_SMPS_OFF;
1239         sdata->needed_rx_chains = sdata->local->rx_chains;
1240 -       sdata->radar_required = params->radar_required;
1241  
1242         mutex_lock(&local->mtx);
1243 +       sdata->radar_required = params->radar_required;
1244         err = ieee80211_vif_use_channel(sdata, &params->chandef,
1245                                         IEEE80211_CHANCTX_SHARED);
1246         mutex_unlock(&local->mtx);
1247 @@ -1021,8 +1021,10 @@ static int ieee80211_start_ap(struct wip
1248                                         IEEE80211_P2P_OPPPS_ENABLE_BIT;
1249  
1250         err = ieee80211_assign_beacon(sdata, &params->beacon);
1251 -       if (err < 0)
1252 +       if (err < 0) {
1253 +               ieee80211_vif_release_channel(sdata);
1254                 return err;
1255 +       }
1256         changed |= err;
1257  
1258         err = drv_start_ap(sdata->local, sdata);
1259 @@ -1032,6 +1034,7 @@ static int ieee80211_start_ap(struct wip
1260                 if (old)
1261                         kfree_rcu(old, rcu_head);
1262                 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1263 +               ieee80211_vif_release_channel(sdata);
1264                 return err;
1265         }
1266  
1267 @@ -1053,6 +1056,7 @@ static int ieee80211_change_beacon(struc
1268         int err;
1269  
1270         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1271 +       sdata_assert_lock(sdata);
1272  
1273         /* don't allow changing the beacon while CSA is in place - offset
1274          * of channel switch counter may change
1275 @@ -1080,6 +1084,8 @@ static int ieee80211_stop_ap(struct wiph
1276         struct probe_resp *old_probe_resp;
1277         struct cfg80211_chan_def chandef;
1278  
1279 +       sdata_assert_lock(sdata);
1280 +
1281         old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1282         if (!old_beacon)
1283                 return -ENOENT;
1284 @@ -1090,8 +1096,6 @@ static int ieee80211_stop_ap(struct wiph
1285         kfree(sdata->u.ap.next_beacon);
1286         sdata->u.ap.next_beacon = NULL;
1287  
1288 -       cancel_work_sync(&sdata->u.ap.request_smps_work);
1289 -
1290         /* turn off carrier for this interface and dependent VLANs */
1291         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1292                 netif_carrier_off(vlan->dev);
1293 @@ -1103,6 +1107,7 @@ static int ieee80211_stop_ap(struct wiph
1294         kfree_rcu(old_beacon, rcu_head);
1295         if (old_probe_resp)
1296                 kfree_rcu(old_probe_resp, rcu_head);
1297 +       sdata->u.ap.driver_smps_mode = IEEE80211_SMPS_OFF;
1298  
1299         __sta_info_flush(sdata, true);
1300         ieee80211_free_keys(sdata, true);
1301 @@ -2638,6 +2643,24 @@ static int ieee80211_start_roc_work(stru
1302         INIT_DELAYED_WORK(&roc->work, ieee80211_sw_roc_work);
1303         INIT_LIST_HEAD(&roc->dependents);
1304  
1305 +       /*
1306 +        * cookie is either the roc cookie (for normal roc)
1307 +        * or the SKB (for mgmt TX)
1308 +        */
1309 +       if (!txskb) {
1310 +               /* local->mtx protects this */
1311 +               local->roc_cookie_counter++;
1312 +               roc->cookie = local->roc_cookie_counter;
1313 +               /* wow, you wrapped 64 bits ... more likely a bug */
1314 +               if (WARN_ON(roc->cookie == 0)) {
1315 +                       roc->cookie = 1;
1316 +                       local->roc_cookie_counter++;
1317 +               }
1318 +               *cookie = roc->cookie;
1319 +       } else {
1320 +               *cookie = (unsigned long)txskb;
1321 +       }
1322 +
1323         /* if there's one pending or we're scanning, queue this one */
1324         if (!list_empty(&local->roc_list) ||
1325             local->scanning || local->radar_detect_enabled)
1326 @@ -2772,24 +2795,6 @@ static int ieee80211_start_roc_work(stru
1327         if (!queued)
1328                 list_add_tail(&roc->list, &local->roc_list);
1329  
1330 -       /*
1331 -        * cookie is either the roc cookie (for normal roc)
1332 -        * or the SKB (for mgmt TX)
1333 -        */
1334 -       if (!txskb) {
1335 -               /* local->mtx protects this */
1336 -               local->roc_cookie_counter++;
1337 -               roc->cookie = local->roc_cookie_counter;
1338 -               /* wow, you wrapped 64 bits ... more likely a bug */
1339 -               if (WARN_ON(roc->cookie == 0)) {
1340 -                       roc->cookie = 1;
1341 -                       local->roc_cookie_counter++;
1342 -               }
1343 -               *cookie = roc->cookie;
1344 -       } else {
1345 -               *cookie = (unsigned long)txskb;
1346 -       }
1347 -
1348         return 0;
1349  }
1350  
1351 @@ -3004,8 +3009,10 @@ void ieee80211_csa_finalize_work(struct 
1352         if (!ieee80211_sdata_running(sdata))
1353                 goto unlock;
1354  
1355 -       sdata->radar_required = sdata->csa_radar_required;
1356 +       sdata_assert_lock(sdata);
1357 +
1358         mutex_lock(&local->mtx);
1359 +       sdata->radar_required = sdata->csa_radar_required;
1360         err = ieee80211_vif_change_channel(sdata, &changed);
1361         mutex_unlock(&local->mtx);
1362         if (WARN_ON(err < 0))
1363 @@ -3022,13 +3029,13 @@ void ieee80211_csa_finalize_work(struct 
1364         switch (sdata->vif.type) {
1365         case NL80211_IFTYPE_AP:
1366                 err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
1367 +               kfree(sdata->u.ap.next_beacon);
1368 +               sdata->u.ap.next_beacon = NULL;
1369 +
1370                 if (err < 0)
1371                         goto unlock;
1372  
1373                 changed |= err;
1374 -               kfree(sdata->u.ap.next_beacon);
1375 -               sdata->u.ap.next_beacon = NULL;
1376 -
1377                 ieee80211_bss_info_change_notify(sdata, err);
1378                 break;
1379         case NL80211_IFTYPE_ADHOC:
1380 @@ -3066,7 +3073,7 @@ int ieee80211_channel_switch(struct wiph
1381         struct ieee80211_if_mesh __maybe_unused *ifmsh;
1382         int err, num_chanctx;
1383  
1384 -       lockdep_assert_held(&sdata->wdev.mtx);
1385 +       sdata_assert_lock(sdata);
1386  
1387         if (!list_empty(&local->roc_list) || local->scanning)
1388                 return -EBUSY;
1389 --- a/net/mac80211/ht.c
1390 +++ b/net/mac80211/ht.c
1391 @@ -375,7 +375,7 @@ void ieee80211_send_delba(struct ieee802
1392         mgmt->u.action.u.delba.params = cpu_to_le16(params);
1393         mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code);
1394  
1395 -       ieee80211_tx_skb_tid(sdata, skb, tid);
1396 +       ieee80211_tx_skb(sdata, skb);
1397  }
1398  
1399  void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
1400 @@ -466,7 +466,9 @@ void ieee80211_request_smps_ap_work(stru
1401                              u.ap.request_smps_work);
1402  
1403         sdata_lock(sdata);
1404 -       __ieee80211_request_smps_ap(sdata, sdata->u.ap.driver_smps_mode);
1405 +       if (sdata_dereference(sdata->u.ap.beacon, sdata))
1406 +               __ieee80211_request_smps_ap(sdata,
1407 +                                           sdata->u.ap.driver_smps_mode);
1408         sdata_unlock(sdata);
1409  }
1410  
1411 --- a/net/mac80211/iface.c
1412 +++ b/net/mac80211/iface.c
1413 @@ -770,12 +770,19 @@ static void ieee80211_do_stop(struct iee
1414  
1415         ieee80211_roc_purge(local, sdata);
1416  
1417 -       if (sdata->vif.type == NL80211_IFTYPE_STATION)
1418 +       switch (sdata->vif.type) {
1419 +       case NL80211_IFTYPE_STATION:
1420                 ieee80211_mgd_stop(sdata);
1421 -
1422 -       if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
1423 +               break;
1424 +       case NL80211_IFTYPE_ADHOC:
1425                 ieee80211_ibss_stop(sdata);
1426 -
1427 +               break;
1428 +       case NL80211_IFTYPE_AP:
1429 +               cancel_work_sync(&sdata->u.ap.request_smps_work);
1430 +               break;
1431 +       default:
1432 +               break;
1433 +       }
1434  
1435         /*
1436          * Remove all stations associated with this interface.
1437 @@ -827,7 +834,9 @@ static void ieee80211_do_stop(struct iee
1438         cancel_work_sync(&local->dynamic_ps_enable_work);
1439  
1440         cancel_work_sync(&sdata->recalc_smps);
1441 +       sdata_lock(sdata);
1442         sdata->vif.csa_active = false;
1443 +       sdata_unlock(sdata);
1444         cancel_work_sync(&sdata->csa_finalize_work);
1445  
1446         cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1447 --- a/net/mac80211/rx.c
1448 +++ b/net/mac80211/rx.c
1449 @@ -599,10 +599,10 @@ static int ieee80211_is_unicast_robust_m
1450  {
1451         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1452  
1453 -       if (skb->len < 24 || is_multicast_ether_addr(hdr->addr1))
1454 +       if (is_multicast_ether_addr(hdr->addr1))
1455                 return 0;
1456  
1457 -       return ieee80211_is_robust_mgmt_frame(hdr);
1458 +       return ieee80211_is_robust_mgmt_frame(skb);
1459  }
1460  
1461  
1462 @@ -610,10 +610,10 @@ static int ieee80211_is_multicast_robust
1463  {
1464         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1465  
1466 -       if (skb->len < 24 || !is_multicast_ether_addr(hdr->addr1))
1467 +       if (!is_multicast_ether_addr(hdr->addr1))
1468                 return 0;
1469  
1470 -       return ieee80211_is_robust_mgmt_frame(hdr);
1471 +       return ieee80211_is_robust_mgmt_frame(skb);
1472  }
1473  
1474  
1475 @@ -626,7 +626,7 @@ static int ieee80211_get_mmie_keyidx(str
1476         if (skb->len < 24 + sizeof(*mmie) || !is_multicast_ether_addr(hdr->da))
1477                 return -1;
1478  
1479 -       if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) hdr))
1480 +       if (!ieee80211_is_robust_mgmt_frame(skb))
1481                 return -1; /* not a robust management frame */
1482  
1483         mmie = (struct ieee80211_mmie *)
1484 @@ -1128,6 +1128,13 @@ static void sta_ps_end(struct sta_info *
1485                sta->sta.addr, sta->sta.aid);
1486  
1487         if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
1488 +               /*
1489 +                * Clear the flag only if the other one is still set
1490 +                * so that the TX path won't start TX'ing new frames
1491 +                * directly ... In the case that the driver flag isn't
1492 +                * set ieee80211_sta_ps_deliver_wakeup() will clear it.
1493 +                */
1494 +               clear_sta_flag(sta, WLAN_STA_PS_STA);
1495                 ps_dbg(sta->sdata, "STA %pM aid %d driver-ps-blocked\n",
1496                        sta->sta.addr, sta->sta.aid);
1497                 return;
1498 @@ -1311,18 +1318,15 @@ ieee80211_rx_h_sta_process(struct ieee80
1499             !ieee80211_has_morefrags(hdr->frame_control) &&
1500             !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
1501             (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1502 -            rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
1503 +            rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
1504 +           /* PM bit is only checked in frames where it isn't reserved,
1505 +            * in AP mode it's reserved in non-bufferable management frames
1506 +            * (cf. IEEE 802.11-2012 8.2.4.1.7 Power Management field)
1507 +            */
1508 +           (!ieee80211_is_mgmt(hdr->frame_control) ||
1509 +            ieee80211_is_bufferable_mmpdu(hdr->frame_control))) {
1510                 if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
1511 -                       /*
1512 -                        * Ignore doze->wake transitions that are
1513 -                        * indicated by non-data frames, the standard
1514 -                        * is unclear here, but for example going to
1515 -                        * PS mode and then scanning would cause a
1516 -                        * doze->wake transition for the probe request,
1517 -                        * and that is clearly undesirable.
1518 -                        */
1519 -                       if (ieee80211_is_data(hdr->frame_control) &&
1520 -                           !ieee80211_has_pm(hdr->frame_control))
1521 +                       if (!ieee80211_has_pm(hdr->frame_control))
1522                                 sta_ps_end(sta);
1523                 } else {
1524                         if (ieee80211_has_pm(hdr->frame_control))
1525 @@ -1845,8 +1849,7 @@ static int ieee80211_drop_unencrypted_mg
1526                  * having configured keys.
1527                  */
1528                 if (unlikely(ieee80211_is_action(fc) && !rx->key &&
1529 -                            ieee80211_is_robust_mgmt_frame(
1530 -                                    (struct ieee80211_hdr *) rx->skb->data)))
1531 +                            ieee80211_is_robust_mgmt_frame(rx->skb)))
1532                         return -EACCES;
1533         }
1534  
1535 --- a/net/mac80211/tx.c
1536 +++ b/net/mac80211/tx.c
1537 @@ -452,8 +452,7 @@ static int ieee80211_use_mfp(__le16 fc, 
1538         if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP))
1539                 return 0;
1540  
1541 -       if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *)
1542 -                                           skb->data))
1543 +       if (!ieee80211_is_robust_mgmt_frame(skb))
1544                 return 0;
1545  
1546         return 1;
1547 @@ -478,6 +477,20 @@ ieee80211_tx_h_unicast_ps_buf(struct iee
1548                        sta->sta.addr, sta->sta.aid, ac);
1549                 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
1550                         purge_old_ps_buffers(tx->local);
1551 +
1552 +               /* sync with ieee80211_sta_ps_deliver_wakeup */
1553 +               spin_lock(&sta->ps_lock);
1554 +               /*
1555 +                * STA woke up the meantime and all the frames on ps_tx_buf have
1556 +                * been queued to pending queue. No reordering can happen, go
1557 +                * ahead and Tx the packet.
1558 +                */
1559 +               if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
1560 +                   !test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
1561 +                       spin_unlock(&sta->ps_lock);
1562 +                       return TX_CONTINUE;
1563 +               }
1564 +
1565                 if (skb_queue_len(&sta->ps_tx_buf[ac]) >= STA_MAX_TX_BUFFER) {
1566                         struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf[ac]);
1567                         ps_dbg(tx->sdata,
1568 @@ -492,6 +505,7 @@ ieee80211_tx_h_unicast_ps_buf(struct iee
1569                 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1570                 info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
1571                 skb_queue_tail(&sta->ps_tx_buf[ac], tx->skb);
1572 +               spin_unlock(&sta->ps_lock);
1573  
1574                 if (!timer_pending(&local->sta_cleanup))
1575                         mod_timer(&local->sta_cleanup,
1576 @@ -525,9 +539,7 @@ ieee80211_tx_h_ps_buf(struct ieee80211_t
1577  
1578         /* only deauth, disassoc and action are bufferable MMPDUs */
1579         if (ieee80211_is_mgmt(hdr->frame_control) &&
1580 -           !ieee80211_is_deauth(hdr->frame_control) &&
1581 -           !ieee80211_is_disassoc(hdr->frame_control) &&
1582 -           !ieee80211_is_action(hdr->frame_control)) {
1583 +           !ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
1584                 if (tx->flags & IEEE80211_TX_UNICAST)
1585                         info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
1586                 return TX_CONTINUE;
1587 @@ -567,7 +579,7 @@ ieee80211_tx_h_select_key(struct ieee802
1588                 tx->key = key;
1589         else if (ieee80211_is_mgmt(hdr->frame_control) &&
1590                  is_multicast_ether_addr(hdr->addr1) &&
1591 -                ieee80211_is_robust_mgmt_frame(hdr) &&
1592 +                ieee80211_is_robust_mgmt_frame(tx->skb) &&
1593                  (key = rcu_dereference(tx->sdata->default_mgmt_key)))
1594                 tx->key = key;
1595         else if (is_multicast_ether_addr(hdr->addr1) &&
1596 @@ -582,12 +594,12 @@ ieee80211_tx_h_select_key(struct ieee802
1597                 tx->key = NULL;
1598         else if (tx->skb->protocol == tx->sdata->control_port_protocol)
1599                 tx->key = NULL;
1600 -       else if (ieee80211_is_robust_mgmt_frame(hdr) &&
1601 +       else if (ieee80211_is_robust_mgmt_frame(tx->skb) &&
1602                  !(ieee80211_is_action(hdr->frame_control) &&
1603                    tx->sta && test_sta_flag(tx->sta, WLAN_STA_MFP)))
1604                 tx->key = NULL;
1605         else if (ieee80211_is_mgmt(hdr->frame_control) &&
1606 -                !ieee80211_is_robust_mgmt_frame(hdr))
1607 +                !ieee80211_is_robust_mgmt_frame(tx->skb))
1608                 tx->key = NULL;
1609         else {
1610                 I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
1611 @@ -878,7 +890,7 @@ static int ieee80211_fragment(struct iee
1612         }
1613  
1614         /* adjust first fragment's length */
1615 -       skb->len = hdrlen + per_fragm;
1616 +       skb_trim(skb, hdrlen + per_fragm);
1617         return 0;
1618  }
1619  
1620 --- a/net/mac80211/wpa.c
1621 +++ b/net/mac80211/wpa.c
1622 @@ -499,7 +499,7 @@ ieee80211_crypto_ccmp_decrypt(struct iee
1623         hdrlen = ieee80211_hdrlen(hdr->frame_control);
1624  
1625         if (!ieee80211_is_data(hdr->frame_control) &&
1626 -           !ieee80211_is_robust_mgmt_frame(hdr))
1627 +           !ieee80211_is_robust_mgmt_frame(skb))
1628                 return RX_CONTINUE;
1629  
1630         data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN -
1631 --- a/net/wireless/ap.c
1632 +++ b/net/wireless/ap.c
1633 @@ -27,9 +27,10 @@ static int __cfg80211_stop_ap(struct cfg
1634         err = rdev_stop_ap(rdev, dev);
1635         if (!err) {
1636                 wdev->beacon_interval = 0;
1637 -               wdev->channel = NULL;
1638 +               memset(&wdev->chandef, 0, sizeof(wdev->chandef));
1639                 wdev->ssid_len = 0;
1640                 rdev_set_qos_map(rdev, dev, NULL);
1641 +               nl80211_send_ap_stopped(wdev);
1642         }
1643  
1644         return err;
1645 --- a/net/wireless/core.c
1646 +++ b/net/wireless/core.c
1647 @@ -203,8 +203,11 @@ void cfg80211_stop_p2p_device(struct cfg
1648  
1649         rdev->opencount--;
1650  
1651 -       WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev &&
1652 -               !rdev->scan_req->notified);
1653 +       if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1654 +               if (WARN_ON(!rdev->scan_req->notified))
1655 +                       rdev->scan_req->aborted = true;
1656 +               ___cfg80211_scan_done(rdev, false);
1657 +       }
1658  }
1659  
1660  static int cfg80211_rfkill_set_block(void *data, bool blocked)
1661 @@ -447,9 +450,6 @@ int wiphy_register(struct wiphy *wiphy)
1662         int i;
1663         u16 ifmodes = wiphy->interface_modes;
1664  
1665 -       /* support for 5/10 MHz is broken due to nl80211 API mess - disable */
1666 -       wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_5_10_MHZ;
1667 -
1668         /*
1669          * There are major locking problems in nl80211/mac80211 for CSA,
1670          * disable for all drivers until this has been reworked.
1671 @@ -875,8 +875,11 @@ static int cfg80211_netdev_notifier_call
1672                 break;
1673         case NETDEV_DOWN:
1674                 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1675 -               WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev &&
1676 -                       !rdev->scan_req->notified);
1677 +               if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1678 +                       if (WARN_ON(!rdev->scan_req->notified))
1679 +                               rdev->scan_req->aborted = true;
1680 +                       ___cfg80211_scan_done(rdev, false);
1681 +               }
1682  
1683                 if (WARN_ON(rdev->sched_scan_req &&
1684                             rdev->sched_scan_req->dev == wdev->netdev)) {
1685 --- a/net/wireless/core.h
1686 +++ b/net/wireless/core.h
1687 @@ -62,6 +62,7 @@ struct cfg80211_registered_device {
1688         struct rb_root bss_tree;
1689         u32 bss_generation;
1690         struct cfg80211_scan_request *scan_req; /* protected by RTNL */
1691 +       struct sk_buff *scan_msg;
1692         struct cfg80211_sched_scan_request *sched_scan_req;
1693         unsigned long suspend_at;
1694         struct work_struct scan_done_wk;
1695 @@ -210,6 +211,7 @@ struct cfg80211_event {
1696                 } dc;
1697                 struct {
1698                         u8 bssid[ETH_ALEN];
1699 +                       struct ieee80211_channel *channel;
1700                 } ij;
1701         };
1702  };
1703 @@ -257,7 +259,8 @@ int __cfg80211_leave_ibss(struct cfg8021
1704                           struct net_device *dev, bool nowext);
1705  int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
1706                         struct net_device *dev, bool nowext);
1707 -void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid);
1708 +void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
1709 +                           struct ieee80211_channel *channel);
1710  int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
1711                             struct wireless_dev *wdev);
1712  
1713 @@ -361,7 +364,8 @@ int cfg80211_validate_key_settings(struc
1714                                    struct key_params *params, int key_idx,
1715                                    bool pairwise, const u8 *mac_addr);
1716  void __cfg80211_scan_done(struct work_struct *wk);
1717 -void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev);
1718 +void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
1719 +                          bool send_message);
1720  void __cfg80211_sched_scan_results(struct work_struct *wk);
1721  int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
1722                                bool driver_initiated);
1723 @@ -441,7 +445,8 @@ static inline unsigned int elapsed_jiffi
1724  void
1725  cfg80211_get_chan_state(struct wireless_dev *wdev,
1726                         struct ieee80211_channel **chan,
1727 -                       enum cfg80211_chan_mode *chanmode);
1728 +                       enum cfg80211_chan_mode *chanmode,
1729 +                       u8 *radar_detect);
1730  
1731  int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1732                                  struct cfg80211_chan_def *chandef);
1733 --- a/net/wireless/nl80211.c
1734 +++ b/net/wireless/nl80211.c
1735 @@ -1723,9 +1723,10 @@ static int nl80211_dump_wiphy(struct sk_
1736                                  * We can then retry with the larger buffer.
1737                                  */
1738                                 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
1739 -                                   !skb->len &&
1740 +                                   !skb->len && !state->split &&
1741                                     cb->min_dump_alloc < 4096) {
1742                                         cb->min_dump_alloc = 4096;
1743 +                                       state->split_start = 0;
1744                                         rtnl_unlock();
1745                                         return 1;
1746                                 }
1747 @@ -2047,10 +2048,12 @@ static int nl80211_set_wiphy(struct sk_b
1748                 nla_for_each_nested(nl_txq_params,
1749                                     info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
1750                                     rem_txq_params) {
1751 -                       nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1752 -                                 nla_data(nl_txq_params),
1753 -                                 nla_len(nl_txq_params),
1754 -                                 txq_params_policy);
1755 +                       result = nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1756 +                                          nla_data(nl_txq_params),
1757 +                                          nla_len(nl_txq_params),
1758 +                                          txq_params_policy);
1759 +                       if (result)
1760 +                               goto bad_res;
1761                         result = parse_txq_params(tb, &txq_params);
1762                         if (result)
1763                                 goto bad_res;
1764 @@ -3289,7 +3292,7 @@ static int nl80211_start_ap(struct sk_bu
1765         if (!err) {
1766                 wdev->preset_chandef = params.chandef;
1767                 wdev->beacon_interval = params.beacon_interval;
1768 -               wdev->channel = params.chandef.chan;
1769 +               wdev->chandef = params.chandef;
1770                 wdev->ssid_len = params.ssid_len;
1771                 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
1772         }
1773 @@ -5210,9 +5213,11 @@ static int nl80211_set_reg(struct sk_buf
1774  
1775         nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1776                             rem_reg_rules) {
1777 -               nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
1778 -                         nla_data(nl_reg_rule), nla_len(nl_reg_rule),
1779 -                         reg_rule_policy);
1780 +               r = nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
1781 +                             nla_data(nl_reg_rule), nla_len(nl_reg_rule),
1782 +                             reg_rule_policy);
1783 +               if (r)
1784 +                       goto bad_reg;
1785                 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
1786                 if (r)
1787                         goto bad_reg;
1788 @@ -5277,7 +5282,7 @@ static int nl80211_trigger_scan(struct s
1789         if (!rdev->ops->scan)
1790                 return -EOPNOTSUPP;
1791  
1792 -       if (rdev->scan_req) {
1793 +       if (rdev->scan_req || rdev->scan_msg) {
1794                 err = -EBUSY;
1795                 goto unlock;
1796         }
1797 @@ -5475,6 +5480,7 @@ static int nl80211_start_sched_scan(stru
1798         enum ieee80211_band band;
1799         size_t ie_len;
1800         struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
1801 +       s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
1802  
1803         if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
1804             !rdev->ops->sched_scan_start)
1805 @@ -5509,11 +5515,40 @@ static int nl80211_start_sched_scan(stru
1806         if (n_ssids > wiphy->max_sched_scan_ssids)
1807                 return -EINVAL;
1808  
1809 -       if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
1810 +       /*
1811 +        * First, count the number of 'real' matchsets. Due to an issue with
1812 +        * the old implementation, matchsets containing only the RSSI attribute
1813 +        * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
1814 +        * RSSI for all matchsets, rather than their own matchset for reporting
1815 +        * all APs with a strong RSSI. This is needed to be compatible with
1816 +        * older userspace that treated a matchset with only the RSSI as the
1817 +        * global RSSI for all other matchsets - if there are other matchsets.
1818 +        */
1819 +       if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
1820                 nla_for_each_nested(attr,
1821                                     info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
1822 -                                   tmp)
1823 -                       n_match_sets++;
1824 +                                   tmp) {
1825 +                       struct nlattr *rssi;
1826 +
1827 +                       err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
1828 +                                       nla_data(attr), nla_len(attr),
1829 +                                       nl80211_match_policy);
1830 +                       if (err)
1831 +                               return err;
1832 +                       /* add other standalone attributes here */
1833 +                       if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID]) {
1834 +                               n_match_sets++;
1835 +                               continue;
1836 +                       }
1837 +                       rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
1838 +                       if (rssi)
1839 +                               default_match_rssi = nla_get_s32(rssi);
1840 +               }
1841 +       }
1842 +
1843 +       /* However, if there's no other matchset, add the RSSI one */
1844 +       if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
1845 +               n_match_sets = 1;
1846  
1847         if (n_match_sets > wiphy->max_match_sets)
1848                 return -EINVAL;
1849 @@ -5634,11 +5669,22 @@ static int nl80211_start_sched_scan(stru
1850                                     tmp) {
1851                         struct nlattr *ssid, *rssi;
1852  
1853 -                       nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
1854 -                                 nla_data(attr), nla_len(attr),
1855 -                                 nl80211_match_policy);
1856 +                       err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
1857 +                                       nla_data(attr), nla_len(attr),
1858 +                                       nl80211_match_policy);
1859 +                       if (err)
1860 +                               goto out_free;
1861                         ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
1862                         if (ssid) {
1863 +                               if (WARN_ON(i >= n_match_sets)) {
1864 +                                       /* this indicates a programming error,
1865 +                                        * the loop above should have verified
1866 +                                        * things properly
1867 +                                        */
1868 +                                       err = -EINVAL;
1869 +                                       goto out_free;
1870 +                               }
1871 +
1872                                 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
1873                                         err = -EINVAL;
1874                                         goto out_free;
1875 @@ -5647,15 +5693,28 @@ static int nl80211_start_sched_scan(stru
1876                                        nla_data(ssid), nla_len(ssid));
1877                                 request->match_sets[i].ssid.ssid_len =
1878                                         nla_len(ssid);
1879 +                               /* special attribute - old implemenation w/a */
1880 +                               request->match_sets[i].rssi_thold =
1881 +                                       default_match_rssi;
1882 +                               rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
1883 +                               if (rssi)
1884 +                                       request->match_sets[i].rssi_thold =
1885 +                                               nla_get_s32(rssi);
1886                         }
1887 -                       rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
1888 -                       if (rssi)
1889 -                               request->rssi_thold = nla_get_u32(rssi);
1890 -                       else
1891 -                               request->rssi_thold =
1892 -                                                  NL80211_SCAN_RSSI_THOLD_OFF;
1893                         i++;
1894                 }
1895 +
1896 +               /* there was no other matchset, so the RSSI one is alone */
1897 +               if (i == 0)
1898 +                       request->match_sets[0].rssi_thold = default_match_rssi;
1899 +
1900 +               request->min_rssi_thold = INT_MAX;
1901 +               for (i = 0; i < n_match_sets; i++)
1902 +                       request->min_rssi_thold =
1903 +                               min(request->match_sets[i].rssi_thold,
1904 +                                   request->min_rssi_thold);
1905 +       } else {
1906 +               request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
1907         }
1908  
1909         if (info->attrs[NL80211_ATTR_IE]) {
1910 @@ -5751,7 +5810,7 @@ static int nl80211_start_radar_detection
1911  
1912         err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef);
1913         if (!err) {
1914 -               wdev->channel = chandef.chan;
1915 +               wdev->chandef = chandef;
1916                 wdev->cac_started = true;
1917                 wdev->cac_start_time = jiffies;
1918         }
1919 @@ -7502,16 +7561,19 @@ static int nl80211_set_tx_bitrate_mask(s
1920          * directly to the enum ieee80211_band values used in cfg80211.
1921          */
1922         BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
1923 -       nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
1924 -       {
1925 +       nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
1926                 enum ieee80211_band band = nla_type(tx_rates);
1927 +               int err;
1928 +
1929                 if (band < 0 || band >= IEEE80211_NUM_BANDS)
1930                         return -EINVAL;
1931                 sband = rdev->wiphy.bands[band];
1932                 if (sband == NULL)
1933                         return -EINVAL;
1934 -               nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
1935 -                         nla_len(tx_rates), nl80211_txattr_policy);
1936 +               err = nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
1937 +                               nla_len(tx_rates), nl80211_txattr_policy);
1938 +               if (err)
1939 +                       return err;
1940                 if (tb[NL80211_TXRATE_LEGACY]) {
1941                         mask.control[band].legacy = rateset_to_mask(
1942                                 sband,
1943 @@ -10054,40 +10116,31 @@ void nl80211_send_scan_start(struct cfg8
1944                                 NL80211_MCGRP_SCAN, GFP_KERNEL);
1945  }
1946  
1947 -void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
1948 -                           struct wireless_dev *wdev)
1949 +struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
1950 +                                      struct wireless_dev *wdev, bool aborted)
1951  {
1952         struct sk_buff *msg;
1953  
1954         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1955         if (!msg)
1956 -               return;
1957 +               return NULL;
1958  
1959         if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
1960 -                                 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
1961 +                                 aborted ? NL80211_CMD_SCAN_ABORTED :
1962 +                                           NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
1963                 nlmsg_free(msg);
1964 -               return;
1965 +               return NULL;
1966         }
1967  
1968 -       genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
1969 -                               NL80211_MCGRP_SCAN, GFP_KERNEL);
1970 +       return msg;
1971  }
1972  
1973 -void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
1974 -                              struct wireless_dev *wdev)
1975 +void nl80211_send_scan_result(struct cfg80211_registered_device *rdev,
1976 +                             struct sk_buff *msg)
1977  {
1978 -       struct sk_buff *msg;
1979 -
1980 -       msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1981         if (!msg)
1982                 return;
1983  
1984 -       if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
1985 -                                 NL80211_CMD_SCAN_ABORTED) < 0) {
1986 -               nlmsg_free(msg);
1987 -               return;
1988 -       }
1989 -
1990         genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
1991                                 NL80211_MCGRP_SCAN, GFP_KERNEL);
1992  }
1993 @@ -11158,7 +11211,8 @@ void cfg80211_ch_switch_notify(struct ne
1994                     wdev->iftype != NL80211_IFTYPE_MESH_POINT))
1995                 return;
1996  
1997 -       wdev->channel = chandef->chan;
1998 +       wdev->chandef = *chandef;
1999 +       wdev->preset_chandef = *chandef;
2000         nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL);
2001  }
2002  EXPORT_SYMBOL(cfg80211_ch_switch_notify);
2003 @@ -11673,6 +11727,35 @@ void cfg80211_crit_proto_stopped(struct 
2004  }
2005  EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
2006  
2007 +void nl80211_send_ap_stopped(struct wireless_dev *wdev)
2008 +{
2009 +       struct wiphy *wiphy = wdev->wiphy;
2010 +       struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
2011 +       struct sk_buff *msg;
2012 +       void *hdr;
2013 +
2014 +       msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2015 +       if (!msg)
2016 +               return;
2017 +
2018 +       hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
2019 +       if (!hdr)
2020 +               goto out;
2021 +
2022 +       if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2023 +           nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
2024 +           nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
2025 +               goto out;
2026 +
2027 +       genlmsg_end(msg, hdr);
2028 +
2029 +       genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
2030 +                               NL80211_MCGRP_MLME, GFP_KERNEL);
2031 +       return;
2032 + out:
2033 +       nlmsg_free(msg);
2034 +}
2035 +
2036  /* initialisation/exit functions */
2037  
2038  int nl80211_init(void)
2039 --- a/net/wireless/nl80211.h
2040 +++ b/net/wireless/nl80211.h
2041 @@ -8,10 +8,10 @@ void nl80211_exit(void);
2042  void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev);
2043  void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
2044                              struct wireless_dev *wdev);
2045 -void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
2046 -                           struct wireless_dev *wdev);
2047 -void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
2048 -                              struct wireless_dev *wdev);
2049 +struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
2050 +                                      struct wireless_dev *wdev, bool aborted);
2051 +void nl80211_send_scan_result(struct cfg80211_registered_device *rdev,
2052 +                             struct sk_buff *msg);
2053  void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
2054                              struct net_device *netdev, u32 cmd);
2055  void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
2056 @@ -74,6 +74,8 @@ nl80211_radar_notify(struct cfg80211_reg
2057                      enum nl80211_radar_event event,
2058                      struct net_device *netdev, gfp_t gfp);
2059  
2060 +void nl80211_send_ap_stopped(struct wireless_dev *wdev);
2061 +
2062  void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev);
2063  
2064  #endif /* __NET_WIRELESS_NL80211_H */
2065 --- a/net/wireless/scan.c
2066 +++ b/net/wireless/scan.c
2067 @@ -161,18 +161,25 @@ static void __cfg80211_bss_expire(struct
2068                 dev->bss_generation++;
2069  }
2070  
2071 -void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev)
2072 +void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
2073 +                          bool send_message)
2074  {
2075         struct cfg80211_scan_request *request;
2076         struct wireless_dev *wdev;
2077 +       struct sk_buff *msg;
2078  #ifdef CPTCFG_CFG80211_WEXT
2079         union iwreq_data wrqu;
2080  #endif
2081  
2082         ASSERT_RTNL();
2083  
2084 -       request = rdev->scan_req;
2085 +       if (rdev->scan_msg) {
2086 +               nl80211_send_scan_result(rdev, rdev->scan_msg);
2087 +               rdev->scan_msg = NULL;
2088 +               return;
2089 +       }
2090  
2091 +       request = rdev->scan_req;
2092         if (!request)
2093                 return;
2094  
2095 @@ -186,18 +193,16 @@ void ___cfg80211_scan_done(struct cfg802
2096         if (wdev->netdev)
2097                 cfg80211_sme_scan_done(wdev->netdev);
2098  
2099 -       if (request->aborted) {
2100 -               nl80211_send_scan_aborted(rdev, wdev);
2101 -       } else {
2102 -               if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
2103 -                       /* flush entries from previous scans */
2104 -                       spin_lock_bh(&rdev->bss_lock);
2105 -                       __cfg80211_bss_expire(rdev, request->scan_start);
2106 -                       spin_unlock_bh(&rdev->bss_lock);
2107 -               }
2108 -               nl80211_send_scan_done(rdev, wdev);
2109 +       if (!request->aborted &&
2110 +           request->flags & NL80211_SCAN_FLAG_FLUSH) {
2111 +               /* flush entries from previous scans */
2112 +               spin_lock_bh(&rdev->bss_lock);
2113 +               __cfg80211_bss_expire(rdev, request->scan_start);
2114 +               spin_unlock_bh(&rdev->bss_lock);
2115         }
2116  
2117 +       msg = nl80211_build_scan_msg(rdev, wdev, request->aborted);
2118 +
2119  #ifdef CPTCFG_CFG80211_WEXT
2120         if (wdev->netdev && !request->aborted) {
2121                 memset(&wrqu, 0, sizeof(wrqu));
2122 @@ -211,6 +216,11 @@ void ___cfg80211_scan_done(struct cfg802
2123  
2124         rdev->scan_req = NULL;
2125         kfree(request);
2126 +
2127 +       if (!send_message)
2128 +               rdev->scan_msg = msg;
2129 +       else
2130 +               nl80211_send_scan_result(rdev, msg);
2131  }
2132  
2133  void __cfg80211_scan_done(struct work_struct *wk)
2134 @@ -221,7 +231,7 @@ void __cfg80211_scan_done(struct work_st
2135                             scan_done_wk);
2136  
2137         rtnl_lock();
2138 -       ___cfg80211_scan_done(rdev);
2139 +       ___cfg80211_scan_done(rdev, true);
2140         rtnl_unlock();
2141  }
2142  
2143 @@ -1079,7 +1089,7 @@ int cfg80211_wext_siwscan(struct net_dev
2144         if (IS_ERR(rdev))
2145                 return PTR_ERR(rdev);
2146  
2147 -       if (rdev->scan_req) {
2148 +       if (rdev->scan_req || rdev->scan_msg) {
2149                 err = -EBUSY;
2150                 goto out;
2151         }
2152 @@ -1481,7 +1491,7 @@ int cfg80211_wext_giwscan(struct net_dev
2153         if (IS_ERR(rdev))
2154                 return PTR_ERR(rdev);
2155  
2156 -       if (rdev->scan_req)
2157 +       if (rdev->scan_req || rdev->scan_msg)
2158                 return -EAGAIN;
2159  
2160         res = ieee80211_scan_results(rdev, info, extra, data->length);
2161 --- a/net/wireless/sme.c
2162 +++ b/net/wireless/sme.c
2163 @@ -67,7 +67,7 @@ static int cfg80211_conn_scan(struct wir
2164         ASSERT_RDEV_LOCK(rdev);
2165         ASSERT_WDEV_LOCK(wdev);
2166  
2167 -       if (rdev->scan_req)
2168 +       if (rdev->scan_req || rdev->scan_msg)
2169                 return -EBUSY;
2170  
2171         if (wdev->conn->params.channel)
2172 --- a/net/mac80211/mlme.c
2173 +++ b/net/mac80211/mlme.c
2174 @@ -1001,7 +1001,6 @@ ieee80211_sta_process_chanswitch(struct 
2175         }
2176  
2177         ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
2178 -       sdata->vif.csa_active = true;
2179  
2180         mutex_lock(&local->chanctx_mtx);
2181         if (local->use_chanctx) {
2182 @@ -1039,6 +1038,7 @@ ieee80211_sta_process_chanswitch(struct 
2183         mutex_unlock(&local->chanctx_mtx);
2184  
2185         sdata->csa_chandef = csa_ie.chandef;
2186 +       sdata->vif.csa_active = true;
2187  
2188         if (csa_ie.mode)
2189                 ieee80211_stop_queues_by_reason(&local->hw,
2190 --- a/net/mac80211/chan.c
2191 +++ b/net/mac80211/chan.c
2192 @@ -196,6 +196,8 @@ static bool ieee80211_is_radar_required(
2193  {
2194         struct ieee80211_sub_if_data *sdata;
2195  
2196 +       lockdep_assert_held(&local->mtx);
2197 +
2198         rcu_read_lock();
2199         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
2200                 if (sdata->radar_required) {
2201 --- a/net/mac80211/ibss.c
2202 +++ b/net/mac80211/ibss.c
2203 @@ -294,7 +294,6 @@ static void __ieee80211_sta_join_ibss(st
2204         }
2205  
2206         mutex_lock(&local->mtx);
2207 -       ieee80211_vif_release_channel(sdata);
2208         if (ieee80211_vif_use_channel(sdata, &chandef,
2209                                       ifibss->fixed_channel ?
2210                                         IEEE80211_CHANCTX_SHARED :
2211 @@ -303,6 +302,7 @@ static void __ieee80211_sta_join_ibss(st
2212                 mutex_unlock(&local->mtx);
2213                 return;
2214         }
2215 +       sdata->radar_required = radar_required;
2216         mutex_unlock(&local->mtx);
2217  
2218         memcpy(ifibss->bssid, bssid, ETH_ALEN);
2219 @@ -318,7 +318,6 @@ static void __ieee80211_sta_join_ibss(st
2220         rcu_assign_pointer(ifibss->presp, presp);
2221         mgmt = (void *)presp->head;
2222  
2223 -       sdata->radar_required = radar_required;
2224         sdata->vif.bss_conf.enable_beacon = true;
2225         sdata->vif.bss_conf.beacon_int = beacon_int;
2226         sdata->vif.bss_conf.basic_rates = basic_rates;
2227 @@ -386,7 +385,7 @@ static void __ieee80211_sta_join_ibss(st
2228                                               presp->head_len, 0, GFP_KERNEL);
2229         cfg80211_put_bss(local->hw.wiphy, bss);
2230         netif_carrier_on(sdata->dev);
2231 -       cfg80211_ibss_joined(sdata->dev, ifibss->bssid, GFP_KERNEL);
2232 +       cfg80211_ibss_joined(sdata->dev, ifibss->bssid, chan, GFP_KERNEL);
2233  }
2234  
2235  static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
2236 @@ -802,6 +801,8 @@ ieee80211_ibss_process_chanswitch(struct
2237         int err;
2238         u32 sta_flags;
2239  
2240 +       sdata_assert_lock(sdata);
2241 +
2242         sta_flags = IEEE80211_STA_DISABLE_VHT;
2243         switch (ifibss->chandef.width) {
2244         case NL80211_CHAN_WIDTH_5:
2245 @@ -1471,6 +1472,11 @@ static void ieee80211_rx_mgmt_probe_req(
2246         memcpy(((struct ieee80211_mgmt *) skb->data)->da, mgmt->sa, ETH_ALEN);
2247         ibss_dbg(sdata, "Sending ProbeResp to %pM\n", mgmt->sa);
2248         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
2249 +
2250 +       /* avoid excessive retries for probe request to wildcard SSIDs */
2251 +       if (pos[1] == 0)
2252 +               IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_NO_ACK;
2253 +
2254         ieee80211_tx_skb(sdata, skb);
2255  }
2256  
2257 --- a/net/mac80211/mesh.c
2258 +++ b/net/mac80211/mesh.c
2259 @@ -872,6 +872,8 @@ ieee80211_mesh_process_chnswitch(struct 
2260         if (!ifmsh->mesh_id)
2261                 return false;
2262  
2263 +       sdata_assert_lock(sdata);
2264 +
2265         sta_flags = IEEE80211_STA_DISABLE_VHT;
2266         switch (sdata->vif.bss_conf.chandef.width) {
2267         case NL80211_CHAN_WIDTH_20_NOHT:
2268 --- a/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
2269 +++ b/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
2270 @@ -4658,6 +4658,7 @@ brcmf_notify_connect_status(struct brcmf
2271         struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
2272         struct net_device *ndev = ifp->ndev;
2273         struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2274 +       struct ieee80211_channel *chan;
2275         s32 err = 0;
2276  
2277         if (ifp->vif->mode == WL_MODE_AP) {
2278 @@ -4665,9 +4666,10 @@ brcmf_notify_connect_status(struct brcmf
2279         } else if (brcmf_is_linkup(e)) {
2280                 brcmf_dbg(CONN, "Linkup\n");
2281                 if (brcmf_is_ibssmode(ifp->vif)) {
2282 +                       chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
2283                         memcpy(profile->bssid, e->addr, ETH_ALEN);
2284                         wl_inform_ibss(cfg, ndev, e->addr);
2285 -                       cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2286 +                       cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
2287                         clear_bit(BRCMF_VIF_STATUS_CONNECTING,
2288                                   &ifp->vif->sme_state);
2289                         set_bit(BRCMF_VIF_STATUS_CONNECTED,
2290 --- a/drivers/net/wireless/libertas/cfg.c
2291 +++ b/drivers/net/wireless/libertas/cfg.c
2292 @@ -1766,7 +1766,8 @@ static void lbs_join_post(struct lbs_pri
2293         memcpy(priv->wdev->ssid, params->ssid, params->ssid_len);
2294         priv->wdev->ssid_len = params->ssid_len;
2295  
2296 -       cfg80211_ibss_joined(priv->dev, bssid, GFP_KERNEL);
2297 +       cfg80211_ibss_joined(priv->dev, bssid, params->chandef.chan,
2298 +                            GFP_KERNEL);
2299  
2300         /* TODO: consider doing this at MACREG_INT_CODE_LINK_SENSED time */
2301         priv->connect_status = LBS_CONNECTED;
2302 --- a/drivers/net/wireless/mwifiex/cfg80211.c
2303 +++ b/drivers/net/wireless/mwifiex/cfg80211.c
2304 @@ -1881,7 +1881,8 @@ mwifiex_cfg80211_join_ibss(struct wiphy 
2305                                      params->privacy);
2306  done:
2307         if (!ret) {
2308 -               cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid, GFP_KERNEL);
2309 +               cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid,
2310 +                                    params->chandef.chan, GFP_KERNEL);
2311                 dev_dbg(priv->adapter->dev,
2312                         "info: joined/created adhoc network with bssid"
2313                         " %pM successfully\n", priv->cfg_bssid);
2314 --- a/drivers/net/wireless/rndis_wlan.c
2315 +++ b/drivers/net/wireless/rndis_wlan.c
2316 @@ -2835,7 +2835,9 @@ static void rndis_wlan_do_link_up_work(s
2317                                         bssid, req_ie, req_ie_len,
2318                                         resp_ie, resp_ie_len, GFP_KERNEL);
2319         } else if (priv->infra_mode == NDIS_80211_INFRA_ADHOC)
2320 -               cfg80211_ibss_joined(usbdev->net, bssid, GFP_KERNEL);
2321 +               cfg80211_ibss_joined(usbdev->net, bssid,
2322 +                                    get_current_channel(usbdev, NULL),
2323 +                                    GFP_KERNEL);
2324  
2325         kfree(info);
2326  
2327 --- a/net/wireless/ibss.c
2328 +++ b/net/wireless/ibss.c
2329 @@ -14,7 +14,8 @@
2330  #include "rdev-ops.h"
2331  
2332  
2333 -void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid)
2334 +void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
2335 +                           struct ieee80211_channel *channel)
2336  {
2337         struct wireless_dev *wdev = dev->ieee80211_ptr;
2338         struct cfg80211_bss *bss;
2339 @@ -28,8 +29,7 @@ void __cfg80211_ibss_joined(struct net_d
2340         if (!wdev->ssid_len)
2341                 return;
2342  
2343 -       bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
2344 -                              wdev->ssid, wdev->ssid_len,
2345 +       bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, NULL, 0,
2346                                WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS);
2347  
2348         if (WARN_ON(!bss))
2349 @@ -54,21 +54,26 @@ void __cfg80211_ibss_joined(struct net_d
2350  #endif
2351  }
2352  
2353 -void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp)
2354 +void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
2355 +                         struct ieee80211_channel *channel, gfp_t gfp)
2356  {
2357         struct wireless_dev *wdev = dev->ieee80211_ptr;
2358         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
2359         struct cfg80211_event *ev;
2360         unsigned long flags;
2361  
2362 -       trace_cfg80211_ibss_joined(dev, bssid);
2363 +       trace_cfg80211_ibss_joined(dev, bssid, channel);
2364 +
2365 +       if (WARN_ON(!channel))
2366 +               return;
2367  
2368         ev = kzalloc(sizeof(*ev), gfp);
2369         if (!ev)
2370                 return;
2371  
2372         ev->type = EVENT_IBSS_JOINED;
2373 -       memcpy(ev->cr.bssid, bssid, ETH_ALEN);
2374 +       memcpy(ev->ij.bssid, bssid, ETH_ALEN);
2375 +       ev->ij.channel = channel;
2376  
2377         spin_lock_irqsave(&wdev->event_lock, flags);
2378         list_add_tail(&ev->list, &wdev->event_list);
2379 @@ -117,6 +122,7 @@ int __cfg80211_join_ibss(struct cfg80211
2380  
2381         wdev->ibss_fixed = params->channel_fixed;
2382         wdev->ibss_dfs_possible = params->userspace_handles_dfs;
2383 +       wdev->chandef = params->chandef;
2384  #ifdef CPTCFG_CFG80211_WEXT
2385         wdev->wext.ibss.chandef = params->chandef;
2386  #endif
2387 @@ -200,6 +206,7 @@ static void __cfg80211_clear_ibss(struct
2388  
2389         wdev->current_bss = NULL;
2390         wdev->ssid_len = 0;
2391 +       memset(&wdev->chandef, 0, sizeof(wdev->chandef));
2392  #ifdef CPTCFG_CFG80211_WEXT
2393         if (!nowext)
2394                 wdev->wext.ibss.ssid_len = 0;
2395 --- a/net/wireless/trace.h
2396 +++ b/net/wireless/trace.h
2397 @@ -2278,11 +2278,6 @@ DECLARE_EVENT_CLASS(cfg80211_rx_evt,
2398         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr))
2399  );
2400  
2401 -DEFINE_EVENT(cfg80211_rx_evt, cfg80211_ibss_joined,
2402 -       TP_PROTO(struct net_device *netdev, const u8 *addr),
2403 -       TP_ARGS(netdev, addr)
2404 -);
2405 -
2406  DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
2407         TP_PROTO(struct net_device *netdev, const u8 *addr),
2408         TP_ARGS(netdev, addr)
2409 @@ -2293,6 +2288,24 @@ DEFINE_EVENT(cfg80211_rx_evt, cfg80211_r
2410         TP_ARGS(netdev, addr)
2411  );
2412  
2413 +TRACE_EVENT(cfg80211_ibss_joined,
2414 +       TP_PROTO(struct net_device *netdev, const u8 *bssid,
2415 +                struct ieee80211_channel *channel),
2416 +       TP_ARGS(netdev, bssid, channel),
2417 +       TP_STRUCT__entry(
2418 +               NETDEV_ENTRY
2419 +               MAC_ENTRY(bssid)
2420 +               CHAN_ENTRY
2421 +       ),
2422 +       TP_fast_assign(
2423 +               NETDEV_ASSIGN;
2424 +               MAC_ASSIGN(bssid, bssid);
2425 +               CHAN_ASSIGN(channel);
2426 +       ),
2427 +       TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT,
2428 +                 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2429 +);
2430 +
2431  TRACE_EVENT(cfg80211_probe_status,
2432         TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
2433                  bool acked),
2434 --- a/net/wireless/util.c
2435 +++ b/net/wireless/util.c
2436 @@ -820,7 +820,8 @@ void cfg80211_process_wdev_events(struct
2437                                                 ev->dc.reason, true);
2438                         break;
2439                 case EVENT_IBSS_JOINED:
2440 -                       __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid);
2441 +                       __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid,
2442 +                                              ev->ij.channel);
2443                         break;
2444                 }
2445                 wdev_unlock(wdev);
2446 @@ -1356,7 +1357,7 @@ int cfg80211_can_use_iftype_chan(struct 
2447                  */
2448                 mutex_lock_nested(&wdev_iter->mtx, 1);
2449                 __acquire(wdev_iter->mtx);
2450 -               cfg80211_get_chan_state(wdev_iter, &ch, &chmode);
2451 +               cfg80211_get_chan_state(wdev_iter, &ch, &chmode, &radar_detect);
2452                 wdev_unlock(wdev_iter);
2453  
2454                 switch (chmode) {
2455 --- a/net/wireless/chan.c
2456 +++ b/net/wireless/chan.c
2457 @@ -642,7 +642,8 @@ int cfg80211_set_monitor_channel(struct 
2458  void
2459  cfg80211_get_chan_state(struct wireless_dev *wdev,
2460                         struct ieee80211_channel **chan,
2461 -                       enum cfg80211_chan_mode *chanmode)
2462 +                       enum cfg80211_chan_mode *chanmode,
2463 +                       u8 *radar_detect)
2464  {
2465         *chan = NULL;
2466         *chanmode = CHAN_MODE_UNDEFINED;
2467 @@ -660,6 +661,11 @@ cfg80211_get_chan_state(struct wireless_
2468                                      !wdev->ibss_dfs_possible)
2469                                   ? CHAN_MODE_SHARED
2470                                   : CHAN_MODE_EXCLUSIVE;
2471 +
2472 +                       /* consider worst-case - IBSS can try to return to the
2473 +                        * original user-specified channel as creator */
2474 +                       if (wdev->ibss_dfs_possible)
2475 +                               *radar_detect |= BIT(wdev->chandef.width);
2476                         return;
2477                 }
2478                 break;
2479 @@ -674,17 +680,26 @@ cfg80211_get_chan_state(struct wireless_
2480         case NL80211_IFTYPE_AP:
2481         case NL80211_IFTYPE_P2P_GO:
2482                 if (wdev->cac_started) {
2483 -                       *chan = wdev->channel;
2484 +                       *chan = wdev->chandef.chan;
2485                         *chanmode = CHAN_MODE_SHARED;
2486 +                       *radar_detect |= BIT(wdev->chandef.width);
2487                 } else if (wdev->beacon_interval) {
2488 -                       *chan = wdev->channel;
2489 +                       *chan = wdev->chandef.chan;
2490                         *chanmode = CHAN_MODE_SHARED;
2491 +
2492 +                       if (cfg80211_chandef_dfs_required(wdev->wiphy,
2493 +                                                         &wdev->chandef))
2494 +                               *radar_detect |= BIT(wdev->chandef.width);
2495                 }
2496                 return;
2497         case NL80211_IFTYPE_MESH_POINT:
2498                 if (wdev->mesh_id_len) {
2499 -                       *chan = wdev->channel;
2500 +                       *chan = wdev->chandef.chan;
2501                         *chanmode = CHAN_MODE_SHARED;
2502 +
2503 +                       if (cfg80211_chandef_dfs_required(wdev->wiphy,
2504 +                                                         &wdev->chandef))
2505 +                               *radar_detect |= BIT(wdev->chandef.width);
2506                 }
2507                 return;
2508         case NL80211_IFTYPE_MONITOR:
2509 --- a/net/wireless/mesh.c
2510 +++ b/net/wireless/mesh.c
2511 @@ -195,7 +195,7 @@ int __cfg80211_join_mesh(struct cfg80211
2512         if (!err) {
2513                 memcpy(wdev->ssid, setup->mesh_id, setup->mesh_id_len);
2514                 wdev->mesh_id_len = setup->mesh_id_len;
2515 -               wdev->channel = setup->chandef.chan;
2516 +               wdev->chandef = setup->chandef;
2517         }
2518  
2519         return err;
2520 @@ -244,7 +244,7 @@ int cfg80211_set_mesh_channel(struct cfg
2521                 err = rdev_libertas_set_mesh_channel(rdev, wdev->netdev,
2522                                                      chandef->chan);
2523                 if (!err)
2524 -                       wdev->channel = chandef->chan;
2525 +                       wdev->chandef = *chandef;
2526  
2527                 return err;
2528         }
2529 @@ -276,7 +276,7 @@ static int __cfg80211_leave_mesh(struct 
2530         err = rdev_leave_mesh(rdev, dev);
2531         if (!err) {
2532                 wdev->mesh_id_len = 0;
2533 -               wdev->channel = NULL;
2534 +               memset(&wdev->chandef, 0, sizeof(wdev->chandef));
2535                 rdev_set_qos_map(rdev, dev, NULL);
2536         }
2537  
2538 --- a/net/wireless/mlme.c
2539 +++ b/net/wireless/mlme.c
2540 @@ -772,7 +772,7 @@ void cfg80211_cac_event(struct net_devic
2541         if (WARN_ON(!wdev->cac_started))
2542                 return;
2543  
2544 -       if (WARN_ON(!wdev->channel))
2545 +       if (WARN_ON(!wdev->chandef.chan))
2546                 return;
2547  
2548         switch (event) {
2549 --- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
2550 +++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
2551 @@ -5065,6 +5065,10 @@ static u16 ar9003_hw_get_max_edge_power(
2552                         break;
2553                 }
2554         }
2555 +
2556 +       if (is2GHz && !twiceMaxEdgePower)
2557 +               twiceMaxEdgePower = 60;
2558 +
2559         return twiceMaxEdgePower;
2560  }
2561  
2562 --- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
2563 +++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
2564 @@ -23,10 +23,11 @@
2565  #define MAX_MEASUREMENT        MAX_IQCAL_MEASUREMENT
2566  #define MAX_MAG_DELTA  11
2567  #define MAX_PHS_DELTA  10
2568 +#define MAXIQCAL        3
2569  
2570  struct coeff {
2571 -       int mag_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT];
2572 -       int phs_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT];
2573 +       int mag_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT][MAXIQCAL];
2574 +       int phs_coeff[AR9300_MAX_CHAINS][MAX_MEASUREMENT][MAXIQCAL];
2575         int iqc_coeff[2];
2576  };
2577  
2578 @@ -800,7 +801,7 @@ static bool ar9003_hw_calc_iq_corr(struc
2579         if (q_q_coff > 63)
2580                 q_q_coff = 63;
2581  
2582 -       iqc_coeff[0] = (q_q_coff * 128) + q_i_coff;
2583 +       iqc_coeff[0] = (q_q_coff * 128) + (0x7f & q_i_coff);
2584  
2585         ath_dbg(common, CALIBRATE, "tx chain %d: iq corr coeff=%x\n",
2586                 chain_idx, iqc_coeff[0]);
2587 @@ -831,7 +832,7 @@ static bool ar9003_hw_calc_iq_corr(struc
2588         if (q_q_coff > 63)
2589                 q_q_coff = 63;
2590  
2591 -       iqc_coeff[1] = (q_q_coff * 128) + q_i_coff;
2592 +       iqc_coeff[1] = (q_q_coff * 128) + (0x7f & q_i_coff);
2593  
2594         ath_dbg(common, CALIBRATE, "rx chain %d: iq corr coeff=%x\n",
2595                 chain_idx, iqc_coeff[1]);
2596 @@ -839,7 +840,8 @@ static bool ar9003_hw_calc_iq_corr(struc
2597         return true;
2598  }
2599  
2600 -static void ar9003_hw_detect_outlier(int *mp_coeff, int nmeasurement,
2601 +static void ar9003_hw_detect_outlier(int mp_coeff[][MAXIQCAL],
2602 +                                    int nmeasurement,
2603                                      int max_delta)
2604  {
2605         int mp_max = -64, max_idx = 0;
2606 @@ -848,20 +850,20 @@ static void ar9003_hw_detect_outlier(int
2607  
2608         /* find min/max mismatch across all calibrated gains */
2609         for (i = 0; i < nmeasurement; i++) {
2610 -               if (mp_coeff[i] > mp_max) {
2611 -                       mp_max = mp_coeff[i];
2612 +               if (mp_coeff[i][0] > mp_max) {
2613 +                       mp_max = mp_coeff[i][0];
2614                         max_idx = i;
2615 -               } else if (mp_coeff[i] < mp_min) {
2616 -                       mp_min = mp_coeff[i];
2617 +               } else if (mp_coeff[i][0] < mp_min) {
2618 +                       mp_min = mp_coeff[i][0];
2619                         min_idx = i;
2620                 }
2621         }
2622  
2623         /* find average (exclude max abs value) */
2624         for (i = 0; i < nmeasurement; i++) {
2625 -               if ((abs(mp_coeff[i]) < abs(mp_max)) ||
2626 -                   (abs(mp_coeff[i]) < abs(mp_min))) {
2627 -                       mp_avg += mp_coeff[i];
2628 +               if ((abs(mp_coeff[i][0]) < abs(mp_max)) ||
2629 +                   (abs(mp_coeff[i][0]) < abs(mp_min))) {
2630 +                       mp_avg += mp_coeff[i][0];
2631                         mp_count++;
2632                 }
2633         }
2634 @@ -873,7 +875,7 @@ static void ar9003_hw_detect_outlier(int
2635         if (mp_count)
2636                 mp_avg /= mp_count;
2637         else
2638 -               mp_avg = mp_coeff[nmeasurement - 1];
2639 +               mp_avg = mp_coeff[nmeasurement - 1][0];
2640  
2641         /* detect outlier */
2642         if (abs(mp_max - mp_min) > max_delta) {
2643 @@ -882,15 +884,16 @@ static void ar9003_hw_detect_outlier(int
2644                 else
2645                         outlier_idx = min_idx;
2646  
2647 -               mp_coeff[outlier_idx] = mp_avg;
2648 +               mp_coeff[outlier_idx][0] = mp_avg;
2649         }
2650  }
2651  
2652 -static void ar9003_hw_tx_iqcal_load_avg_2_passes(struct ath_hw *ah,
2653 -                                                struct coeff *coeff,
2654 -                                                bool is_reusable)
2655 +static void ar9003_hw_tx_iq_cal_outlier_detection(struct ath_hw *ah,
2656 +                                                 struct coeff *coeff,
2657 +                                                 bool is_reusable)
2658  {
2659         int i, im, nmeasurement;
2660 +       int magnitude, phase;
2661         u32 tx_corr_coeff[MAX_MEASUREMENT][AR9300_MAX_CHAINS];
2662         struct ath9k_hw_cal_data *caldata = ah->caldata;
2663  
2664 @@ -920,21 +923,30 @@ static void ar9003_hw_tx_iqcal_load_avg_
2665                 if (nmeasurement > MAX_MEASUREMENT)
2666                         nmeasurement = MAX_MEASUREMENT;
2667  
2668 -               /* detect outlier only if nmeasurement > 1 */
2669 -               if (nmeasurement > 1) {
2670 -                       /* Detect magnitude outlier */
2671 -                       ar9003_hw_detect_outlier(coeff->mag_coeff[i],
2672 -                                       nmeasurement, MAX_MAG_DELTA);
2673 -
2674 -                       /* Detect phase outlier */
2675 -                       ar9003_hw_detect_outlier(coeff->phs_coeff[i],
2676 -                                       nmeasurement, MAX_PHS_DELTA);
2677 +               /*
2678 +                * Skip normal outlier detection for AR9550.
2679 +                */
2680 +               if (!AR_SREV_9550(ah)) {
2681 +                       /* detect outlier only if nmeasurement > 1 */
2682 +                       if (nmeasurement > 1) {
2683 +                               /* Detect magnitude outlier */
2684 +                               ar9003_hw_detect_outlier(coeff->mag_coeff[i],
2685 +                                                        nmeasurement,
2686 +                                                        MAX_MAG_DELTA);
2687 +
2688 +                               /* Detect phase outlier */
2689 +                               ar9003_hw_detect_outlier(coeff->phs_coeff[i],
2690 +                                                        nmeasurement,
2691 +                                                        MAX_PHS_DELTA);
2692 +                       }
2693                 }
2694  
2695                 for (im = 0; im < nmeasurement; im++) {
2696 +                       magnitude = coeff->mag_coeff[i][im][0];
2697 +                       phase = coeff->phs_coeff[i][im][0];
2698  
2699 -                       coeff->iqc_coeff[0] = (coeff->mag_coeff[i][im] & 0x7f) |
2700 -                               ((coeff->phs_coeff[i][im] & 0x7f) << 7);
2701 +                       coeff->iqc_coeff[0] =
2702 +                               (phase & 0x7f) | ((magnitude & 0x7f) << 7);
2703  
2704                         if ((im % 2) == 0)
2705                                 REG_RMW_FIELD(ah, tx_corr_coeff[im][i],
2706 @@ -991,7 +1003,63 @@ static bool ar9003_hw_tx_iq_cal_run(stru
2707         return true;
2708  }
2709  
2710 -static void ar9003_hw_tx_iq_cal_post_proc(struct ath_hw *ah, bool is_reusable)
2711 +static void __ar955x_tx_iq_cal_sort(struct ath_hw *ah,
2712 +                                   struct coeff *coeff,
2713 +                                   int i, int nmeasurement)
2714 +{
2715 +       struct ath_common *common = ath9k_hw_common(ah);
2716 +       int im, ix, iy, temp;
2717 +
2718 +       for (im = 0; im < nmeasurement; im++) {
2719 +               for (ix = 0; ix < MAXIQCAL - 1; ix++) {
2720 +                       for (iy = ix + 1; iy <= MAXIQCAL - 1; iy++) {
2721 +                               if (coeff->mag_coeff[i][im][iy] <
2722 +                                   coeff->mag_coeff[i][im][ix]) {
2723 +                                       temp = coeff->mag_coeff[i][im][ix];
2724 +                                       coeff->mag_coeff[i][im][ix] =
2725 +                                               coeff->mag_coeff[i][im][iy];
2726 +                                       coeff->mag_coeff[i][im][iy] = temp;
2727 +                               }
2728 +                               if (coeff->phs_coeff[i][im][iy] <
2729 +                                   coeff->phs_coeff[i][im][ix]) {
2730 +                                       temp = coeff->phs_coeff[i][im][ix];
2731 +                                       coeff->phs_coeff[i][im][ix] =
2732 +                                               coeff->phs_coeff[i][im][iy];
2733 +                                       coeff->phs_coeff[i][im][iy] = temp;
2734 +                               }
2735 +                       }
2736 +               }
2737 +               coeff->mag_coeff[i][im][0] = coeff->mag_coeff[i][im][MAXIQCAL / 2];
2738 +               coeff->phs_coeff[i][im][0] = coeff->phs_coeff[i][im][MAXIQCAL / 2];
2739 +
2740 +               ath_dbg(common, CALIBRATE,
2741 +                       "IQCAL: Median [ch%d][gain%d]: mag = %d phase = %d\n",
2742 +                       i, im,
2743 +                       coeff->mag_coeff[i][im][0],
2744 +                       coeff->phs_coeff[i][im][0]);
2745 +       }
2746 +}
2747 +
2748 +static bool ar955x_tx_iq_cal_median(struct ath_hw *ah,
2749 +                                   struct coeff *coeff,
2750 +                                   int iqcal_idx,
2751 +                                   int nmeasurement)
2752 +{
2753 +       int i;
2754 +
2755 +       if ((iqcal_idx + 1) != MAXIQCAL)
2756 +               return false;
2757 +
2758 +       for (i = 0; i < AR9300_MAX_CHAINS; i++) {
2759 +               __ar955x_tx_iq_cal_sort(ah, coeff, i, nmeasurement);
2760 +       }
2761 +
2762 +       return true;
2763 +}
2764 +
2765 +static void ar9003_hw_tx_iq_cal_post_proc(struct ath_hw *ah,
2766 +                                         int iqcal_idx,
2767 +                                         bool is_reusable)
2768  {
2769         struct ath_common *common = ath9k_hw_common(ah);
2770         const u32 txiqcal_status[AR9300_MAX_CHAINS] = {
2771 @@ -1004,10 +1072,11 @@ static void ar9003_hw_tx_iq_cal_post_pro
2772                 AR_PHY_CHAN_INFO_TAB_1,
2773                 AR_PHY_CHAN_INFO_TAB_2,
2774         };
2775 -       struct coeff coeff;
2776 +       static struct coeff coeff;
2777         s32 iq_res[6];
2778         int i, im, j;
2779 -       int nmeasurement;
2780 +       int nmeasurement = 0;
2781 +       bool outlier_detect = true;
2782  
2783         for (i = 0; i < AR9300_MAX_CHAINS; i++) {
2784                 if (!(ah->txchainmask & (1 << i)))
2785 @@ -1065,17 +1134,23 @@ static void ar9003_hw_tx_iq_cal_post_pro
2786                                 goto tx_iqcal_fail;
2787                         }
2788  
2789 -                       coeff.mag_coeff[i][im] = coeff.iqc_coeff[0] & 0x7f;
2790 -                       coeff.phs_coeff[i][im] =
2791 +                       coeff.phs_coeff[i][im][iqcal_idx] =
2792 +                               coeff.iqc_coeff[0] & 0x7f;
2793 +                       coeff.mag_coeff[i][im][iqcal_idx] =
2794                                 (coeff.iqc_coeff[0] >> 7) & 0x7f;
2795  
2796 -                       if (coeff.mag_coeff[i][im] > 63)
2797 -                               coeff.mag_coeff[i][im] -= 128;
2798 -                       if (coeff.phs_coeff[i][im] > 63)
2799 -                               coeff.phs_coeff[i][im] -= 128;
2800 +                       if (coeff.mag_coeff[i][im][iqcal_idx] > 63)
2801 +                               coeff.mag_coeff[i][im][iqcal_idx] -= 128;
2802 +                       if (coeff.phs_coeff[i][im][iqcal_idx] > 63)
2803 +                               coeff.phs_coeff[i][im][iqcal_idx] -= 128;
2804                 }
2805         }
2806 -       ar9003_hw_tx_iqcal_load_avg_2_passes(ah, &coeff, is_reusable);
2807 +
2808 +       if (AR_SREV_9550(ah))
2809 +               outlier_detect = ar955x_tx_iq_cal_median(ah, &coeff,
2810 +                                                        iqcal_idx, nmeasurement);
2811 +       if (outlier_detect)
2812 +               ar9003_hw_tx_iq_cal_outlier_detection(ah, &coeff, is_reusable);
2813  
2814         return;
2815  
2816 @@ -1409,7 +1484,7 @@ skip_tx_iqcal:
2817         }
2818  
2819         if (txiqcal_done)
2820 -               ar9003_hw_tx_iq_cal_post_proc(ah, is_reusable);
2821 +               ar9003_hw_tx_iq_cal_post_proc(ah, 0, is_reusable);
2822         else if (caldata && test_bit(TXIQCAL_DONE, &caldata->cal_flags))
2823                 ar9003_hw_tx_iq_cal_reload(ah);
2824  
2825 @@ -1455,14 +1530,38 @@ skip_tx_iqcal:
2826         return true;
2827  }
2828  
2829 +static bool do_ar9003_agc_cal(struct ath_hw *ah)
2830 +{
2831 +       struct ath_common *common = ath9k_hw_common(ah);
2832 +       bool status;
2833 +
2834 +       REG_WRITE(ah, AR_PHY_AGC_CONTROL,
2835 +                 REG_READ(ah, AR_PHY_AGC_CONTROL) |
2836 +                 AR_PHY_AGC_CONTROL_CAL);
2837 +
2838 +       status = ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
2839 +                              AR_PHY_AGC_CONTROL_CAL,
2840 +                              0, AH_WAIT_TIMEOUT);
2841 +       if (!status) {
2842 +               ath_dbg(common, CALIBRATE,
2843 +                       "offset calibration failed to complete in %d ms,"
2844 +                       "noisy environment?\n",
2845 +                       AH_WAIT_TIMEOUT / 1000);
2846 +               return false;
2847 +       }
2848 +
2849 +       return true;
2850 +}
2851 +
2852  static bool ar9003_hw_init_cal_soc(struct ath_hw *ah,
2853                                    struct ath9k_channel *chan)
2854  {
2855         struct ath_common *common = ath9k_hw_common(ah);
2856         struct ath9k_hw_cal_data *caldata = ah->caldata;
2857         bool txiqcal_done = false;
2858 -       bool is_reusable = true, status = true;
2859 +       bool status = true;
2860         bool run_agc_cal = false, sep_iq_cal = false;
2861 +       int i = 0;
2862  
2863         /* Use chip chainmask only for calibration */
2864         ar9003_hw_set_chain_masks(ah, ah->caps.rx_chainmask, ah->caps.tx_chainmask);
2865 @@ -1485,7 +1584,12 @@ static bool ar9003_hw_init_cal_soc(struc
2866          * AGC calibration. Specifically, AR9550 in SoC chips.
2867          */
2868         if (ah->enabled_cals & TX_IQ_ON_AGC_CAL) {
2869 -               txiqcal_done = true;
2870 +               if (REG_READ_FIELD(ah, AR_PHY_TX_IQCAL_CONTROL_0,
2871 +                                  AR_PHY_TX_IQCAL_CONTROL_0_ENABLE_TXIQ_CAL)) {
2872 +                               txiqcal_done = true;
2873 +               } else {
2874 +                       txiqcal_done = false;
2875 +               }
2876                 run_agc_cal = true;
2877         } else {
2878                 sep_iq_cal = true;
2879 @@ -1512,27 +1616,37 @@ skip_tx_iqcal:
2880                 if (AR_SREV_9330_11(ah))
2881                         ar9003_hw_manual_peak_cal(ah, 0, IS_CHAN_2GHZ(chan));
2882  
2883 -               /* Calibrate the AGC */
2884 -               REG_WRITE(ah, AR_PHY_AGC_CONTROL,
2885 -                         REG_READ(ah, AR_PHY_AGC_CONTROL) |
2886 -                         AR_PHY_AGC_CONTROL_CAL);
2887 -
2888 -               /* Poll for offset calibration complete */
2889 -               status = ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
2890 -                                      AR_PHY_AGC_CONTROL_CAL,
2891 -                                      0, AH_WAIT_TIMEOUT);
2892 -       }
2893 +               /*
2894 +                * For non-AR9550 chips, we just trigger AGC calibration
2895 +                * in the HW, poll for completion and then process
2896 +                * the results.
2897 +                *
2898 +                * For AR955x, we run it multiple times and use
2899 +                * median IQ correction.
2900 +                */
2901 +               if (!AR_SREV_9550(ah)) {
2902 +                       status = do_ar9003_agc_cal(ah);
2903 +                       if (!status)
2904 +                               return false;
2905  
2906 -       if (!status) {
2907 -               ath_dbg(common, CALIBRATE,
2908 -                       "offset calibration failed to complete in %d ms; noisy environment?\n",
2909 -                       AH_WAIT_TIMEOUT / 1000);
2910 -               return false;
2911 +                       if (txiqcal_done)
2912 +                               ar9003_hw_tx_iq_cal_post_proc(ah, 0, false);
2913 +               } else {
2914 +                       if (!txiqcal_done) {
2915 +                               status = do_ar9003_agc_cal(ah);
2916 +                               if (!status)
2917 +                                       return false;
2918 +                       } else {
2919 +                               for (i = 0; i < MAXIQCAL; i++) {
2920 +                                       status = do_ar9003_agc_cal(ah);
2921 +                                       if (!status)
2922 +                                               return false;
2923 +                                       ar9003_hw_tx_iq_cal_post_proc(ah, i, false);
2924 +                               }
2925 +                       }
2926 +               }
2927         }
2928  
2929 -       if (txiqcal_done)
2930 -               ar9003_hw_tx_iq_cal_post_proc(ah, is_reusable);
2931 -
2932         /* Revert chainmask to runtime parameters */
2933         ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask);
2934  
2935 --- a/drivers/net/wireless/rtl818x/rtl8187/rtl8187.h
2936 +++ b/drivers/net/wireless/rtl818x/rtl8187/rtl8187.h
2937 @@ -15,6 +15,8 @@
2938  #ifndef RTL8187_H
2939  #define RTL8187_H
2940  
2941 +#include <linux/cache.h>
2942 +
2943  #include "rtl818x.h"
2944  #include "leds.h"
2945  
2946 @@ -139,7 +141,10 @@ struct rtl8187_priv {
2947         u8 aifsn[4];
2948         u8 rfkill_mask;
2949         struct {
2950 -               __le64 buf;
2951 +               union {
2952 +                       __le64 buf;
2953 +                       u8 dummy1[L1_CACHE_BYTES];
2954 +               } ____cacheline_aligned;
2955                 struct sk_buff_head queue;
2956         } b_tx_status; /* This queue is used by both -b and non-b devices */
2957         struct mutex io_mutex;
2958 @@ -147,7 +152,8 @@ struct rtl8187_priv {
2959                 u8 bits8;
2960                 __le16 bits16;
2961                 __le32 bits32;
2962 -       } *io_dmabuf;
2963 +               u8 dummy2[L1_CACHE_BYTES];
2964 +       } *io_dmabuf ____cacheline_aligned;
2965         bool rfkill_off;
2966         u16 seqno;
2967  };
2968 --- a/net/mac80211/wme.c
2969 +++ b/net/mac80211/wme.c
2970 @@ -154,6 +154,11 @@ u16 ieee80211_select_queue(struct ieee80
2971                 return IEEE80211_AC_BE;
2972         }
2973  
2974 +       if (skb->protocol == sdata->control_port_protocol) {
2975 +               skb->priority = 7;
2976 +               return ieee80211_downgrade_queue(sdata, skb);
2977 +       }
2978 +
2979         /* use the data classifier to determine what 802.1d tag the
2980          * data frame has */
2981         rcu_read_lock();
2982 --- a/drivers/net/wireless/ath/ath9k/xmit.c
2983 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
2984 @@ -1444,14 +1444,16 @@ void ath_tx_aggr_sleep(struct ieee80211_
2985         for (tidno = 0, tid = &an->tid[tidno];
2986              tidno < IEEE80211_NUM_TIDS; tidno++, tid++) {
2987  
2988 -               if (!tid->sched)
2989 -                       continue;
2990 -
2991                 ac = tid->ac;
2992                 txq = ac->txq;
2993  
2994                 ath_txq_lock(sc, txq);
2995  
2996 +               if (!tid->sched) {
2997 +                       ath_txq_unlock(sc, txq);
2998 +                       continue;
2999 +               }
3000 +
3001                 buffered = ath_tid_has_buffered(tid);
3002  
3003                 tid->sched = false;
3004 --- a/drivers/net/wireless/ath/ath9k/init.c
3005 +++ b/drivers/net/wireless/ath/ath9k/init.c
3006 @@ -943,6 +943,7 @@ static void ath9k_set_hw_capab(struct at
3007         hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3008         hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_5_10_MHZ;
3009         hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
3010 +       hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3011  
3012         hw->queues = 4;
3013         hw->max_rates = 4;
3014 --- a/net/mac80211/ieee80211_i.h
3015 +++ b/net/mac80211/ieee80211_i.h
3016 @@ -1700,14 +1700,8 @@ void ieee80211_stop_queue_by_reason(stru
3017  void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue);
3018  void ieee80211_add_pending_skb(struct ieee80211_local *local,
3019                                struct sk_buff *skb);
3020 -void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
3021 -                                  struct sk_buff_head *skbs,
3022 -                                  void (*fn)(void *data), void *data);
3023 -static inline void ieee80211_add_pending_skbs(struct ieee80211_local *local,
3024 -                                             struct sk_buff_head *skbs)
3025 -{
3026 -       ieee80211_add_pending_skbs_fn(local, skbs, NULL, NULL);
3027 -}
3028 +void ieee80211_add_pending_skbs(struct ieee80211_local *local,
3029 +                               struct sk_buff_head *skbs);
3030  void ieee80211_flush_queues(struct ieee80211_local *local,
3031                             struct ieee80211_sub_if_data *sdata);
3032  
3033 --- a/net/mac80211/sta_info.c
3034 +++ b/net/mac80211/sta_info.c
3035 @@ -91,7 +91,7 @@ static int sta_info_hash_del(struct ieee
3036         return -ENOENT;
3037  }
3038  
3039 -static void cleanup_single_sta(struct sta_info *sta)
3040 +static void __cleanup_single_sta(struct sta_info *sta)
3041  {
3042         int ac, i;
3043         struct tid_ampdu_tx *tid_tx;
3044 @@ -99,7 +99,8 @@ static void cleanup_single_sta(struct st
3045         struct ieee80211_local *local = sdata->local;
3046         struct ps_data *ps;
3047  
3048 -       if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
3049 +       if (test_sta_flag(sta, WLAN_STA_PS_STA) ||
3050 +           test_sta_flag(sta, WLAN_STA_PS_DRIVER)) {
3051                 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
3052                     sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
3053                         ps = &sdata->bss->ps;
3054 @@ -109,6 +110,7 @@ static void cleanup_single_sta(struct st
3055                         return;
3056  
3057                 clear_sta_flag(sta, WLAN_STA_PS_STA);
3058 +               clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
3059  
3060                 atomic_dec(&ps->num_sta_ps);
3061                 sta_info_recalc_tim(sta);
3062 @@ -139,7 +141,14 @@ static void cleanup_single_sta(struct st
3063                 ieee80211_purge_tx_queue(&local->hw, &tid_tx->pending);
3064                 kfree(tid_tx);
3065         }
3066 +}
3067  
3068 +static void cleanup_single_sta(struct sta_info *sta)
3069 +{
3070 +       struct ieee80211_sub_if_data *sdata = sta->sdata;
3071 +       struct ieee80211_local *local = sdata->local;
3072 +
3073 +       __cleanup_single_sta(sta);
3074         sta_info_free(local, sta);
3075  }
3076  
3077 @@ -330,6 +339,7 @@ struct sta_info *sta_info_alloc(struct i
3078         rcu_read_unlock();
3079  
3080         spin_lock_init(&sta->lock);
3081 +       spin_lock_init(&sta->ps_lock);
3082         INIT_WORK(&sta->drv_unblock_wk, sta_unblock);
3083         INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work);
3084         mutex_init(&sta->ampdu_mlme.mtx);
3085 @@ -487,21 +497,26 @@ static int sta_info_insert_finish(struct
3086                 goto out_err;
3087         }
3088  
3089 -       /* notify driver */
3090 -       err = sta_info_insert_drv_state(local, sdata, sta);
3091 -       if (err)
3092 -               goto out_err;
3093 -
3094         local->num_sta++;
3095         local->sta_generation++;
3096         smp_mb();
3097  
3098 +       /* simplify things and don't accept BA sessions yet */
3099 +       set_sta_flag(sta, WLAN_STA_BLOCK_BA);
3100 +
3101         /* make the station visible */
3102         sta_info_hash_add(local, sta);
3103  
3104         list_add_rcu(&sta->list, &local->sta_list);
3105  
3106 +       /* notify driver */
3107 +       err = sta_info_insert_drv_state(local, sdata, sta);
3108 +       if (err)
3109 +               goto out_remove;
3110 +
3111         set_sta_flag(sta, WLAN_STA_INSERTED);
3112 +       /* accept BA sessions now */
3113 +       clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
3114  
3115         ieee80211_recalc_min_chandef(sdata);
3116         ieee80211_sta_debugfs_add(sta);
3117 @@ -522,6 +537,12 @@ static int sta_info_insert_finish(struct
3118                 mesh_accept_plinks_update(sdata);
3119  
3120         return 0;
3121 + out_remove:
3122 +       sta_info_hash_del(local, sta);
3123 +       list_del_rcu(&sta->list);
3124 +       local->num_sta--;
3125 +       synchronize_net();
3126 +       __cleanup_single_sta(sta);
3127   out_err:
3128         mutex_unlock(&local->sta_mtx);
3129         rcu_read_lock();
3130 @@ -1071,10 +1092,14 @@ struct ieee80211_sta *ieee80211_find_sta
3131  }
3132  EXPORT_SYMBOL(ieee80211_find_sta);
3133  
3134 -static void clear_sta_ps_flags(void *_sta)
3135 +/* powersave support code */
3136 +void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
3137  {
3138 -       struct sta_info *sta = _sta;
3139         struct ieee80211_sub_if_data *sdata = sta->sdata;
3140 +       struct ieee80211_local *local = sdata->local;
3141 +       struct sk_buff_head pending;
3142 +       int filtered = 0, buffered = 0, ac;
3143 +       unsigned long flags;
3144         struct ps_data *ps;
3145  
3146         if (sdata->vif.type == NL80211_IFTYPE_AP ||
3147 @@ -1085,20 +1110,6 @@ static void clear_sta_ps_flags(void *_st
3148         else
3149                 return;
3150  
3151 -       clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
3152 -       if (test_and_clear_sta_flag(sta, WLAN_STA_PS_STA))
3153 -               atomic_dec(&ps->num_sta_ps);
3154 -}
3155 -
3156 -/* powersave support code */
3157 -void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
3158 -{
3159 -       struct ieee80211_sub_if_data *sdata = sta->sdata;
3160 -       struct ieee80211_local *local = sdata->local;
3161 -       struct sk_buff_head pending;
3162 -       int filtered = 0, buffered = 0, ac;
3163 -       unsigned long flags;
3164 -
3165         clear_sta_flag(sta, WLAN_STA_SP);
3166  
3167         BUILD_BUG_ON(BITS_TO_LONGS(IEEE80211_NUM_TIDS) > 1);
3168 @@ -1109,6 +1120,8 @@ void ieee80211_sta_ps_deliver_wakeup(str
3169  
3170         skb_queue_head_init(&pending);
3171  
3172 +       /* sync with ieee80211_tx_h_unicast_ps_buf */
3173 +       spin_lock(&sta->ps_lock);
3174         /* Send all buffered frames to the station */
3175         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
3176                 int count = skb_queue_len(&pending), tmp;
3177 @@ -1127,7 +1140,12 @@ void ieee80211_sta_ps_deliver_wakeup(str
3178                 buffered += tmp - count;
3179         }
3180  
3181 -       ieee80211_add_pending_skbs_fn(local, &pending, clear_sta_ps_flags, sta);
3182 +       ieee80211_add_pending_skbs(local, &pending);
3183 +       clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
3184 +       clear_sta_flag(sta, WLAN_STA_PS_STA);
3185 +       spin_unlock(&sta->ps_lock);
3186 +
3187 +       atomic_dec(&ps->num_sta_ps);
3188  
3189         /* This station just woke up and isn't aware of our SMPS state */
3190         if (!ieee80211_smps_is_restrictive(sta->known_smps_mode,
3191 --- a/net/mac80211/sta_info.h
3192 +++ b/net/mac80211/sta_info.h
3193 @@ -267,6 +267,7 @@ struct ieee80211_tx_latency_stat {
3194   * @drv_unblock_wk: used for driver PS unblocking
3195   * @listen_interval: listen interval of this station, when we're acting as AP
3196   * @_flags: STA flags, see &enum ieee80211_sta_info_flags, do not use directly
3197 + * @ps_lock: used for powersave (when mac80211 is the AP) related locking
3198   * @ps_tx_buf: buffers (per AC) of frames to transmit to this station
3199   *     when it leaves power saving state or polls
3200   * @tx_filtered: buffers (per AC) of frames we already tried to
3201 @@ -356,10 +357,8 @@ struct sta_info {
3202         /* use the accessors defined below */
3203         unsigned long _flags;
3204  
3205 -       /*
3206 -        * STA powersave frame queues, no more than the internal
3207 -        * locking required.
3208 -        */
3209 +       /* STA powersave lock and frame queues */
3210 +       spinlock_t ps_lock;
3211         struct sk_buff_head ps_tx_buf[IEEE80211_NUM_ACS];
3212         struct sk_buff_head tx_filtered[IEEE80211_NUM_ACS];
3213         unsigned long driver_buffered_tids;
3214 --- a/net/mac80211/util.c
3215 +++ b/net/mac80211/util.c
3216 @@ -435,9 +435,8 @@ void ieee80211_add_pending_skb(struct ie
3217         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
3218  }
3219  
3220 -void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
3221 -                                  struct sk_buff_head *skbs,
3222 -                                  void (*fn)(void *data), void *data)
3223 +void ieee80211_add_pending_skbs(struct ieee80211_local *local,
3224 +                               struct sk_buff_head *skbs)
3225  {
3226         struct ieee80211_hw *hw = &local->hw;
3227         struct sk_buff *skb;
3228 @@ -461,9 +460,6 @@ void ieee80211_add_pending_skbs_fn(struc
3229                 __skb_queue_tail(&local->pending[queue], skb);
3230         }
3231  
3232 -       if (fn)
3233 -               fn(data);
3234 -
3235         for (i = 0; i < hw->queues; i++)
3236                 __ieee80211_wake_queue(hw, i,
3237                         IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
3238 --- a/net/wireless/reg.c
3239 +++ b/net/wireless/reg.c
3240 @@ -1700,7 +1700,7 @@ static void reg_process_hint(struct regu
3241                 return;
3242         case NL80211_REGDOM_SET_BY_USER:
3243                 treatment = reg_process_hint_user(reg_request);
3244 -               if (treatment == REG_REQ_OK ||
3245 +               if (treatment == REG_REQ_IGNORE ||
3246                     treatment == REG_REQ_ALREADY_SET)
3247                         return;
3248                 schedule_delayed_work(&reg_timeout, msecs_to_jiffies(3142));
3249 --- a/drivers/net/wireless/ath/ath9k/debug.c
3250 +++ b/drivers/net/wireless/ath/ath9k/debug.c
3251 @@ -866,6 +866,12 @@ static ssize_t read_file_reset(struct fi
3252                          "%17s: %2d\n", "PLL RX Hang",
3253                          sc->debug.stats.reset[RESET_TYPE_PLL_HANG]);
3254         len += scnprintf(buf + len, sizeof(buf) - len,
3255 +                        "%17s: %2d\n", "MAC Hang",
3256 +                        sc->debug.stats.reset[RESET_TYPE_MAC_HANG]);
3257 +       len += scnprintf(buf + len, sizeof(buf) - len,
3258 +                        "%17s: %2d\n", "Stuck Beacon",
3259 +                        sc->debug.stats.reset[RESET_TYPE_BEACON_STUCK]);
3260 +       len += scnprintf(buf + len, sizeof(buf) - len,
3261                          "%17s: %2d\n", "MCI Reset",
3262                          sc->debug.stats.reset[RESET_TYPE_MCI]);
3263