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