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