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  * Copyright 2013-2014  Intel Mobile Communications GmbH
   7  * Copyright      2017  Intel Deutschland GmbH
   8  * Copyright (C) 2018 - 2021 Intel Corporation
   9  *
  10  * Permission to use, copy, modify, and/or distribute this software for any
  11  * purpose with or without fee is hereby granted, provided that the above
  12  * copyright notice and this permission notice appear in all copies.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  15  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  16  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  17  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  19  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  20  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23
  24 /**
  25  * DOC: Wireless regulatory infrastructure
  26  *
  27  * The usual implementation is for a driver to read a device EEPROM to
  28  * determine which regulatory domain it should be operating under, then
  29  * looking up the allowable channels in a driver-local table and finally
  30  * registering those channels in the wiphy structure.
  31  *
  32  * Another set of compliance enforcement is for drivers to use their
  33  * own compliance limits which can be stored on the EEPROM. The host
  34  * driver or firmware may ensure these are used.
  35  *
  36  * In addition to all this we provide an extra layer of regulatory
  37  * conformance. For drivers which do not have any regulatory
  38  * information CRDA provides the complete regulatory solution.
  39  * For others it provides a community effort on further restrictions
  40  * to enhance compliance.
  41  *
  42  * Note: When number of rules --> infinity we will not be able to
  43  * index on alpha2 any more, instead we'll probably have to
  44  * rely on some SHA1 checksum of the regdomain for example.
  45  *
  46  */
  47
  48 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  49
  50 #include <linux/kernel.h>
  51 #include <linux/export.h>
  52 #include <linux/slab.h>
  53 #include <linux/list.h>
  54 #include <linux/ctype.h>
  55 #include <linux/nl80211.h>
  56 #include <linux/platform_device.h>
  57 #include <linux/verification.h>
  58 #include <linux/moduleparam.h>
  59 #include <linux/firmware.h>
  60 #include <net/cfg80211.h>
  61 #include "core.h"
  62 #include "reg.h"
  63 #include "rdev-ops.h"
  64 #include "nl80211.h"
  65
  66 /*
  67  * Grace period we give before making sure all current interfaces reside on
  68  * channels allowed by the current regulatory domain.
  69  */
  70 #define REG_ENFORCE_GRACE_MS 60000
  71
  72 /**
  73  * enum reg_request_treatment - regulatory request treatment
  74  *
  75  * @REG_REQ_OK: continue processing the regulatory request
  76  * @REG_REQ_IGNORE: ignore the regulatory request
  77  * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
  78  *      be intersected with the current one.
  79  * @REG_REQ_ALREADY_SET: the regulatory request will not change the current
  80  *      regulatory settings, and no further processing is required.
  81  */
  82 enum reg_request_treatment {
  83         REG_REQ_OK,
  84         REG_REQ_IGNORE,
  85         REG_REQ_INTERSECT,
  86         REG_REQ_ALREADY_SET,
  87 };
  88
  89 static struct regulatory_request core_request_world = {
  90         .initiator = NL80211_REGDOM_SET_BY_CORE,
  91         .alpha2[0] = '0',
  92         .alpha2[1] = '0',
  93         .intersect = false,
  94         .processed = true,
  95         .country_ie_env = ENVIRON_ANY,
  96 };
  97
  98 /*
  99  * Receipt of information from last regulatory request,
 100  * protected by RTNL (and can be accessed with RCU protection)
 101  */
 102 static struct regulatory_request __rcu *last_request =
 103         (void __force __rcu *)&core_request_world;
 104
 105 /* To trigger userspace events and load firmware */
 106 static struct platform_device *reg_pdev;
 107
 108 /*
 109  * Central wireless core regulatory domains, we only need two,
 110  * the current one and a world regulatory domain in case we have no
 111  * information to give us an alpha2.
 112  * (protected by RTNL, can be read under RCU)
 113  */
 114 const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
 115
 116 /*
 117  * Number of devices that registered to the core
 118  * that support cellular base station regulatory hints
 119  * (protected by RTNL)
 120  */
 121 static int reg_num_devs_support_basehint;
 122
 123 /*
 124  * State variable indicating if the platform on which the devices
 125  * are attached is operating in an indoor environment. The state variable
 126  * is relevant for all registered devices.
 127  */
 128 static bool reg_is_indoor;
 129 static DEFINE_SPINLOCK(reg_indoor_lock);
 130
 131 /* Used to track the userspace process controlling the indoor setting */
 132 static u32 reg_is_indoor_portid;
 133
 134 static void restore_regulatory_settings(bool reset_user, bool cached);
 135 static void print_regdomain(const struct ieee80211_regdomain *rd);
 136
 137 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
 138 {
 139         return rcu_dereference_rtnl(cfg80211_regdomain);
 140 }
 141
 142 /*
 143  * Returns the regulatory domain associated with the wiphy.
 144  *
 145  * Requires any of RTNL, wiphy mutex or RCU protection.
 146  */
 147 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
 148 {
 149         return rcu_dereference_check(wiphy->regd,
 150                                      lockdep_is_held(&wiphy->mtx) ||
 151                                      lockdep_rtnl_is_held());
 152 }
 153 EXPORT_SYMBOL(get_wiphy_regdom);
 154
 155 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
 156 {
 157         switch (dfs_region) {
 158         case NL80211_DFS_UNSET:
 159                 return "unset";
 160         case NL80211_DFS_FCC:
 161                 return "FCC";
 162         case NL80211_DFS_ETSI:
 163                 return "ETSI";
 164         case NL80211_DFS_JP:
 165                 return "JP";
 166         }
 167         return "Unknown";
 168 }
 169
 170 enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy)
 171 {
 172         const struct ieee80211_regdomain *regd = NULL;
 173         const struct ieee80211_regdomain *wiphy_regd = NULL;
 174         enum nl80211_dfs_regions dfs_region;
 175
 176         rcu_read_lock();
 177         regd = get_cfg80211_regdom();
 178         dfs_region = regd->dfs_region;
 179
 180         if (!wiphy)
 181                 goto out;
 182
 183         wiphy_regd = get_wiphy_regdom(wiphy);
 184         if (!wiphy_regd)
 185                 goto out;
 186
 187         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
 188                 dfs_region = wiphy_regd->dfs_region;
 189                 goto out;
 190         }
 191
 192         if (wiphy_regd->dfs_region == regd->dfs_region)
 193                 goto out;
 194
 195         pr_debug("%s: device specific dfs_region (%s) disagrees with cfg80211's central dfs_region (%s)\n",
 196                  dev_name(&wiphy->dev),
 197                  reg_dfs_region_str(wiphy_regd->dfs_region),
 198                  reg_dfs_region_str(regd->dfs_region));
 199
 200 out:
 201         rcu_read_unlock();
 202
 203         return dfs_region;
 204 }
 205
 206 static void rcu_free_regdom(const struct ieee80211_regdomain *r)
 207 {
 208         if (!r)
 209                 return;
 210         kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
 211 }
 212
 213 static struct regulatory_request *get_last_request(void)
 214 {
 215         return rcu_dereference_rtnl(last_request);
 216 }
 217
 218 /* Used to queue up regulatory hints */
 219 static LIST_HEAD(reg_requests_list);
 220 static DEFINE_SPINLOCK(reg_requests_lock);
 221
 222 /* Used to queue up beacon hints for review */
 223 static LIST_HEAD(reg_pending_beacons);
 224 static DEFINE_SPINLOCK(reg_pending_beacons_lock);
 225
 226 /* Used to keep track of processed beacon hints */
 227 static LIST_HEAD(reg_beacon_list);
 228
 229 struct reg_beacon {
 230         struct list_head list;
 231         struct ieee80211_channel chan;
 232 };
 233
 234 static void reg_check_chans_work(struct work_struct *work);
 235 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
 236
 237 static void reg_todo(struct work_struct *work);
 238 static DECLARE_WORK(reg_work, reg_todo);
 239
 240 /* We keep a static world regulatory domain in case of the absence of CRDA */
 241 static const struct ieee80211_regdomain world_regdom = {
 242         .n_reg_rules = 8,
 243         .alpha2 =  "00",
 244         .reg_rules = {
 245                 /* IEEE 802.11b/g, channels 1..11 */
 246                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
 247                 /* IEEE 802.11b/g, channels 12..13. */
 248                 REG_RULE(2467-10, 2472+10, 20, 6, 20,
 249                         NL80211_RRF_NO_IR | NL80211_RRF_AUTO_BW),
 250                 /* IEEE 802.11 channel 14 - Only JP enables
 251                  * this and for 802.11b only */
 252                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
 253                         NL80211_RRF_NO_IR |
 254                         NL80211_RRF_NO_OFDM),
 255                 /* IEEE 802.11a, channel 36..48 */
 256                 REG_RULE(5180-10, 5240+10, 80, 6, 20,
 257                         NL80211_RRF_NO_IR |
 258                         NL80211_RRF_AUTO_BW),
 259
 260                 /* IEEE 802.11a, channel 52..64 - DFS required */
 261                 REG_RULE(5260-10, 5320+10, 80, 6, 20,
 262                         NL80211_RRF_NO_IR |
 263                         NL80211_RRF_AUTO_BW |
 264                         NL80211_RRF_DFS),
 265
 266                 /* IEEE 802.11a, channel 100..144 - DFS required */
 267                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
 268                         NL80211_RRF_NO_IR |
 269                         NL80211_RRF_DFS),
 270
 271                 /* IEEE 802.11a, channel 149..165 */
 272                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
 273                         NL80211_RRF_NO_IR),
 274
 275                 /* IEEE 802.11ad (60GHz), channels 1..3 */
 276                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
 277         }
 278 };
 279
 280 /* protected by RTNL */
 281 static const struct ieee80211_regdomain *cfg80211_world_regdom =
 282         &world_regdom;
 283
 284 static char *ieee80211_regdom = "00";
 285 static char user_alpha2[2];
 286 static const struct ieee80211_regdomain *cfg80211_user_regdom;
 287
 288 module_param(ieee80211_regdom, charp, 0444);
 289 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 290
 291 static void reg_free_request(struct regulatory_request *request)
 292 {
 293         if (request == &core_request_world)
 294                 return;
 295
 296         if (request != get_last_request())
 297                 kfree(request);
 298 }
 299
 300 static void reg_free_last_request(void)
 301 {
 302         struct regulatory_request *lr = get_last_request();
 303
 304         if (lr != &core_request_world && lr)
 305                 kfree_rcu(lr, rcu_head);
 306 }
 307
 308 static void reg_update_last_request(struct regulatory_request *request)
 309 {
 310         struct regulatory_request *lr;
 311
 312         lr = get_last_request();
 313         if (lr == request)
 314                 return;
 315
 316         reg_free_last_request();
 317         rcu_assign_pointer(last_request, request);
 318 }
 319
 320 static void reset_regdomains(bool full_reset,
 321                              const struct ieee80211_regdomain *new_regdom)
 322 {
 323         const struct ieee80211_regdomain *r;
 324
 325         ASSERT_RTNL();
 326
 327         r = get_cfg80211_regdom();
 328
 329         /* avoid freeing static information or freeing something twice */
 330         if (r == cfg80211_world_regdom)
 331                 r = NULL;
 332         if (cfg80211_world_regdom == &world_regdom)
 333                 cfg80211_world_regdom = NULL;
 334         if (r == &world_regdom)
 335                 r = NULL;
 336
 337         rcu_free_regdom(r);
 338         rcu_free_regdom(cfg80211_world_regdom);
 339
 340         cfg80211_world_regdom = &world_regdom;
 341         rcu_assign_pointer(cfg80211_regdomain, new_regdom);
 342
 343         if (!full_reset)
 344                 return;
 345
 346         reg_update_last_request(&core_request_world);
 347 }
 348
 349 /*
 350  * Dynamic world regulatory domain requested by the wireless
 351  * core upon initialization
 352  */
 353 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 354 {
 355         struct regulatory_request *lr;
 356
 357         lr = get_last_request();
 358
 359         WARN_ON(!lr);
 360
 361         reset_regdomains(false, rd);
 362
 363         cfg80211_world_regdom = rd;
 364 }
 365
 366 bool is_world_regdom(const char *alpha2)
 367 {
 368         if (!alpha2)
 369                 return false;
 370         return alpha2[0] == '0' && alpha2[1] == '0';
 371 }
 372
 373 static bool is_alpha2_set(const char *alpha2)
 374 {
 375         if (!alpha2)
 376                 return false;
 377         return alpha2[0] && alpha2[1];
 378 }
 379
 380 static bool is_unknown_alpha2(const char *alpha2)
 381 {
 382         if (!alpha2)
 383                 return false;
 384         /*
 385          * Special case where regulatory domain was built by driver
 386          * but a specific alpha2 cannot be determined
 387          */
 388         return alpha2[0] == '9' && alpha2[1] == '9';
 389 }
 390
 391 static bool is_intersected_alpha2(const char *alpha2)
 392 {
 393         if (!alpha2)
 394                 return false;
 395         /*
 396          * Special case where regulatory domain is the
 397          * result of an intersection between two regulatory domain
 398          * structures
 399          */
 400         return alpha2[0] == '9' && alpha2[1] == '8';
 401 }
 402
 403 static bool is_an_alpha2(const char *alpha2)
 404 {
 405         if (!alpha2)
 406                 return false;
 407         return isalpha(alpha2[0]) && isalpha(alpha2[1]);
 408 }
 409
 410 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 411 {
 412         if (!alpha2_x || !alpha2_y)
 413                 return false;
 414         return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
 415 }
 416
 417 static bool regdom_changes(const char *alpha2)
 418 {
 419         const struct ieee80211_regdomain *r = get_cfg80211_regdom();
 420
 421         if (!r)
 422                 return true;
 423         return !alpha2_equal(r->alpha2, alpha2);
 424 }
 425
 426 /*
 427  * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
 428  * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
 429  * has ever been issued.
 430  */
 431 static bool is_user_regdom_saved(void)
 432 {
 433         if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
 434                 return false;
 435
 436         /* This would indicate a mistake on the design */
 437         if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
 438                  "Unexpected user alpha2: %c%c\n",
 439                  user_alpha2[0], user_alpha2[1]))
 440                 return false;
 441
 442         return true;
 443 }
 444
 445 static const struct ieee80211_regdomain *
 446 reg_copy_regd(const struct ieee80211_regdomain *src_regd)
 447 {
 448         struct ieee80211_regdomain *regd;
 449         unsigned int i;
 450
 451         regd = kzalloc(struct_size(regd, reg_rules, src_regd->n_reg_rules),
 452                        GFP_KERNEL);
 453         if (!regd)
 454                 return ERR_PTR(-ENOMEM);
 455
 456         memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
 457
 458         for (i = 0; i < src_regd->n_reg_rules; i++)
 459                 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
 460                        sizeof(struct ieee80211_reg_rule));
 461
 462         return regd;
 463 }
 464
 465 static void cfg80211_save_user_regdom(const struct ieee80211_regdomain *rd)
 466 {
 467         ASSERT_RTNL();
 468
 469         if (!IS_ERR(cfg80211_user_regdom))
 470                 kfree(cfg80211_user_regdom);
 471         cfg80211_user_regdom = reg_copy_regd(rd);
 472 }
 473
 474 struct reg_regdb_apply_request {
 475         struct list_head list;
 476         const struct ieee80211_regdomain *regdom;
 477 };
 478
 479 static LIST_HEAD(reg_regdb_apply_list);
 480 static DEFINE_MUTEX(reg_regdb_apply_mutex);
 481
 482 static void reg_regdb_apply(struct work_struct *work)
 483 {
 484         struct reg_regdb_apply_request *request;
 485
 486         rtnl_lock();
 487
 488         mutex_lock(&reg_regdb_apply_mutex);
 489         while (!list_empty(&reg_regdb_apply_list)) {
 490                 request = list_first_entry(&reg_regdb_apply_list,
 491                                            struct reg_regdb_apply_request,
 492                                            list);
 493                 list_del(&request->list);
 494
 495                 set_regdom(request->regdom, REGD_SOURCE_INTERNAL_DB);
 496                 kfree(request);
 497         }
 498         mutex_unlock(&reg_regdb_apply_mutex);
 499
 500         rtnl_unlock();
 501 }
 502
 503 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply);
 504
 505 static int reg_schedule_apply(const struct ieee80211_regdomain *regdom)
 506 {
 507         struct reg_regdb_apply_request *request;
 508
 509         request = kzalloc(sizeof(struct reg_regdb_apply_request), GFP_KERNEL);
 510         if (!request) {
 511                 kfree(regdom);
 512                 return -ENOMEM;
 513         }
 514
 515         request->regdom = regdom;
 516
 517         mutex_lock(&reg_regdb_apply_mutex);
 518         list_add_tail(&request->list, &reg_regdb_apply_list);
 519         mutex_unlock(&reg_regdb_apply_mutex);
 520
 521         schedule_work(&reg_regdb_work);
 522         return 0;
 523 }
 524
 525 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
 526 /* Max number of consecutive attempts to communicate with CRDA  */
 527 #define REG_MAX_CRDA_TIMEOUTS 10
 528
 529 static u32 reg_crda_timeouts;
 530
 531 static void crda_timeout_work(struct work_struct *work);
 532 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work);
 533
 534 static void crda_timeout_work(struct work_struct *work)
 535 {
 536         pr_debug("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
 537         rtnl_lock();
 538         reg_crda_timeouts++;
 539         restore_regulatory_settings(true, false);
 540         rtnl_unlock();
 541 }
 542
 543 static void cancel_crda_timeout(void)
 544 {
 545         cancel_delayed_work(&crda_timeout);
 546 }
 547
 548 static void cancel_crda_timeout_sync(void)
 549 {
 550         cancel_delayed_work_sync(&crda_timeout);
 551 }
 552
 553 static void reset_crda_timeouts(void)
 554 {
 555         reg_crda_timeouts = 0;
 556 }
 557
 558 /*
 559  * This lets us keep regulatory code which is updated on a regulatory
 560  * basis in userspace.
 561  */
 562 static int call_crda(const char *alpha2)
 563 {
 564         char country[12];
 565         char *env[] = { country, NULL };
 566         int ret;
 567
 568         snprintf(country, sizeof(country), "COUNTRY=%c%c",
 569                  alpha2[0], alpha2[1]);
 570
 571         if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
 572                 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
 573                 return -EINVAL;
 574         }
 575
 576         if (!is_world_regdom((char *) alpha2))
 577                 pr_debug("Calling CRDA for country: %c%c\n",
 578                          alpha2[0], alpha2[1]);
 579         else
 580                 pr_debug("Calling CRDA to update world regulatory domain\n");
 581
 582         ret = kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);
 583         if (ret)
 584                 return ret;
 585
 586         queue_delayed_work(system_power_efficient_wq,
 587                            &crda_timeout, msecs_to_jiffies(3142));
 588         return 0;
 589 }
 590 #else
 591 static inline void cancel_crda_timeout(void) {}
 592 static inline void cancel_crda_timeout_sync(void) {}
 593 static inline void reset_crda_timeouts(void) {}
 594 static inline int call_crda(const char *alpha2)
 595 {
 596         return -ENODATA;
 597 }
 598 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
 599
 600 /* code to directly load a firmware database through request_firmware */
 601 static const struct fwdb_header *regdb;
 602
 603 struct fwdb_country {
 604         u8 alpha2[2];
 605         __be16 coll_ptr;
 606         /* this struct cannot be extended */
 607 } __packed __aligned(4);
 608
 609 struct fwdb_collection {
 610         u8 len;
 611         u8 n_rules;
 612         u8 dfs_region;
 613         /* no optional data yet */
 614         /* aligned to 2, then followed by __be16 array of rule pointers */
 615 } __packed __aligned(4);
 616
 617 enum fwdb_flags {
 618         FWDB_FLAG_NO_OFDM       = BIT(0),
 619         FWDB_FLAG_NO_OUTDOOR    = BIT(1),
 620         FWDB_FLAG_DFS           = BIT(2),
 621         FWDB_FLAG_NO_IR         = BIT(3),
 622         FWDB_FLAG_AUTO_BW       = BIT(4),
 623 };
 624
 625 struct fwdb_wmm_ac {
 626         u8 ecw;
 627         u8 aifsn;
 628         __be16 cot;
 629 } __packed;
 630
 631 struct fwdb_wmm_rule {
 632         struct fwdb_wmm_ac client[IEEE80211_NUM_ACS];
 633         struct fwdb_wmm_ac ap[IEEE80211_NUM_ACS];
 634 } __packed;
 635
 636 struct fwdb_rule {
 637         u8 len;
 638         u8 flags;
 639         __be16 max_eirp;
 640         __be32 start, end, max_bw;
 641         /* start of optional data */
 642         __be16 cac_timeout;
 643         __be16 wmm_ptr;
 644 } __packed __aligned(4);
 645
 646 #define FWDB_MAGIC 0x52474442
 647 #define FWDB_VERSION 20
 648
 649 struct fwdb_header {
 650         __be32 magic;
 651         __be32 version;
 652         struct fwdb_country country[];
 653 } __packed __aligned(4);
 654
 655 static int ecw2cw(int ecw)
 656 {
 657         return (1 << ecw) - 1;
 658 }
 659
 660 static bool valid_wmm(struct fwdb_wmm_rule *rule)
 661 {
 662         struct fwdb_wmm_ac *ac = (struct fwdb_wmm_ac *)rule;
 663         int i;
 664
 665         for (i = 0; i < IEEE80211_NUM_ACS * 2; i++) {
 666                 u16 cw_min = ecw2cw((ac[i].ecw & 0xf0) >> 4);
 667                 u16 cw_max = ecw2cw(ac[i].ecw & 0x0f);
 668                 u8 aifsn = ac[i].aifsn;
 669
 670                 if (cw_min >= cw_max)
 671                         return false;
 672
 673                 if (aifsn < 1)
 674                         return false;
 675         }
 676
 677         return true;
 678 }
 679
 680 static bool valid_rule(const u8 *data, unsigned int size, u16 rule_ptr)
 681 {
 682         struct fwdb_rule *rule = (void *)(data + (rule_ptr << 2));
 683
 684         if ((u8 *)rule + sizeof(rule->len) > data + size)
 685                 return false;
 686
 687         /* mandatory fields */
 688         if (rule->len < offsetofend(struct fwdb_rule, max_bw))
 689                 return false;
 690         if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) {
 691                 u32 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
 692                 struct fwdb_wmm_rule *wmm;
 693
 694                 if (wmm_ptr + sizeof(struct fwdb_wmm_rule) > size)
 695                         return false;
 696
 697                 wmm = (void *)(data + wmm_ptr);
 698
 699                 if (!valid_wmm(wmm))
 700                         return false;
 701         }
 702         return true;
 703 }
 704
 705 static bool valid_country(const u8 *data, unsigned int size,
 706                           const struct fwdb_country *country)
 707 {
 708         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
 709         struct fwdb_collection *coll = (void *)(data + ptr);
 710         __be16 *rules_ptr;
 711         unsigned int i;
 712
 713         /* make sure we can read len/n_rules */
 714         if ((u8 *)coll + offsetofend(typeof(*coll), n_rules) > data + size)
 715                 return false;
 716
 717         /* make sure base struct and all rules fit */
 718         if ((u8 *)coll + ALIGN(coll->len, 2) +
 719             (coll->n_rules * 2) > data + size)
 720                 return false;
 721
 722         /* mandatory fields must exist */
 723         if (coll->len < offsetofend(struct fwdb_collection, dfs_region))
 724                 return false;
 725
 726         rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
 727
 728         for (i = 0; i < coll->n_rules; i++) {
 729                 u16 rule_ptr = be16_to_cpu(rules_ptr[i]);
 730
 731                 if (!valid_rule(data, size, rule_ptr))
 732                         return false;
 733         }
 734
 735         return true;
 736 }
 737
 738 #ifdef CONFIG_CFG80211_REQUIRE_SIGNED_REGDB
 739 static struct key *builtin_regdb_keys;
 740
 741 static void __init load_keys_from_buffer(const u8 *p, unsigned int buflen)
 742 {
 743         const u8 *end = p + buflen;
 744         size_t plen;
 745         key_ref_t key;
 746
 747         while (p < end) {
 748                 /* Each cert begins with an ASN.1 SEQUENCE tag and must be more
 749                  * than 256 bytes in size.
 750                  */
 751                 if (end - p < 4)
 752                         goto dodgy_cert;
 753                 if (p[0] != 0x30 &&
 754                     p[1] != 0x82)
 755                         goto dodgy_cert;
 756                 plen = (p[2] << 8) | p[3];
 757                 plen += 4;
 758                 if (plen > end - p)
 759                         goto dodgy_cert;
 760
 761                 key = key_create_or_update(make_key_ref(builtin_regdb_keys, 1),
 762                                            "asymmetric", NULL, p, plen,
 763                                            ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
 764                                             KEY_USR_VIEW | KEY_USR_READ),
 765                                            KEY_ALLOC_NOT_IN_QUOTA |
 766                                            KEY_ALLOC_BUILT_IN |
 767                                            KEY_ALLOC_BYPASS_RESTRICTION);
 768                 if (IS_ERR(key)) {
 769                         pr_err("Problem loading in-kernel X.509 certificate (%ld)\n",
 770                                PTR_ERR(key));
 771                 } else {
 772                         pr_notice("Loaded X.509 cert '%s'\n",
 773                                   key_ref_to_ptr(key)->description);
 774                         key_ref_put(key);
 775                 }
 776                 p += plen;
 777         }
 778
 779         return;
 780
 781 dodgy_cert:
 782         pr_err("Problem parsing in-kernel X.509 certificate list\n");
 783 }
 784
 785 static int __init load_builtin_regdb_keys(void)
 786 {
 787         builtin_regdb_keys =
 788                 keyring_alloc(".builtin_regdb_keys",
 789                               KUIDT_INIT(0), KGIDT_INIT(0), current_cred(),
 790                               ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
 791                               KEY_USR_VIEW | KEY_USR_READ | KEY_USR_SEARCH),
 792                               KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
 793         if (IS_ERR(builtin_regdb_keys))
 794                 return PTR_ERR(builtin_regdb_keys);
 795
 796         pr_notice("Loading compiled-in X.509 certificates for regulatory database\n");
 797
 798 #ifdef CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS
 799         load_keys_from_buffer(shipped_regdb_certs, shipped_regdb_certs_len);
 800 #endif
 801 #ifdef CONFIG_CFG80211_EXTRA_REGDB_KEYDIR
 802         if (CONFIG_CFG80211_EXTRA_REGDB_KEYDIR[0] != '\0')
 803                 load_keys_from_buffer(extra_regdb_certs, extra_regdb_certs_len);
 804 #endif
 805
 806         return 0;
 807 }
 808
 809 MODULE_FIRMWARE("regulatory.db.p7s");
 810
 811 static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
 812 {
 813         const struct firmware *sig;
 814         bool result;
 815
 816         if (request_firmware(&sig, "regulatory.db.p7s", &reg_pdev->dev))
 817                 return false;
 818
 819         result = verify_pkcs7_signature(data, size, sig->data, sig->size,
 820                                         builtin_regdb_keys,
 821                                         VERIFYING_UNSPECIFIED_SIGNATURE,
 822                                         NULL, NULL) == 0;
 823
 824         release_firmware(sig);
 825
 826         return result;
 827 }
 828
 829 static void free_regdb_keyring(void)
 830 {
 831         key_put(builtin_regdb_keys);
 832 }
 833 #else
 834 static int load_builtin_regdb_keys(void)
 835 {
 836         return 0;
 837 }
 838
 839 static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
 840 {
 841         return true;
 842 }
 843
 844 static void free_regdb_keyring(void)
 845 {
 846 }
 847 #endif /* CONFIG_CFG80211_REQUIRE_SIGNED_REGDB */
 848
 849 static bool valid_regdb(const u8 *data, unsigned int size)
 850 {
 851         const struct fwdb_header *hdr = (void *)data;
 852         const struct fwdb_country *country;
 853
 854         if (size < sizeof(*hdr))
 855                 return false;
 856
 857         if (hdr->magic != cpu_to_be32(FWDB_MAGIC))
 858                 return false;
 859
 860         if (hdr->version != cpu_to_be32(FWDB_VERSION))
 861                 return false;
 862
 863         if (!regdb_has_valid_signature(data, size))
 864                 return false;
 865
 866         country = &hdr->country[0];
 867         while ((u8 *)(country + 1) <= data + size) {
 868                 if (!country->coll_ptr)
 869                         break;
 870                 if (!valid_country(data, size, country))
 871                         return false;
 872                 country++;
 873         }
 874
 875         return true;
 876 }
 877
 878 static void set_wmm_rule(const struct fwdb_header *db,
 879                          const struct fwdb_country *country,
 880                          const struct fwdb_rule *rule,
 881                          struct ieee80211_reg_rule *rrule)
 882 {
 883         struct ieee80211_wmm_rule *wmm_rule = &rrule->wmm_rule;
 884         struct fwdb_wmm_rule *wmm;
 885         unsigned int i, wmm_ptr;
 886
 887         wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
 888         wmm = (void *)((u8 *)db + wmm_ptr);
 889
 890         if (!valid_wmm(wmm)) {
 891                 pr_err("Invalid regulatory WMM rule %u-%u in domain %c%c\n",
 892                        be32_to_cpu(rule->start), be32_to_cpu(rule->end),
 893                        country->alpha2[0], country->alpha2[1]);
 894                 return;
 895         }
 896
 897         for (i = 0; i < IEEE80211_NUM_ACS; i++) {
 898                 wmm_rule->client[i].cw_min =
 899                         ecw2cw((wmm->client[i].ecw & 0xf0) >> 4);
 900                 wmm_rule->client[i].cw_max = ecw2cw(wmm->client[i].ecw & 0x0f);
 901                 wmm_rule->client[i].aifsn =  wmm->client[i].aifsn;
 902                 wmm_rule->client[i].cot =
 903                         1000 * be16_to_cpu(wmm->client[i].cot);
 904                 wmm_rule->ap[i].cw_min = ecw2cw((wmm->ap[i].ecw & 0xf0) >> 4);
 905                 wmm_rule->ap[i].cw_max = ecw2cw(wmm->ap[i].ecw & 0x0f);
 906                 wmm_rule->ap[i].aifsn = wmm->ap[i].aifsn;
 907                 wmm_rule->ap[i].cot = 1000 * be16_to_cpu(wmm->ap[i].cot);
 908         }
 909
 910         rrule->has_wmm = true;
 911 }
 912
 913 static int __regdb_query_wmm(const struct fwdb_header *db,
 914                              const struct fwdb_country *country, int freq,
 915                              struct ieee80211_reg_rule *rrule)
 916 {
 917         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
 918         struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
 919         int i;
 920
 921         for (i = 0; i < coll->n_rules; i++) {
 922                 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
 923                 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
 924                 struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr);
 925
 926                 if (rule->len < offsetofend(struct fwdb_rule, wmm_ptr))
 927                         continue;
 928
 929                 if (freq >= KHZ_TO_MHZ(be32_to_cpu(rule->start)) &&
 930                     freq <= KHZ_TO_MHZ(be32_to_cpu(rule->end))) {
 931                         set_wmm_rule(db, country, rule, rrule);
 932                         return 0;
 933                 }
 934         }
 935
 936         return -ENODATA;
 937 }
 938
 939 int reg_query_regdb_wmm(char *alpha2, int freq, struct ieee80211_reg_rule *rule)
 940 {
 941         const struct fwdb_header *hdr = regdb;
 942         const struct fwdb_country *country;
 943
 944         if (!regdb)
 945                 return -ENODATA;
 946
 947         if (IS_ERR(regdb))
 948                 return PTR_ERR(regdb);
 949
 950         country = &hdr->country[0];
 951         while (country->coll_ptr) {
 952                 if (alpha2_equal(alpha2, country->alpha2))
 953                         return __regdb_query_wmm(regdb, country, freq, rule);
 954
 955                 country++;
 956         }
 957
 958         return -ENODATA;
 959 }
 960 EXPORT_SYMBOL(reg_query_regdb_wmm);
 961
 962 static int regdb_query_country(const struct fwdb_header *db,
 963                                const struct fwdb_country *country)
 964 {
 965         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
 966         struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
 967         struct ieee80211_regdomain *regdom;
 968         unsigned int i;
 969
 970         regdom = kzalloc(struct_size(regdom, reg_rules, coll->n_rules),
 971                          GFP_KERNEL);
 972         if (!regdom)
 973                 return -ENOMEM;
 974
 975         regdom->n_reg_rules = coll->n_rules;
 976         regdom->alpha2[0] = country->alpha2[0];
 977         regdom->alpha2[1] = country->alpha2[1];
 978         regdom->dfs_region = coll->dfs_region;
 979
 980         for (i = 0; i < regdom->n_reg_rules; i++) {
 981                 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
 982                 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
 983                 struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr);
 984                 struct ieee80211_reg_rule *rrule = &regdom->reg_rules[i];
 985
 986                 rrule->freq_range.start_freq_khz = be32_to_cpu(rule->start);
 987                 rrule->freq_range.end_freq_khz = be32_to_cpu(rule->end);
 988                 rrule->freq_range.max_bandwidth_khz = be32_to_cpu(rule->max_bw);
 989
 990                 rrule->power_rule.max_antenna_gain = 0;
 991                 rrule->power_rule.max_eirp = be16_to_cpu(rule->max_eirp);
 992
 993                 rrule->flags = 0;
 994                 if (rule->flags & FWDB_FLAG_NO_OFDM)
 995                         rrule->flags |= NL80211_RRF_NO_OFDM;
 996                 if (rule->flags & FWDB_FLAG_NO_OUTDOOR)
 997                         rrule->flags |= NL80211_RRF_NO_OUTDOOR;
 998                 if (rule->flags & FWDB_FLAG_DFS)
 999                         rrule->flags |= NL80211_RRF_DFS;
1000                 if (rule->flags & FWDB_FLAG_NO_IR)
1001                         rrule->flags |= NL80211_RRF_NO_IR;
1002                 if (rule->flags & FWDB_FLAG_AUTO_BW)
1003                         rrule->flags |= NL80211_RRF_AUTO_BW;
1004
1005                 rrule->dfs_cac_ms = 0;
1006
1007                 /* handle optional data */
1008                 if (rule->len >= offsetofend(struct fwdb_rule, cac_timeout))
1009                         rrule->dfs_cac_ms =
1010                                 1000 * be16_to_cpu(rule->cac_timeout);
1011                 if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr))
1012                         set_wmm_rule(db, country, rule, rrule);
1013         }
1014
1015         return reg_schedule_apply(regdom);
1016 }
1017
1018 static int query_regdb(const char *alpha2)
1019 {
1020         const struct fwdb_header *hdr = regdb;
1021         const struct fwdb_country *country;
1022
1023         ASSERT_RTNL();
1024
1025         if (IS_ERR(regdb))
1026                 return PTR_ERR(regdb);
1027
1028         country = &hdr->country[0];
1029         while (country->coll_ptr) {
1030                 if (alpha2_equal(alpha2, country->alpha2))
1031                         return regdb_query_country(regdb, country);
1032                 country++;
1033         }
1034
1035         return -ENODATA;
1036 }
1037
1038 static void regdb_fw_cb(const struct firmware *fw, void *context)
1039 {
1040         int set_error = 0;
1041         bool restore = true;
1042         void *db;
1043
1044         if (!fw) {
1045                 pr_info("failed to load regulatory.db\n");
1046                 set_error = -ENODATA;
1047         } else if (!valid_regdb(fw->data, fw->size)) {
1048                 pr_info("loaded regulatory.db is malformed or signature is missing/invalid\n");
1049                 set_error = -EINVAL;
1050         }
1051
1052         rtnl_lock();
1053         if (regdb && !IS_ERR(regdb)) {
1054                 /* negative case - a bug
1055                  * positive case - can happen due to race in case of multiple cb's in
1056                  * queue, due to usage of asynchronous callback
1057                  *
1058                  * Either case, just restore and free new db.
1059                  */
1060         } else if (set_error) {
1061                 regdb = ERR_PTR(set_error);
1062         } else if (fw) {
1063                 db = kmemdup(fw->data, fw->size, GFP_KERNEL);
1064                 if (db) {
1065                         regdb = db;
1066                         restore = context && query_regdb(context);
1067                 } else {
1068                         restore = true;
1069                 }
1070         }
1071
1072         if (restore)
1073                 restore_regulatory_settings(true, false);
1074
1075         rtnl_unlock();
1076
1077         kfree(context);
1078
1079         release_firmware(fw);
1080 }
1081
1082 MODULE_FIRMWARE("regulatory.db");
1083
1084 static int query_regdb_file(const char *alpha2)
1085 {
1086         int err;
1087
1088         ASSERT_RTNL();
1089
1090         if (regdb)
1091                 return query_regdb(alpha2);
1092
1093         alpha2 = kmemdup(alpha2, 2, GFP_KERNEL);
1094         if (!alpha2)
1095                 return -ENOMEM;
1096
1097         err = request_firmware_nowait(THIS_MODULE, true, "regulatory.db",
1098                                       &reg_pdev->dev, GFP_KERNEL,
1099                                       (void *)alpha2, regdb_fw_cb);
1100         if (err)
1101                 kfree(alpha2);
1102
1103         return err;
1104 }
1105
1106 int reg_reload_regdb(void)
1107 {
1108         const struct firmware *fw;
1109         void *db;
1110         int err;
1111
1112         err = request_firmware(&fw, "regulatory.db", &reg_pdev->dev);
1113         if (err)
1114                 return err;
1115
1116         if (!valid_regdb(fw->data, fw->size)) {
1117                 err = -ENODATA;
1118                 goto out;
1119         }
1120
1121         db = kmemdup(fw->data, fw->size, GFP_KERNEL);
1122         if (!db) {
1123                 err = -ENOMEM;
1124                 goto out;
1125         }
1126
1127         rtnl_lock();
1128         if (!IS_ERR_OR_NULL(regdb))
1129                 kfree(regdb);
1130         regdb = db;
1131         rtnl_unlock();
1132
1133  out:
1134         release_firmware(fw);
1135         return err;
1136 }
1137
1138 static bool reg_query_database(struct regulatory_request *request)
1139 {
1140         if (query_regdb_file(request->alpha2) == 0)
1141                 return true;
1142
1143         if (call_crda(request->alpha2) == 0)
1144                 return true;
1145
1146         return false;
1147 }
1148
1149 bool reg_is_valid_request(const char *alpha2)
1150 {
1151         struct regulatory_request *lr = get_last_request();
1152
1153         if (!lr || lr->processed)
1154                 return false;
1155
1156         return alpha2_equal(lr->alpha2, alpha2);
1157 }
1158
1159 static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
1160 {
1161         struct regulatory_request *lr = get_last_request();
1162
1163         /*
1164          * Follow the driver's regulatory domain, if present, unless a country
1165          * IE has been processed or a user wants to help complaince further
1166          */
1167         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1168             lr->initiator != NL80211_REGDOM_SET_BY_USER &&
1169             wiphy->regd)
1170                 return get_wiphy_regdom(wiphy);
1171
1172         return get_cfg80211_regdom();
1173 }
1174
1175 static unsigned int
1176 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
1177                                  const struct ieee80211_reg_rule *rule)
1178 {
1179         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1180         const struct ieee80211_freq_range *freq_range_tmp;
1181         const struct ieee80211_reg_rule *tmp;
1182         u32 start_freq, end_freq, idx, no;
1183
1184         for (idx = 0; idx < rd->n_reg_rules; idx++)
1185                 if (rule == &rd->reg_rules[idx])
1186                         break;
1187
1188         if (idx == rd->n_reg_rules)
1189                 return 0;
1190
1191         /* get start_freq */
1192         no = idx;
1193
1194         while (no) {
1195                 tmp = &rd->reg_rules[--no];
1196                 freq_range_tmp = &tmp->freq_range;
1197
1198                 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
1199                         break;
1200
1201                 freq_range = freq_range_tmp;
1202         }
1203
1204         start_freq = freq_range->start_freq_khz;
1205
1206         /* get end_freq */
1207         freq_range = &rule->freq_range;
1208         no = idx;
1209
1210         while (no < rd->n_reg_rules - 1) {
1211                 tmp = &rd->reg_rules[++no];
1212                 freq_range_tmp = &tmp->freq_range;
1213
1214                 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
1215                         break;
1216
1217                 freq_range = freq_range_tmp;
1218         }
1219
1220         end_freq = freq_range->end_freq_khz;
1221
1222         return end_freq - start_freq;
1223 }
1224
1225 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
1226                                    const struct ieee80211_reg_rule *rule)
1227 {
1228         unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
1229
1230         if (rule->flags & NL80211_RRF_NO_160MHZ)
1231                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
1232         if (rule->flags & NL80211_RRF_NO_80MHZ)
1233                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
1234
1235         /*
1236          * HT40+/HT40- limits are handled per-channel. Only limit BW if both
1237          * are not allowed.
1238          */
1239         if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
1240             rule->flags & NL80211_RRF_NO_HT40PLUS)
1241                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
1242
1243         return bw;
1244 }
1245
1246 /* Sanity check on a regulatory rule */
1247 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
1248 {
1249         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1250         u32 freq_diff;
1251
1252         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
1253                 return false;
1254
1255         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
1256                 return false;
1257
1258         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1259
1260         if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
1261             freq_range->max_bandwidth_khz > freq_diff)
1262                 return false;
1263
1264         return true;
1265 }
1266
1267 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
1268 {
1269         const struct ieee80211_reg_rule *reg_rule = NULL;
1270         unsigned int i;
1271
1272         if (!rd->n_reg_rules)
1273                 return false;
1274
1275         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
1276                 return false;
1277
1278         for (i = 0; i < rd->n_reg_rules; i++) {
1279                 reg_rule = &rd->reg_rules[i];
1280                 if (!is_valid_reg_rule(reg_rule))
1281                         return false;
1282         }
1283
1284         return true;
1285 }
1286
1287 /**
1288  * freq_in_rule_band - tells us if a frequency is in a frequency band
1289  * @freq_range: frequency rule we want to query
1290  * @freq_khz: frequency we are inquiring about
1291  *
1292  * This lets us know if a specific frequency rule is or is not relevant to
1293  * a specific frequency's band. Bands are device specific and artificial
1294  * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
1295  * however it is safe for now to assume that a frequency rule should not be
1296  * part of a frequency's band if the start freq or end freq are off by more
1297  * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 20 GHz for the
1298  * 60 GHz band.
1299  * This resolution can be lowered and should be considered as we add
1300  * regulatory rule support for other "bands".
1301  **/
1302 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
1303                               u32 freq_khz)
1304 {
1305 #define ONE_GHZ_IN_KHZ  1000000
1306         /*
1307          * From 802.11ad: directional multi-gigabit (DMG):
1308          * Pertaining to operation in a frequency band containing a channel
1309          * with the Channel starting frequency above 45 GHz.
1310          */
1311         u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
1312                         20 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
1313         if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
1314                 return true;
1315         if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
1316                 return true;
1317         return false;
1318 #undef ONE_GHZ_IN_KHZ
1319 }
1320
1321 /*
1322  * Later on we can perhaps use the more restrictive DFS
1323  * region but we don't have information for that yet so
1324  * for now simply disallow conflicts.
1325  */
1326 static enum nl80211_dfs_regions
1327 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
1328                          const enum nl80211_dfs_regions dfs_region2)
1329 {
1330         if (dfs_region1 != dfs_region2)
1331                 return NL80211_DFS_UNSET;
1332         return dfs_region1;
1333 }
1334
1335 static void reg_wmm_rules_intersect(const struct ieee80211_wmm_ac *wmm_ac1,
1336                                     const struct ieee80211_wmm_ac *wmm_ac2,
1337                                     struct ieee80211_wmm_ac *intersect)
1338 {
1339         intersect->cw_min = max_t(u16, wmm_ac1->cw_min, wmm_ac2->cw_min);
1340         intersect->cw_max = max_t(u16, wmm_ac1->cw_max, wmm_ac2->cw_max);
1341         intersect->cot = min_t(u16, wmm_ac1->cot, wmm_ac2->cot);
1342         intersect->aifsn = max_t(u8, wmm_ac1->aifsn, wmm_ac2->aifsn);
1343 }
1344
1345 /*
1346  * Helper for regdom_intersect(), this does the real
1347  * mathematical intersection fun
1348  */
1349 static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
1350                                const struct ieee80211_regdomain *rd2,
1351                                const struct ieee80211_reg_rule *rule1,
1352                                const struct ieee80211_reg_rule *rule2,
1353                                struct ieee80211_reg_rule *intersected_rule)
1354 {
1355         const struct ieee80211_freq_range *freq_range1, *freq_range2;
1356         struct ieee80211_freq_range *freq_range;
1357         const struct ieee80211_power_rule *power_rule1, *power_rule2;
1358         struct ieee80211_power_rule *power_rule;
1359         const struct ieee80211_wmm_rule *wmm_rule1, *wmm_rule2;
1360         struct ieee80211_wmm_rule *wmm_rule;
1361         u32 freq_diff, max_bandwidth1, max_bandwidth2;
1362
1363         freq_range1 = &rule1->freq_range;
1364         freq_range2 = &rule2->freq_range;
1365         freq_range = &intersected_rule->freq_range;
1366
1367         power_rule1 = &rule1->power_rule;
1368         power_rule2 = &rule2->power_rule;
1369         power_rule = &intersected_rule->power_rule;
1370
1371         wmm_rule1 = &rule1->wmm_rule;
1372         wmm_rule2 = &rule2->wmm_rule;
1373         wmm_rule = &intersected_rule->wmm_rule;
1374
1375         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
1376                                          freq_range2->start_freq_khz);
1377         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
1378                                        freq_range2->end_freq_khz);
1379
1380         max_bandwidth1 = freq_range1->max_bandwidth_khz;
1381         max_bandwidth2 = freq_range2->max_bandwidth_khz;
1382
1383         if (rule1->flags & NL80211_RRF_AUTO_BW)
1384                 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
1385         if (rule2->flags & NL80211_RRF_AUTO_BW)
1386                 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
1387
1388         freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
1389
1390         intersected_rule->flags = rule1->flags | rule2->flags;
1391
1392         /*
1393          * In case NL80211_RRF_AUTO_BW requested for both rules
1394          * set AUTO_BW in intersected rule also. Next we will
1395          * calculate BW correctly in handle_channel function.
1396          * In other case remove AUTO_BW flag while we calculate
1397          * maximum bandwidth correctly and auto calculation is
1398          * not required.
1399          */
1400         if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
1401             (rule2->flags & NL80211_RRF_AUTO_BW))
1402                 intersected_rule->flags |= NL80211_RRF_AUTO_BW;
1403         else
1404                 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
1405
1406         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1407         if (freq_range->max_bandwidth_khz > freq_diff)
1408                 freq_range->max_bandwidth_khz = freq_diff;
1409
1410         power_rule->max_eirp = min(power_rule1->max_eirp,
1411                 power_rule2->max_eirp);
1412         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
1413                 power_rule2->max_antenna_gain);
1414
1415         intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms,
1416                                            rule2->dfs_cac_ms);
1417
1418         if (rule1->has_wmm && rule2->has_wmm) {
1419                 u8 ac;
1420
1421                 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1422                         reg_wmm_rules_intersect(&wmm_rule1->client[ac],
1423                                                 &wmm_rule2->client[ac],
1424                                                 &wmm_rule->client[ac]);
1425                         reg_wmm_rules_intersect(&wmm_rule1->ap[ac],
1426                                                 &wmm_rule2->ap[ac],
1427                                                 &wmm_rule->ap[ac]);
1428                 }
1429
1430                 intersected_rule->has_wmm = true;
1431         } else if (rule1->has_wmm) {
1432                 *wmm_rule = *wmm_rule1;
1433                 intersected_rule->has_wmm = true;
1434         } else if (rule2->has_wmm) {
1435                 *wmm_rule = *wmm_rule2;
1436                 intersected_rule->has_wmm = true;
1437         } else {
1438                 intersected_rule->has_wmm = false;
1439         }
1440
1441         if (!is_valid_reg_rule(intersected_rule))
1442                 return -EINVAL;
1443
1444         return 0;
1445 }
1446
1447 /* check whether old rule contains new rule */
1448 static bool rule_contains(struct ieee80211_reg_rule *r1,
1449                           struct ieee80211_reg_rule *r2)
1450 {
1451         /* for simplicity, currently consider only same flags */
1452         if (r1->flags != r2->flags)
1453                 return false;
1454
1455         /* verify r1 is more restrictive */
1456         if ((r1->power_rule.max_antenna_gain >
1457              r2->power_rule.max_antenna_gain) ||
1458             r1->power_rule.max_eirp > r2->power_rule.max_eirp)
1459                 return false;
1460
1461         /* make sure r2's range is contained within r1 */
1462         if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz ||
1463             r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz)
1464                 return false;
1465
1466         /* and finally verify that r1.max_bw >= r2.max_bw */
1467         if (r1->freq_range.max_bandwidth_khz <
1468             r2->freq_range.max_bandwidth_khz)
1469                 return false;
1470
1471         return true;
1472 }
1473
1474 /* add or extend current rules. do nothing if rule is already contained */
1475 static void add_rule(struct ieee80211_reg_rule *rule,
1476                      struct ieee80211_reg_rule *reg_rules, u32 *n_rules)
1477 {
1478         struct ieee80211_reg_rule *tmp_rule;
1479         int i;
1480
1481         for (i = 0; i < *n_rules; i++) {
1482                 tmp_rule = &reg_rules[i];
1483                 /* rule is already contained - do nothing */
1484                 if (rule_contains(tmp_rule, rule))
1485                         return;
1486
1487                 /* extend rule if possible */
1488                 if (rule_contains(rule, tmp_rule)) {
1489                         memcpy(tmp_rule, rule, sizeof(*rule));
1490                         return;
1491                 }
1492         }
1493
1494         memcpy(&reg_rules[*n_rules], rule, sizeof(*rule));
1495         (*n_rules)++;
1496 }
1497
1498 /**
1499  * regdom_intersect - do the intersection between two regulatory domains
1500  * @rd1: first regulatory domain
1501  * @rd2: second regulatory domain
1502  *
1503  * Use this function to get the intersection between two regulatory domains.
1504  * Once completed we will mark the alpha2 for the rd as intersected, "98",
1505  * as no one single alpha2 can represent this regulatory domain.
1506  *
1507  * Returns a pointer to the regulatory domain structure which will hold the
1508  * resulting intersection of rules between rd1 and rd2. We will
1509  * kzalloc() this structure for you.
1510  */
1511 static struct ieee80211_regdomain *
1512 regdom_intersect(const struct ieee80211_regdomain *rd1,
1513                  const struct ieee80211_regdomain *rd2)
1514 {
1515         int r;
1516         unsigned int x, y;
1517         unsigned int num_rules = 0;
1518         const struct ieee80211_reg_rule *rule1, *rule2;
1519         struct ieee80211_reg_rule intersected_rule;
1520         struct ieee80211_regdomain *rd;
1521
1522         if (!rd1 || !rd2)
1523                 return NULL;
1524
1525         /*
1526          * First we get a count of the rules we'll need, then we actually
1527          * build them. This is to so we can malloc() and free() a
1528          * regdomain once. The reason we use reg_rules_intersect() here
1529          * is it will return -EINVAL if the rule computed makes no sense.
1530          * All rules that do check out OK are valid.
1531          */
1532
1533         for (x = 0; x < rd1->n_reg_rules; x++) {
1534                 rule1 = &rd1->reg_rules[x];
1535                 for (y = 0; y < rd2->n_reg_rules; y++) {
1536                         rule2 = &rd2->reg_rules[y];
1537                         if (!reg_rules_intersect(rd1, rd2, rule1, rule2,
1538                                                  &intersected_rule))
1539                                 num_rules++;
1540                 }
1541         }
1542
1543         if (!num_rules)
1544                 return NULL;
1545
1546         rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
1547         if (!rd)
1548                 return NULL;
1549
1550         for (x = 0; x < rd1->n_reg_rules; x++) {
1551                 rule1 = &rd1->reg_rules[x];
1552                 for (y = 0; y < rd2->n_reg_rules; y++) {
1553                         rule2 = &rd2->reg_rules[y];
1554                         r = reg_rules_intersect(rd1, rd2, rule1, rule2,
1555                                                 &intersected_rule);
1556                         /*
1557                          * No need to memset here the intersected rule here as
1558                          * we're not using the stack anymore
1559                          */
1560                         if (r)
1561                                 continue;
1562
1563                         add_rule(&intersected_rule, rd->reg_rules,
1564                                  &rd->n_reg_rules);
1565                 }
1566         }
1567
1568         rd->alpha2[0] = '9';
1569         rd->alpha2[1] = '8';
1570         rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region,
1571                                                   rd2->dfs_region);
1572
1573         return rd;
1574 }
1575
1576 /*
1577  * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
1578  * want to just have the channel structure use these
1579  */
1580 static u32 map_regdom_flags(u32 rd_flags)
1581 {
1582         u32 channel_flags = 0;
1583         if (rd_flags & NL80211_RRF_NO_IR_ALL)
1584                 channel_flags |= IEEE80211_CHAN_NO_IR;
1585         if (rd_flags & NL80211_RRF_DFS)
1586                 channel_flags |= IEEE80211_CHAN_RADAR;
1587         if (rd_flags & NL80211_RRF_NO_OFDM)
1588                 channel_flags |= IEEE80211_CHAN_NO_OFDM;
1589         if (rd_flags & NL80211_RRF_NO_OUTDOOR)
1590                 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
1591         if (rd_flags & NL80211_RRF_IR_CONCURRENT)
1592                 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT;
1593         if (rd_flags & NL80211_RRF_NO_HT40MINUS)
1594                 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
1595         if (rd_flags & NL80211_RRF_NO_HT40PLUS)
1596                 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
1597         if (rd_flags & NL80211_RRF_NO_80MHZ)
1598                 channel_flags |= IEEE80211_CHAN_NO_80MHZ;
1599         if (rd_flags & NL80211_RRF_NO_160MHZ)
1600                 channel_flags |= IEEE80211_CHAN_NO_160MHZ;
1601         if (rd_flags & NL80211_RRF_NO_HE)
1602                 channel_flags |= IEEE80211_CHAN_NO_HE;
1603         return channel_flags;
1604 }
1605
1606 static const struct ieee80211_reg_rule *
1607 freq_reg_info_regd(u32 center_freq,
1608                    const struct ieee80211_regdomain *regd, u32 bw)
1609 {
1610         int i;
1611         bool band_rule_found = false;
1612         bool bw_fits = false;
1613
1614         if (!regd)
1615                 return ERR_PTR(-EINVAL);
1616
1617         for (i = 0; i < regd->n_reg_rules; i++) {
1618                 const struct ieee80211_reg_rule *rr;
1619                 const struct ieee80211_freq_range *fr = NULL;
1620
1621                 rr = &regd->reg_rules[i];
1622                 fr = &rr->freq_range;
1623
1624                 /*
1625                  * We only need to know if one frequency rule was
1626                  * in center_freq's band, that's enough, so let's
1627                  * not overwrite it once found
1628                  */
1629                 if (!band_rule_found)
1630                         band_rule_found = freq_in_rule_band(fr, center_freq);
1631
1632                 bw_fits = cfg80211_does_bw_fit_range(fr, center_freq, bw);
1633
1634                 if (band_rule_found && bw_fits)
1635                         return rr;
1636         }
1637
1638         if (!band_rule_found)
1639                 return ERR_PTR(-ERANGE);
1640
1641         return ERR_PTR(-EINVAL);
1642 }
1643
1644 static const struct ieee80211_reg_rule *
1645 __freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw)
1646 {
1647         const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy);
1648         static const u32 bws[] = {0, 1, 2, 4, 5, 8, 10, 16, 20};
1649         const struct ieee80211_reg_rule *reg_rule = ERR_PTR(-ERANGE);
1650         int i = ARRAY_SIZE(bws) - 1;
1651         u32 bw;
1652
1653         for (bw = MHZ_TO_KHZ(bws[i]); bw >= min_bw; bw = MHZ_TO_KHZ(bws[i--])) {
1654                 reg_rule = freq_reg_info_regd(center_freq, regd, bw);
1655                 if (!IS_ERR(reg_rule))
1656                         return reg_rule;
1657         }
1658
1659         return reg_rule;
1660 }
1661
1662 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
1663                                                u32 center_freq)
1664 {
1665         u32 min_bw = center_freq < MHZ_TO_KHZ(1000) ? 1 : 20;
1666
1667         return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(min_bw));
1668 }
1669 EXPORT_SYMBOL(freq_reg_info);
1670
1671 const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
1672 {
1673         switch (initiator) {
1674         case NL80211_REGDOM_SET_BY_CORE:
1675                 return "core";
1676         case NL80211_REGDOM_SET_BY_USER:
1677                 return "user";
1678         case NL80211_REGDOM_SET_BY_DRIVER:
1679                 return "driver";
1680         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1681                 return "country element";
1682         default:
1683                 WARN_ON(1);
1684                 return "bug";
1685         }
1686 }
1687 EXPORT_SYMBOL(reg_initiator_name);
1688
1689 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd,
1690                                           const struct ieee80211_reg_rule *reg_rule,
1691                                           const struct ieee80211_channel *chan)
1692 {
1693         const struct ieee80211_freq_range *freq_range = NULL;
1694         u32 max_bandwidth_khz, center_freq_khz, bw_flags = 0;
1695         bool is_s1g = chan->band == NL80211_BAND_S1GHZ;
1696
1697         freq_range = &reg_rule->freq_range;
1698
1699         max_bandwidth_khz = freq_range->max_bandwidth_khz;
1700         center_freq_khz = ieee80211_channel_to_khz(chan);
1701         /* Check if auto calculation requested */
1702         if (reg_rule->flags & NL80211_RRF_AUTO_BW)
1703                 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
1704
1705         /* If we get a reg_rule we can assume that at least 5Mhz fit */
1706         if (!cfg80211_does_bw_fit_range(freq_range,
1707                                         center_freq_khz,
1708                                         MHZ_TO_KHZ(10)))
1709                 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1710         if (!cfg80211_does_bw_fit_range(freq_range,
1711                                         center_freq_khz,
1712                                         MHZ_TO_KHZ(20)))
1713                 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1714
1715         if (is_s1g) {
1716                 /* S1G is strict about non overlapping channels. We can
1717                  * calculate which bandwidth is allowed per channel by finding
1718                  * the largest bandwidth which cleanly divides the freq_range.
1719                  */
1720                 int edge_offset;
1721                 int ch_bw = max_bandwidth_khz;
1722
1723                 while (ch_bw) {
1724                         edge_offset = (center_freq_khz - ch_bw / 2) -
1725                                       freq_range->start_freq_khz;
1726                         if (edge_offset % ch_bw == 0) {
1727                                 switch (KHZ_TO_MHZ(ch_bw)) {
1728                                 case 1:
1729                                         bw_flags |= IEEE80211_CHAN_1MHZ;
1730                                         break;
1731                                 case 2:
1732                                         bw_flags |= IEEE80211_CHAN_2MHZ;
1733                                         break;
1734                                 case 4:
1735                                         bw_flags |= IEEE80211_CHAN_4MHZ;
1736                                         break;
1737                                 case 8:
1738                                         bw_flags |= IEEE80211_CHAN_8MHZ;
1739                                         break;
1740                                 case 16:
1741                                         bw_flags |= IEEE80211_CHAN_16MHZ;
1742                                         break;
1743                                 default:
1744                                         /* If we got here, no bandwidths fit on
1745                                          * this frequency, ie. band edge.
1746                                          */
1747                                         bw_flags |= IEEE80211_CHAN_DISABLED;
1748                                         break;
1749                                 }
1750                                 break;
1751                         }
1752                         ch_bw /= 2;
1753                 }
1754         } else {
1755                 if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1756                         bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1757                 if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1758                         bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1759                 if (max_bandwidth_khz < MHZ_TO_KHZ(40))
1760                         bw_flags |= IEEE80211_CHAN_NO_HT40;
1761                 if (max_bandwidth_khz < MHZ_TO_KHZ(80))
1762                         bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1763                 if (max_bandwidth_khz < MHZ_TO_KHZ(160))
1764                         bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1765         }
1766         return bw_flags;
1767 }
1768
1769 static void handle_channel_single_rule(struct wiphy *wiphy,
1770                                        enum nl80211_reg_initiator initiator,
1771                                        struct ieee80211_channel *chan,
1772                                        u32 flags,
1773                                        struct regulatory_request *lr,
1774                                        struct wiphy *request_wiphy,
1775                                        const struct ieee80211_reg_rule *reg_rule)
1776 {
1777         u32 bw_flags = 0;
1778         const struct ieee80211_power_rule *power_rule = NULL;
1779         const struct ieee80211_regdomain *regd;
1780
1781         regd = reg_get_regdomain(wiphy);
1782
1783         power_rule = &reg_rule->power_rule;
1784         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
1785
1786         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1787             request_wiphy && request_wiphy == wiphy &&
1788             request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1789                 /*
1790                  * This guarantees the driver's requested regulatory domain
1791                  * will always be used as a base for further regulatory
1792                  * settings
1793                  */
1794                 chan->flags = chan->orig_flags =
1795                         map_regdom_flags(reg_rule->flags) | bw_flags;
1796                 chan->max_antenna_gain = chan->orig_mag =
1797                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1798                 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
1799                         (int) MBM_TO_DBM(power_rule->max_eirp);
1800
1801                 if (chan->flags & IEEE80211_CHAN_RADAR) {
1802                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1803                         if (reg_rule->dfs_cac_ms)
1804                                 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1805                 }
1806
1807                 return;
1808         }
1809
1810         chan->dfs_state = NL80211_DFS_USABLE;
1811         chan->dfs_state_entered = jiffies;
1812
1813         chan->beacon_found = false;
1814         chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
1815         chan->max_antenna_gain =
1816                 min_t(int, chan->orig_mag,
1817                       MBI_TO_DBI(power_rule->max_antenna_gain));
1818         chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1819
1820         if (chan->flags & IEEE80211_CHAN_RADAR) {
1821                 if (reg_rule->dfs_cac_ms)
1822                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1823                 else
1824                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1825         }
1826
1827         if (chan->orig_mpwr) {
1828                 /*
1829                  * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1830                  * will always follow the passed country IE power settings.
1831                  */
1832                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1833                     wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1834                         chan->max_power = chan->max_reg_power;
1835                 else
1836                         chan->max_power = min(chan->orig_mpwr,
1837                                               chan->max_reg_power);
1838         } else
1839                 chan->max_power = chan->max_reg_power;
1840 }
1841
1842 static void handle_channel_adjacent_rules(struct wiphy *wiphy,
1843                                           enum nl80211_reg_initiator initiator,
1844                                           struct ieee80211_channel *chan,
1845                                           u32 flags,
1846                                           struct regulatory_request *lr,
1847                                           struct wiphy *request_wiphy,
1848                                           const struct ieee80211_reg_rule *rrule1,
1849                                           const struct ieee80211_reg_rule *rrule2,
1850                                           struct ieee80211_freq_range *comb_range)
1851 {
1852         u32 bw_flags1 = 0;
1853         u32 bw_flags2 = 0;
1854         const struct ieee80211_power_rule *power_rule1 = NULL;
1855         const struct ieee80211_power_rule *power_rule2 = NULL;
1856         const struct ieee80211_regdomain *regd;
1857
1858         regd = reg_get_regdomain(wiphy);
1859
1860         power_rule1 = &rrule1->power_rule;
1861         power_rule2 = &rrule2->power_rule;
1862         bw_flags1 = reg_rule_to_chan_bw_flags(regd, rrule1, chan);
1863         bw_flags2 = reg_rule_to_chan_bw_flags(regd, rrule2, chan);
1864
1865         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1866             request_wiphy && request_wiphy == wiphy &&
1867             request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1868                 /* This guarantees the driver's requested regulatory domain
1869                  * will always be used as a base for further regulatory
1870                  * settings
1871                  */
1872                 chan->flags =
1873                         map_regdom_flags(rrule1->flags) |
1874                         map_regdom_flags(rrule2->flags) |
1875                         bw_flags1 |
1876                         bw_flags2;
1877                 chan->orig_flags = chan->flags;
1878                 chan->max_antenna_gain =
1879                         min_t(int, MBI_TO_DBI(power_rule1->max_antenna_gain),
1880                               MBI_TO_DBI(power_rule2->max_antenna_gain));
1881                 chan->orig_mag = chan->max_antenna_gain;
1882                 chan->max_reg_power =
1883                         min_t(int, MBM_TO_DBM(power_rule1->max_eirp),
1884                               MBM_TO_DBM(power_rule2->max_eirp));
1885                 chan->max_power = chan->max_reg_power;
1886                 chan->orig_mpwr = chan->max_reg_power;
1887
1888                 if (chan->flags & IEEE80211_CHAN_RADAR) {
1889                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1890                         if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms)
1891                                 chan->dfs_cac_ms = max_t(unsigned int,
1892                                                          rrule1->dfs_cac_ms,
1893                                                          rrule2->dfs_cac_ms);
1894                 }
1895
1896                 return;
1897         }
1898
1899         chan->dfs_state = NL80211_DFS_USABLE;
1900         chan->dfs_state_entered = jiffies;
1901
1902         chan->beacon_found = false;
1903         chan->flags = flags | bw_flags1 | bw_flags2 |
1904                       map_regdom_flags(rrule1->flags) |
1905                       map_regdom_flags(rrule2->flags);
1906
1907         /* reg_rule_to_chan_bw_flags may forbids 10 and forbids 20 MHz
1908          * (otherwise no adj. rule case), recheck therefore
1909          */
1910         if (cfg80211_does_bw_fit_range(comb_range,
1911                                        ieee80211_channel_to_khz(chan),
1912                                        MHZ_TO_KHZ(10)))
1913                 chan->flags &= ~IEEE80211_CHAN_NO_10MHZ;
1914         if (cfg80211_does_bw_fit_range(comb_range,
1915                                        ieee80211_channel_to_khz(chan),
1916                                        MHZ_TO_KHZ(20)))
1917                 chan->flags &= ~IEEE80211_CHAN_NO_20MHZ;
1918
1919         chan->max_antenna_gain =
1920                 min_t(int, chan->orig_mag,
1921                       min_t(int,
1922                             MBI_TO_DBI(power_rule1->max_antenna_gain),
1923                             MBI_TO_DBI(power_rule2->max_antenna_gain)));
1924         chan->max_reg_power = min_t(int,
1925                                     MBM_TO_DBM(power_rule1->max_eirp),
1926                                     MBM_TO_DBM(power_rule2->max_eirp));
1927
1928         if (chan->flags & IEEE80211_CHAN_RADAR) {
1929                 if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms)
1930                         chan->dfs_cac_ms = max_t(unsigned int,
1931                                                  rrule1->dfs_cac_ms,
1932                                                  rrule2->dfs_cac_ms);
1933                 else
1934                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1935         }
1936
1937         if (chan->orig_mpwr) {
1938                 /* Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1939                  * will always follow the passed country IE power settings.
1940                  */
1941                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1942                     wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1943                         chan->max_power = chan->max_reg_power;
1944                 else
1945                         chan->max_power = min(chan->orig_mpwr,
1946                                               chan->max_reg_power);
1947         } else {
1948                 chan->max_power = chan->max_reg_power;
1949         }
1950 }
1951
1952 /* Note that right now we assume the desired channel bandwidth
1953  * is always 20 MHz for each individual channel (HT40 uses 20 MHz
1954  * per channel, the primary and the extension channel).
1955  */
1956 static void handle_channel(struct wiphy *wiphy,
1957                            enum nl80211_reg_initiator initiator,
1958                            struct ieee80211_channel *chan)
1959 {
1960         const u32 orig_chan_freq = ieee80211_channel_to_khz(chan);
1961         struct regulatory_request *lr = get_last_request();
1962         struct wiphy *request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
1963         const struct ieee80211_reg_rule *rrule = NULL;
1964         const struct ieee80211_reg_rule *rrule1 = NULL;
1965         const struct ieee80211_reg_rule *rrule2 = NULL;
1966
1967         u32 flags = chan->orig_flags;
1968
1969         rrule = freq_reg_info(wiphy, orig_chan_freq);
1970         if (IS_ERR(rrule)) {
1971                 /* check for adjacent match, therefore get rules for
1972                  * chan - 20 MHz and chan + 20 MHz and test
1973                  * if reg rules are adjacent
1974                  */
1975                 rrule1 = freq_reg_info(wiphy,
1976                                        orig_chan_freq - MHZ_TO_KHZ(20));
1977                 rrule2 = freq_reg_info(wiphy,
1978                                        orig_chan_freq + MHZ_TO_KHZ(20));
1979                 if (!IS_ERR(rrule1) && !IS_ERR(rrule2)) {
1980                         struct ieee80211_freq_range comb_range;
1981
1982                         if (rrule1->freq_range.end_freq_khz !=
1983                             rrule2->freq_range.start_freq_khz)
1984                                 goto disable_chan;
1985
1986                         comb_range.start_freq_khz =
1987                                 rrule1->freq_range.start_freq_khz;
1988                         comb_range.end_freq_khz =
1989                                 rrule2->freq_range.end_freq_khz;
1990                         comb_range.max_bandwidth_khz =
1991                                 min_t(u32,
1992                                       rrule1->freq_range.max_bandwidth_khz,
1993                                       rrule2->freq_range.max_bandwidth_khz);
1994
1995                         if (!cfg80211_does_bw_fit_range(&comb_range,
1996                                                         orig_chan_freq,
1997                                                         MHZ_TO_KHZ(20)))
1998                                 goto disable_chan;
1999
2000                         handle_channel_adjacent_rules(wiphy, initiator, chan,
2001                                                       flags, lr, request_wiphy,
2002                                                       rrule1, rrule2,
2003                                                       &comb_range);
2004                         return;
2005                 }
2006
2007 disable_chan:
2008                 /* We will disable all channels that do not match our
2009                  * received regulatory rule unless the hint is coming
2010                  * from a Country IE and the Country IE had no information
2011                  * about a band. The IEEE 802.11 spec allows for an AP
2012                  * to send only a subset of the regulatory rules allowed,
2013                  * so an AP in the US that only supports 2.4 GHz may only send
2014                  * a country IE with information for the 2.4 GHz band
2015                  * while 5 GHz is still supported.
2016                  */
2017                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2018                     PTR_ERR(rrule) == -ERANGE)
2019                         return;
2020
2021                 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2022                     request_wiphy && request_wiphy == wiphy &&
2023                     request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
2024                         pr_debug("Disabling freq %d.%03d MHz for good\n",
2025                                  chan->center_freq, chan->freq_offset);
2026                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2027                         chan->flags = chan->orig_flags;
2028                 } else {
2029                         pr_debug("Disabling freq %d.%03d MHz\n",
2030                                  chan->center_freq, chan->freq_offset);
2031                         chan->flags |= IEEE80211_CHAN_DISABLED;
2032                 }
2033                 return;
2034         }
2035
2036         handle_channel_single_rule(wiphy, initiator, chan, flags, lr,
2037                                    request_wiphy, rrule);
2038 }
2039
2040 static void handle_band(struct wiphy *wiphy,
2041                         enum nl80211_reg_initiator initiator,
2042                         struct ieee80211_supported_band *sband)
2043 {
2044         unsigned int i;
2045
2046         if (!sband)
2047                 return;
2048
2049         for (i = 0; i < sband->n_channels; i++)
2050                 handle_channel(wiphy, initiator, &sband->channels[i]);
2051 }
2052
2053 static bool reg_request_cell_base(struct regulatory_request *request)
2054 {
2055         if (request->initiator != NL80211_REGDOM_SET_BY_USER)
2056                 return false;
2057         return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
2058 }
2059
2060 bool reg_last_request_cell_base(void)
2061 {
2062         return reg_request_cell_base(get_last_request());
2063 }
2064
2065 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
2066 /* Core specific check */
2067 static enum reg_request_treatment
2068 reg_ignore_cell_hint(struct regulatory_request *pending_request)
2069 {
2070         struct regulatory_request *lr = get_last_request();
2071
2072         if (!reg_num_devs_support_basehint)
2073                 return REG_REQ_IGNORE;
2074
2075         if (reg_request_cell_base(lr) &&
2076             !regdom_changes(pending_request->alpha2))
2077                 return REG_REQ_ALREADY_SET;
2078
2079         return REG_REQ_OK;
2080 }
2081
2082 /* Device specific check */
2083 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
2084 {
2085         return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
2086 }
2087 #else
2088 static enum reg_request_treatment
2089 reg_ignore_cell_hint(struct regulatory_request *pending_request)
2090 {
2091         return REG_REQ_IGNORE;
2092 }
2093
2094 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
2095 {
2096         return true;
2097 }
2098 #endif
2099
2100 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
2101 {
2102         if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
2103             !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
2104                 return true;
2105         return false;
2106 }
2107
2108 static bool ignore_reg_update(struct wiphy *wiphy,
2109                               enum nl80211_reg_initiator initiator)
2110 {
2111         struct regulatory_request *lr = get_last_request();
2112
2113         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2114                 return true;
2115
2116         if (!lr) {
2117                 pr_debug("Ignoring regulatory request set by %s since last_request is not set\n",
2118                          reg_initiator_name(initiator));
2119                 return true;
2120         }
2121
2122         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
2123             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
2124                 pr_debug("Ignoring regulatory request set by %s since the driver uses its own custom regulatory domain\n",
2125                          reg_initiator_name(initiator));
2126                 return true;
2127         }
2128
2129         /*
2130          * wiphy->regd will be set once the device has its own
2131          * desired regulatory domain set
2132          */
2133         if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
2134             initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2135             !is_world_regdom(lr->alpha2)) {
2136                 pr_debug("Ignoring regulatory request set by %s since the driver requires its own regulatory domain to be set first\n",
2137                          reg_initiator_name(initiator));
2138                 return true;
2139         }
2140
2141         if (reg_request_cell_base(lr))
2142                 return reg_dev_ignore_cell_hint(wiphy);
2143
2144         return false;
2145 }
2146
2147 static bool reg_is_world_roaming(struct wiphy *wiphy)
2148 {
2149         const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
2150         const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
2151         struct regulatory_request *lr = get_last_request();
2152
2153         if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
2154                 return true;
2155
2156         if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2157             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
2158                 return true;
2159
2160         return false;
2161 }
2162
2163 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
2164                               struct reg_beacon *reg_beacon)
2165 {
2166         struct ieee80211_supported_band *sband;
2167         struct ieee80211_channel *chan;
2168         bool channel_changed = false;
2169         struct ieee80211_channel chan_before;
2170
2171         sband = wiphy->bands[reg_beacon->chan.band];
2172         chan = &sband->channels[chan_idx];
2173
2174         if (likely(!ieee80211_channel_equal(chan, &reg_beacon->chan)))
2175                 return;
2176
2177         if (chan->beacon_found)
2178                 return;
2179
2180         chan->beacon_found = true;
2181
2182         if (!reg_is_world_roaming(wiphy))
2183                 return;
2184
2185         if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
2186                 return;
2187
2188         chan_before = *chan;
2189
2190         if (chan->flags & IEEE80211_CHAN_NO_IR) {
2191                 chan->flags &= ~IEEE80211_CHAN_NO_IR;
2192                 channel_changed = true;
2193         }
2194
2195         if (channel_changed)
2196                 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
2197 }
2198
2199 /*
2200  * Called when a scan on a wiphy finds a beacon on
2201  * new channel
2202  */
2203 static void wiphy_update_new_beacon(struct wiphy *wiphy,
2204                                     struct reg_beacon *reg_beacon)
2205 {
2206         unsigned int i;
2207         struct ieee80211_supported_band *sband;
2208
2209         if (!wiphy->bands[reg_beacon->chan.band])
2210                 return;
2211
2212         sband = wiphy->bands[reg_beacon->chan.band];
2213
2214         for (i = 0; i < sband->n_channels; i++)
2215                 handle_reg_beacon(wiphy, i, reg_beacon);
2216 }
2217
2218 /*
2219  * Called upon reg changes or a new wiphy is added
2220  */
2221 static void wiphy_update_beacon_reg(struct wiphy *wiphy)
2222 {
2223         unsigned int i;
2224         struct ieee80211_supported_band *sband;
2225         struct reg_beacon *reg_beacon;
2226
2227         list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
2228                 if (!wiphy->bands[reg_beacon->chan.band])
2229                         continue;
2230                 sband = wiphy->bands[reg_beacon->chan.band];
2231                 for (i = 0; i < sband->n_channels; i++)
2232                         handle_reg_beacon(wiphy, i, reg_beacon);
2233         }
2234 }
2235
2236 /* Reap the advantages of previously found beacons */
2237 static void reg_process_beacons(struct wiphy *wiphy)
2238 {
2239         /*
2240          * Means we are just firing up cfg80211, so no beacons would
2241          * have been processed yet.
2242          */
2243         if (!last_request)
2244                 return;
2245         wiphy_update_beacon_reg(wiphy);
2246 }
2247
2248 static bool is_ht40_allowed(struct ieee80211_channel *chan)
2249 {
2250         if (!chan)
2251                 return false;
2252         if (chan->flags & IEEE80211_CHAN_DISABLED)
2253                 return false;
2254         /* This would happen when regulatory rules disallow HT40 completely */
2255         if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
2256                 return false;
2257         return true;
2258 }
2259
2260 static void reg_process_ht_flags_channel(struct wiphy *wiphy,
2261                                          struct ieee80211_channel *channel)
2262 {
2263         struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
2264         struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
2265         const struct ieee80211_regdomain *regd;
2266         unsigned int i;
2267         u32 flags;
2268
2269         if (!is_ht40_allowed(channel)) {
2270                 channel->flags |= IEEE80211_CHAN_NO_HT40;
2271                 return;
2272         }
2273
2274         /*
2275          * We need to ensure the extension channels exist to
2276          * be able to use HT40- or HT40+, this finds them (or not)
2277          */
2278         for (i = 0; i < sband->n_channels; i++) {
2279                 struct ieee80211_channel *c = &sband->channels[i];
2280
2281                 if (c->center_freq == (channel->center_freq - 20))
2282                         channel_before = c;
2283                 if (c->center_freq == (channel->center_freq + 20))
2284                         channel_after = c;
2285         }
2286
2287         flags = 0;
2288         regd = get_wiphy_regdom(wiphy);
2289         if (regd) {
2290                 const struct ieee80211_reg_rule *reg_rule =
2291                         freq_reg_info_regd(MHZ_TO_KHZ(channel->center_freq),
2292                                            regd, MHZ_TO_KHZ(20));
2293
2294                 if (!IS_ERR(reg_rule))
2295                         flags = reg_rule->flags;
2296         }
2297
2298         /*
2299          * Please note that this assumes target bandwidth is 20 MHz,
2300          * if that ever changes we also need to change the below logic
2301          * to include that as well.
2302          */
2303         if (!is_ht40_allowed(channel_before) ||
2304             flags & NL80211_RRF_NO_HT40MINUS)
2305                 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
2306         else
2307                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
2308
2309         if (!is_ht40_allowed(channel_after) ||
2310             flags & NL80211_RRF_NO_HT40PLUS)
2311                 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
2312         else
2313                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
2314 }
2315
2316 static void reg_process_ht_flags_band(struct wiphy *wiphy,
2317                                       struct ieee80211_supported_band *sband)
2318 {
2319         unsigned int i;
2320
2321         if (!sband)
2322                 return;
2323
2324         for (i = 0; i < sband->n_channels; i++)
2325                 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
2326 }
2327
2328 static void reg_process_ht_flags(struct wiphy *wiphy)
2329 {
2330         enum nl80211_band band;
2331
2332         if (!wiphy)
2333                 return;
2334
2335         for (band = 0; band < NUM_NL80211_BANDS; band++)
2336                 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
2337 }
2338
2339 static void reg_call_notifier(struct wiphy *wiphy,
2340                               struct regulatory_request *request)
2341 {
2342         if (wiphy->reg_notifier)
2343                 wiphy->reg_notifier(wiphy, request);
2344 }
2345
2346 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
2347 {
2348         struct cfg80211_chan_def chandef = {};
2349         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2350         enum nl80211_iftype iftype;
2351         bool ret;
2352
2353         wdev_lock(wdev);
2354         iftype = wdev->iftype;
2355
2356         /* make sure the interface is active */
2357         if (!wdev->netdev || !netif_running(wdev->netdev))
2358                 goto wdev_inactive_unlock;
2359
2360         switch (iftype) {
2361         case NL80211_IFTYPE_AP:
2362         case NL80211_IFTYPE_P2P_GO:
2363                 if (!wdev->beacon_interval)
2364                         goto wdev_inactive_unlock;
2365                 chandef = wdev->chandef;
2366                 break;
2367         case NL80211_IFTYPE_ADHOC:
2368                 if (!wdev->ssid_len)
2369                         goto wdev_inactive_unlock;
2370                 chandef = wdev->chandef;
2371                 break;
2372         case NL80211_IFTYPE_STATION:
2373         case NL80211_IFTYPE_P2P_CLIENT:
2374                 if (!wdev->current_bss ||
2375                     !wdev->current_bss->pub.channel)
2376                         goto wdev_inactive_unlock;
2377
2378                 if (!rdev->ops->get_channel ||
2379                     rdev_get_channel(rdev, wdev, &chandef))
2380                         cfg80211_chandef_create(&chandef,
2381                                                 wdev->current_bss->pub.channel,
2382                                                 NL80211_CHAN_NO_HT);
2383                 break;
2384         case NL80211_IFTYPE_MONITOR:
2385         case NL80211_IFTYPE_AP_VLAN:
2386         case NL80211_IFTYPE_P2P_DEVICE:
2387                 /* no enforcement required */
2388                 break;
2389         default:
2390                 /* others not implemented for now */
2391                 WARN_ON(1);
2392                 break;
2393         }
2394
2395         wdev_unlock(wdev);
2396
2397         switch (iftype) {
2398         case NL80211_IFTYPE_AP:
2399         case NL80211_IFTYPE_P2P_GO:
2400         case NL80211_IFTYPE_ADHOC:
2401                 ret = cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
2402
2403                 return ret;
2404         case NL80211_IFTYPE_STATION:
2405         case NL80211_IFTYPE_P2P_CLIENT:
2406                 return cfg80211_chandef_usable(wiphy, &chandef,
2407                                                IEEE80211_CHAN_DISABLED);
2408         default:
2409                 break;
2410         }
2411
2412         return true;
2413
2414 wdev_inactive_unlock:
2415         wdev_unlock(wdev);
2416         return true;
2417 }
2418
2419 static void reg_leave_invalid_chans(struct wiphy *wiphy)
2420 {
2421         struct wireless_dev *wdev;
2422         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2423
2424         wiphy_lock(wiphy);
2425         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
2426                 if (!reg_wdev_chan_valid(wiphy, wdev))
2427                         cfg80211_leave(rdev, wdev);
2428         wiphy_unlock(wiphy);
2429 }
2430
2431 static void reg_check_chans_work(struct work_struct *work)
2432 {
2433         struct cfg80211_registered_device *rdev;
2434
2435         pr_debug("Verifying active interfaces after reg change\n");
2436         rtnl_lock();
2437
2438         list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2439                 if (!(rdev->wiphy.regulatory_flags &
2440                       REGULATORY_IGNORE_STALE_KICKOFF))
2441                         reg_leave_invalid_chans(&rdev->wiphy);
2442
2443         rtnl_unlock();
2444 }
2445
2446 static void reg_check_channels(void)
2447 {
2448         /*
2449          * Give usermode a chance to do something nicer (move to another
2450          * channel, orderly disconnection), before forcing a disconnection.
2451          */
2452         mod_delayed_work(system_power_efficient_wq,
2453                          &reg_check_chans,
2454                          msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
2455 }
2456
2457 static void wiphy_update_regulatory(struct wiphy *wiphy,
2458                                     enum nl80211_reg_initiator initiator)
2459 {
2460         enum nl80211_band band;
2461         struct regulatory_request *lr = get_last_request();
2462
2463         if (ignore_reg_update(wiphy, initiator)) {
2464                 /*
2465                  * Regulatory updates set by CORE are ignored for custom
2466                  * regulatory cards. Let us notify the changes to the driver,
2467                  * as some drivers used this to restore its orig_* reg domain.
2468                  */
2469                 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
2470                     wiphy->regulatory_flags & REGULATORY_CUSTOM_REG &&
2471                     !(wiphy->regulatory_flags &
2472                       REGULATORY_WIPHY_SELF_MANAGED))
2473                         reg_call_notifier(wiphy, lr);
2474                 return;
2475         }
2476
2477         lr->dfs_region = get_cfg80211_regdom()->dfs_region;
2478
2479         for (band = 0; band < NUM_NL80211_BANDS; band++)
2480                 handle_band(wiphy, initiator, wiphy->bands[band]);
2481
2482         reg_process_beacons(wiphy);
2483         reg_process_ht_flags(wiphy);
2484         reg_call_notifier(wiphy, lr);
2485 }
2486
2487 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
2488 {
2489         struct cfg80211_registered_device *rdev;
2490         struct wiphy *wiphy;
2491
2492         ASSERT_RTNL();
2493
2494         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2495                 wiphy = &rdev->wiphy;
2496                 wiphy_update_regulatory(wiphy, initiator);
2497         }
2498
2499         reg_check_channels();
2500 }
2501
2502 static void handle_channel_custom(struct wiphy *wiphy,
2503                                   struct ieee80211_channel *chan,
2504                                   const struct ieee80211_regdomain *regd,
2505                                   u32 min_bw)
2506 {
2507         u32 bw_flags = 0;
2508         const struct ieee80211_reg_rule *reg_rule = NULL;
2509         const struct ieee80211_power_rule *power_rule = NULL;
2510         u32 bw, center_freq_khz;
2511
2512         center_freq_khz = ieee80211_channel_to_khz(chan);
2513         for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
2514                 reg_rule = freq_reg_info_regd(center_freq_khz, regd, bw);
2515                 if (!IS_ERR(reg_rule))
2516                         break;
2517         }
2518
2519         if (IS_ERR_OR_NULL(reg_rule)) {
2520                 pr_debug("Disabling freq %d.%03d MHz as custom regd has no rule that fits it\n",
2521                          chan->center_freq, chan->freq_offset);
2522                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
2523                         chan->flags |= IEEE80211_CHAN_DISABLED;
2524                 } else {
2525                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2526                         chan->flags = chan->orig_flags;
2527                 }
2528                 return;
2529         }
2530
2531         power_rule = &reg_rule->power_rule;
2532         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
2533
2534         chan->dfs_state_entered = jiffies;
2535         chan->dfs_state = NL80211_DFS_USABLE;
2536
2537         chan->beacon_found = false;
2538
2539         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2540                 chan->flags = chan->orig_flags | bw_flags |
2541                               map_regdom_flags(reg_rule->flags);
2542         else
2543                 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
2544
2545         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
2546         chan->max_reg_power = chan->max_power =
2547                 (int) MBM_TO_DBM(power_rule->max_eirp);
2548
2549         if (chan->flags & IEEE80211_CHAN_RADAR) {
2550                 if (reg_rule->dfs_cac_ms)
2551                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
2552                 else
2553                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
2554         }
2555
2556         chan->max_power = chan->max_reg_power;
2557 }
2558
2559 static void handle_band_custom(struct wiphy *wiphy,
2560                                struct ieee80211_supported_band *sband,
2561                                const struct ieee80211_regdomain *regd)
2562 {
2563         unsigned int i;
2564
2565         if (!sband)
2566                 return;
2567
2568         /*
2569          * We currently assume that you always want at least 20 MHz,
2570          * otherwise channel 12 might get enabled if this rule is
2571          * compatible to US, which permits 2402 - 2472 MHz.
2572          */
2573         for (i = 0; i < sband->n_channels; i++)
2574                 handle_channel_custom(wiphy, &sband->channels[i], regd,
2575                                       MHZ_TO_KHZ(20));
2576 }
2577
2578 /* Used by drivers prior to wiphy registration */
2579 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
2580                                    const struct ieee80211_regdomain *regd)
2581 {
2582         const struct ieee80211_regdomain *new_regd, *tmp;
2583         enum nl80211_band band;
2584         unsigned int bands_set = 0;
2585
2586         WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
2587              "wiphy should have REGULATORY_CUSTOM_REG\n");
2588         wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2589
2590         for (band = 0; band < NUM_NL80211_BANDS; band++) {
2591                 if (!wiphy->bands[band])
2592                         continue;
2593                 handle_band_custom(wiphy, wiphy->bands[band], regd);
2594                 bands_set++;
2595         }
2596
2597         /*
2598          * no point in calling this if it won't have any effect
2599          * on your device's supported bands.
2600          */
2601         WARN_ON(!bands_set);
2602         new_regd = reg_copy_regd(regd);
2603         if (IS_ERR(new_regd))
2604                 return;
2605
2606         rtnl_lock();
2607         wiphy_lock(wiphy);
2608
2609         tmp = get_wiphy_regdom(wiphy);
2610         rcu_assign_pointer(wiphy->regd, new_regd);
2611         rcu_free_regdom(tmp);
2612
2613         wiphy_unlock(wiphy);
2614         rtnl_unlock();
2615 }
2616 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
2617
2618 static void reg_set_request_processed(void)
2619 {
2620         bool need_more_processing = false;
2621         struct regulatory_request *lr = get_last_request();
2622
2623         lr->processed = true;
2624
2625         spin_lock(&reg_requests_lock);
2626         if (!list_empty(&reg_requests_list))
2627                 need_more_processing = true;
2628         spin_unlock(&reg_requests_lock);
2629
2630         cancel_crda_timeout();
2631
2632         if (need_more_processing)
2633                 schedule_work(&reg_work);
2634 }
2635
2636 /**
2637  * reg_process_hint_core - process core regulatory requests
2638  * @core_request: a pending core regulatory request
2639  *
2640  * The wireless subsystem can use this function to process
2641  * a regulatory request issued by the regulatory core.
2642  */
2643 static enum reg_request_treatment
2644 reg_process_hint_core(struct regulatory_request *core_request)
2645 {
2646         if (reg_query_database(core_request)) {
2647                 core_request->intersect = false;
2648                 core_request->processed = false;
2649                 reg_update_last_request(core_request);
2650                 return REG_REQ_OK;
2651         }
2652
2653         return REG_REQ_IGNORE;
2654 }
2655
2656 static enum reg_request_treatment
2657 __reg_process_hint_user(struct regulatory_request *user_request)
2658 {
2659         struct regulatory_request *lr = get_last_request();
2660
2661         if (reg_request_cell_base(user_request))
2662                 return reg_ignore_cell_hint(user_request);
2663
2664         if (reg_request_cell_base(lr))
2665                 return REG_REQ_IGNORE;
2666
2667         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
2668                 return REG_REQ_INTERSECT;
2669         /*
2670          * If the user knows better the user should set the regdom
2671          * to their country before the IE is picked up
2672          */
2673         if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
2674             lr->intersect)
2675                 return REG_REQ_IGNORE;
2676         /*
2677          * Process user requests only after previous user/driver/core
2678          * requests have been processed
2679          */
2680         if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
2681              lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2682              lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
2683             regdom_changes(lr->alpha2))
2684                 return REG_REQ_IGNORE;
2685
2686         if (!regdom_changes(user_request->alpha2))
2687                 return REG_REQ_ALREADY_SET;
2688
2689         return REG_REQ_OK;
2690 }
2691
2692 /**
2693  * reg_process_hint_user - process user regulatory requests
2694  * @user_request: a pending user regulatory request
2695  *
2696  * The wireless subsystem can use this function to process
2697  * a regulatory request initiated by userspace.
2698  */
2699 static enum reg_request_treatment
2700 reg_process_hint_user(struct regulatory_request *user_request)
2701 {
2702         enum reg_request_treatment treatment;
2703
2704         treatment = __reg_process_hint_user(user_request);
2705         if (treatment == REG_REQ_IGNORE ||
2706             treatment == REG_REQ_ALREADY_SET)
2707                 return REG_REQ_IGNORE;
2708
2709         user_request->intersect = treatment == REG_REQ_INTERSECT;
2710         user_request->processed = false;
2711
2712         if (reg_query_database(user_request)) {
2713                 reg_update_last_request(user_request);
2714                 user_alpha2[0] = user_request->alpha2[0];
2715                 user_alpha2[1] = user_request->alpha2[1];
2716                 return REG_REQ_OK;
2717         }
2718
2719         return REG_REQ_IGNORE;
2720 }
2721
2722 static enum reg_request_treatment
2723 __reg_process_hint_driver(struct regulatory_request *driver_request)
2724 {
2725         struct regulatory_request *lr = get_last_request();
2726
2727         if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
2728                 if (regdom_changes(driver_request->alpha2))
2729                         return REG_REQ_OK;
2730                 return REG_REQ_ALREADY_SET;
2731         }
2732
2733         /*
2734          * This would happen if you unplug and plug your card
2735          * back in or if you add a new device for which the previously
2736          * loaded card also agrees on the regulatory domain.
2737          */
2738         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2739             !regdom_changes(driver_request->alpha2))
2740                 return REG_REQ_ALREADY_SET;
2741
2742         return REG_REQ_INTERSECT;
2743 }
2744
2745 /**
2746  * reg_process_hint_driver - process driver regulatory requests
2747  * @wiphy: the wireless device for the regulatory request
2748  * @driver_request: a pending driver regulatory request
2749  *
2750  * The wireless subsystem can use this function to process
2751  * a regulatory request issued by an 802.11 driver.
2752  *
2753  * Returns one of the different reg request treatment values.
2754  */
2755 static enum reg_request_treatment
2756 reg_process_hint_driver(struct wiphy *wiphy,
2757                         struct regulatory_request *driver_request)
2758 {
2759         const struct ieee80211_regdomain *regd, *tmp;
2760         enum reg_request_treatment treatment;
2761
2762         treatment = __reg_process_hint_driver(driver_request);
2763
2764         switch (treatment) {
2765         case REG_REQ_OK:
2766                 break;
2767         case REG_REQ_IGNORE:
2768                 return REG_REQ_IGNORE;
2769         case REG_REQ_INTERSECT:
2770         case REG_REQ_ALREADY_SET:
2771                 regd = reg_copy_regd(get_cfg80211_regdom());
2772                 if (IS_ERR(regd))
2773                         return REG_REQ_IGNORE;
2774
2775                 tmp = get_wiphy_regdom(wiphy);
2776                 ASSERT_RTNL();
2777                 wiphy_lock(wiphy);
2778                 rcu_assign_pointer(wiphy->regd, regd);
2779                 wiphy_unlock(wiphy);
2780                 rcu_free_regdom(tmp);
2781         }
2782
2783
2784         driver_request->intersect = treatment == REG_REQ_INTERSECT;
2785         driver_request->processed = false;
2786
2787         /*
2788          * Since CRDA will not be called in this case as we already
2789          * have applied the requested regulatory domain before we just
2790          * inform userspace we have processed the request
2791          */
2792         if (treatment == REG_REQ_ALREADY_SET) {
2793                 nl80211_send_reg_change_event(driver_request);
2794                 reg_update_last_request(driver_request);
2795                 reg_set_request_processed();
2796                 return REG_REQ_ALREADY_SET;
2797         }
2798
2799         if (reg_query_database(driver_request)) {
2800                 reg_update_last_request(driver_request);
2801                 return REG_REQ_OK;
2802         }
2803
2804         return REG_REQ_IGNORE;
2805 }
2806
2807 static enum reg_request_treatment
2808 __reg_process_hint_country_ie(struct wiphy *wiphy,
2809                               struct regulatory_request *country_ie_request)
2810 {
2811         struct wiphy *last_wiphy = NULL;
2812         struct regulatory_request *lr = get_last_request();
2813
2814         if (reg_request_cell_base(lr)) {
2815                 /* Trust a Cell base station over the AP's country IE */
2816                 if (regdom_changes(country_ie_request->alpha2))
2817                         return REG_REQ_IGNORE;
2818                 return REG_REQ_ALREADY_SET;
2819         } else {
2820                 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
2821                         return REG_REQ_IGNORE;
2822         }
2823
2824         if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2825                 return -EINVAL;
2826
2827         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2828                 return REG_REQ_OK;
2829
2830         last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2831
2832         if (last_wiphy != wiphy) {
2833                 /*
2834                  * Two cards with two APs claiming different
2835                  * Country IE alpha2s. We could
2836                  * intersect them, but that seems unlikely
2837                  * to be correct. Reject second one for now.
2838                  */
2839                 if (regdom_changes(country_ie_request->alpha2))
2840                         return REG_REQ_IGNORE;
2841                 return REG_REQ_ALREADY_SET;
2842         }
2843
2844         if (regdom_changes(country_ie_request->alpha2))
2845                 return REG_REQ_OK;
2846         return REG_REQ_ALREADY_SET;
2847 }
2848
2849 /**
2850  * reg_process_hint_country_ie - process regulatory requests from country IEs
2851  * @wiphy: the wireless device for the regulatory request
2852  * @country_ie_request: a regulatory request from a country IE
2853  *
2854  * The wireless subsystem can use this function to process
2855  * a regulatory request issued by a country Information Element.
2856  *
2857  * Returns one of the different reg request treatment values.
2858  */
2859 static enum reg_request_treatment
2860 reg_process_hint_country_ie(struct wiphy *wiphy,
2861                             struct regulatory_request *country_ie_request)
2862 {
2863         enum reg_request_treatment treatment;
2864
2865         treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
2866
2867         switch (treatment) {
2868         case REG_REQ_OK:
2869                 break;
2870         case REG_REQ_IGNORE:
2871                 return REG_REQ_IGNORE;
2872         case REG_REQ_ALREADY_SET:
2873                 reg_free_request(country_ie_request);
2874                 return REG_REQ_ALREADY_SET;
2875         case REG_REQ_INTERSECT:
2876                 /*
2877                  * This doesn't happen yet, not sure we
2878                  * ever want to support it for this case.
2879                  */
2880                 WARN_ONCE(1, "Unexpected intersection for country elements");
2881                 return REG_REQ_IGNORE;
2882         }
2883
2884         country_ie_request->intersect = false;
2885         country_ie_request->processed = false;
2886
2887         if (reg_query_database(country_ie_request)) {
2888                 reg_update_last_request(country_ie_request);
2889                 return REG_REQ_OK;
2890         }
2891
2892         return REG_REQ_IGNORE;
2893 }
2894
2895 bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2)
2896 {
2897         const struct ieee80211_regdomain *wiphy1_regd = NULL;
2898         const struct ieee80211_regdomain *wiphy2_regd = NULL;
2899         const struct ieee80211_regdomain *cfg80211_regd = NULL;
2900         bool dfs_domain_same;
2901
2902         rcu_read_lock();
2903
2904         cfg80211_regd = rcu_dereference(cfg80211_regdomain);
2905         wiphy1_regd = rcu_dereference(wiphy1->regd);
2906         if (!wiphy1_regd)
2907                 wiphy1_regd = cfg80211_regd;
2908
2909         wiphy2_regd = rcu_dereference(wiphy2->regd);
2910         if (!wiphy2_regd)
2911                 wiphy2_regd = cfg80211_regd;
2912
2913         dfs_domain_same = wiphy1_regd->dfs_region == wiphy2_regd->dfs_region;
2914
2915         rcu_read_unlock();
2916
2917         return dfs_domain_same;
2918 }
2919
2920 static void reg_copy_dfs_chan_state(struct ieee80211_channel *dst_chan,
2921                                     struct ieee80211_channel *src_chan)
2922 {
2923         if (!(dst_chan->flags & IEEE80211_CHAN_RADAR) ||
2924             !(src_chan->flags & IEEE80211_CHAN_RADAR))
2925                 return;
2926
2927         if (dst_chan->flags & IEEE80211_CHAN_DISABLED ||
2928             src_chan->flags & IEEE80211_CHAN_DISABLED)
2929                 return;
2930
2931         if (src_chan->center_freq == dst_chan->center_freq &&
2932             dst_chan->dfs_state == NL80211_DFS_USABLE) {
2933                 dst_chan->dfs_state = src_chan->dfs_state;
2934                 dst_chan->dfs_state_entered = src_chan->dfs_state_entered;
2935         }
2936 }
2937
2938 static void wiphy_share_dfs_chan_state(struct wiphy *dst_wiphy,
2939                                        struct wiphy *src_wiphy)
2940 {
2941         struct ieee80211_supported_band *src_sband, *dst_sband;
2942         struct ieee80211_channel *src_chan, *dst_chan;
2943         int i, j, band;
2944
2945         if (!reg_dfs_domain_same(dst_wiphy, src_wiphy))
2946                 return;
2947
2948         for (band = 0; band < NUM_NL80211_BANDS; band++) {
2949                 dst_sband = dst_wiphy->bands[band];
2950                 src_sband = src_wiphy->bands[band];
2951                 if (!dst_sband || !src_sband)
2952                         continue;
2953
2954                 for (i = 0; i < dst_sband->n_channels; i++) {
2955                         dst_chan = &dst_sband->channels[i];
2956                         for (j = 0; j < src_sband->n_channels; j++) {
2957                                 src_chan = &src_sband->channels[j];
2958                                 reg_copy_dfs_chan_state(dst_chan, src_chan);
2959                         }
2960                 }
2961         }
2962 }
2963
2964 static void wiphy_all_share_dfs_chan_state(struct wiphy *wiphy)
2965 {
2966         struct cfg80211_registered_device *rdev;
2967
2968         ASSERT_RTNL();
2969
2970         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2971                 if (wiphy == &rdev->wiphy)
2972                         continue;
2973                 wiphy_share_dfs_chan_state(wiphy, &rdev->wiphy);
2974         }
2975 }
2976
2977 /* This processes *all* regulatory hints */
2978 static void reg_process_hint(struct regulatory_request *reg_request)
2979 {
2980         struct wiphy *wiphy = NULL;
2981         enum reg_request_treatment treatment;
2982         enum nl80211_reg_initiator initiator = reg_request->initiator;
2983
2984         if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
2985                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
2986
2987         switch (initiator) {
2988         case NL80211_REGDOM_SET_BY_CORE:
2989                 treatment = reg_process_hint_core(reg_request);
2990                 break;
2991         case NL80211_REGDOM_SET_BY_USER:
2992                 treatment = reg_process_hint_user(reg_request);
2993                 break;
2994         case NL80211_REGDOM_SET_BY_DRIVER:
2995                 if (!wiphy)
2996                         goto out_free;
2997                 treatment = reg_process_hint_driver(wiphy, reg_request);
2998                 break;
2999         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3000                 if (!wiphy)
3001                         goto out_free;
3002                 treatment = reg_process_hint_country_ie(wiphy, reg_request);
3003                 break;
3004         default:
3005                 WARN(1, "invalid initiator %d\n", initiator);
3006                 goto out_free;
3007         }
3008
3009         if (treatment == REG_REQ_IGNORE)
3010                 goto out_free;
3011
3012         WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET,
3013              "unexpected treatment value %d\n", treatment);
3014
3015         /* This is required so that the orig_* parameters are saved.
3016          * NOTE: treatment must be set for any case that reaches here!
3017          */
3018         if (treatment == REG_REQ_ALREADY_SET && wiphy &&
3019             wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
3020                 wiphy_update_regulatory(wiphy, initiator);
3021                 wiphy_all_share_dfs_chan_state(wiphy);
3022                 reg_check_channels();
3023         }
3024
3025         return;
3026
3027 out_free:
3028         reg_free_request(reg_request);
3029 }
3030
3031 static void notify_self_managed_wiphys(struct regulatory_request *request)
3032 {
3033         struct cfg80211_registered_device *rdev;
3034         struct wiphy *wiphy;
3035
3036         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3037                 wiphy = &rdev->wiphy;
3038                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
3039                     request->initiator == NL80211_REGDOM_SET_BY_USER)
3040                         reg_call_notifier(wiphy, request);
3041         }
3042 }
3043
3044 /*
3045  * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
3046  * Regulatory hints come on a first come first serve basis and we
3047  * must process each one atomically.
3048  */
3049 static void reg_process_pending_hints(void)
3050 {
3051         struct regulatory_request *reg_request, *lr;
3052
3053         lr = get_last_request();
3054
3055         /* When last_request->processed becomes true this will be rescheduled */
3056         if (lr && !lr->processed) {
3057                 pr_debug("Pending regulatory request, waiting for it to be processed...\n");
3058                 return;
3059         }
3060
3061         spin_lock(&reg_requests_lock);
3062
3063         if (list_empty(&reg_requests_list)) {
3064                 spin_unlock(&reg_requests_lock);
3065                 return;
3066         }
3067
3068         reg_request = list_first_entry(&reg_requests_list,
3069                                        struct regulatory_request,
3070                                        list);
3071         list_del_init(&reg_request->list);
3072
3073         spin_unlock(&reg_requests_lock);
3074
3075         notify_self_managed_wiphys(reg_request);
3076
3077         reg_process_hint(reg_request);
3078
3079         lr = get_last_request();
3080
3081         spin_lock(&reg_requests_lock);
3082         if (!list_empty(&reg_requests_list) && lr && lr->processed)
3083                 schedule_work(&reg_work);
3084         spin_unlock(&reg_requests_lock);
3085 }
3086
3087 /* Processes beacon hints -- this has nothing to do with country IEs */
3088 static void reg_process_pending_beacon_hints(void)
3089 {
3090         struct cfg80211_registered_device *rdev;
3091         struct reg_beacon *pending_beacon, *tmp;
3092
3093         /* This goes through the _pending_ beacon list */
3094         spin_lock_bh(&reg_pending_beacons_lock);
3095
3096         list_for_each_entry_safe(pending_beacon, tmp,
3097                                  &reg_pending_beacons, list) {
3098                 list_del_init(&pending_beacon->list);
3099
3100                 /* Applies the beacon hint to current wiphys */
3101                 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
3102                         wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
3103
3104                 /* Remembers the beacon hint for new wiphys or reg changes */
3105                 list_add_tail(&pending_beacon->list, &reg_beacon_list);
3106         }
3107
3108         spin_unlock_bh(&reg_pending_beacons_lock);
3109 }
3110
3111 static void reg_process_self_managed_hint(struct wiphy *wiphy)
3112 {
3113         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
3114         const struct ieee80211_regdomain *tmp;
3115         const struct ieee80211_regdomain *regd;
3116         enum nl80211_band band;
3117         struct regulatory_request request = {};
3118
3119         ASSERT_RTNL();
3120         lockdep_assert_wiphy(wiphy);
3121
3122         spin_lock(&reg_requests_lock);
3123         regd = rdev->requested_regd;
3124         rdev->requested_regd = NULL;
3125         spin_unlock(&reg_requests_lock);
3126
3127         if (!regd)
3128                 return;
3129
3130         tmp = get_wiphy_regdom(wiphy);
3131         rcu_assign_pointer(wiphy->regd, regd);
3132         rcu_free_regdom(tmp);
3133
3134         for (band = 0; band < NUM_NL80211_BANDS; band++)
3135                 handle_band_custom(wiphy, wiphy->bands[band], regd);
3136
3137         reg_process_ht_flags(wiphy);
3138
3139         request.wiphy_idx = get_wiphy_idx(wiphy);
3140         request.alpha2[0] = regd->alpha2[0];
3141         request.alpha2[1] = regd->alpha2[1];
3142         request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
3143
3144         nl80211_send_wiphy_reg_change_event(&request);
3145 }
3146
3147 static void reg_process_self_managed_hints(void)
3148 {
3149         struct cfg80211_registered_device *rdev;
3150
3151         ASSERT_RTNL();
3152
3153         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3154                 wiphy_lock(&rdev->wiphy);
3155                 reg_process_self_managed_hint(&rdev->wiphy);
3156                 wiphy_unlock(&rdev->wiphy);
3157         }
3158
3159         reg_check_channels();
3160 }
3161
3162 static void reg_todo(struct work_struct *work)
3163 {
3164         rtnl_lock();
3165         reg_process_pending_hints();
3166         reg_process_pending_beacon_hints();
3167         reg_process_self_managed_hints();
3168         rtnl_unlock();
3169 }
3170
3171 static void queue_regulatory_request(struct regulatory_request *request)
3172 {
3173         request->alpha2[0] = toupper(request->alpha2[0]);
3174         request->alpha2[1] = toupper(request->alpha2[1]);
3175
3176         spin_lock(&reg_requests_lock);
3177         list_add_tail(&request->list, &reg_requests_list);
3178         spin_unlock(&reg_requests_lock);
3179
3180         schedule_work(&reg_work);
3181 }
3182
3183 /*
3184  * Core regulatory hint -- happens during cfg80211_init()
3185  * and when we restore regulatory settings.
3186  */
3187 static int regulatory_hint_core(const char *alpha2)
3188 {
3189         struct regulatory_request *request;
3190
3191         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
3192         if (!request)
3193                 return -ENOMEM;
3194
3195         request->alpha2[0] = alpha2[0];
3196         request->alpha2[1] = alpha2[1];
3197         request->initiator = NL80211_REGDOM_SET_BY_CORE;
3198         request->wiphy_idx = WIPHY_IDX_INVALID;
3199
3200         queue_regulatory_request(request);
3201
3202         return 0;
3203 }
3204
3205 /* User hints */
3206 int regulatory_hint_user(const char *alpha2,
3207                          enum nl80211_user_reg_hint_type user_reg_hint_type)
3208 {
3209         struct regulatory_request *request;
3210
3211         if (WARN_ON(!alpha2))
3212                 return -EINVAL;
3213
3214         if (!is_world_regdom(alpha2) && !is_an_alpha2(alpha2))
3215                 return -EINVAL;
3216
3217         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
3218         if (!request)
3219                 return -ENOMEM;
3220
3221         request->wiphy_idx = WIPHY_IDX_INVALID;
3222         request->alpha2[0] = alpha2[0];
3223         request->alpha2[1] = alpha2[1];
3224         request->initiator = NL80211_REGDOM_SET_BY_USER;
3225         request->user_reg_hint_type = user_reg_hint_type;
3226
3227         /* Allow calling CRDA again */
3228         reset_crda_timeouts();
3229
3230         queue_regulatory_request(request);
3231
3232         return 0;
3233 }
3234
3235 int regulatory_hint_indoor(bool is_indoor, u32 portid)
3236 {
3237         spin_lock(&reg_indoor_lock);
3238
3239         /* It is possible that more than one user space process is trying to
3240          * configure the indoor setting. To handle such cases, clear the indoor
3241          * setting in case that some process does not think that the device
3242          * is operating in an indoor environment. In addition, if a user space
3243          * process indicates that it is controlling the indoor setting, save its
3244          * portid, i.e., make it the owner.
3245          */
3246         reg_is_indoor = is_indoor;
3247         if (reg_is_indoor) {
3248                 if (!reg_is_indoor_portid)
3249                         reg_is_indoor_portid = portid;
3250         } else {
3251                 reg_is_indoor_portid = 0;
3252         }
3253
3254         spin_unlock(&reg_indoor_lock);
3255
3256         if (!is_indoor)
3257                 reg_check_channels();
3258
3259         return 0;
3260 }
3261
3262 void regulatory_netlink_notify(u32 portid)
3263 {
3264         spin_lock(&reg_indoor_lock);
3265
3266         if (reg_is_indoor_portid != portid) {
3267                 spin_unlock(&reg_indoor_lock);
3268                 return;
3269         }
3270
3271         reg_is_indoor = false;
3272         reg_is_indoor_portid = 0;
3273
3274         spin_unlock(&reg_indoor_lock);
3275
3276         reg_check_channels();
3277 }
3278
3279 /* Driver hints */
3280 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
3281 {
3282         struct regulatory_request *request;
3283
3284         if (WARN_ON(!alpha2 || !wiphy))
3285                 return -EINVAL;
3286
3287         wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
3288
3289         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
3290         if (!request)
3291                 return -ENOMEM;
3292
3293         request->wiphy_idx = get_wiphy_idx(wiphy);
3294
3295         request->alpha2[0] = alpha2[0];
3296         request->alpha2[1] = alpha2[1];
3297         request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
3298
3299         /* Allow calling CRDA again */
3300         reset_crda_timeouts();
3301
3302         queue_regulatory_request(request);
3303
3304         return 0;
3305 }
3306 EXPORT_SYMBOL(regulatory_hint);
3307
3308 void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band,
3309                                 const u8 *country_ie, u8 country_ie_len)
3310 {
3311         char alpha2[2];
3312         enum environment_cap env = ENVIRON_ANY;
3313         struct regulatory_request *request = NULL, *lr;
3314
3315         /* IE len must be evenly divisible by 2 */
3316         if (country_ie_len & 0x01)
3317                 return;
3318
3319         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
3320                 return;
3321
3322         request = kzalloc(sizeof(*request), GFP_KERNEL);
3323         if (!request)
3324                 return;
3325
3326         alpha2[0] = country_ie[0];
3327         alpha2[1] = country_ie[1];
3328
3329         if (country_ie[2] == 'I')
3330                 env = ENVIRON_INDOOR;
3331         else if (country_ie[2] == 'O')
3332                 env = ENVIRON_OUTDOOR;
3333
3334         rcu_read_lock();
3335         lr = get_last_request();
3336
3337         if (unlikely(!lr))
3338                 goto out;
3339
3340         /*
3341          * We will run this only upon a successful connection on cfg80211.
3342          * We leave conflict resolution to the workqueue, where can hold
3343          * the RTNL.
3344          */
3345         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
3346             lr->wiphy_idx != WIPHY_IDX_INVALID)
3347                 goto out;
3348
3349         request->wiphy_idx = get_wiphy_idx(wiphy);
3350         request->alpha2[0] = alpha2[0];
3351         request->alpha2[1] = alpha2[1];
3352         request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
3353         request->country_ie_env = env;
3354
3355         /* Allow calling CRDA again */
3356         reset_crda_timeouts();
3357
3358         queue_regulatory_request(request);
3359         request = NULL;
3360 out:
3361         kfree(request);
3362         rcu_read_unlock();
3363 }
3364
3365 static void restore_alpha2(char *alpha2, bool reset_user)
3366 {
3367         /* indicates there is no alpha2 to consider for restoration */
3368         alpha2[0] = '9';
3369         alpha2[1] = '7';
3370
3371         /* The user setting has precedence over the module parameter */
3372         if (is_user_regdom_saved()) {
3373                 /* Unless we're asked to ignore it and reset it */
3374                 if (reset_user) {
3375                         pr_debug("Restoring regulatory settings including user preference\n");
3376                         user_alpha2[0] = '9';
3377                         user_alpha2[1] = '7';
3378
3379                         /*
3380                          * If we're ignoring user settings, we still need to
3381                          * check the module parameter to ensure we put things
3382                          * back as they were for a full restore.
3383                          */
3384                         if (!is_world_regdom(ieee80211_regdom)) {
3385                                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3386                                          ieee80211_regdom[0], ieee80211_regdom[1]);
3387                                 alpha2[0] = ieee80211_regdom[0];
3388                                 alpha2[1] = ieee80211_regdom[1];
3389                         }
3390                 } else {
3391                         pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n",
3392                                  user_alpha2[0], user_alpha2[1]);
3393                         alpha2[0] = user_alpha2[0];
3394                         alpha2[1] = user_alpha2[1];
3395                 }
3396         } else if (!is_world_regdom(ieee80211_regdom)) {
3397                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3398                          ieee80211_regdom[0], ieee80211_regdom[1]);
3399                 alpha2[0] = ieee80211_regdom[0];
3400                 alpha2[1] = ieee80211_regdom[1];
3401         } else
3402                 pr_debug("Restoring regulatory settings\n");
3403 }
3404
3405 static void restore_custom_reg_settings(struct wiphy *wiphy)
3406 {
3407         struct ieee80211_supported_band *sband;
3408         enum nl80211_band band;
3409         struct ieee80211_channel *chan;
3410         int i;
3411
3412         for (band = 0; band < NUM_NL80211_BANDS; band++) {
3413                 sband = wiphy->bands[band];
3414                 if (!sband)
3415                         continue;
3416                 for (i = 0; i < sband->n_channels; i++) {
3417                         chan = &sband->channels[i];
3418                         chan->flags = chan->orig_flags;
3419                         chan->max_antenna_gain = chan->orig_mag;
3420                         chan->max_power = chan->orig_mpwr;
3421                         chan->beacon_found = false;
3422                 }
3423         }
3424 }
3425
3426 /*
3427  * Restoring regulatory settings involves ignoring any
3428  * possibly stale country IE information and user regulatory
3429  * settings if so desired, this includes any beacon hints
3430  * learned as we could have traveled outside to another country
3431  * after disconnection. To restore regulatory settings we do
3432  * exactly what we did at bootup:
3433  *
3434  *   - send a core regulatory hint
3435  *   - send a user regulatory hint if applicable
3436  *
3437  * Device drivers that send a regulatory hint for a specific country
3438  * keep their own regulatory domain on wiphy->regd so that does
3439  * not need to be remembered.
3440  */
3441 static void restore_regulatory_settings(bool reset_user, bool cached)
3442 {
3443         char alpha2[2];
3444         char world_alpha2[2];
3445         struct reg_beacon *reg_beacon, *btmp;
3446         LIST_HEAD(tmp_reg_req_list);
3447         struct cfg80211_registered_device *rdev;
3448
3449         ASSERT_RTNL();
3450
3451         /*
3452          * Clear the indoor setting in case that it is not controlled by user
3453          * space, as otherwise there is no guarantee that the device is still
3454          * operating in an indoor environment.
3455          */
3456         spin_lock(&reg_indoor_lock);
3457         if (reg_is_indoor && !reg_is_indoor_portid) {
3458                 reg_is_indoor = false;
3459                 reg_check_channels();
3460         }
3461         spin_unlock(&reg_indoor_lock);
3462
3463         reset_regdomains(true, &world_regdom);
3464         restore_alpha2(alpha2, reset_user);
3465
3466         /*
3467          * If there's any pending requests we simply
3468          * stash them to a temporary pending queue and
3469          * add then after we've restored regulatory
3470          * settings.
3471          */
3472         spin_lock(&reg_requests_lock);
3473         list_splice_tail_init(&reg_requests_list, &tmp_reg_req_list);
3474         spin_unlock(&reg_requests_lock);
3475
3476         /* Clear beacon hints */
3477         spin_lock_bh(&reg_pending_beacons_lock);
3478         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3479                 list_del(&reg_beacon->list);
3480                 kfree(reg_beacon);
3481         }
3482         spin_unlock_bh(&reg_pending_beacons_lock);
3483
3484         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3485                 list_del(&reg_beacon->list);
3486                 kfree(reg_beacon);
3487         }
3488
3489         /* First restore to the basic regulatory settings */
3490         world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
3491         world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
3492
3493         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3494                 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3495                         continue;
3496                 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
3497                         restore_custom_reg_settings(&rdev->wiphy);
3498         }
3499
3500         if (cached && (!is_an_alpha2(alpha2) ||
3501                        !IS_ERR_OR_NULL(cfg80211_user_regdom))) {
3502                 reset_regdomains(false, cfg80211_world_regdom);
3503                 update_all_wiphy_regulatory(NL80211_REGDOM_SET_BY_CORE);
3504                 print_regdomain(get_cfg80211_regdom());
3505                 nl80211_send_reg_change_event(&core_request_world);
3506                 reg_set_request_processed();
3507
3508                 if (is_an_alpha2(alpha2) &&
3509                     !regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER)) {
3510                         struct regulatory_request *ureq;
3511
3512                         spin_lock(&reg_requests_lock);
3513                         ureq = list_last_entry(&reg_requests_list,
3514                                                struct regulatory_request,
3515                                                list);
3516                         list_del(&ureq->list);
3517                         spin_unlock(&reg_requests_lock);
3518
3519                         notify_self_managed_wiphys(ureq);
3520                         reg_update_last_request(ureq);
3521                         set_regdom(reg_copy_regd(cfg80211_user_regdom),
3522                                    REGD_SOURCE_CACHED);
3523                 }
3524         } else {
3525                 regulatory_hint_core(world_alpha2);
3526
3527                 /*
3528                  * This restores the ieee80211_regdom module parameter
3529                  * preference or the last user requested regulatory
3530                  * settings, user regulatory settings takes precedence.
3531                  */
3532                 if (is_an_alpha2(alpha2))
3533                         regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER);
3534         }
3535
3536         spin_lock(&reg_requests_lock);
3537         list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
3538         spin_unlock(&reg_requests_lock);
3539
3540         pr_debug("Kicking the queue\n");
3541
3542         schedule_work(&reg_work);
3543 }
3544
3545 static bool is_wiphy_all_set_reg_flag(enum ieee80211_regulatory_flags flag)
3546 {
3547         struct cfg80211_registered_device *rdev;
3548         struct wireless_dev *wdev;
3549
3550         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3551                 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3552                         wdev_lock(wdev);
3553                         if (!(wdev->wiphy->regulatory_flags & flag)) {
3554                                 wdev_unlock(wdev);
3555                                 return false;
3556                         }
3557                         wdev_unlock(wdev);
3558                 }
3559         }
3560
3561         return true;
3562 }
3563
3564 void regulatory_hint_disconnect(void)
3565 {
3566         /* Restore of regulatory settings is not required when wiphy(s)
3567          * ignore IE from connected access point but clearance of beacon hints
3568          * is required when wiphy(s) supports beacon hints.
3569          */
3570         if (is_wiphy_all_set_reg_flag(REGULATORY_COUNTRY_IE_IGNORE)) {
3571                 struct reg_beacon *reg_beacon, *btmp;
3572
3573                 if (is_wiphy_all_set_reg_flag(REGULATORY_DISABLE_BEACON_HINTS))
3574                         return;
3575
3576                 spin_lock_bh(&reg_pending_beacons_lock);
3577                 list_for_each_entry_safe(reg_beacon, btmp,
3578                                          &reg_pending_beacons, list) {
3579                         list_del(&reg_beacon->list);
3580                         kfree(reg_beacon);
3581                 }
3582                 spin_unlock_bh(&reg_pending_beacons_lock);
3583
3584                 list_for_each_entry_safe(reg_beacon, btmp,
3585                                          &reg_beacon_list, list) {
3586                         list_del(&reg_beacon->list);
3587                         kfree(reg_beacon);
3588                 }
3589
3590                 return;
3591         }
3592
3593         pr_debug("All devices are disconnected, going to restore regulatory settings\n");
3594         restore_regulatory_settings(false, true);
3595 }
3596
3597 static bool freq_is_chan_12_13_14(u32 freq)
3598 {
3599         if (freq == ieee80211_channel_to_frequency(12, NL80211_BAND_2GHZ) ||
3600             freq == ieee80211_channel_to_frequency(13, NL80211_BAND_2GHZ) ||
3601             freq == ieee80211_channel_to_frequency(14, NL80211_BAND_2GHZ))
3602                 return true;
3603         return false;
3604 }
3605
3606 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
3607 {
3608         struct reg_beacon *pending_beacon;
3609
3610         list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
3611                 if (ieee80211_channel_equal(beacon_chan,
3612                                             &pending_beacon->chan))
3613                         return true;
3614         return false;
3615 }
3616
3617 int regulatory_hint_found_beacon(struct wiphy *wiphy,
3618                                  struct ieee80211_channel *beacon_chan,
3619                                  gfp_t gfp)
3620 {
3621         struct reg_beacon *reg_beacon;
3622         bool processing;
3623
3624         if (beacon_chan->beacon_found ||
3625             beacon_chan->flags & IEEE80211_CHAN_RADAR ||
3626             (beacon_chan->band == NL80211_BAND_2GHZ &&
3627              !freq_is_chan_12_13_14(beacon_chan->center_freq)))
3628                 return 0;
3629
3630         spin_lock_bh(&reg_pending_beacons_lock);
3631         processing = pending_reg_beacon(beacon_chan);
3632         spin_unlock_bh(&reg_pending_beacons_lock);
3633
3634         if (processing)
3635                 return 0;
3636
3637         reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
3638         if (!reg_beacon)
3639                 return -ENOMEM;
3640
3641         pr_debug("Found new beacon on frequency: %d.%03d MHz (Ch %d) on %s\n",
3642                  beacon_chan->center_freq, beacon_chan->freq_offset,
3643                  ieee80211_freq_khz_to_channel(
3644                          ieee80211_channel_to_khz(beacon_chan)),
3645                  wiphy_name(wiphy));
3646
3647         memcpy(&reg_beacon->chan, beacon_chan,
3648                sizeof(struct ieee80211_channel));
3649
3650         /*
3651          * Since we can be called from BH or and non-BH context
3652          * we must use spin_lock_bh()
3653          */
3654         spin_lock_bh(&reg_pending_beacons_lock);
3655         list_add_tail(&reg_beacon->list, &reg_pending_beacons);
3656         spin_unlock_bh(&reg_pending_beacons_lock);
3657
3658         schedule_work(&reg_work);
3659
3660         return 0;
3661 }
3662
3663 static void print_rd_rules(const struct ieee80211_regdomain *rd)
3664 {
3665         unsigned int i;
3666         const struct ieee80211_reg_rule *reg_rule = NULL;
3667         const struct ieee80211_freq_range *freq_range = NULL;
3668         const struct ieee80211_power_rule *power_rule = NULL;
3669         char bw[32], cac_time[32];
3670
3671         pr_debug("  (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
3672
3673         for (i = 0; i < rd->n_reg_rules; i++) {
3674                 reg_rule = &rd->reg_rules[i];
3675                 freq_range = &reg_rule->freq_range;
3676                 power_rule = &reg_rule->power_rule;
3677
3678                 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
3679                         snprintf(bw, sizeof(bw), "%d KHz, %u KHz AUTO",
3680                                  freq_range->max_bandwidth_khz,
3681                                  reg_get_max_bandwidth(rd, reg_rule));
3682                 else
3683                         snprintf(bw, sizeof(bw), "%d KHz",
3684                                  freq_range->max_bandwidth_khz);
3685
3686                 if (reg_rule->flags & NL80211_RRF_DFS)
3687                         scnprintf(cac_time, sizeof(cac_time), "%u s",
3688                                   reg_rule->dfs_cac_ms/1000);
3689                 else
3690                         scnprintf(cac_time, sizeof(cac_time), "N/A");
3691
3692
3693                 /*
3694                  * There may not be documentation for max antenna gain
3695                  * in certain regions
3696                  */
3697                 if (power_rule->max_antenna_gain)
3698                         pr_debug("  (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
3699                                 freq_range->start_freq_khz,
3700                                 freq_range->end_freq_khz,
3701                                 bw,
3702                                 power_rule->max_antenna_gain,
3703                                 power_rule->max_eirp,
3704                                 cac_time);
3705                 else
3706                         pr_debug("  (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
3707                                 freq_range->start_freq_khz,
3708                                 freq_range->end_freq_khz,
3709                                 bw,
3710                                 power_rule->max_eirp,
3711                                 cac_time);
3712         }
3713 }
3714
3715 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
3716 {
3717         switch (dfs_region) {
3718         case NL80211_DFS_UNSET:
3719         case NL80211_DFS_FCC:
3720         case NL80211_DFS_ETSI:
3721         case NL80211_DFS_JP:
3722                 return true;
3723         default:
3724                 pr_debug("Ignoring unknown DFS master region: %d\n", dfs_region);
3725                 return false;
3726         }
3727 }
3728
3729 static void print_regdomain(const struct ieee80211_regdomain *rd)
3730 {
3731         struct regulatory_request *lr = get_last_request();
3732
3733         if (is_intersected_alpha2(rd->alpha2)) {
3734                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
3735                         struct cfg80211_registered_device *rdev;
3736                         rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
3737                         if (rdev) {
3738                                 pr_debug("Current regulatory domain updated by AP to: %c%c\n",
3739                                         rdev->country_ie_alpha2[0],
3740                                         rdev->country_ie_alpha2[1]);
3741                         } else
3742                                 pr_debug("Current regulatory domain intersected:\n");
3743                 } else
3744                         pr_debug("Current regulatory domain intersected:\n");
3745         } else if (is_world_regdom(rd->alpha2)) {
3746                 pr_debug("World regulatory domain updated:\n");
3747         } else {
3748                 if (is_unknown_alpha2(rd->alpha2))
3749                         pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
3750                 else {
3751                         if (reg_request_cell_base(lr))
3752                                 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
3753                                         rd->alpha2[0], rd->alpha2[1]);
3754                         else
3755                                 pr_debug("Regulatory domain changed to country: %c%c\n",
3756                                         rd->alpha2[0], rd->alpha2[1]);
3757                 }
3758         }
3759
3760         pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
3761         print_rd_rules(rd);
3762 }
3763
3764 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
3765 {
3766         pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
3767         print_rd_rules(rd);
3768 }
3769
3770 static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
3771 {
3772         if (!is_world_regdom(rd->alpha2))
3773                 return -EINVAL;
3774         update_world_regdomain(rd);
3775         return 0;
3776 }
3777
3778 static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
3779                            struct regulatory_request *user_request)
3780 {
3781         const struct ieee80211_regdomain *intersected_rd = NULL;
3782
3783         if (!regdom_changes(rd->alpha2))
3784                 return -EALREADY;
3785
3786         if (!is_valid_rd(rd)) {
3787                 pr_err("Invalid regulatory domain detected: %c%c\n",
3788                        rd->alpha2[0], rd->alpha2[1]);
3789                 print_regdomain_info(rd);
3790                 return -EINVAL;
3791         }
3792
3793         if (!user_request->intersect) {
3794                 reset_regdomains(false, rd);
3795                 return 0;
3796         }
3797
3798         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3799         if (!intersected_rd)
3800                 return -EINVAL;
3801
3802         kfree(rd);
3803         rd = NULL;
3804         reset_regdomains(false, intersected_rd);
3805
3806         return 0;
3807 }
3808
3809 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
3810                              struct regulatory_request *driver_request)
3811 {
3812         const struct ieee80211_regdomain *regd;
3813         const struct ieee80211_regdomain *intersected_rd = NULL;
3814         const struct ieee80211_regdomain *tmp;
3815         struct wiphy *request_wiphy;
3816
3817         if (is_world_regdom(rd->alpha2))
3818                 return -EINVAL;
3819
3820         if (!regdom_changes(rd->alpha2))
3821                 return -EALREADY;
3822
3823         if (!is_valid_rd(rd)) {
3824                 pr_err("Invalid regulatory domain detected: %c%c\n",
3825                        rd->alpha2[0], rd->alpha2[1]);
3826                 print_regdomain_info(rd);
3827                 return -EINVAL;
3828         }
3829
3830         request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
3831         if (!request_wiphy)
3832                 return -ENODEV;
3833
3834         if (!driver_request->intersect) {
3835                 ASSERT_RTNL();
3836                 wiphy_lock(request_wiphy);
3837                 if (request_wiphy->regd) {
3838                         wiphy_unlock(request_wiphy);
3839                         return -EALREADY;
3840                 }
3841
3842                 regd = reg_copy_regd(rd);
3843                 if (IS_ERR(regd)) {
3844                         wiphy_unlock(request_wiphy);
3845                         return PTR_ERR(regd);
3846                 }
3847
3848                 rcu_assign_pointer(request_wiphy->regd, regd);
3849                 wiphy_unlock(request_wiphy);
3850                 reset_regdomains(false, rd);
3851                 return 0;
3852         }
3853
3854         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3855         if (!intersected_rd)
3856                 return -EINVAL;
3857
3858         /*
3859          * We can trash what CRDA provided now.
3860          * However if a driver requested this specific regulatory
3861          * domain we keep it for its private use
3862          */
3863         tmp = get_wiphy_regdom(request_wiphy);
3864         rcu_assign_pointer(request_wiphy->regd, rd);
3865         rcu_free_regdom(tmp);
3866
3867         rd = NULL;
3868
3869         reset_regdomains(false, intersected_rd);
3870
3871         return 0;
3872 }
3873
3874 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
3875                                  struct regulatory_request *country_ie_request)
3876 {
3877         struct wiphy *request_wiphy;
3878
3879         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
3880             !is_unknown_alpha2(rd->alpha2))
3881                 return -EINVAL;
3882
3883         /*
3884          * Lets only bother proceeding on the same alpha2 if the current
3885          * rd is non static (it means CRDA was present and was used last)
3886          * and the pending request came in from a country IE
3887          */
3888
3889         if (!is_valid_rd(rd)) {
3890                 pr_err("Invalid regulatory domain detected: %c%c\n",
3891                        rd->alpha2[0], rd->alpha2[1]);
3892                 print_regdomain_info(rd);
3893                 return -EINVAL;
3894         }
3895
3896         request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
3897         if (!request_wiphy)
3898                 return -ENODEV;
3899
3900         if (country_ie_request->intersect)
3901                 return -EINVAL;
3902
3903         reset_regdomains(false, rd);
3904         return 0;
3905 }
3906
3907 /*
3908  * Use this call to set the current regulatory domain. Conflicts with
3909  * multiple drivers can be ironed out later. Caller must've already
3910  * kmalloc'd the rd structure.
3911  */
3912 int set_regdom(const struct ieee80211_regdomain *rd,
3913                enum ieee80211_regd_source regd_src)
3914 {
3915         struct regulatory_request *lr;
3916         bool user_reset = false;
3917         int r;
3918
3919         if (IS_ERR_OR_NULL(rd))
3920                 return -ENODATA;
3921
3922         if (!reg_is_valid_request(rd->alpha2)) {
3923                 kfree(rd);
3924                 return -EINVAL;
3925         }
3926
3927         if (regd_src == REGD_SOURCE_CRDA)
3928                 reset_crda_timeouts();
3929
3930         lr = get_last_request();
3931
3932         /* Note that this doesn't update the wiphys, this is done below */
3933         switch (lr->initiator) {
3934         case NL80211_REGDOM_SET_BY_CORE:
3935                 r = reg_set_rd_core(rd);
3936                 break;
3937         case NL80211_REGDOM_SET_BY_USER:
3938                 cfg80211_save_user_regdom(rd);
3939                 r = reg_set_rd_user(rd, lr);
3940                 user_reset = true;
3941                 break;
3942         case NL80211_REGDOM_SET_BY_DRIVER:
3943                 r = reg_set_rd_driver(rd, lr);
3944                 break;
3945         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3946                 r = reg_set_rd_country_ie(rd, lr);
3947                 break;
3948         default:
3949                 WARN(1, "invalid initiator %d\n", lr->initiator);
3950                 kfree(rd);
3951                 return -EINVAL;
3952         }
3953
3954         if (r) {
3955                 switch (r) {
3956                 case -EALREADY:
3957                         reg_set_request_processed();
3958                         break;
3959                 default:
3960                         /* Back to world regulatory in case of errors */
3961                         restore_regulatory_settings(user_reset, false);
3962                 }
3963
3964                 kfree(rd);
3965                 return r;
3966         }
3967
3968         /* This would make this whole thing pointless */
3969         if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
3970                 return -EINVAL;
3971
3972         /* update all wiphys now with the new established regulatory domain */
3973         update_all_wiphy_regulatory(lr->initiator);
3974
3975         print_regdomain(get_cfg80211_regdom());
3976
3977         nl80211_send_reg_change_event(lr);
3978
3979         reg_set_request_processed();
3980
3981         return 0;
3982 }
3983
3984 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
3985                                        struct ieee80211_regdomain *rd)
3986 {
3987         const struct ieee80211_regdomain *regd;
3988         const struct ieee80211_regdomain *prev_regd;
3989         struct cfg80211_registered_device *rdev;
3990
3991         if (WARN_ON(!wiphy || !rd))
3992                 return -EINVAL;
3993
3994         if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
3995                  "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
3996                 return -EPERM;
3997
3998         if (WARN(!is_valid_rd(rd),
3999                  "Invalid regulatory domain detected: %c%c\n",
4000                  rd->alpha2[0], rd->alpha2[1])) {
4001                 print_regdomain_info(rd);
4002                 return -EINVAL;
4003         }
4004
4005         regd = reg_copy_regd(rd);
4006         if (IS_ERR(regd))
4007                 return PTR_ERR(regd);
4008
4009         rdev = wiphy_to_rdev(wiphy);
4010
4011         spin_lock(&reg_requests_lock);
4012         prev_regd = rdev->requested_regd;
4013         rdev->requested_regd = regd;
4014         spin_unlock(&reg_requests_lock);
4015
4016         kfree(prev_regd);
4017         return 0;
4018 }
4019
4020 int regulatory_set_wiphy_regd(struct wiphy *wiphy,
4021                               struct ieee80211_regdomain *rd)
4022 {
4023         int ret = __regulatory_set_wiphy_regd(wiphy, rd);
4024
4025         if (ret)
4026                 return ret;
4027
4028         schedule_work(&reg_work);
4029         return 0;
4030 }
4031 EXPORT_SYMBOL(regulatory_set_wiphy_regd);
4032
4033 int regulatory_set_wiphy_regd_sync(struct wiphy *wiphy,
4034                                    struct ieee80211_regdomain *rd)
4035 {
4036         int ret;
4037
4038         ASSERT_RTNL();
4039
4040         ret = __regulatory_set_wiphy_regd(wiphy, rd);
4041         if (ret)
4042                 return ret;
4043
4044         /* process the request immediately */
4045         reg_process_self_managed_hint(wiphy);
4046         reg_check_channels();
4047         return 0;
4048 }
4049 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync);
4050
4051 void wiphy_regulatory_register(struct wiphy *wiphy)
4052 {
4053         struct regulatory_request *lr = get_last_request();
4054
4055         /* self-managed devices ignore beacon hints and country IE */
4056         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
4057                 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
4058                                            REGULATORY_COUNTRY_IE_IGNORE;
4059
4060                 /*
4061                  * The last request may have been received before this
4062                  * registration call. Call the driver notifier if
4063                  * initiator is USER.
4064                  */
4065                 if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
4066                         reg_call_notifier(wiphy, lr);
4067         }
4068
4069         if (!reg_dev_ignore_cell_hint(wiphy))
4070                 reg_num_devs_support_basehint++;
4071
4072         wiphy_update_regulatory(wiphy, lr->initiator);
4073         wiphy_all_share_dfs_chan_state(wiphy);
4074         reg_process_self_managed_hints();
4075 }
4076
4077 void wiphy_regulatory_deregister(struct wiphy *wiphy)
4078 {
4079         struct wiphy *request_wiphy = NULL;
4080         struct regulatory_request *lr;
4081
4082         lr = get_last_request();
4083
4084         if (!reg_dev_ignore_cell_hint(wiphy))
4085                 reg_num_devs_support_basehint--;
4086
4087         rcu_free_regdom(get_wiphy_regdom(wiphy));
4088         RCU_INIT_POINTER(wiphy->regd, NULL);
4089
4090         if (lr)
4091                 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
4092
4093         if (!request_wiphy || request_wiphy != wiphy)
4094                 return;
4095
4096         lr->wiphy_idx = WIPHY_IDX_INVALID;
4097         lr->country_ie_env = ENVIRON_ANY;
4098 }
4099
4100 /*
4101  * See FCC notices for UNII band definitions
4102  *  5GHz: https://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii
4103  *  6GHz: https://www.fcc.gov/document/fcc-proposes-more-spectrum-unlicensed-use-0
4104  */
4105 int cfg80211_get_unii(int freq)
4106 {
4107         /* UNII-1 */
4108         if (freq >= 5150 && freq <= 5250)
4109                 return 0;
4110
4111         /* UNII-2A */
4112         if (freq > 5250 && freq <= 5350)
4113                 return 1;
4114
4115         /* UNII-2B */
4116         if (freq > 5350 && freq <= 5470)
4117                 return 2;
4118
4119         /* UNII-2C */
4120         if (freq > 5470 && freq <= 5725)
4121                 return 3;
4122
4123         /* UNII-3 */
4124         if (freq > 5725 && freq <= 5825)
4125                 return 4;
4126
4127         /* UNII-5 */
4128         if (freq > 5925 && freq <= 6425)
4129                 return 5;
4130
4131         /* UNII-6 */
4132         if (freq > 6425 && freq <= 6525)
4133                 return 6;
4134
4135         /* UNII-7 */
4136         if (freq > 6525 && freq <= 6875)
4137                 return 7;
4138
4139         /* UNII-8 */
4140         if (freq > 6875 && freq <= 7125)
4141                 return 8;
4142
4143         return -EINVAL;
4144 }
4145
4146 bool regulatory_indoor_allowed(void)
4147 {
4148         return reg_is_indoor;
4149 }
4150
4151 bool regulatory_pre_cac_allowed(struct wiphy *wiphy)
4152 {
4153         const struct ieee80211_regdomain *regd = NULL;
4154         const struct ieee80211_regdomain *wiphy_regd = NULL;
4155         bool pre_cac_allowed = false;
4156
4157         rcu_read_lock();
4158
4159         regd = rcu_dereference(cfg80211_regdomain);
4160         wiphy_regd = rcu_dereference(wiphy->regd);
4161         if (!wiphy_regd) {
4162                 if (regd->dfs_region == NL80211_DFS_ETSI)
4163                         pre_cac_allowed = true;
4164
4165                 rcu_read_unlock();
4166
4167                 return pre_cac_allowed;
4168         }
4169
4170         if (regd->dfs_region == wiphy_regd->dfs_region &&
4171             wiphy_regd->dfs_region == NL80211_DFS_ETSI)
4172                 pre_cac_allowed = true;
4173
4174         rcu_read_unlock();
4175
4176         return pre_cac_allowed;
4177 }
4178 EXPORT_SYMBOL(regulatory_pre_cac_allowed);
4179
4180 static void cfg80211_check_and_end_cac(struct cfg80211_registered_device *rdev)
4181 {
4182         struct wireless_dev *wdev;
4183         /* If we finished CAC or received radar, we should end any
4184          * CAC running on the same channels.
4185          * the check !cfg80211_chandef_dfs_usable contain 2 options:
4186          * either all channels are available - those the CAC_FINISHED
4187          * event has effected another wdev state, or there is a channel
4188          * in unavailable state in wdev chandef - those the RADAR_DETECTED
4189          * event has effected another wdev state.
4190          * In both cases we should end the CAC on the wdev.
4191          */
4192         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4193                 if (wdev->cac_started &&
4194                     !cfg80211_chandef_dfs_usable(&rdev->wiphy, &wdev->chandef))
4195                         rdev_end_cac(rdev, wdev->netdev);
4196         }
4197 }
4198
4199 void regulatory_propagate_dfs_state(struct wiphy *wiphy,
4200                                     struct cfg80211_chan_def *chandef,
4201                                     enum nl80211_dfs_state dfs_state,
4202                                     enum nl80211_radar_event event)
4203 {
4204         struct cfg80211_registered_device *rdev;
4205
4206         ASSERT_RTNL();
4207
4208         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
4209                 return;
4210
4211         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
4212                 if (wiphy == &rdev->wiphy)
4213                         continue;
4214
4215                 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
4216                         continue;
4217
4218                 if (!ieee80211_get_channel(&rdev->wiphy,
4219                                            chandef->chan->center_freq))
4220                         continue;
4221
4222                 cfg80211_set_dfs_state(&rdev->wiphy, chandef, dfs_state);
4223
4224                 if (event == NL80211_RADAR_DETECTED ||
4225                     event == NL80211_RADAR_CAC_FINISHED) {
4226                         cfg80211_sched_dfs_chan_update(rdev);
4227                         cfg80211_check_and_end_cac(rdev);
4228                 }
4229
4230                 nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL);
4231         }
4232 }
4233
4234 static int __init regulatory_init_db(void)
4235 {
4236         int err;
4237
4238         /*
4239          * It's possible that - due to other bugs/issues - cfg80211
4240          * never called regulatory_init() below, or that it failed;
4241          * in that case, don't try to do any further work here as
4242          * it's doomed to lead to crashes.
4243          */
4244         if (IS_ERR_OR_NULL(reg_pdev))
4245                 return -EINVAL;
4246
4247         err = load_builtin_regdb_keys();
4248         if (err) {
4249                 platform_device_unregister(reg_pdev);
4250                 return err;
4251         }
4252
4253         /* We always try to get an update for the static regdomain */
4254         err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
4255         if (err) {
4256                 if (err == -ENOMEM) {
4257                         platform_device_unregister(reg_pdev);
4258                         return err;
4259                 }
4260                 /*
4261                  * N.B. kobject_uevent_env() can fail mainly for when we're out
4262                  * memory which is handled and propagated appropriately above
4263                  * but it can also fail during a netlink_broadcast() or during
4264                  * early boot for call_usermodehelper(). For now treat these
4265                  * errors as non-fatal.
4266                  */
4267                 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
4268         }
4269
4270         /*
4271          * Finally, if the user set the module parameter treat it
4272          * as a user hint.
4273          */
4274         if (!is_world_regdom(ieee80211_regdom))
4275                 regulatory_hint_user(ieee80211_regdom,
4276                                      NL80211_USER_REG_HINT_USER);
4277
4278         return 0;
4279 }
4280 #ifndef MODULE
4281 late_initcall(regulatory_init_db);
4282 #endif
4283
4284 int __init regulatory_init(void)
4285 {
4286         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
4287         if (IS_ERR(reg_pdev))
4288                 return PTR_ERR(reg_pdev);
4289
4290         rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
4291
4292         user_alpha2[0] = '9';
4293         user_alpha2[1] = '7';
4294
4295 #ifdef MODULE
4296         return regulatory_init_db();
4297 #else
4298         return 0;
4299 #endif
4300 }
4301
4302 void regulatory_exit(void)
4303 {
4304         struct regulatory_request *reg_request, *tmp;
4305         struct reg_beacon *reg_beacon, *btmp;
4306
4307         cancel_work_sync(&reg_work);
4308         cancel_crda_timeout_sync();
4309         cancel_delayed_work_sync(&reg_check_chans);
4310
4311         /* Lock to suppress warnings */
4312         rtnl_lock();
4313         reset_regdomains(true, NULL);
4314         rtnl_unlock();
4315
4316         dev_set_uevent_suppress(&reg_pdev->dev, true);
4317
4318         platform_device_unregister(reg_pdev);
4319
4320         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
4321                 list_del(&reg_beacon->list);
4322                 kfree(reg_beacon);
4323         }
4324
4325         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
4326                 list_del(&reg_beacon->list);
4327                 kfree(reg_beacon);
4328         }
4329
4330         list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
4331                 list_del(&reg_request->list);
4332                 kfree(reg_request);
4333         }
4334
4335         if (!IS_ERR_OR_NULL(regdb))
4336                 kfree(regdb);
4337         if (!IS_ERR_OR_NULL(cfg80211_user_regdom))
4338                 kfree(cfg80211_user_regdom);
4339
4340         free_regdb_keyring();
4341 }