Linux Audio

Check our new training course

Linux kernel drivers training

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