reg.c 53.9 KB
Newer Older
1 2 3 4
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
5
 * Copyright 2008	Luis R. Rodriguez <lrodriguz@atheros.com>
6 7 8 9 10 11
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

12 13
/**
 * DOC: Wireless regulatory infrastructure
14 15 16 17 18 19
 *
 * The usual implementation is for a driver to read a device EEPROM to
 * determine which regulatory domain it should be operating under, then
 * looking up the allowable channels in a driver-local table and finally
 * registering those channels in the wiphy structure.
 *
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Another set of compliance enforcement is for drivers to use their
 * own compliance limits which can be stored on the EEPROM. The host
 * driver or firmware may ensure these are used.
 *
 * In addition to all this we provide an extra layer of regulatory
 * conformance. For drivers which do not have any regulatory
 * information CRDA provides the complete regulatory solution.
 * For others it provides a community effort on further restrictions
 * to enhance compliance.
 *
 * Note: When number of rules --> infinity we will not be able to
 * index on alpha2 any more, instead we'll probably have to
 * rely on some SHA1 checksum of the regdomain for example.
 *
34 35
 */
#include <linux/kernel.h>
36
#include <linux/slab.h>
37 38
#include <linux/list.h>
#include <linux/random.h>
39
#include <linux/ctype.h>
40 41 42
#include <linux/nl80211.h>
#include <linux/platform_device.h>
#include <net/cfg80211.h>
43
#include "core.h"
44
#include "reg.h"
45
#include "regdb.h"
46
#include "nl80211.h"
47

48
#ifdef CONFIG_CFG80211_REG_DEBUG
49
#define REG_DBG_PRINT(format, args...) \
50
	do { \
51
		printk(KERN_DEBUG format , ## args); \
52 53
	} while (0)
#else
54
#define REG_DBG_PRINT(args...)
55 56
#endif

57
/* Receipt of information from last regulatory request */
58
static struct regulatory_request *last_request;
59

60 61
/* To trigger userspace events */
static struct platform_device *reg_pdev;
62

63 64
/*
 * Central wireless core regulatory domains, we only need two,
65
 * the current one and a world regulatory domain in case we have no
66 67
 * information to give us an alpha2
 */
68
const struct ieee80211_regdomain *cfg80211_regdomain;
69

70 71 72 73 74 75
/*
 * Protects static reg.c components:
 *     - cfg80211_world_regdom
 *     - cfg80211_regdom
 *     - last_request
 */
76
static DEFINE_MUTEX(reg_mutex);
77 78 79 80 81

static inline void assert_reg_lock(void)
{
	lockdep_assert_held(&reg_mutex);
}
82

83
/* Used to queue up regulatory hints */
84 85 86
static LIST_HEAD(reg_requests_list);
static spinlock_t reg_requests_lock;

87 88 89 90 91 92 93 94 95 96 97 98
/* Used to queue up beacon hints for review */
static LIST_HEAD(reg_pending_beacons);
static spinlock_t reg_pending_beacons_lock;

/* Used to keep track of processed beacon hints */
static LIST_HEAD(reg_beacon_list);

struct reg_beacon {
	struct list_head list;
	struct ieee80211_channel chan;
};

99 100
/* We keep a static world regulatory domain in case of the absence of CRDA */
static const struct ieee80211_regdomain world_regdom = {
101
	.n_reg_rules = 5,
102 103
	.alpha2 =  "00",
	.reg_rules = {
104 105
		/* IEEE 802.11b/g, channels 1..11 */
		REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
106 107 108
		/* IEEE 802.11b/g, channels 12..13. No HT40
		 * channel fits here. */
		REG_RULE(2467-10, 2472+10, 20, 6, 20,
109 110
			NL80211_RRF_PASSIVE_SCAN |
			NL80211_RRF_NO_IBSS),
111 112 113 114 115 116 117
		/* IEEE 802.11 channel 14 - Only JP enables
		 * this and for 802.11b only */
		REG_RULE(2484-10, 2484+10, 20, 6, 20,
			NL80211_RRF_PASSIVE_SCAN |
			NL80211_RRF_NO_IBSS |
			NL80211_RRF_NO_OFDM),
		/* IEEE 802.11a, channel 36..48 */
118
		REG_RULE(5180-10, 5240+10, 40, 6, 20,
119 120
                        NL80211_RRF_PASSIVE_SCAN |
                        NL80211_RRF_NO_IBSS),
121 122 123 124

		/* NB: 5260 MHz - 5700 MHz requies DFS */

		/* IEEE 802.11a, channel 149..165 */
125
		REG_RULE(5745-10, 5825+10, 40, 6, 20,
126 127
			NL80211_RRF_PASSIVE_SCAN |
			NL80211_RRF_NO_IBSS),
128 129 130
	}
};

131 132
static const struct ieee80211_regdomain *cfg80211_world_regdom =
	&world_regdom;
133

134
static char *ieee80211_regdom = "00";
135
static char user_alpha2[2];
136

137 138 139 140 141
module_param(ieee80211_regdom, charp, 0444);
MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");

static void reset_regdomains(void)
{
142 143 144 145 146 147 148 149 150 151
	/* avoid freeing static information or freeing something twice */
	if (cfg80211_regdomain == cfg80211_world_regdom)
		cfg80211_regdomain = NULL;
	if (cfg80211_world_regdom == &world_regdom)
		cfg80211_world_regdom = NULL;
	if (cfg80211_regdomain == &world_regdom)
		cfg80211_regdomain = NULL;

	kfree(cfg80211_regdomain);
	kfree(cfg80211_world_regdom);
152

153
	cfg80211_world_regdom = &world_regdom;
154 155 156
	cfg80211_regdomain = NULL;
}

157 158 159 160
/*
 * Dynamic world regulatory domain requested by the wireless
 * core upon initialization
 */
161
static void update_world_regdomain(const struct ieee80211_regdomain *rd)
162
{
163
	BUG_ON(!last_request);
164 165 166 167 168 169 170

	reset_regdomains();

	cfg80211_world_regdom = rd;
	cfg80211_regdomain = rd;
}

171
bool is_world_regdom(const char *alpha2)
172 173 174 175 176 177 178
{
	if (!alpha2)
		return false;
	if (alpha2[0] == '0' && alpha2[1] == '0')
		return true;
	return false;
}
179

180
static bool is_alpha2_set(const char *alpha2)
181 182 183 184 185 186 187
{
	if (!alpha2)
		return false;
	if (alpha2[0] != 0 && alpha2[1] != 0)
		return true;
	return false;
}
188

189
static bool is_unknown_alpha2(const char *alpha2)
190 191 192
{
	if (!alpha2)
		return false;
193 194 195 196
	/*
	 * Special case where regulatory domain was built by driver
	 * but a specific alpha2 cannot be determined
	 */
197 198 199 200
	if (alpha2[0] == '9' && alpha2[1] == '9')
		return true;
	return false;
}
201

202 203 204 205
static bool is_intersected_alpha2(const char *alpha2)
{
	if (!alpha2)
		return false;
206 207
	/*
	 * Special case where regulatory domain is the
208
	 * result of an intersection between two regulatory domain
209 210
	 * structures
	 */
211 212 213 214 215
	if (alpha2[0] == '9' && alpha2[1] == '8')
		return true;
	return false;
}

216
static bool is_an_alpha2(const char *alpha2)
217 218 219
{
	if (!alpha2)
		return false;
220
	if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
221 222 223
		return true;
	return false;
}
224

225
static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
226 227 228 229 230 231 232 233 234
{
	if (!alpha2_x || !alpha2_y)
		return false;
	if (alpha2_x[0] == alpha2_y[0] &&
		alpha2_x[1] == alpha2_y[1])
		return true;
	return false;
}

235
static bool regdom_changes(const char *alpha2)
236
{
237 238
	assert_cfg80211_lock();

239 240 241 242 243 244 245
	if (!cfg80211_regdomain)
		return true;
	if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
		return false;
	return true;
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
/*
 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
 * has ever been issued.
 */
static bool is_user_regdom_saved(void)
{
	if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
		return false;

	/* This would indicate a mistake on the design */
	if (WARN((!is_world_regdom(user_alpha2) &&
		  !is_an_alpha2(user_alpha2)),
		 "Unexpected user alpha2: %c%c\n",
		 user_alpha2[0],
	         user_alpha2[1]))
		return false;

	return true;
}

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
			 const struct ieee80211_regdomain *src_regd)
{
	struct ieee80211_regdomain *regd;
	int size_of_regd = 0;
	unsigned int i;

	size_of_regd = sizeof(struct ieee80211_regdomain) +
	  ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));

	regd = kzalloc(size_of_regd, GFP_KERNEL);
	if (!regd)
		return -ENOMEM;

	memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));

	for (i = 0; i < src_regd->n_reg_rules; i++)
		memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
			sizeof(struct ieee80211_reg_rule));

	*dst_regd = regd;
	return 0;
}

#ifdef CONFIG_CFG80211_INTERNAL_REGDB
struct reg_regdb_search_request {
	char alpha2[2];
	struct list_head list;
};

static LIST_HEAD(reg_regdb_search_list);
298
static DEFINE_MUTEX(reg_regdb_search_mutex);
299 300 301 302 303 304 305

static void reg_regdb_search(struct work_struct *work)
{
	struct reg_regdb_search_request *request;
	const struct ieee80211_regdomain *curdom, *regdom;
	int i, r;

306
	mutex_lock(&reg_regdb_search_mutex);
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	while (!list_empty(&reg_regdb_search_list)) {
		request = list_first_entry(&reg_regdb_search_list,
					   struct reg_regdb_search_request,
					   list);
		list_del(&request->list);

		for (i=0; i<reg_regdb_size; i++) {
			curdom = reg_regdb[i];

			if (!memcmp(request->alpha2, curdom->alpha2, 2)) {
				r = reg_copy_regd(&regdom, curdom);
				if (r)
					break;
				mutex_lock(&cfg80211_mutex);
				set_regdom(regdom);
				mutex_unlock(&cfg80211_mutex);
				break;
			}
		}

		kfree(request);
	}
329
	mutex_unlock(&reg_regdb_search_mutex);
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
}

static DECLARE_WORK(reg_regdb_work, reg_regdb_search);

static void reg_regdb_query(const char *alpha2)
{
	struct reg_regdb_search_request *request;

	if (!alpha2)
		return;

	request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
	if (!request)
		return;

	memcpy(request->alpha2, alpha2, 2);

347
	mutex_lock(&reg_regdb_search_mutex);
348
	list_add_tail(&request->list, &reg_regdb_search_list);
349
	mutex_unlock(&reg_regdb_search_mutex);
350 351 352 353 354 355 356

	schedule_work(&reg_regdb_work);
}
#else
static inline void reg_regdb_query(const char *alpha2) {}
#endif /* CONFIG_CFG80211_INTERNAL_REGDB */

357 358 359 360
/*
 * This lets us keep regulatory code which is updated on a regulatory
 * basis in userspace.
 */
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
static int call_crda(const char *alpha2)
{
	char country_env[9 + 2] = "COUNTRY=";
	char *envp[] = {
		country_env,
		NULL
	};

	if (!is_world_regdom((char *) alpha2))
		printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
			alpha2[0], alpha2[1]);
	else
		printk(KERN_INFO "cfg80211: Calling CRDA to update world "
			"regulatory domain\n");

376 377 378
	/* query internal regulatory database (if it exists) */
	reg_regdb_query(alpha2);

379 380 381 382 383 384 385
	country_env[8] = alpha2[0];
	country_env[9] = alpha2[1];

	return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
}

/* Used by nl80211 before kmalloc'ing our regulatory domain */
386
bool reg_is_valid_request(const char *alpha2)
387
{
388 389
	assert_cfg80211_lock();

390 391 392 393
	if (!last_request)
		return false;

	return alpha2_equal(last_request->alpha2, alpha2);
394
}
395

396
/* Sanity check on a regulatory rule */
397
static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
398
{
399
	const struct ieee80211_freq_range *freq_range = &rule->freq_range;
400 401
	u32 freq_diff;

402
	if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
403 404 405 406 407 408 409
		return false;

	if (freq_range->start_freq_khz > freq_range->end_freq_khz)
		return false;

	freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;

410 411
	if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
			freq_range->max_bandwidth_khz > freq_diff)
412 413 414 415 416
		return false;

	return true;
}

417
static bool is_valid_rd(const struct ieee80211_regdomain *rd)
418
{
419
	const struct ieee80211_reg_rule *reg_rule = NULL;
420
	unsigned int i;
421

422 423
	if (!rd->n_reg_rules)
		return false;
424

425 426 427
	if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
		return false;

428 429 430 431 432 433 434
	for (i = 0; i < rd->n_reg_rules; i++) {
		reg_rule = &rd->reg_rules[i];
		if (!is_valid_reg_rule(reg_rule))
			return false;
	}

	return true;
435 436
}

437 438 439
static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
			    u32 center_freq_khz,
			    u32 bw_khz)
440
{
441 442 443 444 445 446 447 448 449 450
	u32 start_freq_khz, end_freq_khz;

	start_freq_khz = center_freq_khz - (bw_khz/2);
	end_freq_khz = center_freq_khz + (bw_khz/2);

	if (start_freq_khz >= freq_range->start_freq_khz &&
	    end_freq_khz <= freq_range->end_freq_khz)
		return true;

	return false;
451
}
452

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
/**
 * freq_in_rule_band - tells us if a frequency is in a frequency band
 * @freq_range: frequency rule we want to query
 * @freq_khz: frequency we are inquiring about
 *
 * This lets us know if a specific frequency rule is or is not relevant to
 * a specific frequency's band. Bands are device specific and artificial
 * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
 * safe for now to assume that a frequency rule should not be part of a
 * frequency's band if the start freq or end freq are off by more than 2 GHz.
 * This resolution can be lowered and should be considered as we add
 * regulatory rule support for other "bands".
 **/
static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
	u32 freq_khz)
{
#define ONE_GHZ_IN_KHZ	1000000
	if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
		return true;
	if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
		return true;
	return false;
#undef ONE_GHZ_IN_KHZ
}

478 479 480 481
/*
 * Helper for regdom_intersect(), this does the real
 * mathematical intersection fun
 */
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
static int reg_rules_intersect(
	const struct ieee80211_reg_rule *rule1,
	const struct ieee80211_reg_rule *rule2,
	struct ieee80211_reg_rule *intersected_rule)
{
	const struct ieee80211_freq_range *freq_range1, *freq_range2;
	struct ieee80211_freq_range *freq_range;
	const struct ieee80211_power_rule *power_rule1, *power_rule2;
	struct ieee80211_power_rule *power_rule;
	u32 freq_diff;

	freq_range1 = &rule1->freq_range;
	freq_range2 = &rule2->freq_range;
	freq_range = &intersected_rule->freq_range;

	power_rule1 = &rule1->power_rule;
	power_rule2 = &rule2->power_rule;
	power_rule = &intersected_rule->power_rule;

	freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
		freq_range2->start_freq_khz);
	freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
		freq_range2->end_freq_khz);
	freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
		freq_range2->max_bandwidth_khz);

	freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
	if (freq_range->max_bandwidth_khz > freq_diff)
		freq_range->max_bandwidth_khz = freq_diff;

	power_rule->max_eirp = min(power_rule1->max_eirp,
		power_rule2->max_eirp);
	power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
		power_rule2->max_antenna_gain);

	intersected_rule->flags = (rule1->flags | rule2->flags);

	if (!is_valid_reg_rule(intersected_rule))
		return -EINVAL;

	return 0;
}

/**
 * regdom_intersect - do the intersection between two regulatory domains
 * @rd1: first regulatory domain
 * @rd2: second regulatory domain
 *
 * Use this function to get the intersection between two regulatory domains.
 * Once completed we will mark the alpha2 for the rd as intersected, "98",
 * as no one single alpha2 can represent this regulatory domain.
 *
 * Returns a pointer to the regulatory domain structure which will hold the
 * resulting intersection of rules between rd1 and rd2. We will
 * kzalloc() this structure for you.
 */
static struct ieee80211_regdomain *regdom_intersect(
	const struct ieee80211_regdomain *rd1,
	const struct ieee80211_regdomain *rd2)
{
	int r, size_of_regd;
	unsigned int x, y;
	unsigned int num_rules = 0, rule_idx = 0;
	const struct ieee80211_reg_rule *rule1, *rule2;
	struct ieee80211_reg_rule *intersected_rule;
	struct ieee80211_regdomain *rd;
	/* This is just a dummy holder to help us count */
	struct ieee80211_reg_rule irule;

	/* Uses the stack temporarily for counter arithmetic */
	intersected_rule = &irule;

	memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));

	if (!rd1 || !rd2)
		return NULL;

559 560
	/*
	 * First we get a count of the rules we'll need, then we actually
561 562 563
	 * build them. This is to so we can malloc() and free() a
	 * regdomain once. The reason we use reg_rules_intersect() here
	 * is it will return -EINVAL if the rule computed makes no sense.
564 565
	 * All rules that do check out OK are valid.
	 */
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592

	for (x = 0; x < rd1->n_reg_rules; x++) {
		rule1 = &rd1->reg_rules[x];
		for (y = 0; y < rd2->n_reg_rules; y++) {
			rule2 = &rd2->reg_rules[y];
			if (!reg_rules_intersect(rule1, rule2,
					intersected_rule))
				num_rules++;
			memset(intersected_rule, 0,
					sizeof(struct ieee80211_reg_rule));
		}
	}

	if (!num_rules)
		return NULL;

	size_of_regd = sizeof(struct ieee80211_regdomain) +
		((num_rules + 1) * sizeof(struct ieee80211_reg_rule));

	rd = kzalloc(size_of_regd, GFP_KERNEL);
	if (!rd)
		return NULL;

	for (x = 0; x < rd1->n_reg_rules; x++) {
		rule1 = &rd1->reg_rules[x];
		for (y = 0; y < rd2->n_reg_rules; y++) {
			rule2 = &rd2->reg_rules[y];
593 594
			/*
			 * This time around instead of using the stack lets
595
			 * write to the target rule directly saving ourselves
596 597
			 * a memcpy()
			 */
598 599 600
			intersected_rule = &rd->reg_rules[rule_idx];
			r = reg_rules_intersect(rule1, rule2,
				intersected_rule);
601 602 603 604
			/*
			 * No need to memset here the intersected rule here as
			 * we're not using the stack anymore
			 */
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
			if (r)
				continue;
			rule_idx++;
		}
	}

	if (rule_idx != num_rules) {
		kfree(rd);
		return NULL;
	}

	rd->n_reg_rules = num_rules;
	rd->alpha2[0] = '9';
	rd->alpha2[1] = '8';

	return rd;
}

623 624 625 626
/*
 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 * want to just have the channel structure use these
 */
627 628 629 630 631 632 633 634 635 636 637 638
static u32 map_regdom_flags(u32 rd_flags)
{
	u32 channel_flags = 0;
	if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
		channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
	if (rd_flags & NL80211_RRF_NO_IBSS)
		channel_flags |= IEEE80211_CHAN_NO_IBSS;
	if (rd_flags & NL80211_RRF_DFS)
		channel_flags |= IEEE80211_CHAN_RADAR;
	return channel_flags;
}

639 640
static int freq_reg_info_regd(struct wiphy *wiphy,
			      u32 center_freq,
641
			      u32 desired_bw_khz,
642 643
			      const struct ieee80211_reg_rule **reg_rule,
			      const struct ieee80211_regdomain *custom_regd)
644 645
{
	int i;
646
	bool band_rule_found = false;
647
	const struct ieee80211_regdomain *regd;
648 649 650 651
	bool bw_fits = false;

	if (!desired_bw_khz)
		desired_bw_khz = MHZ_TO_KHZ(20);
652

653
	regd = custom_regd ? custom_regd : cfg80211_regdomain;
654

655 656 657 658
	/*
	 * Follow the driver's regulatory domain, if present, unless a country
	 * IE has been processed or a user wants to help complaince further
	 */
659 660
	if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
	    last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
661 662 663 664
	    wiphy->regd)
		regd = wiphy->regd;

	if (!regd)
665 666
		return -EINVAL;

667
	for (i = 0; i < regd->n_reg_rules; i++) {
668 669 670 671
		const struct ieee80211_reg_rule *rr;
		const struct ieee80211_freq_range *fr = NULL;
		const struct ieee80211_power_rule *pr = NULL;

672
		rr = &regd->reg_rules[i];
673 674
		fr = &rr->freq_range;
		pr = &rr->power_rule;
675

676 677
		/*
		 * We only need to know if one frequency rule was
678
		 * was in center_freq's band, that's enough, so lets
679 680
		 * not overwrite it once found
		 */
681 682 683
		if (!band_rule_found)
			band_rule_found = freq_in_rule_band(fr, center_freq);

684 685 686
		bw_fits = reg_does_bw_fit(fr,
					  center_freq,
					  desired_bw_khz);
687

688
		if (band_rule_found && bw_fits) {
689
			*reg_rule = rr;
690
			return 0;
691 692 693
		}
	}

694 695 696
	if (!band_rule_found)
		return -ERANGE;

697
	return -EINVAL;
698 699
}

700 701 702 703
int freq_reg_info(struct wiphy *wiphy,
		  u32 center_freq,
		  u32 desired_bw_khz,
		  const struct ieee80211_reg_rule **reg_rule)
704
{
705
	assert_cfg80211_lock();
706 707 708 709 710
	return freq_reg_info_regd(wiphy,
				  center_freq,
				  desired_bw_khz,
				  reg_rule,
				  NULL);
711
}
712
EXPORT_SYMBOL(freq_reg_info);
713

714 715 716 717 718 719 720 721 722
/*
 * Note that right now we assume the desired channel bandwidth
 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
 * per channel, the primary and the extension channel). To support
 * smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
 * new ieee80211_channel.target_bw and re run the regulatory check
 * on the wiphy with the target_bw specified. Then we can simply use
 * that below for the desired_bw_khz below.
 */
723 724 725
static void handle_channel(struct wiphy *wiphy,
			   enum nl80211_reg_initiator initiator,
			   enum ieee80211_band band,
726
			   unsigned int chan_idx)
727 728
{
	int r;
729 730
	u32 flags, bw_flags = 0;
	u32 desired_bw_khz = MHZ_TO_KHZ(20);
731 732
	const struct ieee80211_reg_rule *reg_rule = NULL;
	const struct ieee80211_power_rule *power_rule = NULL;
733
	const struct ieee80211_freq_range *freq_range = NULL;
734 735
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;
736
	struct wiphy *request_wiphy = NULL;
737

738 739
	assert_cfg80211_lock();

740 741
	request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);

742 743 744 745 746
	sband = wiphy->bands[band];
	BUG_ON(chan_idx >= sband->n_channels);
	chan = &sband->channels[chan_idx];

	flags = chan->orig_flags;
747

748 749 750 751
	r = freq_reg_info(wiphy,
			  MHZ_TO_KHZ(chan->center_freq),
			  desired_bw_khz,
			  &reg_rule);
752

753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
	if (r) {
		/*
		 * We will disable all channels that do not match our
		 * recieved regulatory rule unless the hint is coming
		 * from a Country IE and the Country IE had no information
		 * about a band. The IEEE 802.11 spec allows for an AP
		 * to send only a subset of the regulatory rules allowed,
		 * so an AP in the US that only supports 2.4 GHz may only send
		 * a country IE with information for the 2.4 GHz band
		 * while 5 GHz is still supported.
		 */
		if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
		    r == -ERANGE)
			return;

		REG_DBG_PRINT("cfg80211: Disabling freq %d MHz\n",
			      chan->center_freq);
		chan->flags = IEEE80211_CHAN_DISABLED;
771
		return;
772
	}
773

774
	power_rule = &reg_rule->power_rule;
775 776 777 778
	freq_range = &reg_rule->freq_range;

	if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
		bw_flags = IEEE80211_CHAN_NO_HT40;
779

780
	if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
781
	    request_wiphy && request_wiphy == wiphy &&
782
	    request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
783 784
		/*
		 * This gaurantees the driver's requested regulatory domain
785
		 * will always be used as a base for further regulatory
786 787
		 * settings
		 */
788
		chan->flags = chan->orig_flags =
789
			map_regdom_flags(reg_rule->flags) | bw_flags;
790 791 792 793 794 795 796
		chan->max_antenna_gain = chan->orig_mag =
			(int) MBI_TO_DBI(power_rule->max_antenna_gain);
		chan->max_power = chan->orig_mpwr =
			(int) MBM_TO_DBM(power_rule->max_eirp);
		return;
	}

797
	chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
798
	chan->max_antenna_gain = min(chan->orig_mag,
799
		(int) MBI_TO_DBI(power_rule->max_antenna_gain));
800
	if (chan->orig_mpwr)
801 802
		chan->max_power = min(chan->orig_mpwr,
			(int) MBM_TO_DBM(power_rule->max_eirp));
803
	else
804
		chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
805 806
}

807 808 809
static void handle_band(struct wiphy *wiphy,
			enum ieee80211_band band,
			enum nl80211_reg_initiator initiator)
810
{
811 812 813 814 815
	unsigned int i;
	struct ieee80211_supported_band *sband;

	BUG_ON(!wiphy->bands[band]);
	sband = wiphy->bands[band];
816 817

	for (i = 0; i < sband->n_channels; i++)
818
		handle_channel(wiphy, initiator, band, i);
819 820
}

821 822
static bool ignore_reg_update(struct wiphy *wiphy,
			      enum nl80211_reg_initiator initiator)
823 824 825
{
	if (!last_request)
		return true;
826
	if (initiator == NL80211_REGDOM_SET_BY_CORE &&
827
	    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
828
		return true;
829 830 831 832
	/*
	 * wiphy->regd will be set once the device has its own
	 * desired regulatory domain set
	 */
833
	if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
834
	    initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
835
	    !is_world_regdom(last_request->alpha2))
836 837 838 839
		return true;
	return false;
}

840
static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
841
{
842
	struct cfg80211_registered_device *rdev;
843

844 845
	list_for_each_entry(rdev, &cfg80211_rdev_list, list)
		wiphy_update_regulatory(&rdev->wiphy, initiator);
846 847
}

848 849 850 851 852 853
static void handle_reg_beacon(struct wiphy *wiphy,
			      unsigned int chan_idx,
			      struct reg_beacon *reg_beacon)
{
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;
854 855
	bool channel_changed = false;
	struct ieee80211_channel chan_before;
856 857 858 859 860 861 862 863 864

	assert_cfg80211_lock();

	sband = wiphy->bands[reg_beacon->chan.band];
	chan = &sband->channels[chan_idx];

	if (likely(chan->center_freq != reg_beacon->chan.center_freq))
		return;

865 866 867 868 869
	if (chan->beacon_found)
		return;

	chan->beacon_found = true;

870
	if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
871 872
		return;

873 874 875
	chan_before.center_freq = chan->center_freq;
	chan_before.flags = chan->flags;

876
	if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
877
		chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
878
		channel_changed = true;
879 880
	}

881
	if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
882
		chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
883
		channel_changed = true;
884 885
	}

886 887
	if (channel_changed)
		nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
}

/*
 * Called when a scan on a wiphy finds a beacon on
 * new channel
 */
static void wiphy_update_new_beacon(struct wiphy *wiphy,
				    struct reg_beacon *reg_beacon)
{
	unsigned int i;
	struct ieee80211_supported_band *sband;

	assert_cfg80211_lock();

	if (!wiphy->bands[reg_beacon->chan.band])
		return;

	sband = wiphy->bands[reg_beacon->chan.band];

	for (i = 0; i < sband->n_channels; i++)
		handle_reg_beacon(wiphy, i, reg_beacon);
}

/*
 * Called upon reg changes or a new wiphy is added
 */
static void wiphy_update_beacon_reg(struct wiphy *wiphy)
{
	unsigned int i;
	struct ieee80211_supported_band *sband;
	struct reg_beacon *reg_beacon;

	assert_cfg80211_lock();

	if (list_empty(&reg_beacon_list))
		return;

	list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
		if (!wiphy->bands[reg_beacon->chan.band])
			continue;
		sband = wiphy->bands[reg_beacon->chan.band];
		for (i = 0; i < sband->n_channels; i++)
			handle_reg_beacon(wiphy, i, reg_beacon);
	}
}

static bool reg_is_world_roaming(struct wiphy *wiphy)
{
	if (is_world_regdom(cfg80211_regdomain->alpha2) ||
	    (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
		return true;
939 940
	if (last_request &&
	    last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
941
	    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
942 943 944 945 946 947 948
		return true;
	return false;
}

/* Reap the advantages of previously found beacons */
static void reg_process_beacons(struct wiphy *wiphy)
{
949 950 951 952 953 954
	/*
	 * Means we are just firing up cfg80211, so no beacons would
	 * have been processed yet.
	 */
	if (!last_request)
		return;
955 956 957 958 959
	if (!reg_is_world_roaming(wiphy))
		return;
	wiphy_update_beacon_reg(wiphy);
}

960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
static bool is_ht40_not_allowed(struct ieee80211_channel *chan)
{
	if (!chan)
		return true;
	if (chan->flags & IEEE80211_CHAN_DISABLED)
		return true;
	/* This would happen when regulatory rules disallow HT40 completely */
	if (IEEE80211_CHAN_NO_HT40 == (chan->flags & (IEEE80211_CHAN_NO_HT40)))
		return true;
	return false;
}

static void reg_process_ht_flags_channel(struct wiphy *wiphy,
					 enum ieee80211_band band,
					 unsigned int chan_idx)
{
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *channel;
	struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
	unsigned int i;

	assert_cfg80211_lock();

	sband = wiphy->bands[band];
	BUG_ON(chan_idx >= sband->n_channels);
	channel = &sband->channels[chan_idx];

	if (is_ht40_not_allowed(channel)) {
		channel->flags |= IEEE80211_CHAN_NO_HT40;
		return;
	}

	/*
	 * We need to ensure the extension channels exist to
	 * be able to use HT40- or HT40+, this finds them (or not)
	 */
	for (i = 0; i < sband->n_channels; i++) {
		struct ieee80211_channel *c = &sband->channels[i];
		if (c->center_freq == (channel->center_freq - 20))
			channel_before = c;
		if (c->center_freq == (channel->center_freq + 20))
			channel_after = c;
	}

	/*
	 * Please note that this assumes target bandwidth is 20 MHz,
	 * if that ever changes we also need to change the below logic
	 * to include that as well.
	 */
	if (is_ht40_not_allowed(channel_before))
1010
		channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1011
	else
1012
		channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1013 1014

	if (is_ht40_not_allowed(channel_after))
1015
		channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1016
	else
1017
		channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
}

static void reg_process_ht_flags_band(struct wiphy *wiphy,
				      enum ieee80211_band band)
{
	unsigned int i;
	struct ieee80211_supported_band *sband;

	BUG_ON(!wiphy->bands[band]);
	sband = wiphy->bands[band];

	for (i = 0; i < sband->n_channels; i++)
		reg_process_ht_flags_channel(wiphy, band, i);
}

static void reg_process_ht_flags(struct wiphy *wiphy)
{
	enum ieee80211_band band;

	if (!wiphy)
		return;

	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		if (wiphy->bands[band])
			reg_process_ht_flags_band(wiphy, band);
	}

}

1047 1048
void wiphy_update_regulatory(struct wiphy *wiphy,
			     enum nl80211_reg_initiator initiator)
1049 1050
{
	enum ieee80211_band band;
1051

1052
	if (ignore_reg_update(wiphy, initiator))
1053
		goto out;
1054
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1055
		if (wiphy->bands[band])
1056
			handle_band(wiphy, band, initiator);
1057
	}
1058 1059
out:
	reg_process_beacons(wiphy);
1060
	reg_process_ht_flags(wiphy);
1061
	if (wiphy->reg_notifier)
1062
		wiphy->reg_notifier(wiphy, last_request);
1063 1064
}

1065 1066 1067 1068 1069 1070
static void handle_channel_custom(struct wiphy *wiphy,
				  enum ieee80211_band band,
				  unsigned int chan_idx,
				  const struct ieee80211_regdomain *regd)
{
	int r;
1071 1072
	u32 desired_bw_khz = MHZ_TO_KHZ(20);
	u32 bw_flags = 0;
1073 1074
	const struct ieee80211_reg_rule *reg_rule = NULL;
	const struct ieee80211_power_rule *power_rule = NULL;
1075
	const struct ieee80211_freq_range *freq_range = NULL;
1076 1077 1078
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;

1079
	assert_reg_lock();
1080

1081 1082 1083 1084
	sband = wiphy->bands[band];
	BUG_ON(chan_idx >= sband->n_channels);
	chan = &sband->channels[chan_idx];

1085 1086 1087 1088 1089
	r = freq_reg_info_regd(wiphy,
			       MHZ_TO_KHZ(chan->center_freq),
			       desired_bw_khz,
			       &reg_rule,
			       regd);
1090 1091 1092 1093 1094 1095 1096

	if (r) {
		chan->flags = IEEE80211_CHAN_DISABLED;
		return;
	}

	power_rule = &reg_rule->power_rule;
1097 1098 1099 1100
	freq_range = &reg_rule->freq_range;

	if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
		bw_flags = IEEE80211_CHAN_NO_HT40;
1101

1102
	chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1103 1104 1105 1106 1107 1108 1109 1110