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