ipv4: flush route cache after change accept_local
[linux-2.6.git] / net / mac80211 / scan.c
index e091cbc..6f09eca 100644 (file)
  * published by the Free Software Foundation.
  */
 
-/* TODO: figure out how to avoid that the "current BSS" expires */
-
-#include <linux/wireless.h>
 #include <linux/if_arp.h>
 #include <linux/rtnetlink.h>
+#include <linux/pm_qos_params.h>
+#include <net/sch_generic.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 
 #include "ieee80211_i.h"
@@ -31,16 +31,19 @@ struct ieee80211_bss *
 ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
                     u8 *ssid, u8 ssid_len)
 {
-       return (void *)cfg80211_get_bss(local->hw.wiphy,
-                                       ieee80211_get_channel(local->hw.wiphy,
-                                                             freq),
-                                       bssid, ssid, ssid_len,
-                                       0, 0);
+       struct cfg80211_bss *cbss;
+
+       cbss = cfg80211_get_bss(local->hw.wiphy,
+                               ieee80211_get_channel(local->hw.wiphy, freq),
+                               bssid, ssid, ssid_len, 0, 0);
+       if (!cbss)
+               return NULL;
+       return (void *)cbss->priv;
 }
 
 static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
 {
-       struct ieee80211_bss *bss = (void *)cbss;
+       struct ieee80211_bss *bss = (void *)cbss->priv;
 
        kfree(bss_mesh_id(bss));
        kfree(bss_mesh_cfg(bss));
@@ -49,7 +52,26 @@ static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
 void ieee80211_rx_bss_put(struct ieee80211_local *local,
                          struct ieee80211_bss *bss)
 {
-       cfg80211_put_bss((struct cfg80211_bss *)bss);
+       if (!bss)
+               return;
+       cfg80211_put_bss(container_of((void *)bss, struct cfg80211_bss, priv));
+}
+
+static bool is_uapsd_supported(struct ieee802_11_elems *elems)
+{
+       u8 qos_info;
+
+       if (elems->wmm_info && elems->wmm_info_len == 7
+           && elems->wmm_info[5] == 1)
+               qos_info = elems->wmm_info[6];
+       else if (elems->wmm_param && elems->wmm_param_len == 24
+                && elems->wmm_param[5] == 1)
+               qos_info = elems->wmm_param[6];
+       else
+               /* no valid wmm information or parameter element found */
+               return false;
+
+       return qos_info & IEEE80211_WMM_IE_AP_QOSINFO_UAPSD;
 }
 
 struct ieee80211_bss *
@@ -61,8 +83,9 @@ ieee80211_bss_info_update(struct ieee80211_local *local,
                          struct ieee80211_channel *channel,
                          bool beacon)
 {
+       struct cfg80211_bss *cbss;
        struct ieee80211_bss *bss;
-       int clen;
+       int clen, srlen;
        s32 signal = 0;
 
        if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
@@ -70,13 +93,14 @@ ieee80211_bss_info_update(struct ieee80211_local *local,
        else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
                signal = (rx_status->signal * 100) / local->hw.max_signal;
 
-       bss = (void *)cfg80211_inform_bss_frame(local->hw.wiphy, channel,
-                                               mgmt, len, signal, GFP_ATOMIC);
+       cbss = cfg80211_inform_bss_frame(local->hw.wiphy, channel,
+                                        mgmt, len, signal, GFP_ATOMIC);
 
-       if (!bss)
+       if (!cbss)
                return NULL;
 
-       bss->cbss.free_priv = ieee80211_rx_bss_free;
+       cbss->free_priv = ieee80211_rx_bss_free;
+       bss = (void *)cbss->priv;
 
        /* save the ERP value so that it is available at association time */
        if (elems->erp_info && elems->erp_info_len >= 1) {
@@ -90,29 +114,31 @@ ieee80211_bss_info_update(struct ieee80211_local *local,
                bss->dtim_period = tim_ie->dtim_period;
        }
 
-       /* set default value for buggy APs */
-       if (!elems->tim || bss->dtim_period == 0)
+       /* If the beacon had no TIM IE, or it was invalid, use 1 */
+       if (beacon && !bss->dtim_period)
                bss->dtim_period = 1;
 
-       bss->supp_rates_len = 0;
+       /* replace old supported rates if we get new values */
+       srlen = 0;
        if (elems->supp_rates) {
-               clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
+               clen = IEEE80211_MAX_SUPP_RATES;
                if (clen > elems->supp_rates_len)
                        clen = elems->supp_rates_len;
-               memcpy(&bss->supp_rates[bss->supp_rates_len], elems->supp_rates,
-                      clen);
-               bss->supp_rates_len += clen;
+               memcpy(bss->supp_rates, elems->supp_rates, clen);
+               srlen += clen;
        }
        if (elems->ext_supp_rates) {
-               clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
+               clen = IEEE80211_MAX_SUPP_RATES - srlen;
                if (clen > elems->ext_supp_rates_len)
                        clen = elems->ext_supp_rates_len;
-               memcpy(&bss->supp_rates[bss->supp_rates_len],
-                      elems->ext_supp_rates, clen);
-               bss->supp_rates_len += clen;
+               memcpy(bss->supp_rates + srlen, elems->ext_supp_rates, clen);
+               srlen += clen;
        }
+       if (srlen)
+               bss->supp_rates_len = srlen;
 
        bss->wmm_used = elems->wmm_param || elems->wmm_info;
+       bss->uapsd_supported = is_uapsd_supported(elems);
 
        if (!beacon)
                bss->last_probe_resp = jiffies;
@@ -144,12 +170,12 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
                return RX_CONTINUE;
 
        if (skb->len < 24)
-               return RX_DROP_MONITOR;
+               return RX_CONTINUE;
 
        presp = ieee80211_is_probe_resp(fc);
        if (presp) {
                /* ignore ProbeResp to foreign address */
-               if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
+               if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN))
                        return RX_DROP_MONITOR;
 
                presp = true;
@@ -170,7 +196,8 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
        ieee802_11_parse_elems(elements, skb->len - baselen, &elems);
 
        if (elems.ds_params && elems.ds_params_len == 1)
-               freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
+               freq = ieee80211_channel_to_frequency(elems.ds_params[0],
+                                                     rx_status->band);
        else
                freq = rx_status->freq;
 
@@ -185,158 +212,134 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
        if (bss)
                ieee80211_rx_bss_put(sdata->local, bss);
 
+       /* If we are on-operating-channel, and this packet is for the
+        * current channel, pass the pkt on up the stack so that
+        * the rest of the stack can make use of it.
+        */
+       if (ieee80211_cfg_on_oper_channel(sdata->local)
+           && (channel == sdata->local->oper_channel))
+               return RX_CONTINUE;
+
        dev_kfree_skb(skb);
        return RX_QUEUED;
 }
 
-/*
- * inform AP that we will go to sleep so that it will buffer the frames
- * while we scan
- */
-static void ieee80211_scan_ps_enable(struct ieee80211_sub_if_data *sdata)
+/* return false if no more work */
+static bool ieee80211_prep_hw_scan(struct ieee80211_local *local)
 {
-       struct ieee80211_local *local = sdata->local;
-       bool ps = false;
+       struct cfg80211_scan_request *req = local->scan_req;
+       enum ieee80211_band band;
+       int i, ielen, n_chans;
 
-       /* FIXME: what to do when local->pspolling is true? */
-
-       del_timer_sync(&local->dynamic_ps_timer);
-       cancel_work_sync(&local->dynamic_ps_enable_work);
-
-       if (local->hw.conf.flags & IEEE80211_CONF_PS) {
-               ps = true;
-               local->hw.conf.flags &= ~IEEE80211_CONF_PS;
-               ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
-       }
+       do {
+               if (local->hw_scan_band == IEEE80211_NUM_BANDS)
+                       return false;
+
+               band = local->hw_scan_band;
+               n_chans = 0;
+               for (i = 0; i < req->n_channels; i++) {
+                       if (req->channels[i]->band == band) {
+                               local->hw_scan_req->channels[n_chans] =
+                                                       req->channels[i];
+                               n_chans++;
+                       }
+               }
 
-       if (!ps || !(local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK))
-               /*
-                * If power save was enabled, no need to send a nullfunc
-                * frame because AP knows that we are sleeping. But if the
-                * hardware is creating the nullfunc frame for power save
-                * status (ie. IEEE80211_HW_PS_NULLFUNC_STACK is not
-                * enabled) and power save was enabled, the firmware just
-                * sent a null frame with power save disabled. So we need
-                * to send a new nullfunc frame to inform the AP that we
-                * are again sleeping.
-                */
-               ieee80211_send_nullfunc(local, sdata, 1);
-}
+               local->hw_scan_band++;
+       } while (!n_chans);
 
-/* inform AP that we are awake again, unless power save is enabled */
-static void ieee80211_scan_ps_disable(struct ieee80211_sub_if_data *sdata)
-{
-       struct ieee80211_local *local = sdata->local;
+       local->hw_scan_req->n_channels = n_chans;
 
-       if (!local->ps_sdata)
-               ieee80211_send_nullfunc(local, sdata, 0);
-       else {
-               /*
-                * In !IEEE80211_HW_PS_NULLFUNC_STACK case the hardware
-                * will send a nullfunc frame with the powersave bit set
-                * even though the AP already knows that we are sleeping.
-                * This could be avoided by sending a null frame with power
-                * save bit disabled before enabling the power save, but
-                * this doesn't gain anything.
-                *
-                * When IEEE80211_HW_PS_NULLFUNC_STACK is enabled, no need
-                * to send a nullfunc frame because AP already knows that
-                * we are sleeping, let's just enable power save mode in
-                * hardware.
-                */
-               local->hw.conf.flags |= IEEE80211_CONF_PS;
-               ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
-       }
-}
+       ielen = ieee80211_build_preq_ies(local, (u8 *)local->hw_scan_req->ie,
+                                        req->ie, req->ie_len, band,
+                                        req->rates[band], 0);
+       local->hw_scan_req->ie_len = ielen;
 
-static void ieee80211_restore_scan_ies(struct ieee80211_local *local)
-{
-       kfree(local->scan_req->ie);
-       local->scan_req->ie = local->orig_ies;
-       local->scan_req->ie_len = local->orig_ies_len;
+       return true;
 }
 
-void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
+static void __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted,
+                                      bool was_hw_scan)
 {
        struct ieee80211_local *local = hw_to_local(hw);
-       struct ieee80211_sub_if_data *sdata;
-       bool was_hw_scan;
+       bool on_oper_chan;
+       bool enable_beacons = false;
 
-       mutex_lock(&local->scan_mtx);
+       lockdep_assert_held(&local->mtx);
 
-       if (WARN_ON(!local->scanning)) {
-               mutex_unlock(&local->scan_mtx);
-               return;
-       }
+       /*
+        * It's ok to abort a not-yet-running scan (that
+        * we have one at all will be verified by checking
+        * local->scan_req next), but not to complete it
+        * successfully.
+        */
+       if (WARN_ON(!local->scanning && !aborted))
+               aborted = true;
 
-       if (WARN_ON(!local->scan_req)) {
-               mutex_unlock(&local->scan_mtx);
+       if (WARN_ON(!local->scan_req))
                return;
+
+       if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
+               int rc = drv_hw_scan(local, local->scan_sdata, local->hw_scan_req);
+               if (rc == 0)
+                       return;
        }
 
-       if (test_bit(SCAN_HW_SCANNING, &local->scanning))
-               ieee80211_restore_scan_ies(local);
+       kfree(local->hw_scan_req);
+       local->hw_scan_req = NULL;
 
        if (local->scan_req != local->int_scan_req)
                cfg80211_scan_done(local->scan_req, aborted);
        local->scan_req = NULL;
+       local->scan_sdata = NULL;
 
-       was_hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
        local->scanning = 0;
        local->scan_channel = NULL;
 
-       /* we only have to protect scan_req and hw/sw scan */
-       mutex_unlock(&local->scan_mtx);
-
-       ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
-       if (was_hw_scan)
-               goto done;
+       on_oper_chan = ieee80211_cfg_on_oper_channel(local);
 
-       spin_lock_bh(&local->filter_lock);
-       local->filter_flags &= ~FIF_BCN_PRBRESP_PROMISC;
-       drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
-                            &local->filter_flags,
-                            local->mc_count,
-                            local->mc_list);
-       spin_unlock_bh(&local->filter_lock);
-
-       drv_sw_scan_complete(local);
-
-       mutex_lock(&local->iflist_mtx);
-       list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
-                       continue;
-
-               /* Tell AP we're back */
-               if (sdata->vif.type == NL80211_IFTYPE_STATION) {
-                       if (sdata->u.mgd.associated) {
-                               ieee80211_scan_ps_disable(sdata);
-                               netif_tx_wake_all_queues(sdata->dev);
-                       }
-               } else
-                       netif_tx_wake_all_queues(sdata->dev);
-
-               /* re-enable beaconing */
-               if (sdata->vif.type == NL80211_IFTYPE_AP ||
-                   sdata->vif.type == NL80211_IFTYPE_ADHOC ||
-                   sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
-                       ieee80211_bss_info_change_notify(
-                               sdata, BSS_CHANGED_BEACON_ENABLED);
+       if (was_hw_scan || !on_oper_chan)
+               ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
+       else
+               /* Set power back to normal operating levels. */
+               ieee80211_hw_config(local, 0);
+
+       if (!was_hw_scan) {
+               bool on_oper_chan2;
+               ieee80211_configure_filter(local);
+               drv_sw_scan_complete(local);
+               on_oper_chan2 = ieee80211_cfg_on_oper_channel(local);
+               /* We should always be on-channel at this point. */
+               WARN_ON(!on_oper_chan2);
+               if (on_oper_chan2 && (on_oper_chan != on_oper_chan2))
+                       enable_beacons = true;
+
+               ieee80211_offchannel_return(local, enable_beacons, true);
        }
-       mutex_unlock(&local->iflist_mtx);
 
- done:
        ieee80211_recalc_idle(local);
+
        ieee80211_mlme_notify_scan_completed(local);
        ieee80211_ibss_notify_scan_completed(local);
        ieee80211_mesh_notify_scan_completed(local);
+       ieee80211_queue_work(&local->hw, &local->work_work);
+}
+
+void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
+{
+       struct ieee80211_local *local = hw_to_local(hw);
+
+       trace_api_scan_completed(local, aborted);
+
+       set_bit(SCAN_COMPLETED, &local->scanning);
+       if (aborted)
+               set_bit(SCAN_ABORTED, &local->scanning);
+       ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
 }
 EXPORT_SYMBOL(ieee80211_scan_completed);
 
 static int ieee80211_start_sw_scan(struct ieee80211_local *local)
 {
-       struct ieee80211_sub_if_data *sdata;
-
        /*
         * Hardware/driver doesn't support hw_scan, so use software
         * scanning instead. First send a nullfunc frame with power save
@@ -352,39 +355,21 @@ static int ieee80211_start_sw_scan(struct ieee80211_local *local)
         */
        drv_sw_scan_start(local);
 
-       mutex_lock(&local->iflist_mtx);
-       list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
-                       continue;
-
-               /* disable beaconing */
-               if (sdata->vif.type == NL80211_IFTYPE_AP ||
-                   sdata->vif.type == NL80211_IFTYPE_ADHOC ||
-                   sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
-                       ieee80211_bss_info_change_notify(
-                               sdata, BSS_CHANGED_BEACON_ENABLED);
-
-               /*
-                * only handle non-STA interfaces here, STA interfaces
-                * are handled in the scan state machine
-                */
-               if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                       netif_tx_stop_all_queues(sdata->dev);
-       }
-       mutex_unlock(&local->iflist_mtx);
-
+       local->leave_oper_channel_time = 0;
        local->next_scan_state = SCAN_DECISION;
        local->scan_channel_idx = 0;
 
-       spin_lock_bh(&local->filter_lock);
-       local->filter_flags |= FIF_BCN_PRBRESP_PROMISC;
-       drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
-                            &local->filter_flags,
-                            local->mc_count,
-                            local->mc_list);
-       spin_unlock_bh(&local->filter_lock);
+       /* We always want to use off-channel PS, even if we
+        * are not really leaving oper-channel.  Don't
+        * tell the AP though, as long as we are on-channel.
+        */
+       ieee80211_offchannel_enable_all_ps(local, false);
+
+       ieee80211_configure_filter(local);
+
+       /* We need to set power level at maximum rate for scanning. */
+       ieee80211_hw_config(local, 0);
 
-       /* TODO: start scan as soon as all nullfunc frames are ACKed */
        ieee80211_queue_delayed_work(&local->hw,
                                     &local->scan_work,
                                     IEEE80211_CHANNEL_TIME);
@@ -397,68 +382,68 @@ static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
                                  struct cfg80211_scan_request *req)
 {
        struct ieee80211_local *local = sdata->local;
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        int rc;
 
+       lockdep_assert_held(&local->mtx);
+
        if (local->scan_req)
                return -EBUSY;
 
+       if (!list_empty(&local->work_list)) {
+               /* wait for the work to finish/time out */
+               local->scan_req = req;
+               local->scan_sdata = sdata;
+               return 0;
+       }
+
        if (local->ops->hw_scan) {
                u8 *ies;
-               int ielen;
 
-               ies = kmalloc(2 + IEEE80211_MAX_SSID_LEN +
-                             local->scan_ies_len + req->ie_len, GFP_KERNEL);
-               if (!ies)
+               local->hw_scan_req = kmalloc(
+                               sizeof(*local->hw_scan_req) +
+                               req->n_channels * sizeof(req->channels[0]) +
+                               2 + IEEE80211_MAX_SSID_LEN + local->scan_ies_len +
+                               req->ie_len, GFP_KERNEL);
+               if (!local->hw_scan_req)
                        return -ENOMEM;
 
-               ielen = ieee80211_build_preq_ies(local, ies,
-                                                req->ie, req->ie_len);
-               local->orig_ies = req->ie;
-               local->orig_ies_len = req->ie_len;
-               req->ie = ies;
-               req->ie_len = ielen;
+               local->hw_scan_req->ssids = req->ssids;
+               local->hw_scan_req->n_ssids = req->n_ssids;
+               ies = (u8 *)local->hw_scan_req +
+                       sizeof(*local->hw_scan_req) +
+                       req->n_channels * sizeof(req->channels[0]);
+               local->hw_scan_req->ie = ies;
+
+               local->hw_scan_band = 0;
+
+               /*
+                * After allocating local->hw_scan_req, we must
+                * go through until ieee80211_prep_hw_scan(), so
+                * anything that might be changed here and leave
+                * this function early must not go after this
+                * allocation.
+                */
        }
 
        local->scan_req = req;
        local->scan_sdata = sdata;
 
-       if (req != local->int_scan_req &&
-           sdata->vif.type == NL80211_IFTYPE_STATION &&
-           !list_empty(&ifmgd->work_list)) {
-               /* actually wait for the work it's doing to finish/time out */
-               set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
-               return 0;
-       }
-
        if (local->ops->hw_scan)
                __set_bit(SCAN_HW_SCANNING, &local->scanning);
        else
                __set_bit(SCAN_SW_SCANNING, &local->scanning);
-       /*
-        * Kicking off the scan need not be protected,
-        * only the scan variable stuff, since now
-        * local->scan_req is assigned and other callers
-        * will abort their scan attempts.
-        *
-        * This avoids getting a scan_mtx -> iflist_mtx
-        * dependency, so that the scan completed calls
-        * have more locking freedom.
-        */
 
        ieee80211_recalc_idle(local);
-       mutex_unlock(&local->scan_mtx);
 
-       if (local->ops->hw_scan)
-               rc = drv_hw_scan(local, local->scan_req);
-       else
+       if (local->ops->hw_scan) {
+               WARN_ON(!ieee80211_prep_hw_scan(local));
+               rc = drv_hw_scan(local, sdata, local->hw_scan_req);
+       } else
                rc = ieee80211_start_sw_scan(local);
 
-       mutex_lock(&local->scan_mtx);
-
        if (rc) {
-               if (local->ops->hw_scan)
-                       ieee80211_restore_scan_ies(local);
+               kfree(local->hw_scan_req);
+               local->hw_scan_req = NULL;
                local->scanning = 0;
 
                ieee80211_recalc_idle(local);
@@ -470,111 +455,146 @@ static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
        return rc;
 }
 
-static int ieee80211_scan_state_decision(struct ieee80211_local *local,
-                                        unsigned long *next_delay)
+static unsigned long
+ieee80211_scan_get_channel_time(struct ieee80211_channel *chan)
+{
+       /*
+        * TODO: channel switching also consumes quite some time,
+        * add that delay as well to get a better estimation
+        */
+       if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
+               return IEEE80211_PASSIVE_CHANNEL_TIME;
+       return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
+}
+
+static void ieee80211_scan_state_decision(struct ieee80211_local *local,
+                                         unsigned long *next_delay)
 {
        bool associated = false;
+       bool tx_empty = true;
+       bool bad_latency;
+       bool listen_int_exceeded;
+       unsigned long min_beacon_int = 0;
        struct ieee80211_sub_if_data *sdata;
+       struct ieee80211_channel *next_chan;
 
-       /* if no more bands/channels left, complete scan and advance to the idle state */
-       if (local->scan_channel_idx >= local->scan_req->n_channels) {
-               ieee80211_scan_completed(&local->hw, false);
-               return 1;
-       }
-
-       /* check if at least one STA interface is associated */
+       /*
+        * check if at least one STA interface is associated,
+        * check if at least one STA interface has pending tx frames
+        * and grab the lowest used beacon interval
+        */
        mutex_lock(&local->iflist_mtx);
        list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
+               if (!ieee80211_sdata_running(sdata))
                        continue;
 
                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                        if (sdata->u.mgd.associated) {
                                associated = true;
-                               break;
+
+                               if (sdata->vif.bss_conf.beacon_int <
+                                   min_beacon_int || min_beacon_int == 0)
+                                       min_beacon_int =
+                                               sdata->vif.bss_conf.beacon_int;
+
+                               if (!qdisc_all_tx_empty(sdata->dev)) {
+                                       tx_empty = false;
+                                       break;
+                               }
                        }
                }
        }
        mutex_unlock(&local->iflist_mtx);
 
-       if (local->scan_channel) {
+       next_chan = local->scan_req->channels[local->scan_channel_idx];
+
+       if (ieee80211_cfg_on_oper_channel(local)) {
+               /* We're currently on operating channel. */
+               if (next_chan == local->oper_channel)
+                       /* We don't need to move off of operating channel. */
+                       local->next_scan_state = SCAN_SET_CHANNEL;
+               else
+                       /*
+                        * We do need to leave operating channel, as next
+                        * scan is somewhere else.
+                        */
+                       local->next_scan_state = SCAN_LEAVE_OPER_CHANNEL;
+       } else {
                /*
                 * we're currently scanning a different channel, let's
-                * switch back to the operating channel now if at least
-                * one interface is associated. Otherwise just scan the
-                * next channel
+                * see if we can scan another channel without interfering
+                * with the current traffic situation.
+                *
+                * Since we don't know if the AP has pending frames for us
+                * we can only check for our tx queues and use the current
+                * pm_qos requirements for rx. Hence, if no tx traffic occurs
+                * at all we will scan as many channels in a row as the pm_qos
+                * latency allows us to. Additionally we also check for the
+                * currently negotiated listen interval to prevent losing
+                * frames unnecessarily.
+                *
+                * Otherwise switch back to the operating channel.
                 */
-               if (associated)
+
+               bad_latency = time_after(jiffies +
+                               ieee80211_scan_get_channel_time(next_chan),
+                               local->leave_oper_channel_time +
+                               usecs_to_jiffies(pm_qos_request(PM_QOS_NETWORK_LATENCY)));
+
+               listen_int_exceeded = time_after(jiffies +
+                               ieee80211_scan_get_channel_time(next_chan),
+                               local->leave_oper_channel_time +
+                               usecs_to_jiffies(min_beacon_int * 1024) *
+                               local->hw.conf.listen_interval);
+
+               if (associated && ( !tx_empty || bad_latency ||
+                   listen_int_exceeded))
                        local->next_scan_state = SCAN_ENTER_OPER_CHANNEL;
                else
                        local->next_scan_state = SCAN_SET_CHANNEL;
-       } else {
-               /*
-                * we're on the operating channel currently, let's
-                * leave that channel now to scan another one
-                */
-               local->next_scan_state = SCAN_LEAVE_OPER_CHANNEL;
        }
 
        *next_delay = 0;
-       return 0;
 }
 
 static void ieee80211_scan_state_leave_oper_channel(struct ieee80211_local *local,
                                                    unsigned long *next_delay)
 {
-       struct ieee80211_sub_if_data *sdata;
+       /* PS will already be in off-channel mode,
+        * we do that once at the beginning of scanning.
+        */
+       ieee80211_offchannel_stop_vifs(local, false);
 
        /*
-        * notify the AP about us leaving the channel and stop all STA interfaces
+        * What if the nullfunc frames didn't arrive?
         */
-       mutex_lock(&local->iflist_mtx);
-       list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
-                       continue;
-
-               if (sdata->vif.type == NL80211_IFTYPE_STATION) {
-                       netif_tx_stop_all_queues(sdata->dev);
-                       if (sdata->u.mgd.associated)
-                               ieee80211_scan_ps_enable(sdata);
-               }
-       }
-       mutex_unlock(&local->iflist_mtx);
+       drv_flush(local, false);
+       if (local->ops->flush)
+               *next_delay = 0;
+       else
+               *next_delay = HZ / 10;
 
-       __set_bit(SCAN_OFF_CHANNEL, &local->scanning);
+       /* remember when we left the operating channel */
+       local->leave_oper_channel_time = jiffies;
 
        /* advance to the next channel to be scanned */
-       *next_delay = HZ / 10;
        local->next_scan_state = SCAN_SET_CHANNEL;
 }
 
 static void ieee80211_scan_state_enter_oper_channel(struct ieee80211_local *local,
                                                    unsigned long *next_delay)
 {
-       struct ieee80211_sub_if_data *sdata = local->scan_sdata;
-
        /* switch back to the operating channel */
        local->scan_channel = NULL;
-       ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
+       if (!ieee80211_cfg_on_oper_channel(local))
+               ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 
        /*
-        * notify the AP about us being back and restart all STA interfaces
+        * Re-enable vifs and beaconing.  Leave PS
+        * in off-channel state..will put that back
+        * on-channel at the end of scanning.
         */
-       mutex_lock(&local->iflist_mtx);
-       list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
-                       continue;
-
-               /* Tell AP we're back */
-               if (sdata->vif.type == NL80211_IFTYPE_STATION) {
-                       if (sdata->u.mgd.associated)
-                               ieee80211_scan_ps_disable(sdata);
-                       netif_tx_wake_all_queues(sdata->dev);
-               }
-       }
-       mutex_unlock(&local->iflist_mtx);
-
-       __clear_bit(SCAN_OFF_CHANNEL, &local->scanning);
+       ieee80211_offchannel_return(local, true, false);
 
        *next_delay = HZ / 5;
        local->next_scan_state = SCAN_DECISION;
@@ -585,22 +605,16 @@ static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
 {
        int skip;
        struct ieee80211_channel *chan;
-       struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 
        skip = 0;
        chan = local->scan_req->channels[local->scan_channel_idx];
 
-       if (chan->flags & IEEE80211_CHAN_DISABLED ||
-           (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
-            chan->flags & IEEE80211_CHAN_NO_IBSS))
-               skip = 1;
+       local->scan_channel = chan;
 
-       if (!skip) {
-               local->scan_channel = chan;
-               if (ieee80211_hw_config(local,
-                                       IEEE80211_CONF_CHANGE_CHANNEL))
+       /* Only call hw-config if we really need to change channels. */
+       if (chan != local->hw.conf.channel)
+               if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
                        skip = 1;
-       }
 
        /* advance state machine to next channel/band */
        local->scan_channel_idx++;
@@ -638,13 +652,15 @@ static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
 {
        int i;
        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
+       enum ieee80211_band band = local->hw.conf.channel->band;
 
        for (i = 0; i < local->scan_req->n_ssids; i++)
                ieee80211_send_probe_req(
                        sdata, NULL,
                        local->scan_req->ssids[i].ssid,
                        local->scan_req->ssids[i].ssid_len,
-                       local->scan_req->ie, local->scan_req->ie_len);
+                       local->scan_req->ie, local->scan_req->ie_len,
+                       local->scan_req->rates[band], false);
 
        /*
         * After sending probe requests, wait for probe responses
@@ -658,37 +674,45 @@ void ieee80211_scan_work(struct work_struct *work)
 {
        struct ieee80211_local *local =
                container_of(work, struct ieee80211_local, scan_work.work);
-       struct ieee80211_sub_if_data *sdata = local->scan_sdata;
+       struct ieee80211_sub_if_data *sdata;
        unsigned long next_delay = 0;
+       bool aborted, hw_scan;
 
-       mutex_lock(&local->scan_mtx);
-       if (!sdata || !local->scan_req) {
-               mutex_unlock(&local->scan_mtx);
-               return;
+       mutex_lock(&local->mtx);
+
+       sdata = local->scan_sdata;
+
+       if (test_and_clear_bit(SCAN_COMPLETED, &local->scanning)) {
+               aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
+               goto out_complete;
        }
 
+       if (!sdata || !local->scan_req)
+               goto out;
+
        if (local->scan_req && !local->scanning) {
                struct cfg80211_scan_request *req = local->scan_req;
                int rc;
 
                local->scan_req = NULL;
+               local->scan_sdata = NULL;
 
                rc = __ieee80211_start_scan(sdata, req);
-               mutex_unlock(&local->scan_mtx);
-
-               if (rc)
-                       ieee80211_scan_completed(&local->hw, true);
-               return;
+               if (rc) {
+                       /* need to complete scan in cfg80211 */
+                       local->scan_req = req;
+                       aborted = true;
+                       goto out_complete;
+               } else
+                       goto out;
        }
 
-       mutex_unlock(&local->scan_mtx);
-
        /*
         * Avoid re-scheduling when the sdata is going away.
         */
-       if (!netif_running(sdata->dev)) {
-               ieee80211_scan_completed(&local->hw, true);
-               return;
+       if (!ieee80211_sdata_running(sdata)) {
+               aborted = true;
+               goto out_complete;
        }
 
        /*
@@ -696,10 +720,19 @@ void ieee80211_scan_work(struct work_struct *work)
         * without scheduling a new work
         */
        do {
+               if (!ieee80211_sdata_running(sdata)) {
+                       aborted = true;
+                       goto out_complete;
+               }
+
                switch (local->next_scan_state) {
                case SCAN_DECISION:
-                       if (ieee80211_scan_state_decision(local, &next_delay))
-                               return;
+                       /* if no more bands/channels left, complete scan */
+                       if (local->scan_channel_idx >= local->scan_req->n_channels) {
+                               aborted = false;
+                               goto out_complete;
+                       }
+                       ieee80211_scan_state_decision(local, &next_delay);
                        break;
                case SCAN_SET_CHANNEL:
                        ieee80211_scan_state_set_channel(local, &next_delay);
@@ -717,6 +750,13 @@ void ieee80211_scan_work(struct work_struct *work)
        } while (next_delay == 0);
 
        ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
+       goto out;
+
+out_complete:
+       hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
+       __ieee80211_scan_completed(&local->hw, aborted, hw_scan);
+out:
+       mutex_unlock(&local->mtx);
 }
 
 int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
@@ -724,48 +764,221 @@ int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
 {
        int res;
 
-       mutex_lock(&sdata->local->scan_mtx);
+       mutex_lock(&sdata->local->mtx);
        res = __ieee80211_start_scan(sdata, req);
-       mutex_unlock(&sdata->local->scan_mtx);
+       mutex_unlock(&sdata->local->mtx);
 
        return res;
 }
 
 int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
-                                   const u8 *ssid, u8 ssid_len)
+                                   const u8 *ssid, u8 ssid_len,
+                                   struct ieee80211_channel *chan)
 {
        struct ieee80211_local *local = sdata->local;
        int ret = -EBUSY;
+       enum ieee80211_band band;
 
-       mutex_lock(&local->scan_mtx);
+       mutex_lock(&local->mtx);
 
        /* busy scanning */
        if (local->scan_req)
                goto unlock;
 
+       /* fill internal scan request */
+       if (!chan) {
+               int i, nchan = 0;
+
+               for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                       if (!local->hw.wiphy->bands[band])
+                               continue;
+                       for (i = 0;
+                            i < local->hw.wiphy->bands[band]->n_channels;
+                            i++) {
+                               local->int_scan_req->channels[nchan] =
+                                   &local->hw.wiphy->bands[band]->channels[i];
+                               nchan++;
+                       }
+               }
+
+               local->int_scan_req->n_channels = nchan;
+       } else {
+               local->int_scan_req->channels[0] = chan;
+               local->int_scan_req->n_channels = 1;
+       }
+
+       local->int_scan_req->ssids = &local->scan_ssid;
+       local->int_scan_req->n_ssids = 1;
        memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
        local->int_scan_req->ssids[0].ssid_len = ssid_len;
 
        ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
  unlock:
-       mutex_unlock(&local->scan_mtx);
+       mutex_unlock(&local->mtx);
        return ret;
 }
 
+/*
+ * Only call this function when a scan can't be queued -- under RTNL.
+ */
 void ieee80211_scan_cancel(struct ieee80211_local *local)
 {
-       bool swscan;
+       /*
+        * We are canceling software scan, or deferred scan that was not
+        * yet really started (see __ieee80211_start_scan ).
+        *
+        * Regarding hardware scan:
+        * - we can not call  __ieee80211_scan_completed() as when
+        *   SCAN_HW_SCANNING bit is set this function change
+        *   local->hw_scan_req to operate on 5G band, what race with
+        *   driver which can use local->hw_scan_req
+        *
+        * - we can not cancel scan_work since driver can schedule it
+        *   by ieee80211_scan_completed(..., true) to finish scan
+        *
+        * Hence we only call the cancel_hw_scan() callback, but the low-level
+        * driver is still responsible for calling ieee80211_scan_completed()
+        * after the scan was completed/aborted.
+        */
 
-       cancel_delayed_work_sync(&local->scan_work);
+       mutex_lock(&local->mtx);
+       if (!local->scan_req)
+               goto out;
+
+       if (test_bit(SCAN_HW_SCANNING, &local->scanning)) {
+               if (local->ops->cancel_hw_scan)
+                       drv_cancel_hw_scan(local, local->scan_sdata);
+               goto out;
+       }
 
        /*
-        * Only call this function when a scan can't be
-        * queued -- mostly at suspend under RTNL.
+        * If the work is currently running, it must be blocked on
+        * the mutex, but we'll set scan_sdata = NULL and it'll
+        * simply exit once it acquires the mutex.
         */
-       mutex_lock(&local->scan_mtx);
-       swscan = test_bit(SCAN_SW_SCANNING, &local->scanning);
-       mutex_unlock(&local->scan_mtx);
+       cancel_delayed_work(&local->scan_work);
+       /* and clean up */
+       __ieee80211_scan_completed(&local->hw, true, false);
+out:
+       mutex_unlock(&local->mtx);
+}
+
+int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
+                                      struct cfg80211_sched_scan_request *req)
+{
+       struct ieee80211_local *local = sdata->local;
+       int ret, i;
+
+       mutex_lock(&sdata->local->mtx);
+
+       if (local->sched_scanning) {
+               ret = -EBUSY;
+               goto out;
+       }
+
+       if (!local->ops->sched_scan_start) {
+               ret = -ENOTSUPP;
+               goto out;
+       }
+
+       for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
+               local->sched_scan_ies.ie[i] = kzalloc(2 +
+                                                     IEEE80211_MAX_SSID_LEN +
+                                                     local->scan_ies_len +
+                                                     req->ie_len,
+                                                     GFP_KERNEL);
+               if (!local->sched_scan_ies.ie[i]) {
+                       ret = -ENOMEM;
+                       goto out_free;
+               }
+
+               local->sched_scan_ies.len[i] =
+                       ieee80211_build_preq_ies(local,
+                                                local->sched_scan_ies.ie[i],
+                                                req->ie, req->ie_len, i,
+                                                (u32) -1, 0);
+       }
+
+       ret = drv_sched_scan_start(local, sdata, req,
+                                  &local->sched_scan_ies);
+       if (ret == 0) {
+               local->sched_scanning = true;
+               goto out;
+       }
+
+out_free:
+       while (i > 0)
+               kfree(local->sched_scan_ies.ie[--i]);
+out:
+       mutex_unlock(&sdata->local->mtx);
+       return ret;
+}
+
+int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata)
+{
+       struct ieee80211_local *local = sdata->local;
+       int ret = 0, i;
+
+       mutex_lock(&sdata->local->mtx);
+
+       if (!local->ops->sched_scan_stop) {
+               ret = -ENOTSUPP;
+               goto out;
+       }
+
+       if (local->sched_scanning) {
+               for (i = 0; i < IEEE80211_NUM_BANDS; i++)
+                       kfree(local->sched_scan_ies.ie[i]);
+
+               drv_sched_scan_stop(local, sdata);
+               local->sched_scanning = false;
+       }
+out:
+       mutex_unlock(&sdata->local->mtx);
+
+       return ret;
+}
+
+void ieee80211_sched_scan_results(struct ieee80211_hw *hw)
+{
+       struct ieee80211_local *local = hw_to_local(hw);
+
+       trace_api_sched_scan_results(local);
+
+       cfg80211_sched_scan_results(hw->wiphy);
+}
+EXPORT_SYMBOL(ieee80211_sched_scan_results);
+
+void ieee80211_sched_scan_stopped_work(struct work_struct *work)
+{
+       struct ieee80211_local *local =
+               container_of(work, struct ieee80211_local,
+                            sched_scan_stopped_work);
+       int i;
+
+       mutex_lock(&local->mtx);
+
+       if (!local->sched_scanning) {
+               mutex_unlock(&local->mtx);
+               return;
+       }
+
+       for (i = 0; i < IEEE80211_NUM_BANDS; i++)
+               kfree(local->sched_scan_ies.ie[i]);
+
+       local->sched_scanning = false;
+
+       mutex_unlock(&local->mtx);
+
+       cfg80211_sched_scan_stopped(local->hw.wiphy);
+}
+
+void ieee80211_sched_scan_stopped(struct ieee80211_hw *hw)
+{
+       struct ieee80211_local *local = hw_to_local(hw);
+
+       trace_api_sched_scan_stopped(local);
 
-       if (swscan)
-               ieee80211_scan_completed(&local->hw, true);
+       ieee80211_queue_work(&local->hw, &local->sched_scan_stopped_work);
 }
+EXPORT_SYMBOL(ieee80211_sched_scan_stopped);