1 /* 2 * Copyright (c) 2016-2019 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 QCA_MCL_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 return &((psoc->soc_cb.tx_ops.dfs_tx_ops)); 44 } 45 46 bool tgt_dfs_is_pdev_5ghz(struct wlan_objmgr_pdev *pdev) 47 { 48 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 49 struct wlan_objmgr_psoc *psoc; 50 bool is_5ghz = false; 51 QDF_STATUS status; 52 53 psoc = wlan_pdev_get_psoc(pdev); 54 if (!psoc) { 55 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 56 return false; 57 } 58 59 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 60 if (!(dfs_tx_ops && dfs_tx_ops->dfs_is_pdev_5ghz)) { 61 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "dfs_tx_ops is null"); 62 return false; 63 } 64 65 status = dfs_tx_ops->dfs_is_pdev_5ghz(pdev, &is_5ghz); 66 if (QDF_IS_STATUS_ERROR(status)) { 67 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "Failed to get is_5ghz value"); 68 return false; 69 } 70 71 return is_5ghz; 72 } 73 74 QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev, 75 uint16_t dfs_ch_freq, 76 uint64_t dfs_ch_flags, 77 uint16_t dfs_ch_flagext, 78 uint8_t dfs_ch_ieee, 79 uint8_t dfs_ch_vhtop_ch_freq_seg1, 80 uint8_t dfs_ch_vhtop_ch_freq_seg2) 81 { 82 struct wlan_dfs *dfs; 83 84 if (!tgt_dfs_is_pdev_5ghz(pdev)) 85 return QDF_STATUS_SUCCESS; 86 87 dfs = wlan_pdev_get_dfs_obj(pdev); 88 if (!dfs) { 89 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 90 return QDF_STATUS_E_FAILURE; 91 } 92 93 dfs_set_current_channel(dfs, 94 dfs_ch_freq, 95 dfs_ch_flags, 96 dfs_ch_flagext, 97 dfs_ch_ieee, 98 dfs_ch_vhtop_ch_freq_seg1, 99 dfs_ch_vhtop_ch_freq_seg2); 100 101 return QDF_STATUS_SUCCESS; 102 } 103 qdf_export_symbol(tgt_dfs_set_current_channel); 104 105 QDF_STATUS tgt_dfs_radar_enable(struct wlan_objmgr_pdev *pdev, 106 int no_cac, uint32_t opmode) 107 { 108 struct wlan_dfs *dfs; 109 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 110 struct wlan_objmgr_psoc *psoc; 111 QDF_STATUS status; 112 113 dfs = wlan_pdev_get_dfs_obj(pdev); 114 if (!dfs) { 115 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 116 return QDF_STATUS_E_FAILURE; 117 } 118 119 if (!dfs->dfs_is_offload_enabled) { 120 dfs_radar_enable(dfs, no_cac, opmode); 121 return QDF_STATUS_SUCCESS; 122 } 123 124 psoc = wlan_pdev_get_psoc(pdev); 125 if (!psoc) { 126 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 127 return QDF_STATUS_E_FAILURE; 128 } 129 130 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 131 if (!dfs_tx_ops) { 132 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs_tx_ops is null"); 133 return QDF_STATUS_E_FAILURE; 134 } 135 136 status = dfs_tx_ops->dfs_send_offload_enable_cmd(pdev, true); 137 if (QDF_IS_STATUS_ERROR(status)) 138 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 139 "Failed to enable dfs offload, pdev_id: %d", 140 wlan_objmgr_pdev_get_pdev_id(pdev)); 141 142 return status; 143 } 144 qdf_export_symbol(tgt_dfs_radar_enable); 145 146 void tgt_dfs_is_radar_enabled(struct wlan_objmgr_pdev *pdev, int *ignore_dfs) 147 { 148 struct wlan_dfs *dfs; 149 150 dfs = wlan_pdev_get_dfs_obj(pdev); 151 if (!dfs) { 152 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 153 return; 154 } 155 156 dfs_is_radar_enabled(dfs, ignore_dfs); 157 } 158 159 qdf_export_symbol(tgt_dfs_is_radar_enabled); 160 161 QDF_STATUS tgt_dfs_process_phyerr(struct wlan_objmgr_pdev *pdev, 162 void *buf, 163 uint16_t datalen, 164 uint8_t r_rssi, 165 uint8_t r_ext_rssi, 166 uint32_t r_rs_tstamp, 167 uint64_t r_fulltsf) 168 { 169 struct wlan_dfs *dfs; 170 171 dfs = wlan_pdev_get_dfs_obj(pdev); 172 if (!dfs) { 173 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 174 return QDF_STATUS_E_FAILURE; 175 } 176 177 if (!dfs->dfs_is_offload_enabled) 178 dfs_process_phyerr(dfs, buf, datalen, r_rssi, 179 r_ext_rssi, r_rs_tstamp, r_fulltsf); 180 else 181 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 182 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 183 wlan_objmgr_pdev_get_pdev_id(pdev)); 184 185 return QDF_STATUS_SUCCESS; 186 } 187 qdf_export_symbol(tgt_dfs_process_phyerr); 188 189 #ifdef QCA_MCL_DFS_SUPPORT 190 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 191 struct radar_event_info 192 *wlan_radar_event) 193 { 194 struct wlan_dfs *dfs; 195 196 dfs = wlan_pdev_get_dfs_obj(pdev); 197 if (!dfs) { 198 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 199 return QDF_STATUS_E_FAILURE; 200 } 201 if (!dfs->dfs_is_offload_enabled) 202 dfs_process_phyerr_filter_offload(dfs, wlan_radar_event); 203 else 204 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 205 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 206 wlan_objmgr_pdev_get_pdev_id(pdev)); 207 208 return QDF_STATUS_SUCCESS; 209 } 210 qdf_export_symbol(tgt_dfs_process_phyerr_filter_offload); 211 212 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 213 bool *is_phyerr_filter_offload) 214 { 215 struct dfs_soc_priv_obj *soc_obj; 216 217 if (!psoc) { 218 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 219 return QDF_STATUS_E_FAILURE; 220 } 221 222 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 223 WLAN_UMAC_COMP_DFS); 224 if (!soc_obj) { 225 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 226 "Failed to get dfs psoc component"); 227 return QDF_STATUS_E_FAILURE; 228 } 229 230 *is_phyerr_filter_offload = soc_obj->dfs_is_phyerr_filter_offload; 231 232 return QDF_STATUS_SUCCESS; 233 } 234 qdf_export_symbol(tgt_dfs_is_phyerr_filter_offload); 235 #else 236 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 237 struct radar_event_info 238 *wlan_radar_event) 239 { 240 return QDF_STATUS_SUCCESS; 241 } 242 243 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 244 bool *is_phyerr_filter_offload) 245 { 246 return QDF_STATUS_SUCCESS; 247 } 248 #endif 249 250 QDF_STATUS tgt_dfs_is_precac_timer_running(struct wlan_objmgr_pdev *pdev, 251 bool *is_precac_timer_running) 252 { 253 struct wlan_dfs *dfs; 254 255 if (!tgt_dfs_is_pdev_5ghz(pdev)) 256 return QDF_STATUS_SUCCESS; 257 258 dfs = wlan_pdev_get_dfs_obj(pdev); 259 if (!dfs) { 260 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 261 return QDF_STATUS_E_FAILURE; 262 } 263 264 *is_precac_timer_running = dfs_is_precac_timer_running(dfs); 265 266 return QDF_STATUS_SUCCESS; 267 } 268 qdf_export_symbol(tgt_dfs_is_precac_timer_running); 269 270 QDF_STATUS tgt_dfs_get_radars(struct wlan_objmgr_pdev *pdev) 271 { 272 struct wlan_dfs *dfs; 273 274 if (!tgt_dfs_is_pdev_5ghz(pdev)) 275 return QDF_STATUS_SUCCESS; 276 277 dfs = wlan_pdev_get_dfs_obj(pdev); 278 if (!dfs) { 279 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 280 return QDF_STATUS_E_FAILURE; 281 } 282 283 if (!dfs->dfs_is_offload_enabled) 284 dfs_get_radars(dfs); 285 286 return QDF_STATUS_SUCCESS; 287 } 288 qdf_export_symbol(tgt_dfs_get_radars); 289 290 QDF_STATUS tgt_dfs_destroy_object(struct wlan_objmgr_pdev *pdev) 291 { 292 struct wlan_dfs *dfs; 293 294 dfs = wlan_pdev_get_dfs_obj(pdev); 295 if (!dfs) { 296 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 297 return QDF_STATUS_E_FAILURE; 298 } 299 300 dfs_destroy_object(dfs); 301 302 return QDF_STATUS_SUCCESS; 303 } 304 qdf_export_symbol(tgt_dfs_destroy_object); 305 306 #ifdef QCA_MCL_DFS_SUPPORT 307 QDF_STATUS tgt_dfs_set_tx_leakage_threshold(struct wlan_objmgr_pdev *pdev) 308 { 309 struct wlan_dfs *dfs; 310 uint32_t tx_leakage_threshold = 0; 311 struct wlan_objmgr_psoc *psoc; 312 313 psoc = wlan_pdev_get_psoc(pdev); 314 if (!psoc) { 315 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 316 return QDF_STATUS_E_FAILURE; 317 } 318 319 dfs = wlan_pdev_get_dfs_obj(pdev); 320 if (!dfs) { 321 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 322 return QDF_STATUS_E_FAILURE; 323 } 324 ucfg_mlme_get_sap_tx_leakage_threshold(psoc, 325 &tx_leakage_threshold); 326 327 dfs->tx_leakage_threshold = tx_leakage_threshold; 328 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 329 "dfs tx_leakage_threshold = %d", dfs->tx_leakage_threshold); 330 331 return QDF_STATUS_SUCCESS; 332 } 333 qdf_export_symbol(tgt_dfs_set_tx_leakage_threshold); 334 #endif 335 336 QDF_STATUS tgt_dfs_control(struct wlan_objmgr_pdev *pdev, 337 u_int id, 338 void *indata, 339 uint32_t insize, 340 void *outdata, 341 uint32_t *outsize, 342 int *error) 343 { 344 struct wlan_dfs *dfs; 345 346 dfs = wlan_pdev_get_dfs_obj(pdev); 347 if (!dfs) { 348 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 349 return QDF_STATUS_E_FAILURE; 350 } 351 352 *error = dfs_control(dfs, id, indata, insize, outdata, outsize); 353 354 return QDF_STATUS_SUCCESS; 355 } 356 qdf_export_symbol(tgt_dfs_control); 357 358 #ifdef QCA_SUPPORT_AGILE_DFS 359 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 360 { 361 struct wlan_dfs *dfs; 362 363 dfs = wlan_pdev_get_dfs_obj(pdev); 364 if (!dfs) { 365 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 366 return QDF_STATUS_E_FAILURE; 367 } 368 369 dfs_agile_precac_start(dfs); 370 371 return QDF_STATUS_SUCCESS; 372 } 373 #else 374 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 375 { 376 return QDF_STATUS_SUCCESS; 377 } 378 #endif 379 qdf_export_symbol(tgt_dfs_agile_precac_start); 380 381 #ifdef QCA_SUPPORT_AGILE_DFS 382 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 383 int agile_precac_state) 384 { 385 struct wlan_dfs *dfs; 386 int i; 387 388 dfs = wlan_pdev_get_dfs_obj(pdev); 389 if (!dfs) { 390 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 391 return QDF_STATUS_E_FAILURE; 392 } 393 394 dfs->dfs_soc_obj->precac_state_started = agile_precac_state; 395 if (!dfs->dfs_soc_obj->precac_state_started) { 396 for (i = 0; i < dfs->dfs_soc_obj->num_dfs_privs; i++) 397 dfs->dfs_soc_obj->dfs_priv[i].agile_precac_active = 0; 398 } 399 400 return QDF_STATUS_SUCCESS; 401 } 402 #else 403 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 404 int agile_precac_state) 405 { 406 return QDF_STATUS_SUCCESS; 407 } 408 #endif 409 qdf_export_symbol(tgt_dfs_set_agile_precac_state); 410 411 #ifdef QCA_SUPPORT_AGILE_DFS 412 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 413 struct vdev_adfs_complete_status *adfs_status) 414 { 415 struct wlan_dfs *dfs; 416 QDF_STATUS status = QDF_STATUS_E_FAILURE; 417 418 if (!pdev) { 419 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 420 return status; 421 } 422 423 dfs = wlan_pdev_get_dfs_obj(pdev); 424 if (!dfs) { 425 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 426 return status; 427 } 428 429 dfs_process_ocac_complete(pdev, adfs_status->ocac_status, 430 adfs_status->center_freq); 431 432 return QDF_STATUS_SUCCESS; 433 } 434 #else 435 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 436 struct vdev_adfs_complete_status *adfs_status) 437 { 438 return QDF_STATUS_SUCCESS; 439 } 440 #endif 441 qdf_export_symbol(tgt_dfs_ocac_complete); 442 443 QDF_STATUS tgt_dfs_find_vht80_chan_for_precac(struct wlan_objmgr_pdev *pdev, 444 uint32_t chan_mode, 445 uint8_t ch_freq_seg1, 446 uint32_t *cfreq1, 447 uint32_t *cfreq2, 448 uint32_t *phy_mode, 449 bool *dfs_set_cfreq2, 450 bool *set_agile) 451 { 452 struct wlan_dfs *dfs; 453 454 dfs = wlan_pdev_get_dfs_obj(pdev); 455 if (!dfs) { 456 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 457 return QDF_STATUS_E_FAILURE; 458 } 459 460 dfs_find_vht80_chan_for_precac(dfs, 461 chan_mode, 462 ch_freq_seg1, 463 cfreq1, 464 cfreq2, 465 phy_mode, 466 dfs_set_cfreq2, 467 set_agile); 468 469 return QDF_STATUS_SUCCESS; 470 } 471 qdf_export_symbol(tgt_dfs_find_vht80_chan_for_precac); 472 473 QDF_STATUS tgt_dfs_process_radar_ind(struct wlan_objmgr_pdev *pdev, 474 struct radar_found_info *radar_found) 475 { 476 struct wlan_dfs *dfs; 477 QDF_STATUS status = QDF_STATUS_E_FAILURE; 478 479 if (!pdev) { 480 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 481 return status; 482 } 483 484 dfs = wlan_pdev_get_dfs_obj(pdev); 485 if (!dfs) { 486 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 487 return status; 488 } 489 490 dfs->dfs_radar_found_for_fo = 1; 491 status = dfs_process_radar_ind(dfs, radar_found); 492 dfs->dfs_radar_found_for_fo = 0; 493 494 return status; 495 } 496 qdf_export_symbol(tgt_dfs_process_radar_ind); 497 498 #ifndef QCA_MCL_DFS_SUPPORT 499 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 500 { 501 return QDF_STATUS_SUCCESS; 502 } 503 #else 504 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 505 { 506 dfs_mlme_proc_cac(pdev, vdev_id); 507 508 return QDF_STATUS_SUCCESS; 509 } 510 #endif 511 qdf_export_symbol(tgt_dfs_cac_complete); 512 513 QDF_STATUS tgt_dfs_reg_ev_handler(struct wlan_objmgr_psoc *psoc) 514 { 515 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 516 517 if (!psoc) { 518 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 519 return QDF_STATUS_E_FAILURE; 520 } 521 522 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 523 if (!dfs_tx_ops) { 524 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null dfs_tx_ops"); 525 return QDF_STATUS_E_FAILURE; 526 } 527 528 if (dfs_tx_ops->dfs_reg_ev_handler) 529 return dfs_tx_ops->dfs_reg_ev_handler(psoc); 530 531 return QDF_STATUS_E_FAILURE; 532 } 533 qdf_export_symbol(tgt_dfs_reg_ev_handler); 534 535 QDF_STATUS tgt_dfs_stop(struct wlan_objmgr_pdev *pdev) 536 { 537 struct wlan_dfs *dfs; 538 539 if (!tgt_dfs_is_pdev_5ghz(pdev)) 540 return QDF_STATUS_SUCCESS; 541 542 dfs = wlan_pdev_get_dfs_obj(pdev); 543 if (!dfs) { 544 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 545 return QDF_STATUS_E_FAILURE; 546 } 547 548 dfs_stop(dfs); 549 550 return QDF_STATUS_SUCCESS; 551 } 552 qdf_export_symbol(tgt_dfs_stop); 553 554 QDF_STATUS tgt_dfs_process_emulate_bang_radar_cmd(struct wlan_objmgr_pdev *pdev, 555 struct dfs_emulate_bang_radar_test_cmd *dfs_unit_test) 556 { 557 struct wlan_objmgr_psoc *psoc; 558 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 559 560 psoc = wlan_pdev_get_psoc(pdev); 561 if (!psoc) { 562 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 563 return QDF_STATUS_E_FAILURE; 564 } 565 566 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 567 if (dfs_tx_ops && dfs_tx_ops->dfs_process_emulate_bang_radar_cmd) 568 return dfs_tx_ops->dfs_process_emulate_bang_radar_cmd(pdev, 569 dfs_unit_test); 570 else 571 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 572 "dfs_tx_ops=%pK", dfs_tx_ops); 573 574 return QDF_STATUS_E_FAILURE; 575 } 576 qdf_export_symbol(tgt_dfs_process_emulate_bang_radar_cmd); 577 578 #ifdef QCA_MCL_DFS_SUPPORT 579 QDF_STATUS tgt_dfs_set_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev) 580 { 581 struct wlan_objmgr_psoc *psoc; 582 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 583 struct dfs_soc_priv_obj *soc_obj; 584 585 psoc = wlan_pdev_get_psoc(pdev); 586 if (!psoc) { 587 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 588 return QDF_STATUS_E_FAILURE; 589 } 590 591 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 592 WLAN_UMAC_COMP_DFS); 593 if (!soc_obj) { 594 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 595 "Failed to get dfs psoc component"); 596 return QDF_STATUS_E_FAILURE; 597 } 598 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 599 if (dfs_tx_ops && dfs_tx_ops->dfs_set_phyerr_filter_offload) 600 return dfs_tx_ops->dfs_set_phyerr_filter_offload(pdev, 601 soc_obj->dfs_is_phyerr_filter_offload); 602 else 603 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 604 "dfs_tx_ops=%pK", dfs_tx_ops); 605 606 return QDF_STATUS_E_FAILURE; 607 } 608 qdf_export_symbol(tgt_dfs_set_phyerr_filter_offload); 609 #endif 610 611 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 612 QDF_STATUS 613 tgt_dfs_send_avg_params_to_fw(struct wlan_objmgr_pdev *pdev, 614 struct dfs_radar_found_params *params) 615 { 616 struct wlan_objmgr_psoc *psoc; 617 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 618 struct wlan_dfs *dfs; 619 QDF_STATUS status = QDF_STATUS_E_FAILURE; 620 621 dfs = wlan_pdev_get_dfs_obj(pdev); 622 if (!dfs) { 623 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 624 return status; 625 } 626 627 psoc = wlan_pdev_get_psoc(pdev); 628 if (!psoc) { 629 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 630 return status; 631 } 632 633 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 634 if (dfs_tx_ops && dfs_tx_ops->dfs_send_avg_radar_params_to_fw) 635 status = dfs_tx_ops->dfs_send_avg_radar_params_to_fw(pdev, 636 params); 637 638 if (QDF_IS_STATUS_SUCCESS(status)) { 639 dfs->dfs_average_params_sent = 1; 640 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 641 "Average radar parameters sent %d", 642 dfs->dfs_average_params_sent); 643 } 644 645 return status; 646 } 647 648 qdf_export_symbol(tgt_dfs_send_avg_params_to_fw); 649 650 QDF_STATUS tgt_dfs_action_on_status_from_fw(struct wlan_objmgr_pdev *pdev, 651 uint32_t *status) 652 { 653 struct wlan_dfs *dfs; 654 655 dfs = wlan_pdev_get_dfs_obj(pdev); 656 if (!dfs) { 657 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 658 return QDF_STATUS_E_FAILURE; 659 } 660 661 dfs_action_on_fw_radar_status_check(dfs, status); 662 663 return QDF_STATUS_SUCCESS; 664 } 665 666 qdf_export_symbol(tgt_dfs_action_on_status_from_fw); 667 668 QDF_STATUS tgt_dfs_reset_spoof_test(struct wlan_objmgr_pdev *pdev) 669 { 670 struct wlan_dfs *dfs; 671 672 if (!tgt_dfs_is_pdev_5ghz(pdev)) 673 return QDF_STATUS_SUCCESS; 674 675 dfs = wlan_pdev_get_dfs_obj(pdev); 676 if (!dfs) { 677 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 678 return QDF_STATUS_E_FAILURE; 679 } 680 681 dfs_reset_spoof_test(dfs); 682 683 return QDF_STATUS_SUCCESS; 684 } 685 686 qdf_export_symbol(tgt_dfs_reset_spoof_test); 687 #endif 688 689 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 690 QDF_STATUS tgt_dfs_send_usenol_pdev_param(struct wlan_objmgr_pdev *pdev, 691 bool usenol) 692 { 693 struct wlan_objmgr_psoc *psoc; 694 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 695 696 psoc = wlan_pdev_get_psoc(pdev); 697 if (!psoc) { 698 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 699 return QDF_STATUS_E_FAILURE; 700 } 701 702 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 703 if (dfs_tx_ops && dfs_tx_ops->dfs_send_usenol_pdev_param) 704 return dfs_tx_ops->dfs_send_usenol_pdev_param(pdev, usenol); 705 706 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 707 "dfs_tx_ops=%pK", dfs_tx_ops); 708 709 return QDF_STATUS_E_FAILURE; 710 } 711 712 qdf_export_symbol(tgt_dfs_send_usenol_pdev_param); 713 714 QDF_STATUS tgt_dfs_send_subchan_marking(struct wlan_objmgr_pdev *pdev, 715 bool subchanmark) 716 { 717 struct wlan_objmgr_psoc *psoc; 718 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 719 720 psoc = wlan_pdev_get_psoc(pdev); 721 if (!psoc) { 722 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 723 return QDF_STATUS_E_FAILURE; 724 } 725 726 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 727 if (!dfs_tx_ops) { 728 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 729 "dfs_tx_ops=%pK", dfs_tx_ops); 730 return QDF_STATUS_E_FAILURE; 731 } 732 733 if (dfs_tx_ops->dfs_send_subchan_marking_pdev_param) 734 return dfs_tx_ops->dfs_send_subchan_marking_pdev_param( 735 pdev, subchanmark); 736 737 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 738 "dfs_send_subchan_marking_pdev_param is null"); 739 740 return QDF_STATUS_E_FAILURE; 741 } 742 743 qdf_export_symbol(tgt_dfs_send_subchan_marking); 744 #endif 745 746 void tgt_dfs_enable_stadfs(struct wlan_objmgr_pdev *pdev, bool val) 747 { 748 struct wlan_dfs *dfs; 749 750 dfs = wlan_pdev_get_dfs_obj(pdev); 751 if (!dfs) { 752 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 753 return; 754 } 755 756 dfs->dfs_is_stadfs_enabled = val; 757 } 758 759 bool tgt_dfs_is_stadfs_enabled(struct wlan_objmgr_pdev *pdev) 760 { 761 struct wlan_dfs *dfs; 762 763 dfs = wlan_pdev_get_dfs_obj(pdev); 764 if (!dfs) { 765 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 766 return false; 767 } 768 769 return dfs->dfs_is_stadfs_enabled; 770 } 771