S5PC100 初始化DRAM

1. //=============================================================================   
2. // File Name : InitSystem.c   
3. // Function  : Initialize DRAM, Clock and LCD setting value.   
4. //   
5. //   
6. //=============================================================================   
7.   
8.   
9. #include    
10. #include    
11. #include    
12.   
13. #include "soc_cfg.h"   
14. #include "S5PC100_dramcon.h"   
15. #include "S5PC100_base_regs.h"   
16. #include "S5PC100_Syscon.h"   
17. #include "S5PC100_regs_for_BL.h"   
18.   
19. #ifdef SMDKC100_POP_NONE   
20. #define SMDKC100_POP    POP_NONE   
21. #elif defined(SMDKC100_POP_A)   
22. #define SMDKC100_POP    POP_A   
23. #elif defined(SMDKC100_POP_D)   
24. #define SMDKC100_POP    POP_D   
25. #else   
26. #define SMDKC100_POP    POP_NONE    // Invalid POP type, set with POP_NONE.   
27. #endif   
28.   
29. #define LPCON_MAXPOWER            0   
30. #define LPCON_MAXPERFORMANCE      1   
31. #define LPCON_BALANCE             2   
32.   
33. //------------------------------------------------------------------------------   
34. // Define LPCON level   
35. //   
36. // LPCON_MAXPOWER                    Maximum power saving state   
37. // LPCON_MAXPERFORMANCE     Maximum performance state   
38. // LPCON_BALANCE                     Balanced state   
39.   
40. #define LPCON_LEVEL             LPCON_MAXPERFORMANCE  // We only use max performance   
41.   
42. void InitClockCONforBL(void);   
43. void InitClockCONforOS(void);   
44. void InitLPCON(void);   
45.   
46. void InitClockCONforBL(void)   
47. {   
48.     unsigned int ReadVal;   
49.     
50.     // SetClockDiviReadValer   
51.  //SetReg32(rCLK_DIV1, 0x00011110);   
52.     SetReg32(rCLK_DIV1, ((HCLK12PCLK1_RATIO-1)<
53.                         ((MPLL2HCLK1_RATIO-1)<
54.                         (0<//< To make External Camera Clock 24Mhz, this must be 0   
55.                         (0<//< To increase FIMC,LCD clock to 264Mhz, this must be 0   
56.                         (0<
57.             // bit[18:16] - PCLKD1   
58.             // bit[14:12] - HCLKD1   
59.             // bit[8]     - MPLL2   
60.             // bit[5:4]   - MPLL   
61.   
62.     SetReg32(rCLK_DIV2, ((HCLK12PCLK1_RATIO-1)<<0));   
63.             // bit[3:0]   - UART   
64.     //SetReg32(rCLK_DIV0, 0x00011301)   
65.  SetReg32(rCLK_DIV0, (1<<16)|((HCLK02PCLK0_RATIO_BL-1)<<12)|((ARM2HCLK0_RATIO_BL-1)<<8)|(0<<4)|((APLL2ARM_RATIO-1)<<0));   
66.             // bit[28:24] - CAM_DIV :0   
67.             // bit[21:20] - ONENAND :0   
68.             // bit[18:16] - SECSS   
69.             // bit[14:12] - PCLKD0   
70.             // bit[10:8]  - HCLKD0   
71.             // bit[6:4]   - ARMCLK   
72.             // bit[0]     - APLL   
73.   
74.     // SetLockTime & StartPLL   
75.     SetReg32(rAPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
76.  //SetReg32(rAPLL_CON, 0x81BC0400);   
77.     SetReg32(rAPLL_CON, (1u<<31)|(APLL_MDIV_BL<<16)|(APLL_PDIV_BL<<8)|(APLL_SDIV_BL<<0));   
78.   
79.     SetReg32(rMPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
80.  //SetReg32(rMPLL_CON, 0x80850302);   
81.     SetReg32(rMPLL_CON, (1u<<31)|(MPLL_MDIV<<16)|(MPLL_PDIV<<8)|(MPLL_SDIV<<0));   
82.   
83.     SetReg32(rEPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
84.  SetReg32(rEPLL_CON, (1u<<31)|(EPLL_MDIV<<16)|(EPLL_PDIV<<8)|(EPLL_SDIV<<0));   
85.   
86.     GetReg32(rCLK_SRC0, ReadVal);   
87.     //SetReg32(rCLK_SRC0, 0x00000011);   
88.  SetReg32(rCLK_SRC0, (ReadVal&~(1<<20))|(0<<20)); // HPLL source clock = HREF_FIN27M   
89.   
90.     SetReg32(rHPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
91.     SetReg32(rHPLL_CON, (1u<<31)|(HPLL_MDIV<<16)|(HPLL_PDIV<<8)|(HPLL_SDIV<<0));   
92.   
93.     // SetSourceClock   
94.     GetReg32(rCLK_SRC0, ReadVal);   
95.     SetReg32(rCLK_SRC0, (ReadVal&~(0x11111))|(0<<16)|(1<<12)|(1<<8)|(1<<4)|(1<<0));   
96.             // bit[16] - muxAM (0: MOUTMPLL, 1: DOUTAPLL2)   
97.             // bit[12] - muxHPLL (0: CLK27M, 1: FOUTHPLL)   
98.             // bit[8]  - muxEPLL (0: FINEPLL, 1: FOUTEPLL)   
99.             // bit[4]  - muxMPLL (0: FINMPLL, 1: FOUTMPLL)   
100.             // bit[0]  - muxAPLL (0: FINAPLL, 1: FOUTAPLL)   
101.     SetReg32(rCLK_SRC1, (1<<24)|(1<<0));   
102.             // bit[24] - muxCLK48M (0: XUSBXTI, 1: OTG_PHY)   
103.             // bit[0]  - muxUART (0: MOUTEPLL, 1: DOUTMPLL)   
104.   
105.     // Internal clock can be monitored through XCLKOUT PAD.   
106.     // * SMDKC100 Single(none POP): TP80 on CPU B'd(EVM)   
107.     // * SMDKC100 POP A type      : TP73 on CPU B'd(EVM)   
108.     SetReg32(rCLK_OUT, (0<<20)|(6<<12));   
109.             // bit[23:20] - DiviReadValer value   
110.             // bit[16:12] - Clock out type (6: PCLKD1)   
111.   
112. }   
113.   
114. void InitClockCONforOS(void)   
115. {   
116.     unsigned int ReadVal;   
117.   
118.     // SetClockDiviReadValer   
119.     SetReg32(rCLK_DIV1, ((HCLK12PCLK1_RATIO-1)<
120.                         ((MPLL2HCLK1_RATIO-1)<
121.                         (0<//< To make External Camera Clock 24Mhz, this must be 0   
122.                         (0<//< To increase FIMC,LCD clock to 264Mhz, this must be 0   
123.                         (0<
124.             // bit[18:16] - PCLKD1   
125.             // bit[14:12] - HCLKD1   
126.             // bit[8]     - MPLL2   
127.             // bit[5:4]   - MPLL   
128.     SetReg32(rCLK_DIV2, ((HCLK12PCLK1_RATIO-1)<<0));   
129.             // bit[3:0]   - UART   
130.   
131.     // SetLockTime & StartPLL   
132.     SetReg32(rAPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
133.     SetReg32(rAPLL_CON, (1u<<31)|(APLL_MDIV<<16)|(APLL_PDIV<<8)|(APLL_SDIV<<0));   
134.   
135.     SetReg32(rCLK_DIV0, (1<<16)|((HCLK02PCLK0_RATIO-1)<<12)|((ARM2HCLK0_RATIO-1)<<8)|(0<<4)|((APLL2ARM_RATIO-1)<<0));   
136.             // bit[28:24] - CAM_DIV :0   
137.             // bit[21:20] - ONENAND :0   
138.             // bit[18:16] - SECSS   
139.             // bit[14:12] - PCLKD0   
140.             // bit[10:8]  - HCLKD0   
141.             // bit[6:4]   - ARMCLK   
142.             // bit[0]     - APLL   
143.   
144.     SetReg32(rMPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
145.     SetReg32(rMPLL_CON, (1u<<31)|(MPLL_MDIV<<16)|(MPLL_PDIV<<8)|(MPLL_SDIV<<0));   
146.   
147.     SetReg32(rEPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
148.     SetReg32(rEPLL_CON, (1u<<31)|(EPLL_MDIV<<16)|(EPLL_PDIV<<8)|(EPLL_SDIV<<0));   
149.   
150.     GetReg32(rCLK_SRC0, ReadVal);   
151.     SetReg32(rCLK_SRC0, (ReadVal&~(1<<20))|(0<<20)); // HPLL source clock = HREF_FIN27M   
152.     SetReg32(rHPLL_LOCK, 0x00000e10); // Lock Time = 300us*12Mhz = 3600(=0xe10)   
153.     SetReg32(rHPLL_CON, (1u<<31)|(HPLL_MDIV<<16)|(HPLL_PDIV<<8)|(HPLL_SDIV<<0));   
154.   
155.     // SetSourceClock   
156.     GetReg32(rCLK_SRC0, ReadVal);   
157.     SetReg32(rCLK_SRC0, (ReadVal&~(0x11111))|(0<<16)|(1<<12)|(1<<8)|(1<<4)|(1<<0));   
158.             // bit[16] - muxAM (0: MOUTMPLL, 1: DOUTAPLL2)   
159.             // bit[12] - muxHPLL (0: CLK27M, 1: FOUTHPLL)   
160.             // bit[8]  - muxEPLL (0: FINEPLL, 1: FOUTEPLL)   
161.             // bit[4]  - muxMPLL (0: FINMPLL, 1: FOUTMPLL)   
162.             // bit[0]  - muxAPLL (0: FINAPLL, 1: FOUTAPLL)   
163.     SetReg32(rCLK_SRC1, (1<<24)|(1<<0));   
164.             // bit[24] - muxCLK48M (0: XUSBXTI, 1: OTG_PHY)   
165.             // bit[0]  - muxUART (0: MOUTEPLL, 1: DOUTMPLL)   
166.   
167.     // Internal clock can be monitored through XCLKOUT PAD.   
168.     // * SMDKC100 Single(none POP): TP80 on CPU B'd   
169.     // * SMDKC100 POP A type      : TP73 on CPU B'd   
170.     SetReg32(rCLK_OUT, (0<<20)|(9<<12));   
171.             // bit[23:20] - DiviReadValer value   
172.             // bit[16:12] - Clock out type (9: ARMCLK_DIV4)   
173.   
174. }   
175.   
176. // We only need to care about performance.   
177.   
178. void InitLPCON()   
179. {   
180.     UINT32 ReadVal;   
181.     UINT32 ReadValStat;   
182. #if INIT_QoS   
183.     volatile unsigned int *rTMP;   
184. #endif   
185.     // ---------------------------------------------------------------   
186.     // 1. Config PHY   
187.     // ---------------------------------------------------------------   
188.     // [ 1. Config PHY ]   
189.   
190. #if  ENABLE_PHY_DLL   // Now, we use ENABLE_PHY_DLL   
191.  SetReg32(rLPCON_PHY_CONTROL0, 0x50101008);   
192.     //SetReg32(rLPCON_PHY_CONTROL0, 0x50<<24|0x10<<16|0x10<<8|0<<4|1<<3|0<<2|0<<1|0<<0);   
193.         // [31:24] DLL force delay   
194.         // [23:16] DLL delay increment   
195.         // [15:8] DLL lock start point   
196.         // [7:5] Should be zero.   
197.         // [4] DLL CRC   
198.         // [3] ctrl_dfdqs   
199.         // [2] ctrl_half   
200.         // [1] ctrl_dll_on   
201.         // [0] ctrl_start   
202.  SetReg32(rLPCON_PHY_CONTROL1, 0xf6<<0);   
203.     //SetReg32(rLPCON_PHY_CONTROL1, 0xf4<<0);   
204.     SetReg32(rLPCON_PHY_CONTROL2, 0<<24|0<<16|0<<8|0<<0);   
205.   
206.     GetReg32(rLPCON_PHY_CONTROL0, ReadVal);   
207.     SetReg32(rLPCON_PHY_CONTROL0, ReadVal|=(1<<1)); // DLL on   
208.     SetReg32(rLPCON_PHY_CONTROL0, ReadVal|=(1<<0)); // DLL start   
209.   
210.     do    
211.  {   
212.         GetReg32(rLPCON_PHY_STATUS0, ReadVal);   
213.     } while ((ReadVal&0x4) != 0x4); // wait until PLL lock.   
214.   
215.     GetReg32(rLPCON_PHY_STATUS0, ReadValStat);   
216.     ReadValStat = (ReadValStat>>6)&0xff; // locked delay   
217.   
218.     GetReg32(rLPCON_PHY_CONTROL0, ReadVal);   
219.     ReadVal &= ~(0xff<<24);   
220.     SetReg32(rLPCON_PHY_CONTROL0, ReadVal|=(ReadValStat<<24)); // force locking value for DLL off   
221.     SetReg32(rLPCON_PHY_CONTROL0, ReadVal&=~(1<<1)); // DLL off   
222. #endif   
223.   
224.     // ---------------------------------------------------------------   
225.     // 2. Config DMC itself   
226.     // ---------------------------------------------------------------   
227.   
228.  SetReg32(rLPCON_CON_CONTROL, 0xFF001010);   
229.     //SetReg32(rLPCON_CON_CONTROL, 0xff<<16|1<<12|0<<10|0<<9|0<<8|0<<7|0<<6|0<<5|1<<4|0<<1|0<<0);   
230.         // [27:16] Default timeout cycles (n aclk cycles)   
231.         // [15:12] Read data fetch cycles (n mclk cycles)   
232.         // [10] DQ swap   
233.         // [9] Command queue status of chip1 (RO)   
234.         // [8] Command queue status of chip0 (RO)   
235.         // [7] PHY driving   
236.         // [6] Read cycle gap for two different chips (0=disable, 1=enable)   
237.         // [5] Auto refresh counter (0=disable, 1=enable)   
238.         // [4] Out of order scheduling (0=disable, 1=enable)   
239.         // [3:1] aclk:mclk (0=1:1, 3=2:1)   
240.         // [0] (0=sync, 1=async)   
241.   
242.  SetReg32(rLPCON_MEM_CONTROL, 0x00212400);   
243.     //SetReg32(rLPCON_MEM_CONTROL, 2<<20|1<<16|2<<12|MEM_TYPE<<8|0<<6|1<<5|1<<4|0<<2|0<<1|0<<0);   
244.         // [22:20] Memory burst length (1=2, 2=4, 3=8, 4=16)   
245.         // [19:16] Number of Memory chips (0=1chip, 1=2chips)   
246.         // [15:12] Width of Memory data bus (1=16bit, 2=32bit)   
247.         // [11:8] Type of Memory (1=LPDDR, 2=LPDDR2, 3=DDR, 4=DDR2)   
248.         // [7:6] Additional latency for PALL   
249.         // [5] Dynamic self refresh (0=disable, 1=enable)   
250.         // [4] Force precharge (1=Auto-precharge)   
251.         // [3:2] Type of dynamic power down   
252.         // [1] Dynamic power down   
253.         // [0] Dynamic clock control   
254. #if (SMDKC100_POP == POP_A)   
255.     SetReg32(rLPCON_MEM_CONFIG0, 0x28<<24|0xf8<<16|0<<12|2<<8|2<<4|2<<0); // OneDRAM   
256.     SetReg32(rLPCON_MEM_CONFIG1, 0x20<<24|0xf8<<16|1<<12|2<<8|2<<4|2<<0); // mDDR   
257. #elif (SMDKC100_POP == POP_D)   
258.     SetReg32(rLPCON_MEM_CONFIG0, 0x30<<24|0xf0<<16|1<<12|3<<8|1<<4|2<<0); // mDDR 128MB 13bit, COL:10bit, 4banks   
259.     SetReg32(rLPCON_MEM_CONFIG1, 0x20<<24|0xf0<<16|1<<12|3<<8|2<<4|2<<0); // mDDR 256MB 14bit, COL:10bit, 4banks   
260. #elif (SMDKC100_POP == POP_NONE)   
261.  SetReg32(rLPCON_MEM_CONFIG0, 0x20F00313);   
262.     //SetReg32(rLPCON_MEM_CONFIG0, 0x20<<24|0xf0<<16|1<<12|3<<8|1<<4|3<<0);   
263.  SetReg32(rLPCON_MEM_CONFIG1, 0x40F00313);   
264.     //SetReg32(rLPCON_MEM_CONFIG1, 0x40<<24|0xf0<<16|1<<12|3<<8|1<<4|3<<0);   
265. #else   
266. #error  // Invalid POP type   
267. #endif   
268.         // [31:24] AXI base address   
269.         // [23:16] AXI base address mask   
270.         // [15:12] Address mapping methid (0=bank/row/col, 1=row/bank/col)   
271.         // [11:8] Number of column address bits (0=7bits, 1=8bits, 2=9bits, 3=10bits, ... 5=12bits)   
272.         // [7:4]  Number of row address bits (0=12bits, 1=13bits, 2=14bits, 3=15bits)   
273.         // [3:0]  Number of banks (0=1banks, 1=2banks, 2=4banks, 3=8banks)   
274.     SetReg32(rLPCON_PRECH_CONFIG, 0x20<<24|0<<8|0<<0);   
275.         // [31:24] Force precharge cycle (if MEM_CONTROL[4] is set.)   
276.         // [15:8] Memory chip1 precharge bank selective policy (1=close page policy) ???   
277.         // [7:0]  Memory chip0 precharge bank selective policy (1=close page policy) ???   
278.      //SetReg32(rLPCON_PWRDN_CONFIG, 0x10<<16|4); ///   
279.         // [31:16] Number of cycles for dynamic self refresh entry   
280.         // [7:0]  Number of cycles for dynamic power down entry   
281.   
282.     //#ifdef SLOWAHB   
283.     //SetReg32(rLPCON_TIMING_AREF, 0x287); // 7.8us*83MHz=0x287   
284.     //#else   
285.     SetReg32(rLPCON_TIMING_AREF, 0x50e); // 7.8us*166MHz=0x50e   
286.     //#endif  // S5PCxxx_SLOWAHB   
287.     
288.         // [15:0] Average periodic refresh interval   
289.  SetReg32(rLPCON_TIMING_ROW, 0x16233288);   
290.     //SetReg32(rLPCON_TIMING_ROW, 22<<24|2<<20|3<<16|3<<12|10<<6|8<<0);   
291.         // [31:24] tRFC = 132ns/6ns = 22   
292.         // [23:20] tRRD = 12ns/6ns = 2   
293.         // [19:16] tRP = 18ns/6ns = 3   
294.         // [15:12] tRCD = 18ns/6ns = 3   
295.         // [11:6] tRC = 60ns/6ns = 10   
296.         // [5:0] tRAS = 48ns/6ns = 8   
297.  SetReg32(rLPCON_TIMING_DATA, 0x23260304);   
298.     //SetReg32(rLPCON_TIMING_DATA, 2<<28|3<<24|2<<20|CAS_DELAY<<16|3<<8|4<<0);   
299.         // [31:28] tWTR (Internal write to Read command delay) (at least 2)   
300.         // [27:24] tWR = 18ns/6ns = 3   
301.         // [23:20] tRTP (Internal read to Precharge command delay) (maybe 3)   
302.         // [19:16] CL = 5   
303.         // [11:8] WL (for only LPDDR2)   
304.         // [3:0] RL (for only LPDDR2)   
305.  SetReg32(rLPCON_TIMING_POWER, 0x09C80232);   
306.     //SetReg32(rLPCON_TIMING_POWER, 9<<24|200<<16|2<<8|3<<4|2<<0);   
307.         // [29:24] tFAW = Four active window (maybe 50ns)   
308.         // [23:16] tXSR = 200   
309.         // [15:8] tXP (Exit power down to next valid command delay) (2)   
310.         // [7:4]  tCKE = CLE minimun pulse width (3)   
311.         // [3:0]  tMRD = 2   
312.   
313. #if INIT_QoS   
314.     // ---------------------------------------------------------------   
315.     // 3.Initialize QoS   
316.     // ---------------------------------------------------------------   
317.     rTMP = rLPCON_QOS_CONTROL0;   
318.     for (ReadVal=0; ReadVal<8; rTMP++)   
319.         SetReg32(rTMP, 0x00ff0000);   
320.     rTMP = rLPCON_QOS_CONFIG0;   
321.     for (ReadVal=0; ReadVal<8; rTMP++)   
322.         SetReg32(rTMP, 0x00000000);   
323. #endif   
324.     // ---------------------------------------------------------------   
325.     // 4.Initialize DRAM (rLPCON_DIRECT_CMD)   
326.     // ---------------------------------------------------------------   
327.         // [27:24] Type of direct command (0=MRS/EMRS, 1=PALL, 2=PRE, 3=DPD, 4=REFS, 5=REFA, 6=CKEL, 7=NOP, 8=REFSX, 9=MRR)   
328.         // [20] The chip number to send the direct command to (0=chip0, 1=chip1)   
329.         // [18:16] Bits mapped to the bank address pins   
330.         // [14:0] Bits mapped to the address pins   
331.   
332.  // for chip 0   
333.     SetReg32(rLPCON_DIRECT_CMD, 7<<24); // chip0 Deselect (NOP)   
334.     SetReg32(rLPCON_DIRECT_CMD, 1<<24); // chip0 PALL   
335.     SetReg32(rLPCON_DIRECT_CMD, 0x02<<16); // chip0 EMRS2   
336.     SetReg32(rLPCON_DIRECT_CMD, 0x03<<16); // chip0 EMRS3   
337.     SetReg32(rLPCON_DIRECT_CMD, 1<<16 | 4<<8); // chip0 EMRS1      
338.     SetReg32(rLPCON_DIRECT_CMD, 0x762<<0); // chip0 MRS   
339.     SetReg32(rLPCON_DIRECT_CMD, 1<<24); // chip0 PALL   
340.     SetReg32(rLPCON_DIRECT_CMD, 5<<24); // chip0 REFA   
341.     SetReg32(rLPCON_DIRECT_CMD, 5<<24); // chip0 REFA   
342.     SetReg32(rLPCON_DIRECT_CMD, 0x662<<0); // chip0 MRS   
343.     SetReg32(rLPCON_DIRECT_CMD, 0x10780<<0); // chip0 EMRS1   
344.     SetReg32(rLPCON_DIRECT_CMD, 0x01<<16 | 4<<8); // chip0 EMRS1               
345.     //SetReg32(rLPCON_DIRECT_CMD, 0<<24 | 0<<16 | CAS_DELAY<<4 | 2<<0); // chip0 MRS   
346.   
347.  // for chip 1   
348.     SetReg32(rLPCON_DIRECT_CMD, 7<<24 | 1<<20); // chip1 Deselect (NOP)   
349.     SetReg32(rLPCON_DIRECT_CMD, 1<<24 | 1<<20); // chip1 PALL   
350.     SetReg32(rLPCON_DIRECT_CMD, 0x02<<16 | 1<<20); // chip1 EMRS2   
351.     SetReg32(rLPCON_DIRECT_CMD, 0x03<<16 | 1<<20); // chip1 EMRS3   
352.     SetReg32(rLPCON_DIRECT_CMD, 0x104<<8 | 4<<8 | 1<<20); // chip1 EMRS1      
353.     SetReg32(rLPCON_DIRECT_CMD, 0x762<<0 | 1<<20); // chip1 MRS   
354.     SetReg32(rLPCON_DIRECT_CMD, 1<<24 | 1<<20); // chip1 PALL   
355.     SetReg32(rLPCON_DIRECT_CMD, 0x51<<20 | 1<<20); // chip1 REFA   
356.     SetReg32(rLPCON_DIRECT_CMD, 0x51<<20 | 1<<20); // chip1 REFA   
357.     SetReg32(rLPCON_DIRECT_CMD, 0x662<<20 | 1<<20); // chip1 MRS   
358.     SetReg32(rLPCON_DIRECT_CMD, 0x117080<<0 | 1<<20); // chip1 EMRS1   
359.     SetReg32(rLPCON_DIRECT_CMD, 0x110400<<0 | 1<<20); // chip1 EMRS1        
360. //    SetReg32(rLPCON_DIRECT_CMD, 5<<24 | 1<<20); // chip1 REFA   
361. //    SetReg32(rLPCON_DIRECT_CMD, 5<<24 | 1<<20); // chip1 REFA   
362. //    SetReg32(rLPCON_DIRECT_CMD, 0<<24 | 1<<20 | 0<<16 | CAS_DELAY<<4 | 2<<0); // chip1 MRS   
363.         // [8] DLL Reset,   
364.         // [6:4] CAS Delay   
365.         // [3] 0=Sequential   
366.         // [2:0] Burst (1=2, 2=4, 3=8)   
367.     //SetReg32(rLPCON_DIRECT_CMD, 0<<24|4<<16|0<<5|0<<0); // chip0 EMRS ///   
368.         // [17:16] 4 for DDR2   
369.         // [6:5] Drive strength (0=full, 1=half, 2=quater, 3=octant)   
370.         // [2:0] Partial Self Refresh (0=full array, 1=half array, 2=quater array)   
371.     //SetReg32(rLPCON_DIRECT_CMD, 7<<24); // chip0 Deselect (NOP) ///   
372.   
373.     // ---------------------------------------------------------------   
374.     // 5. Start the DMC.   
375.     // ---------------------------------------------------------------   
376.   
377.  SetReg32(rLPCON_CON_CONTROL, 0x0FF01030); // auto fresh on   
378.     //GetReg32(rLPCON_CON_CONTROL, ReadVal);   
379.     //SetReg32(rLPCON_CON_CONTROL, ReadVal|=(1<<5));   
380.     SetReg32(rLPCON_PWRDN_CONFIG, 0x10<<16|4); // add   
381.         // [31:16] Number of cycles for dynamic self refresh entry   
382.         // [7:0]  Number of cycles for dynamic power down entry   
383.     //GetReg32(rLPCON_MEM_CONTROL, ReadVal);   
384.     //SetReg32(rLPCON_MEM_CONTROL, ReadVal&=(~0xff));   
385.  SetReg32(rLPCON_MEM_CONTROL, 0x00212400);   
386.   
387. }