1 /* 2 * Copyright (c) 2016-2021 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_5ghz_supported_in_pdev(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_5ghz_supported_in_pdev(pdev)) { 172 *buff = false; 173 return QDF_STATUS_SUCCESS; 174 } 175 176 dfs = wlan_pdev_get_dfs_obj(pdev); 177 if (!dfs) { 178 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 179 *buff = false; 180 return QDF_STATUS_SUCCESS; 181 } 182 183 *buff = dfs_is_agile_precac_enabled(dfs); 184 185 return QDF_STATUS_SUCCESS; 186 } 187 188 qdf_export_symbol(ucfg_dfs_get_agile_precac_enable); 189 190 QDF_STATUS 191 ucfg_dfs_set_nol_subchannel_marking(struct wlan_objmgr_pdev *pdev, 192 bool nol_subchannel_marking) 193 { 194 struct wlan_dfs *dfs; 195 196 dfs = wlan_pdev_get_dfs_obj(pdev); 197 if (!dfs) 198 return QDF_STATUS_E_FAILURE; 199 200 dfs_set_nol_subchannel_marking(dfs, nol_subchannel_marking); 201 202 return QDF_STATUS_SUCCESS; 203 } 204 qdf_export_symbol(ucfg_dfs_set_nol_subchannel_marking); 205 206 QDF_STATUS ucfg_dfs_get_nol_subchannel_marking(struct wlan_objmgr_pdev *pdev, 207 bool *nol_subchannel_marking) 208 { 209 struct wlan_dfs *dfs; 210 211 dfs = wlan_pdev_get_dfs_obj(pdev); 212 if (!dfs) 213 return QDF_STATUS_E_FAILURE; 214 215 dfs_get_nol_subchannel_marking(dfs, nol_subchannel_marking); 216 217 return QDF_STATUS_SUCCESS; 218 } 219 qdf_export_symbol(ucfg_dfs_get_nol_subchannel_marking); 220 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 221 QDF_STATUS ucfg_dfs_set_precac_intermediate_chan(struct wlan_objmgr_pdev *pdev, 222 uint32_t value) 223 { 224 struct wlan_dfs *dfs; 225 226 dfs = wlan_pdev_get_dfs_obj(pdev); 227 if (!dfs) { 228 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 229 return QDF_STATUS_E_FAILURE; 230 } 231 232 dfs_set_precac_intermediate_chan(dfs, value); 233 234 return QDF_STATUS_SUCCESS; 235 } 236 237 QDF_STATUS ucfg_dfs_get_precac_intermediate_chan(struct wlan_objmgr_pdev *pdev, 238 int *buff) 239 { 240 struct wlan_dfs *dfs; 241 242 dfs = wlan_pdev_get_dfs_obj(pdev); 243 if (!dfs) { 244 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 245 return QDF_STATUS_E_FAILURE; 246 } 247 248 *buff = dfs_get_precac_intermediate_chan(dfs); 249 250 return QDF_STATUS_SUCCESS; 251 } 252 253 #ifdef CONFIG_CHAN_FREQ_API 254 enum precac_chan_state 255 ucfg_dfs_get_precac_chan_state_for_freq(struct wlan_objmgr_pdev *pdev, 256 uint16_t precac_chan_freq) 257 { 258 struct wlan_dfs *dfs; 259 enum precac_chan_state retval = PRECAC_ERR; 260 261 dfs = wlan_pdev_get_dfs_obj(pdev); 262 if (!dfs) { 263 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 264 return PRECAC_ERR; 265 } 266 267 retval = dfs_get_precac_chan_state_for_freq(dfs, precac_chan_freq); 268 if (retval == PRECAC_ERR) { 269 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 270 "Could not find precac channel state"); 271 } 272 273 return retval; 274 } 275 #endif 276 #endif 277 278 #ifdef MOBILE_DFS_SUPPORT 279 QDF_STATUS ucfg_dfs_update_config(struct wlan_objmgr_psoc *psoc, 280 struct dfs_user_config *req) 281 { 282 struct dfs_soc_priv_obj *soc_obj; 283 284 if (!psoc || !req) { 285 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 286 "psoc: 0x%pK, req: 0x%pK", psoc, req); 287 return QDF_STATUS_E_FAILURE; 288 } 289 290 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 291 WLAN_UMAC_COMP_DFS); 292 if (!soc_obj) { 293 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 294 "Failed to get dfs psoc component"); 295 return QDF_STATUS_E_FAILURE; 296 } 297 298 soc_obj->dfs_is_phyerr_filter_offload = 299 req->dfs_is_phyerr_filter_offload; 300 301 return QDF_STATUS_SUCCESS; 302 } 303 qdf_export_symbol(ucfg_dfs_update_config); 304 #endif 305 306 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 307 QDF_STATUS ucfg_dfs_set_override_status_timeout(struct wlan_objmgr_pdev *pdev, 308 int status_timeout) 309 { 310 struct wlan_dfs *dfs; 311 312 dfs = wlan_pdev_get_dfs_obj(pdev); 313 if (!dfs) { 314 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 315 return QDF_STATUS_E_FAILURE; 316 } 317 318 dfs_set_override_status_timeout(dfs, status_timeout); 319 320 return QDF_STATUS_SUCCESS; 321 } 322 323 qdf_export_symbol(ucfg_dfs_set_override_status_timeout); 324 325 QDF_STATUS ucfg_dfs_get_override_status_timeout(struct wlan_objmgr_pdev *pdev, 326 int *status_timeout) 327 { 328 struct wlan_dfs *dfs; 329 330 dfs = wlan_pdev_get_dfs_obj(pdev); 331 if (!dfs) { 332 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 333 return QDF_STATUS_E_FAILURE; 334 } 335 336 dfs_get_override_status_timeout(dfs, status_timeout); 337 338 return QDF_STATUS_SUCCESS; 339 } 340 341 qdf_export_symbol(ucfg_dfs_get_override_status_timeout); 342 #endif 343 344 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(WLAN_DFS_SYNTHETIC_RADAR) 345 void ucfg_dfs_allow_hw_pulses(struct wlan_objmgr_pdev *pdev, 346 bool allow_hw_pulses) 347 { 348 struct wlan_dfs *dfs; 349 350 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 351 return; 352 353 dfs = wlan_pdev_get_dfs_obj(pdev); 354 if (!dfs) { 355 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 356 return; 357 } 358 359 dfs_allow_hw_pulses(dfs, allow_hw_pulses); 360 } 361 362 qdf_export_symbol(ucfg_dfs_allow_hw_pulses); 363 364 bool ucfg_dfs_is_hw_pulses_allowed(struct wlan_objmgr_pdev *pdev) 365 { 366 struct wlan_dfs *dfs; 367 368 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 369 return false; 370 371 dfs = wlan_pdev_get_dfs_obj(pdev); 372 if (!dfs) { 373 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 374 return false; 375 } 376 377 return dfs_is_hw_pulses_allowed(dfs); 378 } 379 380 qdf_export_symbol(ucfg_dfs_is_hw_pulses_allowed); 381 #endif 382 383 #ifdef QCA_SUPPORT_AGILE_DFS 384 QDF_STATUS ucfg_dfs_reset_agile_config(struct wlan_objmgr_psoc *psoc) 385 { 386 struct dfs_soc_priv_obj *soc_obj; 387 388 if (!psoc) { 389 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "psoc is null"); 390 return QDF_STATUS_E_FAILURE; 391 } 392 393 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 394 WLAN_UMAC_COMP_DFS); 395 if (!soc_obj) { 396 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 397 "Failed to get dfs psoc component"); 398 return QDF_STATUS_E_FAILURE; 399 } 400 401 dfs_reset_agile_config(soc_obj); 402 403 return QDF_STATUS_SUCCESS; 404 } 405 406 qdf_export_symbol(ucfg_dfs_reset_agile_config); 407 #endif 408 409 QDF_STATUS ucfg_dfs_reinit_timers(struct wlan_objmgr_pdev *pdev) 410 { 411 struct wlan_dfs *dfs; 412 413 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) 414 return QDF_STATUS_SUCCESS; 415 416 dfs = wlan_pdev_get_dfs_obj(pdev); 417 if (!dfs) { 418 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); 419 return QDF_STATUS_E_FAILURE; 420 } 421 422 dfs_reinit_timers(dfs); 423 424 return QDF_STATUS_SUCCESS; 425 } 426 427 qdf_export_symbol(ucfg_dfs_reinit_timers); 428 429 #ifdef QCA_SUPPORT_ADFS_RCAC 430 QDF_STATUS ucfg_dfs_set_rcac_enable(struct wlan_objmgr_pdev *pdev, 431 bool rcac_en) 432 { 433 struct wlan_dfs *dfs; 434 435 dfs = wlan_pdev_get_dfs_obj(pdev); 436 if (!dfs) { 437 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 438 return QDF_STATUS_E_FAILURE; 439 } 440 441 dfs_set_rcac_enable(dfs, rcac_en); 442 443 return QDF_STATUS_SUCCESS; 444 } 445 446 qdf_export_symbol(ucfg_dfs_set_rcac_enable); 447 448 QDF_STATUS ucfg_dfs_get_rcac_enable(struct wlan_objmgr_pdev *pdev, 449 bool *rcac_en) 450 { 451 struct wlan_dfs *dfs; 452 453 if (!tgt_dfs_is_5ghz_supported_in_pdev(pdev)) { 454 *rcac_en = false; 455 return QDF_STATUS_SUCCESS; 456 } 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_get_rcac_enable(dfs, rcac_en); 465 466 return QDF_STATUS_SUCCESS; 467 } 468 469 qdf_export_symbol(ucfg_dfs_get_rcac_enable); 470 471 QDF_STATUS ucfg_dfs_set_rcac_freq(struct wlan_objmgr_pdev *pdev, 472 qdf_freq_t rcac_freq) 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_set_rcac_freq(dfs, rcac_freq); 483 484 return QDF_STATUS_SUCCESS; 485 } 486 487 qdf_export_symbol(ucfg_dfs_set_rcac_freq); 488 489 QDF_STATUS ucfg_dfs_get_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_get_rcac_freq(dfs, rcac_freq); 501 502 return QDF_STATUS_SUCCESS; 503 } 504 505 qdf_export_symbol(ucfg_dfs_get_rcac_freq); 506 507 bool ucfg_dfs_is_agile_rcac_enabled(struct wlan_objmgr_pdev *pdev) 508 { 509 struct wlan_dfs *dfs; 510 511 dfs = wlan_pdev_get_dfs_obj(pdev); 512 if (!dfs) { 513 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 514 return false; 515 } 516 517 return dfs_is_agile_rcac_enabled(dfs); 518 } 519 520 qdf_export_symbol(ucfg_dfs_is_agile_rcac_enabled); 521 #endif 522 523