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