1 files changed, 278 insertions, 528 deletions

diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 7a0754c92df4..f180db0de66c 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -33,6 +33,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/random.h>
 #include <linux/nl80211.h>
@@ -40,8 +41,18 @@
 #include <net/cfg80211.h>
 #include "core.h"
 #include "reg.h"
+#include "regdb.h"
 #include "nl80211.h"
 
+#ifdef CONFIG_CFG80211_REG_DEBUG
+#define REG_DBG_PRINT(format, args...) \
+        do { \
+                printk(KERN_DEBUG format , ## args); \
+        } while (0)
+#else
+#define REG_DBG_PRINT(args...)
+#endif
+
 /* Receipt of information from last regulatory request */
 static struct regulatory_request *last_request;
 
@@ -56,20 +67,12 @@ static struct platform_device *reg_pdev;
 const struct ieee80211_regdomain *cfg80211_regdomain;
 
 /*
- * We use this as a place for the rd structure built from the
- * last parsed country IE to rest until CRDA gets back to us with
- * what it thinks should apply for the same country
- */
-static const struct ieee80211_regdomain *country_ie_regdomain;
-
-/*
  * Protects static reg.c components:
  *     - cfg80211_world_regdom
  *     - cfg80211_regdom
- *     - country_ie_regdomain
  *     - last_request
  */
-DEFINE_MUTEX(reg_mutex);
+static DEFINE_MUTEX(reg_mutex);
 #define assert_reg_lock() WARN_ON(!mutex_is_locked(&reg_mutex))
 
 /* Used to queue up regulatory hints */
@@ -124,82 +127,11 @@ static const struct ieee80211_regdomain *cfg80211_world_regdom =
         &world_regdom;
 
 static char *ieee80211_regdom = "00";
+static char user_alpha2[2];
 
 module_param(ieee80211_regdom, charp, 0444);
 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 
-#ifdef CONFIG_WIRELESS_OLD_REGULATORY
-/*
- * We assume 40 MHz bandwidth for the old regulatory work.
- * We make emphasis we are using the exact same frequencies
- * as before
- */
-
-static const struct ieee80211_regdomain us_regdom = {
-        .n_reg_rules = 6,
-        .alpha2 =  "US",
-        .reg_rules = {
-                /* IEEE 802.11b/g, channels 1..11 */
-                REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
-                /* IEEE 802.11a, channel 36..48 */
-                REG_RULE(5180-10, 5240+10, 40, 6, 17, 0),
-                /* IEEE 802.11a, channels 48..64 */
-                REG_RULE(5260-10, 5320+10, 40, 6, 20, NL80211_RRF_DFS),
-                /* IEEE 802.11a, channels 100..124 */
-                REG_RULE(5500-10, 5590+10, 40, 6, 20, NL80211_RRF_DFS),
-                /* IEEE 802.11a, channels 132..144 */
-                REG_RULE(5660-10, 5700+10, 40, 6, 20, NL80211_RRF_DFS),
-                /* IEEE 802.11a, channels 149..165, outdoor */
-                REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
-        }
-};
-
-static const struct ieee80211_regdomain jp_regdom = {
-        .n_reg_rules = 6,
-        .alpha2 =  "JP",
-        .reg_rules = {
-                /* IEEE 802.11b/g, channels 1..11 */
-                REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
-                /* IEEE 802.11b/g, channels 12..13 */
-                REG_RULE(2467-10, 2472+10, 20, 6, 20, 0),
-                /* IEEE 802.11b/g, channel 14 */
-                REG_RULE(2484-10, 2484+10, 20, 6, 20, NL80211_RRF_NO_OFDM),
-                /* IEEE 802.11a, channels 36..48 */
-                REG_RULE(5180-10, 5240+10, 40, 6, 20, 0),
-                /* IEEE 802.11a, channels 52..64 */
-                REG_RULE(5260-10, 5320+10, 40, 6, 20, NL80211_RRF_DFS),
-                /* IEEE 802.11a, channels 100..144 */
-                REG_RULE(5500-10, 5700+10, 40, 6, 23, NL80211_RRF_DFS),
-        }
-};
-
-static const struct ieee80211_regdomain *static_regdom(char *alpha2)
-{
-        if (alpha2[0] == 'U' && alpha2[1] == 'S')
-                return &us_regdom;
-        if (alpha2[0] == 'J' && alpha2[1] == 'P')
-                return &jp_regdom;
-        /* Use world roaming rules for "EU", since it was a pseudo
-           domain anyway... */
-        if (alpha2[0] == 'E' && alpha2[1] == 'U')
-                return &world_regdom;
-        /* Default, world roaming rules */
-        return &world_regdom;
-}
-
-static bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
-{
-        if (rd == &us_regdom || rd == &jp_regdom || rd == &world_regdom)
-                return true;
-        return false;
-}
-#else
-static inline bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
-{
-        return false;
-}
-#endif
-
 static void reset_regdomains(void)
 {
         /* avoid freeing static information or freeing something twice */
@@ -209,8 +141,6 @@ static void reset_regdomains(void)
                 cfg80211_world_regdom = NULL;
         if (cfg80211_regdomain == &world_regdom)
                 cfg80211_regdomain = NULL;
-        if (is_old_static_regdom(cfg80211_regdomain))
-                cfg80211_regdomain = NULL;
 
         kfree(cfg80211_regdomain);
         kfree(cfg80211_world_regdom);
@@ -316,24 +246,116 @@ static bool regdom_changes(const char *alpha2)
         return true;
 }
 
-/**
- * country_ie_integrity_changes - tells us if the country IE has changed
- * @checksum: checksum of country IE of fields we are interested in
- *
- * If the country IE has not changed you can ignore it safely. This is
- * useful to determine if two devices are seeing two different country IEs
- * even on the same alpha2. Note that this will return false if no IE has
- * been set on the wireless core yet.
+/*
+ * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
+ * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
+ * has ever been issued.
  */
-static bool country_ie_integrity_changes(u32 checksum)
+static bool is_user_regdom_saved(void)
 {
-        /* If no IE has been set then the checksum doesn't change */
-        if (unlikely(!last_request->country_ie_checksum))
+        if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
                 return false;
-        if (unlikely(last_request->country_ie_checksum != checksum))
-                return true;
-        return false;
+
+        /* This would indicate a mistake on the design */
+        if (WARN((!is_world_regdom(user_alpha2) &&
+                  !is_an_alpha2(user_alpha2)),
+                 "Unexpected user alpha2: %c%c\n",
+                 user_alpha2[0],
+                 user_alpha2[1]))
+                return false;
+
+        return true;
+}
+
+static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
+                         const struct ieee80211_regdomain *src_regd)
+{
+        struct ieee80211_regdomain *regd;
+        int size_of_regd = 0;
+        unsigned int i;
+
+        size_of_regd = sizeof(struct ieee80211_regdomain) +
+          ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
+
+        regd = kzalloc(size_of_regd, GFP_KERNEL);
+        if (!regd)
+                return -ENOMEM;
+
+        memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
+
+        for (i = 0; i < src_regd->n_reg_rules; i++)
+                memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
+                        sizeof(struct ieee80211_reg_rule));
+
+        *dst_regd = regd;
+        return 0;
+}
+
+#ifdef CONFIG_CFG80211_INTERNAL_REGDB
+struct reg_regdb_search_request {
+        char alpha2[2];
+        struct list_head list;
+};
+
+static LIST_HEAD(reg_regdb_search_list);
+static DEFINE_MUTEX(reg_regdb_search_mutex);
+
+static void reg_regdb_search(struct work_struct *work)
+{
+        struct reg_regdb_search_request *request;
+        const struct ieee80211_regdomain *curdom, *regdom;
+        int i, r;
+
+        mutex_lock(&reg_regdb_search_mutex);
+        while (!list_empty(&reg_regdb_search_list)) {
+                request = list_first_entry(&reg_regdb_search_list,
+                                           struct reg_regdb_search_request,
+                                           list);
+                list_del(&request->list);
+
+                for (i=0; i<reg_regdb_size; i++) {
+                        curdom = reg_regdb[i];
+
+                        if (!memcmp(request->alpha2, curdom->alpha2, 2)) {
+                                r = reg_copy_regd(&regdom, curdom);
+                                if (r)
+                                        break;
+                                mutex_lock(&cfg80211_mutex);
+                                set_regdom(regdom);
+                                mutex_unlock(&cfg80211_mutex);
+                                break;
+                        }
+                }
+
+                kfree(request);
+        }
+        mutex_unlock(&reg_regdb_search_mutex);
+}
+
+static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
+
+static void reg_regdb_query(const char *alpha2)
+{
+        struct reg_regdb_search_request *request;
+
+        if (!alpha2)
+                return;
+
+        request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
+        if (!request)
+                return;
+
+        memcpy(request->alpha2, alpha2, 2);
+
+        mutex_lock(&reg_regdb_search_mutex);
+        list_add_tail(&request->list, &reg_regdb_search_list);
+        mutex_unlock(&reg_regdb_search_mutex);
+
+        schedule_work(&reg_regdb_work);
 }
+#else
+static inline void reg_regdb_query(const char *alpha2) {}
+#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
 
 /*
  * This lets us keep regulatory code which is updated on a regulatory
@@ -354,6 +376,9 @@ static int call_crda(const char *alpha2)
                 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
                         "regulatory domain\n");
 
+        /* query internal regulatory database (if it exists) */
+        reg_regdb_query(alpha2);
+
         country_env[8] = alpha2[0];
         country_env[9] = alpha2[1];
 
@@ -454,215 +479,6 @@ static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 }
 
 /*
- * Converts a country IE to a regulatory domain. A regulatory domain
- * structure has a lot of information which the IE doesn't yet have,
- * so for the other values we use upper max values as we will intersect
- * with our userspace regulatory agent to get lower bounds.
- */
-static struct ieee80211_regdomain *country_ie_2_rd(
-                                u8 *country_ie,
-                                u8 country_ie_len,
-                                u32 *checksum)
-{
-        struct ieee80211_regdomain *rd = NULL;
-        unsigned int i = 0;
-        char alpha2[2];
-        u32 flags = 0;
-        u32 num_rules = 0, size_of_regd = 0;
-        u8 *triplets_start = NULL;
-        u8 len_at_triplet = 0;
-        /* the last channel we have registered in a subband (triplet) */
-        int last_sub_max_channel = 0;
-
-        *checksum = 0xDEADBEEF;
-
-        /* Country IE requirements */
-        BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
-                country_ie_len & 0x01);
-
-        alpha2[0] = country_ie[0];
-        alpha2[1] = country_ie[1];
-
-        /*
-         * Third octet can be:
-         *    'I' - Indoor
-         *    'O' - Outdoor
-         *
-         *  anything else we assume is no restrictions
-         */
-        if (country_ie[2] == 'I')
-                flags = NL80211_RRF_NO_OUTDOOR;
-        else if (country_ie[2] == 'O')
-                flags = NL80211_RRF_NO_INDOOR;
-
-        country_ie += 3;
-        country_ie_len -= 3;
-
-        triplets_start = country_ie;
-        len_at_triplet = country_ie_len;
-
-        *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
-
-        /*
-         * We need to build a reg rule for each triplet, but first we must
-         * calculate the number of reg rules we will need. We will need one
-         * for each channel subband
-         */
-        while (country_ie_len >= 3) {
-                int end_channel = 0;
-                struct ieee80211_country_ie_triplet *triplet =
-                        (struct ieee80211_country_ie_triplet *) country_ie;
-                int cur_sub_max_channel = 0, cur_channel = 0;
-
-                if (triplet->ext.reg_extension_id >=
-                                IEEE80211_COUNTRY_EXTENSION_ID) {
-                        country_ie += 3;
-                        country_ie_len -= 3;
-                        continue;
-                }
-
-                /* 2 GHz */
-                if (triplet->chans.first_channel <= 14)
-                        end_channel = triplet->chans.first_channel +
-                                triplet->chans.num_channels;
-                else
-                        /*
-                         * 5 GHz -- For example in country IEs if the first
-                         * channel given is 36 and the number of channels is 4
-                         * then the individual channel numbers defined for the
-                         * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
-                         * and not 36, 37, 38, 39.
-                         *
-                         * See: http://tinyurl.com/11d-clarification
-                         */
-                        end_channel =  triplet->chans.first_channel +
-                                (4 * (triplet->chans.num_channels - 1));
-
-                cur_channel = triplet->chans.first_channel;
-                cur_sub_max_channel = end_channel;
-
-                /* Basic sanity check */
-                if (cur_sub_max_channel < cur_channel)
-                        return NULL;
-
-                /*
-                 * Do not allow overlapping channels. Also channels
-                 * passed in each subband must be monotonically
-                 * increasing
-                 */
-                if (last_sub_max_channel) {
-                        if (cur_channel <= last_sub_max_channel)
-                                return NULL;
-                        if (cur_sub_max_channel <= last_sub_max_channel)
-                                return NULL;
-                }
-
-                /*
-                 * When dot11RegulatoryClassesRequired is supported
-                 * we can throw ext triplets as part of this soup,
-                 * for now we don't care when those change as we
-                 * don't support them
-                 */
-                *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
-                  ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
-                  ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
-
-                last_sub_max_channel = cur_sub_max_channel;
-
-                country_ie += 3;
-                country_ie_len -= 3;
-                num_rules++;
-
-                /*
-                 * Note: this is not a IEEE requirement but
-                 * simply a memory requirement
-                 */
-                if (num_rules > NL80211_MAX_SUPP_REG_RULES)
-                        return NULL;
-        }
-
-        country_ie = triplets_start;
-        country_ie_len = len_at_triplet;
-
-        size_of_regd = sizeof(struct ieee80211_regdomain) +
-                (num_rules * sizeof(struct ieee80211_reg_rule));
-
-        rd = kzalloc(size_of_regd, GFP_KERNEL);
-        if (!rd)
-                return NULL;
-
-        rd->n_reg_rules = num_rules;
-        rd->alpha2[0] = alpha2[0];
-        rd->alpha2[1] = alpha2[1];
-
-        /* This time around we fill in the rd */
-        while (country_ie_len >= 3) {
-                int end_channel = 0;
-                struct ieee80211_country_ie_triplet *triplet =
-                        (struct ieee80211_country_ie_triplet *) country_ie;
-                struct ieee80211_reg_rule *reg_rule = NULL;
-                struct ieee80211_freq_range *freq_range = NULL;
-                struct ieee80211_power_rule *power_rule = NULL;
-
-                /*
-                 * Must parse if dot11RegulatoryClassesRequired is true,
-                 * we don't support this yet
-                 */
-                if (triplet->ext.reg_extension_id >=
-                                IEEE80211_COUNTRY_EXTENSION_ID) {
-                        country_ie += 3;
-                        country_ie_len -= 3;
-                        continue;
-                }
-
-                reg_rule = &rd->reg_rules[i];
-                freq_range = &reg_rule->freq_range;
-                power_rule = &reg_rule->power_rule;
-
-                reg_rule->flags = flags;
-
-                /* 2 GHz */
-                if (triplet->chans.first_channel <= 14)
-                        end_channel = triplet->chans.first_channel +
-                                triplet->chans.num_channels;
-                else
-                        end_channel =  triplet->chans.first_channel +
-                                (4 * (triplet->chans.num_channels - 1));
-
-                /*
-                 * The +10 is since the regulatory domain expects
-                 * the actual band edge, not the center of freq for
-                 * its start and end freqs, assuming 20 MHz bandwidth on
-                 * the channels passed
-                 */
-                freq_range->start_freq_khz =
-                        MHZ_TO_KHZ(ieee80211_channel_to_frequency(
-                                triplet->chans.first_channel) - 10);
-                freq_range->end_freq_khz =
-                        MHZ_TO_KHZ(ieee80211_channel_to_frequency(
-                                end_channel) + 10);
-
-                /*
-                 * These are large arbitrary values we use to intersect later.
-                 * Increment this if we ever support >= 40 MHz channels
-                 * in IEEE 802.11
-                 */
-                freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
-                power_rule->max_antenna_gain = DBI_TO_MBI(100);
-                power_rule->max_eirp = DBM_TO_MBM(100);
-
-                country_ie += 3;
-                country_ie_len -= 3;
-                i++;
-
-                BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
-        }
-
-        return rd;
-}
-
-
-/*
  * Helper for regdom_intersect(), this does the real
  * mathematical intersection fun
  */
@@ -883,7 +699,6 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
 
         return -EINVAL;
 }
-EXPORT_SYMBOL(freq_reg_info);
 
 int freq_reg_info(struct wiphy *wiphy,
                   u32 center_freq,
@@ -897,6 +712,7 @@ int freq_reg_info(struct wiphy *wiphy,
                                   reg_rule,
                                   NULL);
 }
+EXPORT_SYMBOL(freq_reg_info);
 
 /*
  * Note that right now we assume the desired channel bandwidth
@@ -935,45 +751,8 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
                           desired_bw_khz,
                           &reg_rule);
 
-        if (r) {
-                /*
-                 * This means no regulatory rule was found in the country IE
-                 * with a frequency range on the center_freq's band, since
-                 * IEEE-802.11 allows for a country IE to have a subset of the
-                 * regulatory information provided in a country we ignore
-                 * disabling the channel unless at least one reg rule was
-                 * found on the center_freq's band. For details see this
-                 * clarification:
-                 *
-                 * http://tinyurl.com/11d-clarification
-                 */
-                if (r == -ERANGE &&
-                    last_request->initiator ==
-                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
-#ifdef CONFIG_CFG80211_REG_DEBUG
-                        printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
-                                "intact on %s - no rule found in band on "
-                                "Country IE\n",
-                                chan->center_freq, wiphy_name(wiphy));
-#endif
-                } else {
-                /*
-                 * In this case we know the country IE has at least one reg rule
-                 * for the band so we respect its band definitions
-                 */
-#ifdef CONFIG_CFG80211_REG_DEBUG
-                        if (last_request->initiator ==
-                            NL80211_REGDOM_SET_BY_COUNTRY_IE)
-                                printk(KERN_DEBUG "cfg80211: Disabling "
-                                        "channel %d MHz on %s due to "
-                                        "Country IE\n",
-                                        chan->center_freq, wiphy_name(wiphy));
-#endif
-                        flags |= IEEE80211_CHAN_DISABLED;
-                        chan->flags = flags;
-                }
+        if (r)
                 return;
-        }
 
         power_rule = &reg_rule->power_rule;
         freq_range = &reg_rule->freq_range;
@@ -1342,30 +1121,6 @@ void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
 }
 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
 
-static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
-                         const struct ieee80211_regdomain *src_regd)
-{
-        struct ieee80211_regdomain *regd;
-        int size_of_regd = 0;
-        unsigned int i;
-
-        size_of_regd = sizeof(struct ieee80211_regdomain) +
-          ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
-
-        regd = kzalloc(size_of_regd, GFP_KERNEL);
-        if (!regd)
-                return -ENOMEM;
-
-        memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
-
-        for (i = 0; i < src_regd->n_reg_rules; i++)
-                memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
-                        sizeof(struct ieee80211_reg_rule));
-
-        *dst_regd = regd;
-        return 0;
-}
-
 /*
  * Return value which can be used by ignore_request() to indicate
  * it has been determined we should intersect two regulatory domains
@@ -1387,7 +1142,7 @@ static int ignore_request(struct wiphy *wiphy,
 
         switch (pending_request->initiator) {
         case NL80211_REGDOM_SET_BY_CORE:
-                return -EINVAL;
+                return 0;
         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
 
                 last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
@@ -1418,8 +1173,6 @@ static int ignore_request(struct wiphy *wiphy,
                 return REG_INTERSECT;
         case NL80211_REGDOM_SET_BY_DRIVER:
                 if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
-                        if (is_old_static_regdom(cfg80211_regdomain))
-                                return 0;
                         if (regdom_changes(pending_request->alpha2))
                                 return 0;
                         return -EALREADY;
@@ -1456,8 +1209,7 @@ static int ignore_request(struct wiphy *wiphy,
                                 return -EAGAIN;
                 }
 
-                if (!is_old_static_regdom(cfg80211_regdomain) &&
-                    !regdom_changes(pending_request->alpha2))
+                if (!regdom_changes(pending_request->alpha2))
                         return -EALREADY;
 
                 return 0;
@@ -1529,6 +1281,11 @@ new_request:
 
         pending_request = NULL;
 
+        if (last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
+                user_alpha2[0] = last_request->alpha2[0];
+                user_alpha2[1] = last_request->alpha2[1];
+        }
+
         /* When r == REG_INTERSECT we do need to call CRDA */
         if (r < 0) {
                 /*
@@ -1549,6 +1306,7 @@ static void reg_process_hint(struct regulatory_request *reg_request)
 {
         int r = 0;
         struct wiphy *wiphy = NULL;
+        enum nl80211_reg_initiator initiator = reg_request->initiator;
 
         BUG_ON(!reg_request->alpha2);
 
@@ -1568,7 +1326,7 @@ static void reg_process_hint(struct regulatory_request *reg_request)
         /* This is required so that the orig_* parameters are saved */
         if (r == -EALREADY && wiphy &&
             wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
-                wiphy_update_regulatory(wiphy, reg_request->initiator);
+                wiphy_update_regulatory(wiphy, initiator);
 out:
         mutex_unlock(&reg_mutex);
         mutex_unlock(&cfg80211_mutex);
@@ -1648,12 +1406,16 @@ static void queue_regulatory_request(struct regulatory_request *request)
         schedule_work(&reg_work);
 }
 
-/* Core regulatory hint -- happens once during cfg80211_init() */
+/*
+ * Core regulatory hint -- happens during cfg80211_init()
+ * and when we restore regulatory settings.
+ */
 static int regulatory_hint_core(const char *alpha2)
 {
         struct regulatory_request *request;
 
-        BUG_ON(last_request);
+        kfree(last_request);
+        last_request = NULL;
 
         request = kzalloc(sizeof(struct regulatory_request),
                           GFP_KERNEL);
@@ -1664,14 +1426,12 @@ static int regulatory_hint_core(const char *alpha2)
         request->alpha2[1] = alpha2[1];
         request->initiator = NL80211_REGDOM_SET_BY_CORE;
 
-        queue_regulatory_request(request);
-
         /*
          * This ensures last_request is populated once modules
          * come swinging in and calling regulatory hints and
          * wiphy_apply_custom_regulatory().
          */
-        flush_scheduled_work();
+        reg_process_hint(request);
 
         return 0;
 }
@@ -1724,46 +1484,16 @@ int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
 }
 EXPORT_SYMBOL(regulatory_hint);
 
-/* Caller must hold reg_mutex */
-static bool reg_same_country_ie_hint(struct wiphy *wiphy,
-                        u32 country_ie_checksum)
-{
-        struct wiphy *request_wiphy;
-
-        assert_reg_lock();
-
-        if (unlikely(last_request->initiator !=
-            NL80211_REGDOM_SET_BY_COUNTRY_IE))
-                return false;
-
-        request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
-
-        if (!request_wiphy)
-                return false;
-
-        if (likely(request_wiphy != wiphy))
-                return !country_ie_integrity_changes(country_ie_checksum);
-        /*
-         * We should not have let these through at this point, they
-         * should have been picked up earlier by the first alpha2 check
-         * on the device
-         */
-        if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
-                return true;
-        return false;
-}
-
 /*
  * We hold wdev_lock() here so we cannot hold cfg80211_mutex() and
  * therefore cannot iterate over the rdev list here.
  */
 void regulatory_hint_11d(struct wiphy *wiphy,
-                        u8 *country_ie,
-                        u8 country_ie_len)
+                         enum ieee80211_band band,
+                         u8 *country_ie,
+                         u8 country_ie_len)
 {
-        struct ieee80211_regdomain *rd = NULL;
         char alpha2[2];
-        u32 checksum = 0;
         enum environment_cap env = ENVIRON_ANY;
         struct regulatory_request *request;
 
@@ -1779,14 +1509,6 @@ void regulatory_hint_11d(struct wiphy *wiphy,
         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
                 goto out;
 
-        /*
-         * Pending country IE processing, this can happen after we
-         * call CRDA and wait for a response if a beacon was received before
-         * we were able to process the last regulatory_hint_11d() call
-         */
-        if (country_ie_regdomain)
-                goto out;
-
         alpha2[0] = country_ie[0];
         alpha2[1] = country_ie[1];
 
@@ -1805,37 +1527,14 @@ void regulatory_hint_11d(struct wiphy *wiphy,
             wiphy_idx_valid(last_request->wiphy_idx)))
                 goto out;
 
-        rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
-        if (!rd)
-                goto out;
-
-        /*
-         * This will not happen right now but we leave it here for the
-         * the future when we want to add suspend/resume support and having
-         * the user move to another country after doing so, or having the user
-         * move to another AP. Right now we just trust the first AP.
-         *
-         * If we hit this before we add this support we want to be informed of
-         * it as it would indicate a mistake in the current design
-         */
-        if (WARN_ON(reg_same_country_ie_hint(wiphy, checksum)))
-                goto free_rd_out;
-
         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
         if (!request)
-                goto free_rd_out;
-
-        /*
-         * We keep this around for when CRDA comes back with a response so
-         * we can intersect with that
-         */
-        country_ie_regdomain = rd;
+                goto out;
 
         request->wiphy_idx = get_wiphy_idx(wiphy);
-        request->alpha2[0] = rd->alpha2[0];
-        request->alpha2[1] = rd->alpha2[1];
+        request->alpha2[0] = alpha2[0];
+        request->alpha2[1] = alpha2[1];
         request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
-        request->country_ie_checksum = checksum;
         request->country_ie_env = env;
 
         mutex_unlock(&reg_mutex);
@@ -1844,12 +1543,127 @@ void regulatory_hint_11d(struct wiphy *wiphy,
 
         return;
 
-free_rd_out:
-        kfree(rd);
 out:
         mutex_unlock(&reg_mutex);
 }
 
+static void restore_alpha2(char *alpha2, bool reset_user)
+{
+        /* indicates there is no alpha2 to consider for restoration */
+        alpha2[0] = '9';
+        alpha2[1] = '7';
+
+        /* The user setting has precedence over the module parameter */
+        if (is_user_regdom_saved()) {
+                /* Unless we're asked to ignore it and reset it */
+                if (reset_user) {
+                        REG_DBG_PRINT("cfg80211: Restoring regulatory settings "
+                               "including user preference\n");
+                        user_alpha2[0] = '9';
+                        user_alpha2[1] = '7';
+
+                        /*
+                         * If we're ignoring user settings, we still need to
+                         * check the module parameter to ensure we put things
+                         * back as they were for a full restore.
+                         */
+                        if (!is_world_regdom(ieee80211_regdom)) {
+                                REG_DBG_PRINT("cfg80211: Keeping preference on "
+                                       "module parameter ieee80211_regdom: %c%c\n",
+                                       ieee80211_regdom[0],
+                                       ieee80211_regdom[1]);
+                                alpha2[0] = ieee80211_regdom[0];
+                                alpha2[1] = ieee80211_regdom[1];
+                        }
+                } else {
+                        REG_DBG_PRINT("cfg80211: Restoring regulatory settings "
+                               "while preserving user preference for: %c%c\n",
+                               user_alpha2[0],
+                               user_alpha2[1]);
+                        alpha2[0] = user_alpha2[0];
+                        alpha2[1] = user_alpha2[1];
+                }
+        } else if (!is_world_regdom(ieee80211_regdom)) {
+                REG_DBG_PRINT("cfg80211: Keeping preference on "
+                       "module parameter ieee80211_regdom: %c%c\n",
+                       ieee80211_regdom[0],
+                       ieee80211_regdom[1]);
+                alpha2[0] = ieee80211_regdom[0];
+                alpha2[1] = ieee80211_regdom[1];
+        } else
+                REG_DBG_PRINT("cfg80211: Restoring regulatory settings\n");
+}
+
+/*
+ * Restoring regulatory settings involves ingoring any
+ * possibly stale country IE information and user regulatory
+ * settings if so desired, this includes any beacon hints
+ * learned as we could have traveled outside to another country
+ * after disconnection. To restore regulatory settings we do
+ * exactly what we did at bootup:
+ *
+ *   - send a core regulatory hint
+ *   - send a user regulatory hint if applicable
+ *
+ * Device drivers that send a regulatory hint for a specific country
+ * keep their own regulatory domain on wiphy->regd so that does does
+ * not need to be remembered.
+ */
+static void restore_regulatory_settings(bool reset_user)
+{
+        char alpha2[2];
+        struct reg_beacon *reg_beacon, *btmp;
+
+        mutex_lock(&cfg80211_mutex);
+        mutex_lock(&reg_mutex);
+
+        reset_regdomains();
+        restore_alpha2(alpha2, reset_user);
+
+        /* Clear beacon hints */
+        spin_lock_bh(&reg_pending_beacons_lock);
+        if (!list_empty(&reg_pending_beacons)) {
+                list_for_each_entry_safe(reg_beacon, btmp,
+                                         &reg_pending_beacons, list) {
+                        list_del(&reg_beacon->list);
+                        kfree(reg_beacon);
+                }
+        }
+        spin_unlock_bh(&reg_pending_beacons_lock);
+
+        if (!list_empty(&reg_beacon_list)) {
+                list_for_each_entry_safe(reg_beacon, btmp,
+                                         &reg_beacon_list, list) {
+                        list_del(&reg_beacon->list);
+                        kfree(reg_beacon);
+                }
+        }
+
+        /* First restore to the basic regulatory settings */
+        cfg80211_regdomain = cfg80211_world_regdom;
+
+        mutex_unlock(&reg_mutex);
+        mutex_unlock(&cfg80211_mutex);
+
+        regulatory_hint_core(cfg80211_regdomain->alpha2);
+
+        /*
+         * This restores the ieee80211_regdom module parameter
+         * preference or the last user requested regulatory
+         * settings, user regulatory settings takes precedence.
+         */
+        if (is_an_alpha2(alpha2))
+                regulatory_hint_user(user_alpha2);
+}
+
+
+void regulatory_hint_disconnect(void)
+{
+        REG_DBG_PRINT("cfg80211: All devices are disconnected, going to "
+                      "restore regulatory settings\n");
+        restore_regulatory_settings(false);
+}
+
 static bool freq_is_chan_12_13_14(u16 freq)
 {
         if (freq == ieee80211_channel_to_frequency(12) ||
@@ -1875,13 +1689,12 @@ int regulatory_hint_found_beacon(struct wiphy *wiphy,
         if (!reg_beacon)
                 return -ENOMEM;
 
-#ifdef CONFIG_CFG80211_REG_DEBUG
-        printk(KERN_DEBUG "cfg80211: Found new beacon on "
-                "frequency: %d MHz (Ch %d) on %s\n",
-                beacon_chan->center_freq,
-                ieee80211_frequency_to_channel(beacon_chan->center_freq),
-                wiphy_name(wiphy));
-#endif
+        REG_DBG_PRINT("cfg80211: Found new beacon on "
+                      "frequency: %d MHz (Ch %d) on %s\n",
+                      beacon_chan->center_freq,
+                      ieee80211_frequency_to_channel(beacon_chan->center_freq),
+                      wiphy_name(wiphy));
+
         memcpy(&reg_beacon->chan, beacon_chan,
                 sizeof(struct ieee80211_channel));
 
@@ -1953,10 +1766,10 @@ static void print_regdomain(const struct ieee80211_regdomain *rd)
                                         rdev->country_ie_alpha2[1]);
                         } else
                                 printk(KERN_INFO "cfg80211: Current regulatory "
-                                        "domain intersected: \n");
+                                        "domain intersected:\n");
                 } else
-                                printk(KERN_INFO "cfg80211: Current regulatory "
-                                        "domain intersected: \n");
+                        printk(KERN_INFO "cfg80211: Current regulatory "
+                                "domain intersected:\n");
         } else if (is_world_regdom(rd->alpha2))
                 printk(KERN_INFO "cfg80211: World regulatory "
                         "domain updated:\n");
@@ -1980,33 +1793,6 @@ static void print_regdomain_info(const struct ieee80211_regdomain *rd)
         print_rd_rules(rd);
 }
 
-#ifdef CONFIG_CFG80211_REG_DEBUG
-static void reg_country_ie_process_debug(
-        const struct ieee80211_regdomain *rd,
-        const struct ieee80211_regdomain *country_ie_regdomain,
-        const struct ieee80211_regdomain *intersected_rd)
-{
-        printk(KERN_DEBUG "cfg80211: Received country IE:\n");
-        print_regdomain_info(country_ie_regdomain);
-        printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
-        print_regdomain_info(rd);
-        if (intersected_rd) {
-                printk(KERN_DEBUG "cfg80211: We intersect both of these "
-                        "and get:\n");
-                print_regdomain_info(intersected_rd);
-                return;
-        }
-        printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
-}
-#else
-static inline void reg_country_ie_process_debug(
-        const struct ieee80211_regdomain *rd,
-        const struct ieee80211_regdomain *country_ie_regdomain,
-        const struct ieee80211_regdomain *intersected_rd)
-{
-}
-#endif
-
 /* Takes ownership of rd only if it doesn't fail */
 static int __set_regdom(const struct ieee80211_regdomain *rd)
 {
@@ -2039,8 +1825,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                  * If someone else asked us to change the rd lets only bother
                  * checking if the alpha2 changes if CRDA was already called
                  */
-                if (!is_old_static_regdom(cfg80211_regdomain) &&
-                    !regdom_changes(rd->alpha2))
+                if (!regdom_changes(rd->alpha2))
                         return -EINVAL;
         }
 
@@ -2119,34 +1904,6 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                 return 0;
         }
 
-        /*
-         * Country IE requests are handled a bit differently, we intersect
-         * the country IE rd with what CRDA believes that country should have
-         */
-
-        /*
-         * Userspace could have sent two replies with only
-         * one kernel request. By the second reply we would have
-         * already processed and consumed the country_ie_regdomain.
-         */
-        if (!country_ie_regdomain)
-                return -EALREADY;
-        BUG_ON(rd == country_ie_regdomain);
-
-        /*
-         * Intersect what CRDA returned and our what we
-         * had built from the Country IE received
-         */
-
-        intersected_rd = regdom_intersect(rd, country_ie_regdomain);
-
-        reg_country_ie_process_debug(rd,
-                                     country_ie_regdomain,
-                                     intersected_rd);
-
-        kfree(country_ie_regdomain);
-        country_ie_regdomain = NULL;
-
         if (!intersected_rd)
                 return -EINVAL;
 
@@ -2228,7 +1985,7 @@ out:
         mutex_unlock(&reg_mutex);
 }
 
-int regulatory_init(void)
+int __init regulatory_init(void)
 {
         int err = 0;
 
@@ -2239,15 +1996,11 @@ int regulatory_init(void)
         spin_lock_init(&reg_requests_lock);
         spin_lock_init(&reg_pending_beacons_lock);
 
-#ifdef CONFIG_WIRELESS_OLD_REGULATORY
-        cfg80211_regdomain = static_regdom(ieee80211_regdom);
-
-        printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
-        print_regdomain_info(cfg80211_regdomain);
-#else
         cfg80211_regdomain = cfg80211_world_regdom;
 
-#endif
+        user_alpha2[0] = '9';
+        user_alpha2[1] = '7';
+
         /* We always try to get an update for the static regdomain */
         err = regulatory_hint_core(cfg80211_regdomain->alpha2);
         if (err) {
@@ -2278,7 +2031,7 @@ int regulatory_init(void)
         return 0;
 }
 
-void regulatory_exit(void)
+void /* __init_or_exit */ regulatory_exit(void)
 {
         struct regulatory_request *reg_request, *tmp;
         struct reg_beacon *reg_beacon, *btmp;
@@ -2290,9 +2043,6 @@ void regulatory_exit(void)
 
         reset_regdomains();
 
-        kfree(country_ie_regdomain);
-        country_ie_regdomain = NULL;
-
         kfree(last_request);
 
         platform_device_unregister(reg_pdev);