1 /* 2 * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved. 3 * 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /** 21 * DOC: This file has the DFS dispatcher API implementation which is exposed 22 * to outside of DFS component. 23 */ 24 #include <wlan_objmgr_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 40 struct dfs_nol_info { 41 uint16_t num_chans; 42 struct dfsreq_nolelem dfs_nol[DFS_MAX_NOL_CHANNEL]; 43 }; 44 45 QDF_STATUS utils_dfs_reset(struct wlan_objmgr_pdev *pdev) 46 { 47 struct wlan_dfs *dfs; 48 49 dfs = wlan_pdev_get_dfs_obj(pdev); 50 if (!dfs) 51 return QDF_STATUS_E_FAILURE; 52 53 dfs_reset(dfs); 54 dfs_nol_update(dfs); 55 dfs_reset_precaclists(dfs); 56 57 return QDF_STATUS_SUCCESS; 58 } 59 60 bool utils_dfs_is_freq_in_nol(struct wlan_objmgr_pdev *pdev, uint32_t freq) 61 { 62 struct wlan_dfs *dfs; 63 64 dfs = wlan_pdev_get_dfs_obj(pdev); 65 if (!dfs) 66 return false; 67 68 return dfs_is_freq_in_nol(dfs, freq); 69 } 70 71 #ifdef CONFIG_CHAN_NUM_API 72 QDF_STATUS utils_dfs_cac_valid_reset(struct wlan_objmgr_pdev *pdev, 73 uint8_t prevchan_ieee, 74 uint32_t prevchan_flags) 75 { 76 struct wlan_dfs *dfs; 77 78 dfs = wlan_pdev_get_dfs_obj(pdev); 79 if (!dfs) 80 return QDF_STATUS_E_FAILURE; 81 82 dfs_cac_valid_reset(dfs, prevchan_ieee, prevchan_flags); 83 84 return QDF_STATUS_SUCCESS; 85 } 86 qdf_export_symbol(utils_dfs_cac_valid_reset); 87 #endif 88 89 #ifdef CONFIG_CHAN_FREQ_API 90 QDF_STATUS utils_dfs_cac_valid_reset_for_freq(struct wlan_objmgr_pdev *pdev, 91 uint16_t prevchan_freq, 92 uint32_t prevchan_flags) 93 { 94 struct wlan_dfs *dfs; 95 96 dfs = wlan_pdev_get_dfs_obj(pdev); 97 if (!dfs) 98 return QDF_STATUS_E_FAILURE; 99 100 dfs_cac_valid_reset_for_freq(dfs, prevchan_freq, prevchan_flags); 101 102 return QDF_STATUS_SUCCESS; 103 } 104 105 qdf_export_symbol(utils_dfs_cac_valid_reset_for_freq); 106 #endif 107 108 QDF_STATUS utils_dfs_reset_precaclists(struct wlan_objmgr_pdev *pdev) 109 { 110 struct wlan_dfs *dfs; 111 112 dfs = wlan_pdev_get_dfs_obj(pdev); 113 if (!dfs) 114 return QDF_STATUS_E_FAILURE; 115 116 dfs_reset_precaclists(dfs); 117 118 return QDF_STATUS_SUCCESS; 119 } 120 qdf_export_symbol(utils_dfs_reset_precaclists); 121 122 #ifdef CONFIG_CHAN_NUM_API 123 void utils_dfs_unmark_precac_nol(struct wlan_objmgr_pdev *pdev, uint8_t chan) 124 { 125 struct wlan_dfs *dfs; 126 127 dfs = wlan_pdev_get_dfs_obj(pdev); 128 if (!dfs) 129 return; 130 131 dfs_unmark_precac_nol(dfs, chan); 132 } 133 134 qdf_export_symbol(utils_dfs_unmark_precac_nol); 135 #endif 136 137 #ifdef CONFIG_CHAN_FREQ_API 138 void utils_dfs_unmark_precac_nol_for_freq(struct wlan_objmgr_pdev *pdev, 139 uint16_t chan_freq) 140 { 141 struct wlan_dfs *dfs; 142 143 dfs = wlan_pdev_get_dfs_obj(pdev); 144 if (!dfs) 145 return; 146 147 dfs_unmark_precac_nol_for_freq(dfs, chan_freq); 148 } 149 150 qdf_export_symbol(utils_dfs_unmark_precac_nol_for_freq); 151 #endif 152 153 QDF_STATUS utils_dfs_cancel_precac_timer(struct wlan_objmgr_pdev *pdev) 154 { 155 struct wlan_dfs *dfs; 156 157 dfs = wlan_pdev_get_dfs_obj(pdev); 158 if (!dfs) 159 return QDF_STATUS_E_FAILURE; 160 161 dfs_cancel_precac_timer(dfs); 162 163 return QDF_STATUS_SUCCESS; 164 } 165 qdf_export_symbol(utils_dfs_cancel_precac_timer); 166 167 #ifdef CONFIG_CHAN_FREQ_API 168 QDF_STATUS utils_dfs_start_precac_timer(struct wlan_objmgr_pdev *pdev) 169 { 170 struct wlan_dfs *dfs; 171 172 dfs = wlan_pdev_get_dfs_obj(pdev); 173 if (!dfs) { 174 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 175 return QDF_STATUS_E_FAILURE; 176 } 177 178 if (!dfs->dfs_precac_secondary_freq_mhz) 179 return QDF_STATUS_E_FAILURE; 180 181 dfs_start_precac_timer_for_freq(dfs, 182 dfs->dfs_precac_secondary_freq_mhz); 183 return QDF_STATUS_SUCCESS; 184 } 185 #else 186 #ifdef CONFIG_CHAN_NUM_API 187 QDF_STATUS utils_dfs_start_precac_timer(struct wlan_objmgr_pdev *pdev) 188 { 189 struct wlan_dfs *dfs; 190 191 dfs = wlan_pdev_get_dfs_obj(pdev); 192 if (!dfs) { 193 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 194 return QDF_STATUS_E_FAILURE; 195 } 196 197 if (!dfs->dfs_precac_secondary_freq) 198 return QDF_STATUS_E_FAILURE; 199 dfs_start_precac_timer(dfs, 200 dfs->dfs_precac_secondary_freq); 201 return QDF_STATUS_SUCCESS; 202 } 203 #endif 204 #endif 205 206 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 207 #ifdef CONFIG_CHAN_NUM_API 208 bool 209 utils_dfs_precac_decide_pref_chan(struct wlan_objmgr_pdev *pdev, 210 uint8_t *ch_ieee, 211 enum wlan_phymode mode) 212 { 213 struct wlan_dfs *dfs; 214 215 dfs = wlan_pdev_get_dfs_obj(pdev); 216 if (!dfs) { 217 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 218 return false; 219 } 220 return dfs_decide_precac_preferred_chan(dfs, ch_ieee, mode); 221 } 222 #endif 223 224 #ifdef CONFIG_CHAN_FREQ_API 225 bool 226 utils_dfs_precac_decide_pref_chan_for_freq(struct wlan_objmgr_pdev *pdev, 227 uint16_t *chan_freq, 228 enum wlan_phymode mode) 229 { 230 struct wlan_dfs *dfs; 231 232 dfs = wlan_pdev_get_dfs_obj(pdev); 233 if (!dfs) { 234 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 235 return false; 236 } 237 return dfs_decide_precac_preferred_chan_for_freq(dfs, chan_freq, mode); 238 } 239 #endif 240 #endif 241 QDF_STATUS utils_dfs_cancel_cac_timer(struct wlan_objmgr_pdev *pdev) 242 { 243 struct wlan_dfs *dfs; 244 245 dfs = wlan_pdev_get_dfs_obj(pdev); 246 if (!dfs) 247 return QDF_STATUS_E_FAILURE; 248 249 dfs_cancel_cac_timer(dfs); 250 251 return QDF_STATUS_SUCCESS; 252 } 253 qdf_export_symbol(utils_dfs_cancel_cac_timer); 254 255 QDF_STATUS utils_dfs_start_cac_timer(struct wlan_objmgr_pdev *pdev) 256 { 257 struct wlan_dfs *dfs; 258 259 dfs = wlan_pdev_get_dfs_obj(pdev); 260 if (!dfs) 261 return QDF_STATUS_E_FAILURE; 262 263 dfs_start_cac_timer(dfs); 264 265 return QDF_STATUS_SUCCESS; 266 } 267 qdf_export_symbol(utils_dfs_start_cac_timer); 268 269 QDF_STATUS utils_dfs_cac_stop(struct wlan_objmgr_pdev *pdev) 270 { 271 struct wlan_dfs *dfs; 272 273 dfs = wlan_pdev_get_dfs_obj(pdev); 274 if (!dfs) 275 return QDF_STATUS_E_FAILURE; 276 277 dfs_cac_stop(dfs); 278 return QDF_STATUS_SUCCESS; 279 } 280 qdf_export_symbol(utils_dfs_cac_stop); 281 282 /** dfs_fill_chan_info() - Fill the dfs channel structure with wlan 283 * channel. 284 * @chan: Pointer to DFS channel structure. 285 * @wlan_chan: Pointer to WLAN Channel structure. 286 * 287 * Return: void 288 */ 289 #ifdef CONFIG_CHAN_FREQ_API 290 static void dfs_fill_chan_info(struct dfs_channel *chan, 291 struct wlan_channel *wlan_chan) 292 { 293 chan->dfs_ch_freq = wlan_chan->ch_freq; 294 chan->dfs_ch_flags = wlan_chan->ch_flags; 295 chan->dfs_ch_flagext = wlan_chan->ch_flagext; 296 chan->dfs_ch_ieee = wlan_chan->ch_ieee; 297 chan->dfs_ch_vhtop_ch_freq_seg1 = wlan_chan->ch_freq_seg1; 298 chan->dfs_ch_vhtop_ch_freq_seg2 = wlan_chan->ch_freq_seg2; 299 chan->dfs_ch_mhz_freq_seg1 = wlan_chan->ch_cfreq1; 300 chan->dfs_ch_mhz_freq_seg2 = wlan_chan->ch_cfreq2; 301 } 302 #else 303 #ifdef CONFIG_CHAN_NUM_API 304 static void dfs_fill_chan_info(struct dfs_channel *chan, 305 struct wlan_channel *wlan_chan) 306 { 307 chan->dfs_ch_freq = wlan_chan->ch_freq; 308 chan->dfs_ch_flags = wlan_chan->ch_flags; 309 chan->dfs_ch_flagext = wlan_chan->ch_flagext; 310 chan->dfs_ch_ieee = wlan_chan->ch_ieee; 311 chan->dfs_ch_vhtop_ch_freq_seg1 = wlan_chan->ch_freq_seg1; 312 chan->dfs_ch_vhtop_ch_freq_seg2 = wlan_chan->ch_freq_seg2; 313 } 314 #endif 315 #endif 316 317 bool utils_dfs_is_precac_done(struct wlan_objmgr_pdev *pdev, 318 struct wlan_channel *wlan_chan) 319 { 320 struct wlan_dfs *dfs; 321 struct dfs_channel chan; 322 323 dfs = wlan_pdev_get_dfs_obj(pdev); 324 if (!dfs) 325 return false; 326 327 dfs_fill_chan_info(&chan, wlan_chan); 328 329 return dfs_is_precac_done(dfs, &chan); 330 } 331 332 bool utils_dfs_is_cac_required(struct wlan_objmgr_pdev *pdev, 333 struct wlan_channel *cur_chan, 334 struct wlan_channel *prev_chan, 335 bool *continue_current_cac) 336 { 337 struct wlan_dfs *dfs; 338 struct dfs_channel cur_channel; 339 struct dfs_channel prev_channel; 340 341 dfs = wlan_pdev_get_dfs_obj(pdev); 342 if (!dfs) 343 return false; 344 345 dfs_fill_chan_info(&cur_channel, cur_chan); 346 dfs_fill_chan_info(&prev_channel, prev_chan); 347 348 return dfs_is_cac_required(dfs, 349 &cur_channel, 350 &prev_channel, 351 continue_current_cac); 352 } 353 354 bool 355 utils_dfs_is_cac_required_on_dfs_curchan(struct wlan_objmgr_pdev *pdev, 356 bool *continue_current_cac) 357 { 358 struct wlan_dfs *dfs; 359 360 dfs = wlan_pdev_get_dfs_obj(pdev); 361 if (!dfs) 362 return false; 363 364 return dfs_is_cac_required(dfs, 365 dfs->dfs_curchan, 366 dfs->dfs_prevchan, 367 continue_current_cac); 368 } 369 370 QDF_STATUS utils_dfs_stacac_stop(struct wlan_objmgr_pdev *pdev) 371 { 372 struct wlan_dfs *dfs; 373 374 dfs = wlan_pdev_get_dfs_obj(pdev); 375 if (!dfs) 376 return QDF_STATUS_E_FAILURE; 377 378 dfs_stacac_stop(dfs); 379 380 return QDF_STATUS_SUCCESS; 381 } 382 qdf_export_symbol(utils_dfs_stacac_stop); 383 384 QDF_STATUS utils_dfs_get_usenol(struct wlan_objmgr_pdev *pdev, uint16_t *usenol) 385 { 386 struct wlan_dfs *dfs; 387 388 dfs = wlan_pdev_get_dfs_obj(pdev); 389 if (!dfs) 390 return QDF_STATUS_E_FAILURE; 391 392 *usenol = dfs_get_use_nol(dfs); 393 394 return QDF_STATUS_SUCCESS; 395 } 396 qdf_export_symbol(utils_dfs_get_usenol); 397 398 QDF_STATUS utils_dfs_radar_disable(struct wlan_objmgr_pdev *pdev) 399 { 400 struct wlan_dfs *dfs; 401 402 dfs = wlan_pdev_get_dfs_obj(pdev); 403 if (!dfs) 404 return QDF_STATUS_E_FAILURE; 405 406 dfs_radar_disable(dfs); 407 408 return QDF_STATUS_SUCCESS; 409 } 410 qdf_export_symbol(utils_dfs_radar_disable); 411 412 QDF_STATUS utils_dfs_set_update_nol_flag(struct wlan_objmgr_pdev *pdev, 413 bool val) 414 { 415 struct wlan_dfs *dfs; 416 417 dfs = wlan_pdev_get_dfs_obj(pdev); 418 if (!dfs) 419 return QDF_STATUS_E_FAILURE; 420 421 dfs_set_update_nol_flag(dfs, val); 422 423 return QDF_STATUS_SUCCESS; 424 } 425 qdf_export_symbol(utils_dfs_set_update_nol_flag); 426 427 QDF_STATUS utils_dfs_get_update_nol_flag(struct wlan_objmgr_pdev *pdev, 428 bool *nol_flag) 429 { 430 struct wlan_dfs *dfs; 431 432 dfs = wlan_pdev_get_dfs_obj(pdev); 433 if (!dfs) 434 return QDF_STATUS_E_FAILURE; 435 436 *nol_flag = dfs_get_update_nol_flag(dfs); 437 438 return QDF_STATUS_SUCCESS; 439 } 440 qdf_export_symbol(utils_dfs_get_update_nol_flag); 441 442 QDF_STATUS utils_dfs_get_dfs_use_nol(struct wlan_objmgr_pdev *pdev, 443 int *dfs_use_nol) 444 { 445 struct wlan_dfs *dfs; 446 447 dfs = wlan_pdev_get_dfs_obj(pdev); 448 if (!dfs) 449 return QDF_STATUS_E_FAILURE; 450 451 *dfs_use_nol = dfs_get_use_nol(dfs); 452 453 return QDF_STATUS_SUCCESS; 454 } 455 qdf_export_symbol(utils_dfs_get_dfs_use_nol); 456 457 QDF_STATUS utils_dfs_get_nol_timeout(struct wlan_objmgr_pdev *pdev, 458 int *dfs_nol_timeout) 459 { 460 struct wlan_dfs *dfs; 461 462 dfs = wlan_pdev_get_dfs_obj(pdev); 463 if (!dfs) 464 return QDF_STATUS_E_FAILURE; 465 466 *dfs_nol_timeout = dfs_get_nol_timeout(dfs); 467 468 return QDF_STATUS_SUCCESS; 469 } 470 qdf_export_symbol(utils_dfs_get_nol_timeout); 471 472 QDF_STATUS utils_dfs_nol_addchan(struct wlan_objmgr_pdev *pdev, 473 uint16_t freq, 474 uint32_t dfs_nol_timeout) 475 { 476 struct wlan_dfs *dfs; 477 478 dfs = wlan_pdev_get_dfs_obj(pdev); 479 if (!dfs) 480 return QDF_STATUS_E_FAILURE; 481 482 DFS_NOL_ADD_CHAN_LOCKED(dfs, freq, dfs_nol_timeout); 483 484 return QDF_STATUS_SUCCESS; 485 } 486 qdf_export_symbol(utils_dfs_nol_addchan); 487 488 QDF_STATUS utils_dfs_nol_update(struct wlan_objmgr_pdev *pdev) 489 { 490 struct wlan_dfs *dfs; 491 492 dfs = wlan_pdev_get_dfs_obj(pdev); 493 if (!dfs) 494 return QDF_STATUS_E_FAILURE; 495 496 dfs_nol_update(dfs); 497 498 return QDF_STATUS_SUCCESS; 499 } 500 qdf_export_symbol(utils_dfs_nol_update); 501 502 QDF_STATUS utils_dfs_second_segment_radar_disable(struct wlan_objmgr_pdev *pdev) 503 { 504 struct wlan_dfs *dfs; 505 506 dfs = wlan_pdev_get_dfs_obj(pdev); 507 if (!dfs) 508 return QDF_STATUS_E_FAILURE; 509 510 dfs_second_segment_radar_disable(dfs); 511 512 return QDF_STATUS_SUCCESS; 513 } 514 515 QDF_STATUS utils_dfs_bw_reduce(struct wlan_objmgr_pdev *pdev, bool bw_reduce) 516 { 517 struct wlan_dfs *dfs; 518 519 dfs = wlan_pdev_get_dfs_obj(pdev); 520 if (!dfs) 521 return QDF_STATUS_E_FAILURE; 522 523 dfs->dfs_bw_reduced = bw_reduce; 524 525 return QDF_STATUS_SUCCESS; 526 } 527 528 qdf_export_symbol(utils_dfs_bw_reduce); 529 530 QDF_STATUS utils_dfs_is_bw_reduce(struct wlan_objmgr_pdev *pdev, 531 bool *bw_reduce) 532 { 533 struct wlan_dfs *dfs; 534 535 dfs = wlan_pdev_get_dfs_obj(pdev); 536 if (!dfs) 537 return QDF_STATUS_E_FAILURE; 538 539 *bw_reduce = dfs->dfs_bw_reduced; 540 541 return QDF_STATUS_SUCCESS; 542 } 543 544 QDF_STATUS utils_dfs_fetch_nol_ie_info(struct wlan_objmgr_pdev *pdev, 545 uint8_t *nol_ie_bandwidth, 546 uint16_t *nol_ie_startfreq, 547 uint8_t *nol_ie_bitmap) 548 { 549 struct wlan_dfs *dfs; 550 551 dfs = wlan_pdev_get_dfs_obj(pdev); 552 if (!dfs) 553 return QDF_STATUS_E_FAILURE; 554 555 dfs_fetch_nol_ie_info(dfs, nol_ie_bandwidth, nol_ie_startfreq, 556 nol_ie_bitmap); 557 558 return QDF_STATUS_SUCCESS; 559 } 560 561 QDF_STATUS utils_dfs_set_rcsa_flags(struct wlan_objmgr_pdev *pdev, 562 bool is_rcsa_ie_sent, 563 bool is_nol_ie_sent) 564 { 565 struct wlan_dfs *dfs; 566 567 dfs = wlan_pdev_get_dfs_obj(pdev); 568 if (!dfs) 569 return QDF_STATUS_E_FAILURE; 570 571 dfs_set_rcsa_flags(dfs, is_rcsa_ie_sent, is_nol_ie_sent); 572 573 return QDF_STATUS_SUCCESS; 574 } 575 576 QDF_STATUS utils_dfs_get_rcsa_flags(struct wlan_objmgr_pdev *pdev, 577 bool *is_rcsa_ie_sent, 578 bool *is_nol_ie_sent) 579 { 580 struct wlan_dfs *dfs; 581 582 dfs = wlan_pdev_get_dfs_obj(pdev); 583 if (!dfs) 584 return QDF_STATUS_E_FAILURE; 585 dfs_get_rcsa_flags(dfs, is_rcsa_ie_sent, is_nol_ie_sent); 586 587 return QDF_STATUS_SUCCESS; 588 } 589 590 bool utils_dfs_process_nol_ie_bitmap(struct wlan_objmgr_pdev *pdev, 591 uint8_t nol_ie_bandwidth, 592 uint16_t nol_ie_startfreq, 593 uint8_t nol_ie_bitmap) 594 { 595 struct wlan_dfs *dfs; 596 597 dfs = wlan_pdev_get_dfs_obj(pdev); 598 if (!dfs) 599 return false; 600 return dfs_process_nol_ie_bitmap(dfs, nol_ie_bandwidth, 601 nol_ie_startfreq, 602 nol_ie_bitmap); 603 } 604 605 QDF_STATUS utils_dfs_set_cac_timer_running(struct wlan_objmgr_pdev *pdev, 606 int val) 607 { 608 struct wlan_dfs *dfs; 609 610 dfs = wlan_pdev_get_dfs_obj(pdev); 611 if (!dfs) 612 return QDF_STATUS_E_FAILURE; 613 614 dfs->dfs_cac_timer_running = val; 615 616 return QDF_STATUS_SUCCESS; 617 } 618 qdf_export_symbol(utils_dfs_set_cac_timer_running); 619 620 QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev, 621 void *nollist, 622 uint32_t *nol_chfreq, 623 uint32_t *nol_chwidth, 624 int index) 625 { 626 struct wlan_dfs *dfs; 627 628 dfs = wlan_pdev_get_dfs_obj(pdev); 629 if (!dfs) 630 return QDF_STATUS_E_FAILURE; 631 632 dfs_get_nol_chfreq_and_chwidth(nollist, nol_chfreq, nol_chwidth, index); 633 634 return QDF_STATUS_SUCCESS; 635 } 636 qdf_export_symbol(utils_dfs_get_nol_chfreq_and_chwidth); 637 638 QDF_STATUS utils_dfs_update_cur_chan_flags(struct wlan_objmgr_pdev *pdev, 639 uint64_t flags, 640 uint16_t flagext) 641 { 642 struct wlan_dfs *dfs; 643 644 dfs = wlan_pdev_get_dfs_obj(pdev); 645 if (!dfs) 646 return QDF_STATUS_E_FAILURE; 647 648 dfs_update_cur_chan_flags(dfs, flags, flagext); 649 650 return QDF_STATUS_SUCCESS; 651 } 652 653 static void utils_dfs_get_max_phy_mode(struct wlan_objmgr_pdev *pdev, 654 uint32_t *phy_mode) 655 { 656 return; 657 } 658 659 static void utils_dfs_get_max_sup_width(struct wlan_objmgr_pdev *pdev, 660 uint8_t *ch_width) 661 { 662 return; 663 } 664 665 #ifndef QCA_DFS_USE_POLICY_MANAGER 666 void utils_dfs_get_nol_history_chan_list(struct wlan_objmgr_pdev *pdev, 667 void *clist, uint32_t *num_chan) 668 { 669 int i, j = 0; 670 struct regulatory_channel *cur_chan_list; 671 struct wlan_dfs *dfs; 672 struct dfs_channel *chan_list = (struct dfs_channel *)clist; 673 674 *num_chan = 0; 675 676 dfs = wlan_pdev_get_dfs_obj(pdev); 677 if (!dfs) 678 return; 679 680 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * sizeof(*cur_chan_list)); 681 if (!cur_chan_list) 682 return; 683 684 if (wlan_reg_get_current_chan_list( 685 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 686 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 687 "failed to get cur_chan list"); 688 qdf_mem_free(cur_chan_list); 689 return; 690 } 691 692 for (i = 0; i < NUM_CHANNELS; i++) { 693 if (cur_chan_list[i].nol_history) { 694 chan_list[j].dfs_ch_freq = cur_chan_list[i].center_freq; 695 j++; 696 } 697 } 698 699 *num_chan = j; 700 qdf_mem_free(cur_chan_list); 701 } 702 703 void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 704 void *clist, uint32_t *num_chan) 705 { 706 int i = 0, j = 0; 707 enum channel_state state; 708 struct regulatory_channel *cur_chan_list; 709 struct wlan_dfs *dfs; 710 struct dfs_channel *chan_list = (struct dfs_channel *)clist; 711 712 dfs = wlan_pdev_get_dfs_obj(pdev); 713 if (!dfs) 714 return; 715 716 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * 717 sizeof(struct regulatory_channel)); 718 if (!cur_chan_list) { 719 *num_chan = 0; 720 return; 721 } 722 723 if (wlan_reg_get_current_chan_list( 724 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 725 *num_chan = 0; 726 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 727 "failed to get curr channel list"); 728 return; 729 } 730 731 for (i = 0; i < NUM_CHANNELS; i++) { 732 state = cur_chan_list[i].state; 733 if (state == CHANNEL_STATE_DFS || 734 state == CHANNEL_STATE_ENABLE) { 735 chan_list[j].dfs_ch_ieee = cur_chan_list[i].chan_num; 736 chan_list[j].dfs_ch_freq = cur_chan_list[i].center_freq; 737 if (state == CHANNEL_STATE_DFS) 738 chan_list[j].dfs_ch_flagext = 739 WLAN_CHAN_DFS; 740 741 if (cur_chan_list[i].nol_history) 742 chan_list[j].dfs_ch_flagext |= 743 WLAN_CHAN_HISTORY_RADAR; 744 j++; 745 } 746 } 747 *num_chan = j; 748 qdf_mem_free(cur_chan_list); 749 750 return; 751 } 752 753 /** 754 * utils_dfs_get_channel_list() - Get channel list from regdb component, based 755 * on current channel list. 756 * @pdev: Pointer to pdev structure. 757 * @vdev: vdev of request 758 * @chan: Pointer to channel list. 759 * @num_chan: number of channels. 760 * 761 * Get regdb channel list based on dfs current channel. 762 * Ex: When AP is operating in 5GHz channel, filter 2.4GHz and 4.9GHZ channels 763 * so that the random channel function does not select either 2.4GHz or 4.9GHz 764 * channel. 765 */ 766 #ifdef CONFIG_CHAN_FREQ_API 767 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 768 struct wlan_objmgr_vdev *vdev, 769 struct dfs_channel *chan_list, 770 uint32_t *num_chan) 771 { 772 struct dfs_channel *tmp_chan_list = NULL; 773 struct wlan_dfs *dfs; 774 bool is_curchan_5g; 775 bool is_curchan_24g; 776 bool is_curchan_49g; 777 uint32_t chan_num; 778 uint32_t center_freq; 779 uint16_t flagext; 780 int i, j = 0; 781 782 dfs = wlan_pdev_get_dfs_obj(pdev); 783 if (!dfs) { 784 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 785 return; 786 } 787 788 tmp_chan_list = qdf_mem_malloc(*num_chan * sizeof(*tmp_chan_list)); 789 if (!tmp_chan_list) 790 return; 791 792 utils_dfs_get_chan_list(pdev, (void *)tmp_chan_list, num_chan); 793 794 chan_num = dfs->dfs_curchan->dfs_ch_ieee; 795 center_freq = dfs->dfs_curchan->dfs_ch_freq; 796 is_curchan_5g = WLAN_REG_IS_5GHZ_CH_FREQ(center_freq); 797 is_curchan_24g = WLAN_REG_IS_24GHZ_CH_FREQ(center_freq); 798 is_curchan_49g = WLAN_REG_IS_49GHZ_FREQ(center_freq); 799 800 for (i = 0; i < *num_chan; i++) { 801 chan_num = tmp_chan_list[i].dfs_ch_ieee; 802 center_freq = tmp_chan_list[i].dfs_ch_freq; 803 flagext = tmp_chan_list[i].dfs_ch_flagext; 804 /* No change in prototype needed. Hence retaining same func */ 805 if (!dfs_mlme_check_allowed_prim_chanlist(pdev, center_freq)) 806 continue; 807 808 if ((is_curchan_5g) && WLAN_REG_IS_5GHZ_CH_FREQ(center_freq)) { 809 chan_list[j].dfs_ch_ieee = chan_num; 810 chan_list[j].dfs_ch_freq = center_freq; 811 chan_list[j].dfs_ch_flagext = flagext; 812 j++; 813 } else if ((is_curchan_24g) && 814 WLAN_REG_IS_24GHZ_CH_FREQ(center_freq)) { 815 chan_list[j].dfs_ch_ieee = chan_num; 816 chan_list[j].dfs_ch_freq = center_freq; 817 j++; 818 } else if ((is_curchan_49g) && 819 WLAN_REG_IS_49GHZ_FREQ(center_freq)) { 820 chan_list[j].dfs_ch_ieee = chan_num; 821 chan_list[j].dfs_ch_freq = center_freq; 822 j++; 823 } 824 } 825 826 *num_chan = j; 827 828 qdf_mem_free(tmp_chan_list); 829 } 830 #else /* NUM_API */ 831 #ifdef CONFIG_CHAN_NUM_API 832 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 833 struct wlan_objmgr_vdev *vdev, 834 struct dfs_channel *chan_list, 835 uint32_t *num_chan) 836 { 837 struct dfs_channel *tmp_chan_list = NULL; 838 struct wlan_dfs *dfs; 839 bool is_curchan_5g; 840 bool is_curchan_24g; 841 bool is_curchan_49g; 842 uint32_t chan_num; 843 uint32_t center_freq; 844 uint16_t flagext; 845 int i, j = 0; 846 847 dfs = wlan_pdev_get_dfs_obj(pdev); 848 if (!dfs) { 849 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 850 return; 851 } 852 853 tmp_chan_list = qdf_mem_malloc(*num_chan * sizeof(*tmp_chan_list)); 854 if (!tmp_chan_list) 855 return; 856 857 utils_dfs_get_chan_list(pdev, (void *)tmp_chan_list, num_chan); 858 859 chan_num = dfs->dfs_curchan->dfs_ch_ieee; 860 center_freq = dfs->dfs_curchan->dfs_ch_freq; 861 is_curchan_5g = WLAN_REG_IS_5GHZ_CH(chan_num); 862 is_curchan_24g = WLAN_REG_IS_24GHZ_CH(chan_num); 863 is_curchan_49g = WLAN_REG_IS_49GHZ_FREQ(center_freq); 864 865 for (i = 0; i < *num_chan; i++) { 866 chan_num = tmp_chan_list[i].dfs_ch_ieee; 867 center_freq = tmp_chan_list[i].dfs_ch_freq; 868 flagext = tmp_chan_list[i].dfs_ch_flagext; 869 870 if (!dfs_mlme_check_allowed_prim_chanlist(pdev, chan_num)) 871 continue; 872 873 if ((is_curchan_5g) && WLAN_REG_IS_5GHZ_CH(chan_num)) { 874 chan_list[j].dfs_ch_ieee = chan_num; 875 chan_list[j].dfs_ch_freq = center_freq; 876 chan_list[j].dfs_ch_flagext = flagext; 877 j++; 878 } else if ((is_curchan_24g) && 879 WLAN_REG_IS_24GHZ_CH(chan_num)) { 880 chan_list[j].dfs_ch_ieee = chan_num; 881 chan_list[j].dfs_ch_freq = center_freq; 882 j++; 883 } else if ((is_curchan_49g) && 884 WLAN_REG_IS_49GHZ_FREQ(center_freq)) { 885 chan_list[j].dfs_ch_ieee = chan_num; 886 chan_list[j].dfs_ch_freq = center_freq; 887 j++; 888 } 889 } 890 891 *num_chan = j; 892 893 qdf_mem_free(tmp_chan_list); 894 } 895 #endif 896 #endif 897 898 #else 899 900 void utils_dfs_get_nol_history_chan_list(struct wlan_objmgr_pdev *pdev, 901 void *clist, uint32_t *num_chan) 902 { 903 utils_dfs_get_chan_list(pdev, clist, num_chan); 904 } 905 906 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 907 struct wlan_objmgr_vdev *vdev, 908 struct dfs_channel *chan_list, 909 uint32_t *num_chan) 910 { 911 uint32_t pcl_ch[QDF_MAX_NUM_CHAN] = {0}; 912 uint8_t weight_list[QDF_MAX_NUM_CHAN] = {0}; 913 uint32_t len; 914 uint32_t weight_len; 915 int i; 916 struct wlan_objmgr_psoc *psoc; 917 uint32_t conn_count = 0; 918 enum policy_mgr_con_mode mode; 919 920 psoc = wlan_pdev_get_psoc(pdev); 921 if (!psoc) { 922 *num_chan = 0; 923 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 924 return; 925 } 926 927 len = QDF_ARRAY_SIZE(pcl_ch); 928 weight_len = QDF_ARRAY_SIZE(weight_list); 929 930 if (vdev) 931 mode = policy_mgr_convert_device_mode_to_qdf_type( 932 wlan_vdev_mlme_get_opmode(vdev)); 933 else 934 mode = PM_SAP_MODE; 935 conn_count = policy_mgr_mode_specific_connection_count( 936 psoc, mode, NULL); 937 if (0 == conn_count) 938 policy_mgr_get_pcl(psoc, mode, pcl_ch, 939 &len, weight_list, weight_len); 940 else 941 policy_mgr_get_pcl_for_existing_conn( 942 psoc, mode, pcl_ch, &len, weight_list, 943 weight_len, true); 944 945 if (*num_chan < len) { 946 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 947 "Invalid len src=%d, dst=%d", 948 *num_chan, len); 949 *num_chan = 0; 950 return; 951 } 952 953 for (i = 0; i < len; i++) { 954 chan_list[i].dfs_ch_ieee = 955 wlan_reg_freq_to_chan(pdev, pcl_ch[i]); 956 chan_list[i].dfs_ch_freq = pcl_ch[i]; 957 } 958 *num_chan = i; 959 dfs_info(NULL, WLAN_DEBUG_DFS_ALWAYS, "num channels %d", i); 960 } 961 962 void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 963 void *clist, uint32_t *num_chan) 964 { 965 utils_dfs_get_channel_list(pdev, NULL, (struct dfs_channel *)clist, 966 num_chan); 967 } 968 #endif 969 970 #ifdef CONFIG_CHAN_NUM_API 971 QDF_STATUS utils_dfs_get_vdev_random_channel( 972 struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev, 973 uint16_t flags, struct ch_params *ch_params, uint32_t *hw_mode, 974 uint8_t *target_chan, struct dfs_acs_info *acs_info) 975 { 976 uint32_t dfs_reg; 977 uint32_t num_chan = NUM_CHANNELS; 978 struct wlan_dfs *dfs = NULL; 979 struct wlan_objmgr_psoc *psoc; 980 struct dfs_channel *chan_list = NULL; 981 struct dfs_channel cur_chan; 982 QDF_STATUS status = QDF_STATUS_E_FAILURE; 983 984 *target_chan = 0; 985 psoc = wlan_pdev_get_psoc(pdev); 986 if (!psoc) { 987 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 988 goto random_chan_error; 989 } 990 991 dfs = wlan_pdev_get_dfs_obj(pdev); 992 if (!dfs) { 993 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 994 goto random_chan_error; 995 } 996 997 wlan_reg_get_dfs_region(pdev, &dfs_reg); 998 chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list)); 999 if (!chan_list) 1000 goto random_chan_error; 1001 1002 utils_dfs_get_channel_list(pdev, vdev, chan_list, &num_chan); 1003 if (!num_chan) { 1004 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels"); 1005 goto random_chan_error; 1006 } 1007 1008 cur_chan.dfs_ch_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0; 1009 cur_chan.dfs_ch_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1; 1010 1011 if (!ch_params->ch_width) 1012 utils_dfs_get_max_sup_width(pdev, 1013 (uint8_t *)&ch_params->ch_width); 1014 1015 *target_chan = dfs_prepare_random_channel(dfs, chan_list, 1016 num_chan, flags, (uint8_t *)&ch_params->ch_width, 1017 &cur_chan, (uint8_t)dfs_reg, acs_info); 1018 1019 ch_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1; 1020 ch_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2; 1021 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1022 "input width=%d", ch_params->ch_width); 1023 1024 if (*target_chan) { 1025 wlan_reg_set_channel_params(pdev, 1026 *target_chan, 0, ch_params); 1027 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1028 status = QDF_STATUS_SUCCESS; 1029 } 1030 1031 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1032 "ch=%d, seg0=%d, seg1=%d, width=%d", 1033 *target_chan, ch_params->center_freq_seg0, 1034 ch_params->center_freq_seg1, ch_params->ch_width); 1035 1036 random_chan_error: 1037 qdf_mem_free(chan_list); 1038 1039 return status; 1040 } 1041 1042 qdf_export_symbol(utils_dfs_get_vdev_random_channel); 1043 #endif 1044 1045 #ifdef CONFIG_CHAN_FREQ_API 1046 QDF_STATUS utils_dfs_get_vdev_random_channel_for_freq( 1047 struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev, 1048 uint16_t flags, struct ch_params *chan_params, uint32_t *hw_mode, 1049 uint16_t *target_chan_freq, struct dfs_acs_info *acs_info) 1050 { 1051 uint32_t dfs_reg; 1052 uint32_t num_chan = NUM_CHANNELS; 1053 struct wlan_dfs *dfs = NULL; 1054 struct wlan_objmgr_psoc *psoc; 1055 struct dfs_channel *chan_list = NULL; 1056 struct dfs_channel cur_chan; 1057 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1058 1059 *target_chan_freq = 0; 1060 psoc = wlan_pdev_get_psoc(pdev); 1061 if (!psoc) { 1062 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1063 goto random_chan_error; 1064 } 1065 1066 dfs = wlan_pdev_get_dfs_obj(pdev); 1067 if (!dfs) { 1068 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1069 goto random_chan_error; 1070 } 1071 1072 wlan_reg_get_dfs_region(pdev, &dfs_reg); 1073 chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list)); 1074 if (!chan_list) 1075 goto random_chan_error; 1076 1077 utils_dfs_get_channel_list(pdev, vdev, chan_list, &num_chan); 1078 if (!num_chan) { 1079 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels"); 1080 goto random_chan_error; 1081 } 1082 1083 cur_chan.dfs_ch_vhtop_ch_freq_seg1 = chan_params->center_freq_seg0; 1084 cur_chan.dfs_ch_vhtop_ch_freq_seg2 = chan_params->center_freq_seg1; 1085 cur_chan.dfs_ch_mhz_freq_seg1 = chan_params->mhz_freq_seg0; 1086 cur_chan.dfs_ch_mhz_freq_seg2 = chan_params->mhz_freq_seg1; 1087 1088 if (!chan_params->ch_width) 1089 utils_dfs_get_max_sup_width(pdev, 1090 (uint8_t *)&chan_params->ch_width); 1091 1092 *target_chan_freq = dfs_prepare_random_channel_for_freq(dfs, chan_list, 1093 num_chan, flags, (uint8_t *)&chan_params->ch_width, 1094 &cur_chan, (uint8_t)dfs_reg, acs_info); 1095 1096 chan_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1; 1097 chan_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2; 1098 chan_params->mhz_freq_seg0 = cur_chan.dfs_ch_mhz_freq_seg1; 1099 chan_params->mhz_freq_seg1 = cur_chan.dfs_ch_mhz_freq_seg2; 1100 1101 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1102 "input width=%d", chan_params->ch_width); 1103 1104 if (*target_chan_freq) { 1105 wlan_reg_set_channel_params_for_freq(pdev, *target_chan_freq, 0, 1106 chan_params); 1107 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1108 status = QDF_STATUS_SUCCESS; 1109 } 1110 1111 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 1112 "ch=%d, seg0=%d, seg1=%d, width=%d", 1113 *target_chan_freq, chan_params->center_freq_seg0, 1114 chan_params->center_freq_seg1, chan_params->ch_width); 1115 1116 random_chan_error: 1117 qdf_mem_free(chan_list); 1118 1119 return status; 1120 } 1121 1122 qdf_export_symbol(utils_dfs_get_vdev_random_channel_for_freq); 1123 #endif 1124 1125 #ifdef CONFIG_CHAN_NUM_API 1126 QDF_STATUS utils_dfs_get_random_channel( 1127 struct wlan_objmgr_pdev *pdev, 1128 uint16_t flags, 1129 struct ch_params *ch_params, 1130 uint32_t *hw_mode, 1131 uint8_t *target_chan, 1132 struct dfs_acs_info *acs_info) 1133 { 1134 return utils_dfs_get_vdev_random_channel( 1135 pdev, NULL, flags, ch_params, hw_mode, target_chan, 1136 acs_info); 1137 } 1138 qdf_export_symbol(utils_dfs_get_random_channel); 1139 #endif 1140 1141 #ifdef CONFIG_CHAN_FREQ_API 1142 QDF_STATUS utils_dfs_get_random_channel_for_freq( 1143 struct wlan_objmgr_pdev *pdev, 1144 uint16_t flags, 1145 struct ch_params *ch_params, 1146 uint32_t *hw_mode, 1147 uint16_t *target_chan_freq, 1148 struct dfs_acs_info *acs_info) 1149 { 1150 return utils_dfs_get_vdev_random_channel_for_freq(pdev, NULL, flags, 1151 ch_params, hw_mode, 1152 target_chan_freq, 1153 acs_info); 1154 } 1155 1156 qdf_export_symbol(utils_dfs_get_random_channel_for_freq); 1157 #endif 1158 1159 #ifdef CONFIG_CHAN_NUM_API 1160 QDF_STATUS utils_dfs_bw_reduced_channel( 1161 struct wlan_objmgr_pdev *pdev, 1162 struct ch_params *ch_params, 1163 uint32_t *hw_mode, 1164 uint8_t *target_chan) 1165 { 1166 struct wlan_dfs *dfs = NULL; 1167 struct wlan_objmgr_psoc *psoc; 1168 enum channel_state ch_state; 1169 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1170 1171 *target_chan = 0; 1172 psoc = wlan_pdev_get_psoc(pdev); 1173 if (!psoc) { 1174 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1175 return status; 1176 } 1177 1178 dfs = wlan_pdev_get_dfs_obj(pdev); 1179 if (!dfs) { 1180 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1181 return status; 1182 } 1183 1184 ch_state = wlan_reg_get_channel_state(pdev, 1185 dfs->dfs_curchan->dfs_ch_ieee); 1186 1187 if (ch_state == CHANNEL_STATE_DFS || 1188 ch_state == CHANNEL_STATE_ENABLE) { 1189 ch_params->center_freq_seg0 = 1190 dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1; 1191 ch_params->center_freq_seg1 = 1192 dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2; 1193 wlan_reg_set_channel_params(pdev, 1194 dfs->dfs_curchan->dfs_ch_ieee, 1195 0, ch_params); 1196 1197 *target_chan = dfs->dfs_curchan->dfs_ch_ieee; 1198 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1199 1200 return QDF_STATUS_SUCCESS; 1201 } 1202 1203 return status; 1204 } 1205 1206 qdf_export_symbol(utils_dfs_bw_reduced_channel); 1207 #endif 1208 1209 #ifdef CONFIG_CHAN_FREQ_API 1210 QDF_STATUS utils_dfs_bw_reduced_channel_for_freq( 1211 struct wlan_objmgr_pdev *pdev, 1212 struct ch_params *chan_params, 1213 uint32_t *hw_mode, 1214 uint16_t *target_chan_freq) 1215 { 1216 struct wlan_dfs *dfs = NULL; 1217 struct wlan_objmgr_psoc *psoc; 1218 enum channel_state ch_state; 1219 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1220 struct dfs_channel *dfs_curchan; 1221 1222 *target_chan_freq = 0; 1223 psoc = wlan_pdev_get_psoc(pdev); 1224 if (!psoc) { 1225 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1226 return status; 1227 } 1228 1229 dfs = wlan_pdev_get_dfs_obj(pdev); 1230 if (!dfs) { 1231 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1232 return status; 1233 } 1234 dfs_curchan = dfs->dfs_curchan; 1235 ch_state = 1236 wlan_reg_get_channel_state_for_freq(pdev, 1237 dfs_curchan->dfs_ch_freq); 1238 1239 if (ch_state == CHANNEL_STATE_DFS || 1240 ch_state == CHANNEL_STATE_ENABLE) { 1241 chan_params->mhz_freq_seg0 = 1242 dfs_curchan->dfs_ch_mhz_freq_seg1; 1243 chan_params->mhz_freq_seg1 = 1244 dfs_curchan->dfs_ch_mhz_freq_seg2; 1245 wlan_reg_set_channel_params_for_freq(pdev, 1246 dfs_curchan->dfs_ch_freq, 1247 0, chan_params); 1248 1249 *target_chan_freq = dfs_curchan->dfs_ch_freq; 1250 utils_dfs_get_max_phy_mode(pdev, hw_mode); 1251 1252 return QDF_STATUS_SUCCESS; 1253 } 1254 1255 return status; 1256 } 1257 1258 qdf_export_symbol(utils_dfs_bw_reduced_channel_for_freq); 1259 #endif 1260 1261 1262 #ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 1263 void utils_dfs_init_nol(struct wlan_objmgr_pdev *pdev) 1264 { 1265 struct wlan_dfs *dfs; 1266 struct wlan_objmgr_psoc *psoc; 1267 qdf_device_t qdf_dev; 1268 struct dfs_nol_info *dfs_nolinfo; 1269 int len; 1270 1271 dfs = wlan_pdev_get_dfs_obj(pdev); 1272 psoc = wlan_pdev_get_psoc(pdev); 1273 if (!dfs || !psoc) { 1274 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 1275 "dfs %pK, psoc %pK", dfs, psoc); 1276 return; 1277 } 1278 1279 qdf_dev = psoc->soc_objmgr.qdf_dev; 1280 if (!qdf_dev->dev) { 1281 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 1282 return; 1283 } 1284 1285 dfs_nolinfo = qdf_mem_malloc(sizeof(*dfs_nolinfo)); 1286 if (!dfs_nolinfo) 1287 return; 1288 1289 qdf_mem_zero(dfs_nolinfo, sizeof(*dfs_nolinfo)); 1290 len = pld_wlan_get_dfs_nol(qdf_dev->dev, (void *)dfs_nolinfo, 1291 (uint16_t)sizeof(*dfs_nolinfo)); 1292 if (len > 0) { 1293 dfs_set_nol(dfs, dfs_nolinfo->dfs_nol, dfs_nolinfo->num_chans); 1294 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "nol channels in pld"); 1295 DFS_PRINT_NOL_LOCKED(dfs); 1296 } else { 1297 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "no nol in pld"); 1298 } 1299 qdf_mem_free(dfs_nolinfo); 1300 } 1301 #endif 1302 qdf_export_symbol(utils_dfs_init_nol); 1303 1304 #ifndef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 1305 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 1306 { 1307 } 1308 #else 1309 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 1310 { 1311 struct dfs_nol_info *dfs_nolinfo; 1312 struct wlan_dfs *dfs = NULL; 1313 struct wlan_objmgr_psoc *psoc; 1314 qdf_device_t qdf_dev; 1315 int num_chans = 0; 1316 1317 dfs = wlan_pdev_get_dfs_obj(pdev); 1318 if (!dfs) { 1319 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1320 return; 1321 } 1322 1323 psoc = wlan_pdev_get_psoc(pdev); 1324 if (!psoc) { 1325 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 1326 return; 1327 } 1328 1329 qdf_dev = psoc->soc_objmgr.qdf_dev; 1330 if (!qdf_dev->dev) { 1331 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 1332 return; 1333 } 1334 1335 dfs_nolinfo = qdf_mem_malloc(sizeof(*dfs_nolinfo)); 1336 if (!dfs_nolinfo) 1337 return; 1338 1339 qdf_mem_zero(dfs_nolinfo, sizeof(*dfs_nolinfo)); 1340 DFS_GET_NOL_LOCKED(dfs, dfs_nolinfo->dfs_nol, &num_chans); 1341 if (num_chans > 0) { 1342 1343 if (num_chans > DFS_MAX_NOL_CHANNEL) 1344 dfs_nolinfo->num_chans = DFS_MAX_NOL_CHANNEL; 1345 else 1346 dfs_nolinfo->num_chans = num_chans; 1347 1348 pld_wlan_set_dfs_nol(qdf_dev->dev, (void *)dfs_nolinfo, 1349 (uint16_t)sizeof(*dfs_nolinfo)); 1350 } 1351 qdf_mem_free(dfs_nolinfo); 1352 } 1353 #endif 1354 qdf_export_symbol(utils_dfs_save_nol); 1355 1356 void utils_dfs_print_nol_channels(struct wlan_objmgr_pdev *pdev) 1357 { 1358 struct wlan_dfs *dfs = NULL; 1359 1360 dfs = wlan_pdev_get_dfs_obj(pdev); 1361 if (!dfs) { 1362 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1363 return; 1364 } 1365 1366 DFS_PRINT_NOL_LOCKED(dfs); 1367 } 1368 qdf_export_symbol(utils_dfs_print_nol_channels); 1369 1370 void utils_dfs_clear_nol_channels(struct wlan_objmgr_pdev *pdev) 1371 { 1372 struct wlan_dfs *dfs = NULL; 1373 1374 dfs = wlan_pdev_get_dfs_obj(pdev); 1375 if (!dfs) { 1376 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1377 return; 1378 } 1379 1380 /* First print list */ 1381 DFS_PRINT_NOL_LOCKED(dfs); 1382 1383 /* clear local cache first */ 1384 dfs_nol_timer_cleanup(dfs); 1385 dfs_nol_update(dfs); 1386 1387 /* 1388 * update platform driver nol list with local cache which is zero, 1389 * cleared in above step, so this will clear list in platform driver. 1390 */ 1391 utils_dfs_save_nol(pdev); 1392 } 1393 qdf_export_symbol(utils_dfs_clear_nol_channels); 1394 1395 #ifdef CONFIG_CHAN_NUM_API 1396 void utils_dfs_reg_update_nol_ch(struct wlan_objmgr_pdev *pdev, 1397 uint8_t *ch_list, 1398 uint8_t num_ch, 1399 bool nol_ch) 1400 { 1401 /* TODO : Need locking?*/ 1402 wlan_reg_update_nol_ch(pdev, ch_list, num_ch, nol_ch); 1403 } 1404 qdf_export_symbol(utils_dfs_reg_update_nol_ch); 1405 #endif 1406 1407 #ifdef CONFIG_CHAN_FREQ_API 1408 void utils_dfs_reg_update_nol_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1409 uint16_t *freq_list, 1410 uint8_t num_chan, 1411 bool nol_chan) 1412 { 1413 wlan_reg_update_nol_ch_for_freq(pdev, freq_list, num_chan, nol_chan); 1414 } 1415 1416 qdf_export_symbol(utils_dfs_reg_update_nol_chan_for_freq); 1417 #endif 1418 1419 #ifdef CONFIG_CHAN_NUM_API 1420 void utils_dfs_reg_update_nol_history_ch(struct wlan_objmgr_pdev *pdev, 1421 uint8_t *ch_list, 1422 uint8_t num_ch, 1423 bool nol_history_ch) 1424 { 1425 wlan_reg_update_nol_history_ch(pdev, ch_list, num_ch, nol_history_ch); 1426 } 1427 #endif 1428 1429 #ifdef CONFIG_CHAN_FREQ_API 1430 void 1431 utils_dfs_reg_update_nol_history_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1432 uint16_t *freq_list, 1433 uint8_t num_chan, 1434 bool nol_history_chan) 1435 { 1436 wlan_reg_update_nol_history_ch_for_freq(pdev, freq_list, num_chan, 1437 nol_history_chan); 1438 } 1439 #endif 1440 1441 uint8_t utils_dfs_freq_to_chan(uint32_t freq) 1442 { 1443 uint8_t chan; 1444 1445 if (freq == 0) 1446 return 0; 1447 1448 if (freq > DFS_24_GHZ_BASE_FREQ && freq < DFS_CHAN_14_FREQ) 1449 chan = ((freq - DFS_24_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ); 1450 else if (freq == DFS_CHAN_14_FREQ) 1451 chan = DFS_24_GHZ_CHANNEL_14; 1452 else if ((freq > DFS_24_GHZ_BASE_FREQ) && (freq < DFS_5_GHZ_BASE_FREQ)) 1453 chan = (((freq - DFS_CHAN_15_FREQ) / DFS_CHAN_SPACING_20MHZ) + 1454 DFS_24_GHZ_CHANNEL_15); 1455 else 1456 chan = (freq - DFS_5_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ; 1457 1458 return chan; 1459 } 1460 qdf_export_symbol(utils_dfs_freq_to_chan); 1461 1462 uint32_t utils_dfs_chan_to_freq(uint8_t chan) 1463 { 1464 if (chan == 0) 1465 return 0; 1466 1467 if (chan < DFS_24_GHZ_CHANNEL_14) 1468 return DFS_24_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 1469 else if (chan == DFS_24_GHZ_CHANNEL_14) 1470 return DFS_CHAN_14_FREQ; 1471 else if (chan < DFS_24_GHZ_CHANNEL_27) 1472 return DFS_CHAN_15_FREQ + ((chan - DFS_24_GHZ_CHANNEL_15) * 1473 DFS_CHAN_SPACING_20MHZ); 1474 else if (chan == DFS_5_GHZ_CHANNEL_170) 1475 return DFS_CHAN_170_FREQ; 1476 else 1477 return DFS_5_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 1478 } 1479 qdf_export_symbol(utils_dfs_chan_to_freq); 1480 1481 #ifdef QCA_MCL_DFS_SUPPORT 1482 #ifdef CONFIG_CHAN_NUM_API 1483 QDF_STATUS utils_dfs_mark_leaking_ch(struct wlan_objmgr_pdev *pdev, 1484 enum phy_ch_width ch_width, 1485 uint8_t temp_ch_lst_sz, 1486 uint8_t *temp_ch_lst) 1487 { 1488 struct wlan_dfs *dfs = NULL; 1489 1490 dfs = wlan_pdev_get_dfs_obj(pdev); 1491 if (!dfs) { 1492 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1493 return QDF_STATUS_E_FAILURE; 1494 } 1495 1496 return dfs_mark_leaking_ch(dfs, ch_width, temp_ch_lst_sz, temp_ch_lst); 1497 } 1498 qdf_export_symbol(utils_dfs_mark_leaking_ch); 1499 #endif 1500 1501 #ifdef CONFIG_CHAN_FREQ_API 1502 QDF_STATUS utils_dfs_mark_leaking_chan_for_freq(struct wlan_objmgr_pdev *pdev, 1503 enum phy_ch_width ch_width, 1504 uint8_t temp_chan_lst_sz, 1505 uint16_t *temp_freq_lst) 1506 { 1507 struct wlan_dfs *dfs = NULL; 1508 1509 dfs = wlan_pdev_get_dfs_obj(pdev); 1510 if (!dfs) { 1511 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 1512 return QDF_STATUS_E_FAILURE; 1513 } 1514 1515 return dfs_mark_leaking_chan_for_freq(dfs, ch_width, temp_chan_lst_sz, 1516 temp_freq_lst); 1517 } 1518 qdf_export_symbol(utils_dfs_mark_leaking_chan_for_freq); 1519 #endif 1520 #endif 1521 1522 int utils_get_dfsdomain(struct wlan_objmgr_pdev *pdev) 1523 { 1524 enum dfs_reg dfsdomain; 1525 1526 wlan_reg_get_dfs_region(pdev, &dfsdomain); 1527 1528 return dfsdomain; 1529 } 1530 1531 uint16_t utils_dfs_get_cur_rd(struct wlan_objmgr_pdev *pdev) 1532 { 1533 struct cur_regdmn_info cur_regdmn; 1534 1535 wlan_reg_get_curr_regdomain(pdev, &cur_regdmn); 1536 1537 return cur_regdmn.regdmn_pair_id; 1538 } 1539 1540 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 1541 QDF_STATUS utils_dfs_is_spoof_check_failed(struct wlan_objmgr_pdev *pdev, 1542 bool *is_spoof_check_failed) 1543 { 1544 struct wlan_dfs *dfs; 1545 1546 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1547 return QDF_STATUS_SUCCESS; 1548 1549 dfs = wlan_pdev_get_dfs_obj(pdev); 1550 if (!dfs) { 1551 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1552 return QDF_STATUS_E_FAILURE; 1553 } 1554 1555 *is_spoof_check_failed = dfs->dfs_spoof_check_failed; 1556 1557 return QDF_STATUS_SUCCESS; 1558 } 1559 1560 qdf_export_symbol(utils_dfs_is_spoof_check_failed); 1561 #endif 1562 1563 int dfs_get_num_chans(void) 1564 { 1565 return NUM_CHANNELS; 1566 } 1567 1568 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 1569 QDF_STATUS utils_dfs_get_disable_radar_marking(struct wlan_objmgr_pdev *pdev, 1570 bool *disable_radar_marking) 1571 { 1572 struct wlan_dfs *dfs; 1573 1574 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1575 return QDF_STATUS_SUCCESS; 1576 1577 dfs = wlan_pdev_get_dfs_obj(pdev); 1578 if (!dfs) { 1579 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1580 return QDF_STATUS_E_FAILURE; 1581 } 1582 1583 *disable_radar_marking = dfs_get_disable_radar_marking(dfs); 1584 1585 return QDF_STATUS_SUCCESS; 1586 } 1587 1588 qdf_export_symbol(utils_dfs_get_disable_radar_marking); 1589 1590 bool utils_is_dfs_cfreq2_ch(struct wlan_objmgr_pdev *pdev) 1591 { 1592 struct wlan_dfs *dfs; 1593 1594 dfs = wlan_pdev_get_dfs_obj(pdev); 1595 if (!dfs) 1596 return false; 1597 1598 return WLAN_IS_CHAN_DFS_CFREQ2(dfs->dfs_curchan); 1599 } 1600 1601 qdf_export_symbol(utils_is_dfs_cfreq2_ch); 1602 #endif 1603 1604 void utils_dfs_deliver_event(struct wlan_objmgr_pdev *pdev, uint16_t freq, 1605 enum WLAN_DFS_EVENTS event) 1606 { 1607 if (global_dfs_to_mlme.mlme_dfs_deliver_event) 1608 global_dfs_to_mlme.mlme_dfs_deliver_event(pdev, freq, event); 1609 } 1610 1611 void utils_dfs_reset_dfs_prevchan(struct wlan_objmgr_pdev *pdev) 1612 { 1613 struct wlan_dfs *dfs; 1614 1615 if (!tgt_dfs_is_pdev_5ghz(pdev)) 1616 return; 1617 1618 dfs = wlan_pdev_get_dfs_obj(pdev); 1619 if (!dfs) { 1620 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null"); 1621 return; 1622 } 1623 1624 dfs_reset_dfs_prevchan(dfs); 1625 } 1626