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