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