1 /* 2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * 6 * Permission to use, copy, modify, and/or distribute this software for 7 * any purpose with or without fee is hereby granted, provided that the 8 * above copyright notice and this permission notice appear in all 9 * copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 12 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 13 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 14 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 15 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 16 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 17 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 18 * PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 /** 22 * DOC: wlan_reg_services_api.c 23 * contains regulatory service functions 24 */ 25 26 #include <qdf_status.h> 27 #include <qdf_types.h> 28 #include <qdf_module.h> 29 #include <wlan_cmn.h> 30 #include <reg_services_public_struct.h> 31 #include <wlan_reg_services_api.h> 32 #include <wlan_objmgr_psoc_obj.h> 33 #include <wlan_objmgr_pdev_obj.h> 34 #include "../../core/src/reg_priv_objs.h" 35 #include "../../core/src/reg_utils.h" 36 #include "../../core/src/reg_services_common.h" 37 #include "../../core/src/reg_db.h" 38 #include "../../core/src/reg_db_parser.h" 39 #include <../../core/src/reg_build_chan_list.h> 40 #include <../../core/src/reg_opclass.h> 41 #include <../../core/src/reg_callbacks.h> 42 #include <../../core/src/reg_offload_11d_scan.h> 43 #include <wlan_objmgr_global_obj.h> 44 45 QDF_STATUS wlan_reg_read_default_country(struct wlan_objmgr_psoc *psoc, 46 uint8_t *country) 47 { 48 /* 49 * Get the default country information 50 */ 51 return reg_read_default_country(psoc, country); 52 } 53 54 QDF_STATUS wlan_reg_read_current_country(struct wlan_objmgr_psoc *psoc, 55 uint8_t *country) 56 { 57 /* 58 * Get the current country information 59 */ 60 return reg_read_current_country(psoc, country); 61 } 62 63 QDF_STATUS wlan_reg_get_max_5g_bw_from_country_code( 64 struct wlan_objmgr_pdev *pdev, 65 uint16_t cc, 66 uint16_t *max_bw_5g) 67 { 68 /* 69 * Get the max 5G bandwidth from country code 70 */ 71 return reg_get_max_5g_bw_from_country_code(pdev, cc, max_bw_5g); 72 } 73 74 QDF_STATUS wlan_reg_get_max_5g_bw_from_regdomain( 75 struct wlan_objmgr_pdev *pdev, 76 uint16_t regdmn, 77 uint16_t *max_bw_5g) 78 { 79 /* 80 * Get the max 5G bandwidth from regdomain pair value 81 */ 82 return reg_get_max_5g_bw_from_regdomain(pdev, regdmn, max_bw_5g); 83 } 84 85 QDF_STATUS wlan_reg_get_max_bw_5G_for_fo(struct wlan_objmgr_pdev *pdev) 86 { 87 return reg_get_max_bw_5G_for_fo(pdev); 88 } 89 90 bool wlan_reg_is_regdb_offloaded(struct wlan_objmgr_psoc *psoc) 91 { 92 return reg_is_regdb_offloaded(psoc); 93 } 94 95 QDF_STATUS wlan_reg_get_pwrmode_chan_list(struct wlan_objmgr_pdev *pdev, 96 struct regulatory_channel *chan_list, 97 enum supported_6g_pwr_types 98 in_6g_pwr_mode) 99 { 100 return reg_get_pwrmode_chan_list(pdev, chan_list, in_6g_pwr_mode); 101 } 102 103 qdf_export_symbol(wlan_reg_get_pwrmode_chan_list); 104 105 #ifdef CONFIG_REG_CLIENT 106 QDF_STATUS 107 wlan_reg_get_6g_power_type_for_ctry(struct wlan_objmgr_psoc *psoc, 108 struct wlan_objmgr_pdev *pdev, 109 uint8_t *ap_ctry, uint8_t *sta_ctry, 110 enum reg_6g_ap_type *pwr_type_6g, 111 bool *ctry_code_match, 112 enum reg_6g_ap_type ap_pwr_type) 113 { 114 return reg_get_6g_power_type_for_ctry(psoc, pdev, ap_ctry, sta_ctry, 115 pwr_type_6g, ctry_code_match, 116 ap_pwr_type); 117 } 118 #endif 119 120 QDF_STATUS wlan_reg_get_dfs_region(struct wlan_objmgr_pdev *pdev, 121 enum dfs_reg *dfs_reg) 122 { 123 /* 124 * Get the current dfs region 125 */ 126 reg_get_current_dfs_region(pdev, dfs_reg); 127 128 return QDF_STATUS_SUCCESS; 129 } 130 131 bool wlan_reg_is_chan_disabled_and_not_nol(struct regulatory_channel *chan) 132 { 133 return reg_is_chan_disabled_and_not_nol(chan); 134 } 135 136 QDF_STATUS wlan_reg_get_current_chan_list(struct wlan_objmgr_pdev *pdev, 137 struct regulatory_channel *chan_list) 138 { 139 return reg_get_current_chan_list(pdev, chan_list); 140 } 141 142 qdf_export_symbol(wlan_reg_get_current_chan_list); 143 144 bool wlan_reg_is_freq_enabled(struct wlan_objmgr_pdev *pdev, 145 qdf_freq_t freq, 146 enum supported_6g_pwr_types in_6g_pwr_mode) 147 { 148 return reg_is_freq_enabled(pdev, freq, in_6g_pwr_mode); 149 } 150 151 bool wlan_reg_is_freq_idx_enabled(struct wlan_objmgr_pdev *pdev, 152 enum channel_enum freq_idx, 153 enum supported_6g_pwr_types in_6g_pwr_mode) 154 { 155 return reg_is_freq_idx_enabled(pdev, freq_idx, in_6g_pwr_mode); 156 } 157 158 #ifdef CONFIG_REG_CLIENT 159 QDF_STATUS wlan_reg_get_secondary_current_chan_list( 160 struct wlan_objmgr_pdev *pdev, 161 struct regulatory_channel *chan_list) 162 { 163 return reg_get_secondary_current_chan_list(pdev, chan_list); 164 } 165 #endif 166 167 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 168 QDF_STATUS wlan_reg_get_6g_afc_chan_list(struct wlan_objmgr_pdev *pdev, 169 struct regulatory_channel *chan_list) 170 { 171 return reg_get_6g_afc_chan_list(pdev, chan_list); 172 } 173 174 qdf_export_symbol(wlan_reg_get_6g_afc_chan_list); 175 176 QDF_STATUS 177 wlan_reg_get_6g_afc_mas_chan_list(struct wlan_objmgr_pdev *pdev, 178 struct regulatory_channel *chan_list) 179 { 180 return reg_get_6g_afc_mas_chan_list(pdev, chan_list); 181 } 182 183 qdf_export_symbol(wlan_reg_get_6g_afc_mas_chan_list); 184 185 bool 186 wlan_reg_is_6ghz_freq_txable(struct wlan_objmgr_pdev *pdev, 187 qdf_freq_t freq, 188 enum supported_6g_pwr_types in_6ghz_pwr_mode) 189 { 190 return reg_is_6ghz_freq_txable(pdev, freq, in_6ghz_pwr_mode); 191 } 192 193 qdf_export_symbol(wlan_reg_is_6ghz_freq_txable); 194 #endif 195 196 uint16_t wlan_reg_get_bw_value(enum phy_ch_width bw) 197 { 198 return reg_get_bw_value(bw); 199 } 200 201 qdf_export_symbol(wlan_reg_get_bw_value); 202 203 void wlan_reg_set_dfs_region(struct wlan_objmgr_pdev *pdev, 204 enum dfs_reg dfs_reg) 205 { 206 reg_set_dfs_region(pdev, dfs_reg); 207 } 208 209 QDF_STATUS wlan_reg_get_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr, 210 const uint8_t *country_alpha2, enum country_src source) 211 { 212 213 return reg_get_domain_from_country_code(reg_domain_ptr, 214 country_alpha2, source); 215 } 216 217 218 uint16_t wlan_reg_dmn_get_opclass_from_channel(uint8_t *country, 219 uint8_t channel, 220 uint8_t offset) 221 { 222 return reg_dmn_get_opclass_from_channel(country, channel, 223 offset); 224 } 225 226 uint8_t wlan_reg_get_band_cap_from_op_class(const uint8_t *country, 227 uint8_t num_of_opclass, 228 const uint8_t *opclass) 229 { 230 return reg_get_band_cap_from_op_class(country, 231 num_of_opclass, opclass); 232 } 233 234 uint8_t wlan_reg_get_opclass_from_freq_width(uint8_t *country, 235 qdf_freq_t freq, 236 uint16_t ch_width, 237 uint16_t behav_limit) 238 { 239 return reg_dmn_get_opclass_from_freq_width(country, freq, ch_width, 240 behav_limit); 241 } 242 243 void wlan_reg_dmn_print_channels_in_opclass(uint8_t *country, 244 uint8_t opclass) 245 { 246 reg_dmn_print_channels_in_opclass(country, opclass); 247 } 248 249 uint16_t wlan_reg_dmn_get_chanwidth_from_opclass(uint8_t *country, 250 uint8_t channel, 251 uint8_t opclass) 252 { 253 return reg_dmn_get_chanwidth_from_opclass(country, channel, 254 opclass); 255 } 256 257 uint16_t wlan_reg_dmn_get_chanwidth_from_opclass_auto(uint8_t *country, 258 uint8_t channel, 259 uint8_t opclass) 260 { 261 return reg_dmn_get_chanwidth_from_opclass_auto(country, channel, 262 opclass); 263 } 264 265 uint16_t wlan_reg_dmn_set_curr_opclasses(uint8_t num_classes, 266 uint8_t *class) 267 { 268 return reg_dmn_set_curr_opclasses(num_classes, class); 269 } 270 271 uint16_t wlan_reg_dmn_get_curr_opclasses(uint8_t *num_classes, 272 uint8_t *class) 273 { 274 return reg_dmn_get_curr_opclasses(num_classes, class); 275 } 276 277 QDF_STATUS 278 wlan_reg_get_opclass_details(struct wlan_objmgr_pdev *pdev, 279 struct regdmn_ap_cap_opclass_t *reg_ap_cap, 280 uint8_t *n_opclasses, 281 uint8_t max_supp_op_class, 282 bool global_tbl_lookup, 283 enum supported_6g_pwr_types in_6g_pwr_mode) 284 { 285 return reg_get_opclass_details(pdev, reg_ap_cap, n_opclasses, 286 max_supp_op_class, 287 global_tbl_lookup, 288 in_6g_pwr_mode); 289 } 290 291 QDF_STATUS 292 wlan_reg_get_opclass_for_cur_hwmode(struct wlan_objmgr_pdev *pdev, 293 struct regdmn_ap_cap_opclass_t *reg_ap_cap, 294 uint8_t *n_opclasses, 295 uint8_t max_supp_op_class, 296 bool global_tbl_lookup, 297 enum phy_ch_width max_chwidth, 298 bool is_80p80_supp, 299 enum supported_6g_pwr_types in_6g_pwr_mode) 300 { 301 return reg_get_opclass_for_cur_hwmode(pdev, reg_ap_cap, n_opclasses, 302 max_supp_op_class, 303 global_tbl_lookup, 304 max_chwidth, 305 is_80p80_supp, 306 in_6g_pwr_mode); 307 } 308 309 enum country_src wlan_reg_get_cc_and_src(struct wlan_objmgr_psoc *psoc, 310 uint8_t *alpha) 311 { 312 return reg_get_cc_and_src(psoc, alpha); 313 } 314 315 QDF_STATUS wlan_regulatory_init(void) 316 { 317 QDF_STATUS status; 318 319 status = wlan_objmgr_register_psoc_create_handler( 320 WLAN_UMAC_COMP_REGULATORY, 321 wlan_regulatory_psoc_obj_created_notification, NULL); 322 if (status != QDF_STATUS_SUCCESS) { 323 reg_err("failed to register reg psoc obj create handler"); 324 return status; 325 } 326 327 status = wlan_objmgr_register_psoc_destroy_handler( 328 WLAN_UMAC_COMP_REGULATORY, 329 wlan_regulatory_psoc_obj_destroyed_notification, NULL); 330 if (status != QDF_STATUS_SUCCESS) { 331 reg_err("failed to register reg psoc obj create handler"); 332 goto unreg_psoc_create; 333 } 334 335 status = wlan_objmgr_register_pdev_create_handler( 336 WLAN_UMAC_COMP_REGULATORY, 337 wlan_regulatory_pdev_obj_created_notification, NULL); 338 if (status != QDF_STATUS_SUCCESS) { 339 reg_err("failed to register reg psoc obj create handler"); 340 goto unreg_psoc_destroy; 341 } 342 343 status = wlan_objmgr_register_pdev_destroy_handler( 344 WLAN_UMAC_COMP_REGULATORY, 345 wlan_regulatory_pdev_obj_destroyed_notification, NULL); 346 if (status != QDF_STATUS_SUCCESS) { 347 reg_err("failed to register reg psoc obj create handler"); 348 goto unreg_pdev_create; 349 } 350 channel_map = channel_map_global; 351 reg_debug("regulatory handlers registered with obj mgr"); 352 353 return status; 354 355 unreg_pdev_create: 356 status = wlan_objmgr_unregister_pdev_create_handler( 357 WLAN_UMAC_COMP_REGULATORY, 358 wlan_regulatory_pdev_obj_created_notification, 359 NULL); 360 361 unreg_psoc_destroy: 362 status = wlan_objmgr_unregister_psoc_destroy_handler( 363 WLAN_UMAC_COMP_REGULATORY, 364 wlan_regulatory_psoc_obj_destroyed_notification, 365 NULL); 366 367 unreg_psoc_create: 368 status = wlan_objmgr_unregister_psoc_create_handler( 369 WLAN_UMAC_COMP_REGULATORY, 370 wlan_regulatory_psoc_obj_created_notification, 371 NULL); 372 373 return QDF_STATUS_E_FAILURE; 374 } 375 376 QDF_STATUS wlan_regulatory_deinit(void) 377 { 378 QDF_STATUS status, ret_status = QDF_STATUS_SUCCESS; 379 380 status = wlan_objmgr_unregister_pdev_destroy_handler( 381 WLAN_UMAC_COMP_REGULATORY, 382 wlan_regulatory_pdev_obj_destroyed_notification, NULL); 383 if (status != QDF_STATUS_SUCCESS) { 384 reg_err("failed to unregister reg pdev obj destroy handler"); 385 ret_status = status; 386 } 387 388 status = wlan_objmgr_unregister_pdev_create_handler( 389 WLAN_UMAC_COMP_REGULATORY, 390 wlan_regulatory_pdev_obj_created_notification, NULL); 391 if (status != QDF_STATUS_SUCCESS) { 392 reg_err("failed to unregister reg pdev obj create handler"); 393 ret_status = status; 394 } 395 396 status = wlan_objmgr_unregister_psoc_destroy_handler( 397 WLAN_UMAC_COMP_REGULATORY, 398 wlan_regulatory_psoc_obj_destroyed_notification, NULL); 399 if (status != QDF_STATUS_SUCCESS) { 400 reg_err("failed to unregister reg psoc obj destroy handler"); 401 ret_status = status; 402 } 403 404 status = wlan_objmgr_unregister_psoc_create_handler( 405 WLAN_UMAC_COMP_REGULATORY, 406 wlan_regulatory_psoc_obj_created_notification, NULL); 407 if (status != QDF_STATUS_SUCCESS) { 408 reg_err("failed to unregister reg psoc obj create handler"); 409 ret_status = status; 410 } 411 412 reg_debug("deregistered callbacks with obj mgr"); 413 414 return ret_status; 415 } 416 417 #ifdef CONFIG_BAND_6GHZ 418 static void 419 regulatory_assign_register_master_ext_handler(struct wlan_objmgr_psoc *psoc, 420 struct wlan_lmac_if_reg_tx_ops *tx_ops) 421 { 422 if (tx_ops->register_master_ext_handler) 423 tx_ops->register_master_ext_handler(psoc, NULL); 424 } 425 426 static void 427 regulatory_assign_unregister_master_ext_handler(struct wlan_objmgr_psoc *psoc, 428 struct wlan_lmac_if_reg_tx_ops *tx_ops) 429 { 430 if (tx_ops->unregister_master_ext_handler) 431 tx_ops->unregister_master_ext_handler(psoc, NULL); 432 } 433 434 QDF_STATUS wlan_reg_get_6g_ap_master_chan_list( 435 struct wlan_objmgr_pdev *pdev, 436 enum reg_6g_ap_type ap_pwr_type, 437 struct regulatory_channel *chan_list) 438 { 439 return reg_get_6g_ap_master_chan_list(pdev, ap_pwr_type, chan_list); 440 } 441 442 #ifdef CONFIG_REG_CLIENT 443 const char *wlan_reg_get_power_string(enum reg_6g_ap_type power_type) 444 { 445 return reg_get_power_string(power_type); 446 } 447 #endif 448 449 qdf_export_symbol(wlan_reg_get_6g_ap_master_chan_list); 450 451 #ifdef CONFIG_AFC_SUPPORT 452 static void regulatory_assign_register_afc_event_handler( 453 struct wlan_objmgr_psoc *psoc, 454 struct wlan_lmac_if_reg_tx_ops *tx_ops) 455 { 456 if (tx_ops->register_afc_event_handler) 457 tx_ops->register_afc_event_handler(psoc, NULL); 458 } 459 460 static void regulatory_assign_unregister_afc_event_handler( 461 struct wlan_objmgr_psoc *psoc, 462 struct wlan_lmac_if_reg_tx_ops *tx_ops) 463 { 464 if (tx_ops->unregister_afc_event_handler) 465 tx_ops->unregister_afc_event_handler(psoc, NULL); 466 } 467 #else 468 static void regulatory_assign_register_afc_event_handler( 469 struct wlan_objmgr_psoc *psoc, 470 struct wlan_lmac_if_reg_tx_ops *tx_ops) 471 { 472 } 473 474 static void regulatory_assign_unregister_afc_event_handler( 475 struct wlan_objmgr_psoc *psoc, 476 struct wlan_lmac_if_reg_tx_ops *tx_ops) 477 { 478 } 479 #endif 480 #else 481 static inline void 482 regulatory_assign_register_master_ext_handler(struct wlan_objmgr_psoc *psoc, 483 struct wlan_lmac_if_reg_tx_ops *tx_ops) 484 { 485 } 486 487 static inline void 488 regulatory_assign_unregister_master_ext_handler(struct wlan_objmgr_psoc *psoc, 489 struct wlan_lmac_if_reg_tx_ops *tx_ops) 490 { 491 } 492 493 static void 494 regulatory_assign_register_afc_event_handler(struct wlan_objmgr_psoc *psoc, 495 struct wlan_lmac_if_reg_tx_ops *tx_ops) 496 { 497 } 498 499 static void 500 regulatory_assign_unregister_afc_event_handler(struct wlan_objmgr_psoc *psoc, 501 struct wlan_lmac_if_reg_tx_ops *tx_ops) 502 { 503 } 504 #endif 505 506 QDF_STATUS regulatory_psoc_open(struct wlan_objmgr_psoc *psoc) 507 { 508 struct wlan_lmac_if_reg_tx_ops *tx_ops; 509 510 tx_ops = reg_get_psoc_tx_ops(psoc); 511 if (tx_ops->register_master_handler) 512 tx_ops->register_master_handler(psoc, NULL); 513 regulatory_assign_register_master_ext_handler(psoc, tx_ops); 514 regulatory_assign_register_afc_event_handler(psoc, tx_ops); 515 if (tx_ops->register_11d_new_cc_handler) 516 tx_ops->register_11d_new_cc_handler(psoc, NULL); 517 if (tx_ops->register_ch_avoid_event_handler) 518 tx_ops->register_ch_avoid_event_handler(psoc, NULL); 519 520 return QDF_STATUS_SUCCESS; 521 } 522 523 QDF_STATUS regulatory_psoc_close(struct wlan_objmgr_psoc *psoc) 524 { 525 struct wlan_lmac_if_reg_tx_ops *tx_ops; 526 527 tx_ops = reg_get_psoc_tx_ops(psoc); 528 if (tx_ops->unregister_11d_new_cc_handler) 529 tx_ops->unregister_11d_new_cc_handler(psoc, NULL); 530 if (tx_ops->unregister_master_handler) 531 tx_ops->unregister_master_handler(psoc, NULL); 532 regulatory_assign_unregister_master_ext_handler(psoc, tx_ops); 533 regulatory_assign_unregister_afc_event_handler(psoc, tx_ops); 534 if (tx_ops->unregister_ch_avoid_event_handler) 535 tx_ops->unregister_ch_avoid_event_handler(psoc, NULL); 536 537 return QDF_STATUS_SUCCESS; 538 } 539 540 #ifdef CONFIG_REG_CLIENT 541 /** 542 * reg_is_cntry_set_pending() - Check if country set is pending 543 * @pdev: Pointer to pdev object. 544 * @psoc: Pointer to psoc object. 545 */ 546 static bool reg_is_cntry_set_pending(struct wlan_objmgr_pdev *pdev, 547 struct wlan_objmgr_psoc *psoc) 548 { 549 struct wlan_regulatory_psoc_priv_obj *soc_reg; 550 struct wlan_lmac_if_reg_tx_ops *tx_ops; 551 uint8_t phy_id; 552 553 soc_reg = reg_get_psoc_obj(psoc); 554 555 if (!IS_VALID_PSOC_REG_OBJ(soc_reg)) { 556 reg_err("psoc reg component is NULL"); 557 return false; 558 } 559 560 tx_ops = reg_get_psoc_tx_ops(psoc); 561 562 if (tx_ops->get_phy_id_from_pdev_id) 563 tx_ops->get_phy_id_from_pdev_id( 564 psoc, 565 wlan_objmgr_pdev_get_pdev_id(pdev), 566 &phy_id); 567 else 568 phy_id = wlan_objmgr_pdev_get_pdev_id(pdev); 569 570 return (soc_reg->new_user_ctry_pending[phy_id] || 571 soc_reg->new_init_ctry_pending[phy_id] || 572 soc_reg->new_11d_ctry_pending[phy_id] || 573 soc_reg->world_country_pending[phy_id]); 574 } 575 #else 576 static inline bool reg_is_cntry_set_pending(struct wlan_objmgr_pdev *pdev, 577 struct wlan_objmgr_psoc *psoc) 578 { 579 return false; 580 } 581 #endif 582 583 QDF_STATUS regulatory_pdev_open(struct wlan_objmgr_pdev *pdev) 584 { 585 struct wlan_objmgr_psoc *parent_psoc; 586 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 587 588 pdev_priv_obj = reg_get_pdev_obj(pdev); 589 590 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 591 reg_err("reg pdev private obj is NULL"); 592 return QDF_STATUS_E_FAILURE; 593 } 594 595 pdev_priv_obj->pdev_opened = true; 596 597 parent_psoc = wlan_pdev_get_psoc(pdev); 598 599 if (reg_is_cntry_set_pending(pdev, parent_psoc)) 600 return QDF_STATUS_SUCCESS; 601 602 reg_send_scheduler_msg_nb(parent_psoc, pdev); 603 604 return QDF_STATUS_SUCCESS; 605 } 606 607 QDF_STATUS regulatory_pdev_close(struct wlan_objmgr_pdev *pdev) 608 { 609 struct wlan_objmgr_psoc *psoc; 610 struct wlan_regulatory_psoc_priv_obj *soc_reg; 611 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 612 613 pdev_priv_obj = reg_get_pdev_obj(pdev); 614 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 615 reg_err("reg pdev private obj is NULL"); 616 return QDF_STATUS_E_FAILURE; 617 } 618 619 pdev_priv_obj->pdev_opened = false; 620 621 psoc = wlan_pdev_get_psoc(pdev); 622 soc_reg = reg_get_psoc_obj(psoc); 623 if (!soc_reg) { 624 reg_err("reg psoc private obj is NULL"); 625 return QDF_STATUS_E_FAULT; 626 } 627 628 reg_reset_ctry_pending_hints(soc_reg); 629 630 return QDF_STATUS_SUCCESS; 631 } 632 633 uint8_t wlan_reg_freq_to_chan(struct wlan_objmgr_pdev *pdev, 634 qdf_freq_t freq) 635 { 636 return reg_freq_to_chan(pdev, freq); 637 } 638 639 qdf_export_symbol(wlan_reg_freq_to_chan); 640 641 qdf_freq_t wlan_reg_legacy_chan_to_freq(struct wlan_objmgr_pdev *pdev, 642 uint8_t chan_num) 643 { 644 return reg_legacy_chan_to_freq(pdev, chan_num); 645 } 646 647 QDF_STATUS wlan_reg_set_country(struct wlan_objmgr_pdev *pdev, 648 uint8_t *country) 649 { 650 return reg_set_country(pdev, country); 651 } 652 653 QDF_STATUS wlan_reg_set_11d_country(struct wlan_objmgr_pdev *pdev, 654 uint8_t *country) 655 { 656 return reg_set_11d_country(pdev, country); 657 } 658 659 bool wlan_reg_is_world(uint8_t *country) 660 { 661 return reg_is_world_alpha2(country); 662 } 663 664 bool wlan_reg_is_us(uint8_t *country) 665 { 666 return reg_is_us_alpha2(country); 667 } 668 669 bool wlan_reg_is_etsi(uint8_t *country) 670 { 671 return reg_is_etsi_alpha2(country); 672 } 673 674 bool wlan_reg_ctry_support_vlp(uint8_t *country) 675 { 676 return reg_ctry_support_vlp(country); 677 } 678 679 void wlan_reg_register_chan_change_callback(struct wlan_objmgr_psoc *psoc, 680 void *cbk, void *arg) 681 { 682 reg_register_chan_change_callback(psoc, (reg_chan_change_callback)cbk, 683 arg); 684 685 } 686 687 void wlan_reg_unregister_chan_change_callback(struct wlan_objmgr_psoc *psoc, 688 void *cbk) 689 { 690 reg_unregister_chan_change_callback(psoc, 691 (reg_chan_change_callback)cbk); 692 } 693 694 void wlan_reg_register_ctry_change_callback(struct wlan_objmgr_psoc *psoc, 695 void *cbk) 696 { 697 reg_register_ctry_change_callback(psoc, (reg_ctry_change_callback)cbk); 698 } 699 700 void wlan_reg_unregister_ctry_change_callback(struct wlan_objmgr_psoc *psoc, 701 void *cbk) 702 { 703 reg_unregister_ctry_change_callback(psoc, 704 (reg_ctry_change_callback)cbk); 705 } 706 707 bool wlan_reg_is_11d_offloaded(struct wlan_objmgr_psoc *psoc) 708 { 709 return reg_is_11d_offloaded(psoc); 710 } 711 712 bool wlan_reg_11d_enabled_on_host(struct wlan_objmgr_psoc *psoc) 713 { 714 return reg_11d_enabled_on_host(psoc); 715 } 716 717 bool wlan_reg_is_etsi13_regdmn(struct wlan_objmgr_pdev *pdev) 718 { 719 return reg_is_etsi13_regdmn(pdev); 720 } 721 722 bool wlan_reg_is_etsi13_srd_chan_allowed_master_mode(struct wlan_objmgr_pdev 723 *pdev) 724 { 725 return reg_is_etsi13_srd_chan_allowed_master_mode(pdev); 726 } 727 728 bool wlan_reg_get_fcc_constraint(struct wlan_objmgr_pdev *pdev, uint32_t freq) 729 { 730 return reg_get_fcc_constraint(pdev, freq); 731 } 732 733 QDF_STATUS wlan_reg_get_chip_mode(struct wlan_objmgr_pdev *pdev, 734 uint64_t *chip_mode) 735 { 736 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 737 738 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 739 WLAN_UMAC_COMP_REGULATORY); 740 741 if (!pdev_priv_obj) { 742 reg_err("reg pdev private obj is NULL"); 743 return QDF_STATUS_E_FAULT; 744 } 745 746 *chip_mode = pdev_priv_obj->wireless_modes; 747 748 return QDF_STATUS_SUCCESS; 749 } 750 751 QDF_STATUS wlan_reg_get_phybitmap(struct wlan_objmgr_pdev *pdev, 752 uint16_t *phybitmap) 753 { 754 return reg_get_phybitmap(pdev, phybitmap); 755 } 756 757 bool wlan_reg_is_11d_scan_inprogress(struct wlan_objmgr_psoc *psoc) 758 { 759 return reg_is_11d_scan_inprogress(psoc); 760 } 761 762 QDF_STATUS wlan_reg_get_freq_range(struct wlan_objmgr_pdev *pdev, 763 qdf_freq_t *low_2g, 764 qdf_freq_t *high_2g, 765 qdf_freq_t *low_5g, 766 qdf_freq_t *high_5g) 767 { 768 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 769 770 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 771 WLAN_UMAC_COMP_REGULATORY); 772 773 if (!pdev_priv_obj) { 774 reg_err("reg pdev private obj is NULL"); 775 return QDF_STATUS_E_FAULT; 776 } 777 778 if (low_2g) 779 *low_2g = pdev_priv_obj->range_2g_low; 780 781 if (high_2g) 782 *high_2g = pdev_priv_obj->range_2g_high; 783 784 if (low_5g) 785 *low_5g = pdev_priv_obj->range_5g_low; 786 787 if (high_5g) 788 *high_5g = pdev_priv_obj->range_5g_high; 789 790 return QDF_STATUS_SUCCESS; 791 } 792 793 struct wlan_lmac_if_reg_tx_ops * 794 wlan_reg_get_tx_ops(struct wlan_objmgr_psoc *psoc) 795 { 796 return reg_get_psoc_tx_ops(psoc); 797 } 798 799 qdf_export_symbol(wlan_reg_get_tx_ops); 800 801 QDF_STATUS wlan_reg_get_curr_regdomain(struct wlan_objmgr_pdev *pdev, 802 struct cur_regdmn_info *cur_regdmn) 803 { 804 return reg_get_curr_regdomain(pdev, cur_regdmn); 805 } 806 807 uint8_t wlan_reg_max_5ghz_ch_num(void) 808 { 809 return reg_max_5ghz_ch_num(); 810 } 811 812 #ifdef CONFIG_CHAN_FREQ_API 813 qdf_freq_t wlan_reg_min_24ghz_chan_freq(void) 814 { 815 return reg_min_24ghz_chan_freq(); 816 } 817 818 qdf_freq_t wlan_reg_max_24ghz_chan_freq(void) 819 { 820 return reg_max_24ghz_chan_freq(); 821 } 822 823 qdf_freq_t wlan_reg_min_5ghz_chan_freq(void) 824 { 825 return reg_min_5ghz_chan_freq(); 826 } 827 828 qdf_freq_t wlan_reg_max_5ghz_chan_freq(void) 829 { 830 return reg_max_5ghz_chan_freq(); 831 } 832 #endif /* CONFIG_CHAN_FREQ_API */ 833 834 bool wlan_reg_is_24ghz_ch_freq(qdf_freq_t freq) 835 { 836 return reg_is_24ghz_ch_freq(freq); 837 } 838 839 bool wlan_reg_is_5ghz_ch_freq(qdf_freq_t freq) 840 { 841 return reg_is_5ghz_ch_freq(freq); 842 } 843 844 bool wlan_reg_is_range_overlap_2g(qdf_freq_t low_freq, qdf_freq_t high_freq) 845 { 846 return reg_is_range_overlap_2g(low_freq, high_freq); 847 } 848 849 bool wlan_reg_is_range_overlap_5g(qdf_freq_t low_freq, qdf_freq_t high_freq) 850 { 851 return reg_is_range_overlap_5g(low_freq, high_freq); 852 } 853 854 bool wlan_reg_is_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 855 { 856 return reg_is_freq_indoor(pdev, freq); 857 } 858 859 uint16_t wlan_reg_get_min_chwidth(struct wlan_objmgr_pdev *pdev, 860 qdf_freq_t freq) 861 { 862 return reg_get_min_chwidth(pdev, freq); 863 } 864 865 uint16_t wlan_reg_get_max_chwidth(struct wlan_objmgr_pdev *pdev, 866 qdf_freq_t freq) 867 { 868 return reg_get_max_chwidth(pdev, freq); 869 } 870 871 enum phy_ch_width 872 wlan_reg_get_next_lower_bandwidth(enum phy_ch_width ch_width) 873 { 874 return get_next_lower_bandwidth(ch_width); 875 } 876 877 #ifdef CONFIG_REG_CLIENT 878 bool wlan_reg_is_freq_indoor_in_secondary_list(struct wlan_objmgr_pdev *pdev, 879 qdf_freq_t freq) 880 { 881 return reg_is_freq_indoor_in_secondary_list(pdev, freq); 882 } 883 #endif 884 885 #ifdef CONFIG_BAND_6GHZ 886 bool wlan_reg_is_6ghz_chan_freq(uint16_t freq) 887 { 888 return reg_is_6ghz_chan_freq(freq); 889 } 890 891 #ifdef CONFIG_6G_FREQ_OVERLAP 892 bool wlan_reg_is_range_only6g(qdf_freq_t low_freq, qdf_freq_t high_freq) 893 { 894 return reg_is_range_only6g(low_freq, high_freq); 895 } 896 897 bool wlan_reg_is_range_overlap_6g(qdf_freq_t low_freq, qdf_freq_t high_freq) 898 { 899 return reg_is_range_overlap_6g(low_freq, high_freq); 900 } 901 #endif 902 903 uint16_t wlan_reg_min_6ghz_chan_freq(void) 904 { 905 return reg_min_6ghz_chan_freq(); 906 } 907 908 uint16_t wlan_reg_max_6ghz_chan_freq(void) 909 { 910 return reg_max_6ghz_chan_freq(); 911 } 912 913 bool wlan_reg_is_6ghz_psc_chan_freq(uint16_t freq) 914 { 915 return reg_is_6ghz_psc_chan_freq(freq); 916 } 917 918 bool wlan_reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 919 { 920 return reg_is_6g_freq_indoor(pdev, freq); 921 } 922 923 QDF_STATUS 924 wlan_reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev *pdev, 925 qdf_freq_t freq, uint8_t bw, 926 enum reg_6g_ap_type reg_ap, 927 enum reg_6g_client_type reg_client, 928 bool is_psd, 929 uint8_t *tx_power) 930 { 931 return reg_get_max_txpower_for_6g_tpe(pdev, freq, bw, 932 reg_ap, 933 reg_client, is_psd, 934 tx_power); 935 } 936 #endif /* CONFIG_BAND_6GHZ */ 937 938 uint16_t 939 wlan_reg_get_band_channel_list(struct wlan_objmgr_pdev *pdev, 940 uint8_t band_mask, 941 struct regulatory_channel *channel_list) 942 { 943 if (!pdev) { 944 reg_err("pdev object is NULL"); 945 return 0; 946 } 947 948 return reg_get_band_channel_list(pdev, band_mask, channel_list); 949 } 950 951 #ifdef CONFIG_REG_6G_PWRMODE 952 uint16_t 953 wlan_reg_get_band_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev, 954 uint8_t band_mask, 955 struct regulatory_channel 956 *channel_list, 957 enum supported_6g_pwr_types 958 in_6g_pwr_type) 959 { 960 if (!pdev) { 961 reg_err("pdev object is NULL"); 962 return 0; 963 } 964 965 return reg_get_band_channel_list_for_pwrmode(pdev, band_mask, 966 channel_list, 967 in_6g_pwr_type); 968 } 969 #endif 970 971 #ifdef CONFIG_REG_CLIENT 972 uint16_t 973 wlan_reg_get_secondary_band_channel_list(struct wlan_objmgr_pdev *pdev, 974 uint8_t band_mask, 975 struct regulatory_channel 976 *channel_list) 977 { 978 if (!pdev) { 979 reg_err("pdev object is NULL"); 980 return 0; 981 } 982 983 return reg_get_secondary_band_channel_list(pdev, band_mask, 984 channel_list); 985 } 986 #endif 987 988 qdf_freq_t wlan_reg_chan_band_to_freq(struct wlan_objmgr_pdev *pdev, 989 uint8_t chan, uint8_t band_mask) 990 { 991 return reg_chan_band_to_freq(pdev, chan, band_mask); 992 } 993 994 qdf_export_symbol(wlan_reg_chan_band_to_freq); 995 996 #ifdef CONFIG_49GHZ_CHAN 997 bool wlan_reg_is_49ghz_freq(qdf_freq_t freq) 998 { 999 return reg_is_49ghz_freq(freq); 1000 } 1001 #endif /* CONFIG_49GHZ_CHAN */ 1002 1003 uint8_t wlan_reg_ch_num(uint32_t ch_enum) 1004 { 1005 return reg_ch_num(ch_enum); 1006 } 1007 1008 qdf_freq_t wlan_reg_ch_to_freq(uint32_t ch_enum) 1009 { 1010 return reg_ch_to_freq(ch_enum); 1011 } 1012 1013 #ifdef WLAN_REG_PARTIAL_OFFLOAD 1014 bool wlan_reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev *pdev) 1015 { 1016 return reg_is_regdmn_en302502_applicable(pdev); 1017 } 1018 #endif 1019 1020 QDF_STATUS wlan_reg_modify_pdev_chan_range(struct wlan_objmgr_pdev *pdev) 1021 { 1022 return reg_modify_pdev_chan_range(pdev); 1023 } 1024 1025 QDF_STATUS wlan_reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev *pdev, 1026 uint64_t wireless_modes) 1027 { 1028 return reg_update_pdev_wireless_modes(pdev, wireless_modes); 1029 } 1030 #ifdef DISABLE_UNII_SHARED_BANDS 1031 QDF_STATUS wlan_reg_disable_chan_coex(struct wlan_objmgr_pdev *pdev, 1032 uint8_t unii_5g_bitmap) 1033 { 1034 return reg_disable_chan_coex(pdev, unii_5g_bitmap); 1035 } 1036 #endif 1037 1038 #ifdef CONFIG_CHAN_FREQ_API 1039 bool wlan_reg_is_same_band_freqs(qdf_freq_t freq1, qdf_freq_t freq2) 1040 { 1041 return reg_is_same_band_freqs(freq1, freq2); 1042 } 1043 1044 enum channel_enum wlan_reg_get_chan_enum_for_freq(qdf_freq_t freq) 1045 { 1046 return reg_get_chan_enum_for_freq(freq); 1047 } 1048 1049 QDF_STATUS 1050 wlan_reg_get_min_max_bw_for_chan_index(struct wlan_objmgr_pdev *pdev, 1051 enum channel_enum chan_idx, 1052 uint16_t *min_bw, uint16_t *max_bw) 1053 { 1054 return reg_get_min_max_bw_on_cur_chan_list(pdev, 1055 chan_idx, min_bw, max_bw); 1056 } 1057 1058 bool wlan_reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev *pdev, 1059 qdf_freq_t freq) 1060 { 1061 return reg_is_freq_present_in_cur_chan_list(pdev, freq); 1062 } 1063 1064 bool wlan_reg_is_etsi13_srd_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1065 qdf_freq_t freq) 1066 { 1067 return reg_is_etsi13_srd_chan_for_freq(pdev, freq); 1068 } 1069 1070 bool wlan_reg_is_dsrc_freq(qdf_freq_t freq) 1071 { 1072 return reg_is_dsrc_freq(freq); 1073 } 1074 1075 void wlan_reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev *pdev, 1076 uint16_t *chan_freq_list, 1077 uint8_t num_ch, 1078 bool nol_ch) 1079 { 1080 reg_update_nol_ch_for_freq(pdev, chan_freq_list, num_ch, nol_ch); 1081 } 1082 1083 void wlan_reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev *pdev, 1084 uint16_t *ch_list, 1085 uint8_t num_ch, 1086 bool nol_history_ch) 1087 { 1088 reg_update_nol_history_ch_for_freq(pdev, 1089 ch_list, 1090 num_ch, 1091 nol_history_ch); 1092 } 1093 1094 bool wlan_reg_is_dfs_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 1095 { 1096 return reg_is_dfs_for_freq(pdev, freq); 1097 } 1098 1099 bool wlan_reg_is_passive_or_disable_for_pwrmode( 1100 struct wlan_objmgr_pdev *pdev, 1101 qdf_freq_t freq, 1102 enum supported_6g_pwr_types in_6g_pwr_mode) 1103 { 1104 return reg_is_passive_or_disable_for_pwrmode(pdev, freq, 1105 in_6g_pwr_mode); 1106 } 1107 1108 #ifdef CONFIG_REG_6G_PWRMODE 1109 bool wlan_reg_is_disable_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1110 qdf_freq_t freq, 1111 enum supported_6g_pwr_types in_6g_pwr_mode) 1112 { 1113 return reg_is_disable_for_pwrmode(pdev, freq, in_6g_pwr_mode); 1114 } 1115 #endif 1116 1117 #ifdef CONFIG_REG_CLIENT 1118 bool wlan_reg_is_disable_in_secondary_list_for_freq( 1119 struct wlan_objmgr_pdev *pdev, 1120 qdf_freq_t freq) 1121 { 1122 return reg_is_disable_in_secondary_list_for_freq(pdev, freq); 1123 } 1124 1125 bool wlan_reg_is_enable_in_secondary_list_for_freq( 1126 struct wlan_objmgr_pdev *pdev, 1127 qdf_freq_t freq) 1128 { 1129 return reg_is_enable_in_secondary_list_for_freq(pdev, freq); 1130 } 1131 1132 bool wlan_reg_is_dfs_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev, 1133 qdf_freq_t freq) 1134 { 1135 return reg_is_dfs_in_secondary_list_for_freq(pdev, freq); 1136 } 1137 1138 QDF_STATUS 1139 wlan_reg_get_chan_pwr_attr_from_secondary_list_for_freq( 1140 struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 1141 bool *is_psd, uint16_t *tx_power, 1142 uint16_t *psd_eirp, uint32_t *flags) 1143 { 1144 return reg_get_channel_power_attr_from_secondary_list_for_freq( 1145 pdev, freq, is_psd, tx_power, psd_eirp, flags); 1146 } 1147 1148 QDF_STATUS 1149 wlan_reg_decide_6ghz_power_within_bw_for_freq(struct wlan_objmgr_pdev *pdev, 1150 qdf_freq_t freq, 1151 enum phy_ch_width bw, 1152 bool *is_psd, 1153 uint16_t *min_tx_power, 1154 int16_t *min_psd_eirp, 1155 enum reg_6g_ap_type *power_type, 1156 enum supported_6g_pwr_types pwr_mode, 1157 uint16_t input_punc_bitmap) 1158 { 1159 return reg_decide_6ghz_power_within_bw_for_freq(pdev, 1160 freq, 1161 bw, 1162 is_psd, 1163 min_tx_power, 1164 min_psd_eirp, 1165 power_type, 1166 pwr_mode, 1167 input_punc_bitmap); 1168 } 1169 #endif 1170 1171 bool wlan_reg_is_passive_for_freq(struct wlan_objmgr_pdev *pdev, 1172 qdf_freq_t freq) 1173 { 1174 return reg_is_passive_for_freq(pdev, freq); 1175 } 1176 1177 QDF_STATUS 1178 wlan_reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev *pdev, 1179 struct channel_power *ch_list, 1180 uint8_t *num_chan) 1181 { 1182 return reg_get_channel_list_with_power_for_freq(pdev, 1183 ch_list, 1184 num_chan); 1185 } 1186 1187 bool 1188 wlan_reg_chan_has_dfs_attribute_for_freq(struct wlan_objmgr_pdev *pdev, 1189 qdf_freq_t freq) 1190 { 1191 return reg_chan_has_dfs_attribute_for_freq(pdev, freq); 1192 } 1193 1194 enum channel_state 1195 wlan_reg_get_5g_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1196 qdf_freq_t freq, 1197 struct ch_params *ch_params, 1198 enum supported_6g_pwr_types 1199 in_6g_pwr_type) 1200 { 1201 enum phy_ch_width bw; 1202 1203 if (!ch_params) { 1204 reg_err_rl("Invalid ch_params"); 1205 return CHANNEL_STATE_INVALID; 1206 } 1207 bw = ch_params->ch_width; 1208 1209 if (reg_is_ch_width_320(bw)) { 1210 const struct bonded_channel_freq *bonded_ch_ptr_ptr = NULL; 1211 uint16_t in_punc_bitmap = reg_fetch_punc_bitmap(ch_params); 1212 1213 return reg_get_5g_bonded_channel_for_pwrmode(pdev, freq, bw, 1214 &bonded_ch_ptr_ptr, 1215 in_6g_pwr_type, 1216 in_punc_bitmap); 1217 } 1218 1219 return reg_get_5g_bonded_channel_state_for_pwrmode(pdev, freq, 1220 ch_params, 1221 in_6g_pwr_type); 1222 } 1223 1224 qdf_export_symbol(wlan_reg_get_5g_bonded_channel_state_for_pwrmode); 1225 1226 enum channel_state 1227 wlan_reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 1228 qdf_freq_t freq, 1229 qdf_freq_t sec_ch_freq, 1230 enum phy_ch_width bw) 1231 { 1232 return reg_get_2g_bonded_channel_state_for_freq(pdev, 1233 freq, 1234 sec_ch_freq, 1235 bw); 1236 } 1237 1238 #ifdef CONFIG_REG_6G_PWRMODE 1239 void wlan_reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1240 qdf_freq_t freq, 1241 qdf_freq_t sec_ch_2g_freq, 1242 struct ch_params *ch_params, 1243 enum supported_6g_pwr_types 1244 in_6g_pwr_mode) 1245 { 1246 reg_set_channel_params_for_pwrmode(pdev, freq, sec_ch_2g_freq, 1247 ch_params, 1248 in_6g_pwr_mode, true); 1249 } 1250 1251 qdf_export_symbol(wlan_reg_set_channel_params_for_pwrmode); 1252 #endif 1253 1254 const struct bonded_channel_freq * 1255 wlan_reg_get_bonded_chan_entry(qdf_freq_t freq, enum phy_ch_width chwidth, 1256 qdf_freq_t cen320_freq) 1257 { 1258 return reg_get_bonded_chan_entry(freq, chwidth, cen320_freq); 1259 } 1260 1261 #ifdef WLAN_FEATURE_11BE 1262 #ifdef CONFIG_REG_6G_PWRMODE 1263 void 1264 wlan_reg_fill_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1265 qdf_freq_t freq, 1266 qdf_freq_t sec_ch_2g_freq, 1267 enum phy_ch_width ch_width, 1268 qdf_freq_t band_center_320, 1269 struct reg_channel_list *chan_list, 1270 enum supported_6g_pwr_types 1271 in_6g_pwr_type, 1272 bool treat_nol_chan_as_disabled) 1273 { 1274 reg_fill_channel_list_for_pwrmode(pdev, freq, sec_ch_2g_freq, ch_width, 1275 band_center_320, chan_list, 1276 in_6g_pwr_type, 1277 treat_nol_chan_as_disabled); 1278 } 1279 #endif /* CONFIG_REG_6G_PWRMODE */ 1280 1281 bool wlan_reg_is_punc_bitmap_valid(enum phy_ch_width bw, 1282 uint16_t puncture_bitmap) 1283 { 1284 return reg_is_punc_bitmap_valid(bw, puncture_bitmap); 1285 } 1286 1287 uint16_t wlan_reg_find_nearest_puncture_pattern(enum phy_ch_width bw, 1288 uint16_t proposed_bitmap) 1289 { 1290 return reg_find_nearest_puncture_pattern(bw, proposed_bitmap); 1291 } 1292 1293 QDF_STATUS wlan_reg_extract_puncture_by_bw(enum phy_ch_width ori_bw, 1294 uint16_t ori_puncture_bitmap, 1295 qdf_freq_t freq, 1296 qdf_freq_t cen320_freq, 1297 enum phy_ch_width new_bw, 1298 uint16_t *new_puncture_bitmap) 1299 { 1300 return reg_extract_puncture_by_bw(ori_bw, ori_puncture_bitmap, freq, 1301 cen320_freq, new_bw, 1302 new_puncture_bitmap); 1303 } 1304 1305 void wlan_reg_set_create_punc_bitmap(struct ch_params *ch_params, 1306 bool is_create_punc_bitmap) 1307 { 1308 reg_set_create_punc_bitmap(ch_params, is_create_punc_bitmap); 1309 } 1310 1311 #ifdef CONFIG_REG_CLIENT 1312 QDF_STATUS wlan_reg_apply_puncture(struct wlan_objmgr_pdev *pdev, 1313 uint16_t puncture_bitmap, 1314 qdf_freq_t freq, 1315 enum phy_ch_width bw, 1316 qdf_freq_t cen320_freq) 1317 { 1318 return reg_apply_puncture(pdev, puncture_bitmap, freq, bw, 1319 cen320_freq); 1320 } 1321 1322 QDF_STATUS wlan_reg_remove_puncture(struct wlan_objmgr_pdev *pdev) 1323 { 1324 return reg_remove_puncture(pdev); 1325 } 1326 #endif 1327 #endif /* WLAN_FEATURE_11BE */ 1328 1329 #ifdef CONFIG_REG_6G_PWRMODE 1330 enum channel_state 1331 wlan_reg_get_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1332 qdf_freq_t freq, 1333 enum supported_6g_pwr_types 1334 in_6g_pwr_type) 1335 { 1336 return reg_get_channel_state_for_pwrmode(pdev, freq, in_6g_pwr_type); 1337 } 1338 #endif 1339 1340 #ifdef CONFIG_REG_CLIENT 1341 enum channel_state wlan_reg_get_channel_state_from_secondary_list_for_freq( 1342 struct wlan_objmgr_pdev *pdev, 1343 qdf_freq_t freq) 1344 { 1345 return reg_get_channel_state_from_secondary_list_for_freq(pdev, freq); 1346 } 1347 1348 QDF_STATUS 1349 wlan_reg_get_channel_list_with_power(struct wlan_objmgr_pdev *pdev, 1350 struct channel_power *ch_list, 1351 uint8_t *num_chan, 1352 enum supported_6g_pwr_types in_6g_pwr_type) 1353 { 1354 return reg_get_channel_list_with_power(pdev, ch_list, num_chan, 1355 in_6g_pwr_type); 1356 } 1357 #endif 1358 1359 uint8_t wlan_reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev *pdev, 1360 qdf_freq_t freq) 1361 { 1362 return reg_get_channel_reg_power_for_freq(pdev, freq); 1363 } 1364 1365 enum reg_wifi_band wlan_reg_freq_to_band(qdf_freq_t freq) 1366 { 1367 return reg_freq_to_band(freq); 1368 } 1369 qdf_export_symbol(wlan_reg_freq_to_band); 1370 1371 qdf_freq_t wlan_reg_min_chan_freq(void) 1372 { 1373 return reg_min_chan_freq(); 1374 } 1375 1376 qdf_freq_t wlan_reg_max_chan_freq(void) 1377 { 1378 return reg_max_chan_freq(); 1379 } 1380 1381 void wlan_reg_freq_width_to_chan_op_class(struct wlan_objmgr_pdev *pdev, 1382 qdf_freq_t freq, 1383 uint16_t chan_width, 1384 bool global_tbl_lookup, 1385 uint16_t behav_limit, 1386 uint8_t *op_class, 1387 uint8_t *chan_num) 1388 { 1389 return reg_freq_width_to_chan_op_class(pdev, freq, chan_width, 1390 global_tbl_lookup, 1391 behav_limit, 1392 op_class, 1393 chan_num); 1394 } 1395 1396 void wlan_reg_freq_width_to_chan_op_class_auto(struct wlan_objmgr_pdev *pdev, 1397 qdf_freq_t freq, 1398 uint16_t chan_width, 1399 bool global_tbl_lookup, 1400 uint16_t behav_limit, 1401 uint8_t *op_class, 1402 uint8_t *chan_num) 1403 { 1404 reg_freq_width_to_chan_op_class_auto(pdev, freq, chan_width, 1405 global_tbl_lookup, 1406 behav_limit, 1407 op_class, 1408 chan_num); 1409 } 1410 1411 qdf_export_symbol(wlan_reg_freq_width_to_chan_op_class_auto); 1412 1413 void wlan_reg_freq_to_chan_op_class(struct wlan_objmgr_pdev *pdev, 1414 qdf_freq_t freq, 1415 bool global_tbl_lookup, 1416 uint16_t behav_limit, 1417 uint8_t *op_class, 1418 uint8_t *chan_num) 1419 { 1420 return reg_freq_to_chan_op_class(pdev, freq, 1421 global_tbl_lookup, 1422 behav_limit, 1423 op_class, 1424 chan_num); 1425 } 1426 1427 bool wlan_reg_is_freq_in_country_opclass(struct wlan_objmgr_pdev *pdev, 1428 const uint8_t country[3], 1429 uint8_t op_class, 1430 qdf_freq_t chan_freq) 1431 { 1432 return reg_is_freq_in_country_opclass(pdev, country, 1433 op_class, chan_freq); 1434 } 1435 1436 enum channel_state 1437 wlan_reg_get_5g_bonded_channel_and_state_for_pwrmode( 1438 struct wlan_objmgr_pdev *pdev, 1439 uint16_t freq, 1440 enum phy_ch_width bw, 1441 const 1442 struct bonded_channel_freq 1443 **bonded_chan_ptr_ptr, 1444 enum supported_6g_pwr_types 1445 in_6g_pwr_mode, 1446 uint16_t input_puncture_bitmap) 1447 { 1448 /* 1449 * Get channel frequencies and state from regulatory 1450 */ 1451 return reg_get_5g_bonded_channel_for_pwrmode(pdev, freq, bw, 1452 bonded_chan_ptr_ptr, 1453 in_6g_pwr_mode, 1454 input_puncture_bitmap); 1455 } 1456 1457 qdf_export_symbol(wlan_reg_get_5g_bonded_channel_and_state_for_pwrmode); 1458 1459 #if defined(WLAN_FEATURE_11BE) && defined(CONFIG_REG_CLIENT) 1460 enum channel_state 1461 wlan_reg_get_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1462 qdf_freq_t freq, 1463 enum phy_ch_width bw, 1464 qdf_freq_t sec_freq, 1465 enum supported_6g_pwr_types 1466 in_6g_pwr_mode) 1467 { 1468 if (WLAN_REG_IS_24GHZ_CH_FREQ(freq)) 1469 return reg_get_2g_bonded_channel_state_for_freq(pdev, freq, 1470 sec_freq, bw); 1471 if (bw == CH_WIDTH_320MHZ) { 1472 const struct bonded_channel_freq *bonded_chan_ptr_ptr = NULL; 1473 1474 return reg_get_chan_state_for_320(pdev, freq, 0, 1475 bw, 1476 &bonded_chan_ptr_ptr, 1477 in_6g_pwr_mode, true, 1478 NO_SCHANS_PUNC); 1479 } else { 1480 struct ch_params params = {0}; 1481 1482 params.ch_width = bw; 1483 1484 return reg_get_5g_bonded_channel_state_for_pwrmode( 1485 pdev, freq, 1486 ¶ms, in_6g_pwr_mode); 1487 } 1488 } 1489 1490 qdf_export_symbol(wlan_reg_get_bonded_channel_state_for_pwrmode); 1491 #endif 1492 #endif /* CONFIG CHAN FREQ API */ 1493 1494 uint16_t wlan_reg_get_op_class_width(struct wlan_objmgr_pdev *pdev, 1495 uint8_t op_class, 1496 bool global_tbl_lookup) 1497 { 1498 return reg_get_op_class_width(pdev, op_class, 1499 global_tbl_lookup); 1500 } 1501 1502 bool wlan_reg_is_5ghz_op_class(const uint8_t *country, uint8_t op_class) 1503 { 1504 return reg_is_5ghz_op_class(country, op_class); 1505 } 1506 1507 bool wlan_reg_is_2ghz_op_class(const uint8_t *country, uint8_t op_class) 1508 { 1509 return reg_is_2ghz_op_class(country, op_class); 1510 } 1511 1512 bool wlan_reg_is_6ghz_op_class(struct wlan_objmgr_pdev *pdev, 1513 uint8_t op_class) 1514 { 1515 return reg_is_6ghz_op_class(pdev, op_class); 1516 } 1517 1518 #ifdef CONFIG_REG_CLIENT 1519 bool wlan_reg_is_6ghz_supported(struct wlan_objmgr_psoc *psoc) 1520 { 1521 return reg_is_6ghz_supported(psoc); 1522 } 1523 #endif 1524 1525 #ifdef HOST_OPCLASS_EXT 1526 qdf_freq_t 1527 wlan_reg_country_chan_opclass_to_freq(struct wlan_objmgr_pdev *pdev, 1528 const uint8_t country[3], 1529 uint8_t chan, uint8_t op_class, 1530 bool strict) 1531 { 1532 return reg_country_chan_opclass_to_freq(pdev, country, chan, op_class, 1533 strict); 1534 } 1535 #endif 1536 1537 uint16_t wlan_reg_chan_opclass_to_freq(uint8_t chan, 1538 uint8_t op_class, 1539 bool global_tbl_lookup) 1540 { 1541 if (!chan || !op_class) 1542 return 0; 1543 1544 return reg_chan_opclass_to_freq(chan, op_class, global_tbl_lookup); 1545 } 1546 1547 qdf_freq_t wlan_reg_chan_opclass_to_freq_auto(uint8_t chan, uint8_t op_class, 1548 bool global_tbl_lookup) 1549 { 1550 if (!chan || !op_class) 1551 return 0; 1552 1553 return reg_chan_opclass_to_freq_auto(chan, op_class, global_tbl_lookup); 1554 } 1555 1556 #ifdef CHECK_REG_PHYMODE 1557 enum reg_phymode wlan_reg_get_max_phymode(struct wlan_objmgr_pdev *pdev, 1558 enum reg_phymode phy_in, 1559 qdf_freq_t freq) 1560 { 1561 return reg_get_max_phymode(pdev, phy_in, freq); 1562 } 1563 #endif /* CHECK_REG_PHYMODE */ 1564 1565 #ifdef CONFIG_REG_CLIENT 1566 enum band_info wlan_reg_band_bitmap_to_band_info(uint32_t band_bitmap) 1567 { 1568 return reg_band_bitmap_to_band_info(band_bitmap); 1569 } 1570 1571 QDF_STATUS 1572 wlan_reg_update_tx_power_on_ctry_change(struct wlan_objmgr_pdev *pdev, 1573 uint8_t vdev_id) 1574 { 1575 return reg_update_tx_power_on_ctry_change(pdev, vdev_id); 1576 } 1577 #endif 1578 1579 #if defined(CONFIG_BAND_6GHZ) 1580 QDF_STATUS wlan_reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev *pdev, 1581 bool *reg_rnr_tpe_usable) 1582 { 1583 return reg_get_rnr_tpe_usable(pdev, reg_rnr_tpe_usable); 1584 } 1585 1586 QDF_STATUS wlan_reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev *pdev, 1587 bool *reg_unspecified_ap_usable) 1588 { 1589 return reg_get_unspecified_ap_usable(pdev, reg_unspecified_ap_usable); 1590 } 1591 1592 QDF_STATUS 1593 wlan_reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 1594 enum reg_6g_ap_type *reg_cur_6g_ap_pwr_type) 1595 { 1596 return reg_get_cur_6g_ap_pwr_type(pdev, reg_cur_6g_ap_pwr_type); 1597 } 1598 1599 qdf_export_symbol(wlan_reg_get_cur_6g_ap_pwr_type); 1600 1601 QDF_STATUS 1602 wlan_reg_get_cur_6g_client_type(struct wlan_objmgr_pdev *pdev, 1603 enum reg_6g_client_type 1604 *reg_cur_6g_client_mobility_type) 1605 { 1606 return reg_get_cur_6g_client_type(pdev, 1607 reg_cur_6g_client_mobility_type); 1608 } 1609 1610 qdf_export_symbol(wlan_reg_get_cur_6g_client_type); 1611 1612 QDF_STATUS 1613 wlan_reg_set_cur_6ghz_client_type(struct wlan_objmgr_pdev *pdev, 1614 enum reg_6g_client_type in_6ghz_client_type) 1615 { 1616 return reg_set_cur_6ghz_client_type(pdev, in_6ghz_client_type); 1617 } 1618 1619 QDF_STATUS 1620 wlan_reg_set_6ghz_client_type_from_target(struct wlan_objmgr_pdev *pdev) 1621 { 1622 return reg_set_6ghz_client_type_from_target(pdev); 1623 } 1624 1625 bool wlan_reg_is_6g_psd_power(struct wlan_objmgr_pdev *pdev) 1626 { 1627 return reg_is_6g_psd_power(pdev); 1628 } 1629 1630 QDF_STATUS wlan_reg_get_6g_chan_ap_power(struct wlan_objmgr_pdev *pdev, 1631 qdf_freq_t chan_freq, bool *is_psd, 1632 uint16_t *tx_power, 1633 uint16_t *eirp_psd_power) 1634 { 1635 return reg_get_6g_chan_ap_power(pdev, chan_freq, is_psd, 1636 tx_power, eirp_psd_power); 1637 } 1638 1639 qdf_export_symbol(wlan_reg_get_6g_chan_ap_power); 1640 1641 QDF_STATUS 1642 wlan_reg_get_client_power_for_connecting_ap(struct wlan_objmgr_pdev *pdev, 1643 enum reg_6g_ap_type ap_type, 1644 qdf_freq_t chan_freq, 1645 bool is_psd, uint16_t *tx_power, 1646 uint16_t *eirp_psd_power) 1647 { 1648 return reg_get_client_power_for_connecting_ap(pdev, ap_type, chan_freq, 1649 is_psd, tx_power, 1650 eirp_psd_power); 1651 } 1652 1653 QDF_STATUS 1654 wlan_reg_get_client_power_for_6ghz_ap(struct wlan_objmgr_pdev *pdev, 1655 enum reg_6g_client_type client_type, 1656 qdf_freq_t chan_freq, 1657 bool *is_psd, uint16_t *tx_power, 1658 uint16_t *eirp_psd_power) 1659 { 1660 return reg_get_client_power_for_6ghz_ap(pdev, client_type, chan_freq, 1661 is_psd, tx_power, 1662 eirp_psd_power); 1663 } 1664 1665 enum reg_6g_ap_type 1666 wlan_reg_decide_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev) 1667 { 1668 return reg_decide_6g_ap_pwr_type(pdev); 1669 } 1670 1671 QDF_STATUS 1672 wlan_reg_set_ap_pwr_and_update_chan_list(struct wlan_objmgr_pdev *pdev, 1673 enum reg_6g_ap_type ap_pwr_type) 1674 { 1675 return reg_set_ap_pwr_and_update_chan_list(pdev, ap_pwr_type); 1676 } 1677 1678 qdf_export_symbol(wlan_reg_set_ap_pwr_and_update_chan_list); 1679 1680 uint8_t 1681 wlan_reg_get_num_rules_of_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 1682 enum reg_6g_ap_type ap_pwr_type) 1683 { 1684 return reg_get_num_rules_of_ap_pwr_type(pdev, ap_pwr_type); 1685 } 1686 1687 qdf_export_symbol(wlan_reg_get_num_rules_of_ap_pwr_type); 1688 1689 QDF_STATUS wlan_reg_get_superchan_entry( 1690 struct wlan_objmgr_pdev *pdev, 1691 enum channel_enum chan_enum, 1692 const struct super_chan_info **p_sup_chan_entry) 1693 { 1694 return reg_get_superchan_entry(pdev, chan_enum, p_sup_chan_entry); 1695 } 1696 1697 enum supported_6g_pwr_types 1698 wlan_reg_conv_6g_ap_type_to_supported_6g_pwr_types(enum reg_6g_ap_type 1699 ap_pwr_type) 1700 { 1701 return reg_conv_6g_ap_type_to_supported_6g_pwr_types(ap_pwr_type); 1702 } 1703 1704 enum supported_6g_pwr_types 1705 wlan_reg_get_best_6g_pwr_type(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 1706 { 1707 return reg_get_best_6g_pwr_type(pdev, freq); 1708 } 1709 1710 enum reg_6g_ap_type 1711 wlan_reg_conv_supported_6g_pwr_type_to_ap_pwr_type(enum supported_6g_pwr_types 1712 in_6g_pwr_type) 1713 { 1714 return reg_convert_supported_6g_pwr_type_to_ap_pwr_type(in_6g_pwr_type); 1715 } 1716 #endif /* CONFIG_BAND_6GHZ */ 1717 1718 bool wlan_reg_is_ext_tpc_supported(struct wlan_objmgr_psoc *psoc) 1719 { 1720 return reg_is_ext_tpc_supported(psoc); 1721 } 1722 1723 #ifdef CONFIG_AFC_SUPPORT 1724 bool wlan_reg_is_afc_power_event_received(struct wlan_objmgr_pdev *pdev) 1725 { 1726 return reg_is_afc_power_event_received(pdev); 1727 } 1728 1729 qdf_export_symbol(wlan_reg_is_afc_power_event_received); 1730 1731 bool wlan_reg_is_afc_done(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 1732 { 1733 return reg_is_afc_done(pdev, freq); 1734 } 1735 1736 qdf_export_symbol(wlan_reg_is_afc_done); 1737 1738 QDF_STATUS wlan_reg_get_afc_req_id(struct wlan_objmgr_pdev *pdev, 1739 uint64_t *req_id) 1740 { 1741 return reg_get_afc_req_id(pdev, req_id); 1742 } 1743 1744 qdf_export_symbol(wlan_reg_get_afc_req_id); 1745 1746 bool wlan_reg_is_afc_expiry_event_received(struct wlan_objmgr_pdev *pdev) 1747 { 1748 return reg_is_afc_expiry_event_received(pdev); 1749 } 1750 1751 qdf_export_symbol(wlan_reg_is_afc_expiry_event_received); 1752 1753 bool wlan_reg_is_noaction_on_afc_pwr_evt(struct wlan_objmgr_pdev *pdev) 1754 { 1755 return reg_is_noaction_on_afc_pwr_evt(pdev); 1756 } 1757 1758 QDF_STATUS 1759 wlan_reg_get_afc_dev_deploy_type(struct wlan_objmgr_pdev *pdev, 1760 enum reg_afc_dev_deploy_type *afc_dev_type) 1761 { 1762 return reg_get_afc_dev_deploy_type(pdev, afc_dev_type); 1763 } 1764 1765 qdf_export_symbol(wlan_reg_get_afc_dev_deploy_type); 1766 1767 bool 1768 wlan_reg_is_sta_connect_allowed(struct wlan_objmgr_pdev *pdev, 1769 enum reg_6g_ap_type root_ap_pwr_mode) 1770 { 1771 return reg_is_sta_connect_allowed(pdev, root_ap_pwr_mode); 1772 } 1773 1774 qdf_export_symbol(wlan_reg_is_sta_connect_allowed); 1775 #endif /* CONFIG_AFC_SUPPORT */ 1776 1777 QDF_STATUS wlan_reg_is_chwidth_supported(struct wlan_objmgr_pdev *pdev, 1778 enum phy_ch_width ch_width, 1779 bool *is_supported) 1780 { 1781 return reg_is_chwidth_supported(pdev, ch_width, is_supported); 1782 } 1783 1784 qdf_export_symbol(wlan_reg_is_chwidth_supported); 1785 1786 #ifdef CONFIG_BAND_6GHZ 1787 qdf_freq_t wlan_reg_get_thresh_priority_freq(struct wlan_objmgr_pdev *pdev) 1788 { 1789 return reg_get_thresh_priority_freq(pdev); 1790 } 1791 1792 QDF_STATUS wlan_reg_psd_2_eirp(struct wlan_objmgr_pdev *pdev, 1793 int16_t psd, 1794 uint16_t ch_bw, 1795 int16_t *eirp) 1796 { 1797 return reg_psd_2_eirp(pdev, psd, ch_bw, eirp); 1798 } 1799 1800 qdf_export_symbol(wlan_reg_psd_2_eirp); 1801 1802 QDF_STATUS wlan_reg_eirp_2_psd(struct wlan_objmgr_pdev *pdev, uint16_t ch_bw, 1803 int16_t eirp, int16_t *psd) 1804 { 1805 return reg_eirp_2_psd(pdev, ch_bw, eirp, psd); 1806 } 1807 1808 enum reg_6g_ap_type 1809 wlan_reg_get_best_pwr_mode(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 1810 qdf_freq_t cen320, 1811 uint16_t bw, uint16_t in_punc_pattern) 1812 { 1813 return reg_get_best_pwr_mode(pdev, freq, cen320, bw, in_punc_pattern); 1814 } 1815 1816 qdf_export_symbol(wlan_reg_get_best_pwr_mode); 1817 1818 uint8_t wlan_reg_get_eirp_pwr(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 1819 qdf_freq_t cen320, uint16_t bw, 1820 enum reg_6g_ap_type ap_pwr_type, 1821 uint16_t in_punc_pattern, 1822 bool is_client_list_lookup_needed, 1823 enum reg_6g_client_type client_type) 1824 { 1825 return reg_get_eirp_pwr(pdev, freq, cen320, bw, ap_pwr_type, 1826 in_punc_pattern, is_client_list_lookup_needed, 1827 client_type); 1828 } 1829 1830 qdf_export_symbol(wlan_reg_get_eirp_pwr); 1831 1832 #endif /* CONFIG_BAND_6GHZ */ 1833 1834 enum phy_ch_width wlan_reg_find_chwidth_from_bw(uint16_t bw) 1835 { 1836 return reg_find_chwidth_from_bw(bw); 1837 } 1838 1839 #ifdef WLAN_FEATURE_11BE 1840 enum channel_state 1841 wlan_reg_get_chan_state_for_320(struct wlan_objmgr_pdev *pdev, 1842 uint16_t freq, 1843 qdf_freq_t center_320, 1844 enum phy_ch_width ch_width, 1845 const struct bonded_channel_freq 1846 **bonded_chan_ptr_ptr, 1847 enum supported_6g_pwr_types in_6g_pwr_type, 1848 bool treat_nol_chan_as_disabled, 1849 uint16_t input_puncture_bitmap) 1850 { 1851 return reg_get_chan_state_for_320(pdev, freq, center_320, 1852 ch_width, bonded_chan_ptr_ptr, 1853 in_6g_pwr_type, 1854 treat_nol_chan_as_disabled, 1855 input_puncture_bitmap); 1856 } 1857 #endif 1858 1859 #ifdef CONFIG_BAND_6GHZ 1860 bool wlan_is_sup_chan_entry_afc_done(struct wlan_objmgr_pdev *pdev, 1861 enum channel_enum chan_idx, 1862 enum supported_6g_pwr_types in_6g_pwr_mode) 1863 { 1864 return reg_is_sup_chan_entry_afc_done(pdev, chan_idx, in_6g_pwr_mode); 1865 } 1866 1867 qdf_export_symbol(wlan_is_sup_chan_entry_afc_done); 1868 1869 QDF_STATUS 1870 wlan_reg_display_super_chan_list(struct wlan_objmgr_pdev *pdev) 1871 { 1872 return reg_display_super_chan_list(pdev); 1873 } 1874 1875 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 1876 QDF_STATUS 1877 wlan_reg_get_afc_freq_range_and_psd_limits(struct wlan_objmgr_pdev *pdev, 1878 uint8_t num_freq_obj, 1879 struct afc_freq_obj *afc_obj) 1880 { 1881 return reg_get_afc_freq_range_and_psd_limits(pdev, num_freq_obj, 1882 afc_obj); 1883 } 1884 1885 QDF_STATUS 1886 wlan_reg_get_num_afc_freq_obj(struct wlan_objmgr_pdev *pdev, 1887 uint8_t *num_freq_obj) 1888 { 1889 return reg_get_num_afc_freq_obj(pdev, num_freq_obj); 1890 } 1891 1892 QDF_STATUS wlan_reg_set_afc_power_event_received(struct wlan_objmgr_pdev *pdev, 1893 bool val) 1894 { 1895 return reg_set_afc_power_event_received(pdev, val); 1896 } 1897 #endif 1898 1899 #endif 1900 1901 #ifdef CONFIG_REG_CLIENT 1902 QDF_STATUS 1903 wlan_reg_recompute_current_chan_list(struct wlan_objmgr_psoc *psoc, 1904 struct wlan_objmgr_pdev *pdev) 1905 { 1906 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1907 1908 pdev_priv_obj = reg_get_pdev_obj(pdev); 1909 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1910 reg_err("reg pdev priv obj is NULL"); 1911 return QDF_STATUS_E_FAILURE; 1912 } 1913 1914 reg_debug("Recomputing the current channel list"); 1915 reg_compute_pdev_current_chan_list(pdev_priv_obj); 1916 return reg_send_scheduler_msg_nb(psoc, pdev); 1917 } 1918 1919 QDF_STATUS 1920 wlan_reg_modify_indoor_concurrency(struct wlan_objmgr_pdev *pdev, 1921 uint8_t vdev_id, uint32_t freq, 1922 enum phy_ch_width width, bool add) 1923 { 1924 if (add) 1925 return reg_add_indoor_concurrency(pdev, vdev_id, freq, width); 1926 else 1927 return reg_remove_indoor_concurrency(pdev, vdev_id, freq); 1928 } 1929 #endif 1930