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