reg.c 62.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-2011	Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
6
 *
7
8
9
10
11
12
13
14
15
16
17
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
19
 */

20

21
22
/**
 * DOC: Wireless regulatory infrastructure
23
24
25
26
27
28
 *
 * 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.
 *
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 * 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.
 *
43
 */
44
45
46

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

47
#include <linux/kernel.h>
48
#include <linux/export.h>
49
#include <linux/slab.h>
50
51
#include <linux/list.h>
#include <linux/random.h>
52
#include <linux/ctype.h>
53
54
#include <linux/nl80211.h>
#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 "regdb.h"
60
#include "nl80211.h"
61

62
#ifdef CONFIG_CFG80211_REG_DEBUG
63
64
#define REG_DBG_PRINT(format, args...)			\
	printk(KERN_DEBUG pr_fmt(format), ##args)
65
#else
66
#define REG_DBG_PRINT(args...)
67
68
#endif

69
70
71
72
73
74
75
76
77
static struct regulatory_request core_request_world = {
	.initiator = NL80211_REGDOM_SET_BY_CORE,
	.alpha2[0] = '0',
	.alpha2[1] = '0',
	.intersect = false,
	.processed = true,
	.country_ie_env = ENVIRON_ANY,
};

78
/* Receipt of information from last regulatory request */
79
static struct regulatory_request *last_request = &core_request_world;
80

81
82
/* To trigger userspace events */
static struct platform_device *reg_pdev;
83

84
85
86
87
static struct device_type reg_device_type = {
	.uevent = reg_device_uevent,
};

88
89
/*
 * Central wireless core regulatory domains, we only need two,
90
 * the current one and a world regulatory domain in case we have no
91
92
 * information to give us an alpha2
 */
93
const struct ieee80211_regdomain *cfg80211_regdomain;
94

95
96
97
98
99
100
/*
 * Protects static reg.c components:
 *     - cfg80211_world_regdom
 *     - cfg80211_regdom
 *     - last_request
 */
101
static DEFINE_MUTEX(reg_mutex);
102
103
104
105
106

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

108
/* Used to queue up regulatory hints */
109
110
111
static LIST_HEAD(reg_requests_list);
static spinlock_t reg_requests_lock;

112
113
114
115
116
117
118
119
120
121
122
123
/* 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;
};

124
125
126
static void reg_todo(struct work_struct *work);
static DECLARE_WORK(reg_work, reg_todo);

127
128
129
static void reg_timeout_work(struct work_struct *work);
static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);

130
131
/* We keep a static world regulatory domain in case of the absence of CRDA */
static const struct ieee80211_regdomain world_regdom = {
132
	.n_reg_rules = 5,
133
134
	.alpha2 =  "00",
	.reg_rules = {
135
136
		/* IEEE 802.11b/g, channels 1..11 */
		REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
137
138
139
		/* IEEE 802.11b/g, channels 12..13. No HT40
		 * channel fits here. */
		REG_RULE(2467-10, 2472+10, 20, 6, 20,
140
141
			NL80211_RRF_PASSIVE_SCAN |
			NL80211_RRF_NO_IBSS),
142
143
144
145
146
147
148
		/* 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 */
149
		REG_RULE(5180-10, 5240+10, 40, 6, 20,
150
151
                        NL80211_RRF_PASSIVE_SCAN |
                        NL80211_RRF_NO_IBSS),
152
153
154
155

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

		/* IEEE 802.11a, channel 149..165 */
156
		REG_RULE(5745-10, 5825+10, 40, 6, 20,
157
158
			NL80211_RRF_PASSIVE_SCAN |
			NL80211_RRF_NO_IBSS),
159
160
161
	}
};

162
163
static const struct ieee80211_regdomain *cfg80211_world_regdom =
	&world_regdom;
164

165
static char *ieee80211_regdom = "00";
166
static char user_alpha2[2];
167

168
169
170
module_param(ieee80211_regdom, charp, 0444);
MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");

171
static void reset_regdomains(bool full_reset)
172
{
173
174
175
176
177
178
179
180
181
182
	/* 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);
183

184
	cfg80211_world_regdom = &world_regdom;
185
	cfg80211_regdomain = NULL;
186
187
188
189
190
191
192

	if (!full_reset)
		return;

	if (last_request != &core_request_world)
		kfree(last_request);
	last_request = &core_request_world;
193
194
}

195
196
197
198
/*
 * Dynamic world regulatory domain requested by the wireless
 * core upon initialization
 */
199
static void update_world_regdomain(const struct ieee80211_regdomain *rd)
200
{
201
	BUG_ON(!last_request);
202

203
	reset_regdomains(false);
204
205
206
207
208

	cfg80211_world_regdom = rd;
	cfg80211_regdomain = rd;
}

209
bool is_world_regdom(const char *alpha2)
210
211
212
213
214
215
216
{
	if (!alpha2)
		return false;
	if (alpha2[0] == '0' && alpha2[1] == '0')
		return true;
	return false;
}
217

218
static bool is_alpha2_set(const char *alpha2)
219
220
221
222
223
224
225
{
	if (!alpha2)
		return false;
	if (alpha2[0] != 0 && alpha2[1] != 0)
		return true;
	return false;
}
226

227
static bool is_unknown_alpha2(const char *alpha2)
228
229
230
{
	if (!alpha2)
		return false;
231
232
233
234
	/*
	 * Special case where regulatory domain was built by driver
	 * but a specific alpha2 cannot be determined
	 */
235
236
237
238
	if (alpha2[0] == '9' && alpha2[1] == '9')
		return true;
	return false;
}
239

240
241
242
243
static bool is_intersected_alpha2(const char *alpha2)
{
	if (!alpha2)
		return false;
244
245
	/*
	 * Special case where regulatory domain is the
246
	 * result of an intersection between two regulatory domain
247
248
	 * structures
	 */
249
250
251
252
253
	if (alpha2[0] == '9' && alpha2[1] == '8')
		return true;
	return false;
}

254
static bool is_an_alpha2(const char *alpha2)
255
256
257
{
	if (!alpha2)
		return false;
258
	if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
259
260
261
		return true;
	return false;
}
262

263
static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
264
265
266
267
268
269
270
271
272
{
	if (!alpha2_x || !alpha2_y)
		return false;
	if (alpha2_x[0] == alpha2_y[0] &&
		alpha2_x[1] == alpha2_y[1])
		return true;
	return false;
}

273
static bool regdom_changes(const char *alpha2)
274
{
275
276
	assert_cfg80211_lock();

277
278
279
280
281
282
283
	if (!cfg80211_regdomain)
		return true;
	if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
		return false;
	return true;
}

284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
/*
 * 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;
}

305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
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);
336
static DEFINE_MUTEX(reg_regdb_search_mutex);
337
338
339
340
341
342
343

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

344
	mutex_lock(&reg_regdb_search_mutex);
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
	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);
	}
367
	mutex_unlock(&reg_regdb_search_mutex);
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
}

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);

385
	mutex_lock(&reg_regdb_search_mutex);
386
	list_add_tail(&request->list, &reg_regdb_search_list);
387
	mutex_unlock(&reg_regdb_search_mutex);
388
389
390

	schedule_work(&reg_regdb_work);
}
391
392
393
394
395
396
397

/* Feel free to add any other sanity checks here */
static void reg_regdb_size_check(void)
{
	/* We should ideally BUILD_BUG_ON() but then random builds would fail */
	WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
}
398
#else
399
static inline void reg_regdb_size_check(void) {}
400
401
402
static inline void reg_regdb_query(const char *alpha2) {}
#endif /* CONFIG_CFG80211_INTERNAL_REGDB */

403
404
/*
 * This lets us keep regulatory code which is updated on a regulatory
405
406
 * basis in userspace. Country information is filled in by
 * reg_device_uevent
407
 */
408
409
410
static int call_crda(const char *alpha2)
{
	if (!is_world_regdom((char *) alpha2))
411
		pr_info("Calling CRDA for country: %c%c\n",
412
413
			alpha2[0], alpha2[1]);
	else
414
		pr_info("Calling CRDA to update world regulatory domain\n");
415

416
417
418
	/* query internal regulatory database (if it exists) */
	reg_regdb_query(alpha2);

419
	return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
420
421
422
}

/* Used by nl80211 before kmalloc'ing our regulatory domain */
423
bool reg_is_valid_request(const char *alpha2)
424
{
425
426
	assert_cfg80211_lock();

427
428
429
430
	if (!last_request)
		return false;

	return alpha2_equal(last_request->alpha2, alpha2);
431
}
432

433
/* Sanity check on a regulatory rule */
434
static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
435
{
436
	const struct ieee80211_freq_range *freq_range = &rule->freq_range;
437
438
	u32 freq_diff;

439
	if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
440
441
442
443
444
445
446
		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;

447
448
	if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
			freq_range->max_bandwidth_khz > freq_diff)
449
450
451
452
453
		return false;

	return true;
}

454
static bool is_valid_rd(const struct ieee80211_regdomain *rd)
455
{
456
	const struct ieee80211_reg_rule *reg_rule = NULL;
457
	unsigned int i;
458

459
460
	if (!rd->n_reg_rules)
		return false;
461

462
463
464
	if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
		return false;

465
466
467
468
469
470
471
	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;
472
473
}

474
475
476
static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
			    u32 center_freq_khz,
			    u32 bw_khz)
477
{
478
479
480
481
482
483
484
485
486
487
	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;
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
/**
 * 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
}

515
516
517
518
/*
 * Helper for regdom_intersect(), this does the real
 * mathematical intersection fun
 */
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
559
560
561
562
563
564
565
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
593
594
595
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;

596
597
	/*
	 * First we get a count of the rules we'll need, then we actually
598
599
600
	 * 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.
601
602
	 * All rules that do check out OK are valid.
	 */
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629

	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];
630
631
			/*
			 * This time around instead of using the stack lets
632
			 * write to the target rule directly saving ourselves
633
634
			 * a memcpy()
			 */
635
636
637
			intersected_rule = &rd->reg_rules[rule_idx];
			r = reg_rules_intersect(rule1, rule2,
				intersected_rule);
638
639
640
641
			/*
			 * No need to memset here the intersected rule here as
			 * we're not using the stack anymore
			 */
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
			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;
}

660
661
662
663
/*
 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 * want to just have the channel structure use these
 */
664
665
666
667
668
669
670
671
672
673
674
675
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;
}

676
677
static int freq_reg_info_regd(struct wiphy *wiphy,
			      u32 center_freq,
678
			      u32 desired_bw_khz,
679
680
			      const struct ieee80211_reg_rule **reg_rule,
			      const struct ieee80211_regdomain *custom_regd)
681
682
{
	int i;
683
	bool band_rule_found = false;
684
	const struct ieee80211_regdomain *regd;
685
686
687
688
	bool bw_fits = false;

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

690
	regd = custom_regd ? custom_regd : cfg80211_regdomain;
691

692
693
694
695
	/*
	 * Follow the driver's regulatory domain, if present, unless a country
	 * IE has been processed or a user wants to help complaince further
	 */
696
697
	if (!custom_regd &&
	    last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
698
	    last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
699
700
701
702
	    wiphy->regd)
		regd = wiphy->regd;

	if (!regd)
703
704
		return -EINVAL;

705
	for (i = 0; i < regd->n_reg_rules; i++) {
706
707
708
		const struct ieee80211_reg_rule *rr;
		const struct ieee80211_freq_range *fr = NULL;

709
		rr = &regd->reg_rules[i];
710
		fr = &rr->freq_range;
711

712
713
		/*
		 * We only need to know if one frequency rule was
714
		 * was in center_freq's band, that's enough, so lets
715
716
		 * not overwrite it once found
		 */
717
718
719
		if (!band_rule_found)
			band_rule_found = freq_in_rule_band(fr, center_freq);

720
721
722
		bw_fits = reg_does_bw_fit(fr,
					  center_freq,
					  desired_bw_khz);
723

724
		if (band_rule_found && bw_fits) {
725
			*reg_rule = rr;
726
			return 0;
727
728
729
		}
	}

730
731
732
	if (!band_rule_found)
		return -ERANGE;

733
	return -EINVAL;
734
735
}

736
737
738
739
int freq_reg_info(struct wiphy *wiphy,
		  u32 center_freq,
		  u32 desired_bw_khz,
		  const struct ieee80211_reg_rule **reg_rule)
740
{
741
	assert_cfg80211_lock();
742
743
744
745
746
	return freq_reg_info_regd(wiphy,
				  center_freq,
				  desired_bw_khz,
				  reg_rule,
				  NULL);
747
}
748
EXPORT_SYMBOL(freq_reg_info);
749

750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
#ifdef CONFIG_CFG80211_REG_DEBUG
static const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
{
	switch (initiator) {
	case NL80211_REGDOM_SET_BY_CORE:
		return "Set by core";
	case NL80211_REGDOM_SET_BY_USER:
		return "Set by user";
	case NL80211_REGDOM_SET_BY_DRIVER:
		return "Set by driver";
	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
		return "Set by country IE";
	default:
		WARN_ON(1);
		return "Set by bug";
	}
}
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783

static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
				    u32 desired_bw_khz,
				    const struct ieee80211_reg_rule *reg_rule)
{
	const struct ieee80211_power_rule *power_rule;
	const struct ieee80211_freq_range *freq_range;
	char max_antenna_gain[32];

	power_rule = &reg_rule->power_rule;
	freq_range = &reg_rule->freq_range;

	if (!power_rule->max_antenna_gain)
		snprintf(max_antenna_gain, 32, "N/A");
	else
		snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);

784
	REG_DBG_PRINT("Updating information on frequency %d MHz "
785
		      "for a %d MHz width channel with regulatory rule:\n",
786
787
788
		      chan->center_freq,
		      KHZ_TO_MHZ(desired_bw_khz));

789
	REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
790
791
		      freq_range->start_freq_khz,
		      freq_range->end_freq_khz,
792
		      freq_range->max_bandwidth_khz,
793
794
795
796
797
798
799
800
801
802
		      max_antenna_gain,
		      power_rule->max_eirp);
}
#else
static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
				    u32 desired_bw_khz,
				    const struct ieee80211_reg_rule *reg_rule)
{
	return;
}
803
804
#endif

805
806
807
808
809
810
811
812
813
/*
 * 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.
 */
814
815
816
static void handle_channel(struct wiphy *wiphy,
			   enum nl80211_reg_initiator initiator,
			   enum ieee80211_band band,
817
			   unsigned int chan_idx)
818
819
{
	int r;
820
821
	u32 flags, bw_flags = 0;
	u32 desired_bw_khz = MHZ_TO_KHZ(20);
822
823
	const struct ieee80211_reg_rule *reg_rule = NULL;
	const struct ieee80211_power_rule *power_rule = NULL;
824
	const struct ieee80211_freq_range *freq_range = NULL;
825
826
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;
827
	struct wiphy *request_wiphy = NULL;
828

829
830
	assert_cfg80211_lock();

831
832
	request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);

833
834
835
836
837
	sband = wiphy->bands[band];
	BUG_ON(chan_idx >= sband->n_channels);
	chan = &sband->channels[chan_idx];

	flags = chan->orig_flags;
838

839
840
841
842
	r = freq_reg_info(wiphy,
			  MHZ_TO_KHZ(chan->center_freq),
			  desired_bw_khz,
			  &reg_rule);
843

844
845
846
	if (r) {
		/*
		 * We will disable all channels that do not match our
Lucas De Marchi's avatar
Lucas De Marchi committed
847
		 * received regulatory rule unless the hint is coming
848
849
850
851
852
853
854
855
856
857
858
		 * 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;

859
		REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
860
		chan->flags = IEEE80211_CHAN_DISABLED;
861
		return;
862
	}
863

864
865
	chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);

866
	power_rule = &reg_rule->power_rule;
867
868
869
870
	freq_range = &reg_rule->freq_range;

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

872
	if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
873
	    request_wiphy && request_wiphy == wiphy &&
874
	    request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
875
		/*
Lucas De Marchi's avatar
Lucas De Marchi committed
876
		 * This guarantees the driver's requested regulatory domain
877
		 * will always be used as a base for further regulatory
878
879
		 * settings
		 */
880
		chan->flags = chan->orig_flags =
881
			map_regdom_flags(reg_rule->flags) | bw_flags;
882
883
884
885
886
887
888
		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;
	}

889
	chan->beacon_found = false;
890
	chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
891
	chan->max_antenna_gain = min(chan->orig_mag,
892
		(int) MBI_TO_DBI(power_rule->max_antenna_gain));
893
	chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
	if (chan->orig_mpwr) {
		/*
		 * Devices that have their own custom regulatory domain
		 * but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
		 * passed country IE power settings.
		 */
		if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
		    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
		    wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
			chan->max_power = chan->max_reg_power;
		else
			chan->max_power = min(chan->orig_mpwr,
					      chan->max_reg_power);
	} else
		chan->max_power = chan->max_reg_power;
909
910
}

911
912
913
static void handle_band(struct wiphy *wiphy,
			enum ieee80211_band band,
			enum nl80211_reg_initiator initiator)
914
{
915
916
917
918
919
	unsigned int i;
	struct ieee80211_supported_band *sband;

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

	for (i = 0; i < sband->n_channels; i++)
922
		handle_channel(wiphy, initiator, band, i);
923
924
}

925
926
static bool ignore_reg_update(struct wiphy *wiphy,
			      enum nl80211_reg_initiator initiator)
927
{
928
	if (!last_request) {
929
		REG_DBG_PRINT("Ignoring regulatory request %s since "
930
931
			      "last_request is not set\n",
			      reg_initiator_name(initiator));
932
		return true;
933
934
	}

935
	if (initiator == NL80211_REGDOM_SET_BY_CORE &&
936
	    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
937
		REG_DBG_PRINT("Ignoring regulatory request %s "
938
			      "since the driver uses its own custom "
939
			      "regulatory domain\n",
940
			      reg_initiator_name(initiator));
941
		return true;
942
943
	}

944
945
946
947
	/*
	 * wiphy->regd will be set once the device has its own
	 * desired regulatory domain set
	 */
948
	if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
949
	    initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
950
	    !is_world_regdom(last_request->alpha2)) {
951
		REG_DBG_PRINT("Ignoring regulatory request %s "
952
			      "since the driver requires its own regulatory "
953
			      "domain to be set first\n",
954
			      reg_initiator_name(initiator));
955
		return true;
956
957
	}

958
959
960
	return false;
}

961
962
963
964
965
966
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;
967
968
	bool channel_changed = false;
	struct ieee80211_channel chan_before;
969
970
971
972
973
974
975
976
977

	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;

978
979
980
981
982
	if (chan->beacon_found)
		return;

	chan->beacon_found = true;

983
	if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
984
985
		return;

986
987
988
	chan_before.center_freq = chan->center_freq;
	chan_before.flags = chan->flags;

989
	if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
990
		chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
991
		channel_changed = true;
992
993
	}

994
	if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
995
		chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
996
		channel_changed = true;
997
998
	}

999
1000
	if (channel_changed)
		nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
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
1047
1048
1049
1050
1051
}

/*
 * 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;
1052
1053
	if (last_request &&
	    last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1054
	    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1055
1056
1057
1058
1059
1060
1061
		return true;
	return false;
}

/* Reap the advantages of previously found beacons */
static void reg_process_beacons(struct wiphy *wiphy)
{
1062
1063
1064
1065
1066
1067
	/*
	 * Means we are just firing up cfg80211, so no beacons would
	 * have been processed yet.
	 */
	if (!last_request)
		return;
1068
1069
1070
1071
1072
	if (!reg_is_world_roaming(wiphy))
		return;
	wiphy_update_beacon_reg(wiphy);
}

1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
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))
1123
		channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1124
	else
1125
		channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1126
1127

	if (is_ht40_not_allowed(channel_after))
1128
		channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1129
	else
1130
		channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
}

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);
	}

}

1160
1161
static void wiphy_update_regulatory(struct wiphy *wiphy,
				    enum nl80211_reg_initiator initiator)
1162
1163
{
	enum ieee80211_band band;
1164

1165
1166
	assert_reg_lock();

1167
	if (ignore_reg_update(wiphy, initiator))
1168
1169
		return;

1170
1171
	last_request->dfs_region = cfg80211_regdomain->dfs_region;

1172
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1173
		if (wiphy->bands[band])
1174
			handle_band(wiphy, band, initiator);
1175
	}
1176

1177
	reg_process_beacons(wiphy);
1178
	reg_process_ht_flags(wiphy);
1179
	if (wiphy->reg_notifier)
1180
		wiphy->reg_notifier(wiphy, last_request);
1181
1182
}

1183
1184
1185
1186
1187
1188
1189
1190
void regulatory_update(struct wiphy *wiphy,
		       enum nl80211_reg_initiator setby)
{
	mutex_lock(&reg_mutex);
	wiphy_update_regulatory(wiphy, setby);
	mutex_unlock(&reg_mutex);
}

1191
1192
1193
static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
{
	struct cfg80211_registered_device *rdev;
1194
	struct wiphy *wiphy;
1195

1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
		wiphy = &rdev->wiphy;
		wiphy_update_regulatory(wiphy, initiator);
		/*
		 * Regulatory updates set by CORE are ignored for custom
		 * regulatory cards. Let us notify the changes to the driver,
		 * as some drivers used this to restore its orig_* reg domain.
		 */
		if (initiator == NL80211_REGDOM_SET_BY_CORE &&
		    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
		    wiphy->reg_notifier)
			wiphy->reg_notifier(wiphy, last_request);
	}
1209
1210
}

1211
1212
1213
1214
1215
1216
static void handle_channel_custom(struct wiphy *wiphy,
				  enum ieee80211_band band,
				  unsigned int chan_idx,
				  const struct ieee80211_regdomain *regd)
{
	int r;
1217
1218
	u32 desired_bw_khz = MHZ_TO_KHZ(20);
	u32 bw_flags = 0;
1219
1220
	const struct ieee80211_reg_rule *reg_rule = NULL;
	const struct ieee80211_power_rule *power_rule = NULL;
1221
	const struct ieee80211_freq_range *freq_range = NULL;
1222
1223
1224
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;

1225
	assert_reg_lock();
1226

1227
1228
1229
1230
	sband = wiphy->bands[band];
	BUG_ON(chan_idx >= sband->n_channels);
	chan = &sband->channels[chan_idx];

1231
1232
1233
1234
1235
	r = freq_reg_info_regd(wiphy,
			       MHZ_TO_KHZ(chan->center_freq),
			       desired_bw_khz,
			       &reg_rule,
			       regd);
1236
1237

	if (r) {
1238
		REG_DBG_PRINT("Disabling freq %d MHz as custom "
1239
1240
1241
1242
			      "regd has no rule that fits a %d MHz "
			      "wide channel\n",
			      chan->center_freq,
			      KHZ_TO_MHZ(desired_bw_khz));
1243
1244
1245
1246
		chan->flags = IEEE80211_CHAN_DISABLED;
		return;
	}

1247
1248
	chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);

1249
	power_rule = &reg_rule->power_rule;
1250
1251
1252
1253
	freq_range = &reg_rule->freq_range;

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

1255
	chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
	chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
	chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
}

static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
			       const struct ieee80211_regdomain *regd)
{
	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++)
		handle_channel_custom(wiphy, band, i, regd);
}

/* Used by drivers prior to wiphy registration */
void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
				   const struct ieee80211_regdomain *regd)
{
	enum ieee80211_band band;
1278
	unsigned int bands_set = 0;
1279

1280
	mutex_lock(&