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