1 /* 2 * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <qdf_types.h> 20 #include <qdf_trace.h> 21 #include <qdf_threads.h> 22 #include <qdf_module.h> 23 #include <dispatcher_init_deinit.h> 24 #include <scheduler_api.h> 25 #include <wlan_scan_ucfg_api.h> 26 #include <wlan_ftm_init_deinit_api.h> 27 #include <wlan_mgmt_txrx_utils_api.h> 28 #include <wlan_serialization_api.h> 29 #ifdef WLAN_POLICY_MGR_ENABLE 30 #include "wlan_policy_mgr_api.h" 31 #endif 32 #ifdef WLAN_ATF_ENABLE 33 #include <wlan_atf_utils_api.h> 34 #endif 35 #ifdef QCA_SUPPORT_SON 36 #include <wlan_son_pub.h> 37 #endif 38 #ifdef WLAN_SA_API_ENABLE 39 #include <wlan_sa_api_utils_api.h> 40 #endif 41 #ifdef WIFI_POS_CONVERGED 42 #include "wifi_pos_api.h" 43 #endif /* WIFI_POS_CONVERGED */ 44 #ifdef WLAN_FEATURE_NAN_CONVERGENCE 45 #include "wlan_nan_api.h" 46 #endif /* WLAN_FEATURE_NAN_CONVERGENCE */ 47 #ifdef CONVERGED_P2P_ENABLE 48 #include <wlan_cfg80211_p2p.h> 49 #include <wlan_p2p_ucfg_api.h> 50 #endif 51 #include <wlan_reg_services_api.h> 52 #ifdef WLAN_CONV_CRYPTO_SUPPORTED 53 #include "wlan_crypto_main.h" 54 #endif 55 #ifdef DFS_COMPONENT_ENABLE 56 #include <wlan_dfs_init_deinit_api.h> 57 #endif 58 59 #ifdef WLAN_OFFCHAN_TXRX_ENABLE 60 #include <wlan_offchan_txrx_api.h> 61 #endif 62 63 #ifdef CONVERGED_TDLS_ENABLE 64 #include "wlan_tdls_ucfg_api.h" 65 #endif 66 67 #ifdef WLAN_SUPPORT_SPLITMAC 68 #include <wlan_splitmac.h> 69 #endif 70 71 #include <wlan_spectral_utils_api.h> 72 #ifdef WLAN_SUPPORT_FILS 73 #include <wlan_fd_utils_api.h> 74 #endif 75 76 #ifdef WLAN_SUPPORT_GREEN_AP 77 #include <wlan_green_ap_api.h> 78 #endif 79 80 #ifdef QCA_SUPPORT_CP_STATS 81 #include <wlan_cp_stats_utils_api.h> 82 #endif 83 84 /** 85 * DOC: This file provides various init/deinit trigger point for new 86 * components. 87 */ 88 89 /* All new components needs to replace their dummy init/deinit 90 * psoc_open, psco_close, psoc_enable and psoc_disable APIs once 91 * their actual handlers are ready 92 */ 93 94 spectral_pdev_open_handler dispatcher_spectral_pdev_open_handler_cb; 95 96 #ifdef QCA_SUPPORT_CP_STATS 97 static QDF_STATUS dispatcher_init_cp_stats(void) 98 { 99 return wlan_cp_stats_init(); 100 } 101 102 static QDF_STATUS dispatcher_deinit_cp_stats(void) 103 { 104 return wlan_cp_stats_deinit(); 105 } 106 107 static QDF_STATUS cp_stats_psoc_open(struct wlan_objmgr_psoc *psoc) 108 { 109 return wlan_cp_stats_open(psoc); 110 } 111 112 static QDF_STATUS cp_stats_psoc_close(struct wlan_objmgr_psoc *psoc) 113 { 114 return wlan_cp_stats_close(psoc); 115 } 116 117 static QDF_STATUS cp_stats_psoc_enable(struct wlan_objmgr_psoc *psoc) 118 { 119 return wlan_cp_stats_enable(psoc); 120 } 121 122 static QDF_STATUS cp_stats_psoc_disable(struct wlan_objmgr_psoc *psoc) 123 { 124 return wlan_cp_stats_disable(psoc); 125 } 126 #else 127 static QDF_STATUS dispatcher_init_cp_stats(void) 128 { 129 return QDF_STATUS_SUCCESS; 130 } 131 132 static QDF_STATUS dispatcher_deinit_cp_stats(void) 133 { 134 return QDF_STATUS_SUCCESS; 135 } 136 137 static QDF_STATUS cp_stats_psoc_open(struct wlan_objmgr_psoc *psoc) 138 { 139 return QDF_STATUS_SUCCESS; 140 } 141 142 static QDF_STATUS cp_stats_psoc_close(struct wlan_objmgr_psoc *psoc) 143 { 144 return QDF_STATUS_SUCCESS; 145 } 146 147 static QDF_STATUS cp_stats_psoc_enable(struct wlan_objmgr_psoc *psoc) 148 { 149 return QDF_STATUS_SUCCESS; 150 } 151 152 static QDF_STATUS cp_stats_psoc_disable(struct wlan_objmgr_psoc *psoc) 153 { 154 return QDF_STATUS_SUCCESS; 155 } 156 #endif 157 158 #ifdef CONVERGED_P2P_ENABLE 159 static QDF_STATUS p2p_init(void) 160 { 161 return ucfg_p2p_init(); 162 } 163 164 static QDF_STATUS p2p_deinit(void) 165 { 166 return ucfg_p2p_deinit(); 167 } 168 169 static QDF_STATUS p2p_psoc_open(struct wlan_objmgr_psoc *psoc) 170 { 171 return ucfg_p2p_psoc_open(psoc); 172 } 173 174 static QDF_STATUS p2p_psoc_close(struct wlan_objmgr_psoc *psoc) 175 { 176 return ucfg_p2p_psoc_close(psoc); 177 } 178 179 static QDF_STATUS p2p_psoc_enable(struct wlan_objmgr_psoc *psoc) 180 { 181 return wlan_p2p_start(psoc); 182 } 183 184 static QDF_STATUS p2p_psoc_disable(struct wlan_objmgr_psoc *psoc) 185 { 186 return wlan_p2p_stop(psoc); 187 } 188 #else 189 static QDF_STATUS p2p_init(void) 190 { 191 return QDF_STATUS_SUCCESS; 192 } 193 194 static QDF_STATUS p2p_deinit(void) 195 { 196 return QDF_STATUS_SUCCESS; 197 } 198 199 static QDF_STATUS p2p_psoc_open(struct wlan_objmgr_psoc *psoc) 200 { 201 return QDF_STATUS_SUCCESS; 202 } 203 204 static QDF_STATUS p2p_psoc_close(struct wlan_objmgr_psoc *psoc) 205 { 206 return QDF_STATUS_SUCCESS; 207 } 208 209 static QDF_STATUS p2p_psoc_enable(struct wlan_objmgr_psoc *psoc) 210 { 211 return QDF_STATUS_SUCCESS; 212 } 213 214 static QDF_STATUS p2p_psoc_disable(struct wlan_objmgr_psoc *psoc) 215 { 216 return QDF_STATUS_SUCCESS; 217 } 218 #endif /* END of CONVERGED_P2P_ENABLE */ 219 220 #ifdef CONVERGED_TDLS_ENABLE 221 static QDF_STATUS tdls_init(void) 222 { 223 return ucfg_tdls_init(); 224 } 225 226 static QDF_STATUS tdls_deinit(void) 227 { 228 return ucfg_tdls_deinit(); 229 } 230 231 static QDF_STATUS tdls_psoc_open(struct wlan_objmgr_psoc *psoc) 232 { 233 return ucfg_tdls_psoc_open(psoc); 234 } 235 236 static QDF_STATUS tdls_psoc_close(struct wlan_objmgr_psoc *psoc) 237 { 238 return ucfg_tdls_psoc_close(psoc); 239 } 240 241 static QDF_STATUS tdls_psoc_enable(struct wlan_objmgr_psoc *psoc) 242 { 243 return ucfg_tdls_psoc_enable(psoc); 244 } 245 246 static QDF_STATUS tdls_psoc_disable(struct wlan_objmgr_psoc *psoc) 247 { 248 return ucfg_tdls_psoc_disable(psoc); 249 } 250 #else 251 static QDF_STATUS tdls_init(void) 252 { 253 return QDF_STATUS_SUCCESS; 254 } 255 256 static QDF_STATUS tdls_deinit(void) 257 { 258 return QDF_STATUS_SUCCESS; 259 } 260 261 static QDF_STATUS tdls_psoc_open(struct wlan_objmgr_psoc *psoc) 262 { 263 return QDF_STATUS_SUCCESS; 264 } 265 266 static QDF_STATUS tdls_psoc_close(struct wlan_objmgr_psoc *psoc) 267 { 268 return QDF_STATUS_SUCCESS; 269 } 270 271 static QDF_STATUS tdls_psoc_enable(struct wlan_objmgr_psoc *psoc) 272 { 273 return QDF_STATUS_SUCCESS; 274 } 275 276 277 static QDF_STATUS tdls_psoc_disable(struct wlan_objmgr_psoc *psoc) 278 { 279 return QDF_STATUS_SUCCESS; 280 } 281 #endif 282 283 #if defined QCA_SUPPORT_SON && QCA_SUPPORT_SON >= 1 284 static QDF_STATUS dispatcher_init_son(void) 285 { 286 return wlan_son_init(); 287 } 288 static QDF_STATUS son_psoc_open(struct wlan_objmgr_psoc *psoc) 289 { 290 return wlan_son_psoc_open(psoc); 291 } 292 static QDF_STATUS dispatcher_deinit_son(void) 293 { 294 return wlan_son_deinit(); 295 } 296 297 static QDF_STATUS son_psoc_close(struct wlan_objmgr_psoc *psoc) 298 { 299 return wlan_son_psoc_close(psoc); 300 } 301 #else 302 static QDF_STATUS dispatcher_init_son(void) 303 { 304 return QDF_STATUS_SUCCESS; 305 } 306 307 static QDF_STATUS dispatcher_deinit_son(void) 308 { 309 return QDF_STATUS_SUCCESS; 310 } 311 312 static QDF_STATUS son_psoc_open(struct wlan_objmgr_psoc *psoc) 313 { 314 return QDF_STATUS_SUCCESS; 315 } 316 317 static QDF_STATUS son_psoc_close(struct wlan_objmgr_psoc *psoc) 318 { 319 return QDF_STATUS_SUCCESS; 320 } 321 322 #endif /* END of QCA_SUPPORT_SON */ 323 324 static QDF_STATUS dispatcher_regulatory_init(void) 325 { 326 return wlan_regulatory_init(); 327 } 328 329 static QDF_STATUS dispatcher_regulatory_deinit(void) 330 { 331 return wlan_regulatory_deinit(); 332 } 333 334 static QDF_STATUS dispatcher_regulatory_psoc_open(struct wlan_objmgr_psoc 335 *psoc) 336 { 337 return regulatory_psoc_open(psoc); 338 } 339 340 static QDF_STATUS dispatcher_regulatory_psoc_close(struct wlan_objmgr_psoc 341 *psoc) 342 { 343 return regulatory_psoc_close(psoc); 344 } 345 346 static QDF_STATUS dispatcher_regulatory_pdev_open(struct wlan_objmgr_pdev 347 *pdev) 348 { 349 return regulatory_pdev_open(pdev); 350 } 351 352 #ifdef CONFIG_WIN 353 QDF_STATUS dispatcher_register_spectral_pdev_open_handler( 354 spectral_pdev_open_handler handler) 355 { 356 dispatcher_spectral_pdev_open_handler_cb = handler; 357 358 return QDF_STATUS_SUCCESS; 359 } 360 qdf_export_symbol(dispatcher_register_spectral_pdev_open_handler); 361 362 static QDF_STATUS dispatcher_spectral_pdev_open(struct wlan_objmgr_pdev 363 *pdev) 364 { 365 return dispatcher_spectral_pdev_open_handler_cb(pdev); 366 } 367 368 static QDF_STATUS dispatcher_spectral_pdev_close(struct wlan_objmgr_pdev *pdev) 369 { 370 return QDF_STATUS_SUCCESS; 371 } 372 #else 373 static QDF_STATUS dispatcher_spectral_pdev_open(struct wlan_objmgr_pdev 374 *pdev) 375 { 376 return spectral_pdev_open(pdev); 377 } 378 379 static QDF_STATUS dispatcher_spectral_pdev_close(struct wlan_objmgr_pdev *pdev) 380 { 381 return QDF_STATUS_SUCCESS; 382 } 383 #endif 384 385 static QDF_STATUS dispatcher_regulatory_pdev_close(struct wlan_objmgr_pdev 386 *pdev) 387 { 388 return regulatory_pdev_close(pdev); 389 } 390 391 #ifdef WLAN_POLICY_MGR_ENABLE 392 static QDF_STATUS dispatcher_policy_mgr_init(void) 393 { 394 return policy_mgr_init(); 395 } 396 397 static QDF_STATUS dispatcher_policy_mgr_deinit(void) 398 { 399 return policy_mgr_deinit(); 400 } 401 402 static QDF_STATUS dispatcher_policy_mgr_psoc_open( 403 struct wlan_objmgr_psoc *psoc) 404 { 405 return policy_mgr_psoc_open(psoc); 406 } 407 408 static QDF_STATUS dispatcher_policy_mgr_psoc_close( 409 struct wlan_objmgr_psoc *psoc) 410 { 411 return policy_mgr_psoc_close(psoc); 412 } 413 414 static QDF_STATUS dispatcher_policy_mgr_psoc_enable( 415 struct wlan_objmgr_psoc *psoc) 416 { 417 return policy_mgr_psoc_enable(psoc); 418 } 419 420 static QDF_STATUS dispatcher_policy_mgr_psoc_disable( 421 struct wlan_objmgr_psoc *psoc) 422 { 423 return policy_mgr_psoc_disable(psoc); 424 } 425 #else 426 static QDF_STATUS dispatcher_policy_mgr_init(void) 427 { 428 return QDF_STATUS_SUCCESS; 429 } 430 431 static QDF_STATUS dispatcher_policy_mgr_deinit(void) 432 { 433 return QDF_STATUS_SUCCESS; 434 } 435 436 static QDF_STATUS dispatcher_policy_mgr_psoc_open( 437 struct wlan_objmgr_psoc *psoc) 438 { 439 return QDF_STATUS_SUCCESS; 440 } 441 442 static QDF_STATUS dispatcher_policy_mgr_psoc_close( 443 struct wlan_objmgr_psoc *psoc) 444 { 445 return QDF_STATUS_SUCCESS; 446 } 447 448 static QDF_STATUS dispatcher_policy_mgr_psoc_enable( 449 struct wlan_objmgr_psoc *psoc) 450 { 451 return QDF_STATUS_SUCCESS; 452 } 453 454 static QDF_STATUS dispatcher_policy_mgr_psoc_disable( 455 struct wlan_objmgr_psoc *psoc) 456 { 457 return QDF_STATUS_SUCCESS; 458 } 459 #endif /* END of WLAN_POLICY_MGR_ENABLE */ 460 461 #ifdef WLAN_SA_API_ENABLE 462 static QDF_STATUS dispatcher_init_sa_api(void) 463 { 464 return wlan_sa_api_init(); 465 } 466 467 static QDF_STATUS dispatcher_deinit_sa_api(void) 468 { 469 return wlan_sa_api_deinit(); 470 } 471 472 static QDF_STATUS sa_api_psoc_enable(struct wlan_objmgr_psoc *psoc) 473 { 474 return wlan_sa_api_enable(psoc); 475 } 476 477 static QDF_STATUS sa_api_psoc_disable(struct wlan_objmgr_psoc *psoc) 478 { 479 return wlan_sa_api_disable(psoc); 480 } 481 #else 482 static QDF_STATUS dispatcher_init_sa_api(void) 483 { 484 return QDF_STATUS_SUCCESS; 485 } 486 487 static QDF_STATUS dispatcher_deinit_sa_api(void) 488 { 489 return QDF_STATUS_SUCCESS; 490 } 491 492 static QDF_STATUS sa_api_psoc_enable(struct wlan_objmgr_psoc *psoc) 493 { 494 return QDF_STATUS_SUCCESS; 495 } 496 497 static QDF_STATUS sa_api_psoc_disable(struct wlan_objmgr_psoc *psoc) 498 { 499 return QDF_STATUS_SUCCESS; 500 } 501 #endif /* END of WLAN_SA_API_ENABLE */ 502 503 504 #ifdef WLAN_ATF_ENABLE 505 static QDF_STATUS dispatcher_init_atf(void) 506 { 507 return wlan_atf_init(); 508 } 509 510 static QDF_STATUS dispatcher_deinit_atf(void) 511 { 512 return wlan_atf_deinit(); 513 } 514 515 static QDF_STATUS atf_psoc_open(struct wlan_objmgr_psoc *psoc) 516 { 517 return wlan_atf_open(psoc); 518 } 519 520 static QDF_STATUS atf_psoc_close(struct wlan_objmgr_psoc *psoc) 521 { 522 return wlan_atf_close(psoc); 523 } 524 525 static QDF_STATUS atf_psoc_enable(struct wlan_objmgr_psoc *psoc) 526 { 527 return wlan_atf_enable(psoc); 528 } 529 530 static QDF_STATUS atf_psoc_disable(struct wlan_objmgr_psoc *psoc) 531 { 532 return wlan_atf_disable(psoc); 533 } 534 #else 535 static QDF_STATUS dispatcher_init_atf(void) 536 { 537 return QDF_STATUS_SUCCESS; 538 } 539 540 static QDF_STATUS dispatcher_deinit_atf(void) 541 { 542 return QDF_STATUS_SUCCESS; 543 } 544 545 static QDF_STATUS atf_psoc_open(struct wlan_objmgr_psoc *psoc) 546 { 547 return QDF_STATUS_SUCCESS; 548 } 549 550 static QDF_STATUS atf_psoc_close(struct wlan_objmgr_psoc *psoc) 551 { 552 return QDF_STATUS_SUCCESS; 553 } 554 555 static QDF_STATUS atf_psoc_enable(struct wlan_objmgr_psoc *psoc) 556 { 557 return QDF_STATUS_SUCCESS; 558 } 559 560 static QDF_STATUS atf_psoc_disable(struct wlan_objmgr_psoc *psoc) 561 { 562 return QDF_STATUS_SUCCESS; 563 } 564 #endif /* END of WLAN_ATF_ENABLE */ 565 566 #ifdef WLAN_CONV_CRYPTO_SUPPORTED 567 static QDF_STATUS dispatcher_init_crypto(void) 568 { 569 return wlan_crypto_init(); 570 } 571 572 static QDF_STATUS dispatcher_deinit_crypto(void) 573 { 574 return wlan_crypto_deinit(); 575 } 576 #else 577 static QDF_STATUS dispatcher_init_crypto(void) 578 { 579 return QDF_STATUS_SUCCESS; 580 } 581 582 static QDF_STATUS dispatcher_deinit_crypto(void) 583 { 584 return QDF_STATUS_SUCCESS; 585 } 586 #endif /* END of WLAN_CONV_CRYPTO_SUPPORTED */ 587 588 #ifdef WIFI_POS_CONVERGED 589 static QDF_STATUS dispatcher_init_wifi_pos(void) 590 { 591 return wifi_pos_init(); 592 } 593 594 static QDF_STATUS dispatcher_deinit_wifi_pos(void) 595 { 596 return wifi_pos_deinit(); 597 } 598 599 static QDF_STATUS dispatcher_wifi_pos_enable(struct wlan_objmgr_psoc *psoc) 600 { 601 return wifi_pos_psoc_enable(psoc); 602 } 603 604 static QDF_STATUS dispatcher_wifi_pos_disable(struct wlan_objmgr_psoc *psoc) 605 { 606 return wifi_pos_psoc_disable(psoc); 607 } 608 #else 609 static QDF_STATUS dispatcher_init_wifi_pos(void) 610 { 611 return QDF_STATUS_SUCCESS; 612 } 613 614 static QDF_STATUS dispatcher_deinit_wifi_pos(void) 615 { 616 return QDF_STATUS_SUCCESS; 617 } 618 619 static QDF_STATUS dispatcher_wifi_pos_enable(struct wlan_objmgr_psoc *psoc) 620 { 621 return QDF_STATUS_SUCCESS; 622 } 623 624 static QDF_STATUS dispatcher_wifi_pos_disable(struct wlan_objmgr_psoc *psoc) 625 { 626 return QDF_STATUS_SUCCESS; 627 } 628 #endif 629 630 #ifdef WLAN_FEATURE_NAN_CONVERGENCE 631 static QDF_STATUS dispatcher_init_nan(void) 632 { 633 return nan_init(); 634 } 635 636 static QDF_STATUS dispatcher_deinit_nan(void) 637 { 638 return nan_deinit(); 639 } 640 641 static QDF_STATUS dispatcher_nan_psoc_enable(struct wlan_objmgr_psoc *psoc) 642 { 643 return nan_psoc_enable(psoc); 644 } 645 646 static QDF_STATUS dispatcher_nan_psoc_disable(struct wlan_objmgr_psoc *psoc) 647 { 648 return nan_psoc_disable(psoc); 649 } 650 #else 651 static QDF_STATUS dispatcher_init_nan(void) 652 { 653 return QDF_STATUS_SUCCESS; 654 } 655 656 static QDF_STATUS dispatcher_deinit_nan(void) 657 { 658 return QDF_STATUS_SUCCESS; 659 } 660 661 static QDF_STATUS dispatcher_nan_psoc_enable(struct wlan_objmgr_psoc *psoc) 662 { 663 return QDF_STATUS_SUCCESS; 664 } 665 666 static QDF_STATUS dispatcher_nan_psoc_disable(struct wlan_objmgr_psoc *psoc) 667 { 668 return QDF_STATUS_SUCCESS; 669 } 670 #endif 671 672 #ifdef DFS_COMPONENT_ENABLE 673 static QDF_STATUS dispatcher_init_dfs(void) 674 { 675 return dfs_init(); 676 } 677 678 static QDF_STATUS dispatcher_deinit_dfs(void) 679 { 680 return dfs_deinit(); 681 } 682 683 static QDF_STATUS dispatcher_dfs_psoc_enable(struct wlan_objmgr_psoc *psoc) 684 { 685 return wifi_dfs_psoc_enable(psoc); 686 } 687 688 static QDF_STATUS dispatcher_dfs_psoc_disable(struct wlan_objmgr_psoc *psoc) 689 { 690 return wifi_dfs_psoc_disable(psoc); 691 } 692 #else 693 static QDF_STATUS dispatcher_init_dfs(void) 694 { 695 return QDF_STATUS_SUCCESS; 696 } 697 698 static QDF_STATUS dispatcher_deinit_dfs(void) 699 { 700 return QDF_STATUS_SUCCESS; 701 } 702 703 static QDF_STATUS dispatcher_dfs_psoc_enable(struct wlan_objmgr_psoc *psoc) 704 { 705 return QDF_STATUS_SUCCESS; 706 } 707 708 static QDF_STATUS dispatcher_dfs_psoc_disable(struct wlan_objmgr_psoc *psoc) 709 { 710 return QDF_STATUS_SUCCESS; 711 } 712 #endif 713 714 #ifdef WLAN_OFFCHAN_TXRX_ENABLE 715 static QDF_STATUS dispatcher_offchan_txrx_init(void) 716 { 717 return wlan_offchan_txrx_init(); 718 } 719 720 static QDF_STATUS dispatcher_offchan_txrx_deinit(void) 721 { 722 return wlan_offchan_txrx_deinit(); 723 } 724 #else 725 static QDF_STATUS dispatcher_offchan_txrx_init(void) 726 { 727 return QDF_STATUS_SUCCESS; 728 } 729 730 static QDF_STATUS dispatcher_offchan_txrx_deinit(void) 731 { 732 return QDF_STATUS_SUCCESS; 733 } 734 #endif /*WLAN_OFFCHAN_TXRX_ENABLE*/ 735 736 #ifdef WLAN_SUPPORT_SPLITMAC 737 static QDF_STATUS dispatcher_splitmac_init(void) 738 { 739 return wlan_splitmac_init(); 740 } 741 742 static QDF_STATUS dispatcher_splitmac_deinit(void) 743 { 744 return wlan_splitmac_deinit(); 745 } 746 #else 747 static QDF_STATUS dispatcher_splitmac_init(void) 748 { 749 return QDF_STATUS_SUCCESS; 750 } 751 752 static QDF_STATUS dispatcher_splitmac_deinit(void) 753 { 754 return QDF_STATUS_SUCCESS; 755 } 756 #endif /* WLAN_SUPPORT_SPLITMAC */ 757 758 #ifdef CONFIG_MCL 759 static QDF_STATUS dispatcher_spectral_init(void) 760 { 761 return wlan_spectral_init(); 762 } 763 764 static QDF_STATUS dispatcher_spectral_deinit(void) 765 { 766 return wlan_spectral_deinit(); 767 } 768 #else 769 static QDF_STATUS dispatcher_spectral_init(void) 770 { 771 return QDF_STATUS_SUCCESS; 772 } 773 774 static QDF_STATUS dispatcher_spectral_deinit(void) 775 { 776 return QDF_STATUS_SUCCESS; 777 } 778 #endif /*CONFIG_MCL*/ 779 780 #ifdef DIRECT_BUF_RX_ENABLE 781 static QDF_STATUS dispatcher_dbr_psoc_enable(struct wlan_objmgr_psoc *psoc) 782 { 783 struct wlan_lmac_if_tx_ops *tx_ops; 784 785 tx_ops = wlan_psoc_get_lmac_if_txops(psoc); 786 if (tx_ops->dbr_tx_ops.direct_buf_rx_register_events) 787 return tx_ops->dbr_tx_ops.direct_buf_rx_register_events(psoc); 788 789 return QDF_STATUS_SUCCESS; 790 } 791 792 static QDF_STATUS dispatcher_dbr_psoc_disable(struct wlan_objmgr_psoc *psoc) 793 { 794 struct wlan_lmac_if_tx_ops *tx_ops; 795 796 tx_ops = wlan_psoc_get_lmac_if_txops(psoc); 797 if (tx_ops->dbr_tx_ops.direct_buf_rx_unregister_events) 798 return tx_ops->dbr_tx_ops.direct_buf_rx_unregister_events(psoc); 799 800 return QDF_STATUS_SUCCESS; 801 } 802 #else 803 static QDF_STATUS dispatcher_dbr_psoc_enable(struct wlan_objmgr_psoc *psoc) 804 { 805 return QDF_STATUS_SUCCESS; 806 } 807 808 static QDF_STATUS dispatcher_dbr_psoc_disable(struct wlan_objmgr_psoc *psoc) 809 { 810 return QDF_STATUS_SUCCESS; 811 } 812 #endif /* DIRECT_BUF_RX_ENABLE */ 813 814 #ifdef WLAN_SUPPORT_GREEN_AP 815 static QDF_STATUS dispatcher_green_ap_init(void) 816 { 817 return wlan_green_ap_init(); 818 } 819 820 static QDF_STATUS dispatcher_green_ap_deinit(void) 821 { 822 return wlan_green_ap_deinit(); 823 } 824 #else 825 static QDF_STATUS dispatcher_green_ap_init(void) 826 { 827 return QDF_STATUS_SUCCESS; 828 } 829 830 static QDF_STATUS dispatcher_green_ap_deinit(void) 831 { 832 return QDF_STATUS_SUCCESS; 833 } 834 #endif 835 836 #ifdef WLAN_SUPPORT_FILS 837 static QDF_STATUS dispatcher_fd_init(void) 838 { 839 return wlan_fd_init(); 840 } 841 842 static QDF_STATUS dispatcher_fd_deinit(void) 843 { 844 return wlan_fd_deinit(); 845 } 846 847 static QDF_STATUS fd_psoc_enable(struct wlan_objmgr_psoc *psoc) 848 { 849 return wlan_fd_enable(psoc); 850 } 851 852 static QDF_STATUS fd_psoc_disable(struct wlan_objmgr_psoc *psoc) 853 { 854 return wlan_fd_disable(psoc); 855 } 856 #else 857 static QDF_STATUS dispatcher_fd_init(void) 858 { 859 return QDF_STATUS_SUCCESS; 860 } 861 862 static QDF_STATUS dispatcher_fd_deinit(void) 863 { 864 return QDF_STATUS_SUCCESS; 865 } 866 867 static QDF_STATUS fd_psoc_enable(struct wlan_objmgr_psoc *psoc) 868 { 869 return QDF_STATUS_SUCCESS; 870 } 871 872 static QDF_STATUS fd_psoc_disable(struct wlan_objmgr_psoc *psoc) 873 { 874 return QDF_STATUS_SUCCESS; 875 } 876 #endif /* WLAN_SUPPORT_FILS */ 877 878 QDF_STATUS dispatcher_init(void) 879 { 880 if (QDF_STATUS_SUCCESS != wlan_objmgr_global_obj_init()) 881 goto out; 882 883 if (QDF_STATUS_SUCCESS != wlan_mgmt_txrx_init()) 884 goto mgmt_txrx_init_fail; 885 886 if (QDF_STATUS_SUCCESS != ucfg_scan_init()) 887 goto ucfg_scan_init_fail; 888 889 if (QDF_STATUS_SUCCESS != p2p_init()) 890 goto p2p_init_fail; 891 892 if (QDF_STATUS_SUCCESS != tdls_init()) 893 goto tdls_init_fail; 894 895 if (QDF_STATUS_SUCCESS != wlan_serialization_init()) 896 goto serialization_init_fail; 897 898 if (QDF_STATUS_SUCCESS != dispatcher_init_crypto()) 899 goto crypto_init_fail; 900 901 if (QDF_STATUS_SUCCESS != dispatcher_policy_mgr_init()) 902 goto policy_mgr_init_fail; 903 904 if (QDF_STATUS_SUCCESS != dispatcher_init_cp_stats()) 905 goto cp_stats_init_fail; 906 907 if (QDF_STATUS_SUCCESS != dispatcher_init_atf()) 908 goto atf_init_fail; 909 910 if (QDF_STATUS_SUCCESS != dispatcher_init_sa_api()) 911 goto sa_api_init_fail; 912 913 if (QDF_STATUS_SUCCESS != dispatcher_init_wifi_pos()) 914 goto wifi_pos_init_fail; 915 916 if (QDF_STATUS_SUCCESS != dispatcher_init_nan()) 917 goto nan_init_fail; 918 919 if (QDF_STATUS_SUCCESS != dispatcher_init_dfs()) 920 goto dfs_init_fail; 921 922 if (QDF_STATUS_SUCCESS != dispatcher_regulatory_init()) 923 goto regulatory_init_fail; 924 925 if (QDF_STATUS_SUCCESS != dispatcher_offchan_txrx_init()) 926 goto offchan_init_fail; 927 928 if (QDF_STATUS_SUCCESS != dispatcher_init_son()) 929 goto son_init_fail; 930 931 if (QDF_STATUS_SUCCESS != dispatcher_splitmac_init()) 932 goto splitmac_init_fail; 933 934 if (QDF_STATUS_SUCCESS != dispatcher_spectral_init()) 935 goto spectral_init_fail; 936 937 if (QDF_STATUS_SUCCESS != dispatcher_fd_init()) 938 goto fd_init_fail; 939 940 if (QDF_STATUS_SUCCESS != dispatcher_green_ap_init()) 941 goto green_ap_init_fail; 942 943 if (QDF_STATUS_SUCCESS != dispatcher_ftm_init()) 944 goto ftm_init_fail; 945 946 /* 947 * scheduler INIT has to be the last as each component's 948 * initialization has to happen first and then at the end 949 * scheduler needs to start accepting the service. 950 */ 951 if (QDF_STATUS_SUCCESS != scheduler_init()) 952 goto scheduler_init_fail; 953 954 return QDF_STATUS_SUCCESS; 955 956 scheduler_init_fail: 957 dispatcher_ftm_deinit(); 958 ftm_init_fail: 959 dispatcher_green_ap_deinit(); 960 green_ap_init_fail: 961 dispatcher_fd_deinit(); 962 fd_init_fail: 963 dispatcher_spectral_deinit(); 964 spectral_init_fail: 965 dispatcher_splitmac_deinit(); 966 splitmac_init_fail: 967 dispatcher_deinit_son(); 968 son_init_fail: 969 dispatcher_offchan_txrx_deinit(); 970 offchan_init_fail: 971 dispatcher_regulatory_deinit(); 972 regulatory_init_fail: 973 dispatcher_deinit_dfs(); 974 dfs_init_fail: 975 dispatcher_deinit_nan(); 976 nan_init_fail: 977 dispatcher_deinit_wifi_pos(); 978 wifi_pos_init_fail: 979 dispatcher_deinit_sa_api(); 980 sa_api_init_fail: 981 dispatcher_deinit_atf(); 982 atf_init_fail: 983 dispatcher_deinit_cp_stats(); 984 cp_stats_init_fail: 985 dispatcher_policy_mgr_deinit(); 986 policy_mgr_init_fail: 987 dispatcher_deinit_crypto(); 988 crypto_init_fail: 989 wlan_serialization_deinit(); 990 serialization_init_fail: 991 tdls_deinit(); 992 tdls_init_fail: 993 p2p_deinit(); 994 p2p_init_fail: 995 ucfg_scan_deinit(); 996 ucfg_scan_init_fail: 997 wlan_mgmt_txrx_deinit(); 998 mgmt_txrx_init_fail: 999 wlan_objmgr_global_obj_deinit(); 1000 1001 out: 1002 return QDF_STATUS_E_FAILURE; 1003 } 1004 qdf_export_symbol(dispatcher_init); 1005 1006 QDF_STATUS dispatcher_deinit(void) 1007 { 1008 QDF_BUG(QDF_STATUS_SUCCESS == scheduler_deinit()); 1009 1010 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_ftm_deinit()); 1011 1012 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_green_ap_deinit()); 1013 1014 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_fd_deinit()); 1015 1016 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_spectral_deinit()); 1017 1018 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_splitmac_deinit()); 1019 1020 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_son()); 1021 1022 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_offchan_txrx_deinit()); 1023 1024 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_regulatory_deinit()); 1025 1026 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_dfs()); 1027 1028 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_nan()); 1029 1030 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_wifi_pos()); 1031 1032 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_sa_api()); 1033 1034 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_atf()); 1035 1036 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_cp_stats()); 1037 1038 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_policy_mgr_deinit()); 1039 1040 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_deinit_crypto()); 1041 1042 QDF_BUG(QDF_STATUS_SUCCESS == wlan_serialization_deinit()); 1043 1044 QDF_BUG(QDF_STATUS_SUCCESS == tdls_deinit()); 1045 1046 QDF_BUG(QDF_STATUS_SUCCESS == p2p_deinit()); 1047 1048 QDF_BUG(QDF_STATUS_SUCCESS == ucfg_scan_deinit()); 1049 1050 QDF_BUG(QDF_STATUS_SUCCESS == wlan_mgmt_txrx_deinit()); 1051 1052 QDF_BUG(QDF_STATUS_SUCCESS == wlan_objmgr_global_obj_deinit()); 1053 1054 return QDF_STATUS_SUCCESS; 1055 } 1056 qdf_export_symbol(dispatcher_deinit); 1057 1058 QDF_STATUS dispatcher_enable(void) 1059 { 1060 QDF_STATUS status; 1061 1062 status = scheduler_enable(); 1063 1064 return status; 1065 } 1066 qdf_export_symbol(dispatcher_enable); 1067 1068 QDF_STATUS dispatcher_disable(void) 1069 { 1070 QDF_BUG(QDF_IS_STATUS_SUCCESS(scheduler_disable())); 1071 1072 return QDF_STATUS_SUCCESS; 1073 } 1074 qdf_export_symbol(dispatcher_disable); 1075 1076 QDF_STATUS dispatcher_psoc_open(struct wlan_objmgr_psoc *psoc) 1077 { 1078 if (QDF_STATUS_SUCCESS != wlan_mgmt_txrx_psoc_open(psoc)) 1079 goto out; 1080 1081 if (QDF_STATUS_SUCCESS != ucfg_scan_psoc_open(psoc)) 1082 goto scan_psoc_open_fail; 1083 1084 if (QDF_STATUS_SUCCESS != p2p_psoc_open(psoc)) 1085 goto p2p_psoc_open_fail; 1086 1087 if (QDF_STATUS_SUCCESS != tdls_psoc_open(psoc)) 1088 goto tdls_psoc_open_fail; 1089 1090 if (QDF_STATUS_SUCCESS != wlan_serialization_psoc_open(psoc)) 1091 goto serialization_psoc_open_fail; 1092 1093 if (QDF_STATUS_SUCCESS != cp_stats_psoc_open(psoc)) 1094 goto cp_stats_psoc_open_fail; 1095 1096 if (QDF_STATUS_SUCCESS != atf_psoc_open(psoc)) 1097 goto atf_psoc_open_fail; 1098 1099 if (QDF_STATUS_SUCCESS != dispatcher_policy_mgr_psoc_open(psoc)) 1100 goto policy_mgr_psoc_open_fail; 1101 1102 if (QDF_STATUS_SUCCESS != dispatcher_regulatory_psoc_open(psoc)) 1103 goto regulatory_psoc_open_fail; 1104 1105 if (QDF_STATUS_SUCCESS != son_psoc_open(psoc)) 1106 goto psoc_son_fail; 1107 1108 if (QDF_STATUS_SUCCESS != dispatcher_ftm_psoc_open(psoc)) 1109 goto ftm_psoc_open_fail; 1110 1111 return QDF_STATUS_SUCCESS; 1112 1113 ftm_psoc_open_fail: 1114 son_psoc_close(psoc); 1115 psoc_son_fail: 1116 regulatory_psoc_close(psoc); 1117 regulatory_psoc_open_fail: 1118 dispatcher_policy_mgr_psoc_close(psoc); 1119 policy_mgr_psoc_open_fail: 1120 atf_psoc_close(psoc); 1121 atf_psoc_open_fail: 1122 cp_stats_psoc_close(psoc); 1123 cp_stats_psoc_open_fail: 1124 wlan_serialization_psoc_close(psoc); 1125 serialization_psoc_open_fail: 1126 tdls_psoc_close(psoc); 1127 tdls_psoc_open_fail: 1128 p2p_psoc_close(psoc); 1129 p2p_psoc_open_fail: 1130 ucfg_scan_psoc_close(psoc); 1131 scan_psoc_open_fail: 1132 wlan_mgmt_txrx_psoc_close(psoc); 1133 1134 out: 1135 return QDF_STATUS_E_FAILURE; 1136 } 1137 qdf_export_symbol(dispatcher_psoc_open); 1138 1139 QDF_STATUS dispatcher_psoc_close(struct wlan_objmgr_psoc *psoc) 1140 { 1141 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_ftm_psoc_close(psoc)); 1142 1143 QDF_BUG(QDF_STATUS_SUCCESS == son_psoc_close(psoc)); 1144 1145 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_regulatory_psoc_close(psoc)); 1146 1147 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_policy_mgr_psoc_close(psoc)); 1148 1149 QDF_BUG(QDF_STATUS_SUCCESS == atf_psoc_close(psoc)); 1150 1151 QDF_BUG(QDF_STATUS_SUCCESS == cp_stats_psoc_close(psoc)); 1152 1153 QDF_BUG(QDF_STATUS_SUCCESS == wlan_serialization_psoc_close(psoc)); 1154 1155 QDF_BUG(QDF_STATUS_SUCCESS == tdls_psoc_close(psoc)); 1156 1157 QDF_BUG(QDF_STATUS_SUCCESS == p2p_psoc_close(psoc)); 1158 1159 QDF_BUG(QDF_STATUS_SUCCESS == ucfg_scan_psoc_close(psoc)); 1160 1161 QDF_BUG(QDF_STATUS_SUCCESS == wlan_mgmt_txrx_psoc_close(psoc)); 1162 1163 return QDF_STATUS_SUCCESS; 1164 } 1165 qdf_export_symbol(dispatcher_psoc_close); 1166 1167 QDF_STATUS dispatcher_psoc_enable(struct wlan_objmgr_psoc *psoc) 1168 { 1169 if (QDF_STATUS_SUCCESS != ucfg_scan_psoc_enable(psoc)) 1170 goto out; 1171 1172 if (QDF_STATUS_SUCCESS != p2p_psoc_enable(psoc)) 1173 goto p2p_psoc_enable_fail; 1174 1175 if (QDF_STATUS_SUCCESS != tdls_psoc_enable(psoc)) 1176 goto tdls_psoc_enable_fail; 1177 1178 if (QDF_STATUS_SUCCESS != dispatcher_policy_mgr_psoc_enable(psoc)) 1179 goto policy_mgr_psoc_enable_fail; 1180 1181 if (QDF_STATUS_SUCCESS != sa_api_psoc_enable(psoc)) 1182 goto sa_api_psoc_enable_fail; 1183 1184 if (QDF_STATUS_SUCCESS != cp_stats_psoc_enable(psoc)) 1185 goto cp_stats_psoc_enable_fail; 1186 1187 if (QDF_STATUS_SUCCESS != atf_psoc_enable(psoc)) 1188 goto atf_psoc_enable_fail; 1189 1190 if (QDF_STATUS_SUCCESS != dispatcher_wifi_pos_enable(psoc)) 1191 goto wifi_pos_psoc_enable_fail; 1192 1193 if (QDF_STATUS_SUCCESS != dispatcher_nan_psoc_enable(psoc)) 1194 goto nan_psoc_enable_fail; 1195 1196 if (QDF_STATUS_SUCCESS != dispatcher_dfs_psoc_enable(psoc)) 1197 goto wifi_dfs_psoc_enable_fail; 1198 1199 if (QDF_STATUS_SUCCESS != fd_psoc_enable(psoc)) 1200 goto fd_psoc_enable_fail; 1201 1202 if (QDF_STATUS_SUCCESS != dispatcher_dbr_psoc_enable(psoc)) 1203 goto dbr_psoc_enable_fail; 1204 1205 return QDF_STATUS_SUCCESS; 1206 1207 dbr_psoc_enable_fail: 1208 fd_psoc_disable(psoc); 1209 fd_psoc_enable_fail: 1210 dispatcher_dfs_psoc_disable(psoc); 1211 wifi_dfs_psoc_enable_fail: 1212 dispatcher_nan_psoc_disable(psoc); 1213 nan_psoc_enable_fail: 1214 dispatcher_wifi_pos_disable(psoc); 1215 wifi_pos_psoc_enable_fail: 1216 atf_psoc_disable(psoc); 1217 atf_psoc_enable_fail: 1218 cp_stats_psoc_disable(psoc); 1219 cp_stats_psoc_enable_fail: 1220 sa_api_psoc_disable(psoc); 1221 sa_api_psoc_enable_fail: 1222 dispatcher_policy_mgr_psoc_disable(psoc); 1223 policy_mgr_psoc_enable_fail: 1224 tdls_psoc_disable(psoc); 1225 tdls_psoc_enable_fail: 1226 p2p_psoc_disable(psoc); 1227 p2p_psoc_enable_fail: 1228 ucfg_scan_psoc_disable(psoc); 1229 1230 out: 1231 return QDF_STATUS_E_FAILURE; 1232 } 1233 qdf_export_symbol(dispatcher_psoc_enable); 1234 1235 QDF_STATUS dispatcher_psoc_disable(struct wlan_objmgr_psoc *psoc) 1236 { 1237 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_dbr_psoc_disable(psoc)); 1238 1239 QDF_BUG(QDF_STATUS_SUCCESS == fd_psoc_disable(psoc)); 1240 1241 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_dfs_psoc_disable(psoc)); 1242 1243 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_nan_psoc_disable(psoc)); 1244 1245 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_wifi_pos_disable(psoc)); 1246 1247 QDF_BUG(QDF_STATUS_SUCCESS == atf_psoc_disable(psoc)); 1248 1249 QDF_BUG(QDF_STATUS_SUCCESS == cp_stats_psoc_disable(psoc)); 1250 1251 QDF_BUG(QDF_STATUS_SUCCESS == sa_api_psoc_disable(psoc)); 1252 1253 QDF_BUG(QDF_STATUS_SUCCESS == 1254 dispatcher_policy_mgr_psoc_disable(psoc)); 1255 1256 QDF_BUG(QDF_STATUS_SUCCESS == tdls_psoc_disable(psoc)); 1257 1258 QDF_BUG(QDF_STATUS_SUCCESS == p2p_psoc_disable(psoc)); 1259 1260 QDF_BUG(QDF_STATUS_SUCCESS == ucfg_scan_psoc_disable(psoc)); 1261 1262 return QDF_STATUS_SUCCESS; 1263 } 1264 qdf_export_symbol(dispatcher_psoc_disable); 1265 1266 QDF_STATUS dispatcher_pdev_open(struct wlan_objmgr_pdev *pdev) 1267 { 1268 if (QDF_STATUS_SUCCESS != dispatcher_regulatory_pdev_open(pdev)) 1269 goto out; 1270 1271 if (QDF_STATUS_SUCCESS != dispatcher_spectral_pdev_open(pdev)) 1272 goto spectral_pdev_open_fail; 1273 1274 if (QDF_STATUS_SUCCESS != wlan_mgmt_txrx_pdev_open(pdev)) 1275 goto out; 1276 1277 return QDF_STATUS_SUCCESS; 1278 1279 spectral_pdev_open_fail: 1280 dispatcher_regulatory_pdev_close(pdev); 1281 1282 out: 1283 return QDF_STATUS_E_FAILURE; 1284 } 1285 qdf_export_symbol(dispatcher_pdev_open); 1286 1287 QDF_STATUS dispatcher_pdev_close(struct wlan_objmgr_pdev *pdev) 1288 { 1289 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_regulatory_pdev_close(pdev)); 1290 1291 QDF_BUG(QDF_STATUS_SUCCESS == dispatcher_spectral_pdev_close(pdev)); 1292 1293 QDF_BUG(QDF_STATUS_SUCCESS == wlan_mgmt_txrx_pdev_close(pdev)); 1294 1295 return QDF_STATUS_SUCCESS; 1296 } 1297 qdf_export_symbol(dispatcher_pdev_close); 1298