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