1 files changed, 262 insertions, 90 deletions

diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 245dce969b31..b82a12a9f0f1 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -131,13 +131,13 @@ void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
         if (unlikely(!sdata->u.mgd.associated))
                 return;
 
+        ifmgd->probe_send_count = 0;
+
         if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
                 return;
 
         mod_timer(&sdata->u.mgd.conn_mon_timer,
                   round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
-
-        ifmgd->probe_send_count = 0;
 }
 
 static int ecw2cw(int ecw)
@@ -531,6 +531,7 @@ static void ieee80211_add_vht_ie(struct ieee80211_sub_if_data *sdata,
         u8 *pos;
         u32 cap;
         struct ieee80211_sta_vht_cap vht_cap;
+        u32 mask, ap_bf_sts, our_bf_sts;
 
         BUILD_BUG_ON(sizeof(vht_cap) != sizeof(sband->vht_cap));
 
@@ -558,6 +559,16 @@ static void ieee80211_add_vht_ie(struct ieee80211_sub_if_data *sdata,
                         cpu_to_le32(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)))
                 cap &= ~IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
 
+        mask = IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
+
+        ap_bf_sts = le32_to_cpu(ap_vht_cap->vht_cap_info) & mask;
+        our_bf_sts = cap & mask;
+
+        if (ap_bf_sts < our_bf_sts) {
+                cap &= ~mask;
+                cap |= ap_bf_sts;
+        }
+
         /* reserve and fill IE */
         pos = skb_put(skb, sizeof(struct ieee80211_vht_cap) + 2);
         ieee80211_ie_build_vht_cap(pos, &vht_cap, cap);
@@ -768,6 +779,34 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
                 ieee80211_add_ht_ie(sdata, skb, assoc_data->ap_ht_param,
                                     sband, chan, sdata->smps_mode);
 
+        /* if present, add any custom IEs that go before VHT */
+        if (assoc_data->ie_len) {
+                static const u8 before_vht[] = {
+                        WLAN_EID_SSID,
+                        WLAN_EID_SUPP_RATES,
+                        WLAN_EID_EXT_SUPP_RATES,
+                        WLAN_EID_PWR_CAPABILITY,
+                        WLAN_EID_SUPPORTED_CHANNELS,
+                        WLAN_EID_RSN,
+                        WLAN_EID_QOS_CAPA,
+                        WLAN_EID_RRM_ENABLED_CAPABILITIES,
+                        WLAN_EID_MOBILITY_DOMAIN,
+                        WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
+                        WLAN_EID_HT_CAPABILITY,
+                        WLAN_EID_BSS_COEX_2040,
+                        WLAN_EID_EXT_CAPABILITY,
+                        WLAN_EID_QOS_TRAFFIC_CAPA,
+                        WLAN_EID_TIM_BCAST_REQ,
+                        WLAN_EID_INTERWORKING,
+                };
+                noffset = ieee80211_ie_split(assoc_data->ie, assoc_data->ie_len,
+                                             before_vht, ARRAY_SIZE(before_vht),
+                                             offset);
+                pos = skb_put(skb, noffset - offset);
+                memcpy(pos, assoc_data->ie + offset, noffset - offset);
+                offset = noffset;
+        }
+
         if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
                 ieee80211_add_vht_ie(sdata, skb, sband,
                                      &assoc_data->ap_vht_cap);
@@ -791,16 +830,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
                         qos_info = 0;
                 }
 
-                pos = skb_put(skb, 9);
-                *pos++ = WLAN_EID_VENDOR_SPECIFIC;
-                *pos++ = 7; /* len */
-                *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
-                *pos++ = 0x50;
-                *pos++ = 0xf2;
-                *pos++ = 2; /* WME */
-                *pos++ = 0; /* WME info */
-                *pos++ = 1; /* WME ver */
-                *pos++ = qos_info;
+                pos = ieee80211_add_wmm_info_ie(skb_put(skb, 9), qos_info);
         }
 
         /* add any remaining custom (i.e. vendor specific here) IEs */
@@ -901,51 +931,77 @@ static void ieee80211_chswitch_work(struct work_struct *work)
                 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-        u32 changed = 0;
         int ret;
 
         if (!ieee80211_sdata_running(sdata))
                 return;
 
         sdata_lock(sdata);
+        mutex_lock(&local->mtx);
+        mutex_lock(&local->chanctx_mtx);
+
         if (!ifmgd->associated)
                 goto out;
 
-        mutex_lock(&local->mtx);
-        ret = ieee80211_vif_change_channel(sdata, &changed);
-        mutex_unlock(&local->mtx);
-        if (ret) {
+        if (!sdata->vif.csa_active)
+                goto out;
+
+        /*
+         * using reservation isn't immediate as it may be deferred until later
+         * with multi-vif. once reservation is complete it will re-schedule the
+         * work with no reserved_chanctx so verify chandef to check if it
+         * completed successfully
+         */
+
+        if (sdata->reserved_chanctx) {
+                /*
+                 * with multi-vif csa driver may call ieee80211_csa_finish()
+                 * many times while waiting for other interfaces to use their
+                 * reservations
+                 */
+                if (sdata->reserved_ready)
+                        goto out;
+
+                ret = ieee80211_vif_use_reserved_context(sdata);
+                if (ret) {
+                        sdata_info(sdata,
+                                   "failed to use reserved channel context, disconnecting (err=%d)\n",
+                                   ret);
+                        ieee80211_queue_work(&sdata->local->hw,
+                                             &ifmgd->csa_connection_drop_work);
+                        goto out;
+                }
+
+                goto out;
+        }
+
+        if (!cfg80211_chandef_identical(&sdata->vif.bss_conf.chandef,
+                                        &sdata->csa_chandef)) {
                 sdata_info(sdata,
-                           "vif channel switch failed, disconnecting\n");
+                           "failed to finalize channel switch, disconnecting\n");
                 ieee80211_queue_work(&sdata->local->hw,
                                      &ifmgd->csa_connection_drop_work);
                 goto out;
         }
 
-        if (!local->use_chanctx) {
-                local->_oper_chandef = sdata->csa_chandef;
-                /* Call "hw_config" only if doing sw channel switch.
-                 * Otherwise update the channel directly
-                 */
-                if (!local->ops->channel_switch)
-                        ieee80211_hw_config(local, 0);
-                else
-                        local->hw.conf.chandef = local->_oper_chandef;
-        }
-
         /* XXX: shouldn't really modify cfg80211-owned data! */
         ifmgd->associated->channel = sdata->csa_chandef.chan;
 
+        sdata->vif.csa_active = false;
+
         /* XXX: wait for a beacon first? */
-        ieee80211_wake_queues_by_reason(&local->hw,
-                                        IEEE80211_MAX_QUEUE_MAP,
-                                        IEEE80211_QUEUE_STOP_REASON_CSA);
+        if (sdata->csa_block_tx) {
+                ieee80211_wake_vif_queues(local, sdata,
+                                          IEEE80211_QUEUE_STOP_REASON_CSA);
+                sdata->csa_block_tx = false;
+        }
 
-        ieee80211_bss_info_change_notify(sdata, changed);
+        ieee80211_sta_reset_beacon_monitor(sdata);
+        ieee80211_sta_reset_conn_monitor(sdata);
 
- out:
-        sdata->vif.csa_active = false;
-        ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
+out:
+        mutex_unlock(&local->chanctx_mtx);
+        mutex_unlock(&local->mtx);
         sdata_unlock(sdata);
 }
 
@@ -982,6 +1038,7 @@ ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct cfg80211_bss *cbss = ifmgd->associated;
+        struct ieee80211_chanctx_conf *conf;
         struct ieee80211_chanctx *chanctx;
         enum ieee80211_band current_band;
         struct ieee80211_csa_ie csa_ie;
@@ -996,7 +1053,7 @@ ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                 return;
 
         /* disregard subsequent announcements if we are already processing */
-        if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
+        if (sdata->vif.csa_active)
                 return;
 
         current_band = cbss->channel->band;
@@ -1023,10 +1080,22 @@ ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                 return;
         }
 
-        ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
-        sdata->vif.csa_active = true;
-
+        mutex_lock(&local->mtx);
         mutex_lock(&local->chanctx_mtx);
+        conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
+                                         lockdep_is_held(&local->chanctx_mtx));
+        if (!conf) {
+                sdata_info(sdata,
+                           "no channel context assigned to vif?, disconnecting\n");
+                ieee80211_queue_work(&local->hw,
+                                     &ifmgd->csa_connection_drop_work);
+                mutex_unlock(&local->chanctx_mtx);
+                mutex_unlock(&local->mtx);
+                return;
+        }
+
+        chanctx = container_of(conf, struct ieee80211_chanctx, conf);
+
         if (local->use_chanctx) {
                 u32 num_chanctx = 0;
                 list_for_each_entry(chanctx, &local->chanctx_list, list)
@@ -1039,34 +1108,33 @@ ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                         ieee80211_queue_work(&local->hw,
                                              &ifmgd->csa_connection_drop_work);
                         mutex_unlock(&local->chanctx_mtx);
+                        mutex_unlock(&local->mtx);
                         return;
                 }
         }
 
-        if (WARN_ON(!rcu_access_pointer(sdata->vif.chanctx_conf))) {
-                ieee80211_queue_work(&local->hw,
-                                     &ifmgd->csa_connection_drop_work);
-                mutex_unlock(&local->chanctx_mtx);
-                return;
-        }
-        chanctx = container_of(rcu_access_pointer(sdata->vif.chanctx_conf),
-                               struct ieee80211_chanctx, conf);
-        if (chanctx->refcount > 1) {
+        res = ieee80211_vif_reserve_chanctx(sdata, &csa_ie.chandef,
+                                            chanctx->mode, false);
+        if (res) {
                 sdata_info(sdata,
-                           "channel switch with multiple interfaces on the same channel, disconnecting\n");
+                           "failed to reserve channel context for channel switch, disconnecting (err=%d)\n",
+                           res);
                 ieee80211_queue_work(&local->hw,
                                      &ifmgd->csa_connection_drop_work);
                 mutex_unlock(&local->chanctx_mtx);
+                mutex_unlock(&local->mtx);
                 return;
         }
         mutex_unlock(&local->chanctx_mtx);
 
+        sdata->vif.csa_active = true;
         sdata->csa_chandef = csa_ie.chandef;
+        sdata->csa_block_tx = csa_ie.mode;
 
-        if (csa_ie.mode)
-                ieee80211_stop_queues_by_reason(&local->hw,
-                                IEEE80211_MAX_QUEUE_MAP,
-                                IEEE80211_QUEUE_STOP_REASON_CSA);
+        if (sdata->csa_block_tx)
+                ieee80211_stop_vif_queues(local, sdata,
+                                          IEEE80211_QUEUE_STOP_REASON_CSA);
+        mutex_unlock(&local->mtx);
 
         if (local->ops->channel_switch) {
                 /* use driver's channel switch callback */
@@ -1335,7 +1403,8 @@ void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
 
         ieee80211_wake_queues_by_reason(&local->hw,
                                         IEEE80211_MAX_QUEUE_MAP,
-                                        IEEE80211_QUEUE_STOP_REASON_PS);
+                                        IEEE80211_QUEUE_STOP_REASON_PS,
+                                        false);
 }
 
 void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
@@ -1778,6 +1847,13 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
         ifmgd->flags = 0;
         mutex_lock(&local->mtx);
         ieee80211_vif_release_channel(sdata);
+
+        sdata->vif.csa_active = false;
+        if (sdata->csa_block_tx) {
+                ieee80211_wake_vif_queues(local, sdata,
+                                          IEEE80211_QUEUE_STOP_REASON_CSA);
+                sdata->csa_block_tx = false;
+        }
         mutex_unlock(&local->mtx);
 
         sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
@@ -2006,6 +2082,7 @@ EXPORT_SYMBOL(ieee80211_ap_probereq_get);
 
 static void __ieee80211_disconnect(struct ieee80211_sub_if_data *sdata)
 {
+        struct ieee80211_local *local = sdata->local;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
 
@@ -2018,11 +2095,14 @@ static void __ieee80211_disconnect(struct ieee80211_sub_if_data *sdata)
         ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
                                WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
                                true, frame_buf);
-        ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
+        mutex_lock(&local->mtx);
         sdata->vif.csa_active = false;
-        ieee80211_wake_queues_by_reason(&sdata->local->hw,
-                                        IEEE80211_MAX_QUEUE_MAP,
-                                        IEEE80211_QUEUE_STOP_REASON_CSA);
+        if (sdata->csa_block_tx) {
+                ieee80211_wake_vif_queues(local, sdata,
+                                          IEEE80211_QUEUE_STOP_REASON_CSA);
+                sdata->csa_block_tx = false;
+        }
+        mutex_unlock(&local->mtx);
 
         cfg80211_tx_mlme_mgmt(sdata->dev, frame_buf,
                               IEEE80211_DEAUTH_FRAME_LEN);
@@ -2233,6 +2313,62 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
         /* ignore frame -- wait for timeout */
 }
 
+#define case_WLAN(type) \
+        case WLAN_REASON_##type: return #type
+
+static const char *ieee80211_get_reason_code_string(u16 reason_code)
+{
+        switch (reason_code) {
+        case_WLAN(UNSPECIFIED);
+        case_WLAN(PREV_AUTH_NOT_VALID);
+        case_WLAN(DEAUTH_LEAVING);
+        case_WLAN(DISASSOC_DUE_TO_INACTIVITY);
+        case_WLAN(DISASSOC_AP_BUSY);
+        case_WLAN(CLASS2_FRAME_FROM_NONAUTH_STA);
+        case_WLAN(CLASS3_FRAME_FROM_NONASSOC_STA);
+        case_WLAN(DISASSOC_STA_HAS_LEFT);
+        case_WLAN(STA_REQ_ASSOC_WITHOUT_AUTH);
+        case_WLAN(DISASSOC_BAD_POWER);
+        case_WLAN(DISASSOC_BAD_SUPP_CHAN);
+        case_WLAN(INVALID_IE);
+        case_WLAN(MIC_FAILURE);
+        case_WLAN(4WAY_HANDSHAKE_TIMEOUT);
+        case_WLAN(GROUP_KEY_HANDSHAKE_TIMEOUT);
+        case_WLAN(IE_DIFFERENT);
+        case_WLAN(INVALID_GROUP_CIPHER);
+        case_WLAN(INVALID_PAIRWISE_CIPHER);
+        case_WLAN(INVALID_AKMP);
+        case_WLAN(UNSUPP_RSN_VERSION);
+        case_WLAN(INVALID_RSN_IE_CAP);
+        case_WLAN(IEEE8021X_FAILED);
+        case_WLAN(CIPHER_SUITE_REJECTED);
+        case_WLAN(DISASSOC_UNSPECIFIED_QOS);
+        case_WLAN(DISASSOC_QAP_NO_BANDWIDTH);
+        case_WLAN(DISASSOC_LOW_ACK);
+        case_WLAN(DISASSOC_QAP_EXCEED_TXOP);
+        case_WLAN(QSTA_LEAVE_QBSS);
+        case_WLAN(QSTA_NOT_USE);
+        case_WLAN(QSTA_REQUIRE_SETUP);
+        case_WLAN(QSTA_TIMEOUT);
+        case_WLAN(QSTA_CIPHER_NOT_SUPP);
+        case_WLAN(MESH_PEER_CANCELED);
+        case_WLAN(MESH_MAX_PEERS);
+        case_WLAN(MESH_CONFIG);
+        case_WLAN(MESH_CLOSE);
+        case_WLAN(MESH_MAX_RETRIES);
+        case_WLAN(MESH_CONFIRM_TIMEOUT);
+        case_WLAN(MESH_INVALID_GTK);
+        case_WLAN(MESH_INCONSISTENT_PARAM);
+        case_WLAN(MESH_INVALID_SECURITY);
+        case_WLAN(MESH_PATH_ERROR);
+        case_WLAN(MESH_PATH_NOFORWARD);
+        case_WLAN(MESH_PATH_DEST_UNREACHABLE);
+        case_WLAN(MAC_EXISTS_IN_MBSS);
+        case_WLAN(MESH_CHAN_REGULATORY);
+        case_WLAN(MESH_CHAN);
+        default: return "<unknown>";
+        }
+}
 
 static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
                                      struct ieee80211_mgmt *mgmt, size_t len)
@@ -2254,8 +2390,8 @@ static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
 
         reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 
-        sdata_info(sdata, "deauthenticated from %pM (Reason: %u)\n",
-                   bssid, reason_code);
+        sdata_info(sdata, "deauthenticated from %pM (Reason: %u=%s)\n",
+                   bssid, reason_code, ieee80211_get_reason_code_string(reason_code));
 
         ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
 
@@ -2688,28 +2824,20 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
                                   struct ieee802_11_elems *elems)
 {
         struct ieee80211_local *local = sdata->local;
-        int freq;
         struct ieee80211_bss *bss;
         struct ieee80211_channel *channel;
 
         sdata_assert_lock(sdata);
 
-        if (elems->ds_params)
-                freq = ieee80211_channel_to_frequency(elems->ds_params[0],
-                                                      rx_status->band);
-        else
-                freq = rx_status->freq;
-
-        channel = ieee80211_get_channel(local->hw.wiphy, freq);
-
-        if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
+        channel = ieee80211_get_channel(local->hw.wiphy, rx_status->freq);
+        if (!channel)
                 return;
 
         bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
                                         channel);
         if (bss) {
-                ieee80211_rx_bss_put(local, bss);
                 sdata->vif.bss_conf.beacon_rate = bss->beacon_rate;
+                ieee80211_rx_bss_put(local, bss);
         }
 }
 
@@ -3459,6 +3587,9 @@ static void ieee80211_sta_bcn_mon_timer(unsigned long data)
         if (local->quiescing)
                 return;
 
+        if (sdata->vif.csa_active)
+                return;
+
         sdata->u.mgd.connection_loss = false;
         ieee80211_queue_work(&sdata->local->hw,
                              &sdata->u.mgd.beacon_connection_loss_work);
@@ -3474,6 +3605,9 @@ static void ieee80211_sta_conn_mon_timer(unsigned long data)
         if (local->quiescing)
                 return;
 
+        if (sdata->vif.csa_active)
+                return;
+
         ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
 }
 
@@ -3504,6 +3638,38 @@ static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
 }
 
 #ifdef CONFIG_PM
+void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+        u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
+
+        sdata_lock(sdata);
+
+        if (ifmgd->auth_data || ifmgd->assoc_data) {
+                const u8 *bssid = ifmgd->auth_data ?
+                                ifmgd->auth_data->bss->bssid :
+                                ifmgd->assoc_data->bss->bssid;
+
+                /*
+                 * If we are trying to authenticate / associate while suspending,
+                 * cfg80211 won't know and won't actually abort those attempts,
+                 * thus we need to do that ourselves.
+                 */
+                ieee80211_send_deauth_disassoc(sdata, bssid,
+                                               IEEE80211_STYPE_DEAUTH,
+                                               WLAN_REASON_DEAUTH_LEAVING,
+                                               false, frame_buf);
+                if (ifmgd->assoc_data)
+                        ieee80211_destroy_assoc_data(sdata, false);
+                if (ifmgd->auth_data)
+                        ieee80211_destroy_auth_data(sdata, false);
+                cfg80211_tx_mlme_mgmt(sdata->dev, frame_buf,
+                                      IEEE80211_DEAUTH_FRAME_LEN);
+        }
+
+        sdata_unlock(sdata);
+}
+
 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
@@ -3541,6 +3707,8 @@ void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
         INIT_WORK(&ifmgd->csa_connection_drop_work,
                   ieee80211_csa_connection_drop_work);
         INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_mgd_work);
+        INIT_DELAYED_WORK(&ifmgd->tdls_peer_del_work,
+                          ieee80211_tdls_peer_del_work);
         setup_timer(&ifmgd->timer, ieee80211_sta_timer,
                     (unsigned long) sdata);
         setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
@@ -3588,7 +3756,7 @@ int ieee80211_max_network_latency(struct notifier_block *nb,
         ieee80211_recalc_ps(local, latency_usec);
         mutex_unlock(&local->iflist_mtx);
 
-        return 0;
+        return NOTIFY_OK;
 }
 
 static u8 ieee80211_ht_vht_rx_chains(struct ieee80211_sub_if_data *sdata,
@@ -4208,8 +4376,7 @@ int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
         rcu_read_unlock();
 
         if (bss->wmm_used && bss->uapsd_supported &&
-            (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD) &&
-            sdata->wmm_acm != 0xff) {
+            (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
                 assoc_data->uapsd = true;
                 ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
         } else {
@@ -4322,37 +4489,41 @@ int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
         bool tx = !req->local_state_change;
-        bool report_frame = false;
 
-        sdata_info(sdata,
-                   "deauthenticating from %pM by local choice (reason=%d)\n",
-                   req->bssid, req->reason_code);
+        if (ifmgd->auth_data &&
+            ether_addr_equal(ifmgd->auth_data->bss->bssid, req->bssid)) {
+                sdata_info(sdata,
+                           "aborting authentication with %pM by local choice (Reason: %u=%s)\n",
+                           req->bssid, req->reason_code,
+                           ieee80211_get_reason_code_string(req->reason_code));
 
-        if (ifmgd->auth_data) {
                 drv_mgd_prepare_tx(sdata->local, sdata);
                 ieee80211_send_deauth_disassoc(sdata, req->bssid,
                                                IEEE80211_STYPE_DEAUTH,
                                                req->reason_code, tx,
                                                frame_buf);
                 ieee80211_destroy_auth_data(sdata, false);
+                cfg80211_tx_mlme_mgmt(sdata->dev, frame_buf,
+                                      IEEE80211_DEAUTH_FRAME_LEN);
 
-                report_frame = true;
-                goto out;
+                return 0;
         }
 
         if (ifmgd->associated &&
             ether_addr_equal(ifmgd->associated->bssid, req->bssid)) {
+                sdata_info(sdata,
+                           "deauthenticating from %pM by local choice (Reason: %u=%s)\n",
+                           req->bssid, req->reason_code,
+                           ieee80211_get_reason_code_string(req->reason_code));
+
                 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
                                        req->reason_code, tx, frame_buf);
-                report_frame = true;
-        }
-
- out:
-        if (report_frame)
                 cfg80211_tx_mlme_mgmt(sdata->dev, frame_buf,
                                       IEEE80211_DEAUTH_FRAME_LEN);
+                return 0;
+        }
 
-        return 0;
+        return -ENOTCONN;
 }
 
 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
@@ -4372,8 +4543,8 @@ int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
                 return -ENOLINK;
 
         sdata_info(sdata,
-                   "disassociating from %pM by local choice (reason=%d)\n",
-                   req->bss->bssid, req->reason_code);
+                   "disassociating from %pM by local choice (Reason: %u=%s)\n",
+                   req->bss->bssid, req->reason_code, ieee80211_get_reason_code_string(req->reason_code));
 
         memcpy(bssid, req->bss->bssid, ETH_ALEN);
         ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DISASSOC,
@@ -4400,6 +4571,7 @@ void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata)
         cancel_work_sync(&ifmgd->request_smps_work);
         cancel_work_sync(&ifmgd->csa_connection_drop_work);
         cancel_work_sync(&ifmgd->chswitch_work);
+        cancel_delayed_work_sync(&ifmgd->tdls_peer_del_work);
 
         sdata_lock(sdata);
         if (ifmgd->assoc_data) {