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 * Copyright 2017 Intel Deutschland GmbH 8 * Copyright (C) 2018 - 2019 Intel Corporation 9 * 10 * Permission to use, copy, modify, and/or distribute this software for any 11 * purpose with or without fee is hereby granted, provided that the above 12 * copyright notice and this permission notice appear in all copies. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 15 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 16 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 17 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 19 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 20 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 21 */ 22 23 24 /** 25 * DOC: Wireless regulatory infrastructure 26 * 27 * The usual implementation is for a driver to read a device EEPROM to 28 * determine which regulatory domain it should be operating under, then 29 * looking up the allowable channels in a driver-local table and finally 30 * registering those channels in the wiphy structure. 31 * 32 * Another set of compliance enforcement is for drivers to use their 33 * own compliance limits which can be stored on the EEPROM. The host 34 * driver or firmware may ensure these are used. 35 * 36 * In addition to all this we provide an extra layer of regulatory 37 * conformance. For drivers which do not have any regulatory 38 * information CRDA provides the complete regulatory solution. 39 * For others it provides a community effort on further restrictions 40 * to enhance compliance. 41 * 42 * Note: When number of rules --> infinity we will not be able to 43 * index on alpha2 any more, instead we'll probably have to 44 * rely on some SHA1 checksum of the regdomain for example. 45 * 46 */ 47 48 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 49 50 #include <linux/kernel.h> 51 #include <linux/export.h> 52 #include <linux/slab.h> 53 #include <linux/list.h> 54 #include <linux/ctype.h> 55 #include <linux/nl80211.h> 56 #include <linux/platform_device.h> 57 #include <linux/verification.h> 58 #include <linux/moduleparam.h> 59 #include <linux/firmware.h> 60 #include <net/cfg80211.h> 61 #include "core.h" 62 #include "reg.h" 63 #include "rdev-ops.h" 64 #include "nl80211.h" 65 66 /* 67 * Grace period we give before making sure all current interfaces reside on 68 * channels allowed by the current regulatory domain. 69 */ 70 #define REG_ENFORCE_GRACE_MS 60000 71 72 /** 73 * enum reg_request_treatment - regulatory request treatment 74 * 75 * @REG_REQ_OK: continue processing the regulatory request 76 * @REG_REQ_IGNORE: ignore the regulatory request 77 * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should 78 * be intersected with the current one. 79 * @REG_REQ_ALREADY_SET: the regulatory request will not change the current 80 * regulatory settings, and no further processing is required. 81 */ 82 enum reg_request_treatment { 83 REG_REQ_OK, 84 REG_REQ_IGNORE, 85 REG_REQ_INTERSECT, 86 REG_REQ_ALREADY_SET, 87 }; 88 89 static struct regulatory_request core_request_world = { 90 .initiator = NL80211_REGDOM_SET_BY_CORE, 91 .alpha2[0] = '0', 92 .alpha2[1] = '0', 93 .intersect = false, 94 .processed = true, 95 .country_ie_env = ENVIRON_ANY, 96 }; 97 98 /* 99 * Receipt of information from last regulatory request, 100 * protected by RTNL (and can be accessed with RCU protection) 101 */ 102 static struct regulatory_request __rcu *last_request = 103 (void __force __rcu *)&core_request_world; 104 105 /* To trigger userspace events and load firmware */ 106 static struct platform_device *reg_pdev; 107 108 /* 109 * Central wireless core regulatory domains, we only need two, 110 * the current one and a world regulatory domain in case we have no 111 * information to give us an alpha2. 112 * (protected by RTNL, can be read under RCU) 113 */ 114 const struct ieee80211_regdomain __rcu *cfg80211_regdomain; 115 116 /* 117 * Number of devices that registered to the core 118 * that support cellular base station regulatory hints 119 * (protected by RTNL) 120 */ 121 static int reg_num_devs_support_basehint; 122 123 /* 124 * State variable indicating if the platform on which the devices 125 * are attached is operating in an indoor environment. The state variable 126 * is relevant for all registered devices. 127 */ 128 static bool reg_is_indoor; 129 static spinlock_t reg_indoor_lock; 130 131 /* Used to track the userspace process controlling the indoor setting */ 132 static u32 reg_is_indoor_portid; 133 134 static void restore_regulatory_settings(bool reset_user, bool cached); 135 static void print_regdomain(const struct ieee80211_regdomain *rd); 136 137 static const struct ieee80211_regdomain *get_cfg80211_regdom(void) 138 { 139 return rcu_dereference_rtnl(cfg80211_regdomain); 140 } 141 142 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy) 143 { 144 return rcu_dereference_rtnl(wiphy->regd); 145 } 146 147 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region) 148 { 149 switch (dfs_region) { 150 case NL80211_DFS_UNSET: 151 return "unset"; 152 case NL80211_DFS_FCC: 153 return "FCC"; 154 case NL80211_DFS_ETSI: 155 return "ETSI"; 156 case NL80211_DFS_JP: 157 return "JP"; 158 } 159 return "Unknown"; 160 } 161 162 enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy) 163 { 164 const struct ieee80211_regdomain *regd = NULL; 165 const struct ieee80211_regdomain *wiphy_regd = NULL; 166 167 regd = get_cfg80211_regdom(); 168 if (!wiphy) 169 goto out; 170 171 wiphy_regd = get_wiphy_regdom(wiphy); 172 if (!wiphy_regd) 173 goto out; 174 175 if (wiphy_regd->dfs_region == regd->dfs_region) 176 goto out; 177 178 pr_debug("%s: device specific dfs_region (%s) disagrees with cfg80211's central dfs_region (%s)\n", 179 dev_name(&wiphy->dev), 180 reg_dfs_region_str(wiphy_regd->dfs_region), 181 reg_dfs_region_str(regd->dfs_region)); 182 183 out: 184 return regd->dfs_region; 185 } 186 187 static void rcu_free_regdom(const struct ieee80211_regdomain *r) 188 { 189 if (!r) 190 return; 191 kfree_rcu((struct ieee80211_regdomain *)r, rcu_head); 192 } 193 194 static struct regulatory_request *get_last_request(void) 195 { 196 return rcu_dereference_rtnl(last_request); 197 } 198 199 /* Used to queue up regulatory hints */ 200 static LIST_HEAD(reg_requests_list); 201 static spinlock_t reg_requests_lock; 202 203 /* Used to queue up beacon hints for review */ 204 static LIST_HEAD(reg_pending_beacons); 205 static spinlock_t reg_pending_beacons_lock; 206 207 /* Used to keep track of processed beacon hints */ 208 static LIST_HEAD(reg_beacon_list); 209 210 struct reg_beacon { 211 struct list_head list; 212 struct ieee80211_channel chan; 213 }; 214 215 static void reg_check_chans_work(struct work_struct *work); 216 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work); 217 218 static void reg_todo(struct work_struct *work); 219 static DECLARE_WORK(reg_work, reg_todo); 220 221 /* We keep a static world regulatory domain in case of the absence of CRDA */ 222 static const struct ieee80211_regdomain world_regdom = { 223 .n_reg_rules = 8, 224 .alpha2 = "00", 225 .reg_rules = { 226 /* IEEE 802.11b/g, channels 1..11 */ 227 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0), 228 /* IEEE 802.11b/g, channels 12..13. */ 229 REG_RULE(2467-10, 2472+10, 20, 6, 20, 230 NL80211_RRF_NO_IR | NL80211_RRF_AUTO_BW), 231 /* IEEE 802.11 channel 14 - Only JP enables 232 * this and for 802.11b only */ 233 REG_RULE(2484-10, 2484+10, 20, 6, 20, 234 NL80211_RRF_NO_IR | 235 NL80211_RRF_NO_OFDM), 236 /* IEEE 802.11a, channel 36..48 */ 237 REG_RULE(5180-10, 5240+10, 80, 6, 20, 238 NL80211_RRF_NO_IR | 239 NL80211_RRF_AUTO_BW), 240 241 /* IEEE 802.11a, channel 52..64 - DFS required */ 242 REG_RULE(5260-10, 5320+10, 80, 6, 20, 243 NL80211_RRF_NO_IR | 244 NL80211_RRF_AUTO_BW | 245 NL80211_RRF_DFS), 246 247 /* IEEE 802.11a, channel 100..144 - DFS required */ 248 REG_RULE(5500-10, 5720+10, 160, 6, 20, 249 NL80211_RRF_NO_IR | 250 NL80211_RRF_DFS), 251 252 /* IEEE 802.11a, channel 149..165 */ 253 REG_RULE(5745-10, 5825+10, 80, 6, 20, 254 NL80211_RRF_NO_IR), 255 256 /* IEEE 802.11ad (60GHz), channels 1..3 */ 257 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0), 258 } 259 }; 260 261 /* protected by RTNL */ 262 static const struct ieee80211_regdomain *cfg80211_world_regdom = 263 &world_regdom; 264 265 static char *ieee80211_regdom = "00"; 266 static char user_alpha2[2]; 267 static const struct ieee80211_regdomain *cfg80211_user_regdom; 268 269 module_param(ieee80211_regdom, charp, 0444); 270 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code"); 271 272 static void reg_free_request(struct regulatory_request *request) 273 { 274 if (request == &core_request_world) 275 return; 276 277 if (request != get_last_request()) 278 kfree(request); 279 } 280 281 static void reg_free_last_request(void) 282 { 283 struct regulatory_request *lr = get_last_request(); 284 285 if (lr != &core_request_world && lr) 286 kfree_rcu(lr, rcu_head); 287 } 288 289 static void reg_update_last_request(struct regulatory_request *request) 290 { 291 struct regulatory_request *lr; 292 293 lr = get_last_request(); 294 if (lr == request) 295 return; 296 297 reg_free_last_request(); 298 rcu_assign_pointer(last_request, request); 299 } 300 301 static void reset_regdomains(bool full_reset, 302 const struct ieee80211_regdomain *new_regdom) 303 { 304 const struct ieee80211_regdomain *r; 305 306 ASSERT_RTNL(); 307 308 r = get_cfg80211_regdom(); 309 310 /* avoid freeing static information or freeing something twice */ 311 if (r == cfg80211_world_regdom) 312 r = NULL; 313 if (cfg80211_world_regdom == &world_regdom) 314 cfg80211_world_regdom = NULL; 315 if (r == &world_regdom) 316 r = NULL; 317 318 rcu_free_regdom(r); 319 rcu_free_regdom(cfg80211_world_regdom); 320 321 cfg80211_world_regdom = &world_regdom; 322 rcu_assign_pointer(cfg80211_regdomain, new_regdom); 323 324 if (!full_reset) 325 return; 326 327 reg_update_last_request(&core_request_world); 328 } 329 330 /* 331 * Dynamic world regulatory domain requested by the wireless 332 * core upon initialization 333 */ 334 static void update_world_regdomain(const struct ieee80211_regdomain *rd) 335 { 336 struct regulatory_request *lr; 337 338 lr = get_last_request(); 339 340 WARN_ON(!lr); 341 342 reset_regdomains(false, rd); 343 344 cfg80211_world_regdom = rd; 345 } 346 347 bool is_world_regdom(const char *alpha2) 348 { 349 if (!alpha2) 350 return false; 351 return alpha2[0] == '0' && alpha2[1] == '0'; 352 } 353 354 static bool is_alpha2_set(const char *alpha2) 355 { 356 if (!alpha2) 357 return false; 358 return alpha2[0] && alpha2[1]; 359 } 360 361 static bool is_unknown_alpha2(const char *alpha2) 362 { 363 if (!alpha2) 364 return false; 365 /* 366 * Special case where regulatory domain was built by driver 367 * but a specific alpha2 cannot be determined 368 */ 369 return alpha2[0] == '9' && alpha2[1] == '9'; 370 } 371 372 static bool is_intersected_alpha2(const char *alpha2) 373 { 374 if (!alpha2) 375 return false; 376 /* 377 * Special case where regulatory domain is the 378 * result of an intersection between two regulatory domain 379 * structures 380 */ 381 return alpha2[0] == '9' && alpha2[1] == '8'; 382 } 383 384 static bool is_an_alpha2(const char *alpha2) 385 { 386 if (!alpha2) 387 return false; 388 return isalpha(alpha2[0]) && isalpha(alpha2[1]); 389 } 390 391 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y) 392 { 393 if (!alpha2_x || !alpha2_y) 394 return false; 395 return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1]; 396 } 397 398 static bool regdom_changes(const char *alpha2) 399 { 400 const struct ieee80211_regdomain *r = get_cfg80211_regdom(); 401 402 if (!r) 403 return true; 404 return !alpha2_equal(r->alpha2, alpha2); 405 } 406 407 /* 408 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets 409 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER 410 * has ever been issued. 411 */ 412 static bool is_user_regdom_saved(void) 413 { 414 if (user_alpha2[0] == '9' && user_alpha2[1] == '7') 415 return false; 416 417 /* This would indicate a mistake on the design */ 418 if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2), 419 "Unexpected user alpha2: %c%c\n", 420 user_alpha2[0], user_alpha2[1])) 421 return false; 422 423 return true; 424 } 425 426 static const struct ieee80211_regdomain * 427 reg_copy_regd(const struct ieee80211_regdomain *src_regd) 428 { 429 struct ieee80211_regdomain *regd; 430 unsigned int i; 431 432 regd = kzalloc(struct_size(regd, reg_rules, src_regd->n_reg_rules), 433 GFP_KERNEL); 434 if (!regd) 435 return ERR_PTR(-ENOMEM); 436 437 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain)); 438 439 for (i = 0; i < src_regd->n_reg_rules; i++) 440 memcpy(®d->reg_rules[i], &src_regd->reg_rules[i], 441 sizeof(struct ieee80211_reg_rule)); 442 443 return regd; 444 } 445 446 static void cfg80211_save_user_regdom(const struct ieee80211_regdomain *rd) 447 { 448 ASSERT_RTNL(); 449 450 if (!IS_ERR(cfg80211_user_regdom)) 451 kfree(cfg80211_user_regdom); 452 cfg80211_user_regdom = reg_copy_regd(rd); 453 } 454 455 struct reg_regdb_apply_request { 456 struct list_head list; 457 const struct ieee80211_regdomain *regdom; 458 }; 459 460 static LIST_HEAD(reg_regdb_apply_list); 461 static DEFINE_MUTEX(reg_regdb_apply_mutex); 462 463 static void reg_regdb_apply(struct work_struct *work) 464 { 465 struct reg_regdb_apply_request *request; 466 467 rtnl_lock(); 468 469 mutex_lock(®_regdb_apply_mutex); 470 while (!list_empty(®_regdb_apply_list)) { 471 request = list_first_entry(®_regdb_apply_list, 472 struct reg_regdb_apply_request, 473 list); 474 list_del(&request->list); 475 476 set_regdom(request->regdom, REGD_SOURCE_INTERNAL_DB); 477 kfree(request); 478 } 479 mutex_unlock(®_regdb_apply_mutex); 480 481 rtnl_unlock(); 482 } 483 484 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply); 485 486 static int reg_schedule_apply(const struct ieee80211_regdomain *regdom) 487 { 488 struct reg_regdb_apply_request *request; 489 490 request = kzalloc(sizeof(struct reg_regdb_apply_request), GFP_KERNEL); 491 if (!request) { 492 kfree(regdom); 493 return -ENOMEM; 494 } 495 496 request->regdom = regdom; 497 498 mutex_lock(®_regdb_apply_mutex); 499 list_add_tail(&request->list, ®_regdb_apply_list); 500 mutex_unlock(®_regdb_apply_mutex); 501 502 schedule_work(®_regdb_work); 503 return 0; 504 } 505 506 #ifdef CONFIG_CFG80211_CRDA_SUPPORT 507 /* Max number of consecutive attempts to communicate with CRDA */ 508 #define REG_MAX_CRDA_TIMEOUTS 10 509 510 static u32 reg_crda_timeouts; 511 512 static void crda_timeout_work(struct work_struct *work); 513 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work); 514 515 static void crda_timeout_work(struct work_struct *work) 516 { 517 pr_debug("Timeout while waiting for CRDA to reply, restoring regulatory settings\n"); 518 rtnl_lock(); 519 reg_crda_timeouts++; 520 restore_regulatory_settings(true, false); 521 rtnl_unlock(); 522 } 523 524 static void cancel_crda_timeout(void) 525 { 526 cancel_delayed_work(&crda_timeout); 527 } 528 529 static void cancel_crda_timeout_sync(void) 530 { 531 cancel_delayed_work_sync(&crda_timeout); 532 } 533 534 static void reset_crda_timeouts(void) 535 { 536 reg_crda_timeouts = 0; 537 } 538 539 /* 540 * This lets us keep regulatory code which is updated on a regulatory 541 * basis in userspace. 542 */ 543 static int call_crda(const char *alpha2) 544 { 545 char country[12]; 546 char *env[] = { country, NULL }; 547 int ret; 548 549 snprintf(country, sizeof(country), "COUNTRY=%c%c", 550 alpha2[0], alpha2[1]); 551 552 if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) { 553 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n"); 554 return -EINVAL; 555 } 556 557 if (!is_world_regdom((char *) alpha2)) 558 pr_debug("Calling CRDA for country: %c%c\n", 559 alpha2[0], alpha2[1]); 560 else 561 pr_debug("Calling CRDA to update world regulatory domain\n"); 562 563 ret = kobject_uevent_env(®_pdev->dev.kobj, KOBJ_CHANGE, env); 564 if (ret) 565 return ret; 566 567 queue_delayed_work(system_power_efficient_wq, 568 &crda_timeout, msecs_to_jiffies(3142)); 569 return 0; 570 } 571 #else 572 static inline void cancel_crda_timeout(void) {} 573 static inline void cancel_crda_timeout_sync(void) {} 574 static inline void reset_crda_timeouts(void) {} 575 static inline int call_crda(const char *alpha2) 576 { 577 return -ENODATA; 578 } 579 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */ 580 581 /* code to directly load a firmware database through request_firmware */ 582 static const struct fwdb_header *regdb; 583 584 struct fwdb_country { 585 u8 alpha2[2]; 586 __be16 coll_ptr; 587 /* this struct cannot be extended */ 588 } __packed __aligned(4); 589 590 struct fwdb_collection { 591 u8 len; 592 u8 n_rules; 593 u8 dfs_region; 594 /* no optional data yet */ 595 /* aligned to 2, then followed by __be16 array of rule pointers */ 596 } __packed __aligned(4); 597 598 enum fwdb_flags { 599 FWDB_FLAG_NO_OFDM = BIT(0), 600 FWDB_FLAG_NO_OUTDOOR = BIT(1), 601 FWDB_FLAG_DFS = BIT(2), 602 FWDB_FLAG_NO_IR = BIT(3), 603 FWDB_FLAG_AUTO_BW = BIT(4), 604 }; 605 606 struct fwdb_wmm_ac { 607 u8 ecw; 608 u8 aifsn; 609 __be16 cot; 610 } __packed; 611 612 struct fwdb_wmm_rule { 613 struct fwdb_wmm_ac client[IEEE80211_NUM_ACS]; 614 struct fwdb_wmm_ac ap[IEEE80211_NUM_ACS]; 615 } __packed; 616 617 struct fwdb_rule { 618 u8 len; 619 u8 flags; 620 __be16 max_eirp; 621 __be32 start, end, max_bw; 622 /* start of optional data */ 623 __be16 cac_timeout; 624 __be16 wmm_ptr; 625 } __packed __aligned(4); 626 627 #define FWDB_MAGIC 0x52474442 628 #define FWDB_VERSION 20 629 630 struct fwdb_header { 631 __be32 magic; 632 __be32 version; 633 struct fwdb_country country[]; 634 } __packed __aligned(4); 635 636 static int ecw2cw(int ecw) 637 { 638 return (1 << ecw) - 1; 639 } 640 641 static bool valid_wmm(struct fwdb_wmm_rule *rule) 642 { 643 struct fwdb_wmm_ac *ac = (struct fwdb_wmm_ac *)rule; 644 int i; 645 646 for (i = 0; i < IEEE80211_NUM_ACS * 2; i++) { 647 u16 cw_min = ecw2cw((ac[i].ecw & 0xf0) >> 4); 648 u16 cw_max = ecw2cw(ac[i].ecw & 0x0f); 649 u8 aifsn = ac[i].aifsn; 650 651 if (cw_min >= cw_max) 652 return false; 653 654 if (aifsn < 1) 655 return false; 656 } 657 658 return true; 659 } 660 661 static bool valid_rule(const u8 *data, unsigned int size, u16 rule_ptr) 662 { 663 struct fwdb_rule *rule = (void *)(data + (rule_ptr << 2)); 664 665 if ((u8 *)rule + sizeof(rule->len) > data + size) 666 return false; 667 668 /* mandatory fields */ 669 if (rule->len < offsetofend(struct fwdb_rule, max_bw)) 670 return false; 671 if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) { 672 u32 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2; 673 struct fwdb_wmm_rule *wmm; 674 675 if (wmm_ptr + sizeof(struct fwdb_wmm_rule) > size) 676 return false; 677 678 wmm = (void *)(data + wmm_ptr); 679 680 if (!valid_wmm(wmm)) 681 return false; 682 } 683 return true; 684 } 685 686 static bool valid_country(const u8 *data, unsigned int size, 687 const struct fwdb_country *country) 688 { 689 unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2; 690 struct fwdb_collection *coll = (void *)(data + ptr); 691 __be16 *rules_ptr; 692 unsigned int i; 693 694 /* make sure we can read len/n_rules */ 695 if ((u8 *)coll + offsetofend(typeof(*coll), n_rules) > data + size) 696 return false; 697 698 /* make sure base struct and all rules fit */ 699 if ((u8 *)coll + ALIGN(coll->len, 2) + 700 (coll->n_rules * 2) > data + size) 701 return false; 702 703 /* mandatory fields must exist */ 704 if (coll->len < offsetofend(struct fwdb_collection, dfs_region)) 705 return false; 706 707 rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2)); 708 709 for (i = 0; i < coll->n_rules; i++) { 710 u16 rule_ptr = be16_to_cpu(rules_ptr[i]); 711 712 if (!valid_rule(data, size, rule_ptr)) 713 return false; 714 } 715 716 return true; 717 } 718 719 #ifdef CONFIG_CFG80211_REQUIRE_SIGNED_REGDB 720 static struct key *builtin_regdb_keys; 721 722 static void __init load_keys_from_buffer(const u8 *p, unsigned int buflen) 723 { 724 const u8 *end = p + buflen; 725 size_t plen; 726 key_ref_t key; 727 728 while (p < end) { 729 /* Each cert begins with an ASN.1 SEQUENCE tag and must be more 730 * than 256 bytes in size. 731 */ 732 if (end - p < 4) 733 goto dodgy_cert; 734 if (p[0] != 0x30 && 735 p[1] != 0x82) 736 goto dodgy_cert; 737 plen = (p[2] << 8) | p[3]; 738 plen += 4; 739 if (plen > end - p) 740 goto dodgy_cert; 741 742 key = key_create_or_update(make_key_ref(builtin_regdb_keys, 1), 743 "asymmetric", NULL, p, plen, 744 ((KEY_POS_ALL & ~KEY_POS_SETATTR) | 745 KEY_USR_VIEW | KEY_USR_READ), 746 KEY_ALLOC_NOT_IN_QUOTA | 747 KEY_ALLOC_BUILT_IN | 748 KEY_ALLOC_BYPASS_RESTRICTION); 749 if (IS_ERR(key)) { 750 pr_err("Problem loading in-kernel X.509 certificate (%ld)\n", 751 PTR_ERR(key)); 752 } else { 753 pr_notice("Loaded X.509 cert '%s'\n", 754 key_ref_to_ptr(key)->description); 755 key_ref_put(key); 756 } 757 p += plen; 758 } 759 760 return; 761 762 dodgy_cert: 763 pr_err("Problem parsing in-kernel X.509 certificate list\n"); 764 } 765 766 static int __init load_builtin_regdb_keys(void) 767 { 768 builtin_regdb_keys = 769 keyring_alloc(".builtin_regdb_keys", 770 KUIDT_INIT(0), KGIDT_INIT(0), current_cred(), 771 ((KEY_POS_ALL & ~KEY_POS_SETATTR) | 772 KEY_USR_VIEW | KEY_USR_READ | KEY_USR_SEARCH), 773 KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); 774 if (IS_ERR(builtin_regdb_keys)) 775 return PTR_ERR(builtin_regdb_keys); 776 777 pr_notice("Loading compiled-in X.509 certificates for regulatory database\n"); 778 779 #ifdef CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS 780 load_keys_from_buffer(shipped_regdb_certs, shipped_regdb_certs_len); 781 #endif 782 #ifdef CONFIG_CFG80211_EXTRA_REGDB_KEYDIR 783 if (CONFIG_CFG80211_EXTRA_REGDB_KEYDIR[0] != '\0') 784 load_keys_from_buffer(extra_regdb_certs, extra_regdb_certs_len); 785 #endif 786 787 return 0; 788 } 789 790 static bool regdb_has_valid_signature(const u8 *data, unsigned int size) 791 { 792 const struct firmware *sig; 793 bool result; 794 795 if (request_firmware(&sig, "regulatory.db.p7s", ®_pdev->dev)) 796 return false; 797 798 result = verify_pkcs7_signature(data, size, sig->data, sig->size, 799 builtin_regdb_keys, 800 VERIFYING_UNSPECIFIED_SIGNATURE, 801 NULL, NULL) == 0; 802 803 release_firmware(sig); 804 805 return result; 806 } 807 808 static void free_regdb_keyring(void) 809 { 810 key_put(builtin_regdb_keys); 811 } 812 #else 813 static int load_builtin_regdb_keys(void) 814 { 815 return 0; 816 } 817 818 static bool regdb_has_valid_signature(const u8 *data, unsigned int size) 819 { 820 return true; 821 } 822 823 static void free_regdb_keyring(void) 824 { 825 } 826 #endif /* CONFIG_CFG80211_REQUIRE_SIGNED_REGDB */ 827 828 static bool valid_regdb(const u8 *data, unsigned int size) 829 { 830 const struct fwdb_header *hdr = (void *)data; 831 const struct fwdb_country *country; 832 833 if (size < sizeof(*hdr)) 834 return false; 835 836 if (hdr->magic != cpu_to_be32(FWDB_MAGIC)) 837 return false; 838 839 if (hdr->version != cpu_to_be32(FWDB_VERSION)) 840 return false; 841 842 if (!regdb_has_valid_signature(data, size)) 843 return false; 844 845 country = &hdr->country[0]; 846 while ((u8 *)(country + 1) <= data + size) { 847 if (!country->coll_ptr) 848 break; 849 if (!valid_country(data, size, country)) 850 return false; 851 country++; 852 } 853 854 return true; 855 } 856 857 static void set_wmm_rule(const struct fwdb_header *db, 858 const struct fwdb_country *country, 859 const struct fwdb_rule *rule, 860 struct ieee80211_reg_rule *rrule) 861 { 862 struct ieee80211_wmm_rule *wmm_rule = &rrule->wmm_rule; 863 struct fwdb_wmm_rule *wmm; 864 unsigned int i, wmm_ptr; 865 866 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2; 867 wmm = (void *)((u8 *)db + wmm_ptr); 868 869 if (!valid_wmm(wmm)) { 870 pr_err("Invalid regulatory WMM rule %u-%u in domain %c%c\n", 871 be32_to_cpu(rule->start), be32_to_cpu(rule->end), 872 country->alpha2[0], country->alpha2[1]); 873 return; 874 } 875 876 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 877 wmm_rule->client[i].cw_min = 878 ecw2cw((wmm->client[i].ecw & 0xf0) >> 4); 879 wmm_rule->client[i].cw_max = ecw2cw(wmm->client[i].ecw & 0x0f); 880 wmm_rule->client[i].aifsn = wmm->client[i].aifsn; 881 wmm_rule->client[i].cot = 882 1000 * be16_to_cpu(wmm->client[i].cot); 883 wmm_rule->ap[i].cw_min = ecw2cw((wmm->ap[i].ecw & 0xf0) >> 4); 884 wmm_rule->ap[i].cw_max = ecw2cw(wmm->ap[i].ecw & 0x0f); 885 wmm_rule->ap[i].aifsn = wmm->ap[i].aifsn; 886 wmm_rule->ap[i].cot = 1000 * be16_to_cpu(wmm->ap[i].cot); 887 } 888 889 rrule->has_wmm = true; 890 } 891 892 static int __regdb_query_wmm(const struct fwdb_header *db, 893 const struct fwdb_country *country, int freq, 894 struct ieee80211_reg_rule *rrule) 895 { 896 unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2; 897 struct fwdb_collection *coll = (void *)((u8 *)db + ptr); 898 int i; 899 900 for (i = 0; i < coll->n_rules; i++) { 901 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2)); 902 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2; 903 struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr); 904 905 if (rule->len < offsetofend(struct fwdb_rule, wmm_ptr)) 906 continue; 907 908 if (freq >= KHZ_TO_MHZ(be32_to_cpu(rule->start)) && 909 freq <= KHZ_TO_MHZ(be32_to_cpu(rule->end))) { 910 set_wmm_rule(db, country, rule, rrule); 911 return 0; 912 } 913 } 914 915 return -ENODATA; 916 } 917 918 int reg_query_regdb_wmm(char *alpha2, int freq, struct ieee80211_reg_rule *rule) 919 { 920 const struct fwdb_header *hdr = regdb; 921 const struct fwdb_country *country; 922 923 if (!regdb) 924 return -ENODATA; 925 926 if (IS_ERR(regdb)) 927 return PTR_ERR(regdb); 928 929 country = &hdr->country[0]; 930 while (country->coll_ptr) { 931 if (alpha2_equal(alpha2, country->alpha2)) 932 return __regdb_query_wmm(regdb, country, freq, rule); 933 934 country++; 935 } 936 937 return -ENODATA; 938 } 939 EXPORT_SYMBOL(reg_query_regdb_wmm); 940 941 static int regdb_query_country(const struct fwdb_header *db, 942 const struct fwdb_country *country) 943 { 944 unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2; 945 struct fwdb_collection *coll = (void *)((u8 *)db + ptr); 946 struct ieee80211_regdomain *regdom; 947 unsigned int i; 948 949 regdom = kzalloc(struct_size(regdom, reg_rules, coll->n_rules), 950 GFP_KERNEL); 951 if (!regdom) 952 return -ENOMEM; 953 954 regdom->n_reg_rules = coll->n_rules; 955 regdom->alpha2[0] = country->alpha2[0]; 956 regdom->alpha2[1] = country->alpha2[1]; 957 regdom->dfs_region = coll->dfs_region; 958 959 for (i = 0; i < regdom->n_reg_rules; i++) { 960 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2)); 961 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2; 962 struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr); 963 struct ieee80211_reg_rule *rrule = ®dom->reg_rules[i]; 964 965 rrule->freq_range.start_freq_khz = be32_to_cpu(rule->start); 966 rrule->freq_range.end_freq_khz = be32_to_cpu(rule->end); 967 rrule->freq_range.max_bandwidth_khz = be32_to_cpu(rule->max_bw); 968 969 rrule->power_rule.max_antenna_gain = 0; 970 rrule->power_rule.max_eirp = be16_to_cpu(rule->max_eirp); 971 972 rrule->flags = 0; 973 if (rule->flags & FWDB_FLAG_NO_OFDM) 974 rrule->flags |= NL80211_RRF_NO_OFDM; 975 if (rule->flags & FWDB_FLAG_NO_OUTDOOR) 976 rrule->flags |= NL80211_RRF_NO_OUTDOOR; 977 if (rule->flags & FWDB_FLAG_DFS) 978 rrule->flags |= NL80211_RRF_DFS; 979 if (rule->flags & FWDB_FLAG_NO_IR) 980 rrule->flags |= NL80211_RRF_NO_IR; 981 if (rule->flags & FWDB_FLAG_AUTO_BW) 982 rrule->flags |= NL80211_RRF_AUTO_BW; 983 984 rrule->dfs_cac_ms = 0; 985 986 /* handle optional data */ 987 if (rule->len >= offsetofend(struct fwdb_rule, cac_timeout)) 988 rrule->dfs_cac_ms = 989 1000 * be16_to_cpu(rule->cac_timeout); 990 if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) 991 set_wmm_rule(db, country, rule, rrule); 992 } 993 994 return reg_schedule_apply(regdom); 995 } 996 997 static int query_regdb(const char *alpha2) 998 { 999 const struct fwdb_header *hdr = regdb; 1000 const struct fwdb_country *country; 1001 1002 ASSERT_RTNL(); 1003 1004 if (IS_ERR(regdb)) 1005 return PTR_ERR(regdb); 1006 1007 country = &hdr->country[0]; 1008 while (country->coll_ptr) { 1009 if (alpha2_equal(alpha2, country->alpha2)) 1010 return regdb_query_country(regdb, country); 1011 country++; 1012 } 1013 1014 return -ENODATA; 1015 } 1016 1017 static void regdb_fw_cb(const struct firmware *fw, void *context) 1018 { 1019 int set_error = 0; 1020 bool restore = true; 1021 void *db; 1022 1023 if (!fw) { 1024 pr_info("failed to load regulatory.db\n"); 1025 set_error = -ENODATA; 1026 } else if (!valid_regdb(fw->data, fw->size)) { 1027 pr_info("loaded regulatory.db is malformed or signature is missing/invalid\n"); 1028 set_error = -EINVAL; 1029 } 1030 1031 rtnl_lock(); 1032 if (regdb && !IS_ERR(regdb)) { 1033 /* negative case - a bug 1034 * positive case - can happen due to race in case of multiple cb's in 1035 * queue, due to usage of asynchronous callback 1036 * 1037 * Either case, just restore and free new db. 1038 */ 1039 } else if (set_error) { 1040 regdb = ERR_PTR(set_error); 1041 } else if (fw) { 1042 db = kmemdup(fw->data, fw->size, GFP_KERNEL); 1043 if (db) { 1044 regdb = db; 1045 restore = context && query_regdb(context); 1046 } else { 1047 restore = true; 1048 } 1049 } 1050 1051 if (restore) 1052 restore_regulatory_settings(true, false); 1053 1054 rtnl_unlock(); 1055 1056 kfree(context); 1057 1058 release_firmware(fw); 1059 } 1060 1061 static int query_regdb_file(const char *alpha2) 1062 { 1063 ASSERT_RTNL(); 1064 1065 if (regdb) 1066 return query_regdb(alpha2); 1067 1068 alpha2 = kmemdup(alpha2, 2, GFP_KERNEL); 1069 if (!alpha2) 1070 return -ENOMEM; 1071 1072 return request_firmware_nowait(THIS_MODULE, true, "regulatory.db", 1073 ®_pdev->dev, GFP_KERNEL, 1074 (void *)alpha2, regdb_fw_cb); 1075 } 1076 1077 int reg_reload_regdb(void) 1078 { 1079 const struct firmware *fw; 1080 void *db; 1081 int err; 1082 1083 err = request_firmware(&fw, "regulatory.db", ®_pdev->dev); 1084 if (err) 1085 return err; 1086 1087 if (!valid_regdb(fw->data, fw->size)) { 1088 err = -ENODATA; 1089 goto out; 1090 } 1091 1092 db = kmemdup(fw->data, fw->size, GFP_KERNEL); 1093 if (!db) { 1094 err = -ENOMEM; 1095 goto out; 1096 } 1097 1098 rtnl_lock(); 1099 if (!IS_ERR_OR_NULL(regdb)) 1100 kfree(regdb); 1101 regdb = db; 1102 rtnl_unlock(); 1103 1104 out: 1105 release_firmware(fw); 1106 return err; 1107 } 1108 1109 static bool reg_query_database(struct regulatory_request *request) 1110 { 1111 if (query_regdb_file(request->alpha2) == 0) 1112 return true; 1113 1114 if (call_crda(request->alpha2) == 0) 1115 return true; 1116 1117 return false; 1118 } 1119 1120 bool reg_is_valid_request(const char *alpha2) 1121 { 1122 struct regulatory_request *lr = get_last_request(); 1123 1124 if (!lr || lr->processed) 1125 return false; 1126 1127 return alpha2_equal(lr->alpha2, alpha2); 1128 } 1129 1130 static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy) 1131 { 1132 struct regulatory_request *lr = get_last_request(); 1133 1134 /* 1135 * Follow the driver's regulatory domain, if present, unless a country 1136 * IE has been processed or a user wants to help complaince further 1137 */ 1138 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 1139 lr->initiator != NL80211_REGDOM_SET_BY_USER && 1140 wiphy->regd) 1141 return get_wiphy_regdom(wiphy); 1142 1143 return get_cfg80211_regdom(); 1144 } 1145 1146 static unsigned int 1147 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd, 1148 const struct ieee80211_reg_rule *rule) 1149 { 1150 const struct ieee80211_freq_range *freq_range = &rule->freq_range; 1151 const struct ieee80211_freq_range *freq_range_tmp; 1152 const struct ieee80211_reg_rule *tmp; 1153 u32 start_freq, end_freq, idx, no; 1154 1155 for (idx = 0; idx < rd->n_reg_rules; idx++) 1156 if (rule == &rd->reg_rules[idx]) 1157 break; 1158 1159 if (idx == rd->n_reg_rules) 1160 return 0; 1161 1162 /* get start_freq */ 1163 no = idx; 1164 1165 while (no) { 1166 tmp = &rd->reg_rules[--no]; 1167 freq_range_tmp = &tmp->freq_range; 1168 1169 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz) 1170 break; 1171 1172 freq_range = freq_range_tmp; 1173 } 1174 1175 start_freq = freq_range->start_freq_khz; 1176 1177 /* get end_freq */ 1178 freq_range = &rule->freq_range; 1179 no = idx; 1180 1181 while (no < rd->n_reg_rules - 1) { 1182 tmp = &rd->reg_rules[++no]; 1183 freq_range_tmp = &tmp->freq_range; 1184 1185 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz) 1186 break; 1187 1188 freq_range = freq_range_tmp; 1189 } 1190 1191 end_freq = freq_range->end_freq_khz; 1192 1193 return end_freq - start_freq; 1194 } 1195 1196 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd, 1197 const struct ieee80211_reg_rule *rule) 1198 { 1199 unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule); 1200 1201 if (rule->flags & NL80211_RRF_NO_160MHZ) 1202 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80)); 1203 if (rule->flags & NL80211_RRF_NO_80MHZ) 1204 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40)); 1205 1206 /* 1207 * HT40+/HT40- limits are handled per-channel. Only limit BW if both 1208 * are not allowed. 1209 */ 1210 if (rule->flags & NL80211_RRF_NO_HT40MINUS && 1211 rule->flags & NL80211_RRF_NO_HT40PLUS) 1212 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20)); 1213 1214 return bw; 1215 } 1216 1217 /* Sanity check on a regulatory rule */ 1218 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule) 1219 { 1220 const struct ieee80211_freq_range *freq_range = &rule->freq_range; 1221 u32 freq_diff; 1222 1223 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0) 1224 return false; 1225 1226 if (freq_range->start_freq_khz > freq_range->end_freq_khz) 1227 return false; 1228 1229 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz; 1230 1231 if (freq_range->end_freq_khz <= freq_range->start_freq_khz || 1232 freq_range->max_bandwidth_khz > freq_diff) 1233 return false; 1234 1235 return true; 1236 } 1237 1238 static bool is_valid_rd(const struct ieee80211_regdomain *rd) 1239 { 1240 const struct ieee80211_reg_rule *reg_rule = NULL; 1241 unsigned int i; 1242 1243 if (!rd->n_reg_rules) 1244 return false; 1245 1246 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES)) 1247 return false; 1248 1249 for (i = 0; i < rd->n_reg_rules; i++) { 1250 reg_rule = &rd->reg_rules[i]; 1251 if (!is_valid_reg_rule(reg_rule)) 1252 return false; 1253 } 1254 1255 return true; 1256 } 1257 1258 /** 1259 * freq_in_rule_band - tells us if a frequency is in a frequency band 1260 * @freq_range: frequency rule we want to query 1261 * @freq_khz: frequency we are inquiring about 1262 * 1263 * This lets us know if a specific frequency rule is or is not relevant to 1264 * a specific frequency's band. Bands are device specific and artificial 1265 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"), 1266 * however it is safe for now to assume that a frequency rule should not be 1267 * part of a frequency's band if the start freq or end freq are off by more 1268 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 20 GHz for the 1269 * 60 GHz band. 1270 * This resolution can be lowered and should be considered as we add 1271 * regulatory rule support for other "bands". 1272 **/ 1273 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range, 1274 u32 freq_khz) 1275 { 1276 #define ONE_GHZ_IN_KHZ 1000000 1277 /* 1278 * From 802.11ad: directional multi-gigabit (DMG): 1279 * Pertaining to operation in a frequency band containing a channel 1280 * with the Channel starting frequency above 45 GHz. 1281 */ 1282 u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ? 1283 20 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ; 1284 if (abs(freq_khz - freq_range->start_freq_khz) <= limit) 1285 return true; 1286 if (abs(freq_khz - freq_range->end_freq_khz) <= limit) 1287 return true; 1288 return false; 1289 #undef ONE_GHZ_IN_KHZ 1290 } 1291 1292 /* 1293 * Later on we can perhaps use the more restrictive DFS 1294 * region but we don't have information for that yet so 1295 * for now simply disallow conflicts. 1296 */ 1297 static enum nl80211_dfs_regions 1298 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1, 1299 const enum nl80211_dfs_regions dfs_region2) 1300 { 1301 if (dfs_region1 != dfs_region2) 1302 return NL80211_DFS_UNSET; 1303 return dfs_region1; 1304 } 1305 1306 static void reg_wmm_rules_intersect(const struct ieee80211_wmm_ac *wmm_ac1, 1307 const struct ieee80211_wmm_ac *wmm_ac2, 1308 struct ieee80211_wmm_ac *intersect) 1309 { 1310 intersect->cw_min = max_t(u16, wmm_ac1->cw_min, wmm_ac2->cw_min); 1311 intersect->cw_max = max_t(u16, wmm_ac1->cw_max, wmm_ac2->cw_max); 1312 intersect->cot = min_t(u16, wmm_ac1->cot, wmm_ac2->cot); 1313 intersect->aifsn = max_t(u8, wmm_ac1->aifsn, wmm_ac2->aifsn); 1314 } 1315 1316 /* 1317 * Helper for regdom_intersect(), this does the real 1318 * mathematical intersection fun 1319 */ 1320 static int reg_rules_intersect(const struct ieee80211_regdomain *rd1, 1321 const struct ieee80211_regdomain *rd2, 1322 const struct ieee80211_reg_rule *rule1, 1323 const struct ieee80211_reg_rule *rule2, 1324 struct ieee80211_reg_rule *intersected_rule) 1325 { 1326 const struct ieee80211_freq_range *freq_range1, *freq_range2; 1327 struct ieee80211_freq_range *freq_range; 1328 const struct ieee80211_power_rule *power_rule1, *power_rule2; 1329 struct ieee80211_power_rule *power_rule; 1330 const struct ieee80211_wmm_rule *wmm_rule1, *wmm_rule2; 1331 struct ieee80211_wmm_rule *wmm_rule; 1332 u32 freq_diff, max_bandwidth1, max_bandwidth2; 1333 1334 freq_range1 = &rule1->freq_range; 1335 freq_range2 = &rule2->freq_range; 1336 freq_range = &intersected_rule->freq_range; 1337 1338 power_rule1 = &rule1->power_rule; 1339 power_rule2 = &rule2->power_rule; 1340 power_rule = &intersected_rule->power_rule; 1341 1342 wmm_rule1 = &rule1->wmm_rule; 1343 wmm_rule2 = &rule2->wmm_rule; 1344 wmm_rule = &intersected_rule->wmm_rule; 1345 1346 freq_range->start_freq_khz = max(freq_range1->start_freq_khz, 1347 freq_range2->start_freq_khz); 1348 freq_range->end_freq_khz = min(freq_range1->end_freq_khz, 1349 freq_range2->end_freq_khz); 1350 1351 max_bandwidth1 = freq_range1->max_bandwidth_khz; 1352 max_bandwidth2 = freq_range2->max_bandwidth_khz; 1353 1354 if (rule1->flags & NL80211_RRF_AUTO_BW) 1355 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1); 1356 if (rule2->flags & NL80211_RRF_AUTO_BW) 1357 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2); 1358 1359 freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2); 1360 1361 intersected_rule->flags = rule1->flags | rule2->flags; 1362 1363 /* 1364 * In case NL80211_RRF_AUTO_BW requested for both rules 1365 * set AUTO_BW in intersected rule also. Next we will 1366 * calculate BW correctly in handle_channel function. 1367 * In other case remove AUTO_BW flag while we calculate 1368 * maximum bandwidth correctly and auto calculation is 1369 * not required. 1370 */ 1371 if ((rule1->flags & NL80211_RRF_AUTO_BW) && 1372 (rule2->flags & NL80211_RRF_AUTO_BW)) 1373 intersected_rule->flags |= NL80211_RRF_AUTO_BW; 1374 else 1375 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW; 1376 1377 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz; 1378 if (freq_range->max_bandwidth_khz > freq_diff) 1379 freq_range->max_bandwidth_khz = freq_diff; 1380 1381 power_rule->max_eirp = min(power_rule1->max_eirp, 1382 power_rule2->max_eirp); 1383 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain, 1384 power_rule2->max_antenna_gain); 1385 1386 intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms, 1387 rule2->dfs_cac_ms); 1388 1389 if (rule1->has_wmm && rule2->has_wmm) { 1390 u8 ac; 1391 1392 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 1393 reg_wmm_rules_intersect(&wmm_rule1->client[ac], 1394 &wmm_rule2->client[ac], 1395 &wmm_rule->client[ac]); 1396 reg_wmm_rules_intersect(&wmm_rule1->ap[ac], 1397 &wmm_rule2->ap[ac], 1398 &wmm_rule->ap[ac]); 1399 } 1400 1401 intersected_rule->has_wmm = true; 1402 } else if (rule1->has_wmm) { 1403 *wmm_rule = *wmm_rule1; 1404 intersected_rule->has_wmm = true; 1405 } else if (rule2->has_wmm) { 1406 *wmm_rule = *wmm_rule2; 1407 intersected_rule->has_wmm = true; 1408 } else { 1409 intersected_rule->has_wmm = false; 1410 } 1411 1412 if (!is_valid_reg_rule(intersected_rule)) 1413 return -EINVAL; 1414 1415 return 0; 1416 } 1417 1418 /* check whether old rule contains new rule */ 1419 static bool rule_contains(struct ieee80211_reg_rule *r1, 1420 struct ieee80211_reg_rule *r2) 1421 { 1422 /* for simplicity, currently consider only same flags */ 1423 if (r1->flags != r2->flags) 1424 return false; 1425 1426 /* verify r1 is more restrictive */ 1427 if ((r1->power_rule.max_antenna_gain > 1428 r2->power_rule.max_antenna_gain) || 1429 r1->power_rule.max_eirp > r2->power_rule.max_eirp) 1430 return false; 1431 1432 /* make sure r2's range is contained within r1 */ 1433 if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz || 1434 r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz) 1435 return false; 1436 1437 /* and finally verify that r1.max_bw >= r2.max_bw */ 1438 if (r1->freq_range.max_bandwidth_khz < 1439 r2->freq_range.max_bandwidth_khz) 1440 return false; 1441 1442 return true; 1443 } 1444 1445 /* add or extend current rules. do nothing if rule is already contained */ 1446 static void add_rule(struct ieee80211_reg_rule *rule, 1447 struct ieee80211_reg_rule *reg_rules, u32 *n_rules) 1448 { 1449 struct ieee80211_reg_rule *tmp_rule; 1450 int i; 1451 1452 for (i = 0; i < *n_rules; i++) { 1453 tmp_rule = ®_rules[i]; 1454 /* rule is already contained - do nothing */ 1455 if (rule_contains(tmp_rule, rule)) 1456 return; 1457 1458 /* extend rule if possible */ 1459 if (rule_contains(rule, tmp_rule)) { 1460 memcpy(tmp_rule, rule, sizeof(*rule)); 1461 return; 1462 } 1463 } 1464 1465 memcpy(®_rules[*n_rules], rule, sizeof(*rule)); 1466 (*n_rules)++; 1467 } 1468 1469 /** 1470 * regdom_intersect - do the intersection between two regulatory domains 1471 * @rd1: first regulatory domain 1472 * @rd2: second regulatory domain 1473 * 1474 * Use this function to get the intersection between two regulatory domains. 1475 * Once completed we will mark the alpha2 for the rd as intersected, "98", 1476 * as no one single alpha2 can represent this regulatory domain. 1477 * 1478 * Returns a pointer to the regulatory domain structure which will hold the 1479 * resulting intersection of rules between rd1 and rd2. We will 1480 * kzalloc() this structure for you. 1481 */ 1482 static struct ieee80211_regdomain * 1483 regdom_intersect(const struct ieee80211_regdomain *rd1, 1484 const struct ieee80211_regdomain *rd2) 1485 { 1486 int r; 1487 unsigned int x, y; 1488 unsigned int num_rules = 0; 1489 const struct ieee80211_reg_rule *rule1, *rule2; 1490 struct ieee80211_reg_rule intersected_rule; 1491 struct ieee80211_regdomain *rd; 1492 1493 if (!rd1 || !rd2) 1494 return NULL; 1495 1496 /* 1497 * First we get a count of the rules we'll need, then we actually 1498 * build them. This is to so we can malloc() and free() a 1499 * regdomain once. The reason we use reg_rules_intersect() here 1500 * is it will return -EINVAL if the rule computed makes no sense. 1501 * All rules that do check out OK are valid. 1502 */ 1503 1504 for (x = 0; x < rd1->n_reg_rules; x++) { 1505 rule1 = &rd1->reg_rules[x]; 1506 for (y = 0; y < rd2->n_reg_rules; y++) { 1507 rule2 = &rd2->reg_rules[y]; 1508 if (!reg_rules_intersect(rd1, rd2, rule1, rule2, 1509 &intersected_rule)) 1510 num_rules++; 1511 } 1512 } 1513 1514 if (!num_rules) 1515 return NULL; 1516 1517 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL); 1518 if (!rd) 1519 return NULL; 1520 1521 for (x = 0; x < rd1->n_reg_rules; x++) { 1522 rule1 = &rd1->reg_rules[x]; 1523 for (y = 0; y < rd2->n_reg_rules; y++) { 1524 rule2 = &rd2->reg_rules[y]; 1525 r = reg_rules_intersect(rd1, rd2, rule1, rule2, 1526 &intersected_rule); 1527 /* 1528 * No need to memset here the intersected rule here as 1529 * we're not using the stack anymore 1530 */ 1531 if (r) 1532 continue; 1533 1534 add_rule(&intersected_rule, rd->reg_rules, 1535 &rd->n_reg_rules); 1536 } 1537 } 1538 1539 rd->alpha2[0] = '9'; 1540 rd->alpha2[1] = '8'; 1541 rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region, 1542 rd2->dfs_region); 1543 1544 return rd; 1545 } 1546 1547 /* 1548 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may 1549 * want to just have the channel structure use these 1550 */ 1551 static u32 map_regdom_flags(u32 rd_flags) 1552 { 1553 u32 channel_flags = 0; 1554 if (rd_flags & NL80211_RRF_NO_IR_ALL) 1555 channel_flags |= IEEE80211_CHAN_NO_IR; 1556 if (rd_flags & NL80211_RRF_DFS) 1557 channel_flags |= IEEE80211_CHAN_RADAR; 1558 if (rd_flags & NL80211_RRF_NO_OFDM) 1559 channel_flags |= IEEE80211_CHAN_NO_OFDM; 1560 if (rd_flags & NL80211_RRF_NO_OUTDOOR) 1561 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY; 1562 if (rd_flags & NL80211_RRF_IR_CONCURRENT) 1563 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT; 1564 if (rd_flags & NL80211_RRF_NO_HT40MINUS) 1565 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS; 1566 if (rd_flags & NL80211_RRF_NO_HT40PLUS) 1567 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS; 1568 if (rd_flags & NL80211_RRF_NO_80MHZ) 1569 channel_flags |= IEEE80211_CHAN_NO_80MHZ; 1570 if (rd_flags & NL80211_RRF_NO_160MHZ) 1571 channel_flags |= IEEE80211_CHAN_NO_160MHZ; 1572 if (rd_flags & NL80211_RRF_NO_HE) 1573 channel_flags |= IEEE80211_CHAN_NO_HE; 1574 return channel_flags; 1575 } 1576 1577 static const struct ieee80211_reg_rule * 1578 freq_reg_info_regd(u32 center_freq, 1579 const struct ieee80211_regdomain *regd, u32 bw) 1580 { 1581 int i; 1582 bool band_rule_found = false; 1583 bool bw_fits = false; 1584 1585 if (!regd) 1586 return ERR_PTR(-EINVAL); 1587 1588 for (i = 0; i < regd->n_reg_rules; i++) { 1589 const struct ieee80211_reg_rule *rr; 1590 const struct ieee80211_freq_range *fr = NULL; 1591 1592 rr = ®d->reg_rules[i]; 1593 fr = &rr->freq_range; 1594 1595 /* 1596 * We only need to know if one frequency rule was 1597 * in center_freq's band, that's enough, so let's 1598 * not overwrite it once found 1599 */ 1600 if (!band_rule_found) 1601 band_rule_found = freq_in_rule_band(fr, center_freq); 1602 1603 bw_fits = cfg80211_does_bw_fit_range(fr, center_freq, bw); 1604 1605 if (band_rule_found && bw_fits) 1606 return rr; 1607 } 1608 1609 if (!band_rule_found) 1610 return ERR_PTR(-ERANGE); 1611 1612 return ERR_PTR(-EINVAL); 1613 } 1614 1615 static const struct ieee80211_reg_rule * 1616 __freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw) 1617 { 1618 const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy); 1619 static const u32 bws[] = {0, 1, 2, 4, 5, 8, 10, 16, 20}; 1620 const struct ieee80211_reg_rule *reg_rule; 1621 int i = ARRAY_SIZE(bws) - 1; 1622 u32 bw; 1623 1624 for (bw = MHZ_TO_KHZ(bws[i]); bw >= min_bw; bw = MHZ_TO_KHZ(bws[i--])) { 1625 reg_rule = freq_reg_info_regd(center_freq, regd, bw); 1626 if (!IS_ERR(reg_rule)) 1627 return reg_rule; 1628 } 1629 1630 return reg_rule; 1631 } 1632 1633 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy, 1634 u32 center_freq) 1635 { 1636 u32 min_bw = center_freq < MHZ_TO_KHZ(1000) ? 1 : 20; 1637 1638 return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(min_bw)); 1639 } 1640 EXPORT_SYMBOL(freq_reg_info); 1641 1642 const char *reg_initiator_name(enum nl80211_reg_initiator initiator) 1643 { 1644 switch (initiator) { 1645 case NL80211_REGDOM_SET_BY_CORE: 1646 return "core"; 1647 case NL80211_REGDOM_SET_BY_USER: 1648 return "user"; 1649 case NL80211_REGDOM_SET_BY_DRIVER: 1650 return "driver"; 1651 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 1652 return "country element"; 1653 default: 1654 WARN_ON(1); 1655 return "bug"; 1656 } 1657 } 1658 EXPORT_SYMBOL(reg_initiator_name); 1659 1660 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd, 1661 const struct ieee80211_reg_rule *reg_rule, 1662 const struct ieee80211_channel *chan) 1663 { 1664 const struct ieee80211_freq_range *freq_range = NULL; 1665 u32 max_bandwidth_khz, center_freq_khz, bw_flags = 0; 1666 bool is_s1g = chan->band == NL80211_BAND_S1GHZ; 1667 1668 freq_range = ®_rule->freq_range; 1669 1670 max_bandwidth_khz = freq_range->max_bandwidth_khz; 1671 center_freq_khz = ieee80211_channel_to_khz(chan); 1672 /* Check if auto calculation requested */ 1673 if (reg_rule->flags & NL80211_RRF_AUTO_BW) 1674 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule); 1675 1676 /* If we get a reg_rule we can assume that at least 5Mhz fit */ 1677 if (!cfg80211_does_bw_fit_range(freq_range, 1678 center_freq_khz, 1679 MHZ_TO_KHZ(10))) 1680 bw_flags |= IEEE80211_CHAN_NO_10MHZ; 1681 if (!cfg80211_does_bw_fit_range(freq_range, 1682 center_freq_khz, 1683 MHZ_TO_KHZ(20))) 1684 bw_flags |= IEEE80211_CHAN_NO_20MHZ; 1685 1686 if (is_s1g) { 1687 /* S1G is strict about non overlapping channels. We can 1688 * calculate which bandwidth is allowed per channel by finding 1689 * the largest bandwidth which cleanly divides the freq_range. 1690 */ 1691 int edge_offset; 1692 int ch_bw = max_bandwidth_khz; 1693 1694 while (ch_bw) { 1695 edge_offset = (center_freq_khz - ch_bw / 2) - 1696 freq_range->start_freq_khz; 1697 if (edge_offset % ch_bw == 0) { 1698 switch (KHZ_TO_MHZ(ch_bw)) { 1699 case 1: 1700 bw_flags |= IEEE80211_CHAN_1MHZ; 1701 break; 1702 case 2: 1703 bw_flags |= IEEE80211_CHAN_2MHZ; 1704 break; 1705 case 4: 1706 bw_flags |= IEEE80211_CHAN_4MHZ; 1707 break; 1708 case 8: 1709 bw_flags |= IEEE80211_CHAN_8MHZ; 1710 break; 1711 case 16: 1712 bw_flags |= IEEE80211_CHAN_16MHZ; 1713 break; 1714 default: 1715 /* If we got here, no bandwidths fit on 1716 * this frequency, ie. band edge. 1717 */ 1718 bw_flags |= IEEE80211_CHAN_DISABLED; 1719 break; 1720 } 1721 break; 1722 } 1723 ch_bw /= 2; 1724 } 1725 } else { 1726 if (max_bandwidth_khz < MHZ_TO_KHZ(10)) 1727 bw_flags |= IEEE80211_CHAN_NO_10MHZ; 1728 if (max_bandwidth_khz < MHZ_TO_KHZ(20)) 1729 bw_flags |= IEEE80211_CHAN_NO_20MHZ; 1730 if (max_bandwidth_khz < MHZ_TO_KHZ(40)) 1731 bw_flags |= IEEE80211_CHAN_NO_HT40; 1732 if (max_bandwidth_khz < MHZ_TO_KHZ(80)) 1733 bw_flags |= IEEE80211_CHAN_NO_80MHZ; 1734 if (max_bandwidth_khz < MHZ_TO_KHZ(160)) 1735 bw_flags |= IEEE80211_CHAN_NO_160MHZ; 1736 } 1737 return bw_flags; 1738 } 1739 1740 static void handle_channel_single_rule(struct wiphy *wiphy, 1741 enum nl80211_reg_initiator initiator, 1742 struct ieee80211_channel *chan, 1743 u32 flags, 1744 struct regulatory_request *lr, 1745 struct wiphy *request_wiphy, 1746 const struct ieee80211_reg_rule *reg_rule) 1747 { 1748 u32 bw_flags = 0; 1749 const struct ieee80211_power_rule *power_rule = NULL; 1750 const struct ieee80211_regdomain *regd; 1751 1752 regd = reg_get_regdomain(wiphy); 1753 1754 power_rule = ®_rule->power_rule; 1755 bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan); 1756 1757 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1758 request_wiphy && request_wiphy == wiphy && 1759 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 1760 /* 1761 * This guarantees the driver's requested regulatory domain 1762 * will always be used as a base for further regulatory 1763 * settings 1764 */ 1765 chan->flags = chan->orig_flags = 1766 map_regdom_flags(reg_rule->flags) | bw_flags; 1767 chan->max_antenna_gain = chan->orig_mag = 1768 (int) MBI_TO_DBI(power_rule->max_antenna_gain); 1769 chan->max_reg_power = chan->max_power = chan->orig_mpwr = 1770 (int) MBM_TO_DBM(power_rule->max_eirp); 1771 1772 if (chan->flags & IEEE80211_CHAN_RADAR) { 1773 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1774 if (reg_rule->dfs_cac_ms) 1775 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 1776 } 1777 1778 return; 1779 } 1780 1781 chan->dfs_state = NL80211_DFS_USABLE; 1782 chan->dfs_state_entered = jiffies; 1783 1784 chan->beacon_found = false; 1785 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags); 1786 chan->max_antenna_gain = 1787 min_t(int, chan->orig_mag, 1788 MBI_TO_DBI(power_rule->max_antenna_gain)); 1789 chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp); 1790 1791 if (chan->flags & IEEE80211_CHAN_RADAR) { 1792 if (reg_rule->dfs_cac_ms) 1793 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 1794 else 1795 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1796 } 1797 1798 if (chan->orig_mpwr) { 1799 /* 1800 * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER 1801 * will always follow the passed country IE power settings. 1802 */ 1803 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 1804 wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER) 1805 chan->max_power = chan->max_reg_power; 1806 else 1807 chan->max_power = min(chan->orig_mpwr, 1808 chan->max_reg_power); 1809 } else 1810 chan->max_power = chan->max_reg_power; 1811 } 1812 1813 static void handle_channel_adjacent_rules(struct wiphy *wiphy, 1814 enum nl80211_reg_initiator initiator, 1815 struct ieee80211_channel *chan, 1816 u32 flags, 1817 struct regulatory_request *lr, 1818 struct wiphy *request_wiphy, 1819 const struct ieee80211_reg_rule *rrule1, 1820 const struct ieee80211_reg_rule *rrule2, 1821 struct ieee80211_freq_range *comb_range) 1822 { 1823 u32 bw_flags1 = 0; 1824 u32 bw_flags2 = 0; 1825 const struct ieee80211_power_rule *power_rule1 = NULL; 1826 const struct ieee80211_power_rule *power_rule2 = NULL; 1827 const struct ieee80211_regdomain *regd; 1828 1829 regd = reg_get_regdomain(wiphy); 1830 1831 power_rule1 = &rrule1->power_rule; 1832 power_rule2 = &rrule2->power_rule; 1833 bw_flags1 = reg_rule_to_chan_bw_flags(regd, rrule1, chan); 1834 bw_flags2 = reg_rule_to_chan_bw_flags(regd, rrule2, chan); 1835 1836 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1837 request_wiphy && request_wiphy == wiphy && 1838 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 1839 /* This guarantees the driver's requested regulatory domain 1840 * will always be used as a base for further regulatory 1841 * settings 1842 */ 1843 chan->flags = 1844 map_regdom_flags(rrule1->flags) | 1845 map_regdom_flags(rrule2->flags) | 1846 bw_flags1 | 1847 bw_flags2; 1848 chan->orig_flags = chan->flags; 1849 chan->max_antenna_gain = 1850 min_t(int, MBI_TO_DBI(power_rule1->max_antenna_gain), 1851 MBI_TO_DBI(power_rule2->max_antenna_gain)); 1852 chan->orig_mag = chan->max_antenna_gain; 1853 chan->max_reg_power = 1854 min_t(int, MBM_TO_DBM(power_rule1->max_eirp), 1855 MBM_TO_DBM(power_rule2->max_eirp)); 1856 chan->max_power = chan->max_reg_power; 1857 chan->orig_mpwr = chan->max_reg_power; 1858 1859 if (chan->flags & IEEE80211_CHAN_RADAR) { 1860 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1861 if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms) 1862 chan->dfs_cac_ms = max_t(unsigned int, 1863 rrule1->dfs_cac_ms, 1864 rrule2->dfs_cac_ms); 1865 } 1866 1867 return; 1868 } 1869 1870 chan->dfs_state = NL80211_DFS_USABLE; 1871 chan->dfs_state_entered = jiffies; 1872 1873 chan->beacon_found = false; 1874 chan->flags = flags | bw_flags1 | bw_flags2 | 1875 map_regdom_flags(rrule1->flags) | 1876 map_regdom_flags(rrule2->flags); 1877 1878 /* reg_rule_to_chan_bw_flags may forbids 10 and forbids 20 MHz 1879 * (otherwise no adj. rule case), recheck therefore 1880 */ 1881 if (cfg80211_does_bw_fit_range(comb_range, 1882 ieee80211_channel_to_khz(chan), 1883 MHZ_TO_KHZ(10))) 1884 chan->flags &= ~IEEE80211_CHAN_NO_10MHZ; 1885 if (cfg80211_does_bw_fit_range(comb_range, 1886 ieee80211_channel_to_khz(chan), 1887 MHZ_TO_KHZ(20))) 1888 chan->flags &= ~IEEE80211_CHAN_NO_20MHZ; 1889 1890 chan->max_antenna_gain = 1891 min_t(int, chan->orig_mag, 1892 min_t(int, 1893 MBI_TO_DBI(power_rule1->max_antenna_gain), 1894 MBI_TO_DBI(power_rule2->max_antenna_gain))); 1895 chan->max_reg_power = min_t(int, 1896 MBM_TO_DBM(power_rule1->max_eirp), 1897 MBM_TO_DBM(power_rule2->max_eirp)); 1898 1899 if (chan->flags & IEEE80211_CHAN_RADAR) { 1900 if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms) 1901 chan->dfs_cac_ms = max_t(unsigned int, 1902 rrule1->dfs_cac_ms, 1903 rrule2->dfs_cac_ms); 1904 else 1905 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 1906 } 1907 1908 if (chan->orig_mpwr) { 1909 /* Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER 1910 * will always follow the passed country IE power settings. 1911 */ 1912 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 1913 wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER) 1914 chan->max_power = chan->max_reg_power; 1915 else 1916 chan->max_power = min(chan->orig_mpwr, 1917 chan->max_reg_power); 1918 } else { 1919 chan->max_power = chan->max_reg_power; 1920 } 1921 } 1922 1923 /* Note that right now we assume the desired channel bandwidth 1924 * is always 20 MHz for each individual channel (HT40 uses 20 MHz 1925 * per channel, the primary and the extension channel). 1926 */ 1927 static void handle_channel(struct wiphy *wiphy, 1928 enum nl80211_reg_initiator initiator, 1929 struct ieee80211_channel *chan) 1930 { 1931 const u32 orig_chan_freq = ieee80211_channel_to_khz(chan); 1932 struct regulatory_request *lr = get_last_request(); 1933 struct wiphy *request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 1934 const struct ieee80211_reg_rule *rrule = NULL; 1935 const struct ieee80211_reg_rule *rrule1 = NULL; 1936 const struct ieee80211_reg_rule *rrule2 = NULL; 1937 1938 u32 flags = chan->orig_flags; 1939 1940 rrule = freq_reg_info(wiphy, orig_chan_freq); 1941 if (IS_ERR(rrule)) { 1942 /* check for adjacent match, therefore get rules for 1943 * chan - 20 MHz and chan + 20 MHz and test 1944 * if reg rules are adjacent 1945 */ 1946 rrule1 = freq_reg_info(wiphy, 1947 orig_chan_freq - MHZ_TO_KHZ(20)); 1948 rrule2 = freq_reg_info(wiphy, 1949 orig_chan_freq + MHZ_TO_KHZ(20)); 1950 if (!IS_ERR(rrule1) && !IS_ERR(rrule2)) { 1951 struct ieee80211_freq_range comb_range; 1952 1953 if (rrule1->freq_range.end_freq_khz != 1954 rrule2->freq_range.start_freq_khz) 1955 goto disable_chan; 1956 1957 comb_range.start_freq_khz = 1958 rrule1->freq_range.start_freq_khz; 1959 comb_range.end_freq_khz = 1960 rrule2->freq_range.end_freq_khz; 1961 comb_range.max_bandwidth_khz = 1962 min_t(u32, 1963 rrule1->freq_range.max_bandwidth_khz, 1964 rrule2->freq_range.max_bandwidth_khz); 1965 1966 if (!cfg80211_does_bw_fit_range(&comb_range, 1967 orig_chan_freq, 1968 MHZ_TO_KHZ(20))) 1969 goto disable_chan; 1970 1971 handle_channel_adjacent_rules(wiphy, initiator, chan, 1972 flags, lr, request_wiphy, 1973 rrule1, rrule2, 1974 &comb_range); 1975 return; 1976 } 1977 1978 disable_chan: 1979 /* We will disable all channels that do not match our 1980 * received regulatory rule unless the hint is coming 1981 * from a Country IE and the Country IE had no information 1982 * about a band. The IEEE 802.11 spec allows for an AP 1983 * to send only a subset of the regulatory rules allowed, 1984 * so an AP in the US that only supports 2.4 GHz may only send 1985 * a country IE with information for the 2.4 GHz band 1986 * while 5 GHz is still supported. 1987 */ 1988 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 1989 PTR_ERR(rrule) == -ERANGE) 1990 return; 1991 1992 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 1993 request_wiphy && request_wiphy == wiphy && 1994 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 1995 pr_debug("Disabling freq %d.%03d MHz for good\n", 1996 chan->center_freq, chan->freq_offset); 1997 chan->orig_flags |= IEEE80211_CHAN_DISABLED; 1998 chan->flags = chan->orig_flags; 1999 } else { 2000 pr_debug("Disabling freq %d.%03d MHz\n", 2001 chan->center_freq, chan->freq_offset); 2002 chan->flags |= IEEE80211_CHAN_DISABLED; 2003 } 2004 return; 2005 } 2006 2007 handle_channel_single_rule(wiphy, initiator, chan, flags, lr, 2008 request_wiphy, rrule); 2009 } 2010 2011 static void handle_band(struct wiphy *wiphy, 2012 enum nl80211_reg_initiator initiator, 2013 struct ieee80211_supported_band *sband) 2014 { 2015 unsigned int i; 2016 2017 if (!sband) 2018 return; 2019 2020 for (i = 0; i < sband->n_channels; i++) 2021 handle_channel(wiphy, initiator, &sband->channels[i]); 2022 } 2023 2024 static bool reg_request_cell_base(struct regulatory_request *request) 2025 { 2026 if (request->initiator != NL80211_REGDOM_SET_BY_USER) 2027 return false; 2028 return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE; 2029 } 2030 2031 bool reg_last_request_cell_base(void) 2032 { 2033 return reg_request_cell_base(get_last_request()); 2034 } 2035 2036 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS 2037 /* Core specific check */ 2038 static enum reg_request_treatment 2039 reg_ignore_cell_hint(struct regulatory_request *pending_request) 2040 { 2041 struct regulatory_request *lr = get_last_request(); 2042 2043 if (!reg_num_devs_support_basehint) 2044 return REG_REQ_IGNORE; 2045 2046 if (reg_request_cell_base(lr) && 2047 !regdom_changes(pending_request->alpha2)) 2048 return REG_REQ_ALREADY_SET; 2049 2050 return REG_REQ_OK; 2051 } 2052 2053 /* Device specific check */ 2054 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy) 2055 { 2056 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS); 2057 } 2058 #else 2059 static enum reg_request_treatment 2060 reg_ignore_cell_hint(struct regulatory_request *pending_request) 2061 { 2062 return REG_REQ_IGNORE; 2063 } 2064 2065 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy) 2066 { 2067 return true; 2068 } 2069 #endif 2070 2071 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy) 2072 { 2073 if (wiphy->regulatory_flags & REGULATORY_STRICT_REG && 2074 !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)) 2075 return true; 2076 return false; 2077 } 2078 2079 static bool ignore_reg_update(struct wiphy *wiphy, 2080 enum nl80211_reg_initiator initiator) 2081 { 2082 struct regulatory_request *lr = get_last_request(); 2083 2084 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 2085 return true; 2086 2087 if (!lr) { 2088 pr_debug("Ignoring regulatory request set by %s since last_request is not set\n", 2089 reg_initiator_name(initiator)); 2090 return true; 2091 } 2092 2093 if (initiator == NL80211_REGDOM_SET_BY_CORE && 2094 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) { 2095 pr_debug("Ignoring regulatory request set by %s since the driver uses its own custom regulatory domain\n", 2096 reg_initiator_name(initiator)); 2097 return true; 2098 } 2099 2100 /* 2101 * wiphy->regd will be set once the device has its own 2102 * desired regulatory domain set 2103 */ 2104 if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd && 2105 initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 2106 !is_world_regdom(lr->alpha2)) { 2107 pr_debug("Ignoring regulatory request set by %s since the driver requires its own regulatory domain to be set first\n", 2108 reg_initiator_name(initiator)); 2109 return true; 2110 } 2111 2112 if (reg_request_cell_base(lr)) 2113 return reg_dev_ignore_cell_hint(wiphy); 2114 2115 return false; 2116 } 2117 2118 static bool reg_is_world_roaming(struct wiphy *wiphy) 2119 { 2120 const struct ieee80211_regdomain *cr = get_cfg80211_regdom(); 2121 const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy); 2122 struct regulatory_request *lr = get_last_request(); 2123 2124 if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2))) 2125 return true; 2126 2127 if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE && 2128 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) 2129 return true; 2130 2131 return false; 2132 } 2133 2134 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx, 2135 struct reg_beacon *reg_beacon) 2136 { 2137 struct ieee80211_supported_band *sband; 2138 struct ieee80211_channel *chan; 2139 bool channel_changed = false; 2140 struct ieee80211_channel chan_before; 2141 2142 sband = wiphy->bands[reg_beacon->chan.band]; 2143 chan = &sband->channels[chan_idx]; 2144 2145 if (likely(!ieee80211_channel_equal(chan, ®_beacon->chan))) 2146 return; 2147 2148 if (chan->beacon_found) 2149 return; 2150 2151 chan->beacon_found = true; 2152 2153 if (!reg_is_world_roaming(wiphy)) 2154 return; 2155 2156 if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS) 2157 return; 2158 2159 chan_before = *chan; 2160 2161 if (chan->flags & IEEE80211_CHAN_NO_IR) { 2162 chan->flags &= ~IEEE80211_CHAN_NO_IR; 2163 channel_changed = true; 2164 } 2165 2166 if (channel_changed) 2167 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan); 2168 } 2169 2170 /* 2171 * Called when a scan on a wiphy finds a beacon on 2172 * new channel 2173 */ 2174 static void wiphy_update_new_beacon(struct wiphy *wiphy, 2175 struct reg_beacon *reg_beacon) 2176 { 2177 unsigned int i; 2178 struct ieee80211_supported_band *sband; 2179 2180 if (!wiphy->bands[reg_beacon->chan.band]) 2181 return; 2182 2183 sband = wiphy->bands[reg_beacon->chan.band]; 2184 2185 for (i = 0; i < sband->n_channels; i++) 2186 handle_reg_beacon(wiphy, i, reg_beacon); 2187 } 2188 2189 /* 2190 * Called upon reg changes or a new wiphy is added 2191 */ 2192 static void wiphy_update_beacon_reg(struct wiphy *wiphy) 2193 { 2194 unsigned int i; 2195 struct ieee80211_supported_band *sband; 2196 struct reg_beacon *reg_beacon; 2197 2198 list_for_each_entry(reg_beacon, ®_beacon_list, list) { 2199 if (!wiphy->bands[reg_beacon->chan.band]) 2200 continue; 2201 sband = wiphy->bands[reg_beacon->chan.band]; 2202 for (i = 0; i < sband->n_channels; i++) 2203 handle_reg_beacon(wiphy, i, reg_beacon); 2204 } 2205 } 2206 2207 /* Reap the advantages of previously found beacons */ 2208 static void reg_process_beacons(struct wiphy *wiphy) 2209 { 2210 /* 2211 * Means we are just firing up cfg80211, so no beacons would 2212 * have been processed yet. 2213 */ 2214 if (!last_request) 2215 return; 2216 wiphy_update_beacon_reg(wiphy); 2217 } 2218 2219 static bool is_ht40_allowed(struct ieee80211_channel *chan) 2220 { 2221 if (!chan) 2222 return false; 2223 if (chan->flags & IEEE80211_CHAN_DISABLED) 2224 return false; 2225 /* This would happen when regulatory rules disallow HT40 completely */ 2226 if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40) 2227 return false; 2228 return true; 2229 } 2230 2231 static void reg_process_ht_flags_channel(struct wiphy *wiphy, 2232 struct ieee80211_channel *channel) 2233 { 2234 struct ieee80211_supported_band *sband = wiphy->bands[channel->band]; 2235 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL; 2236 const struct ieee80211_regdomain *regd; 2237 unsigned int i; 2238 u32 flags; 2239 2240 if (!is_ht40_allowed(channel)) { 2241 channel->flags |= IEEE80211_CHAN_NO_HT40; 2242 return; 2243 } 2244 2245 /* 2246 * We need to ensure the extension channels exist to 2247 * be able to use HT40- or HT40+, this finds them (or not) 2248 */ 2249 for (i = 0; i < sband->n_channels; i++) { 2250 struct ieee80211_channel *c = &sband->channels[i]; 2251 2252 if (c->center_freq == (channel->center_freq - 20)) 2253 channel_before = c; 2254 if (c->center_freq == (channel->center_freq + 20)) 2255 channel_after = c; 2256 } 2257 2258 flags = 0; 2259 regd = get_wiphy_regdom(wiphy); 2260 if (regd) { 2261 const struct ieee80211_reg_rule *reg_rule = 2262 freq_reg_info_regd(MHZ_TO_KHZ(channel->center_freq), 2263 regd, MHZ_TO_KHZ(20)); 2264 2265 if (!IS_ERR(reg_rule)) 2266 flags = reg_rule->flags; 2267 } 2268 2269 /* 2270 * Please note that this assumes target bandwidth is 20 MHz, 2271 * if that ever changes we also need to change the below logic 2272 * to include that as well. 2273 */ 2274 if (!is_ht40_allowed(channel_before) || 2275 flags & NL80211_RRF_NO_HT40MINUS) 2276 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS; 2277 else 2278 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS; 2279 2280 if (!is_ht40_allowed(channel_after) || 2281 flags & NL80211_RRF_NO_HT40PLUS) 2282 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS; 2283 else 2284 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS; 2285 } 2286 2287 static void reg_process_ht_flags_band(struct wiphy *wiphy, 2288 struct ieee80211_supported_band *sband) 2289 { 2290 unsigned int i; 2291 2292 if (!sband) 2293 return; 2294 2295 for (i = 0; i < sband->n_channels; i++) 2296 reg_process_ht_flags_channel(wiphy, &sband->channels[i]); 2297 } 2298 2299 static void reg_process_ht_flags(struct wiphy *wiphy) 2300 { 2301 enum nl80211_band band; 2302 2303 if (!wiphy) 2304 return; 2305 2306 for (band = 0; band < NUM_NL80211_BANDS; band++) 2307 reg_process_ht_flags_band(wiphy, wiphy->bands[band]); 2308 } 2309 2310 static void reg_call_notifier(struct wiphy *wiphy, 2311 struct regulatory_request *request) 2312 { 2313 if (wiphy->reg_notifier) 2314 wiphy->reg_notifier(wiphy, request); 2315 } 2316 2317 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev) 2318 { 2319 struct cfg80211_chan_def chandef = {}; 2320 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 2321 enum nl80211_iftype iftype; 2322 2323 wdev_lock(wdev); 2324 iftype = wdev->iftype; 2325 2326 /* make sure the interface is active */ 2327 if (!wdev->netdev || !netif_running(wdev->netdev)) 2328 goto wdev_inactive_unlock; 2329 2330 switch (iftype) { 2331 case NL80211_IFTYPE_AP: 2332 case NL80211_IFTYPE_P2P_GO: 2333 if (!wdev->beacon_interval) 2334 goto wdev_inactive_unlock; 2335 chandef = wdev->chandef; 2336 break; 2337 case NL80211_IFTYPE_ADHOC: 2338 if (!wdev->ssid_len) 2339 goto wdev_inactive_unlock; 2340 chandef = wdev->chandef; 2341 break; 2342 case NL80211_IFTYPE_STATION: 2343 case NL80211_IFTYPE_P2P_CLIENT: 2344 if (!wdev->current_bss || 2345 !wdev->current_bss->pub.channel) 2346 goto wdev_inactive_unlock; 2347 2348 if (!rdev->ops->get_channel || 2349 rdev_get_channel(rdev, wdev, &chandef)) 2350 cfg80211_chandef_create(&chandef, 2351 wdev->current_bss->pub.channel, 2352 NL80211_CHAN_NO_HT); 2353 break; 2354 case NL80211_IFTYPE_MONITOR: 2355 case NL80211_IFTYPE_AP_VLAN: 2356 case NL80211_IFTYPE_P2P_DEVICE: 2357 /* no enforcement required */ 2358 break; 2359 default: 2360 /* others not implemented for now */ 2361 WARN_ON(1); 2362 break; 2363 } 2364 2365 wdev_unlock(wdev); 2366 2367 switch (iftype) { 2368 case NL80211_IFTYPE_AP: 2369 case NL80211_IFTYPE_P2P_GO: 2370 case NL80211_IFTYPE_ADHOC: 2371 return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype); 2372 case NL80211_IFTYPE_STATION: 2373 case NL80211_IFTYPE_P2P_CLIENT: 2374 return cfg80211_chandef_usable(wiphy, &chandef, 2375 IEEE80211_CHAN_DISABLED); 2376 default: 2377 break; 2378 } 2379 2380 return true; 2381 2382 wdev_inactive_unlock: 2383 wdev_unlock(wdev); 2384 return true; 2385 } 2386 2387 static void reg_leave_invalid_chans(struct wiphy *wiphy) 2388 { 2389 struct wireless_dev *wdev; 2390 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 2391 2392 ASSERT_RTNL(); 2393 2394 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) 2395 if (!reg_wdev_chan_valid(wiphy, wdev)) 2396 cfg80211_leave(rdev, wdev); 2397 } 2398 2399 static void reg_check_chans_work(struct work_struct *work) 2400 { 2401 struct cfg80211_registered_device *rdev; 2402 2403 pr_debug("Verifying active interfaces after reg change\n"); 2404 rtnl_lock(); 2405 2406 list_for_each_entry(rdev, &cfg80211_rdev_list, list) 2407 if (!(rdev->wiphy.regulatory_flags & 2408 REGULATORY_IGNORE_STALE_KICKOFF)) 2409 reg_leave_invalid_chans(&rdev->wiphy); 2410 2411 rtnl_unlock(); 2412 } 2413 2414 static void reg_check_channels(void) 2415 { 2416 /* 2417 * Give usermode a chance to do something nicer (move to another 2418 * channel, orderly disconnection), before forcing a disconnection. 2419 */ 2420 mod_delayed_work(system_power_efficient_wq, 2421 ®_check_chans, 2422 msecs_to_jiffies(REG_ENFORCE_GRACE_MS)); 2423 } 2424 2425 static void wiphy_update_regulatory(struct wiphy *wiphy, 2426 enum nl80211_reg_initiator initiator) 2427 { 2428 enum nl80211_band band; 2429 struct regulatory_request *lr = get_last_request(); 2430 2431 if (ignore_reg_update(wiphy, initiator)) { 2432 /* 2433 * Regulatory updates set by CORE are ignored for custom 2434 * regulatory cards. Let us notify the changes to the driver, 2435 * as some drivers used this to restore its orig_* reg domain. 2436 */ 2437 if (initiator == NL80211_REGDOM_SET_BY_CORE && 2438 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG && 2439 !(wiphy->regulatory_flags & 2440 REGULATORY_WIPHY_SELF_MANAGED)) 2441 reg_call_notifier(wiphy, lr); 2442 return; 2443 } 2444 2445 lr->dfs_region = get_cfg80211_regdom()->dfs_region; 2446 2447 for (band = 0; band < NUM_NL80211_BANDS; band++) 2448 handle_band(wiphy, initiator, wiphy->bands[band]); 2449 2450 reg_process_beacons(wiphy); 2451 reg_process_ht_flags(wiphy); 2452 reg_call_notifier(wiphy, lr); 2453 } 2454 2455 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator) 2456 { 2457 struct cfg80211_registered_device *rdev; 2458 struct wiphy *wiphy; 2459 2460 ASSERT_RTNL(); 2461 2462 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2463 wiphy = &rdev->wiphy; 2464 wiphy_update_regulatory(wiphy, initiator); 2465 } 2466 2467 reg_check_channels(); 2468 } 2469 2470 static void handle_channel_custom(struct wiphy *wiphy, 2471 struct ieee80211_channel *chan, 2472 const struct ieee80211_regdomain *regd, 2473 u32 min_bw) 2474 { 2475 u32 bw_flags = 0; 2476 const struct ieee80211_reg_rule *reg_rule = NULL; 2477 const struct ieee80211_power_rule *power_rule = NULL; 2478 u32 bw, center_freq_khz; 2479 2480 center_freq_khz = ieee80211_channel_to_khz(chan); 2481 for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) { 2482 reg_rule = freq_reg_info_regd(center_freq_khz, regd, bw); 2483 if (!IS_ERR(reg_rule)) 2484 break; 2485 } 2486 2487 if (IS_ERR_OR_NULL(reg_rule)) { 2488 pr_debug("Disabling freq %d.%03d MHz as custom regd has no rule that fits it\n", 2489 chan->center_freq, chan->freq_offset); 2490 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) { 2491 chan->flags |= IEEE80211_CHAN_DISABLED; 2492 } else { 2493 chan->orig_flags |= IEEE80211_CHAN_DISABLED; 2494 chan->flags = chan->orig_flags; 2495 } 2496 return; 2497 } 2498 2499 power_rule = ®_rule->power_rule; 2500 bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan); 2501 2502 chan->dfs_state_entered = jiffies; 2503 chan->dfs_state = NL80211_DFS_USABLE; 2504 2505 chan->beacon_found = false; 2506 2507 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 2508 chan->flags = chan->orig_flags | bw_flags | 2509 map_regdom_flags(reg_rule->flags); 2510 else 2511 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags; 2512 2513 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain); 2514 chan->max_reg_power = chan->max_power = 2515 (int) MBM_TO_DBM(power_rule->max_eirp); 2516 2517 if (chan->flags & IEEE80211_CHAN_RADAR) { 2518 if (reg_rule->dfs_cac_ms) 2519 chan->dfs_cac_ms = reg_rule->dfs_cac_ms; 2520 else 2521 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 2522 } 2523 2524 chan->max_power = chan->max_reg_power; 2525 } 2526 2527 static void handle_band_custom(struct wiphy *wiphy, 2528 struct ieee80211_supported_band *sband, 2529 const struct ieee80211_regdomain *regd) 2530 { 2531 unsigned int i; 2532 2533 if (!sband) 2534 return; 2535 2536 /* 2537 * We currently assume that you always want at least 20 MHz, 2538 * otherwise channel 12 might get enabled if this rule is 2539 * compatible to US, which permits 2402 - 2472 MHz. 2540 */ 2541 for (i = 0; i < sband->n_channels; i++) 2542 handle_channel_custom(wiphy, &sband->channels[i], regd, 2543 MHZ_TO_KHZ(20)); 2544 } 2545 2546 /* Used by drivers prior to wiphy registration */ 2547 void wiphy_apply_custom_regulatory(struct wiphy *wiphy, 2548 const struct ieee80211_regdomain *regd) 2549 { 2550 const struct ieee80211_regdomain *new_regd, *tmp; 2551 enum nl80211_band band; 2552 unsigned int bands_set = 0; 2553 2554 WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG), 2555 "wiphy should have REGULATORY_CUSTOM_REG\n"); 2556 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG; 2557 2558 for (band = 0; band < NUM_NL80211_BANDS; band++) { 2559 if (!wiphy->bands[band]) 2560 continue; 2561 handle_band_custom(wiphy, wiphy->bands[band], regd); 2562 bands_set++; 2563 } 2564 2565 /* 2566 * no point in calling this if it won't have any effect 2567 * on your device's supported bands. 2568 */ 2569 WARN_ON(!bands_set); 2570 new_regd = reg_copy_regd(regd); 2571 if (IS_ERR(new_regd)) 2572 return; 2573 2574 tmp = get_wiphy_regdom(wiphy); 2575 rcu_assign_pointer(wiphy->regd, new_regd); 2576 rcu_free_regdom(tmp); 2577 } 2578 EXPORT_SYMBOL(wiphy_apply_custom_regulatory); 2579 2580 static void reg_set_request_processed(void) 2581 { 2582 bool need_more_processing = false; 2583 struct regulatory_request *lr = get_last_request(); 2584 2585 lr->processed = true; 2586 2587 spin_lock(®_requests_lock); 2588 if (!list_empty(®_requests_list)) 2589 need_more_processing = true; 2590 spin_unlock(®_requests_lock); 2591 2592 cancel_crda_timeout(); 2593 2594 if (need_more_processing) 2595 schedule_work(®_work); 2596 } 2597 2598 /** 2599 * reg_process_hint_core - process core regulatory requests 2600 * @core_request: a pending core regulatory request 2601 * 2602 * The wireless subsystem can use this function to process 2603 * a regulatory request issued by the regulatory core. 2604 */ 2605 static enum reg_request_treatment 2606 reg_process_hint_core(struct regulatory_request *core_request) 2607 { 2608 if (reg_query_database(core_request)) { 2609 core_request->intersect = false; 2610 core_request->processed = false; 2611 reg_update_last_request(core_request); 2612 return REG_REQ_OK; 2613 } 2614 2615 return REG_REQ_IGNORE; 2616 } 2617 2618 static enum reg_request_treatment 2619 __reg_process_hint_user(struct regulatory_request *user_request) 2620 { 2621 struct regulatory_request *lr = get_last_request(); 2622 2623 if (reg_request_cell_base(user_request)) 2624 return reg_ignore_cell_hint(user_request); 2625 2626 if (reg_request_cell_base(lr)) 2627 return REG_REQ_IGNORE; 2628 2629 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) 2630 return REG_REQ_INTERSECT; 2631 /* 2632 * If the user knows better the user should set the regdom 2633 * to their country before the IE is picked up 2634 */ 2635 if (lr->initiator == NL80211_REGDOM_SET_BY_USER && 2636 lr->intersect) 2637 return REG_REQ_IGNORE; 2638 /* 2639 * Process user requests only after previous user/driver/core 2640 * requests have been processed 2641 */ 2642 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE || 2643 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER || 2644 lr->initiator == NL80211_REGDOM_SET_BY_USER) && 2645 regdom_changes(lr->alpha2)) 2646 return REG_REQ_IGNORE; 2647 2648 if (!regdom_changes(user_request->alpha2)) 2649 return REG_REQ_ALREADY_SET; 2650 2651 return REG_REQ_OK; 2652 } 2653 2654 /** 2655 * reg_process_hint_user - process user regulatory requests 2656 * @user_request: a pending user regulatory request 2657 * 2658 * The wireless subsystem can use this function to process 2659 * a regulatory request initiated by userspace. 2660 */ 2661 static enum reg_request_treatment 2662 reg_process_hint_user(struct regulatory_request *user_request) 2663 { 2664 enum reg_request_treatment treatment; 2665 2666 treatment = __reg_process_hint_user(user_request); 2667 if (treatment == REG_REQ_IGNORE || 2668 treatment == REG_REQ_ALREADY_SET) 2669 return REG_REQ_IGNORE; 2670 2671 user_request->intersect = treatment == REG_REQ_INTERSECT; 2672 user_request->processed = false; 2673 2674 if (reg_query_database(user_request)) { 2675 reg_update_last_request(user_request); 2676 user_alpha2[0] = user_request->alpha2[0]; 2677 user_alpha2[1] = user_request->alpha2[1]; 2678 return REG_REQ_OK; 2679 } 2680 2681 return REG_REQ_IGNORE; 2682 } 2683 2684 static enum reg_request_treatment 2685 __reg_process_hint_driver(struct regulatory_request *driver_request) 2686 { 2687 struct regulatory_request *lr = get_last_request(); 2688 2689 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) { 2690 if (regdom_changes(driver_request->alpha2)) 2691 return REG_REQ_OK; 2692 return REG_REQ_ALREADY_SET; 2693 } 2694 2695 /* 2696 * This would happen if you unplug and plug your card 2697 * back in or if you add a new device for which the previously 2698 * loaded card also agrees on the regulatory domain. 2699 */ 2700 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER && 2701 !regdom_changes(driver_request->alpha2)) 2702 return REG_REQ_ALREADY_SET; 2703 2704 return REG_REQ_INTERSECT; 2705 } 2706 2707 /** 2708 * reg_process_hint_driver - process driver regulatory requests 2709 * @wiphy: the wireless device for the regulatory request 2710 * @driver_request: a pending driver regulatory request 2711 * 2712 * The wireless subsystem can use this function to process 2713 * a regulatory request issued by an 802.11 driver. 2714 * 2715 * Returns one of the different reg request treatment values. 2716 */ 2717 static enum reg_request_treatment 2718 reg_process_hint_driver(struct wiphy *wiphy, 2719 struct regulatory_request *driver_request) 2720 { 2721 const struct ieee80211_regdomain *regd, *tmp; 2722 enum reg_request_treatment treatment; 2723 2724 treatment = __reg_process_hint_driver(driver_request); 2725 2726 switch (treatment) { 2727 case REG_REQ_OK: 2728 break; 2729 case REG_REQ_IGNORE: 2730 return REG_REQ_IGNORE; 2731 case REG_REQ_INTERSECT: 2732 case REG_REQ_ALREADY_SET: 2733 regd = reg_copy_regd(get_cfg80211_regdom()); 2734 if (IS_ERR(regd)) 2735 return REG_REQ_IGNORE; 2736 2737 tmp = get_wiphy_regdom(wiphy); 2738 rcu_assign_pointer(wiphy->regd, regd); 2739 rcu_free_regdom(tmp); 2740 } 2741 2742 2743 driver_request->intersect = treatment == REG_REQ_INTERSECT; 2744 driver_request->processed = false; 2745 2746 /* 2747 * Since CRDA will not be called in this case as we already 2748 * have applied the requested regulatory domain before we just 2749 * inform userspace we have processed the request 2750 */ 2751 if (treatment == REG_REQ_ALREADY_SET) { 2752 nl80211_send_reg_change_event(driver_request); 2753 reg_update_last_request(driver_request); 2754 reg_set_request_processed(); 2755 return REG_REQ_ALREADY_SET; 2756 } 2757 2758 if (reg_query_database(driver_request)) { 2759 reg_update_last_request(driver_request); 2760 return REG_REQ_OK; 2761 } 2762 2763 return REG_REQ_IGNORE; 2764 } 2765 2766 static enum reg_request_treatment 2767 __reg_process_hint_country_ie(struct wiphy *wiphy, 2768 struct regulatory_request *country_ie_request) 2769 { 2770 struct wiphy *last_wiphy = NULL; 2771 struct regulatory_request *lr = get_last_request(); 2772 2773 if (reg_request_cell_base(lr)) { 2774 /* Trust a Cell base station over the AP's country IE */ 2775 if (regdom_changes(country_ie_request->alpha2)) 2776 return REG_REQ_IGNORE; 2777 return REG_REQ_ALREADY_SET; 2778 } else { 2779 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE) 2780 return REG_REQ_IGNORE; 2781 } 2782 2783 if (unlikely(!is_an_alpha2(country_ie_request->alpha2))) 2784 return -EINVAL; 2785 2786 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) 2787 return REG_REQ_OK; 2788 2789 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 2790 2791 if (last_wiphy != wiphy) { 2792 /* 2793 * Two cards with two APs claiming different 2794 * Country IE alpha2s. We could 2795 * intersect them, but that seems unlikely 2796 * to be correct. Reject second one for now. 2797 */ 2798 if (regdom_changes(country_ie_request->alpha2)) 2799 return REG_REQ_IGNORE; 2800 return REG_REQ_ALREADY_SET; 2801 } 2802 2803 if (regdom_changes(country_ie_request->alpha2)) 2804 return REG_REQ_OK; 2805 return REG_REQ_ALREADY_SET; 2806 } 2807 2808 /** 2809 * reg_process_hint_country_ie - process regulatory requests from country IEs 2810 * @wiphy: the wireless device for the regulatory request 2811 * @country_ie_request: a regulatory request from a country IE 2812 * 2813 * The wireless subsystem can use this function to process 2814 * a regulatory request issued by a country Information Element. 2815 * 2816 * Returns one of the different reg request treatment values. 2817 */ 2818 static enum reg_request_treatment 2819 reg_process_hint_country_ie(struct wiphy *wiphy, 2820 struct regulatory_request *country_ie_request) 2821 { 2822 enum reg_request_treatment treatment; 2823 2824 treatment = __reg_process_hint_country_ie(wiphy, country_ie_request); 2825 2826 switch (treatment) { 2827 case REG_REQ_OK: 2828 break; 2829 case REG_REQ_IGNORE: 2830 return REG_REQ_IGNORE; 2831 case REG_REQ_ALREADY_SET: 2832 reg_free_request(country_ie_request); 2833 return REG_REQ_ALREADY_SET; 2834 case REG_REQ_INTERSECT: 2835 /* 2836 * This doesn't happen yet, not sure we 2837 * ever want to support it for this case. 2838 */ 2839 WARN_ONCE(1, "Unexpected intersection for country elements"); 2840 return REG_REQ_IGNORE; 2841 } 2842 2843 country_ie_request->intersect = false; 2844 country_ie_request->processed = false; 2845 2846 if (reg_query_database(country_ie_request)) { 2847 reg_update_last_request(country_ie_request); 2848 return REG_REQ_OK; 2849 } 2850 2851 return REG_REQ_IGNORE; 2852 } 2853 2854 bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2) 2855 { 2856 const struct ieee80211_regdomain *wiphy1_regd = NULL; 2857 const struct ieee80211_regdomain *wiphy2_regd = NULL; 2858 const struct ieee80211_regdomain *cfg80211_regd = NULL; 2859 bool dfs_domain_same; 2860 2861 rcu_read_lock(); 2862 2863 cfg80211_regd = rcu_dereference(cfg80211_regdomain); 2864 wiphy1_regd = rcu_dereference(wiphy1->regd); 2865 if (!wiphy1_regd) 2866 wiphy1_regd = cfg80211_regd; 2867 2868 wiphy2_regd = rcu_dereference(wiphy2->regd); 2869 if (!wiphy2_regd) 2870 wiphy2_regd = cfg80211_regd; 2871 2872 dfs_domain_same = wiphy1_regd->dfs_region == wiphy2_regd->dfs_region; 2873 2874 rcu_read_unlock(); 2875 2876 return dfs_domain_same; 2877 } 2878 2879 static void reg_copy_dfs_chan_state(struct ieee80211_channel *dst_chan, 2880 struct ieee80211_channel *src_chan) 2881 { 2882 if (!(dst_chan->flags & IEEE80211_CHAN_RADAR) || 2883 !(src_chan->flags & IEEE80211_CHAN_RADAR)) 2884 return; 2885 2886 if (dst_chan->flags & IEEE80211_CHAN_DISABLED || 2887 src_chan->flags & IEEE80211_CHAN_DISABLED) 2888 return; 2889 2890 if (src_chan->center_freq == dst_chan->center_freq && 2891 dst_chan->dfs_state == NL80211_DFS_USABLE) { 2892 dst_chan->dfs_state = src_chan->dfs_state; 2893 dst_chan->dfs_state_entered = src_chan->dfs_state_entered; 2894 } 2895 } 2896 2897 static void wiphy_share_dfs_chan_state(struct wiphy *dst_wiphy, 2898 struct wiphy *src_wiphy) 2899 { 2900 struct ieee80211_supported_band *src_sband, *dst_sband; 2901 struct ieee80211_channel *src_chan, *dst_chan; 2902 int i, j, band; 2903 2904 if (!reg_dfs_domain_same(dst_wiphy, src_wiphy)) 2905 return; 2906 2907 for (band = 0; band < NUM_NL80211_BANDS; band++) { 2908 dst_sband = dst_wiphy->bands[band]; 2909 src_sband = src_wiphy->bands[band]; 2910 if (!dst_sband || !src_sband) 2911 continue; 2912 2913 for (i = 0; i < dst_sband->n_channels; i++) { 2914 dst_chan = &dst_sband->channels[i]; 2915 for (j = 0; j < src_sband->n_channels; j++) { 2916 src_chan = &src_sband->channels[j]; 2917 reg_copy_dfs_chan_state(dst_chan, src_chan); 2918 } 2919 } 2920 } 2921 } 2922 2923 static void wiphy_all_share_dfs_chan_state(struct wiphy *wiphy) 2924 { 2925 struct cfg80211_registered_device *rdev; 2926 2927 ASSERT_RTNL(); 2928 2929 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2930 if (wiphy == &rdev->wiphy) 2931 continue; 2932 wiphy_share_dfs_chan_state(wiphy, &rdev->wiphy); 2933 } 2934 } 2935 2936 /* This processes *all* regulatory hints */ 2937 static void reg_process_hint(struct regulatory_request *reg_request) 2938 { 2939 struct wiphy *wiphy = NULL; 2940 enum reg_request_treatment treatment; 2941 enum nl80211_reg_initiator initiator = reg_request->initiator; 2942 2943 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID) 2944 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx); 2945 2946 switch (initiator) { 2947 case NL80211_REGDOM_SET_BY_CORE: 2948 treatment = reg_process_hint_core(reg_request); 2949 break; 2950 case NL80211_REGDOM_SET_BY_USER: 2951 treatment = reg_process_hint_user(reg_request); 2952 break; 2953 case NL80211_REGDOM_SET_BY_DRIVER: 2954 if (!wiphy) 2955 goto out_free; 2956 treatment = reg_process_hint_driver(wiphy, reg_request); 2957 break; 2958 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 2959 if (!wiphy) 2960 goto out_free; 2961 treatment = reg_process_hint_country_ie(wiphy, reg_request); 2962 break; 2963 default: 2964 WARN(1, "invalid initiator %d\n", initiator); 2965 goto out_free; 2966 } 2967 2968 if (treatment == REG_REQ_IGNORE) 2969 goto out_free; 2970 2971 WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET, 2972 "unexpected treatment value %d\n", treatment); 2973 2974 /* This is required so that the orig_* parameters are saved. 2975 * NOTE: treatment must be set for any case that reaches here! 2976 */ 2977 if (treatment == REG_REQ_ALREADY_SET && wiphy && 2978 wiphy->regulatory_flags & REGULATORY_STRICT_REG) { 2979 wiphy_update_regulatory(wiphy, initiator); 2980 wiphy_all_share_dfs_chan_state(wiphy); 2981 reg_check_channels(); 2982 } 2983 2984 return; 2985 2986 out_free: 2987 reg_free_request(reg_request); 2988 } 2989 2990 static void notify_self_managed_wiphys(struct regulatory_request *request) 2991 { 2992 struct cfg80211_registered_device *rdev; 2993 struct wiphy *wiphy; 2994 2995 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 2996 wiphy = &rdev->wiphy; 2997 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED && 2998 request->initiator == NL80211_REGDOM_SET_BY_USER) 2999 reg_call_notifier(wiphy, request); 3000 } 3001 } 3002 3003 /* 3004 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_* 3005 * Regulatory hints come on a first come first serve basis and we 3006 * must process each one atomically. 3007 */ 3008 static void reg_process_pending_hints(void) 3009 { 3010 struct regulatory_request *reg_request, *lr; 3011 3012 lr = get_last_request(); 3013 3014 /* When last_request->processed becomes true this will be rescheduled */ 3015 if (lr && !lr->processed) { 3016 pr_debug("Pending regulatory request, waiting for it to be processed...\n"); 3017 return; 3018 } 3019 3020 spin_lock(®_requests_lock); 3021 3022 if (list_empty(®_requests_list)) { 3023 spin_unlock(®_requests_lock); 3024 return; 3025 } 3026 3027 reg_request = list_first_entry(®_requests_list, 3028 struct regulatory_request, 3029 list); 3030 list_del_init(®_request->list); 3031 3032 spin_unlock(®_requests_lock); 3033 3034 notify_self_managed_wiphys(reg_request); 3035 3036 reg_process_hint(reg_request); 3037 3038 lr = get_last_request(); 3039 3040 spin_lock(®_requests_lock); 3041 if (!list_empty(®_requests_list) && lr && lr->processed) 3042 schedule_work(®_work); 3043 spin_unlock(®_requests_lock); 3044 } 3045 3046 /* Processes beacon hints -- this has nothing to do with country IEs */ 3047 static void reg_process_pending_beacon_hints(void) 3048 { 3049 struct cfg80211_registered_device *rdev; 3050 struct reg_beacon *pending_beacon, *tmp; 3051 3052 /* This goes through the _pending_ beacon list */ 3053 spin_lock_bh(®_pending_beacons_lock); 3054 3055 list_for_each_entry_safe(pending_beacon, tmp, 3056 ®_pending_beacons, list) { 3057 list_del_init(&pending_beacon->list); 3058 3059 /* Applies the beacon hint to current wiphys */ 3060 list_for_each_entry(rdev, &cfg80211_rdev_list, list) 3061 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon); 3062 3063 /* Remembers the beacon hint for new wiphys or reg changes */ 3064 list_add_tail(&pending_beacon->list, ®_beacon_list); 3065 } 3066 3067 spin_unlock_bh(®_pending_beacons_lock); 3068 } 3069 3070 static void reg_process_self_managed_hints(void) 3071 { 3072 struct cfg80211_registered_device *rdev; 3073 struct wiphy *wiphy; 3074 const struct ieee80211_regdomain *tmp; 3075 const struct ieee80211_regdomain *regd; 3076 enum nl80211_band band; 3077 struct regulatory_request request = {}; 3078 3079 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 3080 wiphy = &rdev->wiphy; 3081 3082 spin_lock(®_requests_lock); 3083 regd = rdev->requested_regd; 3084 rdev->requested_regd = NULL; 3085 spin_unlock(®_requests_lock); 3086 3087 if (regd == NULL) 3088 continue; 3089 3090 tmp = get_wiphy_regdom(wiphy); 3091 rcu_assign_pointer(wiphy->regd, regd); 3092 rcu_free_regdom(tmp); 3093 3094 for (band = 0; band < NUM_NL80211_BANDS; band++) 3095 handle_band_custom(wiphy, wiphy->bands[band], regd); 3096 3097 reg_process_ht_flags(wiphy); 3098 3099 request.wiphy_idx = get_wiphy_idx(wiphy); 3100 request.alpha2[0] = regd->alpha2[0]; 3101 request.alpha2[1] = regd->alpha2[1]; 3102 request.initiator = NL80211_REGDOM_SET_BY_DRIVER; 3103 3104 nl80211_send_wiphy_reg_change_event(&request); 3105 } 3106 3107 reg_check_channels(); 3108 } 3109 3110 static void reg_todo(struct work_struct *work) 3111 { 3112 rtnl_lock(); 3113 reg_process_pending_hints(); 3114 reg_process_pending_beacon_hints(); 3115 reg_process_self_managed_hints(); 3116 rtnl_unlock(); 3117 } 3118 3119 static void queue_regulatory_request(struct regulatory_request *request) 3120 { 3121 request->alpha2[0] = toupper(request->alpha2[0]); 3122 request->alpha2[1] = toupper(request->alpha2[1]); 3123 3124 spin_lock(®_requests_lock); 3125 list_add_tail(&request->list, ®_requests_list); 3126 spin_unlock(®_requests_lock); 3127 3128 schedule_work(®_work); 3129 } 3130 3131 /* 3132 * Core regulatory hint -- happens during cfg80211_init() 3133 * and when we restore regulatory settings. 3134 */ 3135 static int regulatory_hint_core(const char *alpha2) 3136 { 3137 struct regulatory_request *request; 3138 3139 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 3140 if (!request) 3141 return -ENOMEM; 3142 3143 request->alpha2[0] = alpha2[0]; 3144 request->alpha2[1] = alpha2[1]; 3145 request->initiator = NL80211_REGDOM_SET_BY_CORE; 3146 request->wiphy_idx = WIPHY_IDX_INVALID; 3147 3148 queue_regulatory_request(request); 3149 3150 return 0; 3151 } 3152 3153 /* User hints */ 3154 int regulatory_hint_user(const char *alpha2, 3155 enum nl80211_user_reg_hint_type user_reg_hint_type) 3156 { 3157 struct regulatory_request *request; 3158 3159 if (WARN_ON(!alpha2)) 3160 return -EINVAL; 3161 3162 if (!is_world_regdom(alpha2) && !is_an_alpha2(alpha2)) 3163 return -EINVAL; 3164 3165 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 3166 if (!request) 3167 return -ENOMEM; 3168 3169 request->wiphy_idx = WIPHY_IDX_INVALID; 3170 request->alpha2[0] = alpha2[0]; 3171 request->alpha2[1] = alpha2[1]; 3172 request->initiator = NL80211_REGDOM_SET_BY_USER; 3173 request->user_reg_hint_type = user_reg_hint_type; 3174 3175 /* Allow calling CRDA again */ 3176 reset_crda_timeouts(); 3177 3178 queue_regulatory_request(request); 3179 3180 return 0; 3181 } 3182 3183 int regulatory_hint_indoor(bool is_indoor, u32 portid) 3184 { 3185 spin_lock(®_indoor_lock); 3186 3187 /* It is possible that more than one user space process is trying to 3188 * configure the indoor setting. To handle such cases, clear the indoor 3189 * setting in case that some process does not think that the device 3190 * is operating in an indoor environment. In addition, if a user space 3191 * process indicates that it is controlling the indoor setting, save its 3192 * portid, i.e., make it the owner. 3193 */ 3194 reg_is_indoor = is_indoor; 3195 if (reg_is_indoor) { 3196 if (!reg_is_indoor_portid) 3197 reg_is_indoor_portid = portid; 3198 } else { 3199 reg_is_indoor_portid = 0; 3200 } 3201 3202 spin_unlock(®_indoor_lock); 3203 3204 if (!is_indoor) 3205 reg_check_channels(); 3206 3207 return 0; 3208 } 3209 3210 void regulatory_netlink_notify(u32 portid) 3211 { 3212 spin_lock(®_indoor_lock); 3213 3214 if (reg_is_indoor_portid != portid) { 3215 spin_unlock(®_indoor_lock); 3216 return; 3217 } 3218 3219 reg_is_indoor = false; 3220 reg_is_indoor_portid = 0; 3221 3222 spin_unlock(®_indoor_lock); 3223 3224 reg_check_channels(); 3225 } 3226 3227 /* Driver hints */ 3228 int regulatory_hint(struct wiphy *wiphy, const char *alpha2) 3229 { 3230 struct regulatory_request *request; 3231 3232 if (WARN_ON(!alpha2 || !wiphy)) 3233 return -EINVAL; 3234 3235 wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG; 3236 3237 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL); 3238 if (!request) 3239 return -ENOMEM; 3240 3241 request->wiphy_idx = get_wiphy_idx(wiphy); 3242 3243 request->alpha2[0] = alpha2[0]; 3244 request->alpha2[1] = alpha2[1]; 3245 request->initiator = NL80211_REGDOM_SET_BY_DRIVER; 3246 3247 /* Allow calling CRDA again */ 3248 reset_crda_timeouts(); 3249 3250 queue_regulatory_request(request); 3251 3252 return 0; 3253 } 3254 EXPORT_SYMBOL(regulatory_hint); 3255 3256 void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band, 3257 const u8 *country_ie, u8 country_ie_len) 3258 { 3259 char alpha2[2]; 3260 enum environment_cap env = ENVIRON_ANY; 3261 struct regulatory_request *request = NULL, *lr; 3262 3263 /* IE len must be evenly divisible by 2 */ 3264 if (country_ie_len & 0x01) 3265 return; 3266 3267 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN) 3268 return; 3269 3270 request = kzalloc(sizeof(*request), GFP_KERNEL); 3271 if (!request) 3272 return; 3273 3274 alpha2[0] = country_ie[0]; 3275 alpha2[1] = country_ie[1]; 3276 3277 if (country_ie[2] == 'I') 3278 env = ENVIRON_INDOOR; 3279 else if (country_ie[2] == 'O') 3280 env = ENVIRON_OUTDOOR; 3281 3282 rcu_read_lock(); 3283 lr = get_last_request(); 3284 3285 if (unlikely(!lr)) 3286 goto out; 3287 3288 /* 3289 * We will run this only upon a successful connection on cfg80211. 3290 * We leave conflict resolution to the workqueue, where can hold 3291 * the RTNL. 3292 */ 3293 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE && 3294 lr->wiphy_idx != WIPHY_IDX_INVALID) 3295 goto out; 3296 3297 request->wiphy_idx = get_wiphy_idx(wiphy); 3298 request->alpha2[0] = alpha2[0]; 3299 request->alpha2[1] = alpha2[1]; 3300 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE; 3301 request->country_ie_env = env; 3302 3303 /* Allow calling CRDA again */ 3304 reset_crda_timeouts(); 3305 3306 queue_regulatory_request(request); 3307 request = NULL; 3308 out: 3309 kfree(request); 3310 rcu_read_unlock(); 3311 } 3312 3313 static void restore_alpha2(char *alpha2, bool reset_user) 3314 { 3315 /* indicates there is no alpha2 to consider for restoration */ 3316 alpha2[0] = '9'; 3317 alpha2[1] = '7'; 3318 3319 /* The user setting has precedence over the module parameter */ 3320 if (is_user_regdom_saved()) { 3321 /* Unless we're asked to ignore it and reset it */ 3322 if (reset_user) { 3323 pr_debug("Restoring regulatory settings including user preference\n"); 3324 user_alpha2[0] = '9'; 3325 user_alpha2[1] = '7'; 3326 3327 /* 3328 * If we're ignoring user settings, we still need to 3329 * check the module parameter to ensure we put things 3330 * back as they were for a full restore. 3331 */ 3332 if (!is_world_regdom(ieee80211_regdom)) { 3333 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n", 3334 ieee80211_regdom[0], ieee80211_regdom[1]); 3335 alpha2[0] = ieee80211_regdom[0]; 3336 alpha2[1] = ieee80211_regdom[1]; 3337 } 3338 } else { 3339 pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n", 3340 user_alpha2[0], user_alpha2[1]); 3341 alpha2[0] = user_alpha2[0]; 3342 alpha2[1] = user_alpha2[1]; 3343 } 3344 } else if (!is_world_regdom(ieee80211_regdom)) { 3345 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n", 3346 ieee80211_regdom[0], ieee80211_regdom[1]); 3347 alpha2[0] = ieee80211_regdom[0]; 3348 alpha2[1] = ieee80211_regdom[1]; 3349 } else 3350 pr_debug("Restoring regulatory settings\n"); 3351 } 3352 3353 static void restore_custom_reg_settings(struct wiphy *wiphy) 3354 { 3355 struct ieee80211_supported_band *sband; 3356 enum nl80211_band band; 3357 struct ieee80211_channel *chan; 3358 int i; 3359 3360 for (band = 0; band < NUM_NL80211_BANDS; band++) { 3361 sband = wiphy->bands[band]; 3362 if (!sband) 3363 continue; 3364 for (i = 0; i < sband->n_channels; i++) { 3365 chan = &sband->channels[i]; 3366 chan->flags = chan->orig_flags; 3367 chan->max_antenna_gain = chan->orig_mag; 3368 chan->max_power = chan->orig_mpwr; 3369 chan->beacon_found = false; 3370 } 3371 } 3372 } 3373 3374 /* 3375 * Restoring regulatory settings involves ingoring any 3376 * possibly stale country IE information and user regulatory 3377 * settings if so desired, this includes any beacon hints 3378 * learned as we could have traveled outside to another country 3379 * after disconnection. To restore regulatory settings we do 3380 * exactly what we did at bootup: 3381 * 3382 * - send a core regulatory hint 3383 * - send a user regulatory hint if applicable 3384 * 3385 * Device drivers that send a regulatory hint for a specific country 3386 * keep their own regulatory domain on wiphy->regd so that does 3387 * not need to be remembered. 3388 */ 3389 static void restore_regulatory_settings(bool reset_user, bool cached) 3390 { 3391 char alpha2[2]; 3392 char world_alpha2[2]; 3393 struct reg_beacon *reg_beacon, *btmp; 3394 LIST_HEAD(tmp_reg_req_list); 3395 struct cfg80211_registered_device *rdev; 3396 3397 ASSERT_RTNL(); 3398 3399 /* 3400 * Clear the indoor setting in case that it is not controlled by user 3401 * space, as otherwise there is no guarantee that the device is still 3402 * operating in an indoor environment. 3403 */ 3404 spin_lock(®_indoor_lock); 3405 if (reg_is_indoor && !reg_is_indoor_portid) { 3406 reg_is_indoor = false; 3407 reg_check_channels(); 3408 } 3409 spin_unlock(®_indoor_lock); 3410 3411 reset_regdomains(true, &world_regdom); 3412 restore_alpha2(alpha2, reset_user); 3413 3414 /* 3415 * If there's any pending requests we simply 3416 * stash them to a temporary pending queue and 3417 * add then after we've restored regulatory 3418 * settings. 3419 */ 3420 spin_lock(®_requests_lock); 3421 list_splice_tail_init(®_requests_list, &tmp_reg_req_list); 3422 spin_unlock(®_requests_lock); 3423 3424 /* Clear beacon hints */ 3425 spin_lock_bh(®_pending_beacons_lock); 3426 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) { 3427 list_del(®_beacon->list); 3428 kfree(reg_beacon); 3429 } 3430 spin_unlock_bh(®_pending_beacons_lock); 3431 3432 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) { 3433 list_del(®_beacon->list); 3434 kfree(reg_beacon); 3435 } 3436 3437 /* First restore to the basic regulatory settings */ 3438 world_alpha2[0] = cfg80211_world_regdom->alpha2[0]; 3439 world_alpha2[1] = cfg80211_world_regdom->alpha2[1]; 3440 3441 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 3442 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 3443 continue; 3444 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG) 3445 restore_custom_reg_settings(&rdev->wiphy); 3446 } 3447 3448 if (cached && (!is_an_alpha2(alpha2) || 3449 !IS_ERR_OR_NULL(cfg80211_user_regdom))) { 3450 reset_regdomains(false, cfg80211_world_regdom); 3451 update_all_wiphy_regulatory(NL80211_REGDOM_SET_BY_CORE); 3452 print_regdomain(get_cfg80211_regdom()); 3453 nl80211_send_reg_change_event(&core_request_world); 3454 reg_set_request_processed(); 3455 3456 if (is_an_alpha2(alpha2) && 3457 !regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER)) { 3458 struct regulatory_request *ureq; 3459 3460 spin_lock(®_requests_lock); 3461 ureq = list_last_entry(®_requests_list, 3462 struct regulatory_request, 3463 list); 3464 list_del(&ureq->list); 3465 spin_unlock(®_requests_lock); 3466 3467 notify_self_managed_wiphys(ureq); 3468 reg_update_last_request(ureq); 3469 set_regdom(reg_copy_regd(cfg80211_user_regdom), 3470 REGD_SOURCE_CACHED); 3471 } 3472 } else { 3473 regulatory_hint_core(world_alpha2); 3474 3475 /* 3476 * This restores the ieee80211_regdom module parameter 3477 * preference or the last user requested regulatory 3478 * settings, user regulatory settings takes precedence. 3479 */ 3480 if (is_an_alpha2(alpha2)) 3481 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER); 3482 } 3483 3484 spin_lock(®_requests_lock); 3485 list_splice_tail_init(&tmp_reg_req_list, ®_requests_list); 3486 spin_unlock(®_requests_lock); 3487 3488 pr_debug("Kicking the queue\n"); 3489 3490 schedule_work(®_work); 3491 } 3492 3493 static bool is_wiphy_all_set_reg_flag(enum ieee80211_regulatory_flags flag) 3494 { 3495 struct cfg80211_registered_device *rdev; 3496 struct wireless_dev *wdev; 3497 3498 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 3499 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 3500 wdev_lock(wdev); 3501 if (!(wdev->wiphy->regulatory_flags & flag)) { 3502 wdev_unlock(wdev); 3503 return false; 3504 } 3505 wdev_unlock(wdev); 3506 } 3507 } 3508 3509 return true; 3510 } 3511 3512 void regulatory_hint_disconnect(void) 3513 { 3514 /* Restore of regulatory settings is not required when wiphy(s) 3515 * ignore IE from connected access point but clearance of beacon hints 3516 * is required when wiphy(s) supports beacon hints. 3517 */ 3518 if (is_wiphy_all_set_reg_flag(REGULATORY_COUNTRY_IE_IGNORE)) { 3519 struct reg_beacon *reg_beacon, *btmp; 3520 3521 if (is_wiphy_all_set_reg_flag(REGULATORY_DISABLE_BEACON_HINTS)) 3522 return; 3523 3524 spin_lock_bh(®_pending_beacons_lock); 3525 list_for_each_entry_safe(reg_beacon, btmp, 3526 ®_pending_beacons, list) { 3527 list_del(®_beacon->list); 3528 kfree(reg_beacon); 3529 } 3530 spin_unlock_bh(®_pending_beacons_lock); 3531 3532 list_for_each_entry_safe(reg_beacon, btmp, 3533 ®_beacon_list, list) { 3534 list_del(®_beacon->list); 3535 kfree(reg_beacon); 3536 } 3537 3538 return; 3539 } 3540 3541 pr_debug("All devices are disconnected, going to restore regulatory settings\n"); 3542 restore_regulatory_settings(false, true); 3543 } 3544 3545 static bool freq_is_chan_12_13_14(u32 freq) 3546 { 3547 if (freq == ieee80211_channel_to_frequency(12, NL80211_BAND_2GHZ) || 3548 freq == ieee80211_channel_to_frequency(13, NL80211_BAND_2GHZ) || 3549 freq == ieee80211_channel_to_frequency(14, NL80211_BAND_2GHZ)) 3550 return true; 3551 return false; 3552 } 3553 3554 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan) 3555 { 3556 struct reg_beacon *pending_beacon; 3557 3558 list_for_each_entry(pending_beacon, ®_pending_beacons, list) 3559 if (ieee80211_channel_equal(beacon_chan, 3560 &pending_beacon->chan)) 3561 return true; 3562 return false; 3563 } 3564 3565 int regulatory_hint_found_beacon(struct wiphy *wiphy, 3566 struct ieee80211_channel *beacon_chan, 3567 gfp_t gfp) 3568 { 3569 struct reg_beacon *reg_beacon; 3570 bool processing; 3571 3572 if (beacon_chan->beacon_found || 3573 beacon_chan->flags & IEEE80211_CHAN_RADAR || 3574 (beacon_chan->band == NL80211_BAND_2GHZ && 3575 !freq_is_chan_12_13_14(beacon_chan->center_freq))) 3576 return 0; 3577 3578 spin_lock_bh(®_pending_beacons_lock); 3579 processing = pending_reg_beacon(beacon_chan); 3580 spin_unlock_bh(®_pending_beacons_lock); 3581 3582 if (processing) 3583 return 0; 3584 3585 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp); 3586 if (!reg_beacon) 3587 return -ENOMEM; 3588 3589 pr_debug("Found new beacon on frequency: %d.%03d MHz (Ch %d) on %s\n", 3590 beacon_chan->center_freq, beacon_chan->freq_offset, 3591 ieee80211_freq_khz_to_channel( 3592 ieee80211_channel_to_khz(beacon_chan)), 3593 wiphy_name(wiphy)); 3594 3595 memcpy(®_beacon->chan, beacon_chan, 3596 sizeof(struct ieee80211_channel)); 3597 3598 /* 3599 * Since we can be called from BH or and non-BH context 3600 * we must use spin_lock_bh() 3601 */ 3602 spin_lock_bh(®_pending_beacons_lock); 3603 list_add_tail(®_beacon->list, ®_pending_beacons); 3604 spin_unlock_bh(®_pending_beacons_lock); 3605 3606 schedule_work(®_work); 3607 3608 return 0; 3609 } 3610 3611 static void print_rd_rules(const struct ieee80211_regdomain *rd) 3612 { 3613 unsigned int i; 3614 const struct ieee80211_reg_rule *reg_rule = NULL; 3615 const struct ieee80211_freq_range *freq_range = NULL; 3616 const struct ieee80211_power_rule *power_rule = NULL; 3617 char bw[32], cac_time[32]; 3618 3619 pr_debug(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n"); 3620 3621 for (i = 0; i < rd->n_reg_rules; i++) { 3622 reg_rule = &rd->reg_rules[i]; 3623 freq_range = ®_rule->freq_range; 3624 power_rule = ®_rule->power_rule; 3625 3626 if (reg_rule->flags & NL80211_RRF_AUTO_BW) 3627 snprintf(bw, sizeof(bw), "%d KHz, %u KHz AUTO", 3628 freq_range->max_bandwidth_khz, 3629 reg_get_max_bandwidth(rd, reg_rule)); 3630 else 3631 snprintf(bw, sizeof(bw), "%d KHz", 3632 freq_range->max_bandwidth_khz); 3633 3634 if (reg_rule->flags & NL80211_RRF_DFS) 3635 scnprintf(cac_time, sizeof(cac_time), "%u s", 3636 reg_rule->dfs_cac_ms/1000); 3637 else 3638 scnprintf(cac_time, sizeof(cac_time), "N/A"); 3639 3640 3641 /* 3642 * There may not be documentation for max antenna gain 3643 * in certain regions 3644 */ 3645 if (power_rule->max_antenna_gain) 3646 pr_debug(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n", 3647 freq_range->start_freq_khz, 3648 freq_range->end_freq_khz, 3649 bw, 3650 power_rule->max_antenna_gain, 3651 power_rule->max_eirp, 3652 cac_time); 3653 else 3654 pr_debug(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n", 3655 freq_range->start_freq_khz, 3656 freq_range->end_freq_khz, 3657 bw, 3658 power_rule->max_eirp, 3659 cac_time); 3660 } 3661 } 3662 3663 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region) 3664 { 3665 switch (dfs_region) { 3666 case NL80211_DFS_UNSET: 3667 case NL80211_DFS_FCC: 3668 case NL80211_DFS_ETSI: 3669 case NL80211_DFS_JP: 3670 return true; 3671 default: 3672 pr_debug("Ignoring unknown DFS master region: %d\n", dfs_region); 3673 return false; 3674 } 3675 } 3676 3677 static void print_regdomain(const struct ieee80211_regdomain *rd) 3678 { 3679 struct regulatory_request *lr = get_last_request(); 3680 3681 if (is_intersected_alpha2(rd->alpha2)) { 3682 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) { 3683 struct cfg80211_registered_device *rdev; 3684 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx); 3685 if (rdev) { 3686 pr_debug("Current regulatory domain updated by AP to: %c%c\n", 3687 rdev->country_ie_alpha2[0], 3688 rdev->country_ie_alpha2[1]); 3689 } else 3690 pr_debug("Current regulatory domain intersected:\n"); 3691 } else 3692 pr_debug("Current regulatory domain intersected:\n"); 3693 } else if (is_world_regdom(rd->alpha2)) { 3694 pr_debug("World regulatory domain updated:\n"); 3695 } else { 3696 if (is_unknown_alpha2(rd->alpha2)) 3697 pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n"); 3698 else { 3699 if (reg_request_cell_base(lr)) 3700 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n", 3701 rd->alpha2[0], rd->alpha2[1]); 3702 else 3703 pr_debug("Regulatory domain changed to country: %c%c\n", 3704 rd->alpha2[0], rd->alpha2[1]); 3705 } 3706 } 3707 3708 pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region)); 3709 print_rd_rules(rd); 3710 } 3711 3712 static void print_regdomain_info(const struct ieee80211_regdomain *rd) 3713 { 3714 pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]); 3715 print_rd_rules(rd); 3716 } 3717 3718 static int reg_set_rd_core(const struct ieee80211_regdomain *rd) 3719 { 3720 if (!is_world_regdom(rd->alpha2)) 3721 return -EINVAL; 3722 update_world_regdomain(rd); 3723 return 0; 3724 } 3725 3726 static int reg_set_rd_user(const struct ieee80211_regdomain *rd, 3727 struct regulatory_request *user_request) 3728 { 3729 const struct ieee80211_regdomain *intersected_rd = NULL; 3730 3731 if (!regdom_changes(rd->alpha2)) 3732 return -EALREADY; 3733 3734 if (!is_valid_rd(rd)) { 3735 pr_err("Invalid regulatory domain detected: %c%c\n", 3736 rd->alpha2[0], rd->alpha2[1]); 3737 print_regdomain_info(rd); 3738 return -EINVAL; 3739 } 3740 3741 if (!user_request->intersect) { 3742 reset_regdomains(false, rd); 3743 return 0; 3744 } 3745 3746 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom()); 3747 if (!intersected_rd) 3748 return -EINVAL; 3749 3750 kfree(rd); 3751 rd = NULL; 3752 reset_regdomains(false, intersected_rd); 3753 3754 return 0; 3755 } 3756 3757 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd, 3758 struct regulatory_request *driver_request) 3759 { 3760 const struct ieee80211_regdomain *regd; 3761 const struct ieee80211_regdomain *intersected_rd = NULL; 3762 const struct ieee80211_regdomain *tmp; 3763 struct wiphy *request_wiphy; 3764 3765 if (is_world_regdom(rd->alpha2)) 3766 return -EINVAL; 3767 3768 if (!regdom_changes(rd->alpha2)) 3769 return -EALREADY; 3770 3771 if (!is_valid_rd(rd)) { 3772 pr_err("Invalid regulatory domain detected: %c%c\n", 3773 rd->alpha2[0], rd->alpha2[1]); 3774 print_regdomain_info(rd); 3775 return -EINVAL; 3776 } 3777 3778 request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx); 3779 if (!request_wiphy) 3780 return -ENODEV; 3781 3782 if (!driver_request->intersect) { 3783 if (request_wiphy->regd) 3784 return -EALREADY; 3785 3786 regd = reg_copy_regd(rd); 3787 if (IS_ERR(regd)) 3788 return PTR_ERR(regd); 3789 3790 rcu_assign_pointer(request_wiphy->regd, regd); 3791 reset_regdomains(false, rd); 3792 return 0; 3793 } 3794 3795 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom()); 3796 if (!intersected_rd) 3797 return -EINVAL; 3798 3799 /* 3800 * We can trash what CRDA provided now. 3801 * However if a driver requested this specific regulatory 3802 * domain we keep it for its private use 3803 */ 3804 tmp = get_wiphy_regdom(request_wiphy); 3805 rcu_assign_pointer(request_wiphy->regd, rd); 3806 rcu_free_regdom(tmp); 3807 3808 rd = NULL; 3809 3810 reset_regdomains(false, intersected_rd); 3811 3812 return 0; 3813 } 3814 3815 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd, 3816 struct regulatory_request *country_ie_request) 3817 { 3818 struct wiphy *request_wiphy; 3819 3820 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) && 3821 !is_unknown_alpha2(rd->alpha2)) 3822 return -EINVAL; 3823 3824 /* 3825 * Lets only bother proceeding on the same alpha2 if the current 3826 * rd is non static (it means CRDA was present and was used last) 3827 * and the pending request came in from a country IE 3828 */ 3829 3830 if (!is_valid_rd(rd)) { 3831 pr_err("Invalid regulatory domain detected: %c%c\n", 3832 rd->alpha2[0], rd->alpha2[1]); 3833 print_regdomain_info(rd); 3834 return -EINVAL; 3835 } 3836 3837 request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx); 3838 if (!request_wiphy) 3839 return -ENODEV; 3840 3841 if (country_ie_request->intersect) 3842 return -EINVAL; 3843 3844 reset_regdomains(false, rd); 3845 return 0; 3846 } 3847 3848 /* 3849 * Use this call to set the current regulatory domain. Conflicts with 3850 * multiple drivers can be ironed out later. Caller must've already 3851 * kmalloc'd the rd structure. 3852 */ 3853 int set_regdom(const struct ieee80211_regdomain *rd, 3854 enum ieee80211_regd_source regd_src) 3855 { 3856 struct regulatory_request *lr; 3857 bool user_reset = false; 3858 int r; 3859 3860 if (IS_ERR_OR_NULL(rd)) 3861 return -ENODATA; 3862 3863 if (!reg_is_valid_request(rd->alpha2)) { 3864 kfree(rd); 3865 return -EINVAL; 3866 } 3867 3868 if (regd_src == REGD_SOURCE_CRDA) 3869 reset_crda_timeouts(); 3870 3871 lr = get_last_request(); 3872 3873 /* Note that this doesn't update the wiphys, this is done below */ 3874 switch (lr->initiator) { 3875 case NL80211_REGDOM_SET_BY_CORE: 3876 r = reg_set_rd_core(rd); 3877 break; 3878 case NL80211_REGDOM_SET_BY_USER: 3879 cfg80211_save_user_regdom(rd); 3880 r = reg_set_rd_user(rd, lr); 3881 user_reset = true; 3882 break; 3883 case NL80211_REGDOM_SET_BY_DRIVER: 3884 r = reg_set_rd_driver(rd, lr); 3885 break; 3886 case NL80211_REGDOM_SET_BY_COUNTRY_IE: 3887 r = reg_set_rd_country_ie(rd, lr); 3888 break; 3889 default: 3890 WARN(1, "invalid initiator %d\n", lr->initiator); 3891 kfree(rd); 3892 return -EINVAL; 3893 } 3894 3895 if (r) { 3896 switch (r) { 3897 case -EALREADY: 3898 reg_set_request_processed(); 3899 break; 3900 default: 3901 /* Back to world regulatory in case of errors */ 3902 restore_regulatory_settings(user_reset, false); 3903 } 3904 3905 kfree(rd); 3906 return r; 3907 } 3908 3909 /* This would make this whole thing pointless */ 3910 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom())) 3911 return -EINVAL; 3912 3913 /* update all wiphys now with the new established regulatory domain */ 3914 update_all_wiphy_regulatory(lr->initiator); 3915 3916 print_regdomain(get_cfg80211_regdom()); 3917 3918 nl80211_send_reg_change_event(lr); 3919 3920 reg_set_request_processed(); 3921 3922 return 0; 3923 } 3924 3925 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy, 3926 struct ieee80211_regdomain *rd) 3927 { 3928 const struct ieee80211_regdomain *regd; 3929 const struct ieee80211_regdomain *prev_regd; 3930 struct cfg80211_registered_device *rdev; 3931 3932 if (WARN_ON(!wiphy || !rd)) 3933 return -EINVAL; 3934 3935 if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED), 3936 "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n")) 3937 return -EPERM; 3938 3939 if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) { 3940 print_regdomain_info(rd); 3941 return -EINVAL; 3942 } 3943 3944 regd = reg_copy_regd(rd); 3945 if (IS_ERR(regd)) 3946 return PTR_ERR(regd); 3947 3948 rdev = wiphy_to_rdev(wiphy); 3949 3950 spin_lock(®_requests_lock); 3951 prev_regd = rdev->requested_regd; 3952 rdev->requested_regd = regd; 3953 spin_unlock(®_requests_lock); 3954 3955 kfree(prev_regd); 3956 return 0; 3957 } 3958 3959 int regulatory_set_wiphy_regd(struct wiphy *wiphy, 3960 struct ieee80211_regdomain *rd) 3961 { 3962 int ret = __regulatory_set_wiphy_regd(wiphy, rd); 3963 3964 if (ret) 3965 return ret; 3966 3967 schedule_work(®_work); 3968 return 0; 3969 } 3970 EXPORT_SYMBOL(regulatory_set_wiphy_regd); 3971 3972 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy, 3973 struct ieee80211_regdomain *rd) 3974 { 3975 int ret; 3976 3977 ASSERT_RTNL(); 3978 3979 ret = __regulatory_set_wiphy_regd(wiphy, rd); 3980 if (ret) 3981 return ret; 3982 3983 /* process the request immediately */ 3984 reg_process_self_managed_hints(); 3985 return 0; 3986 } 3987 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl); 3988 3989 void wiphy_regulatory_register(struct wiphy *wiphy) 3990 { 3991 struct regulatory_request *lr = get_last_request(); 3992 3993 /* self-managed devices ignore beacon hints and country IE */ 3994 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) { 3995 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS | 3996 REGULATORY_COUNTRY_IE_IGNORE; 3997 3998 /* 3999 * The last request may have been received before this 4000 * registration call. Call the driver notifier if 4001 * initiator is USER. 4002 */ 4003 if (lr->initiator == NL80211_REGDOM_SET_BY_USER) 4004 reg_call_notifier(wiphy, lr); 4005 } 4006 4007 if (!reg_dev_ignore_cell_hint(wiphy)) 4008 reg_num_devs_support_basehint++; 4009 4010 wiphy_update_regulatory(wiphy, lr->initiator); 4011 wiphy_all_share_dfs_chan_state(wiphy); 4012 } 4013 4014 void wiphy_regulatory_deregister(struct wiphy *wiphy) 4015 { 4016 struct wiphy *request_wiphy = NULL; 4017 struct regulatory_request *lr; 4018 4019 lr = get_last_request(); 4020 4021 if (!reg_dev_ignore_cell_hint(wiphy)) 4022 reg_num_devs_support_basehint--; 4023 4024 rcu_free_regdom(get_wiphy_regdom(wiphy)); 4025 RCU_INIT_POINTER(wiphy->regd, NULL); 4026 4027 if (lr) 4028 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx); 4029 4030 if (!request_wiphy || request_wiphy != wiphy) 4031 return; 4032 4033 lr->wiphy_idx = WIPHY_IDX_INVALID; 4034 lr->country_ie_env = ENVIRON_ANY; 4035 } 4036 4037 /* 4038 * See FCC notices for UNII band definitions 4039 * 5GHz: https://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii 4040 * 6GHz: https://www.fcc.gov/document/fcc-proposes-more-spectrum-unlicensed-use-0 4041 */ 4042 int cfg80211_get_unii(int freq) 4043 { 4044 /* UNII-1 */ 4045 if (freq >= 5150 && freq <= 5250) 4046 return 0; 4047 4048 /* UNII-2A */ 4049 if (freq > 5250 && freq <= 5350) 4050 return 1; 4051 4052 /* UNII-2B */ 4053 if (freq > 5350 && freq <= 5470) 4054 return 2; 4055 4056 /* UNII-2C */ 4057 if (freq > 5470 && freq <= 5725) 4058 return 3; 4059 4060 /* UNII-3 */ 4061 if (freq > 5725 && freq <= 5825) 4062 return 4; 4063 4064 /* UNII-5 */ 4065 if (freq > 5925 && freq <= 6425) 4066 return 5; 4067 4068 /* UNII-6 */ 4069 if (freq > 6425 && freq <= 6525) 4070 return 6; 4071 4072 /* UNII-7 */ 4073 if (freq > 6525 && freq <= 6875) 4074 return 7; 4075 4076 /* UNII-8 */ 4077 if (freq > 6875 && freq <= 7125) 4078 return 8; 4079 4080 return -EINVAL; 4081 } 4082 4083 bool regulatory_indoor_allowed(void) 4084 { 4085 return reg_is_indoor; 4086 } 4087 4088 bool regulatory_pre_cac_allowed(struct wiphy *wiphy) 4089 { 4090 const struct ieee80211_regdomain *regd = NULL; 4091 const struct ieee80211_regdomain *wiphy_regd = NULL; 4092 bool pre_cac_allowed = false; 4093 4094 rcu_read_lock(); 4095 4096 regd = rcu_dereference(cfg80211_regdomain); 4097 wiphy_regd = rcu_dereference(wiphy->regd); 4098 if (!wiphy_regd) { 4099 if (regd->dfs_region == NL80211_DFS_ETSI) 4100 pre_cac_allowed = true; 4101 4102 rcu_read_unlock(); 4103 4104 return pre_cac_allowed; 4105 } 4106 4107 if (regd->dfs_region == wiphy_regd->dfs_region && 4108 wiphy_regd->dfs_region == NL80211_DFS_ETSI) 4109 pre_cac_allowed = true; 4110 4111 rcu_read_unlock(); 4112 4113 return pre_cac_allowed; 4114 } 4115 EXPORT_SYMBOL(regulatory_pre_cac_allowed); 4116 4117 static void cfg80211_check_and_end_cac(struct cfg80211_registered_device *rdev) 4118 { 4119 struct wireless_dev *wdev; 4120 /* If we finished CAC or received radar, we should end any 4121 * CAC running on the same channels. 4122 * the check !cfg80211_chandef_dfs_usable contain 2 options: 4123 * either all channels are available - those the CAC_FINISHED 4124 * event has effected another wdev state, or there is a channel 4125 * in unavailable state in wdev chandef - those the RADAR_DETECTED 4126 * event has effected another wdev state. 4127 * In both cases we should end the CAC on the wdev. 4128 */ 4129 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 4130 if (wdev->cac_started && 4131 !cfg80211_chandef_dfs_usable(&rdev->wiphy, &wdev->chandef)) 4132 rdev_end_cac(rdev, wdev->netdev); 4133 } 4134 } 4135 4136 void regulatory_propagate_dfs_state(struct wiphy *wiphy, 4137 struct cfg80211_chan_def *chandef, 4138 enum nl80211_dfs_state dfs_state, 4139 enum nl80211_radar_event event) 4140 { 4141 struct cfg80211_registered_device *rdev; 4142 4143 ASSERT_RTNL(); 4144 4145 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 4146 return; 4147 4148 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 4149 if (wiphy == &rdev->wiphy) 4150 continue; 4151 4152 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy)) 4153 continue; 4154 4155 if (!ieee80211_get_channel(&rdev->wiphy, 4156 chandef->chan->center_freq)) 4157 continue; 4158 4159 cfg80211_set_dfs_state(&rdev->wiphy, chandef, dfs_state); 4160 4161 if (event == NL80211_RADAR_DETECTED || 4162 event == NL80211_RADAR_CAC_FINISHED) { 4163 cfg80211_sched_dfs_chan_update(rdev); 4164 cfg80211_check_and_end_cac(rdev); 4165 } 4166 4167 nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL); 4168 } 4169 } 4170 4171 static int __init regulatory_init_db(void) 4172 { 4173 int err; 4174 4175 /* 4176 * It's possible that - due to other bugs/issues - cfg80211 4177 * never called regulatory_init() below, or that it failed; 4178 * in that case, don't try to do any further work here as 4179 * it's doomed to lead to crashes. 4180 */ 4181 if (IS_ERR_OR_NULL(reg_pdev)) 4182 return -EINVAL; 4183 4184 err = load_builtin_regdb_keys(); 4185 if (err) 4186 return err; 4187 4188 /* We always try to get an update for the static regdomain */ 4189 err = regulatory_hint_core(cfg80211_world_regdom->alpha2); 4190 if (err) { 4191 if (err == -ENOMEM) { 4192 platform_device_unregister(reg_pdev); 4193 return err; 4194 } 4195 /* 4196 * N.B. kobject_uevent_env() can fail mainly for when we're out 4197 * memory which is handled and propagated appropriately above 4198 * but it can also fail during a netlink_broadcast() or during 4199 * early boot for call_usermodehelper(). For now treat these 4200 * errors as non-fatal. 4201 */ 4202 pr_err("kobject_uevent_env() was unable to call CRDA during init\n"); 4203 } 4204 4205 /* 4206 * Finally, if the user set the module parameter treat it 4207 * as a user hint. 4208 */ 4209 if (!is_world_regdom(ieee80211_regdom)) 4210 regulatory_hint_user(ieee80211_regdom, 4211 NL80211_USER_REG_HINT_USER); 4212 4213 return 0; 4214 } 4215 #ifndef MODULE 4216 late_initcall(regulatory_init_db); 4217 #endif 4218 4219 int __init regulatory_init(void) 4220 { 4221 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0); 4222 if (IS_ERR(reg_pdev)) 4223 return PTR_ERR(reg_pdev); 4224 4225 spin_lock_init(®_requests_lock); 4226 spin_lock_init(®_pending_beacons_lock); 4227 spin_lock_init(®_indoor_lock); 4228 4229 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom); 4230 4231 user_alpha2[0] = '9'; 4232 user_alpha2[1] = '7'; 4233 4234 #ifdef MODULE 4235 return regulatory_init_db(); 4236 #else 4237 return 0; 4238 #endif 4239 } 4240 4241 void regulatory_exit(void) 4242 { 4243 struct regulatory_request *reg_request, *tmp; 4244 struct reg_beacon *reg_beacon, *btmp; 4245 4246 cancel_work_sync(®_work); 4247 cancel_crda_timeout_sync(); 4248 cancel_delayed_work_sync(®_check_chans); 4249 4250 /* Lock to suppress warnings */ 4251 rtnl_lock(); 4252 reset_regdomains(true, NULL); 4253 rtnl_unlock(); 4254 4255 dev_set_uevent_suppress(®_pdev->dev, true); 4256 4257 platform_device_unregister(reg_pdev); 4258 4259 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) { 4260 list_del(®_beacon->list); 4261 kfree(reg_beacon); 4262 } 4263 4264 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) { 4265 list_del(®_beacon->list); 4266 kfree(reg_beacon); 4267 } 4268 4269 list_for_each_entry_safe(reg_request, tmp, ®_requests_list, list) { 4270 list_del(®_request->list); 4271 kfree(reg_request); 4272 } 4273 4274 if (!IS_ERR_OR_NULL(regdb)) 4275 kfree(regdb); 4276 if (!IS_ERR_OR_NULL(cfg80211_user_regdom)) 4277 kfree(cfg80211_user_regdom); 4278 4279 free_regdb_keyring(); 4280 } 4281