20 files changed, 212 insertions, 127 deletions

diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index 363d19b5d5c8..1acb29109b45 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -1347,9 +1347,6 @@ static int sta_apply_parameters(struct ieee80211_local *local,
                                                     params->vht_capa, sta);
 
         if (params->opmode_notif_used) {
-                enum ieee80211_band band =
-                        ieee80211_get_sdata_band(sdata);
-
                 /* returned value is only needed for rc update, but the
                  * rc isn't initialized here yet, so ignore it
                  */
@@ -3647,8 +3644,8 @@ ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev,
 
 static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
                                u8 *peer, u8 action_code, u8 dialog_token,
-                               u16 status_code, const u8 *extra_ies,
-                               size_t extra_ies_len)
+                               u16 status_code, u32 peer_capability,
+                               const u8 *extra_ies, size_t extra_ies_len)
 {
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         struct ieee80211_local *local = sdata->local;
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index ebf80f3abd83..40a648938985 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -358,6 +358,18 @@ static ssize_t ieee80211_if_parse_tkip_mic_test(
 }
 IEEE80211_IF_FILE_W(tkip_mic_test);
 
+static ssize_t ieee80211_if_parse_beacon_loss(
+        struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
+{
+        if (!ieee80211_sdata_running(sdata) || !sdata->vif.bss_conf.assoc)
+                return -ENOTCONN;
+
+        ieee80211_beacon_loss(&sdata->vif);
+
+        return buflen;
+}
+IEEE80211_IF_FILE_W(beacon_loss);
+
 static ssize_t ieee80211_if_fmt_uapsd_queues(
         const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
 {
@@ -569,6 +581,7 @@ static void add_sta_files(struct ieee80211_sub_if_data *sdata)
         DEBUGFS_ADD(beacon_timeout);
         DEBUGFS_ADD_MODE(smps, 0600);
         DEBUGFS_ADD_MODE(tkip_mic_test, 0200);
+        DEBUGFS_ADD_MODE(beacon_loss, 0200);
         DEBUGFS_ADD_MODE(uapsd_queues, 0600);
         DEBUGFS_ADD_MODE(uapsd_max_sp_len, 0600);
 }
diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h
index ef8b385eff04..fc689f5d971e 100644
--- a/net/mac80211/driver-ops.h
+++ b/net/mac80211/driver-ops.h
@@ -354,16 +354,20 @@ drv_sched_scan_start(struct ieee80211_local *local,
         return ret;
 }
 
-static inline void drv_sched_scan_stop(struct ieee80211_local *local,
-                                       struct ieee80211_sub_if_data *sdata)
+static inline int drv_sched_scan_stop(struct ieee80211_local *local,
+                                      struct ieee80211_sub_if_data *sdata)
 {
+        int ret;
+
         might_sleep();
 
         check_sdata_in_driver(sdata);
 
         trace_drv_sched_scan_stop(local, sdata);
-        local->ops->sched_scan_stop(&local->hw, &sdata->vif);
-        trace_drv_return_void(local);
+        ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
+        trace_drv_return_int(local, ret);
+
+        return ret;
 }
 
 static inline void drv_sw_scan_start(struct ieee80211_local *local)
diff --git a/net/mac80211/ht.c b/net/mac80211/ht.c
index afbe2b203c3e..c150b68436d7 100644
--- a/net/mac80211/ht.c
+++ b/net/mac80211/ht.c
@@ -482,8 +482,6 @@ void ieee80211_request_smps(struct ieee80211_vif *vif,
                 return;
 
         if (vif->type == NL80211_IFTYPE_STATION) {
-                if (WARN_ON(smps_mode == IEEE80211_SMPS_OFF))
-                        smps_mode = IEEE80211_SMPS_AUTOMATIC;
                 if (sdata->u.mgd.driver_smps_mode == smps_mode)
                         return;
                 sdata->u.mgd.driver_smps_mode = smps_mode;
diff --git a/net/mac80211/ibss.c b/net/mac80211/ibss.c
index 4453e2725e40..e458ca0dffec 100644
--- a/net/mac80211/ibss.c
+++ b/net/mac80211/ibss.c
@@ -283,6 +283,11 @@ static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
 
         err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
                                             &chandef);
+        if (err < 0) {
+                sdata_info(sdata,
+                           "Failed to join IBSS, invalid chandef\n");
+                return;
+        }
         if (err > 0) {
                 if (!ifibss->userspace_handles_dfs) {
                         sdata_info(sdata,
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 0014b5396ce5..8603dfb52b3a 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -1242,6 +1242,8 @@ struct ieee80211_local {
 
         struct ieee80211_sub_if_data __rcu *p2p_sdata;
 
+        struct napi_struct *napi;
+
         /* virtual monitor interface */
         struct ieee80211_sub_if_data __rcu *monitor_sdata;
         struct cfg80211_chan_def monitor_chandef;
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 96518ad200c4..be198f42f1f7 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -101,9 +101,8 @@ static u32 __ieee80211_idle_on(struct ieee80211_local *local)
 static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
                                    bool force_active)
 {
-        bool working = false, scanning, active;
+        bool working, scanning, active;
         unsigned int led_trig_start = 0, led_trig_stop = 0;
-        struct ieee80211_roc_work *roc;
 
         lockdep_assert_held(&local->mtx);
 
@@ -111,12 +110,8 @@ static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
                  !list_empty(&local->chanctx_list) ||
                  local->monitors;
 
-        if (!local->ops->remain_on_channel) {
-                list_for_each_entry(roc, &local->roc_list, list) {
-                        working = true;
-                        break;
-                }
-        }
+        working = !local->ops->remain_on_channel &&
+                  !list_empty(&local->roc_list);
 
         scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
                    test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index 1f7d8422d62d..b055f6a55c68 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -1076,6 +1076,18 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
 }
 EXPORT_SYMBOL(ieee80211_register_hw);
 
+void ieee80211_napi_add(struct ieee80211_hw *hw, struct napi_struct *napi,
+                        struct net_device *napi_dev,
+                        int (*poll)(struct napi_struct *, int),
+                        int weight)
+{
+        struct ieee80211_local *local = hw_to_local(hw);
+
+        netif_napi_add(napi_dev, napi, poll, weight);
+        local->napi = napi;
+}
+EXPORT_SYMBOL_GPL(ieee80211_napi_add);
+
 void ieee80211_unregister_hw(struct ieee80211_hw *hw)
 {
         struct ieee80211_local *local = hw_to_local(hw);
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 61604834b914..46b62bb3677c 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)
@@ -2249,6 +2249,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)
@@ -2270,8 +2326,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);
 
@@ -4340,8 +4396,8 @@ int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
         bool report_frame = false;
 
         sdata_info(sdata,
-                   "deauthenticating from %pM by local choice (reason=%d)\n",
-                   req->bssid, req->reason_code);
+                   "deauthenticating from %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);
@@ -4387,8 +4443,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,
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 593062109c50..58e4b7052d17 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -1954,7 +1954,10 @@ ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
                 /* deliver to local stack */
                 skb->protocol = eth_type_trans(skb, dev);
                 memset(skb->cb, 0, sizeof(skb->cb));
-                netif_receive_skb(skb);
+                if (rx->local->napi)
+                        napi_gro_receive(rx->local->napi, skb);
+                else
+                        netif_receive_skb(skb);
         }
 
         if (xmit_skb) {
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 88c81616f8f7..836f500dfbf3 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -472,9 +472,7 @@ static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
         if (local->ops->hw_scan) {
                 u8 *ies;
 
-                local->hw_scan_ies_bufsize = 2 + IEEE80211_MAX_SSID_LEN +
-                                             local->scan_ies_len +
-                                             req->ie_len;
+                local->hw_scan_ies_bufsize = local->scan_ies_len + req->ie_len;
                 local->hw_scan_req = kmalloc(
                                 sizeof(*local->hw_scan_req) +
                                 req->n_channels * sizeof(req->channels[0]) +
@@ -979,8 +977,7 @@ int __ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
         struct cfg80211_chan_def chandef;
         int ret, i, iebufsz;
 
-        iebufsz = 2 + IEEE80211_MAX_SSID_LEN +
-                  local->scan_ies_len + req->ie_len;
+        iebufsz = local->scan_ies_len + req->ie_len;
 
         lockdep_assert_held(&local->mtx);
 
@@ -1059,7 +1056,7 @@ int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata)
         local->sched_scan_req = NULL;
 
         if (rcu_access_pointer(local->sched_scan_sdata))
-                drv_sched_scan_stop(local, sdata);
+                ret = drv_sched_scan_stop(local, sdata);
 
 out:
         mutex_unlock(&local->mtx);
diff --git a/net/wireless/chan.c b/net/wireless/chan.c
index f8ab7df1ab0d..5946450c5406 100644
--- a/net/wireless/chan.c
+++ b/net/wireless/chan.c
@@ -705,12 +705,8 @@ cfg80211_get_chan_state(struct wireless_dev *wdev,
         case NL80211_IFTYPE_MONITOR:
         case NL80211_IFTYPE_AP_VLAN:
         case NL80211_IFTYPE_WDS:
-                /* these interface types don't really have a channel */
-                return;
         case NL80211_IFTYPE_P2P_DEVICE:
-                if (wdev->wiphy->features &
-                                NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
-                        *chanmode = CHAN_MODE_EXCLUSIVE;
+                /* these interface types don't really have a channel */
                 return;
         case NL80211_IFTYPE_UNSPECIFIED:
         case NUM_NL80211_IFTYPES:
diff --git a/net/wireless/genregdb.awk b/net/wireless/genregdb.awk
index 9a8217d2a908..fdfd3f063a9b 100644
--- a/net/wireless/genregdb.awk
+++ b/net/wireless/genregdb.awk
@@ -105,6 +105,8 @@ function parse_reg_rule()
                         flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
                 } else if (flagarray[arg] == "NO-IR") {
                         flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
+                } else if (flagarray[arg] == "AUTO-BW") {
+                        flags = flags "\n\t\t\tNL80211_RRF_AUTO_BW | "
                 }
 
         }
diff --git a/net/wireless/ibss.c b/net/wireless/ibss.c
index 1470b90e438f..349db9ddc0d1 100644
--- a/net/wireless/ibss.c
+++ b/net/wireless/ibss.c
@@ -128,12 +128,11 @@ int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
 #endif
         check_chan = params->chandef.chan;
         if (params->userspace_handles_dfs) {
-                /* use channel NULL to check for radar even if the current
-                 * channel is not a radar channel - it might decide to change
-                 * to DFS channel later.
+                /* Check for radar even if the current channel is not
+                 * a radar channel - it might decide to change to DFS
+                 * channel later.
                  */
                 radar_detect_width = BIT(params->chandef.width);
-                check_chan = NULL;
         }
 
         err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
diff --git a/net/wireless/mesh.c b/net/wireless/mesh.c
index d42a3fcb2f67..5af5cc6b2c4c 100644
--- a/net/wireless/mesh.c
+++ b/net/wireless/mesh.c
@@ -236,6 +236,12 @@ int cfg80211_set_mesh_channel(struct cfg80211_registered_device *rdev,
                 if (!netif_running(wdev->netdev))
                         return -ENETDOWN;
 
+                /* cfg80211_can_use_chan() calls
+                 * cfg80211_can_use_iftype_chan() with no radar
+                 * detection, so if we're trying to use a radar
+                 * channel here, something is wrong.
+                 */
+                WARN_ON_ONCE(chandef->chan->flags & IEEE80211_CHAN_RADAR);
                 err = cfg80211_can_use_chan(rdev, wdev, chandef->chan,
                                             CHAN_MODE_SHARED);
                 if (err)
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 8e6b6a2d35cb..2c38b28a85b9 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -384,6 +384,7 @@ static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
                                    .len = IEEE80211_QOS_MAP_LEN_MAX },
         [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
         [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
+        [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
 };
 
 /* policy for the key attributes */
@@ -4627,6 +4628,8 @@ static int parse_reg_rule(struct nlattr *tb[],
                 return -EINVAL;
         if (!tb[NL80211_ATTR_FREQ_RANGE_END])
                 return -EINVAL;
+        if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
+                return -EINVAL;
         if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
                 return -EINVAL;
 
@@ -4636,9 +4639,8 @@ static int parse_reg_rule(struct nlattr *tb[],
                 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
         freq_range->end_freq_khz =
                 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
-        if (tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
-                freq_range->max_bandwidth_khz =
-                        nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
+        freq_range->max_bandwidth_khz =
+                nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
 
         power_rule->max_eirp =
                 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
@@ -5710,8 +5712,8 @@ static int nl80211_start_sched_scan(struct sk_buff *skb,
                 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
         }
 
-        if (info->attrs[NL80211_ATTR_IE]) {
-                request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        if (ie_len) {
+                request->ie_len = ie_len;
                 memcpy((void *)request->ie,
                        nla_data(info->attrs[NL80211_ATTR_IE]),
                        request->ie_len);
@@ -5911,17 +5913,22 @@ skip_beacons:
         if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef))
                 return -EINVAL;
 
-        if (dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP ||
-            dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO ||
-            dev->ieee80211_ptr->iftype == NL80211_IFTYPE_ADHOC) {
+        switch (dev->ieee80211_ptr->iftype) {
+        case NL80211_IFTYPE_AP:
+        case NL80211_IFTYPE_P2P_GO:
+        case NL80211_IFTYPE_ADHOC:
+        case NL80211_IFTYPE_MESH_POINT:
                 err = cfg80211_chandef_dfs_required(wdev->wiphy,
                                                     &params.chandef);
-                if (err < 0) {
+                if (err < 0)
                         return err;
-                } else if (err) {
+                if (err) {
                         radar_detect_width = BIT(params.chandef.width);
                         params.radar_required = true;
                 }
+                break;
+        default:
+                break;
         }
 
         err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
@@ -7269,6 +7276,7 @@ static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
         struct net_device *dev = info->user_ptr[1];
         u8 action_code, dialog_token;
+        u32 peer_capability = 0;
         u16 status_code;
         u8 *peer;
 
@@ -7287,9 +7295,12 @@ static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
         action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
         status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
         dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
+        if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
+                peer_capability =
+                        nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
 
         return rdev_tdls_mgmt(rdev, dev, peer, action_code,
-                              dialog_token, status_code,
+                              dialog_token, status_code, peer_capability,
                               nla_data(info->attrs[NL80211_ATTR_IE]),
                               nla_len(info->attrs[NL80211_ATTR_IE]));
 }
diff --git a/net/wireless/rdev-ops.h b/net/wireless/rdev-ops.h
index c8e225947adb..74d97d33c938 100644
--- a/net/wireless/rdev-ops.h
+++ b/net/wireless/rdev-ops.h
@@ -769,13 +769,16 @@ static inline int rdev_set_rekey_data(struct cfg80211_registered_device *rdev,
 static inline int rdev_tdls_mgmt(struct cfg80211_registered_device *rdev,
                                  struct net_device *dev, u8 *peer,
                                  u8 action_code, u8 dialog_token,
-                                 u16 status_code, const u8 *buf, size_t len)
+                                 u16 status_code, u32 peer_capability,
+                                 const u8 *buf, size_t len)
 {
         int ret;
         trace_rdev_tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
-                             dialog_token, status_code, buf, len);
+                             dialog_token, status_code, peer_capability,
+                             buf, len);
         ret = rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
-                                   dialog_token, status_code, buf, len);
+                                   dialog_token, status_code, peer_capability,
+                                   buf, len);
         trace_rdev_return_int(&rdev->wiphy, ret);
         return ret;
 }
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 27c5253e7a61..6b6f33ad78f2 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -563,9 +563,6 @@ unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
                 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
                         break;
 
-                if (freq_range_tmp->max_bandwidth_khz)
-                        break;
-
                 freq_range = freq_range_tmp;
         }
 
@@ -582,9 +579,6 @@ unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
                 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
                         break;
 
-                if (freq_range_tmp->max_bandwidth_khz)
-                        break;
-
                 freq_range = freq_range_tmp;
         }
 
@@ -729,21 +723,29 @@ static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
         max_bandwidth1 = freq_range1->max_bandwidth_khz;
         max_bandwidth2 = freq_range2->max_bandwidth_khz;
 
-        /*
-         * In case max_bandwidth1 == 0 and max_bandwith2 == 0 set
-         * output bandwidth as 0 (auto calculation). Next we will
-         * calculate this correctly in handle_channel function.
-         * In other case calculate output bandwidth here.
-         */
-        if (max_bandwidth1 || max_bandwidth2) {
-                if (!max_bandwidth1)
-                        max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
-                if (!max_bandwidth2)
-                        max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
-        }
+        if (rule1->flags & NL80211_RRF_AUTO_BW)
+                max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
+        if (rule2->flags & NL80211_RRF_AUTO_BW)
+                max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
 
         freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
 
+        intersected_rule->flags = rule1->flags | rule2->flags;
+
+        /*
+         * In case NL80211_RRF_AUTO_BW requested for both rules
+         * set AUTO_BW in intersected rule also. Next we will
+         * calculate BW correctly in handle_channel function.
+         * In other case remove AUTO_BW flag while we calculate
+         * maximum bandwidth correctly and auto calculation is
+         * not required.
+         */
+        if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
+            (rule2->flags & NL80211_RRF_AUTO_BW))
+                intersected_rule->flags |= NL80211_RRF_AUTO_BW;
+        else
+                intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
+
         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
         if (freq_range->max_bandwidth_khz > freq_diff)
                 freq_range->max_bandwidth_khz = freq_diff;
@@ -753,8 +755,6 @@ static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
                 power_rule2->max_antenna_gain);
 
-        intersected_rule->flags = rule1->flags | rule2->flags;
-
         if (!is_valid_reg_rule(intersected_rule))
                 return -EINVAL;
 
@@ -938,31 +938,42 @@ const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
 EXPORT_SYMBOL(reg_initiator_name);
 
 #ifdef CONFIG_CFG80211_REG_DEBUG
-static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
+static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain *regd,
+                                    struct ieee80211_channel *chan,
                                     const struct ieee80211_reg_rule *reg_rule)
 {
         const struct ieee80211_power_rule *power_rule;
         const struct ieee80211_freq_range *freq_range;
-        char max_antenna_gain[32];
+        char max_antenna_gain[32], bw[32];
 
         power_rule = &reg_rule->power_rule;
         freq_range = &reg_rule->freq_range;
 
         if (!power_rule->max_antenna_gain)
-                snprintf(max_antenna_gain, 32, "N/A");
+                snprintf(max_antenna_gain, sizeof(max_antenna_gain), "N/A");
         else
-                snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
+                snprintf(max_antenna_gain, sizeof(max_antenna_gain), "%d",
+                         power_rule->max_antenna_gain);
+
+        if (reg_rule->flags & NL80211_RRF_AUTO_BW)
+                snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
+                         freq_range->max_bandwidth_khz,
+                         reg_get_max_bandwidth(regd, reg_rule));
+        else
+                snprintf(bw, sizeof(bw), "%d KHz",
+                         freq_range->max_bandwidth_khz);
 
         REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
                       chan->center_freq);
 
-        REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
+        REG_DBG_PRINT("%d KHz - %d KHz @ %s), (%s mBi, %d mBm)\n",
                       freq_range->start_freq_khz, freq_range->end_freq_khz,
-                      freq_range->max_bandwidth_khz, max_antenna_gain,
+                      bw, max_antenna_gain,
                       power_rule->max_eirp);
 }
 #else
-static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
+static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain *regd,
+                                    struct ieee80211_channel *chan,
                                     const struct ieee80211_reg_rule *reg_rule)
 {
         return;
@@ -1022,17 +1033,16 @@ static void handle_channel(struct wiphy *wiphy,
                 return;
         }
 
-        chan_reg_rule_print_dbg(chan, reg_rule);
+        regd = reg_get_regdomain(wiphy);
+        chan_reg_rule_print_dbg(regd, chan, reg_rule);
 
         power_rule = &reg_rule->power_rule;
         freq_range = &reg_rule->freq_range;
 
         max_bandwidth_khz = freq_range->max_bandwidth_khz;
         /* Check if auto calculation requested */
-        if (!max_bandwidth_khz) {
-                regd = reg_get_regdomain(wiphy);
+        if (reg_rule->flags & NL80211_RRF_AUTO_BW)
                 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
-        }
 
         if (max_bandwidth_khz < MHZ_TO_KHZ(40))
                 bw_flags = IEEE80211_CHAN_NO_HT40;
@@ -1437,14 +1447,14 @@ static void handle_channel_custom(struct wiphy *wiphy,
                 return;
         }
 
-        chan_reg_rule_print_dbg(chan, reg_rule);
+        chan_reg_rule_print_dbg(regd, chan, reg_rule);
 
         power_rule = &reg_rule->power_rule;
         freq_range = &reg_rule->freq_range;
 
         max_bandwidth_khz = freq_range->max_bandwidth_khz;
         /* Check if auto calculation requested */
-        if (!max_bandwidth_khz)
+        if (reg_rule->flags & NL80211_RRF_AUTO_BW)
                 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
 
         if (max_bandwidth_khz < MHZ_TO_KHZ(40))
@@ -2254,11 +2264,12 @@ static void print_rd_rules(const struct ieee80211_regdomain *rd)
                 freq_range = &reg_rule->freq_range;
                 power_rule = &reg_rule->power_rule;
 
-                if (!freq_range->max_bandwidth_khz)
-                        snprintf(bw, 32, "%d KHz, AUTO",
+                if (reg_rule->flags & NL80211_RRF_AUTO_BW)
+                        snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
+                                 freq_range->max_bandwidth_khz,
                                  reg_get_max_bandwidth(rd, reg_rule));
                 else
-                        snprintf(bw, 32, "%d KHz",
+                        snprintf(bw, sizeof(bw), "%d KHz",
                                  freq_range->max_bandwidth_khz);
 
                 /*
diff --git a/net/wireless/trace.h b/net/wireless/trace.h
index 5eaeed59db07..aabccf13e07b 100644
--- a/net/wireless/trace.h
+++ b/net/wireless/trace.h
@@ -1468,9 +1468,10 @@ TRACE_EVENT(rdev_sched_scan_start,
 TRACE_EVENT(rdev_tdls_mgmt,
         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
                  u8 *peer, u8 action_code, u8 dialog_token,
-                 u16 status_code, const u8 *buf, size_t len),
+                 u16 status_code, u32 peer_capability,
+                 const u8 *buf, size_t len),
         TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code,
-                buf, len),
+                peer_capability, buf, len),
         TP_STRUCT__entry(
                 WIPHY_ENTRY
                 NETDEV_ENTRY
@@ -1478,6 +1479,7 @@ TRACE_EVENT(rdev_tdls_mgmt,
                 __field(u8, action_code)
                 __field(u8, dialog_token)
                 __field(u16, status_code)
+                __field(u32, peer_capability)
                 __dynamic_array(u8, buf, len)
         ),
         TP_fast_assign(
@@ -1487,13 +1489,15 @@ TRACE_EVENT(rdev_tdls_mgmt,
                 __entry->action_code = action_code;
                 __entry->dialog_token = dialog_token;
                 __entry->status_code = status_code;
+                __entry->peer_capability = peer_capability;
                 memcpy(__get_dynamic_array(buf), buf, len);
         ),
         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", action_code: %u, "
-                  "dialog_token: %u, status_code: %u, buf: %#.2x ",
+                  "dialog_token: %u, status_code: %u, peer_capability: %u buf: %#.2x ",
                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
                   __entry->action_code, __entry->dialog_token,
-                  __entry->status_code, ((u8 *)__get_dynamic_array(buf))[0])
+                  __entry->status_code, __entry->peer_capability,
+                  ((u8 *)__get_dynamic_array(buf))[0])
 );
 
 TRACE_EVENT(rdev_dump_survey,
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 780b4546c9c7..57b3ce7a6b92 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -1269,7 +1269,6 @@ int cfg80211_can_use_iftype_chan(struct cfg80211_registered_device *rdev,
         enum cfg80211_chan_mode chmode;
         int num_different_channels = 0;
         int total = 1;
-        bool radar_required = false;
         int i, j;
 
         ASSERT_RTNL();
@@ -1277,35 +1276,7 @@ int cfg80211_can_use_iftype_chan(struct cfg80211_registered_device *rdev,
         if (WARN_ON(hweight32(radar_detect) > 1))
                 return -EINVAL;
 
-        switch (iftype) {
-        case NL80211_IFTYPE_ADHOC:
-        case NL80211_IFTYPE_AP:
-        case NL80211_IFTYPE_AP_VLAN:
-        case NL80211_IFTYPE_MESH_POINT:
-        case NL80211_IFTYPE_P2P_GO:
-        case NL80211_IFTYPE_WDS:
-                /* if the interface could potentially choose a DFS channel,
-                 * then mark DFS as required.
-                 */
-                if (!chan) {
-                        if (chanmode != CHAN_MODE_UNDEFINED && radar_detect)
-                                radar_required = true;
-                        break;
-                }
-                radar_required = !!(chan->flags & IEEE80211_CHAN_RADAR);
-                break;
-        case NL80211_IFTYPE_P2P_CLIENT:
-        case NL80211_IFTYPE_STATION:
-        case NL80211_IFTYPE_P2P_DEVICE:
-        case NL80211_IFTYPE_MONITOR:
-                break;
-        case NUM_NL80211_IFTYPES:
-        case NL80211_IFTYPE_UNSPECIFIED:
-        default:
-                return -EINVAL;
-        }
-
-        if (radar_required && !radar_detect)
+        if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
                 return -EINVAL;
 
         /* Always allow software iftypes */