regd.c 14.9 KB
Newer Older
1
/*
2
 * Copyright (c) 2008-2009 Atheros Communications Inc.
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/slab.h>
19
20
21
#include <net/cfg80211.h>
#include <net/mac80211.h>
#include "regd.h"
22
23
#include "regd_common.h"

24
25
26
27
28
29
/*
 * This is a set of common rules used by our world regulatory domains.
 * We have 12 world regulatory domains. To save space we consolidate
 * the regulatory domains in 5 structures by frequency and change
 * the flags on our reg_notifier() on a case by case basis.
 */
30

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/* Only these channels all allow active scan on all world regulatory domains */
#define ATH9K_2GHZ_CH01_11	REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)

/* We enable active scan on these a case by case basis by regulatory domain */
#define ATH9K_2GHZ_CH12_13	REG_RULE(2467-10, 2472+10, 40, 0, 20,\
					NL80211_RRF_PASSIVE_SCAN)
#define ATH9K_2GHZ_CH14		REG_RULE(2484-10, 2484+10, 40, 0, 20,\
				NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_OFDM)

/* We allow IBSS on these on a case by case basis by regulatory domain */
#define ATH9K_5GHZ_5150_5350	REG_RULE(5150-10, 5350+10, 40, 0, 30,\
				NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define ATH9K_5GHZ_5470_5850	REG_RULE(5470-10, 5850+10, 40, 0, 30,\
				NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define ATH9K_5GHZ_5725_5850	REG_RULE(5725-10, 5850+10, 40, 0, 30,\
				NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)

#define ATH9K_2GHZ_ALL		ATH9K_2GHZ_CH01_11, \
				ATH9K_2GHZ_CH12_13, \
				ATH9K_2GHZ_CH14

#define ATH9K_5GHZ_ALL		ATH9K_5GHZ_5150_5350, \
				ATH9K_5GHZ_5470_5850
/* This one skips what we call "mid band" */
#define ATH9K_5GHZ_NO_MIDBAND	ATH9K_5GHZ_5150_5350, \
				ATH9K_5GHZ_5725_5850

/* Can be used for:
 * 0x60, 0x61, 0x62 */
60
static const struct ieee80211_regdomain ath_world_regdom_60_61_62 = {
61
62
63
64
65
66
67
68
69
	.n_reg_rules = 5,
	.alpha2 =  "99",
	.reg_rules = {
		ATH9K_2GHZ_ALL,
		ATH9K_5GHZ_ALL,
	}
};

/* Can be used by 0x63 and 0x65 */
70
static const struct ieee80211_regdomain ath_world_regdom_63_65 = {
71
72
73
74
75
76
77
78
79
80
	.n_reg_rules = 4,
	.alpha2 =  "99",
	.reg_rules = {
		ATH9K_2GHZ_CH01_11,
		ATH9K_2GHZ_CH12_13,
		ATH9K_5GHZ_NO_MIDBAND,
	}
};

/* Can be used by 0x64 only */
81
static const struct ieee80211_regdomain ath_world_regdom_64 = {
82
83
84
85
86
87
88
89
90
	.n_reg_rules = 3,
	.alpha2 =  "99",
	.reg_rules = {
		ATH9K_2GHZ_CH01_11,
		ATH9K_5GHZ_NO_MIDBAND,
	}
};

/* Can be used by 0x66 and 0x69 */
91
static const struct ieee80211_regdomain ath_world_regdom_66_69 = {
92
93
94
95
96
97
98
99
100
	.n_reg_rules = 3,
	.alpha2 =  "99",
	.reg_rules = {
		ATH9K_2GHZ_CH01_11,
		ATH9K_5GHZ_ALL,
	}
};

/* Can be used by 0x67, 0x6A and 0x68 */
101
static const struct ieee80211_regdomain ath_world_regdom_67_68_6A = {
102
103
104
105
106
107
108
109
	.n_reg_rules = 4,
	.alpha2 =  "99",
	.reg_rules = {
		ATH9K_2GHZ_CH01_11,
		ATH9K_2GHZ_CH12_13,
		ATH9K_5GHZ_ALL,
	}
};
110

111
112
113
114
115
116
static inline bool is_wwr_sku(u16 regd)
{
	return ((regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||
		(regd == WORLD);
}

117
static u16 ath_regd_get_eepromRD(struct ath_regulatory *reg)
118
{
119
	return reg->current_rd & ~WORLDWIDE_ROAMING_FLAG;
120
121
}

122
bool ath_is_world_regd(struct ath_regulatory *reg)
123
{
124
	return is_wwr_sku(ath_regd_get_eepromRD(reg));
125
}
126
EXPORT_SYMBOL(ath_is_world_regd);
127

128
static const struct ieee80211_regdomain *ath_default_world_regdomain(void)
129
{
130
	/* this is the most restrictive */
131
	return &ath_world_regdom_64;
132
}
133

134
static const struct
135
ieee80211_regdomain *ath_world_regdomain(struct ath_regulatory *reg)
136
{
137
	switch (reg->regpair->regDmnEnum) {
138
139
140
	case 0x60:
	case 0x61:
	case 0x62:
141
		return &ath_world_regdom_60_61_62;
142
143
	case 0x63:
	case 0x65:
144
		return &ath_world_regdom_63_65;
145
	case 0x64:
146
		return &ath_world_regdom_64;
147
148
	case 0x66:
	case 0x69:
149
		return &ath_world_regdom_66_69;
150
151
152
	case 0x67:
	case 0x68:
	case 0x6A:
153
		return &ath_world_regdom_67_68_6A;
154
155
	default:
		WARN_ON(1);
156
		return ath_default_world_regdomain();
157
158
159
	}
}

160
/* Frequency is one where radar detection is required */
161
static bool ath_is_radar_freq(u16 center_freq)
162
163
164
165
{
	return (center_freq >= 5260 && center_freq <= 5700);
}

166
/*
167
168
169
170
171
172
173
 * N.B: These exception rules do not apply radar freqs.
 *
 * - We enable adhoc (or beaconing) if allowed by 11d
 * - We enable active scan if the channel is allowed by 11d
 * - If no country IE has been processed and a we determine we have
 *   received a beacon on a channel we can enable active scan and
 *   adhoc (or beaconing).
174
 */
Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
175
176
177
static void
ath_reg_apply_beaconing_flags(struct wiphy *wiphy,
			      enum nl80211_reg_initiator initiator)
178
{
179
	enum ieee80211_band band;
180
181
182
183
184
185
186
	struct ieee80211_supported_band *sband;
	const struct ieee80211_reg_rule *reg_rule;
	struct ieee80211_channel *ch;
	unsigned int i;
	u32 bandwidth = 0;
	int r;

187
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
188

189
		if (!wiphy->bands[band])
190
			continue;
191
192
193
194
195
196
197

		sband = wiphy->bands[band];

		for (i = 0; i < sband->n_channels; i++) {

			ch = &sband->channels[i];

198
			if (ath_is_radar_freq(ch->center_freq) ||
199
200
201
			    (ch->flags & IEEE80211_CHAN_RADAR))
				continue;

202
			if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
203
204
205
206
				r = freq_reg_info(wiphy,
						  ch->center_freq,
						  bandwidth,
						  &reg_rule);
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
				if (r)
					continue;
				/*
				 * If 11d had a rule for this channel ensure
				 * we enable adhoc/beaconing if it allows us to
				 * use it. Note that we would have disabled it
				 * by applying our static world regdomain by
				 * default during init, prior to calling our
				 * regulatory_hint().
				 */
				if (!(reg_rule->flags &
				    NL80211_RRF_NO_IBSS))
					ch->flags &=
					  ~IEEE80211_CHAN_NO_IBSS;
				if (!(reg_rule->flags &
				    NL80211_RRF_PASSIVE_SCAN))
					ch->flags &=
					  ~IEEE80211_CHAN_PASSIVE_SCAN;
			} else {
				if (ch->beacon_found)
					ch->flags &= ~(IEEE80211_CHAN_NO_IBSS |
					  IEEE80211_CHAN_PASSIVE_SCAN);
			}
		}
231
	}
232

233
234
}

235
/* Allows active scan scan on Ch 12 and 13 */
Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
236
237
238
static void
ath_reg_apply_active_scan_flags(struct wiphy *wiphy,
				enum nl80211_reg_initiator initiator)
239
{
240
241
242
243
244
245
246
247
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *ch;
	const struct ieee80211_reg_rule *reg_rule;
	u32 bandwidth = 0;
	int r;

	sband = wiphy->bands[IEEE80211_BAND_2GHZ];

248
249
250
251
	/*
	 * If no country IE has been received always enable active scan
	 * on these channels. This is only done for specific regulatory SKUs
	 */
252
	if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
253
254
255
256
257
258
259
260
		ch = &sband->channels[11]; /* CH 12 */
		if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
			ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
		ch = &sband->channels[12]; /* CH 13 */
		if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
			ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
		return;
	}
261

262
263
	/*
	 * If a country IE has been recieved check its rule for this
264
	 * channel first before enabling active scan. The passive scan
265
266
267
	 * would have been enforced by the initial processing of our
	 * custom regulatory domain.
	 */
268

269
	ch = &sband->channels[11]; /* CH 12 */
270
	r = freq_reg_info(wiphy, ch->center_freq, bandwidth, &reg_rule);
271
272
273
274
	if (!r) {
		if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
			if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
				ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
275
276
	}

277
	ch = &sband->channels[12]; /* CH 13 */
278
	r = freq_reg_info(wiphy, ch->center_freq, bandwidth, &reg_rule);
279
280
281
282
	if (!r) {
		if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
			if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
				ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
283
284
285
	}
}

286
/* Always apply Radar/DFS rules on freq range 5260 MHz - 5700 MHz */
287
static void ath_reg_apply_radar_flags(struct wiphy *wiphy)
288
{
289
290
291
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *ch;
	unsigned int i;
292

293
294
	if (!wiphy->bands[IEEE80211_BAND_5GHZ])
		return;
295

296
	sband = wiphy->bands[IEEE80211_BAND_5GHZ];
297

298
299
	for (i = 0; i < sband->n_channels; i++) {
		ch = &sband->channels[i];
300
		if (!ath_is_radar_freq(ch->center_freq))
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
			continue;
		/* We always enable radar detection/DFS on this
		 * frequency range. Additionally we also apply on
		 * this frequency range:
		 * - If STA mode does not yet have DFS supports disable
		 *   active scanning
		 * - If adhoc mode does not support DFS yet then
		 *   disable adhoc in the frequency.
		 * - If AP mode does not yet support radar detection/DFS
		 *   do not allow AP mode
		 */
		if (!(ch->flags & IEEE80211_CHAN_DISABLED))
			ch->flags |= IEEE80211_CHAN_RADAR |
				     IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_PASSIVE_SCAN;
	}
}
318

319
static void ath_reg_apply_world_flags(struct wiphy *wiphy,
Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
320
321
				      enum nl80211_reg_initiator initiator,
				      struct ath_regulatory *reg)
322
{
323
	switch (reg->regpair->regDmnEnum) {
324
325
326
327
	case 0x60:
	case 0x63:
	case 0x66:
	case 0x67:
328
		ath_reg_apply_beaconing_flags(wiphy, initiator);
329
330
		break;
	case 0x68:
331
332
		ath_reg_apply_beaconing_flags(wiphy, initiator);
		ath_reg_apply_active_scan_flags(wiphy, initiator);
333
334
335
336
		break;
	}
	return;
}
337

338
int ath_reg_notifier_apply(struct wiphy *wiphy,
Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
339
340
			   struct regulatory_request *request,
			   struct ath_regulatory *reg)
341
342
{
	/* We always apply this */
343
	ath_reg_apply_radar_flags(wiphy);
344

345
	switch (request->initiator) {
346
347
348
	case NL80211_REGDOM_SET_BY_DRIVER:
	case NL80211_REGDOM_SET_BY_CORE:
	case NL80211_REGDOM_SET_BY_USER:
349
		break;
350
	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
351
352
353
		if (ath_is_world_regd(reg))
			ath_reg_apply_world_flags(wiphy, request->initiator,
						  reg);
354
355
		break;
	}
356

357
	return 0;
358
}
359
EXPORT_SYMBOL(ath_reg_notifier_apply);
360

361
static bool ath_regd_is_eeprom_valid(struct ath_regulatory *reg)
362
{
363
	 u16 rd = ath_regd_get_eepromRD(reg);
364
	int i;
365

366
367
368
	if (rd & COUNTRY_ERD_FLAG) {
		/* EEPROM value is a country code */
		u16 cc = rd & ~COUNTRY_ERD_FLAG;
369
370
371
		printk(KERN_DEBUG
		       "ath: EEPROM indicates we should expect "
			"a country code\n");
372
373
374
375
376
		for (i = 0; i < ARRAY_SIZE(allCountries); i++)
			if (allCountries[i].countryCode == cc)
				return true;
	} else {
		/* EEPROM value is a regpair value */
377
378
379
		if (rd != CTRY_DEFAULT)
			printk(KERN_DEBUG "ath: EEPROM indicates we "
			       "should expect a direct regpair map\n");
380
381
382
		for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++)
			if (regDomainPairs[i].regDmnEnum == rd)
				return true;
383
	}
384
	printk(KERN_DEBUG
385
		 "ath: invalid regulatory domain/country code 0x%x\n", rd);
386
387
388
	return false;
}

389
/* EEPROM country code to regpair mapping */
390
static struct country_code_to_enum_rd*
391
ath_regd_find_country(u16 countryCode)
392
393
394
395
396
397
398
399
400
401
{
	int i;

	for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
		if (allCountries[i].countryCode == countryCode)
			return &allCountries[i];
	}
	return NULL;
}

402
403
/* EEPROM rd code to regpair mapping */
static struct country_code_to_enum_rd*
404
ath_regd_find_country_by_rd(int regdmn)
405
406
407
408
409
410
411
412
413
414
415
{
	int i;

	for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
		if (allCountries[i].regDmnEnum == regdmn)
			return &allCountries[i];
	}
	return NULL;
}

/* Returns the map of the EEPROM set RD to a country code */
416
static u16 ath_regd_get_default_country(u16 rd)
417
418
419
420
421
{
	if (rd & COUNTRY_ERD_FLAG) {
		struct country_code_to_enum_rd *country = NULL;
		u16 cc = rd & ~COUNTRY_ERD_FLAG;

422
		country = ath_regd_find_country(cc);
423
424
425
426
427
428
429
		if (country != NULL)
			return cc;
	}

	return CTRY_DEFAULT;
}

430
static struct reg_dmn_pair_mapping*
431
ath_get_regpair(int regdmn)
432
433
434
{
	int i;

435
436
	if (regdmn == NO_ENUMRD)
		return NULL;
437
	for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++) {
438
439
		if (regDomainPairs[i].regDmnEnum == regdmn)
			return &regDomainPairs[i];
440
	}
441
	return NULL;
442
443
}

Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
444
445
446
447
static int
ath_regd_init_wiphy(struct ath_regulatory *reg,
		    struct wiphy *wiphy,
		    int (*reg_notifier)(struct wiphy *wiphy,
448
449
450
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
					struct regulatory_request *request))
{
	const struct ieee80211_regdomain *regd;

	wiphy->reg_notifier = reg_notifier;
	wiphy->strict_regulatory = true;

	if (ath_is_world_regd(reg)) {
		/*
		 * Anything applied here (prior to wiphy registration) gets
		 * saved on the wiphy orig_* parameters
		 */
		regd = ath_world_regdomain(reg);
		wiphy->custom_regulatory = true;
		wiphy->strict_regulatory = false;
	} else {
		/*
		 * This gets applied in the case of the absense of CRDA,
		 * it's our own custom world regulatory domain, similar to
		 * cfg80211's but we enable passive scanning.
		 */
		regd = ath_default_world_regdomain();
	}
	wiphy_apply_custom_regulatory(wiphy, regd);
	ath_reg_apply_radar_flags(wiphy);
	ath_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER, reg);
	return 0;
}

Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
477
478
479
480
481
int
ath_regd_init(struct ath_regulatory *reg,
	      struct wiphy *wiphy,
	      int (*reg_notifier)(struct wiphy *wiphy,
				  struct regulatory_request *request))
482
483
{
	struct country_code_to_enum_rd *country = NULL;
484
	u16 regdmn;
485

486
487
488
489
490
	if (!reg)
		return -EINVAL;

	printk(KERN_DEBUG "ath: EEPROM regdomain: 0x%0x\n", reg->current_rd);

491
	if (!ath_regd_is_eeprom_valid(reg)) {
492
		printk(KERN_ERR "ath: Invalid EEPROM contents\n");
493
		return -EINVAL;
494
495
	}

496
497
	regdmn = ath_regd_get_eepromRD(reg);
	reg->country_code = ath_regd_get_default_country(regdmn);
498

499
	if (reg->country_code == CTRY_DEFAULT &&
500
501
502
	    regdmn == CTRY_DEFAULT) {
		printk(KERN_DEBUG "ath: EEPROM indicates default "
		       "country code should be used\n");
503
		reg->country_code = CTRY_UNITED_STATES;
504
	}
505

506
	if (reg->country_code == CTRY_DEFAULT) {
507
508
		country = NULL;
	} else {
509
510
		printk(KERN_DEBUG "ath: doing EEPROM country->regdmn "
		       "map search\n");
511
		country = ath_regd_find_country(reg->country_code);
512
		if (country == NULL) {
513
			printk(KERN_DEBUG
514
515
				"ath: no valid country maps found for "
				"country code: 0x%0x\n",
516
				reg->country_code);
517
			return -EINVAL;
518
		} else {
519
			regdmn = country->regDmnEnum;
520
521
522
523
			printk(KERN_DEBUG "ath: country maps to "
			       "regdmn code: 0x%0x\n",
			       regdmn);
		}
524
525
	}

526
	reg->regpair = ath_get_regpair(regdmn);
527

528
	if (!reg->regpair) {
529
		printk(KERN_DEBUG "ath: "
530
531
			"No regulatory domain pair found, cannot continue\n");
		return -EINVAL;
532
533
	}

534
	if (!country)
535
		country = ath_regd_find_country_by_rd(regdmn);
536

537
	if (country) {
538
539
		reg->alpha2[0] = country->isoName[0];
		reg->alpha2[1] = country->isoName[1];
540
	} else {
541
542
		reg->alpha2[0] = '0';
		reg->alpha2[1] = '0';
543
544
	}

545
	printk(KERN_DEBUG "ath: Country alpha2 being used: %c%c\n",
546
		reg->alpha2[0], reg->alpha2[1]);
547
	printk(KERN_DEBUG "ath: Regpair used: 0x%0x\n",
548
		reg->regpair->regDmnEnum);
549

550
	ath_regd_init_wiphy(reg, wiphy, reg_notifier);
551
	return 0;
552
}
553
EXPORT_SYMBOL(ath_regd_init);
554

555
556
u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
			  enum ieee80211_band band)
557
{
558
559
	if (!reg->regpair ||
	    (reg->country_code == CTRY_DEFAULT &&
560
	     is_wwr_sku(ath_regd_get_eepromRD(reg)))) {
561
562
563
564
565
		return SD_NO_CTL;
	}

	switch (band) {
	case IEEE80211_BAND_2GHZ:
566
		return reg->regpair->reg_2ghz_ctl;
567
	case IEEE80211_BAND_5GHZ:
568
		return reg->regpair->reg_5ghz_ctl;
569
570
	default:
		return NO_CTL;
571
572
	}

573
574
	return NO_CTL;
}
575
EXPORT_SYMBOL(ath_regd_get_band_ctl);