Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/net/mac80211/mlme.c

 /*
  * BSS client mode implementation
  * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
  * Copyright 2004, Instant802 Networks, Inc.
  * Copyright 2005, Devicescape Software, Inc.
  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ skipping 10 matching lines @@
 #include <linux/crc32.h>
 #include <linux/slab.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 
 #include "ieee80211_i.h"
 #include "driver-ops.h"
 #include "rate.h"
 #include "led.h"
 
-#define IEEE80211_MAX_PROBE_TRIES 1
+#define IEEE80211_MAX_NULLFUNC_TRIES 2

[Sam Leffler, 2010/12/01 00:23:44]

lost local change

+#define IEEE80211_MAX_PROBE_TRIES 5
 
 /*
- * beacon loss timeout is calculated as N frames times the
+ * Beacon loss timeout is calculated as N frames times the
  * advertised beacon interval.  This may need to be somewhat
  * higher than what hardware might detect to account for
  * delays in the host processing frames. But since we also
- * probe on bmiss before declaring the connection lost default
- * to what we want.
+ * probe on beacon miss before declaring the connection lost
+ * default to what we want.
  */
-#define IEEE80211_BEACON_LOSS_COUNT     7
+#define IEEE80211_BEACON_LOSS_COUNT     7
+
 /*
  * Time the connection can be idle before we probe
  * it to see if we can still talk to the AP.
  */
 #define IEEE80211_CONNECTION_IDLE_TIME  (30 * HZ)
 /*
  * Time we wait for a probe response after sending
  * a probe request because of beacon loss or for
  * checking the connection still works.
  */
-#define IEEE80211_PROBE_WAIT            (HZ / 5)
+#define IEEE80211_PROBE_WAIT            (HZ / 2)

[Sam Leffler, 2010/12/01 00:23:44]

lost local change

[nbd, 2010/12/02 23:06:54]

Intentionally dropped. Should be unnecessary with proper !ACK handling.

[Sam Leffler, 2010/12/08 18:37:56]

But you upped the max tries to 2 so there is now a 1/2 sec delay between probe
frames which is just wasted time.

 
 /*
  * Weight given to the latest Beacon frame when calculating average signal
  * strength for Beacon frames received in the current BSS. This must be
  * between 1 and 15.
  */
 #define IEEE80211_SIGNAL_AVE_WEIGHT     3
 
-/*
- * How many Beacon frames need to have been used in average signal strength
- * before starting to indicate signal change events.
- */
-#define IEEE80211_SIGNAL_AVE_MIN_COUNT  4
-
 #define TMR_RUNNING_TIMER       0
 #define TMR_RUNNING_CHANSW      1
 
 /*
  * All cfg80211 functions have to be called outside a locked
  * section so that they can acquire a lock themselves... This
  * is much simpler than queuing up things in cfg80211, but we
  * do need some indirection for that here.
  */
 enum rx_mgmt_action {
@@ skipping 41 matching lines @@
             time_before(timeout, ifmgd->timer.expires))
                 mod_timer(&ifmgd->timer, timeout);
 }
 
 void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata)
 {
         if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)
                 return;
 
         mod_timer(&sdata->u.mgd.bcn_mon_timer,
-                  round_jiffies_up(jiffies + sdata->u.mgd.bloss_timeout));
+                  round_jiffies_up(jiffies + sdata->u.mgd.beacon_timeout));
 }
 
 void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
         if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
                 return;
 
         mod_timer(&sdata->u.mgd.conn_mon_timer,
@@ skipping 726 matching lines @@
                                      struct cfg80211_bss *cbss,
                                      u32 bss_info_changed)
 {
         struct ieee80211_bss *bss = (void *)cbss->priv;
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
 
         bss_info_changed |= BSS_CHANGED_ASSOC;
         /* set timing information */
         bss_conf->beacon_int = cbss->beacon_interval;
-        /* beacon_int is in TU, convert to jiffies for timer handling */
-        sdata->u.mgd.bloss_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
-            IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
         bss_conf->timestamp = cbss->tsf;
 
         bss_info_changed |= BSS_CHANGED_BEACON_INT;
         bss_info_changed |= ieee80211_handle_bss_capability(sdata,
                 cbss->capability, bss->has_erp_value, bss->erp_value);
 
+        sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
+                IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
+
         sdata->u.mgd.associated = cbss;
         memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
 
         sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
 
         /* just to be sure */
         sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
                                 IEEE80211_STA_BEACON_POLL);
 
         /*
@@ skipping 38 matching lines @@
         mutex_lock(&local->iflist_mtx);
         ieee80211_recalc_ps(local, -1);
         ieee80211_recalc_smps(local, sdata);
         mutex_unlock(&local->iflist_mtx);
 
         netif_tx_start_all_queues(sdata->dev);
         netif_carrier_on(sdata->dev);
 }
 
 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
-                                   bool remove_sta, bool tx)
+                                   bool remove_sta)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_local *local = sdata->local;
         struct sta_info *sta;
         u32 changed = 0, config_changed = 0;
         u8 bssid[ETH_ALEN];
 
         ASSERT_MGD_MTX(ifmgd);
 
         if (WARN_ON(!ifmgd->associated))
@@ skipping 18 matching lines @@
          * time -- we don't want the scan code to enable queues.
          */
 
         netif_tx_stop_all_queues(sdata->dev);
         netif_carrier_off(sdata->dev);
 
         mutex_lock(&local->sta_mtx);
         sta = sta_info_get(sdata, bssid);
         if (sta) {
                 set_sta_flags(sta, WLAN_STA_BLOCK_BA);
-                ieee80211_sta_tear_down_BA_sessions(sta, tx);
+                ieee80211_sta_tear_down_BA_sessions(sta);
         }
         mutex_unlock(&local->sta_mtx);
 
         changed |= ieee80211_reset_erp_info(sdata);
 
         ieee80211_led_assoc(local, 0);
         changed |= BSS_CHANGED_ASSOC;
         sdata->vif.bss_conf.assoc = false;
 
         ieee80211_set_wmm_default(sdata);
@@ skipping 40 matching lines @@
          * be ignored here, because we need to trigger the timer during
          * data idle periods for sending the periodic probe request to the
          * AP we're connected to.
          */
         if (is_multicast_ether_addr(hdr->addr1))
                 return;
 
         ieee80211_sta_reset_conn_monitor(sdata);
 }
 
+static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
+                              IEEE80211_STA_CONNECTION_POLL)))
+            return;
+
+        ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
+                          IEEE80211_STA_BEACON_POLL);
+        mutex_lock(&sdata->local->iflist_mtx);
+        ieee80211_recalc_ps(sdata->local, -1);
+        mutex_unlock(&sdata->local->iflist_mtx);
+
+        if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
+                return;
+
+        /*
+         * We've received a probe response, but are not sure whether
+         * we have or will be receiving any beacons or data, so let's
+         * schedule the timers again, just in case.
+         */
+        ieee80211_sta_reset_beacon_monitor(sdata);
+
+        mod_timer(&ifmgd->conn_mon_timer,
+                  round_jiffies_up(jiffies +
+                                   IEEE80211_CONNECTION_IDLE_TIME));
+}
+
+void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
+                             struct ieee80211_hdr *hdr)
+{
+        if (!ieee80211_is_data(hdr->frame_control) &&
+            !ieee80211_is_nullfunc(hdr->frame_control))

[Sam Leffler, 2010/12/01 00:23:44]

should be able to recognize NullData frame w/ one compare

+            return;
+
+        ieee80211_sta_reset_conn_monitor(sdata);
+
+        if (ieee80211_is_nullfunc(hdr->frame_control) &&
+            sdata->u.mgd.probe_send_count > 0) {
+                sdata->u.mgd.probe_send_count = 0;
+                ieee80211_queue_work(&sdata->local->hw, &sdata->work);
+        }
+}
+
 static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         const u8 *ssid;
         u8 *dst = ifmgd->associated->bssid;
+        u8 unicast_limit = max(1, IEEE80211_MAX_PROBE_TRIES - 3);
 
+        /*
+         * Try sending broadcast probe requests for the last three
+         * probe requests after the first ones failed since some
+         * buggy APs only support broadcast probe requests.
+         */
+        if (ifmgd->probe_send_count >= unicast_limit)
+                dst = NULL;
 
-        if ((sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)) {
+        /*
+         * When the hardware reports an accurate Tx ACK status, it's
+         * better to send a nullfunc frame instead of a probe request,
+         * as it will kick us off the AP quickly if we aren't associated
+         * anymore. The timeout will be reset if the frame is ACKed by
+         * the AP.
+         */
+        if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
                 ieee80211_send_nullfunc(sdata->local, sdata, 0);
-        } else {
+        else {
                 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
                 ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid[1], NULL, 0);
         }
 
         ifmgd->probe_send_count++;
+        ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;
+        run_again(ifmgd, ifmgd->probe_timeout);

[Sam Leffler, 2010/12/01 00:23:44]

this should not run for the send_nullfunc case as there will always be a tx
status callback

[nbd, 2010/12/02 23:06:54]

I think we should run this one even for the nullfunc case. The tx status
callback might be significantly delayed in situations where strong interference
kills beacons and delays transmissions.

[Sam Leffler, 2010/12/08 18:37:56]

I don't understand how interference relates to starting this timer.  It should
never be used in the NullData case because we will always get a TX status
callback on sending the frame.  It is only needed when sending ProbeReq frames.

 }
 
 static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
                                    bool beacon)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         bool already = false;
 
         if (!ieee80211_sdata_running(sdata))
                 return;
@@ skipping 57 matching lines @@
         mutex_lock(&ifmgd->mtx);
         if (!ifmgd->associated) {
                 mutex_unlock(&ifmgd->mtx);
                 return;
         }
 
         memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
 
         printk(KERN_DEBUG "Connection to AP %pM lost.\n", bssid);
 
-        ieee80211_set_disassoc(sdata, true, true);
+        ieee80211_set_disassoc(sdata, true);

[Sam Leffler, 2010/12/01 00:23:44]

missing local changes

         ieee80211_recalc_idle(local);
         mutex_unlock(&ifmgd->mtx);
         /*
          * must be outside lock due to cfg80211,
          * but that's not a problem.
          */
         ieee80211_send_deauth_disassoc(sdata, bssid,
                                        IEEE80211_STYPE_DEAUTH,
                                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
                                        NULL, true);
@@ skipping 57 matching lines @@
 
         ASSERT_MGD_MTX(ifmgd);
 
         bssid = ifmgd->associated->bssid;
 
         reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 
         printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
                         sdata->name, bssid, reason_code);
 
-        ieee80211_set_disassoc(sdata, true, false);
+        ieee80211_set_disassoc(sdata, true);
         ieee80211_recalc_idle(sdata->local);
 
         return RX_MGMT_CFG80211_DEAUTH;
 }
 
 
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
                            struct ieee80211_mgmt *mgmt, size_t len)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         u16 reason_code;
 
         if (len < 24 + 2)
                 return RX_MGMT_NONE;
 
         ASSERT_MGD_MTX(ifmgd);
 
         if (WARN_ON(!ifmgd->associated))
                 return RX_MGMT_NONE;
 
         if (WARN_ON(memcmp(ifmgd->associated->bssid, mgmt->sa, ETH_ALEN)))
                 return RX_MGMT_NONE;
 
         reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 
         printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
                         sdata->name, mgmt->sa, reason_code);
 
-        ieee80211_set_disassoc(sdata, true, false);
+        ieee80211_set_disassoc(sdata, true);
         ieee80211_recalc_idle(sdata->local);
         return RX_MGMT_CFG80211_DISASSOC;
 }
 
 
 static bool ieee80211_assoc_success(struct ieee80211_work *wk,
                                     struct ieee80211_mgmt *mgmt, size_t len)
 {
         struct ieee80211_sub_if_data *sdata = wk->sdata;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
@@ skipping 225 matching lines @@
         baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
         if (baselen > len)
                 return;
 
         ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
                                 &elems);
 
         ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
 
         if (ifmgd->associated &&
-            memcmp(mgmt->bssid, ifmgd->associated->bssid, ETH_ALEN) == 0 &&
-            ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
-                            IEEE80211_STA_CONNECTION_POLL)) {
-                ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
-                                  IEEE80211_STA_BEACON_POLL);
-                mutex_lock(&sdata->local->iflist_mtx);
-                ieee80211_recalc_ps(sdata->local, -1);
-                mutex_unlock(&sdata->local->iflist_mtx);
-
-                if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
-                        return;
-
-                /*
-                 * We've received a probe response, but are not sure whether
-                 * we have or will be receiving any beacons or data, so let's
-                 * schedule the timers again, just in case.
-                 */
-                ieee80211_sta_reset_beacon_monitor(sdata);
-
-                mod_timer(&ifmgd->conn_mon_timer,
-                          round_jiffies_up(jiffies +
-                                           IEEE80211_CONNECTION_IDLE_TIME));
-        }
+            memcmp(mgmt->bssid, ifmgd->associated->bssid, ETH_ALEN) == 0)
+                ieee80211_reset_ap_probe(sdata);
 }
 
 /*
  * This is the canonical list of information elements we care about,
  * the filter code also gives us all changes to the Microsoft OUI
  * (00:50:F2) vendor IE which is used for WMM which we need to track.
  *
  * We implement beacon filtering in software since that means we can
  * avoid processing the frame here and in cfg80211, and userspace
  * will not be able to tell whether the hardware supports it or not.
@@ skipping 51 matching lines @@
          */
         if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)
                 return;
 
         /* Track average RSSI from the Beacon frames of the current AP */
         ifmgd->last_beacon_signal = rx_status->signal;
         if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
                 ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
                 ifmgd->ave_beacon_signal = rx_status->signal * 16;
                 ifmgd->last_cqm_event_signal = 0;
-                ifmgd->count_beacon_signal = 1;
         } else {
                 ifmgd->ave_beacon_signal =
                         (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
                          (16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
                          ifmgd->ave_beacon_signal) / 16;
-                ifmgd->count_beacon_signal++;
         }
         if (bss_conf->cqm_rssi_thold &&
-            ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
             !(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) {
                 int sig = ifmgd->ave_beacon_signal / 16;
                 int last_event = ifmgd->last_cqm_event_signal;
                 int thold = bss_conf->cqm_rssi_thold;
                 int hyst = bss_conf->cqm_rssi_hyst;
                 if (sig < thold &&
                     (last_event == 0 || sig < last_event - hyst)) {
                         ifmgd->last_cqm_event_signal = sig;
                         ieee80211_cqm_rssi_notify(
                                 &sdata->vif,
@@ skipping 237 matching lines @@
         if (local->quiescing) {
                 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
                 return;
         }
 
         ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
 {
-        /* nothing right now */
-}
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
-static void ieee80211_sta_process_probe_status(struct ieee80211_sub_if_data *sdata)
-{
-        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-        struct ieee80211_local *local = sdata->local;
-        u8 bssid[ETH_ALEN];
-
+        /* then process the rest of the work */
         mutex_lock(&ifmgd->mtx);
 
-        if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
-                              IEEE80211_STA_CONNECTION_POLL)))
-                goto done;
-        if (!ifmgd->associated) /* XXX can this fail if flags are set? */
-                goto done;
-        memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
-        if (ifmgd->probe_acked) {
-                /*
-                 * Probe frame was ACK'd, just clear polling state.
-                 */
-                ifmgd->flags &= ~(IEEE80211_STA_BEACON_POLL |
-                                  IEEE80211_STA_CONNECTION_POLL);
-                ifmgd->probe_send_count = 0;
+        if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
+                            IEEE80211_STA_CONNECTION_POLL) &&
+            ifmgd->associated) {
+                u8 bssid[ETH_ALEN];
+                int max_tries;
 
-                /*
-                 * Re-enable power save
-                 */
-                mutex_lock(&local->iflist_mtx);
-                ieee80211_recalc_ps(local, -1);
-                mutex_unlock(&local->iflist_mtx);
-        } else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {
+                memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
+
+                if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
+                        max_tries = IEEE80211_MAX_NULLFUNC_TRIES;
+                else
+                        max_tries = IEEE80211_MAX_PROBE_TRIES;
+
+                /* ACK received for nullfunc probing frame */
+                if (!ifmgd->probe_send_count)
+                        ieee80211_reset_ap_probe(sdata);
+
+                else if (time_is_after_jiffies(ifmgd->probe_timeout))
+                        run_again(ifmgd, ifmgd->probe_timeout);
+
+                else if (ifmgd->probe_send_count < max_tries) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
-                printk(KERN_DEBUG "No ACK of probe to AP %pM, try again (%d)\n",
-                        bssid, ifmgd->probe_send_count);
+                        printk(KERN_DEBUG "No probe response from AP %pM"
+                                " after %dms, try %d\n", bssid,
+                                (1000 * IEEE80211_PROBE_WAIT)/HZ,
+                                ifmgd->probe_send_count);
 #endif
-                ieee80211_mgd_probe_ap_send(sdata);
-        } else {
-                /*
-                 * We actually lost the connection.
-                 */
-                ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
-                                  IEEE80211_STA_BEACON_POLL);
+                        ieee80211_mgd_probe_ap_send(sdata);
+                } else {
+                        /*
+                         * We actually lost the connection ... or did we?
+                         * Let's make sure!

[Sam Leffler, 2010/12/01 00:23:44]

comment is wrong

+                         */
+                        ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
+                                          IEEE80211_STA_BEACON_POLL);
+                        printk(KERN_DEBUG "No probe response from AP %pM"
+                                " after %dms, disconnecting.\n",
+                                bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);

[Sam Leffler, 2010/12/01 00:23:44]

this msg is wrong for the nulldata case which is why it was changed locally

+                        ieee80211_set_disassoc(sdata, true);
+                        ieee80211_recalc_idle(local);
+                        mutex_unlock(&ifmgd->mtx);
+                        /*
+                         * must be outside lock due to cfg80211,
+                         * but that's not a problem.
+                         */
+                        ieee80211_send_deauth_disassoc(sdata, bssid,
+                                        IEEE80211_STYPE_DEAUTH,
+                                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
+                                        NULL, true);
+                        mutex_lock(&ifmgd->mtx);
+                }
+        }
 
-                /* XXX juggle __ieee80211_connection_loss to suit */
-                printk(KERN_DEBUG "No response from AP %pM, disconnecting.\n",
-                    bssid);
-
-                ieee80211_set_disassoc(sdata, true, true);
-                ieee80211_recalc_idle(local);
-
-                /*
-                 * NB: must be outside lock due to cfg80211.
-                 */
-                mutex_unlock(&ifmgd->mtx);
-                ieee80211_send_deauth_disassoc(sdata, bssid,
-                               IEEE80211_STYPE_DEAUTH,
-                               WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
-                               NULL, true);
-                return;
-        }
-done:
         mutex_unlock(&ifmgd->mtx);
 }
 
-/*
- * Process TX status for probe frame sent to the associated
- * AP on beacon or connection loss.
- */
-static void ieee80211_probe_status_work(struct work_struct *work)
-{
-        struct ieee80211_sub_if_data *sdata = container_of(work,
-                struct ieee80211_sub_if_data, u.mgd.probe_status_work);
-
-        WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION);
-
-        if (ieee80211_sdata_running(sdata))
-                ieee80211_sta_process_probe_status(sdata);
-}
-
 static void ieee80211_sta_bcn_mon_timer(unsigned long data)
 {
         struct ieee80211_sub_if_data *sdata =
                 (struct ieee80211_sub_if_data *) data;
         struct ieee80211_local *local = sdata->local;
 
         if (local->quiescing)
                 return;
 
         ieee80211_queue_work(&sdata->local->hw,
@@ skipping 21 matching lines @@
 
         ieee80211_mgd_probe_ap(sdata, false);
 }
 
 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
 {
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
                                         IEEE80211_STA_CONNECTION_POLL);
 
+                /* let's probe the connection once */
+                ieee80211_queue_work(&sdata->local->hw,
+                           &sdata->u.mgd.monitor_work);
                 /* and do all the other regular work too */
                 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
         }
 }
 
 #ifdef CONFIG_PM
 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
@@ skipping 18 matching lines @@
 }
 
 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
         if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
                 add_timer(&ifmgd->timer);
         if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
                 add_timer(&ifmgd->chswitch_timer);
-
         ieee80211_sta_reset_beacon_monitor(sdata);
-        ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.monitor_work);
+        ieee80211_restart_sta_timer(sdata);

[Sam Leffler, 2010/12/01 00:23:44]

this restarts more than just the connection monitor work, why?

[nbd, 2010/12/02 23:06:54]

The interface may have collected some unprocessed frames before the suspend
(e.g. action frames). I thought it would be a good idea to speed up the
processing here. If nothing is pending, then running this won't do any harm.

 }
 #endif
 
 /* interface setup */
 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd;
 
         ifmgd = &sdata->u.mgd;
         INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
         INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
         INIT_WORK(&ifmgd->beacon_connection_loss_work,
                   ieee80211_beacon_connection_loss_work);
-        INIT_WORK(&ifmgd->probe_status_work, ieee80211_probe_status_work);
         INIT_WORK(&ifmgd->bitrate_notify_work, ieee80211_rate_notify_work);
         setup_timer(&ifmgd->timer, ieee80211_sta_timer,
                     (unsigned long) sdata);
         setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
                     (unsigned long) sdata);
         setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
                     (unsigned long) sdata);
         setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
                     (unsigned long) sdata);
 
@@ skipping 187 matching lines @@
                         /*
                          * We are already associated and the request was not a
                          * reassociation request from the current BSS, so
                          * reject it.
                          */
                         mutex_unlock(&ifmgd->mtx);
                         return -EALREADY;
                 }
 
                 /* Trying to reassociate - clear previous association state */
-                ieee80211_set_disassoc(sdata, true, false);
+                ieee80211_set_disassoc(sdata, true);
         }
         mutex_unlock(&ifmgd->mtx);
 
         wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
         if (!wk)
                 return -ENOMEM;
 
         ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
         ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
 
@@ skipping 88 matching lines @@
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_work *wk;
         u8 bssid[ETH_ALEN];
         bool assoc_bss = false;
 
         mutex_lock(&ifmgd->mtx);
 
         memcpy(bssid, req->bss->bssid, ETH_ALEN);
         if (ifmgd->associated == req->bss) {
-                ieee80211_set_disassoc(sdata, false, true);
+                ieee80211_set_disassoc(sdata, false);
                 mutex_unlock(&ifmgd->mtx);
                 assoc_bss = true;
         } else {
                 bool not_auth_yet = false;
 
                 mutex_unlock(&ifmgd->mtx);
 
                 mutex_lock(&local->work_mtx);
                 list_for_each_entry(wk, &local->work_list, list) {
                         if (wk->sdata != sdata)
@@ skipping 60 matching lines @@
          */
         if (ifmgd->associated != req->bss) {
                 mutex_unlock(&ifmgd->mtx);
                 return -ENOLINK;
         }
 
         printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
                sdata->name, req->bss->bssid, req->reason_code);
 
         memcpy(bssid, req->bss->bssid, ETH_ALEN);
-        ieee80211_set_disassoc(sdata, false, true);
+        ieee80211_set_disassoc(sdata, false);
 
         mutex_unlock(&ifmgd->mtx);
 
         ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,
                         IEEE80211_STYPE_DISASSOC, req->reason_code,
                         cookie, !req->local_state_change);
         sta_info_destroy_addr(sdata, bssid);
 
         ieee80211_recalc_idle(sdata->local);
 
         return 0;
 }
 
 void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
                                enum nl80211_cqm_rssi_threshold_event rssi_event,
                                gfp_t gfp)
 {
         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 
         trace_api_cqm_rssi_notify(sdata, rssi_event);
 
         cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
 }
 EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);