1 /* 2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022-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: target_if_reg.c 23 * This file contains regulatory target interfaces. 24 */ 25 26 #include <wmi_unified_api.h> 27 #include <reg_services_public_struct.h> 28 #include <wlan_reg_tgt_api.h> 29 #include <target_if.h> 30 #include <target_if_reg.h> 31 #include <wmi_unified_reg_api.h> 32 #include <qdf_platform.h> 33 #include <target_if_reg_11d.h> 34 #include <target_if_reg_lte.h> 35 #include <wlan_reg_ucfg_api.h> 36 #include <wlan_utility.h> 37 #ifdef CONFIG_REG_CLIENT 38 #include <wlan_dcs_tgt_api.h> 39 #endif 40 41 /** 42 * get_chan_list_cc_event_id() - Get chan_list_cc event id 43 * 44 * Return: Event id 45 */ 46 static inline uint32_t get_chan_list_cc_event_id(void) 47 { 48 return wmi_reg_chan_list_cc_event_id; 49 } 50 51 /** 52 * tgt_if_regulatory_is_regdb_offloaded() - Check if regdb is offloaded 53 * @psoc: Pointer to psoc 54 * 55 * Return: true if regdb if offloaded, else false 56 */ 57 static bool tgt_if_regulatory_is_regdb_offloaded(struct wlan_objmgr_psoc *psoc) 58 { 59 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 60 61 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 62 63 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 64 if (!reg_rx_ops) { 65 target_if_err("reg_rx_ops is NULL"); 66 return false; 67 } 68 69 if (!wmi_handle) 70 return false; 71 72 if (reg_rx_ops->reg_ignore_fw_reg_offload_ind && 73 reg_rx_ops->reg_ignore_fw_reg_offload_ind(psoc)) { 74 target_if_debug("User disabled regulatory offload from ini"); 75 return 0; 76 } 77 78 return wmi_service_enabled(wmi_handle, wmi_service_regulatory_db); 79 } 80 81 /** 82 * tgt_if_regulatory_is_6ghz_supported() - Check if 6 GHz is supported 83 * @psoc: Pointer to psoc 84 * 85 * Return: true if regdb if offloaded, else false 86 */ 87 static bool tgt_if_regulatory_is_6ghz_supported(struct wlan_objmgr_psoc *psoc) 88 { 89 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 90 91 if (!wmi_handle) 92 return false; 93 94 return wmi_service_enabled(wmi_handle, wmi_service_6ghz_support); 95 } 96 97 /** 98 * tgt_if_regulatory_is_5dot9_ghz_supported() - Check if 5.9 GHz is supported 99 * @psoc: Pointer to psoc 100 * 101 * Return: true if 5.9 GHz is supported, else false 102 */ 103 static bool 104 tgt_if_regulatory_is_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc) 105 { 106 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 107 108 if (!wmi_handle) 109 return false; 110 111 return wmi_service_enabled(wmi_handle, wmi_service_5dot9_ghz_support); 112 } 113 114 /** 115 * tgt_if_regulatory_is_there_serv_ready_extn() - Check for service ready 116 * extension 117 * @psoc: Pointer to psoc object 118 * 119 * Return: true if service ready extension is present, else false. 120 */ 121 static bool tgt_if_regulatory_is_there_serv_ready_extn( 122 struct wlan_objmgr_psoc *psoc) 123 { 124 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 125 126 if (!wmi_handle) 127 return false; 128 129 return wmi_service_enabled(wmi_handle, wmi_service_ext_msg); 130 } 131 132 /** 133 * target_if_regulatory_get_rx_ops() - Get regdb rx ops 134 * @psoc: Pointer to psoc object 135 * 136 * Return: Reg rx_ops 137 */ 138 struct wlan_lmac_if_reg_rx_ops * 139 target_if_regulatory_get_rx_ops(struct wlan_objmgr_psoc *psoc) 140 { 141 struct wlan_lmac_if_rx_ops *rx_ops; 142 143 rx_ops = wlan_psoc_get_lmac_if_rxops(psoc); 144 if (!rx_ops) { 145 target_if_err("rx_ops is NULL"); 146 return NULL; 147 } 148 149 return &rx_ops->reg_rx_ops; 150 } 151 152 struct wlan_lmac_if_reg_tx_ops * 153 target_if_regulatory_get_tx_ops(struct wlan_objmgr_psoc *psoc) 154 { 155 struct wlan_lmac_if_tx_ops *tx_ops; 156 157 tx_ops = wlan_psoc_get_lmac_if_txops(psoc); 158 if (!tx_ops) { 159 target_if_err("tx_ops is NULL"); 160 return NULL; 161 } 162 163 return &tx_ops->reg_ops; 164 } 165 166 QDF_STATUS target_if_reg_set_offloaded_info(struct wlan_objmgr_psoc *psoc) 167 { 168 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 169 170 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 171 if (!reg_rx_ops) { 172 target_if_err("reg_rx_ops is NULL"); 173 return QDF_STATUS_E_FAILURE; 174 } 175 176 if (reg_rx_ops->reg_set_regdb_offloaded) 177 reg_rx_ops->reg_set_regdb_offloaded( 178 psoc, 179 tgt_if_regulatory_is_regdb_offloaded(psoc)); 180 181 if (reg_rx_ops->reg_set_11d_offloaded) 182 reg_rx_ops->reg_set_11d_offloaded( 183 psoc, tgt_if_regulatory_is_11d_offloaded(psoc)); 184 185 return QDF_STATUS_SUCCESS; 186 } 187 188 QDF_STATUS target_if_reg_set_6ghz_info(struct wlan_objmgr_psoc *psoc) 189 { 190 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 191 192 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 193 if (!reg_rx_ops) { 194 target_if_err("reg_rx_ops is NULL"); 195 return QDF_STATUS_E_FAILURE; 196 } 197 198 if (reg_rx_ops->reg_set_6ghz_supported) 199 reg_rx_ops->reg_set_6ghz_supported( 200 psoc, 201 tgt_if_regulatory_is_6ghz_supported(psoc)); 202 203 return QDF_STATUS_SUCCESS; 204 } 205 206 QDF_STATUS target_if_reg_set_5dot9_ghz_info(struct wlan_objmgr_psoc *psoc) 207 { 208 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 209 210 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 211 if (!reg_rx_ops) { 212 target_if_err("reg_rx_ops is NULL"); 213 return QDF_STATUS_E_FAILURE; 214 } 215 216 if (reg_rx_ops->reg_set_5dot9_ghz_supported) 217 reg_rx_ops->reg_set_5dot9_ghz_supported( 218 psoc, 219 tgt_if_regulatory_is_5dot9_ghz_supported(psoc)); 220 221 return QDF_STATUS_SUCCESS; 222 } 223 224 bool 225 target_if_reg_is_reg_cc_ext_event_host_supported(struct wlan_objmgr_psoc *psoc) 226 { 227 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 228 bool reg_ext_cc_supp = false; 229 230 reg_tx_ops = target_if_regulatory_get_tx_ops(psoc); 231 if (!reg_tx_ops) { 232 target_if_err("reg_tx_ops is NULL"); 233 return reg_ext_cc_supp; 234 } 235 236 if (reg_tx_ops->register_master_ext_handler) 237 reg_ext_cc_supp = true; 238 239 return reg_ext_cc_supp; 240 } 241 242 /** 243 * tgt_reg_chan_list_update_handler() - Channel list update handler 244 * @handle: scn handle 245 * @event_buf: pointer to event buffer 246 * @len: buffer length 247 * 248 * Return: 0 on success 249 */ 250 static int tgt_reg_chan_list_update_handler(ol_scn_t handle, uint8_t *event_buf, 251 uint32_t len) 252 { 253 struct wlan_objmgr_psoc *psoc; 254 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 255 struct cur_regulatory_info *reg_info; 256 QDF_STATUS status; 257 struct wmi_unified *wmi_handle; 258 int ret_val = 0; 259 260 TARGET_IF_ENTER(); 261 262 psoc = target_if_get_psoc_from_scn_hdl(handle); 263 if (!psoc) { 264 target_if_err("psoc ptr is NULL"); 265 return -EINVAL; 266 } 267 268 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 269 if (!reg_rx_ops) { 270 target_if_err("reg_rx_ops is NULL"); 271 return -EINVAL; 272 } 273 274 if (!reg_rx_ops->master_list_handler) { 275 target_if_err("master_list_handler is NULL"); 276 return -EINVAL; 277 } 278 279 wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 280 if (!wmi_handle) { 281 target_if_err("invalid wmi handle"); 282 return -EINVAL; 283 } 284 285 reg_info = qdf_mem_malloc(sizeof(*reg_info)); 286 if (!reg_info) 287 return -ENOMEM; 288 289 if (wmi_extract_reg_chan_list_update_event(wmi_handle, 290 event_buf, reg_info, len) 291 != QDF_STATUS_SUCCESS) { 292 target_if_err("Extraction of channel list event failed"); 293 ret_val = -EFAULT; 294 goto clean; 295 } 296 297 if (reg_info->phy_id >= PSOC_MAX_PHY_REG_CAP) { 298 target_if_err_rl("phy_id %d is out of bounds", 299 reg_info->phy_id); 300 ret_val = -EFAULT; 301 goto clean; 302 } 303 304 reg_info->psoc = psoc; 305 306 status = reg_rx_ops->master_list_handler(reg_info); 307 if (status != QDF_STATUS_SUCCESS) { 308 target_if_err("Failed to process master channel list handler"); 309 ret_val = -EFAULT; 310 } 311 312 clean: 313 qdf_mem_free(reg_info->reg_rules_2g_ptr); 314 qdf_mem_free(reg_info->reg_rules_5g_ptr); 315 qdf_mem_free(reg_info); 316 317 TARGET_IF_EXIT(); 318 319 return ret_val; 320 } 321 322 /** 323 * tgt_if_regulatory_register_master_list_handler() - Register master channel 324 * list 325 * @psoc: Pointer to psoc 326 * @arg: Pointer to argument list 327 * 328 * Return: QDF_STATUS 329 */ 330 static QDF_STATUS tgt_if_regulatory_register_master_list_handler( 331 struct wlan_objmgr_psoc *psoc, void *arg) 332 { 333 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 334 335 if (!wmi_handle) 336 return QDF_STATUS_E_FAILURE; 337 338 return wmi_unified_register_event_handler( 339 wmi_handle, wmi_reg_chan_list_cc_event_id, 340 tgt_reg_chan_list_update_handler, WMI_RX_WORK_CTX); 341 } 342 343 /** 344 * tgt_if_regulatory_unregister_master_list_handler() - Unregister master 345 * channel list 346 * @psoc: Pointer to psoc 347 * @arg: Pointer to argument list 348 * 349 * Return: QDF_STATUS 350 */ 351 static QDF_STATUS tgt_if_regulatory_unregister_master_list_handler( 352 struct wlan_objmgr_psoc *psoc, void *arg) 353 { 354 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 355 356 if (!wmi_handle) 357 return QDF_STATUS_E_FAILURE; 358 359 return wmi_unified_unregister_event_handler( 360 wmi_handle, wmi_reg_chan_list_cc_event_id); 361 } 362 363 #ifdef CONFIG_BAND_6GHZ 364 #ifdef CONFIG_REG_CLIENT 365 /** 366 * tgt_reg_mem_free_fcc_rules() - Free regulatory fcc rules 367 * @reg_info: Pointer to regulatory info 368 * 369 */ 370 static void tgt_reg_mem_free_fcc_rules(struct cur_regulatory_info *reg_info) 371 { 372 qdf_mem_free(reg_info->fcc_rules_ptr); 373 } 374 #else 375 static void tgt_reg_mem_free_fcc_rules(struct cur_regulatory_info *reg_info) 376 { 377 } 378 #endif 379 380 /** 381 * tgt_reg_chan_list_ext_update_handler() - Extended channel list update handler 382 * @handle: scn handle 383 * @event_buf: pointer to event buffer 384 * @len: buffer length 385 * 386 * Return: 0 on success 387 */ 388 static int tgt_reg_chan_list_ext_update_handler(ol_scn_t handle, 389 uint8_t *event_buf, 390 uint32_t len) 391 { 392 struct wlan_objmgr_psoc *psoc; 393 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 394 struct cur_regulatory_info *reg_info; 395 QDF_STATUS status; 396 struct wmi_unified *wmi_handle; 397 int ret_val = 0; 398 uint32_t i; 399 400 TARGET_IF_ENTER(); 401 402 psoc = target_if_get_psoc_from_scn_hdl(handle); 403 if (!psoc) { 404 target_if_err("psoc ptr is NULL"); 405 return -EINVAL; 406 } 407 408 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 409 if (!reg_rx_ops) { 410 target_if_err("reg_rx_ops is NULL"); 411 return -EINVAL; 412 } 413 414 if (!reg_rx_ops->master_list_ext_handler) { 415 target_if_err("master_list_ext_handler is NULL"); 416 return -EINVAL; 417 } 418 419 wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 420 if (!wmi_handle) { 421 target_if_err("invalid wmi handle"); 422 return -EINVAL; 423 } 424 425 reg_info = qdf_mem_malloc(sizeof(*reg_info)); 426 if (!reg_info) 427 return -ENOMEM; 428 429 status = wmi_extract_reg_chan_list_ext_update_event(wmi_handle, 430 event_buf, 431 reg_info, len); 432 if (!QDF_IS_STATUS_SUCCESS(status)) { 433 target_if_err("Extraction of ext channel list event failed"); 434 ret_val = -EFAULT; 435 goto clean; 436 } 437 438 if (reg_info->phy_id >= PSOC_MAX_PHY_REG_CAP) { 439 target_if_err_rl("phy_id %d is out of bounds", 440 reg_info->phy_id); 441 ret_val = -EFAULT; 442 goto clean; 443 } 444 445 reg_info->psoc = psoc; 446 447 status = reg_rx_ops->master_list_ext_handler(reg_info); 448 if (!QDF_IS_STATUS_SUCCESS(status)) { 449 target_if_err("Failed to process master ext channel list handler"); 450 ret_val = -EFAULT; 451 } 452 453 clean: 454 qdf_mem_free(reg_info->reg_rules_2g_ptr); 455 qdf_mem_free(reg_info->reg_rules_5g_ptr); 456 tgt_reg_mem_free_fcc_rules(reg_info); 457 458 for (i = 0; i < REG_CURRENT_MAX_AP_TYPE; i++) { 459 qdf_mem_free(reg_info->reg_rules_6g_ap_ptr[i]); 460 qdf_mem_free(reg_info-> 461 reg_rules_6g_client_ptr[i][REG_DEFAULT_CLIENT]); 462 qdf_mem_free(reg_info-> 463 reg_rules_6g_client_ptr[i][REG_SUBORDINATE_CLIENT]); 464 } 465 466 qdf_mem_free(reg_info); 467 468 TARGET_IF_EXIT(); 469 470 return ret_val; 471 } 472 473 /** 474 * tgt_if_regulatory_register_master_list_ext_handler() - Register extended 475 * master channel list event handler 476 * @psoc: Pointer to psoc 477 * @arg: Pointer to argument list 478 * 479 * Return: QDF_STATUS 480 */ 481 static QDF_STATUS tgt_if_regulatory_register_master_list_ext_handler( 482 struct wlan_objmgr_psoc *psoc, void *arg) 483 { 484 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 485 486 if (!wmi_handle) 487 return QDF_STATUS_E_FAILURE; 488 489 return wmi_unified_register_event_handler( 490 wmi_handle, wmi_reg_chan_list_cc_ext_event_id, 491 tgt_reg_chan_list_ext_update_handler, WMI_RX_WORK_CTX); 492 } 493 494 /** 495 * tgt_if_regulatory_unregister_master_list_ext_handler() - Unregister extended 496 * master channel list event handler 497 * @psoc: Pointer to psoc 498 * @arg: Pointer to argument list 499 * 500 * Return: QDF_STATUS 501 */ 502 static QDF_STATUS tgt_if_regulatory_unregister_master_list_ext_handler( 503 struct wlan_objmgr_psoc *psoc, void *arg) 504 { 505 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 506 507 if (!wmi_handle) 508 return QDF_STATUS_E_FAILURE; 509 510 return wmi_unified_unregister_event_handler( 511 wmi_handle, wmi_reg_chan_list_cc_ext_event_id); 512 } 513 514 #ifdef CONFIG_AFC_SUPPORT 515 /** 516 * tgt_afc_event_handler() - Handler for AFC Event 517 * @handle: scn handle 518 * @event_buf: pointer to event buffer 519 * @len: buffer length 520 * 521 * Return: 0 on success 522 */ 523 static int 524 tgt_afc_event_handler(ol_scn_t handle, uint8_t *event_buf, uint32_t len) 525 { 526 struct wlan_objmgr_psoc *psoc; 527 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 528 struct afc_regulatory_info *afc_info; 529 QDF_STATUS status; 530 struct wmi_unified *wmi_handle; 531 int ret_val = 0; 532 533 TARGET_IF_ENTER(); 534 535 psoc = target_if_get_psoc_from_scn_hdl(handle); 536 if (!psoc) { 537 target_if_err("psoc ptr is NULL"); 538 return -EINVAL; 539 } 540 541 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 542 if (!reg_rx_ops) { 543 target_if_err("reg_rx_ops is NULL"); 544 return -EINVAL; 545 } 546 547 if (!reg_rx_ops->afc_event_handler) { 548 target_if_err("afc_event_handler is NULL"); 549 return -EINVAL; 550 } 551 552 wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 553 if (!wmi_handle) { 554 target_if_err("invalid wmi handle"); 555 return -EINVAL; 556 } 557 558 afc_info = qdf_mem_malloc(sizeof(*afc_info)); 559 if (!afc_info) 560 return -ENOMEM; 561 562 status = wmi_extract_afc_event(wmi_handle, event_buf, afc_info, len); 563 if (!QDF_IS_STATUS_SUCCESS(status)) { 564 target_if_err("Extraction of AFC event failed"); 565 ret_val = -EFAULT; 566 goto clean; 567 } 568 569 if (afc_info->phy_id >= PSOC_MAX_PHY_REG_CAP) { 570 target_if_err_rl("phy_id %d is out of bounds", 571 afc_info->phy_id); 572 ret_val = -EFAULT; 573 goto clean; 574 } 575 576 afc_info->psoc = psoc; 577 578 status = reg_rx_ops->afc_event_handler(afc_info); 579 if (!QDF_IS_STATUS_SUCCESS(status)) { 580 target_if_err("Failed to process AFC event handler"); 581 ret_val = -EFAULT; 582 goto clean; 583 } 584 585 clean: 586 qdf_mem_free(afc_info); 587 TARGET_IF_EXIT(); 588 589 return ret_val; 590 } 591 592 /** 593 * tgt_if_regulatory_register_afc_event_handler() - Register AFC event 594 * handler 595 * @psoc: Pointer to psoc 596 * @arg: Pointer to argument list 597 * 598 * Return: QDF_STATUS 599 */ 600 static QDF_STATUS tgt_if_regulatory_register_afc_event_handler( 601 struct wlan_objmgr_psoc *psoc, void *arg) 602 { 603 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 604 605 if (!wmi_handle) 606 return QDF_STATUS_E_FAILURE; 607 608 return wmi_unified_register_event_handler( 609 wmi_handle, wmi_afc_event_id, 610 tgt_afc_event_handler, WMI_RX_WORK_CTX); 611 } 612 613 /** 614 * tgt_if_regulatory_unregister_afc_event_handler() - Unregister AFC event 615 * handler 616 * @psoc: Pointer to psoc 617 * @arg: Pointer to argument list 618 * 619 * Return: QDF_STATUS 620 */ 621 static QDF_STATUS 622 tgt_if_regulatory_unregister_afc_event_handler(struct wlan_objmgr_psoc *psoc, 623 void *arg) 624 { 625 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 626 627 if (!wmi_handle) 628 return QDF_STATUS_E_FAILURE; 629 630 return wmi_unified_unregister_event_handler( 631 wmi_handle, wmi_afc_event_id); 632 } 633 #endif 634 #endif 635 636 /** 637 * tgt_if_regulatory_set_country_code() - Set country code 638 * @psoc: Pointer to psoc 639 * @arg: Pointer to argument list 640 * 641 * Return: QDF_STATUS 642 */ 643 static QDF_STATUS tgt_if_regulatory_set_country_code( 644 struct wlan_objmgr_psoc *psoc, void *arg) 645 { 646 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 647 648 if (!wmi_handle) 649 return QDF_STATUS_E_FAILURE; 650 651 return wmi_unified_set_country_cmd_send(wmi_handle, arg); 652 } 653 654 /** 655 * tgt_if_regulatory_set_user_country_code() - Set user country code 656 * @psoc: Pointer to psoc 657 * @pdev_id: Pdev id 658 * @rd: Pointer to regdomain structure 659 * 660 * Return: QDF_STATUS 661 */ 662 static QDF_STATUS tgt_if_regulatory_set_user_country_code( 663 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, struct cc_regdmn_s *rd) 664 { 665 struct wlan_objmgr_pdev *pdev; 666 wmi_unified_t wmi_handle; 667 QDF_STATUS status; 668 669 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, 670 WLAN_REGULATORY_NB_ID); 671 672 wmi_handle = get_wmi_unified_hdl_from_pdev(pdev); 673 674 if (!wmi_handle) { 675 status = QDF_STATUS_E_FAILURE; 676 goto free_pdevref; 677 } 678 679 status = wmi_unified_set_user_country_code_cmd_send(wmi_handle, 680 pdev_id, rd); 681 if (QDF_IS_STATUS_ERROR(status)) 682 target_if_err("Set user country code failed,status %d", 683 status); 684 free_pdevref: 685 wlan_objmgr_pdev_release_ref(pdev, WLAN_REGULATORY_NB_ID); 686 687 return status; 688 } 689 690 QDF_STATUS tgt_if_regulatory_modify_freq_range(struct wlan_objmgr_psoc *psoc) 691 { 692 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap; 693 694 reg_cap = ucfg_reg_get_hal_reg_cap(psoc); 695 if (!reg_cap) { 696 target_if_err("reg cap is NULL"); 697 return QDF_STATUS_E_FAILURE; 698 } 699 700 if (!(reg_cap->wireless_modes & HOST_REGDMN_MODE_11A)) { 701 reg_cap->low_5ghz_chan = 0; 702 reg_cap->high_5ghz_chan = 0; 703 } 704 705 if (!(reg_cap->wireless_modes & 706 (HOST_REGDMN_MODE_11B | HOST_REGDMN_MODE_PUREG))) { 707 reg_cap->low_2ghz_chan = 0; 708 reg_cap->high_2ghz_chan = 0; 709 } 710 711 target_if_debug("phy_id = %d - low_2ghz_chan = %d high_2ghz_chan = %d low_5ghz_chan = %d high_5ghz_chan = %d", 712 reg_cap->phy_id, 713 reg_cap->low_2ghz_chan, 714 reg_cap->high_2ghz_chan, 715 reg_cap->low_5ghz_chan, 716 reg_cap->high_5ghz_chan); 717 718 return QDF_STATUS_SUCCESS; 719 } 720 721 #ifdef CONFIG_REG_CLIENT 722 /** 723 * tgt_if_regulatory_send_ctl_info() - Send CTL info to firmware 724 * @psoc: Pointer to psoc 725 * @params: Pointer to reg control params 726 * 727 * Return: QDF_STATUS 728 */ 729 static QDF_STATUS 730 tgt_if_regulatory_send_ctl_info(struct wlan_objmgr_psoc *psoc, 731 struct reg_ctl_params *params) 732 { 733 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 734 735 if (!wmi_handle) 736 return QDF_STATUS_E_FAILURE; 737 738 return wmi_unified_send_regdomain_info_to_fw_cmd(wmi_handle, 739 params->regd, 740 params->regd_2g, 741 params->regd_5g, 742 params->ctl_2g, 743 params->ctl_5g); 744 } 745 #else 746 static QDF_STATUS 747 tgt_if_regulatory_send_ctl_info(struct wlan_objmgr_psoc *psoc, 748 struct reg_ctl_params *params) 749 { 750 return QDF_STATUS_SUCCESS; 751 } 752 #endif 753 754 /** 755 * tgt_if_regulatory_get_phy_id_from_pdev_id() - Get phy_id from pdev_id 756 * @psoc: Pointer to psoc 757 * @pdev_id: Pdev id 758 * @phy_id: phy_id 759 * 760 * Return: QDF_STATUS 761 */ 762 static QDF_STATUS tgt_if_regulatory_get_phy_id_from_pdev_id( 763 struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, uint8_t *phy_id) 764 { 765 struct target_psoc_info *tgt_if_handle = psoc->tgt_if_handle; 766 uint8_t ret; 767 768 if (pdev_id >= WLAN_UMAC_MAX_PDEVS) { 769 target_if_err("pdev_id is greater than WLAN_UMAC_MAX_PDEVS"); 770 return QDF_STATUS_E_FAILURE; 771 } 772 773 /* By default pdev_id and phy_id have one to one mapping */ 774 *phy_id = pdev_id; 775 776 if (!(tgt_if_handle && 777 tgt_if_handle->info.is_pdevid_to_phyid_map)) 778 return QDF_STATUS_SUCCESS; 779 780 ret = tgt_if_handle->info.pdev_id_to_phy_id_map[pdev_id]; 781 782 if (ret < PSOC_MAX_PHY_REG_CAP) { 783 *phy_id = ret; 784 } else { 785 target_if_err("phy_id is greater than PSOC_MAX_PHY_REG_CAP"); 786 return QDF_STATUS_E_FAILURE; 787 } 788 789 return QDF_STATUS_SUCCESS; 790 } 791 792 /** 793 * tgt_if_regulatory_get_pdev_id_from_phy_id() - Get pdev_id for phy_id 794 * @psoc: Pointer to psoc 795 * @phy_id: Phy id 796 * @pdev_id: Pdev id 797 * 798 * Return: QDF_STATUS 799 */ 800 static QDF_STATUS tgt_if_regulatory_get_pdev_id_from_phy_id( 801 struct wlan_objmgr_psoc *psoc, uint8_t phy_id, uint8_t *pdev_id) 802 { 803 struct target_psoc_info *tgt_if_handle = psoc->tgt_if_handle; 804 uint8_t i; 805 806 if (phy_id >= PSOC_MAX_PHY_REG_CAP) { 807 target_if_err("phy_id is greater than PSOC_MAX_PHY_REG_CAP"); 808 return QDF_STATUS_E_FAILURE; 809 } 810 811 /* By default pdev_id and phy_id have one to one mapping */ 812 *pdev_id = phy_id; 813 814 if (!(tgt_if_handle && 815 tgt_if_handle->info.is_pdevid_to_phyid_map)) 816 return QDF_STATUS_SUCCESS; 817 818 for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) { 819 if (tgt_if_handle->info.pdev_id_to_phy_id_map[i] == phy_id) 820 break; 821 } 822 823 if (i < WLAN_UMAC_MAX_PDEVS) { 824 *pdev_id = i; 825 } else { 826 target_if_err("pdev_id is greater than WLAN_UMAC_MAX_PDEVS"); 827 return QDF_STATUS_E_FAILURE; 828 } 829 830 return QDF_STATUS_SUCCESS; 831 } 832 833 #ifdef CONFIG_BAND_6GHZ 834 static void target_if_register_master_ext_handler( 835 struct wlan_lmac_if_reg_tx_ops *reg_ops) 836 { 837 reg_ops->register_master_ext_handler = 838 tgt_if_regulatory_register_master_list_ext_handler; 839 840 reg_ops->unregister_master_ext_handler = 841 tgt_if_regulatory_unregister_master_list_ext_handler; 842 } 843 844 #ifdef CONFIG_AFC_SUPPORT 845 static void target_if_register_afc_event_handler( 846 struct wlan_lmac_if_reg_tx_ops *reg_ops) 847 { 848 reg_ops->register_afc_event_handler = 849 tgt_if_regulatory_register_afc_event_handler; 850 851 reg_ops->unregister_afc_event_handler = 852 tgt_if_regulatory_unregister_afc_event_handler; 853 } 854 855 #ifdef CONFIG_REG_CLIENT 856 static void target_if_register_acs_trigger_for_afc 857 (struct wlan_lmac_if_reg_tx_ops *reg_ops) 858 { 859 reg_ops->trigger_acs_for_afc = tgt_afc_trigger_dcs; 860 } 861 #else 862 static void target_if_register_acs_trigger_for_afc 863 (struct wlan_lmac_if_reg_tx_ops *reg_ops) 864 { 865 reg_ops->trigger_acs_for_afc = NULL; 866 } 867 #endif 868 #else 869 static void target_if_register_afc_event_handler( 870 struct wlan_lmac_if_reg_tx_ops *reg_ops) 871 { 872 } 873 874 static void target_if_register_acs_trigger_for_afc 875 (struct wlan_lmac_if_reg_tx_ops *reg_ops) 876 { 877 } 878 #endif 879 #else 880 static inline void 881 target_if_register_master_ext_handler(struct wlan_lmac_if_reg_tx_ops *reg_ops) 882 { 883 } 884 885 static void target_if_register_afc_event_handler( 886 struct wlan_lmac_if_reg_tx_ops *reg_ops) 887 { 888 } 889 890 static void target_if_register_acs_trigger_for_afc 891 (struct wlan_lmac_if_reg_tx_ops *reg_ops) 892 { 893 } 894 #endif 895 896 static QDF_STATUS 897 tgt_if_regulatory_set_tpc_power(struct wlan_objmgr_psoc *psoc, 898 uint8_t vdev_id, 899 struct reg_tpc_power_info *param) 900 { 901 wmi_unified_t wmi_handle; 902 uint8_t pdev_id; 903 struct wlan_objmgr_pdev *pdev; 904 QDF_STATUS status; 905 906 pdev_id = wlan_get_pdev_id_from_vdev_id(psoc, 907 vdev_id, WLAN_REGULATORY_NB_ID); 908 909 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, 910 WLAN_REGULATORY_NB_ID); 911 912 wmi_handle = get_wmi_unified_hdl_from_pdev(pdev); 913 914 if (!wmi_handle) { 915 status = QDF_STATUS_E_FAILURE; 916 goto free_pdevref; 917 } 918 status = wmi_unified_send_set_tpc_power_cmd(wmi_handle, vdev_id, param); 919 if (QDF_IS_STATUS_ERROR(status)) 920 target_if_err("send tpc power cmd failed, status: %d", status); 921 922 free_pdevref: 923 wlan_objmgr_pdev_release_ref(pdev, WLAN_REGULATORY_NB_ID); 924 925 return status; 926 } 927 928 #ifdef CONFIG_AFC_SUPPORT 929 /** 930 * tgt_if_regulatory_send_afc_cmd() - Send AFC command to the FW 931 * 932 * @psoc: Pointer to psoc 933 * @pdev_id: Pdev id 934 * @param: Pointer to hold AFC indication. 935 * 936 * Return: QDF_STATUS_SUCCESS if WMI_AFC_CMD is sent, else QDF_STATUS_E_FAILURE 937 */ 938 static QDF_STATUS 939 tgt_if_regulatory_send_afc_cmd(struct wlan_objmgr_psoc *psoc, 940 uint8_t pdev_id, 941 struct reg_afc_resp_rx_ind_info *param) 942 { 943 struct wlan_objmgr_pdev *pdev; 944 wmi_unified_t wmi_handle; 945 QDF_STATUS status; 946 947 pdev = wlan_objmgr_get_pdev_by_id(psoc, pdev_id, 948 WLAN_REGULATORY_NB_ID); 949 950 wmi_handle = get_wmi_unified_hdl_from_pdev(pdev); 951 952 if (!wmi_handle) { 953 status = QDF_STATUS_E_FAILURE; 954 goto free_pdevref; 955 } 956 957 status = wmi_unified_send_afc_cmd(wmi_handle, pdev_id, param); 958 959 if (QDF_IS_STATUS_ERROR(status)) 960 target_if_err("send afc cmd failed, status: %d", status); 961 962 free_pdevref: 963 wlan_objmgr_pdev_release_ref(pdev, WLAN_REGULATORY_NB_ID); 964 965 return status; 966 } 967 968 static void 969 tgt_if_register_afc_callback(struct wlan_lmac_if_reg_tx_ops *reg_ops) 970 { 971 reg_ops->send_afc_ind = tgt_if_regulatory_send_afc_cmd; 972 reg_ops->reg_get_min_psd = NULL; 973 reg_ops->trigger_update_channel_list = NULL; 974 } 975 #else 976 static void 977 tgt_if_register_afc_callback(struct wlan_lmac_if_reg_tx_ops *reg_ops) 978 { 979 } 980 #endif 981 982 /** 983 * tgt_if_regulatory_is_ext_tpc_supported() - Check if FW supports new 984 * WMI command for TPC power 985 * 986 * @psoc: Pointer to psoc 987 * 988 * Return: true if FW supports new WMI command for TPC, else false 989 */ 990 static bool 991 tgt_if_regulatory_is_ext_tpc_supported(struct wlan_objmgr_psoc *psoc) 992 { 993 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 994 995 if (!wmi_handle) 996 return false; 997 998 return wmi_service_enabled(wmi_handle, 999 wmi_service_ext_tpc_reg_support); 1000 } 1001 1002 QDF_STATUS target_if_regulatory_set_ext_tpc(struct wlan_objmgr_psoc *psoc) 1003 { 1004 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1005 1006 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1007 if (!reg_rx_ops) { 1008 target_if_err("reg_rx_ops is NULL"); 1009 return QDF_STATUS_E_FAILURE; 1010 } 1011 1012 if (reg_rx_ops->reg_set_ext_tpc_supported) 1013 reg_rx_ops->reg_set_ext_tpc_supported( 1014 psoc, 1015 tgt_if_regulatory_is_ext_tpc_supported(psoc)); 1016 1017 return QDF_STATUS_SUCCESS; 1018 } 1019 1020 #if defined(CONFIG_BAND_6GHZ) && defined(CONFIG_AFC_SUPPORT) 1021 void tgt_if_set_reg_afc_configure(struct target_psoc_info *tgt_hdl, 1022 struct wlan_objmgr_psoc *psoc) 1023 { 1024 struct tgt_info *info; 1025 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1026 1027 if (!wmi_handle || !tgt_hdl) 1028 return; 1029 1030 if (!wmi_service_enabled(wmi_handle, wmi_service_afc_support)) { 1031 target_if_err("service afc support not enable"); 1032 return; 1033 } 1034 1035 info = (&tgt_hdl->info); 1036 1037 info->wlan_res_cfg.is_6ghz_sp_pwrmode_supp_enabled = 1038 ucfg_reg_get_enable_6ghz_sp_mode_support(psoc); 1039 info->wlan_res_cfg.afc_timer_check_disable = 1040 ucfg_reg_get_afc_disable_timer_check(psoc); 1041 info->wlan_res_cfg.afc_req_id_check_disable = 1042 ucfg_reg_get_afc_disable_request_id_check(psoc); 1043 } 1044 #endif 1045 1046 #if defined(CONFIG_BAND_6GHZ) 1047 /** 1048 * tgt_if_regulatory_is_lower_6g_edge_ch_supp() - Check if lower 6 GHz 1049 * edge channel (5935 MHz) is supported 1050 * @psoc: Pointer to psoc 1051 * 1052 * Return: true if channel is supported, else false 1053 */ 1054 static bool 1055 tgt_if_regulatory_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc) 1056 { 1057 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1058 1059 if (!wmi_handle) 1060 return false; 1061 1062 return wmi_service_enabled(wmi_handle, 1063 wmi_service_lower_6g_edge_ch_supp); 1064 } 1065 1066 /** 1067 * tgt_if_regulatory_is_upper_6g_edge_ch_disabled() - Check if upper 1068 * 6 GHz edge channel (7115 MHz) is disabled 1069 * @psoc: Pointer to psoc 1070 * 1071 * Return: true if channel is disabled, else false 1072 */ 1073 static bool 1074 tgt_if_regulatory_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc *psoc) 1075 { 1076 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1077 1078 if (!wmi_handle) 1079 return false; 1080 1081 return wmi_service_enabled(wmi_handle, 1082 wmi_service_disable_upper_6g_edge_ch_supp); 1083 } 1084 1085 QDF_STATUS 1086 target_if_reg_set_lower_6g_edge_ch_info(struct wlan_objmgr_psoc *psoc) 1087 { 1088 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1089 1090 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1091 if (!reg_rx_ops) { 1092 target_if_err("reg_rx_ops is NULL"); 1093 return QDF_STATUS_E_FAILURE; 1094 } 1095 1096 if (reg_rx_ops->reg_set_lower_6g_edge_ch_supp) 1097 reg_rx_ops->reg_set_lower_6g_edge_ch_supp( 1098 psoc, 1099 tgt_if_regulatory_is_lower_6g_edge_ch_supp(psoc)); 1100 1101 return QDF_STATUS_SUCCESS; 1102 } 1103 1104 QDF_STATUS 1105 target_if_reg_set_disable_upper_6g_edge_ch_info(struct wlan_objmgr_psoc *psoc) 1106 { 1107 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1108 1109 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1110 if (!reg_rx_ops) { 1111 target_if_err("reg_rx_ops is NULL"); 1112 return QDF_STATUS_E_FAILURE; 1113 } 1114 1115 if (reg_rx_ops->reg_set_disable_upper_6g_edge_ch_supp) 1116 reg_rx_ops->reg_set_disable_upper_6g_edge_ch_supp( 1117 psoc, 1118 tgt_if_regulatory_is_upper_6g_edge_ch_disabled(psoc)); 1119 1120 return QDF_STATUS_SUCCESS; 1121 } 1122 #else 1123 static inline bool 1124 tgt_if_regulatory_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc) 1125 { 1126 return false; 1127 } 1128 1129 static inline bool 1130 tgt_if_regulatory_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc *psoc) 1131 { 1132 return false; 1133 } 1134 #endif 1135 1136 #if defined(CONFIG_AFC_SUPPORT) 1137 QDF_STATUS 1138 target_if_reg_set_afc_dev_type(struct wlan_objmgr_psoc *psoc, 1139 struct target_psoc_info *tgt_hdl) 1140 { 1141 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1142 struct tgt_info *info; 1143 1144 if (!tgt_hdl) { 1145 target_if_err("target_psoc_info is null"); 1146 return QDF_STATUS_E_FAILURE; 1147 } 1148 1149 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1150 if (!reg_rx_ops) { 1151 target_if_err("reg_rx_ops is NULL"); 1152 return QDF_STATUS_E_FAILURE; 1153 } 1154 1155 info = (&tgt_hdl->info); 1156 1157 if (reg_rx_ops->reg_set_afc_dev_type) 1158 reg_rx_ops->reg_set_afc_dev_type( 1159 psoc, 1160 info->service_ext2_param.afc_dev_type); 1161 1162 return QDF_STATUS_SUCCESS; 1163 } 1164 1165 QDF_STATUS 1166 target_if_reg_get_afc_dev_type(struct wlan_objmgr_psoc *psoc, 1167 enum reg_afc_dev_deploy_type *reg_afc_dev_type) 1168 { 1169 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1170 1171 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1172 if (!reg_rx_ops) { 1173 target_if_err("reg_rx_ops is NULL"); 1174 return QDF_STATUS_E_FAILURE; 1175 } 1176 1177 if (reg_rx_ops->reg_get_afc_dev_type) 1178 reg_rx_ops->reg_get_afc_dev_type( 1179 psoc, 1180 reg_afc_dev_type); 1181 1182 return QDF_STATUS_SUCCESS; 1183 } 1184 1185 /** 1186 * target_if_regulatory_is_eirp_preferred_support() - Check if FW prefers EIRP 1187 * support for TPC power command. 1188 * @psoc: Pointer to psoc 1189 * 1190 * Return: true if FW prefers EIRP format for TPC, else false 1191 */ 1192 static bool 1193 target_if_regulatory_is_eirp_preferred_support(struct wlan_objmgr_psoc *psoc) 1194 { 1195 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1196 1197 if (!wmi_handle) 1198 return false; 1199 1200 return wmi_service_enabled(wmi_handle, 1201 wmi_service_eirp_preferred_support); 1202 } 1203 1204 QDF_STATUS 1205 target_if_set_regulatory_eirp_preferred_support(struct wlan_objmgr_psoc *psoc) 1206 { 1207 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1208 1209 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1210 if (!reg_rx_ops) { 1211 target_if_err("reg_rx_ops is NULL"); 1212 return QDF_STATUS_E_FAILURE; 1213 } 1214 1215 if (reg_rx_ops->reg_set_eirp_preferred_support) 1216 reg_rx_ops->reg_set_eirp_preferred_support( 1217 psoc, 1218 target_if_regulatory_is_eirp_preferred_support(psoc)); 1219 1220 return QDF_STATUS_SUCCESS; 1221 } 1222 #endif 1223 1224 /** 1225 * tgt_if_reg_is_chip_11be_cap() - Finds out if the hardware is capable 1226 * of 11BE. The capability bit is read from mac_phy_cap populated by the 1227 * FW per pdev. 1228 * @psoc: Pointer to psoc 1229 * @phy_id: phy_id 1230 * 1231 * Return: True if chip is 11BE capable, false otherwise. 1232 */ 1233 #ifdef WLAN_FEATURE_11BE 1234 static bool tgt_if_reg_is_chip_11be_cap(struct wlan_objmgr_psoc *psoc, 1235 uint16_t phy_id) 1236 { 1237 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap_arr, *mac_phy_cap; 1238 struct target_psoc_info *tgt_hdl; 1239 uint8_t pdev_id; 1240 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 1241 1242 reg_tx_ops = target_if_regulatory_get_tx_ops(psoc); 1243 1244 if (!reg_tx_ops) { 1245 target_if_err("reg_tx_ops is NULL"); 1246 return false; 1247 } 1248 1249 if (reg_tx_ops->get_pdev_id_from_phy_id) 1250 reg_tx_ops->get_pdev_id_from_phy_id(psoc, phy_id, &pdev_id); 1251 else 1252 pdev_id = phy_id; 1253 1254 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1255 if (tgt_hdl) { 1256 mac_phy_cap_arr = target_psoc_get_mac_phy_cap(tgt_hdl); 1257 if (!mac_phy_cap_arr) 1258 return false; 1259 mac_phy_cap = &mac_phy_cap_arr[pdev_id]; 1260 if (mac_phy_cap && mac_phy_cap->supports_11be) 1261 return true; 1262 } 1263 return false; 1264 } 1265 #else 1266 static bool tgt_if_reg_is_chip_11be_cap(struct wlan_objmgr_psoc *psoc, 1267 uint16_t phy_id) 1268 { 1269 return false; 1270 } 1271 #endif 1272 1273 static int 1274 tgt_rate_to_power_complete_handler(ol_scn_t handle, uint8_t *event_buf, 1275 uint32_t len) 1276 { 1277 int ret_val = 0; 1278 struct wlan_objmgr_psoc *psoc; 1279 struct wlan_lmac_if_reg_rx_ops *reg_rx_ops; 1280 QDF_STATUS status; 1281 struct wmi_unified *wmi_handle; 1282 struct r2p_table_update_status_obj *update_status_obj = NULL; 1283 uint32_t pdev_id; 1284 1285 TARGET_IF_ENTER(); 1286 1287 psoc = target_if_get_psoc_from_scn_hdl(handle); 1288 if (!psoc) { 1289 target_if_err("psoc ptr is NULL"); 1290 ret_val = -EINVAL; 1291 goto clean; 1292 } 1293 1294 reg_rx_ops = target_if_regulatory_get_rx_ops(psoc); 1295 if (!reg_rx_ops) { 1296 target_if_err("reg_rx_ops is NULL"); 1297 ret_val = -EINVAL; 1298 goto clean; 1299 } 1300 1301 if (!reg_rx_ops->reg_r2p_table_update_response_handler) { 1302 target_if_err("reg_r2p_table_update_response_handler is NULL"); 1303 ret_val = -EINVAL; 1304 goto clean; 1305 } 1306 1307 wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1308 if (!wmi_handle) { 1309 target_if_err("invalid wmi handle"); 1310 ret_val = -EINVAL; 1311 goto clean; 1312 } 1313 1314 update_status_obj = qdf_mem_malloc(sizeof(*update_status_obj)); 1315 if (!update_status_obj) { 1316 ret_val = -ENOMEM; 1317 goto clean; 1318 } 1319 1320 status = wmi_extract_tgtr2p_table_event(wmi_handle, event_buf, 1321 update_status_obj, len); 1322 if (!QDF_IS_STATUS_SUCCESS(status)) { 1323 target_if_err("Extraction of r2p update response event failed"); 1324 ret_val = -EFAULT; 1325 goto clean; 1326 } 1327 1328 pdev_id = update_status_obj->pdev_id; 1329 status = reg_rx_ops->reg_r2p_table_update_response_handler(psoc, 1330 pdev_id); 1331 if (!QDF_IS_STATUS_SUCCESS(status)) { 1332 target_if_err("Failed to process r2p update response"); 1333 ret_val = -EFAULT; 1334 goto clean; 1335 } 1336 clean: 1337 qdf_mem_free(update_status_obj); 1338 TARGET_IF_EXIT(); 1339 1340 return ret_val; 1341 } 1342 1343 /** 1344 * tgt_if_regulatory_register_rate2power_table_update_handler() - Register 1345 * rate2power table update handler 1346 * @psoc: Pointer to psoc 1347 * @arg: Pointer to argument list 1348 * 1349 * Return: QDF_STATUS 1350 */ 1351 static QDF_STATUS 1352 tgt_if_regulatory_register_rate2power_table_update_handler( 1353 struct wlan_objmgr_psoc *psoc, 1354 void *arg) 1355 { 1356 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1357 1358 if (!wmi_handle) 1359 return QDF_STATUS_E_FAILURE; 1360 1361 return wmi_unified_register_event_handler( 1362 wmi_handle, wmi_pdev_set_tgtr2p_table_eventid, 1363 tgt_rate_to_power_complete_handler, WMI_RX_WORK_CTX); 1364 } 1365 1366 /** 1367 * tgt_if_regulatory_unregister_rate2power_table_update_handler() - Unregister 1368 * rate2power table update handler 1369 * @psoc: Pointer to psoc 1370 * @arg: Pointer to argument list 1371 * 1372 * Return: QDF_STATUS 1373 */ 1374 static QDF_STATUS 1375 tgt_if_regulatory_unregister_rate2power_table_update_handler( 1376 struct wlan_objmgr_psoc *psoc, 1377 void *arg) 1378 { 1379 wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 1380 1381 if (!wmi_handle) 1382 return QDF_STATUS_E_FAILURE; 1383 1384 return wmi_unified_unregister_event_handler( 1385 wmi_handle, wmi_pdev_set_tgtr2p_table_eventid); 1386 } 1387 1388 QDF_STATUS target_if_register_regulatory_tx_ops( 1389 struct wlan_lmac_if_tx_ops *tx_ops) 1390 { 1391 struct wlan_lmac_if_reg_tx_ops *reg_ops = &tx_ops->reg_ops; 1392 1393 reg_ops->register_master_handler = 1394 tgt_if_regulatory_register_master_list_handler; 1395 1396 reg_ops->unregister_master_handler = 1397 tgt_if_regulatory_unregister_master_list_handler; 1398 1399 target_if_register_master_ext_handler(reg_ops); 1400 1401 target_if_register_afc_event_handler(reg_ops); 1402 1403 reg_ops->set_country_code = tgt_if_regulatory_set_country_code; 1404 1405 reg_ops->fill_umac_legacy_chanlist = NULL; 1406 1407 reg_ops->set_wait_for_init_cc_response_event = NULL; 1408 1409 target_if_register_acs_trigger_for_afc(reg_ops); 1410 1411 reg_ops->register_11d_new_cc_handler = 1412 tgt_if_regulatory_register_11d_new_cc_handler; 1413 1414 reg_ops->unregister_11d_new_cc_handler = 1415 tgt_if_regulatory_unregister_11d_new_cc_handler; 1416 1417 reg_ops->start_11d_scan = tgt_if_regulatory_start_11d_scan; 1418 1419 reg_ops->stop_11d_scan = tgt_if_regulatory_stop_11d_scan; 1420 1421 reg_ops->is_there_serv_ready_extn = 1422 tgt_if_regulatory_is_there_serv_ready_extn; 1423 1424 reg_ops->set_user_country_code = 1425 tgt_if_regulatory_set_user_country_code; 1426 1427 reg_ops->register_ch_avoid_event_handler = 1428 tgt_if_regulatory_register_ch_avoid_event_handler; 1429 1430 reg_ops->unregister_ch_avoid_event_handler = 1431 tgt_if_regulatory_unregister_ch_avoid_event_handler; 1432 1433 reg_ops->send_ctl_info = tgt_if_regulatory_send_ctl_info; 1434 1435 reg_ops->get_phy_id_from_pdev_id = 1436 tgt_if_regulatory_get_phy_id_from_pdev_id; 1437 1438 reg_ops->get_pdev_id_from_phy_id = 1439 tgt_if_regulatory_get_pdev_id_from_phy_id; 1440 1441 reg_ops->set_tpc_power = tgt_if_regulatory_set_tpc_power; 1442 1443 reg_ops->get_opclass_tbl_idx = NULL; 1444 1445 tgt_if_register_afc_callback(reg_ops); 1446 1447 reg_ops->is_chip_11be = tgt_if_reg_is_chip_11be_cap; 1448 1449 reg_ops->register_rate2power_table_update_event_handler = 1450 tgt_if_regulatory_register_rate2power_table_update_handler; 1451 1452 reg_ops->unregister_rate2power_table_update_event_handler = 1453 tgt_if_regulatory_unregister_rate2power_table_update_handler; 1454 1455 reg_ops->end_r2p_table_update_wait = NULL; 1456 1457 reg_ops->is_80p80_supported = NULL; 1458 1459 reg_ops->is_freq_80p80_supported = NULL; 1460 1461 return QDF_STATUS_SUCCESS; 1462 } 1463