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 * Copyright 2013-2014 Intel Mobile Communications GmbH 7 * 8 * Permission to use, copy, modify, and/or distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 22 /** 23 * DOC: Wireless regulatory infrastructure 24 * 25 * The usual implementation is for a driver to read a device EEPROM to 26 * determine which regulatory domain it should be operating under, then 27 * looking up the allowable channels in a driver-local table and finally 28 * registering those channels in the wiphy structure. 29 * 30 * Another set of compliance enforcement is for drivers to use their 31 * own compliance limits which can be stored on the EEPROM. The host 32 * driver or firmware may ensure these are used. 33 * 34 * In addition to all this we provide an extra layer of regulatory 35 * conformance. For drivers which do not have any regulatory 36 * information CRDA provides the complete regulatory solution. 37 * For others it provides a community effort on further restrictions 38 * to enhance compliance. 39 * 40 * Note: When number of rules --> infinity we will not be able to 41 * index on alpha2 any more, instead we'll probably have to 42 * rely on some SHA1 checksum of the regdomain for example. 43 * 44 */ 45 46 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 47 48 #include <linux/kernel.h> 49 #include <linux/export.h> 50 #include <linux/slab.h> 51 #include <linux/list.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 "rdev-ops.h" 60 #include "regdb.h" 61 #include "nl80211.h" 62 63 #ifdef CONFIG_CFG80211_REG_DEBUG 64 #define REG_DBG_PRINT(format, args...) \ 65 printk(KERN_DEBUG pr_fmt(format), ##args) 66 #else 67 #define REG_DBG_PRINT(args...) 68 #endif 69 70 /* 71 * Grace period we give before making sure all current interfaces reside on 72 * channels allowed by the current regulatory domain. 73 */ 74 #define REG_ENFORCE_GRACE_MS 60000 75 76 /** 77 * enum reg_request_treatment - regulatory request treatment 78 * 79 * @REG_REQ_OK: continue processing the regulatory request 80 * @REG_REQ_IGNORE: ignore the regulatory request 81 * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should 82 * be intersected with the current one. 83 * @REG_REQ_ALREADY_SET: the regulatory request will not change the current 84 * regulatory settings, and no further processing is required. 85 */ 86 enum reg_request_treatment { 87 REG_REQ_OK, 88 REG_REQ_IGNORE, 89 REG_REQ_INTERSECT, 90 REG_REQ_ALREADY_SET, 91 }; 92 93 static struct regulatory_request core_request_world = { 94 .initiator = NL80211_REGDOM_SET_BY_CORE, 95 .alpha2[0] = '0', 96 .alpha2[1] = '0', 97 .intersect = false, 98 .processed = true, 99 .country_ie_env = ENVIRON_ANY, 100 }; 101 102 /* 103 * Receipt of information from last regulatory request, 104 * protected by RTNL (and can be accessed with RCU protection) 105 */ 106 static struct regulatory_request __rcu *last_request = 107 (void __force __rcu *)&core_request_world; 108 109 /* To trigger userspace events */ 110 static struct platform_device *reg_pdev; 111 112 /* 113 * Central wireless core regulatory domains, we only need two, 114 * the current one and a world regulatory domain in case we have no 115 * information to give us an alpha2. 116 * (protected by RTNL, can be read under RCU) 117 */ 118 const struct ieee80211_regdomain __rcu *cfg80211_regdomain; 119 120 /* 121 * Number of devices that registered to the core 122 * that support cellular base station regulatory hints 123 * (protected by RTNL) 124 */ 125 static int reg_num_devs_support_basehint; 126 127 /* 128 * State variable indicating if the platform on which the devices 129 * are attached is operating in an indoor environment. The state variable 130 * is relevant for all registered devices. 131 */ 132 static bool reg_is_indoor; 133 static spinlock_t reg_indoor_lock; 134 135 /* Used to track the userspace process controlling the indoor setting */ 136 static u32 reg_is_indoor_portid; 137 138 static void restore_regulatory_settings(bool reset_user); 139 140 static const struct ieee80211_regdomain *get_cfg80211_regdom(void) 141 { 142 return rtnl_dereference(cfg80211_regdomain); 143 } 144 145 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy) 146 { 147 return rtnl_dereference(wiphy->regd); 148 } 149 150 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region) 151 { 152 switch (dfs_region) { 153 case NL80211_DFS_UNSET: 154 return "unset"; 155 case NL80211_DFS_FCC: 156 return "FCC"; 157 case NL80211_DFS_ETSI: 158 return "ETSI"; 159 case NL80211_DFS_JP: 160 return "JP"; 161 } 162 return "Unknown"; 163 } 164 165 enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy) 166 { 167 const struct ieee80211_regdomain *regd = NULL; 168 const struct ieee80211_regdomain *wiphy_regd = NULL; 169 170 regd = get_cfg80211_regdom(); 171 if (!wiphy) 172 goto out; 173 174 wiphy_regd = get_wiphy_regdom(wiphy); 175 if (!wiphy_regd) 176 goto out; 177 178 if (wiphy_regd->dfs_region == regd->dfs_region) 179 goto out; 180 181 REG_DBG_PRINT("%s: device specific dfs_region " 182 "(%s) disagrees with cfg80211's " 183 "central dfs_region (%s)\n", 184 dev_name(&wiphy->dev), 185 reg_dfs_region_str(wiphy_regd->dfs_region), 186 reg_dfs_region_str(regd->dfs_region)); 187 188 out: 189 return regd->dfs_region; 190 } 191 192 static void rcu_free_regdom(const struct ieee80211_regdomain *r) 193 { 194 if (!r) 195 return; 196 kfree_rcu((struct ieee80211_regdomain *)r, rcu_head); 197 } 198 199 static struct regulatory_request *get_last_request(void) 200 { 201 return rcu_dereference_rtnl(last_request); 202 } 203 204 /* Used to queue up regulatory hints */ 205 static LIST_HEAD(reg_requests_list); 206 static spinlock_t reg_requests_lock; 207 208 /* Used to queue up beacon hints for review */ 209 static LIST_HEAD(reg_pending_beacons); 210 static spinlock_t reg_pending_beacons_lock; 211 212 /* Used to keep track of processed beacon hints */ 213 static LIST_HEAD(reg_beacon_list); 214 215 struct reg_beacon { 216 struct list_head list; 217 struct ieee80211_channel chan; 218 }; 219 220 static void reg_check_chans_work(struct work_struct *work); 221 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work); 222 223 static void reg_todo(struct work_struct *work); 224 static DECLARE_WORK(reg_work, reg_todo); 225 226 /* We keep a static world regulatory domain in case of the absence of CRDA */ 227 static const struct ieee80211_regdomain world_regdom = { 228 .n_reg_rules = 8, 229 .alpha2 = "00", 230 .reg_rules = { 231 /* IEEE 802.11b/g, channels 1..11 */ 232 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0), 233 /* IEEE 802.11b/g, channels 12..13. */ 234 REG_RULE(2467-10, 2472+10, 40, 6, 20, 235 NL80211_RRF_NO_IR), 236 /* IEEE 802.11 channel 14 - Only JP enables 237 * this and for 802.11b only */ 238 REG_RULE(2484-10, 2484+10, 20, 6, 20, 239 NL80211_RRF_NO_IR | 240 NL80211_RRF_NO_OFDM), 241 /* IEEE 802.11a, channel 36..48 */ 242 REG_RULE(5180-10, 5240+10, 160, 6, 20, 243 NL80211_RRF_NO_IR), 244 245 /* IEEE 802.11a, channel 52..64 - DFS required */ 246 REG_RULE(5260-10, 5320+10, 160, 6, 20, 247 NL80211_RRF_NO_IR | 248 NL80211_RRF_DFS), 249 250 /* IEEE 802.11a, channel 100..144 - DFS required */ 251 REG_RULE(5500-10, 5720+10, 160, 6, 20, 252 NL80211_RRF_NO_IR | 253 NL80211_RRF_DFS), 254 255 /* IEEE 802.11a, channel 149..165 */ 256 REG_RULE(5745-10, 5825+10, 80, 6, 20, 257 NL80211_RRF_NO_IR), 258 259 /* IEEE 802.11ad (60GHz), channels 1..3 */ 260 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0), 261 } 262 }; 263 264 /* protected by RTNL */ 265 static const struct ieee80211_regdomain *cfg80211_world_regdom = 266 &world_regdom; 267 268 static char *ieee80211_regdom = "00"; 269 static char user_alpha2[2]; 270 271 module_param(ieee80211_regdom, charp, 0444); 272 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code"); 273 274 static void reg_free_request(struct regulatory_request *request) 275 { 276 if (request == &core_request_world) 277 return; 278 279 if (request != get_last_request()) 280 kfree(request); 281 } 282 283 static void reg_free_last_request(void) 284 { 285 struct regulatory_request *lr = get_last_request(); 286 287 if (lr != &core_request_world && lr) 288 kfree_rcu(lr, rcu_head); 289 } 290 291 static void reg_update_last_request(struct regulatory_request *request) 292 { 293 struct regulatory_request *lr; 294 295 lr = get_last_request(); 296 if (lr == request) 297 return; 298 299 reg_free_last_request(); 300 rcu_assign_pointer(last_request, request); 301 } 302 303 static void reset_regdomains(bool full_reset, 304 const struct ieee80211_regdomain *new_regdom) 305 { 306 const struct ieee80211_regdomain *r; 307 308 ASSERT_RTNL(); 309 310 r = get_cfg80211_regdom(); 311 312 /* avoid freeing static information or freeing something twice */ 313 if (r == cfg80211_world_regdom) 314 r = NULL; 315 if (cfg80211_world_regdom == &world_regdom) 316 cfg80211_world_regdom = NULL; 317 if (r == &world_regdom) 318 r = NULL; 319 320 rcu_free_regdom(r); 321 rcu_free_regdom(cfg80211_world_regdom); 322 323 cfg80211_world_regdom = &world_regdom; 324 rcu_assign_pointer(cfg80211_regdomain, new_regdom); 325 326 if (!full_reset) 327 return; 328 329 reg_update_last_request(&core_request_world); 330 } 331 332 /* 333 * Dynamic world regulatory domain requested by the wireless 334 * core upon initialization 335 */ 336 static void update_world_regdomain(const struct ieee80211_regdomain *rd) 337 { 338 struct regulatory_request *lr; 339 340 lr = get_last_request(); 341 342 WARN_ON(!lr); 343 344 reset_regdomains(false, rd); 345 346 cfg80211_world_regdom = rd; 347 } 348 349 bool is_world_regdom(const char *alpha2) 350 { 351 if (!alpha2) 352 return false; 353 return alpha2[0] == '0' && alpha2[1] == '0'; 354 } 355 356 static bool is_alpha2_set(const char *alpha2) 357 { 358 if (!alpha2) 359 return false; 360 return alpha2[0] && alpha2[1]; 361 } 362 363 static bool is_unknown_alpha2(const char *alpha2) 364 { 365 if (!alpha2) 366 return false; 367 /* 368 * Special case where regulatory domain was built by driver 369 * but a specific alpha2 cannot be determined 370 */ 371 return alpha2[0] == '9' && alpha2[1] == '9'; 372 } 373 374 static bool is_intersected_alpha2(const char *alpha2) 375 { 376 if (!alpha2) 377 return false; 378 /* 379 * Special case where regulatory domain is the 380 * result of an intersection between two regulatory domain 381 * structures 382 */ 383 return alpha2[0] == '9' && alpha2[1] == '8'; 384 } 385 386 static bool is_an_alpha2(const char *alpha2) 387 { 388 if (!alpha2) 389 return false; 390 return isalpha(alpha2[0]) && isalpha(alpha2[1]); 391 } 392 393 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y) 394 { 395 if (!alpha2_x || !alpha2_y) 396 return false; 397 return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1]; 398 } 399 400 static bool regdom_changes(const char *alpha2) 401 { 402 const struct ieee80211_regdomain *r = get_cfg80211_regdom(); 403 404 if (!r) 405 return true; 406 return !alpha2_equal(r->alpha2, alpha2); 407 } 408 409 /* 410 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets 411 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER 412 * has ever been issued. 413 */ 414 static bool is_user_regdom_saved(void) 415 { 416 if (user_alpha2[0] == '9' && user_alpha2[1] == '7') 417 return false; 418 419 /* This would indicate a mistake on the design */ 420 if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2), 421 "Unexpected user alpha2: %c%c\n", 422 user_alpha2[0], user_alpha2[1])) 423 return false; 424 425 return true; 426 } 427 428 static const struct ieee80211_regdomain * 429 reg_copy_regd(const struct ieee80211_regdomain *src_regd) 430 { 431 struct ieee80211_regdomain *regd; 432 int size_of_regd; 433 unsigned int i; 434 435 size_of_regd = 436 sizeof(struct ieee80211_regdomain) + 437 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule); 438 439 regd = kzalloc(size_of_regd, GFP_KERNEL); 440 if (!regd) 441 return ERR_PTR(-ENOMEM); 442 443 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain)); 444 445 for (i = 0; i < src_regd->n_reg_rules; i++) 446 memcpy(®d->reg_rules[i], &src_regd->reg_rules[i], 447 sizeof(struct ieee80211_reg_rule)); 448 449 return regd; 450 } 451 452 #ifdef CONFIG_CFG80211_INTERNAL_REGDB 453 struct reg_regdb_apply_request { 454 struct list_head list; 455 const struct ieee80211_regdomain *regdom; 456 }; 457 458 static LIST_HEAD(reg_regdb_apply_list); 459 static DEFINE_MUTEX(reg_regdb_apply_mutex); 460 461 static void reg_regdb_apply(struct work_struct *work) 462 { 463 struct reg_regdb_apply_request *request; 464 465 rtnl_lock(); 466 467 mutex_lock(®_regdb_apply_mutex); 468 while (!list_empty(®_regdb_apply_list)) { 469 request = list_first_entry(®_regdb_apply_list, 470 struct reg_regdb_apply_request, 471 list); 472 list_del(&request->list); 473 474 set_regdom(request->regdom, REGD_SOURCE_INTERNAL_DB); 475 kfree(request); 476 } 477 mutex_unlock(®_regdb_apply_mutex); 478 479 rtnl_unlock(); 480 } 481 482 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply); 483 484 static int reg_query_builtin(const char *alpha2) 485 { 486 const struct ieee80211_regdomain *regdom = NULL; 487 struct reg_regdb_apply_request *request; 488 unsigned int i; 489 490 for (i = 0; i < reg_regdb_size; i++) { 491 if (alpha2_equal(alpha2, reg_regdb[i]->alpha2)) { 492 regdom = reg_regdb[i]; 493 break; 494 } 495 } 496 497 if (!regdom) 498 return -ENODATA; 499 500 request = kzalloc(sizeof(struct reg_regdb_apply_request), GFP_KERNEL); 501 if (!request) 502 return -ENOMEM; 503 504 request->regdom = reg_copy_regd(regdom); 505 if (IS_ERR_OR_NULL(request->regdom)) { 506 kfree(request); 507 return -ENOMEM; 508 } 509 510 mutex_lock(®_regdb_apply_mutex); 511 list_add_tail(&request->list, ®_regdb_apply_list); 512 mutex_unlock(®_regdb_apply_mutex); 513 514 schedule_work(®_regdb_work); 515 516 return 0; 517 } 518 519 /* Feel free to add any other sanity checks here */ 520 static void reg_regdb_size_check(void) 521 { 522 /* We should ideally BUILD_BUG_ON() but then random builds would fail */ 523 WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it..."); 524 } 525 #else 526 static inline void reg_regdb_size_check(void) {} 527 static inline int reg_query_builtin(const char *alpha2) 528 { 529 return -ENODATA; 530 } 531 #endif /* CONFIG_CFG80211_INTERNAL_REGDB */ 532 533 #ifdef CONFIG_CFG80211_CRDA_SUPPORT 534 /* Max number of consecutive attempts to communicate with CRDA */ 535 #define REG_MAX_CRDA_TIMEOUTS 10 536 537 static u32 reg_crda_timeouts; 538 539 static void crda_timeout_work(struct work_struct *work); 540 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work); 541 542 static void crda_timeout_work(struct work_struct *work) 543 { 544 REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n"); 545 rtnl_lock(); 546 reg_crda_timeouts++; 547 restore_regulatory_settings(true); 548 rtnl_unlock(); 549 } 550 551 static void cancel_crda_timeout(void) 552 { 553 cancel_delayed_work(&crda_timeout); 554 } 555 556 static void cancel_crda_timeout_sync(void) 557 { 558 cancel_delayed_work_sync(&crda_timeout); 559 } 560 561 static void reset_crda_timeouts(void) 562 { 563 reg_crda_timeouts = 0; 564 } 565 566 /* 567 * This lets us keep regulatory code which is updated on a regulatory 568 * basis in userspace. 569 */ 570 static int call_crda(const char *alpha2) 571 { 572 char country[12]; 573 char *env[] = { country, NULL }; 574 int ret; 575 576 snprintf(country, sizeof(country), "COUNTRY=%c%c", 577 alpha2[0], alpha2[1]); 578 579 if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) { 580 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n"); 581 return -EINVAL; 582 } 583 584 if (!is_world_regdom((char *) alpha2)) 585 pr_debug("Calling CRDA for country: %c%c\n", 586 alpha2[0], alpha2[1]); 587 else 588 pr_debug("Calling CRDA to update world regulatory domain\n"); 589 590 ret = kobject_uevent_env(®_pdev->dev.kobj, KOBJ_CHANGE, env); 591 if (ret) 592 return ret; 593 594 queue_delayed_work(system_power_efficient_wq, 595 &crda_timeout, msecs_to_jiffies(3142)); 596 return 0; 597 } 598 #else 599 static inline void cancel_crda_timeout(void) {} 600 static inline void cancel_crda_timeout_sync(void) {} 601 static inline void reset_crda_timeouts(void) {} 602 static inline int call_crda(const char *alpha2) 603 { 604 return -ENODATA; 605 } 606 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */ 607 608 static bool reg_query_database(struct regulatory_request *request) 609 { 610 /* query internal regulatory database (if it exists) */ 611 if (reg_query_builtin(request->alpha2) == 0) 612 return true; 613 614 if (call_crda(request->alpha2) == 0) 615 return true; 616 617 return false; 618 } 619 620 bool reg_is_valid_request(const char *alpha2) 621 { 622 struct regulatory_request *lr = get_last_request(); 623 624 if (!lr || lr->processed) 625 return false; 626 627 return alpha2_equal(lr->alpha2, alpha2); 628 } 629 630 static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy) 631 { 632 struct regulatory_request *lr = get_last_request(); 633 634 /* 635 * Follow the driver's regulatory domain, if present, unless a country 636 * IE has been processed or a user wants to help complaince further 637 */ 638 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 639 lr->initiator != NL80211_REGDOM_SET_BY_USER && 640 wiphy->regd) 641 return get_wiphy_regdom(wiphy); 642 643 return get_cfg80211_regdom(); 644 } 645 646 static unsigned int 647 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd, 648 const struct ieee80211_reg_rule *rule) 649 { 650 const struct ieee80211_freq_range *freq_range = &rule->freq_range; 651 const struct ieee80211_freq_range *freq_range_tmp; 652 const struct ieee80211_reg_rule *tmp; 653 u32 start_freq, end_freq, idx, no; 654 655 for (idx = 0; idx < rd->n_reg_rules; idx++) 656 if (rule == &rd->reg_rules[idx]) 657 break; 658 659 if (idx == rd->n_reg_rules) 660 return 0; 661 662 /* get start_freq */ 663 no = idx; 664 665 while (no) { 666 tmp = &rd->reg_rules[--no]; 667 freq_range_tmp = &tmp->freq_range; 668 669 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz) 670 break; 671 672 freq_range = freq_range_tmp; 673 } 674 675 start_freq = freq_range->start_freq_khz; 676 677 /* get end_freq */ 678 freq_range = &rule->freq_range; 679 no = idx; 680 681 while (no < rd->n_reg_rules - 1) { 682 tmp = &rd->reg_rules[++no]; 683 freq_range_tmp = &tmp->freq_range; 684 685 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz) 686 break; 687 688 freq_range = freq_range_tmp; 689 } 690 691 end_freq = freq_range->end_freq_khz; 692 693 return end_freq - start_freq; 694 } 695 696 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd, 697 const struct ieee80211_reg_rule *rule) 698 { 699 unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule); 700 701 if (rule->flags & NL80211_RRF_NO_160MHZ) 702 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80)); 703 if (rule->flags & NL80211_RRF_NO_80MHZ) 704 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40)); 705 706 /* 707 * HT40+/HT40- limits are handled per-channel. Only limit BW if both 708 * are not allowed. 709 */ 710 if (rule->flags & NL80211_RRF_NO_HT40MINUS && 711 rule->flags & NL80211_RRF_NO_HT40PLUS) 712 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20)); 713 714 return bw; 715 } 716 717 /* Sanity check on a regulatory rule */ 718 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule) 719 { 720 const struct ieee80211_freq_range *freq_range = &rule->freq_range; 721 u32 freq_diff; 722 723 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0) 724 return false; 725 726 if (freq_range->start_freq_khz > freq_range->end_freq_khz) 727 return false; 728 729 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz; 730 731 if (freq_range->end_freq_khz <= freq_range->start_freq_khz || 732 freq_range->max_bandwidth_khz > freq_diff) 733 return false; 734 735 return true; 736 } 737 738 static bool is_valid_rd(const struct ieee80211_regdomain *rd) 739 { 740 const struct ieee80211_reg_rule *reg_rule = NULL; 741 unsigned int i; 742 743 if (!rd->n_reg_rules) 744 return false; 745 746 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES)) 747 return false; 748 749 for (i = 0; i < rd->n_reg_rules; i++) { 750 reg_rule = &rd->reg_rules[i]; 751 if (!is_valid_reg_rule(reg_rule)) 752 return false; 753 } 754 755 return true; 756 } 757 758 static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range, 759 u32 center_freq_khz, u32 bw_khz) 760 { 761 u32 start_freq_khz, end_freq_khz; 762 763 start_freq_khz = center_freq_khz - (bw_khz/2); 764 end_freq_khz = center_freq_khz + (bw_khz/2); 765 766 if (start_freq_khz >= freq_range->start_freq_khz && 767 end_freq_khz <= freq_range->end_freq_khz) 768 return true; 769 770 return false; 771 } 772 773 /** 774 * freq_in_rule_band - tells us if a frequency is in a frequency band 775 * @freq_range: frequency rule we want to query 776 * @freq_khz: frequency we are inquiring about 777 * 778 * This lets us know if a specific frequency rule is or is not relevant to 779 * a specific frequency's band. Bands are device specific and artificial 780 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"), 781 * however it is safe for now to assume that a frequency rule should not be 782 * part of a frequency's band if the start freq or end freq are off by more 783 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the 784 * 60 GHz band. 785 * This resolution can be lowered and should be considered as we add 786 * regulatory rule support for other "bands". 787 **/ 788 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range, 789 u32 freq_khz) 790 { 791 #define ONE_GHZ_IN_KHZ 1000000 792 /* 793 * From 802.11ad: directional multi-gigabit (DMG): 794 * Pertaining to operation in a frequency band containing a channel 795 * with the Channel starting frequency above 45 GHz. 796 */ 797 u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ? 798 10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ; 799 if (abs(freq_khz - freq_range->start_freq_khz) <= limit) 800 return true; 801 if (abs(freq_khz - freq_range->end_freq_khz) <= limit) 802 return true; 803 return false; 804 #undef ONE_GHZ_IN_KHZ 805 } 806 807 /* 808 * Later on we can perhaps use the more restrictive DFS 809 * region but we don't have information for that yet so 810 * for now simply disallow conflicts. 811 */ 812 static enum nl80211_dfs_regions 813 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1, 814 const enum nl80211_dfs_regions dfs_region2) 815 { 816 if (dfs_region1 != dfs_region2) 817 return NL80211_DFS_UNSET; 818 return dfs_region1; 819 } 820 821 /* 822 * Helper for regdom_intersect(), this does the real 823 * mathematical intersection fun 824 */ 825 static int reg_rules_intersect(const struct ieee80211_regdomain *rd1, 826 const struct ieee80211_regdomain *rd2, 827 const struct ieee80211_reg_rule *rule1, 828 const struct ieee80211_reg_rule *rule2, 829 struct ieee80211_reg_rule *intersected_rule) 830 { 831 const struct ieee80211_freq_range *freq_range1, *freq_range2; 832 struct ieee80211_freq_range *freq_range; 833 const struct ieee80211_power_rule *power_rule1, *power_rule2; 834 struct ieee80211_power_rule *power_rule; 835 u32 freq_diff, max_bandwidth1, max_bandwidth2; 836 837 freq_range1 = &rule1->freq_range; 838 freq_range2 = &rule2->freq_range; 839 freq_range = &intersected_rule->freq_range; 840 841 power_rule1 = &rule1->power_rule; 842 power_rule2 = &rule2->power_rule; 843 power_rule = &intersected_rule->power_rule; 844 845 freq_range->start_freq_khz = max(freq_range1->start_freq_khz, 846 freq_range2->start_freq_khz); 847 freq_range->end_freq_khz = min(freq_range1->end_freq_khz, 848 freq_range2->end_freq_khz); 849 850 max_bandwidth1 = freq_range1->max_bandwidth_khz; 851 max_bandwidth2 = freq_range2->max_bandwidth_khz; 852 853 if (rule1->flags & NL80211_RRF_AUTO_BW) 854 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1); 855 if (rule2->flags & NL80211_RRF_AUTO_BW) 856 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2); 857 858 freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2); 859 860 intersected_rule->flags = rule1->flags | rule2->flags; 861 862 /* 863 * In case NL80211_RRF_AUTO_BW requested for both rules 864 * set AUTO_BW in intersected rule also. Next we will 865 * calculate BW correctly in handle_channel function. 866 * In other case remove AUTO_BW flag while we calculate 867 * maximum bandwidth correctly and auto calculation is 868 * not required. 869 */ 870 if ((rule1->flags & NL80211_RRF_AUTO_BW) && 871 (rule2->flags & NL80211_RRF_AUTO_BW)) 872 intersected_rule->flags |= NL80211_RRF_AUTO_BW; 873 else 874 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW; 875 876 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz; 877 if (freq_range->max_bandwidth_khz > freq_diff) 878 freq_range->max_bandwidth_khz = freq_diff; 879 880 power_rule->max_eirp = min(power_rule1->max_eirp, 881 power_rule2->max_eirp); 882 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain, 883 power_rule2->max_antenna_gain); 884 885 intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms, 886 rule2->dfs_cac_ms); 887 888 if (!is_valid_reg_rule(intersected_rule)) 889 return -EINVAL; 890 891 return 0; 892 } 893 894 /* check whether old rule contains new rule */ 895 static bool rule_contains(struct ieee80211_reg_rule *r1, 896 struct ieee80211_reg_rule *r2) 897 { 898 /* for simplicity, currently consider only same flags */ 899 if (r1->flags != r2->flags) 900 return false; 901 902 /* verify r1 is more restrictive */ 903 if ((r1->power_rule.max_antenna_gain > 904 r2->power_rule.max_antenna_gain) || 905 r1->power_rule.max_eirp > r2->power_rule.max_eirp) 906 return false; 907 908 /* make sure r2's range is contained within r1 */ 909 if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz || 910 r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz) 911 return false; 912 913 /* and finally verify that r1.max_bw >= r2.max_bw */ 914 if (r1->freq_range.max_bandwidth_khz < 915 r2->freq_range.max_bandwidth_khz) 916 return false; 917 918 return true; 919 } 920 921 /* add or extend current rules. do nothing if rule is already contained */ 922 static void add_rule(struct ieee80211_reg_rule *rule, 923 struct ieee80211_reg_rule *reg_rules, u32 *n_rules) 924 { 925 struct ieee80211_reg_rule *tmp_rule; 926 int i; 927 928 for (i = 0; i < *n_rules; i++) { 929 tmp_rule = ®_rules[i]; 930 /* rule is already contained - do nothing */ 931 if (rule_contains(tmp_rule, rule)) 932 return; 933 934 /* extend rule if possible */ 935 if (rule_contains(rule, tmp_rule)) { 936 memcpy(tmp_rule, rule, sizeof(*rule)); 937 return; 938 } 939 } 940 941 memcpy(®_rules[*n_rules], rule, sizeof(*rule)); 942 (*n_rules)++; 943 } 944 945 /** 946 * regdom_intersect - do the intersection between two regulatory domains 947 * @rd1: first regulatory domain 948 * @rd2: second regulatory domain 949 * 950 * Use this function to get the intersection between two regulatory domains. 951 * Once completed we will mark the alpha2 for the rd as intersected, "98", 952 * as no one single alpha2 can represent this regulatory domain. 953 * 954 * Returns a pointer to the regulatory domain structure which will hold the 955 * resulting intersection of rules between rd1 and rd2. We will 956 * kzalloc() this structure for you. 957 */ 958 static struct ieee80211_regdomain * 959 regdom_intersect(const struct ieee80211_regdomain *rd1, 960 const struct ieee80211_regdomain *rd2) 961 { 962 int r, size_of_regd; 963 unsigned int x, y; 964 unsigned int num_rules = 0; 965 const struct ieee80211_reg_rule *rule1, *rule2; 966 struct ieee80211_reg_rule intersected_rule; 967 struct ieee80211_regdomain *rd; 968 969 if (!rd1 || !rd2) 970 return NULL; 971 972 /* 973 * First we get a count of the rules we'll need, then we actually 974 * build them. This is to so we can malloc() and free() a 975 * regdomain once. The reason we use reg_rules_intersect() here 976 * is it will return -EINVAL if the rule computed makes no sense. 977 * All rules that do check out OK are valid. 978 */ 979 980 for (x = 0; x < rd1->n_reg_rules; x++) { 981 rule1 = &rd1->reg_rules[x]; 982 for (y = 0; y < rd2->n_reg_rules; y++) { 983 rule2 = &rd2->reg_rules[y]; 984 if (!reg_rules_intersect(rd1, rd2, rule1, rule2, 985 &intersected_rule)) 986 num_rules++; 987 } 988 } 989 990 if (!num_rules) 991 return NULL; 992 993 size_of_regd = sizeof(struct ieee80211_regdomain) + 994 num_rules * sizeof(struct ieee80211_reg_rule); 995 996 rd = kzalloc(size_of_regd, GFP_KERNEL); 997 if (!rd) 998 return NULL; 999 1000 for (x = 0; x < rd1->n_reg_rules; x++) { 1001 rule1 = &rd1->reg_rules[x]; 1002 for (y = 0; y < rd2->n_reg_rules; y++) { 1003 rule2 = &rd2->reg_rules[y]; 1004 r = reg_rules_intersect(rd1, rd2, rule1, rule2, 1005 &intersected_rule); 1006 /* 1007 * No need to memset here the intersected rule here as 1008 * we're not using the stack anymore 1009 */ 1010 if (r) 1011 continue; 1012 1013 add_rule(&intersected_rule, rd->reg_rules, 1014 &rd->n_reg_rules); 1015 } 1016 } 1017 1018 rd->alpha2[0] = '9'; 1019 rd->alpha2[1] = '8'; 1020 rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region, 1021 rd2->dfs_region); 1022 1023 return rd; 1024 } 1025 1026 /* 1027 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may 1028 * want to just have the channel structure use these 1029 */ 1030 static u32 map_regdom_flags(u32 rd_flags) 1031 { 1032 u32 channel_flags = 0; 1033 if (rd_flags & NL80211_RRF_NO_IR_ALL) 1034 channel_flags |= IEEE80211_CHAN_NO_IR; 1035 if (rd_flags & NL80211_RRF_DFS) 1036 channel_flags |= IEEE80211_CHAN_RADAR; 1037 if (rd_flags & NL80211_RRF_NO_OFDM) 1038 channel_flags |= IEEE80211_CHAN_NO_OFDM; 1039 if (rd_flags & NL80211_RRF_NO_OUTDOOR) 1040 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY; 1041 if (rd_flags & NL80211_RRF_IR_CONCURRENT) 1042 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT; 1043 if (rd_flags & NL80211_RRF_NO_HT40MINUS) 1044 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS; 1045 if (rd_flags & NL80211_RRF_NO_HT40PLUS) 1046 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS; 1047 if (rd_flags & NL80211_RRF_NO_80MHZ) 1048 channel_flags |= IEEE80211_CHAN_NO_80MHZ; 1049 if (rd_flags & NL80211_RRF_NO_160MHZ) 1050 channel_flags |= IEEE80211_CHAN_NO_160MHZ; 1051 return channel_flags; 1052 } 1053 1054 static const struct ieee80211_reg_rule * 1055 freq_reg_info_regd(u32 center_freq, 1056 const struct ieee80211_regdomain *regd, u32 bw) 1057 { 1058 int i; 1059 bool band_rule_found = false; 1060 bool bw_fits = false; 1061 1062 if (!regd) 1063 return ERR_PTR(-EINVAL); 1064 1065 for (i = 0; i < regd->n_reg_rules; i++) { 1066 const struct ieee80211_reg_rule *rr; 1067 const struct ieee80211_freq_range *fr = NULL; 1068 1069 rr = ®d->reg_rules[i]; 1070 fr = &rr->freq_range; 1071 1072 /* 1073 * We only need to know if one frequency rule was 1074 * was in center_freq's band, that's enough, so lets 1075 * not overwrite it once found 1076 */ 1077 if (!band_rule_found) 1078 band_rule_found = freq_in_rule_band(fr, center_freq); 1079 1080 bw_fits = reg_does_bw_fit(fr, center_freq, bw); 1081 1082 if (band_rule_found && bw_fits) 1083 return rr; 1084 } 1085 1086 if (!band_rule_found) 1087 return ERR_PTR(-ERANGE); 1088 1089 return ERR_PTR(-EINVAL); 1090 } 1091 1092 static const struct ieee80211_reg_rule * 1093 __freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw) 1094 { 1095 const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy); 1096 const struct ieee80211_reg_rule *reg_rule = NULL; 1097 u32 bw; 1098 1099 for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) { 1100 reg_rule = freq_reg_info_regd(center_freq, regd, bw); 1101 if (!IS_ERR(reg_rule)) 1102 return reg_rule; 1103 } 1104 1105 return reg_rule; 1106 } 1107 1108 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy, 1109 u32 center_freq) 1110 { 1111 return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(20)); 1112 } 1113 EXPORT_SYMBOL(freq_reg_info); 1114 1115 const char *reg_initiator_name(enum nl80211_reg_initiator initiator) 1116 { 1117 switch (initiator) { 1118 case NL80211_REGDOM_SET_BY_CORE: 1119 return "core"; 1120 case NL80211_REGDOM_SET_BY_USER: 1121 return "user"; 1122 case NL80211_REGDOM_SET_BY_DRIVER: 1123 return "driver"; 1124 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 1125 return "country IE"; 1126 default: 1127 WARN_ON(1); 1128 return "bug"; 1129 } 1130 } 1131 EXPORT_SYMBOL(reg_initiator_name); 1132 1133 static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain *regd, 1134 struct ieee80211_channel *chan, 1135 const struct ieee80211_reg_rule *reg_rule) 1136 { 1137 #ifdef CONFIG_CFG80211_REG_DEBUG 1138 const struct ieee80211_power_rule *power_rule; 1139 const struct ieee80211_freq_range *freq_range; 1140 char max_antenna_gain[32], bw[32]; 1141 1142 power_rule = ®_rule->power_rule; 1143 freq_range = ®_rule->freq_range; 1144 1145 if (!power_rule->max_antenna_gain) 1146 snprintf(max_antenna_gain, sizeof(max_antenna_gain), "N/A"); 1147 else 1148 snprintf(max_antenna_gain, sizeof(max_antenna_gain), "%d mBi", 1149 power_rule->max_antenna_gain); 1150 1151 if (reg_rule->flags & NL80211_RRF_AUTO_BW) 1152 snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO", 1153 freq_range->max_bandwidth_khz, 1154 reg_get_max_bandwidth(regd, reg_rule)); 1155 else 1156 snprintf(bw, sizeof(bw), "%d KHz", 1157 freq_range->max_bandwidth_khz); 1158 1159 REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n", 1160 chan->center_freq); 1161 1162 REG_DBG_PRINT("(%d KHz - %d KHz @ %s), (%s, %d mBm)\n", 1163 freq_range->start_freq_khz, freq_range->end_freq_khz, 1164 bw, max_antenna_gain, 1165 power_rule->max_eirp); 1166 #endif 1167 } 1168 1169 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd, 1170 const struct ieee80211_reg_rule *reg_rule, 1171 const struct ieee80211_channel *chan) 1172 { 1173 const struct ieee80211_freq_range *freq_range = NULL; 1174 u32 max_bandwidth_khz, bw_flags = 0; 1175 1176 freq_range = ®_rule->freq_range; 1177 1178 max_bandwidth_khz = freq_range->max_bandwidth_khz; 1179 /* Check if auto calculation requested */ 1180 if (reg_rule->flags & NL80211_RRF_AUTO_BW) 1181 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule); 1182 1183 /* If we get a reg_rule we can assume that at least 5Mhz fit */ 1184 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq), 1185 MHZ_TO_KHZ(10))) 1186 bw_flags |= IEEE80211_CHAN_NO_10MHZ; 1187 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq), 1188 MHZ_TO_KHZ(20))) 1189 bw_flags |= IEEE80211_CHAN_NO_20MHZ; 1190 1191 if (max_bandwidth_khz < MHZ_TO_KHZ(10)) 1192 bw_flags |= IEEE80211_CHAN_NO_10MHZ; 1193 if (max_bandwidth_khz < MHZ_TO_KHZ(20)) 1194 bw_flags |= IEEE80211_CHAN_NO_20MHZ; 1195 if (max_bandwidth_khz < MHZ_TO_KHZ(40)) 1196 bw_flags |= IEEE80211_CHAN_NO_HT40; 1197 if (max_bandwidth_khz < MHZ_TO_KHZ(80)) 1198 bw_flags |= IEEE80211_CHAN_NO_80MHZ; 1199 if (max_bandwidth_khz < MHZ_TO_KHZ(160)) 1200 bw_flags |= IEEE80211_CHAN_NO_160MHZ; 1201 return bw_flags; 1202 } 1203 1204 /* 1205 * Note that right now we assume the desired channel bandwidth 1206 * is always 20 MHz for each individual channel (HT40 uses 20 MHz 1207 * per channel, the primary and the extension channel). 1208 */ 1209 static void handle_channel(struct wiphy *wiphy, 1210 enum nl80211_reg_initiator initiator, 1211 struct ieee80211_channel *chan) 1212 { 1213 u32 flags, bw_flags = 0; 1214 const struct ieee80211_reg_rule *reg_rule = NULL; 1215 const struct ieee80211_power_rule *power_rule = NULL; 1216 struct wiphy *request_wiphy = NULL; 1217 struct regulatory_request *lr = get_last_request(); 1218 const struct ieee80211_regdomain *regd; 1219 1220 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 1221 1222 flags = chan->orig_flags; 1223 1224 reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq)); 1225 if (IS_ERR(reg_rule)) { 1226 /* 1227 * We will disable all channels that do not match our 1228 * received regulatory rule unless the hint is coming 1229 * from a Country IE and the Country IE had no information 1230 * about a band. The IEEE 802.11 spec allows for an AP 1231 * to send only a subset of the regulatory rules allowed, 1232 * so an AP in the US that only supports 2.4 GHz may only send 1233 * a country IE with information for the 2.4 GHz band 1234 * while 5 GHz is still supported. 1235 */ 1236 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 1237 PTR_ERR(reg_rule) == -ERANGE) 1238 return; 1239 1240 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1241 request_wiphy && request_wiphy == wiphy && 1242 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 1243 REG_DBG_PRINT("Disabling freq %d MHz for good\n", 1244 chan->center_freq); 1245 chan->orig_flags |= IEEE80211_CHAN_DISABLED; 1246 chan->flags = chan->orig_flags; 1247 } else { 1248 REG_DBG_PRINT("Disabling freq %d MHz\n", 1249 chan->center_freq); 1250 chan->flags |= IEEE80211_CHAN_DISABLED; 1251 } 1252 return; 1253 } 1254 1255 regd = reg_get_regdomain(wiphy); 1256 chan_reg_rule_print_dbg(regd, chan, reg_rule); 1257 1258 power_rule = ®_rule->power_rule; 1259 bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan); 1260 1261 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1262 request_wiphy && request_wiphy == wiphy && 1263 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 1264 /* 1265 * This guarantees the driver's requested regulatory domain 1266 * will always be used as a base for further regulatory 1267 * settings 1268 */ 1269 chan->flags = chan->orig_flags = 1270 map_regdom_flags(reg_rule->flags) | bw_flags; 1271 chan->max_antenna_gain = chan->orig_mag = 1272 (int) MBI_TO_DBI(power_rule->max_antenna_gain); 1273 chan->max_reg_power = chan->max_power = chan->orig_mpwr = 1274 (int) MBM_TO_DBM(power_rule->max_eirp); 1275 1276 if (chan->flags & IEEE80211_CHAN_RADAR) { 1277 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1278 if (reg_rule->dfs_cac_ms) 1279 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 1280 } 1281 1282 return; 1283 } 1284 1285 chan->dfs_state = NL80211_DFS_USABLE; 1286 chan->dfs_state_entered = jiffies; 1287 1288 chan->beacon_found = false; 1289 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags); 1290 chan->max_antenna_gain = 1291 min_t(int, chan->orig_mag, 1292 MBI_TO_DBI(power_rule->max_antenna_gain)); 1293 chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp); 1294 1295 if (chan->flags & IEEE80211_CHAN_RADAR) { 1296 if (reg_rule->dfs_cac_ms) 1297 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 1298 else 1299 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1300 } 1301 1302 if (chan->orig_mpwr) { 1303 /* 1304 * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER 1305 * will always follow the passed country IE power settings. 1306 */ 1307 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 1308 wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER) 1309 chan->max_power = chan->max_reg_power; 1310 else 1311 chan->max_power = min(chan->orig_mpwr, 1312 chan->max_reg_power); 1313 } else 1314 chan->max_power = chan->max_reg_power; 1315 } 1316 1317 static void handle_band(struct wiphy *wiphy, 1318 enum nl80211_reg_initiator initiator, 1319 struct ieee80211_supported_band *sband) 1320 { 1321 unsigned int i; 1322 1323 if (!sband) 1324 return; 1325 1326 for (i = 0; i < sband->n_channels; i++) 1327 handle_channel(wiphy, initiator, &sband->channels[i]); 1328 } 1329 1330 static bool reg_request_cell_base(struct regulatory_request *request) 1331 { 1332 if (request->initiator != NL80211_REGDOM_SET_BY_USER) 1333 return false; 1334 return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE; 1335 } 1336 1337 bool reg_last_request_cell_base(void) 1338 { 1339 return reg_request_cell_base(get_last_request()); 1340 } 1341 1342 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS 1343 /* Core specific check */ 1344 static enum reg_request_treatment 1345 reg_ignore_cell_hint(struct regulatory_request *pending_request) 1346 { 1347 struct regulatory_request *lr = get_last_request(); 1348 1349 if (!reg_num_devs_support_basehint) 1350 return REG_REQ_IGNORE; 1351 1352 if (reg_request_cell_base(lr) && 1353 !regdom_changes(pending_request->alpha2)) 1354 return REG_REQ_ALREADY_SET; 1355 1356 return REG_REQ_OK; 1357 } 1358 1359 /* Device specific check */ 1360 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy) 1361 { 1362 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS); 1363 } 1364 #else 1365 static enum reg_request_treatment 1366 reg_ignore_cell_hint(struct regulatory_request *pending_request) 1367 { 1368 return REG_REQ_IGNORE; 1369 } 1370 1371 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy) 1372 { 1373 return true; 1374 } 1375 #endif 1376 1377 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy) 1378 { 1379 if (wiphy->regulatory_flags & REGULATORY_STRICT_REG && 1380 !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)) 1381 return true; 1382 return false; 1383 } 1384 1385 static bool ignore_reg_update(struct wiphy *wiphy, 1386 enum nl80211_reg_initiator initiator) 1387 { 1388 struct regulatory_request *lr = get_last_request(); 1389 1390 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 1391 return true; 1392 1393 if (!lr) { 1394 REG_DBG_PRINT("Ignoring regulatory request set by %s " 1395 "since last_request is not set\n", 1396 reg_initiator_name(initiator)); 1397 return true; 1398 } 1399 1400 if (initiator == NL80211_REGDOM_SET_BY_CORE && 1401 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) { 1402 REG_DBG_PRINT("Ignoring regulatory request set by %s " 1403 "since the driver uses its own custom " 1404 "regulatory domain\n", 1405 reg_initiator_name(initiator)); 1406 return true; 1407 } 1408 1409 /* 1410 * wiphy->regd will be set once the device has its own 1411 * desired regulatory domain set 1412 */ 1413 if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd && 1414 initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 1415 !is_world_regdom(lr->alpha2)) { 1416 REG_DBG_PRINT("Ignoring regulatory request set by %s " 1417 "since the driver requires its own regulatory " 1418 "domain to be set first\n", 1419 reg_initiator_name(initiator)); 1420 return true; 1421 } 1422 1423 if (reg_request_cell_base(lr)) 1424 return reg_dev_ignore_cell_hint(wiphy); 1425 1426 return false; 1427 } 1428 1429 static bool reg_is_world_roaming(struct wiphy *wiphy) 1430 { 1431 const struct ieee80211_regdomain *cr = get_cfg80211_regdom(); 1432 const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy); 1433 struct regulatory_request *lr = get_last_request(); 1434 1435 if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2))) 1436 return true; 1437 1438 if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 1439 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) 1440 return true; 1441 1442 return false; 1443 } 1444 1445 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx, 1446 struct reg_beacon *reg_beacon) 1447 { 1448 struct ieee80211_supported_band *sband; 1449 struct ieee80211_channel *chan; 1450 bool channel_changed = false; 1451 struct ieee80211_channel chan_before; 1452 1453 sband = wiphy->bands[reg_beacon->chan.band]; 1454 chan = &sband->channels[chan_idx]; 1455 1456 if (likely(chan->center_freq != reg_beacon->chan.center_freq)) 1457 return; 1458 1459 if (chan->beacon_found) 1460 return; 1461 1462 chan->beacon_found = true; 1463 1464 if (!reg_is_world_roaming(wiphy)) 1465 return; 1466 1467 if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS) 1468 return; 1469 1470 chan_before.center_freq = chan->center_freq; 1471 chan_before.flags = chan->flags; 1472 1473 if (chan->flags & IEEE80211_CHAN_NO_IR) { 1474 chan->flags &= ~IEEE80211_CHAN_NO_IR; 1475 channel_changed = true; 1476 } 1477 1478 if (channel_changed) 1479 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan); 1480 } 1481 1482 /* 1483 * Called when a scan on a wiphy finds a beacon on 1484 * new channel 1485 */ 1486 static void wiphy_update_new_beacon(struct wiphy *wiphy, 1487 struct reg_beacon *reg_beacon) 1488 { 1489 unsigned int i; 1490 struct ieee80211_supported_band *sband; 1491 1492 if (!wiphy->bands[reg_beacon->chan.band]) 1493 return; 1494 1495 sband = wiphy->bands[reg_beacon->chan.band]; 1496 1497 for (i = 0; i < sband->n_channels; i++) 1498 handle_reg_beacon(wiphy, i, reg_beacon); 1499 } 1500 1501 /* 1502 * Called upon reg changes or a new wiphy is added 1503 */ 1504 static void wiphy_update_beacon_reg(struct wiphy *wiphy) 1505 { 1506 unsigned int i; 1507 struct ieee80211_supported_band *sband; 1508 struct reg_beacon *reg_beacon; 1509 1510 list_for_each_entry(reg_beacon, ®_beacon_list, list) { 1511 if (!wiphy->bands[reg_beacon->chan.band]) 1512 continue; 1513 sband = wiphy->bands[reg_beacon->chan.band]; 1514 for (i = 0; i < sband->n_channels; i++) 1515 handle_reg_beacon(wiphy, i, reg_beacon); 1516 } 1517 } 1518 1519 /* Reap the advantages of previously found beacons */ 1520 static void reg_process_beacons(struct wiphy *wiphy) 1521 { 1522 /* 1523 * Means we are just firing up cfg80211, so no beacons would 1524 * have been processed yet. 1525 */ 1526 if (!last_request) 1527 return; 1528 wiphy_update_beacon_reg(wiphy); 1529 } 1530 1531 static bool is_ht40_allowed(struct ieee80211_channel *chan) 1532 { 1533 if (!chan) 1534 return false; 1535 if (chan->flags & IEEE80211_CHAN_DISABLED) 1536 return false; 1537 /* This would happen when regulatory rules disallow HT40 completely */ 1538 if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40) 1539 return false; 1540 return true; 1541 } 1542 1543 static void reg_process_ht_flags_channel(struct wiphy *wiphy, 1544 struct ieee80211_channel *channel) 1545 { 1546 struct ieee80211_supported_band *sband = wiphy->bands[channel->band]; 1547 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL; 1548 unsigned int i; 1549 1550 if (!is_ht40_allowed(channel)) { 1551 channel->flags |= IEEE80211_CHAN_NO_HT40; 1552 return; 1553 } 1554 1555 /* 1556 * We need to ensure the extension channels exist to 1557 * be able to use HT40- or HT40+, this finds them (or not) 1558 */ 1559 for (i = 0; i < sband->n_channels; i++) { 1560 struct ieee80211_channel *c = &sband->channels[i]; 1561 1562 if (c->center_freq == (channel->center_freq - 20)) 1563 channel_before = c; 1564 if (c->center_freq == (channel->center_freq + 20)) 1565 channel_after = c; 1566 } 1567 1568 /* 1569 * Please note that this assumes target bandwidth is 20 MHz, 1570 * if that ever changes we also need to change the below logic 1571 * to include that as well. 1572 */ 1573 if (!is_ht40_allowed(channel_before)) 1574 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS; 1575 else 1576 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS; 1577 1578 if (!is_ht40_allowed(channel_after)) 1579 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS; 1580 else 1581 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS; 1582 } 1583 1584 static void reg_process_ht_flags_band(struct wiphy *wiphy, 1585 struct ieee80211_supported_band *sband) 1586 { 1587 unsigned int i; 1588 1589 if (!sband) 1590 return; 1591 1592 for (i = 0; i < sband->n_channels; i++) 1593 reg_process_ht_flags_channel(wiphy, &sband->channels[i]); 1594 } 1595 1596 static void reg_process_ht_flags(struct wiphy *wiphy) 1597 { 1598 enum ieee80211_band band; 1599 1600 if (!wiphy) 1601 return; 1602 1603 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 1604 reg_process_ht_flags_band(wiphy, wiphy->bands[band]); 1605 } 1606 1607 static void reg_call_notifier(struct wiphy *wiphy, 1608 struct regulatory_request *request) 1609 { 1610 if (wiphy->reg_notifier) 1611 wiphy->reg_notifier(wiphy, request); 1612 } 1613 1614 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev) 1615 { 1616 struct cfg80211_chan_def chandef; 1617 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 1618 enum nl80211_iftype iftype; 1619 1620 wdev_lock(wdev); 1621 iftype = wdev->iftype; 1622 1623 /* make sure the interface is active */ 1624 if (!wdev->netdev || !netif_running(wdev->netdev)) 1625 goto wdev_inactive_unlock; 1626 1627 switch (iftype) { 1628 case NL80211_IFTYPE_AP: 1629 case NL80211_IFTYPE_P2P_GO: 1630 if (!wdev->beacon_interval) 1631 goto wdev_inactive_unlock; 1632 chandef = wdev->chandef; 1633 break; 1634 case NL80211_IFTYPE_ADHOC: 1635 if (!wdev->ssid_len) 1636 goto wdev_inactive_unlock; 1637 chandef = wdev->chandef; 1638 break; 1639 case NL80211_IFTYPE_STATION: 1640 case NL80211_IFTYPE_P2P_CLIENT: 1641 if (!wdev->current_bss || 1642 !wdev->current_bss->pub.channel) 1643 goto wdev_inactive_unlock; 1644 1645 if (!rdev->ops->get_channel || 1646 rdev_get_channel(rdev, wdev, &chandef)) 1647 cfg80211_chandef_create(&chandef, 1648 wdev->current_bss->pub.channel, 1649 NL80211_CHAN_NO_HT); 1650 break; 1651 case NL80211_IFTYPE_MONITOR: 1652 case NL80211_IFTYPE_AP_VLAN: 1653 case NL80211_IFTYPE_P2P_DEVICE: 1654 /* no enforcement required */ 1655 break; 1656 default: 1657 /* others not implemented for now */ 1658 WARN_ON(1); 1659 break; 1660 } 1661 1662 wdev_unlock(wdev); 1663 1664 switch (iftype) { 1665 case NL80211_IFTYPE_AP: 1666 case NL80211_IFTYPE_P2P_GO: 1667 case NL80211_IFTYPE_ADHOC: 1668 return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype); 1669 case NL80211_IFTYPE_STATION: 1670 case NL80211_IFTYPE_P2P_CLIENT: 1671 return cfg80211_chandef_usable(wiphy, &chandef, 1672 IEEE80211_CHAN_DISABLED); 1673 default: 1674 break; 1675 } 1676 1677 return true; 1678 1679 wdev_inactive_unlock: 1680 wdev_unlock(wdev); 1681 return true; 1682 } 1683 1684 static void reg_leave_invalid_chans(struct wiphy *wiphy) 1685 { 1686 struct wireless_dev *wdev; 1687 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 1688 1689 ASSERT_RTNL(); 1690 1691 list_for_each_entry(wdev, &rdev->wdev_list, list) 1692 if (!reg_wdev_chan_valid(wiphy, wdev)) 1693 cfg80211_leave(rdev, wdev); 1694 } 1695 1696 static void reg_check_chans_work(struct work_struct *work) 1697 { 1698 struct cfg80211_registered_device *rdev; 1699 1700 REG_DBG_PRINT("Verifying active interfaces after reg change\n"); 1701 rtnl_lock(); 1702 1703 list_for_each_entry(rdev, &cfg80211_rdev_list, list) 1704 if (!(rdev->wiphy.regulatory_flags & 1705 REGULATORY_IGNORE_STALE_KICKOFF)) 1706 reg_leave_invalid_chans(&rdev->wiphy); 1707 1708 rtnl_unlock(); 1709 } 1710 1711 static void reg_check_channels(void) 1712 { 1713 /* 1714 * Give usermode a chance to do something nicer (move to another 1715 * channel, orderly disconnection), before forcing a disconnection. 1716 */ 1717 mod_delayed_work(system_power_efficient_wq, 1718 ®_check_chans, 1719 msecs_to_jiffies(REG_ENFORCE_GRACE_MS)); 1720 } 1721 1722 static void wiphy_update_regulatory(struct wiphy *wiphy, 1723 enum nl80211_reg_initiator initiator) 1724 { 1725 enum ieee80211_band band; 1726 struct regulatory_request *lr = get_last_request(); 1727 1728 if (ignore_reg_update(wiphy, initiator)) { 1729 /* 1730 * Regulatory updates set by CORE are ignored for custom 1731 * regulatory cards. Let us notify the changes to the driver, 1732 * as some drivers used this to restore its orig_* reg domain. 1733 */ 1734 if (initiator == NL80211_REGDOM_SET_BY_CORE && 1735 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) 1736 reg_call_notifier(wiphy, lr); 1737 return; 1738 } 1739 1740 lr->dfs_region = get_cfg80211_regdom()->dfs_region; 1741 1742 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 1743 handle_band(wiphy, initiator, wiphy->bands[band]); 1744 1745 reg_process_beacons(wiphy); 1746 reg_process_ht_flags(wiphy); 1747 reg_call_notifier(wiphy, lr); 1748 } 1749 1750 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator) 1751 { 1752 struct cfg80211_registered_device *rdev; 1753 struct wiphy *wiphy; 1754 1755 ASSERT_RTNL(); 1756 1757 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 1758 wiphy = &rdev->wiphy; 1759 wiphy_update_regulatory(wiphy, initiator); 1760 } 1761 1762 reg_check_channels(); 1763 } 1764 1765 static void handle_channel_custom(struct wiphy *wiphy, 1766 struct ieee80211_channel *chan, 1767 const struct ieee80211_regdomain *regd) 1768 { 1769 u32 bw_flags = 0; 1770 const struct ieee80211_reg_rule *reg_rule = NULL; 1771 const struct ieee80211_power_rule *power_rule = NULL; 1772 u32 bw; 1773 1774 for (bw = MHZ_TO_KHZ(20); bw >= MHZ_TO_KHZ(5); bw = bw / 2) { 1775 reg_rule = freq_reg_info_regd(MHZ_TO_KHZ(chan->center_freq), 1776 regd, bw); 1777 if (!IS_ERR(reg_rule)) 1778 break; 1779 } 1780 1781 if (IS_ERR(reg_rule)) { 1782 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n", 1783 chan->center_freq); 1784 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) { 1785 chan->flags |= IEEE80211_CHAN_DISABLED; 1786 } else { 1787 chan->orig_flags |= IEEE80211_CHAN_DISABLED; 1788 chan->flags = chan->orig_flags; 1789 } 1790 return; 1791 } 1792 1793 chan_reg_rule_print_dbg(regd, chan, reg_rule); 1794 1795 power_rule = ®_rule->power_rule; 1796 bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan); 1797 1798 chan->dfs_state_entered = jiffies; 1799 chan->dfs_state = NL80211_DFS_USABLE; 1800 1801 chan->beacon_found = false; 1802 1803 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 1804 chan->flags = chan->orig_flags | bw_flags | 1805 map_regdom_flags(reg_rule->flags); 1806 else 1807 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags; 1808 1809 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain); 1810 chan->max_reg_power = chan->max_power = 1811 (int) MBM_TO_DBM(power_rule->max_eirp); 1812 1813 if (chan->flags & IEEE80211_CHAN_RADAR) { 1814 if (reg_rule->dfs_cac_ms) 1815 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 1816 else 1817 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1818 } 1819 1820 chan->max_power = chan->max_reg_power; 1821 } 1822 1823 static void handle_band_custom(struct wiphy *wiphy, 1824 struct ieee80211_supported_band *sband, 1825 const struct ieee80211_regdomain *regd) 1826 { 1827 unsigned int i; 1828 1829 if (!sband) 1830 return; 1831 1832 for (i = 0; i < sband->n_channels; i++) 1833 handle_channel_custom(wiphy, &sband->channels[i], regd); 1834 } 1835 1836 /* Used by drivers prior to wiphy registration */ 1837 void wiphy_apply_custom_regulatory(struct wiphy *wiphy, 1838 const struct ieee80211_regdomain *regd) 1839 { 1840 enum ieee80211_band band; 1841 unsigned int bands_set = 0; 1842 1843 WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG), 1844 "wiphy should have REGULATORY_CUSTOM_REG\n"); 1845 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG; 1846 1847 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1848 if (!wiphy->bands[band]) 1849 continue; 1850 handle_band_custom(wiphy, wiphy->bands[band], regd); 1851 bands_set++; 1852 } 1853 1854 /* 1855 * no point in calling this if it won't have any effect 1856 * on your device's supported bands. 1857 */ 1858 WARN_ON(!bands_set); 1859 } 1860 EXPORT_SYMBOL(wiphy_apply_custom_regulatory); 1861 1862 static void reg_set_request_processed(void) 1863 { 1864 bool need_more_processing = false; 1865 struct regulatory_request *lr = get_last_request(); 1866 1867 lr->processed = true; 1868 1869 spin_lock(®_requests_lock); 1870 if (!list_empty(®_requests_list)) 1871 need_more_processing = true; 1872 spin_unlock(®_requests_lock); 1873 1874 cancel_crda_timeout(); 1875 1876 if (need_more_processing) 1877 schedule_work(®_work); 1878 } 1879 1880 /** 1881 * reg_process_hint_core - process core regulatory requests 1882 * @pending_request: a pending core regulatory request 1883 * 1884 * The wireless subsystem can use this function to process 1885 * a regulatory request issued by the regulatory core. 1886 */ 1887 static enum reg_request_treatment 1888 reg_process_hint_core(struct regulatory_request *core_request) 1889 { 1890 if (reg_query_database(core_request)) { 1891 core_request->intersect = false; 1892 core_request->processed = false; 1893 reg_update_last_request(core_request); 1894 return REG_REQ_OK; 1895 } 1896 1897 return REG_REQ_IGNORE; 1898 } 1899 1900 static enum reg_request_treatment 1901 __reg_process_hint_user(struct regulatory_request *user_request) 1902 { 1903 struct regulatory_request *lr = get_last_request(); 1904 1905 if (reg_request_cell_base(user_request)) 1906 return reg_ignore_cell_hint(user_request); 1907 1908 if (reg_request_cell_base(lr)) 1909 return REG_REQ_IGNORE; 1910 1911 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) 1912 return REG_REQ_INTERSECT; 1913 /* 1914 * If the user knows better the user should set the regdom 1915 * to their country before the IE is picked up 1916 */ 1917 if (lr->initiator == NL80211_REGDOM_SET_BY_USER && 1918 lr->intersect) 1919 return REG_REQ_IGNORE; 1920 /* 1921 * Process user requests only after previous user/driver/core 1922 * requests have been processed 1923 */ 1924 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE || 1925 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER || 1926 lr->initiator == NL80211_REGDOM_SET_BY_USER) && 1927 regdom_changes(lr->alpha2)) 1928 return REG_REQ_IGNORE; 1929 1930 if (!regdom_changes(user_request->alpha2)) 1931 return REG_REQ_ALREADY_SET; 1932 1933 return REG_REQ_OK; 1934 } 1935 1936 /** 1937 * reg_process_hint_user - process user regulatory requests 1938 * @user_request: a pending user regulatory request 1939 * 1940 * The wireless subsystem can use this function to process 1941 * a regulatory request initiated by userspace. 1942 */ 1943 static enum reg_request_treatment 1944 reg_process_hint_user(struct regulatory_request *user_request) 1945 { 1946 enum reg_request_treatment treatment; 1947 1948 treatment = __reg_process_hint_user(user_request); 1949 if (treatment == REG_REQ_IGNORE || 1950 treatment == REG_REQ_ALREADY_SET) 1951 return REG_REQ_IGNORE; 1952 1953 user_request->intersect = treatment == REG_REQ_INTERSECT; 1954 user_request->processed = false; 1955 1956 if (reg_query_database(user_request)) { 1957 reg_update_last_request(user_request); 1958 user_alpha2[0] = user_request->alpha2[0]; 1959 user_alpha2[1] = user_request->alpha2[1]; 1960 return REG_REQ_OK; 1961 } 1962 1963 return REG_REQ_IGNORE; 1964 } 1965 1966 static enum reg_request_treatment 1967 __reg_process_hint_driver(struct regulatory_request *driver_request) 1968 { 1969 struct regulatory_request *lr = get_last_request(); 1970 1971 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) { 1972 if (regdom_changes(driver_request->alpha2)) 1973 return REG_REQ_OK; 1974 return REG_REQ_ALREADY_SET; 1975 } 1976 1977 /* 1978 * This would happen if you unplug and plug your card 1979 * back in or if you add a new device for which the previously 1980 * loaded card also agrees on the regulatory domain. 1981 */ 1982 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1983 !regdom_changes(driver_request->alpha2)) 1984 return REG_REQ_ALREADY_SET; 1985 1986 return REG_REQ_INTERSECT; 1987 } 1988 1989 /** 1990 * reg_process_hint_driver - process driver regulatory requests 1991 * @driver_request: a pending driver regulatory request 1992 * 1993 * The wireless subsystem can use this function to process 1994 * a regulatory request issued by an 802.11 driver. 1995 * 1996 * Returns one of the different reg request treatment values. 1997 */ 1998 static enum reg_request_treatment 1999 reg_process_hint_driver(struct wiphy *wiphy, 2000 struct regulatory_request *driver_request) 2001 { 2002 const struct ieee80211_regdomain *regd, *tmp; 2003 enum reg_request_treatment treatment; 2004 2005 treatment = __reg_process_hint_driver(driver_request); 2006 2007 switch (treatment) { 2008 case REG_REQ_OK: 2009 break; 2010 case REG_REQ_IGNORE: 2011 return REG_REQ_IGNORE; 2012 case REG_REQ_INTERSECT: 2013 case REG_REQ_ALREADY_SET: 2014 regd = reg_copy_regd(get_cfg80211_regdom()); 2015 if (IS_ERR(regd)) 2016 return REG_REQ_IGNORE; 2017 2018 tmp = get_wiphy_regdom(wiphy); 2019 rcu_assign_pointer(wiphy->regd, regd); 2020 rcu_free_regdom(tmp); 2021 } 2022 2023 2024 driver_request->intersect = treatment == REG_REQ_INTERSECT; 2025 driver_request->processed = false; 2026 2027 /* 2028 * Since CRDA will not be called in this case as we already 2029 * have applied the requested regulatory domain before we just 2030 * inform userspace we have processed the request 2031 */ 2032 if (treatment == REG_REQ_ALREADY_SET) { 2033 nl80211_send_reg_change_event(driver_request); 2034 reg_update_last_request(driver_request); 2035 reg_set_request_processed(); 2036 return REG_REQ_ALREADY_SET; 2037 } 2038 2039 if (reg_query_database(driver_request)) { 2040 reg_update_last_request(driver_request); 2041 return REG_REQ_OK; 2042 } 2043 2044 return REG_REQ_IGNORE; 2045 } 2046 2047 static enum reg_request_treatment 2048 __reg_process_hint_country_ie(struct wiphy *wiphy, 2049 struct regulatory_request *country_ie_request) 2050 { 2051 struct wiphy *last_wiphy = NULL; 2052 struct regulatory_request *lr = get_last_request(); 2053 2054 if (reg_request_cell_base(lr)) { 2055 /* Trust a Cell base station over the AP's country IE */ 2056 if (regdom_changes(country_ie_request->alpha2)) 2057 return REG_REQ_IGNORE; 2058 return REG_REQ_ALREADY_SET; 2059 } else { 2060 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE) 2061 return REG_REQ_IGNORE; 2062 } 2063 2064 if (unlikely(!is_an_alpha2(country_ie_request->alpha2))) 2065 return -EINVAL; 2066 2067 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) 2068 return REG_REQ_OK; 2069 2070 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 2071 2072 if (last_wiphy != wiphy) { 2073 /* 2074 * Two cards with two APs claiming different 2075 * Country IE alpha2s. We could 2076 * intersect them, but that seems unlikely 2077 * to be correct. Reject second one for now. 2078 */ 2079 if (regdom_changes(country_ie_request->alpha2)) 2080 return REG_REQ_IGNORE; 2081 return REG_REQ_ALREADY_SET; 2082 } 2083 2084 if (regdom_changes(country_ie_request->alpha2)) 2085 return REG_REQ_OK; 2086 return REG_REQ_ALREADY_SET; 2087 } 2088 2089 /** 2090 * reg_process_hint_country_ie - process regulatory requests from country IEs 2091 * @country_ie_request: a regulatory request from a country IE 2092 * 2093 * The wireless subsystem can use this function to process 2094 * a regulatory request issued by a country Information Element. 2095 * 2096 * Returns one of the different reg request treatment values. 2097 */ 2098 static enum reg_request_treatment 2099 reg_process_hint_country_ie(struct wiphy *wiphy, 2100 struct regulatory_request *country_ie_request) 2101 { 2102 enum reg_request_treatment treatment; 2103 2104 treatment = __reg_process_hint_country_ie(wiphy, country_ie_request); 2105 2106 switch (treatment) { 2107 case REG_REQ_OK: 2108 break; 2109 case REG_REQ_IGNORE: 2110 return REG_REQ_IGNORE; 2111 case REG_REQ_ALREADY_SET: 2112 reg_free_request(country_ie_request); 2113 return REG_REQ_ALREADY_SET; 2114 case REG_REQ_INTERSECT: 2115 /* 2116 * This doesn't happen yet, not sure we 2117 * ever want to support it for this case. 2118 */ 2119 WARN_ONCE(1, "Unexpected intersection for country IEs"); 2120 return REG_REQ_IGNORE; 2121 } 2122 2123 country_ie_request->intersect = false; 2124 country_ie_request->processed = false; 2125 2126 if (reg_query_database(country_ie_request)) { 2127 reg_update_last_request(country_ie_request); 2128 return REG_REQ_OK; 2129 } 2130 2131 return REG_REQ_IGNORE; 2132 } 2133 2134 /* This processes *all* regulatory hints */ 2135 static void reg_process_hint(struct regulatory_request *reg_request) 2136 { 2137 struct wiphy *wiphy = NULL; 2138 enum reg_request_treatment treatment; 2139 2140 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID) 2141 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx); 2142 2143 switch (reg_request->initiator) { 2144 case NL80211_REGDOM_SET_BY_CORE: 2145 treatment = reg_process_hint_core(reg_request); 2146 break; 2147 case NL80211_REGDOM_SET_BY_USER: 2148 treatment = reg_process_hint_user(reg_request); 2149 break; 2150 case NL80211_REGDOM_SET_BY_DRIVER: 2151 if (!wiphy) 2152 goto out_free; 2153 treatment = reg_process_hint_driver(wiphy, reg_request); 2154 break; 2155 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 2156 if (!wiphy) 2157 goto out_free; 2158 treatment = reg_process_hint_country_ie(wiphy, reg_request); 2159 break; 2160 default: 2161 WARN(1, "invalid initiator %d\n", reg_request->initiator); 2162 goto out_free; 2163 } 2164 2165 if (treatment == REG_REQ_IGNORE) 2166 goto out_free; 2167 2168 WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET, 2169 "unexpected treatment value %d\n", treatment); 2170 2171 /* This is required so that the orig_* parameters are saved. 2172 * NOTE: treatment must be set for any case that reaches here! 2173 */ 2174 if (treatment == REG_REQ_ALREADY_SET && wiphy && 2175 wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 2176 wiphy_update_regulatory(wiphy, reg_request->initiator); 2177 reg_check_channels(); 2178 } 2179 2180 return; 2181 2182 out_free: 2183 reg_free_request(reg_request); 2184 } 2185 2186 static bool reg_only_self_managed_wiphys(void) 2187 { 2188 struct cfg80211_registered_device *rdev; 2189 struct wiphy *wiphy; 2190 bool self_managed_found = false; 2191 2192 ASSERT_RTNL(); 2193 2194 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2195 wiphy = &rdev->wiphy; 2196 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 2197 self_managed_found = true; 2198 else 2199 return false; 2200 } 2201 2202 /* make sure at least one self-managed wiphy exists */ 2203 return self_managed_found; 2204 } 2205 2206 /* 2207 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_* 2208 * Regulatory hints come on a first come first serve basis and we 2209 * must process each one atomically. 2210 */ 2211 static void reg_process_pending_hints(void) 2212 { 2213 struct regulatory_request *reg_request, *lr; 2214 2215 lr = get_last_request(); 2216 2217 /* When last_request->processed becomes true this will be rescheduled */ 2218 if (lr && !lr->processed) { 2219 reg_process_hint(lr); 2220 return; 2221 } 2222 2223 spin_lock(®_requests_lock); 2224 2225 if (list_empty(®_requests_list)) { 2226 spin_unlock(®_requests_lock); 2227 return; 2228 } 2229 2230 reg_request = list_first_entry(®_requests_list, 2231 struct regulatory_request, 2232 list); 2233 list_del_init(®_request->list); 2234 2235 spin_unlock(®_requests_lock); 2236 2237 if (reg_only_self_managed_wiphys()) { 2238 reg_free_request(reg_request); 2239 return; 2240 } 2241 2242 reg_process_hint(reg_request); 2243 2244 lr = get_last_request(); 2245 2246 spin_lock(®_requests_lock); 2247 if (!list_empty(®_requests_list) && lr && lr->processed) 2248 schedule_work(®_work); 2249 spin_unlock(®_requests_lock); 2250 } 2251 2252 /* Processes beacon hints -- this has nothing to do with country IEs */ 2253 static void reg_process_pending_beacon_hints(void) 2254 { 2255 struct cfg80211_registered_device *rdev; 2256 struct reg_beacon *pending_beacon, *tmp; 2257 2258 /* This goes through the _pending_ beacon list */ 2259 spin_lock_bh(®_pending_beacons_lock); 2260 2261 list_for_each_entry_safe(pending_beacon, tmp, 2262 ®_pending_beacons, list) { 2263 list_del_init(&pending_beacon->list); 2264 2265 /* Applies the beacon hint to current wiphys */ 2266 list_for_each_entry(rdev, &cfg80211_rdev_list, list) 2267 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon); 2268 2269 /* Remembers the beacon hint for new wiphys or reg changes */ 2270 list_add_tail(&pending_beacon->list, ®_beacon_list); 2271 } 2272 2273 spin_unlock_bh(®_pending_beacons_lock); 2274 } 2275 2276 static void reg_process_self_managed_hints(void) 2277 { 2278 struct cfg80211_registered_device *rdev; 2279 struct wiphy *wiphy; 2280 const struct ieee80211_regdomain *tmp; 2281 const struct ieee80211_regdomain *regd; 2282 enum ieee80211_band band; 2283 struct regulatory_request request = {}; 2284 2285 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2286 wiphy = &rdev->wiphy; 2287 2288 spin_lock(®_requests_lock); 2289 regd = rdev->requested_regd; 2290 rdev->requested_regd = NULL; 2291 spin_unlock(®_requests_lock); 2292 2293 if (regd == NULL) 2294 continue; 2295 2296 tmp = get_wiphy_regdom(wiphy); 2297 rcu_assign_pointer(wiphy->regd, regd); 2298 rcu_free_regdom(tmp); 2299 2300 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 2301 handle_band_custom(wiphy, wiphy->bands[band], regd); 2302 2303 reg_process_ht_flags(wiphy); 2304 2305 request.wiphy_idx = get_wiphy_idx(wiphy); 2306 request.alpha2[0] = regd->alpha2[0]; 2307 request.alpha2[1] = regd->alpha2[1]; 2308 request.initiator = NL80211_REGDOM_SET_BY_DRIVER; 2309 2310 nl80211_send_wiphy_reg_change_event(&request); 2311 } 2312 2313 reg_check_channels(); 2314 } 2315 2316 static void reg_todo(struct work_struct *work) 2317 { 2318 rtnl_lock(); 2319 reg_process_pending_hints(); 2320 reg_process_pending_beacon_hints(); 2321 reg_process_self_managed_hints(); 2322 rtnl_unlock(); 2323 } 2324 2325 static void queue_regulatory_request(struct regulatory_request *request) 2326 { 2327 request->alpha2[0] = toupper(request->alpha2[0]); 2328 request->alpha2[1] = toupper(request->alpha2[1]); 2329 2330 spin_lock(®_requests_lock); 2331 list_add_tail(&request->list, ®_requests_list); 2332 spin_unlock(®_requests_lock); 2333 2334 schedule_work(®_work); 2335 } 2336 2337 /* 2338 * Core regulatory hint -- happens during cfg80211_init() 2339 * and when we restore regulatory settings. 2340 */ 2341 static int regulatory_hint_core(const char *alpha2) 2342 { 2343 struct regulatory_request *request; 2344 2345 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 2346 if (!request) 2347 return -ENOMEM; 2348 2349 request->alpha2[0] = alpha2[0]; 2350 request->alpha2[1] = alpha2[1]; 2351 request->initiator = NL80211_REGDOM_SET_BY_CORE; 2352 2353 queue_regulatory_request(request); 2354 2355 return 0; 2356 } 2357 2358 /* User hints */ 2359 int regulatory_hint_user(const char *alpha2, 2360 enum nl80211_user_reg_hint_type user_reg_hint_type) 2361 { 2362 struct regulatory_request *request; 2363 2364 if (WARN_ON(!alpha2)) 2365 return -EINVAL; 2366 2367 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 2368 if (!request) 2369 return -ENOMEM; 2370 2371 request->wiphy_idx = WIPHY_IDX_INVALID; 2372 request->alpha2[0] = alpha2[0]; 2373 request->alpha2[1] = alpha2[1]; 2374 request->initiator = NL80211_REGDOM_SET_BY_USER; 2375 request->user_reg_hint_type = user_reg_hint_type; 2376 2377 /* Allow calling CRDA again */ 2378 reset_crda_timeouts(); 2379 2380 queue_regulatory_request(request); 2381 2382 return 0; 2383 } 2384 2385 int regulatory_hint_indoor(bool is_indoor, u32 portid) 2386 { 2387 spin_lock(®_indoor_lock); 2388 2389 /* It is possible that more than one user space process is trying to 2390 * configure the indoor setting. To handle such cases, clear the indoor 2391 * setting in case that some process does not think that the device 2392 * is operating in an indoor environment. In addition, if a user space 2393 * process indicates that it is controlling the indoor setting, save its 2394 * portid, i.e., make it the owner. 2395 */ 2396 reg_is_indoor = is_indoor; 2397 if (reg_is_indoor) { 2398 if (!reg_is_indoor_portid) 2399 reg_is_indoor_portid = portid; 2400 } else { 2401 reg_is_indoor_portid = 0; 2402 } 2403 2404 spin_unlock(®_indoor_lock); 2405 2406 if (!is_indoor) 2407 reg_check_channels(); 2408 2409 return 0; 2410 } 2411 2412 void regulatory_netlink_notify(u32 portid) 2413 { 2414 spin_lock(®_indoor_lock); 2415 2416 if (reg_is_indoor_portid != portid) { 2417 spin_unlock(®_indoor_lock); 2418 return; 2419 } 2420 2421 reg_is_indoor = false; 2422 reg_is_indoor_portid = 0; 2423 2424 spin_unlock(®_indoor_lock); 2425 2426 reg_check_channels(); 2427 } 2428 2429 /* Driver hints */ 2430 int regulatory_hint(struct wiphy *wiphy, const char *alpha2) 2431 { 2432 struct regulatory_request *request; 2433 2434 if (WARN_ON(!alpha2 || !wiphy)) 2435 return -EINVAL; 2436 2437 wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG; 2438 2439 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 2440 if (!request) 2441 return -ENOMEM; 2442 2443 request->wiphy_idx = get_wiphy_idx(wiphy); 2444 2445 request->alpha2[0] = alpha2[0]; 2446 request->alpha2[1] = alpha2[1]; 2447 request->initiator = NL80211_REGDOM_SET_BY_DRIVER; 2448 2449 /* Allow calling CRDA again */ 2450 reset_crda_timeouts(); 2451 2452 queue_regulatory_request(request); 2453 2454 return 0; 2455 } 2456 EXPORT_SYMBOL(regulatory_hint); 2457 2458 void regulatory_hint_country_ie(struct wiphy *wiphy, enum ieee80211_band band, 2459 const u8 *country_ie, u8 country_ie_len) 2460 { 2461 char alpha2[2]; 2462 enum environment_cap env = ENVIRON_ANY; 2463 struct regulatory_request *request = NULL, *lr; 2464 2465 /* IE len must be evenly divisible by 2 */ 2466 if (country_ie_len & 0x01) 2467 return; 2468 2469 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN) 2470 return; 2471 2472 request = kzalloc(sizeof(*request), GFP_KERNEL); 2473 if (!request) 2474 return; 2475 2476 alpha2[0] = country_ie[0]; 2477 alpha2[1] = country_ie[1]; 2478 2479 if (country_ie[2] == 'I') 2480 env = ENVIRON_INDOOR; 2481 else if (country_ie[2] == 'O') 2482 env = ENVIRON_OUTDOOR; 2483 2484 rcu_read_lock(); 2485 lr = get_last_request(); 2486 2487 if (unlikely(!lr)) 2488 goto out; 2489 2490 /* 2491 * We will run this only upon a successful connection on cfg80211. 2492 * We leave conflict resolution to the workqueue, where can hold 2493 * the RTNL. 2494 */ 2495 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 2496 lr->wiphy_idx != WIPHY_IDX_INVALID) 2497 goto out; 2498 2499 request->wiphy_idx = get_wiphy_idx(wiphy); 2500 request->alpha2[0] = alpha2[0]; 2501 request->alpha2[1] = alpha2[1]; 2502 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE; 2503 request->country_ie_env = env; 2504 2505 /* Allow calling CRDA again */ 2506 reset_crda_timeouts(); 2507 2508 queue_regulatory_request(request); 2509 request = NULL; 2510 out: 2511 kfree(request); 2512 rcu_read_unlock(); 2513 } 2514 2515 static void restore_alpha2(char *alpha2, bool reset_user) 2516 { 2517 /* indicates there is no alpha2 to consider for restoration */ 2518 alpha2[0] = '9'; 2519 alpha2[1] = '7'; 2520 2521 /* The user setting has precedence over the module parameter */ 2522 if (is_user_regdom_saved()) { 2523 /* Unless we're asked to ignore it and reset it */ 2524 if (reset_user) { 2525 REG_DBG_PRINT("Restoring regulatory settings including user preference\n"); 2526 user_alpha2[0] = '9'; 2527 user_alpha2[1] = '7'; 2528 2529 /* 2530 * If we're ignoring user settings, we still need to 2531 * check the module parameter to ensure we put things 2532 * back as they were for a full restore. 2533 */ 2534 if (!is_world_regdom(ieee80211_regdom)) { 2535 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n", 2536 ieee80211_regdom[0], ieee80211_regdom[1]); 2537 alpha2[0] = ieee80211_regdom[0]; 2538 alpha2[1] = ieee80211_regdom[1]; 2539 } 2540 } else { 2541 REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n", 2542 user_alpha2[0], user_alpha2[1]); 2543 alpha2[0] = user_alpha2[0]; 2544 alpha2[1] = user_alpha2[1]; 2545 } 2546 } else if (!is_world_regdom(ieee80211_regdom)) { 2547 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n", 2548 ieee80211_regdom[0], ieee80211_regdom[1]); 2549 alpha2[0] = ieee80211_regdom[0]; 2550 alpha2[1] = ieee80211_regdom[1]; 2551 } else 2552 REG_DBG_PRINT("Restoring regulatory settings\n"); 2553 } 2554 2555 static void restore_custom_reg_settings(struct wiphy *wiphy) 2556 { 2557 struct ieee80211_supported_band *sband; 2558 enum ieee80211_band band; 2559 struct ieee80211_channel *chan; 2560 int i; 2561 2562 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 2563 sband = wiphy->bands[band]; 2564 if (!sband) 2565 continue; 2566 for (i = 0; i < sband->n_channels; i++) { 2567 chan = &sband->channels[i]; 2568 chan->flags = chan->orig_flags; 2569 chan->max_antenna_gain = chan->orig_mag; 2570 chan->max_power = chan->orig_mpwr; 2571 chan->beacon_found = false; 2572 } 2573 } 2574 } 2575 2576 /* 2577 * Restoring regulatory settings involves ingoring any 2578 * possibly stale country IE information and user regulatory 2579 * settings if so desired, this includes any beacon hints 2580 * learned as we could have traveled outside to another country 2581 * after disconnection. To restore regulatory settings we do 2582 * exactly what we did at bootup: 2583 * 2584 * - send a core regulatory hint 2585 * - send a user regulatory hint if applicable 2586 * 2587 * Device drivers that send a regulatory hint for a specific country 2588 * keep their own regulatory domain on wiphy->regd so that does does 2589 * not need to be remembered. 2590 */ 2591 static void restore_regulatory_settings(bool reset_user) 2592 { 2593 char alpha2[2]; 2594 char world_alpha2[2]; 2595 struct reg_beacon *reg_beacon, *btmp; 2596 LIST_HEAD(tmp_reg_req_list); 2597 struct cfg80211_registered_device *rdev; 2598 2599 ASSERT_RTNL(); 2600 2601 /* 2602 * Clear the indoor setting in case that it is not controlled by user 2603 * space, as otherwise there is no guarantee that the device is still 2604 * operating in an indoor environment. 2605 */ 2606 spin_lock(®_indoor_lock); 2607 if (reg_is_indoor && !reg_is_indoor_portid) { 2608 reg_is_indoor = false; 2609 reg_check_channels(); 2610 } 2611 spin_unlock(®_indoor_lock); 2612 2613 reset_regdomains(true, &world_regdom); 2614 restore_alpha2(alpha2, reset_user); 2615 2616 /* 2617 * If there's any pending requests we simply 2618 * stash them to a temporary pending queue and 2619 * add then after we've restored regulatory 2620 * settings. 2621 */ 2622 spin_lock(®_requests_lock); 2623 list_splice_tail_init(®_requests_list, &tmp_reg_req_list); 2624 spin_unlock(®_requests_lock); 2625 2626 /* Clear beacon hints */ 2627 spin_lock_bh(®_pending_beacons_lock); 2628 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) { 2629 list_del(®_beacon->list); 2630 kfree(reg_beacon); 2631 } 2632 spin_unlock_bh(®_pending_beacons_lock); 2633 2634 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) { 2635 list_del(®_beacon->list); 2636 kfree(reg_beacon); 2637 } 2638 2639 /* First restore to the basic regulatory settings */ 2640 world_alpha2[0] = cfg80211_world_regdom->alpha2[0]; 2641 world_alpha2[1] = cfg80211_world_regdom->alpha2[1]; 2642 2643 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2644 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 2645 continue; 2646 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG) 2647 restore_custom_reg_settings(&rdev->wiphy); 2648 } 2649 2650 regulatory_hint_core(world_alpha2); 2651 2652 /* 2653 * This restores the ieee80211_regdom module parameter 2654 * preference or the last user requested regulatory 2655 * settings, user regulatory settings takes precedence. 2656 */ 2657 if (is_an_alpha2(alpha2)) 2658 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER); 2659 2660 spin_lock(®_requests_lock); 2661 list_splice_tail_init(&tmp_reg_req_list, ®_requests_list); 2662 spin_unlock(®_requests_lock); 2663 2664 REG_DBG_PRINT("Kicking the queue\n"); 2665 2666 schedule_work(®_work); 2667 } 2668 2669 void regulatory_hint_disconnect(void) 2670 { 2671 REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n"); 2672 restore_regulatory_settings(false); 2673 } 2674 2675 static bool freq_is_chan_12_13_14(u16 freq) 2676 { 2677 if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) || 2678 freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) || 2679 freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ)) 2680 return true; 2681 return false; 2682 } 2683 2684 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan) 2685 { 2686 struct reg_beacon *pending_beacon; 2687 2688 list_for_each_entry(pending_beacon, ®_pending_beacons, list) 2689 if (beacon_chan->center_freq == 2690 pending_beacon->chan.center_freq) 2691 return true; 2692 return false; 2693 } 2694 2695 int regulatory_hint_found_beacon(struct wiphy *wiphy, 2696 struct ieee80211_channel *beacon_chan, 2697 gfp_t gfp) 2698 { 2699 struct reg_beacon *reg_beacon; 2700 bool processing; 2701 2702 if (beacon_chan->beacon_found || 2703 beacon_chan->flags & IEEE80211_CHAN_RADAR || 2704 (beacon_chan->band == IEEE80211_BAND_2GHZ && 2705 !freq_is_chan_12_13_14(beacon_chan->center_freq))) 2706 return 0; 2707 2708 spin_lock_bh(®_pending_beacons_lock); 2709 processing = pending_reg_beacon(beacon_chan); 2710 spin_unlock_bh(®_pending_beacons_lock); 2711 2712 if (processing) 2713 return 0; 2714 2715 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp); 2716 if (!reg_beacon) 2717 return -ENOMEM; 2718 2719 REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n", 2720 beacon_chan->center_freq, 2721 ieee80211_frequency_to_channel(beacon_chan->center_freq), 2722 wiphy_name(wiphy)); 2723 2724 memcpy(®_beacon->chan, beacon_chan, 2725 sizeof(struct ieee80211_channel)); 2726 2727 /* 2728 * Since we can be called from BH or and non-BH context 2729 * we must use spin_lock_bh() 2730 */ 2731 spin_lock_bh(®_pending_beacons_lock); 2732 list_add_tail(®_beacon->list, ®_pending_beacons); 2733 spin_unlock_bh(®_pending_beacons_lock); 2734 2735 schedule_work(®_work); 2736 2737 return 0; 2738 } 2739 2740 static void print_rd_rules(const struct ieee80211_regdomain *rd) 2741 { 2742 unsigned int i; 2743 const struct ieee80211_reg_rule *reg_rule = NULL; 2744 const struct ieee80211_freq_range *freq_range = NULL; 2745 const struct ieee80211_power_rule *power_rule = NULL; 2746 char bw[32], cac_time[32]; 2747 2748 pr_info(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n"); 2749 2750 for (i = 0; i < rd->n_reg_rules; i++) { 2751 reg_rule = &rd->reg_rules[i]; 2752 freq_range = ®_rule->freq_range; 2753 power_rule = ®_rule->power_rule; 2754 2755 if (reg_rule->flags & NL80211_RRF_AUTO_BW) 2756 snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO", 2757 freq_range->max_bandwidth_khz, 2758 reg_get_max_bandwidth(rd, reg_rule)); 2759 else 2760 snprintf(bw, sizeof(bw), "%d KHz", 2761 freq_range->max_bandwidth_khz); 2762 2763 if (reg_rule->flags & NL80211_RRF_DFS) 2764 scnprintf(cac_time, sizeof(cac_time), "%u s", 2765 reg_rule->dfs_cac_ms/1000); 2766 else 2767 scnprintf(cac_time, sizeof(cac_time), "N/A"); 2768 2769 2770 /* 2771 * There may not be documentation for max antenna gain 2772 * in certain regions 2773 */ 2774 if (power_rule->max_antenna_gain) 2775 pr_info(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n", 2776 freq_range->start_freq_khz, 2777 freq_range->end_freq_khz, 2778 bw, 2779 power_rule->max_antenna_gain, 2780 power_rule->max_eirp, 2781 cac_time); 2782 else 2783 pr_info(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n", 2784 freq_range->start_freq_khz, 2785 freq_range->end_freq_khz, 2786 bw, 2787 power_rule->max_eirp, 2788 cac_time); 2789 } 2790 } 2791 2792 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region) 2793 { 2794 switch (dfs_region) { 2795 case NL80211_DFS_UNSET: 2796 case NL80211_DFS_FCC: 2797 case NL80211_DFS_ETSI: 2798 case NL80211_DFS_JP: 2799 return true; 2800 default: 2801 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n", 2802 dfs_region); 2803 return false; 2804 } 2805 } 2806 2807 static void print_regdomain(const struct ieee80211_regdomain *rd) 2808 { 2809 struct regulatory_request *lr = get_last_request(); 2810 2811 if (is_intersected_alpha2(rd->alpha2)) { 2812 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) { 2813 struct cfg80211_registered_device *rdev; 2814 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx); 2815 if (rdev) { 2816 pr_info("Current regulatory domain updated by AP to: %c%c\n", 2817 rdev->country_ie_alpha2[0], 2818 rdev->country_ie_alpha2[1]); 2819 } else 2820 pr_info("Current regulatory domain intersected:\n"); 2821 } else 2822 pr_info("Current regulatory domain intersected:\n"); 2823 } else if (is_world_regdom(rd->alpha2)) { 2824 pr_info("World regulatory domain updated:\n"); 2825 } else { 2826 if (is_unknown_alpha2(rd->alpha2)) 2827 pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n"); 2828 else { 2829 if (reg_request_cell_base(lr)) 2830 pr_info("Regulatory domain changed to country: %c%c by Cell Station\n", 2831 rd->alpha2[0], rd->alpha2[1]); 2832 else 2833 pr_info("Regulatory domain changed to country: %c%c\n", 2834 rd->alpha2[0], rd->alpha2[1]); 2835 } 2836 } 2837 2838 pr_info(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region)); 2839 print_rd_rules(rd); 2840 } 2841 2842 static void print_regdomain_info(const struct ieee80211_regdomain *rd) 2843 { 2844 pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]); 2845 print_rd_rules(rd); 2846 } 2847 2848 static int reg_set_rd_core(const struct ieee80211_regdomain *rd) 2849 { 2850 if (!is_world_regdom(rd->alpha2)) 2851 return -EINVAL; 2852 update_world_regdomain(rd); 2853 return 0; 2854 } 2855 2856 static int reg_set_rd_user(const struct ieee80211_regdomain *rd, 2857 struct regulatory_request *user_request) 2858 { 2859 const struct ieee80211_regdomain *intersected_rd = NULL; 2860 2861 if (!regdom_changes(rd->alpha2)) 2862 return -EALREADY; 2863 2864 if (!is_valid_rd(rd)) { 2865 pr_err("Invalid regulatory domain detected:\n"); 2866 print_regdomain_info(rd); 2867 return -EINVAL; 2868 } 2869 2870 if (!user_request->intersect) { 2871 reset_regdomains(false, rd); 2872 return 0; 2873 } 2874 2875 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom()); 2876 if (!intersected_rd) 2877 return -EINVAL; 2878 2879 kfree(rd); 2880 rd = NULL; 2881 reset_regdomains(false, intersected_rd); 2882 2883 return 0; 2884 } 2885 2886 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd, 2887 struct regulatory_request *driver_request) 2888 { 2889 const struct ieee80211_regdomain *regd; 2890 const struct ieee80211_regdomain *intersected_rd = NULL; 2891 const struct ieee80211_regdomain *tmp; 2892 struct wiphy *request_wiphy; 2893 2894 if (is_world_regdom(rd->alpha2)) 2895 return -EINVAL; 2896 2897 if (!regdom_changes(rd->alpha2)) 2898 return -EALREADY; 2899 2900 if (!is_valid_rd(rd)) { 2901 pr_err("Invalid regulatory domain detected:\n"); 2902 print_regdomain_info(rd); 2903 return -EINVAL; 2904 } 2905 2906 request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx); 2907 if (!request_wiphy) 2908 return -ENODEV; 2909 2910 if (!driver_request->intersect) { 2911 if (request_wiphy->regd) 2912 return -EALREADY; 2913 2914 regd = reg_copy_regd(rd); 2915 if (IS_ERR(regd)) 2916 return PTR_ERR(regd); 2917 2918 rcu_assign_pointer(request_wiphy->regd, regd); 2919 reset_regdomains(false, rd); 2920 return 0; 2921 } 2922 2923 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom()); 2924 if (!intersected_rd) 2925 return -EINVAL; 2926 2927 /* 2928 * We can trash what CRDA provided now. 2929 * However if a driver requested this specific regulatory 2930 * domain we keep it for its private use 2931 */ 2932 tmp = get_wiphy_regdom(request_wiphy); 2933 rcu_assign_pointer(request_wiphy->regd, rd); 2934 rcu_free_regdom(tmp); 2935 2936 rd = NULL; 2937 2938 reset_regdomains(false, intersected_rd); 2939 2940 return 0; 2941 } 2942 2943 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd, 2944 struct regulatory_request *country_ie_request) 2945 { 2946 struct wiphy *request_wiphy; 2947 2948 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) && 2949 !is_unknown_alpha2(rd->alpha2)) 2950 return -EINVAL; 2951 2952 /* 2953 * Lets only bother proceeding on the same alpha2 if the current 2954 * rd is non static (it means CRDA was present and was used last) 2955 * and the pending request came in from a country IE 2956 */ 2957 2958 if (!is_valid_rd(rd)) { 2959 pr_err("Invalid regulatory domain detected:\n"); 2960 print_regdomain_info(rd); 2961 return -EINVAL; 2962 } 2963 2964 request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx); 2965 if (!request_wiphy) 2966 return -ENODEV; 2967 2968 if (country_ie_request->intersect) 2969 return -EINVAL; 2970 2971 reset_regdomains(false, rd); 2972 return 0; 2973 } 2974 2975 /* 2976 * Use this call to set the current regulatory domain. Conflicts with 2977 * multiple drivers can be ironed out later. Caller must've already 2978 * kmalloc'd the rd structure. 2979 */ 2980 int set_regdom(const struct ieee80211_regdomain *rd, 2981 enum ieee80211_regd_source regd_src) 2982 { 2983 struct regulatory_request *lr; 2984 bool user_reset = false; 2985 int r; 2986 2987 if (!reg_is_valid_request(rd->alpha2)) { 2988 kfree(rd); 2989 return -EINVAL; 2990 } 2991 2992 if (regd_src == REGD_SOURCE_CRDA) 2993 reset_crda_timeouts(); 2994 2995 lr = get_last_request(); 2996 2997 /* Note that this doesn't update the wiphys, this is done below */ 2998 switch (lr->initiator) { 2999 case NL80211_REGDOM_SET_BY_CORE: 3000 r = reg_set_rd_core(rd); 3001 break; 3002 case NL80211_REGDOM_SET_BY_USER: 3003 r = reg_set_rd_user(rd, lr); 3004 user_reset = true; 3005 break; 3006 case NL80211_REGDOM_SET_BY_DRIVER: 3007 r = reg_set_rd_driver(rd, lr); 3008 break; 3009 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 3010 r = reg_set_rd_country_ie(rd, lr); 3011 break; 3012 default: 3013 WARN(1, "invalid initiator %d\n", lr->initiator); 3014 kfree(rd); 3015 return -EINVAL; 3016 } 3017 3018 if (r) { 3019 switch (r) { 3020 case -EALREADY: 3021 reg_set_request_processed(); 3022 break; 3023 default: 3024 /* Back to world regulatory in case of errors */ 3025 restore_regulatory_settings(user_reset); 3026 } 3027 3028 kfree(rd); 3029 return r; 3030 } 3031 3032 /* This would make this whole thing pointless */ 3033 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom())) 3034 return -EINVAL; 3035 3036 /* update all wiphys now with the new established regulatory domain */ 3037 update_all_wiphy_regulatory(lr->initiator); 3038 3039 print_regdomain(get_cfg80211_regdom()); 3040 3041 nl80211_send_reg_change_event(lr); 3042 3043 reg_set_request_processed(); 3044 3045 return 0; 3046 } 3047 3048 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy, 3049 struct ieee80211_regdomain *rd) 3050 { 3051 const struct ieee80211_regdomain *regd; 3052 const struct ieee80211_regdomain *prev_regd; 3053 struct cfg80211_registered_device *rdev; 3054 3055 if (WARN_ON(!wiphy || !rd)) 3056 return -EINVAL; 3057 3058 if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED), 3059 "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n")) 3060 return -EPERM; 3061 3062 if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) { 3063 print_regdomain_info(rd); 3064 return -EINVAL; 3065 } 3066 3067 regd = reg_copy_regd(rd); 3068 if (IS_ERR(regd)) 3069 return PTR_ERR(regd); 3070 3071 rdev = wiphy_to_rdev(wiphy); 3072 3073 spin_lock(®_requests_lock); 3074 prev_regd = rdev->requested_regd; 3075 rdev->requested_regd = regd; 3076 spin_unlock(®_requests_lock); 3077 3078 kfree(prev_regd); 3079 return 0; 3080 } 3081 3082 int regulatory_set_wiphy_regd(struct wiphy *wiphy, 3083 struct ieee80211_regdomain *rd) 3084 { 3085 int ret = __regulatory_set_wiphy_regd(wiphy, rd); 3086 3087 if (ret) 3088 return ret; 3089 3090 schedule_work(®_work); 3091 return 0; 3092 } 3093 EXPORT_SYMBOL(regulatory_set_wiphy_regd); 3094 3095 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy, 3096 struct ieee80211_regdomain *rd) 3097 { 3098 int ret; 3099 3100 ASSERT_RTNL(); 3101 3102 ret = __regulatory_set_wiphy_regd(wiphy, rd); 3103 if (ret) 3104 return ret; 3105 3106 /* process the request immediately */ 3107 reg_process_self_managed_hints(); 3108 return 0; 3109 } 3110 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl); 3111 3112 void wiphy_regulatory_register(struct wiphy *wiphy) 3113 { 3114 struct regulatory_request *lr; 3115 3116 /* self-managed devices ignore external hints */ 3117 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 3118 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS | 3119 REGULATORY_COUNTRY_IE_IGNORE; 3120 3121 if (!reg_dev_ignore_cell_hint(wiphy)) 3122 reg_num_devs_support_basehint++; 3123 3124 lr = get_last_request(); 3125 wiphy_update_regulatory(wiphy, lr->initiator); 3126 } 3127 3128 void wiphy_regulatory_deregister(struct wiphy *wiphy) 3129 { 3130 struct wiphy *request_wiphy = NULL; 3131 struct regulatory_request *lr; 3132 3133 lr = get_last_request(); 3134 3135 if (!reg_dev_ignore_cell_hint(wiphy)) 3136 reg_num_devs_support_basehint--; 3137 3138 rcu_free_regdom(get_wiphy_regdom(wiphy)); 3139 RCU_INIT_POINTER(wiphy->regd, NULL); 3140 3141 if (lr) 3142 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 3143 3144 if (!request_wiphy || request_wiphy != wiphy) 3145 return; 3146 3147 lr->wiphy_idx = WIPHY_IDX_INVALID; 3148 lr->country_ie_env = ENVIRON_ANY; 3149 } 3150 3151 /* 3152 * See http://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii, for 3153 * UNII band definitions 3154 */ 3155 int cfg80211_get_unii(int freq) 3156 { 3157 /* UNII-1 */ 3158 if (freq >= 5150 && freq <= 5250) 3159 return 0; 3160 3161 /* UNII-2A */ 3162 if (freq > 5250 && freq <= 5350) 3163 return 1; 3164 3165 /* UNII-2B */ 3166 if (freq > 5350 && freq <= 5470) 3167 return 2; 3168 3169 /* UNII-2C */ 3170 if (freq > 5470 && freq <= 5725) 3171 return 3; 3172 3173 /* UNII-3 */ 3174 if (freq > 5725 && freq <= 5825) 3175 return 4; 3176 3177 return -EINVAL; 3178 } 3179 3180 bool regulatory_indoor_allowed(void) 3181 { 3182 return reg_is_indoor; 3183 } 3184 3185 int __init regulatory_init(void) 3186 { 3187 int err = 0; 3188 3189 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0); 3190 if (IS_ERR(reg_pdev)) 3191 return PTR_ERR(reg_pdev); 3192 3193 spin_lock_init(®_requests_lock); 3194 spin_lock_init(®_pending_beacons_lock); 3195 spin_lock_init(®_indoor_lock); 3196 3197 reg_regdb_size_check(); 3198 3199 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom); 3200 3201 user_alpha2[0] = '9'; 3202 user_alpha2[1] = '7'; 3203 3204 /* We always try to get an update for the static regdomain */ 3205 err = regulatory_hint_core(cfg80211_world_regdom->alpha2); 3206 if (err) { 3207 if (err == -ENOMEM) { 3208 platform_device_unregister(reg_pdev); 3209 return err; 3210 } 3211 /* 3212 * N.B. kobject_uevent_env() can fail mainly for when we're out 3213 * memory which is handled and propagated appropriately above 3214 * but it can also fail during a netlink_broadcast() or during 3215 * early boot for call_usermodehelper(). For now treat these 3216 * errors as non-fatal. 3217 */ 3218 pr_err("kobject_uevent_env() was unable to call CRDA during init\n"); 3219 } 3220 3221 /* 3222 * Finally, if the user set the module parameter treat it 3223 * as a user hint. 3224 */ 3225 if (!is_world_regdom(ieee80211_regdom)) 3226 regulatory_hint_user(ieee80211_regdom, 3227 NL80211_USER_REG_HINT_USER); 3228 3229 return 0; 3230 } 3231 3232 void regulatory_exit(void) 3233 { 3234 struct regulatory_request *reg_request, *tmp; 3235 struct reg_beacon *reg_beacon, *btmp; 3236 3237 cancel_work_sync(®_work); 3238 cancel_crda_timeout_sync(); 3239 cancel_delayed_work_sync(®_check_chans); 3240 3241 /* Lock to suppress warnings */ 3242 rtnl_lock(); 3243 reset_regdomains(true, NULL); 3244 rtnl_unlock(); 3245 3246 dev_set_uevent_suppress(®_pdev->dev, true); 3247 3248 platform_device_unregister(reg_pdev); 3249 3250 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) { 3251 list_del(®_beacon->list); 3252 kfree(reg_beacon); 3253 } 3254 3255 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) { 3256 list_del(®_beacon->list); 3257 kfree(reg_beacon); 3258 } 3259 3260 list_for_each_entry_safe(reg_request, tmp, ®_requests_list, list) { 3261 list_del(®_request->list); 3262 kfree(reg_request); 3263 } 3264 } 3265