net/wireless/reg.c

   1 /*
   2  * Copyright 2002-2005, Instant802 Networks, Inc.
   3  * Copyright 2005-2006, Devicescape Software, Inc.
   4  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
   5  * Copyright 2008       Luis R. Rodriguez <lrodriguz@atheros.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 /**
  13  * DOC: Wireless regulatory infrastructure
  14  *
  15  * The usual implementation is for a driver to read a device EEPROM to
  16  * determine which regulatory domain it should be operating under, then
  17  * looking up the allowable channels in a driver-local table and finally
  18  * registering those channels in the wiphy structure.
  19  *
  20  * Another set of compliance enforcement is for drivers to use their
  21  * own compliance limits which can be stored on the EEPROM. The host
  22  * driver or firmware may ensure these are used.
  23  *
  24  * In addition to all this we provide an extra layer of regulatory
  25  * conformance. For drivers which do not have any regulatory
  26  * information CRDA provides the complete regulatory solution.
  27  * For others it provides a community effort on further restrictions
  28  * to enhance compliance.
  29  *
  30  * Note: When number of rules --> infinity we will not be able to
  31  * index on alpha2 any more, instead we'll probably have to
  32  * rely on some SHA1 checksum of the regdomain for example.
  33  *
  34  */
  35 #include <linux/kernel.h>
  36 #include <linux/list.h>
  37 #include <linux/random.h>
  38 #include <linux/nl80211.h>
  39 #include <linux/platform_device.h>
  40 #include <net/wireless.h>
  41 #include <net/cfg80211.h>
  42 #include "core.h"
  43 #include "reg.h"
  44
  45 /**
  46  * struct regulatory_request - receipt of last regulatory request
  47  *
  48  * @wiphy: this is set if this request's initiator is
  49  *      %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
  50  *      can be used by the wireless core to deal with conflicts
  51  *      and potentially inform users of which devices specifically
  52  *      cased the conflicts.
  53  * @initiator: indicates who sent this request, could be any of
  54  *      of those set in reg_set_by, %REGDOM_SET_BY_*
  55  * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
  56  *      regulatory domain. We have a few special codes:
  57  *      00 - World regulatory domain
  58  *      99 - built by driver but a specific alpha2 cannot be determined
  59  *      98 - result of an intersection between two regulatory domains
  60  * @intersect: indicates whether the wireless core should intersect
  61  *      the requested regulatory domain with the presently set regulatory
  62  *      domain.
  63  * @country_ie_checksum: checksum of the last processed and accepted
  64  *      country IE
  65  * @country_ie_env: lets us know if the AP is telling us we are outdoor,
  66  *      indoor, or if it doesn't matter
  67  */
  68 struct regulatory_request {
  69         struct wiphy *wiphy;
  70         enum reg_set_by initiator;
  71         char alpha2[2];
  72         bool intersect;
  73         u32 country_ie_checksum;
  74         enum environment_cap country_ie_env;
  75 };
  76
  77 /* Receipt of information from last regulatory request */
  78 static struct regulatory_request *last_request;
  79
  80 /* To trigger userspace events */
  81 static struct platform_device *reg_pdev;
  82
  83 /* Keep the ordering from large to small */
  84 static u32 supported_bandwidths[] = {
  85         MHZ_TO_KHZ(40),
  86         MHZ_TO_KHZ(20),
  87 };
  88
  89 /* Central wireless core regulatory domains, we only need two,
  90  * the current one and a world regulatory domain in case we have no
  91  * information to give us an alpha2 */
  92 static const struct ieee80211_regdomain *cfg80211_regdomain;
  93
  94 /* We use this as a place for the rd structure built from the
  95  * last parsed country IE to rest until CRDA gets back to us with
  96  * what it thinks should apply for the same country */
  97 static const struct ieee80211_regdomain *country_ie_regdomain;
  98
  99 /* We keep a static world regulatory domain in case of the absence of CRDA */
 100 static const struct ieee80211_regdomain world_regdom = {
 101         .n_reg_rules = 1,
 102         .alpha2 =  "00",
 103         .reg_rules = {
 104                 REG_RULE(2412-10, 2462+10, 40, 6, 20,
 105                         NL80211_RRF_PASSIVE_SCAN |
 106                         NL80211_RRF_NO_IBSS),
 107         }
 108 };
 109
 110 static const struct ieee80211_regdomain *cfg80211_world_regdom =
 111         &world_regdom;
 112
 113 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
 114 static char *ieee80211_regdom = "US";
 115 module_param(ieee80211_regdom, charp, 0444);
 116 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 117
 118 /* We assume 40 MHz bandwidth for the old regulatory work.
 119  * We make emphasis we are using the exact same frequencies
 120  * as before */
 121
 122 static const struct ieee80211_regdomain us_regdom = {
 123         .n_reg_rules = 6,
 124         .alpha2 =  "US",
 125         .reg_rules = {
 126                 /* IEEE 802.11b/g, channels 1..11 */
 127                 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
 128                 /* IEEE 802.11a, channel 36 */
 129                 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
 130                 /* IEEE 802.11a, channel 40 */
 131                 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
 132                 /* IEEE 802.11a, channel 44 */
 133                 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
 134                 /* IEEE 802.11a, channels 48..64 */
 135                 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
 136                 /* IEEE 802.11a, channels 149..165, outdoor */
 137                 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
 138         }
 139 };
 140
 141 static const struct ieee80211_regdomain jp_regdom = {
 142         .n_reg_rules = 3,
 143         .alpha2 =  "JP",
 144         .reg_rules = {
 145                 /* IEEE 802.11b/g, channels 1..14 */
 146                 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
 147                 /* IEEE 802.11a, channels 34..48 */
 148                 REG_RULE(5170-10, 5240+10, 40, 6, 20,
 149                         NL80211_RRF_PASSIVE_SCAN),
 150                 /* IEEE 802.11a, channels 52..64 */
 151                 REG_RULE(5260-10, 5320+10, 40, 6, 20,
 152                         NL80211_RRF_NO_IBSS |
 153                         NL80211_RRF_DFS),
 154         }
 155 };
 156
 157 static const struct ieee80211_regdomain eu_regdom = {
 158         .n_reg_rules = 6,
 159         /* This alpha2 is bogus, we leave it here just for stupid
 160          * backward compatibility */
 161         .alpha2 =  "EU",
 162         .reg_rules = {
 163                 /* IEEE 802.11b/g, channels 1..13 */
 164                 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
 165                 /* IEEE 802.11a, channel 36 */
 166                 REG_RULE(5180-10, 5180+10, 40, 6, 23,
 167                         NL80211_RRF_PASSIVE_SCAN),
 168                 /* IEEE 802.11a, channel 40 */
 169                 REG_RULE(5200-10, 5200+10, 40, 6, 23,
 170                         NL80211_RRF_PASSIVE_SCAN),
 171                 /* IEEE 802.11a, channel 44 */
 172                 REG_RULE(5220-10, 5220+10, 40, 6, 23,
 173                         NL80211_RRF_PASSIVE_SCAN),
 174                 /* IEEE 802.11a, channels 48..64 */
 175                 REG_RULE(5240-10, 5320+10, 40, 6, 20,
 176                         NL80211_RRF_NO_IBSS |
 177                         NL80211_RRF_DFS),
 178                 /* IEEE 802.11a, channels 100..140 */
 179                 REG_RULE(5500-10, 5700+10, 40, 6, 30,
 180                         NL80211_RRF_NO_IBSS |
 181                         NL80211_RRF_DFS),
 182         }
 183 };
 184
 185 static const struct ieee80211_regdomain *static_regdom(char *alpha2)
 186 {
 187         if (alpha2[0] == 'U' && alpha2[1] == 'S')
 188                 return &us_regdom;
 189         if (alpha2[0] == 'J' && alpha2[1] == 'P')
 190                 return &jp_regdom;
 191         if (alpha2[0] == 'E' && alpha2[1] == 'U')
 192                 return &eu_regdom;
 193         /* Default, as per the old rules */
 194         return &us_regdom;
 195 }
 196
 197 static bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
 198 {
 199         if (rd == &us_regdom || rd == &jp_regdom || rd == &eu_regdom)
 200                 return true;
 201         return false;
 202 }
 203 #else
 204 static inline bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
 205 {
 206         return false;
 207 }
 208 #endif
 209
 210 static void reset_regdomains(void)
 211 {
 212         /* avoid freeing static information or freeing something twice */
 213         if (cfg80211_regdomain == cfg80211_world_regdom)
 214                 cfg80211_regdomain = NULL;
 215         if (cfg80211_world_regdom == &world_regdom)
 216                 cfg80211_world_regdom = NULL;
 217         if (cfg80211_regdomain == &world_regdom)
 218                 cfg80211_regdomain = NULL;
 219         if (is_old_static_regdom(cfg80211_regdomain))
 220                 cfg80211_regdomain = NULL;
 221
 222         kfree(cfg80211_regdomain);
 223         kfree(cfg80211_world_regdom);
 224
 225         cfg80211_world_regdom = &world_regdom;
 226         cfg80211_regdomain = NULL;
 227 }
 228
 229 /* Dynamic world regulatory domain requested by the wireless
 230  * core upon initialization */
 231 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 232 {
 233         BUG_ON(!last_request);
 234
 235         reset_regdomains();
 236
 237         cfg80211_world_regdom = rd;
 238         cfg80211_regdomain = rd;
 239 }
 240
 241 bool is_world_regdom(const char *alpha2)
 242 {
 243         if (!alpha2)
 244                 return false;
 245         if (alpha2[0] == '0' && alpha2[1] == '0')
 246                 return true;
 247         return false;
 248 }
 249
 250 static bool is_alpha2_set(const char *alpha2)
 251 {
 252         if (!alpha2)
 253                 return false;
 254         if (alpha2[0] != 0 && alpha2[1] != 0)
 255                 return true;
 256         return false;
 257 }
 258
 259 static bool is_alpha_upper(char letter)
 260 {
 261         /* ASCII A - Z */
 262         if (letter >= 65 && letter <= 90)
 263                 return true;
 264         return false;
 265 }
 266
 267 static bool is_unknown_alpha2(const char *alpha2)
 268 {
 269         if (!alpha2)
 270                 return false;
 271         /* Special case where regulatory domain was built by driver
 272          * but a specific alpha2 cannot be determined */
 273         if (alpha2[0] == '9' && alpha2[1] == '9')
 274                 return true;
 275         return false;
 276 }
 277
 278 static bool is_intersected_alpha2(const char *alpha2)
 279 {
 280         if (!alpha2)
 281                 return false;
 282         /* Special case where regulatory domain is the
 283          * result of an intersection between two regulatory domain
 284          * structures */
 285         if (alpha2[0] == '9' && alpha2[1] == '8')
 286                 return true;
 287         return false;
 288 }
 289
 290 static bool is_an_alpha2(const char *alpha2)
 291 {
 292         if (!alpha2)
 293                 return false;
 294         if (is_alpha_upper(alpha2[0]) && is_alpha_upper(alpha2[1]))
 295                 return true;
 296         return false;
 297 }
 298
 299 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 300 {
 301         if (!alpha2_x || !alpha2_y)
 302                 return false;
 303         if (alpha2_x[0] == alpha2_y[0] &&
 304                 alpha2_x[1] == alpha2_y[1])
 305                 return true;
 306         return false;
 307 }
 308
 309 static bool regdom_changed(const char *alpha2)
 310 {
 311         if (!cfg80211_regdomain)
 312                 return true;
 313         if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
 314                 return false;
 315         return true;
 316 }
 317
 318 /**
 319  * country_ie_integrity_changes - tells us if the country IE has changed
 320  * @checksum: checksum of country IE of fields we are interested in
 321  *
 322  * If the country IE has not changed you can ignore it safely. This is
 323  * useful to determine if two devices are seeing two different country IEs
 324  * even on the same alpha2. Note that this will return false if no IE has
 325  * been set on the wireless core yet.
 326  */
 327 static bool country_ie_integrity_changes(u32 checksum)
 328 {
 329         /* If no IE has been set then the checksum doesn't change */
 330         if (unlikely(!last_request->country_ie_checksum))
 331                 return false;
 332         if (unlikely(last_request->country_ie_checksum != checksum))
 333                 return true;
 334         return false;
 335 }
 336
 337 /* This lets us keep regulatory code which is updated on a regulatory
 338  * basis in userspace. */
 339 static int call_crda(const char *alpha2)
 340 {
 341         char country_env[9 + 2] = "COUNTRY=";
 342         char *envp[] = {
 343                 country_env,
 344                 NULL
 345         };
 346
 347         if (!is_world_regdom((char *) alpha2))
 348                 printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
 349                         alpha2[0], alpha2[1]);
 350         else
 351                 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
 352                         "regulatory domain\n");
 353
 354         country_env[8] = alpha2[0];
 355         country_env[9] = alpha2[1];
 356
 357         return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
 358 }
 359
 360 /* Used by nl80211 before kmalloc'ing our regulatory domain */
 361 bool reg_is_valid_request(const char *alpha2)
 362 {
 363         if (!last_request)
 364                 return false;
 365
 366         return alpha2_equal(last_request->alpha2, alpha2);
 367 }
 368
 369 /* Sanity check on a regulatory rule */
 370 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 371 {
 372         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 373         u32 freq_diff;
 374
 375         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
 376                 return false;
 377
 378         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
 379                 return false;
 380
 381         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 382
 383         if (freq_diff <= 0 || freq_range->max_bandwidth_khz > freq_diff)
 384                 return false;
 385
 386         return true;
 387 }
 388
 389 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
 390 {
 391         const struct ieee80211_reg_rule *reg_rule = NULL;
 392         unsigned int i;
 393
 394         if (!rd->n_reg_rules)
 395                 return false;
 396
 397         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 398                 return false;
 399
 400         for (i = 0; i < rd->n_reg_rules; i++) {
 401                 reg_rule = &rd->reg_rules[i];
 402                 if (!is_valid_reg_rule(reg_rule))
 403                         return false;
 404         }
 405
 406         return true;
 407 }
 408
 409 /* Returns value in KHz */
 410 static u32 freq_max_bandwidth(const struct ieee80211_freq_range *freq_range,
 411         u32 freq)
 412 {
 413         unsigned int i;
 414         for (i = 0; i < ARRAY_SIZE(supported_bandwidths); i++) {
 415                 u32 start_freq_khz = freq - supported_bandwidths[i]/2;
 416                 u32 end_freq_khz = freq + supported_bandwidths[i]/2;
 417                 if (start_freq_khz >= freq_range->start_freq_khz &&
 418                         end_freq_khz <= freq_range->end_freq_khz)
 419                         return supported_bandwidths[i];
 420         }
 421         return 0;
 422 }
 423
 424 /**
 425  * freq_in_rule_band - tells us if a frequency is in a frequency band
 426  * @freq_range: frequency rule we want to query
 427  * @freq_khz: frequency we are inquiring about
 428  *
 429  * This lets us know if a specific frequency rule is or is not relevant to
 430  * a specific frequency's band. Bands are device specific and artificial
 431  * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
 432  * safe for now to assume that a frequency rule should not be part of a
 433  * frequency's band if the start freq or end freq are off by more than 2 GHz.
 434  * This resolution can be lowered and should be considered as we add
 435  * regulatory rule support for other "bands".
 436  **/
 437 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 438         u32 freq_khz)
 439 {
 440 #define ONE_GHZ_IN_KHZ  1000000
 441         if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
 442                 return true;
 443         if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
 444                 return true;
 445         return false;
 446 #undef ONE_GHZ_IN_KHZ
 447 }
 448
 449 /* Converts a country IE to a regulatory domain. A regulatory domain
 450  * structure has a lot of information which the IE doesn't yet have,
 451  * so for the other values we use upper max values as we will intersect
 452  * with our userspace regulatory agent to get lower bounds. */
 453 static struct ieee80211_regdomain *country_ie_2_rd(
 454                                 u8 *country_ie,
 455                                 u8 country_ie_len,
 456                                 u32 *checksum)
 457 {
 458         struct ieee80211_regdomain *rd = NULL;
 459         unsigned int i = 0;
 460         char alpha2[2];
 461         u32 flags = 0;
 462         u32 num_rules = 0, size_of_regd = 0;
 463         u8 *triplets_start = NULL;
 464         u8 len_at_triplet = 0;
 465         /* the last channel we have registered in a subband (triplet) */
 466         int last_sub_max_channel = 0;
 467
 468         *checksum = 0xDEADBEEF;
 469
 470         /* Country IE requirements */
 471         BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
 472                 country_ie_len & 0x01);
 473
 474         alpha2[0] = country_ie[0];
 475         alpha2[1] = country_ie[1];
 476
 477         /*
 478          * Third octet can be:
 479          *    'I' - Indoor
 480          *    'O' - Outdoor
 481          *
 482          *  anything else we assume is no restrictions
 483          */
 484         if (country_ie[2] == 'I')
 485                 flags = NL80211_RRF_NO_OUTDOOR;
 486         else if (country_ie[2] == 'O')
 487                 flags = NL80211_RRF_NO_INDOOR;
 488
 489         country_ie += 3;
 490         country_ie_len -= 3;
 491
 492         triplets_start = country_ie;
 493         len_at_triplet = country_ie_len;
 494
 495         *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
 496
 497         /* We need to build a reg rule for each triplet, but first we must
 498          * calculate the number of reg rules we will need. We will need one
 499          * for each channel subband */
 500         while (country_ie_len >= 3) {
 501                 struct ieee80211_country_ie_triplet *triplet =
 502                         (struct ieee80211_country_ie_triplet *) country_ie;
 503                 int cur_sub_max_channel = 0, cur_channel = 0;
 504
 505                 if (triplet->ext.reg_extension_id >=
 506                                 IEEE80211_COUNTRY_EXTENSION_ID) {
 507                         country_ie += 3;
 508                         country_ie_len -= 3;
 509                         continue;
 510                 }
 511
 512                 cur_channel = triplet->chans.first_channel;
 513                 cur_sub_max_channel = ieee80211_channel_to_frequency(
 514                         cur_channel + triplet->chans.num_channels);
 515
 516                 /* Basic sanity check */
 517                 if (cur_sub_max_channel < cur_channel)
 518                         return NULL;
 519
 520                 /* Do not allow overlapping channels. Also channels
 521                  * passed in each subband must be monotonically
 522                  * increasing */
 523                 if (last_sub_max_channel) {
 524                         if (cur_channel <= last_sub_max_channel)
 525                                 return NULL;
 526                         if (cur_sub_max_channel <= last_sub_max_channel)
 527                                 return NULL;
 528                 }
 529
 530                 /* When dot11RegulatoryClassesRequired is supported
 531                  * we can throw ext triplets as part of this soup,
 532                  * for now we don't care when those change as we
 533                  * don't support them */
 534                 *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
 535                   ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
 536                   ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
 537
 538                 last_sub_max_channel = cur_sub_max_channel;
 539
 540                 country_ie += 3;
 541                 country_ie_len -= 3;
 542                 num_rules++;
 543
 544                 /* Note: this is not a IEEE requirement but
 545                  * simply a memory requirement */
 546                 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
 547                         return NULL;
 548         }
 549
 550         country_ie = triplets_start;
 551         country_ie_len = len_at_triplet;
 552
 553         size_of_regd = sizeof(struct ieee80211_regdomain) +
 554                 (num_rules * sizeof(struct ieee80211_reg_rule));
 555
 556         rd = kzalloc(size_of_regd, GFP_KERNEL);
 557         if (!rd)
 558                 return NULL;
 559
 560         rd->n_reg_rules = num_rules;
 561         rd->alpha2[0] = alpha2[0];
 562         rd->alpha2[1] = alpha2[1];
 563
 564         /* This time around we fill in the rd */
 565         while (country_ie_len >= 3) {
 566                 int end_channel = 0;
 567                 struct ieee80211_country_ie_triplet *triplet =
 568                         (struct ieee80211_country_ie_triplet *) country_ie;
 569                 struct ieee80211_reg_rule *reg_rule = NULL;
 570                 struct ieee80211_freq_range *freq_range = NULL;
 571                 struct ieee80211_power_rule *power_rule = NULL;
 572
 573                 /* Must parse if dot11RegulatoryClassesRequired is true,
 574                  * we don't support this yet */
 575                 if (triplet->ext.reg_extension_id >=
 576                                 IEEE80211_COUNTRY_EXTENSION_ID) {
 577                         country_ie += 3;
 578                         country_ie_len -= 3;
 579                         continue;
 580                 }
 581
 582                 reg_rule = &rd->reg_rules[i];
 583                 freq_range = &reg_rule->freq_range;
 584                 power_rule = &reg_rule->power_rule;
 585
 586                 reg_rule->flags = flags;
 587
 588                 /* 2 GHz */
 589                 if (triplet->chans.first_channel <= 14)
 590                         end_channel = triplet->chans.first_channel +
 591                                 triplet->chans.num_channels;
 592                 else
 593                         /*
 594                          * 5 GHz -- For example in country IEs if the first
 595                          * channel given is 36 and the number of channels is 4
 596                          * then the individual channel numbers defined for the
 597                          * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
 598                          * and not 36, 37, 38, 39.
 599                          *
 600                          * See: http://tinyurl.com/11d-clarification
 601                          */
 602                         end_channel =  triplet->chans.first_channel +
 603                                 (4 * (triplet->chans.num_channels - 1));
 604
 605                 /* The +10 is since the regulatory domain expects
 606                  * the actual band edge, not the center of freq for
 607                  * its start and end freqs, assuming 20 MHz bandwidth on
 608                  * the channels passed */
 609                 freq_range->start_freq_khz =
 610                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
 611                                 triplet->chans.first_channel) - 10);
 612                 freq_range->end_freq_khz =
 613                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
 614                                 end_channel) + 10);
 615
 616                 /* Large arbitrary values, we intersect later */
 617                 /* Increment this if we ever support >= 40 MHz channels
 618                  * in IEEE 802.11 */
 619                 freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
 620                 power_rule->max_antenna_gain = DBI_TO_MBI(100);
 621                 power_rule->max_eirp = DBM_TO_MBM(100);
 622
 623                 country_ie += 3;
 624                 country_ie_len -= 3;
 625                 i++;
 626
 627                 BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
 628         }
 629
 630         return rd;
 631 }
 632
 633
 634 /* Helper for regdom_intersect(), this does the real
 635  * mathematical intersection fun */
 636 static int reg_rules_intersect(
 637         const struct ieee80211_reg_rule *rule1,
 638         const struct ieee80211_reg_rule *rule2,
 639         struct ieee80211_reg_rule *intersected_rule)
 640 {
 641         const struct ieee80211_freq_range *freq_range1, *freq_range2;
 642         struct ieee80211_freq_range *freq_range;
 643         const struct ieee80211_power_rule *power_rule1, *power_rule2;
 644         struct ieee80211_power_rule *power_rule;
 645         u32 freq_diff;
 646
 647         freq_range1 = &rule1->freq_range;
 648         freq_range2 = &rule2->freq_range;
 649         freq_range = &intersected_rule->freq_range;
 650
 651         power_rule1 = &rule1->power_rule;
 652         power_rule2 = &rule2->power_rule;
 653         power_rule = &intersected_rule->power_rule;
 654
 655         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
 656                 freq_range2->start_freq_khz);
 657         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
 658                 freq_range2->end_freq_khz);
 659         freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
 660                 freq_range2->max_bandwidth_khz);
 661
 662         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 663         if (freq_range->max_bandwidth_khz > freq_diff)
 664                 freq_range->max_bandwidth_khz = freq_diff;
 665
 666         power_rule->max_eirp = min(power_rule1->max_eirp,
 667                 power_rule2->max_eirp);
 668         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
 669                 power_rule2->max_antenna_gain);
 670
 671         intersected_rule->flags = (rule1->flags | rule2->flags);
 672
 673         if (!is_valid_reg_rule(intersected_rule))
 674                 return -EINVAL;
 675
 676         return 0;
 677 }
 678
 679 /**
 680  * regdom_intersect - do the intersection between two regulatory domains
 681  * @rd1: first regulatory domain
 682  * @rd2: second regulatory domain
 683  *
 684  * Use this function to get the intersection between two regulatory domains.
 685  * Once completed we will mark the alpha2 for the rd as intersected, "98",
 686  * as no one single alpha2 can represent this regulatory domain.
 687  *
 688  * Returns a pointer to the regulatory domain structure which will hold the
 689  * resulting intersection of rules between rd1 and rd2. We will
 690  * kzalloc() this structure for you.
 691  */
 692 static struct ieee80211_regdomain *regdom_intersect(
 693         const struct ieee80211_regdomain *rd1,
 694         const struct ieee80211_regdomain *rd2)
 695 {
 696         int r, size_of_regd;
 697         unsigned int x, y;
 698         unsigned int num_rules = 0, rule_idx = 0;
 699         const struct ieee80211_reg_rule *rule1, *rule2;
 700         struct ieee80211_reg_rule *intersected_rule;
 701         struct ieee80211_regdomain *rd;
 702         /* This is just a dummy holder to help us count */
 703         struct ieee80211_reg_rule irule;
 704
 705         /* Uses the stack temporarily for counter arithmetic */
 706         intersected_rule = &irule;
 707
 708         memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
 709
 710         if (!rd1 || !rd2)
 711                 return NULL;
 712
 713         /* First we get a count of the rules we'll need, then we actually
 714          * build them. This is to so we can malloc() and free() a
 715          * regdomain once. The reason we use reg_rules_intersect() here
 716          * is it will return -EINVAL if the rule computed makes no sense.
 717          * All rules that do check out OK are valid. */
 718
 719         for (x = 0; x < rd1->n_reg_rules; x++) {
 720                 rule1 = &rd1->reg_rules[x];
 721                 for (y = 0; y < rd2->n_reg_rules; y++) {
 722                         rule2 = &rd2->reg_rules[y];
 723                         if (!reg_rules_intersect(rule1, rule2,
 724                                         intersected_rule))
 725                                 num_rules++;
 726                         memset(intersected_rule, 0,
 727                                         sizeof(struct ieee80211_reg_rule));
 728                 }
 729         }
 730
 731         if (!num_rules)
 732                 return NULL;
 733
 734         size_of_regd = sizeof(struct ieee80211_regdomain) +
 735                 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
 736
 737         rd = kzalloc(size_of_regd, GFP_KERNEL);
 738         if (!rd)
 739                 return NULL;
 740
 741         for (x = 0; x < rd1->n_reg_rules; x++) {
 742                 rule1 = &rd1->reg_rules[x];
 743                 for (y = 0; y < rd2->n_reg_rules; y++) {
 744                         rule2 = &rd2->reg_rules[y];
 745                         /* This time around instead of using the stack lets
 746                          * write to the target rule directly saving ourselves
 747                          * a memcpy() */
 748                         intersected_rule = &rd->reg_rules[rule_idx];
 749                         r = reg_rules_intersect(rule1, rule2,
 750                                 intersected_rule);
 751                         /* No need to memset here the intersected rule here as
 752                          * we're not using the stack anymore */
 753                         if (r)
 754                                 continue;
 755                         rule_idx++;
 756                 }
 757         }
 758
 759         if (rule_idx != num_rules) {
 760                 kfree(rd);
 761                 return NULL;
 762         }
 763
 764         rd->n_reg_rules = num_rules;
 765         rd->alpha2[0] = '9';
 766         rd->alpha2[1] = '8';
 767
 768         return rd;
 769 }
 770
 771 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 772  * want to just have the channel structure use these */
 773 static u32 map_regdom_flags(u32 rd_flags)
 774 {
 775         u32 channel_flags = 0;
 776         if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
 777                 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 778         if (rd_flags & NL80211_RRF_NO_IBSS)
 779                 channel_flags |= IEEE80211_CHAN_NO_IBSS;
 780         if (rd_flags & NL80211_RRF_DFS)
 781                 channel_flags |= IEEE80211_CHAN_RADAR;
 782         return channel_flags;
 783 }
 784
 785 /**
 786  * freq_reg_info - get regulatory information for the given frequency
 787  * @center_freq: Frequency in KHz for which we want regulatory information for
 788  * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
 789  *      you can set this to 0. If this frequency is allowed we then set
 790  *      this value to the maximum allowed bandwidth.
 791  * @reg_rule: the regulatory rule which we have for this frequency
 792  *
 793  * Use this function to get the regulatory rule for a specific frequency on
 794  * a given wireless device. If the device has a specific regulatory domain
 795  * it wants to follow we respect that unless a country IE has been received
 796  * and processed already.
 797  *
 798  * Returns 0 if it was able to find a valid regulatory rule which does
 799  * apply to the given center_freq otherwise it returns non-zero. It will
 800  * also return -ERANGE if we determine the given center_freq does not even have
 801  * a regulatory rule for a frequency range in the center_freq's band. See
 802  * freq_in_rule_band() for our current definition of a band -- this is purely
 803  * subjective and right now its 802.11 specific.
 804  */
 805 static int freq_reg_info(u32 center_freq, u32 *bandwidth,
 806                          const struct ieee80211_reg_rule **reg_rule)
 807 {
 808         int i;
 809         bool band_rule_found = false;
 810         u32 max_bandwidth = 0;
 811
 812         if (!cfg80211_regdomain)
 813                 return -EINVAL;
 814
 815         for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
 816                 const struct ieee80211_reg_rule *rr;
 817                 const struct ieee80211_freq_range *fr = NULL;
 818                 const struct ieee80211_power_rule *pr = NULL;
 819
 820                 rr = &cfg80211_regdomain->reg_rules[i];
 821                 fr = &rr->freq_range;
 822                 pr = &rr->power_rule;
 823
 824                 /* We only need to know if one frequency rule was
 825                  * was in center_freq's band, that's enough, so lets
 826                  * not overwrite it once found */
 827                 if (!band_rule_found)
 828                         band_rule_found = freq_in_rule_band(fr, center_freq);
 829
 830                 max_bandwidth = freq_max_bandwidth(fr, center_freq);
 831
 832                 if (max_bandwidth && *bandwidth <= max_bandwidth) {
 833                         *reg_rule = rr;
 834                         *bandwidth = max_bandwidth;
 835                         break;
 836                 }
 837         }
 838
 839         if (!band_rule_found)
 840                 return -ERANGE;
 841
 842         return !max_bandwidth;
 843 }
 844
 845 static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
 846                            unsigned int chan_idx)
 847 {
 848         int r;
 849         u32 flags;
 850         u32 max_bandwidth = 0;
 851         const struct ieee80211_reg_rule *reg_rule = NULL;
 852         const struct ieee80211_power_rule *power_rule = NULL;
 853         struct ieee80211_supported_band *sband;
 854         struct ieee80211_channel *chan;
 855
 856         sband = wiphy->bands[band];
 857         BUG_ON(chan_idx >= sband->n_channels);
 858         chan = &sband->channels[chan_idx];
 859
 860         flags = chan->orig_flags;
 861
 862         r = freq_reg_info(MHZ_TO_KHZ(chan->center_freq),
 863                 &max_bandwidth, &reg_rule);
 864
 865         if (r) {
 866                 /* This means no regulatory rule was found in the country IE
 867                  * with a frequency range on the center_freq's band, since
 868                  * IEEE-802.11 allows for a country IE to have a subset of the
 869                  * regulatory information provided in a country we ignore
 870                  * disabling the channel unless at least one reg rule was
 871                  * found on the center_freq's band. For details see this
 872                  * clarification:
 873                  *
 874                  * http://tinyurl.com/11d-clarification
 875                  */
 876                 if (r == -ERANGE &&
 877                     last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
 878 #ifdef CONFIG_CFG80211_REG_DEBUG
 879                         printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
 880                                 "intact on %s - no rule found in band on "
 881                                 "Country IE\n",
 882                                 chan->center_freq, wiphy_name(wiphy));
 883 #endif
 884                 } else {
 885                 /* In this case we know the country IE has at least one reg rule
 886                  * for the band so we respect its band definitions */
 887 #ifdef CONFIG_CFG80211_REG_DEBUG
 888                         if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
 889                                 printk(KERN_DEBUG "cfg80211: Disabling "
 890                                         "channel %d MHz on %s due to "
 891                                         "Country IE\n",
 892                                         chan->center_freq, wiphy_name(wiphy));
 893 #endif
 894                         flags |= IEEE80211_CHAN_DISABLED;
 895                         chan->flags = flags;
 896                 }
 897                 return;
 898         }
 899
 900         power_rule = &reg_rule->power_rule;
 901
 902         chan->flags = flags | map_regdom_flags(reg_rule->flags);
 903         chan->max_antenna_gain = min(chan->orig_mag,
 904                 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
 905         chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
 906         if (chan->orig_mpwr)
 907                 chan->max_power = min(chan->orig_mpwr,
 908                         (int) MBM_TO_DBM(power_rule->max_eirp));
 909         else
 910                 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 911 }
 912
 913 static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
 914 {
 915         unsigned int i;
 916         struct ieee80211_supported_band *sband;
 917
 918         BUG_ON(!wiphy->bands[band]);
 919         sband = wiphy->bands[band];
 920
 921         for (i = 0; i < sband->n_channels; i++)
 922                 handle_channel(wiphy, band, i);
 923 }
 924
 925 static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
 926 {
 927         if (!last_request)
 928                 return true;
 929         if (setby == REGDOM_SET_BY_CORE &&
 930                   wiphy->fw_handles_regulatory)
 931                 return true;
 932         return false;
 933 }
 934
 935 static void update_all_wiphy_regulatory(enum reg_set_by setby)
 936 {
 937         struct cfg80211_registered_device *drv;
 938
 939         list_for_each_entry(drv, &cfg80211_drv_list, list)
 940                 if (!ignore_reg_update(&drv->wiphy, setby))
 941                         wiphy_update_regulatory(&drv->wiphy, setby);
 942 }
 943
 944 void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby)
 945 {
 946         enum ieee80211_band band;
 947         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 948                 if (wiphy->bands[band])
 949                         handle_band(wiphy, band);
 950                 if (wiphy->reg_notifier)
 951                         wiphy->reg_notifier(wiphy, setby);
 952         }
 953 }
 954
 955 /* Return value which can be used by ignore_request() to indicate
 956  * it has been determined we should intersect two regulatory domains */
 957 #define REG_INTERSECT   1
 958
 959 /* This has the logic which determines when a new request
 960  * should be ignored. */
 961 static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
 962                           const char *alpha2)
 963 {
 964         /* All initial requests are respected */
 965         if (!last_request)
 966                 return 0;
 967
 968         switch (set_by) {
 969         case REGDOM_SET_BY_INIT:
 970                 return -EINVAL;
 971         case REGDOM_SET_BY_CORE:
 972                 /*
 973                  * Always respect new wireless core hints, should only happen
 974                  * when updating the world regulatory domain at init.
 975                  */
 976                 return 0;
 977         case REGDOM_SET_BY_COUNTRY_IE:
 978                 if (unlikely(!is_an_alpha2(alpha2)))
 979                         return -EINVAL;
 980                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
 981                         if (last_request->wiphy != wiphy) {
 982                                 /*
 983                                  * Two cards with two APs claiming different
 984                                  * different Country IE alpha2s. We could
 985                                  * intersect them, but that seems unlikely
 986                                  * to be correct. Reject second one for now.
 987                                  */
 988                                 if (!alpha2_equal(alpha2,
 989                                                   cfg80211_regdomain->alpha2))
 990                                         return -EOPNOTSUPP;
 991                                 return -EALREADY;
 992                         }
 993                         /* Two consecutive Country IE hints on the same wiphy.
 994                          * This should be picked up early by the driver/stack */
 995                         if (WARN_ON(!alpha2_equal(cfg80211_regdomain->alpha2,
 996                                   alpha2)))
 997                                 return 0;
 998                         return -EALREADY;
 999                 }
1000                 return REG_INTERSECT;
1001         case REGDOM_SET_BY_DRIVER:
1002                 if (last_request->initiator == REGDOM_SET_BY_DRIVER)
1003                         return -EALREADY;
1004                 return 0;
1005         case REGDOM_SET_BY_USER:
1006                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
1007                         return REG_INTERSECT;
1008                 /* If the user knows better the user should set the regdom
1009                  * to their country before the IE is picked up */
1010                 if (last_request->initiator == REGDOM_SET_BY_USER &&
1011                           last_request->intersect)
1012                         return -EOPNOTSUPP;
1013                 return 0;
1014         }
1015
1016         return -EINVAL;
1017 }
1018
1019 /* Caller must hold &cfg80211_drv_mutex */
1020 int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
1021                         const char *alpha2,
1022                         u32 country_ie_checksum,
1023                         enum environment_cap env)
1024 {
1025         struct regulatory_request *request;
1026         bool intersect = false;
1027         int r = 0;
1028
1029         r = ignore_request(wiphy, set_by, alpha2);
1030
1031         if (r == REG_INTERSECT)
1032                 intersect = true;
1033         else if (r)
1034                 return r;
1035
1036         request = kzalloc(sizeof(struct regulatory_request),
1037                           GFP_KERNEL);
1038         if (!request)
1039                 return -ENOMEM;
1040
1041         request->alpha2[0] = alpha2[0];
1042         request->alpha2[1] = alpha2[1];
1043         request->initiator = set_by;
1044         request->wiphy = wiphy;
1045         request->intersect = intersect;
1046         request->country_ie_checksum = country_ie_checksum;
1047         request->country_ie_env = env;
1048
1049         kfree(last_request);
1050         last_request = request;
1051         /*
1052          * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
1053          * AND if CRDA is NOT present nothing will happen, if someone
1054          * wants to bother with 11d with OLD_REG you can add a timer.
1055          * If after x amount of time nothing happens you can call:
1056          *
1057          * return set_regdom(country_ie_regdomain);
1058          *
1059          * to intersect with the static rd
1060          */
1061         return call_crda(alpha2);
1062 }
1063
1064 void regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1065 {
1066         BUG_ON(!alpha2);
1067
1068         mutex_lock(&cfg80211_drv_mutex);
1069         __regulatory_hint(wiphy, REGDOM_SET_BY_DRIVER, alpha2, 0, ENVIRON_ANY);
1070         mutex_unlock(&cfg80211_drv_mutex);
1071 }
1072 EXPORT_SYMBOL(regulatory_hint);
1073
1074 static bool reg_same_country_ie_hint(struct wiphy *wiphy,
1075                         u32 country_ie_checksum)
1076 {
1077         if (!last_request->wiphy)
1078                 return false;
1079         if (likely(last_request->wiphy != wiphy))
1080                 return !country_ie_integrity_changes(country_ie_checksum);
1081         /* We should not have let these through at this point, they
1082          * should have been picked up earlier by the first alpha2 check
1083          * on the device */
1084         if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
1085                 return true;
1086         return false;
1087 }
1088
1089 void regulatory_hint_11d(struct wiphy *wiphy,
1090                         u8 *country_ie,
1091                         u8 country_ie_len)
1092 {
1093         struct ieee80211_regdomain *rd = NULL;
1094         char alpha2[2];
1095         u32 checksum = 0;
1096         enum environment_cap env = ENVIRON_ANY;
1097
1098         if (!last_request)
1099                 return;
1100
1101         mutex_lock(&cfg80211_drv_mutex);
1102
1103         /* IE len must be evenly divisible by 2 */
1104         if (country_ie_len & 0x01)
1105                 goto out;
1106
1107         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1108                 goto out;
1109
1110         /* Pending country IE processing, this can happen after we
1111          * call CRDA and wait for a response if a beacon was received before
1112          * we were able to process the last regulatory_hint_11d() call */
1113         if (country_ie_regdomain)
1114                 goto out;
1115
1116         alpha2[0] = country_ie[0];
1117         alpha2[1] = country_ie[1];
1118
1119         if (country_ie[2] == 'I')
1120                 env = ENVIRON_INDOOR;
1121         else if (country_ie[2] == 'O')
1122                 env = ENVIRON_OUTDOOR;
1123
1124         /* We will run this for *every* beacon processed for the BSSID, so
1125          * we optimize an early check to exit out early if we don't have to
1126          * do anything */
1127         if (likely(last_request->wiphy)) {
1128                 struct cfg80211_registered_device *drv_last_ie;
1129
1130                 drv_last_ie = wiphy_to_dev(last_request->wiphy);
1131
1132                 /* Lets keep this simple -- we trust the first AP
1133                  * after we intersect with CRDA */
1134                 if (likely(last_request->wiphy == wiphy)) {
1135                         /* Ignore IEs coming in on this wiphy with
1136                          * the same alpha2 and environment cap */
1137                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1138                                   alpha2) &&
1139                                   env == drv_last_ie->env)) {
1140                                 goto out;
1141                         }
1142                         /* the wiphy moved on to another BSSID or the AP
1143                          * was reconfigured. XXX: We need to deal with the
1144                          * case where the user suspends and goes to goes
1145                          * to another country, and then gets IEs from an
1146                          * AP with different settings */
1147                         goto out;
1148                 } else {
1149                         /* Ignore IEs coming in on two separate wiphys with
1150                          * the same alpha2 and environment cap */
1151                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1152                                   alpha2) &&
1153                                   env == drv_last_ie->env)) {
1154                                 goto out;
1155                         }
1156                         /* We could potentially intersect though */
1157                         goto out;
1158                 }
1159         }
1160
1161         rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
1162         if (!rd)
1163                 goto out;
1164
1165         /* This will not happen right now but we leave it here for the
1166          * the future when we want to add suspend/resume support and having
1167          * the user move to another country after doing so, or having the user
1168          * move to another AP. Right now we just trust the first AP. This is why
1169          * this is marked as likley(). If we hit this before we add this support
1170          * we want to be informed of it as it would indicate a mistake in the
1171          * current design  */
1172         if (likely(WARN_ON(reg_same_country_ie_hint(wiphy, checksum))))
1173                 goto out;
1174
1175         /* We keep this around for when CRDA comes back with a response so
1176          * we can intersect with that */
1177         country_ie_regdomain = rd;
1178
1179         __regulatory_hint(wiphy, REGDOM_SET_BY_COUNTRY_IE,
1180                 country_ie_regdomain->alpha2, checksum, env);
1181
1182 out:
1183         mutex_unlock(&cfg80211_drv_mutex);
1184 }
1185 EXPORT_SYMBOL(regulatory_hint_11d);
1186
1187 static void print_rd_rules(const struct ieee80211_regdomain *rd)
1188 {
1189         unsigned int i;
1190         const struct ieee80211_reg_rule *reg_rule = NULL;
1191         const struct ieee80211_freq_range *freq_range = NULL;
1192         const struct ieee80211_power_rule *power_rule = NULL;
1193
1194         printk(KERN_INFO "\t(start_freq - end_freq @ bandwidth), "
1195                 "(max_antenna_gain, max_eirp)\n");
1196
1197         for (i = 0; i < rd->n_reg_rules; i++) {
1198                 reg_rule = &rd->reg_rules[i];
1199                 freq_range = &reg_rule->freq_range;
1200                 power_rule = &reg_rule->power_rule;
1201
1202                 /* There may not be documentation for max antenna gain
1203                  * in certain regions */
1204                 if (power_rule->max_antenna_gain)
1205                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1206                                 "(%d mBi, %d mBm)\n",
1207                                 freq_range->start_freq_khz,
1208                                 freq_range->end_freq_khz,
1209                                 freq_range->max_bandwidth_khz,
1210                                 power_rule->max_antenna_gain,
1211                                 power_rule->max_eirp);
1212                 else
1213                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1214                                 "(N/A, %d mBm)\n",
1215                                 freq_range->start_freq_khz,
1216                                 freq_range->end_freq_khz,
1217                                 freq_range->max_bandwidth_khz,
1218                                 power_rule->max_eirp);
1219         }
1220 }
1221
1222 static void print_regdomain(const struct ieee80211_regdomain *rd)
1223 {
1224
1225         if (is_intersected_alpha2(rd->alpha2)) {
1226                 struct wiphy *wiphy = NULL;
1227                 struct cfg80211_registered_device *drv;
1228
1229                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1230                         if (last_request->wiphy) {
1231                                 wiphy = last_request->wiphy;
1232                                 drv = wiphy_to_dev(wiphy);
1233                                 printk(KERN_INFO "cfg80211: Current regulatory "
1234                                         "domain updated by AP to: %c%c\n",
1235                                         drv->country_ie_alpha2[0],
1236                                         drv->country_ie_alpha2[1]);
1237                         } else
1238                                 printk(KERN_INFO "cfg80211: Current regulatory "
1239                                         "domain intersected: \n");
1240                 } else
1241                                 printk(KERN_INFO "cfg80211: Current regulatory "
1242                                         "intersected: \n");
1243         } else if (is_world_regdom(rd->alpha2))
1244                 printk(KERN_INFO "cfg80211: World regulatory "
1245                         "domain updated:\n");
1246         else {
1247                 if (is_unknown_alpha2(rd->alpha2))
1248                         printk(KERN_INFO "cfg80211: Regulatory domain "
1249                                 "changed to driver built-in settings "
1250                                 "(unknown country)\n");
1251                 else
1252                         printk(KERN_INFO "cfg80211: Regulatory domain "
1253                                 "changed to country: %c%c\n",
1254                                 rd->alpha2[0], rd->alpha2[1]);
1255         }
1256         print_rd_rules(rd);
1257 }
1258
1259 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
1260 {
1261         printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
1262                 rd->alpha2[0], rd->alpha2[1]);
1263         print_rd_rules(rd);
1264 }
1265
1266 #ifdef CONFIG_CFG80211_REG_DEBUG
1267 static void reg_country_ie_process_debug(
1268         const struct ieee80211_regdomain *rd,
1269         const struct ieee80211_regdomain *country_ie_regdomain,
1270         const struct ieee80211_regdomain *intersected_rd)
1271 {
1272         printk(KERN_DEBUG "cfg80211: Received country IE:\n");
1273         print_regdomain_info(country_ie_regdomain);
1274         printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
1275         print_regdomain_info(rd);
1276         if (intersected_rd) {
1277                 printk(KERN_DEBUG "cfg80211: We intersect both of these "
1278                         "and get:\n");
1279                 print_regdomain_info(rd);
1280                 return;
1281         }
1282         printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
1283 }
1284 #else
1285 static inline void reg_country_ie_process_debug(
1286         const struct ieee80211_regdomain *rd,
1287         const struct ieee80211_regdomain *country_ie_regdomain,
1288         const struct ieee80211_regdomain *intersected_rd)
1289 {
1290 }
1291 #endif
1292
1293 /* Takes ownership of rd only if it doesn't fail */
1294 static int __set_regdom(const struct ieee80211_regdomain *rd)
1295 {
1296         const struct ieee80211_regdomain *intersected_rd = NULL;
1297         struct cfg80211_registered_device *drv = NULL;
1298         struct wiphy *wiphy = NULL;
1299         /* Some basic sanity checks first */
1300
1301         if (is_world_regdom(rd->alpha2)) {
1302                 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1303                         return -EINVAL;
1304                 update_world_regdomain(rd);
1305                 return 0;
1306         }
1307
1308         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
1309                         !is_unknown_alpha2(rd->alpha2))
1310                 return -EINVAL;
1311
1312         if (!last_request)
1313                 return -EINVAL;
1314
1315         /* Lets only bother proceeding on the same alpha2 if the current
1316          * rd is non static (it means CRDA was present and was used last)
1317          * and the pending request came in from a country IE */
1318         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1319                 /* If someone else asked us to change the rd lets only bother
1320                  * checking if the alpha2 changes if CRDA was already called */
1321                 if (!is_old_static_regdom(cfg80211_regdomain) &&
1322                     !regdom_changed(rd->alpha2))
1323                         return -EINVAL;
1324         }
1325
1326         wiphy = last_request->wiphy;
1327
1328         /* Now lets set the regulatory domain, update all driver channels
1329          * and finally inform them of what we have done, in case they want
1330          * to review or adjust their own settings based on their own
1331          * internal EEPROM data */
1332
1333         if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1334                 return -EINVAL;
1335
1336         if (!is_valid_rd(rd)) {
1337                 printk(KERN_ERR "cfg80211: Invalid "
1338                         "regulatory domain detected:\n");
1339                 print_regdomain_info(rd);
1340                 return -EINVAL;
1341         }
1342
1343         if (!last_request->intersect) {
1344                 reset_regdomains();
1345                 cfg80211_regdomain = rd;
1346                 return 0;
1347         }
1348
1349         /* Intersection requires a bit more work */
1350
1351         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1352
1353                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1354                 if (!intersected_rd)
1355                         return -EINVAL;
1356
1357                 /* We can trash what CRDA provided now */
1358                 kfree(rd);
1359                 rd = NULL;
1360
1361                 reset_regdomains();
1362                 cfg80211_regdomain = intersected_rd;
1363
1364                 return 0;
1365         }
1366
1367         /*
1368          * Country IE requests are handled a bit differently, we intersect
1369          * the country IE rd with what CRDA believes that country should have
1370          */
1371
1372         BUG_ON(!country_ie_regdomain);
1373
1374         if (rd != country_ie_regdomain) {
1375                 /* Intersect what CRDA returned and our what we
1376                  * had built from the Country IE received */
1377
1378                 intersected_rd = regdom_intersect(rd, country_ie_regdomain);
1379
1380                 reg_country_ie_process_debug(rd, country_ie_regdomain,
1381                         intersected_rd);
1382
1383                 kfree(country_ie_regdomain);
1384                 country_ie_regdomain = NULL;
1385         } else {
1386                 /* This would happen when CRDA was not present and
1387                  * OLD_REGULATORY was enabled. We intersect our Country
1388                  * IE rd and what was set on cfg80211 originally */
1389                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1390         }
1391
1392         if (!intersected_rd)
1393                 return -EINVAL;
1394
1395         drv = wiphy_to_dev(wiphy);
1396
1397         drv->country_ie_alpha2[0] = rd->alpha2[0];
1398         drv->country_ie_alpha2[1] = rd->alpha2[1];
1399         drv->env = last_request->country_ie_env;
1400
1401         BUG_ON(intersected_rd == rd);
1402
1403         kfree(rd);
1404         rd = NULL;
1405
1406         reset_regdomains();
1407         cfg80211_regdomain = intersected_rd;
1408
1409         return 0;
1410 }
1411
1412
1413 /* Use this call to set the current regulatory domain. Conflicts with
1414  * multiple drivers can be ironed out later. Caller must've already
1415  * kmalloc'd the rd structure. Caller must hold cfg80211_drv_mutex */
1416 int set_regdom(const struct ieee80211_regdomain *rd)
1417 {
1418         int r;
1419
1420         /* Note that this doesn't update the wiphys, this is done below */
1421         r = __set_regdom(rd);
1422         if (r) {
1423                 kfree(rd);
1424                 return r;
1425         }
1426
1427         /* This would make this whole thing pointless */
1428         if (!last_request->intersect)
1429                 BUG_ON(rd != cfg80211_regdomain);
1430
1431         /* update all wiphys now with the new established regulatory domain */
1432         update_all_wiphy_regulatory(last_request->initiator);
1433
1434         print_regdomain(cfg80211_regdomain);
1435
1436         return r;
1437 }
1438
1439 /* Caller must hold cfg80211_drv_mutex */
1440 void reg_device_remove(struct wiphy *wiphy)
1441 {
1442         if (!last_request || !last_request->wiphy)
1443                 return;
1444         if (last_request->wiphy != wiphy)
1445                 return;
1446         last_request->wiphy = NULL;
1447         last_request->country_ie_env = ENVIRON_ANY;
1448 }
1449
1450 int regulatory_init(void)
1451 {
1452         int err;
1453
1454         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
1455         if (IS_ERR(reg_pdev))
1456                 return PTR_ERR(reg_pdev);
1457
1458 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
1459         cfg80211_regdomain = static_regdom(ieee80211_regdom);
1460
1461         printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
1462         print_regdomain_info(cfg80211_regdomain);
1463         /* The old code still requests for a new regdomain and if
1464          * you have CRDA you get it updated, otherwise you get
1465          * stuck with the static values. We ignore "EU" code as
1466          * that is not a valid ISO / IEC 3166 alpha2 */
1467         if (ieee80211_regdom[0] != 'E' || ieee80211_regdom[1] != 'U')
1468                 err = __regulatory_hint(NULL, REGDOM_SET_BY_CORE,
1469                                         ieee80211_regdom, 0, ENVIRON_ANY);
1470 #else
1471         cfg80211_regdomain = cfg80211_world_regdom;
1472
1473         err = __regulatory_hint(NULL, REGDOM_SET_BY_CORE, "00", 0, ENVIRON_ANY);
1474         if (err)
1475                 printk(KERN_ERR "cfg80211: calling CRDA failed - "
1476                        "unable to update world regulatory domain, "
1477                        "using static definition\n");
1478 #endif
1479
1480         return 0;
1481 }
1482
1483 void regulatory_exit(void)
1484 {
1485         mutex_lock(&cfg80211_drv_mutex);
1486
1487         reset_regdomains();
1488
1489         kfree(country_ie_regdomain);
1490         country_ie_regdomain = NULL;
1491
1492         kfree(last_request);
1493
1494         platform_device_unregister(reg_pdev);
1495
1496         mutex_unlock(&cfg80211_drv_mutex);
1497 }