linux/net/wireless/reg.c
<<
>>
Prefs
   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-2011  Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
   6 *
   7 * Permission to use, copy, modify, and/or distribute this software for any
   8 * purpose with or without fee is hereby granted, provided that the above
   9 * copyright notice and this permission notice appear in all copies.
  10 *
  11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18 */
  19
  20
  21/**
  22 * DOC: Wireless regulatory infrastructure
  23 *
  24 * The usual implementation is for a driver to read a device EEPROM to
  25 * determine which regulatory domain it should be operating under, then
  26 * looking up the allowable channels in a driver-local table and finally
  27 * registering those channels in the wiphy structure.
  28 *
  29 * Another set of compliance enforcement is for drivers to use their
  30 * own compliance limits which can be stored on the EEPROM. The host
  31 * driver or firmware may ensure these are used.
  32 *
  33 * In addition to all this we provide an extra layer of regulatory
  34 * conformance. For drivers which do not have any regulatory
  35 * information CRDA provides the complete regulatory solution.
  36 * For others it provides a community effort on further restrictions
  37 * to enhance compliance.
  38 *
  39 * Note: When number of rules --> infinity we will not be able to
  40 * index on alpha2 any more, instead we'll probably have to
  41 * rely on some SHA1 checksum of the regdomain for example.
  42 *
  43 */
  44
  45#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  46
  47#include <linux/kernel.h>
  48#include <linux/export.h>
  49#include <linux/slab.h>
  50#include <linux/list.h>
  51#include <linux/random.h>
  52#include <linux/ctype.h>
  53#include <linux/nl80211.h>
  54#include <linux/platform_device.h>
  55#include <linux/moduleparam.h>
  56#include <net/cfg80211.h>
  57#include "core.h"
  58#include "reg.h"
  59#include "regdb.h"
  60#include "nl80211.h"
  61
  62#ifdef CONFIG_CFG80211_REG_DEBUG
  63#define REG_DBG_PRINT(format, args...)                  \
  64        printk(KERN_DEBUG pr_fmt(format), ##args)
  65#else
  66#define REG_DBG_PRINT(args...)
  67#endif
  68
  69static struct regulatory_request core_request_world = {
  70        .initiator = NL80211_REGDOM_SET_BY_CORE,
  71        .alpha2[0] = '0',
  72        .alpha2[1] = '0',
  73        .intersect = false,
  74        .processed = true,
  75        .country_ie_env = ENVIRON_ANY,
  76};
  77
  78/* Receipt of information from last regulatory request */
  79static struct regulatory_request *last_request = &core_request_world;
  80
  81/* To trigger userspace events */
  82static struct platform_device *reg_pdev;
  83
  84static struct device_type reg_device_type = {
  85        .uevent = reg_device_uevent,
  86};
  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 */
  93const struct ieee80211_regdomain *cfg80211_regdomain;
  94
  95/*
  96 * Protects static reg.c components:
  97 *     - cfg80211_world_regdom
  98 *     - cfg80211_regdom
  99 *     - last_request
 100 *     - reg_num_devs_support_basehint
 101 */
 102static DEFINE_MUTEX(reg_mutex);
 103
 104/*
 105 * Number of devices that registered to the core
 106 * that support cellular base station regulatory hints
 107 */
 108static int reg_num_devs_support_basehint;
 109
 110static inline void assert_reg_lock(void)
 111{
 112        lockdep_assert_held(&reg_mutex);
 113}
 114
 115/* Used to queue up regulatory hints */
 116static LIST_HEAD(reg_requests_list);
 117static spinlock_t reg_requests_lock;
 118
 119/* Used to queue up beacon hints for review */
 120static LIST_HEAD(reg_pending_beacons);
 121static spinlock_t reg_pending_beacons_lock;
 122
 123/* Used to keep track of processed beacon hints */
 124static LIST_HEAD(reg_beacon_list);
 125
 126struct reg_beacon {
 127        struct list_head list;
 128        struct ieee80211_channel chan;
 129};
 130
 131static void reg_todo(struct work_struct *work);
 132static DECLARE_WORK(reg_work, reg_todo);
 133
 134static void reg_timeout_work(struct work_struct *work);
 135static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
 136
 137/* We keep a static world regulatory domain in case of the absence of CRDA */
 138static const struct ieee80211_regdomain world_regdom = {
 139        .n_reg_rules = 6,
 140        .alpha2 =  "00",
 141        .reg_rules = {
 142                /* IEEE 802.11b/g, channels 1..11 */
 143                REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
 144                /* IEEE 802.11b/g, channels 12..13. */
 145                REG_RULE(2467-10, 2472+10, 40, 6, 20,
 146                        NL80211_RRF_PASSIVE_SCAN |
 147                        NL80211_RRF_NO_IBSS),
 148                /* IEEE 802.11 channel 14 - Only JP enables
 149                 * this and for 802.11b only */
 150                REG_RULE(2484-10, 2484+10, 20, 6, 20,
 151                        NL80211_RRF_PASSIVE_SCAN |
 152                        NL80211_RRF_NO_IBSS |
 153                        NL80211_RRF_NO_OFDM),
 154                /* IEEE 802.11a, channel 36..48 */
 155                REG_RULE(5180-10, 5240+10, 40, 6, 20,
 156                        NL80211_RRF_PASSIVE_SCAN |
 157                        NL80211_RRF_NO_IBSS),
 158
 159                /* NB: 5260 MHz - 5700 MHz requies DFS */
 160
 161                /* IEEE 802.11a, channel 149..165 */
 162                REG_RULE(5745-10, 5825+10, 40, 6, 20,
 163                        NL80211_RRF_PASSIVE_SCAN |
 164                        NL80211_RRF_NO_IBSS),
 165
 166                /* IEEE 802.11ad (60gHz), channels 1..3 */
 167                REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
 168        }
 169};
 170
 171static const struct ieee80211_regdomain *cfg80211_world_regdom =
 172        &world_regdom;
 173
 174static char *ieee80211_regdom = "00";
 175static char user_alpha2[2];
 176
 177module_param(ieee80211_regdom, charp, 0444);
 178MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 179
 180static void reset_regdomains(bool full_reset)
 181{
 182        /* avoid freeing static information or freeing something twice */
 183        if (cfg80211_regdomain == cfg80211_world_regdom)
 184                cfg80211_regdomain = NULL;
 185        if (cfg80211_world_regdom == &world_regdom)
 186                cfg80211_world_regdom = NULL;
 187        if (cfg80211_regdomain == &world_regdom)
 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        if (!full_reset)
 197                return;
 198
 199        if (last_request != &core_request_world)
 200                kfree(last_request);
 201        last_request = &core_request_world;
 202}
 203
 204/*
 205 * Dynamic world regulatory domain requested by the wireless
 206 * core upon initialization
 207 */
 208static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 209{
 210        BUG_ON(!last_request);
 211
 212        reset_regdomains(false);
 213
 214        cfg80211_world_regdom = rd;
 215        cfg80211_regdomain = rd;
 216}
 217
 218bool is_world_regdom(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
 227static bool is_alpha2_set(const char *alpha2)
 228{
 229        if (!alpha2)
 230                return false;
 231        if (alpha2[0] != 0 && alpha2[1] != 0)
 232                return true;
 233        return false;
 234}
 235
 236static bool is_unknown_alpha2(const char *alpha2)
 237{
 238        if (!alpha2)
 239                return false;
 240        /*
 241         * Special case where regulatory domain was built by driver
 242         * but a specific alpha2 cannot be determined
 243         */
 244        if (alpha2[0] == '9' && alpha2[1] == '9')
 245                return true;
 246        return false;
 247}
 248
 249static bool is_intersected_alpha2(const char *alpha2)
 250{
 251        if (!alpha2)
 252                return false;
 253        /*
 254         * Special case where regulatory domain is the
 255         * result of an intersection between two regulatory domain
 256         * structures
 257         */
 258        if (alpha2[0] == '9' && alpha2[1] == '8')
 259                return true;
 260        return false;
 261}
 262
 263static bool is_an_alpha2(const char *alpha2)
 264{
 265        if (!alpha2)
 266                return false;
 267        if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
 268                return true;
 269        return false;
 270}
 271
 272static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
 273{
 274        if (!alpha2_x || !alpha2_y)
 275                return false;
 276        if (alpha2_x[0] == alpha2_y[0] &&
 277                alpha2_x[1] == alpha2_y[1])
 278                return true;
 279        return false;
 280}
 281
 282static bool regdom_changes(const char *alpha2)
 283{
 284        assert_cfg80211_lock();
 285
 286        if (!cfg80211_regdomain)
 287                return true;
 288        if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
 289                return false;
 290        return true;
 291}
 292
 293/*
 294 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
 295 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
 296 * has ever been issued.
 297 */
 298static bool is_user_regdom_saved(void)
 299{
 300        if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
 301                return false;
 302
 303        /* This would indicate a mistake on the design */
 304        if (WARN((!is_world_regdom(user_alpha2) &&
 305                  !is_an_alpha2(user_alpha2)),
 306                 "Unexpected user alpha2: %c%c\n",
 307                 user_alpha2[0],
 308                 user_alpha2[1]))
 309                return false;
 310
 311        return true;
 312}
 313
 314static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
 315                         const struct ieee80211_regdomain *src_regd)
 316{
 317        struct ieee80211_regdomain *regd;
 318        int size_of_regd = 0;
 319        unsigned int i;
 320
 321        size_of_regd = sizeof(struct ieee80211_regdomain) +
 322          ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
 323
 324        regd = kzalloc(size_of_regd, GFP_KERNEL);
 325        if (!regd)
 326                return -ENOMEM;
 327
 328        memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
 329
 330        for (i = 0; i < src_regd->n_reg_rules; i++)
 331                memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
 332                        sizeof(struct ieee80211_reg_rule));
 333
 334        *dst_regd = regd;
 335        return 0;
 336}
 337
 338#ifdef CONFIG_CFG80211_INTERNAL_REGDB
 339struct reg_regdb_search_request {
 340        char alpha2[2];
 341        struct list_head list;
 342};
 343
 344static LIST_HEAD(reg_regdb_search_list);
 345static DEFINE_MUTEX(reg_regdb_search_mutex);
 346
 347static void reg_regdb_search(struct work_struct *work)
 348{
 349        struct reg_regdb_search_request *request;
 350        const struct ieee80211_regdomain *curdom, *regdom;
 351        int i, r;
 352        bool set_reg = false;
 353
 354        mutex_lock(&cfg80211_mutex);
 355
 356        mutex_lock(&reg_regdb_search_mutex);
 357        while (!list_empty(&reg_regdb_search_list)) {
 358                request = list_first_entry(&reg_regdb_search_list,
 359                                           struct reg_regdb_search_request,
 360                                           list);
 361                list_del(&request->list);
 362
 363                for (i=0; i<reg_regdb_size; i++) {
 364                        curdom = reg_regdb[i];
 365
 366                        if (!memcmp(request->alpha2, curdom->alpha2, 2)) {
 367                                r = reg_copy_regd(&regdom, curdom);
 368                                if (r)
 369                                        break;
 370                                set_reg = true;
 371                                break;
 372                        }
 373                }
 374
 375                kfree(request);
 376        }
 377        mutex_unlock(&reg_regdb_search_mutex);
 378
 379        if (set_reg)
 380                set_regdom(regdom);
 381
 382        mutex_unlock(&cfg80211_mutex);
 383}
 384
 385static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
 386
 387static void reg_regdb_query(const char *alpha2)
 388{
 389        struct reg_regdb_search_request *request;
 390
 391        if (!alpha2)
 392                return;
 393
 394        request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
 395        if (!request)
 396                return;
 397
 398        memcpy(request->alpha2, alpha2, 2);
 399
 400        mutex_lock(&reg_regdb_search_mutex);
 401        list_add_tail(&request->list, &reg_regdb_search_list);
 402        mutex_unlock(&reg_regdb_search_mutex);
 403
 404        schedule_work(&reg_regdb_work);
 405}
 406
 407/* Feel free to add any other sanity checks here */
 408static void reg_regdb_size_check(void)
 409{
 410        /* We should ideally BUILD_BUG_ON() but then random builds would fail */
 411        WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
 412}
 413#else
 414static inline void reg_regdb_size_check(void) {}
 415static inline void reg_regdb_query(const char *alpha2) {}
 416#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
 417
 418/*
 419 * This lets us keep regulatory code which is updated on a regulatory
 420 * basis in userspace. Country information is filled in by
 421 * reg_device_uevent
 422 */
 423static int call_crda(const char *alpha2)
 424{
 425        if (!is_world_regdom((char *) alpha2))
 426                pr_info("Calling CRDA for country: %c%c\n",
 427                        alpha2[0], alpha2[1]);
 428        else
 429                pr_info("Calling CRDA to update world regulatory domain\n");
 430
 431        /* query internal regulatory database (if it exists) */
 432        reg_regdb_query(alpha2);
 433
 434        return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
 435}
 436
 437/* Used by nl80211 before kmalloc'ing our regulatory domain */
 438bool reg_is_valid_request(const char *alpha2)
 439{
 440        assert_cfg80211_lock();
 441
 442        if (!last_request)
 443                return false;
 444
 445        return alpha2_equal(last_request->alpha2, alpha2);
 446}
 447
 448/* Sanity check on a regulatory rule */
 449static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
 450{
 451        const struct ieee80211_freq_range *freq_range = &rule->freq_range;
 452        u32 freq_diff;
 453
 454        if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
 455                return false;
 456
 457        if (freq_range->start_freq_khz > freq_range->end_freq_khz)
 458                return false;
 459
 460        freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 461
 462        if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
 463                        freq_range->max_bandwidth_khz > freq_diff)
 464                return false;
 465
 466        return true;
 467}
 468
 469static bool is_valid_rd(const struct ieee80211_regdomain *rd)
 470{
 471        const struct ieee80211_reg_rule *reg_rule = NULL;
 472        unsigned int i;
 473
 474        if (!rd->n_reg_rules)
 475                return false;
 476
 477        if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 478                return false;
 479
 480        for (i = 0; i < rd->n_reg_rules; i++) {
 481                reg_rule = &rd->reg_rules[i];
 482                if (!is_valid_reg_rule(reg_rule))
 483                        return false;
 484        }
 485
 486        return true;
 487}
 488
 489static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
 490                            u32 center_freq_khz,
 491                            u32 bw_khz)
 492{
 493        u32 start_freq_khz, end_freq_khz;
 494
 495        start_freq_khz = center_freq_khz - (bw_khz/2);
 496        end_freq_khz = center_freq_khz + (bw_khz/2);
 497
 498        if (start_freq_khz >= freq_range->start_freq_khz &&
 499            end_freq_khz <= freq_range->end_freq_khz)
 500                return true;
 501
 502        return false;
 503}
 504
 505/**
 506 * freq_in_rule_band - tells us if a frequency is in a frequency band
 507 * @freq_range: frequency rule we want to query
 508 * @freq_khz: frequency we are inquiring about
 509 *
 510 * This lets us know if a specific frequency rule is or is not relevant to
 511 * a specific frequency's band. Bands are device specific and artificial
 512 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
 513 * however it is safe for now to assume that a frequency rule should not be
 514 * part of a frequency's band if the start freq or end freq are off by more
 515 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
 516 * 60 GHz band.
 517 * This resolution can be lowered and should be considered as we add
 518 * regulatory rule support for other "bands".
 519 **/
 520static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 521        u32 freq_khz)
 522{
 523#define ONE_GHZ_IN_KHZ  1000000
 524        /*
 525         * From 802.11ad: directional multi-gigabit (DMG):
 526         * Pertaining to operation in a frequency band containing a channel
 527         * with the Channel starting frequency above 45 GHz.
 528         */
 529        u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
 530                        10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
 531        if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
 532                return true;
 533        if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
 534                return true;
 535        return false;
 536#undef ONE_GHZ_IN_KHZ
 537}
 538
 539/*
 540 * Helper for regdom_intersect(), this does the real
 541 * mathematical intersection fun
 542 */
 543static int reg_rules_intersect(
 544        const struct ieee80211_reg_rule *rule1,
 545        const struct ieee80211_reg_rule *rule2,
 546        struct ieee80211_reg_rule *intersected_rule)
 547{
 548        const struct ieee80211_freq_range *freq_range1, *freq_range2;
 549        struct ieee80211_freq_range *freq_range;
 550        const struct ieee80211_power_rule *power_rule1, *power_rule2;
 551        struct ieee80211_power_rule *power_rule;
 552        u32 freq_diff;
 553
 554        freq_range1 = &rule1->freq_range;
 555        freq_range2 = &rule2->freq_range;
 556        freq_range = &intersected_rule->freq_range;
 557
 558        power_rule1 = &rule1->power_rule;
 559        power_rule2 = &rule2->power_rule;
 560        power_rule = &intersected_rule->power_rule;
 561
 562        freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
 563                freq_range2->start_freq_khz);
 564        freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
 565                freq_range2->end_freq_khz);
 566        freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
 567                freq_range2->max_bandwidth_khz);
 568
 569        freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
 570        if (freq_range->max_bandwidth_khz > freq_diff)
 571                freq_range->max_bandwidth_khz = freq_diff;
 572
 573        power_rule->max_eirp = min(power_rule1->max_eirp,
 574                power_rule2->max_eirp);
 575        power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
 576                power_rule2->max_antenna_gain);
 577
 578        intersected_rule->flags = (rule1->flags | rule2->flags);
 579
 580        if (!is_valid_reg_rule(intersected_rule))
 581                return -EINVAL;
 582
 583        return 0;
 584}
 585
 586/**
 587 * regdom_intersect - do the intersection between two regulatory domains
 588 * @rd1: first regulatory domain
 589 * @rd2: second regulatory domain
 590 *
 591 * Use this function to get the intersection between two regulatory domains.
 592 * Once completed we will mark the alpha2 for the rd as intersected, "98",
 593 * as no one single alpha2 can represent this regulatory domain.
 594 *
 595 * Returns a pointer to the regulatory domain structure which will hold the
 596 * resulting intersection of rules between rd1 and rd2. We will
 597 * kzalloc() this structure for you.
 598 */
 599static struct ieee80211_regdomain *regdom_intersect(
 600        const struct ieee80211_regdomain *rd1,
 601        const struct ieee80211_regdomain *rd2)
 602{
 603        int r, size_of_regd;
 604        unsigned int x, y;
 605        unsigned int num_rules = 0, rule_idx = 0;
 606        const struct ieee80211_reg_rule *rule1, *rule2;
 607        struct ieee80211_reg_rule *intersected_rule;
 608        struct ieee80211_regdomain *rd;
 609        /* This is just a dummy holder to help us count */
 610        struct ieee80211_reg_rule irule;
 611
 612        /* Uses the stack temporarily for counter arithmetic */
 613        intersected_rule = &irule;
 614
 615        memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
 616
 617        if (!rd1 || !rd2)
 618                return NULL;
 619
 620        /*
 621         * First we get a count of the rules we'll need, then we actually
 622         * build them. This is to so we can malloc() and free() a
 623         * regdomain once. The reason we use reg_rules_intersect() here
 624         * is it will return -EINVAL if the rule computed makes no sense.
 625         * All rules that do check out OK are valid.
 626         */
 627
 628        for (x = 0; x < rd1->n_reg_rules; x++) {
 629                rule1 = &rd1->reg_rules[x];
 630                for (y = 0; y < rd2->n_reg_rules; y++) {
 631                        rule2 = &rd2->reg_rules[y];
 632                        if (!reg_rules_intersect(rule1, rule2,
 633                                        intersected_rule))
 634                                num_rules++;
 635                        memset(intersected_rule, 0,
 636                                        sizeof(struct ieee80211_reg_rule));
 637                }
 638        }
 639
 640        if (!num_rules)
 641                return NULL;
 642
 643        size_of_regd = sizeof(struct ieee80211_regdomain) +
 644                ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
 645
 646        rd = kzalloc(size_of_regd, GFP_KERNEL);
 647        if (!rd)
 648                return NULL;
 649
 650        for (x = 0; x < rd1->n_reg_rules; x++) {
 651                rule1 = &rd1->reg_rules[x];
 652                for (y = 0; y < rd2->n_reg_rules; y++) {
 653                        rule2 = &rd2->reg_rules[y];
 654                        /*
 655                         * This time around instead of using the stack lets
 656                         * write to the target rule directly saving ourselves
 657                         * a memcpy()
 658                         */
 659                        intersected_rule = &rd->reg_rules[rule_idx];
 660                        r = reg_rules_intersect(rule1, rule2,
 661                                intersected_rule);
 662                        /*
 663                         * No need to memset here the intersected rule here as
 664                         * we're not using the stack anymore
 665                         */
 666                        if (r)
 667                                continue;
 668                        rule_idx++;
 669                }
 670        }
 671
 672        if (rule_idx != num_rules) {
 673                kfree(rd);
 674                return NULL;
 675        }
 676
 677        rd->n_reg_rules = num_rules;
 678        rd->alpha2[0] = '9';
 679        rd->alpha2[1] = '8';
 680
 681        return rd;
 682}
 683
 684/*
 685 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
 686 * want to just have the channel structure use these
 687 */
 688static u32 map_regdom_flags(u32 rd_flags)
 689{
 690        u32 channel_flags = 0;
 691        if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
 692                channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 693        if (rd_flags & NL80211_RRF_NO_IBSS)
 694                channel_flags |= IEEE80211_CHAN_NO_IBSS;
 695        if (rd_flags & NL80211_RRF_DFS)
 696                channel_flags |= IEEE80211_CHAN_RADAR;
 697        if (rd_flags & NL80211_RRF_NO_OFDM)
 698                channel_flags |= IEEE80211_CHAN_NO_OFDM;
 699        return channel_flags;
 700}
 701
 702static int freq_reg_info_regd(struct wiphy *wiphy,
 703                              u32 center_freq,
 704                              u32 desired_bw_khz,
 705                              const struct ieee80211_reg_rule **reg_rule,
 706                              const struct ieee80211_regdomain *custom_regd)
 707{
 708        int i;
 709        bool band_rule_found = false;
 710        const struct ieee80211_regdomain *regd;
 711        bool bw_fits = false;
 712
 713        if (!desired_bw_khz)
 714                desired_bw_khz = MHZ_TO_KHZ(20);
 715
 716        regd = custom_regd ? custom_regd : cfg80211_regdomain;
 717
 718        /*
 719         * Follow the driver's regulatory domain, if present, unless a country
 720         * IE has been processed or a user wants to help complaince further
 721         */
 722        if (!custom_regd &&
 723            last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 724            last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
 725            wiphy->regd)
 726                regd = wiphy->regd;
 727
 728        if (!regd)
 729                return -EINVAL;
 730
 731        for (i = 0; i < regd->n_reg_rules; i++) {
 732                const struct ieee80211_reg_rule *rr;
 733                const struct ieee80211_freq_range *fr = NULL;
 734
 735                rr = &regd->reg_rules[i];
 736                fr = &rr->freq_range;
 737
 738                /*
 739                 * We only need to know if one frequency rule was
 740                 * was in center_freq's band, that's enough, so lets
 741                 * not overwrite it once found
 742                 */
 743                if (!band_rule_found)
 744                        band_rule_found = freq_in_rule_band(fr, center_freq);
 745
 746                bw_fits = reg_does_bw_fit(fr,
 747                                          center_freq,
 748                                          desired_bw_khz);
 749
 750                if (band_rule_found && bw_fits) {
 751                        *reg_rule = rr;
 752                        return 0;
 753                }
 754        }
 755
 756        if (!band_rule_found)
 757                return -ERANGE;
 758
 759        return -EINVAL;
 760}
 761
 762int freq_reg_info(struct wiphy *wiphy,
 763                  u32 center_freq,
 764                  u32 desired_bw_khz,
 765                  const struct ieee80211_reg_rule **reg_rule)
 766{
 767        assert_cfg80211_lock();
 768        return freq_reg_info_regd(wiphy,
 769                                  center_freq,
 770                                  desired_bw_khz,
 771                                  reg_rule,
 772                                  NULL);
 773}
 774EXPORT_SYMBOL(freq_reg_info);
 775
 776#ifdef CONFIG_CFG80211_REG_DEBUG
 777static const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
 778{
 779        switch (initiator) {
 780        case NL80211_REGDOM_SET_BY_CORE:
 781                return "Set by core";
 782        case NL80211_REGDOM_SET_BY_USER:
 783                return "Set by user";
 784        case NL80211_REGDOM_SET_BY_DRIVER:
 785                return "Set by driver";
 786        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
 787                return "Set by country IE";
 788        default:
 789                WARN_ON(1);
 790                return "Set by bug";
 791        }
 792}
 793
 794static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
 795                                    u32 desired_bw_khz,
 796                                    const struct ieee80211_reg_rule *reg_rule)
 797{
 798        const struct ieee80211_power_rule *power_rule;
 799        const struct ieee80211_freq_range *freq_range;
 800        char max_antenna_gain[32];
 801
 802        power_rule = &reg_rule->power_rule;
 803        freq_range = &reg_rule->freq_range;
 804
 805        if (!power_rule->max_antenna_gain)
 806                snprintf(max_antenna_gain, 32, "N/A");
 807        else
 808                snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
 809
 810        REG_DBG_PRINT("Updating information on frequency %d MHz "
 811                      "for a %d MHz width channel with regulatory rule:\n",
 812                      chan->center_freq,
 813                      KHZ_TO_MHZ(desired_bw_khz));
 814
 815        REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
 816                      freq_range->start_freq_khz,
 817                      freq_range->end_freq_khz,
 818                      freq_range->max_bandwidth_khz,
 819                      max_antenna_gain,
 820                      power_rule->max_eirp);
 821}
 822#else
 823static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
 824                                    u32 desired_bw_khz,
 825                                    const struct ieee80211_reg_rule *reg_rule)
 826{
 827        return;
 828}
 829#endif
 830
 831/*
 832 * Note that right now we assume the desired channel bandwidth
 833 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
 834 * per channel, the primary and the extension channel). To support
 835 * smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
 836 * new ieee80211_channel.target_bw and re run the regulatory check
 837 * on the wiphy with the target_bw specified. Then we can simply use
 838 * that below for the desired_bw_khz below.
 839 */
 840static void handle_channel(struct wiphy *wiphy,
 841                           enum nl80211_reg_initiator initiator,
 842                           enum ieee80211_band band,
 843                           unsigned int chan_idx)
 844{
 845        int r;
 846        u32 flags, bw_flags = 0;
 847        u32 desired_bw_khz = MHZ_TO_KHZ(20);
 848        const struct ieee80211_reg_rule *reg_rule = NULL;
 849        const struct ieee80211_power_rule *power_rule = NULL;
 850        const struct ieee80211_freq_range *freq_range = NULL;
 851        struct ieee80211_supported_band *sband;
 852        struct ieee80211_channel *chan;
 853        struct wiphy *request_wiphy = NULL;
 854
 855        assert_cfg80211_lock();
 856
 857        request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
 858
 859        sband = wiphy->bands[band];
 860        BUG_ON(chan_idx >= sband->n_channels);
 861        chan = &sband->channels[chan_idx];
 862
 863        flags = chan->orig_flags;
 864
 865        r = freq_reg_info(wiphy,
 866                          MHZ_TO_KHZ(chan->center_freq),
 867                          desired_bw_khz,
 868                          &reg_rule);
 869
 870        if (r) {
 871                /*
 872                 * We will disable all channels that do not match our
 873                 * received regulatory rule unless the hint is coming
 874                 * from a Country IE and the Country IE had no information
 875                 * about a band. The IEEE 802.11 spec allows for an AP
 876                 * to send only a subset of the regulatory rules allowed,
 877                 * so an AP in the US that only supports 2.4 GHz may only send
 878                 * a country IE with information for the 2.4 GHz band
 879                 * while 5 GHz is still supported.
 880                 */
 881                if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 882                    r == -ERANGE)
 883                        return;
 884
 885                REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
 886                chan->flags = IEEE80211_CHAN_DISABLED;
 887                return;
 888        }
 889
 890        chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);
 891
 892        power_rule = &reg_rule->power_rule;
 893        freq_range = &reg_rule->freq_range;
 894
 895        if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
 896                bw_flags = IEEE80211_CHAN_NO_HT40;
 897
 898        if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
 899            request_wiphy && request_wiphy == wiphy &&
 900            request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
 901                /*
 902                 * This guarantees the driver's requested regulatory domain
 903                 * will always be used as a base for further regulatory
 904                 * settings
 905                 */
 906                chan->flags = chan->orig_flags =
 907                        map_regdom_flags(reg_rule->flags) | bw_flags;
 908                chan->max_antenna_gain = chan->orig_mag =
 909                        (int) MBI_TO_DBI(power_rule->max_antenna_gain);
 910                chan->max_reg_power = chan->max_power = chan->orig_mpwr =
 911                        (int) MBM_TO_DBM(power_rule->max_eirp);
 912                return;
 913        }
 914
 915        chan->beacon_found = false;
 916        chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
 917        chan->max_antenna_gain = min(chan->orig_mag,
 918                (int) MBI_TO_DBI(power_rule->max_antenna_gain));
 919        chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 920        if (chan->orig_mpwr) {
 921                /*
 922                 * Devices that have their own custom regulatory domain
 923                 * but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
 924                 * passed country IE power settings.
 925                 */
 926                if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
 927                    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
 928                    wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
 929                        chan->max_power = chan->max_reg_power;
 930                else
 931                        chan->max_power = min(chan->orig_mpwr,
 932                                              chan->max_reg_power);
 933        } else
 934                chan->max_power = chan->max_reg_power;
 935}
 936
 937static void handle_band(struct wiphy *wiphy,
 938                        enum ieee80211_band band,
 939                        enum nl80211_reg_initiator initiator)
 940{
 941        unsigned int i;
 942        struct ieee80211_supported_band *sband;
 943
 944        BUG_ON(!wiphy->bands[band]);
 945        sband = wiphy->bands[band];
 946
 947        for (i = 0; i < sband->n_channels; i++)
 948                handle_channel(wiphy, initiator, band, i);
 949}
 950
 951static bool reg_request_cell_base(struct regulatory_request *request)
 952{
 953        if (request->initiator != NL80211_REGDOM_SET_BY_USER)
 954                return false;
 955        if (request->user_reg_hint_type != NL80211_USER_REG_HINT_CELL_BASE)
 956                return false;
 957        return true;
 958}
 959
 960bool reg_last_request_cell_base(void)
 961{
 962        bool val;
 963        assert_cfg80211_lock();
 964
 965        mutex_lock(&reg_mutex);
 966        val = reg_request_cell_base(last_request);
 967        mutex_unlock(&reg_mutex);
 968        return val;
 969}
 970
 971#ifdef CONFIG_CFG80211_CERTIFICATION_ONUS
 972
 973/* Core specific check */
 974static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
 975{
 976        if (!reg_num_devs_support_basehint)
 977                return -EOPNOTSUPP;
 978
 979        if (reg_request_cell_base(last_request)) {
 980                if (!regdom_changes(pending_request->alpha2))
 981                        return -EALREADY;
 982                return 0;
 983        }
 984        return 0;
 985}
 986
 987/* Device specific check */
 988static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
 989{
 990        if (!(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS))
 991                return true;
 992        return false;
 993}
 994#else
 995static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
 996{
 997        return -EOPNOTSUPP;
 998}
 999static int reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1000{
1001        return true;
1002}
1003#endif
1004
1005
1006static bool ignore_reg_update(struct wiphy *wiphy,
1007                              enum nl80211_reg_initiator initiator)
1008{
1009        if (!last_request) {
1010                REG_DBG_PRINT("Ignoring regulatory request %s since "
1011                              "last_request is not set\n",
1012                              reg_initiator_name(initiator));
1013                return true;
1014        }
1015
1016        if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1017            wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
1018                REG_DBG_PRINT("Ignoring regulatory request %s "
1019                              "since the driver uses its own custom "
1020                              "regulatory domain\n",
1021                              reg_initiator_name(initiator));
1022                return true;
1023        }
1024
1025        /*
1026         * wiphy->regd will be set once the device has its own
1027         * desired regulatory domain set
1028         */
1029        if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
1030            initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1031            !is_world_regdom(last_request->alpha2)) {
1032                REG_DBG_PRINT("Ignoring regulatory request %s "
1033                              "since the driver requires its own regulatory "
1034                              "domain to be set first\n",
1035                              reg_initiator_name(initiator));
1036                return true;
1037        }
1038
1039        if (reg_request_cell_base(last_request))
1040                return reg_dev_ignore_cell_hint(wiphy);
1041
1042        return false;
1043}
1044
1045static void handle_reg_beacon(struct wiphy *wiphy,
1046                              unsigned int chan_idx,
1047                              struct reg_beacon *reg_beacon)
1048{
1049        struct ieee80211_supported_band *sband;
1050        struct ieee80211_channel *chan;
1051        bool channel_changed = false;
1052        struct ieee80211_channel chan_before;
1053
1054        assert_cfg80211_lock();
1055
1056        sband = wiphy->bands[reg_beacon->chan.band];
1057        chan = &sband->channels[chan_idx];
1058
1059        if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1060                return;
1061
1062        if (chan->beacon_found)
1063                return;
1064
1065        chan->beacon_found = true;
1066
1067        if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
1068                return;
1069
1070        chan_before.center_freq = chan->center_freq;
1071        chan_before.flags = chan->flags;
1072
1073        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
1074                chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
1075                channel_changed = true;
1076        }
1077
1078        if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
1079                chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
1080                channel_changed = true;
1081        }
1082
1083        if (channel_changed)
1084                nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1085}
1086
1087/*
1088 * Called when a scan on a wiphy finds a beacon on
1089 * new channel
1090 */
1091static void wiphy_update_new_beacon(struct wiphy *wiphy,
1092                                    struct reg_beacon *reg_beacon)
1093{
1094        unsigned int i;
1095        struct ieee80211_supported_band *sband;
1096
1097        assert_cfg80211_lock();
1098
1099        if (!wiphy->bands[reg_beacon->chan.band])
1100                return;
1101
1102        sband = wiphy->bands[reg_beacon->chan.band];
1103
1104        for (i = 0; i < sband->n_channels; i++)
1105                handle_reg_beacon(wiphy, i, reg_beacon);
1106}
1107
1108/*
1109 * Called upon reg changes or a new wiphy is added
1110 */
1111static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1112{
1113        unsigned int i;
1114        struct ieee80211_supported_band *sband;
1115        struct reg_beacon *reg_beacon;
1116
1117        assert_cfg80211_lock();
1118
1119        if (list_empty(&reg_beacon_list))
1120                return;
1121
1122        list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1123                if (!wiphy->bands[reg_beacon->chan.band])
1124                        continue;
1125                sband = wiphy->bands[reg_beacon->chan.band];
1126                for (i = 0; i < sband->n_channels; i++)
1127                        handle_reg_beacon(wiphy, i, reg_beacon);
1128        }
1129}
1130
1131static bool reg_is_world_roaming(struct wiphy *wiphy)
1132{
1133        if (is_world_regdom(cfg80211_regdomain->alpha2) ||
1134            (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
1135                return true;
1136        if (last_request &&
1137            last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1138            wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1139                return true;
1140        return false;
1141}
1142
1143/* Reap the advantages of previously found beacons */
1144static void reg_process_beacons(struct wiphy *wiphy)
1145{
1146        /*
1147         * Means we are just firing up cfg80211, so no beacons would
1148         * have been processed yet.
1149         */
1150        if (!last_request)
1151                return;
1152        if (!reg_is_world_roaming(wiphy))
1153                return;
1154        wiphy_update_beacon_reg(wiphy);
1155}
1156
1157static bool is_ht40_not_allowed(struct ieee80211_channel *chan)
1158{
1159        if (!chan)
1160                return true;
1161        if (chan->flags & IEEE80211_CHAN_DISABLED)
1162                return true;
1163        /* This would happen when regulatory rules disallow HT40 completely */
1164        if (IEEE80211_CHAN_NO_HT40 == (chan->flags & (IEEE80211_CHAN_NO_HT40)))
1165                return true;
1166        return false;
1167}
1168
1169static void reg_process_ht_flags_channel(struct wiphy *wiphy,
1170                                         enum ieee80211_band band,
1171                                         unsigned int chan_idx)
1172{
1173        struct ieee80211_supported_band *sband;
1174        struct ieee80211_channel *channel;
1175        struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1176        unsigned int i;
1177
1178        assert_cfg80211_lock();
1179
1180        sband = wiphy->bands[band];
1181        BUG_ON(chan_idx >= sband->n_channels);
1182        channel = &sband->channels[chan_idx];
1183
1184        if (is_ht40_not_allowed(channel)) {
1185                channel->flags |= IEEE80211_CHAN_NO_HT40;
1186                return;
1187        }
1188
1189        /*
1190         * We need to ensure the extension channels exist to
1191         * be able to use HT40- or HT40+, this finds them (or not)
1192         */
1193        for (i = 0; i < sband->n_channels; i++) {
1194                struct ieee80211_channel *c = &sband->channels[i];
1195                if (c->center_freq == (channel->center_freq - 20))
1196                        channel_before = c;
1197                if (c->center_freq == (channel->center_freq + 20))
1198                        channel_after = c;
1199        }
1200
1201        /*
1202         * Please note that this assumes target bandwidth is 20 MHz,
1203         * if that ever changes we also need to change the below logic
1204         * to include that as well.
1205         */
1206        if (is_ht40_not_allowed(channel_before))
1207                channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1208        else
1209                channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1210
1211        if (is_ht40_not_allowed(channel_after))
1212                channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1213        else
1214                channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1215}
1216
1217static void reg_process_ht_flags_band(struct wiphy *wiphy,
1218                                      enum ieee80211_band band)
1219{
1220        unsigned int i;
1221        struct ieee80211_supported_band *sband;
1222
1223        BUG_ON(!wiphy->bands[band]);
1224        sband = wiphy->bands[band];
1225
1226        for (i = 0; i < sband->n_channels; i++)
1227                reg_process_ht_flags_channel(wiphy, band, i);
1228}
1229
1230static void reg_process_ht_flags(struct wiphy *wiphy)
1231{
1232        enum ieee80211_band band;
1233
1234        if (!wiphy)
1235                return;
1236
1237        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1238                if (wiphy->bands[band])
1239                        reg_process_ht_flags_band(wiphy, band);
1240        }
1241
1242}
1243
1244static void wiphy_update_regulatory(struct wiphy *wiphy,
1245                                    enum nl80211_reg_initiator initiator)
1246{
1247        enum ieee80211_band band;
1248
1249        assert_reg_lock();
1250
1251        if (ignore_reg_update(wiphy, initiator))
1252                return;
1253
1254        last_request->dfs_region = cfg80211_regdomain->dfs_region;
1255
1256        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1257                if (wiphy->bands[band])
1258                        handle_band(wiphy, band, initiator);
1259        }
1260
1261        reg_process_beacons(wiphy);
1262        reg_process_ht_flags(wiphy);
1263        if (wiphy->reg_notifier)
1264                wiphy->reg_notifier(wiphy, last_request);
1265}
1266
1267static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1268{
1269        struct cfg80211_registered_device *rdev;
1270        struct wiphy *wiphy;
1271
1272        list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1273                wiphy = &rdev->wiphy;
1274                wiphy_update_regulatory(wiphy, initiator);
1275                /*
1276                 * Regulatory updates set by CORE are ignored for custom
1277                 * regulatory cards. Let us notify the changes to the driver,
1278                 * as some drivers used this to restore its orig_* reg domain.
1279                 */
1280                if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1281                    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
1282                    wiphy->reg_notifier)
1283                        wiphy->reg_notifier(wiphy, last_request);
1284        }
1285}
1286
1287static void handle_channel_custom(struct wiphy *wiphy,
1288                                  enum ieee80211_band band,
1289                                  unsigned int chan_idx,
1290                                  const struct ieee80211_regdomain *regd)
1291{
1292        int r;
1293        u32 desired_bw_khz = MHZ_TO_KHZ(20);
1294        u32 bw_flags = 0;
1295        const struct ieee80211_reg_rule *reg_rule = NULL;
1296        const struct ieee80211_power_rule *power_rule = NULL;
1297        const struct ieee80211_freq_range *freq_range = NULL;
1298        struct ieee80211_supported_band *sband;
1299        struct ieee80211_channel *chan;
1300
1301        assert_reg_lock();
1302
1303        sband = wiphy->bands[band];
1304        BUG_ON(chan_idx >= sband->n_channels);
1305        chan = &sband->channels[chan_idx];
1306
1307        r = freq_reg_info_regd(wiphy,
1308                               MHZ_TO_KHZ(chan->center_freq),
1309                               desired_bw_khz,
1310                               &reg_rule,
1311                               regd);
1312
1313        if (r) {
1314                REG_DBG_PRINT("Disabling freq %d MHz as custom "
1315                              "regd has no rule that fits a %d MHz "
1316                              "wide channel\n",
1317                              chan->center_freq,
1318                              KHZ_TO_MHZ(desired_bw_khz));
1319                chan->flags = IEEE80211_CHAN_DISABLED;
1320                return;
1321        }
1322
1323        chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);
1324
1325        power_rule = &reg_rule->power_rule;
1326        freq_range = &reg_rule->freq_range;
1327
1328        if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1329                bw_flags = IEEE80211_CHAN_NO_HT40;
1330
1331        chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1332        chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1333        chan->max_reg_power = chan->max_power =
1334                (int) MBM_TO_DBM(power_rule->max_eirp);
1335}
1336
1337static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
1338                               const struct ieee80211_regdomain *regd)
1339{
1340        unsigned int i;
1341        struct ieee80211_supported_band *sband;
1342
1343        BUG_ON(!wiphy->bands[band]);
1344        sband = wiphy->bands[band];
1345
1346        for (i = 0; i < sband->n_channels; i++)
1347                handle_channel_custom(wiphy, band, i, regd);
1348}
1349
1350/* Used by drivers prior to wiphy registration */
1351void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1352                                   const struct ieee80211_regdomain *regd)
1353{
1354        enum ieee80211_band band;
1355        unsigned int bands_set = 0;
1356
1357        mutex_lock(&reg_mutex);
1358        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1359                if (!wiphy->bands[band])
1360                        continue;
1361                handle_band_custom(wiphy, band, regd);
1362                bands_set++;
1363        }
1364        mutex_unlock(&reg_mutex);
1365
1366        /*
1367         * no point in calling this if it won't have any effect
1368         * on your device's supportd bands.
1369         */
1370        WARN_ON(!bands_set);
1371}
1372EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1373
1374/*
1375 * Return value which can be used by ignore_request() to indicate
1376 * it has been determined we should intersect two regulatory domains
1377 */
1378#define REG_INTERSECT   1
1379
1380/* This has the logic which determines when a new request
1381 * should be ignored. */
1382static int ignore_request(struct wiphy *wiphy,
1383                          struct regulatory_request *pending_request)
1384{
1385        struct wiphy *last_wiphy = NULL;
1386
1387        assert_cfg80211_lock();
1388
1389        /* All initial requests are respected */
1390        if (!last_request)
1391                return 0;
1392
1393        switch (pending_request->initiator) {
1394        case NL80211_REGDOM_SET_BY_CORE:
1395                return 0;
1396        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1397
1398                if (reg_request_cell_base(last_request)) {
1399                        /* Trust a Cell base station over the AP's country IE */
1400                        if (regdom_changes(pending_request->alpha2))
1401                                return -EOPNOTSUPP;
1402                        return -EALREADY;
1403                }
1404
1405                last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1406
1407                if (unlikely(!is_an_alpha2(pending_request->alpha2)))
1408                        return -EINVAL;
1409                if (last_request->initiator ==
1410                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
1411                        if (last_wiphy != wiphy) {
1412                                /*
1413                                 * Two cards with two APs claiming different
1414                                 * Country IE alpha2s. We could
1415                                 * intersect them, but that seems unlikely
1416                                 * to be correct. Reject second one for now.
1417                                 */
1418                                if (regdom_changes(pending_request->alpha2))
1419                                        return -EOPNOTSUPP;
1420                                return -EALREADY;
1421                        }
1422                        /*
1423                         * Two consecutive Country IE hints on the same wiphy.
1424                         * This should be picked up early by the driver/stack
1425                         */
1426                        if (WARN_ON(regdom_changes(pending_request->alpha2)))
1427                                return 0;
1428                        return -EALREADY;
1429                }
1430                return 0;
1431        case NL80211_REGDOM_SET_BY_DRIVER:
1432                if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
1433                        if (regdom_changes(pending_request->alpha2))
1434                                return 0;
1435                        return -EALREADY;
1436                }
1437
1438                /*
1439                 * This would happen if you unplug and plug your card
1440                 * back in or if you add a new device for which the previously
1441                 * loaded card also agrees on the regulatory domain.
1442                 */
1443                if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1444                    !regdom_changes(pending_request->alpha2))
1445                        return -EALREADY;
1446
1447                return REG_INTERSECT;
1448        case NL80211_REGDOM_SET_BY_USER:
1449                if (reg_request_cell_base(pending_request))
1450                        return reg_ignore_cell_hint(pending_request);
1451
1452                if (reg_request_cell_base(last_request))
1453                        return -EOPNOTSUPP;
1454
1455                if (last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
1456                        return REG_INTERSECT;
1457                /*
1458                 * If the user knows better the user should set the regdom
1459                 * to their country before the IE is picked up
1460                 */
1461                if (last_request->initiator == NL80211_REGDOM_SET_BY_USER &&
1462                          last_request->intersect)
1463                        return -EOPNOTSUPP;
1464                /*
1465                 * Process user requests only after previous user/driver/core
1466                 * requests have been processed
1467                 */
1468                if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE ||
1469                    last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1470                    last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
1471                        if (regdom_changes(last_request->alpha2))
1472                                return -EAGAIN;
1473                }
1474
1475                if (!regdom_changes(pending_request->alpha2))
1476                        return -EALREADY;
1477
1478                return 0;
1479        }
1480
1481        return -EINVAL;
1482}
1483
1484static void reg_set_request_processed(void)
1485{
1486        bool need_more_processing = false;
1487
1488        last_request->processed = true;
1489
1490        spin_lock(&reg_requests_lock);
1491        if (!list_empty(&reg_requests_list))
1492                need_more_processing = true;
1493        spin_unlock(&reg_requests_lock);
1494
1495        if (last_request->initiator == NL80211_REGDOM_SET_BY_USER)
1496                cancel_delayed_work(&reg_timeout);
1497
1498        if (need_more_processing)
1499                schedule_work(&reg_work);
1500}
1501
1502/**
1503 * __regulatory_hint - hint to the wireless core a regulatory domain
1504 * @wiphy: if the hint comes from country information from an AP, this
1505 *      is required to be set to the wiphy that received the information
1506 * @pending_request: the regulatory request currently being processed
1507 *
1508 * The Wireless subsystem can use this function to hint to the wireless core
1509 * what it believes should be the current regulatory domain.
1510 *
1511 * Returns zero if all went fine, %-EALREADY if a regulatory domain had
1512 * already been set or other standard error codes.
1513 *
1514 * Caller must hold &cfg80211_mutex and &reg_mutex
1515 */
1516static int __regulatory_hint(struct wiphy *wiphy,
1517                             struct regulatory_request *pending_request)
1518{
1519        bool intersect = false;
1520        int r = 0;
1521
1522        assert_cfg80211_lock();
1523
1524        r = ignore_request(wiphy, pending_request);
1525
1526        if (r == REG_INTERSECT) {
1527                if (pending_request->initiator ==
1528                    NL80211_REGDOM_SET_BY_DRIVER) {
1529                        r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1530                        if (r) {
1531                                kfree(pending_request);
1532                                return r;
1533                        }
1534                }
1535                intersect = true;
1536        } else if (r) {
1537                /*
1538                 * If the regulatory domain being requested by the
1539                 * driver has already been set just copy it to the
1540                 * wiphy
1541                 */
1542                if (r == -EALREADY &&
1543                    pending_request->initiator ==
1544                    NL80211_REGDOM_SET_BY_DRIVER) {
1545                        r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1546                        if (r) {
1547                                kfree(pending_request);
1548                                return r;
1549                        }
1550                        r = -EALREADY;
1551                        goto new_request;
1552                }
1553                kfree(pending_request);
1554                return r;
1555        }
1556
1557new_request:
1558        if (last_request != &core_request_world)
1559                kfree(last_request);
1560
1561        last_request = pending_request;
1562        last_request->intersect = intersect;
1563
1564        pending_request = NULL;
1565
1566        if (last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
1567                user_alpha2[0] = last_request->alpha2[0];
1568                user_alpha2[1] = last_request->alpha2[1];
1569        }
1570
1571        /* When r == REG_INTERSECT we do need to call CRDA */
1572        if (r < 0) {
1573                /*
1574                 * Since CRDA will not be called in this case as we already
1575                 * have applied the requested regulatory domain before we just
1576                 * inform userspace we have processed the request
1577                 */
1578                if (r == -EALREADY) {
1579                        nl80211_send_reg_change_event(last_request);
1580                        reg_set_request_processed();
1581                }
1582                return r;
1583        }
1584
1585        return call_crda(last_request->alpha2);
1586}
1587
1588/* This processes *all* regulatory hints */
1589static void reg_process_hint(struct regulatory_request *reg_request,
1590                             enum nl80211_reg_initiator reg_initiator)
1591{
1592        int r = 0;
1593        struct wiphy *wiphy = NULL;
1594
1595        BUG_ON(!reg_request->alpha2);
1596
1597        if (wiphy_idx_valid(reg_request->wiphy_idx))
1598                wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1599
1600        if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1601            !wiphy) {
1602                kfree(reg_request);
1603                return;
1604        }
1605
1606        r = __regulatory_hint(wiphy, reg_request);
1607        /* This is required so that the orig_* parameters are saved */
1608        if (r == -EALREADY && wiphy &&
1609            wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
1610                wiphy_update_regulatory(wiphy, reg_initiator);
1611                return;
1612        }
1613
1614        /*
1615         * We only time out user hints, given that they should be the only
1616         * source of bogus requests.
1617         */
1618        if (r != -EALREADY &&
1619            reg_initiator == NL80211_REGDOM_SET_BY_USER)
1620                schedule_delayed_work(&reg_timeout, msecs_to_jiffies(3142));
1621}
1622
1623/*
1624 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
1625 * Regulatory hints come on a first come first serve basis and we
1626 * must process each one atomically.
1627 */
1628static void reg_process_pending_hints(void)
1629{
1630        struct regulatory_request *reg_request;
1631
1632        mutex_lock(&cfg80211_mutex);
1633        mutex_lock(&reg_mutex);
1634
1635        /* When last_request->processed becomes true this will be rescheduled */
1636        if (last_request && !last_request->processed) {
1637                REG_DBG_PRINT("Pending regulatory request, waiting "
1638                              "for it to be processed...\n");
1639                goto out;
1640        }
1641
1642        spin_lock(&reg_requests_lock);
1643
1644        if (list_empty(&reg_requests_list)) {
1645                spin_unlock(&reg_requests_lock);
1646                goto out;
1647        }
1648
1649        reg_request = list_first_entry(&reg_requests_list,
1650                                       struct regulatory_request,
1651                                       list);
1652        list_del_init(&reg_request->list);
1653
1654        spin_unlock(&reg_requests_lock);
1655
1656        reg_process_hint(reg_request, reg_request->initiator);
1657
1658out:
1659        mutex_unlock(&reg_mutex);
1660        mutex_unlock(&cfg80211_mutex);
1661}
1662
1663/* Processes beacon hints -- this has nothing to do with country IEs */
1664static void reg_process_pending_beacon_hints(void)
1665{
1666        struct cfg80211_registered_device *rdev;
1667        struct reg_beacon *pending_beacon, *tmp;
1668
1669        /*
1670         * No need to hold the reg_mutex here as we just touch wiphys
1671         * and do not read or access regulatory variables.
1672         */
1673        mutex_lock(&cfg80211_mutex);
1674
1675        /* This goes through the _pending_ beacon list */
1676        spin_lock_bh(&reg_pending_beacons_lock);
1677
1678        if (list_empty(&reg_pending_beacons)) {
1679                spin_unlock_bh(&reg_pending_beacons_lock);
1680                goto out;
1681        }
1682
1683        list_for_each_entry_safe(pending_beacon, tmp,
1684                                 &reg_pending_beacons, list) {
1685
1686                list_del_init(&pending_beacon->list);
1687
1688                /* Applies the beacon hint to current wiphys */
1689                list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1690                        wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
1691
1692                /* Remembers the beacon hint for new wiphys or reg changes */
1693                list_add_tail(&pending_beacon->list, &reg_beacon_list);
1694        }
1695
1696        spin_unlock_bh(&reg_pending_beacons_lock);
1697out:
1698        mutex_unlock(&cfg80211_mutex);
1699}
1700
1701static void reg_todo(struct work_struct *work)
1702{
1703        reg_process_pending_hints();
1704        reg_process_pending_beacon_hints();
1705}
1706
1707static void queue_regulatory_request(struct regulatory_request *request)
1708{
1709        if (isalpha(request->alpha2[0]))
1710                request->alpha2[0] = toupper(request->alpha2[0]);
1711        if (isalpha(request->alpha2[1]))
1712                request->alpha2[1] = toupper(request->alpha2[1]);
1713
1714        spin_lock(&reg_requests_lock);
1715        list_add_tail(&request->list, &reg_requests_list);
1716        spin_unlock(&reg_requests_lock);
1717
1718        schedule_work(&reg_work);
1719}
1720
1721/*
1722 * Core regulatory hint -- happens during cfg80211_init()
1723 * and when we restore regulatory settings.
1724 */
1725static int regulatory_hint_core(const char *alpha2)
1726{
1727        struct regulatory_request *request;
1728
1729        request = kzalloc(sizeof(struct regulatory_request),
1730                          GFP_KERNEL);
1731        if (!request)
1732                return -ENOMEM;
1733
1734        request->alpha2[0] = alpha2[0];
1735        request->alpha2[1] = alpha2[1];
1736        request->initiator = NL80211_REGDOM_SET_BY_CORE;
1737
1738        queue_regulatory_request(request);
1739
1740        return 0;
1741}
1742
1743/* User hints */
1744int regulatory_hint_user(const char *alpha2,
1745                         enum nl80211_user_reg_hint_type user_reg_hint_type)
1746{
1747        struct regulatory_request *request;
1748
1749        BUG_ON(!alpha2);
1750
1751        request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1752        if (!request)
1753                return -ENOMEM;
1754
1755        request->wiphy_idx = WIPHY_IDX_STALE;
1756        request->alpha2[0] = alpha2[0];
1757        request->alpha2[1] = alpha2[1];
1758        request->initiator = NL80211_REGDOM_SET_BY_USER;
1759        request->user_reg_hint_type = user_reg_hint_type;
1760
1761        queue_regulatory_request(request);
1762
1763        return 0;
1764}
1765
1766/* Driver hints */
1767int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1768{
1769        struct regulatory_request *request;
1770
1771        BUG_ON(!alpha2);
1772        BUG_ON(!wiphy);
1773
1774        request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1775        if (!request)
1776                return -ENOMEM;
1777
1778        request->wiphy_idx = get_wiphy_idx(wiphy);
1779
1780        /* Must have registered wiphy first */
1781        BUG_ON(!wiphy_idx_valid(request->wiphy_idx));
1782
1783        request->alpha2[0] = alpha2[0];
1784        request->alpha2[1] = alpha2[1];
1785        request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
1786
1787        queue_regulatory_request(request);
1788
1789        return 0;
1790}
1791EXPORT_SYMBOL(regulatory_hint);
1792
1793/*
1794 * We hold wdev_lock() here so we cannot hold cfg80211_mutex() and
1795 * therefore cannot iterate over the rdev list here.
1796 */
1797void regulatory_hint_11d(struct wiphy *wiphy,
1798                         enum ieee80211_band band,
1799                         u8 *country_ie,
1800                         u8 country_ie_len)
1801{
1802        char alpha2[2];
1803        enum environment_cap env = ENVIRON_ANY;
1804        struct regulatory_request *request;
1805
1806        mutex_lock(&reg_mutex);
1807
1808        if (unlikely(!last_request))
1809                goto out;
1810
1811        /* IE len must be evenly divisible by 2 */
1812        if (country_ie_len & 0x01)
1813                goto out;
1814
1815        if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1816                goto out;
1817
1818        alpha2[0] = country_ie[0];
1819        alpha2[1] = country_ie[1];
1820
1821        if (country_ie[2] == 'I')
1822                env = ENVIRON_INDOOR;
1823        else if (country_ie[2] == 'O')
1824                env = ENVIRON_OUTDOOR;
1825
1826        /*
1827         * We will run this only upon a successful connection on cfg80211.
1828         * We leave conflict resolution to the workqueue, where can hold
1829         * cfg80211_mutex.
1830         */
1831        if (likely(last_request->initiator ==
1832            NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1833            wiphy_idx_valid(last_request->wiphy_idx)))
1834                goto out;
1835
1836        request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1837        if (!request)
1838                goto out;
1839
1840        request->wiphy_idx = get_wiphy_idx(wiphy);
1841        request->alpha2[0] = alpha2[0];
1842        request->alpha2[1] = alpha2[1];
1843        request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
1844        request->country_ie_env = env;
1845
1846        mutex_unlock(&reg_mutex);
1847
1848        queue_regulatory_request(request);
1849
1850        return;
1851
1852out:
1853        mutex_unlock(&reg_mutex);
1854}
1855
1856static void restore_alpha2(char *alpha2, bool reset_user)
1857{
1858        /* indicates there is no alpha2 to consider for restoration */
1859        alpha2[0] = '9';
1860        alpha2[1] = '7';
1861
1862        /* The user setting has precedence over the module parameter */
1863        if (is_user_regdom_saved()) {
1864                /* Unless we're asked to ignore it and reset it */
1865                if (reset_user) {
1866                        REG_DBG_PRINT("Restoring regulatory settings "
1867                               "including user preference\n");
1868                        user_alpha2[0] = '9';
1869                        user_alpha2[1] = '7';
1870
1871                        /*
1872                         * If we're ignoring user settings, we still need to
1873                         * check the module parameter to ensure we put things
1874                         * back as they were for a full restore.
1875                         */
1876                        if (!is_world_regdom(ieee80211_regdom)) {
1877                                REG_DBG_PRINT("Keeping preference on "
1878                                       "module parameter ieee80211_regdom: %c%c\n",
1879                                       ieee80211_regdom[0],
1880                                       ieee80211_regdom[1]);
1881                                alpha2[0] = ieee80211_regdom[0];
1882                                alpha2[1] = ieee80211_regdom[1];
1883                        }
1884                } else {
1885                        REG_DBG_PRINT("Restoring regulatory settings "
1886                               "while preserving user preference for: %c%c\n",
1887                               user_alpha2[0],
1888                               user_alpha2[1]);
1889                        alpha2[0] = user_alpha2[0];
1890                        alpha2[1] = user_alpha2[1];
1891                }
1892        } else if (!is_world_regdom(ieee80211_regdom)) {
1893                REG_DBG_PRINT("Keeping preference on "
1894                       "module parameter ieee80211_regdom: %c%c\n",
1895                       ieee80211_regdom[0],
1896                       ieee80211_regdom[1]);
1897                alpha2[0] = ieee80211_regdom[0];
1898                alpha2[1] = ieee80211_regdom[1];
1899        } else
1900                REG_DBG_PRINT("Restoring regulatory settings\n");
1901}
1902
1903static void restore_custom_reg_settings(struct wiphy *wiphy)
1904{
1905        struct ieee80211_supported_band *sband;
1906        enum ieee80211_band band;
1907        struct ieee80211_channel *chan;
1908        int i;
1909
1910        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1911                sband = wiphy->bands[band];
1912                if (!sband)
1913                        continue;
1914                for (i = 0; i < sband->n_channels; i++) {
1915                        chan = &sband->channels[i];
1916                        chan->flags = chan->orig_flags;
1917                        chan->max_antenna_gain = chan->orig_mag;
1918                        chan->max_power = chan->orig_mpwr;
1919                        chan->beacon_found = false;
1920                }
1921        }
1922}
1923
1924/*
1925 * Restoring regulatory settings involves ingoring any
1926 * possibly stale country IE information and user regulatory
1927 * settings if so desired, this includes any beacon hints
1928 * learned as we could have traveled outside to another country
1929 * after disconnection. To restore regulatory settings we do
1930 * exactly what we did at bootup:
1931 *
1932 *   - send a core regulatory hint
1933 *   - send a user regulatory hint if applicable
1934 *
1935 * Device drivers that send a regulatory hint for a specific country
1936 * keep their own regulatory domain on wiphy->regd so that does does
1937 * not need to be remembered.
1938 */
1939static void restore_regulatory_settings(bool reset_user)
1940{
1941        char alpha2[2];
1942        char world_alpha2[2];
1943        struct reg_beacon *reg_beacon, *btmp;
1944        struct regulatory_request *reg_request, *tmp;
1945        LIST_HEAD(tmp_reg_req_list);
1946        struct cfg80211_registered_device *rdev;
1947
1948        mutex_lock(&cfg80211_mutex);
1949        mutex_lock(&reg_mutex);
1950
1951        reset_regdomains(true);
1952        restore_alpha2(alpha2, reset_user);
1953
1954        /*
1955         * If there's any pending requests we simply
1956         * stash them to a temporary pending queue and
1957         * add then after we've restored regulatory
1958         * settings.
1959         */
1960        spin_lock(&reg_requests_lock);
1961        if (!list_empty(&reg_requests_list)) {
1962                list_for_each_entry_safe(reg_request, tmp,
1963                                         &reg_requests_list, list) {
1964                        if (reg_request->initiator !=
1965                            NL80211_REGDOM_SET_BY_USER)
1966                                continue;
1967                        list_move_tail(&reg_request->list, &tmp_reg_req_list);
1968                }
1969        }
1970        spin_unlock(&reg_requests_lock);
1971
1972        /* Clear beacon hints */
1973        spin_lock_bh(&reg_pending_beacons_lock);
1974        if (!list_empty(&reg_pending_beacons)) {
1975                list_for_each_entry_safe(reg_beacon, btmp,
1976                                         &reg_pending_beacons, list) {
1977                        list_del(&reg_beacon->list);
1978                        kfree(reg_beacon);
1979                }
1980        }
1981        spin_unlock_bh(&reg_pending_beacons_lock);
1982
1983        if (!list_empty(&reg_beacon_list)) {
1984                list_for_each_entry_safe(reg_beacon, btmp,
1985                                         &reg_beacon_list, list) {
1986                        list_del(&reg_beacon->list);
1987                        kfree(reg_beacon);
1988                }
1989        }
1990
1991        /* First restore to the basic regulatory settings */
1992        cfg80211_regdomain = cfg80211_world_regdom;
1993        world_alpha2[0] = cfg80211_regdomain->alpha2[0];
1994        world_alpha2[1] = cfg80211_regdomain->alpha2[1];
1995
1996        list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1997                if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1998                        restore_custom_reg_settings(&rdev->wiphy);
1999        }
2000
2001        mutex_unlock(&reg_mutex);
2002        mutex_unlock(&cfg80211_mutex);
2003
2004        regulatory_hint_core(world_alpha2);
2005
2006        /*
2007         * This restores the ieee80211_regdom module parameter
2008         * preference or the last user requested regulatory
2009         * settings, user regulatory settings takes precedence.
2010         */
2011        if (is_an_alpha2(alpha2))
2012                regulatory_hint_user(user_alpha2, NL80211_USER_REG_HINT_USER);
2013
2014        if (list_empty(&tmp_reg_req_list))
2015                return;
2016
2017        mutex_lock(&cfg80211_mutex);
2018        mutex_lock(&reg_mutex);
2019
2020        spin_lock(&reg_requests_lock);
2021        list_for_each_entry_safe(reg_request, tmp, &tmp_reg_req_list, list) {
2022                REG_DBG_PRINT("Adding request for country %c%c back "
2023                              "into the queue\n",
2024                              reg_request->alpha2[0],
2025                              reg_request->alpha2[1]);
2026                list_move_tail(&reg_request->list, &reg_requests_list);
2027        }
2028        spin_unlock(&reg_requests_lock);
2029
2030        mutex_unlock(&reg_mutex);
2031        mutex_unlock(&cfg80211_mutex);
2032
2033        REG_DBG_PRINT("Kicking the queue\n");
2034
2035        schedule_work(&reg_work);
2036}
2037
2038void regulatory_hint_disconnect(void)
2039{
2040        REG_DBG_PRINT("All devices are disconnected, going to "
2041                      "restore regulatory settings\n");
2042        restore_regulatory_settings(false);
2043}
2044
2045static bool freq_is_chan_12_13_14(u16 freq)
2046{
2047        if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
2048            freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
2049            freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
2050                return true;
2051        return false;
2052}
2053
2054int regulatory_hint_found_beacon(struct wiphy *wiphy,
2055                                 struct ieee80211_channel *beacon_chan,
2056                                 gfp_t gfp)
2057{
2058        struct reg_beacon *reg_beacon;
2059
2060        if (likely((beacon_chan->beacon_found ||
2061            (beacon_chan->flags & IEEE80211_CHAN_RADAR) ||
2062            (beacon_chan->band == IEEE80211_BAND_2GHZ &&
2063             !freq_is_chan_12_13_14(beacon_chan->center_freq)))))
2064                return 0;
2065
2066        reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
2067        if (!reg_beacon)
2068                return -ENOMEM;
2069
2070        REG_DBG_PRINT("Found new beacon on "
2071                      "frequency: %d MHz (Ch %d) on %s\n",
2072                      beacon_chan->center_freq,
2073                      ieee80211_frequency_to_channel(beacon_chan->center_freq),
2074                      wiphy_name(wiphy));
2075
2076        memcpy(&reg_beacon->chan, beacon_chan,
2077                sizeof(struct ieee80211_channel));
2078
2079
2080        /*
2081         * Since we can be called from BH or and non-BH context
2082         * we must use spin_lock_bh()
2083         */
2084        spin_lock_bh(&reg_pending_beacons_lock);
2085        list_add_tail(&reg_beacon->list, &reg_pending_beacons);
2086        spin_unlock_bh(&reg_pending_beacons_lock);
2087
2088        schedule_work(&reg_work);
2089
2090        return 0;
2091}
2092
2093static void print_rd_rules(const struct ieee80211_regdomain *rd)
2094{
2095        unsigned int i;
2096        const struct ieee80211_reg_rule *reg_rule = NULL;
2097        const struct ieee80211_freq_range *freq_range = NULL;
2098        const struct ieee80211_power_rule *power_rule = NULL;
2099
2100        pr_info("  (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
2101
2102        for (i = 0; i < rd->n_reg_rules; i++) {
2103                reg_rule = &rd->reg_rules[i];
2104                freq_range = &reg_rule->freq_range;
2105                power_rule = &reg_rule->power_rule;
2106
2107                /*
2108                 * There may not be documentation for max antenna gain
2109                 * in certain regions
2110                 */
2111                if (power_rule->max_antenna_gain)
2112                        pr_info("  (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
2113                                freq_range->start_freq_khz,
2114                                freq_range->end_freq_khz,
2115                                freq_range->max_bandwidth_khz,
2116                                power_rule->max_antenna_gain,
2117                                power_rule->max_eirp);
2118                else
2119                        pr_info("  (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
2120                                freq_range->start_freq_khz,
2121                                freq_range->end_freq_khz,
2122                                freq_range->max_bandwidth_khz,
2123                                power_rule->max_eirp);
2124        }
2125}
2126
2127bool reg_supported_dfs_region(u8 dfs_region)
2128{
2129        switch (dfs_region) {
2130        case NL80211_DFS_UNSET:
2131        case NL80211_DFS_FCC:
2132        case NL80211_DFS_ETSI:
2133        case NL80211_DFS_JP:
2134                return true;
2135        default:
2136                REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2137                              dfs_region);
2138                return false;
2139        }
2140}
2141
2142static void print_dfs_region(u8 dfs_region)
2143{
2144        if (!dfs_region)
2145                return;
2146
2147        switch (dfs_region) {
2148        case NL80211_DFS_FCC:
2149                pr_info(" DFS Master region FCC");
2150                break;
2151        case NL80211_DFS_ETSI:
2152                pr_info(" DFS Master region ETSI");
2153                break;
2154        case NL80211_DFS_JP:
2155                pr_info(" DFS Master region JP");
2156                break;
2157        default:
2158                pr_info(" DFS Master region Uknown");
2159                break;
2160        }
2161}
2162
2163static void print_regdomain(const struct ieee80211_regdomain *rd)
2164{
2165
2166        if (is_intersected_alpha2(rd->alpha2)) {
2167
2168                if (last_request->initiator ==
2169                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2170                        struct cfg80211_registered_device *rdev;
2171                        rdev = cfg80211_rdev_by_wiphy_idx(
2172                                last_request->wiphy_idx);
2173                        if (rdev) {
2174                                pr_info("Current regulatory domain updated by AP to: %c%c\n",
2175                                        rdev->country_ie_alpha2[0],
2176                                        rdev->country_ie_alpha2[1]);
2177                        } else
2178                                pr_info("Current regulatory domain intersected:\n");
2179                } else
2180                        pr_info("Current regulatory domain intersected:\n");
2181        } else if (is_world_regdom(rd->alpha2))
2182                pr_info("World regulatory domain updated:\n");
2183        else {
2184                if (is_unknown_alpha2(rd->alpha2))
2185                        pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
2186                else {
2187                        if (reg_request_cell_base(last_request))
2188                                pr_info("Regulatory domain changed "
2189                                        "to country: %c%c by Cell Station\n",
2190                                        rd->alpha2[0], rd->alpha2[1]);
2191                        else
2192                                pr_info("Regulatory domain changed "
2193                                        "to country: %c%c\n",
2194                                        rd->alpha2[0], rd->alpha2[1]);
2195                }
2196        }
2197        print_dfs_region(rd->dfs_region);
2198        print_rd_rules(rd);
2199}
2200
2201static void print_regdomain_info(const struct ieee80211_regdomain *rd)
2202{
2203        pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
2204        print_rd_rules(rd);
2205}
2206
2207/* Takes ownership of rd only if it doesn't fail */
2208static int __set_regdom(const struct ieee80211_regdomain *rd)
2209{
2210        const struct ieee80211_regdomain *intersected_rd = NULL;
2211        struct wiphy *request_wiphy;
2212        /* Some basic sanity checks first */
2213
2214        if (is_world_regdom(rd->alpha2)) {
2215                if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
2216                        return -EINVAL;
2217                update_world_regdomain(rd);
2218                return 0;
2219        }
2220
2221        if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2222                        !is_unknown_alpha2(rd->alpha2))
2223                return -EINVAL;
2224
2225        if (!last_request)
2226                return -EINVAL;
2227
2228        /*
2229         * Lets only bother proceeding on the same alpha2 if the current
2230         * rd is non static (it means CRDA was present and was used last)
2231         * and the pending request came in from a country IE
2232         */
2233        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2234                /*
2235                 * If someone else asked us to change the rd lets only bother
2236                 * checking if the alpha2 changes if CRDA was already called
2237                 */
2238                if (!regdom_changes(rd->alpha2))
2239                        return -EALREADY;
2240        }
2241
2242        /*
2243         * Now lets set the regulatory domain, update all driver channels
2244         * and finally inform them of what we have done, in case they want
2245         * to review or adjust their own settings based on their own
2246         * internal EEPROM data
2247         */
2248
2249        if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
2250                return -EINVAL;
2251
2252        if (!is_valid_rd(rd)) {
2253                pr_err("Invalid regulatory domain detected:\n");
2254                print_regdomain_info(rd);
2255                return -EINVAL;
2256        }
2257
2258        request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
2259        if (!request_wiphy &&
2260            (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2261             last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
2262                schedule_delayed_work(&reg_timeout, 0);
2263                return -ENODEV;
2264        }
2265
2266        if (!last_request->intersect) {
2267                int r;
2268
2269                if (last_request->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
2270                        reset_regdomains(false);
2271                        cfg80211_regdomain = rd;
2272                        return 0;
2273                }
2274
2275                /*
2276                 * For a driver hint, lets copy the regulatory domain the
2277                 * driver wanted to the wiphy to deal with conflicts
2278                 */
2279
2280                /*
2281                 * Userspace could have sent two replies with only
2282                 * one kernel request.
2283                 */
2284                if (request_wiphy->regd)
2285                        return -EALREADY;
2286
2287                r = reg_copy_regd(&request_wiphy->regd, rd);
2288                if (r)
2289                        return r;
2290
2291                reset_regdomains(false);
2292                cfg80211_regdomain = rd;
2293                return 0;
2294        }
2295
2296        /* Intersection requires a bit more work */
2297
2298        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2299
2300                intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
2301                if (!intersected_rd)
2302                        return -EINVAL;
2303
2304                /*
2305                 * We can trash what CRDA provided now.
2306                 * However if a driver requested this specific regulatory
2307                 * domain we keep it for its private use
2308                 */
2309                if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER)
2310                        request_wiphy->regd = rd;
2311                else
2312                        kfree(rd);
2313
2314                rd = NULL;
2315
2316                reset_regdomains(false);
2317                cfg80211_regdomain = intersected_rd;
2318
2319                return 0;
2320        }
2321
2322        return -EINVAL;
2323}
2324
2325
2326/*
2327 * Use this call to set the current regulatory domain. Conflicts with
2328 * multiple drivers can be ironed out later. Caller must've already
2329 * kmalloc'd the rd structure. Caller must hold cfg80211_mutex
2330 */
2331int set_regdom(const struct ieee80211_regdomain *rd)
2332{
2333        int r;
2334
2335        assert_cfg80211_lock();
2336
2337        mutex_lock(&reg_mutex);
2338
2339        /* Note that this doesn't update the wiphys, this is done below */
2340        r = __set_regdom(rd);
2341        if (r) {
2342                if (r == -EALREADY)
2343                        reg_set_request_processed();
2344
2345                kfree(rd);
2346                mutex_unlock(&reg_mutex);
2347                return r;
2348        }
2349
2350        /* This would make this whole thing pointless */
2351        if (!last_request->intersect)
2352                BUG_ON(rd != cfg80211_regdomain);
2353
2354        /* update all wiphys now with the new established regulatory domain */
2355        update_all_wiphy_regulatory(last_request->initiator);
2356
2357        print_regdomain(cfg80211_regdomain);
2358
2359        nl80211_send_reg_change_event(last_request);
2360
2361        reg_set_request_processed();
2362
2363        mutex_unlock(&reg_mutex);
2364
2365        return r;
2366}
2367
2368#ifdef CONFIG_HOTPLUG
2369int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
2370{
2371        if (last_request && !last_request->processed) {
2372                if (add_uevent_var(env, "COUNTRY=%c%c",
2373                                   last_request->alpha2[0],
2374                                   last_request->alpha2[1]))
2375                        return -ENOMEM;
2376        }
2377
2378        return 0;
2379}
2380#else
2381int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
2382{
2383        return -ENODEV;
2384}
2385#endif /* CONFIG_HOTPLUG */
2386
2387void wiphy_regulatory_register(struct wiphy *wiphy)
2388{
2389        assert_cfg80211_lock();
2390
2391        mutex_lock(&reg_mutex);
2392
2393        if (!reg_dev_ignore_cell_hint(wiphy))
2394                reg_num_devs_support_basehint++;
2395
2396        wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
2397
2398        mutex_unlock(&reg_mutex);
2399}
2400
2401/* Caller must hold cfg80211_mutex */
2402void wiphy_regulatory_deregister(struct wiphy *wiphy)
2403{
2404        struct wiphy *request_wiphy = NULL;
2405
2406        assert_cfg80211_lock();
2407
2408        mutex_lock(&reg_mutex);
2409
2410        if (!reg_dev_ignore_cell_hint(wiphy))
2411                reg_num_devs_support_basehint--;
2412
2413        kfree(wiphy->regd);
2414
2415        if (last_request)
2416                request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
2417
2418        if (!request_wiphy || request_wiphy != wiphy)
2419                goto out;
2420
2421        last_request->wiphy_idx = WIPHY_IDX_STALE;
2422        last_request->country_ie_env = ENVIRON_ANY;
2423out:
2424        mutex_unlock(&reg_mutex);
2425}
2426
2427static void reg_timeout_work(struct work_struct *work)
2428{
2429        REG_DBG_PRINT("Timeout while waiting for CRDA to reply, "
2430                      "restoring regulatory settings\n");
2431        restore_regulatory_settings(true);
2432}
2433
2434int __init regulatory_init(void)
2435{
2436        int err = 0;
2437
2438        reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2439        if (IS_ERR(reg_pdev))
2440                return PTR_ERR(reg_pdev);
2441
2442        reg_pdev->dev.type = &reg_device_type;
2443
2444        spin_lock_init(&reg_requests_lock);
2445        spin_lock_init(&reg_pending_beacons_lock);
2446
2447        reg_regdb_size_check();
2448
2449        cfg80211_regdomain = cfg80211_world_regdom;
2450
2451        user_alpha2[0] = '9';
2452        user_alpha2[1] = '7';
2453
2454        /* We always try to get an update for the static regdomain */
2455        err = regulatory_hint_core(cfg80211_regdomain->alpha2);
2456        if (err) {
2457                if (err == -ENOMEM)
2458                        return err;
2459                /*
2460                 * N.B. kobject_uevent_env() can fail mainly for when we're out
2461                 * memory which is handled and propagated appropriately above
2462                 * but it can also fail during a netlink_broadcast() or during
2463                 * early boot for call_usermodehelper(). For now treat these
2464                 * errors as non-fatal.
2465                 */
2466                pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
2467#ifdef CONFIG_CFG80211_REG_DEBUG
2468                /* We want to find out exactly why when debugging */
2469                WARN_ON(err);
2470#endif
2471        }
2472
2473        /*
2474         * Finally, if the user set the module parameter treat it
2475         * as a user hint.
2476         */
2477        if (!is_world_regdom(ieee80211_regdom))
2478                regulatory_hint_user(ieee80211_regdom,
2479                                     NL80211_USER_REG_HINT_USER);
2480
2481        return 0;
2482}
2483
2484void /* __init_or_exit */ regulatory_exit(void)
2485{
2486        struct regulatory_request *reg_request, *tmp;
2487        struct reg_beacon *reg_beacon, *btmp;
2488
2489        cancel_work_sync(&reg_work);
2490        cancel_delayed_work_sync(&reg_timeout);
2491
2492        mutex_lock(&cfg80211_mutex);
2493        mutex_lock(&reg_mutex);
2494
2495        reset_regdomains(true);
2496
2497        dev_set_uevent_suppress(&reg_pdev->dev, true);
2498
2499        platform_device_unregister(reg_pdev);
2500
2501        spin_lock_bh(&reg_pending_beacons_lock);
2502        if (!list_empty(&reg_pending_beacons)) {
2503                list_for_each_entry_safe(reg_beacon, btmp,
2504                                         &reg_pending_beacons, list) {
2505                        list_del(&reg_beacon->list);
2506                        kfree(reg_beacon);
2507                }
2508        }
2509        spin_unlock_bh(&reg_pending_beacons_lock);
2510
2511        if (!list_empty(&reg_beacon_list)) {
2512                list_for_each_entry_safe(reg_beacon, btmp,
2513                                         &reg_beacon_list, list) {
2514                        list_del(&reg_beacon->list);
2515                        kfree(reg_beacon);
2516                }
2517        }
2518
2519        spin_lock(&reg_requests_lock);
2520        if (!list_empty(&reg_requests_list)) {
2521                list_for_each_entry_safe(reg_request, tmp,
2522                                         &reg_requests_list, list) {
2523                        list_del(&reg_request->list);
2524                        kfree(reg_request);
2525                }
2526        }
2527        spin_unlock(&reg_requests_lock);
2528
2529        mutex_unlock(&reg_mutex);
2530        mutex_unlock(&cfg80211_mutex);
2531}
2532
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.