85c9034c59b276fb3a3606f3845e81ea714bc1c5
[sfrench/cifs-2.6.git] / net / wireless / reg.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
5  * Copyright 2008       Luis R. Rodriguez <lrodriguz@atheros.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 /**
13  * DOC: Wireless regulatory infrastructure
14  *
15  * The usual implementation is for a driver to read a device EEPROM to
16  * determine which regulatory domain it should be operating under, then
17  * looking up the allowable channels in a driver-local table and finally
18  * registering those channels in the wiphy structure.
19  *
20  * Another set of compliance enforcement is for drivers to use their
21  * own compliance limits which can be stored on the EEPROM. The host
22  * driver or firmware may ensure these are used.
23  *
24  * In addition to all this we provide an extra layer of regulatory
25  * conformance. For drivers which do not have any regulatory
26  * information CRDA provides the complete regulatory solution.
27  * For others it provides a community effort on further restrictions
28  * to enhance compliance.
29  *
30  * Note: When number of rules --> infinity we will not be able to
31  * index on alpha2 any more, instead we'll probably have to
32  * rely on some SHA1 checksum of the regdomain for example.
33  *
34  */
35 #include <linux/kernel.h>
36 #include <linux/list.h>
37 #include <linux/random.h>
38 #include <linux/nl80211.h>
39 #include <linux/platform_device.h>
40 #include <net/wireless.h>
41 #include <net/cfg80211.h>
42 #include "core.h"
43 #include "reg.h"
44
45 /**
46  * struct regulatory_request - receipt of last regulatory request
47  *
48  * @wiphy: this is set if this request's initiator is
49  *      %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
50  *      can be used by the wireless core to deal with conflicts
51  *      and potentially inform users of which devices specifically
52  *      cased the conflicts.
53  * @initiator: indicates who sent this request, could be any of
54  *      of those set in reg_set_by, %REGDOM_SET_BY_*
55  * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
56  *      regulatory domain. We have a few special codes:
57  *      00 - World regulatory domain
58  *      99 - built by driver but a specific alpha2 cannot be determined
59  *      98 - result of an intersection between two regulatory domains
60  * @intersect: indicates whether the wireless core should intersect
61  *      the requested regulatory domain with the presently set regulatory
62  *      domain.
63  * @country_ie_checksum: checksum of the last processed and accepted
64  *      country IE
65  * @country_ie_env: lets us know if the AP is telling us we are outdoor,
66  *      indoor, or if it doesn't matter
67  */
68 struct regulatory_request {
69         struct wiphy *wiphy;
70         enum reg_set_by initiator;
71         char alpha2[2];
72         bool intersect;
73         u32 country_ie_checksum;
74         enum environment_cap country_ie_env;
75 };
76
77 /* Receipt of information from last regulatory request */
78 static struct regulatory_request *last_request;
79
80 /* To trigger userspace events */
81 static struct platform_device *reg_pdev;
82
83 /* Keep the ordering from large to small */
84 static u32 supported_bandwidths[] = {
85         MHZ_TO_KHZ(40),
86         MHZ_TO_KHZ(20),
87 };
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  * information to give us an alpha2 */
92 static const struct ieee80211_regdomain *cfg80211_regdomain;
93
94 /* We use this as a place for the rd structure built from the
95  * last parsed country IE to rest until CRDA gets back to us with
96  * what it thinks should apply for the same country */
97 static const struct ieee80211_regdomain *country_ie_regdomain;
98
99 /* We keep a static world regulatory domain in case of the absence of CRDA */
100 static const struct ieee80211_regdomain world_regdom = {
101         .n_reg_rules = 1,
102         .alpha2 =  "00",
103         .reg_rules = {
104                 REG_RULE(2412-10, 2462+10, 40, 6, 20,
105                         NL80211_RRF_PASSIVE_SCAN |
106                         NL80211_RRF_NO_IBSS),
107         }
108 };
109
110 static const struct ieee80211_regdomain *cfg80211_world_regdom =
111         &world_regdom;
112
113 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
114 static char *ieee80211_regdom = "US";
115 module_param(ieee80211_regdom, charp, 0444);
116 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
117
118 /* We assume 40 MHz bandwidth for the old regulatory work.
119  * We make emphasis we are using the exact same frequencies
120  * as before */
121
122 static const struct ieee80211_regdomain us_regdom = {
123         .n_reg_rules = 6,
124         .alpha2 =  "US",
125         .reg_rules = {
126                 /* IEEE 802.11b/g, channels 1..11 */
127                 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
128                 /* IEEE 802.11a, channel 36 */
129                 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
130                 /* IEEE 802.11a, channel 40 */
131                 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
132                 /* IEEE 802.11a, channel 44 */
133                 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
134                 /* IEEE 802.11a, channels 48..64 */
135                 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
136                 /* IEEE 802.11a, channels 149..165, outdoor */
137                 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
138         }
139 };
140
141 static const struct ieee80211_regdomain jp_regdom = {
142         .n_reg_rules = 3,
143         .alpha2 =  "JP",
144         .reg_rules = {
145                 /* IEEE 802.11b/g, channels 1..14 */
146                 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
147                 /* IEEE 802.11a, channels 34..48 */
148                 REG_RULE(5170-10, 5240+10, 40, 6, 20,
149                         NL80211_RRF_PASSIVE_SCAN),
150                 /* IEEE 802.11a, channels 52..64 */
151                 REG_RULE(5260-10, 5320+10, 40, 6, 20,
152                         NL80211_RRF_NO_IBSS |
153                         NL80211_RRF_DFS),
154         }
155 };
156
157 static const struct ieee80211_regdomain eu_regdom = {
158         .n_reg_rules = 6,
159         /* This alpha2 is bogus, we leave it here just for stupid
160          * backward compatibility */
161         .alpha2 =  "EU",
162         .reg_rules = {
163                 /* IEEE 802.11b/g, channels 1..13 */
164                 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
165                 /* IEEE 802.11a, channel 36 */
166                 REG_RULE(5180-10, 5180+10, 40, 6, 23,
167                         NL80211_RRF_PASSIVE_SCAN),
168                 /* IEEE 802.11a, channel 40 */
169                 REG_RULE(5200-10, 5200+10, 40, 6, 23,
170                         NL80211_RRF_PASSIVE_SCAN),
171                 /* IEEE 802.11a, channel 44 */
172                 REG_RULE(5220-10, 5220+10, 40, 6, 23,
173                         NL80211_RRF_PASSIVE_SCAN),
174                 /* IEEE 802.11a, channels 48..64 */
175                 REG_RULE(5240-10, 5320+10, 40, 6, 20,
176                         NL80211_RRF_NO_IBSS |
177                         NL80211_RRF_DFS),
178                 /* IEEE 802.11a, channels 100..140 */
179                 REG_RULE(5500-10, 5700+10, 40, 6, 30,
180                         NL80211_RRF_NO_IBSS |
181                         NL80211_RRF_DFS),
182         }
183 };
184
185 static const struct ieee80211_regdomain *static_regdom(char *alpha2)
186 {
187         if (alpha2[0] == 'U' && alpha2[1] == 'S')
188                 return &us_regdom;
189         if (alpha2[0] == 'J' && alpha2[1] == 'P')
190                 return &jp_regdom;
191         if (alpha2[0] == 'E' && alpha2[1] == 'U')
192                 return &eu_regdom;
193         /* Default, as per the old rules */
194         return &us_regdom;
195 }
196
197 static bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
198 {
199         if (rd == &us_regdom || rd == &jp_regdom || rd == &eu_regdom)
200                 return true;
201         return false;
202 }
203 #else
204 static inline bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
205 {
206         return false;
207 }
208 #endif
209
210 static void reset_regdomains(void)
211 {
212         /* avoid freeing static information or freeing something twice */
213         if (cfg80211_regdomain == cfg80211_world_regdom)
214                 cfg80211_regdomain = NULL;
215         if (cfg80211_world_regdom == &world_regdom)
216                 cfg80211_world_regdom = NULL;
217         if (cfg80211_regdomain == &world_regdom)
218                 cfg80211_regdomain = NULL;
219         if (is_old_static_regdom(cfg80211_regdomain))
220                 cfg80211_regdomain = NULL;
221
222         kfree(cfg80211_regdomain);
223         kfree(cfg80211_world_regdom);
224
225         cfg80211_world_regdom = &world_regdom;
226         cfg80211_regdomain = NULL;
227 }
228
229 /* Dynamic world regulatory domain requested by the wireless
230  * core upon initialization */
231 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
232 {
233         BUG_ON(!last_request);
234
235         reset_regdomains();
236
237         cfg80211_world_regdom = rd;
238         cfg80211_regdomain = rd;
239 }
240
241 bool is_world_regdom(const char *alpha2)
242 {
243         if (!alpha2)
244                 return false;
245         if (alpha2[0] == '0' && alpha2[1] == '0')
246                 return true;
247         return false;
248 }
249
250 static bool is_alpha2_set(const char *alpha2)
251 {
252         if (!alpha2)
253                 return false;
254         if (alpha2[0] != 0 && alpha2[1] != 0)
255                 return true;
256         return false;
257 }
258
259 static bool is_alpha_upper(char letter)
260 {
261         /* ASCII A - Z */
262         if (letter >= 65 && letter <= 90)
263                 return true;
264         return false;
265 }
266
267 static bool is_unknown_alpha2(const char *alpha2)
268 {
269         if (!alpha2)
270                 return false;
271         /* Special case where regulatory domain was built by driver
272          * but a specific alpha2 cannot be determined */
273         if (alpha2[0] == '9' && alpha2[1] == '9')
274                 return true;
275         return false;
276 }
277
278 static bool is_intersected_alpha2(const char *alpha2)
279 {
280         if (!alpha2)
281                 return false;
282         /* Special case where regulatory domain is the
283          * result of an intersection between two regulatory domain
284          * structures */
285         if (alpha2[0] == '9' && alpha2[1] == '8')
286                 return true;
287         return false;
288 }
289
290 static bool is_an_alpha2(const char *alpha2)
291 {
292         if (!alpha2)
293                 return false;
294         if (is_alpha_upper(alpha2[0]) && is_alpha_upper(alpha2[1]))
295                 return true;
296         return false;
297 }
298
299 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
300 {
301         if (!alpha2_x || !alpha2_y)
302                 return false;
303         if (alpha2_x[0] == alpha2_y[0] &&
304                 alpha2_x[1] == alpha2_y[1])
305                 return true;
306         return false;
307 }
308
309 static bool regdom_changed(const char *alpha2)
310 {
311         if (!cfg80211_regdomain)
312                 return true;
313         if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
314                 return false;
315         return true;
316 }
317
318 /**
319  * country_ie_integrity_changes - tells us if the country IE has changed
320  * @checksum: checksum of country IE of fields we are interested in
321  *
322  * If the country IE has not changed you can ignore it safely. This is
323  * useful to determine if two devices are seeing two different country IEs
324  * even on the same alpha2. Note that this will return false if no IE has
325  * been set on the wireless core yet.
326  */
327 static bool country_ie_integrity_changes(u32 checksum)
328 {
329         /* If no IE has been set then the checksum doesn't change */
330         if (unlikely(!last_request->country_ie_checksum))
331                 return false;
332         if (unlikely(last_request->country_ie_checksum != checksum))
333                 return true;
334         return false;
335 }
336
337 /* This lets us keep regulatory code which is updated on a regulatory
338  * basis in userspace. */
339 static int call_crda(const char *alpha2)
340 {
341         char country_env[9 + 2] = "COUNTRY=";
342         char *envp[] = {
343                 country_env,
344                 NULL
345         };
346
347         if (!is_world_regdom((char *) alpha2))
348                 printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
349                         alpha2[0], alpha2[1]);
350         else
351                 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
352                         "regulatory domain\n");
353
354         country_env[8] = alpha2[0];
355         country_env[9] = alpha2[1];
356
357         return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
358 }
359
360 /* Used by nl80211 before kmalloc'ing our regulatory domain */
361 bool reg_is_valid_request(const char *alpha2)
362 {
363         if (!last_request)
364                 return false;
365
366         return alpha2_equal(last_request->alpha2, alpha2);
367 }
368
369 /* Sanity check on a regulatory rule */
370 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
371 {
372         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
373         u32 freq_diff;
374
375         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
376                 return false;
377
378         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
379                 return false;
380
381         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
382
383         if (freq_diff <= 0 || freq_range->max_bandwidth_khz > freq_diff)
384                 return false;
385
386         return true;
387 }
388
389 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
390 {
391         const struct ieee80211_reg_rule *reg_rule = NULL;
392         unsigned int i;
393
394         if (!rd->n_reg_rules)
395                 return false;
396
397         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
398                 return false;
399
400         for (i = 0; i < rd->n_reg_rules; i++) {
401                 reg_rule = &rd->reg_rules[i];
402                 if (!is_valid_reg_rule(reg_rule))
403                         return false;
404         }
405
406         return true;
407 }
408
409 /* Returns value in KHz */
410 static u32 freq_max_bandwidth(const struct ieee80211_freq_range *freq_range,
411         u32 freq)
412 {
413         unsigned int i;
414         for (i = 0; i < ARRAY_SIZE(supported_bandwidths); i++) {
415                 u32 start_freq_khz = freq - supported_bandwidths[i]/2;
416                 u32 end_freq_khz = freq + supported_bandwidths[i]/2;
417                 if (start_freq_khz >= freq_range->start_freq_khz &&
418                         end_freq_khz <= freq_range->end_freq_khz)
419                         return supported_bandwidths[i];
420         }
421         return 0;
422 }
423
424 /**
425  * freq_in_rule_band - tells us if a frequency is in a frequency band
426  * @freq_range: frequency rule we want to query
427  * @freq_khz: frequency we are inquiring about
428  *
429  * This lets us know if a specific frequency rule is or is not relevant to
430  * a specific frequency's band. Bands are device specific and artificial
431  * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
432  * safe for now to assume that a frequency rule should not be part of a
433  * frequency's band if the start freq or end freq are off by more than 2 GHz.
434  * This resolution can be lowered and should be considered as we add
435  * regulatory rule support for other "bands".
436  **/
437 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
438         u32 freq_khz)
439 {
440 #define ONE_GHZ_IN_KHZ  1000000
441         if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
442                 return true;
443         if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
444                 return true;
445         return false;
446 #undef ONE_GHZ_IN_KHZ
447 }
448
449 /* Converts a country IE to a regulatory domain. A regulatory domain
450  * structure has a lot of information which the IE doesn't yet have,
451  * so for the other values we use upper max values as we will intersect
452  * with our userspace regulatory agent to get lower bounds. */
453 static struct ieee80211_regdomain *country_ie_2_rd(
454                                 u8 *country_ie,
455                                 u8 country_ie_len,
456                                 u32 *checksum)
457 {
458         struct ieee80211_regdomain *rd = NULL;
459         unsigned int i = 0;
460         char alpha2[2];
461         u32 flags = 0;
462         u32 num_rules = 0, size_of_regd = 0;
463         u8 *triplets_start = NULL;
464         u8 len_at_triplet = 0;
465         /* the last channel we have registered in a subband (triplet) */
466         int last_sub_max_channel = 0;
467
468         *checksum = 0xDEADBEEF;
469
470         /* Country IE requirements */
471         BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
472                 country_ie_len & 0x01);
473
474         alpha2[0] = country_ie[0];
475         alpha2[1] = country_ie[1];
476
477         /*
478          * Third octet can be:
479          *    'I' - Indoor
480          *    'O' - Outdoor
481          *
482          *  anything else we assume is no restrictions
483          */
484         if (country_ie[2] == 'I')
485                 flags = NL80211_RRF_NO_OUTDOOR;
486         else if (country_ie[2] == 'O')
487                 flags = NL80211_RRF_NO_INDOOR;
488
489         country_ie += 3;
490         country_ie_len -= 3;
491
492         triplets_start = country_ie;
493         len_at_triplet = country_ie_len;
494
495         *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
496
497         /* We need to build a reg rule for each triplet, but first we must
498          * calculate the number of reg rules we will need. We will need one
499          * for each channel subband */
500         while (country_ie_len >= 3) {
501                 int end_channel = 0;
502                 struct ieee80211_country_ie_triplet *triplet =
503                         (struct ieee80211_country_ie_triplet *) country_ie;
504                 int cur_sub_max_channel = 0, cur_channel = 0;
505
506                 if (triplet->ext.reg_extension_id >=
507                                 IEEE80211_COUNTRY_EXTENSION_ID) {
508                         country_ie += 3;
509                         country_ie_len -= 3;
510                         continue;
511                 }
512
513                 /* 2 GHz */
514                 if (triplet->chans.first_channel <= 14)
515                         end_channel = triplet->chans.first_channel +
516                                 triplet->chans.num_channels;
517                 else
518                         /*
519                          * 5 GHz -- For example in country IEs if the first
520                          * channel given is 36 and the number of channels is 4
521                          * then the individual channel numbers defined for the
522                          * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
523                          * and not 36, 37, 38, 39.
524                          *
525                          * See: http://tinyurl.com/11d-clarification
526                          */
527                         end_channel =  triplet->chans.first_channel +
528                                 (4 * (triplet->chans.num_channels - 1));
529
530                 cur_channel = triplet->chans.first_channel;
531                 cur_sub_max_channel = end_channel;
532
533                 /* Basic sanity check */
534                 if (cur_sub_max_channel < cur_channel)
535                         return NULL;
536
537                 /* Do not allow overlapping channels. Also channels
538                  * passed in each subband must be monotonically
539                  * increasing */
540                 if (last_sub_max_channel) {
541                         if (cur_channel <= last_sub_max_channel)
542                                 return NULL;
543                         if (cur_sub_max_channel <= last_sub_max_channel)
544                                 return NULL;
545                 }
546
547                 /* When dot11RegulatoryClassesRequired is supported
548                  * we can throw ext triplets as part of this soup,
549                  * for now we don't care when those change as we
550                  * don't support them */
551                 *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
552                   ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
553                   ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
554
555                 last_sub_max_channel = cur_sub_max_channel;
556
557                 country_ie += 3;
558                 country_ie_len -= 3;
559                 num_rules++;
560
561                 /* Note: this is not a IEEE requirement but
562                  * simply a memory requirement */
563                 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
564                         return NULL;
565         }
566
567         country_ie = triplets_start;
568         country_ie_len = len_at_triplet;
569
570         size_of_regd = sizeof(struct ieee80211_regdomain) +
571                 (num_rules * sizeof(struct ieee80211_reg_rule));
572
573         rd = kzalloc(size_of_regd, GFP_KERNEL);
574         if (!rd)
575                 return NULL;
576
577         rd->n_reg_rules = num_rules;
578         rd->alpha2[0] = alpha2[0];
579         rd->alpha2[1] = alpha2[1];
580
581         /* This time around we fill in the rd */
582         while (country_ie_len >= 3) {
583                 int end_channel = 0;
584                 struct ieee80211_country_ie_triplet *triplet =
585                         (struct ieee80211_country_ie_triplet *) country_ie;
586                 struct ieee80211_reg_rule *reg_rule = NULL;
587                 struct ieee80211_freq_range *freq_range = NULL;
588                 struct ieee80211_power_rule *power_rule = NULL;
589
590                 /* Must parse if dot11RegulatoryClassesRequired is true,
591                  * we don't support this yet */
592                 if (triplet->ext.reg_extension_id >=
593                                 IEEE80211_COUNTRY_EXTENSION_ID) {
594                         country_ie += 3;
595                         country_ie_len -= 3;
596                         continue;
597                 }
598
599                 reg_rule = &rd->reg_rules[i];
600                 freq_range = &reg_rule->freq_range;
601                 power_rule = &reg_rule->power_rule;
602
603                 reg_rule->flags = flags;
604
605                 /* 2 GHz */
606                 if (triplet->chans.first_channel <= 14)
607                         end_channel = triplet->chans.first_channel +
608                                 triplet->chans.num_channels;
609                 else
610                         end_channel =  triplet->chans.first_channel +
611                                 (4 * (triplet->chans.num_channels - 1));
612
613                 /* The +10 is since the regulatory domain expects
614                  * the actual band edge, not the center of freq for
615                  * its start and end freqs, assuming 20 MHz bandwidth on
616                  * the channels passed */
617                 freq_range->start_freq_khz =
618                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
619                                 triplet->chans.first_channel) - 10);
620                 freq_range->end_freq_khz =
621                         MHZ_TO_KHZ(ieee80211_channel_to_frequency(
622                                 end_channel) + 10);
623
624                 /* Large arbitrary values, we intersect later */
625                 /* Increment this if we ever support >= 40 MHz channels
626                  * in IEEE 802.11 */
627                 freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
628                 power_rule->max_antenna_gain = DBI_TO_MBI(100);
629                 power_rule->max_eirp = DBM_TO_MBM(100);
630
631                 country_ie += 3;
632                 country_ie_len -= 3;
633                 i++;
634
635                 BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
636         }
637
638         return rd;
639 }
640
641
642 /* Helper for regdom_intersect(), this does the real
643  * mathematical intersection fun */
644 static int reg_rules_intersect(
645         const struct ieee80211_reg_rule *rule1,
646         const struct ieee80211_reg_rule *rule2,
647         struct ieee80211_reg_rule *intersected_rule)
648 {
649         const struct ieee80211_freq_range *freq_range1, *freq_range2;
650         struct ieee80211_freq_range *freq_range;
651         const struct ieee80211_power_rule *power_rule1, *power_rule2;
652         struct ieee80211_power_rule *power_rule;
653         u32 freq_diff;
654
655         freq_range1 = &rule1->freq_range;
656         freq_range2 = &rule2->freq_range;
657         freq_range = &intersected_rule->freq_range;
658
659         power_rule1 = &rule1->power_rule;
660         power_rule2 = &rule2->power_rule;
661         power_rule = &intersected_rule->power_rule;
662
663         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
664                 freq_range2->start_freq_khz);
665         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
666                 freq_range2->end_freq_khz);
667         freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
668                 freq_range2->max_bandwidth_khz);
669
670         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
671         if (freq_range->max_bandwidth_khz > freq_diff)
672                 freq_range->max_bandwidth_khz = freq_diff;
673
674         power_rule->max_eirp = min(power_rule1->max_eirp,
675                 power_rule2->max_eirp);
676         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
677                 power_rule2->max_antenna_gain);
678
679         intersected_rule->flags = (rule1->flags | rule2->flags);
680
681         if (!is_valid_reg_rule(intersected_rule))
682                 return -EINVAL;
683
684         return 0;
685 }
686
687 /**
688  * regdom_intersect - do the intersection between two regulatory domains
689  * @rd1: first regulatory domain
690  * @rd2: second regulatory domain
691  *
692  * Use this function to get the intersection between two regulatory domains.
693  * Once completed we will mark the alpha2 for the rd as intersected, "98",
694  * as no one single alpha2 can represent this regulatory domain.
695  *
696  * Returns a pointer to the regulatory domain structure which will hold the
697  * resulting intersection of rules between rd1 and rd2. We will
698  * kzalloc() this structure for you.
699  */
700 static struct ieee80211_regdomain *regdom_intersect(
701         const struct ieee80211_regdomain *rd1,
702         const struct ieee80211_regdomain *rd2)
703 {
704         int r, size_of_regd;
705         unsigned int x, y;
706         unsigned int num_rules = 0, rule_idx = 0;
707         const struct ieee80211_reg_rule *rule1, *rule2;
708         struct ieee80211_reg_rule *intersected_rule;
709         struct ieee80211_regdomain *rd;
710         /* This is just a dummy holder to help us count */
711         struct ieee80211_reg_rule irule;
712
713         /* Uses the stack temporarily for counter arithmetic */
714         intersected_rule = &irule;
715
716         memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
717
718         if (!rd1 || !rd2)
719                 return NULL;
720
721         /* First we get a count of the rules we'll need, then we actually
722          * build them. This is to so we can malloc() and free() a
723          * regdomain once. The reason we use reg_rules_intersect() here
724          * is it will return -EINVAL if the rule computed makes no sense.
725          * All rules that do check out OK are valid. */
726
727         for (x = 0; x < rd1->n_reg_rules; x++) {
728                 rule1 = &rd1->reg_rules[x];
729                 for (y = 0; y < rd2->n_reg_rules; y++) {
730                         rule2 = &rd2->reg_rules[y];
731                         if (!reg_rules_intersect(rule1, rule2,
732                                         intersected_rule))
733                                 num_rules++;
734                         memset(intersected_rule, 0,
735                                         sizeof(struct ieee80211_reg_rule));
736                 }
737         }
738
739         if (!num_rules)
740                 return NULL;
741
742         size_of_regd = sizeof(struct ieee80211_regdomain) +
743                 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
744
745         rd = kzalloc(size_of_regd, GFP_KERNEL);
746         if (!rd)
747                 return NULL;
748
749         for (x = 0; x < rd1->n_reg_rules; x++) {
750                 rule1 = &rd1->reg_rules[x];
751                 for (y = 0; y < rd2->n_reg_rules; y++) {
752                         rule2 = &rd2->reg_rules[y];
753                         /* This time around instead of using the stack lets
754                          * write to the target rule directly saving ourselves
755                          * a memcpy() */
756                         intersected_rule = &rd->reg_rules[rule_idx];
757                         r = reg_rules_intersect(rule1, rule2,
758                                 intersected_rule);
759                         /* No need to memset here the intersected rule here as
760                          * we're not using the stack anymore */
761                         if (r)
762                                 continue;
763                         rule_idx++;
764                 }
765         }
766
767         if (rule_idx != num_rules) {
768                 kfree(rd);
769                 return NULL;
770         }
771
772         rd->n_reg_rules = num_rules;
773         rd->alpha2[0] = '9';
774         rd->alpha2[1] = '8';
775
776         return rd;
777 }
778
779 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
780  * want to just have the channel structure use these */
781 static u32 map_regdom_flags(u32 rd_flags)
782 {
783         u32 channel_flags = 0;
784         if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
785                 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
786         if (rd_flags & NL80211_RRF_NO_IBSS)
787                 channel_flags |= IEEE80211_CHAN_NO_IBSS;
788         if (rd_flags & NL80211_RRF_DFS)
789                 channel_flags |= IEEE80211_CHAN_RADAR;
790         return channel_flags;
791 }
792
793 /**
794  * freq_reg_info - get regulatory information for the given frequency
795  * @center_freq: Frequency in KHz for which we want regulatory information for
796  * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
797  *      you can set this to 0. If this frequency is allowed we then set
798  *      this value to the maximum allowed bandwidth.
799  * @reg_rule: the regulatory rule which we have for this frequency
800  *
801  * Use this function to get the regulatory rule for a specific frequency on
802  * a given wireless device. If the device has a specific regulatory domain
803  * it wants to follow we respect that unless a country IE has been received
804  * and processed already.
805  *
806  * Returns 0 if it was able to find a valid regulatory rule which does
807  * apply to the given center_freq otherwise it returns non-zero. It will
808  * also return -ERANGE if we determine the given center_freq does not even have
809  * a regulatory rule for a frequency range in the center_freq's band. See
810  * freq_in_rule_band() for our current definition of a band -- this is purely
811  * subjective and right now its 802.11 specific.
812  */
813 static int freq_reg_info(u32 center_freq, u32 *bandwidth,
814                          const struct ieee80211_reg_rule **reg_rule)
815 {
816         int i;
817         bool band_rule_found = false;
818         u32 max_bandwidth = 0;
819
820         if (!cfg80211_regdomain)
821                 return -EINVAL;
822
823         for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
824                 const struct ieee80211_reg_rule *rr;
825                 const struct ieee80211_freq_range *fr = NULL;
826                 const struct ieee80211_power_rule *pr = NULL;
827
828                 rr = &cfg80211_regdomain->reg_rules[i];
829                 fr = &rr->freq_range;
830                 pr = &rr->power_rule;
831
832                 /* We only need to know if one frequency rule was
833                  * was in center_freq's band, that's enough, so lets
834                  * not overwrite it once found */
835                 if (!band_rule_found)
836                         band_rule_found = freq_in_rule_band(fr, center_freq);
837
838                 max_bandwidth = freq_max_bandwidth(fr, center_freq);
839
840                 if (max_bandwidth && *bandwidth <= max_bandwidth) {
841                         *reg_rule = rr;
842                         *bandwidth = max_bandwidth;
843                         break;
844                 }
845         }
846
847         if (!band_rule_found)
848                 return -ERANGE;
849
850         return !max_bandwidth;
851 }
852
853 static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
854                            unsigned int chan_idx)
855 {
856         int r;
857         u32 flags;
858         u32 max_bandwidth = 0;
859         const struct ieee80211_reg_rule *reg_rule = NULL;
860         const struct ieee80211_power_rule *power_rule = NULL;
861         struct ieee80211_supported_band *sband;
862         struct ieee80211_channel *chan;
863
864         sband = wiphy->bands[band];
865         BUG_ON(chan_idx >= sband->n_channels);
866         chan = &sband->channels[chan_idx];
867
868         flags = chan->orig_flags;
869
870         r = freq_reg_info(MHZ_TO_KHZ(chan->center_freq),
871                 &max_bandwidth, &reg_rule);
872
873         if (r) {
874                 /* This means no regulatory rule was found in the country IE
875                  * with a frequency range on the center_freq's band, since
876                  * IEEE-802.11 allows for a country IE to have a subset of the
877                  * regulatory information provided in a country we ignore
878                  * disabling the channel unless at least one reg rule was
879                  * found on the center_freq's band. For details see this
880                  * clarification:
881                  *
882                  * http://tinyurl.com/11d-clarification
883                  */
884                 if (r == -ERANGE &&
885                     last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
886 #ifdef CONFIG_CFG80211_REG_DEBUG
887                         printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
888                                 "intact on %s - no rule found in band on "
889                                 "Country IE\n",
890                                 chan->center_freq, wiphy_name(wiphy));
891 #endif
892                 } else {
893                 /* In this case we know the country IE has at least one reg rule
894                  * for the band so we respect its band definitions */
895 #ifdef CONFIG_CFG80211_REG_DEBUG
896                         if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
897                                 printk(KERN_DEBUG "cfg80211: Disabling "
898                                         "channel %d MHz on %s due to "
899                                         "Country IE\n",
900                                         chan->center_freq, wiphy_name(wiphy));
901 #endif
902                         flags |= IEEE80211_CHAN_DISABLED;
903                         chan->flags = flags;
904                 }
905                 return;
906         }
907
908         power_rule = &reg_rule->power_rule;
909
910         chan->flags = flags | map_regdom_flags(reg_rule->flags);
911         chan->max_antenna_gain = min(chan->orig_mag,
912                 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
913         chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
914         if (chan->orig_mpwr)
915                 chan->max_power = min(chan->orig_mpwr,
916                         (int) MBM_TO_DBM(power_rule->max_eirp));
917         else
918                 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
919 }
920
921 static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
922 {
923         unsigned int i;
924         struct ieee80211_supported_band *sband;
925
926         BUG_ON(!wiphy->bands[band]);
927         sband = wiphy->bands[band];
928
929         for (i = 0; i < sband->n_channels; i++)
930                 handle_channel(wiphy, band, i);
931 }
932
933 static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
934 {
935         if (!last_request)
936                 return true;
937         if (setby == REGDOM_SET_BY_CORE &&
938                   wiphy->fw_handles_regulatory)
939                 return true;
940         return false;
941 }
942
943 static void update_all_wiphy_regulatory(enum reg_set_by setby)
944 {
945         struct cfg80211_registered_device *drv;
946
947         list_for_each_entry(drv, &cfg80211_drv_list, list)
948                 if (!ignore_reg_update(&drv->wiphy, setby))
949                         wiphy_update_regulatory(&drv->wiphy, setby);
950 }
951
952 void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby)
953 {
954         enum ieee80211_band band;
955         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
956                 if (wiphy->bands[band])
957                         handle_band(wiphy, band);
958                 if (wiphy->reg_notifier)
959                         wiphy->reg_notifier(wiphy, setby);
960         }
961 }
962
963 /* Return value which can be used by ignore_request() to indicate
964  * it has been determined we should intersect two regulatory domains */
965 #define REG_INTERSECT   1
966
967 /* This has the logic which determines when a new request
968  * should be ignored. */
969 static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
970                           const char *alpha2)
971 {
972         /* All initial requests are respected */
973         if (!last_request)
974                 return 0;
975
976         switch (set_by) {
977         case REGDOM_SET_BY_INIT:
978                 return -EINVAL;
979         case REGDOM_SET_BY_CORE:
980                 /*
981                  * Always respect new wireless core hints, should only happen
982                  * when updating the world regulatory domain at init.
983                  */
984                 return 0;
985         case REGDOM_SET_BY_COUNTRY_IE:
986                 if (unlikely(!is_an_alpha2(alpha2)))
987                         return -EINVAL;
988                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
989                         if (last_request->wiphy != wiphy) {
990                                 /*
991                                  * Two cards with two APs claiming different
992                                  * different Country IE alpha2s. We could
993                                  * intersect them, but that seems unlikely
994                                  * to be correct. Reject second one for now.
995                                  */
996                                 if (!alpha2_equal(alpha2,
997                                                   cfg80211_regdomain->alpha2))
998                                         return -EOPNOTSUPP;
999                                 return -EALREADY;
1000                         }
1001                         /* Two consecutive Country IE hints on the same wiphy.
1002                          * This should be picked up early by the driver/stack */
1003                         if (WARN_ON(!alpha2_equal(cfg80211_regdomain->alpha2,
1004                                   alpha2)))
1005                                 return 0;
1006                         return -EALREADY;
1007                 }
1008                 return REG_INTERSECT;
1009         case REGDOM_SET_BY_DRIVER:
1010                 if (last_request->initiator == REGDOM_SET_BY_DRIVER)
1011                         return -EALREADY;
1012                 return 0;
1013         case REGDOM_SET_BY_USER:
1014                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
1015                         return REG_INTERSECT;
1016                 /* If the user knows better the user should set the regdom
1017                  * to their country before the IE is picked up */
1018                 if (last_request->initiator == REGDOM_SET_BY_USER &&
1019                           last_request->intersect)
1020                         return -EOPNOTSUPP;
1021                 return 0;
1022         }
1023
1024         return -EINVAL;
1025 }
1026
1027 /* Caller must hold &cfg80211_drv_mutex */
1028 int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
1029                         const char *alpha2,
1030                         u32 country_ie_checksum,
1031                         enum environment_cap env)
1032 {
1033         struct regulatory_request *request;
1034         bool intersect = false;
1035         int r = 0;
1036
1037         r = ignore_request(wiphy, set_by, alpha2);
1038
1039         if (r == REG_INTERSECT)
1040                 intersect = true;
1041         else if (r)
1042                 return r;
1043
1044         request = kzalloc(sizeof(struct regulatory_request),
1045                           GFP_KERNEL);
1046         if (!request)
1047                 return -ENOMEM;
1048
1049         request->alpha2[0] = alpha2[0];
1050         request->alpha2[1] = alpha2[1];
1051         request->initiator = set_by;
1052         request->wiphy = wiphy;
1053         request->intersect = intersect;
1054         request->country_ie_checksum = country_ie_checksum;
1055         request->country_ie_env = env;
1056
1057         kfree(last_request);
1058         last_request = request;
1059         /*
1060          * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
1061          * AND if CRDA is NOT present nothing will happen, if someone
1062          * wants to bother with 11d with OLD_REG you can add a timer.
1063          * If after x amount of time nothing happens you can call:
1064          *
1065          * return set_regdom(country_ie_regdomain);
1066          *
1067          * to intersect with the static rd
1068          */
1069         return call_crda(alpha2);
1070 }
1071
1072 void regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1073 {
1074         BUG_ON(!alpha2);
1075
1076         mutex_lock(&cfg80211_drv_mutex);
1077         __regulatory_hint(wiphy, REGDOM_SET_BY_DRIVER, alpha2, 0, ENVIRON_ANY);
1078         mutex_unlock(&cfg80211_drv_mutex);
1079 }
1080 EXPORT_SYMBOL(regulatory_hint);
1081
1082 static bool reg_same_country_ie_hint(struct wiphy *wiphy,
1083                         u32 country_ie_checksum)
1084 {
1085         if (!last_request->wiphy)
1086                 return false;
1087         if (likely(last_request->wiphy != wiphy))
1088                 return !country_ie_integrity_changes(country_ie_checksum);
1089         /* We should not have let these through at this point, they
1090          * should have been picked up earlier by the first alpha2 check
1091          * on the device */
1092         if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
1093                 return true;
1094         return false;
1095 }
1096
1097 void regulatory_hint_11d(struct wiphy *wiphy,
1098                         u8 *country_ie,
1099                         u8 country_ie_len)
1100 {
1101         struct ieee80211_regdomain *rd = NULL;
1102         char alpha2[2];
1103         u32 checksum = 0;
1104         enum environment_cap env = ENVIRON_ANY;
1105
1106         if (!last_request)
1107                 return;
1108
1109         mutex_lock(&cfg80211_drv_mutex);
1110
1111         /* IE len must be evenly divisible by 2 */
1112         if (country_ie_len & 0x01)
1113                 goto out;
1114
1115         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1116                 goto out;
1117
1118         /* Pending country IE processing, this can happen after we
1119          * call CRDA and wait for a response if a beacon was received before
1120          * we were able to process the last regulatory_hint_11d() call */
1121         if (country_ie_regdomain)
1122                 goto out;
1123
1124         alpha2[0] = country_ie[0];
1125         alpha2[1] = country_ie[1];
1126
1127         if (country_ie[2] == 'I')
1128                 env = ENVIRON_INDOOR;
1129         else if (country_ie[2] == 'O')
1130                 env = ENVIRON_OUTDOOR;
1131
1132         /* We will run this for *every* beacon processed for the BSSID, so
1133          * we optimize an early check to exit out early if we don't have to
1134          * do anything */
1135         if (likely(last_request->wiphy)) {
1136                 struct cfg80211_registered_device *drv_last_ie;
1137
1138                 drv_last_ie = wiphy_to_dev(last_request->wiphy);
1139
1140                 /* Lets keep this simple -- we trust the first AP
1141                  * after we intersect with CRDA */
1142                 if (likely(last_request->wiphy == wiphy)) {
1143                         /* Ignore IEs coming in on this wiphy with
1144                          * the same alpha2 and environment cap */
1145                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1146                                   alpha2) &&
1147                                   env == drv_last_ie->env)) {
1148                                 goto out;
1149                         }
1150                         /* the wiphy moved on to another BSSID or the AP
1151                          * was reconfigured. XXX: We need to deal with the
1152                          * case where the user suspends and goes to goes
1153                          * to another country, and then gets IEs from an
1154                          * AP with different settings */
1155                         goto out;
1156                 } else {
1157                         /* Ignore IEs coming in on two separate wiphys with
1158                          * the same alpha2 and environment cap */
1159                         if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1160                                   alpha2) &&
1161                                   env == drv_last_ie->env)) {
1162                                 goto out;
1163                         }
1164                         /* We could potentially intersect though */
1165                         goto out;
1166                 }
1167         }
1168
1169         rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
1170         if (!rd)
1171                 goto out;
1172
1173         /* This will not happen right now but we leave it here for the
1174          * the future when we want to add suspend/resume support and having
1175          * the user move to another country after doing so, or having the user
1176          * move to another AP. Right now we just trust the first AP. This is why
1177          * this is marked as likley(). If we hit this before we add this support
1178          * we want to be informed of it as it would indicate a mistake in the
1179          * current design  */
1180         if (likely(WARN_ON(reg_same_country_ie_hint(wiphy, checksum))))
1181                 goto out;
1182
1183         /* We keep this around for when CRDA comes back with a response so
1184          * we can intersect with that */
1185         country_ie_regdomain = rd;
1186
1187         __regulatory_hint(wiphy, REGDOM_SET_BY_COUNTRY_IE,
1188                 country_ie_regdomain->alpha2, checksum, env);
1189
1190 out:
1191         mutex_unlock(&cfg80211_drv_mutex);
1192 }
1193 EXPORT_SYMBOL(regulatory_hint_11d);
1194
1195 static void print_rd_rules(const struct ieee80211_regdomain *rd)
1196 {
1197         unsigned int i;
1198         const struct ieee80211_reg_rule *reg_rule = NULL;
1199         const struct ieee80211_freq_range *freq_range = NULL;
1200         const struct ieee80211_power_rule *power_rule = NULL;
1201
1202         printk(KERN_INFO "\t(start_freq - end_freq @ bandwidth), "
1203                 "(max_antenna_gain, max_eirp)\n");
1204
1205         for (i = 0; i < rd->n_reg_rules; i++) {
1206                 reg_rule = &rd->reg_rules[i];
1207                 freq_range = &reg_rule->freq_range;
1208                 power_rule = &reg_rule->power_rule;
1209
1210                 /* There may not be documentation for max antenna gain
1211                  * in certain regions */
1212                 if (power_rule->max_antenna_gain)
1213                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1214                                 "(%d mBi, %d mBm)\n",
1215                                 freq_range->start_freq_khz,
1216                                 freq_range->end_freq_khz,
1217                                 freq_range->max_bandwidth_khz,
1218                                 power_rule->max_antenna_gain,
1219                                 power_rule->max_eirp);
1220                 else
1221                         printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1222                                 "(N/A, %d mBm)\n",
1223                                 freq_range->start_freq_khz,
1224                                 freq_range->end_freq_khz,
1225                                 freq_range->max_bandwidth_khz,
1226                                 power_rule->max_eirp);
1227         }
1228 }
1229
1230 static void print_regdomain(const struct ieee80211_regdomain *rd)
1231 {
1232
1233         if (is_intersected_alpha2(rd->alpha2)) {
1234                 struct wiphy *wiphy = NULL;
1235                 struct cfg80211_registered_device *drv;
1236
1237                 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1238                         if (last_request->wiphy) {
1239                                 wiphy = last_request->wiphy;
1240                                 drv = wiphy_to_dev(wiphy);
1241                                 printk(KERN_INFO "cfg80211: Current regulatory "
1242                                         "domain updated by AP to: %c%c\n",
1243                                         drv->country_ie_alpha2[0],
1244                                         drv->country_ie_alpha2[1]);
1245                         } else
1246                                 printk(KERN_INFO "cfg80211: Current regulatory "
1247                                         "domain intersected: \n");
1248                 } else
1249                                 printk(KERN_INFO "cfg80211: Current regulatory "
1250                                         "intersected: \n");
1251         } else if (is_world_regdom(rd->alpha2))
1252                 printk(KERN_INFO "cfg80211: World regulatory "
1253                         "domain updated:\n");
1254         else {
1255                 if (is_unknown_alpha2(rd->alpha2))
1256                         printk(KERN_INFO "cfg80211: Regulatory domain "
1257                                 "changed to driver built-in settings "
1258                                 "(unknown country)\n");
1259                 else
1260                         printk(KERN_INFO "cfg80211: Regulatory domain "
1261                                 "changed to country: %c%c\n",
1262                                 rd->alpha2[0], rd->alpha2[1]);
1263         }
1264         print_rd_rules(rd);
1265 }
1266
1267 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
1268 {
1269         printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
1270                 rd->alpha2[0], rd->alpha2[1]);
1271         print_rd_rules(rd);
1272 }
1273
1274 #ifdef CONFIG_CFG80211_REG_DEBUG
1275 static void reg_country_ie_process_debug(
1276         const struct ieee80211_regdomain *rd,
1277         const struct ieee80211_regdomain *country_ie_regdomain,
1278         const struct ieee80211_regdomain *intersected_rd)
1279 {
1280         printk(KERN_DEBUG "cfg80211: Received country IE:\n");
1281         print_regdomain_info(country_ie_regdomain);
1282         printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
1283         print_regdomain_info(rd);
1284         if (intersected_rd) {
1285                 printk(KERN_DEBUG "cfg80211: We intersect both of these "
1286                         "and get:\n");
1287                 print_regdomain_info(intersected_rd);
1288                 return;
1289         }
1290         printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
1291 }
1292 #else
1293 static inline void reg_country_ie_process_debug(
1294         const struct ieee80211_regdomain *rd,
1295         const struct ieee80211_regdomain *country_ie_regdomain,
1296         const struct ieee80211_regdomain *intersected_rd)
1297 {
1298 }
1299 #endif
1300
1301 /* Takes ownership of rd only if it doesn't fail */
1302 static int __set_regdom(const struct ieee80211_regdomain *rd)
1303 {
1304         const struct ieee80211_regdomain *intersected_rd = NULL;
1305         struct cfg80211_registered_device *drv = NULL;
1306         struct wiphy *wiphy = NULL;
1307         /* Some basic sanity checks first */
1308
1309         if (is_world_regdom(rd->alpha2)) {
1310                 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1311                         return -EINVAL;
1312                 update_world_regdomain(rd);
1313                 return 0;
1314         }
1315
1316         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
1317                         !is_unknown_alpha2(rd->alpha2))
1318                 return -EINVAL;
1319
1320         if (!last_request)
1321                 return -EINVAL;
1322
1323         /* Lets only bother proceeding on the same alpha2 if the current
1324          * rd is non static (it means CRDA was present and was used last)
1325          * and the pending request came in from a country IE */
1326         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1327                 /* If someone else asked us to change the rd lets only bother
1328                  * checking if the alpha2 changes if CRDA was already called */
1329                 if (!is_old_static_regdom(cfg80211_regdomain) &&
1330                     !regdom_changed(rd->alpha2))
1331                         return -EINVAL;
1332         }
1333
1334         wiphy = last_request->wiphy;
1335
1336         /* Now lets set the regulatory domain, update all driver channels
1337          * and finally inform them of what we have done, in case they want
1338          * to review or adjust their own settings based on their own
1339          * internal EEPROM data */
1340
1341         if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1342                 return -EINVAL;
1343
1344         if (!is_valid_rd(rd)) {
1345                 printk(KERN_ERR "cfg80211: Invalid "
1346                         "regulatory domain detected:\n");
1347                 print_regdomain_info(rd);
1348                 return -EINVAL;
1349         }
1350
1351         if (!last_request->intersect) {
1352                 reset_regdomains();
1353                 cfg80211_regdomain = rd;
1354                 return 0;
1355         }
1356
1357         /* Intersection requires a bit more work */
1358
1359         if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1360
1361                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1362                 if (!intersected_rd)
1363                         return -EINVAL;
1364
1365                 /* We can trash what CRDA provided now */
1366                 kfree(rd);
1367                 rd = NULL;
1368
1369                 reset_regdomains();
1370                 cfg80211_regdomain = intersected_rd;
1371
1372                 return 0;
1373         }
1374
1375         /*
1376          * Country IE requests are handled a bit differently, we intersect
1377          * the country IE rd with what CRDA believes that country should have
1378          */
1379
1380         BUG_ON(!country_ie_regdomain);
1381
1382         if (rd != country_ie_regdomain) {
1383                 /* Intersect what CRDA returned and our what we
1384                  * had built from the Country IE received */
1385
1386                 intersected_rd = regdom_intersect(rd, country_ie_regdomain);
1387
1388                 reg_country_ie_process_debug(rd, country_ie_regdomain,
1389                         intersected_rd);
1390
1391                 kfree(country_ie_regdomain);
1392                 country_ie_regdomain = NULL;
1393         } else {
1394                 /* This would happen when CRDA was not present and
1395                  * OLD_REGULATORY was enabled. We intersect our Country
1396                  * IE rd and what was set on cfg80211 originally */
1397                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1398         }
1399
1400         if (!intersected_rd)
1401                 return -EINVAL;
1402
1403         drv = wiphy_to_dev(wiphy);
1404
1405         drv->country_ie_alpha2[0] = rd->alpha2[0];
1406         drv->country_ie_alpha2[1] = rd->alpha2[1];
1407         drv->env = last_request->country_ie_env;
1408
1409         BUG_ON(intersected_rd == rd);
1410
1411         kfree(rd);
1412         rd = NULL;
1413
1414         reset_regdomains();
1415         cfg80211_regdomain = intersected_rd;
1416
1417         return 0;
1418 }
1419
1420
1421 /* Use this call to set the current regulatory domain. Conflicts with
1422  * multiple drivers can be ironed out later. Caller must've already
1423  * kmalloc'd the rd structure. Caller must hold cfg80211_drv_mutex */
1424 int set_regdom(const struct ieee80211_regdomain *rd)
1425 {
1426         int r;
1427
1428         /* Note that this doesn't update the wiphys, this is done below */
1429         r = __set_regdom(rd);
1430         if (r) {
1431                 kfree(rd);
1432                 return r;
1433         }
1434
1435         /* This would make this whole thing pointless */
1436         if (!last_request->intersect)
1437                 BUG_ON(rd != cfg80211_regdomain);
1438
1439         /* update all wiphys now with the new established regulatory domain */
1440         update_all_wiphy_regulatory(last_request->initiator);
1441
1442         print_regdomain(cfg80211_regdomain);
1443
1444         return r;
1445 }
1446
1447 /* Caller must hold cfg80211_drv_mutex */
1448 void reg_device_remove(struct wiphy *wiphy)
1449 {
1450         if (!last_request || !last_request->wiphy)
1451                 return;
1452         if (last_request->wiphy != wiphy)
1453                 return;
1454         last_request->wiphy = NULL;
1455         last_request->country_ie_env = ENVIRON_ANY;
1456 }
1457
1458 int regulatory_init(void)
1459 {
1460         int err;
1461
1462         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
1463         if (IS_ERR(reg_pdev))
1464                 return PTR_ERR(reg_pdev);
1465
1466 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
1467         cfg80211_regdomain = static_regdom(ieee80211_regdom);
1468
1469         printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
1470         print_regdomain_info(cfg80211_regdomain);
1471         /* The old code still requests for a new regdomain and if
1472          * you have CRDA you get it updated, otherwise you get
1473          * stuck with the static values. We ignore "EU" code as
1474          * that is not a valid ISO / IEC 3166 alpha2 */
1475         if (ieee80211_regdom[0] != 'E' || ieee80211_regdom[1] != 'U')
1476                 err = __regulatory_hint(NULL, REGDOM_SET_BY_CORE,
1477                                         ieee80211_regdom, 0, ENVIRON_ANY);
1478 #else
1479         cfg80211_regdomain = cfg80211_world_regdom;
1480
1481         err = __regulatory_hint(NULL, REGDOM_SET_BY_CORE, "00", 0, ENVIRON_ANY);
1482         if (err)
1483                 printk(KERN_ERR "cfg80211: calling CRDA failed - "
1484                        "unable to update world regulatory domain, "
1485                        "using static definition\n");
1486 #endif
1487
1488         return 0;
1489 }
1490
1491 void regulatory_exit(void)
1492 {
1493         mutex_lock(&cfg80211_drv_mutex);
1494
1495         reset_regdomains();
1496
1497         kfree(country_ie_regdomain);
1498         country_ie_regdomain = NULL;
1499
1500         kfree(last_request);
1501
1502         platform_device_unregister(reg_pdev);
1503
1504         mutex_unlock(&cfg80211_drv_mutex);
1505 }