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

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