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