1 files changed, 254 insertions, 288 deletions

diff --git a/net/wireless/sme.c b/net/wireless/sme.c
index 81be95f3be74..ae7e2cbf45cb 100644
--- a/net/wireless/sme.c
+++ b/net/wireless/sme.c
@@ -1,5 +1,7 @@
 /*
- * SME code for cfg80211's connect emulation.
+ * SME code for cfg80211
+ * both driver SME event handling and the SME implementation
+ * (for nl80211's connect() and wext)
  *
  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
  * Copyright (C) 2009   Intel Corporation. All rights reserved.
@@ -18,18 +20,24 @@
 #include "reg.h"
 #include "rdev-ops.h"
 
+/*
+ * Software SME in cfg80211, using auth/assoc/deauth calls to the
+ * driver. This is is for implementing nl80211's connect/disconnect
+ * and wireless extensions (if configured.)
+ */
+
 struct cfg80211_conn {
         struct cfg80211_connect_params params;
         /* these are sub-states of the _CONNECTING sme_state */
         enum {
-                CFG80211_CONN_IDLE,
                 CFG80211_CONN_SCANNING,
                 CFG80211_CONN_SCAN_AGAIN,
                 CFG80211_CONN_AUTHENTICATE_NEXT,
                 CFG80211_CONN_AUTHENTICATING,
                 CFG80211_CONN_ASSOCIATE_NEXT,
                 CFG80211_CONN_ASSOCIATING,
-                CFG80211_CONN_DEAUTH_ASSOC_FAIL,
+                CFG80211_CONN_DEAUTH,
+                CFG80211_CONN_CONNECTED,
         } state;
         u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
         u8 *ie;
@@ -37,39 +45,16 @@ struct cfg80211_conn {
         bool auto_auth, prev_bssid_valid;
 };
 
-static bool cfg80211_is_all_idle(void)
+static void cfg80211_sme_free(struct wireless_dev *wdev)
 {
-        struct cfg80211_registered_device *rdev;
-        struct wireless_dev *wdev;
-        bool is_all_idle = true;
-
-        /*
-         * All devices must be idle as otherwise if you are actively
-         * scanning some new beacon hints could be learned and would
-         * count as new regulatory hints.
-         */
-        list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
-                list_for_each_entry(wdev, &rdev->wdev_list, list) {
-                        wdev_lock(wdev);
-                        if (wdev->sme_state != CFG80211_SME_IDLE)
-                                is_all_idle = false;
-                        wdev_unlock(wdev);
-                }
-        }
-
-        return is_all_idle;
-}
+        if (!wdev->conn)
+                return;
 
-static void disconnect_work(struct work_struct *work)
-{
-        rtnl_lock();
-        if (cfg80211_is_all_idle())
-                regulatory_hint_disconnect();
-        rtnl_unlock();
+        kfree(wdev->conn->ie);
+        kfree(wdev->conn);
+        wdev->conn = NULL;
 }
 
-static DECLARE_WORK(cfg80211_disconnect_work, disconnect_work);
-
 static int cfg80211_conn_scan(struct wireless_dev *wdev)
 {
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
@@ -164,6 +149,9 @@ static int cfg80211_conn_do_work(struct wireless_dev *wdev)
         params = &wdev->conn->params;
 
         switch (wdev->conn->state) {
+        case CFG80211_CONN_SCANNING:
+                /* didn't find it during scan ... */
+                return -ENOENT;
         case CFG80211_CONN_SCAN_AGAIN:
                 return cfg80211_conn_scan(wdev);
         case CFG80211_CONN_AUTHENTICATE_NEXT:
@@ -200,12 +188,11 @@ static int cfg80211_conn_do_work(struct wireless_dev *wdev)
                                              WLAN_REASON_DEAUTH_LEAVING,
                                              false);
                 return err;
-        case CFG80211_CONN_DEAUTH_ASSOC_FAIL:
+        case CFG80211_CONN_DEAUTH:
                 cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
                                      NULL, 0,
                                      WLAN_REASON_DEAUTH_LEAVING, false);
-                /* return an error so that we call __cfg80211_connect_result() */
-                return -EINVAL;
+                return 0;
         default:
                 return 0;
         }
@@ -229,7 +216,8 @@ void cfg80211_conn_work(struct work_struct *work)
                         wdev_unlock(wdev);
                         continue;
                 }
-                if (wdev->sme_state != CFG80211_SME_CONNECTING || !wdev->conn) {
+                if (!wdev->conn ||
+                    wdev->conn->state == CFG80211_CONN_CONNECTED) {
                         wdev_unlock(wdev);
                         continue;
                 }
@@ -237,12 +225,14 @@ void cfg80211_conn_work(struct work_struct *work)
                         memcpy(bssid_buf, wdev->conn->params.bssid, ETH_ALEN);
                         bssid = bssid_buf;
                 }
-                if (cfg80211_conn_do_work(wdev))
+                if (cfg80211_conn_do_work(wdev)) {
                         __cfg80211_connect_result(
                                         wdev->netdev, bssid,
                                         NULL, 0, NULL, 0,
                                         WLAN_STATUS_UNSPECIFIED_FAILURE,
                                         false, NULL);
+                        cfg80211_sme_free(wdev);
+                }
                 wdev_unlock(wdev);
         }
 
@@ -286,9 +276,6 @@ static void __cfg80211_sme_scan_done(struct net_device *dev)
 
         ASSERT_WDEV_LOCK(wdev);
 
-        if (wdev->sme_state != CFG80211_SME_CONNECTING)
-                return;
-
         if (!wdev->conn)
                 return;
 
@@ -297,20 +284,10 @@ static void __cfg80211_sme_scan_done(struct net_device *dev)
                 return;
 
         bss = cfg80211_get_conn_bss(wdev);
-        if (bss) {
+        if (bss)
                 cfg80211_put_bss(&rdev->wiphy, bss);
-        } else {
-                /* not found */
-                if (wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)
-                        schedule_work(&rdev->conn_work);
-                else
-                        __cfg80211_connect_result(
-                                        wdev->netdev,
-                                        wdev->conn->params.bssid,
-                                        NULL, 0, NULL, 0,
-                                        WLAN_STATUS_UNSPECIFIED_FAILURE,
-                                        false, NULL);
-        }
+        else
+                schedule_work(&rdev->conn_work);
 }
 
 void cfg80211_sme_scan_done(struct net_device *dev)
@@ -322,10 +299,8 @@ void cfg80211_sme_scan_done(struct net_device *dev)
         wdev_unlock(wdev);
 }
 
-void cfg80211_sme_rx_auth(struct net_device *dev,
-                          const u8 *buf, size_t len)
+void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len)
 {
-        struct wireless_dev *wdev = dev->ieee80211_ptr;
         struct wiphy *wiphy = wdev->wiphy;
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
@@ -333,11 +308,7 @@ void cfg80211_sme_rx_auth(struct net_device *dev,
 
         ASSERT_WDEV_LOCK(wdev);
 
-        /* should only RX auth frames when connecting */
-        if (wdev->sme_state != CFG80211_SME_CONNECTING)
-                return;
-
-        if (WARN_ON(!wdev->conn))
+        if (!wdev->conn || wdev->conn->state == CFG80211_CONN_CONNECTED)
                 return;
 
         if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
@@ -366,46 +337,226 @@ void cfg80211_sme_rx_auth(struct net_device *dev,
                 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
                 schedule_work(&rdev->conn_work);
         } else if (status_code != WLAN_STATUS_SUCCESS) {
-                __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
+                __cfg80211_connect_result(wdev->netdev, mgmt->bssid,
+                                          NULL, 0, NULL, 0,
                                           status_code, false, NULL);
-        } else if (wdev->sme_state == CFG80211_SME_CONNECTING &&
-                 wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
+        } else if (wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
                 wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
                 schedule_work(&rdev->conn_work);
         }
 }
 
-bool cfg80211_sme_failed_reassoc(struct wireless_dev *wdev)
+bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status)
 {
-        struct wiphy *wiphy = wdev->wiphy;
-        struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 
-        if (WARN_ON(!wdev->conn))
+        if (!wdev->conn)
                 return false;
 
-        if (!wdev->conn->prev_bssid_valid)
+        if (status == WLAN_STATUS_SUCCESS) {
+                wdev->conn->state = CFG80211_CONN_CONNECTED;
                 return false;
+        }
 
-        /*
-         * Some stupid APs don't accept reassoc, so we
-         * need to fall back to trying regular assoc.
-         */
-        wdev->conn->prev_bssid_valid = false;
-        wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
+        if (wdev->conn->prev_bssid_valid) {
+                /*
+                 * Some stupid APs don't accept reassoc, so we
+                 * need to fall back to trying regular assoc;
+                 * return true so no event is sent to userspace.
+                 */
+                wdev->conn->prev_bssid_valid = false;
+                wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
+                schedule_work(&rdev->conn_work);
+                return true;
+        }
+
+        wdev->conn->state = CFG80211_CONN_DEAUTH;
         schedule_work(&rdev->conn_work);
+        return false;
+}
 
-        return true;
+void cfg80211_sme_deauth(struct wireless_dev *wdev)
+{
+        cfg80211_sme_free(wdev);
 }
 
-void cfg80211_sme_failed_assoc(struct wireless_dev *wdev)
+void cfg80211_sme_auth_timeout(struct wireless_dev *wdev)
 {
-        struct wiphy *wiphy = wdev->wiphy;
-        struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
+        cfg80211_sme_free(wdev);
+}
 
-        wdev->conn->state = CFG80211_CONN_DEAUTH_ASSOC_FAIL;
+void cfg80211_sme_disassoc(struct wireless_dev *wdev)
+{
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+
+        if (!wdev->conn)
+                return;
+
+        wdev->conn->state = CFG80211_CONN_DEAUTH;
         schedule_work(&rdev->conn_work);
 }
 
+void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev)
+{
+        cfg80211_sme_disassoc(wdev);
+}
+
+static int cfg80211_sme_connect(struct wireless_dev *wdev,
+                                struct cfg80211_connect_params *connect,
+                                const u8 *prev_bssid)
+{
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        struct cfg80211_bss *bss;
+        int err;
+
+        if (!rdev->ops->auth || !rdev->ops->assoc)
+                return -EOPNOTSUPP;
+
+        if (wdev->current_bss)
+                return -EALREADY;
+
+        if (WARN_ON(wdev->conn))
+                return -EINPROGRESS;
+
+        wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
+        if (!wdev->conn)
+                return -ENOMEM;
+
+        /*
+         * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
+         */
+        memcpy(&wdev->conn->params, connect, sizeof(*connect));
+        if (connect->bssid) {
+                wdev->conn->params.bssid = wdev->conn->bssid;
+                memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
+        }
+
+        if (connect->ie) {
+                wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
+                                        GFP_KERNEL);
+                wdev->conn->params.ie = wdev->conn->ie;
+                if (!wdev->conn->ie) {
+                        kfree(wdev->conn);
+                        wdev->conn = NULL;
+                        return -ENOMEM;
+                }
+        }
+
+        if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
+                wdev->conn->auto_auth = true;
+                /* start with open system ... should mostly work */
+                wdev->conn->params.auth_type =
+                        NL80211_AUTHTYPE_OPEN_SYSTEM;
+        } else {
+                wdev->conn->auto_auth = false;
+        }
+
+        wdev->conn->params.ssid = wdev->ssid;
+        wdev->conn->params.ssid_len = connect->ssid_len;
+
+        /* see if we have the bss already */
+        bss = cfg80211_get_conn_bss(wdev);
+
+        if (prev_bssid) {
+                memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
+                wdev->conn->prev_bssid_valid = true;
+        }
+
+        /* we're good if we have a matching bss struct */
+        if (bss) {
+                wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
+                err = cfg80211_conn_do_work(wdev);
+                cfg80211_put_bss(wdev->wiphy, bss);
+        } else {
+                /* otherwise we'll need to scan for the AP first */
+                err = cfg80211_conn_scan(wdev);
+
+                /*
+                 * If we can't scan right now, then we need to scan again
+                 * after the current scan finished, since the parameters
+                 * changed (unless we find a good AP anyway).
+                 */
+                if (err == -EBUSY) {
+                        err = 0;
+                        wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
+                }
+        }
+
+        if (err)
+                cfg80211_sme_free(wdev);
+
+        return err;
+}
+
+static int cfg80211_sme_disconnect(struct wireless_dev *wdev, u16 reason)
+{
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        int err;
+
+        if (!wdev->conn)
+                return 0;
+
+        if (!rdev->ops->deauth)
+                return -EOPNOTSUPP;
+
+        if (wdev->conn->state == CFG80211_CONN_SCANNING ||
+            wdev->conn->state == CFG80211_CONN_SCAN_AGAIN) {
+                err = 0;
+                goto out;
+        }
+
+        /* wdev->conn->params.bssid must be set if > SCANNING */
+        err = cfg80211_mlme_deauth(rdev, wdev->netdev,
+                                   wdev->conn->params.bssid,
+                                   NULL, 0, reason, false);
+ out:
+        cfg80211_sme_free(wdev);
+        return err;
+}
+
+/*
+ * code shared for in-device and software SME
+ */
+
+static bool cfg80211_is_all_idle(void)
+{
+        struct cfg80211_registered_device *rdev;
+        struct wireless_dev *wdev;
+        bool is_all_idle = true;
+
+        /*
+         * All devices must be idle as otherwise if you are actively
+         * scanning some new beacon hints could be learned and would
+         * count as new regulatory hints.
+         */
+        list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
+                list_for_each_entry(wdev, &rdev->wdev_list, list) {
+                        wdev_lock(wdev);
+                        if (wdev->conn || wdev->current_bss)
+                                is_all_idle = false;
+                        wdev_unlock(wdev);
+                }
+        }
+
+        return is_all_idle;
+}
+
+static void disconnect_work(struct work_struct *work)
+{
+        rtnl_lock();
+        if (cfg80211_is_all_idle())
+                regulatory_hint_disconnect();
+        rtnl_unlock();
+}
+
+static DECLARE_WORK(cfg80211_disconnect_work, disconnect_work);
+
+
+/*
+ * API calls for drivers implementing connect/disconnect and
+ * SME event handling
+ */
+
 void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
                                const u8 *req_ie, size_t req_ie_len,
                                const u8 *resp_ie, size_t resp_ie_len,
@@ -424,9 +575,6 @@ void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
                     wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
                 return;
 
-        if (wdev->sme_state != CFG80211_SME_CONNECTING)
-                return;
-
         nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev,
                                     bssid, req_ie, req_ie_len,
                                     resp_ie, resp_ie_len,
@@ -463,15 +611,7 @@ void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
                 wdev->current_bss = NULL;
         }
 
-        if (wdev->conn)
-                wdev->conn->state = CFG80211_CONN_IDLE;
-
         if (status != WLAN_STATUS_SUCCESS) {
-                wdev->sme_state = CFG80211_SME_IDLE;
-                if (wdev->conn)
-                        kfree(wdev->conn->ie);
-                kfree(wdev->conn);
-                wdev->conn = NULL;
                 kfree(wdev->connect_keys);
                 wdev->connect_keys = NULL;
                 wdev->ssid_len = 0;
@@ -480,21 +620,16 @@ void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
         }
 
         if (!bss)
-                bss = cfg80211_get_bss(wdev->wiphy,
-                                       wdev->conn ? wdev->conn->params.channel :
-                                       NULL,
-                                       bssid,
+                bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
                                        wdev->ssid, wdev->ssid_len,
                                        WLAN_CAPABILITY_ESS,
                                        WLAN_CAPABILITY_ESS);
-
         if (WARN_ON(!bss))
                 return;
 
         cfg80211_hold_bss(bss_from_pub(bss));
         wdev->current_bss = bss_from_pub(bss);
 
-        wdev->sme_state = CFG80211_SME_CONNECTED;
         cfg80211_upload_connect_keys(wdev);
 
         rcu_read_lock();
@@ -530,8 +665,6 @@ void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
         struct cfg80211_event *ev;
         unsigned long flags;
 
-        CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTING);
-
         ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
         if (!ev)
                 return;
@@ -572,13 +705,8 @@ void __cfg80211_roamed(struct wireless_dev *wdev,
                     wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
                 goto out;
 
-        if (wdev->sme_state != CFG80211_SME_CONNECTED)
-                goto out;
-
-        /* internal error -- how did we get to CONNECTED w/o BSS? */
-        if (WARN_ON(!wdev->current_bss)) {
+        if (WARN_ON(!wdev->current_bss))
                 goto out;
-        }
 
         cfg80211_unhold_bss(wdev->current_bss);
         cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
@@ -628,8 +756,6 @@ void cfg80211_roamed(struct net_device *dev,
         struct wireless_dev *wdev = dev->ieee80211_ptr;
         struct cfg80211_bss *bss;
 
-        CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED);
-
         bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, wdev->ssid,
                                wdev->ssid_len, WLAN_CAPABILITY_ESS,
                                WLAN_CAPABILITY_ESS);
@@ -651,8 +777,6 @@ void cfg80211_roamed_bss(struct net_device *dev,
         struct cfg80211_event *ev;
         unsigned long flags;
 
-        CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED);
-
         if (WARN_ON(!bss))
                 return;
 
@@ -694,25 +818,14 @@ void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
                     wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
                 return;
 
-        if (wdev->sme_state != CFG80211_SME_CONNECTED)
-                return;
-
         if (wdev->current_bss) {
                 cfg80211_unhold_bss(wdev->current_bss);
                 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
         }
 
         wdev->current_bss = NULL;
-        wdev->sme_state = CFG80211_SME_IDLE;
         wdev->ssid_len = 0;
 
-        if (wdev->conn) {
-                kfree(wdev->conn->ie);
-                wdev->conn->ie = NULL;
-                kfree(wdev->conn);
-                wdev->conn = NULL;
-        }
-
         nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
 
         /*
@@ -741,8 +854,6 @@ void cfg80211_disconnected(struct net_device *dev, u16 reason,
         struct cfg80211_event *ev;
         unsigned long flags;
 
-        CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED);
-
         ev = kzalloc(sizeof(*ev) + ie_len, gfp);
         if (!ev)
                 return;
@@ -760,6 +871,9 @@ void cfg80211_disconnected(struct net_device *dev, u16 reason,
 }
 EXPORT_SYMBOL(cfg80211_disconnected);
 
+/*
+ * API calls for nl80211/wext compatibility code
+ */
 int cfg80211_connect(struct cfg80211_registered_device *rdev,
                      struct net_device *dev,
                      struct cfg80211_connect_params *connect,
@@ -767,14 +881,10 @@ int cfg80211_connect(struct cfg80211_registered_device *rdev,
                      const u8 *prev_bssid)
 {
         struct wireless_dev *wdev = dev->ieee80211_ptr;
-        struct cfg80211_bss *bss = NULL;
         int err;
 
         ASSERT_WDEV_LOCK(wdev);
 
-        if (wdev->sme_state != CFG80211_SME_IDLE)
-                return -EALREADY;
-
         if (WARN_ON(wdev->connect_keys)) {
                 kfree(wdev->connect_keys);
                 wdev->connect_keys = NULL;
@@ -810,105 +920,22 @@ int cfg80211_connect(struct cfg80211_registered_device *rdev,
                 }
         }
 
-        if (!rdev->ops->connect) {
-                if (!rdev->ops->auth || !rdev->ops->assoc)
-                        return -EOPNOTSUPP;
-
-                if (WARN_ON(wdev->conn))
-                        return -EINPROGRESS;
-
-                wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
-                if (!wdev->conn)
-                        return -ENOMEM;
-
-                /*
-                 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
-                 */
-                memcpy(&wdev->conn->params, connect, sizeof(*connect));
-                if (connect->bssid) {
-                        wdev->conn->params.bssid = wdev->conn->bssid;
-                        memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
-                }
+        wdev->connect_keys = connkeys;
+        memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
+        wdev->ssid_len = connect->ssid_len;
 
-                if (connect->ie) {
-                        wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
-                                                GFP_KERNEL);
-                        wdev->conn->params.ie = wdev->conn->ie;
-                        if (!wdev->conn->ie) {
-                                kfree(wdev->conn);
-                                wdev->conn = NULL;
-                                return -ENOMEM;
-                        }
-                }
-
-                if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
-                        wdev->conn->auto_auth = true;
-                        /* start with open system ... should mostly work */
-                        wdev->conn->params.auth_type =
-                                NL80211_AUTHTYPE_OPEN_SYSTEM;
-                } else {
-                        wdev->conn->auto_auth = false;
-                }
-
-                memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
-                wdev->ssid_len = connect->ssid_len;
-                wdev->conn->params.ssid = wdev->ssid;
-                wdev->conn->params.ssid_len = connect->ssid_len;
-
-                /* see if we have the bss already */
-                bss = cfg80211_get_conn_bss(wdev);
-
-                wdev->sme_state = CFG80211_SME_CONNECTING;
-                wdev->connect_keys = connkeys;
-
-                if (prev_bssid) {
-                        memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
-                        wdev->conn->prev_bssid_valid = true;
-                }
-
-                /* we're good if we have a matching bss struct */
-                if (bss) {
-                        wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
-                        err = cfg80211_conn_do_work(wdev);
-                        cfg80211_put_bss(wdev->wiphy, bss);
-                } else {
-                        /* otherwise we'll need to scan for the AP first */
-                        err = cfg80211_conn_scan(wdev);
-                        /*
-                         * If we can't scan right now, then we need to scan again
-                         * after the current scan finished, since the parameters
-                         * changed (unless we find a good AP anyway).
-                         */
-                        if (err == -EBUSY) {
-                                err = 0;
-                                wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
-                        }
-                }
-                if (err) {
-                        kfree(wdev->conn->ie);
-                        kfree(wdev->conn);
-                        wdev->conn = NULL;
-                        wdev->sme_state = CFG80211_SME_IDLE;
-                        wdev->connect_keys = NULL;
-                        wdev->ssid_len = 0;
-                }
-
-                return err;
-        } else {
-                wdev->sme_state = CFG80211_SME_CONNECTING;
-                wdev->connect_keys = connkeys;
+        if (!rdev->ops->connect)
+                err = cfg80211_sme_connect(wdev, connect, prev_bssid);
+        else
                 err = rdev_connect(rdev, dev, connect);
-                if (err) {
-                        wdev->connect_keys = NULL;
-                        wdev->sme_state = CFG80211_SME_IDLE;
-                        return err;
-                }
 
-                memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
-                wdev->ssid_len = connect->ssid_len;
-
-                return 0;
+        if (err) {
+                wdev->connect_keys = NULL;
+                wdev->ssid_len = 0;
+                return err;
         }
+
+        return 0;
 }
 
 int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
@@ -919,78 +946,17 @@ int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
 
         ASSERT_WDEV_LOCK(wdev);
 
-        if (wdev->sme_state == CFG80211_SME_IDLE)
-                return -EINVAL;
-
         kfree(wdev->connect_keys);
         wdev->connect_keys = NULL;
 
-        if (!rdev->ops->disconnect) {
-                if (!rdev->ops->deauth)
-                        return -EOPNOTSUPP;
-
-                /* was it connected by userspace SME? */
-                if (!wdev->conn) {
-                        cfg80211_mlme_down(rdev, dev);
-                        goto disconnect;
-                }
-
-                if (wdev->sme_state == CFG80211_SME_CONNECTING &&
-                    (wdev->conn->state == CFG80211_CONN_SCANNING ||
-                     wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)) {
-                        wdev->sme_state = CFG80211_SME_IDLE;
-                        kfree(wdev->conn->ie);
-                        kfree(wdev->conn);
-                        wdev->conn = NULL;
-                        wdev->ssid_len = 0;
-                        return 0;
-                }
-
-                /* wdev->conn->params.bssid must be set if > SCANNING */
-                err = cfg80211_mlme_deauth(rdev, dev,
-                                             wdev->conn->params.bssid,
-                                             NULL, 0, reason, false);
-                if (err)
-                        return err;
+        if (wdev->conn) {
+                err = cfg80211_sme_disconnect(wdev, reason);
+        } else if (!rdev->ops->disconnect) {
+                cfg80211_mlme_down(rdev, dev);
+                err = 0;
         } else {
                 err = rdev_disconnect(rdev, dev, reason);
-                if (err)
-                        return err;
         }
 
- disconnect:
-        if (wdev->sme_state == CFG80211_SME_CONNECTED)
-                __cfg80211_disconnected(dev, NULL, 0, 0, false);
-        else if (wdev->sme_state == CFG80211_SME_CONNECTING)
-                __cfg80211_connect_result(dev, NULL, NULL, 0, NULL, 0,
-                                          WLAN_STATUS_UNSPECIFIED_FAILURE,
-                                          wextev, NULL);
-
-        return 0;
-}
-
-void cfg80211_sme_disassoc(struct net_device *dev,
-                           struct cfg80211_internal_bss *bss)
-{
-        struct wireless_dev *wdev = dev->ieee80211_ptr;
-        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
-        u8 bssid[ETH_ALEN];
-
-        ASSERT_WDEV_LOCK(wdev);
-
-        if (!wdev->conn)
-                return;
-
-        if (wdev->conn->state == CFG80211_CONN_IDLE)
-                return;
-
-        /*
-         * Ok, so the association was made by this SME -- we don't
-         * want it any more so deauthenticate too.
-         */
-
-        memcpy(bssid, bss->pub.bssid, ETH_ALEN);
-
-        cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0,
-                             WLAN_REASON_DEAUTH_LEAVING, false);
+        return err;
 }