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 #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 bool *is_channel_updated) 119 { 120 struct wlan_dfs *dfs; 121 122 if (!tgt_dfs_is_pdev_5ghz(pdev)) 123 return QDF_STATUS_SUCCESS; 124 125 dfs = wlan_pdev_get_dfs_obj(pdev); 126 if (!dfs) { 127 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 128 return QDF_STATUS_E_FAILURE; 129 } 130 131 dfs_set_current_channel_for_freq(dfs, 132 dfs_chan_freq, 133 dfs_chan_flags, 134 dfs_chan_flagext, 135 dfs_chan_ieee, 136 dfs_chan_vhtop_freq_seg1, 137 dfs_chan_vhtop_freq_seg2, 138 dfs_chan_mhz_freq_seg1, 139 dfs_chan_mhz_freq_seg2, 140 is_channel_updated); 141 142 return QDF_STATUS_SUCCESS; 143 } 144 145 qdf_export_symbol(tgt_dfs_set_current_channel_for_freq); 146 #endif 147 148 QDF_STATUS tgt_dfs_radar_enable(struct wlan_objmgr_pdev *pdev, 149 int no_cac, uint32_t opmode, bool enable) 150 { 151 struct wlan_dfs *dfs; 152 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 153 struct wlan_objmgr_psoc *psoc; 154 QDF_STATUS status; 155 156 dfs = wlan_pdev_get_dfs_obj(pdev); 157 if (!dfs) { 158 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 159 return QDF_STATUS_E_FAILURE; 160 } 161 162 if (!dfs->dfs_is_offload_enabled) { 163 if (enable) { 164 dfs_radar_enable(dfs, no_cac, opmode); 165 return QDF_STATUS_SUCCESS; 166 } else { 167 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 168 "Disabling dfs not allowed for non-offload chips"); 169 return QDF_STATUS_E_FAILURE; 170 } 171 } 172 173 psoc = wlan_pdev_get_psoc(pdev); 174 if (!psoc) { 175 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 176 return QDF_STATUS_E_FAILURE; 177 } 178 179 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 180 if (!dfs_tx_ops) { 181 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs_tx_ops is null"); 182 return QDF_STATUS_E_FAILURE; 183 } 184 185 status = dfs_tx_ops->dfs_send_offload_enable_cmd(pdev, enable); 186 if (QDF_IS_STATUS_ERROR(status)) 187 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 188 "Failed to enable dfs offload, pdev_id: %d", 189 wlan_objmgr_pdev_get_pdev_id(pdev)); 190 191 return status; 192 } 193 qdf_export_symbol(tgt_dfs_radar_enable); 194 195 void tgt_dfs_is_radar_enabled(struct wlan_objmgr_pdev *pdev, int *ignore_dfs) 196 { 197 struct wlan_dfs *dfs; 198 199 dfs = wlan_pdev_get_dfs_obj(pdev); 200 if (!dfs) { 201 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 202 return; 203 } 204 205 dfs_is_radar_enabled(dfs, ignore_dfs); 206 } 207 208 qdf_export_symbol(tgt_dfs_is_radar_enabled); 209 210 QDF_STATUS tgt_dfs_process_phyerr(struct wlan_objmgr_pdev *pdev, 211 void *buf, 212 uint16_t datalen, 213 uint8_t r_rssi, 214 uint8_t r_ext_rssi, 215 uint32_t r_rs_tstamp, 216 uint64_t r_fulltsf) 217 { 218 struct wlan_dfs *dfs; 219 220 dfs = wlan_pdev_get_dfs_obj(pdev); 221 if (!dfs) { 222 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 223 return QDF_STATUS_E_FAILURE; 224 } 225 226 if (!dfs->dfs_is_offload_enabled) 227 dfs_process_phyerr(dfs, buf, datalen, r_rssi, 228 r_ext_rssi, r_rs_tstamp, r_fulltsf); 229 else 230 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 231 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 232 wlan_objmgr_pdev_get_pdev_id(pdev)); 233 234 return QDF_STATUS_SUCCESS; 235 } 236 qdf_export_symbol(tgt_dfs_process_phyerr); 237 238 #ifdef QCA_MCL_DFS_SUPPORT 239 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 240 struct radar_event_info 241 *wlan_radar_event) 242 { 243 struct wlan_dfs *dfs; 244 245 dfs = wlan_pdev_get_dfs_obj(pdev); 246 if (!dfs) { 247 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 248 return QDF_STATUS_E_FAILURE; 249 } 250 if (!dfs->dfs_is_offload_enabled) 251 dfs_process_phyerr_filter_offload(dfs, wlan_radar_event); 252 else 253 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 254 "Unexpect phyerror as DFS is offloaded, pdev_id: %d", 255 wlan_objmgr_pdev_get_pdev_id(pdev)); 256 257 return QDF_STATUS_SUCCESS; 258 } 259 qdf_export_symbol(tgt_dfs_process_phyerr_filter_offload); 260 261 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 262 bool *is_phyerr_filter_offload) 263 { 264 struct dfs_soc_priv_obj *soc_obj; 265 266 if (!psoc) { 267 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 268 return QDF_STATUS_E_FAILURE; 269 } 270 271 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 272 WLAN_UMAC_COMP_DFS); 273 if (!soc_obj) { 274 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 275 "Failed to get dfs psoc component"); 276 return QDF_STATUS_E_FAILURE; 277 } 278 279 *is_phyerr_filter_offload = soc_obj->dfs_is_phyerr_filter_offload; 280 281 return QDF_STATUS_SUCCESS; 282 } 283 qdf_export_symbol(tgt_dfs_is_phyerr_filter_offload); 284 #else 285 QDF_STATUS tgt_dfs_process_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev, 286 struct radar_event_info 287 *wlan_radar_event) 288 { 289 return QDF_STATUS_SUCCESS; 290 } 291 292 QDF_STATUS tgt_dfs_is_phyerr_filter_offload(struct wlan_objmgr_psoc *psoc, 293 bool *is_phyerr_filter_offload) 294 { 295 return QDF_STATUS_SUCCESS; 296 } 297 #endif 298 299 QDF_STATUS tgt_dfs_is_precac_timer_running(struct wlan_objmgr_pdev *pdev, 300 bool *is_precac_timer_running) 301 { 302 struct wlan_dfs *dfs; 303 304 if (!tgt_dfs_is_pdev_5ghz(pdev)) 305 return QDF_STATUS_SUCCESS; 306 307 dfs = wlan_pdev_get_dfs_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 *is_precac_timer_running = dfs_is_precac_timer_running(dfs); 314 315 return QDF_STATUS_SUCCESS; 316 } 317 qdf_export_symbol(tgt_dfs_is_precac_timer_running); 318 319 QDF_STATUS tgt_dfs_get_radars(struct wlan_objmgr_pdev *pdev) 320 { 321 struct wlan_dfs *dfs; 322 323 if (!tgt_dfs_is_pdev_5ghz(pdev)) 324 return QDF_STATUS_SUCCESS; 325 326 dfs = wlan_pdev_get_dfs_obj(pdev); 327 if (!dfs) { 328 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 329 return QDF_STATUS_E_FAILURE; 330 } 331 332 if (!dfs->dfs_is_offload_enabled) 333 dfs_get_radars(dfs); 334 335 return QDF_STATUS_SUCCESS; 336 } 337 qdf_export_symbol(tgt_dfs_get_radars); 338 339 QDF_STATUS tgt_dfs_destroy_object(struct wlan_objmgr_pdev *pdev) 340 { 341 struct wlan_dfs *dfs; 342 343 dfs = wlan_pdev_get_dfs_obj(pdev); 344 if (!dfs) { 345 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 346 return QDF_STATUS_E_FAILURE; 347 } 348 349 dfs_destroy_object(dfs); 350 351 return QDF_STATUS_SUCCESS; 352 } 353 qdf_export_symbol(tgt_dfs_destroy_object); 354 355 #ifdef QCA_MCL_DFS_SUPPORT 356 QDF_STATUS tgt_dfs_set_tx_leakage_threshold(struct wlan_objmgr_pdev *pdev) 357 { 358 struct wlan_dfs *dfs; 359 uint32_t tx_leakage_threshold = 0; 360 struct wlan_objmgr_psoc *psoc; 361 362 psoc = wlan_pdev_get_psoc(pdev); 363 if (!psoc) { 364 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 365 return QDF_STATUS_E_FAILURE; 366 } 367 368 dfs = wlan_pdev_get_dfs_obj(pdev); 369 if (!dfs) { 370 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 371 return QDF_STATUS_E_FAILURE; 372 } 373 ucfg_mlme_get_sap_tx_leakage_threshold(psoc, 374 &tx_leakage_threshold); 375 376 dfs->tx_leakage_threshold = tx_leakage_threshold; 377 dfs_debug(dfs, WLAN_DEBUG_DFS_ALWAYS, 378 "dfs tx_leakage_threshold = %d", dfs->tx_leakage_threshold); 379 380 return QDF_STATUS_SUCCESS; 381 } 382 qdf_export_symbol(tgt_dfs_set_tx_leakage_threshold); 383 #endif 384 385 QDF_STATUS tgt_dfs_control(struct wlan_objmgr_pdev *pdev, 386 u_int id, 387 void *indata, 388 uint32_t insize, 389 void *outdata, 390 uint32_t *outsize, 391 int *error) 392 { 393 struct wlan_dfs *dfs; 394 395 dfs = wlan_pdev_get_dfs_obj(pdev); 396 if (!dfs) { 397 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 398 return QDF_STATUS_E_FAILURE; 399 } 400 401 *error = dfs_control(dfs, id, indata, insize, outdata, outsize); 402 403 return QDF_STATUS_SUCCESS; 404 } 405 qdf_export_symbol(tgt_dfs_control); 406 407 #ifdef QCA_SUPPORT_AGILE_DFS 408 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 409 { 410 struct wlan_dfs *dfs; 411 412 dfs = wlan_pdev_get_dfs_obj(pdev); 413 if (!dfs) { 414 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 415 return QDF_STATUS_E_FAILURE; 416 } 417 418 dfs_agile_precac_start(dfs); 419 420 return QDF_STATUS_SUCCESS; 421 } 422 #else 423 QDF_STATUS tgt_dfs_agile_precac_start(struct wlan_objmgr_pdev *pdev) 424 { 425 return QDF_STATUS_SUCCESS; 426 } 427 #endif 428 qdf_export_symbol(tgt_dfs_agile_precac_start); 429 430 #ifdef QCA_SUPPORT_AGILE_DFS 431 #ifdef CONFIG_CHAN_FREQ_API 432 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 433 int agile_precac_state) 434 { 435 struct wlan_dfs *dfs; 436 struct dfs_soc_priv_obj *dfs_soc; 437 bool is_precac_running_on_given_pdev = false; 438 int i; 439 440 if (!tgt_dfs_is_pdev_5ghz(pdev)) 441 return QDF_STATUS_SUCCESS; 442 443 dfs = wlan_pdev_get_dfs_obj(pdev); 444 if (!dfs) { 445 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 446 return QDF_STATUS_E_FAILURE; 447 } 448 449 dfs_soc = dfs->dfs_soc_obj; 450 for (i = 0; i < dfs_soc->num_dfs_privs; i++) { 451 if (dfs_soc->dfs_priv[i].dfs == dfs) { 452 /* Set the pdev state to given value. */ 453 dfs_soc->dfs_priv[i].agile_precac_active = 454 agile_precac_state; 455 /* If the pdev state is changed to inactive, 456 * reset the agile channel. 457 */ 458 if (!agile_precac_state) 459 dfs->dfs_agile_precac_freq_mhz = 0; 460 if (dfs_soc->cur_precac_dfs_index == i) 461 is_precac_running_on_given_pdev = true; 462 } 463 } 464 465 /* If preCAC is running on this pdev and the agile_precac_state 466 * is set to false, set the global state in dfs_soc_obj to false. 467 * If this global state is not set to false, then preCAC will not be 468 * started the next time this pdev becomes active. 469 */ 470 if (is_precac_running_on_given_pdev && !agile_precac_state) 471 dfs_soc->precac_state_started = PRECAC_NOT_STARTED; 472 473 return QDF_STATUS_SUCCESS; 474 } 475 #else 476 #ifdef CONFIG_CHAN_NUM_API 477 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 478 int agile_precac_state) 479 { 480 struct wlan_dfs *dfs; 481 struct dfs_soc_priv_obj *dfs_soc; 482 bool is_precac_running_on_given_pdev = false; 483 int i; 484 485 if (!tgt_dfs_is_pdev_5ghz(pdev)) 486 return QDF_STATUS_SUCCESS; 487 488 dfs = wlan_pdev_get_dfs_obj(pdev); 489 if (!dfs) { 490 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 491 return QDF_STATUS_E_FAILURE; 492 } 493 494 dfs_soc = dfs->dfs_soc_obj; 495 for (i = 0; i < dfs_soc->num_dfs_privs; i++) { 496 if (dfs_soc->dfs_priv[i].dfs == dfs) { 497 /* Set the pdev state to given value. */ 498 dfs_soc->dfs_priv[i].agile_precac_active = 499 agile_precac_state; 500 /* If the pdev state is changed to inactive, 501 * reset the agile channel. 502 */ 503 if (!agile_precac_state) 504 dfs->dfs_agile_precac_freq = 0; 505 if (dfs_soc->cur_precac_dfs_index == i) 506 is_precac_running_on_given_pdev = true; 507 } 508 } 509 510 /* If preCAC is running on this pdev and the agile_precac_state 511 * is set to false, set the global state in dfs_soc_obj to false. 512 * If this global state is not set to false, then preCAC will not be 513 * started the next time this pdev becomes active. 514 */ 515 if (is_precac_running_on_given_pdev && !agile_precac_state) 516 dfs_soc->precac_state_started = PRECAC_NOT_STARTED; 517 518 return QDF_STATUS_SUCCESS; 519 } 520 #endif 521 #endif 522 523 #else 524 QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev, 525 int agile_precac_state) 526 { 527 return QDF_STATUS_SUCCESS; 528 } 529 #endif 530 qdf_export_symbol(tgt_dfs_set_agile_precac_state); 531 532 #ifdef QCA_SUPPORT_AGILE_DFS 533 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 534 struct vdev_adfs_complete_status *adfs_status) 535 { 536 struct wlan_dfs *dfs; 537 QDF_STATUS status = QDF_STATUS_E_FAILURE; 538 539 if (!pdev) { 540 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 541 return status; 542 } 543 544 dfs = wlan_pdev_get_dfs_obj(pdev); 545 if (!dfs) { 546 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 547 return status; 548 } 549 550 dfs_process_ocac_complete(pdev, adfs_status->ocac_status, 551 adfs_status->center_freq); 552 553 return QDF_STATUS_SUCCESS; 554 } 555 #else 556 QDF_STATUS tgt_dfs_ocac_complete(struct wlan_objmgr_pdev *pdev, 557 struct vdev_adfs_complete_status *adfs_status) 558 { 559 return QDF_STATUS_SUCCESS; 560 } 561 #endif 562 qdf_export_symbol(tgt_dfs_ocac_complete); 563 564 #ifdef CONFIG_CHAN_NUM_API 565 QDF_STATUS tgt_dfs_find_vht80_chan_for_precac(struct wlan_objmgr_pdev *pdev, 566 uint32_t chan_mode, 567 uint8_t ch_freq_seg1, 568 uint32_t *cfreq1, 569 uint32_t *cfreq2, 570 uint32_t *phy_mode, 571 bool *dfs_set_cfreq2, 572 bool *set_agile) 573 { 574 struct wlan_dfs *dfs; 575 576 dfs = wlan_pdev_get_dfs_obj(pdev); 577 if (!dfs) { 578 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 579 return QDF_STATUS_E_FAILURE; 580 } 581 582 dfs_find_vht80_chan_for_precac(dfs, 583 chan_mode, 584 ch_freq_seg1, 585 cfreq1, 586 cfreq2, 587 phy_mode, 588 dfs_set_cfreq2, 589 set_agile); 590 591 return QDF_STATUS_SUCCESS; 592 } 593 qdf_export_symbol(tgt_dfs_find_vht80_chan_for_precac); 594 #endif 595 596 #ifdef CONFIG_CHAN_FREQ_API 597 QDF_STATUS 598 tgt_dfs_find_vht80_precac_chan_freq(struct wlan_objmgr_pdev *pdev, 599 uint32_t chan_mode, 600 uint16_t chan_freq_seg1_mhz, 601 uint32_t *cfreq1, 602 uint32_t *cfreq2, 603 uint32_t *phy_mode, 604 bool *dfs_set_cfreq2, 605 bool *set_agile) 606 { 607 struct wlan_dfs *dfs; 608 609 dfs = wlan_pdev_get_dfs_obj(pdev); 610 if (!dfs) { 611 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 612 return QDF_STATUS_E_FAILURE; 613 } 614 615 dfs_find_vht80_chan_for_precac_for_freq(dfs, 616 chan_mode, 617 chan_freq_seg1_mhz, 618 cfreq1, 619 cfreq2, 620 phy_mode, 621 dfs_set_cfreq2, 622 set_agile); 623 624 return QDF_STATUS_SUCCESS; 625 } 626 627 qdf_export_symbol(tgt_dfs_find_vht80_precac_chan_freq); 628 #endif 629 630 QDF_STATUS tgt_dfs_process_radar_ind(struct wlan_objmgr_pdev *pdev, 631 struct radar_found_info *radar_found) 632 { 633 struct wlan_dfs *dfs; 634 QDF_STATUS status = QDF_STATUS_E_FAILURE; 635 636 if (!pdev) { 637 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null pdev"); 638 return status; 639 } 640 641 dfs = wlan_pdev_get_dfs_obj(pdev); 642 if (!dfs) { 643 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 644 return status; 645 } 646 647 dfs->dfs_radar_found_for_fo = 1; 648 status = dfs_process_radar_ind(dfs, radar_found); 649 dfs->dfs_radar_found_for_fo = 0; 650 651 return status; 652 } 653 qdf_export_symbol(tgt_dfs_process_radar_ind); 654 655 #ifndef QCA_MCL_DFS_SUPPORT 656 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 657 { 658 return QDF_STATUS_SUCCESS; 659 } 660 #else 661 QDF_STATUS tgt_dfs_cac_complete(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id) 662 { 663 dfs_mlme_proc_cac(pdev, vdev_id); 664 665 return QDF_STATUS_SUCCESS; 666 } 667 #endif 668 qdf_export_symbol(tgt_dfs_cac_complete); 669 670 QDF_STATUS tgt_dfs_reg_ev_handler(struct wlan_objmgr_psoc *psoc) 671 { 672 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 673 674 if (!psoc) { 675 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 676 return QDF_STATUS_E_FAILURE; 677 } 678 679 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 680 if (!dfs_tx_ops) { 681 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null dfs_tx_ops"); 682 return QDF_STATUS_E_FAILURE; 683 } 684 685 if (dfs_tx_ops->dfs_reg_ev_handler) 686 return dfs_tx_ops->dfs_reg_ev_handler(psoc); 687 688 return QDF_STATUS_E_FAILURE; 689 } 690 qdf_export_symbol(tgt_dfs_reg_ev_handler); 691 692 QDF_STATUS tgt_dfs_stop(struct wlan_objmgr_pdev *pdev) 693 { 694 struct wlan_dfs *dfs; 695 696 if (!tgt_dfs_is_pdev_5ghz(pdev)) 697 return QDF_STATUS_SUCCESS; 698 699 dfs = wlan_pdev_get_dfs_obj(pdev); 700 if (!dfs) { 701 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 702 return QDF_STATUS_E_FAILURE; 703 } 704 705 dfs_stop(dfs); 706 707 return QDF_STATUS_SUCCESS; 708 } 709 qdf_export_symbol(tgt_dfs_stop); 710 711 QDF_STATUS tgt_dfs_process_emulate_bang_radar_cmd(struct wlan_objmgr_pdev *pdev, 712 struct dfs_emulate_bang_radar_test_cmd *dfs_unit_test) 713 { 714 struct wlan_objmgr_psoc *psoc; 715 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 716 717 psoc = wlan_pdev_get_psoc(pdev); 718 if (!psoc) { 719 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 720 return QDF_STATUS_E_FAILURE; 721 } 722 723 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 724 if (dfs_tx_ops && dfs_tx_ops->dfs_process_emulate_bang_radar_cmd) 725 return dfs_tx_ops->dfs_process_emulate_bang_radar_cmd(pdev, 726 dfs_unit_test); 727 else 728 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 729 "dfs_tx_ops=%pK", dfs_tx_ops); 730 731 return QDF_STATUS_E_FAILURE; 732 } 733 qdf_export_symbol(tgt_dfs_process_emulate_bang_radar_cmd); 734 735 #ifdef QCA_MCL_DFS_SUPPORT 736 QDF_STATUS tgt_dfs_set_phyerr_filter_offload(struct wlan_objmgr_pdev *pdev) 737 { 738 struct wlan_objmgr_psoc *psoc; 739 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 740 struct dfs_soc_priv_obj *soc_obj; 741 742 psoc = wlan_pdev_get_psoc(pdev); 743 if (!psoc) { 744 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 745 return QDF_STATUS_E_FAILURE; 746 } 747 748 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 749 WLAN_UMAC_COMP_DFS); 750 if (!soc_obj) { 751 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 752 "Failed to get dfs psoc component"); 753 return QDF_STATUS_E_FAILURE; 754 } 755 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 756 if (dfs_tx_ops && dfs_tx_ops->dfs_set_phyerr_filter_offload) 757 return dfs_tx_ops->dfs_set_phyerr_filter_offload(pdev, 758 soc_obj->dfs_is_phyerr_filter_offload); 759 else 760 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 761 "dfs_tx_ops=%pK", dfs_tx_ops); 762 763 return QDF_STATUS_E_FAILURE; 764 } 765 qdf_export_symbol(tgt_dfs_set_phyerr_filter_offload); 766 #endif 767 768 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 769 QDF_STATUS 770 tgt_dfs_send_avg_params_to_fw(struct wlan_objmgr_pdev *pdev, 771 struct dfs_radar_found_params *params) 772 { 773 struct wlan_objmgr_psoc *psoc; 774 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 775 struct wlan_dfs *dfs; 776 QDF_STATUS status = QDF_STATUS_E_FAILURE; 777 778 dfs = wlan_pdev_get_dfs_obj(pdev); 779 if (!dfs) { 780 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 781 return status; 782 } 783 784 psoc = wlan_pdev_get_psoc(pdev); 785 if (!psoc) { 786 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 787 return status; 788 } 789 790 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 791 if (dfs_tx_ops && dfs_tx_ops->dfs_send_avg_radar_params_to_fw) 792 status = dfs_tx_ops->dfs_send_avg_radar_params_to_fw(pdev, 793 params); 794 795 if (QDF_IS_STATUS_SUCCESS(status)) { 796 dfs->dfs_average_params_sent = 1; 797 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, 798 "Average radar parameters sent %d", 799 dfs->dfs_average_params_sent); 800 } 801 802 return status; 803 } 804 805 qdf_export_symbol(tgt_dfs_send_avg_params_to_fw); 806 807 QDF_STATUS tgt_dfs_action_on_status_from_fw(struct wlan_objmgr_pdev *pdev, 808 uint32_t *status) 809 { 810 struct wlan_dfs *dfs; 811 812 dfs = wlan_pdev_get_dfs_obj(pdev); 813 if (!dfs) { 814 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 815 return QDF_STATUS_E_FAILURE; 816 } 817 818 dfs_action_on_fw_radar_status_check(dfs, status); 819 820 return QDF_STATUS_SUCCESS; 821 } 822 823 qdf_export_symbol(tgt_dfs_action_on_status_from_fw); 824 825 QDF_STATUS tgt_dfs_reset_spoof_test(struct wlan_objmgr_pdev *pdev) 826 { 827 struct wlan_dfs *dfs; 828 829 if (!tgt_dfs_is_pdev_5ghz(pdev)) 830 return QDF_STATUS_SUCCESS; 831 832 dfs = wlan_pdev_get_dfs_obj(pdev); 833 if (!dfs) { 834 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 835 return QDF_STATUS_E_FAILURE; 836 } 837 838 dfs_reset_spoof_test(dfs); 839 840 return QDF_STATUS_SUCCESS; 841 } 842 843 qdf_export_symbol(tgt_dfs_reset_spoof_test); 844 #endif 845 846 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 847 QDF_STATUS tgt_dfs_send_usenol_pdev_param(struct wlan_objmgr_pdev *pdev, 848 bool usenol) 849 { 850 struct wlan_objmgr_psoc *psoc; 851 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 852 853 psoc = wlan_pdev_get_psoc(pdev); 854 if (!psoc) { 855 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 856 return QDF_STATUS_E_FAILURE; 857 } 858 859 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 860 if (dfs_tx_ops && dfs_tx_ops->dfs_send_usenol_pdev_param) 861 return dfs_tx_ops->dfs_send_usenol_pdev_param(pdev, usenol); 862 863 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 864 "dfs_tx_ops=%pK", dfs_tx_ops); 865 866 return QDF_STATUS_E_FAILURE; 867 } 868 869 qdf_export_symbol(tgt_dfs_send_usenol_pdev_param); 870 871 QDF_STATUS tgt_dfs_send_subchan_marking(struct wlan_objmgr_pdev *pdev, 872 bool subchanmark) 873 { 874 struct wlan_objmgr_psoc *psoc; 875 struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops; 876 877 psoc = wlan_pdev_get_psoc(pdev); 878 if (!psoc) { 879 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 880 return QDF_STATUS_E_FAILURE; 881 } 882 883 dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc); 884 if (!dfs_tx_ops) { 885 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 886 "dfs_tx_ops=%pK", dfs_tx_ops); 887 return QDF_STATUS_E_FAILURE; 888 } 889 890 if (dfs_tx_ops->dfs_send_subchan_marking_pdev_param) 891 return dfs_tx_ops->dfs_send_subchan_marking_pdev_param( 892 pdev, subchanmark); 893 894 dfs_debug(NULL, WLAN_DEBUG_DFS_ALWAYS, 895 "dfs_send_subchan_marking_pdev_param is null"); 896 897 return QDF_STATUS_E_FAILURE; 898 } 899 900 qdf_export_symbol(tgt_dfs_send_subchan_marking); 901 #endif 902 903 void tgt_dfs_enable_stadfs(struct wlan_objmgr_pdev *pdev, bool val) 904 { 905 struct wlan_dfs *dfs; 906 907 dfs = wlan_pdev_get_dfs_obj(pdev); 908 if (!dfs) { 909 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 910 return; 911 } 912 913 dfs->dfs_is_stadfs_enabled = val; 914 } 915 916 bool tgt_dfs_is_stadfs_enabled(struct wlan_objmgr_pdev *pdev) 917 { 918 struct wlan_dfs *dfs; 919 920 dfs = wlan_pdev_get_dfs_obj(pdev); 921 if (!dfs) { 922 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 923 return false; 924 } 925 926 return dfs->dfs_is_stadfs_enabled; 927 } 928 929 #ifdef QCA_SUPPORT_AGILE_DFS 930 void tgt_dfs_set_fw_adfs_support(struct wlan_objmgr_pdev *pdev, 931 bool fw_adfs_support_160, 932 bool fw_adfs_support_non_160) 933 { 934 struct wlan_dfs *dfs; 935 936 dfs = wlan_pdev_get_dfs_obj(pdev); 937 if (!dfs) { 938 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 939 return; 940 } 941 942 dfs_set_fw_adfs_support(dfs, 943 fw_adfs_support_160, 944 fw_adfs_support_non_160); 945 } 946 947 qdf_export_symbol(tgt_dfs_set_fw_adfs_support); 948 #endif 949 950 void tgt_dfs_init_tmp_psoc_nol(struct wlan_objmgr_pdev *pdev, 951 uint8_t num_radios) 952 { 953 struct wlan_dfs *dfs; 954 955 dfs = wlan_pdev_get_dfs_obj(pdev); 956 if (!dfs) { 957 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 958 return; 959 } 960 961 dfs_init_tmp_psoc_nol(dfs, num_radios); 962 } 963 964 qdf_export_symbol(tgt_dfs_init_tmp_psoc_nol); 965 966 void tgt_dfs_deinit_tmp_psoc_nol(struct wlan_objmgr_pdev *pdev) 967 { 968 struct wlan_dfs *dfs; 969 970 dfs = wlan_pdev_get_dfs_obj(pdev); 971 if (!dfs) { 972 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 973 return; 974 } 975 976 dfs_deinit_tmp_psoc_nol(dfs); 977 } 978 979 qdf_export_symbol(tgt_dfs_deinit_tmp_psoc_nol); 980 981 void tgt_dfs_save_dfs_nol_in_psoc(struct wlan_objmgr_pdev *pdev, 982 uint8_t pdev_id) 983 { 984 struct wlan_dfs *dfs; 985 986 dfs = wlan_pdev_get_dfs_obj(pdev); 987 if (!dfs) { 988 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 989 return; 990 } 991 992 dfs_save_dfs_nol_in_psoc(dfs, pdev_id); 993 } 994 995 qdf_export_symbol(tgt_dfs_save_dfs_nol_in_psoc); 996 997 void tgt_dfs_reinit_nol_from_psoc_copy(struct wlan_objmgr_pdev *pdev, 998 uint8_t pdev_id, 999 uint16_t low_5ghz_freq, 1000 uint16_t high_5ghz_freq) 1001 { 1002 struct wlan_dfs *dfs; 1003 1004 dfs = wlan_pdev_get_dfs_obj(pdev); 1005 if (!dfs) { 1006 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 1007 return; 1008 } 1009 1010 dfs_reinit_nol_from_psoc_copy(dfs, 1011 pdev_id, 1012 low_5ghz_freq, 1013 high_5ghz_freq); 1014 } 1015 1016 qdf_export_symbol(tgt_dfs_reinit_nol_from_psoc_copy); 1017 1018 void tgt_dfs_reinit_precac_lists(struct wlan_objmgr_pdev *src_pdev, 1019 struct wlan_objmgr_pdev *dest_pdev, 1020 uint16_t low_5g_freq, 1021 uint16_t high_5g_freq) 1022 { 1023 struct wlan_dfs *src_dfs, *dest_dfs; 1024 1025 src_dfs = wlan_pdev_get_dfs_obj(src_pdev); 1026 if (!src_dfs) { 1027 dfs_err(src_dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 1028 return; 1029 } 1030 dest_dfs = wlan_pdev_get_dfs_obj(dest_pdev); 1031 if (!dest_dfs) { 1032 dfs_err(dest_dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 1033 return; 1034 } 1035 1036 dfs_reinit_precac_lists(src_dfs, dest_dfs, low_5g_freq, high_5g_freq); 1037 } 1038 1039 void tgt_dfs_complete_deferred_tasks(struct wlan_objmgr_pdev *pdev) 1040 { 1041 struct wlan_dfs *dfs; 1042 1043 dfs = wlan_pdev_get_dfs_obj(pdev); 1044 if (!dfs) { 1045 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 1046 return; 1047 } 1048 1049 dfs_complete_deferred_tasks(dfs); 1050 } 1051