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