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