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_vdev_obj.h> 25 #include "wlan_dfs_utils_api.h" 26 #include "wlan_dfs_init_deinit_api.h" 27 #include "wlan_dfs_mlme_api.h" 28 #include "../../core/src/dfs.h" 29 #include "../../core/src/dfs_zero_cac.h" 30 #include <wlan_reg_services_api.h> 31 #include "../../core/src/dfs_random_chan_sel.h" 32 #ifdef QCA_DFS_USE_POLICY_MANAGER 33 #include "wlan_policy_mgr_api.h" 34 #endif 35 #ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 36 #include <pld_common.h> 37 #endif 38 #include <qdf_module.h> 39 #include "wlan_dfs_lmac_api.h" 40 #include "../../core/src/dfs_internal.h" 41 42 struct dfs_nol_info { 43 uint16_t num_chans; 44 struct dfsreq_nolelem dfs_nol[DFS_MAX_NOL_CHANNEL]; 45 }; 46 47 QDF_STATUS utils_dfs_reset(struct wlan_objmgr_pdev *pdev) 48 { 49 struct wlan_dfs *dfs; 50 51 dfs = wlan_pdev_get_dfs_obj(pdev); 52 if (!dfs) 53 return QDF_STATUS_E_FAILURE; 54 55 dfs_reset(dfs); 56 dfs_nol_update(dfs); 57 dfs_reset_precaclists(dfs); 58 dfs_init_chan_state_array(pdev); 59 60 return QDF_STATUS_SUCCESS; 61 } 62 63 bool utils_dfs_is_freq_in_nol(struct wlan_objmgr_pdev *pdev, uint32_t freq) 64 { 65 struct wlan_dfs *dfs; 66 67 dfs = wlan_pdev_get_dfs_obj(pdev); 68 if (!dfs) 69 return false; 70 71 return dfs_is_freq_in_nol(dfs, freq); 72 } 73 74 #ifdef CONFIG_CHAN_NUM_API 75 QDF_STATUS utils_dfs_cac_valid_reset(struct wlan_objmgr_pdev *pdev, 76 uint8_t prevchan_ieee, 77 uint32_t prevchan_flags) 78 { 79 struct wlan_dfs *dfs; 80 81 dfs = wlan_pdev_get_dfs_obj(pdev); 82 if (!dfs) 83 return QDF_STATUS_E_FAILURE; 84 85 dfs_cac_valid_reset(dfs, prevchan_ieee, prevchan_flags); 86 87 return QDF_STATUS_SUCCESS; 88 } 89 qdf_export_symbol(utils_dfs_cac_valid_reset); 90 #endif 91 92 #ifdef CONFIG_CHAN_FREQ_API 93 QDF_STATUS utils_dfs_cac_valid_reset_for_freq(struct wlan_objmgr_pdev *pdev, 94 uint16_t prevchan_freq, 95 uint32_t prevchan_flags) 96 { 97 struct wlan_dfs *dfs; 98 99 dfs = wlan_pdev_get_dfs_obj(pdev); 100 if (!dfs) 101 return QDF_STATUS_E_FAILURE; 102 103 dfs_cac_valid_reset_for_freq(dfs, prevchan_freq, prevchan_flags); 104 105 return QDF_STATUS_SUCCESS; 106 } 107 108 qdf_export_symbol(utils_dfs_cac_valid_reset_for_freq); 109 #endif 110 111 QDF_STATUS utils_dfs_reset_precaclists(struct wlan_objmgr_pdev *pdev) 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_reset_precaclists(dfs); 120 121 return QDF_STATUS_SUCCESS; 122 } 123 qdf_export_symbol(utils_dfs_reset_precaclists); 124 125 #ifdef CONFIG_CHAN_NUM_API 126 void utils_dfs_unmark_precac_nol(struct wlan_objmgr_pdev *pdev, uint8_t chan) 127 { 128 struct wlan_dfs *dfs; 129 130 dfs = wlan_pdev_get_dfs_obj(pdev); 131 if (!dfs) 132 return; 133 134 dfs_unmark_precac_nol(dfs, chan); 135 } 136 137 qdf_export_symbol(utils_dfs_unmark_precac_nol); 138 #endif 139 140 #ifdef CONFIG_CHAN_FREQ_API 141 void utils_dfs_unmark_precac_nol_for_freq(struct wlan_objmgr_pdev *pdev, 142 uint16_t chan_freq) 143 { 144 struct wlan_dfs *dfs; 145 146 dfs = wlan_pdev_get_dfs_obj(pdev); 147 if (!dfs) 148 return; 149 150 dfs_unmark_precac_nol_for_freq(dfs, chan_freq); 151 } 152 153 qdf_export_symbol(utils_dfs_unmark_precac_nol_for_freq); 154 #endif 155 156 QDF_STATUS utils_dfs_cancel_precac_timer(struct wlan_objmgr_pdev *pdev) 157 { 158 struct wlan_dfs *dfs; 159 160 dfs = wlan_pdev_get_dfs_obj(pdev); 161 if (!dfs) 162 return QDF_STATUS_E_FAILURE; 163 164 dfs_cancel_precac_timer(dfs); 165 166 return QDF_STATUS_SUCCESS; 167 } 168 qdf_export_symbol(utils_dfs_cancel_precac_timer); 169 170 #ifdef CONFIG_CHAN_FREQ_API 171 QDF_STATUS utils_dfs_start_precac_timer(struct wlan_objmgr_pdev *pdev) 172 { 173 struct wlan_dfs *dfs; 174 175 dfs = wlan_pdev_get_dfs_obj(pdev); 176 if (!dfs) { 177 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 178 return QDF_STATUS_E_FAILURE; 179 } 180 181 if (!dfs->dfs_precac_secondary_freq_mhz) 182 return QDF_STATUS_E_FAILURE; 183 184 dfs_start_precac_timer_for_freq(dfs, 185 dfs->dfs_precac_secondary_freq_mhz); 186 return QDF_STATUS_SUCCESS; 187 } 188 #else 189 #ifdef CONFIG_CHAN_NUM_API 190 QDF_STATUS utils_dfs_start_precac_timer(struct wlan_objmgr_pdev *pdev) 191 { 192 struct wlan_dfs *dfs; 193 194 dfs = wlan_pdev_get_dfs_obj(pdev); 195 if (!dfs) { 196 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 197 return QDF_STATUS_E_FAILURE; 198 } 199 200 if (!dfs->dfs_precac_secondary_freq) 201 return QDF_STATUS_E_FAILURE; 202 dfs_start_precac_timer(dfs, 203 dfs->dfs_precac_secondary_freq); 204 return QDF_STATUS_SUCCESS; 205 } 206 #endif 207 #endif 208 209 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 210 #ifdef CONFIG_CHAN_NUM_API 211 bool 212 utils_dfs_precac_decide_pref_chan(struct wlan_objmgr_pdev *pdev, 213 uint8_t *ch_ieee, 214 enum wlan_phymode mode) 215 { 216 struct wlan_dfs *dfs; 217 218 dfs = wlan_pdev_get_dfs_obj(pdev); 219 if (!dfs) { 220 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 221 return false; 222 } 223 return dfs_decide_precac_preferred_chan(dfs, ch_ieee, mode); 224 } 225 #endif 226 227 #ifdef CONFIG_CHAN_FREQ_API 228 bool 229 utils_dfs_precac_decide_pref_chan_for_freq(struct wlan_objmgr_pdev *pdev, 230 uint16_t *chan_freq, 231 enum wlan_phymode mode) 232 { 233 struct wlan_dfs *dfs; 234 235 dfs = wlan_pdev_get_dfs_obj(pdev); 236 if (!dfs) { 237 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 238 return false; 239 } 240 return dfs_decide_precac_preferred_chan_for_freq(dfs, chan_freq, mode); 241 } 242 #endif 243 #endif 244 QDF_STATUS utils_dfs_cancel_cac_timer(struct wlan_objmgr_pdev *pdev) 245 { 246 struct wlan_dfs *dfs; 247 248 dfs = wlan_pdev_get_dfs_obj(pdev); 249 if (!dfs) 250 return QDF_STATUS_E_FAILURE; 251 252 dfs_cancel_cac_timer(dfs); 253 254 return QDF_STATUS_SUCCESS; 255 } 256 qdf_export_symbol(utils_dfs_cancel_cac_timer); 257 258 QDF_STATUS utils_dfs_start_cac_timer(struct wlan_objmgr_pdev *pdev) 259 { 260 struct wlan_dfs *dfs; 261 262 dfs = wlan_pdev_get_dfs_obj(pdev); 263 if (!dfs) 264 return QDF_STATUS_E_FAILURE; 265 266 dfs_start_cac_timer(dfs); 267 268 return QDF_STATUS_SUCCESS; 269 } 270 qdf_export_symbol(utils_dfs_start_cac_timer); 271 272 QDF_STATUS utils_dfs_cac_stop(struct wlan_objmgr_pdev *pdev) 273 { 274 struct wlan_dfs *dfs; 275 276 dfs = wlan_pdev_get_dfs_obj(pdev); 277 if (!dfs) 278 return QDF_STATUS_E_FAILURE; 279 280 dfs_cac_stop(dfs); 281 return QDF_STATUS_SUCCESS; 282 } 283 qdf_export_symbol(utils_dfs_cac_stop); 284 285 /** dfs_fill_chan_info() - Fill the dfs channel structure with wlan 286 * channel. 287 * @chan: Pointer to DFS channel structure. 288 * @wlan_chan: Pointer to WLAN Channel structure. 289 * 290 * Return: void 291 */ 292 #ifdef CONFIG_CHAN_FREQ_API 293 static void dfs_fill_chan_info(struct dfs_channel *chan, 294 struct wlan_channel *wlan_chan) 295 { 296 chan->dfs_ch_freq = wlan_chan->ch_freq; 297 chan->dfs_ch_flags = wlan_chan->ch_flags; 298 chan->dfs_ch_flagext = wlan_chan->ch_flagext; 299 chan->dfs_ch_ieee = wlan_chan->ch_ieee; 300 chan->dfs_ch_vhtop_ch_freq_seg1 = wlan_chan->ch_freq_seg1; 301 chan->dfs_ch_vhtop_ch_freq_seg2 = wlan_chan->ch_freq_seg2; 302 chan->dfs_ch_mhz_freq_seg1 = wlan_chan->ch_cfreq1; 303 chan->dfs_ch_mhz_freq_seg2 = wlan_chan->ch_cfreq2; 304 } 305 #else 306 #ifdef CONFIG_CHAN_NUM_API 307 static void dfs_fill_chan_info(struct dfs_channel *chan, 308 struct wlan_channel *wlan_chan) 309 { 310 chan->dfs_ch_freq = wlan_chan->ch_freq; 311 chan->dfs_ch_flags = wlan_chan->ch_flags; 312 chan->dfs_ch_flagext = wlan_chan->ch_flagext; 313 chan->dfs_ch_ieee = wlan_chan->ch_ieee; 314 chan->dfs_ch_vhtop_ch_freq_seg1 = wlan_chan->ch_freq_seg1; 315 chan->dfs_ch_vhtop_ch_freq_seg2 = wlan_chan->ch_freq_seg2; 316 } 317 #endif 318 #endif 319 320 bool utils_dfs_is_precac_done(struct wlan_objmgr_pdev *pdev, 321 struct wlan_channel *wlan_chan) 322 { 323 struct wlan_dfs *dfs; 324 struct dfs_channel chan; 325 326 dfs = wlan_pdev_get_dfs_obj(pdev); 327 if (!dfs) 328 return false; 329 330 dfs_fill_chan_info(&chan, wlan_chan); 331 332 return dfs_is_precac_done(dfs, &chan); 333 } 334 335 bool utils_dfs_is_cac_required(struct wlan_objmgr_pdev *pdev, 336 struct wlan_channel *cur_chan, 337 struct wlan_channel *prev_chan, 338 bool *continue_current_cac) 339 { 340 struct wlan_dfs *dfs; 341 struct dfs_channel cur_channel; 342 struct dfs_channel prev_channel; 343 344 dfs = wlan_pdev_get_dfs_obj(pdev); 345 if (!dfs) 346 return false; 347 348 dfs_fill_chan_info(&cur_channel, cur_chan); 349 dfs_fill_chan_info(&prev_channel, prev_chan); 350 351 return dfs_is_cac_required(dfs, 352 &cur_channel, 353 &prev_channel, 354 continue_current_cac); 355 } 356 357 bool 358 utils_dfs_is_cac_required_on_dfs_curchan(struct wlan_objmgr_pdev *pdev, 359 bool *continue_current_cac) 360 { 361 struct wlan_dfs *dfs; 362 363 dfs = wlan_pdev_get_dfs_obj(pdev); 364 if (!dfs) 365 return false; 366 367 return dfs_is_cac_required(dfs, 368 dfs->dfs_curchan, 369 dfs->dfs_prevchan, 370 continue_current_cac); 371 } 372 373 QDF_STATUS utils_dfs_stacac_stop(struct wlan_objmgr_pdev *pdev) 374 { 375 struct wlan_dfs *dfs; 376 377 dfs = wlan_pdev_get_dfs_obj(pdev); 378 if (!dfs) 379 return QDF_STATUS_E_FAILURE; 380 381 dfs_stacac_stop(dfs); 382 383 return QDF_STATUS_SUCCESS; 384 } 385 qdf_export_symbol(utils_dfs_stacac_stop); 386 387 QDF_STATUS utils_dfs_get_usenol(struct wlan_objmgr_pdev *pdev, uint16_t *usenol) 388 { 389 struct wlan_dfs *dfs; 390 391 dfs = wlan_pdev_get_dfs_obj(pdev); 392 if (!dfs) 393 return QDF_STATUS_E_FAILURE; 394 395 *usenol = dfs_get_use_nol(dfs); 396 397 return QDF_STATUS_SUCCESS; 398 } 399 qdf_export_symbol(utils_dfs_get_usenol); 400 401 QDF_STATUS utils_dfs_radar_disable(struct wlan_objmgr_pdev *pdev) 402 { 403 struct wlan_dfs *dfs; 404 405 dfs = wlan_pdev_get_dfs_obj(pdev); 406 if (!dfs) 407 return QDF_STATUS_E_FAILURE; 408 409 dfs_radar_disable(dfs); 410 411 return QDF_STATUS_SUCCESS; 412 } 413 qdf_export_symbol(utils_dfs_radar_disable); 414 415 QDF_STATUS utils_dfs_set_update_nol_flag(struct wlan_objmgr_pdev *pdev, 416 bool val) 417 { 418 struct wlan_dfs *dfs; 419 420 dfs = wlan_pdev_get_dfs_obj(pdev); 421 if (!dfs) 422 return QDF_STATUS_E_FAILURE; 423 424 dfs_set_update_nol_flag(dfs, val); 425 426 return QDF_STATUS_SUCCESS; 427 } 428 qdf_export_symbol(utils_dfs_set_update_nol_flag); 429 430 QDF_STATUS utils_dfs_get_update_nol_flag(struct wlan_objmgr_pdev *pdev, 431 bool *nol_flag) 432 { 433 struct wlan_dfs *dfs; 434 435 dfs = wlan_pdev_get_dfs_obj(pdev); 436 if (!dfs) 437 return QDF_STATUS_E_FAILURE; 438 439 *nol_flag = dfs_get_update_nol_flag(dfs); 440 441 return QDF_STATUS_SUCCESS; 442 } 443 qdf_export_symbol(utils_dfs_get_update_nol_flag); 444 445 QDF_STATUS utils_dfs_get_dfs_use_nol(struct wlan_objmgr_pdev *pdev, 446 int *dfs_use_nol) 447 { 448 struct wlan_dfs *dfs; 449 450 dfs = wlan_pdev_get_dfs_obj(pdev); 451 if (!dfs) 452 return QDF_STATUS_E_FAILURE; 453 454 *dfs_use_nol = dfs_get_use_nol(dfs); 455 456 return QDF_STATUS_SUCCESS; 457 } 458 qdf_export_symbol(utils_dfs_get_dfs_use_nol); 459 460 QDF_STATUS utils_dfs_get_nol_timeout(struct wlan_objmgr_pdev *pdev, 461 int *dfs_nol_timeout) 462 { 463 struct wlan_dfs *dfs; 464 465 dfs = wlan_pdev_get_dfs_obj(pdev); 466 if (!dfs) 467 return QDF_STATUS_E_FAILURE; 468 469 *dfs_nol_timeout = dfs_get_nol_timeout(dfs); 470 471 return QDF_STATUS_SUCCESS; 472 } 473 qdf_export_symbol(utils_dfs_get_nol_timeout); 474 475 QDF_STATUS utils_dfs_nol_addchan(struct wlan_objmgr_pdev *pdev, 476 uint16_t freq, 477 uint32_t dfs_nol_timeout) 478 { 479 struct wlan_dfs *dfs; 480 481 dfs = wlan_pdev_get_dfs_obj(pdev); 482 if (!dfs) 483 return QDF_STATUS_E_FAILURE; 484 485 DFS_NOL_ADD_CHAN_LOCKED(dfs, freq, dfs_nol_timeout); 486 487 return QDF_STATUS_SUCCESS; 488 } 489 qdf_export_symbol(utils_dfs_nol_addchan); 490 491 QDF_STATUS utils_dfs_nol_update(struct wlan_objmgr_pdev *pdev) 492 { 493 struct wlan_dfs *dfs; 494 495 dfs = wlan_pdev_get_dfs_obj(pdev); 496 if (!dfs) 497 return QDF_STATUS_E_FAILURE; 498 499 dfs_nol_update(dfs); 500 501 return QDF_STATUS_SUCCESS; 502 } 503 qdf_export_symbol(utils_dfs_nol_update); 504 505 QDF_STATUS utils_dfs_second_segment_radar_disable(struct wlan_objmgr_pdev *pdev) 506 { 507 struct wlan_dfs *dfs; 508 509 dfs = wlan_pdev_get_dfs_obj(pdev); 510 if (!dfs) 511 return QDF_STATUS_E_FAILURE; 512 513 dfs_second_segment_radar_disable(dfs); 514 515 return QDF_STATUS_SUCCESS; 516 } 517 518 QDF_STATUS utils_dfs_bw_reduce(struct wlan_objmgr_pdev *pdev, bool bw_reduce) 519 { 520 struct wlan_dfs *dfs; 521 522 dfs = wlan_pdev_get_dfs_obj(pdev); 523 if (!dfs) 524 return QDF_STATUS_E_FAILURE; 525 526 dfs->dfs_bw_reduced = bw_reduce; 527 528 return QDF_STATUS_SUCCESS; 529 } 530 531 qdf_export_symbol(utils_dfs_bw_reduce); 532 533 QDF_STATUS utils_dfs_is_bw_reduce(struct wlan_objmgr_pdev *pdev, 534 bool *bw_reduce) 535 { 536 struct wlan_dfs *dfs; 537 538 dfs = wlan_pdev_get_dfs_obj(pdev); 539 if (!dfs) 540 return QDF_STATUS_E_FAILURE; 541 542 *bw_reduce = dfs->dfs_bw_reduced; 543 544 return QDF_STATUS_SUCCESS; 545 } 546 547 QDF_STATUS utils_dfs_fetch_nol_ie_info(struct wlan_objmgr_pdev *pdev, 548 uint8_t *nol_ie_bandwidth, 549 uint16_t *nol_ie_startfreq, 550 uint8_t *nol_ie_bitmap) 551 { 552 struct wlan_dfs *dfs; 553 554 dfs = wlan_pdev_get_dfs_obj(pdev); 555 if (!dfs) 556 return QDF_STATUS_E_FAILURE; 557 558 dfs_fetch_nol_ie_info(dfs, nol_ie_bandwidth, nol_ie_startfreq, 559 nol_ie_bitmap); 560 561 return QDF_STATUS_SUCCESS; 562 } 563 564 QDF_STATUS utils_dfs_set_rcsa_flags(struct wlan_objmgr_pdev *pdev, 565 bool is_rcsa_ie_sent, 566 bool is_nol_ie_sent) 567 { 568 struct wlan_dfs *dfs; 569 570 dfs = wlan_pdev_get_dfs_obj(pdev); 571 if (!dfs) 572 return QDF_STATUS_E_FAILURE; 573 574 dfs_set_rcsa_flags(dfs, is_rcsa_ie_sent, is_nol_ie_sent); 575 576 return QDF_STATUS_SUCCESS; 577 } 578 579 QDF_STATUS utils_dfs_get_rcsa_flags(struct wlan_objmgr_pdev *pdev, 580 bool *is_rcsa_ie_sent, 581 bool *is_nol_ie_sent) 582 { 583 struct wlan_dfs *dfs; 584 585 dfs = wlan_pdev_get_dfs_obj(pdev); 586 if (!dfs) 587 return QDF_STATUS_E_FAILURE; 588 dfs_get_rcsa_flags(dfs, is_rcsa_ie_sent, is_nol_ie_sent); 589 590 return QDF_STATUS_SUCCESS; 591 } 592 593 bool utils_dfs_process_nol_ie_bitmap(struct wlan_objmgr_pdev *pdev, 594 uint8_t nol_ie_bandwidth, 595 uint16_t nol_ie_startfreq, 596 uint8_t nol_ie_bitmap) 597 { 598 struct wlan_dfs *dfs; 599 600 dfs = wlan_pdev_get_dfs_obj(pdev); 601 if (!dfs) 602 return false; 603 return dfs_process_nol_ie_bitmap(dfs, nol_ie_bandwidth, 604 nol_ie_startfreq, 605 nol_ie_bitmap); 606 } 607 608 QDF_STATUS utils_dfs_set_cac_timer_running(struct wlan_objmgr_pdev *pdev, 609 int val) 610 { 611 struct wlan_dfs *dfs; 612 613 dfs = wlan_pdev_get_dfs_obj(pdev); 614 if (!dfs) 615 return QDF_STATUS_E_FAILURE; 616 617 dfs->dfs_cac_timer_running = val; 618 619 return QDF_STATUS_SUCCESS; 620 } 621 qdf_export_symbol(utils_dfs_set_cac_timer_running); 622 623 QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev, 624 void *nollist, 625 uint32_t *nol_chfreq, 626 uint32_t *nol_chwidth, 627 int index) 628 { 629 struct wlan_dfs *dfs; 630 631 dfs = wlan_pdev_get_dfs_obj(pdev); 632 if (!dfs) 633 return QDF_STATUS_E_FAILURE; 634 635 dfs_get_nol_chfreq_and_chwidth(nollist, nol_chfreq, nol_chwidth, index); 636 637 return QDF_STATUS_SUCCESS; 638 } 639 qdf_export_symbol(utils_dfs_get_nol_chfreq_and_chwidth); 640 641 QDF_STATUS utils_dfs_update_cur_chan_flags(struct wlan_objmgr_pdev *pdev, 642 uint64_t flags, 643 uint16_t flagext) 644 { 645 struct wlan_dfs *dfs; 646 647 dfs = wlan_pdev_get_dfs_obj(pdev); 648 if (!dfs) 649 return QDF_STATUS_E_FAILURE; 650 651 dfs_update_cur_chan_flags(dfs, flags, flagext); 652 653 return QDF_STATUS_SUCCESS; 654 } 655 656 static void utils_dfs_get_max_phy_mode(struct wlan_objmgr_pdev *pdev, 657 uint32_t *phy_mode) 658 { 659 return; 660 } 661 662 static void utils_dfs_get_max_sup_width(struct wlan_objmgr_pdev *pdev, 663 uint8_t *ch_width) 664 { 665 return; 666 } 667 668 #ifndef QCA_DFS_USE_POLICY_MANAGER 669 void utils_dfs_get_nol_history_chan_list(struct wlan_objmgr_pdev *pdev, 670 void *clist, uint32_t *num_chan) 671 { 672 int i, j = 0; 673 struct regulatory_channel *cur_chan_list; 674 struct wlan_dfs *dfs; 675 struct dfs_channel *chan_list = (struct dfs_channel *)clist; 676 677 *num_chan = 0; 678 679 dfs = wlan_pdev_get_dfs_obj(pdev); 680 if (!dfs) 681 return; 682 683 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * sizeof(*cur_chan_list)); 684 if (!cur_chan_list) 685 return; 686 687 if (wlan_reg_get_current_chan_list( 688 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 689 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 690 "failed to get cur_chan list"); 691 qdf_mem_free(cur_chan_list); 692 return; 693 } 694 695 for (i = 0; i < NUM_CHANNELS; i++) { 696 if (cur_chan_list[i].nol_history) { 697 chan_list[j].dfs_ch_freq = cur_chan_list[i].center_freq; 698 j++; 699 } 700 } 701 702 *num_chan = j; 703 qdf_mem_free(cur_chan_list); 704 } 705 706 void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 707 void *clist, uint32_t *num_chan) 708 { 709 int i = 0, j = 0; 710 enum channel_state state; 711 struct regulatory_channel *cur_chan_list; 712 struct wlan_dfs *dfs; 713 struct dfs_channel *chan_list = (struct dfs_channel *)clist; 714 715 dfs = wlan_pdev_get_dfs_obj(pdev); 716 if (!dfs) 717 return; 718 719 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * 720 sizeof(struct regulatory_channel)); 721 if (!cur_chan_list) { 722 *num_chan = 0; 723 return; 724 } 725 726 if (wlan_reg_get_current_chan_list( 727 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 728 *num_chan = 0; 729 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 730 "failed to get curr channel list"); 731 return; 732 } 733 734 for (i = 0; i < NUM_CHANNELS; i++) { 735 state = cur_chan_list[i].state; 736 if (state == CHANNEL_STATE_DFS || 737 state == CHANNEL_STATE_ENABLE) { 738 chan_list[j].dfs_ch_ieee = cur_chan_list[i].chan_num; 739 chan_list[j].dfs_ch_freq = cur_chan_list[i].center_freq; 740 if (state == CHANNEL_STATE_DFS) 741 chan_list[j].dfs_ch_flagext = 742 WLAN_CHAN_DFS; 743 744 if (cur_chan_list[i].nol_history) 745 chan_list[j].dfs_ch_flagext |= 746 WLAN_CHAN_HISTORY_RADAR; 747 j++; 748 } 749 } 750 *num_chan = j; 751 qdf_mem_free(cur_chan_list); 752 753 return; 754 } 755 756 /** 757 * utils_dfs_get_channel_list() - Get channel list from regdb component, based 758 * on current channel list. 759 * @pdev: Pointer to pdev structure. 760 * @vdev: vdev of request 761 * @chan: Pointer to channel list. 762 * @num_chan: number of channels. 763 * 764 * Get regdb channel list based on dfs current channel. 765 * Ex: When AP is operating in 5GHz channel, filter 2.4GHz and 4.9GHZ channels 766 * so that the random channel function does not select either 2.4GHz or 4.9GHz 767 * channel. 768 */ 769 #ifdef CONFIG_CHAN_FREQ_API 770 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 771 struct wlan_objmgr_vdev *vdev, 772 struct dfs_channel *chan_list, 773 uint32_t *num_chan) 774 { 775 struct dfs_channel *tmp_chan_list = NULL; 776 struct wlan_dfs *dfs; 777 bool is_curchan_5g; 778 bool is_curchan_24g; 779 bool is_curchan_49g; 780 bool is_inter_band_switch_allowed; 781 uint8_t chan_num; 782 uint16_t center_freq; 783 uint16_t flagext; 784 int i, j = 0; 785 786 dfs = wlan_pdev_get_dfs_obj(pdev); 787 if (!dfs) { 788 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 789 return; 790 } 791 792 tmp_chan_list = qdf_mem_malloc(*num_chan * sizeof(*tmp_chan_list)); 793 if (!tmp_chan_list) 794 return; 795 796 utils_dfs_get_chan_list(pdev, (void *)tmp_chan_list, num_chan); 797 798 chan_num = dfs->dfs_curchan->dfs_ch_ieee; 799 center_freq = dfs->dfs_curchan->dfs_ch_freq; 800 is_curchan_5g = WLAN_REG_IS_5GHZ_CH_FREQ(center_freq); 801 is_curchan_24g = WLAN_REG_IS_24GHZ_CH_FREQ(center_freq); 802 is_curchan_49g = WLAN_REG_IS_49GHZ_FREQ(center_freq); 803 is_inter_band_switch_allowed = 804 dfs_mlme_is_inter_band_chan_switch_allowed(dfs->dfs_pdev_obj); 805 806 for (i = 0; i < *num_chan; i++) { 807 chan_num = tmp_chan_list[i].dfs_ch_ieee; 808 center_freq = tmp_chan_list[i].dfs_ch_freq; 809 flagext = tmp_chan_list[i].dfs_ch_flagext; 810 /* No change in prototype needed. Hence retaining same func */ 811 if (!dfs_mlme_check_allowed_prim_chanlist(pdev, center_freq)) 812 continue; 813 814 if (is_curchan_5g) { 815 /* 816 * Always add 5G channels. 817 * If inter band is allowed, add 6G also. 818 */ 819 if (WLAN_REG_IS_5GHZ_CH_FREQ(center_freq) || 820 (is_inter_band_switch_allowed && 821 WLAN_REG_IS_6GHZ_CHAN_FREQ(center_freq))) { 822 chan_list[j].dfs_ch_ieee = chan_num; 823 chan_list[j].dfs_ch_freq = center_freq; 824 chan_list[j].dfs_ch_flagext = flagext; 825 j++; 826 } 827 } else if ((is_curchan_24g) && 828 WLAN_REG_IS_24GHZ_CH_FREQ(center_freq)) { 829 chan_list[j].dfs_ch_ieee = chan_num; 830 chan_list[j].dfs_ch_freq = center_freq; 831 j++; 832 } else if ((is_curchan_49g) && 833 WLAN_REG_IS_49GHZ_FREQ(center_freq)) { 834 chan_list[j].dfs_ch_ieee = chan_num; 835 chan_list[j].dfs_ch_freq = center_freq; 836 j++; 837 } 838 } 839 840 *num_chan = j; 841 842 qdf_mem_free(tmp_chan_list); 843 } 844 #else /* NUM_API */ 845 #ifdef CONFIG_CHAN_NUM_API 846 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 847 struct wlan_objmgr_vdev *vdev, 848 struct dfs_channel *chan_list, 849 uint32_t *num_chan) 850 { 851 struct dfs_channel *tmp_chan_list = NULL; 852 struct wlan_dfs *dfs; 853 bool is_curchan_5g; 854 bool is_curchan_24g; 855 bool is_curchan_49g; 856 uint32_t chan_num; 857 uint32_t center_freq; 858 uint16_t flagext; 859 int i, j = 0; 860 861 dfs = wlan_pdev_get_dfs_obj(pdev); 862 if (!dfs) { 863 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 864 return; 865 } 866 867 tmp_chan_list = qdf_mem_malloc(*num_chan * sizeof(*tmp_chan_list)); 868 if (!tmp_chan_list) 869 return; 870 871 utils_dfs_get_chan_list(pdev, (void *)tmp_chan_list, num_chan); 872 873 chan_num = dfs->dfs_curchan->dfs_ch_ieee; 874 center_freq = dfs->dfs_curchan->dfs_ch_freq; 875 is_curchan_5g = WLAN_REG_IS_5GHZ_CH_FREQ(center_freq); 876 is_curchan_24g = WLAN_REG_IS_24GHZ_CH_FREQ(center_freq); 877 is_curchan_49g = WLAN_REG_IS_49GHZ_FREQ(center_freq); 878 879 for (i = 0; i < *num_chan; i++) { 880 chan_num = tmp_chan_list[i].dfs_ch_ieee; 881 center_freq = tmp_chan_list[i].dfs_ch_freq; 882 flagext = tmp_chan_list[i].dfs_ch_flagext; 883 884 if (!dfs_mlme_check_allowed_prim_chanlist(pdev, chan_num)) 885 continue; 886 887 if ((is_curchan_5g) && WLAN_REG_IS_5GHZ_CH_FREQ(center_freq)) { 888 chan_list[j].dfs_ch_ieee = chan_num; 889 chan_list[j].dfs_ch_freq = center_freq; 890 chan_list[j].dfs_ch_flagext = flagext; 891 j++; 892 } else if ((is_curchan_24g) && 893 WLAN_REG_IS_24GHZ_CH_FREQ(center_freq)) { 894 chan_list[j].dfs_ch_ieee = chan_num; 895 chan_list[j].dfs_ch_freq = center_freq; 896 j++; 897 } else if ((is_curchan_49g) && 898 WLAN_REG_IS_49GHZ_FREQ(center_freq)) { 899 chan_list[j].dfs_ch_ieee = chan_num; 900 chan_list[j].dfs_ch_freq = center_freq; 901 j++; 902 } 903 } 904 905 *num_chan = j; 906 907 qdf_mem_free(tmp_chan_list); 908 } 909 #endif 910 #endif 911 912 #else 913 914 void utils_dfs_get_nol_history_chan_list(struct wlan_objmgr_pdev *pdev, 915 void *clist, uint32_t *num_chan) 916 { 917 utils_dfs_get_chan_list(pdev, clist, num_chan); 918 } 919 920 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 921 struct wlan_objmgr_vdev *vdev, 922 struct dfs_channel *chan_list, 923 uint32_t *num_chan) 924 { 925 uint32_t pcl_ch[NUM_CHANNELS] = {0}; 926 uint8_t weight_list[NUM_CHANNELS] = {0}; 927 uint32_t len; 928 uint32_t weight_len; 929 int i; 930 struct wlan_objmgr_psoc *psoc; 931 uint32_t conn_count = 0; 932 enum policy_mgr_con_mode mode; 933 934 psoc = wlan_pdev_get_psoc(pdev); 935 if (!psoc) { 936 *num_chan = 0; 937 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 938 return; 939 } 940 941 len = QDF_ARRAY_SIZE(pcl_ch); 942 weight_len = QDF_ARRAY_SIZE(weight_list); 943 944 if (vdev) 945 mode = policy_mgr_convert_device_mode_to_qdf_type( 946 wlan_vdev_mlme_get_opmode(vdev)); 947 else 948 mode = PM_SAP_MODE; 949 conn_count = policy_mgr_mode_specific_connection_count( 950 psoc, mode, NULL); 951 if (0 == conn_count) 952 policy_mgr_get_pcl(psoc, mode, pcl_ch, 953 &len, weight_list, weight_len); 954 else 955 policy_mgr_get_pcl_for_existing_conn( 956 psoc, mode, pcl_ch, &len, weight_list, 957 weight_len, true); 958 959 if (*num_chan < len) { 960 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 961 "Invalid len src=%d, dst=%d", 962 *num_chan, len); 963 *num_chan = 0; 964 return; 965 } 966 967 for (i = 0; i < len; i++) { 968 chan_list[i].dfs_ch_ieee = 969 wlan_reg_freq_to_chan(pdev, pcl_ch[i]); 970 chan_list[i].dfs_ch_freq = pcl_ch[i]; 971 } 972 *num_chan = i; 973 dfs_info(NULL, WLAN_DEBUG_DFS_ALWAYS, "num channels %d", i); 974 } 975 976 void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 977 void *clist, uint32_t *num_chan) 978 { 979 utils_dfs_get_channel_list(pdev, NULL, (struct dfs_channel *)clist, 980 num_chan); 981 } 982 983 bool utils_dfs_can_ignore_radar_event(struct wlan_objmgr_pdev *pdev) 984 { 985 return policy_mgr_get_can_skip_radar_event( 986 wlan_pdev_get_psoc(pdev), INVALID_VDEV_ID); 987 } 988 #endif 989 990 #ifdef CONFIG_CHAN_NUM_API 991 QDF_STATUS utils_dfs_get_vdev_random_channel( 992 struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev, 993 uint16_t flags, struct ch_params *ch_params, uint32_t *hw_mode, 994 uint8_t *target_chan, struct dfs_acs_info *acs_info) 995 { 996 uint32_t dfs_reg; 997 uint32_t num_chan = NUM_CHANNELS; 998 struct wlan_dfs *dfs = NULL; 999 struct wlan_objmgr_psoc *psoc; 1000 struct dfs_channel *chan_list = NULL; 1001 struct dfs_channel cur_chan; 1002 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1003 1004 *target_chan = 0; 1005 psoc = wlan_pdev_get_psoc(pdev); 1006 if (!psoc) { 1007 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1008 goto random_chan_error; 1009 } 1010 1011 dfs = wlan_pdev_get_dfs_obj(pdev); 1012 if (!dfs) { 1013 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1014 goto random_chan_error; 1015 } 1016 1017 wlan_reg_get_dfs_region(pdev, &dfs_reg); 1018 chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list)); 1019 if (!chan_list) 1020 goto random_chan_error; 1021 1022 utils_dfs_get_channel_list(pdev, vdev, chan_list, &num_chan); 1023 if (!num_chan) { 1024 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels"); 1025 goto random_chan_error; 1026 } 1027 1028 cur_chan.dfs_ch_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0; 1029 cur_chan.dfs_ch_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1; 1030 1031 if (!ch_params->ch_width) 1032 utils_dfs_get_max_sup_width(pdev, 1033 (uint8_t *)&ch_params->ch_width); 1034 1035 *target_chan = dfs_prepare_random_channel(dfs, chan_list, 1036 num_chan, flags, (uint8_t *)&ch_params->ch_width, 1037 &cur_chan, (uint8_t)dfs_reg, acs_info); 1038 1039 ch_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1; 1040 ch_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2; 1041 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1042 "input width=%d", ch_params->ch_width); 1043 1044 if (*target_chan) { 1045 wlan_reg_set_channel_params(pdev, 1046 *target_chan, 0, ch_params); 1047 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1048 status = QDF_STATUS_SUCCESS; 1049 } 1050 1051 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1052 "ch=%d, seg0=%d, seg1=%d, width=%d", 1053 *target_chan, ch_params->center_freq_seg0, 1054 ch_params->center_freq_seg1, ch_params->ch_width); 1055 1056 random_chan_error: 1057 qdf_mem_free(chan_list); 1058 1059 return status; 1060 } 1061 1062 qdf_export_symbol(utils_dfs_get_vdev_random_channel); 1063 #endif 1064 1065 #ifdef CONFIG_CHAN_FREQ_API 1066 QDF_STATUS utils_dfs_get_vdev_random_channel_for_freq( 1067 struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev, 1068 uint16_t flags, struct ch_params *chan_params, uint32_t *hw_mode, 1069 uint16_t *target_chan_freq, struct dfs_acs_info *acs_info) 1070 { 1071 uint32_t dfs_reg; 1072 uint32_t num_chan = NUM_CHANNELS; 1073 struct wlan_dfs *dfs = NULL; 1074 struct wlan_objmgr_psoc *psoc; 1075 struct dfs_channel *chan_list = NULL; 1076 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1077 1078 *target_chan_freq = 0; 1079 psoc = wlan_pdev_get_psoc(pdev); 1080 if (!psoc) { 1081 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1082 goto random_chan_error; 1083 } 1084 1085 dfs = wlan_pdev_get_dfs_obj(pdev); 1086 if (!dfs) { 1087 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1088 goto random_chan_error; 1089 } 1090 1091 wlan_reg_get_dfs_region(pdev, &dfs_reg); 1092 chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list)); 1093 if (!chan_list) 1094 goto random_chan_error; 1095 1096 utils_dfs_get_channel_list(pdev, vdev, chan_list, &num_chan); 1097 if (!num_chan) { 1098 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels"); 1099 goto random_chan_error; 1100 } 1101 1102 if (!chan_params->ch_width) 1103 utils_dfs_get_max_sup_width(pdev, 1104 (uint8_t *)&chan_params->ch_width); 1105 1106 *target_chan_freq = dfs_prepare_random_channel_for_freq( 1107 dfs, chan_list, num_chan, flags, chan_params, 1108 (uint8_t)dfs_reg, acs_info); 1109 1110 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1111 "input width=%d", chan_params->ch_width); 1112 1113 if (*target_chan_freq) { 1114 wlan_reg_set_channel_params_for_freq(pdev, *target_chan_freq, 0, 1115 chan_params); 1116 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1117 status = QDF_STATUS_SUCCESS; 1118 } 1119 1120 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1121 "ch=%d, seg0=%d, seg1=%d, width=%d", 1122 *target_chan_freq, chan_params->center_freq_seg0, 1123 chan_params->center_freq_seg1, chan_params->ch_width); 1124 1125 random_chan_error: 1126 qdf_mem_free(chan_list); 1127 1128 return status; 1129 } 1130 1131 qdf_export_symbol(utils_dfs_get_vdev_random_channel_for_freq); 1132 #endif 1133 1134 #ifdef CONFIG_CHAN_NUM_API 1135 QDF_STATUS utils_dfs_get_random_channel( 1136 struct wlan_objmgr_pdev *pdev, 1137 uint16_t flags, 1138 struct ch_params *ch_params, 1139 uint32_t *hw_mode, 1140 uint8_t *target_chan, 1141 struct dfs_acs_info *acs_info) 1142 { 1143 return utils_dfs_get_vdev_random_channel( 1144 pdev, NULL, flags, ch_params, hw_mode, target_chan, 1145 acs_info); 1146 } 1147 qdf_export_symbol(utils_dfs_get_random_channel); 1148 #endif 1149 1150 #ifdef CONFIG_CHAN_FREQ_API 1151 QDF_STATUS utils_dfs_get_random_channel_for_freq( 1152 struct wlan_objmgr_pdev *pdev, 1153 uint16_t flags, 1154 struct ch_params *ch_params, 1155 uint32_t *hw_mode, 1156 uint16_t *target_chan_freq, 1157 struct dfs_acs_info *acs_info) 1158 { 1159 return utils_dfs_get_vdev_random_channel_for_freq(pdev, NULL, flags, 1160 ch_params, hw_mode, 1161 target_chan_freq, 1162 acs_info); 1163 } 1164 1165 qdf_export_symbol(utils_dfs_get_random_channel_for_freq); 1166 #endif 1167 1168 #ifdef CONFIG_CHAN_NUM_API 1169 QDF_STATUS utils_dfs_bw_reduced_channel( 1170 struct wlan_objmgr_pdev *pdev, 1171 struct ch_params *ch_params, 1172 uint32_t *hw_mode, 1173 uint8_t *target_chan) 1174 { 1175 struct wlan_dfs *dfs = NULL; 1176 struct wlan_objmgr_psoc *psoc; 1177 enum channel_state ch_state; 1178 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1179 1180 *target_chan = 0; 1181 psoc = wlan_pdev_get_psoc(pdev); 1182 if (!psoc) { 1183 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1184 return status; 1185 } 1186 1187 dfs = wlan_pdev_get_dfs_obj(pdev); 1188 if (!dfs) { 1189 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1190 return status; 1191 } 1192 1193 ch_state = wlan_reg_get_channel_state(pdev, 1194 dfs->dfs_curchan->dfs_ch_ieee); 1195 1196 if (ch_state == CHANNEL_STATE_DFS || 1197 ch_state == CHANNEL_STATE_ENABLE) { 1198 ch_params->center_freq_seg0 = 1199 dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1; 1200 ch_params->center_freq_seg1 = 1201 dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2; 1202 wlan_reg_set_channel_params(pdev, 1203 dfs->dfs_curchan->dfs_ch_ieee, 1204 0, ch_params); 1205 1206 *target_chan = dfs->dfs_curchan->dfs_ch_ieee; 1207 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1208 1209 return QDF_STATUS_SUCCESS; 1210 } 1211 1212 return status; 1213 } 1214 1215 qdf_export_symbol(utils_dfs_bw_reduced_channel); 1216 #endif 1217 1218 #ifdef CONFIG_CHAN_FREQ_API 1219 QDF_STATUS utils_dfs_bw_reduced_channel_for_freq( 1220 struct wlan_objmgr_pdev *pdev, 1221 struct ch_params *chan_params, 1222 uint32_t *hw_mode, 1223 uint16_t *target_chan_freq) 1224 { 1225 struct wlan_dfs *dfs = NULL; 1226 struct wlan_objmgr_psoc *psoc; 1227 enum channel_state ch_state; 1228 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1229 struct dfs_channel *dfs_curchan; 1230 1231 *target_chan_freq = 0; 1232 psoc = wlan_pdev_get_psoc(pdev); 1233 if (!psoc) { 1234 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1235 return status; 1236 } 1237 1238 dfs = wlan_pdev_get_dfs_obj(pdev); 1239 if (!dfs) { 1240 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1241 return status; 1242 } 1243 dfs_curchan = dfs->dfs_curchan; 1244 ch_state = 1245 wlan_reg_get_channel_state_for_freq(pdev, 1246 dfs_curchan->dfs_ch_freq); 1247 1248 if (ch_state == CHANNEL_STATE_DFS || 1249 ch_state == CHANNEL_STATE_ENABLE) { 1250 /* If the current channel is 80P80MHz and radar is detected on 1251 * the channel, the next highest bandwidth that maybe available 1252 * is 80MHz. Since the current regulatory algorithm reduces the 1253 * bandwidth from 80P80MHz to 160MHz, provide the channel 1254 * width as 80MHz if current channel is 80P80MHz. 1255 */ 1256 if (chan_params->ch_width == CH_WIDTH_80P80MHZ) 1257 chan_params->ch_width = CH_WIDTH_80MHZ; 1258 1259 chan_params->mhz_freq_seg0 = 1260 dfs_curchan->dfs_ch_mhz_freq_seg1; 1261 chan_params->mhz_freq_seg1 = 1262 dfs_curchan->dfs_ch_mhz_freq_seg2; 1263 wlan_reg_set_channel_params_for_freq(pdev, 1264 dfs_curchan->dfs_ch_freq, 1265 0, chan_params); 1266 1267 *target_chan_freq = dfs_curchan->dfs_ch_freq; 1268 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1269 1270 return QDF_STATUS_SUCCESS; 1271 } 1272 1273 return status; 1274 } 1275 1276 qdf_export_symbol(utils_dfs_bw_reduced_channel_for_freq); 1277 #endif 1278 1279 1280 #ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 1281 void utils_dfs_init_nol(struct wlan_objmgr_pdev *pdev) 1282 { 1283 struct wlan_dfs *dfs; 1284 struct wlan_objmgr_psoc *psoc; 1285 qdf_device_t qdf_dev; 1286 struct dfs_nol_info *dfs_nolinfo; 1287 int len; 1288 1289 dfs = wlan_pdev_get_dfs_obj(pdev); 1290 psoc = wlan_pdev_get_psoc(pdev); 1291 if (!dfs || !psoc) { 1292 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 1293 "dfs %pK, psoc %pK", dfs, psoc); 1294 return; 1295 } 1296 1297 qdf_dev = psoc->soc_objmgr.qdf_dev; 1298 if (!qdf_dev->dev) { 1299 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 1300 return; 1301 } 1302 1303 dfs_nolinfo = qdf_mem_malloc(sizeof(*dfs_nolinfo)); 1304 if (!dfs_nolinfo) 1305 return; 1306 1307 qdf_mem_zero(dfs_nolinfo, sizeof(*dfs_nolinfo)); 1308 len = pld_wlan_get_dfs_nol(qdf_dev->dev, (void *)dfs_nolinfo, 1309 (uint16_t)sizeof(*dfs_nolinfo)); 1310 if (len > 0) { 1311 dfs_set_nol(dfs, dfs_nolinfo->dfs_nol, dfs_nolinfo->num_chans); 1312 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "nol channels in pld"); 1313 DFS_PRINT_NOL_LOCKED(dfs); 1314 } else { 1315 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "no nol in pld"); 1316 } 1317 qdf_mem_free(dfs_nolinfo); 1318 } 1319 #endif 1320 qdf_export_symbol(utils_dfs_init_nol); 1321 1322 #ifndef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 1323 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 1324 { 1325 } 1326 #else 1327 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 1328 { 1329 struct dfs_nol_info *dfs_nolinfo; 1330 struct wlan_dfs *dfs = NULL; 1331 struct wlan_objmgr_psoc *psoc; 1332 qdf_device_t qdf_dev; 1333 int num_chans = 0; 1334 1335 dfs = wlan_pdev_get_dfs_obj(pdev); 1336 if (!dfs) { 1337 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1338 return; 1339 } 1340 1341 psoc = wlan_pdev_get_psoc(pdev); 1342 if (!psoc) { 1343 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1344 return; 1345 } 1346 1347 qdf_dev = psoc->soc_objmgr.qdf_dev; 1348 if (!qdf_dev->dev) { 1349 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 1350 return; 1351 } 1352 1353 dfs_nolinfo = qdf_mem_malloc(sizeof(*dfs_nolinfo)); 1354 if (!dfs_nolinfo) 1355 return; 1356 1357 qdf_mem_zero(dfs_nolinfo, sizeof(*dfs_nolinfo)); 1358 DFS_GET_NOL_LOCKED(dfs, dfs_nolinfo->dfs_nol, &num_chans); 1359 1360 if (num_chans > DFS_MAX_NOL_CHANNEL) 1361 dfs_nolinfo->num_chans = DFS_MAX_NOL_CHANNEL; 1362 else 1363 dfs_nolinfo->num_chans = num_chans; 1364 1365 pld_wlan_set_dfs_nol(qdf_dev->dev, (void *)dfs_nolinfo, 1366 (uint16_t)sizeof(*dfs_nolinfo)); 1367 qdf_mem_free(dfs_nolinfo); 1368 } 1369 #endif 1370 qdf_export_symbol(utils_dfs_save_nol); 1371 1372 void utils_dfs_print_nol_channels(struct wlan_objmgr_pdev *pdev) 1373 { 1374 struct wlan_dfs *dfs = NULL; 1375 1376 dfs = wlan_pdev_get_dfs_obj(pdev); 1377 if (!dfs) { 1378 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1379 return; 1380 } 1381 1382 DFS_PRINT_NOL_LOCKED(dfs); 1383 } 1384 qdf_export_symbol(utils_dfs_print_nol_channels); 1385 1386 void utils_dfs_clear_nol_channels(struct wlan_objmgr_pdev *pdev) 1387 { 1388 struct wlan_dfs *dfs = NULL; 1389 1390 dfs = wlan_pdev_get_dfs_obj(pdev); 1391 if (!dfs) { 1392 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1393 return; 1394 } 1395 1396 /* First print list */ 1397 DFS_PRINT_NOL_LOCKED(dfs); 1398 1399 /* clear local cache first */ 1400 dfs_nol_timer_cleanup(dfs); 1401 dfs_nol_update(dfs); 1402 1403 /* 1404 * update platform driver nol list with local cache which is zero, 1405 * cleared in above step, so this will clear list in platform driver. 1406 */ 1407 utils_dfs_save_nol(pdev); 1408 } 1409 qdf_export_symbol(utils_dfs_clear_nol_channels); 1410 1411 #ifdef CONFIG_CHAN_NUM_API 1412 void utils_dfs_reg_update_nol_ch(struct wlan_objmgr_pdev *pdev, 1413 uint8_t *ch_list, 1414 uint8_t num_ch, 1415 bool nol_ch) 1416 { 1417 /* TODO : Need locking?*/ 1418 wlan_reg_update_nol_ch(pdev, ch_list, num_ch, nol_ch); 1419 } 1420 qdf_export_symbol(utils_dfs_reg_update_nol_ch); 1421 #endif 1422 1423 #ifdef CONFIG_CHAN_FREQ_API 1424 void utils_dfs_reg_update_nol_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1425 uint16_t *freq_list, 1426 uint8_t num_chan, 1427 bool nol_chan) 1428 { 1429 wlan_reg_update_nol_ch_for_freq(pdev, freq_list, num_chan, nol_chan); 1430 } 1431 1432 qdf_export_symbol(utils_dfs_reg_update_nol_chan_for_freq); 1433 #endif 1434 1435 #ifdef CONFIG_CHAN_NUM_API 1436 void utils_dfs_reg_update_nol_history_ch(struct wlan_objmgr_pdev *pdev, 1437 uint8_t *ch_list, 1438 uint8_t num_ch, 1439 bool nol_history_ch) 1440 { 1441 wlan_reg_update_nol_history_ch(pdev, ch_list, num_ch, nol_history_ch); 1442 } 1443 #endif 1444 1445 #ifdef CONFIG_CHAN_FREQ_API 1446 void 1447 utils_dfs_reg_update_nol_history_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1448 uint16_t *freq_list, 1449 uint8_t num_chan, 1450 bool nol_history_chan) 1451 { 1452 wlan_reg_update_nol_history_ch_for_freq(pdev, freq_list, num_chan, 1453 nol_history_chan); 1454 } 1455 #endif 1456 1457 uint8_t utils_dfs_freq_to_chan(uint32_t freq) 1458 { 1459 uint8_t chan; 1460 1461 if (freq == 0) 1462 return 0; 1463 1464 if (freq > DFS_24_GHZ_BASE_FREQ && freq < DFS_CHAN_14_FREQ) 1465 chan = ((freq - DFS_24_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ); 1466 else if (freq == DFS_CHAN_14_FREQ) 1467 chan = DFS_24_GHZ_CHANNEL_14; 1468 else if ((freq > DFS_24_GHZ_BASE_FREQ) && (freq < DFS_5_GHZ_BASE_FREQ)) 1469 chan = (((freq - DFS_CHAN_15_FREQ) / DFS_CHAN_SPACING_20MHZ) + 1470 DFS_24_GHZ_CHANNEL_15); 1471 else 1472 chan = (freq - DFS_5_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ; 1473 1474 return chan; 1475 } 1476 qdf_export_symbol(utils_dfs_freq_to_chan); 1477 1478 uint32_t utils_dfs_chan_to_freq(uint8_t chan) 1479 { 1480 if (chan == 0) 1481 return 0; 1482 1483 if (chan < DFS_24_GHZ_CHANNEL_14) 1484 return DFS_24_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 1485 else if (chan == DFS_24_GHZ_CHANNEL_14) 1486 return DFS_CHAN_14_FREQ; 1487 else if (chan < DFS_24_GHZ_CHANNEL_27) 1488 return DFS_CHAN_15_FREQ + ((chan - DFS_24_GHZ_CHANNEL_15) * 1489 DFS_CHAN_SPACING_20MHZ); 1490 else if (chan == DFS_5_GHZ_CHANNEL_170) 1491 return DFS_CHAN_170_FREQ; 1492 else 1493 return DFS_5_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 1494 } 1495 qdf_export_symbol(utils_dfs_chan_to_freq); 1496 1497 #ifdef QCA_MCL_DFS_SUPPORT 1498 #ifdef CONFIG_CHAN_NUM_API 1499 QDF_STATUS utils_dfs_mark_leaking_ch(struct wlan_objmgr_pdev *pdev, 1500 enum phy_ch_width ch_width, 1501 uint8_t temp_ch_lst_sz, 1502 uint8_t *temp_ch_lst) 1503 { 1504 struct wlan_dfs *dfs = NULL; 1505 1506 dfs = wlan_pdev_get_dfs_obj(pdev); 1507 if (!dfs) { 1508 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1509 return QDF_STATUS_E_FAILURE; 1510 } 1511 1512 return dfs_mark_leaking_ch(dfs, ch_width, temp_ch_lst_sz, temp_ch_lst); 1513 } 1514 qdf_export_symbol(utils_dfs_mark_leaking_ch); 1515 #endif 1516 1517 #ifdef CONFIG_CHAN_FREQ_API 1518 QDF_STATUS utils_dfs_mark_leaking_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1519 enum phy_ch_width ch_width, 1520 uint8_t temp_chan_lst_sz, 1521 uint16_t *temp_freq_lst) 1522 { 1523 struct wlan_dfs *dfs = NULL; 1524 1525 dfs = wlan_pdev_get_dfs_obj(pdev); 1526 if (!dfs) { 1527 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1528 return QDF_STATUS_E_FAILURE; 1529 } 1530 1531 return dfs_mark_leaking_chan_for_freq(dfs, ch_width, temp_chan_lst_sz, 1532 temp_freq_lst); 1533 } 1534 qdf_export_symbol(utils_dfs_mark_leaking_chan_for_freq); 1535 #endif 1536 #endif 1537 1538 int utils_get_dfsdomain(struct wlan_objmgr_pdev *pdev) 1539 { 1540 enum dfs_reg dfsdomain; 1541 1542 wlan_reg_get_dfs_region(pdev, &dfsdomain); 1543 1544 return dfsdomain; 1545 } 1546 1547 uint16_t utils_dfs_get_cur_rd(struct wlan_objmgr_pdev *pdev) 1548 { 1549 struct cur_regdmn_info cur_regdmn; 1550 1551 wlan_reg_get_curr_regdomain(pdev, &cur_regdmn); 1552 1553 return cur_regdmn.regdmn_pair_id; 1554 } 1555 1556 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 1557 QDF_STATUS utils_dfs_is_spoof_check_failed(struct wlan_objmgr_pdev *pdev, 1558 bool *is_spoof_check_failed) 1559 { 1560 struct wlan_dfs *dfs; 1561 1562 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1563 return QDF_STATUS_SUCCESS; 1564 1565 dfs = wlan_pdev_get_dfs_obj(pdev); 1566 if (!dfs) { 1567 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1568 return QDF_STATUS_E_FAILURE; 1569 } 1570 1571 *is_spoof_check_failed = dfs->dfs_spoof_check_failed; 1572 1573 return QDF_STATUS_SUCCESS; 1574 } 1575 1576 qdf_export_symbol(utils_dfs_is_spoof_check_failed); 1577 1578 bool utils_dfs_is_spoof_done(struct wlan_objmgr_pdev *pdev) 1579 { 1580 struct wlan_dfs *dfs; 1581 1582 dfs = wlan_pdev_get_dfs_obj(pdev); 1583 if (!dfs) 1584 return false; 1585 1586 if (lmac_is_host_dfs_check_support_enabled(dfs->dfs_pdev_obj) && 1587 utils_get_dfsdomain(dfs->dfs_pdev_obj) == DFS_FCC_DOMAIN) 1588 return !!dfs->dfs_spoof_test_done; 1589 return true; 1590 } 1591 #endif 1592 1593 int dfs_get_num_chans(void) 1594 { 1595 return NUM_CHANNELS; 1596 } 1597 1598 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 1599 QDF_STATUS utils_dfs_get_disable_radar_marking(struct wlan_objmgr_pdev *pdev, 1600 bool *disable_radar_marking) 1601 { 1602 struct wlan_dfs *dfs; 1603 1604 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1605 return QDF_STATUS_SUCCESS; 1606 1607 dfs = wlan_pdev_get_dfs_obj(pdev); 1608 if (!dfs) { 1609 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1610 return QDF_STATUS_E_FAILURE; 1611 } 1612 1613 *disable_radar_marking = dfs_get_disable_radar_marking(dfs); 1614 1615 return QDF_STATUS_SUCCESS; 1616 } 1617 1618 qdf_export_symbol(utils_dfs_get_disable_radar_marking); 1619 #endif 1620 1621 bool utils_is_dfs_cfreq2_ch(struct wlan_objmgr_pdev *pdev) 1622 { 1623 struct wlan_dfs *dfs; 1624 1625 dfs = wlan_pdev_get_dfs_obj(pdev); 1626 if (!dfs) 1627 return false; 1628 1629 return WLAN_IS_CHAN_DFS_CFREQ2(dfs->dfs_curchan); 1630 } 1631 1632 qdf_export_symbol(utils_is_dfs_cfreq2_ch); 1633 1634 void utils_dfs_deliver_event(struct wlan_objmgr_pdev *pdev, uint16_t freq, 1635 enum WLAN_DFS_EVENTS event) 1636 { 1637 if (global_dfs_to_mlme.mlme_dfs_deliver_event) 1638 global_dfs_to_mlme.mlme_dfs_deliver_event(pdev, freq, event); 1639 } 1640 1641 void utils_dfs_reset_dfs_prevchan(struct wlan_objmgr_pdev *pdev) 1642 { 1643 struct wlan_dfs *dfs; 1644 1645 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1646 return; 1647 1648 dfs = wlan_pdev_get_dfs_obj(pdev); 1649 if (!dfs) { 1650 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1651 return; 1652 } 1653 1654 dfs_reset_dfs_prevchan(dfs); 1655 } 1656 1657 #ifdef QCA_SUPPORT_AGILE_DFS 1658 1659 void utils_dfs_agile_sm_deliver_evt(struct wlan_objmgr_pdev *pdev, 1660 enum dfs_agile_sm_evt event) 1661 { 1662 struct wlan_dfs *dfs; 1663 void *event_data; 1664 1665 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1666 return; 1667 1668 dfs = wlan_pdev_get_dfs_obj(pdev); 1669 if (!dfs) { 1670 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1671 return; 1672 } 1673 1674 if (!dfs_is_agile_cac_enabled(dfs)) 1675 return; 1676 1677 event_data = (void *)dfs; 1678 1679 dfs_agile_sm_deliver_evt(dfs->dfs_soc_obj, 1680 event, 1681 0, 1682 event_data); 1683 } 1684 #endif 1685 1686 #ifdef QCA_SUPPORT_ADFS_RCAC 1687 QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev, 1688 struct ch_params *chan_params, 1689 qdf_freq_t *target_chan_freq) 1690 { 1691 struct wlan_dfs *dfs = NULL; 1692 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1693 1694 if (!target_chan_freq) 1695 return status; 1696 1697 *target_chan_freq = 0; 1698 1699 dfs = wlan_pdev_get_dfs_obj(pdev); 1700 if (!dfs) { 1701 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1702 return status; 1703 } 1704 1705 if (!dfs_is_agile_rcac_enabled(dfs)) 1706 return status; 1707 1708 *target_chan_freq = dfs->dfs_rcac_param.rcac_pri_freq; 1709 1710 /* Do not modify the input ch_params if no RCAC channel is present. */ 1711 if (!*target_chan_freq) 1712 return status; 1713 1714 *chan_params = dfs->dfs_rcac_param.rcac_ch_params; 1715 1716 return QDF_STATUS_SUCCESS; 1717 } 1718 #endif 1719 1720 #ifdef ATH_SUPPORT_ZERO_CAC_DFS 1721 enum precac_status_for_chan 1722 utils_dfs_precac_status_for_channel(struct wlan_objmgr_pdev *pdev, 1723 struct wlan_channel *deschan) 1724 { 1725 struct wlan_dfs *dfs; 1726 struct dfs_channel chan; 1727 1728 dfs = wlan_pdev_get_dfs_obj(pdev); 1729 if (!dfs) 1730 return false; 1731 1732 dfs_fill_chan_info(&chan, deschan); 1733 1734 return dfs_precac_status_for_channel(dfs, &chan); 1735 } 1736 #endif 1737 1738 #if defined(WLAN_DISP_CHAN_INFO) 1739 #define FIRST_DFS_CHAN_NUM 52 1740 #define CHAN_NUM_SPACING 4 1741 #define INVALID_INDEX (-1) 1742 #define IS_CHAN_DFS(_flags) ((_flags) & REGULATORY_CHAN_RADAR) 1743 /** 1744 * utils_dfs_convert_freq_to_index() - Converts a DFS channel frequency 1745 * to the DFS channel state array index. The input frequency should be a DFS 1746 * channel frequency and this check should be done in the caller. 1747 * @freq: Input DFS channel frequency. 1748 * @index: Output DFS channel state array index. 1749 * 1750 * Return: QDF_STATUS. 1751 */ 1752 static void utils_dfs_convert_freq_to_index(qdf_freq_t freq, int8_t *index) 1753 { 1754 uint16_t chan_num; 1755 int8_t tmp_index; 1756 1757 chan_num = (freq - WLAN_5_GHZ_BASE_FREQ) / WLAN_CHAN_SPACING_5MHZ; 1758 tmp_index = (chan_num - FIRST_DFS_CHAN_NUM) / CHAN_NUM_SPACING; 1759 *index = ((tmp_index >= 0) && (tmp_index < NUM_DFS_CHANS)) ? 1760 tmp_index : INVALID_INDEX; 1761 } 1762 1763 /** 1764 * utils_dfs_update_chan_state_array_element() - Update the per dfs channel 1765 * state array element indexed by the frequency with the new state. 1766 * 1767 * @freq: Input DFS Channel frequency which will converted to channel state 1768 * array index. 1769 * @state: Input DFS state with which the value indexed by frequency will be 1770 * updated with. 1771 * 1772 * Return: void. 1773 */ 1774 static QDF_STATUS 1775 utils_dfs_update_chan_state_array_element(struct wlan_dfs *dfs, 1776 qdf_freq_t freq, 1777 enum channel_dfs_state state) 1778 { 1779 int8_t index; 1780 1781 if (state == CH_DFS_S_INVALID) 1782 return QDF_STATUS_E_INVAL; 1783 1784 utils_dfs_convert_freq_to_index(freq, &index); 1785 1786 if (index == INVALID_INDEX) 1787 return QDF_STATUS_E_INVAL; 1788 1789 dfs->dfs_channel_state_array[index] = state; 1790 1791 return QDF_STATUS_SUCCESS; 1792 } 1793 1794 QDF_STATUS dfs_init_chan_state_array(struct wlan_objmgr_pdev *pdev) 1795 { 1796 struct regulatory_channel *cur_chan_list; 1797 struct wlan_dfs *dfs; 1798 int i; 1799 1800 dfs = wlan_pdev_get_dfs_obj(pdev); 1801 1802 if (!dfs) 1803 return QDF_STATUS_E_FAILURE; 1804 1805 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * 1806 sizeof(struct regulatory_channel)); 1807 1808 if (!cur_chan_list) 1809 return QDF_STATUS_E_NOMEM; 1810 1811 if (wlan_reg_get_current_chan_list( 1812 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 1813 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 1814 "failed to get curr channel list"); 1815 return QDF_STATUS_E_FAILURE; 1816 } 1817 1818 for (i = 0; i < NUM_CHANNELS; i++) { 1819 qdf_freq_t freq = cur_chan_list[i].center_freq; 1820 1821 if (!IS_CHAN_DFS(cur_chan_list[i].chan_flags)) 1822 continue; 1823 1824 utils_dfs_update_chan_state_array_element(dfs, 1825 freq, 1826 CH_DFS_S_CAC_REQ); 1827 } 1828 1829 qdf_mem_free(cur_chan_list); 1830 qdf_err("channel state array initialized"); 1831 return QDF_STATUS_SUCCESS; 1832 } 1833 1834 QDF_STATUS utils_dfs_get_chan_dfs_state(struct wlan_objmgr_pdev *pdev, 1835 enum channel_dfs_state *dfs_ch_s) 1836 { 1837 struct wlan_dfs *dfs; 1838 1839 dfs = wlan_pdev_get_dfs_obj(pdev); 1840 1841 if (!dfs) 1842 return QDF_STATUS_E_FAILURE; 1843 1844 qdf_mem_copy(dfs_ch_s, 1845 dfs->dfs_channel_state_array, 1846 sizeof(dfs->dfs_channel_state_array)); 1847 1848 return QDF_STATUS_SUCCESS; 1849 } 1850 1851 qdf_export_symbol(utils_dfs_get_chan_dfs_state); 1852 1853 /** 1854 * convert_event_to_state() - Coverts the dfs events WLAN_DFS_EVENTS to dfs 1855 * states channel_dfs_state. 1856 * @event: Input DFS event. 1857 * @state: Output DFS state. 1858 * 1859 * Return: void. 1860 */ 1861 static 1862 void convert_event_to_state(enum WLAN_DFS_EVENTS event, 1863 enum channel_dfs_state *state) 1864 { 1865 static const 1866 enum channel_dfs_state ev_to_state[WLAN_EV_PCAC_COMPLETED + 1] = { 1867 [WLAN_EV_RADAR_DETECTED] = CH_DFS_S_INVALID, 1868 [WLAN_EV_CAC_RESET] = CH_DFS_S_CAC_REQ, 1869 [WLAN_EV_CAC_STARTED] = CH_DFS_S_CAC_STARTED, 1870 [WLAN_EV_CAC_COMPLETED] = CH_DFS_S_CAC_COMPLETED, 1871 [WLAN_EV_NOL_STARTED] = CH_DFS_S_NOL, 1872 [WLAN_EV_NOL_FINISHED] = CH_DFS_S_CAC_REQ, 1873 [WLAN_EV_PCAC_STARTED] = CH_DFS_S_PRECAC_STARTED, 1874 [WLAN_EV_PCAC_COMPLETED] = CH_DFS_S_PRECAC_COMPLETED, 1875 }; 1876 1877 *state = ev_to_state[event]; 1878 } 1879 1880 QDF_STATUS utils_dfs_update_chan_state_array(struct wlan_objmgr_pdev *pdev, 1881 qdf_freq_t freq, 1882 enum WLAN_DFS_EVENTS event) 1883 { 1884 enum channel_dfs_state state; 1885 struct wlan_dfs *dfs; 1886 1887 dfs = wlan_pdev_get_dfs_obj(pdev); 1888 if (!dfs) 1889 return QDF_STATUS_E_FAILURE; 1890 1891 convert_event_to_state(event, &state); 1892 return utils_dfs_update_chan_state_array_element(dfs, freq, state); 1893 } 1894 #endif /* WLAN_DISP_CHAN_INFO */ 1895