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

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