cfg80211: Use capability info to detect mesh beacons.
[linux-2.6.git] / net / wireless / reg.c
index 3fa2474..798cb4c 100644 (file)
@@ -32,6 +32,9 @@
  * rely on some SHA1 checksum of the regdomain for example.
  *
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/list.h>
@@ -48,7 +51,7 @@
 #ifdef CONFIG_CFG80211_REG_DEBUG
 #define REG_DBG_PRINT(format, args...) \
        do { \
-               printk(KERN_DEBUG "cfg80211: " format , ## args); \
+               printk(KERN_DEBUG pr_fmt(format), ##args);      \
        } while (0)
 #else
 #define REG_DBG_PRINT(args...)
@@ -60,6 +63,10 @@ static struct regulatory_request *last_request;
 /* To trigger userspace events */
 static struct platform_device *reg_pdev;
 
+static struct device_type reg_device_type = {
+       .uevent = reg_device_uevent,
+};
+
 /*
  * Central wireless core regulatory domains, we only need two,
  * the current one and a world regulatory domain in case we have no
@@ -99,6 +106,9 @@ struct reg_beacon {
 static void reg_todo(struct work_struct *work);
 static DECLARE_WORK(reg_work, reg_todo);
 
+static void reg_timeout_work(struct work_struct *work);
+static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
+
 /* We keep a static world regulatory domain in case of the absence of CRDA */
 static const struct ieee80211_regdomain world_regdom = {
        .n_reg_rules = 5,
@@ -359,30 +369,21 @@ static inline void reg_regdb_query(const char *alpha2) {}
 
 /*
  * This lets us keep regulatory code which is updated on a regulatory
- * basis in userspace.
+ * basis in userspace. Country information is filled in by
+ * reg_device_uevent
  */
 static int call_crda(const char *alpha2)
 {
-       char country_env[9 + 2] = "COUNTRY=";
-       char *envp[] = {
-               country_env,
-               NULL
-       };
-
        if (!is_world_regdom((char *) alpha2))
-               printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
+               pr_info("Calling CRDA for country: %c%c\n",
                        alpha2[0], alpha2[1]);
        else
-               printk(KERN_INFO "cfg80211: Calling CRDA to update world "
-                       "regulatory domain\n");
+               pr_info("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];
-
-       return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
+       return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
 }
 
 /* Used by nl80211 before kmalloc'ing our regulatory domain */
@@ -659,7 +660,8 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
         * Follow the driver's regulatory domain, if present, unless a country
         * IE has been processed or a user wants to help complaince further
         */
-       if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
+       if (!custom_regd &&
+           last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
            last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
            wiphy->regd)
                regd = wiphy->regd;
@@ -670,11 +672,9 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
        for (i = 0; i < regd->n_reg_rules; i++) {
                const struct ieee80211_reg_rule *rr;
                const struct ieee80211_freq_range *fr = NULL;
-               const struct ieee80211_power_rule *pr = NULL;
 
                rr = &regd->reg_rules[i];
                fr = &rr->freq_range;
-               pr = &rr->power_rule;
 
                /*
                 * We only need to know if one frequency rule was
@@ -749,7 +749,7 @@ static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
                snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
 
        REG_DBG_PRINT("Updating information on frequency %d MHz "
-                     "for %d a MHz width channel with regulatory rule:\n",
+                     "for a %d MHz width channel with regulatory rule:\n",
                      chan->center_freq,
                      KHZ_TO_MHZ(desired_bw_khz));
 
@@ -1320,6 +1320,24 @@ static int ignore_request(struct wiphy *wiphy,
        return -EINVAL;
 }
 
+static void reg_set_request_processed(void)
+{
+       bool need_more_processing = false;
+
+       last_request->processed = true;
+
+       spin_lock(&reg_requests_lock);
+       if (!list_empty(&reg_requests_list))
+               need_more_processing = true;
+       spin_unlock(&reg_requests_lock);
+
+       if (last_request->initiator == NL80211_REGDOM_SET_BY_USER)
+               cancel_delayed_work_sync(&reg_timeout);
+
+       if (need_more_processing)
+               schedule_work(&reg_work);
+}
+
 /**
  * __regulatory_hint - hint to the wireless core a regulatory domain
  * @wiphy: if the hint comes from country information from an AP, this
@@ -1395,8 +1413,10 @@ new_request:
                 * have applied the requested regulatory domain before we just
                 * inform userspace we have processed the request
                 */
-               if (r == -EALREADY)
+               if (r == -EALREADY) {
                        nl80211_send_reg_change_event(last_request);
+                       reg_set_request_processed();
+               }
                return r;
        }
 
@@ -1412,45 +1432,70 @@ static void reg_process_hint(struct regulatory_request *reg_request)
 
        BUG_ON(!reg_request->alpha2);
 
-       mutex_lock(&cfg80211_mutex);
-       mutex_lock(&reg_mutex);
-
        if (wiphy_idx_valid(reg_request->wiphy_idx))
                wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
 
        if (reg_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
            !wiphy) {
                kfree(reg_request);
-               goto out;
+               return;
        }
 
        r = __regulatory_hint(wiphy, reg_request);
        /* This is required so that the orig_* parameters are saved */
        if (r == -EALREADY && wiphy &&
-           wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
+           wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
                wiphy_update_regulatory(wiphy, initiator);
-out:
-       mutex_unlock(&reg_mutex);
-       mutex_unlock(&cfg80211_mutex);
+               return;
+       }
+
+       /*
+        * We only time out user hints, given that they should be the only
+        * source of bogus requests.
+        */
+       if (r != -EALREADY &&
+           reg_request->initiator == NL80211_REGDOM_SET_BY_USER)
+               schedule_delayed_work(&reg_timeout, msecs_to_jiffies(3142));
 }
 
-/* Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_* */
+/*
+ * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
+ * Regulatory hints come on a first come first serve basis and we
+ * must process each one atomically.
+ */
 static void reg_process_pending_hints(void)
-       {
+{
        struct regulatory_request *reg_request;
 
+       mutex_lock(&cfg80211_mutex);
+       mutex_lock(&reg_mutex);
+
+       /* When last_request->processed becomes true this will be rescheduled */
+       if (last_request && !last_request->processed) {
+               REG_DBG_PRINT("Pending regulatory request, waiting "
+                             "for it to be processed...");
+               goto out;
+       }
+
        spin_lock(&reg_requests_lock);
-       while (!list_empty(&reg_requests_list)) {
-               reg_request = list_first_entry(&reg_requests_list,
-                                              struct regulatory_request,
-                                              list);
-               list_del_init(&reg_request->list);
 
+       if (list_empty(&reg_requests_list)) {
                spin_unlock(&reg_requests_lock);
-               reg_process_hint(reg_request);
-               spin_lock(&reg_requests_lock);
+               goto out;
        }
+
+       reg_request = list_first_entry(&reg_requests_list,
+                                      struct regulatory_request,
+                                      list);
+       list_del_init(&reg_request->list);
+
        spin_unlock(&reg_requests_lock);
+
+       reg_process_hint(reg_request);
+
+out:
+       mutex_unlock(&reg_mutex);
+       mutex_unlock(&cfg80211_mutex);
 }
 
 /* Processes beacon hints -- this has nothing to do with country IEs */
@@ -1713,6 +1758,8 @@ static void restore_regulatory_settings(bool reset_user)
 {
        char alpha2[2];
        struct reg_beacon *reg_beacon, *btmp;
+       struct regulatory_request *reg_request, *tmp;
+       LIST_HEAD(tmp_reg_req_list);
 
        mutex_lock(&cfg80211_mutex);
        mutex_lock(&reg_mutex);
@@ -1720,6 +1767,25 @@ static void restore_regulatory_settings(bool reset_user)
        reset_regdomains();
        restore_alpha2(alpha2, reset_user);
 
+       /*
+        * If there's any pending requests we simply
+        * stash them to a temporary pending queue and
+        * add then after we've restored regulatory
+        * settings.
+        */
+       spin_lock(&reg_requests_lock);
+       if (!list_empty(&reg_requests_list)) {
+               list_for_each_entry_safe(reg_request, tmp,
+                                        &reg_requests_list, list) {
+                       if (reg_request->initiator !=
+                           NL80211_REGDOM_SET_BY_USER)
+                               continue;
+                       list_del(&reg_request->list);
+                       list_add_tail(&reg_request->list, &tmp_reg_req_list);
+               }
+       }
+       spin_unlock(&reg_requests_lock);
+
        /* Clear beacon hints */
        spin_lock_bh(&reg_pending_beacons_lock);
        if (!list_empty(&reg_pending_beacons)) {
@@ -1754,8 +1820,31 @@ static void restore_regulatory_settings(bool reset_user)
         */
        if (is_an_alpha2(alpha2))
                regulatory_hint_user(user_alpha2);
-}
 
+       if (list_empty(&tmp_reg_req_list))
+               return;
+
+       mutex_lock(&cfg80211_mutex);
+       mutex_lock(&reg_mutex);
+
+       spin_lock(&reg_requests_lock);
+       list_for_each_entry_safe(reg_request, tmp, &tmp_reg_req_list, list) {
+               REG_DBG_PRINT("Adding request for country %c%c back "
+                             "into the queue\n",
+                             reg_request->alpha2[0],
+                             reg_request->alpha2[1]);
+               list_del(&reg_request->list);
+               list_add_tail(&reg_request->list, &reg_requests_list);
+       }
+       spin_unlock(&reg_requests_lock);
+
+       mutex_unlock(&reg_mutex);
+       mutex_unlock(&cfg80211_mutex);
+
+       REG_DBG_PRINT("Kicking the queue\n");
+
+       schedule_work(&reg_work);
+}
 
 void regulatory_hint_disconnect(void)
 {
@@ -1766,9 +1855,9 @@ void regulatory_hint_disconnect(void)
 
 static bool freq_is_chan_12_13_14(u16 freq)
 {
-       if (freq == ieee80211_channel_to_frequency(12) ||
-           freq == ieee80211_channel_to_frequency(13) ||
-           freq == ieee80211_channel_to_frequency(14))
+       if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
+           freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
+           freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
                return true;
        return false;
 }
@@ -1819,8 +1908,7 @@ static void print_rd_rules(const struct ieee80211_regdomain *rd)
        const struct ieee80211_freq_range *freq_range = NULL;
        const struct ieee80211_power_rule *power_rule = NULL;
 
-       printk(KERN_INFO "    (start_freq - end_freq @ bandwidth), "
-               "(max_antenna_gain, max_eirp)\n");
+       pr_info("    (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
 
        for (i = 0; i < rd->n_reg_rules; i++) {
                reg_rule = &rd->reg_rules[i];
@@ -1832,16 +1920,14 @@ static void print_rd_rules(const struct ieee80211_regdomain *rd)
                 * in certain regions
                 */
                if (power_rule->max_antenna_gain)
-                       printk(KERN_INFO "    (%d KHz - %d KHz @ %d KHz), "
-                               "(%d mBi, %d mBm)\n",
+                       pr_info("    (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
                                freq_range->start_freq_khz,
                                freq_range->end_freq_khz,
                                freq_range->max_bandwidth_khz,
                                power_rule->max_antenna_gain,
                                power_rule->max_eirp);
                else
-                       printk(KERN_INFO "    (%d KHz - %d KHz @ %d KHz), "
-                               "(N/A, %d mBm)\n",
+                       pr_info("    (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
                                freq_range->start_freq_khz,
                                freq_range->end_freq_khz,
                                freq_range->max_bandwidth_khz,
@@ -1860,27 +1946,20 @@ static void print_regdomain(const struct ieee80211_regdomain *rd)
                        rdev = cfg80211_rdev_by_wiphy_idx(
                                last_request->wiphy_idx);
                        if (rdev) {
-                               printk(KERN_INFO "cfg80211: Current regulatory "
-                                       "domain updated by AP to: %c%c\n",
+                               pr_info("Current regulatory domain updated by AP to: %c%c\n",
                                        rdev->country_ie_alpha2[0],
                                        rdev->country_ie_alpha2[1]);
                        } else
-                               printk(KERN_INFO "cfg80211: Current regulatory "
-                                       "domain intersected:\n");
+                               pr_info("Current regulatory domain intersected:\n");
                } else
-                       printk(KERN_INFO "cfg80211: Current regulatory "
-                               "domain intersected:\n");
+                       pr_info("Current regulatory domain intersected:\n");
        } else if (is_world_regdom(rd->alpha2))
-               printk(KERN_INFO "cfg80211: World regulatory "
-                       "domain updated:\n");
+               pr_info("World regulatory domain updated:\n");
        else {
                if (is_unknown_alpha2(rd->alpha2))
-                       printk(KERN_INFO "cfg80211: Regulatory domain "
-                               "changed to driver built-in settings "
-                               "(unknown country)\n");
+                       pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
                else
-                       printk(KERN_INFO "cfg80211: Regulatory domain "
-                               "changed to country: %c%c\n",
+                       pr_info("Regulatory domain changed to country: %c%c\n",
                                rd->alpha2[0], rd->alpha2[1]);
        }
        print_rd_rules(rd);
@@ -1888,8 +1967,7 @@ static void print_regdomain(const struct ieee80211_regdomain *rd)
 
 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
 {
-       printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
-               rd->alpha2[0], rd->alpha2[1]);
+       pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
        print_rd_rules(rd);
 }
 
@@ -1940,8 +2018,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                return -EINVAL;
 
        if (!is_valid_rd(rd)) {
-               printk(KERN_ERR "cfg80211: Invalid "
-                       "regulatory domain detected:\n");
+               pr_err("Invalid regulatory domain detected:\n");
                print_regdomain_info(rd);
                return -EINVAL;
        }
@@ -2057,11 +2134,32 @@ int set_regdom(const struct ieee80211_regdomain *rd)
 
        nl80211_send_reg_change_event(last_request);
 
+       reg_set_request_processed();
+
        mutex_unlock(&reg_mutex);
 
        return r;
 }
 
+#ifdef CONFIG_HOTPLUG
+int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+       if (last_request && !last_request->processed) {
+               if (add_uevent_var(env, "COUNTRY=%c%c",
+                                  last_request->alpha2[0],
+                                  last_request->alpha2[1]))
+                       return -ENOMEM;
+       }
+
+       return 0;
+}
+#else
+int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+       return -ENODEV;
+}
+#endif /* CONFIG_HOTPLUG */
+
 /* Caller must hold cfg80211_mutex */
 void reg_device_remove(struct wiphy *wiphy)
 {
@@ -2085,6 +2183,13 @@ out:
        mutex_unlock(&reg_mutex);
 }
 
+static void reg_timeout_work(struct work_struct *work)
+{
+       REG_DBG_PRINT("Timeout while waiting for CRDA to reply, "
+                     "restoring regulatory settings");
+       restore_regulatory_settings(true);
+}
+
 int __init regulatory_init(void)
 {
        int err = 0;
@@ -2093,6 +2198,8 @@ int __init regulatory_init(void)
        if (IS_ERR(reg_pdev))
                return PTR_ERR(reg_pdev);
 
+       reg_pdev->dev.type = &reg_device_type;
+
        spin_lock_init(&reg_requests_lock);
        spin_lock_init(&reg_pending_beacons_lock);
 
@@ -2113,8 +2220,7 @@ int __init regulatory_init(void)
                 * early boot for call_usermodehelper(). For now treat these
                 * errors as non-fatal.
                 */
-               printk(KERN_ERR "cfg80211: kobject_uevent_env() was unable "
-                       "to call CRDA during init");
+               pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
 #ifdef CONFIG_CFG80211_REG_DEBUG
                /* We want to find out exactly why when debugging */
                WARN_ON(err);
@@ -2137,6 +2243,7 @@ void /* __init_or_exit */ regulatory_exit(void)
        struct reg_beacon *reg_beacon, *btmp;
 
        cancel_work_sync(&reg_work);
+       cancel_delayed_work_sync(&reg_timeout);
 
        mutex_lock(&cfg80211_mutex);
        mutex_lock(&reg_mutex);