net/wireless/reg.c

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