Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/net/wireless/reg.c

 /*
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
  * Copyright 2008       Luis R. Rodriguez <lrodriguz@atheros.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
@@ skipping 705 matching lines @@
 
 /*
  * Note that right now we assume the desired channel bandwidth
  * is always 20 MHz for each individual channel (HT40 uses 20 MHz
  * per channel, the primary and the extension channel). To support
  * smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
  * new ieee80211_channel.target_bw and re run the regulatory check
  * on the wiphy with the target_bw specified. Then we can simply use
  * that below for the desired_bw_khz below.
  */
-static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
+static void handle_channel(struct wiphy *wiphy,
+                           enum nl80211_reg_initiator initiator,
+                           enum ieee80211_band band,
                            unsigned int chan_idx)
 {
         int r;
         u32 flags, bw_flags = 0;
         u32 desired_bw_khz = MHZ_TO_KHZ(20);
         const struct ieee80211_reg_rule *reg_rule = NULL;
         const struct ieee80211_power_rule *power_rule = NULL;
         const struct ieee80211_freq_range *freq_range = NULL;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *chan;
         struct wiphy *request_wiphy = NULL;
 
         assert_cfg80211_lock();
 
         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
 
         sband = wiphy->bands[band];
         BUG_ON(chan_idx >= sband->n_channels);
         chan = &sband->channels[chan_idx];
 
         flags = chan->orig_flags;
 
         r = freq_reg_info(wiphy,
                           MHZ_TO_KHZ(chan->center_freq),
                           desired_bw_khz,
                           &reg_rule);
 
-        if (r)
+        if (r) {
+                /*
+                 * We will disable all channels that do not match our
+                 * recieved regulatory rule unless the hint is coming
+                 * from a Country IE and the Country IE had no information
+                 * about a band. The IEEE 802.11 spec allows for an AP
+                 * to send only a subset of the regulatory rules allowed,
+                 * so an AP in the US that only supports 2.4 GHz may only send
+                 * a country IE with information for the 2.4 GHz band
+                 * while 5 GHz is still supported.
+                 */
+                if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
+                    r == -ERANGE)
+                        return;
+
+                REG_DBG_PRINT("cfg80211: Disabling freq %d MHz\n",
+                              chan->center_freq);
+                chan->flags = IEEE80211_CHAN_DISABLED;
                 return;
+        }
 
         power_rule = &reg_rule->power_rule;
         freq_range = &reg_rule->freq_range;
 
         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
                 bw_flags = IEEE80211_CHAN_NO_HT40;
 
         if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
             request_wiphy && request_wiphy == wiphy &&
             request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
@@ skipping 14 matching lines @@
         chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
         chan->max_antenna_gain = min(chan->orig_mag,
                 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
         if (chan->orig_mpwr)
                 chan->max_power = min(chan->orig_mpwr,
                         (int) MBM_TO_DBM(power_rule->max_eirp));
         else
                 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 }
 
-static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
+static void handle_band(struct wiphy *wiphy,
+                        enum ieee80211_band band,
+                        enum nl80211_reg_initiator initiator)
 {
         unsigned int i;
         struct ieee80211_supported_band *sband;
 
         BUG_ON(!wiphy->bands[band]);
         sband = wiphy->bands[band];
 
         for (i = 0; i < sband->n_channels; i++)
-                handle_channel(wiphy, band, i);
+                handle_channel(wiphy, initiator, band, i);
 }
 
 static bool ignore_reg_update(struct wiphy *wiphy,
                               enum nl80211_reg_initiator initiator)
 {
         if (!last_request)
                 return true;
         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
             wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
                 return true;
         /*
          * wiphy->regd will be set once the device has its own
          * desired regulatory domain set
          */
         if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
+            initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
             !is_world_regdom(last_request->alpha2))
                 return true;
         return false;
 }
 
 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
 {
         struct cfg80211_registered_device *rdev;
 
         list_for_each_entry(rdev, &cfg80211_rdev_list, list)
@@ skipping 201 matching lines @@
 
 void wiphy_update_regulatory(struct wiphy *wiphy,
                              enum nl80211_reg_initiator initiator)
 {
         enum ieee80211_band band;
 
         if (ignore_reg_update(wiphy, initiator))
                 goto out;
         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
                 if (wiphy->bands[band])
-                        handle_band(wiphy, band);
+                        handle_band(wiphy, band, initiator);
         }
 out:
         reg_process_beacons(wiphy);
         reg_process_ht_flags(wiphy);
         if (wiphy->reg_notifier)
                 wiphy->reg_notifier(wiphy, last_request);
 }
 
 static void handle_channel_custom(struct wiphy *wiphy,
                                   enum ieee80211_band band,
@@ skipping 116 matching lines @@
                                 return -EALREADY;
                         }
                         /*
                          * Two consecutive Country IE hints on the same wiphy.
                          * This should be picked up early by the driver/stack
                          */
                         if (WARN_ON(regdom_changes(pending_request->alpha2)))
                                 return 0;
                         return -EALREADY;
                 }
-                return REG_INTERSECT;
+                return 0;
         case NL80211_REGDOM_SET_BY_DRIVER:
                 if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
                         if (regdom_changes(pending_request->alpha2))
                                 return 0;
                         return -EALREADY;
                 }
 
                 /*
                  * This would happen if you unplug and plug your card
                  * back in or if you add a new device for which the previously
@@ skipping 887 matching lines @@
                                          &reg_requests_list, list) {
                         list_del(&reg_request->list);
                         kfree(reg_request);
                 }
         }
         spin_unlock(&reg_requests_lock);
 
         mutex_unlock(&reg_mutex);
         mutex_unlock(&cfg80211_mutex);
 }