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  *
   8  * Permission to use, copy, modify, and/or distribute this software for any
   9  * purpose with or without fee is hereby granted, provided that the above
  10  * copyright notice and this permission notice appear in all copies.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19  */
  20
  21
  22 /**
  23  * DOC: Wireless regulatory infrastructure
  24  *
  25  * The usual implementation is for a driver to read a device EEPROM to
  26  * determine which regulatory domain it should be operating under, then
  27  * looking up the allowable channels in a driver-local table and finally
  28  * registering those channels in the wiphy structure.
  29  *
  30  * Another set of compliance enforcement is for drivers to use their
  31  * own compliance limits which can be stored on the EEPROM. The host
  32  * driver or firmware may ensure these are used.
  33  *
  34  * In addition to all this we provide an extra layer of regulatory
  35  * conformance. For drivers which do not have any regulatory
  36  * information CRDA provides the complete regulatory solution.
  37  * For others it provides a community effort on further restrictions
  38  * to enhance compliance.
  39  *
  40  * Note: When number of rules --> infinity we will not be able to
  41  * index on alpha2 any more, instead we'll probably have to
  42  * rely on some SHA1 checksum of the regdomain for example.
  43  *
  44  */
  45
  46 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  47
  48 #include <linux/kernel.h>
  49 #include <linux/export.h>
  50 #include <linux/slab.h>
  51 #include <linux/list.h>
  52 #include <linux/ctype.h>
  53 #include <linux/nl80211.h>
  54 #include <linux/platform_device.h>
  55 #include <linux/moduleparam.h>
  56 #include <net/cfg80211.h>
  57 #include "core.h"
  58 #include "reg.h"
  59 #include "rdev-ops.h"
  60 #include "regdb.h"
  61 #include "nl80211.h"
  62
  63 /*
  64  * Grace period we give before making sure all current interfaces reside on
  65  * channels allowed by the current regulatory domain.
  66  */
  67 #define REG_ENFORCE_GRACE_MS 60000
  68
  69 /**
  70  * enum reg_request_treatment - regulatory request treatment
  71  *
  72  * @REG_REQ_OK: continue processing the regulatory request
  73  * @REG_REQ_IGNORE: ignore the regulatory request
  74  * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
  75  *      be intersected with the current one.
  76  * @REG_REQ_ALREADY_SET: the regulatory request will not change the current
  77  *      regulatory settings, and no further processing is required.
  78  */
  79 enum reg_request_treatment {
  80         REG_REQ_OK,
  81         REG_REQ_IGNORE,
  82         REG_REQ_INTERSECT,
  83         REG_REQ_ALREADY_SET,
  84 };
  85
  86 static struct regulatory_request core_request_world = {
  87         .initiator = NL80211_REGDOM_SET_BY_CORE,
  88         .alpha2[0] = '0',
  89         .alpha2[1] = '0',
  90         .intersect = false,
  91         .processed = true,
  92         .country_ie_env = ENVIRON_ANY,
  93 };
  94
  95 /*
  96  * Receipt of information from last regulatory request,
  97  * protected by RTNL (and can be accessed with RCU protection)
  98  */
  99 static struct regulatory_request __rcu *last_request =
 100         (void __force __rcu *)&core_request_world;
 101
 102 /* To trigger userspace events */
 103 static struct platform_device *reg_pdev;
 104
 105 /*
 106  * Central wireless core regulatory domains, we only need two,
 107  * the current one and a world regulatory domain in case we have no
 108  * information to give us an alpha2.
 109  * (protected by RTNL, can be read under RCU)
 110  */
 111 const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
 112
 113 /*
 114  * Number of devices that registered to the core
 115  * that support cellular base station regulatory hints
 116  * (protected by RTNL)
 117  */
 118 static int reg_num_devs_support_basehint;
 119
 120 /*
 121  * State variable indicating if the platform on which the devices
 122  * are attached is operating in an indoor environment. The state variable
 123  * is relevant for all registered devices.
 124  */
 125 static bool reg_is_indoor;
 126 static spinlock_t reg_indoor_lock;
 127
 128 /* Used to track the userspace process controlling the indoor setting */
 129 static u32 reg_is_indoor_portid;
 130
 131 static void restore_regulatory_settings(bool reset_user);
 132
 133 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
 134 {
 135         return rtnl_dereference(cfg80211_regdomain);
 136 }
 137
 138 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
 139 {
 140         return rtnl_dereference(wiphy->regd);
 141 }
 142
 143 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
 144 {
 145         switch (dfs_region) {
 146         case NL80211_DFS_UNSET:
 147                 return "unset";
 148         case NL80211_DFS_FCC:
 149                 return "FCC";
 150         case NL80211_DFS_ETSI:
 151                 return "ETSI";
 152         case NL80211_DFS_JP:
 153                 return "JP";
 154         }
 155         return "Unknown";
 156 }
 157
 158 enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy)
 159 {
 160         const struct ieee80211_regdomain *regd = NULL;
 161         const struct ieee80211_regdomain *wiphy_regd = NULL;
 162
 163         regd = get_cfg80211_regdom();
 164         if (!wiphy)
 165                 goto out;
 166
 167         wiphy_regd = get_wiphy_regdom(wiphy);
 168         if (!wiphy_regd)
 169                 goto out;
 170
 171         if (wiphy_regd->dfs_region == regd->dfs_region)
 172                 goto out;
 173
 174         pr_debug("%s: device specific dfs_region (%s) disagrees with cfg80211's central dfs_region (%s)\n",
 175                  dev_name(&wiphy->dev),
 176                  reg_dfs_region_str(wiphy_regd->dfs_region),
 177                  reg_dfs_region_str(regd->dfs_region));
 178
 179 out:
 180         return regd->dfs_region;
 181 }
 182
 183 static void rcu_free_regdom(const struct ieee80211_regdomain *r)
 184 {
 185         if (!r)
 186                 return;
 187         kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
 188 }
 189
 190 static struct regulatory_request *get_last_request(void)
 191 {
 192         return rcu_dereference_rtnl(last_request);
 193 }
 194
 195 /* Used to queue up regulatory hints */
 196 static LIST_HEAD(reg_requests_list);
 197 static spinlock_t reg_requests_lock;
 198
 199 /* Used to queue up beacon hints for review */
 200 static LIST_HEAD(reg_pending_beacons);
 201 static spinlock_t reg_pending_beacons_lock;
 202
 203 /* Used to keep track of processed beacon hints */
 204 static LIST_HEAD(reg_beacon_list);
 205
 206 struct reg_beacon {
 207         struct list_head list;
 208         struct ieee80211_channel chan;
 209 };
 210
 211 static void reg_check_chans_work(struct work_struct *work);
 212 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
 213
 214 static void reg_todo(struct work_struct *work);
 215 static DECLARE_WORK(reg_work, reg_todo);
 216
 217 /* We keep a static world regulatory domain in case of the absence of CRDA */
 218 static const struct ieee80211_regdomain world_regdom = {
 219         .n_reg_rules = 8,
 220         .alpha2 =  "00",
 221         .reg_rules = {
 222                 /* IEEE 802.11b/g, channels 1..11 */
 223                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
 224                 /* IEEE 802.11b/g, channels 12..13. */
 225                 REG_RULE(2467-10, 2472+10, 20, 6, 20,
 226                         NL80211_RRF_NO_IR | NL80211_RRF_AUTO_BW),
 227                 /* IEEE 802.11 channel 14 - Only JP enables
 228                  * this and for 802.11b only */
 229                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
 230                         NL80211_RRF_NO_IR |
 231                         NL80211_RRF_NO_OFDM),
 232                 /* IEEE 802.11a, channel 36..48 */
 233                 REG_RULE(5180-10, 5240+10, 80, 6, 20,
 234                         NL80211_RRF_NO_IR |
 235                         NL80211_RRF_AUTO_BW),
 236
 237                 /* IEEE 802.11a, channel 52..64 - DFS required */
 238                 REG_RULE(5260-10, 5320+10, 80, 6, 20,
 239                         NL80211_RRF_NO_IR |
 240                         NL80211_RRF_AUTO_BW |
 241                         NL80211_RRF_DFS),
 242
 243                 /* IEEE 802.11a, channel 100..144 - DFS required */
 244                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
 245                         NL80211_RRF_NO_IR |
 246                         NL80211_RRF_DFS),
 247
 248                 /* IEEE 802.11a, channel 149..165 */
 249                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
 250                         NL80211_RRF_NO_IR),
 251
 252                 /* IEEE 802.11ad (60GHz), channels 1..3 */
 253                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
 254         }
 255 };
 256
 257 /* protected by RTNL */
 258 static const struct ieee80211_regdomain *cfg80211_world_regdom =
 259         &world_regdom;
 260
 261 static char *ieee80211_regdom = "00";
 262 static char user_alpha2[2];
 263
 264 module_param(ieee80211_regdom, charp, 0444);
 265 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 266
 267 static void reg_free_request(struct regulatory_request *request)
 268 {
 269         if (request == &core_request_world)
 270                 return;
 271
 272         if (request != get_last_request())
 273                 kfree(request);
 274 }
 275
 276 static void reg_free_last_request(void)
 277 {
 278         struct regulatory_request *lr = get_last_request();
 279
 280         if (lr != &core_request_world && lr)
 281                 kfree_rcu(lr, rcu_head);
 282 }
 283
 284 static void reg_update_last_request(struct regulatory_request *request)
 285 {
 286         struct regulatory_request *lr;
 287
 288         lr = get_last_request();
 289         if (lr == request)
 290                 return;
 291
 292         reg_free_last_request();
 293         rcu_assign_pointer(last_request, request);
 294 }
 295
 296 static void reset_regdomains(bool full_reset,
 297                              const struct ieee80211_regdomain *new_regdom)
 298 {
 299         const struct ieee80211_regdomain *r;
 300
 301         ASSERT_RTNL();
 302
 303         r = get_cfg80211_regdom();
 304
 305         /* avoid freeing static information or freeing something twice */
 306         if (r == cfg80211_world_regdom)
 307                 r = NULL;
 308         if (cfg80211_world_regdom == &world_regdom)
 309                 cfg80211_world_regdom = NULL;
 310         if (r == &world_regdom)
 311                 r = NULL;
 312
 313         rcu_free_regdom(r);
 314         rcu_free_regdom(cfg80211_world_regdom);
 315
 316         cfg80211_world_regdom = &world_regdom;
 317         rcu_assign_pointer(cfg80211_regdomain, new_regdom);
 318
 319         if (!full_reset)
 320                 return;
 321
 322         reg_update_last_request(&core_request_world);
 323 }
 324
 325 /*
 326  * Dynamic world regulatory domain requested by the wireless
 327  * core upon initialization
 328  */
 329 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 330 {
 331         struct regulatory_request *lr;
 332
 333         lr = get_last_request();
 334
 335         WARN_ON(!lr);
 336
 337         reset_regdomains(false, rd);
 338
 339         cfg80211_world_regdom = rd;
 340 }
 341
 342 bool is_world_regdom(const char *alpha2)
 343 {
 344         if (!alpha2)
 345                 return false;
 346         return alpha2[0] == '0' && alpha2[1] == '0';
 347 }
 348
 349 static bool is_alpha2_set(const char *alpha2)
 350 {
 351         if (!alpha2)
 352                 return false;
 353         return alpha2[0] && alpha2[1];
 354 }
 355
 356 static bool is_unknown_alpha2(const char *alpha2)
 357 {
 358         if (!alpha2)
 359                 return false;
 360         /*
 361          * Special case where regulatory domain was built by driver
 362          * but a specific alpha2 cannot be determined
 363          */
 364         return alpha2[0] == '9' && alpha2[1] == '9';
 365 }
 366
 367 static bool is_intersected_alpha2(const char *alpha2)
 368 {
 369         if (!alpha2)
 370                 return false;
 371         /*
 372          * Special case where regulatory domain is the
 373          * result of an intersection between two regulatory domain
 374          * structures
 375          */
 376         return alpha2[0] == '9' && alpha2[1] == '8';
 377 }
 378
 379 static bool is_an_alpha2(const char *alpha2)
 380 {
 381         if (!alpha2)
 382                 return false;
 383         return isalpha(alpha2[0]) && isalpha(alpha2[1]);
 384 }
 385
 386 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 387 {
 388         if (!alpha2_x || !alpha2_y)
 389                 return false;
 390         return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
 391 }
 392
 393 static bool regdom_changes(const char *alpha2)
 394 {
 395         const struct ieee80211_regdomain *r = get_cfg80211_regdom();
 396
 397         if (!r)
 398                 return true;
 399         return !alpha2_equal(r->alpha2, alpha2);
 400 }
 401
 402 /*
 403  * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
 404  * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
 405  * has ever been issued.
 406  */
 407 static bool is_user_regdom_saved(void)
 408 {
 409         if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
 410                 return false;
 411
 412         /* This would indicate a mistake on the design */
 413         if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
 414                  "Unexpected user alpha2: %c%c\n",
 415                  user_alpha2[0], user_alpha2[1]))
 416                 return false;
 417
 418         return true;
 419 }
 420
 421 static const struct ieee80211_regdomain *
 422 reg_copy_regd(const struct ieee80211_regdomain *src_regd)
 423 {
 424         struct ieee80211_regdomain *regd;
 425         int size_of_regd;
 426         unsigned int i;
 427
 428         size_of_regd =
 429                 sizeof(struct ieee80211_regdomain) +
 430                 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
 431
 432         regd = kzalloc(size_of_regd, GFP_KERNEL);
 433         if (!regd)
 434                 return ERR_PTR(-ENOMEM);
 435
 436         memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
 437
 438         for (i = 0; i < src_regd->n_reg_rules; i++)
 439                 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
 440                        sizeof(struct ieee80211_reg_rule));
 441
 442         return regd;
 443 }
 444
 445 #ifdef CONFIG_CFG80211_INTERNAL_REGDB
 446 struct reg_regdb_apply_request {
 447         struct list_head list;
 448         const struct ieee80211_regdomain *regdom;
 449 };
 450
 451 static LIST_HEAD(reg_regdb_apply_list);
 452 static DEFINE_MUTEX(reg_regdb_apply_mutex);
 453
 454 static void reg_regdb_apply(struct work_struct *work)
 455 {
 456         struct reg_regdb_apply_request *request;
 457
 458         rtnl_lock();
 459
 460         mutex_lock(&reg_regdb_apply_mutex);
 461         while (!list_empty(&reg_regdb_apply_list)) {
 462                 request = list_first_entry(&reg_regdb_apply_list,
 463                                            struct reg_regdb_apply_request,
 464                                            list);
 465                 list_del(&request->list);
 466
 467                 set_regdom(request->regdom, REGD_SOURCE_INTERNAL_DB);
 468                 kfree(request);
 469         }
 470         mutex_unlock(&reg_regdb_apply_mutex);
 471
 472         rtnl_unlock();
 473 }
 474
 475 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply);
 476
 477 static int reg_query_builtin(const char *alpha2)
 478 {
 479         const struct ieee80211_regdomain *regdom = NULL;
 480         struct reg_regdb_apply_request *request;
 481         unsigned int i;
 482
 483         for (i = 0; i < reg_regdb_size; i++) {
 484                 if (alpha2_equal(alpha2, reg_regdb[i]->alpha2)) {
 485                         regdom = reg_regdb[i];
 486                         break;
 487                 }
 488         }
 489
 490         if (!regdom)
 491                 return -ENODATA;
 492
 493         request = kzalloc(sizeof(struct reg_regdb_apply_request), GFP_KERNEL);
 494         if (!request)
 495                 return -ENOMEM;
 496
 497         request->regdom = reg_copy_regd(regdom);
 498         if (IS_ERR_OR_NULL(request->regdom)) {
 499                 kfree(request);
 500                 return -ENOMEM;
 501         }
 502
 503         mutex_lock(&reg_regdb_apply_mutex);
 504         list_add_tail(&request->list, &reg_regdb_apply_list);
 505         mutex_unlock(&reg_regdb_apply_mutex);
 506
 507         schedule_work(&reg_regdb_work);
 508
 509         return 0;
 510 }
 511
 512 /* Feel free to add any other sanity checks here */
 513 static void reg_regdb_size_check(void)
 514 {
 515         /* We should ideally BUILD_BUG_ON() but then random builds would fail */
 516         WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
 517 }
 518 #else
 519 static inline void reg_regdb_size_check(void) {}
 520 static inline int reg_query_builtin(const char *alpha2)
 521 {
 522         return -ENODATA;
 523 }
 524 #endif /* CONFIG_CFG80211_INTERNAL_REGDB */
 525
 526 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
 527 /* Max number of consecutive attempts to communicate with CRDA  */
 528 #define REG_MAX_CRDA_TIMEOUTS 10
 529
 530 static u32 reg_crda_timeouts;
 531
 532 static void crda_timeout_work(struct work_struct *work);
 533 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work);
 534
 535 static void crda_timeout_work(struct work_struct *work)
 536 {
 537         pr_debug("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
 538         rtnl_lock();
 539         reg_crda_timeouts++;
 540         restore_regulatory_settings(true);
 541         rtnl_unlock();
 542 }
 543
 544 static void cancel_crda_timeout(void)
 545 {
 546         cancel_delayed_work(&crda_timeout);
 547 }
 548
 549 static void cancel_crda_timeout_sync(void)
 550 {
 551         cancel_delayed_work_sync(&crda_timeout);
 552 }
 553
 554 static void reset_crda_timeouts(void)
 555 {
 556         reg_crda_timeouts = 0;
 557 }
 558
 559 /*
 560  * This lets us keep regulatory code which is updated on a regulatory
 561  * basis in userspace.
 562  */
 563 static int call_crda(const char *alpha2)
 564 {
 565         char country[12];
 566         char *env[] = { country, NULL };
 567         int ret;
 568
 569         snprintf(country, sizeof(country), "COUNTRY=%c%c",
 570                  alpha2[0], alpha2[1]);
 571
 572         if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
 573                 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
 574                 return -EINVAL;
 575         }
 576
 577         if (!is_world_regdom((char *) alpha2))
 578                 pr_debug("Calling CRDA for country: %c%c\n",
 579                          alpha2[0], alpha2[1]);
 580         else
 581                 pr_debug("Calling CRDA to update world regulatory domain\n");
 582
 583         ret = kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);
 584         if (ret)
 585                 return ret;
 586
 587         queue_delayed_work(system_power_efficient_wq,
 588                            &crda_timeout, msecs_to_jiffies(3142));
 589         return 0;
 590 }
 591 #else
 592 static inline void cancel_crda_timeout(void) {}
 593 static inline void cancel_crda_timeout_sync(void) {}
 594 static inline void reset_crda_timeouts(void) {}
 595 static inline int call_crda(const char *alpha2)
 596 {
 597         return -ENODATA;
 598 }
 599 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
 600
 601 static bool reg_query_database(struct regulatory_request *request)
 602 {
 603         /* query internal regulatory database (if it exists) */
 604         if (reg_query_builtin(request->alpha2) == 0)
 605                 return true;
 606
 607         if (call_crda(request->alpha2) == 0)
 608                 return true;
 609
 610         return false;
 611 }
 612
 613 bool reg_is_valid_request(const char *alpha2)
 614 {
 615         struct regulatory_request *lr = get_last_request();
 616
 617         if (!lr || lr->processed)
 618                 return false;
 619
 620         return alpha2_equal(lr->alpha2, alpha2);
 621 }
 622
 623 static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
 624 {
 625         struct regulatory_request *lr = get_last_request();
 626
 627         /*
 628          * Follow the driver's regulatory domain, if present, unless a country
 629          * IE has been processed or a user wants to help complaince further
 630          */
 631         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 632             lr->initiator != NL80211_REGDOM_SET_BY_USER &&
 633             wiphy->regd)
 634                 return get_wiphy_regdom(wiphy);
 635
 636         return get_cfg80211_regdom();
 637 }
 638
 639 static unsigned int
 640 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
 641                                  const struct ieee80211_reg_rule *rule)
 642 {
 643         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 644         const struct ieee80211_freq_range *freq_range_tmp;
 645         const struct ieee80211_reg_rule *tmp;
 646         u32 start_freq, end_freq, idx, no;
 647
 648         for (idx = 0; idx < rd->n_reg_rules; idx++)
 649                 if (rule == &rd->reg_rules[idx])
 650                         break;
 651
 652         if (idx == rd->n_reg_rules)
 653                 return 0;
 654
 655         /* get start_freq */
 656         no = idx;
 657
 658         while (no) {
 659                 tmp = &rd->reg_rules[--no];
 660                 freq_range_tmp = &tmp->freq_range;
 661
 662                 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
 663                         break;
 664
 665                 freq_range = freq_range_tmp;
 666         }
 667
 668         start_freq = freq_range->start_freq_khz;
 669
 670         /* get end_freq */
 671         freq_range = &rule->freq_range;
 672         no = idx;
 673
 674         while (no < rd->n_reg_rules - 1) {
 675                 tmp = &rd->reg_rules[++no];
 676                 freq_range_tmp = &tmp->freq_range;
 677
 678                 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
 679                         break;
 680
 681                 freq_range = freq_range_tmp;
 682         }
 683
 684         end_freq = freq_range->end_freq_khz;
 685
 686         return end_freq - start_freq;
 687 }
 688
 689 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
 690                                    const struct ieee80211_reg_rule *rule)
 691 {
 692         unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
 693
 694         if (rule->flags & NL80211_RRF_NO_160MHZ)
 695                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
 696         if (rule->flags & NL80211_RRF_NO_80MHZ)
 697                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
 698
 699         /*
 700          * HT40+/HT40- limits are handled per-channel. Only limit BW if both
 701          * are not allowed.
 702          */
 703         if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
 704             rule->flags & NL80211_RRF_NO_HT40PLUS)
 705                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
 706
 707         return bw;
 708 }
 709
 710 /* Sanity check on a regulatory rule */
 711 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 712 {
 713         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 714         u32 freq_diff;
 715
 716         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
 717                 return false;
 718
 719         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
 720                 return false;
 721
 722         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 723
 724         if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
 725             freq_range->max_bandwidth_khz > freq_diff)
 726                 return false;
 727
 728         return true;
 729 }
 730
 731 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
 732 {
 733         const struct ieee80211_reg_rule *reg_rule = NULL;
 734         unsigned int i;
 735
 736         if (!rd->n_reg_rules)
 737                 return false;
 738
 739         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 740                 return false;
 741
 742         for (i = 0; i < rd->n_reg_rules; i++) {
 743                 reg_rule = &rd->reg_rules[i];
 744                 if (!is_valid_reg_rule(reg_rule))
 745                         return false;
 746         }
 747
 748         return true;
 749 }
 750
 751 /**
 752  * freq_in_rule_band - tells us if a frequency is in a frequency band
 753  * @freq_range: frequency rule we want to query
 754  * @freq_khz: frequency we are inquiring about
 755  *
 756  * This lets us know if a specific frequency rule is or is not relevant to
 757  * a specific frequency's band. Bands are device specific and artificial
 758  * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
 759  * however it is safe for now to assume that a frequency rule should not be
 760  * part of a frequency's band if the start freq or end freq are off by more
 761  * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
 762  * 60 GHz band.
 763  * This resolution can be lowered and should be considered as we add
 764  * regulatory rule support for other "bands".
 765  **/
 766 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 767                               u32 freq_khz)
 768 {
 769 #define ONE_GHZ_IN_KHZ  1000000
 770         /*
 771          * From 802.11ad: directional multi-gigabit (DMG):
 772          * Pertaining to operation in a frequency band containing a channel
 773          * with the Channel starting frequency above 45 GHz.
 774          */
 775         u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
 776                         10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
 777         if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
 778                 return true;
 779         if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
 780                 return true;
 781         return false;
 782 #undef ONE_GHZ_IN_KHZ
 783 }
 784
 785 /*
 786  * Later on we can perhaps use the more restrictive DFS
 787  * region but we don't have information for that yet so
 788  * for now simply disallow conflicts.
 789  */
 790 static enum nl80211_dfs_regions
 791 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
 792                          const enum nl80211_dfs_regions dfs_region2)
 793 {
 794         if (dfs_region1 != dfs_region2)
 795                 return NL80211_DFS_UNSET;
 796         return dfs_region1;
 797 }
 798
 799 /*
 800  * Helper for regdom_intersect(), this does the real
 801  * mathematical intersection fun
 802  */
 803 static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
 804                                const struct ieee80211_regdomain *rd2,
 805                                const struct ieee80211_reg_rule *rule1,
 806                                const struct ieee80211_reg_rule *rule2,
 807                                struct ieee80211_reg_rule *intersected_rule)
 808 {
 809         const struct ieee80211_freq_range *freq_range1, *freq_range2;
 810         struct ieee80211_freq_range *freq_range;
 811         const struct ieee80211_power_rule *power_rule1, *power_rule2;
 812         struct ieee80211_power_rule *power_rule;
 813         u32 freq_diff, max_bandwidth1, max_bandwidth2;
 814
 815         freq_range1 = &rule1->freq_range;
 816         freq_range2 = &rule2->freq_range;
 817         freq_range = &intersected_rule->freq_range;
 818
 819         power_rule1 = &rule1->power_rule;
 820         power_rule2 = &rule2->power_rule;
 821         power_rule = &intersected_rule->power_rule;
 822
 823         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
 824                                          freq_range2->start_freq_khz);
 825         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
 826                                        freq_range2->end_freq_khz);
 827
 828         max_bandwidth1 = freq_range1->max_bandwidth_khz;
 829         max_bandwidth2 = freq_range2->max_bandwidth_khz;
 830
 831         if (rule1->flags & NL80211_RRF_AUTO_BW)
 832                 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
 833         if (rule2->flags & NL80211_RRF_AUTO_BW)
 834                 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
 835
 836         freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
 837
 838         intersected_rule->flags = rule1->flags | rule2->flags;
 839
 840         /*
 841          * In case NL80211_RRF_AUTO_BW requested for both rules
 842          * set AUTO_BW in intersected rule also. Next we will
 843          * calculate BW correctly in handle_channel function.
 844          * In other case remove AUTO_BW flag while we calculate
 845          * maximum bandwidth correctly and auto calculation is
 846          * not required.
 847          */
 848         if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
 849             (rule2->flags & NL80211_RRF_AUTO_BW))
 850                 intersected_rule->flags |= NL80211_RRF_AUTO_BW;
 851         else
 852                 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
 853
 854         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 855         if (freq_range->max_bandwidth_khz > freq_diff)
 856                 freq_range->max_bandwidth_khz = freq_diff;
 857
 858         power_rule->max_eirp = min(power_rule1->max_eirp,
 859                 power_rule2->max_eirp);
 860         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
 861                 power_rule2->max_antenna_gain);
 862
 863         intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms,
 864                                            rule2->dfs_cac_ms);
 865
 866         if (!is_valid_reg_rule(intersected_rule))
 867                 return -EINVAL;
 868
 869         return 0;
 870 }
 871
 872 /* check whether old rule contains new rule */
 873 static bool rule_contains(struct ieee80211_reg_rule *r1,
 874                           struct ieee80211_reg_rule *r2)
 875 {
 876         /* for simplicity, currently consider only same flags */
 877         if (r1->flags != r2->flags)
 878                 return false;
 879
 880         /* verify r1 is more restrictive */
 881         if ((r1->power_rule.max_antenna_gain >
 882              r2->power_rule.max_antenna_gain) ||
 883             r1->power_rule.max_eirp > r2->power_rule.max_eirp)
 884                 return false;
 885
 886         /* make sure r2's range is contained within r1 */
 887         if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz ||
 888             r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz)
 889                 return false;
 890
 891         /* and finally verify that r1.max_bw >= r2.max_bw */
 892         if (r1->freq_range.max_bandwidth_khz <
 893             r2->freq_range.max_bandwidth_khz)
 894                 return false;
 895
 896         return true;
 897 }
 898
 899 /* add or extend current rules. do nothing if rule is already contained */
 900 static void add_rule(struct ieee80211_reg_rule *rule,
 901                      struct ieee80211_reg_rule *reg_rules, u32 *n_rules)
 902 {
 903         struct ieee80211_reg_rule *tmp_rule;
 904         int i;
 905
 906         for (i = 0; i < *n_rules; i++) {
 907                 tmp_rule = &reg_rules[i];
 908                 /* rule is already contained - do nothing */
 909                 if (rule_contains(tmp_rule, rule))
 910                         return;
 911
 912                 /* extend rule if possible */
 913                 if (rule_contains(rule, tmp_rule)) {
 914                         memcpy(tmp_rule, rule, sizeof(*rule));
 915                         return;
 916                 }
 917         }
 918
 919         memcpy(&reg_rules[*n_rules], rule, sizeof(*rule));
 920         (*n_rules)++;
 921 }
 922
 923 /**
 924  * regdom_intersect - do the intersection between two regulatory domains
 925  * @rd1: first regulatory domain
 926  * @rd2: second regulatory domain
 927  *
 928  * Use this function to get the intersection between two regulatory domains.
 929  * Once completed we will mark the alpha2 for the rd as intersected, "98",
 930  * as no one single alpha2 can represent this regulatory domain.
 931  *
 932  * Returns a pointer to the regulatory domain structure which will hold the
 933  * resulting intersection of rules between rd1 and rd2. We will
 934  * kzalloc() this structure for you.
 935  */
 936 static struct ieee80211_regdomain *
 937 regdom_intersect(const struct ieee80211_regdomain *rd1,
 938                  const struct ieee80211_regdomain *rd2)
 939 {
 940         int r, size_of_regd;
 941         unsigned int x, y;
 942         unsigned int num_rules = 0;
 943         const struct ieee80211_reg_rule *rule1, *rule2;
 944         struct ieee80211_reg_rule intersected_rule;
 945         struct ieee80211_regdomain *rd;
 946
 947         if (!rd1 || !rd2)
 948                 return NULL;
 949
 950         /*
 951          * First we get a count of the rules we'll need, then we actually
 952          * build them. This is to so we can malloc() and free() a
 953          * regdomain once. The reason we use reg_rules_intersect() here
 954          * is it will return -EINVAL if the rule computed makes no sense.
 955          * All rules that do check out OK are valid.
 956          */
 957
 958         for (x = 0; x < rd1->n_reg_rules; x++) {
 959                 rule1 = &rd1->reg_rules[x];
 960                 for (y = 0; y < rd2->n_reg_rules; y++) {
 961                         rule2 = &rd2->reg_rules[y];
 962                         if (!reg_rules_intersect(rd1, rd2, rule1, rule2,
 963                                                  &intersected_rule))
 964                                 num_rules++;
 965                 }
 966         }
 967
 968         if (!num_rules)
 969                 return NULL;
 970
 971         size_of_regd = sizeof(struct ieee80211_regdomain) +
 972                        num_rules * sizeof(struct ieee80211_reg_rule);
 973
 974         rd = kzalloc(size_of_regd, GFP_KERNEL);
 975         if (!rd)
 976                 return NULL;
 977
 978         for (x = 0; x < rd1->n_reg_rules; x++) {
 979                 rule1 = &rd1->reg_rules[x];
 980                 for (y = 0; y < rd2->n_reg_rules; y++) {
 981                         rule2 = &rd2->reg_rules[y];
 982                         r = reg_rules_intersect(rd1, rd2, rule1, rule2,
 983                                                 &intersected_rule);
 984                         /*
 985                          * No need to memset here the intersected rule here as
 986                          * we're not using the stack anymore
 987                          */
 988                         if (r)
 989                                 continue;
 990
 991                         add_rule(&intersected_rule, rd->reg_rules,
 992                                  &rd->n_reg_rules);
 993                 }
 994         }
 995
 996         rd->alpha2[0] = '9';
 997         rd->alpha2[1] = '8';
 998         rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region,
 999                                                   rd2->dfs_region);
1000
1001         return rd;
1002 }
1003
1004 /*
1005  * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
1006  * want to just have the channel structure use these
1007  */
1008 static u32 map_regdom_flags(u32 rd_flags)
1009 {
1010         u32 channel_flags = 0;
1011         if (rd_flags & NL80211_RRF_NO_IR_ALL)
1012                 channel_flags |= IEEE80211_CHAN_NO_IR;
1013         if (rd_flags & NL80211_RRF_DFS)
1014                 channel_flags |= IEEE80211_CHAN_RADAR;
1015         if (rd_flags & NL80211_RRF_NO_OFDM)
1016                 channel_flags |= IEEE80211_CHAN_NO_OFDM;
1017         if (rd_flags & NL80211_RRF_NO_OUTDOOR)
1018                 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
1019         if (rd_flags & NL80211_RRF_IR_CONCURRENT)
1020                 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT;
1021         if (rd_flags & NL80211_RRF_NO_HT40MINUS)
1022                 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
1023         if (rd_flags & NL80211_RRF_NO_HT40PLUS)
1024                 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
1025         if (rd_flags & NL80211_RRF_NO_80MHZ)
1026                 channel_flags |= IEEE80211_CHAN_NO_80MHZ;
1027         if (rd_flags & NL80211_RRF_NO_160MHZ)
1028                 channel_flags |= IEEE80211_CHAN_NO_160MHZ;
1029         return channel_flags;
1030 }
1031
1032 static const struct ieee80211_reg_rule *
1033 freq_reg_info_regd(u32 center_freq,
1034                    const struct ieee80211_regdomain *regd, u32 bw)
1035 {
1036         int i;
1037         bool band_rule_found = false;
1038         bool bw_fits = false;
1039
1040         if (!regd)
1041                 return ERR_PTR(-EINVAL);
1042
1043         for (i = 0; i < regd->n_reg_rules; i++) {
1044                 const struct ieee80211_reg_rule *rr;
1045                 const struct ieee80211_freq_range *fr = NULL;
1046
1047                 rr = &regd->reg_rules[i];
1048                 fr = &rr->freq_range;
1049
1050                 /*
1051                  * We only need to know if one frequency rule was
1052                  * was in center_freq's band, that's enough, so lets
1053                  * not overwrite it once found
1054                  */
1055                 if (!band_rule_found)
1056                         band_rule_found = freq_in_rule_band(fr, center_freq);
1057
1058                 bw_fits = cfg80211_does_bw_fit_range(fr, center_freq, bw);
1059
1060                 if (band_rule_found && bw_fits)
1061                         return rr;
1062         }
1063
1064         if (!band_rule_found)
1065                 return ERR_PTR(-ERANGE);
1066
1067         return ERR_PTR(-EINVAL);
1068 }
1069
1070 static const struct ieee80211_reg_rule *
1071 __freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw)
1072 {
1073         const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy);
1074         const struct ieee80211_reg_rule *reg_rule = NULL;
1075         u32 bw;
1076
1077         for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
1078                 reg_rule = freq_reg_info_regd(center_freq, regd, bw);
1079                 if (!IS_ERR(reg_rule))
1080                         return reg_rule;
1081         }
1082
1083         return reg_rule;
1084 }
1085
1086 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
1087                                                u32 center_freq)
1088 {
1089         return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(20));
1090 }
1091 EXPORT_SYMBOL(freq_reg_info);
1092
1093 const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
1094 {
1095         switch (initiator) {
1096         case NL80211_REGDOM_SET_BY_CORE:
1097                 return "core";
1098         case NL80211_REGDOM_SET_BY_USER:
1099                 return "user";
1100         case NL80211_REGDOM_SET_BY_DRIVER:
1101                 return "driver";
1102         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1103                 return "country IE";
1104         default:
1105                 WARN_ON(1);
1106                 return "bug";
1107         }
1108 }
1109 EXPORT_SYMBOL(reg_initiator_name);
1110
1111 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd,
1112                                           const struct ieee80211_reg_rule *reg_rule,
1113                                           const struct ieee80211_channel *chan)
1114 {
1115         const struct ieee80211_freq_range *freq_range = NULL;
1116         u32 max_bandwidth_khz, bw_flags = 0;
1117
1118         freq_range = &reg_rule->freq_range;
1119
1120         max_bandwidth_khz = freq_range->max_bandwidth_khz;
1121         /* Check if auto calculation requested */
1122         if (reg_rule->flags & NL80211_RRF_AUTO_BW)
1123                 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
1124
1125         /* If we get a reg_rule we can assume that at least 5Mhz fit */
1126         if (!cfg80211_does_bw_fit_range(freq_range,
1127                                         MHZ_TO_KHZ(chan->center_freq),
1128                                         MHZ_TO_KHZ(10)))
1129                 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1130         if (!cfg80211_does_bw_fit_range(freq_range,
1131                                         MHZ_TO_KHZ(chan->center_freq),
1132                                         MHZ_TO_KHZ(20)))
1133                 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1134
1135         if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1136                 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1137         if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1138                 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1139         if (max_bandwidth_khz < MHZ_TO_KHZ(40))
1140                 bw_flags |= IEEE80211_CHAN_NO_HT40;
1141         if (max_bandwidth_khz < MHZ_TO_KHZ(80))
1142                 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1143         if (max_bandwidth_khz < MHZ_TO_KHZ(160))
1144                 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1145         return bw_flags;
1146 }
1147
1148 /*
1149  * Note that right now we assume the desired channel bandwidth
1150  * is always 20 MHz for each individual channel (HT40 uses 20 MHz
1151  * per channel, the primary and the extension channel).
1152  */
1153 static void handle_channel(struct wiphy *wiphy,
1154                            enum nl80211_reg_initiator initiator,
1155                            struct ieee80211_channel *chan)
1156 {
1157         u32 flags, bw_flags = 0;
1158         const struct ieee80211_reg_rule *reg_rule = NULL;
1159         const struct ieee80211_power_rule *power_rule = NULL;
1160         struct wiphy *request_wiphy = NULL;
1161         struct regulatory_request *lr = get_last_request();
1162         const struct ieee80211_regdomain *regd;
1163
1164         request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
1165
1166         flags = chan->orig_flags;
1167
1168         reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1169         if (IS_ERR(reg_rule)) {
1170                 /*
1171                  * We will disable all channels that do not match our
1172                  * received regulatory rule unless the hint is coming
1173                  * from a Country IE and the Country IE had no information
1174                  * about a band. The IEEE 802.11 spec allows for an AP
1175                  * to send only a subset of the regulatory rules allowed,
1176                  * so an AP in the US that only supports 2.4 GHz may only send
1177                  * a country IE with information for the 2.4 GHz band
1178                  * while 5 GHz is still supported.
1179                  */
1180                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1181                     PTR_ERR(reg_rule) == -ERANGE)
1182                         return;
1183
1184                 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1185                     request_wiphy && request_wiphy == wiphy &&
1186                     request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1187                         pr_debug("Disabling freq %d MHz for good\n",
1188                                  chan->center_freq);
1189                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
1190                         chan->flags = chan->orig_flags;
1191                 } else {
1192                         pr_debug("Disabling freq %d MHz\n",
1193                                  chan->center_freq);
1194                         chan->flags |= IEEE80211_CHAN_DISABLED;
1195                 }
1196                 return;
1197         }
1198
1199         regd = reg_get_regdomain(wiphy);
1200
1201         power_rule = &reg_rule->power_rule;
1202         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
1203
1204         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1205             request_wiphy && request_wiphy == wiphy &&
1206             request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1207                 /*
1208                  * This guarantees the driver's requested regulatory domain
1209                  * will always be used as a base for further regulatory
1210                  * settings
1211                  */
1212                 chan->flags = chan->orig_flags =
1213                         map_regdom_flags(reg_rule->flags) | bw_flags;
1214                 chan->max_antenna_gain = chan->orig_mag =
1215                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1216                 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
1217                         (int) MBM_TO_DBM(power_rule->max_eirp);
1218
1219                 if (chan->flags & IEEE80211_CHAN_RADAR) {
1220                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1221                         if (reg_rule->dfs_cac_ms)
1222                                 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1223                 }
1224
1225                 return;
1226         }
1227
1228         chan->dfs_state = NL80211_DFS_USABLE;
1229         chan->dfs_state_entered = jiffies;
1230
1231         chan->beacon_found = false;
1232         chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
1233         chan->max_antenna_gain =
1234                 min_t(int, chan->orig_mag,
1235                       MBI_TO_DBI(power_rule->max_antenna_gain));
1236         chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1237
1238         if (chan->flags & IEEE80211_CHAN_RADAR) {
1239                 if (reg_rule->dfs_cac_ms)
1240                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1241                 else
1242                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1243         }
1244
1245         if (chan->orig_mpwr) {
1246                 /*
1247                  * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1248                  * will always follow the passed country IE power settings.
1249                  */
1250                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1251                     wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1252                         chan->max_power = chan->max_reg_power;
1253                 else
1254                         chan->max_power = min(chan->orig_mpwr,
1255                                               chan->max_reg_power);
1256         } else
1257                 chan->max_power = chan->max_reg_power;
1258 }
1259
1260 static void handle_band(struct wiphy *wiphy,
1261                         enum nl80211_reg_initiator initiator,
1262                         struct ieee80211_supported_band *sband)
1263 {
1264         unsigned int i;
1265
1266         if (!sband)
1267                 return;
1268
1269         for (i = 0; i < sband->n_channels; i++)
1270                 handle_channel(wiphy, initiator, &sband->channels[i]);
1271 }
1272
1273 static bool reg_request_cell_base(struct regulatory_request *request)
1274 {
1275         if (request->initiator != NL80211_REGDOM_SET_BY_USER)
1276                 return false;
1277         return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
1278 }
1279
1280 bool reg_last_request_cell_base(void)
1281 {
1282         return reg_request_cell_base(get_last_request());
1283 }
1284
1285 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
1286 /* Core specific check */
1287 static enum reg_request_treatment
1288 reg_ignore_cell_hint(struct regulatory_request *pending_request)
1289 {
1290         struct regulatory_request *lr = get_last_request();
1291
1292         if (!reg_num_devs_support_basehint)
1293                 return REG_REQ_IGNORE;
1294
1295         if (reg_request_cell_base(lr) &&
1296             !regdom_changes(pending_request->alpha2))
1297                 return REG_REQ_ALREADY_SET;
1298
1299         return REG_REQ_OK;
1300 }
1301
1302 /* Device specific check */
1303 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1304 {
1305         return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
1306 }
1307 #else
1308 static enum reg_request_treatment
1309 reg_ignore_cell_hint(struct regulatory_request *pending_request)
1310 {
1311         return REG_REQ_IGNORE;
1312 }
1313
1314 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1315 {
1316         return true;
1317 }
1318 #endif
1319
1320 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
1321 {
1322         if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
1323             !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
1324                 return true;
1325         return false;
1326 }
1327
1328 static bool ignore_reg_update(struct wiphy *wiphy,
1329                               enum nl80211_reg_initiator initiator)
1330 {
1331         struct regulatory_request *lr = get_last_request();
1332
1333         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
1334                 return true;
1335
1336         if (!lr) {
1337                 pr_debug("Ignoring regulatory request set by %s since last_request is not set\n",
1338                          reg_initiator_name(initiator));
1339                 return true;
1340         }
1341
1342         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1343             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
1344                 pr_debug("Ignoring regulatory request set by %s since the driver uses its own custom regulatory domain\n",
1345                          reg_initiator_name(initiator));
1346                 return true;
1347         }
1348
1349         /*
1350          * wiphy->regd will be set once the device has its own
1351          * desired regulatory domain set
1352          */
1353         if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
1354             initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1355             !is_world_regdom(lr->alpha2)) {
1356                 pr_debug("Ignoring regulatory request set by %s since the driver requires its own regulatory domain to be set first\n",
1357                          reg_initiator_name(initiator));
1358                 return true;
1359         }
1360
1361         if (reg_request_cell_base(lr))
1362                 return reg_dev_ignore_cell_hint(wiphy);
1363
1364         return false;
1365 }
1366
1367 static bool reg_is_world_roaming(struct wiphy *wiphy)
1368 {
1369         const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1370         const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1371         struct regulatory_request *lr = get_last_request();
1372
1373         if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1374                 return true;
1375
1376         if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1377             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
1378                 return true;
1379
1380         return false;
1381 }
1382
1383 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
1384                               struct reg_beacon *reg_beacon)
1385 {
1386         struct ieee80211_supported_band *sband;
1387         struct ieee80211_channel *chan;
1388         bool channel_changed = false;
1389         struct ieee80211_channel chan_before;
1390
1391         sband = wiphy->bands[reg_beacon->chan.band];
1392         chan = &sband->channels[chan_idx];
1393
1394         if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1395                 return;
1396
1397         if (chan->beacon_found)
1398                 return;
1399
1400         chan->beacon_found = true;
1401
1402         if (!reg_is_world_roaming(wiphy))
1403                 return;
1404
1405         if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
1406                 return;
1407
1408         chan_before.center_freq = chan->center_freq;
1409         chan_before.flags = chan->flags;
1410
1411         if (chan->flags & IEEE80211_CHAN_NO_IR) {
1412                 chan->flags &= ~IEEE80211_CHAN_NO_IR;
1413                 channel_changed = true;
1414         }
1415
1416         if (channel_changed)
1417                 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1418 }
1419
1420 /*
1421  * Called when a scan on a wiphy finds a beacon on
1422  * new channel
1423  */
1424 static void wiphy_update_new_beacon(struct wiphy *wiphy,
1425                                     struct reg_beacon *reg_beacon)
1426 {
1427         unsigned int i;
1428         struct ieee80211_supported_band *sband;
1429
1430         if (!wiphy->bands[reg_beacon->chan.band])
1431                 return;
1432
1433         sband = wiphy->bands[reg_beacon->chan.band];
1434
1435         for (i = 0; i < sband->n_channels; i++)
1436                 handle_reg_beacon(wiphy, i, reg_beacon);
1437 }
1438
1439 /*
1440  * Called upon reg changes or a new wiphy is added
1441  */
1442 static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1443 {
1444         unsigned int i;
1445         struct ieee80211_supported_band *sband;
1446         struct reg_beacon *reg_beacon;
1447
1448         list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1449                 if (!wiphy->bands[reg_beacon->chan.band])
1450                         continue;
1451                 sband = wiphy->bands[reg_beacon->chan.band];
1452                 for (i = 0; i < sband->n_channels; i++)
1453                         handle_reg_beacon(wiphy, i, reg_beacon);
1454         }
1455 }
1456
1457 /* Reap the advantages of previously found beacons */
1458 static void reg_process_beacons(struct wiphy *wiphy)
1459 {
1460         /*
1461          * Means we are just firing up cfg80211, so no beacons would
1462          * have been processed yet.
1463          */
1464         if (!last_request)
1465                 return;
1466         wiphy_update_beacon_reg(wiphy);
1467 }
1468
1469 static bool is_ht40_allowed(struct ieee80211_channel *chan)
1470 {
1471         if (!chan)
1472                 return false;
1473         if (chan->flags & IEEE80211_CHAN_DISABLED)
1474                 return false;
1475         /* This would happen when regulatory rules disallow HT40 completely */
1476         if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
1477                 return false;
1478         return true;
1479 }
1480
1481 static void reg_process_ht_flags_channel(struct wiphy *wiphy,
1482                                          struct ieee80211_channel *channel)
1483 {
1484         struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
1485         struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1486         unsigned int i;
1487
1488         if (!is_ht40_allowed(channel)) {
1489                 channel->flags |= IEEE80211_CHAN_NO_HT40;
1490                 return;
1491         }
1492
1493         /*
1494          * We need to ensure the extension channels exist to
1495          * be able to use HT40- or HT40+, this finds them (or not)
1496          */
1497         for (i = 0; i < sband->n_channels; i++) {
1498                 struct ieee80211_channel *c = &sband->channels[i];
1499
1500                 if (c->center_freq == (channel->center_freq - 20))
1501                         channel_before = c;
1502                 if (c->center_freq == (channel->center_freq + 20))
1503                         channel_after = c;
1504         }
1505
1506         /*
1507          * Please note that this assumes target bandwidth is 20 MHz,
1508          * if that ever changes we also need to change the below logic
1509          * to include that as well.
1510          */
1511         if (!is_ht40_allowed(channel_before))
1512                 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1513         else
1514                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1515
1516         if (!is_ht40_allowed(channel_after))
1517                 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1518         else
1519                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1520 }
1521
1522 static void reg_process_ht_flags_band(struct wiphy *wiphy,
1523                                       struct ieee80211_supported_band *sband)
1524 {
1525         unsigned int i;
1526
1527         if (!sband)
1528                 return;
1529
1530         for (i = 0; i < sband->n_channels; i++)
1531                 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
1532 }
1533
1534 static void reg_process_ht_flags(struct wiphy *wiphy)
1535 {
1536         enum nl80211_band band;
1537
1538         if (!wiphy)
1539                 return;
1540
1541         for (band = 0; band < NUM_NL80211_BANDS; band++)
1542                 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
1543 }
1544
1545 static void reg_call_notifier(struct wiphy *wiphy,
1546                               struct regulatory_request *request)
1547 {
1548         if (wiphy->reg_notifier)
1549                 wiphy->reg_notifier(wiphy, request);
1550 }
1551
1552 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
1553 {
1554         struct cfg80211_chan_def chandef;
1555         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1556         enum nl80211_iftype iftype;
1557
1558         wdev_lock(wdev);
1559         iftype = wdev->iftype;
1560
1561         /* make sure the interface is active */
1562         if (!wdev->netdev || !netif_running(wdev->netdev))
1563                 goto wdev_inactive_unlock;
1564
1565         switch (iftype) {
1566         case NL80211_IFTYPE_AP:
1567         case NL80211_IFTYPE_P2P_GO:
1568                 if (!wdev->beacon_interval)
1569                         goto wdev_inactive_unlock;
1570                 chandef = wdev->chandef;
1571                 break;
1572         case NL80211_IFTYPE_ADHOC:
1573                 if (!wdev->ssid_len)
1574                         goto wdev_inactive_unlock;
1575                 chandef = wdev->chandef;
1576                 break;
1577         case NL80211_IFTYPE_STATION:
1578         case NL80211_IFTYPE_P2P_CLIENT:
1579                 if (!wdev->current_bss ||
1580                     !wdev->current_bss->pub.channel)
1581                         goto wdev_inactive_unlock;
1582
1583                 if (!rdev->ops->get_channel ||
1584                     rdev_get_channel(rdev, wdev, &chandef))
1585                         cfg80211_chandef_create(&chandef,
1586                                                 wdev->current_bss->pub.channel,
1587                                                 NL80211_CHAN_NO_HT);
1588                 break;
1589         case NL80211_IFTYPE_MONITOR:
1590         case NL80211_IFTYPE_AP_VLAN:
1591         case NL80211_IFTYPE_P2P_DEVICE:
1592                 /* no enforcement required */
1593                 break;
1594         default:
1595                 /* others not implemented for now */
1596                 WARN_ON(1);
1597                 break;
1598         }
1599
1600         wdev_unlock(wdev);
1601
1602         switch (iftype) {
1603         case NL80211_IFTYPE_AP:
1604         case NL80211_IFTYPE_P2P_GO:
1605         case NL80211_IFTYPE_ADHOC:
1606                 return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
1607         case NL80211_IFTYPE_STATION:
1608         case NL80211_IFTYPE_P2P_CLIENT:
1609                 return cfg80211_chandef_usable(wiphy, &chandef,
1610                                                IEEE80211_CHAN_DISABLED);
1611         default:
1612                 break;
1613         }
1614
1615         return true;
1616
1617 wdev_inactive_unlock:
1618         wdev_unlock(wdev);
1619         return true;
1620 }
1621
1622 static void reg_leave_invalid_chans(struct wiphy *wiphy)
1623 {
1624         struct wireless_dev *wdev;
1625         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1626
1627         ASSERT_RTNL();
1628
1629         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
1630                 if (!reg_wdev_chan_valid(wiphy, wdev))
1631                         cfg80211_leave(rdev, wdev);
1632 }
1633
1634 static void reg_check_chans_work(struct work_struct *work)
1635 {
1636         struct cfg80211_registered_device *rdev;
1637
1638         pr_debug("Verifying active interfaces after reg change\n");
1639         rtnl_lock();
1640
1641         list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1642                 if (!(rdev->wiphy.regulatory_flags &
1643                       REGULATORY_IGNORE_STALE_KICKOFF))
1644                         reg_leave_invalid_chans(&rdev->wiphy);
1645
1646         rtnl_unlock();
1647 }
1648
1649 static void reg_check_channels(void)
1650 {
1651         /*
1652          * Give usermode a chance to do something nicer (move to another
1653          * channel, orderly disconnection), before forcing a disconnection.
1654          */
1655         mod_delayed_work(system_power_efficient_wq,
1656                          &reg_check_chans,
1657                          msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
1658 }
1659
1660 static void wiphy_update_regulatory(struct wiphy *wiphy,
1661                                     enum nl80211_reg_initiator initiator)
1662 {
1663         enum nl80211_band band;
1664         struct regulatory_request *lr = get_last_request();
1665
1666         if (ignore_reg_update(wiphy, initiator)) {
1667                 /*
1668                  * Regulatory updates set by CORE are ignored for custom
1669                  * regulatory cards. Let us notify the changes to the driver,
1670                  * as some drivers used this to restore its orig_* reg domain.
1671                  */
1672                 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1673                     wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
1674                         reg_call_notifier(wiphy, lr);
1675                 return;
1676         }
1677
1678         lr->dfs_region = get_cfg80211_regdom()->dfs_region;
1679
1680         for (band = 0; band < NUM_NL80211_BANDS; band++)
1681                 handle_band(wiphy, initiator, wiphy->bands[band]);
1682
1683         reg_process_beacons(wiphy);
1684         reg_process_ht_flags(wiphy);
1685         reg_call_notifier(wiphy, lr);
1686 }
1687
1688 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1689 {
1690         struct cfg80211_registered_device *rdev;
1691         struct wiphy *wiphy;
1692
1693         ASSERT_RTNL();
1694
1695         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1696                 wiphy = &rdev->wiphy;
1697                 wiphy_update_regulatory(wiphy, initiator);
1698         }
1699
1700         reg_check_channels();
1701 }
1702
1703 static void handle_channel_custom(struct wiphy *wiphy,
1704                                   struct ieee80211_channel *chan,
1705                                   const struct ieee80211_regdomain *regd)
1706 {
1707         u32 bw_flags = 0;
1708         const struct ieee80211_reg_rule *reg_rule = NULL;
1709         const struct ieee80211_power_rule *power_rule = NULL;
1710         u32 bw;
1711
1712         for (bw = MHZ_TO_KHZ(20); bw >= MHZ_TO_KHZ(5); bw = bw / 2) {
1713                 reg_rule = freq_reg_info_regd(MHZ_TO_KHZ(chan->center_freq),
1714                                               regd, bw);
1715                 if (!IS_ERR(reg_rule))
1716                         break;
1717         }
1718
1719         if (IS_ERR(reg_rule)) {
1720                 pr_debug("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1721                          chan->center_freq);
1722                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
1723                         chan->flags |= IEEE80211_CHAN_DISABLED;
1724                 } else {
1725                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
1726                         chan->flags = chan->orig_flags;
1727                 }
1728                 return;
1729         }
1730
1731         power_rule = &reg_rule->power_rule;
1732         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
1733
1734         chan->dfs_state_entered = jiffies;
1735         chan->dfs_state = NL80211_DFS_USABLE;
1736
1737         chan->beacon_found = false;
1738
1739         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
1740                 chan->flags = chan->orig_flags | bw_flags |
1741                               map_regdom_flags(reg_rule->flags);
1742         else
1743                 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1744
1745         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1746         chan->max_reg_power = chan->max_power =
1747                 (int) MBM_TO_DBM(power_rule->max_eirp);
1748
1749         if (chan->flags & IEEE80211_CHAN_RADAR) {
1750                 if (reg_rule->dfs_cac_ms)
1751                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1752                 else
1753                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1754         }
1755
1756         chan->max_power = chan->max_reg_power;
1757 }
1758
1759 static void handle_band_custom(struct wiphy *wiphy,
1760                                struct ieee80211_supported_band *sband,
1761                                const struct ieee80211_regdomain *regd)
1762 {
1763         unsigned int i;
1764
1765         if (!sband)
1766                 return;
1767
1768         for (i = 0; i < sband->n_channels; i++)
1769                 handle_channel_custom(wiphy, &sband->channels[i], regd);
1770 }
1771
1772 /* Used by drivers prior to wiphy registration */
1773 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1774                                    const struct ieee80211_regdomain *regd)
1775 {
1776         enum nl80211_band band;
1777         unsigned int bands_set = 0;
1778
1779         WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
1780              "wiphy should have REGULATORY_CUSTOM_REG\n");
1781         wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
1782
1783         for (band = 0; band < NUM_NL80211_BANDS; band++) {
1784                 if (!wiphy->bands[band])
1785                         continue;
1786                 handle_band_custom(wiphy, wiphy->bands[band], regd);
1787                 bands_set++;
1788         }
1789
1790         /*
1791          * no point in calling this if it won't have any effect
1792          * on your device's supported bands.
1793          */
1794         WARN_ON(!bands_set);
1795 }
1796 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1797
1798 static void reg_set_request_processed(void)
1799 {
1800         bool need_more_processing = false;
1801         struct regulatory_request *lr = get_last_request();
1802
1803         lr->processed = true;
1804
1805         spin_lock(&reg_requests_lock);
1806         if (!list_empty(&reg_requests_list))
1807                 need_more_processing = true;
1808         spin_unlock(&reg_requests_lock);
1809
1810         cancel_crda_timeout();
1811
1812         if (need_more_processing)
1813                 schedule_work(&reg_work);
1814 }
1815
1816 /**
1817  * reg_process_hint_core - process core regulatory requests
1818  * @pending_request: a pending core regulatory request
1819  *
1820  * The wireless subsystem can use this function to process
1821  * a regulatory request issued by the regulatory core.
1822  */
1823 static enum reg_request_treatment
1824 reg_process_hint_core(struct regulatory_request *core_request)
1825 {
1826         if (reg_query_database(core_request)) {
1827                 core_request->intersect = false;
1828                 core_request->processed = false;
1829                 reg_update_last_request(core_request);
1830                 return REG_REQ_OK;
1831         }
1832
1833         return REG_REQ_IGNORE;
1834 }
1835
1836 static enum reg_request_treatment
1837 __reg_process_hint_user(struct regulatory_request *user_request)
1838 {
1839         struct regulatory_request *lr = get_last_request();
1840
1841         if (reg_request_cell_base(user_request))
1842                 return reg_ignore_cell_hint(user_request);
1843
1844         if (reg_request_cell_base(lr))
1845                 return REG_REQ_IGNORE;
1846
1847         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
1848                 return REG_REQ_INTERSECT;
1849         /*
1850          * If the user knows better the user should set the regdom
1851          * to their country before the IE is picked up
1852          */
1853         if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
1854             lr->intersect)
1855                 return REG_REQ_IGNORE;
1856         /*
1857          * Process user requests only after previous user/driver/core
1858          * requests have been processed
1859          */
1860         if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
1861              lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1862              lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
1863             regdom_changes(lr->alpha2))
1864                 return REG_REQ_IGNORE;
1865
1866         if (!regdom_changes(user_request->alpha2))
1867                 return REG_REQ_ALREADY_SET;
1868
1869         return REG_REQ_OK;
1870 }
1871
1872 /**
1873  * reg_process_hint_user - process user regulatory requests
1874  * @user_request: a pending user regulatory request
1875  *
1876  * The wireless subsystem can use this function to process
1877  * a regulatory request initiated by userspace.
1878  */
1879 static enum reg_request_treatment
1880 reg_process_hint_user(struct regulatory_request *user_request)
1881 {
1882         enum reg_request_treatment treatment;
1883
1884         treatment = __reg_process_hint_user(user_request);
1885         if (treatment == REG_REQ_IGNORE ||
1886             treatment == REG_REQ_ALREADY_SET)
1887                 return REG_REQ_IGNORE;
1888
1889         user_request->intersect = treatment == REG_REQ_INTERSECT;
1890         user_request->processed = false;
1891
1892         if (reg_query_database(user_request)) {
1893                 reg_update_last_request(user_request);
1894                 user_alpha2[0] = user_request->alpha2[0];
1895                 user_alpha2[1] = user_request->alpha2[1];
1896                 return REG_REQ_OK;
1897         }
1898
1899         return REG_REQ_IGNORE;
1900 }
1901
1902 static enum reg_request_treatment
1903 __reg_process_hint_driver(struct regulatory_request *driver_request)
1904 {
1905         struct regulatory_request *lr = get_last_request();
1906
1907         if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
1908                 if (regdom_changes(driver_request->alpha2))
1909                         return REG_REQ_OK;
1910                 return REG_REQ_ALREADY_SET;
1911         }
1912
1913         /*
1914          * This would happen if you unplug and plug your card
1915          * back in or if you add a new device for which the previously
1916          * loaded card also agrees on the regulatory domain.
1917          */
1918         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1919             !regdom_changes(driver_request->alpha2))
1920                 return REG_REQ_ALREADY_SET;
1921
1922         return REG_REQ_INTERSECT;
1923 }
1924
1925 /**
1926  * reg_process_hint_driver - process driver regulatory requests
1927  * @driver_request: a pending driver regulatory request
1928  *
1929  * The wireless subsystem can use this function to process
1930  * a regulatory request issued by an 802.11 driver.
1931  *
1932  * Returns one of the different reg request treatment values.
1933  */
1934 static enum reg_request_treatment
1935 reg_process_hint_driver(struct wiphy *wiphy,
1936                         struct regulatory_request *driver_request)
1937 {
1938         const struct ieee80211_regdomain *regd, *tmp;
1939         enum reg_request_treatment treatment;
1940
1941         treatment = __reg_process_hint_driver(driver_request);
1942
1943         switch (treatment) {
1944         case REG_REQ_OK:
1945                 break;
1946         case REG_REQ_IGNORE:
1947                 return REG_REQ_IGNORE;
1948         case REG_REQ_INTERSECT:
1949         case REG_REQ_ALREADY_SET:
1950                 regd = reg_copy_regd(get_cfg80211_regdom());
1951                 if (IS_ERR(regd))
1952                         return REG_REQ_IGNORE;
1953
1954                 tmp = get_wiphy_regdom(wiphy);
1955                 rcu_assign_pointer(wiphy->regd, regd);
1956                 rcu_free_regdom(tmp);
1957         }
1958
1959
1960         driver_request->intersect = treatment == REG_REQ_INTERSECT;
1961         driver_request->processed = false;
1962
1963         /*
1964          * Since CRDA will not be called in this case as we already
1965          * have applied the requested regulatory domain before we just
1966          * inform userspace we have processed the request
1967          */
1968         if (treatment == REG_REQ_ALREADY_SET) {
1969                 nl80211_send_reg_change_event(driver_request);
1970                 reg_update_last_request(driver_request);
1971                 reg_set_request_processed();
1972                 return REG_REQ_ALREADY_SET;
1973         }
1974
1975         if (reg_query_database(driver_request)) {
1976                 reg_update_last_request(driver_request);
1977                 return REG_REQ_OK;
1978         }
1979
1980         return REG_REQ_IGNORE;
1981 }
1982
1983 static enum reg_request_treatment
1984 __reg_process_hint_country_ie(struct wiphy *wiphy,
1985                               struct regulatory_request *country_ie_request)
1986 {
1987         struct wiphy *last_wiphy = NULL;
1988         struct regulatory_request *lr = get_last_request();
1989
1990         if (reg_request_cell_base(lr)) {
1991                 /* Trust a Cell base station over the AP's country IE */
1992                 if (regdom_changes(country_ie_request->alpha2))
1993                         return REG_REQ_IGNORE;
1994                 return REG_REQ_ALREADY_SET;
1995         } else {
1996                 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
1997                         return REG_REQ_IGNORE;
1998         }
1999
2000         if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2001                 return -EINVAL;
2002
2003         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2004                 return REG_REQ_OK;
2005
2006         last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2007
2008         if (last_wiphy != wiphy) {
2009                 /*
2010                  * Two cards with two APs claiming different
2011                  * Country IE alpha2s. We could
2012                  * intersect them, but that seems unlikely
2013                  * to be correct. Reject second one for now.
2014                  */
2015                 if (regdom_changes(country_ie_request->alpha2))
2016                         return REG_REQ_IGNORE;
2017                 return REG_REQ_ALREADY_SET;
2018         }
2019
2020         if (regdom_changes(country_ie_request->alpha2))
2021                 return REG_REQ_OK;
2022         return REG_REQ_ALREADY_SET;
2023 }
2024
2025 /**
2026  * reg_process_hint_country_ie - process regulatory requests from country IEs
2027  * @country_ie_request: a regulatory request from a country IE
2028  *
2029  * The wireless subsystem can use this function to process
2030  * a regulatory request issued by a country Information Element.
2031  *
2032  * Returns one of the different reg request treatment values.
2033  */
2034 static enum reg_request_treatment
2035 reg_process_hint_country_ie(struct wiphy *wiphy,
2036                             struct regulatory_request *country_ie_request)
2037 {
2038         enum reg_request_treatment treatment;
2039
2040         treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
2041
2042         switch (treatment) {
2043         case REG_REQ_OK:
2044                 break;
2045         case REG_REQ_IGNORE:
2046                 return REG_REQ_IGNORE;
2047         case REG_REQ_ALREADY_SET:
2048                 reg_free_request(country_ie_request);
2049                 return REG_REQ_ALREADY_SET;
2050         case REG_REQ_INTERSECT:
2051                 /*
2052                  * This doesn't happen yet, not sure we
2053                  * ever want to support it for this case.
2054                  */
2055                 WARN_ONCE(1, "Unexpected intersection for country IEs");
2056                 return REG_REQ_IGNORE;
2057         }
2058
2059         country_ie_request->intersect = false;
2060         country_ie_request->processed = false;
2061
2062         if (reg_query_database(country_ie_request)) {
2063                 reg_update_last_request(country_ie_request);
2064                 return REG_REQ_OK;
2065         }
2066
2067         return REG_REQ_IGNORE;
2068 }
2069
2070 /* This processes *all* regulatory hints */
2071 static void reg_process_hint(struct regulatory_request *reg_request)
2072 {
2073         struct wiphy *wiphy = NULL;
2074         enum reg_request_treatment treatment;
2075
2076         if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
2077                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
2078
2079         switch (reg_request->initiator) {
2080         case NL80211_REGDOM_SET_BY_CORE:
2081                 treatment = reg_process_hint_core(reg_request);
2082                 break;
2083         case NL80211_REGDOM_SET_BY_USER:
2084                 treatment = reg_process_hint_user(reg_request);
2085                 break;
2086         case NL80211_REGDOM_SET_BY_DRIVER:
2087                 if (!wiphy)
2088                         goto out_free;
2089                 treatment = reg_process_hint_driver(wiphy, reg_request);
2090                 break;
2091         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2092                 if (!wiphy)
2093                         goto out_free;
2094                 treatment = reg_process_hint_country_ie(wiphy, reg_request);
2095                 break;
2096         default:
2097                 WARN(1, "invalid initiator %d\n", reg_request->initiator);
2098                 goto out_free;
2099         }
2100
2101         if (treatment == REG_REQ_IGNORE)
2102                 goto out_free;
2103
2104         WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET,
2105              "unexpected treatment value %d\n", treatment);
2106
2107         /* This is required so that the orig_* parameters are saved.
2108          * NOTE: treatment must be set for any case that reaches here!
2109          */
2110         if (treatment == REG_REQ_ALREADY_SET && wiphy &&
2111             wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
2112                 wiphy_update_regulatory(wiphy, reg_request->initiator);
2113                 reg_check_channels();
2114         }
2115
2116         return;
2117
2118 out_free:
2119         reg_free_request(reg_request);
2120 }
2121
2122 static bool reg_only_self_managed_wiphys(void)
2123 {
2124         struct cfg80211_registered_device *rdev;
2125         struct wiphy *wiphy;
2126         bool self_managed_found = false;
2127
2128         ASSERT_RTNL();
2129
2130         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2131                 wiphy = &rdev->wiphy;
2132                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2133                         self_managed_found = true;
2134                 else
2135                         return false;
2136         }
2137
2138         /* make sure at least one self-managed wiphy exists */
2139         return self_managed_found;
2140 }
2141
2142 /*
2143  * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
2144  * Regulatory hints come on a first come first serve basis and we
2145  * must process each one atomically.
2146  */
2147 static void reg_process_pending_hints(void)
2148 {
2149         struct regulatory_request *reg_request, *lr;
2150
2151         lr = get_last_request();
2152
2153         /* When last_request->processed becomes true this will be rescheduled */
2154         if (lr && !lr->processed) {
2155                 reg_process_hint(lr);
2156                 return;
2157         }
2158
2159         spin_lock(&reg_requests_lock);
2160
2161         if (list_empty(&reg_requests_list)) {
2162                 spin_unlock(&reg_requests_lock);
2163                 return;
2164         }
2165
2166         reg_request = list_first_entry(&reg_requests_list,
2167                                        struct regulatory_request,
2168                                        list);
2169         list_del_init(&reg_request->list);
2170
2171         spin_unlock(&reg_requests_lock);
2172
2173         if (reg_only_self_managed_wiphys()) {
2174                 reg_free_request(reg_request);
2175                 return;
2176         }
2177
2178         reg_process_hint(reg_request);
2179
2180         lr = get_last_request();
2181
2182         spin_lock(&reg_requests_lock);
2183         if (!list_empty(&reg_requests_list) && lr && lr->processed)
2184                 schedule_work(&reg_work);
2185         spin_unlock(&reg_requests_lock);
2186 }
2187
2188 /* Processes beacon hints -- this has nothing to do with country IEs */
2189 static void reg_process_pending_beacon_hints(void)
2190 {
2191         struct cfg80211_registered_device *rdev;
2192         struct reg_beacon *pending_beacon, *tmp;
2193
2194         /* This goes through the _pending_ beacon list */
2195         spin_lock_bh(&reg_pending_beacons_lock);
2196
2197         list_for_each_entry_safe(pending_beacon, tmp,
2198                                  &reg_pending_beacons, list) {
2199                 list_del_init(&pending_beacon->list);
2200
2201                 /* Applies the beacon hint to current wiphys */
2202                 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2203                         wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
2204
2205                 /* Remembers the beacon hint for new wiphys or reg changes */
2206                 list_add_tail(&pending_beacon->list, &reg_beacon_list);
2207         }
2208
2209         spin_unlock_bh(&reg_pending_beacons_lock);
2210 }
2211
2212 static void reg_process_self_managed_hints(void)
2213 {
2214         struct cfg80211_registered_device *rdev;
2215         struct wiphy *wiphy;
2216         const struct ieee80211_regdomain *tmp;
2217         const struct ieee80211_regdomain *regd;
2218         enum nl80211_band band;
2219         struct regulatory_request request = {};
2220
2221         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2222                 wiphy = &rdev->wiphy;
2223
2224                 spin_lock(&reg_requests_lock);
2225                 regd = rdev->requested_regd;
2226                 rdev->requested_regd = NULL;
2227                 spin_unlock(&reg_requests_lock);
2228
2229                 if (regd == NULL)
2230                         continue;
2231
2232                 tmp = get_wiphy_regdom(wiphy);
2233                 rcu_assign_pointer(wiphy->regd, regd);
2234                 rcu_free_regdom(tmp);
2235
2236                 for (band = 0; band < NUM_NL80211_BANDS; band++)
2237                         handle_band_custom(wiphy, wiphy->bands[band], regd);
2238
2239                 reg_process_ht_flags(wiphy);
2240
2241                 request.wiphy_idx = get_wiphy_idx(wiphy);
2242                 request.alpha2[0] = regd->alpha2[0];
2243                 request.alpha2[1] = regd->alpha2[1];
2244                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
2245
2246                 nl80211_send_wiphy_reg_change_event(&request);
2247         }
2248
2249         reg_check_channels();
2250 }
2251
2252 static void reg_todo(struct work_struct *work)
2253 {
2254         rtnl_lock();
2255         reg_process_pending_hints();
2256         reg_process_pending_beacon_hints();
2257         reg_process_self_managed_hints();
2258         rtnl_unlock();
2259 }
2260
2261 static void queue_regulatory_request(struct regulatory_request *request)
2262 {
2263         request->alpha2[0] = toupper(request->alpha2[0]);
2264         request->alpha2[1] = toupper(request->alpha2[1]);
2265
2266         spin_lock(&reg_requests_lock);
2267         list_add_tail(&request->list, &reg_requests_list);
2268         spin_unlock(&reg_requests_lock);
2269
2270         schedule_work(&reg_work);
2271 }
2272
2273 /*
2274  * Core regulatory hint -- happens during cfg80211_init()
2275  * and when we restore regulatory settings.
2276  */
2277 static int regulatory_hint_core(const char *alpha2)
2278 {
2279         struct regulatory_request *request;
2280
2281         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2282         if (!request)
2283                 return -ENOMEM;
2284
2285         request->alpha2[0] = alpha2[0];
2286         request->alpha2[1] = alpha2[1];
2287         request->initiator = NL80211_REGDOM_SET_BY_CORE;
2288
2289         queue_regulatory_request(request);
2290
2291         return 0;
2292 }
2293
2294 /* User hints */
2295 int regulatory_hint_user(const char *alpha2,
2296                          enum nl80211_user_reg_hint_type user_reg_hint_type)
2297 {
2298         struct regulatory_request *request;
2299
2300         if (WARN_ON(!alpha2))
2301                 return -EINVAL;
2302
2303         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2304         if (!request)
2305                 return -ENOMEM;
2306
2307         request->wiphy_idx = WIPHY_IDX_INVALID;
2308         request->alpha2[0] = alpha2[0];
2309         request->alpha2[1] = alpha2[1];
2310         request->initiator = NL80211_REGDOM_SET_BY_USER;
2311         request->user_reg_hint_type = user_reg_hint_type;
2312
2313         /* Allow calling CRDA again */
2314         reset_crda_timeouts();
2315
2316         queue_regulatory_request(request);
2317
2318         return 0;
2319 }
2320
2321 int regulatory_hint_indoor(bool is_indoor, u32 portid)
2322 {
2323         spin_lock(&reg_indoor_lock);
2324
2325         /* It is possible that more than one user space process is trying to
2326          * configure the indoor setting. To handle such cases, clear the indoor
2327          * setting in case that some process does not think that the device
2328          * is operating in an indoor environment. In addition, if a user space
2329          * process indicates that it is controlling the indoor setting, save its
2330          * portid, i.e., make it the owner.
2331          */
2332         reg_is_indoor = is_indoor;
2333         if (reg_is_indoor) {
2334                 if (!reg_is_indoor_portid)
2335                         reg_is_indoor_portid = portid;
2336         } else {
2337                 reg_is_indoor_portid = 0;
2338         }
2339
2340         spin_unlock(&reg_indoor_lock);
2341
2342         if (!is_indoor)
2343                 reg_check_channels();
2344
2345         return 0;
2346 }
2347
2348 void regulatory_netlink_notify(u32 portid)
2349 {
2350         spin_lock(&reg_indoor_lock);
2351
2352         if (reg_is_indoor_portid != portid) {
2353                 spin_unlock(&reg_indoor_lock);
2354                 return;
2355         }
2356
2357         reg_is_indoor = false;
2358         reg_is_indoor_portid = 0;
2359
2360         spin_unlock(&reg_indoor_lock);
2361
2362         reg_check_channels();
2363 }
2364
2365 /* Driver hints */
2366 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
2367 {
2368         struct regulatory_request *request;
2369
2370         if (WARN_ON(!alpha2 || !wiphy))
2371                 return -EINVAL;
2372
2373         wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
2374
2375         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2376         if (!request)
2377                 return -ENOMEM;
2378
2379         request->wiphy_idx = get_wiphy_idx(wiphy);
2380
2381         request->alpha2[0] = alpha2[0];
2382         request->alpha2[1] = alpha2[1];
2383         request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
2384
2385         /* Allow calling CRDA again */
2386         reset_crda_timeouts();
2387
2388         queue_regulatory_request(request);
2389
2390         return 0;
2391 }
2392 EXPORT_SYMBOL(regulatory_hint);
2393
2394 void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band,
2395                                 const u8 *country_ie, u8 country_ie_len)
2396 {
2397         char alpha2[2];
2398         enum environment_cap env = ENVIRON_ANY;
2399         struct regulatory_request *request = NULL, *lr;
2400
2401         /* IE len must be evenly divisible by 2 */
2402         if (country_ie_len & 0x01)
2403                 return;
2404
2405         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
2406                 return;
2407
2408         request = kzalloc(sizeof(*request), GFP_KERNEL);
2409         if (!request)
2410                 return;
2411
2412         alpha2[0] = country_ie[0];
2413         alpha2[1] = country_ie[1];
2414
2415         if (country_ie[2] == 'I')
2416                 env = ENVIRON_INDOOR;
2417         else if (country_ie[2] == 'O')
2418                 env = ENVIRON_OUTDOOR;
2419
2420         rcu_read_lock();
2421         lr = get_last_request();
2422
2423         if (unlikely(!lr))
2424                 goto out;
2425
2426         /*
2427          * We will run this only upon a successful connection on cfg80211.
2428          * We leave conflict resolution to the workqueue, where can hold
2429          * the RTNL.
2430          */
2431         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2432             lr->wiphy_idx != WIPHY_IDX_INVALID)
2433                 goto out;
2434
2435         request->wiphy_idx = get_wiphy_idx(wiphy);
2436         request->alpha2[0] = alpha2[0];
2437         request->alpha2[1] = alpha2[1];
2438         request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
2439         request->country_ie_env = env;
2440
2441         /* Allow calling CRDA again */
2442         reset_crda_timeouts();
2443
2444         queue_regulatory_request(request);
2445         request = NULL;
2446 out:
2447         kfree(request);
2448         rcu_read_unlock();
2449 }
2450
2451 static void restore_alpha2(char *alpha2, bool reset_user)
2452 {
2453         /* indicates there is no alpha2 to consider for restoration */
2454         alpha2[0] = '9';
2455         alpha2[1] = '7';
2456
2457         /* The user setting has precedence over the module parameter */
2458         if (is_user_regdom_saved()) {
2459                 /* Unless we're asked to ignore it and reset it */
2460                 if (reset_user) {
2461                         pr_debug("Restoring regulatory settings including user preference\n");
2462                         user_alpha2[0] = '9';
2463                         user_alpha2[1] = '7';
2464
2465                         /*
2466                          * If we're ignoring user settings, we still need to
2467                          * check the module parameter to ensure we put things
2468                          * back as they were for a full restore.
2469                          */
2470                         if (!is_world_regdom(ieee80211_regdom)) {
2471                                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2472                                          ieee80211_regdom[0], ieee80211_regdom[1]);
2473                                 alpha2[0] = ieee80211_regdom[0];
2474                                 alpha2[1] = ieee80211_regdom[1];
2475                         }
2476                 } else {
2477                         pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n",
2478                                  user_alpha2[0], user_alpha2[1]);
2479                         alpha2[0] = user_alpha2[0];
2480                         alpha2[1] = user_alpha2[1];
2481                 }
2482         } else if (!is_world_regdom(ieee80211_regdom)) {
2483                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2484                          ieee80211_regdom[0], ieee80211_regdom[1]);
2485                 alpha2[0] = ieee80211_regdom[0];
2486                 alpha2[1] = ieee80211_regdom[1];
2487         } else
2488                 pr_debug("Restoring regulatory settings\n");
2489 }
2490
2491 static void restore_custom_reg_settings(struct wiphy *wiphy)
2492 {
2493         struct ieee80211_supported_band *sband;
2494         enum nl80211_band band;
2495         struct ieee80211_channel *chan;
2496         int i;
2497
2498         for (band = 0; band < NUM_NL80211_BANDS; band++) {
2499                 sband = wiphy->bands[band];
2500                 if (!sband)
2501                         continue;
2502                 for (i = 0; i < sband->n_channels; i++) {
2503                         chan = &sband->channels[i];
2504                         chan->flags = chan->orig_flags;
2505                         chan->max_antenna_gain = chan->orig_mag;
2506                         chan->max_power = chan->orig_mpwr;
2507                         chan->beacon_found = false;
2508                 }
2509         }
2510 }
2511
2512 /*
2513  * Restoring regulatory settings involves ingoring any
2514  * possibly stale country IE information and user regulatory
2515  * settings if so desired, this includes any beacon hints
2516  * learned as we could have traveled outside to another country
2517  * after disconnection. To restore regulatory settings we do
2518  * exactly what we did at bootup:
2519  *
2520  *   - send a core regulatory hint
2521  *   - send a user regulatory hint if applicable
2522  *
2523  * Device drivers that send a regulatory hint for a specific country
2524  * keep their own regulatory domain on wiphy->regd so that does does
2525  * not need to be remembered.
2526  */
2527 static void restore_regulatory_settings(bool reset_user)
2528 {
2529         char alpha2[2];
2530         char world_alpha2[2];
2531         struct reg_beacon *reg_beacon, *btmp;
2532         LIST_HEAD(tmp_reg_req_list);
2533         struct cfg80211_registered_device *rdev;
2534
2535         ASSERT_RTNL();
2536
2537         /*
2538          * Clear the indoor setting in case that it is not controlled by user
2539          * space, as otherwise there is no guarantee that the device is still
2540          * operating in an indoor environment.
2541          */
2542         spin_lock(&reg_indoor_lock);
2543         if (reg_is_indoor && !reg_is_indoor_portid) {
2544                 reg_is_indoor = false;
2545                 reg_check_channels();
2546         }
2547         spin_unlock(&reg_indoor_lock);
2548
2549         reset_regdomains(true, &world_regdom);
2550         restore_alpha2(alpha2, reset_user);
2551
2552         /*
2553          * If there's any pending requests we simply
2554          * stash them to a temporary pending queue and
2555          * add then after we've restored regulatory
2556          * settings.
2557          */
2558         spin_lock(&reg_requests_lock);
2559         list_splice_tail_init(&reg_requests_list, &tmp_reg_req_list);
2560         spin_unlock(&reg_requests_lock);
2561
2562         /* Clear beacon hints */
2563         spin_lock_bh(&reg_pending_beacons_lock);
2564         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
2565                 list_del(&reg_beacon->list);
2566                 kfree(reg_beacon);
2567         }
2568         spin_unlock_bh(&reg_pending_beacons_lock);
2569
2570         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
2571                 list_del(&reg_beacon->list);
2572                 kfree(reg_beacon);
2573         }
2574
2575         /* First restore to the basic regulatory settings */
2576         world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
2577         world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
2578
2579         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2580                 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2581                         continue;
2582                 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
2583                         restore_custom_reg_settings(&rdev->wiphy);
2584         }
2585
2586         regulatory_hint_core(world_alpha2);
2587
2588         /*
2589          * This restores the ieee80211_regdom module parameter
2590          * preference or the last user requested regulatory
2591          * settings, user regulatory settings takes precedence.
2592          */
2593         if (is_an_alpha2(alpha2))
2594                 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER);
2595
2596         spin_lock(&reg_requests_lock);
2597         list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
2598         spin_unlock(&reg_requests_lock);
2599
2600         pr_debug("Kicking the queue\n");
2601
2602         schedule_work(&reg_work);
2603 }
2604
2605 void regulatory_hint_disconnect(void)
2606 {
2607         pr_debug("All devices are disconnected, going to restore regulatory settings\n");
2608         restore_regulatory_settings(false);
2609 }
2610
2611 static bool freq_is_chan_12_13_14(u16 freq)
2612 {
2613         if (freq == ieee80211_channel_to_frequency(12, NL80211_BAND_2GHZ) ||
2614             freq == ieee80211_channel_to_frequency(13, NL80211_BAND_2GHZ) ||
2615             freq == ieee80211_channel_to_frequency(14, NL80211_BAND_2GHZ))
2616                 return true;
2617         return false;
2618 }
2619
2620 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
2621 {
2622         struct reg_beacon *pending_beacon;
2623
2624         list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
2625                 if (beacon_chan->center_freq ==
2626                     pending_beacon->chan.center_freq)
2627                         return true;
2628         return false;
2629 }
2630
2631 int regulatory_hint_found_beacon(struct wiphy *wiphy,
2632                                  struct ieee80211_channel *beacon_chan,
2633                                  gfp_t gfp)
2634 {
2635         struct reg_beacon *reg_beacon;
2636         bool processing;
2637
2638         if (beacon_chan->beacon_found ||
2639             beacon_chan->flags & IEEE80211_CHAN_RADAR ||
2640             (beacon_chan->band == NL80211_BAND_2GHZ &&
2641              !freq_is_chan_12_13_14(beacon_chan->center_freq)))
2642                 return 0;
2643
2644         spin_lock_bh(&reg_pending_beacons_lock);
2645         processing = pending_reg_beacon(beacon_chan);
2646         spin_unlock_bh(&reg_pending_beacons_lock);
2647
2648         if (processing)
2649                 return 0;
2650
2651         reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
2652         if (!reg_beacon)
2653                 return -ENOMEM;
2654
2655         pr_debug("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
2656                  beacon_chan->center_freq,
2657                  ieee80211_frequency_to_channel(beacon_chan->center_freq),
2658                  wiphy_name(wiphy));
2659
2660         memcpy(&reg_beacon->chan, beacon_chan,
2661                sizeof(struct ieee80211_channel));
2662
2663         /*
2664          * Since we can be called from BH or and non-BH context
2665          * we must use spin_lock_bh()
2666          */
2667         spin_lock_bh(&reg_pending_beacons_lock);
2668         list_add_tail(&reg_beacon->list, &reg_pending_beacons);
2669         spin_unlock_bh(&reg_pending_beacons_lock);
2670
2671         schedule_work(&reg_work);
2672
2673         return 0;
2674 }
2675
2676 static void print_rd_rules(const struct ieee80211_regdomain *rd)
2677 {
2678         unsigned int i;
2679         const struct ieee80211_reg_rule *reg_rule = NULL;
2680         const struct ieee80211_freq_range *freq_range = NULL;
2681         const struct ieee80211_power_rule *power_rule = NULL;
2682         char bw[32], cac_time[32];
2683
2684         pr_debug("  (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
2685
2686         for (i = 0; i < rd->n_reg_rules; i++) {
2687                 reg_rule = &rd->reg_rules[i];
2688                 freq_range = &reg_rule->freq_range;
2689                 power_rule = &reg_rule->power_rule;
2690
2691                 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
2692                         snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
2693                                  freq_range->max_bandwidth_khz,
2694                                  reg_get_max_bandwidth(rd, reg_rule));
2695                 else
2696                         snprintf(bw, sizeof(bw), "%d KHz",
2697                                  freq_range->max_bandwidth_khz);
2698
2699                 if (reg_rule->flags & NL80211_RRF_DFS)
2700                         scnprintf(cac_time, sizeof(cac_time), "%u s",
2701                                   reg_rule->dfs_cac_ms/1000);
2702                 else
2703                         scnprintf(cac_time, sizeof(cac_time), "N/A");
2704
2705
2706                 /*
2707                  * There may not be documentation for max antenna gain
2708                  * in certain regions
2709                  */
2710                 if (power_rule->max_antenna_gain)
2711                         pr_debug("  (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
2712                                 freq_range->start_freq_khz,
2713                                 freq_range->end_freq_khz,
2714                                 bw,
2715                                 power_rule->max_antenna_gain,
2716                                 power_rule->max_eirp,
2717                                 cac_time);
2718                 else
2719                         pr_debug("  (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
2720                                 freq_range->start_freq_khz,
2721                                 freq_range->end_freq_khz,
2722                                 bw,
2723                                 power_rule->max_eirp,
2724                                 cac_time);
2725         }
2726 }
2727
2728 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
2729 {
2730         switch (dfs_region) {
2731         case NL80211_DFS_UNSET:
2732         case NL80211_DFS_FCC:
2733         case NL80211_DFS_ETSI:
2734         case NL80211_DFS_JP:
2735                 return true;
2736         default:
2737                 pr_debug("Ignoring uknown DFS master region: %d\n", dfs_region);
2738                 return false;
2739         }
2740 }
2741
2742 static void print_regdomain(const struct ieee80211_regdomain *rd)
2743 {
2744         struct regulatory_request *lr = get_last_request();
2745
2746         if (is_intersected_alpha2(rd->alpha2)) {
2747                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2748                         struct cfg80211_registered_device *rdev;
2749                         rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
2750                         if (rdev) {
2751                                 pr_debug("Current regulatory domain updated by AP to: %c%c\n",
2752                                         rdev->country_ie_alpha2[0],
2753                                         rdev->country_ie_alpha2[1]);
2754                         } else
2755                                 pr_debug("Current regulatory domain intersected:\n");
2756                 } else
2757                         pr_debug("Current regulatory domain intersected:\n");
2758         } else if (is_world_regdom(rd->alpha2)) {
2759                 pr_debug("World regulatory domain updated:\n");
2760         } else {
2761                 if (is_unknown_alpha2(rd->alpha2))
2762                         pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
2763                 else {
2764                         if (reg_request_cell_base(lr))
2765                                 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
2766                                         rd->alpha2[0], rd->alpha2[1]);
2767                         else
2768                                 pr_debug("Regulatory domain changed to country: %c%c\n",
2769                                         rd->alpha2[0], rd->alpha2[1]);
2770                 }
2771         }
2772
2773         pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
2774         print_rd_rules(rd);
2775 }
2776
2777 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
2778 {
2779         pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
2780         print_rd_rules(rd);
2781 }
2782
2783 static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
2784 {
2785         if (!is_world_regdom(rd->alpha2))
2786                 return -EINVAL;
2787         update_world_regdomain(rd);
2788         return 0;
2789 }
2790
2791 static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
2792                            struct regulatory_request *user_request)
2793 {
2794         const struct ieee80211_regdomain *intersected_rd = NULL;
2795
2796         if (!regdom_changes(rd->alpha2))
2797                 return -EALREADY;
2798
2799         if (!is_valid_rd(rd)) {
2800                 pr_err("Invalid regulatory domain detected: %c%c\n",
2801                        rd->alpha2[0], rd->alpha2[1]);
2802                 print_regdomain_info(rd);
2803                 return -EINVAL;
2804         }
2805
2806         if (!user_request->intersect) {
2807                 reset_regdomains(false, rd);
2808                 return 0;
2809         }
2810
2811         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2812         if (!intersected_rd)
2813                 return -EINVAL;
2814
2815         kfree(rd);
2816         rd = NULL;
2817         reset_regdomains(false, intersected_rd);
2818
2819         return 0;
2820 }
2821
2822 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
2823                              struct regulatory_request *driver_request)
2824 {
2825         const struct ieee80211_regdomain *regd;
2826         const struct ieee80211_regdomain *intersected_rd = NULL;
2827         const struct ieee80211_regdomain *tmp;
2828         struct wiphy *request_wiphy;
2829
2830         if (is_world_regdom(rd->alpha2))
2831                 return -EINVAL;
2832
2833         if (!regdom_changes(rd->alpha2))
2834                 return -EALREADY;
2835
2836         if (!is_valid_rd(rd)) {
2837                 pr_err("Invalid regulatory domain detected: %c%c\n",
2838                        rd->alpha2[0], rd->alpha2[1]);
2839                 print_regdomain_info(rd);
2840                 return -EINVAL;
2841         }
2842
2843         request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
2844         if (!request_wiphy)
2845                 return -ENODEV;
2846
2847         if (!driver_request->intersect) {
2848                 if (request_wiphy->regd)
2849                         return -EALREADY;
2850
2851                 regd = reg_copy_regd(rd);
2852                 if (IS_ERR(regd))
2853                         return PTR_ERR(regd);
2854
2855                 rcu_assign_pointer(request_wiphy->regd, regd);
2856                 reset_regdomains(false, rd);
2857                 return 0;
2858         }
2859
2860         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2861         if (!intersected_rd)
2862                 return -EINVAL;
2863
2864         /*
2865          * We can trash what CRDA provided now.
2866          * However if a driver requested this specific regulatory
2867          * domain we keep it for its private use
2868          */
2869         tmp = get_wiphy_regdom(request_wiphy);
2870         rcu_assign_pointer(request_wiphy->regd, rd);
2871         rcu_free_regdom(tmp);
2872
2873         rd = NULL;
2874
2875         reset_regdomains(false, intersected_rd);
2876
2877         return 0;
2878 }
2879
2880 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
2881                                  struct regulatory_request *country_ie_request)
2882 {
2883         struct wiphy *request_wiphy;
2884
2885         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2886             !is_unknown_alpha2(rd->alpha2))
2887                 return -EINVAL;
2888
2889         /*
2890          * Lets only bother proceeding on the same alpha2 if the current
2891          * rd is non static (it means CRDA was present and was used last)
2892          * and the pending request came in from a country IE
2893          */
2894
2895         if (!is_valid_rd(rd)) {
2896                 pr_err("Invalid regulatory domain detected: %c%c\n",
2897                        rd->alpha2[0], rd->alpha2[1]);
2898                 print_regdomain_info(rd);
2899                 return -EINVAL;
2900         }
2901
2902         request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
2903         if (!request_wiphy)
2904                 return -ENODEV;
2905
2906         if (country_ie_request->intersect)
2907                 return -EINVAL;
2908
2909         reset_regdomains(false, rd);
2910         return 0;
2911 }
2912
2913 /*
2914  * Use this call to set the current regulatory domain. Conflicts with
2915  * multiple drivers can be ironed out later. Caller must've already
2916  * kmalloc'd the rd structure.
2917  */
2918 int set_regdom(const struct ieee80211_regdomain *rd,
2919                enum ieee80211_regd_source regd_src)
2920 {
2921         struct regulatory_request *lr;
2922         bool user_reset = false;
2923         int r;
2924
2925         if (!reg_is_valid_request(rd->alpha2)) {
2926                 kfree(rd);
2927                 return -EINVAL;
2928         }
2929
2930         if (regd_src == REGD_SOURCE_CRDA)
2931                 reset_crda_timeouts();
2932
2933         lr = get_last_request();
2934
2935         /* Note that this doesn't update the wiphys, this is done below */
2936         switch (lr->initiator) {
2937         case NL80211_REGDOM_SET_BY_CORE:
2938                 r = reg_set_rd_core(rd);
2939                 break;
2940         case NL80211_REGDOM_SET_BY_USER:
2941                 r = reg_set_rd_user(rd, lr);
2942                 user_reset = true;
2943                 break;
2944         case NL80211_REGDOM_SET_BY_DRIVER:
2945                 r = reg_set_rd_driver(rd, lr);
2946                 break;
2947         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2948                 r = reg_set_rd_country_ie(rd, lr);
2949                 break;
2950         default:
2951                 WARN(1, "invalid initiator %d\n", lr->initiator);
2952                 kfree(rd);
2953                 return -EINVAL;
2954         }
2955
2956         if (r) {
2957                 switch (r) {
2958                 case -EALREADY:
2959                         reg_set_request_processed();
2960                         break;
2961                 default:
2962                         /* Back to world regulatory in case of errors */
2963                         restore_regulatory_settings(user_reset);
2964                 }
2965
2966                 kfree(rd);
2967                 return r;
2968         }
2969
2970         /* This would make this whole thing pointless */
2971         if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
2972                 return -EINVAL;
2973
2974         /* update all wiphys now with the new established regulatory domain */
2975         update_all_wiphy_regulatory(lr->initiator);
2976
2977         print_regdomain(get_cfg80211_regdom());
2978
2979         nl80211_send_reg_change_event(lr);
2980
2981         reg_set_request_processed();
2982
2983         return 0;
2984 }
2985
2986 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
2987                                        struct ieee80211_regdomain *rd)
2988 {
2989         const struct ieee80211_regdomain *regd;
2990         const struct ieee80211_regdomain *prev_regd;
2991         struct cfg80211_registered_device *rdev;
2992
2993         if (WARN_ON(!wiphy || !rd))
2994                 return -EINVAL;
2995
2996         if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
2997                  "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
2998                 return -EPERM;
2999
3000         if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) {
3001                 print_regdomain_info(rd);
3002                 return -EINVAL;
3003         }
3004
3005         regd = reg_copy_regd(rd);
3006         if (IS_ERR(regd))
3007                 return PTR_ERR(regd);
3008
3009         rdev = wiphy_to_rdev(wiphy);
3010
3011         spin_lock(&reg_requests_lock);
3012         prev_regd = rdev->requested_regd;
3013         rdev->requested_regd = regd;
3014         spin_unlock(&reg_requests_lock);
3015
3016         kfree(prev_regd);
3017         return 0;
3018 }
3019
3020 int regulatory_set_wiphy_regd(struct wiphy *wiphy,
3021                               struct ieee80211_regdomain *rd)
3022 {
3023         int ret = __regulatory_set_wiphy_regd(wiphy, rd);
3024
3025         if (ret)
3026                 return ret;
3027
3028         schedule_work(&reg_work);
3029         return 0;
3030 }
3031 EXPORT_SYMBOL(regulatory_set_wiphy_regd);
3032
3033 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy,
3034                                         struct ieee80211_regdomain *rd)
3035 {
3036         int ret;
3037
3038         ASSERT_RTNL();
3039
3040         ret = __regulatory_set_wiphy_regd(wiphy, rd);
3041         if (ret)
3042                 return ret;
3043
3044         /* process the request immediately */
3045         reg_process_self_managed_hints();
3046         return 0;
3047 }
3048 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl);
3049
3050 void wiphy_regulatory_register(struct wiphy *wiphy)
3051 {
3052         struct regulatory_request *lr;
3053
3054         /* self-managed devices ignore external hints */
3055         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3056                 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
3057                                            REGULATORY_COUNTRY_IE_IGNORE;
3058
3059         if (!reg_dev_ignore_cell_hint(wiphy))
3060                 reg_num_devs_support_basehint++;
3061
3062         lr = get_last_request();
3063         wiphy_update_regulatory(wiphy, lr->initiator);
3064 }
3065
3066 void wiphy_regulatory_deregister(struct wiphy *wiphy)
3067 {
3068         struct wiphy *request_wiphy = NULL;
3069         struct regulatory_request *lr;
3070
3071         lr = get_last_request();
3072
3073         if (!reg_dev_ignore_cell_hint(wiphy))
3074                 reg_num_devs_support_basehint--;
3075
3076         rcu_free_regdom(get_wiphy_regdom(wiphy));
3077         RCU_INIT_POINTER(wiphy->regd, NULL);
3078
3079         if (lr)
3080                 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
3081
3082         if (!request_wiphy || request_wiphy != wiphy)
3083                 return;
3084
3085         lr->wiphy_idx = WIPHY_IDX_INVALID;
3086         lr->country_ie_env = ENVIRON_ANY;
3087 }
3088
3089 /*
3090  * See http://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii, for
3091  * UNII band definitions
3092  */
3093 int cfg80211_get_unii(int freq)
3094 {
3095         /* UNII-1 */
3096         if (freq >= 5150 && freq <= 5250)
3097                 return 0;
3098
3099         /* UNII-2A */
3100         if (freq > 5250 && freq <= 5350)
3101                 return 1;
3102
3103         /* UNII-2B */
3104         if (freq > 5350 && freq <= 5470)
3105                 return 2;
3106
3107         /* UNII-2C */
3108         if (freq > 5470 && freq <= 5725)
3109                 return 3;
3110
3111         /* UNII-3 */
3112         if (freq > 5725 && freq <= 5825)
3113                 return 4;
3114
3115         return -EINVAL;
3116 }
3117
3118 bool regulatory_indoor_allowed(void)
3119 {
3120         return reg_is_indoor;
3121 }
3122
3123 int __init regulatory_init(void)
3124 {
3125         int err = 0;
3126
3127         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
3128         if (IS_ERR(reg_pdev))
3129                 return PTR_ERR(reg_pdev);
3130
3131         spin_lock_init(&reg_requests_lock);
3132         spin_lock_init(&reg_pending_beacons_lock);
3133         spin_lock_init(&reg_indoor_lock);
3134
3135         reg_regdb_size_check();
3136
3137         rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
3138
3139         user_alpha2[0] = '9';
3140         user_alpha2[1] = '7';
3141
3142         /* We always try to get an update for the static regdomain */
3143         err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
3144         if (err) {
3145                 if (err == -ENOMEM) {
3146                         platform_device_unregister(reg_pdev);
3147                         return err;
3148                 }
3149                 /*
3150                  * N.B. kobject_uevent_env() can fail mainly for when we're out
3151                  * memory which is handled and propagated appropriately above
3152                  * but it can also fail during a netlink_broadcast() or during
3153                  * early boot for call_usermodehelper(). For now treat these
3154                  * errors as non-fatal.
3155                  */
3156                 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
3157         }
3158
3159         /*
3160          * Finally, if the user set the module parameter treat it
3161          * as a user hint.
3162          */
3163         if (!is_world_regdom(ieee80211_regdom))
3164                 regulatory_hint_user(ieee80211_regdom,
3165                                      NL80211_USER_REG_HINT_USER);
3166
3167         return 0;
3168 }
3169
3170 void regulatory_exit(void)
3171 {
3172         struct regulatory_request *reg_request, *tmp;
3173         struct reg_beacon *reg_beacon, *btmp;
3174
3175         cancel_work_sync(&reg_work);
3176         cancel_crda_timeout_sync();
3177         cancel_delayed_work_sync(&reg_check_chans);
3178
3179         /* Lock to suppress warnings */
3180         rtnl_lock();
3181         reset_regdomains(true, NULL);
3182         rtnl_unlock();
3183
3184         dev_set_uevent_suppress(&reg_pdev->dev, true);
3185
3186         platform_device_unregister(reg_pdev);
3187
3188         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3189                 list_del(&reg_beacon->list);
3190                 kfree(reg_beacon);
3191         }
3192
3193         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3194                 list_del(&reg_beacon->list);
3195                 kfree(reg_beacon);
3196         }
3197
3198         list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
3199                 list_del(&reg_request->list);
3200                 kfree(reg_request);
3201         }
3202 }