1 /* 2 * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. 3 * 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /** 21 * DOC: This file has the DFS dispatcher API implementation which is exposed 22 * to outside of DFS component. 23 */ 24 #include <wlan_objmgr_pdev_obj.h> 25 #include "wlan_dfs_tgt_api.h" 26 #include "wlan_dfs_utils_api.h" 27 #include "wlan_dfs_init_deinit_api.h" 28 #include "wlan_lmac_if_def.h" 29 #include "wlan_lmac_if_api.h" 30 #include "wlan_dfs_mlme_api.h" 31 #include "../../core/src/dfs.h" 32 #include "../../core/src/dfs_zero_cac.h" 33 #include "../../core/src/dfs_process_radar_found_ind.h" 34 #include <qdf_module.h> 35 #include "../../core/src/dfs_partial_offload_radar.h" 36 #ifdef MOBILE_DFS_SUPPORT 37 #include "wlan_mlme_ucfg_api.h" 38 #endif 39 40 struct wlan_lmac_if_dfs_tx_ops * 41 wlan_psoc_get_dfs_txops(struct wlan_objmgr_psoc *psoc) 42 { 43 struct wlan_lmac_if_tx_ops *tx_ops; 44 45 tx_ops = wlan_psoc_get_lmac_if_txops(psoc); 46 if (!tx_ops) { 47 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "tx_ops is null"); 48 return NULL; 49 } 50 51 return &tx_ops->dfs_tx_ops; 52 } 53 54 qdf_export_symbol(wlan_psoc_get_dfs_txops); 55 56 bool tgt_dfs_is_5ghz_supported_in_pdev(struct wlan_objmgr_pdev *pdev) 57 { 58 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 59 struct wlan_objmgr_psoc *psoc; 60 bool is_5ghz = false; 61 QDF_STATUS status; 62 bool is_6ghz_only_pdev; 63 qdf_freq_t low_5g = 0; 64 qdf_freq_t high_5g = 0; 65 66 wlan_reg_get_freq_range(pdev, NULL, NULL, &low_5g, &high_5g); 67 is_6ghz_only_pdev = wlan_reg_is_range_only6g(low_5g, high_5g); 68 69 if (is_6ghz_only_pdev) 70 return false; 71 72 psoc = wlan_pdev_get_psoc(pdev); 73 if (!psoc) { 74 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 75 return false; 76 } 77 78 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 79 if (!(dfs_tx_ops && dfs_tx_ops->dfs_is_pdev_5ghz)) { 80 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "dfs_tx_ops is null"); 81 return false; 82 } 83 84 status = dfs_tx_ops->dfs_is_pdev_5ghz(pdev, &is_5ghz); 85 if (QDF_IS_STATUS_ERROR(status)) { 86 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "Failed to get is_5ghz value"); 87 return false; 88 } 89 90 return is_5ghz; 91 } 92 93 #ifdef CONFIG_CHAN_FREQ_API 94 QDF_STATUS 95 tgt_dfs_set_current_channel_for_freq(struct wlan_objmgr_pdev *pdev, 96 uint16_t dfs_chan_freq, 97 uint64_t dfs_chan_flags, 98 uint16_t dfs_chan_flagext, 99 uint8_t dfs_chan_ieee, 100 uint8_t dfs_chan_vhtop_freq_seg1, 101 uint8_t dfs_chan_vhtop_freq_seg2, 102 uint16_t dfs_chan_mhz_freq_seg1, 103 uint16_t dfs_chan_mhz_freq_seg2, 104 bool *is_channel_updated) 105 { 106 struct wlan_dfs *dfs; 107 108 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 109 return QDF_STATUS_SUCCESS; 110 111 dfs = wlan_pdev_get_dfs_obj(pdev); 112 if (!dfs) { 113 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 114 return QDF_STATUS_E_FAILURE; 115 } 116 117 dfs_set_current_channel_for_freq(dfs, 118 dfs_chan_freq, 119 dfs_chan_flags, 120 dfs_chan_flagext, 121 dfs_chan_ieee, 122 dfs_chan_vhtop_freq_seg1, 123 dfs_chan_vhtop_freq_seg2, 124 dfs_chan_mhz_freq_seg1, 125 dfs_chan_mhz_freq_seg2, 126 is_channel_updated); 127 128 return QDF_STATUS_SUCCESS; 129 } 130 131 qdf_export_symbol(tgt_dfs_set_current_channel_for_freq); 132 #endif 133 134 QDF_STATUS tgt_dfs_radar_enable(struct wlan_objmgr_pdev *pdev, 135 int no_cac, uint32_t opmode, bool enable) 136 { 137 struct wlan_dfs *dfs; 138 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 139 struct wlan_objmgr_psoc *psoc; 140 QDF_STATUS status; 141 142 dfs = wlan_pdev_get_dfs_obj(pdev); 143 if (!dfs) { 144 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 145 return QDF_STATUS_E_FAILURE; 146 } 147 148 if (!dfs->dfs_is_offload_enabled) { 149 if (enable) { 150 dfs_radar_enable(dfs, no_cac, opmode); 151 return QDF_STATUS_SUCCESS; 152 } else { 153 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 154 "Disabling dfs not allowed for non-offload chips"); 155 return QDF_STATUS_E_FAILURE; 156 } 157 } 158 159 psoc = wlan_pdev_get_psoc(pdev); 160 if (!psoc) { 161 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 162 return QDF_STATUS_E_FAILURE; 163 } 164 165 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 166 if (!dfs_tx_ops) { 167 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs_tx_ops is null"); 168 return QDF_STATUS_E_FAILURE; 169 } 170 171 status = dfs_tx_ops->dfs_send_offload_enable_cmd(pdev, enable); 172 if (QDF_IS_STATUS_ERROR(status)) 173 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 174 "Failed to enable dfs offload, pdev_id: %d", 175 wlan_objmgr_pdev_get_pdev_id(pdev)); 176 177 return status; 178 } 179 qdf_export_symbol(tgt_dfs_radar_enable); 180 181 void tgt_dfs_is_radar_enabled(struct wlan_objmgr_pdev *pdev, int *ignore_dfs) 182 { 183 struct wlan_dfs *dfs; 184 185 dfs = wlan_pdev_get_dfs_obj(pdev); 186 if (!dfs) { 187 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 188 return; 189 } 190 191 dfs_is_radar_enabled(dfs, ignore_dfs); 192 } 193 194 qdf_export_symbol(tgt_dfs_is_radar_enabled); 195 196 QDF_STATUS tgt_dfs_process_phyerr(struct wlan_objmgr_pdev *pdev, 197 void *buf, 198 uint16_t datalen, 199 uint8_t r_rssi, 200 uint8_t r_ext_rssi, 201 uint32_t r_rs_tstamp, 202 uint64_t r_fulltsf) 203 { 204 struct wlan_dfs *dfs; 205 206 dfs = wlan_pdev_get_dfs_obj(pdev); 207 if (!dfs) { 208 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 209 return QDF_STATUS_E_FAILURE; 210 } 211 212 if (!dfs->dfs_is_offload_enabled) 213 dfs_process_phyerr(dfs, buf, datalen, r_rssi, 214 r_ext_rssi, r_rs_tstamp, r_fulltsf); 215 else 216 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 217 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 218 wlan_objmgr_pdev_get_pdev_id(pdev)); 219 220 return QDF_STATUS_SUCCESS; 221 } 222 qdf_export_symbol(tgt_dfs_process_phyerr); 223 224 #ifdef MOBILE_DFS_SUPPORT 225 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 226 struct radar_event_info 227 *wlan_radar_event) 228 { 229 struct wlan_dfs *dfs; 230 231 dfs = wlan_pdev_get_dfs_obj(pdev); 232 if (!dfs) { 233 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 234 return QDF_STATUS_E_FAILURE; 235 } 236 if (!dfs->dfs_is_offload_enabled) 237 dfs_process_phyerr_filter_offload(dfs, wlan_radar_event); 238 else 239 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 240 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 241 wlan_objmgr_pdev_get_pdev_id(pdev)); 242 243 return QDF_STATUS_SUCCESS; 244 } 245 qdf_export_symbol(tgt_dfs_process_phyerr_filter_offload); 246 247 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 248 bool *is_phyerr_filter_offload) 249 { 250 struct dfs_soc_priv_obj *soc_obj; 251 252 if (!psoc) { 253 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 254 return QDF_STATUS_E_FAILURE; 255 } 256 257 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 258 WLAN_UMAC_COMP_DFS); 259 if (!soc_obj) { 260 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 261 "Failed to get dfs psoc component"); 262 return QDF_STATUS_E_FAILURE; 263 } 264 265 *is_phyerr_filter_offload = soc_obj->dfs_is_phyerr_filter_offload; 266 267 return QDF_STATUS_SUCCESS; 268 } 269 qdf_export_symbol(tgt_dfs_is_phyerr_filter_offload); 270 #else 271 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 272 struct radar_event_info 273 *wlan_radar_event) 274 { 275 return QDF_STATUS_SUCCESS; 276 } 277 278 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 279 bool *is_phyerr_filter_offload) 280 { 281 return QDF_STATUS_SUCCESS; 282 } 283 #endif 284 285 QDF_STATUS tgt_dfs_is_precac_timer_running(struct wlan_objmgr_pdev *pdev, 286 bool *is_precac_timer_running) 287 { 288 struct wlan_dfs *dfs; 289 290 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 291 return QDF_STATUS_SUCCESS; 292 293 dfs = wlan_pdev_get_dfs_obj(pdev); 294 if (!dfs) { 295 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 296 return QDF_STATUS_E_FAILURE; 297 } 298 299 *is_precac_timer_running = dfs_is_precac_timer_running(dfs); 300 301 return QDF_STATUS_SUCCESS; 302 } 303 qdf_export_symbol(tgt_dfs_is_precac_timer_running); 304 305 QDF_STATUS tgt_dfs_get_radars(struct wlan_objmgr_pdev *pdev) 306 { 307 struct wlan_dfs *dfs; 308 309 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 310 return QDF_STATUS_SUCCESS; 311 312 dfs = wlan_pdev_get_dfs_obj(pdev); 313 if (!dfs) { 314 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 315 return QDF_STATUS_E_FAILURE; 316 } 317 318 if (!dfs->dfs_is_offload_enabled) 319 dfs_get_radars(dfs); 320 321 return QDF_STATUS_SUCCESS; 322 } 323 qdf_export_symbol(tgt_dfs_get_radars); 324 325 QDF_STATUS tgt_dfs_destroy_object(struct wlan_objmgr_pdev *pdev) 326 { 327 struct wlan_dfs *dfs; 328 329 dfs = wlan_pdev_get_dfs_obj(pdev); 330 if (!dfs) { 331 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 332 return QDF_STATUS_E_FAILURE; 333 } 334 335 dfs_destroy_object(dfs); 336 337 return QDF_STATUS_SUCCESS; 338 } 339 qdf_export_symbol(tgt_dfs_destroy_object); 340 341 #ifdef MOBILE_DFS_SUPPORT 342 QDF_STATUS tgt_dfs_set_tx_leakage_threshold(struct wlan_objmgr_pdev *pdev) 343 { 344 struct wlan_dfs *dfs; 345 uint32_t tx_leakage_threshold = 0; 346 struct wlan_objmgr_psoc *psoc; 347 348 psoc = wlan_pdev_get_psoc(pdev); 349 if (!psoc) { 350 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 351 return QDF_STATUS_E_FAILURE; 352 } 353 354 dfs = wlan_pdev_get_dfs_obj(pdev); 355 if (!dfs) { 356 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 357 return QDF_STATUS_E_FAILURE; 358 } 359 ucfg_mlme_get_sap_tx_leakage_threshold(psoc, 360 &tx_leakage_threshold); 361 362 dfs->tx_leakage_threshold = tx_leakage_threshold; 363 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 364 "dfs tx_leakage_threshold = %d", dfs->tx_leakage_threshold); 365 366 return QDF_STATUS_SUCCESS; 367 } 368 qdf_export_symbol(tgt_dfs_set_tx_leakage_threshold); 369 #endif 370 371 QDF_STATUS tgt_dfs_control(struct wlan_objmgr_pdev *pdev, 372 u_int id, 373 void *indata, 374 uint32_t insize, 375 void *outdata, 376 uint32_t *outsize, 377 int *error) 378 { 379 struct wlan_dfs *dfs; 380 381 dfs = wlan_pdev_get_dfs_obj(pdev); 382 if (!dfs) { 383 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 384 return QDF_STATUS_E_FAILURE; 385 } 386 387 *error = dfs_control(dfs, id, indata, insize, outdata, outsize); 388 389 return QDF_STATUS_SUCCESS; 390 } 391 qdf_export_symbol(tgt_dfs_control); 392 393 #ifdef QCA_SUPPORT_AGILE_DFS 394 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 395 { 396 struct wlan_dfs *dfs; 397 398 dfs = wlan_pdev_get_dfs_obj(pdev); 399 if (!dfs) { 400 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 401 return QDF_STATUS_E_FAILURE; 402 } 403 404 dfs_agile_precac_start(dfs); 405 406 return QDF_STATUS_SUCCESS; 407 } 408 #else 409 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 410 { 411 return QDF_STATUS_SUCCESS; 412 } 413 #endif 414 qdf_export_symbol(tgt_dfs_agile_precac_start); 415 416 #ifdef QCA_SUPPORT_AGILE_DFS 417 #ifdef CONFIG_CHAN_FREQ_API 418 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 419 int agile_precac_state) 420 { 421 struct wlan_dfs *dfs; 422 struct dfs_soc_priv_obj *dfs_soc; 423 bool is_precac_running_on_given_pdev = false; 424 int i; 425 426 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 427 return QDF_STATUS_SUCCESS; 428 429 dfs = wlan_pdev_get_dfs_obj(pdev); 430 if (!dfs) { 431 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 432 return QDF_STATUS_E_FAILURE; 433 } 434 435 dfs_soc = dfs->dfs_soc_obj; 436 for (i = 0; i < dfs_soc->num_dfs_privs; i++) { 437 if (dfs_soc->dfs_priv[i].dfs == dfs) { 438 /* Set the pdev state to given value. */ 439 dfs_soc->dfs_priv[i].agile_precac_active = 440 agile_precac_state; 441 /* If the pdev state is changed to inactive, 442 * reset the agile channel. 443 */ 444 if (!agile_precac_state) 445 dfs->dfs_agile_precac_freq_mhz = 0; 446 if (dfs_soc->cur_agile_dfs_index == i) 447 is_precac_running_on_given_pdev = true; 448 } 449 } 450 451 /* If preCAC is running on this pdev and the agile_precac_state 452 * is set to false, set the global state in dfs_soc_obj to false. 453 * If this global state is not set to false, then preCAC will not be 454 * started the next time this pdev becomes active. 455 */ 456 if (is_precac_running_on_given_pdev && !agile_precac_state) 457 dfs_soc->precac_state_started = PRECAC_NOT_STARTED; 458 459 return QDF_STATUS_SUCCESS; 460 } 461 #else 462 #endif 463 464 #else 465 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 466 int agile_precac_state) 467 { 468 return QDF_STATUS_SUCCESS; 469 } 470 #endif 471 qdf_export_symbol(tgt_dfs_set_agile_precac_state); 472 473 #ifdef QCA_SUPPORT_AGILE_DFS 474 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 475 struct vdev_adfs_complete_status *adfs_status) 476 { 477 struct wlan_dfs *dfs; 478 QDF_STATUS status = QDF_STATUS_E_FAILURE; 479 480 if (!pdev) { 481 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 482 return status; 483 } 484 485 dfs = wlan_pdev_get_dfs_obj(pdev); 486 if (!dfs) { 487 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 488 return status; 489 } 490 491 dfs_process_ocac_complete(pdev, adfs_status->ocac_status, 492 adfs_status->center_freq1, 493 adfs_status->center_freq2, 494 adfs_status->chan_width); 495 496 return QDF_STATUS_SUCCESS; 497 } 498 #else 499 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 500 struct vdev_adfs_complete_status *adfs_status) 501 { 502 return QDF_STATUS_SUCCESS; 503 } 504 #endif 505 qdf_export_symbol(tgt_dfs_ocac_complete); 506 507 #ifdef CONFIG_CHAN_FREQ_API 508 QDF_STATUS 509 tgt_dfs_find_vht80_precac_chan_freq(struct wlan_objmgr_pdev *pdev, 510 uint32_t chan_mode, 511 uint16_t chan_freq_seg1_mhz, 512 uint32_t *cfreq1, 513 uint32_t *cfreq2, 514 uint32_t *phy_mode, 515 bool *dfs_set_cfreq2, 516 bool *set_agile) 517 { 518 struct wlan_dfs *dfs; 519 520 dfs = wlan_pdev_get_dfs_obj(pdev); 521 if (!dfs) { 522 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 523 return QDF_STATUS_E_FAILURE; 524 } 525 526 dfs_find_vht80_chan_for_precac_for_freq(dfs, 527 chan_mode, 528 chan_freq_seg1_mhz, 529 cfreq1, 530 cfreq2, 531 phy_mode, 532 dfs_set_cfreq2, 533 set_agile); 534 535 return QDF_STATUS_SUCCESS; 536 } 537 538 qdf_export_symbol(tgt_dfs_find_vht80_precac_chan_freq); 539 #endif 540 541 QDF_STATUS tgt_dfs_process_radar_ind(struct wlan_objmgr_pdev *pdev, 542 struct radar_found_info *radar_found) 543 { 544 struct wlan_dfs *dfs; 545 QDF_STATUS status = QDF_STATUS_E_FAILURE; 546 547 if (!pdev) { 548 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 549 return status; 550 } 551 552 dfs = wlan_pdev_get_dfs_obj(pdev); 553 if (!dfs) { 554 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 555 return status; 556 } 557 558 dfs_translate_radar_params(dfs, radar_found); 559 status = dfs_process_radar_ind(dfs, radar_found); 560 dfs_inc_num_radar(dfs); 561 562 return status; 563 } 564 qdf_export_symbol(tgt_dfs_process_radar_ind); 565 566 #ifndef MOBILE_DFS_SUPPORT 567 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 568 { 569 return QDF_STATUS_SUCCESS; 570 } 571 #else 572 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 573 { 574 dfs_mlme_proc_cac(pdev, vdev_id); 575 576 return QDF_STATUS_SUCCESS; 577 } 578 #endif 579 qdf_export_symbol(tgt_dfs_cac_complete); 580 581 QDF_STATUS tgt_dfs_reg_ev_handler(struct wlan_objmgr_psoc *psoc) 582 { 583 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 584 585 if (!psoc) { 586 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 587 return QDF_STATUS_E_FAILURE; 588 } 589 590 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 591 if (!dfs_tx_ops) { 592 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null dfs_tx_ops"); 593 return QDF_STATUS_E_FAILURE; 594 } 595 596 if (dfs_tx_ops->dfs_reg_ev_handler) 597 return dfs_tx_ops->dfs_reg_ev_handler(psoc); 598 599 return QDF_STATUS_E_FAILURE; 600 } 601 qdf_export_symbol(tgt_dfs_reg_ev_handler); 602 603 QDF_STATUS tgt_dfs_stop(struct wlan_objmgr_pdev *pdev) 604 { 605 struct wlan_dfs *dfs; 606 607 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 608 return QDF_STATUS_SUCCESS; 609 610 dfs = wlan_pdev_get_dfs_obj(pdev); 611 if (!dfs) { 612 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 613 return QDF_STATUS_E_FAILURE; 614 } 615 616 dfs_stop(dfs); 617 618 return QDF_STATUS_SUCCESS; 619 } 620 qdf_export_symbol(tgt_dfs_stop); 621 622 QDF_STATUS tgt_dfs_process_emulate_bang_radar_cmd(struct wlan_objmgr_pdev *pdev, 623 struct dfs_emulate_bang_radar_test_cmd *dfs_unit_test) 624 { 625 struct wlan_objmgr_psoc *psoc; 626 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 627 628 psoc = wlan_pdev_get_psoc(pdev); 629 if (!psoc) { 630 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 631 return QDF_STATUS_E_FAILURE; 632 } 633 634 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 635 if (dfs_tx_ops && dfs_tx_ops->dfs_process_emulate_bang_radar_cmd) 636 return dfs_tx_ops->dfs_process_emulate_bang_radar_cmd(pdev, 637 dfs_unit_test); 638 else 639 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 640 "dfs_tx_ops=%pK", dfs_tx_ops); 641 642 return QDF_STATUS_E_FAILURE; 643 } 644 qdf_export_symbol(tgt_dfs_process_emulate_bang_radar_cmd); 645 646 #ifdef MOBILE_DFS_SUPPORT 647 QDF_STATUS tgt_dfs_set_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev) 648 { 649 struct wlan_objmgr_psoc *psoc; 650 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 651 struct dfs_soc_priv_obj *soc_obj; 652 653 psoc = wlan_pdev_get_psoc(pdev); 654 if (!psoc) { 655 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 656 return QDF_STATUS_E_FAILURE; 657 } 658 659 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 660 WLAN_UMAC_COMP_DFS); 661 if (!soc_obj) { 662 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 663 "Failed to get dfs psoc component"); 664 return QDF_STATUS_E_FAILURE; 665 } 666 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 667 if (dfs_tx_ops && dfs_tx_ops->dfs_set_phyerr_filter_offload) 668 return dfs_tx_ops->dfs_set_phyerr_filter_offload(pdev, 669 soc_obj->dfs_is_phyerr_filter_offload); 670 else 671 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 672 "dfs_tx_ops=%pK", dfs_tx_ops); 673 674 return QDF_STATUS_E_FAILURE; 675 } 676 qdf_export_symbol(tgt_dfs_set_phyerr_filter_offload); 677 #endif 678 679 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 680 QDF_STATUS 681 tgt_dfs_send_avg_params_to_fw(struct wlan_objmgr_pdev *pdev, 682 struct dfs_radar_found_params *params) 683 { 684 struct wlan_objmgr_psoc *psoc; 685 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 686 struct wlan_dfs *dfs; 687 QDF_STATUS status = QDF_STATUS_E_FAILURE; 688 689 dfs = wlan_pdev_get_dfs_obj(pdev); 690 if (!dfs) { 691 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 692 return status; 693 } 694 695 psoc = wlan_pdev_get_psoc(pdev); 696 if (!psoc) { 697 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 698 return status; 699 } 700 701 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 702 "params->pri_min = %d; params->pri_max = %d; params->duration_min = %d; params->duration_max = %d; params->sidx_min = %d; params->sidx_max = %d", 703 params->pri_min, params->pri_max, 704 params->duration_min, params->duration_max, 705 params->sidx_min, params->sidx_max); 706 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 707 if (dfs_tx_ops && dfs_tx_ops->dfs_send_avg_radar_params_to_fw) 708 status = dfs_tx_ops->dfs_send_avg_radar_params_to_fw(pdev, 709 params); 710 711 if (QDF_IS_STATUS_SUCCESS(status)) { 712 dfs->dfs_average_params_sent = 1; 713 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, "Average radar parameters sent %d", 714 dfs->dfs_average_params_sent); 715 } 716 717 return status; 718 } 719 720 qdf_export_symbol(tgt_dfs_send_avg_params_to_fw); 721 722 QDF_STATUS tgt_dfs_action_on_status_from_fw(struct wlan_objmgr_pdev *pdev, 723 uint32_t *status) 724 { 725 struct wlan_dfs *dfs; 726 727 dfs = wlan_pdev_get_dfs_obj(pdev); 728 if (!dfs) { 729 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 730 return QDF_STATUS_E_FAILURE; 731 } 732 733 dfs_action_on_fw_radar_status_check(dfs, status); 734 735 return QDF_STATUS_SUCCESS; 736 } 737 738 qdf_export_symbol(tgt_dfs_action_on_status_from_fw); 739 740 QDF_STATUS tgt_dfs_reset_spoof_test(struct wlan_objmgr_pdev *pdev) 741 { 742 struct wlan_dfs *dfs; 743 744 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 745 return QDF_STATUS_SUCCESS; 746 747 dfs = wlan_pdev_get_dfs_obj(pdev); 748 if (!dfs) { 749 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 750 return QDF_STATUS_E_FAILURE; 751 } 752 753 dfs_reset_spoof_test(dfs); 754 755 return QDF_STATUS_SUCCESS; 756 } 757 758 qdf_export_symbol(tgt_dfs_reset_spoof_test); 759 #endif 760 761 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 762 QDF_STATUS tgt_dfs_send_usenol_pdev_param(struct wlan_objmgr_pdev *pdev, 763 bool usenol) 764 { 765 struct wlan_objmgr_psoc *psoc; 766 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 767 768 psoc = wlan_pdev_get_psoc(pdev); 769 if (!psoc) { 770 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 771 return QDF_STATUS_E_FAILURE; 772 } 773 774 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 775 if (dfs_tx_ops && dfs_tx_ops->dfs_send_usenol_pdev_param) 776 return dfs_tx_ops->dfs_send_usenol_pdev_param(pdev, usenol); 777 778 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 779 "dfs_tx_ops=%pK", dfs_tx_ops); 780 781 return QDF_STATUS_E_FAILURE; 782 } 783 784 qdf_export_symbol(tgt_dfs_send_usenol_pdev_param); 785 786 QDF_STATUS tgt_dfs_send_subchan_marking(struct wlan_objmgr_pdev *pdev, 787 bool subchanmark) 788 { 789 struct wlan_objmgr_psoc *psoc; 790 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 791 792 psoc = wlan_pdev_get_psoc(pdev); 793 if (!psoc) { 794 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 795 return QDF_STATUS_E_FAILURE; 796 } 797 798 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 799 if (!dfs_tx_ops) { 800 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 801 "dfs_tx_ops=%pK", dfs_tx_ops); 802 return QDF_STATUS_E_FAILURE; 803 } 804 805 if (dfs_tx_ops->dfs_send_subchan_marking_pdev_param) 806 return dfs_tx_ops->dfs_send_subchan_marking_pdev_param( 807 pdev, subchanmark); 808 809 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 810 "dfs_send_subchan_marking_pdev_param is null"); 811 812 return QDF_STATUS_E_FAILURE; 813 } 814 815 qdf_export_symbol(tgt_dfs_send_subchan_marking); 816 #endif 817 818 #ifdef QCA_SUPPORT_AGILE_DFS 819 void tgt_dfs_set_fw_adfs_support(struct wlan_objmgr_pdev *pdev, 820 bool fw_adfs_support_160, 821 bool fw_adfs_support_non_160) 822 { 823 struct wlan_dfs *dfs; 824 825 dfs = wlan_pdev_get_dfs_obj(pdev); 826 if (!dfs) { 827 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 828 return; 829 } 830 831 dfs_set_fw_adfs_support(dfs, 832 fw_adfs_support_160, 833 fw_adfs_support_non_160); 834 } 835 836 qdf_export_symbol(tgt_dfs_set_fw_adfs_support); 837 #endif 838