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