mirror of
https://github.com/torvalds/linux.git
synced 2024-11-25 21:51:40 +00:00
cfg80211: comments style cleanup
Signed-off-by: Luis R. Rodriguez <lrodriguez@atheros.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Luis R. Rodriguez
John W. Linville
parent
fe33eb3908
commit
fb1fc7add5
@ -54,14 +54,18 @@ static u32 supported_bandwidths[] = {
|
||||
MHZ_TO_KHZ(20),
|
||||
};
|
||||
|
||||
/* Central wireless core regulatory domains, we only need two,
|
||||
/*
|
||||
* Central wireless core regulatory domains, we only need two,
|
||||
* the current one and a world regulatory domain in case we have no
|
||||
* information to give us an alpha2 */
|
||||
* information to give us an alpha2
|
||||
*/
|
||||
const struct ieee80211_regdomain *cfg80211_regdomain;
|
||||
|
||||
/* We use this as a place for the rd structure built from the
|
||||
/*
|
||||
* 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 */
|
||||
* what it thinks should apply for the same country
|
||||
*/
|
||||
static const struct ieee80211_regdomain *country_ie_regdomain;
|
||||
|
||||
static LIST_HEAD(reg_requests_list);
|
||||
@ -86,9 +90,11 @@ static char *ieee80211_regdom = "US";
|
||||
module_param(ieee80211_regdom, charp, 0444);
|
||||
MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
|
||||
|
||||
/* We assume 40 MHz bandwidth for the old regulatory work.
|
||||
/*
|
||||
* We assume 40 MHz bandwidth for the old regulatory work.
|
||||
* We make emphasis we are using the exact same frequencies
|
||||
* as before */
|
||||
* as before
|
||||
*/
|
||||
|
||||
static const struct ieee80211_regdomain us_regdom = {
|
||||
.n_reg_rules = 6,
|
||||
@ -127,8 +133,10 @@ static const struct ieee80211_regdomain jp_regdom = {
|
||||
|
||||
static const struct ieee80211_regdomain eu_regdom = {
|
||||
.n_reg_rules = 6,
|
||||
/* This alpha2 is bogus, we leave it here just for stupid
|
||||
* backward compatibility */
|
||||
/*
|
||||
* This alpha2 is bogus, we leave it here just for stupid
|
||||
* backward compatibility
|
||||
*/
|
||||
.alpha2 = "EU",
|
||||
.reg_rules = {
|
||||
/* IEEE 802.11b/g, channels 1..13 */
|
||||
@ -197,8 +205,10 @@ static void reset_regdomains(void)
|
||||
cfg80211_regdomain = NULL;
|
||||
}
|
||||
|
||||
/* Dynamic world regulatory domain requested by the wireless
|
||||
* core upon initialization */
|
||||
/*
|
||||
* Dynamic world regulatory domain requested by the wireless
|
||||
* core upon initialization
|
||||
*/
|
||||
static void update_world_regdomain(const struct ieee80211_regdomain *rd)
|
||||
{
|
||||
BUG_ON(!last_request);
|
||||
@ -239,8 +249,10 @@ static bool is_unknown_alpha2(const char *alpha2)
|
||||
{
|
||||
if (!alpha2)
|
||||
return false;
|
||||
/* Special case where regulatory domain was built by driver
|
||||
* but a specific alpha2 cannot be determined */
|
||||
/*
|
||||
* Special case where regulatory domain was built by driver
|
||||
* but a specific alpha2 cannot be determined
|
||||
*/
|
||||
if (alpha2[0] == '9' && alpha2[1] == '9')
|
||||
return true;
|
||||
return false;
|
||||
@ -250,9 +262,11 @@ static bool is_intersected_alpha2(const char *alpha2)
|
||||
{
|
||||
if (!alpha2)
|
||||
return false;
|
||||
/* Special case where regulatory domain is the
|
||||
/*
|
||||
* Special case where regulatory domain is the
|
||||
* result of an intersection between two regulatory domain
|
||||
* structures */
|
||||
* structures
|
||||
*/
|
||||
if (alpha2[0] == '9' && alpha2[1] == '8')
|
||||
return true;
|
||||
return false;
|
||||
@ -307,8 +321,10 @@ static bool country_ie_integrity_changes(u32 checksum)
|
||||
return false;
|
||||
}
|
||||
|
||||
/* This lets us keep regulatory code which is updated on a regulatory
|
||||
* basis in userspace. */
|
||||
/*
|
||||
* This lets us keep regulatory code which is updated on a regulatory
|
||||
* basis in userspace.
|
||||
*/
|
||||
static int call_crda(const char *alpha2)
|
||||
{
|
||||
char country_env[9 + 2] = "COUNTRY=";
|
||||
@ -419,10 +435,12 @@ static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
|
||||
#undef ONE_GHZ_IN_KHZ
|
||||
}
|
||||
|
||||
/* Converts a country IE to a regulatory domain. A regulatory domain
|
||||
/*
|
||||
* 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. */
|
||||
* with our userspace regulatory agent to get lower bounds.
|
||||
*/
|
||||
static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
u8 *country_ie,
|
||||
u8 country_ie_len,
|
||||
@ -467,9 +485,11 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
|
||||
*checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
|
||||
|
||||
/* We need to build a reg rule for each triplet, but first we must
|
||||
/*
|
||||
* 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 */
|
||||
* for each channel subband
|
||||
*/
|
||||
while (country_ie_len >= 3) {
|
||||
int end_channel = 0;
|
||||
struct ieee80211_country_ie_triplet *triplet =
|
||||
@ -507,9 +527,11 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
if (cur_sub_max_channel < cur_channel)
|
||||
return NULL;
|
||||
|
||||
/* Do not allow overlapping channels. Also channels
|
||||
/*
|
||||
* Do not allow overlapping channels. Also channels
|
||||
* passed in each subband must be monotonically
|
||||
* increasing */
|
||||
* increasing
|
||||
*/
|
||||
if (last_sub_max_channel) {
|
||||
if (cur_channel <= last_sub_max_channel)
|
||||
return NULL;
|
||||
@ -517,10 +539,12 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* When dot11RegulatoryClassesRequired is supported
|
||||
/*
|
||||
* 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 */
|
||||
* 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);
|
||||
@ -531,8 +555,10 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
country_ie_len -= 3;
|
||||
num_rules++;
|
||||
|
||||
/* Note: this is not a IEEE requirement but
|
||||
* simply a memory requirement */
|
||||
/*
|
||||
* Note: this is not a IEEE requirement but
|
||||
* simply a memory requirement
|
||||
*/
|
||||
if (num_rules > NL80211_MAX_SUPP_REG_RULES)
|
||||
return NULL;
|
||||
}
|
||||
@ -560,8 +586,10 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
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 */
|
||||
/*
|
||||
* 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;
|
||||
@ -583,10 +611,12 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
end_channel = triplet->chans.first_channel +
|
||||
(4 * (triplet->chans.num_channels - 1));
|
||||
|
||||
/* The +10 is since the regulatory domain expects
|
||||
/*
|
||||
* 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 */
|
||||
* the channels passed
|
||||
*/
|
||||
freq_range->start_freq_khz =
|
||||
MHZ_TO_KHZ(ieee80211_channel_to_frequency(
|
||||
triplet->chans.first_channel) - 10);
|
||||
@ -594,9 +624,11 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
MHZ_TO_KHZ(ieee80211_channel_to_frequency(
|
||||
end_channel) + 10);
|
||||
|
||||
/* Large arbitrary values, we intersect later */
|
||||
/* Increment this if we ever support >= 40 MHz channels
|
||||
* in IEEE 802.11 */
|
||||
/*
|
||||
* 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);
|
||||
@ -612,8 +644,10 @@ static struct ieee80211_regdomain *country_ie_2_rd(
|
||||
}
|
||||
|
||||
|
||||
/* Helper for regdom_intersect(), this does the real
|
||||
* mathematical intersection fun */
|
||||
/*
|
||||
* Helper for regdom_intersect(), this does the real
|
||||
* mathematical intersection fun
|
||||
*/
|
||||
static int reg_rules_intersect(
|
||||
const struct ieee80211_reg_rule *rule1,
|
||||
const struct ieee80211_reg_rule *rule2,
|
||||
@ -691,11 +725,13 @@ static struct ieee80211_regdomain *regdom_intersect(
|
||||
if (!rd1 || !rd2)
|
||||
return NULL;
|
||||
|
||||
/* First we get a count of the rules we'll need, then we actually
|
||||
/*
|
||||
* First we get a count of the rules we'll need, then we actually
|
||||
* build them. This is to so we can malloc() and free() a
|
||||
* regdomain once. The reason we use reg_rules_intersect() here
|
||||
* is it will return -EINVAL if the rule computed makes no sense.
|
||||
* All rules that do check out OK are valid. */
|
||||
* All rules that do check out OK are valid.
|
||||
*/
|
||||
|
||||
for (x = 0; x < rd1->n_reg_rules; x++) {
|
||||
rule1 = &rd1->reg_rules[x];
|
||||
@ -723,14 +759,18 @@ static struct ieee80211_regdomain *regdom_intersect(
|
||||
rule1 = &rd1->reg_rules[x];
|
||||
for (y = 0; y < rd2->n_reg_rules; y++) {
|
||||
rule2 = &rd2->reg_rules[y];
|
||||
/* This time around instead of using the stack lets
|
||||
/*
|
||||
* This time around instead of using the stack lets
|
||||
* write to the target rule directly saving ourselves
|
||||
* a memcpy() */
|
||||
* a memcpy()
|
||||
*/
|
||||
intersected_rule = &rd->reg_rules[rule_idx];
|
||||
r = reg_rules_intersect(rule1, rule2,
|
||||
intersected_rule);
|
||||
/* No need to memset here the intersected rule here as
|
||||
* we're not using the stack anymore */
|
||||
/*
|
||||
* No need to memset here the intersected rule here as
|
||||
* we're not using the stack anymore
|
||||
*/
|
||||
if (r)
|
||||
continue;
|
||||
rule_idx++;
|
||||
@ -749,8 +789,10 @@ static struct ieee80211_regdomain *regdom_intersect(
|
||||
return rd;
|
||||
}
|
||||
|
||||
/* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
|
||||
* want to just have the channel structure use these */
|
||||
/*
|
||||
* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
|
||||
* want to just have the channel structure use these
|
||||
*/
|
||||
static u32 map_regdom_flags(u32 rd_flags)
|
||||
{
|
||||
u32 channel_flags = 0;
|
||||
@ -776,8 +818,10 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
|
||||
|
||||
regd = custom_regd ? custom_regd : cfg80211_regdomain;
|
||||
|
||||
/* Follow the driver's regulatory domain, if present, unless a country
|
||||
* IE has been processed or a user wants to help complaince further */
|
||||
/*
|
||||
* 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 != REGDOM_SET_BY_COUNTRY_IE &&
|
||||
last_request->initiator != REGDOM_SET_BY_USER &&
|
||||
wiphy->regd)
|
||||
@ -795,9 +839,11 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
|
||||
fr = &rr->freq_range;
|
||||
pr = &rr->power_rule;
|
||||
|
||||
/* We only need to know if one frequency rule was
|
||||
/*
|
||||
* We only need to know if one frequency rule was
|
||||
* was in center_freq's band, that's enough, so lets
|
||||
* not overwrite it once found */
|
||||
* not overwrite it once found
|
||||
*/
|
||||
if (!band_rule_found)
|
||||
band_rule_found = freq_in_rule_band(fr, center_freq);
|
||||
|
||||
@ -850,7 +896,8 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
|
||||
&max_bandwidth, ®_rule);
|
||||
|
||||
if (r) {
|
||||
/* This means no regulatory rule was found in the country IE
|
||||
/*
|
||||
* 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
|
||||
@ -869,8 +916,10 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
|
||||
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 */
|
||||
/*
|
||||
* 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 == REGDOM_SET_BY_COUNTRY_IE)
|
||||
printk(KERN_DEBUG "cfg80211: Disabling "
|
||||
@ -889,9 +938,11 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
|
||||
if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
|
||||
request_wiphy && request_wiphy == wiphy &&
|
||||
request_wiphy->strict_regulatory) {
|
||||
/* This gaurantees the driver's requested regulatory domain
|
||||
/*
|
||||
* This gaurantees the driver's requested regulatory domain
|
||||
* will always be used as a base for further regulatory
|
||||
* settings */
|
||||
* settings
|
||||
*/
|
||||
chan->flags = chan->orig_flags =
|
||||
map_regdom_flags(reg_rule->flags);
|
||||
chan->max_antenna_gain = chan->orig_mag =
|
||||
@ -932,8 +983,10 @@ static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
|
||||
if (setby == REGDOM_SET_BY_CORE &&
|
||||
wiphy->custom_regulatory)
|
||||
return true;
|
||||
/* wiphy->regd will be set once the device has its own
|
||||
* desired regulatory domain set */
|
||||
/*
|
||||
* wiphy->regd will be set once the device has its own
|
||||
* desired regulatory domain set
|
||||
*/
|
||||
if (wiphy->strict_regulatory && !wiphy->regd &&
|
||||
!is_world_regdom(last_request->alpha2))
|
||||
return true;
|
||||
@ -1043,8 +1096,10 @@ static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Return value which can be used by ignore_request() to indicate
|
||||
* it has been determined we should intersect two regulatory domains */
|
||||
/*
|
||||
* Return value which can be used by ignore_request() to indicate
|
||||
* it has been determined we should intersect two regulatory domains
|
||||
*/
|
||||
#define REG_INTERSECT 1
|
||||
|
||||
/* This has the logic which determines when a new request
|
||||
@ -1084,8 +1139,10 @@ static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
|
||||
return -EOPNOTSUPP;
|
||||
return -EALREADY;
|
||||
}
|
||||
/* Two consecutive Country IE hints on the same wiphy.
|
||||
* This should be picked up early by the driver/stack */
|
||||
/*
|
||||
* Two consecutive Country IE hints on the same wiphy.
|
||||
* This should be picked up early by the driver/stack
|
||||
*/
|
||||
if (WARN_ON(!alpha2_equal(cfg80211_regdomain->alpha2,
|
||||
alpha2)))
|
||||
return 0;
|
||||
@ -1104,13 +1161,17 @@ static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
|
||||
case REGDOM_SET_BY_USER:
|
||||
if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
|
||||
return REG_INTERSECT;
|
||||
/* If the user knows better the user should set the regdom
|
||||
* to their country before the IE is picked up */
|
||||
/*
|
||||
* If the user knows better the user should set the regdom
|
||||
* to their country before the IE is picked up
|
||||
*/
|
||||
if (last_request->initiator == REGDOM_SET_BY_USER &&
|
||||
last_request->intersect)
|
||||
return -EOPNOTSUPP;
|
||||
/* Process user requests only after previous user/driver/core
|
||||
* requests have been processed */
|
||||
/*
|
||||
* Process user requests only after previous user/driver/core
|
||||
* requests have been processed
|
||||
*/
|
||||
if (last_request->initiator == REGDOM_SET_BY_CORE ||
|
||||
last_request->initiator == REGDOM_SET_BY_DRIVER ||
|
||||
last_request->initiator == REGDOM_SET_BY_USER) {
|
||||
@ -1151,9 +1212,11 @@ int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
|
||||
}
|
||||
intersect = true;
|
||||
} else if (r) {
|
||||
/* If the regulatory domain being requested by the
|
||||
/*
|
||||
* If the regulatory domain being requested by the
|
||||
* driver has already been set just copy it to the
|
||||
* wiphy */
|
||||
* wiphy
|
||||
*/
|
||||
if (r == -EALREADY && set_by == REGDOM_SET_BY_DRIVER) {
|
||||
r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
|
||||
if (r)
|
||||
@ -1363,9 +1426,11 @@ static bool reg_same_country_ie_hint(struct wiphy *wiphy,
|
||||
|
||||
if (likely(request_wiphy != wiphy))
|
||||
return !country_ie_integrity_changes(country_ie_checksum);
|
||||
/* We should not have let these through at this point, they
|
||||
/*
|
||||
* 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 */
|
||||
* on the device
|
||||
*/
|
||||
if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
|
||||
return true;
|
||||
return false;
|
||||
@ -1395,9 +1460,11 @@ 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
|
||||
/*
|
||||
* 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 */
|
||||
* we were able to process the last regulatory_hint_11d() call
|
||||
*/
|
||||
if (country_ie_regdomain)
|
||||
goto out;
|
||||
|
||||
@ -1409,34 +1476,44 @@ void regulatory_hint_11d(struct wiphy *wiphy,
|
||||
else if (country_ie[2] == 'O')
|
||||
env = ENVIRON_OUTDOOR;
|
||||
|
||||
/* We will run this for *every* beacon processed for the BSSID, so
|
||||
/*
|
||||
* We will run this for *every* beacon processed for the BSSID, so
|
||||
* we optimize an early check to exit out early if we don't have to
|
||||
* do anything */
|
||||
* do anything
|
||||
*/
|
||||
if (likely(wiphy_idx_valid(last_request->wiphy_idx))) {
|
||||
struct cfg80211_registered_device *drv_last_ie;
|
||||
|
||||
drv_last_ie =
|
||||
cfg80211_drv_by_wiphy_idx(last_request->wiphy_idx);
|
||||
|
||||
/* Lets keep this simple -- we trust the first AP
|
||||
* after we intersect with CRDA */
|
||||
/*
|
||||
* Lets keep this simple -- we trust the first AP
|
||||
* after we intersect with CRDA
|
||||
*/
|
||||
if (likely(&drv_last_ie->wiphy == wiphy)) {
|
||||
/* Ignore IEs coming in on this wiphy with
|
||||
* the same alpha2 and environment cap */
|
||||
/*
|
||||
* Ignore IEs coming in on this wiphy with
|
||||
* the same alpha2 and environment cap
|
||||
*/
|
||||
if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
|
||||
alpha2) &&
|
||||
env == drv_last_ie->env)) {
|
||||
goto out;
|
||||
}
|
||||
/* the wiphy moved on to another BSSID or the AP
|
||||
/*
|
||||
* the wiphy moved on to another BSSID or the AP
|
||||
* was reconfigured. XXX: We need to deal with the
|
||||
* case where the user suspends and goes to goes
|
||||
* to another country, and then gets IEs from an
|
||||
* AP with different settings */
|
||||
* AP with different settings
|
||||
*/
|
||||
goto out;
|
||||
} else {
|
||||
/* Ignore IEs coming in on two separate wiphys with
|
||||
* the same alpha2 and environment cap */
|
||||
/*
|
||||
* Ignore IEs coming in on two separate wiphys with
|
||||
* the same alpha2 and environment cap
|
||||
*/
|
||||
if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
|
||||
alpha2) &&
|
||||
env == drv_last_ie->env)) {
|
||||
@ -1467,8 +1544,10 @@ void regulatory_hint_11d(struct wiphy *wiphy,
|
||||
if (!request)
|
||||
goto free_rd_out;
|
||||
|
||||
/* We keep this around for when CRDA comes back with a response so
|
||||
* we can intersect with that */
|
||||
/*
|
||||
* We keep this around for when CRDA comes back with a response so
|
||||
* we can intersect with that
|
||||
*/
|
||||
country_ie_regdomain = rd;
|
||||
|
||||
request->wiphy_idx = get_wiphy_idx(wiphy);
|
||||
@ -1506,8 +1585,10 @@ static void print_rd_rules(const struct ieee80211_regdomain *rd)
|
||||
freq_range = ®_rule->freq_range;
|
||||
power_rule = ®_rule->power_rule;
|
||||
|
||||
/* There may not be documentation for max antenna gain
|
||||
* in certain regions */
|
||||
/*
|
||||
* There may not be documentation for max antenna gain
|
||||
* in certain regions
|
||||
*/
|
||||
if (power_rule->max_antenna_gain)
|
||||
printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
|
||||
"(%d mBi, %d mBm)\n",
|
||||
@ -1618,21 +1699,27 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
if (!last_request)
|
||||
return -EINVAL;
|
||||
|
||||
/* Lets only bother proceeding on the same alpha2 if the current
|
||||
/*
|
||||
* Lets only bother proceeding on the same alpha2 if the current
|
||||
* rd is non static (it means CRDA was present and was used last)
|
||||
* and the pending request came in from a country IE */
|
||||
* and the pending request came in from a country IE
|
||||
*/
|
||||
if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
|
||||
/* If someone else asked us to change the rd lets only bother
|
||||
* checking if the alpha2 changes if CRDA was already called */
|
||||
/*
|
||||
* 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_changed(rd->alpha2))
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Now lets set the regulatory domain, update all driver channels
|
||||
/*
|
||||
* Now lets set the regulatory domain, update all driver channels
|
||||
* and finally inform them of what we have done, in case they want
|
||||
* to review or adjust their own settings based on their own
|
||||
* internal EEPROM data */
|
||||
* internal EEPROM data
|
||||
*/
|
||||
|
||||
if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
|
||||
return -EINVAL;
|
||||
@ -1655,8 +1742,10 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* For a driver hint, lets copy the regulatory domain the
|
||||
* driver wanted to the wiphy to deal with conflicts */
|
||||
/*
|
||||
* For a driver hint, lets copy the regulatory domain the
|
||||
* driver wanted to the wiphy to deal with conflicts
|
||||
*/
|
||||
|
||||
BUG_ON(request_wiphy->regd);
|
||||
|
||||
@ -1677,9 +1766,11 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
if (!intersected_rd)
|
||||
return -EINVAL;
|
||||
|
||||
/* We can trash what CRDA provided now.
|
||||
/*
|
||||
* We can trash what CRDA provided now.
|
||||
* However if a driver requested this specific regulatory
|
||||
* domain we keep it for its private use */
|
||||
* domain we keep it for its private use
|
||||
*/
|
||||
if (last_request->initiator == REGDOM_SET_BY_DRIVER)
|
||||
request_wiphy->regd = rd;
|
||||
else
|
||||
@ -1701,8 +1792,10 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
BUG_ON(!country_ie_regdomain);
|
||||
|
||||
if (rd != country_ie_regdomain) {
|
||||
/* Intersect what CRDA returned and our what we
|
||||
* had built from the Country IE received */
|
||||
/*
|
||||
* Intersect what CRDA returned and our what we
|
||||
* had built from the Country IE received
|
||||
*/
|
||||
|
||||
intersected_rd = regdom_intersect(rd, country_ie_regdomain);
|
||||
|
||||
@ -1712,9 +1805,11 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
kfree(country_ie_regdomain);
|
||||
country_ie_regdomain = NULL;
|
||||
} else {
|
||||
/* This would happen when CRDA was not present and
|
||||
/*
|
||||
* This would happen when CRDA was not present and
|
||||
* OLD_REGULATORY was enabled. We intersect our Country
|
||||
* IE rd and what was set on cfg80211 originally */
|
||||
* IE rd and what was set on cfg80211 originally
|
||||
*/
|
||||
intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
|
||||
}
|
||||
|
||||
@ -1739,9 +1834,11 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
|
||||
}
|
||||
|
||||
|
||||
/* Use this call to set the current regulatory domain. Conflicts with
|
||||
/*
|
||||
* Use this call to set the current regulatory domain. Conflicts with
|
||||
* multiple drivers can be ironed out later. Caller must've already
|
||||
* kmalloc'd the rd structure. Caller must hold cfg80211_mutex */
|
||||
* kmalloc'd the rd structure. Caller must hold cfg80211_mutex
|
||||
*/
|
||||
int set_regdom(const struct ieee80211_regdomain *rd)
|
||||
{
|
||||
int r;
|
||||
@ -1800,10 +1897,12 @@ int regulatory_init(void)
|
||||
|
||||
printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
|
||||
print_regdomain_info(cfg80211_regdomain);
|
||||
/* The old code still requests for a new regdomain and if
|
||||
/*
|
||||
* The old code still requests for a new regdomain and if
|
||||
* you have CRDA you get it updated, otherwise you get
|
||||
* stuck with the static values. We ignore "EU" code as
|
||||
* that is not a valid ISO / IEC 3166 alpha2 */
|
||||
* that is not a valid ISO / IEC 3166 alpha2
|
||||
*/
|
||||
if (ieee80211_regdom[0] != 'E' || ieee80211_regdom[1] != 'U')
|
||||
err = regulatory_hint_core(ieee80211_regdom);
|
||||
#else
|
||||
|
||||
Loading…
Reference in New Issue
Block a user