projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cfg80211: remove enum ieee80211_band
[linux-block.git] / drivers / net / wireless / ath / regd.c
CommitLineData
f078f209 1/*
cee075a2 2 * Copyright (c) 2008-2009 Atheros Communications Inc.
f078f209
LR		 3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
516304b0
JP		 17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
f078f209 19#include <linux/kernel.h>
ee40fa06 20#include <linux/export.h>
3a702e49
BC		 21#include <net/cfg80211.h>
22#include <net/mac80211.h>
3a702e49 23#include "regd.h"
f078f209
LR		 24#include "regd_common.h"
25
de1c732b
LR		 26static int __ath_regd_init(struct ath_regulatory *reg);
27
5f8e077c
LR		 28/*
29 * This is a set of common rules used by our world regulatory domains.
30 * We have 12 world regulatory domains. To save space we consolidate
31 * the regulatory domains in 5 structures by frequency and change
32 * the flags on our reg_notifier() on a case by case basis.
33 */
f078f209 34
5f8e077c
LR		 35/* Only these channels all allow active scan on all world regulatory domains */
36#define ATH9K_2GHZ_CH01_11 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)
37
38/* We enable active scan on these a case by case basis by regulatory domain */
39#define ATH9K_2GHZ_CH12_13 REG_RULE(2467-10, 2472+10, 40, 0, 20,\
8fe02e16 40 NL80211_RRF_NO_IR)
5f8e077c 41#define ATH9K_2GHZ_CH14 REG_RULE(2484-10, 2484+10, 40, 0, 20,\
8fe02e16
LR		 42 NL80211_RRF_NO_IR | \
43 NL80211_RRF_NO_OFDM)
5f8e077c
LR		 44
45/* We allow IBSS on these on a case by case basis by regulatory domain */
d619c62f 46#define ATH9K_5GHZ_5150_5350 REG_RULE(5150-10, 5350+10, 80, 0, 30,\
8fe02e16 47 NL80211_RRF_NO_IR)
d619c62f 48#define ATH9K_5GHZ_5470_5850 REG_RULE(5470-10, 5850+10, 80, 0, 30,\
8fe02e16 49 NL80211_RRF_NO_IR)
d619c62f 50#define ATH9K_5GHZ_5725_5850 REG_RULE(5725-10, 5850+10, 80, 0, 30,\
8fe02e16 51 NL80211_RRF_NO_IR)
5f8e077c
LR		 52
53#define ATH9K_2GHZ_ALL ATH9K_2GHZ_CH01_11, \
54 ATH9K_2GHZ_CH12_13, \
55 ATH9K_2GHZ_CH14
56
57#define ATH9K_5GHZ_ALL ATH9K_5GHZ_5150_5350, \
58 ATH9K_5GHZ_5470_5850
cfcfe446 59
5f8e077c
LR		 60/* This one skips what we call "mid band" */
61#define ATH9K_5GHZ_NO_MIDBAND ATH9K_5GHZ_5150_5350, \
62 ATH9K_5GHZ_5725_5850
63
64/* Can be used for:
65 * 0x60, 0x61, 0x62 */
3a702e49 66static const struct ieee80211_regdomain ath_world_regdom_60_61_62 = {
5f8e077c
LR		 67 .n_reg_rules = 5,
68 .alpha2 = "99",
69 .reg_rules = {
70 ATH9K_2GHZ_ALL,
71 ATH9K_5GHZ_ALL,
72 }
73};
74
75/* Can be used by 0x63 and 0x65 */
3a702e49 76static const struct ieee80211_regdomain ath_world_regdom_63_65 = {
5f8e077c
LR		 77 .n_reg_rules = 4,
78 .alpha2 = "99",
79 .reg_rules = {
80 ATH9K_2GHZ_CH01_11,
81 ATH9K_2GHZ_CH12_13,
82 ATH9K_5GHZ_NO_MIDBAND,
83 }
84};
85
86/* Can be used by 0x64 only */
3a702e49 87static const struct ieee80211_regdomain ath_world_regdom_64 = {
5f8e077c
LR		 88 .n_reg_rules = 3,
89 .alpha2 = "99",
90 .reg_rules = {
91 ATH9K_2GHZ_CH01_11,
92 ATH9K_5GHZ_NO_MIDBAND,
93 }
94};
95
96/* Can be used by 0x66 and 0x69 */
3a702e49 97static const struct ieee80211_regdomain ath_world_regdom_66_69 = {
5f8e077c
LR		 98 .n_reg_rules = 3,
99 .alpha2 = "99",
100 .reg_rules = {
101 ATH9K_2GHZ_CH01_11,
102 ATH9K_5GHZ_ALL,
103 }
104};
105
34a0a202
SB		 106/* Can be used by 0x67, 0x68, 0x6A and 0x6C */
107static const struct ieee80211_regdomain ath_world_regdom_67_68_6A_6C = {
5f8e077c
LR		 108 .n_reg_rules = 4,
109 .alpha2 = "99",
110 .reg_rules = {
111 ATH9K_2GHZ_CH01_11,
112 ATH9K_2GHZ_CH12_13,
113 ATH9K_5GHZ_ALL,
114 }
115};
f078f209 116
a44ea6ff
LR		 117static bool dynamic_country_user_possible(struct ath_regulatory *reg)
118{
119 if (config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING))
120 return true;
121
122 switch (reg->country_code) {
123 case CTRY_UNITED_STATES:
124 case CTRY_JAPAN1:
125 case CTRY_JAPAN2:
126 case CTRY_JAPAN3:
127 case CTRY_JAPAN4:
128 case CTRY_JAPAN5:
129 case CTRY_JAPAN6:
130 case CTRY_JAPAN7:
131 case CTRY_JAPAN8:
132 case CTRY_JAPAN9:
133 case CTRY_JAPAN10:
134 case CTRY_JAPAN11:
135 case CTRY_JAPAN12:
136 case CTRY_JAPAN13:
137 case CTRY_JAPAN14:
138 case CTRY_JAPAN15:
139 case CTRY_JAPAN16:
140 case CTRY_JAPAN17:
141 case CTRY_JAPAN18:
142 case CTRY_JAPAN19:
143 case CTRY_JAPAN20:
144 case CTRY_JAPAN21:
145 case CTRY_JAPAN22:
146 case CTRY_JAPAN23:
147 case CTRY_JAPAN24:
148 case CTRY_JAPAN25:
149 case CTRY_JAPAN26:
150 case CTRY_JAPAN27:
151 case CTRY_JAPAN28:
152 case CTRY_JAPAN29:
153 case CTRY_JAPAN30:
154 case CTRY_JAPAN31:
155 case CTRY_JAPAN32:
156 case CTRY_JAPAN33:
157 case CTRY_JAPAN34:
158 case CTRY_JAPAN35:
159 case CTRY_JAPAN36:
160 case CTRY_JAPAN37:
161 case CTRY_JAPAN38:
162 case CTRY_JAPAN39:
163 case CTRY_JAPAN40:
164 case CTRY_JAPAN41:
165 case CTRY_JAPAN42:
166 case CTRY_JAPAN43:
167 case CTRY_JAPAN44:
168 case CTRY_JAPAN45:
169 case CTRY_JAPAN46:
170 case CTRY_JAPAN47:
171 case CTRY_JAPAN48:
172 case CTRY_JAPAN49:
173 case CTRY_JAPAN50:
174 case CTRY_JAPAN51:
175 case CTRY_JAPAN52:
176 case CTRY_JAPAN53:
177 case CTRY_JAPAN54:
178 case CTRY_JAPAN55:
179 case CTRY_JAPAN56:
180 case CTRY_JAPAN57:
181 case CTRY_JAPAN58:
182 case CTRY_JAPAN59:
183 return false;
184 }
185
186 return true;
187}
188
ba94c049
LR		 189static bool ath_reg_dyn_country_user_allow(struct ath_regulatory *reg)
190{
191 if (!config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS))
192 return false;
193 if (!dynamic_country_user_possible(reg))
194 return false;
195 return true;
196}
197
d0f48f9d
BC		 198static inline bool is_wwr_sku(u16 regd)
199{
641eabb0
CL		 200 return ((regd & COUNTRY_ERD_FLAG) != COUNTRY_ERD_FLAG) &&
201 (((regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||
202 (regd == WORLD));
d0f48f9d
BC		 203}
204
3a702e49 205static u16 ath_regd_get_eepromRD(struct ath_regulatory *reg)
f078f209 206{
c02cf373 207 return reg->current_rd & ~WORLDWIDE_ROAMING_FLAG;
f078f209
LR		 208}
209
3a702e49 210bool ath_is_world_regd(struct ath_regulatory *reg)
5f8e077c 211{
3a702e49 212 return is_wwr_sku(ath_regd_get_eepromRD(reg));
f078f209 213}
3a702e49 214EXPORT_SYMBOL(ath_is_world_regd);
f078f209 215
e3bb249b 216static const struct ieee80211_regdomain *ath_default_world_regdomain(void)
f078f209 217{
5f8e077c 218 /* this is the most restrictive */
3a702e49 219 return &ath_world_regdom_64;
5f8e077c 220}
f078f209 221
e3bb249b 222static const struct
3a702e49 223ieee80211_regdomain *ath_world_regdomain(struct ath_regulatory *reg)
5f8e077c 224{
ef8c0017 225 switch (reg->regpair->reg_domain) {
5f8e077c
LR		 226 case 0x60:
227 case 0x61:
228 case 0x62:
3a702e49 229 return &ath_world_regdom_60_61_62;
5f8e077c
LR		 230 case 0x63:
231 case 0x65:
3a702e49 232 return &ath_world_regdom_63_65;
5f8e077c 233 case 0x64:
3a702e49 234 return &ath_world_regdom_64;
5f8e077c
LR		 235 case 0x66:
236 case 0x69:
3a702e49 237 return &ath_world_regdom_66_69;
5f8e077c
LR		 238 case 0x67:
239 case 0x68:
240 case 0x6A:
34a0a202
SB		 241 case 0x6C:
242 return &ath_world_regdom_67_68_6A_6C;
5f8e077c
LR		 243 default:
244 WARN_ON(1);
3a702e49 245 return ath_default_world_regdomain();
f078f209 246 }
f078f209
LR		 247}
248
5719efdd
BR		 249bool ath_is_49ghz_allowed(u16 regdomain)
250{
251 /* possibly more */
252 return regdomain == MKK9_MKKC;
253}
254EXPORT_SYMBOL(ath_is_49ghz_allowed);
255
547e4c2e 256/* Frequency is one where radar detection is required */
3a702e49 257static bool ath_is_radar_freq(u16 center_freq)
547e4c2e
LR		 258{
259 return (center_freq >= 5260 && center_freq <= 5700);
260}
261
bc0aa069
LR		 262static void ath_force_clear_no_ir_chan(struct wiphy *wiphy,
263 struct ieee80211_channel *ch)
264{
265 const struct ieee80211_reg_rule *reg_rule;
266
62452a99 267 reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(ch->center_freq));
bc0aa069
LR		 268 if (IS_ERR(reg_rule))
269 return;
270
271 if (!(reg_rule->flags & NL80211_RRF_NO_IR))
272 if (ch->flags & IEEE80211_CHAN_NO_IR)
273 ch->flags &= ~IEEE80211_CHAN_NO_IR;
274}
275
276static void ath_force_clear_no_ir_freq(struct wiphy *wiphy, u16 center_freq)
277{
278 struct ieee80211_channel *ch;
279
280 ch = ieee80211_get_channel(wiphy, center_freq);
281 if (!ch)
282 return;
283
284 ath_force_clear_no_ir_chan(wiphy, ch);
285}
286
287static void ath_force_no_ir_chan(struct ieee80211_channel *ch)
288{
289 ch->flags |= IEEE80211_CHAN_NO_IR;
290}
291
292static void ath_force_no_ir_freq(struct wiphy *wiphy, u16 center_freq)
293{
294 struct ieee80211_channel *ch;
295
296 ch = ieee80211_get_channel(wiphy, center_freq);
297 if (!ch)
298 return;
299
300 ath_force_no_ir_chan(ch);
301}
302
07782d94
LR		 303static void
304__ath_reg_apply_beaconing_flags(struct wiphy *wiphy,
251c9ba1 305 struct ath_regulatory *reg,
07782d94
LR		 306 enum nl80211_reg_initiator initiator,
307 struct ieee80211_channel *ch)
308{
309 if (ath_is_radar_freq(ch->center_freq) ||
310 (ch->flags & IEEE80211_CHAN_RADAR))
311 return;
312
313 switch (initiator) {
314 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
315 ath_force_clear_no_ir_chan(wiphy, ch);
316 break;
251c9ba1
LR		 317 case NL80211_REGDOM_SET_BY_USER:
318 if (ath_reg_dyn_country_user_allow(reg))
319 ath_force_clear_no_ir_chan(wiphy, ch);
320 break;
07782d94
LR		 321 default:
322 if (ch->beacon_found)
323 ch->flags &= ~IEEE80211_CHAN_NO_IR;
324 }
325}
326
7519a8f0 327/*
6c3af588 328 * These exception rules do not apply radar frequencies.
84540869 329 *
6c3af588 330 * - We enable initiating radiation if the country IE says its fine:
84540869 331 * - If no country IE has been processed and a we determine we have
6c3af588 332 * received a beacon on a channel we can enable initiating radiation.
7519a8f0 333 */
6b2b2ffb
LR		 334static void
335ath_reg_apply_beaconing_flags(struct wiphy *wiphy,
251c9ba1 336 struct ath_regulatory *reg,
6b2b2ffb 337 enum nl80211_reg_initiator initiator)
f078f209 338{
57fbcce3 339 enum nl80211_band band;
5f8e077c 340 struct ieee80211_supported_band *sband;
5f8e077c
LR		 341 struct ieee80211_channel *ch;
342 unsigned int i;
5f8e077c 343
57fbcce3 344 for (band = 0; band < NUM_NL80211_BANDS; band++) {
84540869 345 if (!wiphy->bands[band])
5f8e077c 346 continue;
84540869 347 sband = wiphy->bands[band];
84540869 348 for (i = 0; i < sband->n_channels; i++) {
84540869 349 ch = &sband->channels[i];
251c9ba1
LR		 350 __ath_reg_apply_beaconing_flags(wiphy, reg,
351 initiator, ch);
84540869 352 }
5f8e077c 353 }
f078f209
LR		 354}
355
bc0aa069 356/**
f33cbc4f 357 * ath_reg_apply_ir_flags()
bc0aa069
LR		 358 * @wiphy: the wiphy to use
359 * @initiator: the regulatory hint initiator
360 *
361 * If no country IE has been received always enable passive scan
362 * and no-ibss on these channels. This is only done for specific
363 * regulatory SKUs.
364 *
365 * If a country IE has been received check its rule for this
366 * channel first before enabling active scan. The passive scan
367 * would have been enforced by the initial processing of our
368 * custom regulatory domain.
369 */
6b2b2ffb 370static void
f33cbc4f 371ath_reg_apply_ir_flags(struct wiphy *wiphy,
251c9ba1
LR		 372 struct ath_regulatory *reg,
373 enum nl80211_reg_initiator initiator)
f078f209 374{
5f8e077c 375 struct ieee80211_supported_band *sband;
5f8e077c 376
57fbcce3 377 sband = wiphy->bands[NL80211_BAND_2GHZ];
a59be081
HS		 378 if (!sband)
379 return;
5f8e077c 380
bc0aa069
LR		 381 switch(initiator) {
382 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
383 ath_force_clear_no_ir_freq(wiphy, 2467);
384 ath_force_clear_no_ir_freq(wiphy, 2472);
385 break;
251c9ba1
LR		 386 case NL80211_REGDOM_SET_BY_USER:
387 if (!ath_reg_dyn_country_user_allow(reg))
388 break;
389 ath_force_clear_no_ir_freq(wiphy, 2467);
390 ath_force_clear_no_ir_freq(wiphy, 2472);
391 break;
bc0aa069
LR		 392 default:
393 ath_force_no_ir_freq(wiphy, 2467);
394 ath_force_no_ir_freq(wiphy, 2472);
f078f209 395 }
f078f209
LR		 396}
397
5f8e077c 398/* Always apply Radar/DFS rules on freq range 5260 MHz - 5700 MHz */
e3bb249b 399static void ath_reg_apply_radar_flags(struct wiphy *wiphy)
f078f209 400{
5f8e077c
LR		 401 struct ieee80211_supported_band *sband;
402 struct ieee80211_channel *ch;
403 unsigned int i;
f078f209 404
57fbcce3 405 if (!wiphy->bands[NL80211_BAND_5GHZ])
5f8e077c 406 return;
f078f209 407
57fbcce3 408 sband = wiphy->bands[NL80211_BAND_5GHZ];
f078f209 409
5f8e077c
LR		 410 for (i = 0; i < sband->n_channels; i++) {
411 ch = &sband->channels[i];
3a702e49 412 if (!ath_is_radar_freq(ch->center_freq))
5f8e077c
LR		 413 continue;
414 /* We always enable radar detection/DFS on this
415 * frequency range. Additionally we also apply on
416 * this frequency range:
417 * - If STA mode does not yet have DFS supports disable
418 * active scanning
419 * - If adhoc mode does not support DFS yet then
420 * disable adhoc in the frequency.
421 * - If AP mode does not yet support radar detection/DFS
422 * do not allow AP mode
423 */
424 if (!(ch->flags & IEEE80211_CHAN_DISABLED))
425 ch->flags |= IEEE80211_CHAN_RADAR |
8fe02e16 426 IEEE80211_CHAN_NO_IR;
5f8e077c
LR		 427 }
428}
f078f209 429
e3bb249b 430static void ath_reg_apply_world_flags(struct wiphy *wiphy,
6b2b2ffb
LR		 431 enum nl80211_reg_initiator initiator,
432 struct ath_regulatory *reg)
5f8e077c 433{
ef8c0017 434 switch (reg->regpair->reg_domain) {
5f8e077c
LR		 435 case 0x60:
436 case 0x63:
437 case 0x66:
438 case 0x67:
2290a9c3 439 case 0x6C:
251c9ba1 440 ath_reg_apply_beaconing_flags(wiphy, reg, initiator);
5f8e077c
LR		 441 break;
442 case 0x68:
251c9ba1
LR		 443 ath_reg_apply_beaconing_flags(wiphy, reg, initiator);
444 ath_reg_apply_ir_flags(wiphy, reg, initiator);
5f8e077c 445 break;
251c9ba1
LR		 446 default:
447 if (ath_reg_dyn_country_user_allow(reg))
448 ath_reg_apply_beaconing_flags(wiphy, reg, initiator);
5f8e077c 449 }
5f8e077c 450}
f078f209 451
de1c732b
LR		 452static u16 ath_regd_find_country_by_name(char *alpha2)
453{
454 unsigned int i;
455
456 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
457 if (!memcmp(allCountries[i].isoName, alpha2, 2))
458 return allCountries[i].countryCode;
459 }
460
461 return -1;
462}
463
8a3b6c80
LR		 464static int __ath_reg_dyn_country(struct wiphy *wiphy,
465 struct ath_regulatory *reg,
466 struct regulatory_request *request)
467{
468 u16 country_code;
469
3e850edd
LR		 470 if (request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
471 !ath_is_world_regd(reg))
8a3b6c80
LR		 472 return -EINVAL;
473
474 country_code = ath_regd_find_country_by_name(request->alpha2);
475 if (country_code == (u16) -1)
476 return -EINVAL;
477
478 reg->current_rd = COUNTRY_ERD_FLAG;
479 reg->current_rd |= country_code;
480
481 __ath_regd_init(reg);
482
483 ath_reg_apply_world_flags(wiphy, request->initiator, reg);
484
485 return 0;
486}
487
488static void ath_reg_dyn_country(struct wiphy *wiphy,
489 struct ath_regulatory *reg,
490 struct regulatory_request *request)
491{
492 if (__ath_reg_dyn_country(wiphy, reg, request))
493 return;
494
495 printk(KERN_DEBUG "ath: regdomain 0x%0x "
496 "dynamically updated by %s\n",
497 reg->current_rd,
498 reg_initiator_name(request->initiator));
499}
500
0c0280bd
LR		 501void ath_reg_notifier_apply(struct wiphy *wiphy,
502 struct regulatory_request *request,
503 struct ath_regulatory *reg)
5f8e077c 504{
de1c732b
LR		 505 struct ath_common *common = container_of(reg, struct ath_common,
506 regulatory);
5f8e077c 507 /* We always apply this */
3a702e49 508 ath_reg_apply_radar_flags(wiphy);
f078f209 509
931299cf
LR		 510 /*
511 * This would happen when we have sent a custom regulatory request
512 * a world regulatory domain and the scheduler hasn't yet processed
513 * any pending requests in the queue.
514 */
515 if (!request)
0c0280bd 516 return;
931299cf 517
94e05900 518 reg->region = request->dfs_region;
5f8e077c 519 switch (request->initiator) {
7db90f4a 520 case NL80211_REGDOM_SET_BY_CORE:
de1c732b
LR		 521 /*
522 * If common->reg_world_copy is world roaming it means we *were*
523 * world roaming... so we now have to restore that data.
524 */
525 if (!ath_is_world_regd(&common->reg_world_copy))
526 break;
527
528 memcpy(reg, &common->reg_world_copy,
529 sizeof(struct ath_regulatory));
530 break;
531 case NL80211_REGDOM_SET_BY_DRIVER:
4da225bb 532 break;
7db90f4a 533 case NL80211_REGDOM_SET_BY_USER:
ba94c049
LR		 534 if (ath_reg_dyn_country_user_allow(reg))
535 ath_reg_dyn_country(wiphy, reg, request);
5f8e077c 536 break;
7db90f4a 537 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
8a3b6c80 538 ath_reg_dyn_country(wiphy, reg, request);
5f8e077c
LR		 539 break;
540 }
f078f209 541}
3a702e49 542EXPORT_SYMBOL(ath_reg_notifier_apply);
f078f209 543
e3bb249b 544static bool ath_regd_is_eeprom_valid(struct ath_regulatory *reg)
c02cf373 545{
cfcfe446 546 u16 rd = ath_regd_get_eepromRD(reg);
5f8e077c 547 int i;
f078f209 548
5f8e077c
LR		 549 if (rd & COUNTRY_ERD_FLAG) {
550 /* EEPROM value is a country code */
551 u16 cc = rd & ~COUNTRY_ERD_FLAG;
e03e5ffd
LR		 552 printk(KERN_DEBUG
553 "ath: EEPROM indicates we should expect "
554 "a country code\n");
5f8e077c
LR		 555 for (i = 0; i < ARRAY_SIZE(allCountries); i++)
556 if (allCountries[i].countryCode == cc)
557 return true;
558 } else {
559 /* EEPROM value is a regpair value */
e03e5ffd
LR		 560 if (rd != CTRY_DEFAULT)
561 printk(KERN_DEBUG "ath: EEPROM indicates we "
562 "should expect a direct regpair map\n");
5f8e077c 563 for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++)
ef8c0017 564 if (regDomainPairs[i].reg_domain == rd)
5f8e077c 565 return true;
f078f209 566 }
c02cf373 567 printk(KERN_DEBUG
3a702e49 568 "ath: invalid regulatory domain/country code 0x%x\n", rd);
f078f209
LR		 569 return false;
570}
571
5f8e077c 572/* EEPROM country code to regpair mapping */
f078f209 573static struct country_code_to_enum_rd*
3a702e49 574ath_regd_find_country(u16 countryCode)
f078f209
LR		 575{
576 int i;
577
578 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
579 if (allCountries[i].countryCode == countryCode)
580 return &allCountries[i];
581 }
582 return NULL;
583}
584
5f8e077c
LR		 585/* EEPROM rd code to regpair mapping */
586static struct country_code_to_enum_rd*
3a702e49 587ath_regd_find_country_by_rd(int regdmn)
5f8e077c
LR		 588{
589 int i;
590
591 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
592 if (allCountries[i].regDmnEnum == regdmn)
593 return &allCountries[i];
594 }
595 return NULL;
596}
597
598/* Returns the map of the EEPROM set RD to a country code */
3a702e49 599static u16 ath_regd_get_default_country(u16 rd)
f078f209 600{
f078f209
LR		 601 if (rd & COUNTRY_ERD_FLAG) {
602 struct country_code_to_enum_rd *country = NULL;
603 u16 cc = rd & ~COUNTRY_ERD_FLAG;
604
3a702e49 605 country = ath_regd_find_country(cc);
f078f209
LR		 606 if (country != NULL)
607 return cc;
608 }
609
f078f209
LR		 610 return CTRY_DEFAULT;
611}
612
5f8e077c 613static struct reg_dmn_pair_mapping*
3a702e49 614ath_get_regpair(int regdmn)
f078f209
LR		 615{
616 int i;
617
5f8e077c
LR		 618 if (regdmn == NO_ENUMRD)
619 return NULL;
f078f209 620 for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++) {
ef8c0017 621 if (regDomainPairs[i].reg_domain == regdmn)
5f8e077c 622 return &regDomainPairs[i];
f078f209 623 }
5f8e077c 624 return NULL;
f078f209
LR		 625}
626
6b2b2ffb
LR		 627static int
628ath_regd_init_wiphy(struct ath_regulatory *reg,
629 struct wiphy *wiphy,
0c0280bd
LR		 630 void (*reg_notifier)(struct wiphy *wiphy,
631 struct regulatory_request *request))
e3bb249b
BC		 632{
633 const struct ieee80211_regdomain *regd;
634
635 wiphy->reg_notifier = reg_notifier;
8fc68580
LR		 636 wiphy->regulatory_flags |= REGULATORY_STRICT_REG |
637 REGULATORY_CUSTOM_REG;
e3bb249b
BC		 638
639 if (ath_is_world_regd(reg)) {
640 /*
641 * Anything applied here (prior to wiphy registration) gets
642 * saved on the wiphy orig_* parameters
643 */
644 regd = ath_world_regdomain(reg);
8fc68580 645 wiphy->regulatory_flags |= REGULATORY_COUNTRY_IE_FOLLOW_POWER;
e3bb249b
BC		 646 } else {
647 /*
25985edc 648 * This gets applied in the case of the absence of CRDA,
e3bb249b
BC		 649 * it's our own custom world regulatory domain, similar to
650 * cfg80211's but we enable passive scanning.
651 */
652 regd = ath_default_world_regdomain();
653 }
8fc68580 654
e3bb249b
BC		 655 wiphy_apply_custom_regulatory(wiphy, regd);
656 ath_reg_apply_radar_flags(wiphy);
657 ath_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER, reg);
658 return 0;
659}
660
5d2214ac
LR		 661/*
662 * Some users have reported their EEPROM programmed with
663 * 0x8000 set, this is not a supported regulatory domain
664 * but since we have more than one user with it we need
665 * a solution for them. We default to 0x64, which is the
666 * default Atheros world regulatory domain.
667 */
668static void ath_regd_sanitize(struct ath_regulatory *reg)
669{
670 if (reg->current_rd != COUNTRY_ERD_FLAG)
671 return;
672 printk(KERN_DEBUG "ath: EEPROM regdomain sanitized\n");
673 reg->current_rd = 0x64;
674}
675
43fcb430 676static int __ath_regd_init(struct ath_regulatory *reg)
f078f209 677{
f078f209 678 struct country_code_to_enum_rd *country = NULL;
e775aaf0 679 u16 regdmn;
f078f209 680
e03e5ffd
LR		 681 if (!reg)
682 return -EINVAL;
683
5d2214ac
LR		 684 ath_regd_sanitize(reg);
685
e03e5ffd
LR		 686 printk(KERN_DEBUG "ath: EEPROM regdomain: 0x%0x\n", reg->current_rd);
687
3a702e49 688 if (!ath_regd_is_eeprom_valid(reg)) {
516304b0 689 pr_err("Invalid EEPROM contents\n");
5f8e077c 690 return -EINVAL;
f078f209
LR		 691 }
692
3a702e49
BC		 693 regdmn = ath_regd_get_eepromRD(reg);
694 reg->country_code = ath_regd_get_default_country(regdmn);
f078f209 695
c02cf373 696 if (reg->country_code == CTRY_DEFAULT &&
e03e5ffd
LR		 697 regdmn == CTRY_DEFAULT) {
698 printk(KERN_DEBUG "ath: EEPROM indicates default "
699 "country code should be used\n");
c02cf373 700 reg->country_code = CTRY_UNITED_STATES;
e03e5ffd 701 }
f078f209 702
c02cf373 703 if (reg->country_code == CTRY_DEFAULT) {
f078f209
LR		 704 country = NULL;
705 } else {
e03e5ffd
LR		 706 printk(KERN_DEBUG "ath: doing EEPROM country->regdmn "
707 "map search\n");
3a702e49 708 country = ath_regd_find_country(reg->country_code);
f078f209 709 if (country == NULL) {
c02cf373 710 printk(KERN_DEBUG
e03e5ffd
LR		 711 "ath: no valid country maps found for "
712 "country code: 0x%0x\n",
c02cf373 713 reg->country_code);
5f8e077c 714 return -EINVAL;
e03e5ffd 715 } else {
f078f209 716 regdmn = country->regDmnEnum;
e03e5ffd
LR		 717 printk(KERN_DEBUG "ath: country maps to "
718 "regdmn code: 0x%0x\n",
719 regdmn);
720 }
f078f209
LR		 721 }
722
3a702e49 723 reg->regpair = ath_get_regpair(regdmn);
f078f209 724
c02cf373 725 if (!reg->regpair) {
3a702e49 726 printk(KERN_DEBUG "ath: "
5f8e077c
LR		 727 "No regulatory domain pair found, cannot continue\n");
728 return -EINVAL;
f078f209 729 }
f078f209 730
5f8e077c 731 if (!country)
3a702e49 732 country = ath_regd_find_country_by_rd(regdmn);
f078f209 733
5f8e077c 734 if (country) {
c02cf373
BC		 735 reg->alpha2[0] = country->isoName[0];
736 reg->alpha2[1] = country->isoName[1];
f078f209 737 } else {
c02cf373
BC		 738 reg->alpha2[0] = '0';
739 reg->alpha2[1] = '0';
f078f209
LR		 740 }
741
3a702e49 742 printk(KERN_DEBUG "ath: Country alpha2 being used: %c%c\n",
c02cf373 743 reg->alpha2[0], reg->alpha2[1]);
e03e5ffd 744 printk(KERN_DEBUG "ath: Regpair used: 0x%0x\n",
ef8c0017 745 reg->regpair->reg_domain);
f078f209 746
43fcb430
LR		 747 return 0;
748}
749
750int
751ath_regd_init(struct ath_regulatory *reg,
752 struct wiphy *wiphy,
0c0280bd
LR		 753 void (*reg_notifier)(struct wiphy *wiphy,
754 struct regulatory_request *request))
43fcb430 755{
de1c732b
LR		 756 struct ath_common *common = container_of(reg, struct ath_common,
757 regulatory);
43fcb430
LR		 758 int r;
759
760 r = __ath_regd_init(reg);
761 if (r)
762 return r;
763
de1c732b
LR		 764 if (ath_is_world_regd(reg))
765 memcpy(&common->reg_world_copy, reg,
766 sizeof(struct ath_regulatory));
767
e3bb249b 768 ath_regd_init_wiphy(reg, wiphy, reg_notifier);
43fcb430 769
5f8e077c 770 return 0;
f078f209 771}
3a702e49 772EXPORT_SYMBOL(ath_regd_init);
f078f209 773
3a702e49 774u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
57fbcce3 775 enum nl80211_band band)
f078f209 776{
c02cf373
BC		 777 if (!reg->regpair ||
778 (reg->country_code == CTRY_DEFAULT &&
3a702e49 779 is_wwr_sku(ath_regd_get_eepromRD(reg)))) {
fc2ada30
BC		 780 return SD_NO_CTL;
781 }
782
94e05900
FF		 783 if (ath_regd_get_eepromRD(reg) == CTRY_DEFAULT) {
784 switch (reg->region) {
785 case NL80211_DFS_FCC:
786 return CTL_FCC;
787 case NL80211_DFS_ETSI:
788 return CTL_ETSI;
789 case NL80211_DFS_JP:
790 return CTL_MKK;
791 default:
792 break;
793 }
794 }
795
fc2ada30 796 switch (band) {
57fbcce3 797 case NL80211_BAND_2GHZ:
c02cf373 798 return reg->regpair->reg_2ghz_ctl;
57fbcce3 799 case NL80211_BAND_5GHZ:
c02cf373 800 return reg->regpair->reg_5ghz_ctl;
fc2ada30
BC		 801 default:
802 return NO_CTL;
f078f209 803 }
fc2ada30 804}
3a702e49 805EXPORT_SYMBOL(ath_regd_get_band_ctl);
Linux 6.x block layer and io_uring tree(s)