1 files changed, 153 insertions, 3 deletions

diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index b725a31a4751..47be6163381c 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -56,6 +56,7 @@
 #include <net/cfg80211.h>
 #include "core.h"
 #include "reg.h"
+#include "rdev-ops.h"
 #include "regdb.h"
 #include "nl80211.h"
 
@@ -66,6 +67,12 @@
 #define REG_DBG_PRINT(args...)
 #endif
 
+/*
+ * Grace period we give before making sure all current interfaces reside on
+ * channels allowed by the current regulatory domain.
+ */
+#define REG_ENFORCE_GRACE_MS 60000
+
 /**
  * enum reg_request_treatment - regulatory request treatment
  *
@@ -210,6 +217,9 @@ struct reg_beacon {
         struct ieee80211_channel chan;
 };
 
+static void reg_check_chans_work(struct work_struct *work);
+static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
+
 static void reg_todo(struct work_struct *work);
 static DECLARE_WORK(reg_work, reg_todo);
 
@@ -573,8 +583,9 @@ static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
         return get_cfg80211_regdom();
 }
 
-unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
-                                   const struct ieee80211_reg_rule *rule)
+static unsigned int
+reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
+                                 const struct ieee80211_reg_rule *rule)
 {
         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
         const struct ieee80211_freq_range *freq_range_tmp;
@@ -622,6 +633,27 @@ unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
         return end_freq - start_freq;
 }
 
+unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
+                                   const struct ieee80211_reg_rule *rule)
+{
+        unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
+
+        if (rule->flags & NL80211_RRF_NO_160MHZ)
+                bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
+        if (rule->flags & NL80211_RRF_NO_80MHZ)
+                bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
+
+        /*
+         * HT40+/HT40- limits are handled per-channel. Only limit BW if both
+         * are not allowed.
+         */
+        if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
+            rule->flags & NL80211_RRF_NO_HT40PLUS)
+                bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
+
+        return bw;
+}
+
 /* Sanity check on a regulatory rule */
 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 {
@@ -946,6 +978,16 @@ static u32 map_regdom_flags(u32 rd_flags)
                 channel_flags |= IEEE80211_CHAN_NO_OFDM;
         if (rd_flags & NL80211_RRF_NO_OUTDOOR)
                 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
+        if (rd_flags & NL80211_RRF_GO_CONCURRENT)
+                channel_flags |= IEEE80211_CHAN_GO_CONCURRENT;
+        if (rd_flags & NL80211_RRF_NO_HT40MINUS)
+                channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
+        if (rd_flags & NL80211_RRF_NO_HT40PLUS)
+                channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
+        if (rd_flags & NL80211_RRF_NO_80MHZ)
+                channel_flags |= IEEE80211_CHAN_NO_80MHZ;
+        if (rd_flags & NL80211_RRF_NO_160MHZ)
+                channel_flags |= IEEE80211_CHAN_NO_160MHZ;
         return channel_flags;
 }
 
@@ -1486,6 +1528,96 @@ static void reg_call_notifier(struct wiphy *wiphy,
                 wiphy->reg_notifier(wiphy, request);
 }
 
+static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
+{
+        struct ieee80211_channel *ch;
+        struct cfg80211_chan_def chandef;
+        struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
+        bool ret = true;
+
+        wdev_lock(wdev);
+
+        if (!wdev->netdev || !netif_running(wdev->netdev))
+                goto out;
+
+        switch (wdev->iftype) {
+        case NL80211_IFTYPE_AP:
+        case NL80211_IFTYPE_P2P_GO:
+                if (!wdev->beacon_interval)
+                        goto out;
+
+                ret = cfg80211_reg_can_beacon(wiphy,
+                                              &wdev->chandef, wdev->iftype);
+                break;
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_ADHOC:
+                if (!wdev->current_bss ||
+                    !wdev->current_bss->pub.channel)
+                        goto out;
+
+                ch = wdev->current_bss->pub.channel;
+                if (rdev->ops->get_channel &&
+                    !rdev_get_channel(rdev, wdev, &chandef))
+                        ret = cfg80211_chandef_usable(wiphy, &chandef,
+                                                      IEEE80211_CHAN_DISABLED);
+                else
+                        ret = !(ch->flags & IEEE80211_CHAN_DISABLED);
+                break;
+        case NL80211_IFTYPE_MONITOR:
+        case NL80211_IFTYPE_AP_VLAN:
+        case NL80211_IFTYPE_P2P_DEVICE:
+                /* no enforcement required */
+                break;
+        default:
+                /* others not implemented for now */
+                WARN_ON(1);
+                break;
+        }
+
+out:
+        wdev_unlock(wdev);
+        return ret;
+}
+
+static void reg_leave_invalid_chans(struct wiphy *wiphy)
+{
+        struct wireless_dev *wdev;
+        struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
+
+        ASSERT_RTNL();
+
+        list_for_each_entry(wdev, &rdev->wdev_list, list)
+                if (!reg_wdev_chan_valid(wiphy, wdev))
+                        cfg80211_leave(rdev, wdev);
+}
+
+static void reg_check_chans_work(struct work_struct *work)
+{
+        struct cfg80211_registered_device *rdev;
+
+        REG_DBG_PRINT("Verifying active interfaces after reg change\n");
+        rtnl_lock();
+
+        list_for_each_entry(rdev, &cfg80211_rdev_list, list)
+                if (!(rdev->wiphy.regulatory_flags &
+                      REGULATORY_IGNORE_STALE_KICKOFF))
+                        reg_leave_invalid_chans(&rdev->wiphy);
+
+        rtnl_unlock();
+}
+
+static void reg_check_channels(void)
+{
+        /*
+         * Give usermode a chance to do something nicer (move to another
+         * channel, orderly disconnection), before forcing a disconnection.
+         */
+        mod_delayed_work(system_power_efficient_wq,
+                         &reg_check_chans,
+                         msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
+}
+
 static void wiphy_update_regulatory(struct wiphy *wiphy,
                                     enum nl80211_reg_initiator initiator)
 {
@@ -1525,6 +1657,8 @@ static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
                 wiphy = &rdev->wiphy;
                 wiphy_update_regulatory(wiphy, initiator);
         }
+
+        reg_check_channels();
 }
 
 static void handle_channel_custom(struct wiphy *wiphy,
@@ -1565,10 +1699,23 @@ static void handle_channel_custom(struct wiphy *wiphy,
         if (max_bandwidth_khz < MHZ_TO_KHZ(160))
                 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
 
+        chan->dfs_state_entered = jiffies;
+        chan->dfs_state = NL80211_DFS_USABLE;
+
+        chan->beacon_found = false;
         chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
         chan->max_reg_power = chan->max_power =
                 (int) MBM_TO_DBM(power_rule->max_eirp);
+
+        if (chan->flags & IEEE80211_CHAN_RADAR) {
+                if (reg_rule->dfs_cac_ms)
+                        chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
+                else
+                        chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
+        }
+
+        chan->max_power = chan->max_reg_power;
 }
 
 static void handle_band_custom(struct wiphy *wiphy,
@@ -1931,8 +2078,10 @@ static void reg_process_hint(struct regulatory_request *reg_request)
 
         /* This is required so that the orig_* parameters are saved */
         if (treatment == REG_REQ_ALREADY_SET && wiphy &&
-            wiphy->regulatory_flags & REGULATORY_STRICT_REG)
+            wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
                 wiphy_update_regulatory(wiphy, reg_request->initiator);
+                reg_check_channels();
+        }
 
         return;
 
@@ -2813,6 +2962,7 @@ void regulatory_exit(void)
 
         cancel_work_sync(&reg_work);
         cancel_delayed_work_sync(&reg_timeout);
+        cancel_delayed_work_sync(&reg_check_chans);
 
         /* Lock to suppress warnings */
         rtnl_lock();