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