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