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