1 /* 2 * Copyright (c) 2016-2018 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_dfs_utils_api.h" 25 #include "wlan_dfs_mlme_api.h" 26 #include "../../core/src/dfs.h" 27 #include "../../core/src/dfs_zero_cac.h" 28 #include "../../core/src/dfs_etsi_precac.h" 29 #include <wlan_reg_services_api.h> 30 #include "../../core/src/dfs_random_chan_sel.h" 31 #ifdef QCA_DFS_USE_POLICY_MANAGER 32 #include "wlan_policy_mgr_api.h" 33 #endif 34 #ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 35 #include <pld_common.h> 36 #endif 37 #include <qdf_module.h> 38 39 struct dfs_nol_info { 40 uint16_t num_chans; 41 struct dfsreq_nolelem dfs_nol[DFS_MAX_NOL_CHANNEL]; 42 }; 43 44 QDF_STATUS utils_dfs_reset(struct wlan_objmgr_pdev *pdev) 45 { 46 struct wlan_dfs *dfs; 47 48 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 49 if (!dfs) 50 return QDF_STATUS_E_FAILURE; 51 52 dfs_reset(dfs); 53 dfs_nol_update(dfs); 54 dfs_reset_precaclists(dfs); 55 dfs_reset_etsiprecaclists(dfs); 56 57 return QDF_STATUS_SUCCESS; 58 } 59 60 bool utils_dfs_freq_is_in_nol(struct wlan_objmgr_pdev *pdev, uint32_t freq) 61 { 62 struct wlan_dfs *dfs; 63 64 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 65 if (!dfs) 66 return false; 67 68 return dfs_freq_is_in_nol(dfs, freq); 69 } 70 71 QDF_STATUS utils_dfs_cac_valid_reset(struct wlan_objmgr_pdev *pdev, 72 uint8_t prevchan_ieee, 73 uint32_t prevchan_flags) 74 { 75 struct wlan_dfs *dfs; 76 77 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 78 if (!dfs) 79 return QDF_STATUS_E_FAILURE; 80 81 dfs_cac_valid_reset(dfs, prevchan_ieee, prevchan_flags); 82 83 return QDF_STATUS_SUCCESS; 84 } 85 qdf_export_symbol(utils_dfs_cac_valid_reset); 86 87 QDF_STATUS utils_dfs_reset_precaclists(struct wlan_objmgr_pdev *pdev) 88 { 89 struct wlan_dfs *dfs; 90 91 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 92 if (!dfs) 93 return QDF_STATUS_E_FAILURE; 94 95 dfs_reset_precaclists(dfs); 96 97 return QDF_STATUS_SUCCESS; 98 } 99 qdf_export_symbol(utils_dfs_reset_precaclists); 100 101 #ifdef QCA_SUPPORT_ETSI_PRECAC_DFS 102 QDF_STATUS utils_dfs_reset_etsi_precaclists(struct wlan_objmgr_pdev *pdev) 103 { 104 struct wlan_dfs *dfs; 105 106 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 107 if (!dfs) 108 return QDF_STATUS_E_FAILURE; 109 110 dfs_reset_etsiprecaclists(dfs); 111 112 return QDF_STATUS_SUCCESS; 113 } 114 115 qdf_export_symbol(utils_dfs_reset_etsi_precaclists); 116 #endif 117 118 QDF_STATUS utils_dfs_cancel_precac_timer(struct wlan_objmgr_pdev *pdev) 119 { 120 struct wlan_dfs *dfs; 121 122 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 123 if (!dfs) 124 return QDF_STATUS_E_FAILURE; 125 126 dfs_cancel_precac_timer(dfs); 127 128 return QDF_STATUS_SUCCESS; 129 } 130 qdf_export_symbol(utils_dfs_cancel_precac_timer); 131 132 QDF_STATUS utils_dfs_start_precac_timer(struct wlan_objmgr_pdev *pdev) 133 { 134 struct wlan_dfs *dfs; 135 136 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 137 if (!dfs) { 138 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 139 return QDF_STATUS_E_FAILURE; 140 } 141 dfs_start_precac_timer(dfs, dfs->dfs_precac_secondary_freq); 142 return QDF_STATUS_SUCCESS; 143 } 144 145 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 146 QDF_STATUS utils_dfs_precac_decide_pref_chan(struct wlan_objmgr_pdev *pdev, 147 uint8_t *ch_ieee) 148 { 149 struct wlan_dfs *dfs; 150 151 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 152 if (!dfs) { 153 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "NULL dfs"); 154 return QDF_STATUS_E_FAILURE; 155 } 156 dfs_decide_precac_preferred_chan(dfs, ch_ieee); 157 158 return QDF_STATUS_SUCCESS; 159 } 160 #endif 161 162 QDF_STATUS utils_dfs_is_precac_done(struct wlan_objmgr_pdev *pdev, 163 bool *is_precac_done) 164 { 165 struct wlan_dfs *dfs; 166 167 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 168 if (!dfs) 169 return QDF_STATUS_E_FAILURE; 170 171 *is_precac_done = dfs_is_precac_done(dfs, dfs->dfs_curchan); 172 173 return QDF_STATUS_SUCCESS; 174 } 175 qdf_export_symbol(utils_dfs_is_precac_done); 176 177 #ifdef QCA_SUPPORT_ETSI_PRECAC_DFS 178 QDF_STATUS utils_dfs_is_etsi_precac_done(struct wlan_objmgr_pdev *pdev, 179 bool *is_etsi_precac_done) 180 { 181 struct wlan_dfs *dfs; 182 183 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 184 if (!dfs) 185 return QDF_STATUS_E_FAILURE; 186 187 *is_etsi_precac_done = dfs_is_etsi_precac_done(dfs); 188 189 return QDF_STATUS_SUCCESS; 190 } 191 192 qdf_export_symbol(utils_dfs_is_etsi_precac_done); 193 #endif 194 195 QDF_STATUS utils_dfs_cancel_cac_timer(struct wlan_objmgr_pdev *pdev) 196 { 197 struct wlan_dfs *dfs; 198 199 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 200 if (!dfs) 201 return QDF_STATUS_E_FAILURE; 202 203 dfs_cancel_cac_timer(dfs); 204 205 return QDF_STATUS_SUCCESS; 206 } 207 qdf_export_symbol(utils_dfs_cancel_cac_timer); 208 209 QDF_STATUS utils_dfs_start_cac_timer(struct wlan_objmgr_pdev *pdev) 210 { 211 struct wlan_dfs *dfs; 212 213 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 214 if (!dfs) 215 return QDF_STATUS_E_FAILURE; 216 217 dfs_start_cac_timer(dfs); 218 219 return QDF_STATUS_SUCCESS; 220 } 221 qdf_export_symbol(utils_dfs_start_cac_timer); 222 223 QDF_STATUS utils_dfs_cac_stop(struct wlan_objmgr_pdev *pdev) 224 { 225 struct wlan_dfs *dfs; 226 227 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 228 if (!dfs) 229 return QDF_STATUS_E_FAILURE; 230 231 dfs_cac_stop(dfs); 232 return QDF_STATUS_SUCCESS; 233 } 234 qdf_export_symbol(utils_dfs_cac_stop); 235 236 QDF_STATUS utils_dfs_stacac_stop(struct wlan_objmgr_pdev *pdev) 237 { 238 struct wlan_dfs *dfs; 239 240 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 241 if (!dfs) 242 return QDF_STATUS_E_FAILURE; 243 244 dfs_stacac_stop(dfs); 245 246 return QDF_STATUS_SUCCESS; 247 } 248 qdf_export_symbol(utils_dfs_stacac_stop); 249 250 QDF_STATUS utils_dfs_get_usenol(struct wlan_objmgr_pdev *pdev, uint16_t *usenol) 251 { 252 struct wlan_dfs *dfs; 253 254 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 255 if (!dfs) 256 return QDF_STATUS_E_FAILURE; 257 258 *usenol = dfs_get_use_nol(dfs); 259 260 return QDF_STATUS_SUCCESS; 261 } 262 qdf_export_symbol(utils_dfs_get_usenol); 263 264 QDF_STATUS utils_dfs_radar_disable(struct wlan_objmgr_pdev *pdev) 265 { 266 struct wlan_dfs *dfs; 267 268 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 269 if (!dfs) 270 return QDF_STATUS_E_FAILURE; 271 272 dfs_radar_disable(dfs); 273 274 return QDF_STATUS_SUCCESS; 275 } 276 qdf_export_symbol(utils_dfs_radar_disable); 277 278 QDF_STATUS utils_dfs_set_update_nol_flag(struct wlan_objmgr_pdev *pdev, 279 bool val) 280 { 281 struct wlan_dfs *dfs; 282 283 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 284 if (!dfs) 285 return QDF_STATUS_E_FAILURE; 286 287 dfs_set_update_nol_flag(dfs, val); 288 289 return QDF_STATUS_SUCCESS; 290 } 291 qdf_export_symbol(utils_dfs_set_update_nol_flag); 292 293 QDF_STATUS utils_dfs_get_update_nol_flag(struct wlan_objmgr_pdev *pdev, 294 bool *nol_flag) 295 { 296 struct wlan_dfs *dfs; 297 298 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 299 if (!dfs) 300 return QDF_STATUS_E_FAILURE; 301 302 *nol_flag = dfs_get_update_nol_flag(dfs); 303 304 return QDF_STATUS_SUCCESS; 305 } 306 qdf_export_symbol(utils_dfs_get_update_nol_flag); 307 308 QDF_STATUS utils_dfs_get_dfs_use_nol(struct wlan_objmgr_pdev *pdev, 309 int *dfs_use_nol) 310 { 311 struct wlan_dfs *dfs; 312 313 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 314 if (!dfs) 315 return QDF_STATUS_E_FAILURE; 316 317 *dfs_use_nol = dfs_get_use_nol(dfs); 318 319 return QDF_STATUS_SUCCESS; 320 } 321 qdf_export_symbol(utils_dfs_get_dfs_use_nol); 322 323 QDF_STATUS utils_dfs_get_nol_timeout(struct wlan_objmgr_pdev *pdev, 324 int *dfs_nol_timeout) 325 { 326 struct wlan_dfs *dfs; 327 328 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 329 if (!dfs) 330 return QDF_STATUS_E_FAILURE; 331 332 *dfs_nol_timeout = dfs_get_nol_timeout(dfs); 333 334 return QDF_STATUS_SUCCESS; 335 } 336 qdf_export_symbol(utils_dfs_get_nol_timeout); 337 338 QDF_STATUS utils_dfs_nol_addchan(struct wlan_objmgr_pdev *pdev, 339 uint16_t freq, 340 uint32_t dfs_nol_timeout) 341 { 342 struct wlan_dfs *dfs; 343 344 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 345 if (!dfs) 346 return QDF_STATUS_E_FAILURE; 347 348 DFS_NOL_ADD_CHAN_LOCKED(dfs, freq, dfs_nol_timeout); 349 350 return QDF_STATUS_SUCCESS; 351 } 352 qdf_export_symbol(utils_dfs_nol_addchan); 353 354 QDF_STATUS utils_dfs_nol_update(struct wlan_objmgr_pdev *pdev) 355 { 356 struct wlan_dfs *dfs; 357 358 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 359 if (!dfs) 360 return QDF_STATUS_E_FAILURE; 361 362 dfs_nol_update(dfs); 363 364 return QDF_STATUS_SUCCESS; 365 } 366 qdf_export_symbol(utils_dfs_nol_update); 367 368 QDF_STATUS utils_dfs_second_segment_radar_disable(struct wlan_objmgr_pdev *pdev) 369 { 370 struct wlan_dfs *dfs; 371 372 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 373 if (!dfs) 374 return QDF_STATUS_E_FAILURE; 375 376 dfs_second_segment_radar_disable(dfs); 377 378 return QDF_STATUS_SUCCESS; 379 } 380 381 QDF_STATUS utils_dfs_is_ignore_dfs(struct wlan_objmgr_pdev *pdev, 382 bool *ignore_dfs) 383 { 384 struct wlan_dfs *dfs; 385 386 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 387 if (!dfs) 388 return QDF_STATUS_E_FAILURE; 389 390 *ignore_dfs = dfs->dfs_ignore_dfs; 391 392 return QDF_STATUS_SUCCESS; 393 } 394 qdf_export_symbol(utils_dfs_is_ignore_dfs); 395 396 QDF_STATUS utils_dfs_is_cac_valid(struct wlan_objmgr_pdev *pdev, 397 bool *is_cac_valid) 398 { 399 struct wlan_dfs *dfs; 400 401 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 402 if (!dfs) 403 return QDF_STATUS_E_FAILURE; 404 405 *is_cac_valid = dfs->dfs_cac_valid; 406 407 return QDF_STATUS_SUCCESS; 408 } 409 qdf_export_symbol(utils_dfs_is_cac_valid); 410 411 QDF_STATUS utils_dfs_is_ignore_cac(struct wlan_objmgr_pdev *pdev, 412 bool *ignore_cac) 413 { 414 struct wlan_dfs *dfs; 415 416 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 417 if (!dfs) 418 return QDF_STATUS_E_FAILURE; 419 420 *ignore_cac = dfs->dfs_ignore_cac; 421 422 return QDF_STATUS_SUCCESS; 423 } 424 qdf_export_symbol(utils_dfs_is_ignore_cac); 425 426 QDF_STATUS utils_dfs_set_cac_timer_running(struct wlan_objmgr_pdev *pdev, 427 int val) 428 { 429 struct wlan_dfs *dfs; 430 431 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 432 if (!dfs) 433 return QDF_STATUS_E_FAILURE; 434 435 dfs->dfs_cac_timer_running = val; 436 437 return QDF_STATUS_SUCCESS; 438 } 439 qdf_export_symbol(utils_dfs_set_cac_timer_running); 440 441 QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev, 442 void *nollist, 443 uint32_t *nol_chfreq, 444 uint32_t *nol_chwidth, 445 int index) 446 { 447 struct wlan_dfs *dfs; 448 449 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 450 if (!dfs) 451 return QDF_STATUS_E_FAILURE; 452 453 dfs_get_nol_chfreq_and_chwidth(nollist, nol_chfreq, nol_chwidth, index); 454 455 return QDF_STATUS_SUCCESS; 456 } 457 qdf_export_symbol(utils_dfs_get_nol_chfreq_and_chwidth); 458 459 QDF_STATUS utils_dfs_update_cur_chan_flags(struct wlan_objmgr_pdev *pdev, 460 uint64_t flags, 461 uint16_t flagext) 462 { 463 struct wlan_dfs *dfs; 464 465 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 466 if (!dfs) 467 return QDF_STATUS_E_FAILURE; 468 469 dfs_update_cur_chan_flags(dfs, flags, flagext); 470 471 return QDF_STATUS_SUCCESS; 472 } 473 474 static void utils_dfs_get_max_phy_mode(struct wlan_objmgr_pdev *pdev, 475 uint32_t *phy_mode) 476 { 477 return; 478 } 479 480 static void utils_dfs_get_max_sup_width(struct wlan_objmgr_pdev *pdev, 481 uint8_t *ch_width) 482 { 483 return; 484 } 485 486 /** 487 * utils_dfs_get_chan_list() - Get channel list from regdb based on current 488 * operating channel. 489 * @pdev: Pointer to DFS pdev object. 490 * @chan_list: Pointer to current channel list 491 * @num_chan: number of channels in the current channel list. 492 */ 493 #ifndef QCA_DFS_USE_POLICY_MANAGER 494 static void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 495 struct dfs_channel *chan_list, uint32_t *num_chan) 496 { 497 int i = 0, j = 0; 498 enum channel_state state; 499 struct regulatory_channel *cur_chan_list; 500 struct wlan_dfs *dfs; 501 502 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 503 if (!dfs) 504 return; 505 506 cur_chan_list = qdf_mem_malloc(NUM_CHANNELS * 507 sizeof(struct regulatory_channel)); 508 if (!cur_chan_list) { 509 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, "fail to alloc"); 510 *num_chan = 0; 511 return; 512 } 513 514 if (wlan_reg_get_current_chan_list( 515 pdev, cur_chan_list) != QDF_STATUS_SUCCESS) { 516 *num_chan = 0; 517 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, 518 "failed to get curr channel list"); 519 return; 520 } 521 522 for (i = 0; i < NUM_CHANNELS; i++) { 523 state = cur_chan_list[i].state; 524 if (state == CHANNEL_STATE_DFS || 525 state == CHANNEL_STATE_ENABLE) { 526 chan_list[j].dfs_ch_ieee = cur_chan_list[i].chan_num; 527 chan_list[j].dfs_ch_freq = cur_chan_list[i].center_freq; 528 if (state == CHANNEL_STATE_DFS) 529 chan_list[j].dfs_ch_flagext = 530 WLAN_CHAN_DFS; 531 j++; 532 } 533 } 534 *num_chan = j; 535 qdf_mem_free(cur_chan_list); 536 537 return; 538 } 539 540 /** 541 * utils_dfs_get_channel_list() - Get channel list from regdb component based 542 * on current channel list. 543 * @pdev: Pointer to pdev structure. 544 * @chan_list: Pointer to regdb channel list. 545 * @num_chan: number of channels. 546 * 547 * Get regdb channel list based on dfs current channel. 548 * ex: When AP is operating in 5GHz channel, filter 2.4GHz and 4.9GHZ channels 549 * so that the random channel function does not select either 2.4GHz or 4.9GHz 550 * channel. 551 */ 552 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 553 struct dfs_channel *chan_list, uint32_t *num_chan) 554 { 555 struct dfs_channel *tmp_chan_list = NULL; 556 struct wlan_dfs *dfs; 557 bool is_curchan_5g; 558 bool is_curchan_24g; 559 bool is_curchan_49g; 560 uint32_t chan_num; 561 uint32_t center_freq; 562 uint16_t flagext; 563 int i, j = 0; 564 565 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 566 if (!dfs) { 567 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 568 return; 569 } 570 571 tmp_chan_list = qdf_mem_malloc(*num_chan * sizeof(*tmp_chan_list)); 572 if (!tmp_chan_list) { 573 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, "mem alloc failed"); 574 return; 575 } 576 577 utils_dfs_get_chan_list(pdev, tmp_chan_list, num_chan); 578 579 chan_num = dfs->dfs_curchan->dfs_ch_ieee; 580 center_freq = dfs->dfs_curchan->dfs_ch_freq; 581 is_curchan_5g = WLAN_REG_IS_5GHZ_CH(chan_num); 582 is_curchan_24g = WLAN_REG_IS_24GHZ_CH(chan_num); 583 is_curchan_49g = WLAN_REG_IS_49GHZ_FREQ(center_freq); 584 585 for (i = 0; i < *num_chan; i++) { 586 chan_num = tmp_chan_list[i].dfs_ch_ieee; 587 center_freq = tmp_chan_list[i].dfs_ch_freq; 588 flagext = tmp_chan_list[i].dfs_ch_flagext; 589 590 if (!dfs_mlme_check_allowed_prim_chanlist(pdev, chan_num)) 591 continue; 592 593 if ((is_curchan_5g) && WLAN_REG_IS_5GHZ_CH(chan_num)) { 594 chan_list[j].dfs_ch_ieee = chan_num; 595 chan_list[j].dfs_ch_freq = center_freq; 596 chan_list[j].dfs_ch_flagext = flagext; 597 j++; 598 } else if ((is_curchan_24g) && 599 WLAN_REG_IS_24GHZ_CH(chan_num)) { 600 chan_list[j].dfs_ch_ieee = chan_num; 601 chan_list[j].dfs_ch_freq = center_freq; 602 j++; 603 } else if ((is_curchan_49g) && 604 WLAN_REG_IS_49GHZ_FREQ(center_freq)) { 605 chan_list[j].dfs_ch_ieee = chan_num; 606 chan_list[j].dfs_ch_freq = center_freq; 607 j++; 608 } 609 } 610 611 *num_chan = j; 612 613 qdf_mem_free(tmp_chan_list); 614 } 615 616 #else 617 618 static void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, 619 struct dfs_channel *chan_list, uint32_t *num_chan) 620 { 621 uint8_t pcl_ch[QDF_MAX_NUM_CHAN] = {0}; 622 uint8_t weight_list[QDF_MAX_NUM_CHAN] = {0}; 623 uint32_t len; 624 uint32_t weight_len; 625 int i; 626 struct wlan_objmgr_psoc *psoc; 627 uint32_t conn_count = 0; 628 629 psoc = wlan_pdev_get_psoc(pdev); 630 if (!psoc) { 631 *num_chan = 0; 632 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 633 return; 634 } 635 636 len = QDF_ARRAY_SIZE(pcl_ch); 637 weight_len = QDF_ARRAY_SIZE(weight_list); 638 conn_count = policy_mgr_mode_specific_connection_count( 639 psoc, PM_SAP_MODE, NULL); 640 if (0 == conn_count) 641 policy_mgr_get_pcl(psoc, PM_SAP_MODE, pcl_ch, 642 &len, weight_list, weight_len); 643 else 644 policy_mgr_get_pcl_for_existing_conn(psoc, PM_SAP_MODE, pcl_ch, 645 &len, weight_list, weight_len, true); 646 647 if (*num_chan < len) { 648 dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, 649 "Invalid len src=%d, dst=%d", 650 *num_chan, len); 651 *num_chan = 0; 652 return; 653 } 654 655 for (i = 0; i < len; i++) { 656 chan_list[i].dfs_ch_ieee = pcl_ch[i]; 657 chan_list[i].dfs_ch_freq = 658 wlan_reg_chan_to_freq(pdev, pcl_ch[i]); 659 } 660 *num_chan = i; 661 dfs_info(NULL, WLAN_DEBUG_DFS_ALWAYS, "num channels %d", i); 662 } 663 664 /** 665 * utils_dfs_get_channel_list() - Wrapper function to get channel list from 666 * regdb component. 667 * @pdev: Pointer to pdev structure. 668 * @chan_list: Pointer to regdb channel list. 669 * @num_chan: number of channels. 670 */ 671 static void utils_dfs_get_channel_list(struct wlan_objmgr_pdev *pdev, 672 struct dfs_channel *chan_list, uint32_t *num_chan) 673 { 674 utils_dfs_get_chan_list(pdev, chan_list, num_chan); 675 } 676 #endif 677 678 QDF_STATUS utils_dfs_get_random_channel( 679 struct wlan_objmgr_pdev *pdev, 680 uint16_t flags, 681 struct ch_params *ch_params, 682 uint32_t *hw_mode, 683 uint8_t *target_chan, 684 struct dfs_acs_info *acs_info) 685 { 686 uint32_t dfs_reg; 687 uint32_t num_chan = NUM_CHANNELS; 688 struct wlan_dfs *dfs = NULL; 689 struct wlan_objmgr_psoc *psoc; 690 struct dfs_channel *chan_list = NULL; 691 struct dfs_channel cur_chan; 692 QDF_STATUS status = QDF_STATUS_E_FAILURE; 693 694 *target_chan = 0; 695 psoc = wlan_pdev_get_psoc(pdev); 696 if (!psoc) { 697 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 698 goto random_chan_error; 699 } 700 701 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 702 if (!dfs) { 703 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 704 goto random_chan_error; 705 } 706 707 wlan_reg_get_dfs_region(pdev, &dfs_reg); 708 chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list)); 709 if (!chan_list) { 710 dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, "mem alloc failed"); 711 goto random_chan_error; 712 } 713 714 utils_dfs_get_channel_list(pdev, chan_list, &num_chan); 715 if (!num_chan) { 716 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels"); 717 goto random_chan_error; 718 } 719 720 cur_chan.dfs_ch_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0; 721 cur_chan.dfs_ch_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1; 722 723 if (!ch_params->ch_width) 724 utils_dfs_get_max_sup_width(pdev, 725 (uint8_t *)&ch_params->ch_width); 726 727 *target_chan = dfs_prepare_random_channel(dfs, chan_list, 728 num_chan, flags, (uint8_t *)&ch_params->ch_width, 729 &cur_chan, (uint8_t)dfs_reg, acs_info); 730 731 ch_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1; 732 ch_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2; 733 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 734 "input width=%d", ch_params->ch_width); 735 736 if (*target_chan) { 737 wlan_reg_set_channel_params(pdev, 738 *target_chan, 0, ch_params); 739 utils_dfs_get_max_phy_mode(pdev, hw_mode); 740 status = QDF_STATUS_SUCCESS; 741 } 742 743 dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, 744 "ch=%d, seg0=%d, seg1=%d, width=%d", 745 *target_chan, ch_params->center_freq_seg0, 746 ch_params->center_freq_seg1, ch_params->ch_width); 747 748 random_chan_error: 749 qdf_mem_free(chan_list); 750 751 return status; 752 } 753 qdf_export_symbol(utils_dfs_get_random_channel); 754 755 #ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 756 void utils_dfs_init_nol(struct wlan_objmgr_pdev *pdev) 757 { 758 struct wlan_dfs *dfs; 759 struct wlan_objmgr_psoc *psoc; 760 qdf_device_t qdf_dev; 761 struct dfs_nol_info dfs_nolinfo; 762 int len; 763 764 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 765 psoc = wlan_pdev_get_psoc(pdev); 766 if (!dfs || !psoc) { 767 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, 768 "dfs %pK, psoc %pK", dfs, psoc); 769 return; 770 } 771 772 qdf_dev = psoc->soc_objmgr.qdf_dev; 773 if (!qdf_dev->dev) { 774 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 775 return; 776 } 777 778 qdf_mem_zero(&dfs_nolinfo, sizeof(dfs_nolinfo)); 779 len = pld_wlan_get_dfs_nol(qdf_dev->dev, (void *)&dfs_nolinfo, 780 (uint16_t)sizeof(dfs_nolinfo)); 781 if (len > 0) { 782 dfs_set_nol(dfs, dfs_nolinfo.dfs_nol, dfs_nolinfo.num_chans); 783 dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "nol channels in pld"); 784 DFS_PRINT_NOL_LOCKED(dfs); 785 } else { 786 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "no nol in pld"); 787 } 788 } 789 #endif 790 qdf_export_symbol(utils_dfs_init_nol); 791 792 #ifndef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT 793 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 794 { 795 } 796 #else 797 void utils_dfs_save_nol(struct wlan_objmgr_pdev *pdev) 798 { 799 struct dfs_nol_info dfs_nolinfo; 800 struct wlan_dfs *dfs = NULL; 801 struct wlan_objmgr_psoc *psoc; 802 qdf_device_t qdf_dev; 803 int num_chans = 0; 804 805 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 806 if (!dfs) { 807 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 808 return; 809 } 810 811 psoc = wlan_pdev_get_psoc(pdev); 812 if (!psoc) { 813 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc"); 814 return; 815 } 816 817 qdf_dev = psoc->soc_objmgr.qdf_dev; 818 if (!qdf_dev->dev) { 819 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null device"); 820 return; 821 } 822 823 qdf_mem_zero(&dfs_nolinfo, sizeof(dfs_nolinfo)); 824 DFS_GET_NOL_LOCKED(dfs, dfs_nolinfo.dfs_nol, &num_chans); 825 if (num_chans > 0) { 826 827 if (num_chans > DFS_MAX_NOL_CHANNEL) 828 dfs_nolinfo.num_chans = DFS_MAX_NOL_CHANNEL; 829 else 830 dfs_nolinfo.num_chans = num_chans; 831 832 pld_wlan_set_dfs_nol(qdf_dev->dev, (void *)&dfs_nolinfo, 833 (uint16_t)sizeof(dfs_nolinfo)); 834 } 835 } 836 #endif 837 qdf_export_symbol(utils_dfs_save_nol); 838 839 void utils_dfs_print_nol_channels(struct wlan_objmgr_pdev *pdev) 840 { 841 struct wlan_dfs *dfs = NULL; 842 843 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 844 if (!dfs) { 845 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 846 return; 847 } 848 849 DFS_PRINT_NOL_LOCKED(dfs); 850 } 851 qdf_export_symbol(utils_dfs_print_nol_channels); 852 853 void utils_dfs_clear_nol_channels(struct wlan_objmgr_pdev *pdev) 854 { 855 struct wlan_dfs *dfs = NULL; 856 857 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 858 if (!dfs) { 859 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 860 return; 861 } 862 863 /* First print list */ 864 DFS_PRINT_NOL_LOCKED(dfs); 865 866 /* clear local cache first */ 867 dfs_nol_timer_cleanup(dfs); 868 dfs_nol_update(dfs); 869 870 /* 871 * update platform driver nol list with local cache which is zero, 872 * cleared in above step, so this will clear list in platform driver. 873 */ 874 utils_dfs_save_nol(pdev); 875 } 876 qdf_export_symbol(utils_dfs_clear_nol_channels); 877 878 void utils_dfs_reg_update_nol_ch(struct wlan_objmgr_pdev *pdev, 879 uint8_t *ch_list, 880 uint8_t num_ch, 881 bool nol_ch) 882 { 883 /* TODO : Need locking?*/ 884 wlan_reg_update_nol_ch(pdev, ch_list, num_ch, nol_ch); 885 } 886 qdf_export_symbol(utils_dfs_reg_update_nol_ch); 887 888 uint8_t utils_dfs_freq_to_chan(uint32_t freq) 889 { 890 uint8_t chan; 891 892 if (freq == 0) 893 return 0; 894 895 if (freq > DFS_24_GHZ_BASE_FREQ && freq < DFS_CHAN_14_FREQ) 896 chan = ((freq - DFS_24_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ); 897 else if (freq == DFS_CHAN_14_FREQ) 898 chan = DFS_24_GHZ_CHANNEL_14; 899 else if ((freq > DFS_24_GHZ_BASE_FREQ) && (freq < DFS_5_GHZ_BASE_FREQ)) 900 chan = (((freq - DFS_CHAN_15_FREQ) / DFS_CHAN_SPACING_20MHZ) + 901 DFS_24_GHZ_CHANNEL_15); 902 else 903 chan = (freq - DFS_5_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ; 904 905 return chan; 906 } 907 qdf_export_symbol(utils_dfs_freq_to_chan); 908 909 uint32_t utils_dfs_chan_to_freq(uint8_t chan) 910 { 911 if (chan == 0) 912 return 0; 913 914 if (chan < DFS_24_GHZ_CHANNEL_14) 915 return DFS_24_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 916 else if (chan == DFS_24_GHZ_CHANNEL_14) 917 return DFS_CHAN_14_FREQ; 918 else if (chan < DFS_24_GHZ_CHANNEL_27) 919 return DFS_CHAN_15_FREQ + ((chan - DFS_24_GHZ_CHANNEL_15) * 920 DFS_CHAN_SPACING_20MHZ); 921 else if (chan == DFS_5_GHZ_CHANNEL_170) 922 return DFS_CHAN_170_FREQ; 923 else 924 return DFS_5_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ); 925 } 926 qdf_export_symbol(utils_dfs_chan_to_freq); 927 928 #ifdef QCA_MCL_DFS_SUPPORT 929 QDF_STATUS utils_dfs_mark_leaking_ch(struct wlan_objmgr_pdev *pdev, 930 enum phy_ch_width ch_width, 931 uint8_t temp_ch_lst_sz, 932 uint8_t *temp_ch_lst) 933 { 934 struct wlan_dfs *dfs = NULL; 935 936 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 937 if (!dfs) { 938 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 939 return QDF_STATUS_E_FAILURE; 940 } 941 942 return dfs_mark_leaking_ch(dfs, ch_width, temp_ch_lst_sz, temp_ch_lst); 943 } 944 qdf_export_symbol(utils_dfs_mark_leaking_ch); 945 #endif 946 947 int utils_get_dfsdomain(struct wlan_objmgr_pdev *pdev) 948 { 949 enum dfs_reg dfsdomain; 950 951 wlan_reg_get_dfs_region(pdev, &dfsdomain); 952 953 return dfsdomain; 954 } 955 956 uint16_t utils_dfs_get_cur_rd(struct wlan_objmgr_pdev *pdev) 957 { 958 struct cur_regdmn_info cur_regdmn; 959 960 wlan_reg_get_curr_regdomain(pdev, &cur_regdmn); 961 962 return cur_regdmn.regdmn_pair_id; 963 } 964 965 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 966 QDF_STATUS utils_dfs_is_spoof_check_failed(struct wlan_objmgr_pdev *pdev, 967 bool *is_spoof_check_failed) 968 { 969 struct wlan_dfs *dfs; 970 971 dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); 972 if (!dfs) { 973 dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); 974 return QDF_STATUS_E_FAILURE; 975 } 976 977 *is_spoof_check_failed = dfs->dfs_spoof_check_failed; 978 979 return QDF_STATUS_SUCCESS; 980 } 981 982 qdf_export_symbol(utils_dfs_is_spoof_check_failed); 983 #endif 984