Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / b0f5b85a5b9d69cbfa1dd990d559a4a9c7d8f2a6 / . / mcu / driver / storage / mc / src / msdc.c
blob: 28328cf89c5a18bcb666cc24d5d7ab2982b4e3db [file] [log] [blame]
rjw6c1fd8f2022-11-30 14:33:01 +0800[diff] [blame]1/*****************************************************************************
2* Copyright Statement:
3* --------------------
4* This software is protected by Copyright and the information contained
5* herein is confidential. The software may not be copied and the information
6* contained herein may not be used or disclosed except with the written
7* permission of MediaTek Inc. (C) 2005
8*
9* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
10* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
11* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
12* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
13* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
14* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
15* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
16* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
17* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
18* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
19* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
20* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
21*
22* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
23* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
24* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
25* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
26* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
27*
28* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
29* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
30* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
31* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
32* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
33*
34*****************************************************************************/
35
36/*****************************************************************************
37 *
38 * Filename:
39 * ---------
40 * msdc.c
41 *
42 * Project:
43 * --------
44 * Maui_Software
45 *
46 * Description:
47 * ------------
48 * driver functons for MSDC controller
49 *
50 *
51 * Author:
52 * -------
53 * -------
54 *
55 *============================================================================
56 * HISTORY
57 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
58 *------------------------------------------------------------------------------
59 * removed!
60 * removed!
61 * removed!
62 *
63 * removed!
64 * removed!
65 * removed!
66 *
67 * removed!
68 * removed!
69 * removed!
70 *
71 * removed!
72 * removed!
73 * removed!
74 *
75 * removed!
76 * removed!
77 * removed!
78 *
79 * removed!
80 * removed!
81 * removed!
82 * removed!
83 * removed!
84 *
85 * removed!
86 * removed!
87 * removed!
88 *
89 * removed!
90 * removed!
91 * removed!
92 * removed!
93 * removed!
94 * removed!
95 * removed!
96 *
97 * removed!
98 * removed!
99 * removed!
100 * removed!
101 * removed!
102 * removed!
103 * removed!
104 *
105 * removed!
106 * removed!
107 * removed!
108 *
109 * removed!
110 * removed!
111 * removed!
112 *
113 * removed!
114 * removed!
115 * removed!
116 *
117 * removed!
118 * removed!
119 * removed!
120 * removed!
121 *
122 * removed!
123 * removed!
124 * removed!
125 *
126 * removed!
127 * removed!
128 * removed!
129 * removed!
130 *
131 * removed!
132 * removed!
133 * removed!
134 *
135 * removed!
136 * removed!
137 * removed!
138 *
139 * removed!
140 * removed!
141 * removed!
142 * removed!
143 *
144 * removed!
145 * removed!
146 * removed!
147 *
148 * removed!
149 * removed!
150 * removed!
151 * removed!
152 * removed!
153 * removed!
154 * removed!
155 * removed!
156 * removed!
157 * removed!
158 * removed!
159 * removed!
160 * removed!
161 * removed!
162 * removed!
163 * removed!
164 * removed!
165 * removed!
166 * removed!
167 * removed!
168 * removed!
169 * removed!
170 * removed!
171 * removed!
172 * removed!
173 * removed!
174 * removed!
175 * removed!
176 * removed!
177 * removed!
178 * removed!
179 * removed!
180 * removed!
181 * removed!
182 * removed!
183 * removed!
184 * removed!
185 * removed!
186 * removed!
187 * removed!
188 * removed!
189 * removed!
190 * removed!
191 * removed!
192 * removed!
193 * removed!
194 * removed!
195 * removed!
196 * removed!
197 * removed!
198 *
199 * removed!
200 * removed!
201 * removed!
202 * removed!
203 * removed!
204 * removed!
205 * removed!
206 * removed!
207 * removed!
208 * removed!
209 * removed!
210 * removed!
211 * removed!
212 * removed!
213 * removed!
214 * removed!
215 * removed!
216 * removed!
217 * removed!
218 * removed!
219 * removed!
220 * removed!
221 * removed!
222 *
223 * removed!
224 * removed!
225 * removed!
226 *
227 * removed!
228 * removed!
229 * removed!
230 *
231 * removed!
232 * removed!
233 * removed!
234 *
235 * removed!
236 * removed!
237 * removed!
238 *
239 * removed!
240 * removed!
241 * removed!
242 *
243 * removed!
244 * removed!
245 * removed!
246 *
247 * removed!
248 * removed!
249 * removed!
250 *
251 * removed!
252 * removed!
253 * removed!
254 *
255 * removed!
256 * removed!
257 * removed!
258 *
259 * removed!
260 * removed!
261 * removed!
262 *
263 * removed!
264 * removed!
265 * removed!
266 *
267 * removed!
268 * removed!
269 * removed!
270 *
271 * removed!
272 * removed!
273 * removed!
274 *
275 * removed!
276 * removed!
277 * removed!
278 *
279 * removed!
280 * removed!
281 * removed!
282 *
283 * removed!
284 * removed!
285 * removed!
286 *
287 * removed!
288 * removed!
289 * removed!
290 *
291 * removed!
292 * removed!
293 * removed!
294 *
295 * removed!
296 * removed!
297 * removed!
298 *
299 * removed!
300 * removed!
301 * removed!
302 *
303 * removed!
304 * removed!
305 * removed!
306 *
307 * removed!
308 * removed!
309 * removed!
310 *
311 * removed!
312 * removed!
313 * removed!
314 *
315 * removed!
316 * removed!
317 * removed!
318 *
319 * removed!
320 * removed!
321 * removed!
322 *
323 * removed!
324 * removed!
325 * removed!
326 *
327 * removed!
328 * removed!
329 * removed!
330 *
331 * removed!
332 * removed!
333 * removed!
334 *
335 * removed!
336 * removed!
337 * removed!
338 *
339 * removed!
340 * removed!
341 * removed!
342 *
343 * removed!
344 * removed!
345 * removed!
346 *
347 * removed!
348 * removed!
349 * removed!
350 *
351 * removed!
352 * removed!
353 * removed!
354 *
355 * removed!
356 * removed!
357 * removed!
358 *
359 * removed!
360 * removed!
361 * removed!
362 *
363 * removed!
364 * removed!
365 * removed!
366 *
367 * removed!
368 * removed!
369 * removed!
370 *
371 * removed!
372 * removed!
373 * removed!
374 *
375 * removed!
376 * removed!
377 * removed!
378 *
379 * removed!
380 * removed!
381 * removed!
382 *
383 * removed!
384 * removed!
385 * removed!
386 *
387 * removed!
388 * removed!
389 * removed!
390 *
391 * removed!
392 * removed!
393 * removed!
394 *
395 * removed!
396 * removed!
397 * removed!
398 *
399 * removed!
400 * removed!
401 * removed!
402 *
403 * removed!
404 * removed!
405 * removed!
406 *
407 * removed!
408 * removed!
409 * removed!
410 *
411 * removed!
412 * removed!
413 * removed!
414 *
415 * removed!
416 * removed!
417 * removed!
418 *
419 * removed!
420 * removed!
421 * removed!
422 *
423 * removed!
424 * removed!
425 * removed!
426 *
427 * removed!
428 * removed!
429 * removed!
430 *
431 * removed!
432 * removed!
433 * removed!
434 *
435 * removed!
436 * removed!
437 * removed!
438 *
439 * removed!
440 * removed!
441 * removed!
442 *
443 * removed!
444 * removed!
445 * removed!
446 *
447 * removed!
448 * removed!
449 * removed!
450 *
451 * removed!
452 * removed!
453 * removed!
454 *
455 * removed!
456 * removed!
457 * removed!
458 *
459 * removed!
460 * removed!
461 * removed!
462 *
463 * removed!
464 * removed!
465 * removed!
466 *
467 * removed!
468 * removed!
469 * removed!
470 *
471 * removed!
472 * removed!
473 * removed!
474 *
475 * removed!
476 * removed!
477 * removed!
478 *
479 * removed!
480 * removed!
481 * removed!
482 *
483 * removed!
484 * removed!
485 * removed!
486 *
487 * removed!
488 * removed!
489 * removed!
490 *
491 * removed!
492 * removed!
493 * removed!
494 *
495 * removed!
496 * removed!
497 * removed!
498 *
499 * removed!
500 * removed!
501 * removed!
502 *
503 * removed!
504 * removed!
505 * removed!
506 *
507 * removed!
508 * removed!
509 * removed!
510 *
511 * removed!
512 * removed!
513 * removed!
514 *
515 * removed!
516 * removed!
517 * removed!
518 *
519 * removed!
520 * removed!
521 * removed!
522 *
523 * removed!
524 * removed!
525 * removed!
526 *
527 * removed!
528 * removed!
529 * removed!
530 *
531 * removed!
532 * removed!
533 * removed!
534 *
535 * removed!
536 * removed!
537 * removed!
538 *
539 * removed!
540 * removed!
541 * removed!
542 *
543 * removed!
544 * removed!
545 * removed!
546 *
547 * removed!
548 * removed!
549 *
550 *
551 * removed!
552 * removed!
553 *
554 *
555 * removed!
556 * removed!
557 *
558 *
559 * removed!
560 * removed!
561 *
562 *
563 * removed!
564 * removed!
565 * removed!
566 *
567 * removed!
568 * removed!
569 *
570 *
571 * removed!
572 * removed!
573 *
574 *
575 * removed!
576 * removed!
577 *
578 *
579 * removed!
580 * removed!
581 *
582 *
583 * removed!
584 * removed!
585 *
586 *
587 * removed!
588 * removed!
589 *
590 *
591 * removed!
592 * removed!
593 *
594 *
595 * removed!
596 * removed!
597 *
598 *
599 * removed!
600 * removed!
601 *
602 *
603 * removed!
604 * removed!
605 *
606 *
607 * removed!
608 * removed!
609 *
610 *
611 * removed!
612 * removed!
613 *
614 *
615 * removed!
616 * removed!
617 *
618 *
619 * removed!
620 * removed!
621 *
622 *
623 * removed!
624 * removed!
625 *
626 *
627 * removed!
628 * removed!
629 *
630 *
631 * removed!
632 * removed!
633 *
634 *
635 * removed!
636 * removed!
637 *
638 *
639 * removed!
640 * removed!
641 *
642 *
643 * removed!
644 * removed!
645 *
646 *
647 * removed!
648 * removed!
649 *
650 *
651 * removed!
652 * removed!
653 *
654 *
655 * removed!
656 * removed!
657 *
658 *
659 * removed!
660 * removed!
661 *
662 *
663 * removed!
664 * removed!
665 *
666 *
667 * removed!
668 * removed!
669 *
670 *
671 * removed!
672 * removed!
673 *
674 *
675 * removed!
676 * removed!
677 *
678 *
679 * removed!
680 * removed!
681 *
682 *
683 * removed!
684 * removed!
685 *
686 *
687 * removed!
688 * removed!
689 *
690 *
691 * removed!
692 * removed!
693 *
694 *
695 * removed!
696 * removed!
697 *
698 *
699 * removed!
700 * removed!
701 *
702 *
703 * removed!
704 * removed!
705 *
706 *
707 * removed!
708 * removed!
709 *
710 *
711 * removed!
712 * removed!
713 *
714 *
715 * removed!
716 * removed!
717 *
718 *
719 * removed!
720 * removed!
721 *
722 *
723 * removed!
724 * removed!
725 *
726 *
727 * removed!
728 * removed!
729 *
730 *
731 * removed!
732 * removed!
733 *
734 *
735 * removed!
736 * removed!
737 *
738 *
739 * removed!
740 * removed!
741 *
742 *
743 * removed!
744 * removed!
745 *
746 *
747 * removed!
748 * removed!
749 *
750 *
751 * removed!
752 * removed!
753 *
754 *
755 * removed!
756 * removed!
757 *
758 *
759 * removed!
760 * removed!
761 *
762 *
763 * removed!
764 * removed!
765 *
766 *
767 * removed!
768 * removed!
769 *
770 *
771 * removed!
772 * removed!
773 *
774 *
775 * removed!
776 * removed!
777 *
778 *
779 * removed!
780 * removed!
781 *
782 *
783 * removed!
784 * removed!
785 *
786 *
787 * removed!
788 * removed!
789 *
790 *
791 * removed!
792 * removed!
793 *
794 *
795 * removed!
796 * removed!
797 *
798 *
799 * removed!
800 * removed!
801 *
802 *
803 * removed!
804 * removed!
805 *
806 *
807 * removed!
808 * removed!
809 *
810 *
811 * removed!
812 * removed!
813 *
814 *
815 * removed!
816 * removed!
817 *
818 *
819 * removed!
820 * removed!
821 *
822 *
823 * removed!
824 * removed!
825 *
826 *
827 * removed!
828 * removed!
829 *
830 *
831 * removed!
832 * removed!
833 *
834 *
835 * removed!
836 * removed!
837 *
838 *
839 * removed!
840 * removed!
841 *
842 *
843 * removed!
844 * removed!
845 *
846 *
847 * removed!
848 * removed!
849 *
850 *
851 * removed!
852 * removed!
853 *
854 *
855 * removed!
856 * removed!
857 *
858 *
859 * removed!
860 * removed!
861 *
862 *
863 * removed!
864 * removed!
865 *
866 *
867 * removed!
868 * removed!
869 *
870 *
871 * removed!
872 * removed!
873 *
874 *
875 * removed!
876 * removed!
877 *
878 *
879 * removed!
880 * removed!
881 *
882 *
883 * removed!
884 * removed!
885 *
886 *
887 * removed!
888 * removed!
889 *
890 *
891 * removed!
892 * removed!
893 *
894 *
895 * removed!
896 * removed!
897 *
898 *
899 * removed!
900 * removed!
901 *
902 *
903 * removed!
904 * removed!
905 *
906 *
907 * removed!
908 * removed!
909 *
910 *
911 * removed!
912 * removed!
913 *
914 *
915 * removed!
916 * removed!
917 *
918 *
919 * removed!
920 * removed!
921 *
922 *
923 * removed!
924 * removed!
925 *
926 *
927 * removed!
928 * removed!
929 *
930 *
931 * removed!
932 * removed!
933 *
934 *
935 * removed!
936 * removed!
937 *
938 *
939 * removed!
940 * removed!
941 *
942 *
943 * removed!
944 * removed!
945 *
946 *
947 * removed!
948 * removed!
949 *
950 *
951 * removed!
952 * removed!
953 *
954 *
955 * removed!
956 * removed!
957 *
958 *
959 * removed!
960 * removed!
961 *
962 *
963 * removed!
964 * removed!
965 *
966 *
967 * removed!
968 * removed!
969 *
970 *
971 * removed!
972 * removed!
973 *
974 *
975 * removed!
976 * removed!
977 *
978 *
979 * removed!
980 * removed!
981 *
982 *
983 * removed!
984 * removed!
985 *
986 *
987 * removed!
988 * removed!
989 *
990 *
991 * removed!
992 * removed!
993 *
994 *
995 * removed!
996 * removed!
997 *
998 *
999 * removed!
1000 * removed!
1001 *
1002 *
1003 * removed!
1004 * removed!
1005 *
1006 *
1007 * removed!
1008 * removed!
1009 *
1010 *
1011 * removed!
1012 * removed!
1013 *
1014 *
1015 * removed!
1016 * removed!
1017 * removed!
1018 *
1019 * removed!
1020 * removed!
1021 * removed!
1022 *
1023 * removed!
1024 * removed!
1025 * removed!
1026 *
1027 * removed!
1028 * removed!
1029 * removed!
1030 *
1031 * removed!
1032 * removed!
1033 * removed!
1034 *
1035 * removed!
1036 * removed!
1037 * removed!
1038 *
1039 * removed!
1040 * removed!
1041 * removed!
1042 *
1043 * removed!
1044 * removed!
1045 * removed!
1046 *
1047 * removed!
1048 * removed!
1049 * removed!
1050 * removed!
1051 *
1052 * removed!
1053 * removed!
1054 *
1055 * removed!
1056 * removed!
1057 * removed!
1058 *
1059 * removed!
1060 * removed!
1061 * removed!
1062 * removed!
1063 *
1064 * removed!
1065 * removed!
1066 * removed!
1067 *
1068 * removed!
1069 * removed!
1070 * removed!
1071 *
1072 * removed!
1073 * removed!
1074 * removed!
1075 *
1076 * removed!
1077 * removed!
1078 * removed!
1079 *
1080 * removed!
1081 * removed!
1082 * removed!
1083 *
1084 * removed!
1085 * removed!
1086 * removed!
1087 *
1088 * removed!
1089 * removed!
1090 * removed!
1091 *
1092 * removed!
1093 * removed!
1094 * removed!
1095 * removed!
1096 *
1097 * removed!
1098 * removed!
1099 *
1100 * removed!
1101 * removed!
1102 * removed!
1103 *
1104 * removed!
1105 * removed!
1106 * removed!
1107 *
1108 * removed!
1109 * removed!
1110 * removed!
1111 * removed!
1112 *
1113 * removed!
1114 * removed!
1115 * removed!
1116 *
1117 * removed!
1118 * removed!
1119 *
1120 * removed!
1121 * removed!
1122 * removed!
1123 *
1124 * removed!
1125 * removed!
1126 * removed!
1127 *
1128 * removed!
1129 * removed!
1130 * removed!
1131 *
1132 * removed!
1133 * removed!
1134 * removed!
1135 *
1136 * removed!
1137 * removed!
1138 * removed!
1139 *
1140 * removed!
1141 * removed!
1142 *
1143 * removed!
1144 * removed!
1145 * removed!
1146 *
1147 * removed!
1148 * removed!
1149 * removed!
1150 *
1151 *------------------------------------------------------------------------------
1152 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
1153 *============================================================================
1154 ****************************************************************************/
1155#include "drv_features.h"
1156#ifndef DRV_MSDC_OFF
1157#include "kal_public_api.h" //MSBB change #include "kal_release.h"
1158#include "md_drv_sap.h"
1159#include "drv_msgid.h"
1160#include "kal_general_types.h"
1161#include "kal_public_defs.h"
1162#include "kal_public_api.h"
1163#include "kal_debug.h"
1164#include "hisr_config.h"
1165#include "config_hw.h"
1166#include "init.h"
1167
1168#include "kal_trace.h"
1169#include "dcl.h"
1170#include "kal_public_defs.h" //MSBB change #include "stack_common.h"
1171#include "kal_public_defs.h" //MSBB change #include "stack_msgs.h"
1172#include "kal_public_defs.h" //MSBB change #include "stack_config.h"
1173#include "kal_public_api.h"
1174#include "kal_public_api.h" //MSBB change #include "app_ltlcom.h" /* Task message communiction */
1175#include "intrCtrl.h"
1176#include "reg_base.h"
1177#include "drvpdn.h"
1178#include "drv_features.h"
1179#include "drv_comm.h"
1180#include "msdc_reg_adap.h"
1181#include "drv_hisr.h"
1182#include "sleepdrv_interface.h"
1183#include "eint.h"
1184
1185#if !defined(__UBL__) || defined(__CARD_DOWNLOAD__) || defined(__EMMC_BOOTING__)
1186#include "msdc_api.h"
1187#include "msdc_def.h"
1188#include "sd_def.h"
1189#include "../../../devdrv/iomux/inc/drv_iomux.h"
1190
1191//! EMB
1192#include "FTL.h"
1193
1194#if defined(__MSDC_SD_MMC__)&&defined(__MSDC_SD_SDIO__)
1195#include "sdio_sw.h"
1196#endif
1197#if defined(__MSDC_MS__)
1198#include "ms_def.h"
1199#elif defined(__MSDC_MSPRO__)
1200#include "mspro_def.h"
1201#endif
1202#include "upll_ctrl.h"
1203//#include "gpio_sw.h"
1204#include "drv_trc.h"
1205#if defined(__AUDIO_DSP_LOWPOWER__)
1206#include "audlp_exp.h"
1207#endif
1208
1209#ifdef DRV_LSD
1210#include "msdc_lsd.h"
1211#endif
1212
1213#ifdef __CLKG_DEFINE__
1214#ifdef DRVPDN_CON1
1215#error "__CLKG_DEFINE__ & DRVPDN_CON1 are all defined"
1216#else
1217#define DRVPDN_CON1 CG_CON1
1218#endif
1219
1220#ifdef DRVPDN_CON1_SIM
1221#error "__CLKG_DEFINE__ & DRVPDN_CON1_SIM are all defined"
1222#else
1223#define DRVPDN_CON1_SIM CG_CON1_SIM
1224#endif
1225
1226#ifndef MSDC_TEST_MSDC2_FROM_MSDC1_CODE
1227
1228#ifdef DRVPDN_CON1_MSDC
1229#error "__CLKG_DEFINE__ & DRVPDN_CON1_MSDC are all defined"
1230#else
1231#define DRVPDN_CON1_MSDC CG_CON1_MSDC
1232#endif
1233
1234#ifdef DRVPDN_CON1_CLR
1235#error "__CLKG_DEFINE__ & DRVPDN_CON1_CLR are all defined"
1236#else
1237#define DRVPDN_CON1_CLR CG_CLR1
1238#endif
1239
1240#ifdef DRVPDN_CON1_SET
1241#error "__CLKG_DEFINE__ & DRVPDN_CON1_SET are all defined"
1242#else
1243#define DRVPDN_CON1_SET CG_SET1
1244#endif
1245
1246#else /*when MSDC_TEST_MSDC2_FROM_MSDC1_CODE is defined, we direct CON1 related macro to CON0 related*/
1247
1248#ifdef DRVPDN_CON1_MSDC
1249#error "__CLKG_DEFINE__ & DRVPDN_CON1_MSDC are all defined"
1250#else
1251#define DRVPDN_CON1_MSDC CG_CON0_MSDC2
1252#endif
1253
1254#ifdef DRVPDN_CON1_CLR
1255#error "__CLKG_DEFINE__ & DRVPDN_CON1_CLR are all defined"
1256#else
1257#define DRVPDN_CON1_CLR CG_CLR0
1258#endif
1259
1260#ifdef DRVPDN_CON1_SET
1261#error "__CLKG_DEFINE__ & DRVPDN_CON1_SET are all defined"
1262#else
1263#define DRVPDN_CON1_SET CG_SET0
1264#endif
1265#endif//MSDC_TEST_MSDC2_FROM_MSDC1_CODE
1266
1267#endif
1268
1269
1270
1271
1272/*
1273#if !(defined __MSDC_NOT_SUPPORT_HOT_PLUG__)
1274#if defined(MT6218B_FN) || defined(MT6219_EV) ||defined(MT6217)||defined(MT6227)||defined(MT6226)||defined(MT6226M)\
1275 || defined(MT6225)
1276#define USE_INT26_CARD_DETECTION
1277#endif
1278#endif
1279*/
1280
1281
1282#if defined (WISDOM35B_DEMO_BB)
1283extern const char gpio_SD_det_pin;
1284#endif
1285
1286// global variable
1287MSDC_HANDLE MSDC_Blk[SD_NUM];
1288
1289#if (defined(__MSDC_MS__) || defined(__MSDC_SD_MMC__)|| defined(__MSDC_MSPRO__)) || defined(__MSDC_SD_SDIO__)
1290MSDC_HANDLE *gMSDC_Handle = &(MSDC_Blk[0]);
1291
1292#if defined(__UBL__) && defined(__EMMC_BOOTING__)
1293__attribute__ ((zero_init, section ("EXT_UN_INIT_ZI")))kal_uint32 MSDC_Sector[128];
1294__attribute__ ((zero_init, section ("EXT_UN_INIT_ZI")))kal_uint32 MSDC_eCSD[128];
1295#ifdef MSDC_CACHED_SUPPORT
1296__attribute__ ((zero_init, section ("EXT_UN_INIT_ZI")))kal_uint32 msdc_uncachedBuf[MSDC_UNCACHED_BUF_SIZE / 4];
1297#endif
1298#else
1299__attribute__ ((zero_init, section ("NONCACHEDZI")))kal_uint32 MSDC_Sector[128];
1300__attribute__ ((zero_init, section ("NONCACHEDZI")))kal_uint32 MSDC_eCSD[128];
1301#ifdef MSDC_CACHED_SUPPORT
1302__attribute__ ((zero_init, section ("NONCACHEDZI")))kal_uint32 msdc_uncachedBuf[MSDC_UNCACHED_BUF_SIZE / 4];
1303#endif
1304#endif
1305//Light 120907
1306#define MSDC_DMA_BURSTLEN_LIMIT 0xFFFFFFFF//4294966784 //32bit
1307//#define MSDC_DMA_BURSTLEN_LIMIT 65024
1308kal_bool MSDC_useDMA4ByteBurst = KAL_FALSE;
1309
1310/* Debug log */
1311kal_uint32 MSDC_DebugLevel;
1312
1313/* IO configurations */
1314static struct msdc_cust msdc_cap = {
1315 0, /* host clock source */
1316 1, /* command latch edge */
1317 1, /* read data latch edge */
1318 1, /* write data latch edge */
1319
1320 {6, 6, 0, 0, 1, 0, 1},
1321 {4, 4, 0, 0, 1, 0, 1},
1322 {4, 4, 0, 0, 1, 0, 1},
1323
1324 8, /* data pins */
1325 0, /* data address offset */
1326
1327 /* hardware capability flags */
1328 0,
1329};
1330
1331#ifdef __TST_WRITE_TO_FILE__
1332/*error recording: add this additional global variable to use when in error recording*/
1333MSDC_HANDLE MSDC_ErrorRecordingBlk;
1334#endif
1335
1336#if defined(DRV_MSDC_SHARE_BY_SWITCH)
1337sd_select_enum current_card; // active card
1338#if !defined(__CUST_NEW__)
1339extern kal_char MSDC_GetLDO_GPIO(void);
1340extern kal_char MSDC_GetSwitch_GPIO(void);
1341extern kal_char MSDC_GetEXTLDO_GPIO(void);
1342extern kal_char MSDC_GetSwitchDirection(void);
1343kal_char gpio_simplug_ldo_switch;
1344kal_char gpio_ext_sd_ldo_switch;
1345kal_char gpio_sim_msdc_switch;
1346#endif
1347#endif
1348
1349#if !defined(DRV_LSD) && defined(__DRV_DBG_MEMORY_TRACE_SUPPORT__) && !defined(__UBL__)
1350msdc_debugMessage msdc_msgArray[MSDC_DBG_ARRAY_SIZE];
1351kal_uint32 msdc_msdIndex;
1352#endif
1353
1354#define MSDC_EINT_NUM MSDC_EINT_NO
1355
1356
1357// system control blocks
1358
1359// function predeclaration
1360void MSDC_DMAInit(void);
1361void MSDC_INT_Init(void);
1362void MSDC_DMA_Callback(void);
1363void MSDC_EINT_Handler(void);
1364void MSDC_turnOnVMC(kal_bool turnOnLdo);
1365#ifdef R1B_INTERRUPT_MODE
1366static void MSDC_R1B_Init();
1367#endif
1368
1369
1370extern void GPIO_ModeSetup(kal_uint16 pin, kal_uint16 conf_dada);
1371extern kal_bool INT_USBBoot(void);
1372extern kal_int8 MSDC_GetDLTFromOPCLK(kal_uint32 opClk, kal_uint8 *setRED);
1373extern void SD_Sleep4Wait(kal_int32 sleep_tick);
1374extern void msdc_tune_init(void);
1375
1376#ifdef __CARD_DOWNLOAD__
1377extern kal_bool MSDC_QueryIsPowerControllable(void);
1378extern void MSDC_SetPower(kal_bool enable);
1379#endif
1380
1381#if !defined(_MSDC_INTERNAL_CD_INT_PIN_)
1382
1383#if defined(__MSDC_NOT_SUPPORT_HOT_PLUG__)
1384#error "__MSDC_NOT_SUPPORT_HOT_PLUG__ shouldn't be defined."
1385#endif
1386extern const unsigned char MSDC_EINT_NO;
1387static kal_uint32 MSDC_debounceTime;
1388static kal_bool cardDetectionEINTPolarity;
1389#endif
1390
1391#if defined(__UBL__) || defined(__FUE__)
1392kal_bool MSDC_START_TIMER(kal_uint16 x)
1393{
1394 gMSDC_Handle->is_timeout = KAL_FALSE;
1395}
1396#else// defined(__UBL__) || defined(__FUE__)
1397
1398kal_bool MSDC_START_TIMER(kal_uint16 x)
1399{
1400 //DCL_HANDLE gpt_handle;
1401 DCL_STATUS status;
1402 SGPT_CTRL_START_T start;
1403
1404#if defined(MSDC_DEBUG_INFO)
1405 strcpy(gMSDC_Handle->msdc_fname, __FILE__);
1406 gMSDC_Handle->msdc_lines = __LINE__;
1407#endif
1408
1409 gMSDC_Handle->is_timeout = KAL_FALSE;
1410 start.u2Tick = x;
1411 start.pfCallback = MSDC_TimeOutHandler;
1412 start.vPara = NULL;
1413 //gpt_handle= module |MSDC_GPT_CB_MAGIC_NUM;
1414 status = DclSGPT_Control(MSDC_Blk[0].gpt_handle, SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start);
1415 //dbg_print("start timer++++++++%d+++++\r\n",drv_get_current_time());
1416 if (STATUS_OK == status)
1417 return KAL_TRUE;
1418 else
1419 return KAL_FALSE;
1420}
1421#endif// defined(__UBL__) || defined(__FUE__)
1422
1423#if defined(__UBL__) || defined(__FUE__)
1424kal_bool MSDC_STOP_TIMER()
1425{
1426 return KAL_TRUE;
1427}
1428#else// defined(__UBL__) || defined(__FUE__)
1429kal_bool MSDC_STOP_TIMER()
1430{
1431
1432
1433 //MSDC_GPTI_StopItem(gMSDC_Handle->gpt_handle);
1434 DclSGPT_Control(MSDC_Blk[0].gpt_handle, SGPT_CMD_STOP, 0);
1435 if (gMSDC_Handle->is_timeout ||!gMSDC_Handle->mIsPresent)
1436 {
1437 kal_set_eg_events(gMSDC_Handle->MSDC_Events, 0, KAL_AND);
1438 }
1439 //dbg_print("stop timer +++++++%d++++++++\r\n",drv_get_current_time());
1440 return KAL_TRUE;
1441}
1442#endif// defined(__UBL__) || defined(__FUE__)
1443
1444#if !defined(__FUE__) && !defined(__UBL__)
1445void MSDC_GPTI_BusyWait(kal_uint16 len)
1446{
1447#if 0
1448/* under construction !*/
1449/* under construction !*/
1450/* under construction !*/
1451/* under construction !*/
1452/* under construction !*/
1453/* under construction !*/
1454#endif
1455}
1456
1457kal_uint8 MSDC_GPTI_GetHandle(DCL_HANDLE *handle)
1458{
1459 //DCL_HANDLE gpt_handle;
1460 *handle = DclSGPT_Open(DCL_GPT_CB, 0);
1461
1462 //*handle = 0xFF & gpt_handle;
1463
1464 return KAL_TRUE;
1465}
1466
1467#endif//!defined(__FUE__) && !defined(__UBL__)
1468
1469/*************************************************************************
1470* FUNCTION
1471* MSDC_SetClock
1472*
1473* DESCRIPTION
1474*
1475* PARAMETERS
1476* clock: the desired operating clock rate in the unit of kHz
1477*
1478* RETURNS
1479*
1480* GLOBALS AFFECTED
1481*
1482*************************************************************************/
1483kal_uint32 MSDC_SetClock(kal_uint32 bus_clock,kal_bool ddr_mode)
1484{
1485 kal_uint32 msdc_clock,op_clock=0;
1486 kal_uint32 div,mode;
1487 if (!gMSDC_Handle->msdc_clock)
1488 {
1489 /*didn't set source clock*/
1490 MSDC_ERR("[MSDC][%s %d]set clock before set source clock\r\n",__FUNCTION__,__LINE__);
1491 return MSDC_ERROR;
1492 }
1493
1494 msdc_clock=gMSDC_Handle->msdc_clock;
1495
1496 if (!(bus_clock))
1497 {
1498 MSDC_RESET();
1499 MSDC_ENABLE_CARD_CLOCK(KAL_TRUE);
1500 MSDC_ERR("[MSDC][%s %d]can't set bus clock to %d\r\n",__FUNCTION__,__LINE__,bus_clock);
1501 return MSDC_ERROR;
1502 }
1503
1504 /* Check the MAX bus clock which could be supportted by driver */
1505 if (bus_clock > gMSDC_Handle->op_clock_max)
1506 bus_clock = gMSDC_Handle->op_clock_max;
1507
1508 /*need disable irq*/
1509
1510 MSDC_ENABLE_CARD_CLOCK(KAL_FALSE);
1511
1512 if (ddr_mode){
1513 mode=USE_DDR_MODE;
1514 if (bus_clock>=(msdc_clock >> 2)){
1515 div=0;
1516 op_clock=msdc_clock >> 2;
1517 }
1518 else
1519 {
1520 bus_clock=bus_clock << 1;
1521 div=(msdc_clock+((bus_clock << 2)-1))/(bus_clock << 2);
1522 op_clock=(msdc_clock>>2)/div;
1523 op_clock=op_clock>>1;
1524 }
1525 }
1526 else
1527 {
1528 if (bus_clock >=msdc_clock)
1529 {
1530 //dbg_print("entry bus_clock==msdc_clock\r\n");
1531 mode =USE_MSDC_SRC_CK;
1532 div=0;
1533 op_clock=msdc_clock;
1534 }
1535 else
1536 {
1537 mode =USE_CLOCK_DIV;
1538 if (bus_clock >= (msdc_clock >> 1))
1539 {
1540
1541 div=0;
1542 op_clock=msdc_clock>>1;
1543 //dbg_print("entry bus_clock >= (msdc_clock>>1),op_clock=%d\r\n",op_clock);
1544 } else {
1545
1546 div=(msdc_clock+((bus_clock << 2)-1))/(bus_clock << 2);
1547 op_clock=(msdc_clock >> 2)/div;
1548 //dbg_print("entry bus_clock <(msdc_clock>>1),bus_clock=%d ,op_clock=%d,msdc_clock=%d\r\n",bus_clock,op_clock,msdc_clock);
1549 }
1550 }
1551 }
1552
1553 gMSDC_Handle->op_clock=op_clock;
1554 gMSDC_Handle->msdc_clock=msdc_clock;
1555 //dbg_print("op_clock=%d ,msdc_clock=%d,div=%x\r\n",op_clock,msdc_clock,div);
1556 BitFieldWrite32((kal_uint32 *)MSDC_CFG, mode, MSDC_CFG_CKMOD);
1557 BitFieldWrite32((kal_uint32 *)MSDC_CFG,div,MSDC_CFG_CKDIV);
1558 if (MSDC_TIMEOUT_WAIT((MSDC_Reg32(MSDC_CFG)&MSDC_CFG_CKSTB),500))
1559 {
1560 MSDC_ERR("[MSDC][%s %d]wait clock stable 500ms,then timeout \r\n",__FUNCTION__,__LINE__);
1561 return MSDC_ERROR;
1562 }
1563 //dbg_print("MSDC_CFG=%x\r\n",MSDC_Reg32(MSDC_CFG));
1564
1565 /*open irq*/
1566 MSDC_CRIT("[MSDC][%s %d] SET_CLK(%dkHz): SCLK(%dkHz) MODE(%d) DDR(%d) DIV(%d)\r\n",
1567 __FUNCTION__,__LINE__, bus_clock / 1000, op_clock / 1000, mode, ddr_mode, div);
1568
1569 MSDC_ENABLE_CARD_CLOCK(KAL_TRUE);
1570 return MSDC_OK;
1571
1572}
1573
1574kal_uint32 uffs(kal_uint32 x)
1575{
1576 kal_uint32 r=1;
1577 if (!x)
1578 {
1579 return 0 ;
1580 }
1581 if (!(x&0xffff))
1582 {
1583 x>>=16;
1584 r+=16;
1585 }
1586 if (!(x&0xff))
1587 {
1588 x>>=8;
1589 r+=8;
1590 }
1591 if (!(x&0xf))
1592 {
1593 x>>=4;
1594 r+=4;
1595 }
1596 if (!(x&0x3))
1597 {
1598 x>>=2;
1599 r+=2;
1600 }
1601 if (!(x&0x1))
1602 {
1603 x>>=1;
1604 r+=1;
1605 }
1606 return r;
1607}
1608
1609
1610void msdc_sleep(kal_uint32 ticks)
1611{
1612 if ((kal_query_systemInit() == KAL_TRUE)
1613 #ifdef __TST_WRITE_TO_FILE__ /*error recording: considering error recording additionally*/
1614 || (KAL_TRUE == INT_QueryExceptionStatus())
1615 #endif
1616 #ifndef __MTK_TARGET__
1617 || KAL_TRUE == FTL_isPollingMode()
1618 #endif
1619 )
1620 {
1621 MSDC_GPTI_BusyWait(ticks*5);
1622 }
1623 else
1624 {
1625 kal_sleep_task(ticks);
1626 }
1627}
1628/*************************************************************************
1629* FUNCTION
1630* MSDC_SetClockSource
1631*
1632* DESCRIPTION
1633*
1634* PARAMETERS
1635* type: the desired operating clock source
1636*
1637* RETURNS
1638*
1639* GLOBALS AFFECTED
1640*
1641*************************************************************************/
1642#if (CHIP_VER == 0)
1643void MSDC_SetClockSource(T_MSDC_CLK_TYPE type)
1644{
1645 kal_uint32 orig_val;
1646 // 3'b000: 26MHz
1647 // 3'b001: 40MHz
1648 // 3'b010: 50MHz
1649 // 3'b011: 60MHz
1650 // 3'b100: 69MHz
1651 // 3'b101: 80MHz
1652 // 3'b110: 96MHz
1653 // 3'b111: 100MHz
1654 #define MSDC_SOURCE_SEL_ADDR (0xBF814004)
1655 orig_val=MSDC_Reg32(MSDC_SOURCE_SEL_ADDR);
1656 orig_val=orig_val&(~0x7);
1657 switch (type)
1658 {
1659 case SRC_26M:
1660 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_26M);
1661 gMSDC_Handle->msdc_clock=26000000;
1662 gMSDC_Handle->op_clock_max = 13000000;
1663 break;
1664
1665 case SRC_40M:
1666 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_40M);
1667 gMSDC_Handle->msdc_clock=40000000;
1668 gMSDC_Handle->op_clock_max = 20000000;
1669 break;
1670 case SRC_50M:
1671 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_50M);
1672 gMSDC_Handle->msdc_clock=50000000;
1673 gMSDC_Handle->msdc_clock=35000000;
1674 gMSDC_Handle->op_clock_max = 17000000;
1675 break;
1676 case SRC_60M:
1677 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_60M);
1678 gMSDC_Handle->msdc_clock=60000000;
1679 gMSDC_Handle->op_clock_max = 30000000;
1680 break;
1681 case SRC_69M:
1682 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_69M);
1683 gMSDC_Handle->msdc_clock=69000000;
1684 gMSDC_Handle->op_clock_max = 35000000;
1685 break;
1686 case SRC_80M:
1687 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_80M);
1688 gMSDC_Handle->msdc_clock=80000000;
1689 gMSDC_Handle->op_clock_max = 40000000;
1690 break;
1691 case SRC_96M:
1692 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_96M);
1693 gMSDC_Handle->msdc_clock=96000000;
1694 gMSDC_Handle->op_clock_max = 48000000;
1695 break;
1696 case SRC_100M:
1697 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_100M);
1698 gMSDC_Handle->msdc_clock=100000000;
1699 gMSDC_Handle->op_clock_max = 50000000;
1700 break;
1701 default:
1702 MSDC_WriteReg32(MSDC_SOURCE_SEL_ADDR,orig_val|SRC_26M);
1703 gMSDC_Handle->msdc_clock=26000000;
1704 MSDC_ERR("[MSDC][%s %d]unknow source CLK %d\r\n",__FUNCTION__,__LINE__,type);
1705 break;
1706 }
1707}
1708#elif (CHIP_VER == 1)
1709
1710#define MSDC_OP_SCLK (200000000)
1711#define MSDC_MAX_SCLK (200000000)
1712void MSDC_SetClockSource(T_MSDC_CLK_TYPE type)
1713{
1714 gMSDC_Handle->msdc_clock = MSDC_OP_SCLK;
1715 gMSDC_Handle->op_clock_max = MSDC_MAX_SCLK;
1716}
1717
1718#endif
1719/*************************************************************************
1720* FUNCTION
1721* MSDC_Check_Card_Present
1722*
1723* DESCRIPTION
1724* c
1725*
1726* PARAMETERS
1727* ON: turn on power saving or not
1728*
1729* RETURNS
1730*
1731* GLOBALS AFFECTED
1732*
1733*
1734*************************************************************************/
1735kal_bool MSDC_Check_Card_Present(void)
1736{
1737#if !defined(__MSDC_NOT_SUPPORT_HOT_PLUG__)
1738 return gMSDC_Handle->mIsPresent;
1739#else
1740 return KAL_TRUE;
1741#endif
1742}
1743/*************************************************************************
1744* FUNCTION
1745* MSDC_PDNControl
1746*
1747* DESCRIPTION
1748* Enable power saving or not.
1749*
1750* PARAMETERS
1751* ON: turn on power saving or not
1752*
1753* RETURNS
1754*
1755* GLOBALS AFFECTED
1756*
1757*
1758*************************************************************************/
1759#define MSDC_PDN_EN
1760void MSDC_PDNControl(kal_bool ON)
1761{
1762 if (ON) {
1763 #if !defined(ATEST_DRV_ENABLE)
1764
1765 #if defined(MSDC_PDN_EN)
1766 PDN_SET(PDN_MSDC0);
1767 #endif
1768
1769 SleepDrv_SleepEnable(gMSDC_Handle->msdc_sm_hdl);
1770 #endif
1771 }
1772 else {
1773 #if !defined(ATEST_DRV_ENABLE)
1774
1775 #if defined(MSDC_PDN_EN)
1776 PDN_CLR(PDN_MSDC0);
1777 #endif
1778
1779 SleepDrv_SleepDisable(gMSDC_Handle->msdc_sm_hdl);
1780 #endif
1781 }
1782}
1783/*************************************************************************
1784* FUNCTION
1785* MSDC_TimeOutHandler
1786*
1787* DESCRIPTION
1788* Callback function of gpt timer, and launched while MSDC busy for a while
1789
1790*
1791* PARAMETERS
1792*
1793*
1794* RETURNS
1795*
1796* GLOBALS AFFECTED
1797*
1798*
1799*************************************************************************/
1800void MSDC_TimeOutHandler(void *parameter)
1801{
1802 gMSDC_Handle->is_timeout=KAL_TRUE;
1803 kal_set_eg_events(gMSDC_Handle->MSDC_Events,
1804 EVENT_DMA_DONE|EVENT_XFER_DONE|EVENT_CMD_DONE,KAL_OR);
1805 MSDC_ERR("[MSDC][%s %d] Enter timeout handler \r\n",__FUNCTION__,__LINE__);
1806}
1807
1808/*************************************************************************
1809* FUNCTION
1810* MSDC_GetCardStatus
1811*
1812* DESCRIPTION
1813* Check currently card is present or not.
1814*
1815* PARAMETERS
1816*
1817*
1818* RETURNS
1819*
1820* GLOBALS AFFECTED
1821* msdc_eint_state
1822*
1823*
1824*************************************************************************/
1825int MSDC_GetCardStatus(void * DriveData, int AckType)
1826{
1827 return 0;
1828}
1829/*************************************************************************
1830* FUNCTION
1831* MSDC_SendCardInd
1832*
1833* DESCRIPTION
1834* Send card indication to the specified module.
1835*
1836* PARAMETERS
1837*
1838* RETURNS
1839*
1840* GLOBALS AFFECTED
1841*
1842*
1843*************************************************************************/
1844void MSDC_SendCardInd(module_type dest_id, sd_select_enum sel, kal_uint32 msg_id)
1845{
1846
1847}
1848/*************************************************************************
1849* FUNCTION
1850* MSDC_GetMediaChanged
1851*
1852* DESCRIPTION
1853* Check if the media is changed, and clear the status after function call
1854*
1855* PARAMETERS
1856*
1857* RETURNS
1858*
1859* GLOBALS AFFECTED
1860*
1861*
1862*************************************************************************/
1863kal_bool MSDC_GetMediaChanged(sd_select_enum sel)
1864{
1865 kal_bool ret;
1866
1867 ENTER_CRITICAL();
1868 ret = (MSDC_Blk[sel].mIsChanged ) ? (KAL_TRUE) : (KAL_FALSE);
1869 MSDC_Blk[sel].mIsChanged = KAL_FALSE;
1870 EXIT_CRITICAL();
1871
1872 return ret;
1873}
1874/*************************************************************************
1875* FUNCTION
1876* MSDC_InvertN
1877*
1878* DESCRIPTION
1879* Invert the order of bytes eg,
1880* src: 0x01 0x02, len: 2 => dest: 0x02 0x01
1881*
1882* PARAMETERS
1883* 1. dest: used for store inverted result
1884* 2. src: source for inverting
1885* 3. len: bytes for inverting
1886*
1887* RETURNS
1888*
1889* GLOBALS AFFECTED
1890*
1891* NOTE
1892* 1. make sure dest has the same size with src.
1893*************************************************************************/
1894void MSDC_InvertN(kal_uint8 *dest, kal_uint8 *src, kal_uint8 len)
1895{
1896 int i;
1897
1898 for (i = 0; i < len; i++)
1899 *(dest + len - 1 - i) = *(src + i);
1900
1901}
1902/*************************************************************************
1903* FUNCTION
1904* MSDC_Config_INS_WP
1905*
1906* DESCRIPTION
1907* Configure the pull up or pull down status for INS and WP pin
1908*
1909* PARAMETERS
1910* 1. ins: MSDC_IOCTRL_PULL_DOWN, MSDC_IOCTRL_PULL_UP
1911* 2. wp: MSDC_IOCTRL_PULL_DOWN, MSDC_IOCTRL_PULL_UP
1912*
1913* RETURNS
1914*
1915* GLOBALS AFFECTED
1916*
1917* NOTE
1918* 1. MT6219 can not be configured to PULL up or down. They are all pulled up by IO.
1919* 2. MT6218B and MT6217, WP is configured with data lines.
1920*************************************************************************/
1921void MSDC_Config_INS_WP(msdc_ioctrl_enum ins, msdc_ioctrl_enum wp)
1922{
1923
1924}
1925
1926void MSDC_InitializeSwitchGpio()
1927{
1928
1929 #if defined(__SIM_PLUS__) || defined(DRV_MSDC_DUAL_TCARD_BY_SWITCH)
1930 DCL_HANDLE handle;
1931#if !defined(__CUST_NEW__)
1932 GPIO_LDO_SWITCH = MSDC_GetLDO_GPIO();
1933 GPIO_EXT_SD_LDO_SWITCH = MSDC_GetEXTLDO_GPIO();
1934 GPIO_SIM_MSDC_SWITCH = MSDC_GetSwitch_GPIO();
1935#endif
1936 //GPIO_ModeSetup(GPIO_SIM_MSDC_SWITCH, 0); // gpio mode (replaced by DCL)
1937 handle = DclGPIO_Open(DCL_GPIO, GPIO_SIM_MSDC_SWITCH);
1938 DclGPIO_Control(handle, GPIO_CMD_SET_MODE_0, 0);
1939 DclGPIO_Close(handle);
1940 //GPIO_InitIO(OUTPUT, GPIO_SIM_MSDC_SWITCH); // replaced by DCL
1941 handle = DclGPIO_Open(DCL_GPIO, GPIO_SIM_MSDC_SWITCH);
1942 DclGPIO_Control(handle, GPIO_CMD_SET_DIR_OUT, 0);
1943 DclGPIO_Close(handle);
1944 /*bewlow comes after JRD SIM+ issue on 2007_03_08, use custom setting instead of fix value*/
1945 //GPIO_WriteIO(MSDC_GetSwitchDirection(), GPIO_SIM_MSDC_SWITCH); // replaced by DCL
1946 handle = DclGPIO_Open(DCL_GPIO, GPIO_SIM_MSDC_SWITCH);
1947
1948 if (0 == MSDC_GetSwitchDirection())
1949 DclGPIO_Control(handle, GPIO_CMD_WRITE_LOW, 0);
1950 else if (1 == MSDC_GetSwitchDirection())
1951 DclGPIO_Control(handle, GPIO_CMD_WRITE_HIGH, 0);
1952 else
1953 {
1954 DclGPIO_Close(handle);
1955 ASSERT(0);
1956 }
1957
1958 DclGPIO_Close(handle);
1959 /*end of changes of JRD SIM+ issue on 2007_03_08*/
1960#endif
1961
1962}
1963
1964#if !defined(_MSDC_INTERNAL_CD_INT_PIN_)
1965#if defined(__MSDC_TFLASH_DAT3_1BIT_HOT_PLUG__)
1966kal_bool EINT_DefaultPolarity = KAL_FALSE;
1967#else
1968kal_bool EINT_DefaultPolarity = KAL_FALSE;
1969#endif
1970#endif
1971
1972void MSDC_ConfigPin(kal_uint32 pullmode)
1973{
1974 /*
1975 * Note that the CLK signal is a output signal,
1976 * and it should be kept to the default value.
1977 * that is, PULL DOWN
1978 */
1979 switch (pullmode)
1980 {
1981 case MSDC_PIN_PULL_UP:
1982
1983 /* For CMD pin */
1984 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU_DUAL_IO, 1);
1985 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD_DUAL_IO, 0);
1986 /* For DATA pin */
1987 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU_DUAL_IO, 1);
1988 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD_DUAL_IO, 0);
1989 break;
1990
1991 case MSDC_PIN_PULL_DOWN:
1992
1993 /* For CMD pin */
1994 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU_DUAL_IO, 0);
1995 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD_DUAL_IO, 1);
1996 /* For DATA pin */
1997 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU_DUAL_IO, 0);
1998 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD_DUAL_IO, 1);
1999
2000 break;
2001 case MSDC_PIN_PULL_NONE:
2002 default:
2003
2004 /* For CMD pin */
2005 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU_DUAL_IO, 0);
2006 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD_DUAL_IO, 0);
2007 /* For DATA pin */
2008 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU_DUAL_IO, 0);
2009 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD_DUAL_IO, 0);
2010
2011 break;
2012 }
2013}
2014
2015/*************************************************************************
2016* FUNCTION
2017* MSDC_SetHostPower
2018*
2019* DESCRIPTION
2020* enable or disable the power of host
2021*
2022* PARAMETERS*
2023* on: KAL_TURE enable the power, KAL_FALSE disable the power
2024*
2025* RETURNS
2026*
2027* KAL_FALSE: fail to set the power
2028* KAL_TURE: success to set the power
2029*
2030* GLOBALS AFFECTED
2031* gMSDC_Handle
2032*
2033*************************************************************************/
2034kal_bool MSDC_SetHostPower(kal_bool on)
2035{
2036 kal_bool ret = KAL_TRUE;
2037
2038 return ret;
2039}
2040
2041#if (CHIP_VER == 0)
2042/*************************************************************************
2043* FUNCTION
2044* MSDC_SetVddPower
2045*
2046* DESCRIPTION
2047* enable or disable the power of host
2048*
2049* PARAMETERS*
2050* on: KAL_TURE enable the power, KAL_FALSE disable the power
2051* volt: the voltage of vdd 3300 mean 3.3v
2052* RETURNS
2053*
2054* KAL_FALSE: fail to set the power
2055* KAL_TURE: success to set the power
2056*
2057* GLOBALS AFFECTED
2058* gMSDC_Handle
2059*
2060*************************************************************************/
2061kal_bool MSDC_SetVddPower(kal_bool on,kal_uint32 volt)
2062{
2063 kal_bool ret =KAL_TRUE;
2064 if (on)
2065 {
2066 if (volt == 3300)
2067 {
2068 MSDC_ConfigPin(MSDC_PIN_PULL_UP);
2069 }
2070 else
2071 {
2072 ret = KAL_FALSE;
2073 }
2074 }
2075 else
2076 {
2077 MSDC_ConfigPin(MSDC_PIN_PULL_DOWN);
2078 }
2079 return ret;
2080}
2081
2082/*************************************************************************
2083* FUNCTION
2084* MSDC_SetSignalPower
2085*
2086* DESCRIPTION
2087* enable or disable the power of host
2088*
2089* PARAMETERS*
2090* on: KAL_TURE enable the power, KAL_FALSE disable the power
2091* volt: the voltage of signal , 3300 mean 3.3v ,1800 mean 1.8v
2092* RETURNS
2093*
2094* KAL_FALSE: fail to set the power
2095* KAL_TURE: success to set the power
2096*
2097* GLOBALS AFFECTED
2098* gMSDC_Handle
2099*
2100*************************************************************************/
2101/*
2102 CARD_PWR 1 LEVEL_PWR33 0 1.8v
2103 CARD_PWR 1 LEVEL_PWR33 1 3.3v
2104 CARD_PWR0 0v
2105*/
2106#define MSDC_CARD_PWR 26
2107#define MSDC_LEVEL_PWR33 27
2108kal_bool MSDC_SetSignalPower(kal_bool on,kal_uint32 volt)
2109{
2110 DCL_HANDLE handle;
2111 kal_bool ret =KAL_TRUE;
2112 if (on)
2113 {
2114 handle = DclGPIO_Open(DCL_GPIO, MSDC_CARD_PWR);
2115 DclGPIO_Control(handle, GPIO_CMD_SET_OWNERSHIP_TO_MD, 0);
2116 DclGPIO_Control(handle, GPIO_CMD_SET_DIR_OUT, 0);
2117 DclGPIO_Control(handle, GPIO_CMD_WRITE_HIGH, 0);
2118 //DclGPIO_Control(handle, GPIO_CMD_SET_MODE_0, 0);
2119
2120 DclGPIO_Close(handle);
2121 if (volt == 3300)
2122 {
2123 handle = DclGPIO_Open(DCL_GPIO, MSDC_LEVEL_PWR33);
2124 DclGPIO_Control(handle, GPIO_CMD_SET_OWNERSHIP_TO_MD, 0);
2125 DclGPIO_Control(handle, GPIO_CMD_SET_DIR_OUT, 0);
2126 DclGPIO_Control(handle, GPIO_CMD_WRITE_HIGH, 0);
2127 //DclGPIO_Control(handle, GPIO_CMD_SET_MODE_0, 0);
2128
2129 DclGPIO_Close(handle);
2130 MSDC_CRIT("[MSDC][%s %d]set signal power to 3.3v\r\n",__FUNCTION__,__LINE__);
2131 gMSDC_Handle->signal_volt=3300;
2132 }
2133 else if (volt ==1800)
2134 {
2135 handle = DclGPIO_Open(DCL_GPIO,MSDC_LEVEL_PWR33);
2136 DclGPIO_Control(handle, GPIO_CMD_SET_OWNERSHIP_TO_MD, 0);
2137 DclGPIO_Control(handle, GPIO_CMD_SET_DIR_OUT, 0);
2138 DclGPIO_Control(handle, GPIO_CMD_WRITE_LOW, 0);
2139 //DclGPIO_Control(handle, GPIO_CMD_SET_MODE_0, 0);
2140
2141 DclGPIO_Close(handle);
2142 MSDC_CRIT("[MSDC][%s %d]set signal power to 1.8v\r\n",__FUNCTION__,__LINE__);
2143 gMSDC_Handle->signal_volt=1800;
2144 }
2145 else
2146 {
2147 MSDC_ERR("[MSDC][%s %d]unknow signal power %d v\r\n",__FUNCTION__,__LINE__,volt);
2148 ret = KAL_FALSE;
2149 }
2150 }
2151 else
2152 {
2153 /*set signal volt to 0v*/
2154 handle = DclGPIO_Open(DCL_GPIO, MSDC_CARD_PWR);
2155 DclGPIO_Control(handle, GPIO_CMD_SET_OWNERSHIP_TO_MD, 0);
2156 DclGPIO_Control(handle, GPIO_CMD_SET_DIR_OUT, 0);
2157 DclGPIO_Control(handle, GPIO_CMD_WRITE_LOW, 0);
2158 //DclGPIO_Control(handle, GPIO_CMD_SET_MODE_0, 0);
2159
2160 DclGPIO_Close(handle);
2161 MSDC_CRIT("[MSDC][%s %d]set signal power to 0v\r\n",__FUNCTION__,__LINE__);
2162 gMSDC_Handle->signal_volt=0;
2163 }
2164
2165 return ret;
2166}
2167
2168#elif (CHIP_VER == 1)
2169
2170#define LDO_VMC 0
2171#define LDO_VMCH 1
2172#define LDO_VIO18_PMU 2
2173
2174static kal_uint32 g_msdc0_io = PMU_VOLT_03_300000_V;
2175static kal_uint32 g_msdc0_card = PMU_VOLT_03_300000_V;
2176
2177static kal_uint32 hwPowerOn(kal_uint32 powerID, PMU_VOLTAGE_ENUM powerVolt)
2178{
2179 PMU_CTRL_LDO_BUCK_SET_EN pmu_en;
2180 PMU_CTRL_LDO_BUCK_SET_VOLTAGE pmu_volsel;
2181 DCL_HANDLE handle;
2182
2183 /* Open PMU handle */
2184 handle = DclPMU_Open(DCL_PMU, FLAGS_NONE);
2185
2186 switch(powerID) {
2187 case LDO_VMC:
2188 /* Set enable control */
2189 pmu_en.mod = VMC;
2190 pmu_en.enable = 1;
2191
2192 /* Set voltage */
2193 pmu_volsel.mod = VMC;
2194 pmu_volsel.voltage = powerVolt;
2195
2196 DclPMU_Control(handle, LDO_BUCK_SET_VOLTAGE, (DCL_CTRL_DATA_T *)&pmu_volsel);
2197 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
2198
2199 break;
2200
2201 case LDO_VMCH:
2202 /* Set enable control */
2203 pmu_en.mod = VMCH;
2204 pmu_en.enable = 1;
2205
2206 /* Set voltage */
2207 pmu_volsel.mod = VMCH;
2208 pmu_volsel.voltage = powerVolt;
2209
2210 DclPMU_Control(handle, LDO_BUCK_SET_VOLTAGE, (DCL_CTRL_DATA_T *)&pmu_volsel);
2211 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
2212
2213 break;
2214
2215 default:
2216 break;
2217 }
2218
2219 /* Close PMU handle */
2220 DclPMU_Close(handle);
2221
2222 return 1;
2223}
2224
2225static kal_uint32 hwPowerDown(kal_uint32 powerID)
2226{
2227 PMU_CTRL_LDO_BUCK_SET_EN pmu_en;
2228 DCL_HANDLE handle;
2229
2230 /* Open PMU handle */
2231 handle = DclPMU_Open(DCL_PMU, FLAGS_NONE);
2232
2233 switch(powerID) {
2234 case LDO_VMC:
2235 /* Set enable control */
2236 pmu_en.mod = VMC;
2237 pmu_en.enable = 0;
2238
2239 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
2240 break;
2241
2242 case LDO_VMCH:
2243 /* Set enable control */
2244 pmu_en.mod = VMCH;
2245 pmu_en.enable = 0;
2246
2247 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
2248
2249 break;
2250
2251 default:
2252 break;
2253 }
2254
2255 /* Close PMU handle */
2256 DclPMU_Close(handle);
2257
2258 return 1;
2259}
2260
2261static kal_uint32 msdc_ldo_power(kal_uint32 on, kal_uint8 powerId,
2262 PMU_VOLTAGE_ENUM powerVolt, kal_uint32 *status)
2263{
2264 if (on) { // want to power on
2265 if (*status == 0) { // can power on
2266 MSDC_CRIT("msdc LDO<%s> power on<%d>\r\n",
2267 powerId ? "VMCH" : "VMC", powerVolt);
2268
2269 hwPowerOn(powerId, powerVolt);
2270
2271 *status = powerVolt;
2272 } else if (*status == powerVolt) {
2273 MSDC_CRIT("msdc LDO<%s><%d> power on again!\r\n",
2274 powerId ? "VMCH" : "VMC", powerVolt);
2275 } else { // for sd3.0 later
2276 MSDC_CRIT("msdc LDO<%s> change<%d> to <%d>\r\n",
2277 powerId ? "VMCH" : "VMC", *status, powerVolt);
2278
2279 hwPowerDown(powerId);
2280 hwPowerOn(powerId, powerVolt);
2281
2282 *status = powerVolt;
2283 }
2284 } else { // want to power off
2285 if (*status != 0) { // has been powerred on
2286 MSDC_CRIT("msdc LDO<%s> power off\r\n", powerId ? "VMCH" : "VMC");
2287
2288 hwPowerDown(powerId);
2289
2290 *status = 0;
2291 } else {
2292 MSDC_CRIT("LDO<%s> not power on\r\n", powerId ? "VMCH" : "VMC");
2293 }
2294 }
2295
2296 return 0;
2297}
2298
2299void msdc_set_smt(kal_bool clk, kal_bool cmd, kal_bool dat)
2300{
2301 clk &= 0xF;
2302 cmd &= 0xF;
2303 dat &= 0xF;
2304
2305 /* For CLK pin */
2306 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKSMT, clk);
2307 /* For CMD pin */
2308 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDSMT, cmd);
2309 /* For DATA pin */
2310 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATSMT, dat);
2311}
2312
2313void msdc_set_slew_rate(int clk,int cmd, int dat)
2314{
2315 clk &= 0x1;
2316 cmd &= 0x1;
2317 dat &= 0x1;
2318
2319 /* For CLK pin */
2320 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKSR, clk);
2321 /* For CMD pin */
2322 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDSR, cmd);
2323 /* For DATA pin */
2324 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATSR, dat);
2325}
2326
2327void msdc_set_rdsel(kal_bool clk, kal_bool cmd, kal_bool dat)
2328{
2329 clk &= 0xF;
2330 cmd &= 0xF;
2331 dat &= 0xF;
2332
2333 /* For CLK pin */
2334 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKRDSEL, clk);
2335 /* For CMD pin */
2336 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDRDSEL, cmd);
2337 /* For DATA pin */
2338 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATRDSEL, dat);
2339}
2340
2341void msdc_set_tdsel(kal_bool clk, kal_bool cmd, kal_bool dat)
2342{
2343 clk &= 0xF;
2344 cmd &= 0xF;
2345 dat &= 0xF;
2346
2347 /* For CLK pin */
2348 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKTDSEL, clk);
2349 /* For CMD pin */
2350 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDTDSEL, cmd);
2351 /* For DATA pin */
2352 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATTDSEL, dat);
2353}
2354
2355void msdc_set_driving(struct msdc_cust *hw, kal_bool sd_18)
2356{
2357 if (sd_18) {
2358 /* For CLK pin */
2359 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRV, hw->io_clk.io_drv_18);
2360 /* For CMD pin */
2361 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRV, hw->io_cmd.io_drv_18);
2362 /* For DATA pin */
2363 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRV, hw->io_dat.io_drv_18);
2364 } else {
2365 /* For CLK pin */
2366 MSDC_SET_FIELD(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRV, hw->io_clk.io_drv_33);
2367 /* For CMD pin */
2368 MSDC_SET_FIELD(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRV, hw->io_cmd.io_drv_33);
2369 /* For DATA pin */
2370 MSDC_SET_FIELD(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRV, hw->io_dat.io_drv_33);
2371 }
2372
2373}
2374
2375int msdc_io_init()
2376{
2377 struct msdc_cust *pmsdc_cust = NULL;
2378
2379 pmsdc_cust = &msdc_cap;
2380
2381 if (!pmsdc_cust) {
2382 MSDC_ERR("<%s> : Invalid host ID!\r\n", __FUNCTION__);
2383 goto exit;
2384 }
2385
2386 /* RDSEL Init */
2387 msdc_set_rdsel(pmsdc_cust->io_clk.rdsel, pmsdc_cust->io_cmd.rdsel,
2388 pmsdc_cust->io_dat.rdsel);
2389
2390 /* TDSEL Init */
2391 msdc_set_tdsel(pmsdc_cust->io_clk.tdsel, pmsdc_cust->io_cmd.tdsel,
2392 pmsdc_cust->io_dat.tdsel);
2393
2394 /* SMTen Init */
2395 msdc_set_smt(pmsdc_cust->io_clk.smten, pmsdc_cust->io_cmd.smten,
2396 pmsdc_cust->io_dat.smten);
2397
2398 /* Slew Rate Init */
2399 msdc_set_slew_rate(pmsdc_cust->io_clk.slew, pmsdc_cust->io_cmd.slew,
2400 pmsdc_cust->io_dat.slew);
2401
2402 /* IO driving Init */
2403 msdc_set_driving(pmsdc_cust, 0);
2404
2405exit:
2406
2407 return 1;
2408}
2409
2410void msdc_pin_init()
2411{
2412 /* Pin config for MSDC0 */
2413#if defined(_MSDC_INTERNAL_CD_INT_PIN_)
2414 /* Set to MSDC function(INS and WP) */
2415 IOMUX_set_module_func(0, sel_msdc0p_0);
2416#else
2417 /* Set GPIO/EINT function, both for INS and WP */
2418 IOMUX_set_module_func(4, sel_msdc0p_0);
2419
2420 #ifdef ATEST_DRV_MSDC
2421 GPIO_init();
2422 EINT_Setting_Init();
2423 #endif
2424
2425#endif
2426
2427 IOMUX_set_module_func(0, sel_msdc0p_1);
2428 IOMUX_set_module_func(0, sel_msdc0p_2);
2429
2430 return;
2431}
2432
2433kal_bool MSDC_SetVddPower(kal_bool on, kal_uint32 volt)
2434{
2435 kal_bool ret =KAL_TRUE;
2436
2437 if (on)
2438 MSDC_ConfigPin(MSDC_PIN_PULL_UP);
2439
2440 if (volt == 3300)
2441 {
2442 msdc_ldo_power(on, LDO_VMCH, PMU_VOLT_03_300000_V, &g_msdc0_card);
2443 }
2444 else
2445 {
2446 MSDC_ERR("[MSDC][%s %d]unknow signal power %d v\r\n",
2447 __FUNCTION__, __LINE__, volt);
2448
2449 ret = KAL_FALSE;
2450 }
2451
2452 if (!on)
2453 MSDC_ConfigPin(MSDC_PIN_PULL_UP);
2454
2455 return ret;
2456}
2457
2458kal_bool MSDC_SetSignalPower(kal_bool on,kal_uint32 volt)
2459{
2460 kal_bool ret =KAL_TRUE;
2461 if (volt == 3300)
2462 {
2463 msdc_ldo_power(on, LDO_VMC, PMU_VOLT_03_300000_V, &g_msdc0_io);
2464 msdc_set_driving(&msdc_cap, 0);
2465 }
2466 else if (volt ==1800)
2467 {
2468 msdc_ldo_power(on, LDO_VMC, PMU_VOLT_01_800000_V, &g_msdc0_io);
2469 msdc_set_driving(&msdc_cap, 1);
2470 }
2471 else
2472 {
2473 MSDC_ERR("[MSDC][%s %d]unknow signal power %d v\r\n",
2474 __FUNCTION__, __LINE__, volt);
2475
2476 ret = KAL_FALSE;
2477 }
2478
2479 return ret;
2480}
2481#endif
2482
2483/*************************************************************************
2484* FUNCTION
2485* MSDC_SetAllPower
2486*
2487* DESCRIPTION
2488* enable or disable the power of host\Vdd\signal
2489*
2490* PARAMETERS*
2491*
2492* RETURNS
2493*
2494* KAL_FALSE: fail to set the power
2495* KAL_TURE: success to set the power
2496*
2497* GLOBALS AFFECTED
2498* gMSDC_Handle
2499*
2500*************************************************************************/
2501kal_bool MSDC_SetAllPower(kal_bool on)
2502{
2503 kal_bool ret=KAL_TRUE;
2504
2505 if (on)
2506 {
2507 MSDC_SetHostPower(on);
2508 MSDC_SetVddPower(on,gMSDC_Handle->vdd_volt);
2509 MSDC_SetSignalPower(on,gMSDC_Handle->signal_volt);
2510 }
2511 else
2512 {
2513 MSDC_SetSignalPower(on,gMSDC_Handle->signal_volt);
2514 MSDC_SetVddPower(on,gMSDC_Handle->vdd_volt);
2515 MSDC_SetHostPower(on);
2516
2517 }
2518 return ret;
2519
2520}
2521
2522void power_cycle(kal_uint32 interval_ticks)
2523{
2524 MSDC_SetVddPower(0,gMSDC_Handle->vdd_volt);
2525 msdc_sleep(interval_ticks);
2526 MSDC_SetVddPower(1,gMSDC_Handle->vdd_volt);
2527}
2528
2529/*************************************************************************
2530* FUNCTION
2531* MSDC_SetBusWidth
2532*
2533* DESCRIPTION
2534* set the bus width to 1 ,4 8
2535*
2536* PARAMETERS*
2537* bus_width : set to 1 ,4 ,8
2538* RETURNS
2539*
2540* GLOBALS AFFECTED
2541* gMSDC_Handle
2542*
2543*************************************************************************/
2544void MSDC_SetBusWidth(SD_BITWIDTH bus_width)
2545{
2546 kal_uint32 val;
2547 val=MSDC_Reg32(SDC_CFG)&(~SDC_CFG_BUSWIDTH);
2548 switch(bus_width)
2549 {
2550 default:
2551 case BIT_1W:
2552 val |=(MSDC_BUS_1BITS << 16);
2553 gMSDC_Handle->bus_width=1;
2554 break;
2555 case BIT_4W:
2556 val |=(MSDC_BUS_4BITS <<16);
2557 gMSDC_Handle->bus_width=4;
2558 break;
2559 case BIT_8W:
2560 val |=(MSDC_BUS_8BITS<<16);
2561 gMSDC_Handle->bus_width=8;
2562 break;
2563 }
2564 MSDC_WriteReg32(SDC_CFG,val);
2565
2566 MSDC_CRIT("[MSDC][%s %d]Set to %d-bit bus width\r\n", __FUNCTION__,
2567 __LINE__, gMSDC_Handle->bus_width);
2568}
2569
2570void MSDC_FatalErrorHandle()
2571{
2572 /*reset msdc*/
2573 MSDC_RESET();
2574 /*stop dma*/
2575 MSDC_STOP_DMA();
2576 /*clear fifo*/
2577 MSDC_CLR_FIFO_EX();
2578 /*clear ints*/
2579 MSDC_CLR_INT();
2580 /**/
2581}
2582
2583 kal_uint32 MSDC_PollInts(kal_uint32 int_mask,kal_uint32 timeout_ms)
2584{
2585 kal_uint32 intsts;
2586 if (!MSDC_TIMEOUT_WAIT((MSDC_Reg32(MSDC_INT)&int_mask),timeout_ms))
2587 {
2588 intsts=MSDC_Reg32(MSDC_INT);
2589 MSDC_WriteReg32(MSDC_INT,intsts&int_mask);
2590 return intsts&int_mask;
2591 }
2592
2593 MSDC_ERR("[MSDC][%s %d]poll INT %d, SW timeout\r\n",__FUNCTION__,__LINE__,timeout_ms);
2594 return 0;
2595}
2596/*************************************************************************
2597* FUNCTION
2598
2599* MSDC_Initialize
2600*
2601* DESCRIPTION
2602* Initialize the MS/SD host controller, called only once at drv_init
2603*
2604* PARAMETERS*
2605*
2606* RETURNS
2607* 1: initailized failed
2608* 0: successful
2609*
2610* GLOBALS AFFECTED
2611* gMSDC_Handle
2612*
2613*************************************************************************/
2614extern kal_semid dualMsdcArb;
2615
2616void MSDC_Probe (void)
2617{
2618 if (gMSDC_Handle->mIsProbeMSDC)
2619 return;
2620
2621 /* PDN disable first */
2622 MSDC_PDNControl(KAL_FALSE);
2623
2624 #if (CHIP_VER == 1)
2625 msdc_io_init();
2626 #endif
2627
2628 /*check card present or not*/
2629#if defined(MSDC_HOTPLUG_EN)
2630#if defined(_MSDC_INTERNAL_CD_INT_PIN_)
2631 if (MSDC_Reg32(MSDC_PS)&MSDC_PS_CDSTS)
2632 gMSDC_Handle->mIsPresent=KAL_FALSE;
2633 else
2634 gMSDC_Handle->mIsPresent=KAL_TRUE;
2635#else /* _MSDC_INTERNAL_CD_INT_PIN_ */
2636 {
2637 DCL_HANDLE handle;
2638
2639 GPIO_CTRL_READ_T data;
2640
2641 /* when use EINT for card detect,get the status */
2642 handle = DclGPIO_Open(DCL_GPIO, MSDC_INS_GPIO);
2643 DclGPIO_Control(handle, GPIO_CMD_READ, (DCL_CTRL_DATA_T *)&data);
2644
2645 if (data.u1IOData)
2646 gMSDC_Handle->mIsPresent = KAL_FALSE;
2647 else
2648 gMSDC_Handle->mIsPresent = KAL_TRUE;
2649
2650 DclGPIO_Close(handle);
2651 }
2652#endif
2653#else /* MSDC_HOTPLUG_EN */
2654 gMSDC_Handle->mIsPresent = KAL_TRUE;
2655#endif
2656 MSDC_CRIT("[MSDC][%s %d]Card is %s\r\n",__FUNCTION__,__LINE__,
2657 gMSDC_Handle->mIsPresent ? "Present" : "Not Present");
2658
2659 /* If card is not exist, step over the INIT flow */
2660 if (gMSDC_Handle->mIsPresent)
2661 gMSDC_Handle->mIsProbeMSDC = KAL_TRUE;
2662 else {
2663 gMSDC_Handle->mIsProbeMSDC = KAL_FALSE;
2664 goto exit;
2665 }
2666
2667 /*set MSDC as the controller of SD*/
2668 MSDC_SET_FIELD(MSDC_CFG, MSDC_CFG_MODE, 1);
2669
2670 /*reset MSDC ,clear FIFO*/
2671 MSDC_RESET();
2672 MSDC_CLR_FIFO_EX();
2673 MSDC_DEBUG("[MSDC][%s %d]reset MSDC,clear FIFO\r\n",__FUNCTION__,__LINE__);
2674
2675 /*write crc timeout detection*/
2676 MSDC_SetData32(MSDC_PATCH_BIT0,1<<30,(1<<30));
2677 /*Configure To Default Data Timeout */
2678 MSDC_SetData32(SDC_CFG,SDC_CFG_DTOC,(DEFAULT_DTOC<<24));
2679 /*set bus width to 1 */
2680 MSDC_SetBusWidth(BIT_1W);
2681
2682 /* Tuning parameters INIT */
2683 msdc_tune_init();
2684
2685exit:
2686 MSDC_PDNControl(KAL_TRUE);
2687
2688 /* Shut card power */
2689 MSDC_SetVddPower(KAL_FALSE, gMSDC_Handle->vdd_volt);
2690
2691 /* Defaultly turn VMC to 1.8V to save power */
2692 MSDC_SetSignalPower(KAL_TRUE, gMSDC_Handle->signal_volt);
2693}
2694
2695void MSDC_Initialize(void)
2696{
2697 /* INIT MSDC debug flag */
2698 MSDC_SetDebugLevel(K_NOTICE);
2699
2700 MSDC_CRIT("[MSDC][%s %d]Start init MSDC...\r\n",__FUNCTION__,__LINE__);
2701
2702 /*check MSDC is initalized or not */
2703 if (gMSDC_Handle->mIsInitMSDC)
2704 return;
2705
2706 gMSDC_Handle->mIsProbeMSDC = 0;
2707
2708 /*init gSD*/
2709 kal_mem_set(gSD,0,sizeof(T_SDC_HANDLE));
2710
2711 /* Set voltage of single and card power */
2712 gMSDC_Handle->signal_volt = 1800;
2713 gMSDC_Handle->vdd_volt = 3300;
2714
2715 #if !defined(ATEST_DRV_ENABLE)
2716 /* Get Sleep handler */
2717 gMSDC_Handle->msdc_sm_hdl = SleepDrv_GetHandle(SMP);
2718 MSDC_CRIT("[MSDC][%s %d]MSDC Slp Handler: %d\r\n",
2719 __FUNCTION__, __LINE__, gMSDC_Handle->msdc_sm_hdl);
2720 #endif
2721
2722 /*set clock source */
2723 MSDC_SetClockSource(SRC_80M);
2724
2725 #if (CHIP_VER == 1)
2726 /* Pin MUX setting and IO settings */
2727 msdc_pin_init();
2728 #endif
2729
2730 /*get gpt handle*/
2731 if (gMSDC_Handle->gpt_handle==0)
2732 MSDC_GPTI_GetHandle(&gMSDC_Handle->gpt_handle);
2733
2734 /*clear and disable all interrupt*/
2735 MSDC_ClearBits32(MSDC_INTEN,MSDC_Reg32(MSDC_INTEN));
2736 MSDC_WriteReg32(MSDC_INT,MSDC_Reg32(MSDC_INT));
2737
2738 /* INIT the MSDC related registers */
2739 MSDC_Probe();
2740
2741 /*init INT handle*/
2742 MSDC_INT_Init();
2743
2744 /*set the function support by host*/
2745 gMSDC_Handle->host_support.function1=FUN1_SDR12_DS|FUN1_SDR25_HS|FUN1_SDR50|FUN1_SDR104|FUN1_DDR50;
2746 gMSDC_Handle->host_support.function2=FUN2_DEFAULT;
2747 gMSDC_Handle->host_support.function3=FUN3_TYPE_B;
2748 gMSDC_Handle->host_support.function4=FUN4_200MA|FUN4_400MA|FUN4_600MA|FUN4_800MA;
2749
2750 gMSDC_Handle->mIsInitMSDC = KAL_TRUE;
2751
2752 MSDC_DEBUG("[MSDC][%s %d]finish init MSDC\r\n",__FUNCTION__,__LINE__);
2753}
2754
2755/*************************************************************************
2756* FUNCTION
2757* MSDC_DeInit
2758*
2759* DESCRIPTION
2760* De-initialize the MS/SD host controller, called only once at drv_init
2761*
2762* PARAMETERS*
2763*
2764* RETURNS
2765*
2766* GLOBALS AFFECTED
2767*
2768*************************************************************************/
2769void MSDC_DeInit(void)
2770{
2771 /* Shutdown Card power Only */
2772 MSDC_SetVddPower(KAL_FALSE, gMSDC_Handle->vdd_volt);
2773
2774 gMSDC_Handle->mIsProbeMSDC = KAL_FALSE;
2775 gMSDC_Handle->mIsInitialized = KAL_FALSE;
2776
2777 return;
2778}
2779
2780
2781#ifdef __TST_WRITE_TO_FILE__
2782/*error recording: add this function to do MSDC reset when error recording*/
2783void MSDC_ErrorRecordingReset()
2784{
2785
2786
2787}
2788#endif
2789
2790#ifndef DRV_LSD
2791/*************************************************************************
2792* FUNCTION
2793* BitFieldWrite32
2794*
2795* DESCRIPTION
2796* Write src to dest at mask position
2797*
2798* PARAMETERS
2799* dest: destination to be update
2800* src: value to be written
2801* mask: bit mask
2802* RETURNS
2803*
2804* GLOBALS AFFECTED
2805*
2806*
2807*************************************************************************/
2808// Note: mask must be a continuous area during 32bits. eg,
2809// dest : 00A30000 , src : BF, mask : 0000BF00.
2810// after BitFieldCpy, dest : 00A3BF00, copy src to dest at mask position.
2811void BitFieldWrite32(kal_uint32 * dest, kal_uint32 src, kal_uint32 mask)
2812{
2813 kal_uint8 bit_pos;
2814 kal_uint32 tmp;
2815
2816 bit_pos = 0;
2817 tmp = MSDC_Reg32(dest);
2818
2819 // get bit positoin
2820 while (!((mask >> bit_pos++) & 1));
2821
2822 //use mask clear the corresponding area
2823 tmp &= ~mask;
2824 //shift src to the corresponding positiion
2825 src <<= (bit_pos - 1);
2826 //copy src into destination
2827 tmp |= src;
2828 MSDC_WriteReg32(dest, tmp);
2829}
2830#endif
2831
2832#ifdef MSDC_USED_STUFF
2833/*************************************************************************
2834* FUNCTION
2835* BitFieldRead32
2836*
2837* DESCRIPTION
2838* read src to dest at mask position
2839*
2840* PARAMETERS
2841* dest: destination to store
2842* src: value to be written
2843* mask: bit mask
2844* RETURNS
2845*
2846* GLOBALS AFFECTED
2847*
2848*
2849*************************************************************************/
2850
2851// Note: mask must ve continuous area during 32 bits.eg,
2852// src : 00A3BF00, mask : 00FF0000
2853// after BitFieldRead, dest : A3
2854void BitFieldRead32(kal_uint32 * dest, kal_uint32 src, kal_uint32 mask)
2855{
2856 kal_uint8 bit_pos = 0;
2857
2858 while (!((mask >> bit_pos++) & 1));
2859
2860 src &= mask;
2861 *(kal_uint32 *)dest = src >> (bit_pos - 1);
2862}
2863#endif//MSDC_USED_STUFF
2864
2865// get the bit field value of start_bit with width bits
2866// note 1) start_bit start from bit 0
2867// 2) prepare dest with initialized with zeros
2868// 3) width must less than 32 if using the retrun value as a result
2869// eg,
2870// src:00110110, start_bit:2,width:3 => dest:101
2871void GetBitFieldN(kal_uint8* dest, kal_uint8* src, kal_uint16 start_bit, kal_uint16 width)
2872{
2873 int i;
2874 kal_uint16 bytes, bits;
2875
2876 //kal_mem_set(dest,0,width/8+1);
2877 kal_mem_set(dest, 0, (width / 8) + (0 == (width % 8) ? 0 : 1));
2878
2879 for ( i = 0; i < width; i++)
2880 {
2881 bytes = (start_bit + i) / 8;
2882 bits = (start_bit + i) % 8;
2883 *(dest + i / 8) |= (kal_uint8)(((*(src + bytes) >> bits) & 1) << (i % 8));
2884 }
2885
2886 /*in MT6238, address of kal_uint32 is checked strictly, and we don't need the return value of this function*/
2887 /*change it's return type to void*/
2888 return ;
2889}
2890
2891#if defined(DRV_MSDC_LATCH_MT6276_SERIES)
2892void MSDC_SetLatchTuning(void)
2893{
2894
2895}
2896#else
2897void MSDC_SetIOCONRegDLT(void)
2898{
2899
2900}
2901#endif//#if defined(DRV_MSDC_LATCH_MT6276_SERIES)
2902
2903void msdc_dump_reg(void)
2904{
2905 int idx;
2906
2907 MSDC_CRIT("****** [00]MSDC_CFG : %x\r\n", MSDC_Reg32(MSDC_CFG));
2908 MSDC_CRIT("****** [04]MSDC_IOCON : %x\r\n", MSDC_Reg32(MSDC_IOCON));
2909 MSDC_CRIT("****** [08]MSDC_PS : %x\r\n", MSDC_Reg32(MSDC_PS));
2910 MSDC_CRIT("****** [0C]MSDC_INT : %x\r\n", MSDC_Reg32(MSDC_INT));
2911 MSDC_CRIT("****** [10]MSDC_INTEN : %x\r\n", MSDC_Reg32(MSDC_INTEN));
2912 MSDC_CRIT("****** [14]MSDC_FIFOCS : %x\r\n", MSDC_Reg32(MSDC_FIFOCS));
2913 MSDC_CRIT("****** [18]MSDC_TXDATA : %x\r\n", MSDC_Reg32(MSDC_TXDATA));
2914 MSDC_CRIT("****** [1C]MSDC_RXDATA : --------\r\n");
2915 MSDC_CRIT("****** [30]SDC_CFG : %x\r\n", MSDC_Reg32(SDC_CFG));
2916 MSDC_CRIT("****** [34]SDC_CMD : %x\r\n", MSDC_Reg32(SDC_CMD));
2917 MSDC_CRIT("****** [38]SDC_ARG : %x\r\n", MSDC_Reg32(SDC_ARG));
2918 MSDC_CRIT("****** [3C]SDC_STS : %x\r\n", MSDC_Reg32(SDC_STS));
2919 MSDC_CRIT("****** [40]SDC_RESP0 : %x\r\n", MSDC_Reg32(SDC_RESP0));
2920 MSDC_CRIT("****** [44]SDC_RESP1 : %x\r\n", MSDC_Reg32(SDC_RESP1));
2921 MSDC_CRIT("****** [48]SDC_RESP2 : %x\r\n", MSDC_Reg32(SDC_RESP2));
2922 MSDC_CRIT("****** [4C]SDC_RESP3 : %x\r\n", MSDC_Reg32(SDC_RESP3));
2923 MSDC_CRIT("****** [50]SDC_BLK_NUM : %x\r\n", MSDC_Reg32(SDC_BLK_NUM));
2924 MSDC_CRIT("****** [58]SDC_CSTS : %x\r\n", MSDC_Reg32(SDC_CSTS));
2925 MSDC_CRIT("****** [5C]SDC_CSTS_EN : %x\r\n", MSDC_Reg32(SDC_CSTS_EN));
2926 MSDC_CRIT("****** [60]SDC_DATCRC_STS : %x\r\n", MSDC_Reg32(SDC_DCRC_STS));
2927 MSDC_CRIT("****** [70]EMMC_CFG0 : %x\r\n", MSDC_Reg32(EMMC_CFG0));
2928 MSDC_CRIT("****** [74]EMMC_CFG1 : %x\r\n", MSDC_Reg32(EMMC_CFG1));
2929 MSDC_CRIT("****** [78]EMMC_STS : %x\r\n", MSDC_Reg32(EMMC_STS));
2930 MSDC_CRIT("****** [7C]EMMC_IOCON : %x\r\n", MSDC_Reg32(EMMC_IOCON));
2931 MSDC_CRIT("****** [80]SD_ACMD_RESP : %x\r\n", MSDC_Reg32(SDC_ACMD_RESP));
2932 MSDC_CRIT("****** [84]SD_ACMD19_TRG : %x\r\n", MSDC_Reg32(SDC_ACMD19_TRG));
2933 MSDC_CRIT("****** [88]SD_ACMD19_STS : %x\r\n", MSDC_Reg32(SDC_ACMD19_STS));
2934 MSDC_CRIT("****** [90]DMA_SA : %x\r\n", MSDC_Reg32(MSDC_DMA_SA));
2935 MSDC_CRIT("****** [94]DMA_CA : %x\r\n", MSDC_Reg32(MSDC_DMA_CA));
2936 MSDC_CRIT("****** [98]DMA_CTRL : %x\r\n", MSDC_Reg32(MSDC_DMA_CTL));
2937 MSDC_CRIT("****** [9C]DMA_CFG : %x\r\n", MSDC_Reg32(MSDC_DMA_CFG));
2938 MSDC_CRIT("****** [A8]DMA_LENGTH : %x\r\n", MSDC_Reg32(MSDC_DMA_LENGTH));
2939 MSDC_CRIT("****** [B0]PATCH_BIT0 : %x\r\n", MSDC_Reg32(MSDC_PATCH_BIT0));
2940 MSDC_CRIT("****** [B4]PATCH_BIT1 : %x\r\n", MSDC_Reg32(MSDC_PATCH_BIT1));
2941 MSDC_CRIT("****** [E0]SD30_PAD_CTL0 : %x\r\n", MSDC_Reg32(MSDC_PAD_CTL0));
2942 MSDC_CRIT("****** [E4]SD30_PAD_CTL1 : %x\r\n", MSDC_Reg32(MSDC_PAD_CTL1));
2943 MSDC_CRIT("****** [E8]SD30_PAD_CTL2 : %x\r\n", MSDC_Reg32(MSDC_PAD_CTL2));
2944 MSDC_CRIT("****** [EC]PAD_TUNE : %x\r\n", MSDC_Reg32(MSDC_PAD_TUNE));
2945 MSDC_CRIT("****** [F0]DAT_RD_DLY0 : %x\r\n", MSDC_Reg32(MSDC_DAT_RDDLY0));
2946 MSDC_CRIT("****** [F4]DAT_RD_DLY1 : %x\r\n", MSDC_Reg32(MSDC_DAT_RDDLY1));
2947 MSDC_CRIT("****** [100]MAIN_VERSION : %x\r\n", MSDC_Reg32(MSDC_VERSION));
2948 MSDC_CRIT("****** [104]ECO_VERSION : %x\r\n", MSDC_Reg32(MSDC_ECO_VER));
2949
2950 for (idx = 0; idx < 26; idx++) {
2951 MSDC_WriteReg32(MSDC_DBG_SEL, idx);
2952 MSDC_CRIT("=*=*=* MSDC_DBG_SEL:%d => MSDC_DBG_OUT:%x\r\n",
2953 idx, MSDC_Reg32(MSDC_DBG_OUT));
2954 }
2955
2956 MSDC_CRIT("====== MSDC Register and Debug Register Dump End ======\r\n");
2957}
2958
2959#ifdef _MSDC_DMA_
2960/*************************************************************************
2961* FUNCTION
2962* MSDC_DMAInit
2963*
2964* DESCRIPTION
2965* Initialize MSDC's DMA
2966*
2967* PARAMETERS
2968*
2969* RETURNS
2970*
2971* GLOBALS AFFECTED
2972*
2973*
2974*************************************************************************/
2975void MSDC_DMAInit(void)
2976{
2977
2978}
2979void MSDC_StartDMA(void)
2980{
2981 kal_uint32 ints=MSDC_INTEN_XFER_COMPL | MSDC_INTEN_DATTMO |
2982 MSDC_INTEN_DATCRCERR |MSDC_INTEN_DXFER_DONE |
2983 MSDC_INTEN_BD_CS_ERR | MSDC_INTEN_GPD_CS_ERR;
2984 //kal_uint32 ints=MSDC_DAT_INTS;
2985 kal_uint32 abnormal_ints;
2986 abnormal_ints=MSDC_Reg32(MSDC_INT)&ints;
2987 if(0 != abnormal_ints)
2988 {
2989 /*error, have irq before we enable it*/
2990 MSDC_ERR("[MSDC][%s %d]abnormal irq %x\r\n",__FUNCTION__,__LINE__,abnormal_ints);
2991 MSDC_WriteReg32(MSDC_INT,abnormal_ints);
2992 }
2993 MSDC_SetBits32(MSDC_INTEN, ints);
2994 MSDC_SET_FIELD(MSDC_DMA_CTL, MSDC_DMA_CTL_START, 1);
2995 gMSDC_Handle->is_timeout=KAL_FALSE;
2996 MSDC_START_TIMER(MSDC_DMA_DAT_TMO);
2997}
2998SDC_CMD_STATUS MSDC_ConfigDMA(kal_uint32 * buffer,kal_uint32 num,msdc_gpd_t * gpd_ptr,kal_bool isLastBuf)
2999{
3000 kal_uint32 dma_ctl_arg;
3001 #define BURST_8Byte 3
3002 #define BURST_16Byte 4
3003 #define BURST_32Byte 5
3004 #define BURST_64Byte 6
3005 /*if (gpd_ptr==NULL)
3006 {
3007 gMSDC_Handle->error=ERR_ARGUMENT;
3008 #ifdef MSDC_DEBUG_PRINT
3009 dbg_print("[MSDC][ERROR][%s %d]gpd_ptr point to zero\r\n",__FUNCTION__,__LINE__);
3010 #endif
3011 return ERR_ARGUMENT;
3012 }*/
3013 //set to DMA mode
3014 //BitFieldWrite32((kal_uint32 *)MSDC_CFG, 0, MSDC_CFG_PIO);
3015 MSDC_ClearBits32(MSDC_CFG,MSDC_CFG_PIO);
3016 gMSDC_Handle->dma_xfer=1;
3017 if ((buffer==NULL) && (gpd_ptr != NULL))
3018 {
3019 /*use link list based DMA */
3020
3021 #ifdef MSDC_DMA_CHKSUM_EN
3022 /*Enable descriptor 's checksum*/
3023 MSDC_SET_FIELD(MSDC_DMA_CFG, MSDC_DMA_CFG_DECSEN, 1);
3024 #else
3025 /*Disable descriptor 's checksum*/
3026 MSDC_SET_FIELD(MSDC_DMA_CFG, MSDC_DMA_CFG_DECSEN, 0);
3027 #endif
3028
3029 /*descriptor mode and burst size=64Bytes*/
3030 dma_ctl_arg=(BURST_64Byte<<12)|MSDC_DMA_CTL_MODE;
3031 MSDC_WriteReg32(MSDC_DMA_CTL,dma_ctl_arg);
3032 /*write DMA start address to GPD's physical address*/
3033 MSDC_WriteReg32(MSDC_DMA_SA,gpd_ptr);
3034 }
3035 else if((buffer != NULL)&& (gpd_ptr == NULL))
3036 {
3037
3038 /*use basic DMA*/
3039 /*burst size\last buffer*/
3040 dma_ctl_arg = (isLastBuf==KAL_TRUE)? ((BURST_64Byte<<12)|MSDC_DMA_CTL_LASTBUF) : (BURST_64Byte<<12);
3041 MSDC_WriteReg32(MSDC_DMA_CTL,dma_ctl_arg);
3042 /*set xfer size*/
3043 MSDC_WriteReg32(MSDC_DMA_LENGTH,num);
3044 /*set address*/
3045 MSDC_WriteReg32(MSDC_DMA_SA,buffer);
3046 }
3047 else
3048 {
3049 //wrong argument
3050 }
3051 return NO_ERROR;
3052}
3053SDC_CMD_STATUS MSDC_WaitDMADone()
3054{
3055 kal_uint32 status;
3056 kal_uint32 ints= MSDC_INTEN_XFER_COMPL | MSDC_INTEN_DATTMO |
3057 MSDC_INTEN_DATCRCERR |MSDC_INTEN_DXFER_DONE |
3058 MSDC_INTEN_BD_CS_ERR | MSDC_INTEN_GPD_CS_ERR;
3059
3060 /*wait DMA done*/
3061 kal_retrieve_eg_events(gMSDC_Handle->MSDC_Events,EVENT_XFER_DONE|EVENT_DMA_DONE,KAL_OR_CONSUME,&status,KAL_SUSPEND);
3062 MSDC_STOP_TIMER();
3063 MSDC_DEBUG("[MSDC][%s]msdc_int=%x\r\n",__FUNCTION__,gMSDC_Handle->msdc_int);
3064 if (gMSDC_Handle->is_timeout)
3065 {
3066 MSDC_ERR("[MSDC][%s %d]wait DMA done GPT timeout\r\n",__FUNCTION__,__LINE__);
3067 msdc_dump_reg();
3068 gMSDC_Handle->error=MSDC_GPT_TIMEOUT_ERR;
3069 }
3070 /*Disable interrupt*/
3071 MSDC_ClearBits32(MSDC_INTEN,ints);
3072 /*stop dma*/
3073 MSDC_STOP_DMA();
3074 return gMSDC_Handle->error;
3075}
3076kal_uint32 MSDC_CheckCardBusy(kal_bool send_stop,kal_uint32 timeout_ms)
3077{
3078 kal_uint32 start_time,status;
3079 kal_uint32 err,count=0;
3080 start_time = drv_get_current_time();
3081
3082 do{
3083 err=SD_GetStatus(gSD->mRCA, &status);
3084 if(err)
3085 {
3086 break;
3087 }
3088 count++;
3089 if(count%5000==0)
3090 {
3091 if(send_stop)
3092 {
3093 SD_StopTrans();
3094 }
3095 }
3096 }while((!(status&R1_READY_FOR_DATA_8)||(R1_CURRENT_STATE(status)==7))&&(drv_get_duration_ms(start_time) <=timeout_ms));
3097 if (!(drv_get_duration_ms(start_time) <=timeout_ms))
3098 {
3099 MSDC_ERR("[MSDC][%s %d]card busy timeout\r\n",__FUNCTION__,__LINE__);
3100 gMSDC_Handle->error=err=ERR_CARD_BUSY_TIMEOUT;
3101 }
3102 return err;
3103}
3104/************************************************************************
3105* FUNCTION
3106* MSDC_DMATransferFinal_In_Callback
3107*
3108* DESCRIPTION
3109* Initialize MSDC's DMA
3110*
3111* PARAMETERS
3112*
3113* RETURNS
3114*
3115* GLOBALS AFFECTED
3116*
3117*
3118*************************************************************************/
3119#if defined(MSDC_START_DMA_IN_CALLBACK)
3120
3121void MSDC_DMATransferFinal_In_Callback(void)
3122{
3123
3124}
3125
3126kal_uint32 MSDC_DMATransferFinal(void)
3127{
3128
3129}
3130#endif
3131/*************************************************************************
3132* FUNCTION
3133* MSDC_DMATransfer
3134*
3135* DESCRIPTION
3136* MSDC using DAM for data transfer
3137*
3138* PARAMETERS
3139* adrs: data buffer
3140* count: bytes to be transfered
3141* isTx: ture for move data from MSDC to data buffer and vise versa
3142*
3143* RETURNS
3144*
3145* GLOBALS AFFECTED
3146*
3147*
3148*************************************************************************/
3149extern kal_bool FTL_isPollingMode();
3150void MSDC_DMATransferFirst( kal_bool isWrite,kal_bool isLinkListBuf)
3151{
3152 kal_uint32 * adrs;
3153
3154 kal_set_eg_events(gMSDC_Handle->MSDC_Events,0,KAL_AND);
3155 if (isLinkListBuf)
3156 {
3157 /*configure DMA*/
3158 MSDC_ConfigDMA(NULL,gMSDC_Handle->total_count,(msdc_gpd_t *)gMSDC_Handle->buf_addr,1);
3159 }
3160 else
3161 {
3162 adrs=gMSDC_Handle->buf_addr;
3163 #ifdef MSDC_CACHED_SUPPORT
3164 if (gMSDC_Handle->isRomSpace)
3165 {
3166 gMSDC_Handle->trans_count=(gMSDC_Handle->total_count > MSDC_UNCACHED_TRANSFER_SIZE) ? (MSDC_UNCACHED_TRANSFER_SIZE) : gMSDC_Handle->total_count;
3167 /*copy from upper application buffer*/
3168 if (isWrite)
3169 {
3170 kal_mem_cpy((void *)msdc_uncachedBuf,(void*)gMSDC_Handle->buf_addr,gMSDC_Handle->trans_count);
3171 }
3172 adrs=(kal_uint32 *)msdc_uncachedBuf;
3173 }
3174 else if (gMSDC_Handle->isCachedBuf)
3175 {
3176 //clear cache
3177 gMSDC_Handle->trans_count=(gMSDC_Handle->total_count > MSDC_DMA_BURSTLEN_LIMIT) ? (MSDC_DMA_BURSTLEN_LIMIT) : gMSDC_Handle->total_count;
3178 clean_and_invalidate_dcache(CPU_CACHE_LINE_ALIGN_ADDR((kal_uint32)gMSDC_Handle->buf_addr),CPU_CACHE_LINE_ALIGN_LEN((kal_uint32)gMSDC_Handle->buf_addr,gMSDC_Handle->trans_count));
3179 Data_Mem_Barrier();
3180 }
3181 else
3182 #endif
3183 {
3184 gMSDC_Handle->trans_count=(gMSDC_Handle->total_count > MSDC_DMA_BURSTLEN_LIMIT) ? (MSDC_DMA_BURSTLEN_LIMIT) : gMSDC_Handle->total_count;
3185 }
3186 /*configure DMA*/
3187 MSDC_ConfigDMA(adrs,gMSDC_Handle->trans_count,NULL,(gMSDC_Handle->total_count==gMSDC_Handle->trans_count));
3188 }
3189
3190}
3191#if !defined(MSDC_START_DMA_IN_CALLBACK)
3192kal_uint32 MSDC_DMATransferFinal(kal_bool isWrite,kal_bool isLinkListBuf)
3193{
3194 kal_uint32 status;
3195 while(1)
3196 {
3197 /*start DMA*/
3198 MSDC_StartDMA();
3199 /*wait DMA finish*/
3200 status=MSDC_WaitDMADone();
3201 if (status!=NO_ERROR)
3202 {
3203 MSDC_ERR("[MSDC][%s %d]INTS<%x>\r\n",__FUNCTION__,__LINE__,gMSDC_Handle->msdc_int);
3204 goto done;
3205 }
3206 if (isLinkListBuf)
3207 {
3208 MSDC_DEBUG("[MSDC]link list DMA finish\r\n");
3209 break;
3210 }
3211 else
3212 {
3213 /*copy RX data when use cached buffer*/
3214 #ifdef MSDC_CACHED_SUPPORT
3215 if (gMSDC_Handle->isCachedBuf)
3216 {
3217 /*if (!isWrite)
3218 {
3219 kal_mem_cpy((void *)gMSDC_Handle->buf_addr,(void *)msdc_uncachedBuf,gMSDC_Handle->trans_count);
3220 }*/
3221 //invalidate_dcache((gMSDC_Handle->buf_addr&~CPU_CACHE_LINE_SIZE_MASK),(gMSDC_Handle->trans_count+CPU_CACHE_LINE_SIZE_MASK)&~CPU_CACHE_LINE_SIZE_MASK);
3222 }
3223 #endif
3224 /*check need do further transfer or not */
3225 gMSDC_Handle->total_count-=gMSDC_Handle->trans_count;
3226 if (gMSDC_Handle->total_count==0)
3227 {
3228 gMSDC_Handle->error=NO_ERROR;
3229 goto done;
3230 }
3231 gMSDC_Handle->buf_addr+=gMSDC_Handle->trans_count;
3232 MSDC_DMATransferFirst( isWrite,isLinkListBuf);
3233 }
3234 }
3235done:
3236
3237 return status;
3238}
3239#endif //!defined(MSDC_START_DMA_IN_CALLBACK)
3240
3241#endif // DMA
3242
3243void* GetMsdcHandle(kal_uint8 id)
3244{
3245 return (void*)&MSDC_Blk[id];
3246}
3247
3248#ifdef R1B_INTERRUPT_MODE
3249static void MSDC_R1B_Init()
3250{
3251
3252}
3253#endif
3254
3255// ===========================================================
3256// MSDC common lock
3257// ===========================================================
3258
3259#if !defined(__FUE__) && !defined(__UBL__)
3260
3261void init_MSDC_lock(PMSDC_LOCK_TAG lock, const kal_char *str)
3262{
3263 if (lock->mtd_mutex == NULL)
3264 {
3265 strcpy((char *)lock->name, str);
3266 lock->mtd_mutex = kal_create_mutex((kal_char *)lock->name);
3267 lock->lock_count = 0;
3268 lock->owner_id = NULL;
3269 }
3270}
3271
3272static kal_uint8 msdc_lock_user = 0;
3273
3274void get_MSDC_lock(PMSDC_LOCK_TAG lock)
3275{
3276 if (msdc_lock_user > 0)
3277 ;//ASSERT(0); // init debugging purpose
3278 else
3279 msdc_lock_user ++;
3280
3281 if ( kal_query_systemInit() || INT_QueryExceptionStatus() )
3282 return;
3283
3284 if (kal_if_hisr() == KAL_TRUE || kal_if_lisr() == KAL_TRUE)
3285 {
3286 kal_uint32 retaddr0 = 0;
3287 GET_RETURN_ADDRESS(retaddr0);
3288 EXT_ASSERT(0, retaddr0, 0, 0);
3289 }
3290
3291 if ( kal_get_current_task() == lock->owner_id )
3292 {
3293 force_ASSERT(0 != lock->lock_count, lock->lock_count, (kal_uint32)lock->owner_id, (kal_uint32)lock->mtd_mutex);
3294 lock->lock_count++;
3295 }
3296 else
3297 {
3298 if (lock->mtd_mutex == NULL)
3299 {
3300 init_MSDC_lock(lock, (const kal_char *)lock->name);
3301 }
3302
3303 kal_take_mutex(lock->mtd_mutex);
3304 // lock->owner_id = kal_get_task_self_id();
3305 lock->owner_id = kal_get_current_task();
3306 lock->lock_count++;
3307 }
3308}
3309
3310void free_MSDC_lock(PMSDC_LOCK_TAG lock)
3311{
3312 if (msdc_lock_user != 1)
3313 ;//ASSERT(0); // init debugging purpose
3314 else
3315 msdc_lock_user --;
3316
3317 if ( kal_query_systemInit() || INT_QueryExceptionStatus() )
3318 return;
3319
3320 if ( kal_get_current_task() == lock->owner_id )
3321 {
3322 force_ASSERT(lock->lock_count > 0, lock->lock_count, (kal_uint32)lock->owner_id, (kal_uint32)lock->mtd_mutex);
3323 lock->lock_count--;
3324
3325 if (0 == lock->lock_count)
3326 {
3327 lock->owner_id = NULL;
3328
3329 if (lock->mtd_mutex != NULL)
3330 kal_give_mutex(lock->mtd_mutex);
3331 }
3332 }
3333 else
3334 {
3335 force_ASSERT(0, (kal_uint32)lock->owner_id, (kal_uint32)kal_get_current_task(), (kal_uint32)lock->mtd_mutex);
3336 }
3337}
3338
3339#else /* __FUE__, __UBL__ */
3340
3341//#define init_MSDC_lock(x)
3342
3343//#define get_MSDC_lock(x)
3344
3345//#define free_MSDC_lock(x)
3346
3347#endif /* !defined(__FUE__) && !defined(__UBL__) */
3348
3349#ifdef _MSDC_INT_
3350
3351#ifdef USE_INT26_CARD_DETECTION
3352void MSDC_CardDetect_LISR(void)
3353{
3354
3355}
3356#endif //USE_INT26_CARD_DETECTION
3357
3358
3359#ifdef DRV_LSD
3360kal_uint32 MSDC_CARD_INSERT_COUNTER, MSDC_CARD_REMOVE_COUNTER;
3361kal_uint32 notifiedFMT;//this variable is to sync the state, since we only allow FMT get disk infor to be the first operation that access SD
3362
3363
3364void MSDC_LSD_HISR(void)
3365{
3366
3367
3368}
3369
3370void MSDC_unsealMountOperation(void)
3371{
3372 /*notifiedFMT may be modified by FMT and MMI tasks, but it is no need to protect this, any task that preempt FMT just get mount fail*/
3373 if (1 == notifiedFMT) /*FMT may call this function no matter card exits or not*/
3374 {
3375 notifiedFMT = 2;
3376 }
3377
3378}
3379#endif
3380
3381#if !defined(_MSDC_INTERNAL_CD_INT_PIN_)
3382void MSDC_CD_Entry()
3383{
3384 /* Reverse the polarity */
3385 cardDetectionEINTPolarity = !cardDetectionEINTPolarity;
3386 EINT_Set_Polarity(MSDC_EINT_NUM, cardDetectionEINTPolarity);
3387
3388 gMSDC_Handle->mIsChanged=KAL_TRUE;
3389
3390 /*memory card insertion\removal */
3391 if (!cardDetectionEINTPolarity)
3392 {
3393 gMSDC_Handle->mIsPresent=KAL_FALSE;
3394 gMSDC_Handle->mIsInitialized=KAL_FALSE;
3395 #ifdef MSDC_MUST_RECORD_PLUGOUT
3396 if (KAL_FALSE == gMSDC_Handle->mIsPresent)
3397 gMSDC_Handle->MSDC_everPlugOut = KAL_TRUE;
3398 #endif//MSDC_MUST_RECORD_PLUGOUT
3399
3400 MSDC_CRIT("[MSDC]Card Remove(EINT)\r\n");
3401 MSDC_DeInit();
3402 }
3403 else
3404 {
3405 gMSDC_Handle->mIsPresent=KAL_TRUE;
3406 gMSDC_Handle->mIsInitialized=KAL_FALSE;
3407
3408 MSDC_CRIT("[MSDC]Card Insert(EINT)\r\n");
3409 MSDC_Probe();
3410 }
3411}
3412#endif
3413
3414/*************************************************************************
3415* FUNCTION
3416* MSDC_INT_Init
3417*
3418* DESCRIPTION
3419* Initialize MSDC's interrupt
3420*
3421* PARAMETERS
3422*
3423* RETURNS
3424*
3425* GLOBALS AFFECTED
3426*
3427*
3428*************************************************************************/
3429void MSDC_INT_Init(void)
3430{
3431 /*create events group*/
3432 gMSDC_Handle->MSDC_Events=kal_create_event_group("MSDC Event");
3433 /*register HISR*/
3434 DRV_Register_HISR(DRV_MSDC_HISR_ID,MSDC_HISR_Entry);
3435 /*register LISR*/
3436 IRQ_Register_LISR(MD_IRQID_MSDC0,MSDC_LISR,"MSDC ISR");
3437 IRQSensitivity(MD_IRQID_MSDC0,LEVEL_SENSITIVE);
3438 IRQUnmask(MD_IRQID_MSDC0);
3439 /*clear IRQ */
3440 MSDC_WriteReg32(MSDC_INT,MSDC_Reg32(MSDC_INT));
3441
3442 /*register IRQ for card detect*/
3443 /*enable card detect interrupt*/
3444#if defined(_MSDC_INTERNAL_CD_INT_PIN_)
3445 /*enable card detect*/
3446 MSDC_SET_FIELD(MSDC_PS, MSDC_PS_CDEN, 1);
3447 MSDC_SET_FIELD(MSDC_INTEN, MSDC_INTEN_CDSC, 1);
3448#else
3449
3450 /* Polarity setting, default triggered by low level */
3451 cardDetectionEINTPolarity = EINT_DefaultPolarity;
3452
3453 /* SW debounce time is 300ms */
3454 MSDC_debounceTime=30;
3455
3456 EINT_Mask(MSDC_EINT_NUM); //need check the MSDC_EINT_NO ,unused current time
3457
3458 /* Level trigger */
3459 EINT_Set_Sensitivity(MSDC_EINT_NUM, KAL_FALSE);
3460
3461 EINT_Registration(MSDC_EINT_NUM,KAL_TRUE,cardDetectionEINTPolarity,MSDC_CD_Entry,KAL_TRUE);
3462 EINT_SW_Debounce_Modify(MSDC_EINT_NUM,MSDC_debounceTime);
3463 EINT_UnMask(MSDC_EINT_NUM);
3464
3465#endif
3466}
3467void MSDC_LISR(void)
3468{
3469 /*Mask IRQ*/
3470 IRQMask(MD_IRQID_MSDC0);
3471 /*save IRQ information*/
3472 gMSDC_Handle->msdc_int=MSDC_Reg32(MSDC_INT);
3473 /*call hisr*/
3474 drv_active_hisr(DRV_MSDC_HISR_ID);
3475
3476}
3477
3478void MSDC_DatIrqHandle(kal_uint32 intsts)
3479{
3480 if (intsts & MSDC_INT_XFER_COMPL){
3481 gMSDC_Handle->error=NO_ERROR;
3482 kal_set_eg_events(gMSDC_Handle->MSDC_Events,EVENT_XFER_DONE,KAL_OR);
3483 }
3484 else if (intsts & MSDC_INT_DXFER_DONE)
3485 {
3486
3487 gMSDC_Handle->error=NO_ERROR;
3488 kal_set_eg_events(gMSDC_Handle->MSDC_Events,EVENT_DMA_DONE,KAL_OR);
3489 }
3490 else
3491 {
3492
3493 /*mean some error */
3494 if (intsts & MSDC_INT_DATCRCERR)
3495 {
3496 gMSDC_Handle->error=ERR_DAT_CRCERR;
3497 MSDC_ERR("[MSDC][%s %d]CMD%d DMA DAT CRCERR!\r\n",__FUNCTION__,
3498 __LINE__, gMSDC_Handle->cmd & 0x3F);
3499 }
3500 else if (intsts & MSDC_INT_DATTMO)
3501 {
3502 gMSDC_Handle->error=ERR_DAT_TIMEOUT;
3503 MSDC_ERR("[MSDC][%s %d]CMD%d DMA DAT TMO!\r\n",__FUNCTION__,
3504 __LINE__, gMSDC_Handle->cmd & 0x3F);
3505 } else if (intsts & MSDC_INT_BD_CS_ERR) {
3506
3507 gMSDC_Handle->error = ERR_DAT_TIMEOUT;
3508 MSDC_ERR("[MSDC][%s %d]CMD%d DMA BD checksum ERR!\r\n",__FUNCTION__,
3509 __LINE__, gMSDC_Handle->cmd & 0x3F);
3510 } else if (intsts & MSDC_INT_GPD_CS_ERR) {
3511
3512 gMSDC_Handle->error = ERR_DAT_TIMEOUT;
3513 MSDC_ERR("[MSDC][%s %d]CMD%d DMA GPD checksum ERR!\r\n",__FUNCTION__,
3514 __LINE__, gMSDC_Handle->cmd & 0x3F);
3515 }
3516
3517 /*for poll mode exit*/
3518 gMSDC_Handle->abort=1;
3519
3520 if (gMSDC_Handle->dma_xfer)
3521 {
3522 kal_set_eg_events(gMSDC_Handle->MSDC_Events,EVENT_XFER_DONE,KAL_OR);
3523 }
3524 }
3525}
3526void MSDC_CmdIrqHandle(kal_uint32 intsts)
3527{
3528 if ((intsts&MSDC_INT_CMDRDY)||(intsts&MSDC_INT_ACMDRDY)||(intsts&MSDC_INT_ACMD19_DONE))
3529 {
3530 gMSDC_Handle->error=NO_ERROR;
3531 }
3532 else if ((intsts&MSDC_INT_RSPCRCERR)||(intsts&MSDC_INT_ACMDCRCERR))
3533 {
3534 gMSDC_Handle->error=ERR_CMD_RSPCRCERR;
3535 }
3536 else if ((intsts&MSDC_INT_ACMDTMO)||(intsts&MSDC_INT_CMDTMO))
3537 {
3538 gMSDC_Handle->error=ERR_CMD_TIMEOUT;
3539 }
3540 kal_set_eg_events(gMSDC_Handle->MSDC_Events,EVENT_CMD_DONE,KAL_OR);
3541}
3542
3543void MSDC_CardDetectHandle(kal_uint32 intsts)
3544{
3545#if defined(_MSDC_INTERNAL_CD_INT_PIN_)
3546
3547
3548 gMSDC_Handle->mIsChanged=KAL_TRUE;
3549
3550 /*memory card insertion\removal */
3551 if (MSDC_Reg32(MSDC_PS)&MSDC_PS_CDSTS)
3552 {
3553 /*Card detection pin is logic high*/
3554 gMSDC_Handle->mIsPresent=KAL_FALSE;
3555 gMSDC_Handle->mIsInitialized=KAL_FALSE;
3556 #ifdef MSDC_MUST_RECORD_PLUGOUT
3557 if (KAL_FALSE == gMSDC_Handle->mIsPresent)
3558 gMSDC_Handle->MSDC_everPlugOut = KAL_TRUE;
3559 #endif//MSDC_MUST_RECORD_PLUGOUT
3560
3561 MSDC_CRIT("[MSDC]Card Remove\r\n");
3562 MSDC_DeInit();
3563
3564 }
3565 else
3566 {
3567 /*Card detection pin is logic low*/
3568 gMSDC_Handle->mIsPresent=KAL_TRUE;
3569 gMSDC_Handle->mIsInitialized=KAL_FALSE;
3570
3571 MSDC_CRIT("[MSDC]Card Insert\r\n");
3572 MSDC_Probe();
3573 }
3574
3575#endif
3576}
3577
3578/*************************************************************************
3579* FUNCTION
3580* MSDC_HISR_Entry
3581*
3582* DESCRIPTION
3583* Set corresponding enevt and wake up waiting task.
3584*
3585* PARAMETERS
3586*
3587* RETURNS
3588*
3589* GLOBALS AFFECTED
3590*
3591*
3592*************************************************************************/
3593void MSDC_HISR_Entry(void)
3594{
3595 kal_uint32 cmdsts =MSDC_INT_CMDRDY|MSDC_INT_CMDTMO|MSDC_INT_RSPCRCERR;
3596 kal_uint32 acmdsts =MSDC_INT_ACMDRDY|MSDC_INT_ACMDTMO|MSDC_INT_ACMDCRCERR|MSDC_INT_ACMD19_DONE;
3597 kal_uint32 datsts =MSDC_INT_XFER_COMPL | MSDC_INT_DXFER_DONE |
3598 MSDC_INT_DATCRCERR | MSDC_INT_DATTMO |
3599 MSDC_INT_BD_CS_ERR | MSDC_INT_GPD_CS_ERR;
3600
3601 kal_uint32 intsts_pure;
3602 kal_uint32 inten, intsts;
3603
3604 /*Mask IRQ*/
3605 IRQMask(MD_IRQID_MSDC0);
3606 /*save IRQ information*/
3607 gMSDC_Handle->msdc_int=MSDC_Reg32(MSDC_INT);
3608
3609 intsts_pure=gMSDC_Handle->msdc_int;
3610 inten=MSDC_Reg32(MSDC_INTEN);
3611
3612 intsts=intsts_pure&inten;
3613 /*clear all interrupt*/
3614 MSDC_WriteReg32(MSDC_INT,intsts);
3615 /*data transfer interrupt*/
3616 if (intsts&datsts)
3617 {
3618 MSDC_DatIrqHandle(intsts);
3619 }
3620 /*command interrupt*/
3621 if (intsts&(cmdsts|acmdsts))
3622 {
3623 MSDC_CmdIrqHandle(intsts);
3624 }
3625 /*card detect interrupt*/
3626 if(intsts & MSDC_INT_CDSC)
3627 {
3628 MSDC_CardDetectHandle(intsts);
3629 }
3630 /*mmc interrupt*/
3631
3632 /*unmask irq*/
3633 IRQUnmask(MD_IRQID_MSDC0);
3634}
3635
3636/*************************************************************************
3637* FUNCTION
3638* MSDC_DMA_Callback
3639*
3640* DESCRIPTION
3641* Call back while DMA has done the data transfer.
3642*
3643* PARAMETERS
3644*
3645* RETURNS
3646*
3647* GLOBALS AFFECTED
3648*
3649*
3650*************************************************************************/
3651void MSDC_DMA_Callback(void)
3652{
3653
3654}
3655
3656#ifdef DRV_MSDC_SHARE_BY_SWITCH
3657void MSDC_changeSwContext(sd_select_enum sel)
3658{
3659 gMSDC_Handle = &MSDC_Blk[sel];
3660 gSD = &gSD_blk[sel];
3661}
3662
3663/*
3664 this function do not consider race condition issue, caller should make sure this function is called without risk
3665 currently, this function is called in sdio_drv.c and sd_drv.c
3666*/
3667void MSDC_backupHwSetting()
3668{
3669 /*backup MSDC_CFG, MSDC_IOCON, SDC_CFG*/
3670 gMSDC_Handle->setting_MSDC_CFG = MSDC_Reg32(MSDC_CFG);
3671 gMSDC_Handle->setting_MSDC_IOCON = MSDC_Reg32(MSDC_IOCON);
3672 gMSDC_Handle->setting_SDC_CFG = MSDC_Reg32(SDC_CFG);
3673}
3674
3675void MSDC_retreiveHwSetting()
3676{
3677 MSDC_WriteReg32(MSDC_CFG, gMSDC_Handle->setting_MSDC_CFG);
3678 MSDC_WriteReg32(MSDC_IOCON, gMSDC_Handle->setting_MSDC_IOCON);
3679 MSDC_WriteReg32(SDC_CFG, gMSDC_Handle->setting_SDC_CFG);
3680}
3681#endif
3682
3683#if defined(__SIM_PLUS__) || defined(DRV_MSDC_DUAL_TCARD_BY_SWITCH)
3684void MSDC_Switch_Card(sd_select_enum sel)
3685{
3686
3687}
3688#endif
3689
3690#endif //end of MSDC_INT
3691
3692
3693void MSDC_turnOnVMC(kal_bool turnOnLdo)
3694{
3695
3696}
3697
3698#if defined(MSDC_TRACE_LEVEL3)
3699void MSDC_add_dbg_msg( msdc_dbg_Event event, kal_uint32 data1, kal_uint32 data2)
3700{
3701
3702}
3703#endif
3704
3705#ifdef DRV_MSDC_SD_SDIO_SHARE_BY_SWITCH
3706void MSDC_Switch_SDIO(sd_select_enum sel)
3707{
3708
3709
3710}
3711#endif
3712
3713#ifdef DRV_MSDC_SD_SDIO_SHARE_BY_SWITCH
3714
3715/*following should be the value defined in custom files*/
3716#define MSDC_SWITCH_2_SD 1
3717#define MSDC_SWITCH_2_SDIO 0
3718#define MSDC_SWITCH_GPIO 20
3719typedef enum
3720{
3721 MSDC_SWITCH_DIRECTION_SD,
3722 MSDC_SWITCH_DIRECTION_SDIO
3723} MSDC_SWITCH_DIRECTION;
3724
3725
3726void MSDC_Switch_init()
3727{
3728
3729}
3730
3731/*
3732 direction:
3733 0 : cmmb
3734 1 : sd card
3735*/
3736
3737void MSDC_Switch(sd_select_enum direction)
3738{
3739
3740}
3741#endif
3742
3743
3744#else
3745#ifdef DRV_LSD
3746void MSDC_LSD_HISR(void)
3747{
3748}
3749#endif
3750#endif // end of (defined(__MSDC_MS__) || defined(__MSDC_SD_MMC__))
3751#endif//!defined(__UBL__) || defined(__CARD_DOWNLOAD__) || defined(__EMMC_BOOTING__)
3752
3753#else //DRV_MSDC_OFF
3754#include "kal_public_api.h" //MSBB change #include "kal_release.h"
3755#include "msdc_def.h"
3756
3757/*
3758#include "kal_public_api.h" //MSBB change #include "kal_release.h"
3759//RHR REMOVE
3760#include "syscomp_config.h"
3761#include "task_config.h"
3762#include "stacklib.h"
3763#include "eint.h"
3764#include "fat_fs.h"
3765*/
3766//RHR
3767#include "kal_public_defs.h" //MSBB change #include "stack_common.h"
3768#include "kal_public_defs.h" //MSBB change #include "stack_msgs.h"
3769#include "kal_public_api.h" //MSBB change #include "app_ltlcom.h"
3770#include "intrCtrl.h"
3771#include "reg_base.h"
3772#include "drvpdn.h"
3773//#include "gpt_sw.h"
3774#include "drv_comm.h"
3775#include "drv_hisr.h"
3776#include "msdc_def.h"
3777#include "dcl.h"
3778
3779/* Debug log */
3780kal_uint32 MSDC_DebugLevel;
3781
3782#define LDO_VMC 0
3783#define LDO_VMCH 1
3784#define LDO_VIO18_PMU 2
3785
3786static kal_uint32 g_msdc0_io = PMU_VOLT_03_300000_V;
3787static kal_uint32 g_msdc0_card = PMU_VOLT_03_300000_V;
3788
3789static kal_uint32 hwPowerOn(kal_uint32 powerID, PMU_VOLTAGE_ENUM powerVolt)
3790{
3791 PMU_CTRL_LDO_BUCK_SET_EN pmu_en;
3792 PMU_CTRL_LDO_BUCK_SET_VOLTAGE pmu_volsel;
3793 DCL_HANDLE handle;
3794
3795 /* Open PMU handle */
3796 handle = DclPMU_Open(DCL_PMU, FLAGS_NONE);
3797
3798 switch(powerID) {
3799 case LDO_VMC:
3800 /* Set enable control */
3801 pmu_en.mod = VMC;
3802 pmu_en.enable = 1;
3803
3804 /* Set voltage */
3805 pmu_volsel.mod = VMC;
3806 pmu_volsel.voltage = powerVolt;
3807
3808 DclPMU_Control(handle, LDO_BUCK_SET_VOLTAGE, (DCL_CTRL_DATA_T *)&pmu_volsel);
3809 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
3810
3811 break;
3812
3813 case LDO_VMCH:
3814 /* Set enable control */
3815 pmu_en.mod = VMCH;
3816 pmu_en.enable = 1;
3817
3818 /* Set voltage */
3819 pmu_volsel.mod = VMCH;
3820 pmu_volsel.voltage = powerVolt;
3821
3822 DclPMU_Control(handle, LDO_BUCK_SET_VOLTAGE, (DCL_CTRL_DATA_T *)&pmu_volsel);
3823 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
3824
3825 break;
3826
3827 default:
3828 break;
3829 }
3830
3831 /* Close PMU handle */
3832 DclPMU_Close(handle);
3833
3834 return 1;
3835}
3836
3837static kal_uint32 hwPowerDown(kal_uint32 powerID)
3838{
3839 PMU_CTRL_LDO_BUCK_SET_EN pmu_en;
3840 DCL_HANDLE handle;
3841
3842 /* Open PMU handle */
3843 handle = DclPMU_Open(DCL_PMU, FLAGS_NONE);
3844
3845 switch(powerID) {
3846 case LDO_VMC:
3847 /* Set enable control */
3848 pmu_en.mod = VMC;
3849 pmu_en.enable = 0;
3850
3851 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
3852 break;
3853
3854 case LDO_VMCH:
3855 /* Set enable control */
3856 pmu_en.mod = VMCH;
3857 pmu_en.enable = 0;
3858
3859 DclPMU_Control(handle, LDO_BUCK_SET_EN, (DCL_CTRL_DATA_T *)&pmu_en);
3860
3861 break;
3862
3863 default:
3864 break;
3865 }
3866
3867 /* Close PMU handle */
3868 DclPMU_Close(handle);
3869
3870 return 1;
3871}
3872
3873static kal_uint32 msdc_ldo_power(kal_uint32 on, kal_uint8 powerId,
3874 PMU_VOLTAGE_ENUM powerVolt, kal_uint32 *status)
3875{
3876 if (on) { // want to power on
3877 if (*status == 0) { // can power on
3878 hwPowerOn(powerId, powerVolt);
3879
3880 *status = powerVolt;
3881 } else if (*status == powerVolt) {
3882 } else { // for sd3.0 later
3883
3884 hwPowerDown(powerId);
3885 hwPowerOn(powerId, powerVolt);
3886
3887 *status = powerVolt;
3888 }
3889 } else { // want to power off
3890 if (*status != 0) { // has been powerred on
3891
3892 hwPowerDown(powerId);
3893
3894 *status = 0;
3895 } else {
3896 }
3897 }
3898
3899 return 0;
3900}
3901
3902kal_bool MSDC_SetVddPower(kal_bool on, kal_uint32 volt)
3903{
3904 kal_bool ret =KAL_TRUE;
3905
3906 if (volt == 3300)
3907 {
3908 msdc_ldo_power(on, LDO_VMCH, PMU_VOLT_03_300000_V, &g_msdc0_card);
3909 }
3910 else
3911 {
3912 ret = KAL_FALSE;
3913 }
3914
3915 return ret;
3916}
3917
3918kal_bool MSDC_SetSignalPower(kal_bool on,kal_uint32 volt)
3919{
3920 kal_bool ret =KAL_TRUE;
3921 if (volt == 3300)
3922 {
3923 msdc_ldo_power(on, LDO_VMC, PMU_VOLT_03_300000_V, &g_msdc0_io);
3924 }
3925 else if (volt ==1800)
3926 {
3927 msdc_ldo_power(on, LDO_VMC, PMU_VOLT_01_800000_V, &g_msdc0_io);
3928 }
3929 else
3930 {
3931 ret = KAL_FALSE;
3932 }
3933
3934 return ret;
3935}
3936
3937/*here are dummy API*/
3938void MSDC_Initialize(void)
3939{
3940 /* INIT MSDC debug flag */
3941 MSDC_SetDebugLevel(K_WARNIN);
3942
3943 /* Shut card power and signal power */
3944 MSDC_SetVddPower(KAL_FALSE, 3300);
3945 MSDC_SetSignalPower(KAL_FALSE, 3300);
3946}
3947
3948void MSDC_PDNControl(kal_bool ON) {}
3949int MSDC_GetCardStatus(void * DriveData, int AckType) {return 0;}
3950//kal_bool MSDC_GetMediaChanged(void * id) {}
3951kal_bool MSDC_GetMediaChanged(sd_select_enum id) {return 0;}
3952MSDC_HANDLE MSDC_Blk[SD_NUM];
3953MSDC_HANDLE *gMSDC_Handle = &(MSDC_Blk[0]);
3954//kal_bool MSDC_everPlugOut;
3955
3956#endif //DRV_MSDC_OFF