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  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20
  21 /**
  22  * DOC: Wireless regulatory infrastructure
  23  *
  24  * The usual implementation is for a driver to read a device EEPROM to
  25  * determine which regulatory domain it should be operating under, then
  26  * looking up the allowable channels in a driver-local table and finally
  27  * registering those channels in the wiphy structure.
  28  *
  29  * Another set of compliance enforcement is for drivers to use their
  30  * own compliance limits which can be stored on the EEPROM. The host
  31  * driver or firmware may ensure these are used.
  32  *
  33  * In addition to all this we provide an extra layer of regulatory
  34  * conformance. For drivers which do not have any regulatory
  35  * information CRDA provides the complete regulatory solution.
  36  * For others it provides a community effort on further restrictions
  37  * to enhance compliance.
  38  *
  39  * Note: When number of rules --> infinity we will not be able to
  40  * index on alpha2 any more, instead we'll probably have to
  41  * rely on some SHA1 checksum of the regdomain for example.
  42  *
  43  */
  44
  45 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  46
  47 #include <linux/kernel.h>
  48 #include <linux/export.h>
  49 #include <linux/slab.h>
  50 #include <linux/list.h>
  51 #include <linux/ctype.h>
  52 #include <linux/nl80211.h>
  53 #include <linux/platform_device.h>
  54 #include <linux/moduleparam.h>
  55 #include <net/cfg80211.h>
  56 #include "core.h"
  57 #include "reg.h"
  58 #include "regdb.h"
  59 #include "nl80211.h"
  60
  61 #ifdef CONFIG_CFG80211_REG_DEBUG
  62 #define REG_DBG_PRINT(format, args...)                  \
  63         printk(KERN_DEBUG pr_fmt(format), ##args)
  64 #else
  65 #define REG_DBG_PRINT(args...)
  66 #endif
  67
  68 enum reg_request_treatment {
  69         REG_REQ_OK,
  70         REG_REQ_IGNORE,
  71         REG_REQ_INTERSECT,
  72         REG_REQ_ALREADY_SET,
  73 };
  74
  75 static struct regulatory_request core_request_world = {
  76         .initiator = NL80211_REGDOM_SET_BY_CORE,
  77         .alpha2[0] = '0',
  78         .alpha2[1] = '0',
  79         .intersect = false,
  80         .processed = true,
  81         .country_ie_env = ENVIRON_ANY,
  82 };
  83
  84 /*
  85  * Receipt of information from last regulatory request,
  86  * protected by RTNL (and can be accessed with RCU protection)
  87  */
  88 static struct regulatory_request __rcu *last_request =
  89         (void __rcu *)&core_request_world;
  90
  91 /* To trigger userspace events */
  92 static struct platform_device *reg_pdev;
  93
  94 static struct device_type reg_device_type = {
  95         .uevent = reg_device_uevent,
  96 };
  97
  98 /*
  99  * Central wireless core regulatory domains, we only need two,
 100  * the current one and a world regulatory domain in case we have no
 101  * information to give us an alpha2.
 102  * (protected by RTNL, can be read under RCU)
 103  */
 104 const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
 105
 106 /*
 107  * Number of devices that registered to the core
 108  * that support cellular base station regulatory hints
 109  * (protected by RTNL)
 110  */
 111 static int reg_num_devs_support_basehint;
 112
 113 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
 114 {
 115         return rtnl_dereference(cfg80211_regdomain);
 116 }
 117
 118 static const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
 119 {
 120         return rtnl_dereference(wiphy->regd);
 121 }
 122
 123 static void rcu_free_regdom(const struct ieee80211_regdomain *r)
 124 {
 125         if (!r)
 126                 return;
 127         kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
 128 }
 129
 130 static struct regulatory_request *get_last_request(void)
 131 {
 132         return rcu_dereference_rtnl(last_request);
 133 }
 134
 135 /* Used to queue up regulatory hints */
 136 static LIST_HEAD(reg_requests_list);
 137 static spinlock_t reg_requests_lock;
 138
 139 /* Used to queue up beacon hints for review */
 140 static LIST_HEAD(reg_pending_beacons);
 141 static spinlock_t reg_pending_beacons_lock;
 142
 143 /* Used to keep track of processed beacon hints */
 144 static LIST_HEAD(reg_beacon_list);
 145
 146 struct reg_beacon {
 147         struct list_head list;
 148         struct ieee80211_channel chan;
 149 };
 150
 151 static void reg_todo(struct work_struct *work);
 152 static DECLARE_WORK(reg_work, reg_todo);
 153
 154 static void reg_timeout_work(struct work_struct *work);
 155 static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
 156
 157 /* We keep a static world regulatory domain in case of the absence of CRDA */
 158 static const struct ieee80211_regdomain world_regdom = {
 159         .n_reg_rules = 6,
 160         .alpha2 =  "00",
 161         .reg_rules = {
 162                 /* IEEE 802.11b/g, channels 1..11 */
 163                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
 164                 /* IEEE 802.11b/g, channels 12..13. */
 165                 REG_RULE(2467-10, 2472+10, 40, 6, 20,
 166                         NL80211_RRF_PASSIVE_SCAN |
 167                         NL80211_RRF_NO_IBSS),
 168                 /* IEEE 802.11 channel 14 - Only JP enables
 169                  * this and for 802.11b only */
 170                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
 171                         NL80211_RRF_PASSIVE_SCAN |
 172                         NL80211_RRF_NO_IBSS |
 173                         NL80211_RRF_NO_OFDM),
 174                 /* IEEE 802.11a, channel 36..48 */
 175                 REG_RULE(5180-10, 5240+10, 160, 6, 20,
 176                         NL80211_RRF_PASSIVE_SCAN |
 177                         NL80211_RRF_NO_IBSS),
 178
 179                 /* IEEE 802.11a, channel 52..64 - DFS required */
 180                 REG_RULE(5260-10, 5320+10, 160, 6, 20,
 181                         NL80211_RRF_PASSIVE_SCAN |
 182                         NL80211_RRF_NO_IBSS |
 183                         NL80211_RRF_DFS),
 184
 185                 /* IEEE 802.11a, channel 100..144 - DFS required */
 186                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
 187                         NL80211_RRF_PASSIVE_SCAN |
 188                         NL80211_RRF_NO_IBSS |
 189                         NL80211_RRF_DFS),
 190
 191                 /* IEEE 802.11a, channel 149..165 */
 192                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
 193                         NL80211_RRF_PASSIVE_SCAN |
 194                         NL80211_RRF_NO_IBSS),
 195
 196                 /* IEEE 802.11ad (60gHz), channels 1..3 */
 197                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
 198         }
 199 };
 200
 201 /* protected by RTNL */
 202 static const struct ieee80211_regdomain *cfg80211_world_regdom =
 203         &world_regdom;
 204
 205 static char *ieee80211_regdom = "00";
 206 static char user_alpha2[2];
 207
 208 module_param(ieee80211_regdom, charp, 0444);
 209 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 210
 211 static void reset_regdomains(bool full_reset,
 212                              const struct ieee80211_regdomain *new_regdom)
 213 {
 214         const struct ieee80211_regdomain *r;
 215         struct regulatory_request *lr;
 216
 217         ASSERT_RTNL();
 218
 219         r = get_cfg80211_regdom();
 220
 221         /* avoid freeing static information or freeing something twice */
 222         if (r == cfg80211_world_regdom)
 223                 r = NULL;
 224         if (cfg80211_world_regdom == &world_regdom)
 225                 cfg80211_world_regdom = NULL;
 226         if (r == &world_regdom)
 227                 r = NULL;
 228
 229         rcu_free_regdom(r);
 230         rcu_free_regdom(cfg80211_world_regdom);
 231
 232         cfg80211_world_regdom = &world_regdom;
 233         rcu_assign_pointer(cfg80211_regdomain, new_regdom);
 234
 235         if (!full_reset)
 236                 return;
 237
 238         lr = get_last_request();
 239         if (lr != &core_request_world && lr)
 240                 kfree_rcu(lr, rcu_head);
 241         rcu_assign_pointer(last_request, &core_request_world);
 242 }
 243
 244 /*
 245  * Dynamic world regulatory domain requested by the wireless
 246  * core upon initialization
 247  */
 248 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 249 {
 250         struct regulatory_request *lr;
 251
 252         lr = get_last_request();
 253
 254         WARN_ON(!lr);
 255
 256         reset_regdomains(false, rd);
 257
 258         cfg80211_world_regdom = rd;
 259 }
 260
 261 bool is_world_regdom(const char *alpha2)
 262 {
 263         if (!alpha2)
 264                 return false;
 265         return alpha2[0] == '0' && alpha2[1] == '0';
 266 }
 267
 268 static bool is_alpha2_set(const char *alpha2)
 269 {
 270         if (!alpha2)
 271                 return false;
 272         return alpha2[0] && alpha2[1];
 273 }
 274
 275 static bool is_unknown_alpha2(const char *alpha2)
 276 {
 277         if (!alpha2)
 278                 return false;
 279         /*
 280          * Special case where regulatory domain was built by driver
 281          * but a specific alpha2 cannot be determined
 282          */
 283         return alpha2[0] == '9' && alpha2[1] == '9';
 284 }
 285
 286 static bool is_intersected_alpha2(const char *alpha2)
 287 {
 288         if (!alpha2)
 289                 return false;
 290         /*
 291          * Special case where regulatory domain is the
 292          * result of an intersection between two regulatory domain
 293          * structures
 294          */
 295         return alpha2[0] == '9' && alpha2[1] == '8';
 296 }
 297
 298 static bool is_an_alpha2(const char *alpha2)
 299 {
 300         if (!alpha2)
 301                 return false;
 302         return isalpha(alpha2[0]) && isalpha(alpha2[1]);
 303 }
 304
 305 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 306 {
 307         if (!alpha2_x || !alpha2_y)
 308                 return false;
 309         return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
 310 }
 311
 312 static bool regdom_changes(const char *alpha2)
 313 {
 314         const struct ieee80211_regdomain *r = get_cfg80211_regdom();
 315
 316         if (!r)
 317                 return true;
 318         return !alpha2_equal(r->alpha2, alpha2);
 319 }
 320
 321 /*
 322  * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
 323  * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
 324  * has ever been issued.
 325  */
 326 static bool is_user_regdom_saved(void)
 327 {
 328         if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
 329                 return false;
 330
 331         /* This would indicate a mistake on the design */
 332         if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
 333                  "Unexpected user alpha2: %c%c\n",
 334                  user_alpha2[0], user_alpha2[1]))
 335                 return false;
 336
 337         return true;
 338 }
 339
 340 static const struct ieee80211_regdomain *
 341 reg_copy_regd(const struct ieee80211_regdomain *src_regd)
 342 {
 343         struct ieee80211_regdomain *regd;
 344         int size_of_regd;
 345         unsigned int i;
 346
 347         size_of_regd =
 348                 sizeof(struct ieee80211_regdomain) +
 349                 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
 350
 351         regd = kzalloc(size_of_regd, GFP_KERNEL);
 352         if (!regd)
 353                 return ERR_PTR(-ENOMEM);
 354
 355         memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
 356
 357         for (i = 0; i < src_regd->n_reg_rules; i++)
 358                 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
 359                        sizeof(struct ieee80211_reg_rule));
 360
 361         return regd;
 362 }
 363
 364 #ifdef CONFIG_CFG80211_INTERNAL_REGDB
 365 struct reg_regdb_search_request {
 366         char alpha2[2];
 367         struct list_head list;
 368 };
 369
 370 static LIST_HEAD(reg_regdb_search_list);
 371 static DEFINE_MUTEX(reg_regdb_search_mutex);
 372
 373 static void reg_regdb_search(struct work_struct *work)
 374 {
 375         struct reg_regdb_search_request *request;
 376         const struct ieee80211_regdomain *curdom, *regdom = NULL;
 377         int i;
 378
 379         rtnl_lock();
 380
 381         mutex_lock(&reg_regdb_search_mutex);
 382         while (!list_empty(&reg_regdb_search_list)) {
 383                 request = list_first_entry(&reg_regdb_search_list,
 384                                            struct reg_regdb_search_request,
 385                                            list);
 386                 list_del(&request->list);
 387
 388                 for (i = 0; i < reg_regdb_size; i++) {
 389                         curdom = reg_regdb[i];
 390
 391                         if (alpha2_equal(request->alpha2, curdom->alpha2)) {
 392                                 regdom = reg_copy_regd(curdom);
 393                                 break;
 394                         }
 395                 }
 396
 397                 kfree(request);
 398         }
 399         mutex_unlock(&reg_regdb_search_mutex);
 400
 401         if (!IS_ERR_OR_NULL(regdom))
 402                 set_regdom(regdom);
 403
 404         rtnl_unlock();
 405 }
 406
 407 static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
 408
 409 static void reg_regdb_query(const char *alpha2)
 410 {
 411         struct reg_regdb_search_request *request;
 412
 413         if (!alpha2)
 414                 return;
 415
 416         request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
 417         if (!request)
 418                 return;
 419
 420         memcpy(request->alpha2, alpha2, 2);
 421
 422         mutex_lock(&reg_regdb_search_mutex);
 423         list_add_tail(&request->list, &reg_regdb_search_list);
 424         mutex_unlock(&reg_regdb_search_mutex);
 425
 426         schedule_work(&reg_regdb_work);
 427 }
 428
 429 /* Feel free to add any other sanity checks here */
 430 static void reg_regdb_size_check(void)
 431 {
 432         /* We should ideally BUILD_BUG_ON() but then random builds would fail */
 433         WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
 434 }
 435 #else
 436 static inline void reg_regdb_size_check(void) {}
 437 static inline void reg_regdb_query(const char *alpha2) {}
 438 #endif /* CONFIG_CFG80211_INTERNAL_REGDB */
 439
 440 /*
 441  * This lets us keep regulatory code which is updated on a regulatory
 442  * basis in userspace. Country information is filled in by
 443  * reg_device_uevent
 444  */
 445 static int call_crda(const char *alpha2)
 446 {
 447         if (!is_world_regdom((char *) alpha2))
 448                 pr_info("Calling CRDA for country: %c%c\n",
 449                         alpha2[0], alpha2[1]);
 450         else
 451                 pr_info("Calling CRDA to update world regulatory domain\n");
 452
 453         /* query internal regulatory database (if it exists) */
 454         reg_regdb_query(alpha2);
 455
 456         return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
 457 }
 458
 459 static bool reg_is_valid_request(const char *alpha2)
 460 {
 461         struct regulatory_request *lr = get_last_request();
 462
 463         if (!lr || lr->processed)
 464                 return false;
 465
 466         return alpha2_equal(lr->alpha2, alpha2);
 467 }
 468
 469 /* Sanity check on a regulatory rule */
 470 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 471 {
 472         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 473         u32 freq_diff;
 474
 475         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
 476                 return false;
 477
 478         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
 479                 return false;
 480
 481         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 482
 483         if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
 484             freq_range->max_bandwidth_khz > freq_diff)
 485                 return false;
 486
 487         return true;
 488 }
 489
 490 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
 491 {
 492         const struct ieee80211_reg_rule *reg_rule = NULL;
 493         unsigned int i;
 494
 495         if (!rd->n_reg_rules)
 496                 return false;
 497
 498         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 499                 return false;
 500
 501         for (i = 0; i < rd->n_reg_rules; i++) {
 502                 reg_rule = &rd->reg_rules[i];
 503                 if (!is_valid_reg_rule(reg_rule))
 504                         return false;
 505         }
 506
 507         return true;
 508 }
 509
 510 static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
 511                             u32 center_freq_khz, u32 bw_khz)
 512 {
 513         u32 start_freq_khz, end_freq_khz;
 514
 515         start_freq_khz = center_freq_khz - (bw_khz/2);
 516         end_freq_khz = center_freq_khz + (bw_khz/2);
 517
 518         if (start_freq_khz >= freq_range->start_freq_khz &&
 519             end_freq_khz <= freq_range->end_freq_khz)
 520                 return true;
 521
 522         return false;
 523 }
 524
 525 /**
 526  * freq_in_rule_band - tells us if a frequency is in a frequency band
 527  * @freq_range: frequency rule we want to query
 528  * @freq_khz: frequency we are inquiring about
 529  *
 530  * This lets us know if a specific frequency rule is or is not relevant to
 531  * a specific frequency's band. Bands are device specific and artificial
 532  * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
 533  * however it is safe for now to assume that a frequency rule should not be
 534  * part of a frequency's band if the start freq or end freq are off by more
 535  * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
 536  * 60 GHz band.
 537  * This resolution can be lowered and should be considered as we add
 538  * regulatory rule support for other "bands".
 539  **/
 540 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 541                               u32 freq_khz)
 542 {
 543 #define ONE_GHZ_IN_KHZ  1000000
 544         /*
 545          * From 802.11ad: directional multi-gigabit (DMG):
 546          * Pertaining to operation in a frequency band containing a channel
 547          * with the Channel starting frequency above 45 GHz.
 548          */
 549         u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
 550                         10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
 551         if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
 552                 return true;
 553         if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
 554                 return true;
 555         return false;
 556 #undef ONE_GHZ_IN_KHZ
 557 }
 558
 559 /*
 560  * Helper for regdom_intersect(), this does the real
 561  * mathematical intersection fun
 562  */
 563 static int reg_rules_intersect(const struct ieee80211_reg_rule *rule1,
 564                                const struct ieee80211_reg_rule *rule2,
 565                                struct ieee80211_reg_rule *intersected_rule)
 566 {
 567         const struct ieee80211_freq_range *freq_range1, *freq_range2;
 568         struct ieee80211_freq_range *freq_range;
 569         const struct ieee80211_power_rule *power_rule1, *power_rule2;
 570         struct ieee80211_power_rule *power_rule;
 571         u32 freq_diff;
 572
 573         freq_range1 = &rule1->freq_range;
 574         freq_range2 = &rule2->freq_range;
 575         freq_range = &intersected_rule->freq_range;
 576
 577         power_rule1 = &rule1->power_rule;
 578         power_rule2 = &rule2->power_rule;
 579         power_rule = &intersected_rule->power_rule;
 580
 581         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
 582                                          freq_range2->start_freq_khz);
 583         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
 584                                        freq_range2->end_freq_khz);
 585         freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
 586                                             freq_range2->max_bandwidth_khz);
 587
 588         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 589         if (freq_range->max_bandwidth_khz > freq_diff)
 590                 freq_range->max_bandwidth_khz = freq_diff;
 591
 592         power_rule->max_eirp = min(power_rule1->max_eirp,
 593                 power_rule2->max_eirp);
 594         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
 595                 power_rule2->max_antenna_gain);
 596
 597         intersected_rule->flags = rule1->flags | rule2->flags;
 598
 599         if (!is_valid_reg_rule(intersected_rule))
 600                 return -EINVAL;
 601
 602         return 0;
 603 }
 604
 605 /**
 606  * regdom_intersect - do the intersection between two regulatory domains
 607  * @rd1: first regulatory domain
 608  * @rd2: second regulatory domain
 609  *
 610  * Use this function to get the intersection between two regulatory domains.
 611  * Once completed we will mark the alpha2 for the rd as intersected, "98",
 612  * as no one single alpha2 can represent this regulatory domain.
 613  *
 614  * Returns a pointer to the regulatory domain structure which will hold the
 615  * resulting intersection of rules between rd1 and rd2. We will
 616  * kzalloc() this structure for you.
 617  */
 618 static struct ieee80211_regdomain *
 619 regdom_intersect(const struct ieee80211_regdomain *rd1,
 620                  const struct ieee80211_regdomain *rd2)
 621 {
 622         int r, size_of_regd;
 623         unsigned int x, y;
 624         unsigned int num_rules = 0, rule_idx = 0;
 625         const struct ieee80211_reg_rule *rule1, *rule2;
 626         struct ieee80211_reg_rule *intersected_rule;
 627         struct ieee80211_regdomain *rd;
 628         /* This is just a dummy holder to help us count */
 629         struct ieee80211_reg_rule dummy_rule;
 630
 631         if (!rd1 || !rd2)
 632                 return NULL;
 633
 634         /*
 635          * First we get a count of the rules we'll need, then we actually
 636          * build them. This is to so we can malloc() and free() a
 637          * regdomain once. The reason we use reg_rules_intersect() here
 638          * is it will return -EINVAL if the rule computed makes no sense.
 639          * All rules that do check out OK are valid.
 640          */
 641
 642         for (x = 0; x < rd1->n_reg_rules; x++) {
 643                 rule1 = &rd1->reg_rules[x];
 644                 for (y = 0; y < rd2->n_reg_rules; y++) {
 645                         rule2 = &rd2->reg_rules[y];
 646                         if (!reg_rules_intersect(rule1, rule2, &dummy_rule))
 647                                 num_rules++;
 648                 }
 649         }
 650
 651         if (!num_rules)
 652                 return NULL;
 653
 654         size_of_regd = sizeof(struct ieee80211_regdomain) +
 655                        num_rules * sizeof(struct ieee80211_reg_rule);
 656
 657         rd = kzalloc(size_of_regd, GFP_KERNEL);
 658         if (!rd)
 659                 return NULL;
 660
 661         for (x = 0; x < rd1->n_reg_rules && rule_idx < num_rules; x++) {
 662                 rule1 = &rd1->reg_rules[x];
 663                 for (y = 0; y < rd2->n_reg_rules && rule_idx < num_rules; y++) {
 664                         rule2 = &rd2->reg_rules[y];
 665                         /*
 666                          * This time around instead of using the stack lets
 667                          * write to the target rule directly saving ourselves
 668                          * a memcpy()
 669                          */
 670                         intersected_rule = &rd->reg_rules[rule_idx];
 671                         r = reg_rules_intersect(rule1, rule2, intersected_rule);
 672                         /*
 673                          * No need to memset here the intersected rule here as
 674                          * we're not using the stack anymore
 675                          */
 676                         if (r)
 677                                 continue;
 678                         rule_idx++;
 679                 }
 680         }
 681
 682         if (rule_idx != num_rules) {
 683                 kfree(rd);
 684                 return NULL;
 685         }
 686
 687         rd->n_reg_rules = num_rules;
 688         rd->alpha2[0] = '9';
 689         rd->alpha2[1] = '8';
 690
 691         return rd;
 692 }
 693
 694 /*
 695  * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 696  * want to just have the channel structure use these
 697  */
 698 static u32 map_regdom_flags(u32 rd_flags)
 699 {
 700         u32 channel_flags = 0;
 701         if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
 702                 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 703         if (rd_flags & NL80211_RRF_NO_IBSS)
 704                 channel_flags |= IEEE80211_CHAN_NO_IBSS;
 705         if (rd_flags & NL80211_RRF_DFS)
 706                 channel_flags |= IEEE80211_CHAN_RADAR;
 707         if (rd_flags & NL80211_RRF_NO_OFDM)
 708                 channel_flags |= IEEE80211_CHAN_NO_OFDM;
 709         return channel_flags;
 710 }
 711
 712 static const struct ieee80211_reg_rule *
 713 freq_reg_info_regd(struct wiphy *wiphy, u32 center_freq,
 714                    const struct ieee80211_regdomain *regd)
 715 {
 716         int i;
 717         bool band_rule_found = false;
 718         bool bw_fits = false;
 719
 720         if (!regd)
 721                 return ERR_PTR(-EINVAL);
 722
 723         for (i = 0; i < regd->n_reg_rules; i++) {
 724                 const struct ieee80211_reg_rule *rr;
 725                 const struct ieee80211_freq_range *fr = NULL;
 726
 727                 rr = &regd->reg_rules[i];
 728                 fr = &rr->freq_range;
 729
 730                 /*
 731                  * We only need to know if one frequency rule was
 732                  * was in center_freq's band, that's enough, so lets
 733                  * not overwrite it once found
 734                  */
 735                 if (!band_rule_found)
 736                         band_rule_found = freq_in_rule_band(fr, center_freq);
 737
 738                 bw_fits = reg_does_bw_fit(fr, center_freq, MHZ_TO_KHZ(20));
 739
 740                 if (band_rule_found && bw_fits)
 741                         return rr;
 742         }
 743
 744         if (!band_rule_found)
 745                 return ERR_PTR(-ERANGE);
 746
 747         return ERR_PTR(-EINVAL);
 748 }
 749
 750 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
 751                                                u32 center_freq)
 752 {
 753         const struct ieee80211_regdomain *regd;
 754         struct regulatory_request *lr = get_last_request();
 755
 756         /*
 757          * Follow the driver's regulatory domain, if present, unless a country
 758          * IE has been processed or a user wants to help complaince further
 759          */
 760         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 761             lr->initiator != NL80211_REGDOM_SET_BY_USER &&
 762             wiphy->regd)
 763                 regd = get_wiphy_regdom(wiphy);
 764         else
 765                 regd = get_cfg80211_regdom();
 766
 767         return freq_reg_info_regd(wiphy, center_freq, regd);
 768 }
 769 EXPORT_SYMBOL(freq_reg_info);
 770
 771 const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
 772 {
 773         switch (initiator) {
 774         case NL80211_REGDOM_SET_BY_CORE:
 775                 return "core";
 776         case NL80211_REGDOM_SET_BY_USER:
 777                 return "user";
 778         case NL80211_REGDOM_SET_BY_DRIVER:
 779                 return "driver";
 780         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
 781                 return "country IE";
 782         default:
 783                 WARN_ON(1);
 784                 return "bug";
 785         }
 786 }
 787 EXPORT_SYMBOL(reg_initiator_name);
 788
 789 #ifdef CONFIG_CFG80211_REG_DEBUG
 790
 791 static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
 792                                     const struct ieee80211_reg_rule *reg_rule)
 793 {
 794         const struct ieee80211_power_rule *power_rule;
 795         const struct ieee80211_freq_range *freq_range;
 796         char max_antenna_gain[32];
 797
 798         power_rule = &reg_rule->power_rule;
 799         freq_range = &reg_rule->freq_range;
 800
 801         if (!power_rule->max_antenna_gain)
 802                 snprintf(max_antenna_gain, 32, "N/A");
 803         else
 804                 snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
 805
 806         REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
 807                       chan->center_freq);
 808
 809         REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
 810                       freq_range->start_freq_khz, freq_range->end_freq_khz,
 811                       freq_range->max_bandwidth_khz, max_antenna_gain,
 812                       power_rule->max_eirp);
 813 }
 814 #else
 815 static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
 816                                     const struct ieee80211_reg_rule *reg_rule)
 817 {
 818         return;
 819 }
 820 #endif
 821
 822 /*
 823  * Note that right now we assume the desired channel bandwidth
 824  * is always 20 MHz for each individual channel (HT40 uses 20 MHz
 825  * per channel, the primary and the extension channel).
 826  */
 827 static void handle_channel(struct wiphy *wiphy,
 828                            enum nl80211_reg_initiator initiator,
 829                            struct ieee80211_channel *chan)
 830 {
 831         u32 flags, bw_flags = 0;
 832         const struct ieee80211_reg_rule *reg_rule = NULL;
 833         const struct ieee80211_power_rule *power_rule = NULL;
 834         const struct ieee80211_freq_range *freq_range = NULL;
 835         struct wiphy *request_wiphy = NULL;
 836         struct regulatory_request *lr = get_last_request();
 837
 838         request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
 839
 840         flags = chan->orig_flags;
 841
 842         reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
 843         if (IS_ERR(reg_rule)) {
 844                 /*
 845                  * We will disable all channels that do not match our
 846                  * received regulatory rule unless the hint is coming
 847                  * from a Country IE and the Country IE had no information
 848                  * about a band. The IEEE 802.11 spec allows for an AP
 849                  * to send only a subset of the regulatory rules allowed,
 850                  * so an AP in the US that only supports 2.4 GHz may only send
 851                  * a country IE with information for the 2.4 GHz band
 852                  * while 5 GHz is still supported.
 853                  */
 854                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 855                     PTR_ERR(reg_rule) == -ERANGE)
 856                         return;
 857
 858                 REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
 859                 chan->flags |= IEEE80211_CHAN_DISABLED;
 860                 return;
 861         }
 862
 863         chan_reg_rule_print_dbg(chan, reg_rule);
 864
 865         power_rule = &reg_rule->power_rule;
 866         freq_range = &reg_rule->freq_range;
 867
 868         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
 869                 bw_flags = IEEE80211_CHAN_NO_HT40;
 870         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
 871                 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
 872         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
 873                 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
 874
 875         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
 876             request_wiphy && request_wiphy == wiphy &&
 877             request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
 878                 /*
 879                  * This guarantees the driver's requested regulatory domain
 880                  * will always be used as a base for further regulatory
 881                  * settings
 882                  */
 883                 chan->flags = chan->orig_flags =
 884                         map_regdom_flags(reg_rule->flags) | bw_flags;
 885                 chan->max_antenna_gain = chan->orig_mag =
 886                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
 887                 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
 888                         (int) MBM_TO_DBM(power_rule->max_eirp);
 889                 return;
 890         }
 891
 892         chan->dfs_state = NL80211_DFS_USABLE;
 893         chan->dfs_state_entered = jiffies;
 894
 895         chan->beacon_found = false;
 896         chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
 897         chan->max_antenna_gain =
 898                 min_t(int, chan->orig_mag,
 899                       MBI_TO_DBI(power_rule->max_antenna_gain));
 900         chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 901         if (chan->orig_mpwr) {
 902                 /*
 903                  * Devices that have their own custom regulatory domain
 904                  * but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
 905                  * passed country IE power settings.
 906                  */
 907                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 908                     wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
 909                     wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
 910                         chan->max_power = chan->max_reg_power;
 911                 else
 912                         chan->max_power = min(chan->orig_mpwr,
 913                                               chan->max_reg_power);
 914         } else
 915                 chan->max_power = chan->max_reg_power;
 916 }
 917
 918 static void handle_band(struct wiphy *wiphy,
 919                         enum nl80211_reg_initiator initiator,
 920                         struct ieee80211_supported_band *sband)
 921 {
 922         unsigned int i;
 923
 924         if (!sband)
 925                 return;
 926
 927         for (i = 0; i < sband->n_channels; i++)
 928                 handle_channel(wiphy, initiator, &sband->channels[i]);
 929 }
 930
 931 static bool reg_request_cell_base(struct regulatory_request *request)
 932 {
 933         if (request->initiator != NL80211_REGDOM_SET_BY_USER)
 934                 return false;
 935         return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
 936 }
 937
 938 bool reg_last_request_cell_base(void)
 939 {
 940         return reg_request_cell_base(get_last_request());
 941 }
 942
 943 #ifdef CONFIG_CFG80211_CERTIFICATION_ONUS
 944 /* Core specific check */
 945 static enum reg_request_treatment
 946 reg_ignore_cell_hint(struct regulatory_request *pending_request)
 947 {
 948         struct regulatory_request *lr = get_last_request();
 949
 950         if (!reg_num_devs_support_basehint)
 951                 return REG_REQ_IGNORE;
 952
 953         if (reg_request_cell_base(lr) &&
 954             !regdom_changes(pending_request->alpha2))
 955                 return REG_REQ_ALREADY_SET;
 956
 957         return REG_REQ_OK;
 958 }
 959
 960 /* Device specific check */
 961 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
 962 {
 963         return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
 964 }
 965 #else
 966 static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
 967 {
 968         return REG_REQ_IGNORE;
 969 }
 970
 971 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
 972 {
 973         return true;
 974 }
 975 #endif
 976
 977
 978 static bool ignore_reg_update(struct wiphy *wiphy,
 979                               enum nl80211_reg_initiator initiator)
 980 {
 981         struct regulatory_request *lr = get_last_request();
 982
 983         if (!lr) {
 984                 REG_DBG_PRINT("Ignoring regulatory request set by %s "
 985                               "since last_request is not set\n",
 986                               reg_initiator_name(initiator));
 987                 return true;
 988         }
 989
 990         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
 991             wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
 992                 REG_DBG_PRINT("Ignoring regulatory request set by %s "
 993                               "since the driver uses its own custom "
 994                               "regulatory domain\n",
 995                               reg_initiator_name(initiator));
 996                 return true;
 997         }
 998
 999         /*
1000          * wiphy->regd will be set once the device has its own
1001          * desired regulatory domain set
1002          */
1003         if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
1004             initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1005             !is_world_regdom(lr->alpha2)) {
1006                 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1007                               "since the driver requires its own regulatory "
1008                               "domain to be set first\n",
1009                               reg_initiator_name(initiator));
1010                 return true;
1011         }
1012
1013         if (reg_request_cell_base(lr))
1014                 return reg_dev_ignore_cell_hint(wiphy);
1015
1016         return false;
1017 }
1018
1019 static bool reg_is_world_roaming(struct wiphy *wiphy)
1020 {
1021         const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1022         const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1023         struct regulatory_request *lr = get_last_request();
1024
1025         if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1026                 return true;
1027
1028         if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1029             wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1030                 return true;
1031
1032         return false;
1033 }
1034
1035 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
1036                               struct reg_beacon *reg_beacon)
1037 {
1038         struct ieee80211_supported_band *sband;
1039         struct ieee80211_channel *chan;
1040         bool channel_changed = false;
1041         struct ieee80211_channel chan_before;
1042
1043         sband = wiphy->bands[reg_beacon->chan.band];
1044         chan = &sband->channels[chan_idx];
1045
1046         if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1047                 return;
1048
1049         if (chan->beacon_found)
1050                 return;
1051
1052         chan->beacon_found = true;
1053
1054         if (!reg_is_world_roaming(wiphy))
1055                 return;
1056
1057         if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
1058                 return;
1059
1060         chan_before.center_freq = chan->center_freq;
1061         chan_before.flags = chan->flags;
1062
1063         if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
1064                 chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
1065                 channel_changed = true;
1066         }
1067
1068         if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
1069                 chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
1070                 channel_changed = true;
1071         }
1072
1073         if (channel_changed)
1074                 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1075 }
1076
1077 /*
1078  * Called when a scan on a wiphy finds a beacon on
1079  * new channel
1080  */
1081 static void wiphy_update_new_beacon(struct wiphy *wiphy,
1082                                     struct reg_beacon *reg_beacon)
1083 {
1084         unsigned int i;
1085         struct ieee80211_supported_band *sband;
1086
1087         if (!wiphy->bands[reg_beacon->chan.band])
1088                 return;
1089
1090         sband = wiphy->bands[reg_beacon->chan.band];
1091
1092         for (i = 0; i < sband->n_channels; i++)
1093                 handle_reg_beacon(wiphy, i, reg_beacon);
1094 }
1095
1096 /*
1097  * Called upon reg changes or a new wiphy is added
1098  */
1099 static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1100 {
1101         unsigned int i;
1102         struct ieee80211_supported_band *sband;
1103         struct reg_beacon *reg_beacon;
1104
1105         list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1106                 if (!wiphy->bands[reg_beacon->chan.band])
1107                         continue;
1108                 sband = wiphy->bands[reg_beacon->chan.band];
1109                 for (i = 0; i < sband->n_channels; i++)
1110                         handle_reg_beacon(wiphy, i, reg_beacon);
1111         }
1112 }
1113
1114 /* Reap the advantages of previously found beacons */
1115 static void reg_process_beacons(struct wiphy *wiphy)
1116 {
1117         /*
1118          * Means we are just firing up cfg80211, so no beacons would
1119          * have been processed yet.
1120          */
1121         if (!last_request)
1122                 return;
1123         wiphy_update_beacon_reg(wiphy);
1124 }
1125
1126 static bool is_ht40_allowed(struct ieee80211_channel *chan)
1127 {
1128         if (!chan)
1129                 return false;
1130         if (chan->flags & IEEE80211_CHAN_DISABLED)
1131                 return false;
1132         /* This would happen when regulatory rules disallow HT40 completely */
1133         if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
1134                 return false;
1135         return true;
1136 }
1137
1138 static void reg_process_ht_flags_channel(struct wiphy *wiphy,
1139                                          struct ieee80211_channel *channel)
1140 {
1141         struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
1142         struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1143         unsigned int i;
1144
1145         if (!is_ht40_allowed(channel)) {
1146                 channel->flags |= IEEE80211_CHAN_NO_HT40;
1147                 return;
1148         }
1149
1150         /*
1151          * We need to ensure the extension channels exist to
1152          * be able to use HT40- or HT40+, this finds them (or not)
1153          */
1154         for (i = 0; i < sband->n_channels; i++) {
1155                 struct ieee80211_channel *c = &sband->channels[i];
1156
1157                 if (c->center_freq == (channel->center_freq - 20))
1158                         channel_before = c;
1159                 if (c->center_freq == (channel->center_freq + 20))
1160                         channel_after = c;
1161         }
1162
1163         /*
1164          * Please note that this assumes target bandwidth is 20 MHz,
1165          * if that ever changes we also need to change the below logic
1166          * to include that as well.
1167          */
1168         if (!is_ht40_allowed(channel_before))
1169                 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1170         else
1171                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1172
1173         if (!is_ht40_allowed(channel_after))
1174                 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1175         else
1176                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1177 }
1178
1179 static void reg_process_ht_flags_band(struct wiphy *wiphy,
1180                                       struct ieee80211_supported_band *sband)
1181 {
1182         unsigned int i;
1183
1184         if (!sband)
1185                 return;
1186
1187         for (i = 0; i < sband->n_channels; i++)
1188                 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
1189 }
1190
1191 static void reg_process_ht_flags(struct wiphy *wiphy)
1192 {
1193         enum ieee80211_band band;
1194
1195         if (!wiphy)
1196                 return;
1197
1198         for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1199                 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
1200 }
1201
1202 static void wiphy_update_regulatory(struct wiphy *wiphy,
1203                                     enum nl80211_reg_initiator initiator)
1204 {
1205         enum ieee80211_band band;
1206         struct regulatory_request *lr = get_last_request();
1207
1208         if (ignore_reg_update(wiphy, initiator))
1209                 return;
1210
1211         lr->dfs_region = get_cfg80211_regdom()->dfs_region;
1212
1213         for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1214                 handle_band(wiphy, initiator, wiphy->bands[band]);
1215
1216         reg_process_beacons(wiphy);
1217         reg_process_ht_flags(wiphy);
1218
1219         if (wiphy->reg_notifier)
1220                 wiphy->reg_notifier(wiphy, lr);
1221 }
1222
1223 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1224 {
1225         struct cfg80211_registered_device *rdev;
1226         struct wiphy *wiphy;
1227
1228         ASSERT_RTNL();
1229
1230         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1231                 wiphy = &rdev->wiphy;
1232                 wiphy_update_regulatory(wiphy, initiator);
1233                 /*
1234                  * Regulatory updates set by CORE are ignored for custom
1235                  * regulatory cards. Let us notify the changes to the driver,
1236                  * as some drivers used this to restore its orig_* reg domain.
1237                  */
1238                 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1239                     wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
1240                     wiphy->reg_notifier)
1241                         wiphy->reg_notifier(wiphy, get_last_request());
1242         }
1243 }
1244
1245 static void handle_channel_custom(struct wiphy *wiphy,
1246                                   struct ieee80211_channel *chan,
1247                                   const struct ieee80211_regdomain *regd)
1248 {
1249         u32 bw_flags = 0;
1250         const struct ieee80211_reg_rule *reg_rule = NULL;
1251         const struct ieee80211_power_rule *power_rule = NULL;
1252         const struct ieee80211_freq_range *freq_range = NULL;
1253
1254         reg_rule = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
1255                                       regd);
1256
1257         if (IS_ERR(reg_rule)) {
1258                 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1259                               chan->center_freq);
1260                 chan->flags = IEEE80211_CHAN_DISABLED;
1261                 return;
1262         }
1263
1264         chan_reg_rule_print_dbg(chan, reg_rule);
1265
1266         power_rule = &reg_rule->power_rule;
1267         freq_range = &reg_rule->freq_range;
1268
1269         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1270                 bw_flags = IEEE80211_CHAN_NO_HT40;
1271         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
1272                 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1273         if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
1274                 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1275
1276         chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1277         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1278         chan->max_reg_power = chan->max_power =
1279                 (int) MBM_TO_DBM(power_rule->max_eirp);
1280 }
1281
1282 static void handle_band_custom(struct wiphy *wiphy,
1283                                struct ieee80211_supported_band *sband,
1284                                const struct ieee80211_regdomain *regd)
1285 {
1286         unsigned int i;
1287
1288         if (!sband)
1289                 return;
1290
1291         for (i = 0; i < sband->n_channels; i++)
1292                 handle_channel_custom(wiphy, &sband->channels[i], regd);
1293 }
1294
1295 /* Used by drivers prior to wiphy registration */
1296 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1297                                    const struct ieee80211_regdomain *regd)
1298 {
1299         enum ieee80211_band band;
1300         unsigned int bands_set = 0;
1301
1302         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1303                 if (!wiphy->bands[band])
1304                         continue;
1305                 handle_band_custom(wiphy, wiphy->bands[band], regd);
1306                 bands_set++;
1307         }
1308
1309         /*
1310          * no point in calling this if it won't have any effect
1311          * on your device's supported bands.
1312          */
1313         WARN_ON(!bands_set);
1314 }
1315 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1316
1317 /* This has the logic which determines when a new request
1318  * should be ignored. */
1319 static enum reg_request_treatment
1320 get_reg_request_treatment(struct wiphy *wiphy,
1321                           struct regulatory_request *pending_request)
1322 {
1323         struct wiphy *last_wiphy = NULL;
1324         struct regulatory_request *lr = get_last_request();
1325
1326         /* All initial requests are respected */
1327         if (!lr)
1328                 return REG_REQ_OK;
1329
1330         switch (pending_request->initiator) {
1331         case NL80211_REGDOM_SET_BY_CORE:
1332                 return REG_REQ_OK;
1333         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1334                 if (reg_request_cell_base(lr)) {
1335                         /* Trust a Cell base station over the AP's country IE */
1336                         if (regdom_changes(pending_request->alpha2))
1337                                 return REG_REQ_IGNORE;
1338                         return REG_REQ_ALREADY_SET;
1339                 }
1340
1341                 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
1342
1343                 if (unlikely(!is_an_alpha2(pending_request->alpha2)))
1344                         return -EINVAL;
1345                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
1346                         if (last_wiphy != wiphy) {
1347                                 /*
1348                                  * Two cards with two APs claiming different
1349                                  * Country IE alpha2s. We could
1350                                  * intersect them, but that seems unlikely
1351                                  * to be correct. Reject second one for now.
1352                                  */
1353                                 if (regdom_changes(pending_request->alpha2))
1354                                         return REG_REQ_IGNORE;
1355                                 return REG_REQ_ALREADY_SET;
1356                         }
1357                         /*
1358                          * Two consecutive Country IE hints on the same wiphy.
1359                          * This should be picked up early by the driver/stack
1360                          */
1361                         if (WARN_ON(regdom_changes(pending_request->alpha2)))
1362                                 return REG_REQ_OK;
1363                         return REG_REQ_ALREADY_SET;
1364                 }
1365                 return REG_REQ_OK;
1366         case NL80211_REGDOM_SET_BY_DRIVER:
1367                 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
1368                         if (regdom_changes(pending_request->alpha2))
1369                                 return REG_REQ_OK;
1370                         return REG_REQ_ALREADY_SET;
1371                 }
1372
1373                 /*
1374                  * This would happen if you unplug and plug your card
1375                  * back in or if you add a new device for which the previously
1376                  * loaded card also agrees on the regulatory domain.
1377                  */
1378                 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1379                     !regdom_changes(pending_request->alpha2))
1380                         return REG_REQ_ALREADY_SET;
1381
1382                 return REG_REQ_INTERSECT;
1383         case NL80211_REGDOM_SET_BY_USER:
1384                 if (reg_request_cell_base(pending_request))
1385                         return reg_ignore_cell_hint(pending_request);
1386
1387                 if (reg_request_cell_base(lr))
1388                         return REG_REQ_IGNORE;
1389
1390                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
1391                         return REG_REQ_INTERSECT;
1392                 /*
1393                  * If the user knows better the user should set the regdom
1394                  * to their country before the IE is picked up
1395                  */
1396                 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
1397                     lr->intersect)
1398                         return REG_REQ_IGNORE;
1399                 /*
1400                  * Process user requests only after previous user/driver/core
1401                  * requests have been processed
1402                  */
1403                 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
1404                      lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1405                      lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
1406                     regdom_changes(lr->alpha2))
1407                         return REG_REQ_IGNORE;
1408
1409                 if (!regdom_changes(pending_request->alpha2))
1410                         return REG_REQ_ALREADY_SET;
1411
1412                 return REG_REQ_OK;
1413         }
1414
1415         return REG_REQ_IGNORE;
1416 }
1417
1418 static void reg_set_request_processed(void)
1419 {
1420         bool need_more_processing = false;
1421         struct regulatory_request *lr = get_last_request();
1422
1423         lr->processed = true;
1424
1425         spin_lock(&reg_requests_lock);
1426         if (!list_empty(&reg_requests_list))
1427                 need_more_processing = true;
1428         spin_unlock(&reg_requests_lock);
1429
1430         if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
1431                 cancel_delayed_work(&reg_timeout);
1432
1433         if (need_more_processing)
1434                 schedule_work(&reg_work);
1435 }
1436
1437 /**
1438  * __regulatory_hint - hint to the wireless core a regulatory domain
1439  * @wiphy: if the hint comes from country information from an AP, this
1440  *      is required to be set to the wiphy that received the information
1441  * @pending_request: the regulatory request currently being processed
1442  *
1443  * The Wireless subsystem can use this function to hint to the wireless core
1444  * what it believes should be the current regulatory domain.
1445  *
1446  * Returns one of the different reg request treatment values.
1447  */
1448 static enum reg_request_treatment
1449 __regulatory_hint(struct wiphy *wiphy,
1450                   struct regulatory_request *pending_request)
1451 {
1452         const struct ieee80211_regdomain *regd;
1453         bool intersect = false;
1454         enum reg_request_treatment treatment;
1455         struct regulatory_request *lr;
1456
1457         treatment = get_reg_request_treatment(wiphy, pending_request);
1458
1459         switch (treatment) {
1460         case REG_REQ_INTERSECT:
1461                 if (pending_request->initiator ==
1462                     NL80211_REGDOM_SET_BY_DRIVER) {
1463                         regd = reg_copy_regd(get_cfg80211_regdom());
1464                         if (IS_ERR(regd)) {
1465                                 kfree(pending_request);
1466                                 return PTR_ERR(regd);
1467                         }
1468                         rcu_assign_pointer(wiphy->regd, regd);
1469                 }
1470                 intersect = true;
1471                 break;
1472         case REG_REQ_OK:
1473                 break;
1474         default:
1475                 /*
1476                  * If the regulatory domain being requested by the
1477                  * driver has already been set just copy it to the
1478                  * wiphy
1479                  */
1480                 if (treatment == REG_REQ_ALREADY_SET &&
1481                     pending_request->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
1482                         regd = reg_copy_regd(get_cfg80211_regdom());
1483                         if (IS_ERR(regd)) {
1484                                 kfree(pending_request);
1485                                 return REG_REQ_IGNORE;
1486                         }
1487                         treatment = REG_REQ_ALREADY_SET;
1488                         rcu_assign_pointer(wiphy->regd, regd);
1489                         goto new_request;
1490                 }
1491                 kfree(pending_request);
1492                 return treatment;
1493         }
1494
1495 new_request:
1496         lr = get_last_request();
1497         if (lr != &core_request_world && lr)
1498                 kfree_rcu(lr, rcu_head);
1499
1500         pending_request->intersect = intersect;
1501         pending_request->processed = false;
1502         rcu_assign_pointer(last_request, pending_request);
1503         lr = pending_request;
1504
1505         pending_request = NULL;
1506
1507         if (lr->initiator == NL80211_REGDOM_SET_BY_USER) {
1508                 user_alpha2[0] = lr->alpha2[0];
1509                 user_alpha2[1] = lr->alpha2[1];
1510         }
1511
1512         /* When r == REG_REQ_INTERSECT we do need to call CRDA */
1513         if (treatment != REG_REQ_OK && treatment != REG_REQ_INTERSECT) {
1514                 /*
1515                  * Since CRDA will not be called in this case as we already
1516                  * have applied the requested regulatory domain before we just
1517                  * inform userspace we have processed the request
1518                  */
1519                 if (treatment == REG_REQ_ALREADY_SET) {
1520                         nl80211_send_reg_change_event(lr);
1521                         reg_set_request_processed();
1522                 }
1523                 return treatment;
1524         }
1525
1526         if (call_crda(lr->alpha2))
1527                 return REG_REQ_IGNORE;
1528         return REG_REQ_OK;
1529 }
1530
1531 /* This processes *all* regulatory hints */
1532 static void reg_process_hint(struct regulatory_request *reg_request,
1533                              enum nl80211_reg_initiator reg_initiator)
1534 {
1535         struct wiphy *wiphy = NULL;
1536
1537         if (WARN_ON(!reg_request->alpha2))
1538                 return;
1539
1540         if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
1541                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1542
1543         if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER && !wiphy) {
1544                 kfree(reg_request);
1545                 return;
1546         }
1547
1548         switch (__regulatory_hint(wiphy, reg_request)) {
1549         case REG_REQ_ALREADY_SET:
1550                 /* This is required so that the orig_* parameters are saved */
1551                 if (wiphy && wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
1552                         wiphy_update_regulatory(wiphy, reg_initiator);
1553                 break;
1554         default:
1555                 if (reg_initiator == NL80211_REGDOM_SET_BY_USER)
1556                         schedule_delayed_work(&reg_timeout,
1557                                               msecs_to_jiffies(3142));
1558                 break;
1559         }
1560 }
1561
1562 /*
1563  * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
1564  * Regulatory hints come on a first come first serve basis and we
1565  * must process each one atomically.
1566  */
1567 static void reg_process_pending_hints(void)
1568 {
1569         struct regulatory_request *reg_request, *lr;
1570
1571         lr = get_last_request();
1572
1573         /* When last_request->processed becomes true this will be rescheduled */
1574         if (lr && !lr->processed) {
1575                 REG_DBG_PRINT("Pending regulatory request, waiting for it to be processed...\n");
1576                 return;
1577         }
1578
1579         spin_lock(&reg_requests_lock);
1580
1581         if (list_empty(&reg_requests_list)) {
1582                 spin_unlock(&reg_requests_lock);
1583                 return;
1584         }
1585
1586         reg_request = list_first_entry(&reg_requests_list,
1587                                        struct regulatory_request,
1588                                        list);
1589         list_del_init(&reg_request->list);
1590
1591         spin_unlock(&reg_requests_lock);
1592
1593         reg_process_hint(reg_request, reg_request->initiator);
1594 }
1595
1596 /* Processes beacon hints -- this has nothing to do with country IEs */
1597 static void reg_process_pending_beacon_hints(void)
1598 {
1599         struct cfg80211_registered_device *rdev;
1600         struct reg_beacon *pending_beacon, *tmp;
1601
1602         /* This goes through the _pending_ beacon list */
1603         spin_lock_bh(&reg_pending_beacons_lock);
1604
1605         list_for_each_entry_safe(pending_beacon, tmp,
1606                                  &reg_pending_beacons, list) {
1607                 list_del_init(&pending_beacon->list);
1608
1609                 /* Applies the beacon hint to current wiphys */
1610                 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1611                         wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
1612
1613                 /* Remembers the beacon hint for new wiphys or reg changes */
1614                 list_add_tail(&pending_beacon->list, &reg_beacon_list);
1615         }
1616
1617         spin_unlock_bh(&reg_pending_beacons_lock);
1618 }
1619
1620 static void reg_todo(struct work_struct *work)
1621 {
1622         rtnl_lock();
1623         reg_process_pending_hints();
1624         reg_process_pending_beacon_hints();
1625         rtnl_unlock();
1626 }
1627
1628 static void queue_regulatory_request(struct regulatory_request *request)
1629 {
1630         request->alpha2[0] = toupper(request->alpha2[0]);
1631         request->alpha2[1] = toupper(request->alpha2[1]);
1632
1633         spin_lock(&reg_requests_lock);
1634         list_add_tail(&request->list, &reg_requests_list);
1635         spin_unlock(&reg_requests_lock);
1636
1637         schedule_work(&reg_work);
1638 }
1639
1640 /*
1641  * Core regulatory hint -- happens during cfg80211_init()
1642  * and when we restore regulatory settings.
1643  */
1644 static int regulatory_hint_core(const char *alpha2)
1645 {
1646         struct regulatory_request *request;
1647
1648         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1649         if (!request)
1650                 return -ENOMEM;
1651
1652         request->alpha2[0] = alpha2[0];
1653         request->alpha2[1] = alpha2[1];
1654         request->initiator = NL80211_REGDOM_SET_BY_CORE;
1655
1656         queue_regulatory_request(request);
1657
1658         return 0;
1659 }
1660
1661 /* User hints */
1662 int regulatory_hint_user(const char *alpha2,
1663                          enum nl80211_user_reg_hint_type user_reg_hint_type)
1664 {
1665         struct regulatory_request *request;
1666
1667         if (WARN_ON(!alpha2))
1668                 return -EINVAL;
1669
1670         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1671         if (!request)
1672                 return -ENOMEM;
1673
1674         request->wiphy_idx = WIPHY_IDX_INVALID;
1675         request->alpha2[0] = alpha2[0];
1676         request->alpha2[1] = alpha2[1];
1677         request->initiator = NL80211_REGDOM_SET_BY_USER;
1678         request->user_reg_hint_type = user_reg_hint_type;
1679
1680         queue_regulatory_request(request);
1681
1682         return 0;
1683 }
1684
1685 /* Driver hints */
1686 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1687 {
1688         struct regulatory_request *request;
1689
1690         if (WARN_ON(!alpha2 || !wiphy))
1691                 return -EINVAL;
1692
1693         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1694         if (!request)
1695                 return -ENOMEM;
1696
1697         request->wiphy_idx = get_wiphy_idx(wiphy);
1698
1699         request->alpha2[0] = alpha2[0];
1700         request->alpha2[1] = alpha2[1];
1701         request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
1702
1703         queue_regulatory_request(request);
1704
1705         return 0;
1706 }
1707 EXPORT_SYMBOL(regulatory_hint);
1708
1709 void regulatory_hint_11d(struct wiphy *wiphy, enum ieee80211_band band,
1710                          const u8 *country_ie, u8 country_ie_len)
1711 {
1712         char alpha2[2];
1713         enum environment_cap env = ENVIRON_ANY;
1714         struct regulatory_request *request = NULL, *lr;
1715
1716         /* IE len must be evenly divisible by 2 */
1717         if (country_ie_len & 0x01)
1718                 return;
1719
1720         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1721                 return;
1722
1723         request = kzalloc(sizeof(*request), GFP_KERNEL);
1724         if (!request)
1725                 return;
1726
1727         alpha2[0] = country_ie[0];
1728         alpha2[1] = country_ie[1];
1729
1730         if (country_ie[2] == 'I')
1731                 env = ENVIRON_INDOOR;
1732         else if (country_ie[2] == 'O')
1733                 env = ENVIRON_OUTDOOR;
1734
1735         rcu_read_lock();
1736         lr = get_last_request();
1737
1738         if (unlikely(!lr))
1739                 goto out;
1740
1741         /*
1742          * We will run this only upon a successful connection on cfg80211.
1743          * We leave conflict resolution to the workqueue, where can hold
1744          * the RTNL.
1745          */
1746         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1747             lr->wiphy_idx != WIPHY_IDX_INVALID)
1748                 goto out;
1749
1750         request->wiphy_idx = get_wiphy_idx(wiphy);
1751         request->alpha2[0] = alpha2[0];
1752         request->alpha2[1] = alpha2[1];
1753         request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
1754         request->country_ie_env = env;
1755
1756         queue_regulatory_request(request);
1757         request = NULL;
1758 out:
1759         kfree(request);
1760         rcu_read_unlock();
1761 }
1762
1763 static void restore_alpha2(char *alpha2, bool reset_user)
1764 {
1765         /* indicates there is no alpha2 to consider for restoration */
1766         alpha2[0] = '9';
1767         alpha2[1] = '7';
1768
1769         /* The user setting has precedence over the module parameter */
1770         if (is_user_regdom_saved()) {
1771                 /* Unless we're asked to ignore it and reset it */
1772                 if (reset_user) {
1773                         REG_DBG_PRINT("Restoring regulatory settings including user preference\n");
1774                         user_alpha2[0] = '9';
1775                         user_alpha2[1] = '7';
1776
1777                         /*
1778                          * If we're ignoring user settings, we still need to
1779                          * check the module parameter to ensure we put things
1780                          * back as they were for a full restore.
1781                          */
1782                         if (!is_world_regdom(ieee80211_regdom)) {
1783                                 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1784                                               ieee80211_regdom[0], ieee80211_regdom[1]);
1785                                 alpha2[0] = ieee80211_regdom[0];
1786                                 alpha2[1] = ieee80211_regdom[1];
1787                         }
1788                 } else {
1789                         REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n",
1790                                       user_alpha2[0], user_alpha2[1]);
1791                         alpha2[0] = user_alpha2[0];
1792                         alpha2[1] = user_alpha2[1];
1793                 }
1794         } else if (!is_world_regdom(ieee80211_regdom)) {
1795                 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1796                               ieee80211_regdom[0], ieee80211_regdom[1]);
1797                 alpha2[0] = ieee80211_regdom[0];
1798                 alpha2[1] = ieee80211_regdom[1];
1799         } else
1800                 REG_DBG_PRINT("Restoring regulatory settings\n");
1801 }
1802
1803 static void restore_custom_reg_settings(struct wiphy *wiphy)
1804 {
1805         struct ieee80211_supported_band *sband;
1806         enum ieee80211_band band;
1807         struct ieee80211_channel *chan;
1808         int i;
1809
1810         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1811                 sband = wiphy->bands[band];
1812                 if (!sband)
1813                         continue;
1814                 for (i = 0; i < sband->n_channels; i++) {
1815                         chan = &sband->channels[i];
1816                         chan->flags = chan->orig_flags;
1817                         chan->max_antenna_gain = chan->orig_mag;
1818                         chan->max_power = chan->orig_mpwr;
1819                         chan->beacon_found = false;
1820                 }
1821         }
1822 }
1823
1824 /*
1825  * Restoring regulatory settings involves ingoring any
1826  * possibly stale country IE information and user regulatory
1827  * settings if so desired, this includes any beacon hints
1828  * learned as we could have traveled outside to another country
1829  * after disconnection. To restore regulatory settings we do
1830  * exactly what we did at bootup:
1831  *
1832  *   - send a core regulatory hint
1833  *   - send a user regulatory hint if applicable
1834  *
1835  * Device drivers that send a regulatory hint for a specific country
1836  * keep their own regulatory domain on wiphy->regd so that does does
1837  * not need to be remembered.
1838  */
1839 static void restore_regulatory_settings(bool reset_user)
1840 {
1841         char alpha2[2];
1842         char world_alpha2[2];
1843         struct reg_beacon *reg_beacon, *btmp;
1844         struct regulatory_request *reg_request, *tmp;
1845         LIST_HEAD(tmp_reg_req_list);
1846         struct cfg80211_registered_device *rdev;
1847
1848         ASSERT_RTNL();
1849
1850         reset_regdomains(true, &world_regdom);
1851         restore_alpha2(alpha2, reset_user);
1852
1853         /*
1854          * If there's any pending requests we simply
1855          * stash them to a temporary pending queue and
1856          * add then after we've restored regulatory
1857          * settings.
1858          */
1859         spin_lock(&reg_requests_lock);
1860         list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
1861                 if (reg_request->initiator != NL80211_REGDOM_SET_BY_USER)
1862                         continue;
1863                 list_move_tail(&reg_request->list, &tmp_reg_req_list);
1864         }
1865         spin_unlock(&reg_requests_lock);
1866
1867         /* Clear beacon hints */
1868         spin_lock_bh(&reg_pending_beacons_lock);
1869         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
1870                 list_del(&reg_beacon->list);
1871                 kfree(reg_beacon);
1872         }
1873         spin_unlock_bh(&reg_pending_beacons_lock);
1874
1875         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
1876                 list_del(&reg_beacon->list);
1877                 kfree(reg_beacon);
1878         }
1879
1880         /* First restore to the basic regulatory settings */
1881         world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
1882         world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
1883
1884         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1885                 if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1886                         restore_custom_reg_settings(&rdev->wiphy);
1887         }
1888
1889         regulatory_hint_core(world_alpha2);
1890
1891         /*
1892          * This restores the ieee80211_regdom module parameter
1893          * preference or the last user requested regulatory
1894          * settings, user regulatory settings takes precedence.
1895          */
1896         if (is_an_alpha2(alpha2))
1897                 regulatory_hint_user(user_alpha2, NL80211_USER_REG_HINT_USER);
1898
1899         spin_lock(&reg_requests_lock);
1900         list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
1901         spin_unlock(&reg_requests_lock);
1902
1903         REG_DBG_PRINT("Kicking the queue\n");
1904
1905         schedule_work(&reg_work);
1906 }
1907
1908 void regulatory_hint_disconnect(void)
1909 {
1910         REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n");
1911         restore_regulatory_settings(false);
1912 }
1913
1914 static bool freq_is_chan_12_13_14(u16 freq)
1915 {
1916         if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
1917             freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
1918             freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
1919                 return true;
1920         return false;
1921 }
1922
1923 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
1924 {
1925         struct reg_beacon *pending_beacon;
1926
1927         list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
1928                 if (beacon_chan->center_freq ==
1929                     pending_beacon->chan.center_freq)
1930                         return true;
1931         return false;
1932 }
1933
1934 int regulatory_hint_found_beacon(struct wiphy *wiphy,
1935                                  struct ieee80211_channel *beacon_chan,
1936                                  gfp_t gfp)
1937 {
1938         struct reg_beacon *reg_beacon;
1939         bool processing;
1940
1941         if (beacon_chan->beacon_found ||
1942             beacon_chan->flags & IEEE80211_CHAN_RADAR ||
1943             (beacon_chan->band == IEEE80211_BAND_2GHZ &&
1944              !freq_is_chan_12_13_14(beacon_chan->center_freq)))
1945                 return 0;
1946
1947         spin_lock_bh(&reg_pending_beacons_lock);
1948         processing = pending_reg_beacon(beacon_chan);
1949         spin_unlock_bh(&reg_pending_beacons_lock);
1950
1951         if (processing)
1952                 return 0;
1953
1954         reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
1955         if (!reg_beacon)
1956                 return -ENOMEM;
1957
1958         REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
1959                       beacon_chan->center_freq,
1960                       ieee80211_frequency_to_channel(beacon_chan->center_freq),
1961                       wiphy_name(wiphy));
1962
1963         memcpy(&reg_beacon->chan, beacon_chan,
1964                sizeof(struct ieee80211_channel));
1965
1966         /*
1967          * Since we can be called from BH or and non-BH context
1968          * we must use spin_lock_bh()
1969          */
1970         spin_lock_bh(&reg_pending_beacons_lock);
1971         list_add_tail(&reg_beacon->list, &reg_pending_beacons);
1972         spin_unlock_bh(&reg_pending_beacons_lock);
1973
1974         schedule_work(&reg_work);
1975
1976         return 0;
1977 }
1978
1979 static void print_rd_rules(const struct ieee80211_regdomain *rd)
1980 {
1981         unsigned int i;
1982         const struct ieee80211_reg_rule *reg_rule = NULL;
1983         const struct ieee80211_freq_range *freq_range = NULL;
1984         const struct ieee80211_power_rule *power_rule = NULL;
1985
1986         pr_info("  (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
1987
1988         for (i = 0; i < rd->n_reg_rules; i++) {
1989                 reg_rule = &rd->reg_rules[i];
1990                 freq_range = &reg_rule->freq_range;
1991                 power_rule = &reg_rule->power_rule;
1992
1993                 /*
1994                  * There may not be documentation for max antenna gain
1995                  * in certain regions
1996                  */
1997                 if (power_rule->max_antenna_gain)
1998                         pr_info("  (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
1999                                 freq_range->start_freq_khz,
2000                                 freq_range->end_freq_khz,
2001                                 freq_range->max_bandwidth_khz,
2002                                 power_rule->max_antenna_gain,
2003                                 power_rule->max_eirp);
2004                 else
2005                         pr_info("  (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
2006                                 freq_range->start_freq_khz,
2007                                 freq_range->end_freq_khz,
2008                                 freq_range->max_bandwidth_khz,
2009                                 power_rule->max_eirp);
2010         }
2011 }
2012
2013 bool reg_supported_dfs_region(u8 dfs_region)
2014 {
2015         switch (dfs_region) {
2016         case NL80211_DFS_UNSET:
2017         case NL80211_DFS_FCC:
2018         case NL80211_DFS_ETSI:
2019         case NL80211_DFS_JP:
2020                 return true;
2021         default:
2022                 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2023                               dfs_region);
2024                 return false;
2025         }
2026 }
2027
2028 static void print_dfs_region(u8 dfs_region)
2029 {
2030         if (!dfs_region)
2031                 return;
2032
2033         switch (dfs_region) {
2034         case NL80211_DFS_FCC:
2035                 pr_info(" DFS Master region FCC");
2036                 break;
2037         case NL80211_DFS_ETSI:
2038                 pr_info(" DFS Master region ETSI");
2039                 break;
2040         case NL80211_DFS_JP:
2041                 pr_info(" DFS Master region JP");
2042                 break;
2043         default:
2044                 pr_info(" DFS Master region Unknown");
2045                 break;
2046         }
2047 }
2048
2049 static void print_regdomain(const struct ieee80211_regdomain *rd)
2050 {
2051         struct regulatory_request *lr = get_last_request();
2052
2053         if (is_intersected_alpha2(rd->alpha2)) {
2054                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2055                         struct cfg80211_registered_device *rdev;
2056                         rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
2057                         if (rdev) {
2058                                 pr_info("Current regulatory domain updated by AP to: %c%c\n",
2059                                         rdev->country_ie_alpha2[0],
2060                                         rdev->country_ie_alpha2[1]);
2061                         } else
2062                                 pr_info("Current regulatory domain intersected:\n");
2063                 } else
2064                         pr_info("Current regulatory domain intersected:\n");
2065         } else if (is_world_regdom(rd->alpha2)) {
2066                 pr_info("World regulatory domain updated:\n");
2067         } else {
2068                 if (is_unknown_alpha2(rd->alpha2))
2069                         pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
2070                 else {
2071                         if (reg_request_cell_base(lr))
2072                                 pr_info("Regulatory domain changed to country: %c%c by Cell Station\n",
2073                                         rd->alpha2[0], rd->alpha2[1]);
2074                         else
2075                                 pr_info("Regulatory domain changed to country: %c%c\n",
2076                                         rd->alpha2[0], rd->alpha2[1]);
2077                 }
2078         }
2079
2080         print_dfs_region(rd->dfs_region);
2081         print_rd_rules(rd);
2082 }
2083
2084 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
2085 {
2086         pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
2087         print_rd_rules(rd);
2088 }
2089
2090 /* Takes ownership of rd only if it doesn't fail */
2091 static int __set_regdom(const struct ieee80211_regdomain *rd)
2092 {
2093         const struct ieee80211_regdomain *regd;
2094         const struct ieee80211_regdomain *intersected_rd = NULL;
2095         struct wiphy *request_wiphy;
2096         struct regulatory_request *lr = get_last_request();
2097
2098         /* Some basic sanity checks first */
2099
2100         if (!reg_is_valid_request(rd->alpha2))
2101                 return -EINVAL;
2102
2103         if (is_world_regdom(rd->alpha2)) {
2104                 update_world_regdomain(rd);
2105                 return 0;
2106         }
2107
2108         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2109             !is_unknown_alpha2(rd->alpha2))
2110                 return -EINVAL;
2111
2112         /*
2113          * Lets only bother proceeding on the same alpha2 if the current
2114          * rd is non static (it means CRDA was present and was used last)
2115          * and the pending request came in from a country IE
2116          */
2117         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2118                 /*
2119                  * If someone else asked us to change the rd lets only bother
2120                  * checking if the alpha2 changes if CRDA was already called
2121                  */
2122                 if (!regdom_changes(rd->alpha2))
2123                         return -EALREADY;
2124         }
2125
2126         /*
2127          * Now lets set the regulatory domain, update all driver channels
2128          * and finally inform them of what we have done, in case they want
2129          * to review or adjust their own settings based on their own
2130          * internal EEPROM data
2131          */
2132
2133         if (!is_valid_rd(rd)) {
2134                 pr_err("Invalid regulatory domain detected:\n");
2135                 print_regdomain_info(rd);
2136                 return -EINVAL;
2137         }
2138
2139         request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2140         if (!request_wiphy &&
2141             (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2142              lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
2143                 schedule_delayed_work(&reg_timeout, 0);
2144                 return -ENODEV;
2145         }
2146
2147         if (!lr->intersect) {
2148                 if (lr->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
2149                         reset_regdomains(false, rd);
2150                         return 0;
2151                 }
2152
2153                 /*
2154                  * For a driver hint, lets copy the regulatory domain the
2155                  * driver wanted to the wiphy to deal with conflicts
2156                  */
2157
2158                 /*
2159                  * Userspace could have sent two replies with only
2160                  * one kernel request.
2161                  */
2162                 if (request_wiphy->regd)
2163                         return -EALREADY;
2164
2165                 regd = reg_copy_regd(rd);
2166                 if (IS_ERR(regd))
2167                         return PTR_ERR(regd);
2168
2169                 rcu_assign_pointer(request_wiphy->regd, regd);
2170                 reset_regdomains(false, rd);
2171                 return 0;
2172         }
2173
2174         /* Intersection requires a bit more work */
2175
2176         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2177                 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2178                 if (!intersected_rd)
2179                         return -EINVAL;
2180
2181                 /*
2182                  * We can trash what CRDA provided now.
2183                  * However if a driver requested this specific regulatory
2184                  * domain we keep it for its private use
2185                  */
2186                 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
2187                         const struct ieee80211_regdomain *tmp;
2188
2189                         tmp = get_wiphy_regdom(request_wiphy);
2190                         rcu_assign_pointer(request_wiphy->regd, rd);
2191                         rcu_free_regdom(tmp);
2192                 } else {
2193                         kfree(rd);
2194                 }
2195
2196                 rd = NULL;
2197
2198                 reset_regdomains(false, intersected_rd);
2199
2200                 return 0;
2201         }
2202
2203         return -EINVAL;
2204 }
2205
2206
2207 /*
2208  * Use this call to set the current regulatory domain. Conflicts with
2209  * multiple drivers can be ironed out later. Caller must've already
2210  * kmalloc'd the rd structure.
2211  */
2212 int set_regdom(const struct ieee80211_regdomain *rd)
2213 {
2214         struct regulatory_request *lr;
2215         int r;
2216
2217         lr = get_last_request();
2218
2219         /* Note that this doesn't update the wiphys, this is done below */
2220         r = __set_regdom(rd);
2221         if (r) {
2222                 if (r == -EALREADY)
2223                         reg_set_request_processed();
2224
2225                 kfree(rd);
2226                 return r;
2227         }
2228
2229         /* This would make this whole thing pointless */
2230         if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
2231                 return -EINVAL;
2232
2233         /* update all wiphys now with the new established regulatory domain */
2234         update_all_wiphy_regulatory(lr->initiator);
2235
2236         print_regdomain(get_cfg80211_regdom());
2237
2238         nl80211_send_reg_change_event(lr);
2239
2240         reg_set_request_processed();
2241
2242         return 0;
2243 }
2244
2245 int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
2246 {
2247         struct regulatory_request *lr;
2248         u8 alpha2[2];
2249         bool add = false;
2250
2251         rcu_read_lock();
2252         lr = get_last_request();
2253         if (lr && !lr->processed) {
2254                 memcpy(alpha2, lr->alpha2, 2);
2255                 add = true;
2256         }
2257         rcu_read_unlock();
2258
2259         if (add)
2260                 return add_uevent_var(env, "COUNTRY=%c%c",
2261                                       alpha2[0], alpha2[1]);
2262         return 0;
2263 }
2264
2265 void wiphy_regulatory_register(struct wiphy *wiphy)
2266 {
2267         struct regulatory_request *lr;
2268
2269         if (!reg_dev_ignore_cell_hint(wiphy))
2270                 reg_num_devs_support_basehint++;
2271
2272         lr = get_last_request();
2273         wiphy_update_regulatory(wiphy, lr->initiator);
2274 }
2275
2276 void wiphy_regulatory_deregister(struct wiphy *wiphy)
2277 {
2278         struct wiphy *request_wiphy = NULL;
2279         struct regulatory_request *lr;
2280
2281         lr = get_last_request();
2282
2283         if (!reg_dev_ignore_cell_hint(wiphy))
2284                 reg_num_devs_support_basehint--;
2285
2286         rcu_free_regdom(get_wiphy_regdom(wiphy));
2287         rcu_assign_pointer(wiphy->regd, NULL);
2288
2289         if (lr)
2290                 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2291
2292         if (!request_wiphy || request_wiphy != wiphy)
2293                 return;
2294
2295         lr->wiphy_idx = WIPHY_IDX_INVALID;
2296         lr->country_ie_env = ENVIRON_ANY;
2297 }
2298
2299 static void reg_timeout_work(struct work_struct *work)
2300 {
2301         REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
2302         rtnl_lock();
2303         restore_regulatory_settings(true);
2304         rtnl_unlock();
2305 }
2306
2307 int __init regulatory_init(void)
2308 {
2309         int err = 0;
2310
2311         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2312         if (IS_ERR(reg_pdev))
2313                 return PTR_ERR(reg_pdev);
2314
2315         reg_pdev->dev.type = &reg_device_type;
2316
2317         spin_lock_init(&reg_requests_lock);
2318         spin_lock_init(&reg_pending_beacons_lock);
2319
2320         reg_regdb_size_check();
2321
2322         rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
2323
2324         user_alpha2[0] = '9';
2325         user_alpha2[1] = '7';
2326
2327         /* We always try to get an update for the static regdomain */
2328         err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
2329         if (err) {
2330                 if (err == -ENOMEM)
2331                         return err;
2332                 /*
2333                  * N.B. kobject_uevent_env() can fail mainly for when we're out
2334                  * memory which is handled and propagated appropriately above
2335                  * but it can also fail during a netlink_broadcast() or during
2336                  * early boot for call_usermodehelper(). For now treat these
2337                  * errors as non-fatal.
2338                  */
2339                 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
2340         }
2341
2342         /*
2343          * Finally, if the user set the module parameter treat it
2344          * as a user hint.
2345          */
2346         if (!is_world_regdom(ieee80211_regdom))
2347                 regulatory_hint_user(ieee80211_regdom,
2348                                      NL80211_USER_REG_HINT_USER);
2349
2350         return 0;
2351 }
2352
2353 void regulatory_exit(void)
2354 {
2355         struct regulatory_request *reg_request, *tmp;
2356         struct reg_beacon *reg_beacon, *btmp;
2357
2358         cancel_work_sync(&reg_work);
2359         cancel_delayed_work_sync(&reg_timeout);
2360
2361         /* Lock to suppress warnings */
2362         rtnl_lock();
2363         reset_regdomains(true, NULL);
2364         rtnl_unlock();
2365
2366         dev_set_uevent_suppress(&reg_pdev->dev, true);
2367
2368         platform_device_unregister(reg_pdev);
2369
2370         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
2371                 list_del(&reg_beacon->list);
2372                 kfree(reg_beacon);
2373         }
2374
2375         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
2376                 list_del(&reg_beacon->list);
2377                 kfree(reg_beacon);
2378         }
2379
2380         list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
2381                 list_del(&reg_request->list);
2382                 kfree(reg_request);
2383         }
2384 }