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