1 /* 2 * Copyright (c) 2016-2020 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 25 #include "wlan_dfs_ucfg_api.h" 26 #include "wlan_dfs_init_deinit_api.h" 27 #include "../../core/src/dfs.h" 28 #include "../../core/src/dfs_zero_cac.h" 29 #include "../../core/src/dfs_partial_offload_radar.h" 30 #include "../../core/src/dfs_process_radar_found_ind.h" 31 #include <qdf_module.h> 32 33 QDF_STATUS ucfg_dfs_is_ap_cac_timer_running(struct wlan_objmgr_pdev *pdev, 34 int *is_ap_cac_timer_running) 35 { 36 struct wlan_dfs *dfs; 37 38 dfs = wlan_pdev_get_dfs_obj(pdev); 39 if (!dfs) 40 return QDF_STATUS_E_FAILURE; 41 42 *is_ap_cac_timer_running = dfs_is_ap_cac_timer_running(dfs); 43 44 return QDF_STATUS_SUCCESS; 45 } 46 qdf_export_symbol(ucfg_dfs_is_ap_cac_timer_running); 47 48 QDF_STATUS ucfg_dfs_getnol(struct wlan_objmgr_pdev *pdev, 49 void *dfs_nolinfo) 50 { 51 struct wlan_dfs *dfs; 52 53 dfs = wlan_pdev_get_dfs_obj(pdev); 54 if (!dfs) 55 return QDF_STATUS_E_FAILURE; 56 57 dfs_getnol(dfs, dfs_nolinfo); 58 59 return QDF_STATUS_SUCCESS; 60 } 61 qdf_export_symbol(ucfg_dfs_getnol); 62 63 QDF_STATUS ucfg_dfs_override_cac_timeout(struct wlan_objmgr_pdev *pdev, 64 int cac_timeout, 65 int *status) 66 { 67 struct wlan_dfs *dfs; 68 69 dfs = wlan_pdev_get_dfs_obj(pdev); 70 if (!dfs) 71 return QDF_STATUS_E_FAILURE; 72 73 *status = dfs_override_cac_timeout(dfs, cac_timeout); 74 75 return QDF_STATUS_SUCCESS; 76 } 77 qdf_export_symbol(ucfg_dfs_override_cac_timeout); 78 79 QDF_STATUS ucfg_dfs_get_override_cac_timeout(struct wlan_objmgr_pdev *pdev, 80 int *cac_timeout, 81 int *status) 82 { 83 struct wlan_dfs *dfs; 84 85 dfs = wlan_pdev_get_dfs_obj(pdev); 86 if (!dfs) 87 return QDF_STATUS_E_FAILURE; 88 89 *status = dfs_get_override_cac_timeout(dfs, cac_timeout); 90 91 return QDF_STATUS_SUCCESS; 92 } 93 qdf_export_symbol(ucfg_dfs_get_override_cac_timeout); 94 95 QDF_STATUS ucfg_dfs_get_override_precac_timeout(struct wlan_objmgr_pdev *pdev, 96 int *precac_timeout) 97 { 98 struct wlan_dfs *dfs; 99 100 dfs = wlan_pdev_get_dfs_obj(pdev); 101 if (!dfs) 102 return QDF_STATUS_E_FAILURE; 103 104 dfs_get_override_precac_timeout(dfs, precac_timeout); 105 106 return QDF_STATUS_SUCCESS; 107 } 108 qdf_export_symbol(ucfg_dfs_get_override_precac_timeout); 109 110 QDF_STATUS ucfg_dfs_override_precac_timeout(struct wlan_objmgr_pdev *pdev, 111 int precac_timeout) 112 { 113 struct wlan_dfs *dfs; 114 115 dfs = wlan_pdev_get_dfs_obj(pdev); 116 if (!dfs) 117 return QDF_STATUS_E_FAILURE; 118 119 dfs_override_precac_timeout(dfs, precac_timeout); 120 121 return QDF_STATUS_SUCCESS; 122 } 123 qdf_export_symbol(ucfg_dfs_override_precac_timeout); 124 125 QDF_STATUS ucfg_dfs_set_precac_enable(struct wlan_objmgr_pdev *pdev, 126 uint32_t value) 127 { 128 struct wlan_dfs *dfs; 129 130 dfs = wlan_pdev_get_dfs_obj(pdev); 131 if (!dfs) { 132 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 133 return QDF_STATUS_E_FAILURE; 134 } 135 136 dfs_set_precac_enable(dfs, value); 137 138 return QDF_STATUS_SUCCESS; 139 } 140 qdf_export_symbol(ucfg_dfs_set_precac_enable); 141 142 QDF_STATUS ucfg_dfs_get_legacy_precac_enable(struct wlan_objmgr_pdev *pdev, 143 bool *buff) 144 { 145 struct wlan_dfs *dfs; 146 147 if (!tgt_dfs_is_pdev_5ghz(pdev)) 148 return QDF_STATUS_SUCCESS; 149 150 dfs = wlan_pdev_get_dfs_obj(pdev); 151 if (!dfs) { 152 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 153 return QDF_STATUS_E_FAILURE; 154 } 155 156 *buff = dfs_is_legacy_precac_enabled(dfs); 157 158 return QDF_STATUS_SUCCESS; 159 } 160 161 qdf_export_symbol(ucfg_dfs_get_legacy_precac_enable); 162 163 QDF_STATUS ucfg_dfs_get_agile_precac_enable(struct wlan_objmgr_pdev *pdev, 164 bool *buff) 165 { 166 struct wlan_dfs *dfs; 167 168 if (!pdev || !buff) 169 return QDF_STATUS_E_FAILURE; 170 171 if (!tgt_dfs_is_pdev_5ghz(pdev)) { 172 *buff = false; 173 return QDF_STATUS_SUCCESS; 174 } 175 176 dfs = wlan_pdev_get_dfs_obj(pdev); 177 if (!dfs) { 178 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 179 return QDF_STATUS_E_FAILURE; 180 } 181 182 *buff = dfs_is_agile_precac_enabled(dfs); 183 184 return QDF_STATUS_SUCCESS; 185 } 186 187 qdf_export_symbol(ucfg_dfs_get_agile_precac_enable); 188 189 QDF_STATUS 190 ucfg_dfs_set_nol_subchannel_marking(struct wlan_objmgr_pdev *pdev, 191 bool nol_subchannel_marking) 192 { 193 struct wlan_dfs *dfs; 194 195 dfs = wlan_pdev_get_dfs_obj(pdev); 196 if (!dfs) 197 return QDF_STATUS_E_FAILURE; 198 199 dfs_set_nol_subchannel_marking(dfs, nol_subchannel_marking); 200 201 return QDF_STATUS_SUCCESS; 202 } 203 qdf_export_symbol(ucfg_dfs_set_nol_subchannel_marking); 204 205 QDF_STATUS ucfg_dfs_get_nol_subchannel_marking(struct wlan_objmgr_pdev *pdev, 206 bool *nol_subchannel_marking) 207 { 208 struct wlan_dfs *dfs; 209 210 dfs = wlan_pdev_get_dfs_obj(pdev); 211 if (!dfs) 212 return QDF_STATUS_E_FAILURE; 213 214 dfs_get_nol_subchannel_marking(dfs, nol_subchannel_marking); 215 216 return QDF_STATUS_SUCCESS; 217 } 218 qdf_export_symbol(ucfg_dfs_get_nol_subchannel_marking); 219 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 220 QDF_STATUS ucfg_dfs_set_precac_intermediate_chan(struct wlan_objmgr_pdev *pdev, 221 uint32_t value) 222 { 223 struct wlan_dfs *dfs; 224 225 dfs = wlan_pdev_get_dfs_obj(pdev); 226 if (!dfs) { 227 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 228 return QDF_STATUS_E_FAILURE; 229 } 230 231 dfs_set_precac_intermediate_chan(dfs, value); 232 233 return QDF_STATUS_SUCCESS; 234 } 235 236 QDF_STATUS ucfg_dfs_get_precac_intermediate_chan(struct wlan_objmgr_pdev *pdev, 237 int *buff) 238 { 239 struct wlan_dfs *dfs; 240 241 dfs = wlan_pdev_get_dfs_obj(pdev); 242 if (!dfs) { 243 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 244 return QDF_STATUS_E_FAILURE; 245 } 246 247 *buff = dfs_get_precac_intermediate_chan(dfs); 248 249 return QDF_STATUS_SUCCESS; 250 } 251 252 #ifdef CONFIG_CHAN_NUM_API 253 enum precac_chan_state 254 ucfg_dfs_get_precac_chan_state(struct wlan_objmgr_pdev *pdev, 255 uint8_t precac_chan) 256 { 257 struct wlan_dfs *dfs; 258 enum precac_chan_state retval = PRECAC_ERR; 259 260 dfs = wlan_pdev_get_dfs_obj(pdev); 261 if (!dfs) { 262 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 263 return PRECAC_ERR; 264 } 265 266 retval = dfs_get_precac_chan_state(dfs, precac_chan); 267 if (retval == PRECAC_ERR) { 268 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 269 "Could not find precac channel state"); 270 } 271 272 return retval; 273 } 274 #endif 275 276 #ifdef CONFIG_CHAN_FREQ_API 277 enum precac_chan_state 278 ucfg_dfs_get_precac_chan_state_for_freq(struct wlan_objmgr_pdev *pdev, 279 uint16_t precac_chan_freq) 280 { 281 struct wlan_dfs *dfs; 282 enum precac_chan_state retval = PRECAC_ERR; 283 284 dfs = wlan_pdev_get_dfs_obj(pdev); 285 if (!dfs) { 286 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 287 return PRECAC_ERR; 288 } 289 290 retval = dfs_get_precac_chan_state_for_freq(dfs, precac_chan_freq); 291 if (retval == PRECAC_ERR) { 292 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 293 "Could not find precac channel state"); 294 } 295 296 return retval; 297 } 298 #endif 299 #endif 300 301 #ifdef QCA_MCL_DFS_SUPPORT 302 QDF_STATUS ucfg_dfs_update_config(struct wlan_objmgr_psoc *psoc, 303 struct dfs_user_config *req) 304 { 305 struct dfs_soc_priv_obj *soc_obj; 306 307 if (!psoc || !req) { 308 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 309 "psoc: 0x%pK, req: 0x%pK", psoc, req); 310 return QDF_STATUS_E_FAILURE; 311 } 312 313 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 314 WLAN_UMAC_COMP_DFS); 315 if (!soc_obj) { 316 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 317 "Failed to get dfs psoc component"); 318 return QDF_STATUS_E_FAILURE; 319 } 320 321 soc_obj->dfs_is_phyerr_filter_offload = 322 req->dfs_is_phyerr_filter_offload; 323 324 return QDF_STATUS_SUCCESS; 325 } 326 qdf_export_symbol(ucfg_dfs_update_config); 327 #endif 328 329 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 330 QDF_STATUS ucfg_dfs_set_override_status_timeout(struct wlan_objmgr_pdev *pdev, 331 int status_timeout) 332 { 333 struct wlan_dfs *dfs; 334 335 dfs = wlan_pdev_get_dfs_obj(pdev); 336 if (!dfs) { 337 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 338 return QDF_STATUS_E_FAILURE; 339 } 340 341 dfs_set_override_status_timeout(dfs, status_timeout); 342 343 return QDF_STATUS_SUCCESS; 344 } 345 346 qdf_export_symbol(ucfg_dfs_set_override_status_timeout); 347 348 QDF_STATUS ucfg_dfs_get_override_status_timeout(struct wlan_objmgr_pdev *pdev, 349 int *status_timeout) 350 { 351 struct wlan_dfs *dfs; 352 353 dfs = wlan_pdev_get_dfs_obj(pdev); 354 if (!dfs) { 355 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 356 return QDF_STATUS_E_FAILURE; 357 } 358 359 dfs_get_override_status_timeout(dfs, status_timeout); 360 361 return QDF_STATUS_SUCCESS; 362 } 363 364 qdf_export_symbol(ucfg_dfs_get_override_status_timeout); 365 #endif 366 367 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(WLAN_DFS_SYNTHETIC_RADAR) 368 void ucfg_dfs_allow_hw_pulses(struct wlan_objmgr_pdev *pdev, 369 bool allow_hw_pulses) 370 { 371 struct wlan_dfs *dfs; 372 373 if (!tgt_dfs_is_pdev_5ghz(pdev)) 374 return; 375 376 dfs = wlan_pdev_get_dfs_obj(pdev); 377 if (!dfs) { 378 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 379 return; 380 } 381 382 dfs_allow_hw_pulses(dfs, allow_hw_pulses); 383 } 384 385 qdf_export_symbol(ucfg_dfs_allow_hw_pulses); 386 387 bool ucfg_dfs_is_hw_pulses_allowed(struct wlan_objmgr_pdev *pdev) 388 { 389 struct wlan_dfs *dfs; 390 391 if (!tgt_dfs_is_pdev_5ghz(pdev)) 392 return false; 393 394 dfs = wlan_pdev_get_dfs_obj(pdev); 395 if (!dfs) { 396 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 397 return false; 398 } 399 400 return dfs_is_hw_pulses_allowed(dfs); 401 } 402 403 qdf_export_symbol(ucfg_dfs_is_hw_pulses_allowed); 404 #endif 405 406 #ifdef QCA_SUPPORT_AGILE_DFS 407 QDF_STATUS ucfg_dfs_reset_agile_config(struct wlan_objmgr_psoc *psoc) 408 { 409 struct dfs_soc_priv_obj *soc_obj; 410 411 if (!psoc) { 412 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 413 return QDF_STATUS_E_FAILURE; 414 } 415 416 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 417 WLAN_UMAC_COMP_DFS); 418 if (!soc_obj) { 419 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 420 "Failed to get dfs psoc component"); 421 return QDF_STATUS_E_FAILURE; 422 } 423 424 dfs_reset_agile_config(soc_obj); 425 426 return QDF_STATUS_SUCCESS; 427 } 428 429 qdf_export_symbol(ucfg_dfs_reset_agile_config); 430 #endif 431 432 QDF_STATUS ucfg_dfs_reinit_timers(struct wlan_objmgr_pdev *pdev) 433 { 434 struct wlan_dfs *dfs; 435 436 if (!tgt_dfs_is_pdev_5ghz(pdev)) 437 return QDF_STATUS_SUCCESS; 438 439 dfs = wlan_pdev_get_dfs_obj(pdev); 440 if (!dfs) { 441 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 442 return QDF_STATUS_E_FAILURE; 443 } 444 445 dfs_reinit_timers(dfs); 446 447 return QDF_STATUS_SUCCESS; 448 } 449 450 qdf_export_symbol(ucfg_dfs_reinit_timers); 451 452 #ifdef QCA_SUPPORT_ADFS_RCAC 453 QDF_STATUS ucfg_dfs_set_rcac_enable(struct wlan_objmgr_pdev *pdev, 454 bool rcac_en) 455 { 456 struct wlan_dfs *dfs; 457 458 dfs = wlan_pdev_get_dfs_obj(pdev); 459 if (!dfs) { 460 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 461 return QDF_STATUS_E_FAILURE; 462 } 463 464 dfs_set_rcac_enable(dfs, rcac_en); 465 466 return QDF_STATUS_SUCCESS; 467 } 468 469 qdf_export_symbol(ucfg_dfs_set_rcac_enable); 470 471 QDF_STATUS ucfg_dfs_get_rcac_enable(struct wlan_objmgr_pdev *pdev, 472 bool *rcac_en) 473 { 474 struct wlan_dfs *dfs; 475 476 dfs = wlan_pdev_get_dfs_obj(pdev); 477 if (!dfs) { 478 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 479 return QDF_STATUS_E_FAILURE; 480 } 481 482 dfs_get_rcac_enable(dfs, rcac_en); 483 484 return QDF_STATUS_SUCCESS; 485 } 486 487 qdf_export_symbol(ucfg_dfs_get_rcac_enable); 488 489 QDF_STATUS ucfg_dfs_set_rcac_freq(struct wlan_objmgr_pdev *pdev, 490 qdf_freq_t rcac_freq) 491 { 492 struct wlan_dfs *dfs; 493 494 dfs = wlan_pdev_get_dfs_obj(pdev); 495 if (!dfs) { 496 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 497 return QDF_STATUS_E_FAILURE; 498 } 499 500 dfs_set_rcac_freq(dfs, rcac_freq); 501 502 return QDF_STATUS_SUCCESS; 503 } 504 505 qdf_export_symbol(ucfg_dfs_set_rcac_freq); 506 507 QDF_STATUS ucfg_dfs_get_rcac_freq(struct wlan_objmgr_pdev *pdev, 508 qdf_freq_t *rcac_freq) 509 { 510 struct wlan_dfs *dfs; 511 512 dfs = wlan_pdev_get_dfs_obj(pdev); 513 if (!dfs) { 514 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 515 return QDF_STATUS_E_FAILURE; 516 } 517 518 dfs_get_rcac_freq(dfs, rcac_freq); 519 520 return QDF_STATUS_SUCCESS; 521 } 522 523 qdf_export_symbol(ucfg_dfs_get_rcac_freq); 524 525 bool ucfg_dfs_is_agile_rcac_enabled(struct wlan_objmgr_pdev *pdev) 526 { 527 struct wlan_dfs *dfs; 528 529 dfs = wlan_pdev_get_dfs_obj(pdev); 530 if (!dfs) { 531 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 532 return false; 533 } 534 535 return dfs_is_agile_rcac_enabled(dfs); 536 } 537 538 qdf_export_symbol(ucfg_dfs_is_agile_rcac_enabled); 539 #endif 540 541 #ifdef QCA_SUPPORT_DFS_CHAN_POSTNOL 542 QDF_STATUS ucfg_dfs_set_postnol_freq(struct wlan_objmgr_pdev *pdev, 543 qdf_freq_t postnol_freq) 544 { 545 struct wlan_dfs *dfs; 546 547 dfs = wlan_pdev_get_dfs_obj(pdev); 548 if (!dfs) { 549 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 550 return QDF_STATUS_E_FAILURE; 551 } 552 553 dfs_set_postnol_freq(dfs, postnol_freq); 554 555 return QDF_STATUS_SUCCESS; 556 } 557 558 qdf_export_symbol(ucfg_dfs_set_postnol_freq); 559 560 QDF_STATUS ucfg_dfs_set_postnol_mode(struct wlan_objmgr_pdev *pdev, 561 uint8_t postnol_mode) 562 { 563 struct wlan_dfs *dfs; 564 565 dfs = wlan_pdev_get_dfs_obj(pdev); 566 if (!dfs) { 567 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 568 return QDF_STATUS_E_FAILURE; 569 } 570 571 dfs_set_postnol_mode(dfs, postnol_mode); 572 573 return QDF_STATUS_SUCCESS; 574 } 575 576 qdf_export_symbol(ucfg_dfs_set_postnol_mode); 577 578 QDF_STATUS ucfg_dfs_set_postnol_cfreq2(struct wlan_objmgr_pdev *pdev, 579 qdf_freq_t postnol_cfreq2) 580 { 581 struct wlan_dfs *dfs; 582 583 dfs = wlan_pdev_get_dfs_obj(pdev); 584 if (!dfs) { 585 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 586 return QDF_STATUS_E_FAILURE; 587 } 588 589 dfs_set_postnol_cfreq2(dfs, postnol_cfreq2); 590 591 return QDF_STATUS_SUCCESS; 592 } 593 594 qdf_export_symbol(ucfg_dfs_set_postnol_cfreq2); 595 596 QDF_STATUS ucfg_dfs_get_postnol_freq(struct wlan_objmgr_pdev *pdev, 597 qdf_freq_t *postnol_freq) 598 { 599 struct wlan_dfs *dfs; 600 601 dfs = wlan_pdev_get_dfs_obj(pdev); 602 if (!dfs) { 603 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 604 return QDF_STATUS_E_FAILURE; 605 } 606 607 dfs_get_postnol_freq(dfs, postnol_freq); 608 609 return QDF_STATUS_SUCCESS; 610 } 611 612 qdf_export_symbol(ucfg_dfs_get_postnol_freq); 613 614 QDF_STATUS ucfg_dfs_get_postnol_mode(struct wlan_objmgr_pdev *pdev, 615 uint8_t *postnol_mode) 616 { 617 struct wlan_dfs *dfs; 618 619 dfs = wlan_pdev_get_dfs_obj(pdev); 620 if (!dfs) { 621 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 622 return QDF_STATUS_E_FAILURE; 623 } 624 625 dfs_get_postnol_mode(dfs, postnol_mode); 626 627 return QDF_STATUS_SUCCESS; 628 } 629 630 qdf_export_symbol(ucfg_dfs_get_postnol_mode); 631 632 QDF_STATUS ucfg_dfs_get_postnol_cfreq2(struct wlan_objmgr_pdev *pdev, 633 qdf_freq_t *postnol_cfreq2) 634 { 635 struct wlan_dfs *dfs; 636 637 dfs = wlan_pdev_get_dfs_obj(pdev); 638 if (!dfs) { 639 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 640 return QDF_STATUS_E_FAILURE; 641 } 642 643 dfs_get_postnol_cfreq2(dfs, postnol_cfreq2); 644 645 return QDF_STATUS_SUCCESS; 646 } 647 648 qdf_export_symbol(ucfg_dfs_get_postnol_cfreq2); 649 #endif 650