SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 /* Receipt of information from last regulatory request */
  46 static struct regulatory_request *last_request;
  47
  48 /* To trigger userspace events */
  49 static struct platform_device *reg_pdev;
  50
  51 /* Keep the ordering from large to small */
  52 static u32 supported_bandwidths[] = {
  53         MHZ_TO_KHZ(40),
  54         MHZ_TO_KHZ(20),
  55 };
  56
  57 /*
  58  * Central wireless core regulatory domains, we only need two,
  59  * the current one and a world regulatory domain in case we have no
  60  * information to give us an alpha2
  61  */
  62 const struct ieee80211_regdomain *cfg80211_regdomain;
  63
  64 /*
  65  * We use this as a place for the rd structure built from the
  66  * last parsed country IE to rest until CRDA gets back to us with
  67  * what it thinks should apply for the same country
  68  */
  69 static const struct ieee80211_regdomain *country_ie_regdomain;
  70
  71 /* Used to queue up regulatory hints */
  72 static LIST_HEAD(reg_requests_list);
  73 static spinlock_t reg_requests_lock;
  74
  75 /* Used to queue up beacon hints for review */
  76 static LIST_HEAD(reg_pending_beacons);
  77 static spinlock_t reg_pending_beacons_lock;
  78
  79 /* Used to keep track of processed beacon hints */
  80 static LIST_HEAD(reg_beacon_list);
  81
  82 struct reg_beacon {
  83         struct list_head list;
  84         struct ieee80211_channel chan;
  85 };
  86
  87 /* We keep a static world regulatory domain in case of the absence of CRDA */
  88 static const struct ieee80211_regdomain world_regdom = {
  89         .n_reg_rules = 3,
  90         .alpha2 =  "00",
  91         .reg_rules = {
  92                 /* IEEE 802.11b/g, channels 1..11 */
  93                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
  94                 /* IEEE 802.11a, channel 36..48 */
  95                 REG_RULE(5180-10, 5240+10, 40, 6, 23,
  96                         NL80211_RRF_PASSIVE_SCAN |
  97                         NL80211_RRF_NO_IBSS),
  98
  99                 /* NB: 5260 MHz - 5700 MHz requies DFS */
 100
 101                 /* IEEE 802.11a, channel 149..165 */
 102                 REG_RULE(5745-10, 5825+10, 40, 6, 23,
 103                         NL80211_RRF_PASSIVE_SCAN |
 104                         NL80211_RRF_NO_IBSS),
 105         }
 106 };
 107
 108 static const struct ieee80211_regdomain *cfg80211_world_regdom =
 109         &world_regdom;
 110
 111 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
 112 static char *ieee80211_regdom = "US";
 113 module_param(ieee80211_regdom, charp, 0444);
 114 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 115
 116 /*
 117  * We assume 40 MHz bandwidth for the old regulatory work.
 118  * We make emphasis we are using the exact same frequencies
 119  * as before
 120  */
 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         /*
 160          * This alpha2 is bogus, we leave it here just for stupid
 161          * backward compatibility
 162          */
 163         .alpha2 =  "EU",
 164         .reg_rules = {
 165                 /* IEEE 802.11b/g, channels 1..13 */
 166                 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
 167                 /* IEEE 802.11a, channel 36 */
 168                 REG_RULE(5180-10, 5180+10, 40, 6, 23,
 169                         NL80211_RRF_PASSIVE_SCAN),
 170                 /* IEEE 802.11a, channel 40 */
 171                 REG_RULE(5200-10, 5200+10, 40, 6, 23,
 172                         NL80211_RRF_PASSIVE_SCAN),
 173                 /* IEEE 802.11a, channel 44 */
 174                 REG_RULE(5220-10, 5220+10, 40, 6, 23,
 175                         NL80211_RRF_PASSIVE_SCAN),
 176                 /* IEEE 802.11a, channels 48..64 */
 177                 REG_RULE(5240-10, 5320+10, 40, 6, 20,
 178                         NL80211_RRF_NO_IBSS |
 179                         NL80211_RRF_DFS),
 180                 /* IEEE 802.11a, channels 100..140 */
 181                 REG_RULE(5500-10, 5700+10, 40, 6, 30,
 182                         NL80211_RRF_NO_IBSS |
 183                         NL80211_RRF_DFS),
 184         }
 185 };
 186
 187 static const struct ieee80211_regdomain *static_regdom(char *alpha2)
 188 {
 189         if (alpha2[0] == 'U' && alpha2[1] == 'S')
 190                 return &us_regdom;
 191         if (alpha2[0] == 'J' && alpha2[1] == 'P')
 192                 return &jp_regdom;
 193         if (alpha2[0] == 'E' && alpha2[1] == 'U')
 194                 return &eu_regdom;
 195         /* Default, as per the old rules */
 196         return &us_regdom;
 197 }
 198
 199 static bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
 200 {
 201         if (rd == &us_regdom || rd == &jp_regdom || rd == &eu_regdom)
 202                 return true;
 203         return false;
 204 }
 205 #else
 206 static inline bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
 207 {
 208         return false;
 209 }
 210 #endif
 211
 212 static void reset_regdomains(void)
 213 {
 214         /* avoid freeing static information or freeing something twice */
 215         if (cfg80211_regdomain == cfg80211_world_regdom)
 216                 cfg80211_regdomain = NULL;
 217         if (cfg80211_world_regdom == &world_regdom)
 218                 cfg80211_world_regdom = NULL;
 219         if (cfg80211_regdomain == &world_regdom)
 220                 cfg80211_regdomain = NULL;
 221         if (is_old_static_regdom(cfg80211_regdomain))
 222                 cfg80211_regdomain = NULL;
 223
 224         kfree(cfg80211_regdomain);
 225         kfree(cfg80211_world_regdom);
 226
 227         cfg80211_world_regdom = &world_regdom;
 228         cfg80211_regdomain = NULL;
 229 }
 230
 231 /*
 232  * Dynamic world regulatory domain requested by the wireless
 233  * core upon initialization
 234  */
 235 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 236 {
 237         BUG_ON(!last_request);
 238
 239         reset_regdomains();
 240
 241         cfg80211_world_regdom = rd;
 242         cfg80211_regdomain = rd;
 243 }
 244
 245 bool is_world_regdom(const char *alpha2)
 246 {
 247         if (!alpha2)
 248                 return false;
 249         if (alpha2[0] == '0' && alpha2[1] == '0')
 250                 return true;
 251         return false;
 252 }
 253
 254 static bool is_alpha2_set(const char *alpha2)
 255 {
 256         if (!alpha2)
 257                 return false;
 258         if (alpha2[0] != 0 && alpha2[1] != 0)
 259                 return true;
 260         return false;
 261 }
 262
 263 static bool is_alpha_upper(char letter)
 264 {
 265         /* ASCII A - Z */
 266         if (letter >= 65 && letter <= 90)
 267                 return true;
 268         return false;
 269 }
 270
 271 static bool is_unknown_alpha2(const char *alpha2)
 272 {
 273         if (!alpha2)
 274                 return false;
 275         /*
 276          * Special case where regulatory domain was built by driver
 277          * but a specific alpha2 cannot be determined
 278          */
 279         if (alpha2[0] == '9' && alpha2[1] == '9')
 280                 return true;
 281         return false;
 282 }
 283
 284 static bool is_intersected_alpha2(const char *alpha2)
 285 {
 286         if (!alpha2)
 287                 return false;
 288         /*
 289          * Special case where regulatory domain is the
 290          * result of an intersection between two regulatory domain
 291          * structures
 292          */
 293         if (alpha2[0] == '9' && alpha2[1] == '8')
 294                 return true;
 295         return false;
 296 }
 297
 298 static bool is_an_alpha2(const char *alpha2)
 299 {
 300         if (!alpha2)
 301                 return false;
 302         if (is_alpha_upper(alpha2[0]) && is_alpha_upper(alpha2[1]))
 303                 return true;
 304         return false;
 305 }
 306
 307 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 308 {
 309         if (!alpha2_x || !alpha2_y)
 310                 return false;
 311         if (alpha2_x[0] == alpha2_y[0] &&
 312                 alpha2_x[1] == alpha2_y[1])
 313                 return true;
 314         return false;
 315 }
 316
 317 static bool regdom_changes(const char *alpha2)
 318 {
 319         assert_cfg80211_lock();
 320
 321         if (!cfg80211_regdomain)
 322                 return true;
 323         if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
 324                 return false;
 325         return true;
 326 }
 327
 328 /**
 329  * country_ie_integrity_changes - tells us if the country IE has changed
 330  * @checksum: checksum of country IE of fields we are interested in
 331  *
 332  * If the country IE has not changed you can ignore it safely. This is
 333  * useful to determine if two devices are seeing two different country IEs
 334  * even on the same alpha2. Note that this will return false if no IE has
 335  * been set on the wireless core yet.
 336  */
 337 static bool country_ie_integrity_changes(u32 checksum)
 338 {
 339         /* If no IE has been set then the checksum doesn't change */
 340         if (unlikely(!last_request->country_ie_checksum))
 341                 return false;
 342         if (unlikely(last_request->country_ie_checksum != checksum))
 343                 return true;
 344         return false;
 345 }
 346
 347 /*
 348  * This lets us keep regulatory code which is updated on a regulatory
 349  * basis in userspace.
 350  */
 351 static int call_crda(const char *alpha2)
 352 {
 353         char country_env[9 + 2] = "COUNTRY=";
 354         char *envp[] = {
 355                 country_env,
 356                 NULL
 357         };
 358
 359         if (!is_world_regdom((char *) alpha2))
 360                 printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
 361                         alpha2[0], alpha2[1]);
 362         else
 363                 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
 364                         "regulatory domain\n");
 365
 366         country_env[8] = alpha2[0];
 367         country_env[9] = alpha2[1];
 368
 369         return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
 370 }
 371
 372 /* Used by nl80211 before kmalloc'ing our regulatory domain */
 373 bool reg_is_valid_request(const char *alpha2)
 374 {
 375         if (!last_request)
 376                 return false;
 377
 378         return alpha2_equal(last_request->alpha2, alpha2);
 379 }
 380
 381 /* Sanity check on a regulatory rule */
 382 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 383 {
 384         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 385         u32 freq_diff;
 386
 387         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
 388                 return false;
 389
 390         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
 391                 return false;
 392
 393         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 394
 395         if (freq_diff <= 0 || freq_range->max_bandwidth_khz > freq_diff)
 396                 return false;
 397
 398         return true;
 399 }
 400
 401 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
 402 {
 403         const struct ieee80211_reg_rule *reg_rule = NULL;
 404         unsigned int i;
 405
 406         if (!rd->n_reg_rules)
 407                 return false;
 408
 409         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 410                 return false;
 411
 412         for (i = 0; i < rd->n_reg_rules; i++) {
 413                 reg_rule = &rd->reg_rules[i];
 414                 if (!is_valid_reg_rule(reg_rule))
 415                         return false;
 416         }
 417
 418         return true;
 419 }
 420
 421 /* Returns value in KHz */
 422 static u32 freq_max_bandwidth(const struct ieee80211_freq_range *freq_range,
 423         u32 freq)
 424 {
 425         unsigned int i;
 426         for (i = 0; i < ARRAY_SIZE(supported_bandwidths); i++) {
 427                 u32 start_freq_khz = freq - supported_bandwidths[i]/2;
 428                 u32 end_freq_khz = freq + supported_bandwidths[i]/2;
 429                 if (start_freq_khz >= freq_range->start_freq_khz &&
 430                         end_freq_khz <= freq_range->end_freq_khz)
 431                         return supported_bandwidths[i];
 432         }
 433         return 0;
 434 }
 435
 436 /**
 437  * freq_in_rule_band - tells us if a frequency is in a frequency band
 438  * @freq_range: frequency rule we want to query
 439  * @freq_khz: frequency we are inquiring about
 440  *
 441  * This lets us know if a specific frequency rule is or is not relevant to
 442  * a specific frequency's band. Bands are device specific and artificial
 443  * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
 444  * safe for now to assume that a frequency rule should not be part of a
 445  * frequency's band if the start freq or end freq are off by more than 2 GHz.
 446  * This resolution can be lowered and should be considered as we add
 447  * regulatory rule support for other "bands".
 448  **/
 449 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 450         u32 freq_khz)
 451 {
 452 #define ONE_GHZ_IN_KHZ  1000000
 453         if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
 454                 return true;
 455         if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
 456                 return true;
 457         return false;
 458 #undef ONE_GHZ_IN_KHZ
 459 }
 460
 461 /*
 462  * Converts a country IE to a regulatory domain. A regulatory domain
 463  * structure has a lot of information which the IE doesn't yet have,
 464  * so for the other values we use upper max values as we will intersect
 465  * with our userspace regulatory agent to get lower bounds.
 466  */
 467 static struct ieee80211_regdomain *country_ie_2_rd(
 468                                 u8 *country_ie,
 469                                 u8 country_ie_len,
 470                                 u32 *checksum)
 471 {
 472         struct ieee80211_regdomain *rd = NULL;
 473         unsigned int i = 0;
 474         char alpha2[2];
 475         u32 flags = 0;
 476         u32 num_rules = 0, size_of_regd = 0;
 477         u8 *triplets_start = NULL;
 478         u8 len_at_triplet = 0;
 479         /* the last channel we have registered in a subband (triplet) */
 480         int last_sub_max_channel = 0;
 481
 482         *checksum = 0xDEADBEEF;
 483
 484         /* Country IE requirements */
 485         BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
 486                 country_ie_len & 0x01);
 487
 488         alpha2[0] = country_ie[0];
 489         alpha2[1] = country_ie[1];
 490
 491         /*
 492          * Third octet can be:
 493          *    'I' - Indoor
 494          *    'O' - Outdoor
 495          *
 496          *  anything else we assume is no restrictions
 497          */
 498         if (country_ie[2] == 'I')
 499                 flags = NL80211_RRF_NO_OUTDOOR;
 500         else if (country_ie[2] == 'O')
 501                 flags = NL80211_RRF_NO_INDOOR;
 502
 503         country_ie += 3;
 504         country_ie_len -= 3;
 505
 506         triplets_start = country_ie;
 507         len_at_triplet = country_ie_len;
 508
 509         *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
 510
 511         /*
 512          * We need to build a reg rule for each triplet, but first we must
 513          * calculate the number of reg rules we will need. We will need one
 514          * for each channel subband
 515          */
 516         while (country_ie_len >= 3) {
 517                 int end_channel = 0;
 518                 struct ieee80211_country_ie_triplet *triplet =
 519                         (struct ieee80211_country_ie_triplet *) country_ie;
 520                 int cur_sub_max_channel = 0, cur_channel = 0;
 521
 522                 if (triplet->ext.reg_extension_id >=
 523                                 IEEE80211_COUNTRY_EXTENSION_ID) {
 524                         country_ie += 3;
 525                         country_ie_len -= 3;
 526                         continue;
 527                 }
 528
 529                 /* 2 GHz */
 530                 if (triplet->chans.first_channel <= 14)
 531                         end_channel = triplet->chans.first_channel +
 532                                 triplet->chans.num_channels;
 533                 else
 534                         /*
 535                          * 5 GHz -- For example in country IEs if the first
 536                          * channel given is 36 and the number of channels is 4
 537                          * then the individual channel numbers defined for the
 538                          * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
 539                          * and not 36, 37, 38, 39.
 540                          *
 541                          * See: http://tinyurl.com/11d-clarification
 542                          */
 543                         end_channel =  triplet->chans.first_channel +
 544                                 (4 * (triplet->chans.num_channels - 1));
 545
 546                 cur_channel = triplet->chans.first_channel;
 547                 cur_sub_max_channel = end_channel;
 548
 549                 /* Basic sanity check */
 550                 if (cur_sub_max_channel < cur_channel)
 551                         return NULL;
 552
 553                 /*
 554                  * Do not allow overlapping channels. Also channels
 555                  * passed in each subband must be monotonically
 556                  * increasing
 557                  */
 558                 if (last_sub_max_channel) {
 559                         if (cur_channel <= last_sub_max_channel)
 560                                 return NULL;
 561                         if (cur_sub_max_channel <= last_sub_max_channel)
 562                                 return NULL;
 563                 }
 564
 565                 /*
 566                  * When dot11RegulatoryClassesRequired is supported
 567                  * we can throw ext triplets as part of this soup,
 568                  * for now we don't care when those change as we
 569                  * don't support them
 570                  */
 571                 *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
 572                   ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
 573                   ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
 574
 575                 last_sub_max_channel = cur_sub_max_channel;
 576
 577                 country_ie += 3;
 578                 country_ie_len -= 3;
 579                 num_rules++;
 580
 581                 /*
 582                  * Note: this is not a IEEE requirement but
 583                  * simply a memory requirement
 584                  */
 585                 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
 586                         return NULL;
 587         }
 588
 589         country_ie = triplets_start;
 590         country_ie_len = len_at_triplet;
 591
 592         size_of_regd = sizeof(struct ieee80211_regdomain) +
 593                 (num_rules * sizeof(struct ieee80211_reg_rule));
 594
 595         rd = kzalloc(size_of_regd, GFP_KERNEL);
 596         if (!rd)
 597                 return NULL;
 598
 599         rd->n_reg_rules = num_rules;
 600         rd->alpha2[0] = alpha2[0];
 601         rd->alpha2[1] = alpha2[1];
 602
 603         /* This time around we fill in the rd */
 604         while (country_ie_len >= 3) {
 605                 int end_channel = 0;
 606                 struct ieee80211_country_ie_triplet *triplet =
 607                         (struct ieee80211_country_ie_triplet *) country_ie;
 608                 struct ieee80211_reg_rule *reg_rule = NULL;
 609                 struct ieee80211_freq_range *freq_range = NULL;
 610                 struct ieee80211_power_rule *power_rule = NULL;
 611
 612                 /*
 613                  * Must parse if dot11RegulatoryClassesRequired is true,
 614                  * we don't support this yet
 615                  */
 616                 if (triplet->ext.reg_extension_id >=
 617                                 IEEE80211_COUNTRY_EXTENSION_ID) {
 618                         country_ie += 3;
 619                         country_ie_len -= 3;
 620                         continue;
 621                 }
 622
 623                 reg_rule = &rd->reg_rules[i];
 624                 freq_range = &reg_rule->freq_range;
 625                 power_rule = &reg_rule->power_rule;
 626
 627                 reg_rule->flags = flags;
 628
 629                 /* 2 GHz */
 630                 if (triplet->chans.first_channel <= 14)
 631                         end_channel = triplet->chans.first_channel +
 632                                 triplet->chans.num_channels;
 633                 else
 634                         end_channel =  triplet->chans.first_channel +
 635                                 (4 * (triplet->chans.num_channels - 1));
 636
 637                 /*
 638                  * The +10 is since the regulatory domain expects
 639                  * the actual band edge, not the center of freq for
 640                  * its start and end freqs, assuming 20 MHz bandwidth on
 641                  * the channels passed
 642                  */
 643                 freq_range->start_freq_khz =
 644                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
 645                                 triplet->chans.first_channel) - 10);
 646                 freq_range->end_freq_khz =
 647                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
 648                                 end_channel) + 10);
 649
 650                 /*
 651                  * These are large arbitrary values we use to intersect later.
 652                  * Increment this if we ever support >= 40 MHz channels
 653                  * in IEEE 802.11
 654                  */
 655                 freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
 656                 power_rule->max_antenna_gain = DBI_TO_MBI(100);
 657                 power_rule->max_eirp = DBM_TO_MBM(100);
 658
 659                 country_ie += 3;
 660                 country_ie_len -= 3;
 661                 i++;
 662
 663                 BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
 664         }
 665
 666         return rd;
 667 }
 668
 669
 670 /*
 671  * Helper for regdom_intersect(), this does the real
 672  * mathematical intersection fun
 673  */
 674 static int reg_rules_intersect(
 675         const struct ieee80211_reg_rule *rule1,
 676         const struct ieee80211_reg_rule *rule2,
 677         struct ieee80211_reg_rule *intersected_rule)
 678 {
 679         const struct ieee80211_freq_range *freq_range1, *freq_range2;
 680         struct ieee80211_freq_range *freq_range;
 681         const struct ieee80211_power_rule *power_rule1, *power_rule2;
 682         struct ieee80211_power_rule *power_rule;
 683         u32 freq_diff;
 684
 685         freq_range1 = &rule1->freq_range;
 686         freq_range2 = &rule2->freq_range;
 687         freq_range = &intersected_rule->freq_range;
 688
 689         power_rule1 = &rule1->power_rule;
 690         power_rule2 = &rule2->power_rule;
 691         power_rule = &intersected_rule->power_rule;
 692
 693         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
 694                 freq_range2->start_freq_khz);
 695         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
 696                 freq_range2->end_freq_khz);
 697         freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
 698                 freq_range2->max_bandwidth_khz);
 699
 700         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 701         if (freq_range->max_bandwidth_khz > freq_diff)
 702                 freq_range->max_bandwidth_khz = freq_diff;
 703
 704         power_rule->max_eirp = min(power_rule1->max_eirp,
 705                 power_rule2->max_eirp);
 706         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
 707                 power_rule2->max_antenna_gain);
 708
 709         intersected_rule->flags = (rule1->flags | rule2->flags);
 710
 711         if (!is_valid_reg_rule(intersected_rule))
 712                 return -EINVAL;
 713
 714         return 0;
 715 }
 716
 717 /**
 718  * regdom_intersect - do the intersection between two regulatory domains
 719  * @rd1: first regulatory domain
 720  * @rd2: second regulatory domain
 721  *
 722  * Use this function to get the intersection between two regulatory domains.
 723  * Once completed we will mark the alpha2 for the rd as intersected, "98",
 724  * as no one single alpha2 can represent this regulatory domain.
 725  *
 726  * Returns a pointer to the regulatory domain structure which will hold the
 727  * resulting intersection of rules between rd1 and rd2. We will
 728  * kzalloc() this structure for you.
 729  */
 730 static struct ieee80211_regdomain *regdom_intersect(
 731         const struct ieee80211_regdomain *rd1,
 732         const struct ieee80211_regdomain *rd2)
 733 {
 734         int r, size_of_regd;
 735         unsigned int x, y;
 736         unsigned int num_rules = 0, rule_idx = 0;
 737         const struct ieee80211_reg_rule *rule1, *rule2;
 738         struct ieee80211_reg_rule *intersected_rule;
 739         struct ieee80211_regdomain *rd;
 740         /* This is just a dummy holder to help us count */
 741         struct ieee80211_reg_rule irule;
 742
 743         /* Uses the stack temporarily for counter arithmetic */
 744         intersected_rule = &irule;
 745
 746         memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
 747
 748         if (!rd1 || !rd2)
 749                 return NULL;
 750
 751         /*
 752          * First we get a count of the rules we'll need, then we actually
 753          * build them. This is to so we can malloc() and free() a
 754          * regdomain once. The reason we use reg_rules_intersect() here
 755          * is it will return -EINVAL if the rule computed makes no sense.
 756          * All rules that do check out OK are valid.
 757          */
 758
 759         for (x = 0; x < rd1->n_reg_rules; x++) {
 760                 rule1 = &rd1->reg_rules[x];
 761                 for (y = 0; y < rd2->n_reg_rules; y++) {
 762                         rule2 = &rd2->reg_rules[y];
 763                         if (!reg_rules_intersect(rule1, rule2,
 764                                         intersected_rule))
 765                                 num_rules++;
 766                         memset(intersected_rule, 0,
 767                                         sizeof(struct ieee80211_reg_rule));
 768                 }
 769         }
 770
 771         if (!num_rules)
 772                 return NULL;
 773
 774         size_of_regd = sizeof(struct ieee80211_regdomain) +
 775                 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
 776
 777         rd = kzalloc(size_of_regd, GFP_KERNEL);
 778         if (!rd)
 779                 return NULL;
 780
 781         for (x = 0; x < rd1->n_reg_rules; x++) {
 782                 rule1 = &rd1->reg_rules[x];
 783                 for (y = 0; y < rd2->n_reg_rules; y++) {
 784                         rule2 = &rd2->reg_rules[y];
 785                         /*
 786                          * This time around instead of using the stack lets
 787                          * write to the target rule directly saving ourselves
 788                          * a memcpy()
 789                          */
 790                         intersected_rule = &rd->reg_rules[rule_idx];
 791                         r = reg_rules_intersect(rule1, rule2,
 792                                 intersected_rule);
 793                         /*
 794                          * No need to memset here the intersected rule here as
 795                          * we're not using the stack anymore
 796                          */
 797                         if (r)
 798                                 continue;
 799                         rule_idx++;
 800                 }
 801         }
 802
 803         if (rule_idx != num_rules) {
 804                 kfree(rd);
 805                 return NULL;
 806         }
 807
 808         rd->n_reg_rules = num_rules;
 809         rd->alpha2[0] = '9';
 810         rd->alpha2[1] = '8';
 811
 812         return rd;
 813 }
 814
 815 /*
 816  * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 817  * want to just have the channel structure use these
 818  */
 819 static u32 map_regdom_flags(u32 rd_flags)
 820 {
 821         u32 channel_flags = 0;
 822         if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
 823                 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 824         if (rd_flags & NL80211_RRF_NO_IBSS)
 825                 channel_flags |= IEEE80211_CHAN_NO_IBSS;
 826         if (rd_flags & NL80211_RRF_DFS)
 827                 channel_flags |= IEEE80211_CHAN_RADAR;
 828         return channel_flags;
 829 }
 830
 831 static int freq_reg_info_regd(struct wiphy *wiphy,
 832                               u32 center_freq,
 833                               u32 *bandwidth,
 834                               const struct ieee80211_reg_rule **reg_rule,
 835                               const struct ieee80211_regdomain *custom_regd)
 836 {
 837         int i;
 838         bool band_rule_found = false;
 839         const struct ieee80211_regdomain *regd;
 840         u32 max_bandwidth = 0;
 841
 842         regd = custom_regd ? custom_regd : cfg80211_regdomain;
 843
 844         /*
 845          * Follow the driver's regulatory domain, if present, unless a country
 846          * IE has been processed or a user wants to help complaince further
 847          */
 848         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE &&
 849             last_request->initiator != REGDOM_SET_BY_USER &&
 850             wiphy->regd)
 851                 regd = wiphy->regd;
 852
 853         if (!regd)
 854                 return -EINVAL;
 855
 856         for (i = 0; i < regd->n_reg_rules; i++) {
 857                 const struct ieee80211_reg_rule *rr;
 858                 const struct ieee80211_freq_range *fr = NULL;
 859                 const struct ieee80211_power_rule *pr = NULL;
 860
 861                 rr = &regd->reg_rules[i];
 862                 fr = &rr->freq_range;
 863                 pr = &rr->power_rule;
 864
 865                 /*
 866                  * We only need to know if one frequency rule was
 867                  * was in center_freq's band, that's enough, so lets
 868                  * not overwrite it once found
 869                  */
 870                 if (!band_rule_found)
 871                         band_rule_found = freq_in_rule_band(fr, center_freq);
 872
 873                 max_bandwidth = freq_max_bandwidth(fr, center_freq);
 874
 875                 if (max_bandwidth && *bandwidth <= max_bandwidth) {
 876                         *reg_rule = rr;
 877                         *bandwidth = max_bandwidth;
 878                         break;
 879                 }
 880         }
 881
 882         if (!band_rule_found)
 883                 return -ERANGE;
 884
 885         return !max_bandwidth;
 886 }
 887 EXPORT_SYMBOL(freq_reg_info);
 888
 889 int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
 890                          const struct ieee80211_reg_rule **reg_rule)
 891 {
 892         return freq_reg_info_regd(wiphy, center_freq,
 893                 bandwidth, reg_rule, NULL);
 894 }
 895
 896 static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
 897                            unsigned int chan_idx)
 898 {
 899         int r;
 900         u32 flags;
 901         u32 max_bandwidth = 0;
 902         const struct ieee80211_reg_rule *reg_rule = NULL;
 903         const struct ieee80211_power_rule *power_rule = NULL;
 904         struct ieee80211_supported_band *sband;
 905         struct ieee80211_channel *chan;
 906         struct wiphy *request_wiphy = NULL;
 907
 908         assert_cfg80211_lock();
 909
 910         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
 911
 912         sband = wiphy->bands[band];
 913         BUG_ON(chan_idx >= sband->n_channels);
 914         chan = &sband->channels[chan_idx];
 915
 916         flags = chan->orig_flags;
 917
 918         r = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq),
 919                 &max_bandwidth, &reg_rule);
 920
 921         if (r) {
 922                 /*
 923                  * This means no regulatory rule was found in the country IE
 924                  * with a frequency range on the center_freq's band, since
 925                  * IEEE-802.11 allows for a country IE to have a subset of the
 926                  * regulatory information provided in a country we ignore
 927                  * disabling the channel unless at least one reg rule was
 928                  * found on the center_freq's band. For details see this
 929                  * clarification:
 930                  *
 931                  * http://tinyurl.com/11d-clarification
 932                  */
 933                 if (r == -ERANGE &&
 934                     last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
 935 #ifdef CONFIG_CFG80211_REG_DEBUG
 936                         printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
 937                                 "intact on %s - no rule found in band on "
 938                                 "Country IE\n",
 939                                 chan->center_freq, wiphy_name(wiphy));
 940 #endif
 941                 } else {
 942                 /*
 943                  * In this case we know the country IE has at least one reg rule
 944                  * for the band so we respect its band definitions
 945                  */
 946 #ifdef CONFIG_CFG80211_REG_DEBUG
 947                         if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
 948                                 printk(KERN_DEBUG "cfg80211: Disabling "
 949                                         "channel %d MHz on %s due to "
 950                                         "Country IE\n",
 951                                         chan->center_freq, wiphy_name(wiphy));
 952 #endif
 953                         flags |= IEEE80211_CHAN_DISABLED;
 954                         chan->flags = flags;
 955                 }
 956                 return;
 957         }
 958
 959         power_rule = &reg_rule->power_rule;
 960
 961         if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
 962             request_wiphy && request_wiphy == wiphy &&
 963             request_wiphy->strict_regulatory) {
 964                 /*
 965                  * This gaurantees the driver's requested regulatory domain
 966                  * will always be used as a base for further regulatory
 967                  * settings
 968                  */
 969                 chan->flags = chan->orig_flags =
 970                         map_regdom_flags(reg_rule->flags);
 971                 chan->max_antenna_gain = chan->orig_mag =
 972                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
 973                 chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
 974                 chan->max_power = chan->orig_mpwr =
 975                         (int) MBM_TO_DBM(power_rule->max_eirp);
 976                 return;
 977         }
 978
 979         chan->flags = flags | map_regdom_flags(reg_rule->flags);
 980         chan->max_antenna_gain = min(chan->orig_mag,
 981                 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
 982         chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
 983         if (chan->orig_mpwr)
 984                 chan->max_power = min(chan->orig_mpwr,
 985                         (int) MBM_TO_DBM(power_rule->max_eirp));
 986         else
 987                 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 988 }
 989
 990 static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
 991 {
 992         unsigned int i;
 993         struct ieee80211_supported_band *sband;
 994
 995         BUG_ON(!wiphy->bands[band]);
 996         sband = wiphy->bands[band];
 997
 998         for (i = 0; i < sband->n_channels; i++)
 999                 handle_channel(wiphy, band, i);
1000 }
1001
1002 static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
1003 {
1004         if (!last_request)
1005                 return true;
1006         if (setby == REGDOM_SET_BY_CORE &&
1007                   wiphy->custom_regulatory)
1008                 return true;
1009         /*
1010          * wiphy->regd will be set once the device has its own
1011          * desired regulatory domain set
1012          */
1013         if (wiphy->strict_regulatory && !wiphy->regd &&
1014             !is_world_regdom(last_request->alpha2))
1015                 return true;
1016         return false;
1017 }
1018
1019 static void update_all_wiphy_regulatory(enum reg_set_by setby)
1020 {
1021         struct cfg80211_registered_device *drv;
1022
1023         list_for_each_entry(drv, &cfg80211_drv_list, list)
1024                 wiphy_update_regulatory(&drv->wiphy, setby);
1025 }
1026
1027 static void handle_reg_beacon(struct wiphy *wiphy,
1028                               unsigned int chan_idx,
1029                               struct reg_beacon *reg_beacon)
1030 {
1031 #ifdef CONFIG_CFG80211_REG_DEBUG
1032 #define REG_DEBUG_BEACON_FLAG(desc) \
1033         printk(KERN_DEBUG "cfg80211: Enabling " desc " on " \
1034                 "frequency: %d MHz (Ch %d) on %s\n", \
1035                 reg_beacon->chan.center_freq, \
1036                 ieee80211_frequency_to_channel(reg_beacon->chan.center_freq), \
1037                 wiphy_name(wiphy));
1038 #else
1039 #define REG_DEBUG_BEACON_FLAG(desc) do {} while (0)
1040 #endif
1041         struct ieee80211_supported_band *sband;
1042         struct ieee80211_channel *chan;
1043
1044         assert_cfg80211_lock();
1045
1046         sband = wiphy->bands[reg_beacon->chan.band];
1047         chan = &sband->channels[chan_idx];
1048
1049         if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1050                 return;
1051
1052         if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
1053                 chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
1054                 REG_DEBUG_BEACON_FLAG("active scanning");
1055         }
1056
1057         if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
1058                 chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
1059                 REG_DEBUG_BEACON_FLAG("beaconing");
1060         }
1061
1062         chan->beacon_found = true;
1063 #undef REG_DEBUG_BEACON_FLAG
1064 }
1065
1066 /*
1067  * Called when a scan on a wiphy finds a beacon on
1068  * new channel
1069  */
1070 static void wiphy_update_new_beacon(struct wiphy *wiphy,
1071                                     struct reg_beacon *reg_beacon)
1072 {
1073         unsigned int i;
1074         struct ieee80211_supported_band *sband;
1075
1076         assert_cfg80211_lock();
1077
1078         if (!wiphy->bands[reg_beacon->chan.band])
1079                 return;
1080
1081         sband = wiphy->bands[reg_beacon->chan.band];
1082
1083         for (i = 0; i < sband->n_channels; i++)
1084                 handle_reg_beacon(wiphy, i, reg_beacon);
1085 }
1086
1087 /*
1088  * Called upon reg changes or a new wiphy is added
1089  */
1090 static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1091 {
1092         unsigned int i;
1093         struct ieee80211_supported_band *sband;
1094         struct reg_beacon *reg_beacon;
1095
1096         assert_cfg80211_lock();
1097
1098         if (list_empty(&reg_beacon_list))
1099                 return;
1100
1101         list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1102                 if (!wiphy->bands[reg_beacon->chan.band])
1103                         continue;
1104                 sband = wiphy->bands[reg_beacon->chan.band];
1105                 for (i = 0; i < sband->n_channels; i++)
1106                         handle_reg_beacon(wiphy, i, reg_beacon);
1107         }
1108 }
1109
1110 static bool reg_is_world_roaming(struct wiphy *wiphy)
1111 {
1112         if (is_world_regdom(cfg80211_regdomain->alpha2) ||
1113             (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
1114                 return true;
1115         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE &&
1116             wiphy->custom_regulatory)
1117                 return true;
1118         return false;
1119 }
1120
1121 /* Reap the advantages of previously found beacons */
1122 static void reg_process_beacons(struct wiphy *wiphy)
1123 {
1124         if (!reg_is_world_roaming(wiphy))
1125                 return;
1126         wiphy_update_beacon_reg(wiphy);
1127 }
1128
1129 void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby)
1130 {
1131         enum ieee80211_band band;
1132
1133         if (ignore_reg_update(wiphy, setby))
1134                 goto out;
1135         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1136                 if (wiphy->bands[band])
1137                         handle_band(wiphy, band);
1138         }
1139 out:
1140         reg_process_beacons(wiphy);
1141         if (wiphy->reg_notifier)
1142                 wiphy->reg_notifier(wiphy, last_request);
1143 }
1144
1145 static void handle_channel_custom(struct wiphy *wiphy,
1146                                   enum ieee80211_band band,
1147                                   unsigned int chan_idx,
1148                                   const struct ieee80211_regdomain *regd)
1149 {
1150         int r;
1151         u32 max_bandwidth = 0;
1152         const struct ieee80211_reg_rule *reg_rule = NULL;
1153         const struct ieee80211_power_rule *power_rule = NULL;
1154         struct ieee80211_supported_band *sband;
1155         struct ieee80211_channel *chan;
1156
1157         sband = wiphy->bands[band];
1158         BUG_ON(chan_idx >= sband->n_channels);
1159         chan = &sband->channels[chan_idx];
1160
1161         r = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
1162                 &max_bandwidth, &reg_rule, regd);
1163
1164         if (r) {
1165                 chan->flags = IEEE80211_CHAN_DISABLED;
1166                 return;
1167         }
1168
1169         power_rule = &reg_rule->power_rule;
1170
1171         chan->flags |= map_regdom_flags(reg_rule->flags);
1172         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1173         chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
1174         chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1175 }
1176
1177 static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
1178                                const struct ieee80211_regdomain *regd)
1179 {
1180         unsigned int i;
1181         struct ieee80211_supported_band *sband;
1182
1183         BUG_ON(!wiphy->bands[band]);
1184         sband = wiphy->bands[band];
1185
1186         for (i = 0; i < sband->n_channels; i++)
1187                 handle_channel_custom(wiphy, band, i, regd);
1188 }
1189
1190 /* Used by drivers prior to wiphy registration */
1191 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1192                                    const struct ieee80211_regdomain *regd)
1193 {
1194         enum ieee80211_band band;
1195         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1196                 if (wiphy->bands[band])
1197                         handle_band_custom(wiphy, band, regd);
1198         }
1199 }
1200 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1201
1202 static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
1203                          const struct ieee80211_regdomain *src_regd)
1204 {
1205         struct ieee80211_regdomain *regd;
1206         int size_of_regd = 0;
1207         unsigned int i;
1208
1209         size_of_regd = sizeof(struct ieee80211_regdomain) +
1210           ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
1211
1212         regd = kzalloc(size_of_regd, GFP_KERNEL);
1213         if (!regd)
1214                 return -ENOMEM;
1215
1216         memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
1217
1218         for (i = 0; i < src_regd->n_reg_rules; i++)
1219                 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
1220                         sizeof(struct ieee80211_reg_rule));
1221
1222         *dst_regd = regd;
1223         return 0;
1224 }
1225
1226 /*
1227  * Return value which can be used by ignore_request() to indicate
1228  * it has been determined we should intersect two regulatory domains
1229  */
1230 #define REG_INTERSECT   1
1231
1232 /* This has the logic which determines when a new request
1233  * should be ignored. */
1234 static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
1235                           const char *alpha2)
1236 {
1237         struct wiphy *last_wiphy = NULL;
1238
1239         assert_cfg80211_lock();
1240
1241         /* All initial requests are respected */
1242         if (!last_request)
1243                 return 0;
1244
1245         switch (set_by) {
1246         case REGDOM_SET_BY_INIT:
1247                 return -EINVAL;
1248         case REGDOM_SET_BY_CORE:
1249                 return -EINVAL;
1250         case REGDOM_SET_BY_COUNTRY_IE:
1251
1252                 last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1253
1254                 if (unlikely(!is_an_alpha2(alpha2)))
1255                         return -EINVAL;
1256                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1257                         if (last_wiphy != wiphy) {
1258                                 /*
1259                                  * Two cards with two APs claiming different
1260                                  * different Country IE alpha2s. We could
1261                                  * intersect them, but that seems unlikely
1262                                  * to be correct. Reject second one for now.
1263                                  */
1264                                 if (regdom_changes(alpha2))
1265                                         return -EOPNOTSUPP;
1266                                 return -EALREADY;
1267                         }
1268                         /*
1269                          * Two consecutive Country IE hints on the same wiphy.
1270                          * This should be picked up early by the driver/stack
1271                          */
1272                         if (WARN_ON(regdom_changes(alpha2)))
1273                                 return 0;
1274                         return -EALREADY;
1275                 }
1276                 return REG_INTERSECT;
1277         case REGDOM_SET_BY_DRIVER:
1278                 if (last_request->initiator == REGDOM_SET_BY_CORE) {
1279                         if (is_old_static_regdom(cfg80211_regdomain))
1280                                 return 0;
1281                         if (regdom_changes(alpha2))
1282                                 return 0;
1283                         return -EALREADY;
1284                 }
1285
1286                 /*
1287                  * This would happen if you unplug and plug your card
1288                  * back in or if you add a new device for which the previously
1289                  * loaded card also agrees on the regulatory domain.
1290                  */
1291                 if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
1292                     !regdom_changes(alpha2))
1293                         return -EALREADY;
1294
1295                 return REG_INTERSECT;
1296         case REGDOM_SET_BY_USER:
1297                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
1298                         return REG_INTERSECT;
1299                 /*
1300                  * If the user knows better the user should set the regdom
1301                  * to their country before the IE is picked up
1302                  */
1303                 if (last_request->initiator == REGDOM_SET_BY_USER &&
1304                           last_request->intersect)
1305                         return -EOPNOTSUPP;
1306                 /*
1307                  * Process user requests only after previous user/driver/core
1308                  * requests have been processed
1309                  */
1310                 if (last_request->initiator == REGDOM_SET_BY_CORE ||
1311                     last_request->initiator == REGDOM_SET_BY_DRIVER ||
1312                     last_request->initiator == REGDOM_SET_BY_USER) {
1313                         if (regdom_changes(last_request->alpha2))
1314                                 return -EAGAIN;
1315                 }
1316
1317                 if (!is_old_static_regdom(cfg80211_regdomain) &&
1318                     !regdom_changes(alpha2))
1319                         return -EALREADY;
1320
1321                 return 0;
1322         }
1323
1324         return -EINVAL;
1325 }
1326
1327 /* Caller must hold &cfg80211_mutex */
1328 int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
1329                         const char *alpha2,
1330                         u32 country_ie_checksum,
1331                         enum environment_cap env)
1332 {
1333         struct regulatory_request *request;
1334         bool intersect = false;
1335         int r = 0;
1336
1337         assert_cfg80211_lock();
1338
1339         r = ignore_request(wiphy, set_by, alpha2);
1340
1341         if (r == REG_INTERSECT) {
1342                 if (set_by == REGDOM_SET_BY_DRIVER) {
1343                         r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1344                         if (r)
1345                                 return r;
1346                 }
1347                 intersect = true;
1348         } else if (r) {
1349                 /*
1350                  * If the regulatory domain being requested by the
1351                  * driver has already been set just copy it to the
1352                  * wiphy
1353                  */
1354                 if (r == -EALREADY && set_by == REGDOM_SET_BY_DRIVER) {
1355                         r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1356                         if (r)
1357                                 return r;
1358                         r = -EALREADY;
1359                         goto new_request;
1360                 }
1361                 return r;
1362         }
1363
1364 new_request:
1365         request = kzalloc(sizeof(struct regulatory_request),
1366                           GFP_KERNEL);
1367         if (!request)
1368                 return -ENOMEM;
1369
1370         request->alpha2[0] = alpha2[0];
1371         request->alpha2[1] = alpha2[1];
1372         request->initiator = set_by;
1373         request->wiphy_idx = get_wiphy_idx(wiphy);
1374         request->intersect = intersect;
1375         request->country_ie_checksum = country_ie_checksum;
1376         request->country_ie_env = env;
1377
1378         kfree(last_request);
1379         last_request = request;
1380
1381         /* When r == REG_INTERSECT we do need to call CRDA */
1382         if (r < 0)
1383                 return r;
1384
1385         /*
1386          * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
1387          * AND if CRDA is NOT present nothing will happen, if someone
1388          * wants to bother with 11d with OLD_REG you can add a timer.
1389          * If after x amount of time nothing happens you can call:
1390          *
1391          * return set_regdom(country_ie_regdomain);
1392          *
1393          * to intersect with the static rd
1394          */
1395         return call_crda(alpha2);
1396 }
1397
1398 /* This currently only processes user and driver regulatory hints */
1399 static int reg_process_hint(struct regulatory_request *reg_request)
1400 {
1401         int r = 0;
1402         struct wiphy *wiphy = NULL;
1403
1404         BUG_ON(!reg_request->alpha2);
1405
1406         mutex_lock(&cfg80211_mutex);
1407
1408         if (wiphy_idx_valid(reg_request->wiphy_idx))
1409                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1410
1411         if (reg_request->initiator == REGDOM_SET_BY_DRIVER &&
1412             !wiphy) {
1413                 r = -ENODEV;
1414                 goto out;
1415         }
1416
1417         r = __regulatory_hint(wiphy,
1418                               reg_request->initiator,
1419                               reg_request->alpha2,
1420                               reg_request->country_ie_checksum,
1421                               reg_request->country_ie_env);
1422         /* This is required so that the orig_* parameters are saved */
1423         if (r == -EALREADY && wiphy && wiphy->strict_regulatory)
1424                 wiphy_update_regulatory(wiphy, reg_request->initiator);
1425 out:
1426         mutex_unlock(&cfg80211_mutex);
1427
1428         if (r == -EALREADY)
1429                 r = 0;
1430
1431         return r;
1432 }
1433
1434 /* Processes regulatory hints, this is all the REGDOM_SET_BY_* */
1435 static void reg_process_pending_hints(void)
1436         {
1437         struct regulatory_request *reg_request;
1438         int r;
1439
1440         spin_lock(&reg_requests_lock);
1441         while (!list_empty(&reg_requests_list)) {
1442                 reg_request = list_first_entry(&reg_requests_list,
1443                                                struct regulatory_request,
1444                                                list);
1445                 list_del_init(&reg_request->list);
1446                 spin_unlock(&reg_requests_lock);
1447
1448                 r = reg_process_hint(reg_request);
1449 #ifdef CONFIG_CFG80211_REG_DEBUG
1450                 if (r && (reg_request->initiator == REGDOM_SET_BY_DRIVER ||
1451                     reg_request->initiator == REGDOM_SET_BY_COUNTRY_IE))
1452                         printk(KERN_ERR "cfg80211: wiphy_idx %d sent a "
1453                                 "regulatory hint for %c%c but now has "
1454                                 "gone fishing, ignoring request\n",
1455                                 reg_request->wiphy_idx,
1456                                 reg_request->alpha2[0],
1457                                 reg_request->alpha2[1]);
1458 #endif
1459                 kfree(reg_request);
1460                 spin_lock(&reg_requests_lock);
1461         }
1462         spin_unlock(&reg_requests_lock);
1463 }
1464
1465 /* Processes beacon hints -- this has nothing to do with country IEs */
1466 static void reg_process_pending_beacon_hints(void)
1467 {
1468         struct cfg80211_registered_device *drv;
1469         struct reg_beacon *pending_beacon, *tmp;
1470
1471         mutex_lock(&cfg80211_mutex);
1472
1473         /* This goes through the _pending_ beacon list */
1474         spin_lock_bh(&reg_pending_beacons_lock);
1475
1476         if (list_empty(&reg_pending_beacons)) {
1477                 spin_unlock_bh(&reg_pending_beacons_lock);
1478                 goto out;
1479         }
1480
1481         list_for_each_entry_safe(pending_beacon, tmp,
1482                                  &reg_pending_beacons, list) {
1483
1484                 list_del_init(&pending_beacon->list);
1485
1486                 /* Applies the beacon hint to current wiphys */
1487                 list_for_each_entry(drv, &cfg80211_drv_list, list)
1488                         wiphy_update_new_beacon(&drv->wiphy, pending_beacon);
1489
1490                 /* Remembers the beacon hint for new wiphys or reg changes */
1491                 list_add_tail(&pending_beacon->list, &reg_beacon_list);
1492         }
1493
1494         spin_unlock_bh(&reg_pending_beacons_lock);
1495 out:
1496         mutex_unlock(&cfg80211_mutex);
1497 }
1498
1499 static void reg_todo(struct work_struct *work)
1500 {
1501         reg_process_pending_hints();
1502         reg_process_pending_beacon_hints();
1503 }
1504
1505 static DECLARE_WORK(reg_work, reg_todo);
1506
1507 static void queue_regulatory_request(struct regulatory_request *request)
1508 {
1509         spin_lock(&reg_requests_lock);
1510         list_add_tail(&request->list, &reg_requests_list);
1511         spin_unlock(&reg_requests_lock);
1512
1513         schedule_work(&reg_work);
1514 }
1515
1516 /* Core regulatory hint -- happens once during cfg80211_init() */
1517 static int regulatory_hint_core(const char *alpha2)
1518 {
1519         struct regulatory_request *request;
1520
1521         BUG_ON(last_request);
1522
1523         request = kzalloc(sizeof(struct regulatory_request),
1524                           GFP_KERNEL);
1525         if (!request)
1526                 return -ENOMEM;
1527
1528         request->alpha2[0] = alpha2[0];
1529         request->alpha2[1] = alpha2[1];
1530         request->initiator = REGDOM_SET_BY_CORE;
1531
1532         queue_regulatory_request(request);
1533
1534         return 0;
1535 }
1536
1537 /* User hints */
1538 int regulatory_hint_user(const char *alpha2)
1539 {
1540         struct regulatory_request *request;
1541
1542         BUG_ON(!alpha2);
1543
1544         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1545         if (!request)
1546                 return -ENOMEM;
1547
1548         request->wiphy_idx = WIPHY_IDX_STALE;
1549         request->alpha2[0] = alpha2[0];
1550         request->alpha2[1] = alpha2[1];
1551         request->initiator = REGDOM_SET_BY_USER,
1552
1553         queue_regulatory_request(request);
1554
1555         return 0;
1556 }
1557
1558 /* Driver hints */
1559 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1560 {
1561         struct regulatory_request *request;
1562
1563         BUG_ON(!alpha2);
1564         BUG_ON(!wiphy);
1565
1566         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1567         if (!request)
1568                 return -ENOMEM;
1569
1570         request->wiphy_idx = get_wiphy_idx(wiphy);
1571
1572         /* Must have registered wiphy first */
1573         BUG_ON(!wiphy_idx_valid(request->wiphy_idx));
1574
1575         request->alpha2[0] = alpha2[0];
1576         request->alpha2[1] = alpha2[1];
1577         request->initiator = REGDOM_SET_BY_DRIVER;
1578
1579         queue_regulatory_request(request);
1580
1581         return 0;
1582 }
1583 EXPORT_SYMBOL(regulatory_hint);
1584
1585 static bool reg_same_country_ie_hint(struct wiphy *wiphy,
1586                         u32 country_ie_checksum)
1587 {
1588         struct wiphy *request_wiphy;
1589
1590         assert_cfg80211_lock();
1591
1592         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1593
1594         if (!request_wiphy)
1595                 return false;
1596
1597         if (likely(request_wiphy != wiphy))
1598                 return !country_ie_integrity_changes(country_ie_checksum);
1599         /*
1600          * We should not have let these through at this point, they
1601          * should have been picked up earlier by the first alpha2 check
1602          * on the device
1603          */
1604         if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
1605                 return true;
1606         return false;
1607 }
1608
1609 void regulatory_hint_11d(struct wiphy *wiphy,
1610                         u8 *country_ie,
1611                         u8 country_ie_len)
1612 {
1613         struct ieee80211_regdomain *rd = NULL;
1614         char alpha2[2];
1615         u32 checksum = 0;
1616         enum environment_cap env = ENVIRON_ANY;
1617         struct regulatory_request *request;
1618
1619         mutex_lock(&cfg80211_mutex);
1620
1621         if (unlikely(!last_request)) {
1622                 mutex_unlock(&cfg80211_mutex);
1623                 return;
1624         }
1625
1626         /* IE len must be evenly divisible by 2 */
1627         if (country_ie_len & 0x01)
1628                 goto out;
1629
1630         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1631                 goto out;
1632
1633         /*
1634          * Pending country IE processing, this can happen after we
1635          * call CRDA and wait for a response if a beacon was received before
1636          * we were able to process the last regulatory_hint_11d() call
1637          */
1638         if (country_ie_regdomain)
1639                 goto out;
1640
1641         alpha2[0] = country_ie[0];
1642         alpha2[1] = country_ie[1];
1643
1644         if (country_ie[2] == 'I')
1645                 env = ENVIRON_INDOOR;
1646         else if (country_ie[2] == 'O')
1647                 env = ENVIRON_OUTDOOR;
1648
1649         /*
1650          * We will run this for *every* beacon processed for the BSSID, so
1651          * we optimize an early check to exit out early if we don't have to
1652          * do anything
1653          */
1654         if (likely(wiphy_idx_valid(last_request->wiphy_idx))) {
1655                 struct cfg80211_registered_device *drv_last_ie;
1656
1657                 drv_last_ie =
1658                         cfg80211_drv_by_wiphy_idx(last_request->wiphy_idx);
1659
1660                 /*
1661                  * Lets keep this simple -- we trust the first AP
1662                  * after we intersect with CRDA
1663                  */
1664                 if (likely(&drv_last_ie->wiphy == wiphy)) {
1665                         /*
1666                          * Ignore IEs coming in on this wiphy with
1667                          * the same alpha2 and environment cap
1668                          */
1669                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1670                                   alpha2) &&
1671                                   env == drv_last_ie->env)) {
1672                                 goto out;
1673                         }
1674                         /*
1675                          * the wiphy moved on to another BSSID or the AP
1676                          * was reconfigured. XXX: We need to deal with the
1677                          * case where the user suspends and goes to goes
1678                          * to another country, and then gets IEs from an
1679                          * AP with different settings
1680                          */
1681                         goto out;
1682                 } else {
1683                         /*
1684                          * Ignore IEs coming in on two separate wiphys with
1685                          * the same alpha2 and environment cap
1686                          */
1687                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1688                                   alpha2) &&
1689                                   env == drv_last_ie->env)) {
1690                                 goto out;
1691                         }
1692                         /* We could potentially intersect though */
1693                         goto out;
1694                 }
1695         }
1696
1697         rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
1698         if (!rd)
1699                 goto out;
1700
1701         /*
1702          * This will not happen right now but we leave it here for the
1703          * the future when we want to add suspend/resume support and having
1704          * the user move to another country after doing so, or having the user
1705          * move to another AP. Right now we just trust the first AP.
1706          *
1707          * If we hit this before we add this support we want to be informed of
1708          * it as it would indicate a mistake in the current design
1709          */
1710         if (WARN_ON(reg_same_country_ie_hint(wiphy, checksum)))
1711                 goto free_rd_out;
1712
1713         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1714         if (!request)
1715                 goto free_rd_out;
1716
1717         /*
1718          * We keep this around for when CRDA comes back with a response so
1719          * we can intersect with that
1720          */
1721         country_ie_regdomain = rd;
1722
1723         request->wiphy_idx = get_wiphy_idx(wiphy);
1724         request->alpha2[0] = rd->alpha2[0];
1725         request->alpha2[1] = rd->alpha2[1];
1726         request->initiator = REGDOM_SET_BY_COUNTRY_IE;
1727         request->country_ie_checksum = checksum;
1728         request->country_ie_env = env;
1729
1730         mutex_unlock(&cfg80211_mutex);
1731
1732         queue_regulatory_request(request);
1733
1734         return;
1735
1736 free_rd_out:
1737         kfree(rd);
1738 out:
1739         mutex_unlock(&cfg80211_mutex);
1740 }
1741 EXPORT_SYMBOL(regulatory_hint_11d);
1742
1743 static bool freq_is_chan_12_13_14(u16 freq)
1744 {
1745         if (freq == ieee80211_channel_to_frequency(12) ||
1746             freq == ieee80211_channel_to_frequency(13) ||
1747             freq == ieee80211_channel_to_frequency(14))
1748                 return true;
1749         return false;
1750 }
1751
1752 int regulatory_hint_found_beacon(struct wiphy *wiphy,
1753                                  struct ieee80211_channel *beacon_chan,
1754                                  gfp_t gfp)
1755 {
1756         struct reg_beacon *reg_beacon;
1757
1758         if (likely((beacon_chan->beacon_found ||
1759             (beacon_chan->flags & IEEE80211_CHAN_RADAR) ||
1760             (beacon_chan->band == IEEE80211_BAND_2GHZ &&
1761              !freq_is_chan_12_13_14(beacon_chan->center_freq)))))
1762                 return 0;
1763
1764         reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
1765         if (!reg_beacon)
1766                 return -ENOMEM;
1767
1768 #ifdef CONFIG_CFG80211_REG_DEBUG
1769         printk(KERN_DEBUG "cfg80211: Found new beacon on "
1770                 "frequency: %d MHz (Ch %d) on %s\n",
1771                 beacon_chan->center_freq,
1772                 ieee80211_frequency_to_channel(beacon_chan->center_freq),
1773                 wiphy_name(wiphy));
1774 #endif
1775         memcpy(&reg_beacon->chan, beacon_chan,
1776                 sizeof(struct ieee80211_channel));
1777
1778
1779         /*
1780          * Since we can be called from BH or and non-BH context
1781          * we must use spin_lock_bh()
1782          */
1783         spin_lock_bh(&reg_pending_beacons_lock);
1784         list_add_tail(&reg_beacon->list, &reg_pending_beacons);
1785         spin_unlock_bh(&reg_pending_beacons_lock);
1786
1787         schedule_work(&reg_work);
1788
1789         return 0;
1790 }
1791
1792 static void print_rd_rules(const struct ieee80211_regdomain *rd)
1793 {
1794         unsigned int i;
1795         const struct ieee80211_reg_rule *reg_rule = NULL;
1796         const struct ieee80211_freq_range *freq_range = NULL;
1797         const struct ieee80211_power_rule *power_rule = NULL;
1798
1799         printk(KERN_INFO "\t(start_freq - end_freq @ bandwidth), "
1800                 "(max_antenna_gain, max_eirp)\n");
1801
1802         for (i = 0; i < rd->n_reg_rules; i++) {
1803                 reg_rule = &rd->reg_rules[i];
1804                 freq_range = &reg_rule->freq_range;
1805                 power_rule = &reg_rule->power_rule;
1806
1807                 /*
1808                  * There may not be documentation for max antenna gain
1809                  * in certain regions
1810                  */
1811                 if (power_rule->max_antenna_gain)
1812                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1813                                 "(%d mBi, %d mBm)\n",
1814                                 freq_range->start_freq_khz,
1815                                 freq_range->end_freq_khz,
1816                                 freq_range->max_bandwidth_khz,
1817                                 power_rule->max_antenna_gain,
1818                                 power_rule->max_eirp);
1819                 else
1820                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1821                                 "(N/A, %d mBm)\n",
1822                                 freq_range->start_freq_khz,
1823                                 freq_range->end_freq_khz,
1824                                 freq_range->max_bandwidth_khz,
1825                                 power_rule->max_eirp);
1826         }
1827 }
1828
1829 static void print_regdomain(const struct ieee80211_regdomain *rd)
1830 {
1831
1832         if (is_intersected_alpha2(rd->alpha2)) {
1833
1834                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1835                         struct cfg80211_registered_device *drv;
1836                         drv = cfg80211_drv_by_wiphy_idx(
1837                                 last_request->wiphy_idx);
1838                         if (drv) {
1839                                 printk(KERN_INFO "cfg80211: Current regulatory "
1840                                         "domain updated by AP to: %c%c\n",
1841                                         drv->country_ie_alpha2[0],
1842                                         drv->country_ie_alpha2[1]);
1843                         } else
1844                                 printk(KERN_INFO "cfg80211: Current regulatory "
1845                                         "domain intersected: \n");
1846                 } else
1847                                 printk(KERN_INFO "cfg80211: Current regulatory "
1848                                         "domain intersected: \n");
1849         } else if (is_world_regdom(rd->alpha2))
1850                 printk(KERN_INFO "cfg80211: World regulatory "
1851                         "domain updated:\n");
1852         else {
1853                 if (is_unknown_alpha2(rd->alpha2))
1854                         printk(KERN_INFO "cfg80211: Regulatory domain "
1855                                 "changed to driver built-in settings "
1856                                 "(unknown country)\n");
1857                 else
1858                         printk(KERN_INFO "cfg80211: Regulatory domain "
1859                                 "changed to country: %c%c\n",
1860                                 rd->alpha2[0], rd->alpha2[1]);
1861         }
1862         print_rd_rules(rd);
1863 }
1864
1865 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
1866 {
1867         printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
1868                 rd->alpha2[0], rd->alpha2[1]);
1869         print_rd_rules(rd);
1870 }
1871
1872 #ifdef CONFIG_CFG80211_REG_DEBUG
1873 static void reg_country_ie_process_debug(
1874         const struct ieee80211_regdomain *rd,
1875         const struct ieee80211_regdomain *country_ie_regdomain,
1876         const struct ieee80211_regdomain *intersected_rd)
1877 {
1878         printk(KERN_DEBUG "cfg80211: Received country IE:\n");
1879         print_regdomain_info(country_ie_regdomain);
1880         printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
1881         print_regdomain_info(rd);
1882         if (intersected_rd) {
1883                 printk(KERN_DEBUG "cfg80211: We intersect both of these "
1884                         "and get:\n");
1885                 print_regdomain_info(intersected_rd);
1886                 return;
1887         }
1888         printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
1889 }
1890 #else
1891 static inline void reg_country_ie_process_debug(
1892         const struct ieee80211_regdomain *rd,
1893         const struct ieee80211_regdomain *country_ie_regdomain,
1894         const struct ieee80211_regdomain *intersected_rd)
1895 {
1896 }
1897 #endif
1898
1899 /* Takes ownership of rd only if it doesn't fail */
1900 static int __set_regdom(const struct ieee80211_regdomain *rd)
1901 {
1902         const struct ieee80211_regdomain *intersected_rd = NULL;
1903         struct cfg80211_registered_device *drv = NULL;
1904         struct wiphy *request_wiphy;
1905         /* Some basic sanity checks first */
1906
1907         if (is_world_regdom(rd->alpha2)) {
1908                 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1909                         return -EINVAL;
1910                 update_world_regdomain(rd);
1911                 return 0;
1912         }
1913
1914         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
1915                         !is_unknown_alpha2(rd->alpha2))
1916                 return -EINVAL;
1917
1918         if (!last_request)
1919                 return -EINVAL;
1920
1921         /*
1922          * Lets only bother proceeding on the same alpha2 if the current
1923          * rd is non static (it means CRDA was present and was used last)
1924          * and the pending request came in from a country IE
1925          */
1926         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1927                 /*
1928                  * If someone else asked us to change the rd lets only bother
1929                  * checking if the alpha2 changes if CRDA was already called
1930                  */
1931                 if (!is_old_static_regdom(cfg80211_regdomain) &&
1932                     !regdom_changes(rd->alpha2))
1933                         return -EINVAL;
1934         }
1935
1936         /*
1937          * Now lets set the regulatory domain, update all driver channels
1938          * and finally inform them of what we have done, in case they want
1939          * to review or adjust their own settings based on their own
1940          * internal EEPROM data
1941          */
1942
1943         if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1944                 return -EINVAL;
1945
1946         if (!is_valid_rd(rd)) {
1947                 printk(KERN_ERR "cfg80211: Invalid "
1948                         "regulatory domain detected:\n");
1949                 print_regdomain_info(rd);
1950                 return -EINVAL;
1951         }
1952
1953         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1954
1955         if (!last_request->intersect) {
1956                 int r;
1957
1958                 if (last_request->initiator != REGDOM_SET_BY_DRIVER) {
1959                         reset_regdomains();
1960                         cfg80211_regdomain = rd;
1961                         return 0;
1962                 }
1963
1964                 /*
1965                  * For a driver hint, lets copy the regulatory domain the
1966                  * driver wanted to the wiphy to deal with conflicts
1967                  */
1968
1969                 BUG_ON(request_wiphy->regd);
1970
1971                 r = reg_copy_regd(&request_wiphy->regd, rd);
1972                 if (r)
1973                         return r;
1974
1975                 reset_regdomains();
1976                 cfg80211_regdomain = rd;
1977                 return 0;
1978         }
1979
1980         /* Intersection requires a bit more work */
1981
1982         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1983
1984                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1985                 if (!intersected_rd)
1986                         return -EINVAL;
1987
1988                 /*
1989                  * We can trash what CRDA provided now.
1990                  * However if a driver requested this specific regulatory
1991                  * domain we keep it for its private use
1992                  */
1993                 if (last_request->initiator == REGDOM_SET_BY_DRIVER)
1994                         request_wiphy->regd = rd;
1995                 else
1996                         kfree(rd);
1997
1998                 rd = NULL;
1999
2000                 reset_regdomains();
2001                 cfg80211_regdomain = intersected_rd;
2002
2003                 return 0;
2004         }
2005
2006         /*
2007          * Country IE requests are handled a bit differently, we intersect
2008          * the country IE rd with what CRDA believes that country should have
2009          */
2010
2011         BUG_ON(!country_ie_regdomain);
2012
2013         if (rd != country_ie_regdomain) {
2014                 /*
2015                  * Intersect what CRDA returned and our what we
2016                  * had built from the Country IE received
2017                  */
2018
2019                 intersected_rd = regdom_intersect(rd, country_ie_regdomain);
2020
2021                 reg_country_ie_process_debug(rd, country_ie_regdomain,
2022                         intersected_rd);
2023
2024                 kfree(country_ie_regdomain);
2025                 country_ie_regdomain = NULL;
2026         } else {
2027                 /*
2028                  * This would happen when CRDA was not present and
2029                  * OLD_REGULATORY was enabled. We intersect our Country
2030                  * IE rd and what was set on cfg80211 originally
2031                  */
2032                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
2033         }
2034
2035         if (!intersected_rd)
2036                 return -EINVAL;
2037
2038         drv = wiphy_to_dev(request_wiphy);
2039
2040         drv->country_ie_alpha2[0] = rd->alpha2[0];
2041         drv->country_ie_alpha2[1] = rd->alpha2[1];
2042         drv->env = last_request->country_ie_env;
2043
2044         BUG_ON(intersected_rd == rd);
2045
2046         kfree(rd);
2047         rd = NULL;
2048
2049         reset_regdomains();
2050         cfg80211_regdomain = intersected_rd;
2051
2052         return 0;
2053 }
2054
2055
2056 /*
2057  * Use this call to set the current regulatory domain. Conflicts with
2058  * multiple drivers can be ironed out later. Caller must've already
2059  * kmalloc'd the rd structure. Caller must hold cfg80211_mutex
2060  */
2061 int set_regdom(const struct ieee80211_regdomain *rd)
2062 {
2063         int r;
2064
2065         assert_cfg80211_lock();
2066
2067         /* Note that this doesn't update the wiphys, this is done below */
2068         r = __set_regdom(rd);
2069         if (r) {
2070                 kfree(rd);
2071                 return r;
2072         }
2073
2074         /* This would make this whole thing pointless */
2075         if (!last_request->intersect)
2076                 BUG_ON(rd != cfg80211_regdomain);
2077
2078         /* update all wiphys now with the new established regulatory domain */
2079         update_all_wiphy_regulatory(last_request->initiator);
2080
2081         print_regdomain(cfg80211_regdomain);
2082
2083         return r;
2084 }
2085
2086 /* Caller must hold cfg80211_mutex */
2087 void reg_device_remove(struct wiphy *wiphy)
2088 {
2089         struct wiphy *request_wiphy;
2090
2091         assert_cfg80211_lock();
2092
2093         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
2094
2095         kfree(wiphy->regd);
2096         if (!last_request || !request_wiphy)
2097                 return;
2098         if (request_wiphy != wiphy)
2099                 return;
2100         last_request->wiphy_idx = WIPHY_IDX_STALE;
2101         last_request->country_ie_env = ENVIRON_ANY;
2102 }
2103
2104 int regulatory_init(void)
2105 {
2106         int err = 0;
2107
2108         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2109         if (IS_ERR(reg_pdev))
2110                 return PTR_ERR(reg_pdev);
2111
2112         spin_lock_init(&reg_requests_lock);
2113         spin_lock_init(&reg_pending_beacons_lock);
2114
2115 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
2116         cfg80211_regdomain = static_regdom(ieee80211_regdom);
2117
2118         printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
2119         print_regdomain_info(cfg80211_regdomain);
2120         /*
2121          * The old code still requests for a new regdomain and if
2122          * you have CRDA you get it updated, otherwise you get
2123          * stuck with the static values. We ignore "EU" code as
2124          * that is not a valid ISO / IEC 3166 alpha2
2125          */
2126         if (ieee80211_regdom[0] != 'E' || ieee80211_regdom[1] != 'U')
2127                 err = regulatory_hint_core(ieee80211_regdom);
2128 #else
2129         cfg80211_regdomain = cfg80211_world_regdom;
2130
2131         err = regulatory_hint_core("00");
2132 #endif
2133         if (err) {
2134                 if (err == -ENOMEM)
2135                         return err;
2136                 /*
2137                  * N.B. kobject_uevent_env() can fail mainly for when we're out
2138                  * memory which is handled and propagated appropriately above
2139                  * but it can also fail during a netlink_broadcast() or during
2140                  * early boot for call_usermodehelper(). For now treat these
2141                  * errors as non-fatal.
2142                  */
2143                 printk(KERN_ERR "cfg80211: kobject_uevent_env() was unable "
2144                         "to call CRDA during init");
2145 #ifdef CONFIG_CFG80211_REG_DEBUG
2146                 /* We want to find out exactly why when debugging */
2147                 WARN_ON(err);
2148 #endif
2149         }
2150
2151         return 0;
2152 }
2153
2154 void regulatory_exit(void)
2155 {
2156         struct regulatory_request *reg_request, *tmp;
2157         struct reg_beacon *reg_beacon, *btmp;
2158
2159         cancel_work_sync(&reg_work);
2160
2161         mutex_lock(&cfg80211_mutex);
2162
2163         reset_regdomains();
2164
2165         kfree(country_ie_regdomain);
2166         country_ie_regdomain = NULL;
2167
2168         kfree(last_request);
2169
2170         platform_device_unregister(reg_pdev);
2171
2172         spin_lock_bh(&reg_pending_beacons_lock);
2173         if (!list_empty(&reg_pending_beacons)) {
2174                 list_for_each_entry_safe(reg_beacon, btmp,
2175                                          &reg_pending_beacons, list) {
2176                         list_del(&reg_beacon->list);
2177                         kfree(reg_beacon);
2178                 }
2179         }
2180         spin_unlock_bh(&reg_pending_beacons_lock);
2181
2182         if (!list_empty(&reg_beacon_list)) {
2183                 list_for_each_entry_safe(reg_beacon, btmp,
2184                                          &reg_beacon_list, list) {
2185                         list_del(&reg_beacon->list);
2186                         kfree(reg_beacon);
2187                 }
2188         }
2189
2190         spin_lock(&reg_requests_lock);
2191         if (!list_empty(&reg_requests_list)) {
2192                 list_for_each_entry_safe(reg_request, tmp,
2193                                          &reg_requests_list, list) {
2194                         list_del(&reg_request->list);
2195                         kfree(reg_request);
2196                 }
2197         }
2198         spin_unlock(&reg_requests_lock);
2199
2200         mutex_unlock(&cfg80211_mutex);
2201 }