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