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