开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
initfuncs.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：54k
源码类别：

DVD

开发平台：

C/C++

initfuncs.c：源码内容
  1. /****************************************************************************
  3. File Name   : initfuncs.c
  5. Description : Initialization functions, used incase of Boot from Flash.
  7. Copyright (C) 2004, ST Microelectronics
  9.  ****************************************************************************/
  10.  /* Includes ----------------------------------------------------------- */
  12. #include <initfuncs.h>
  13. #include "stsys.h"
  14. /*#include "reg.h"*/
  16. /* Private Types ------------------------------------------------------ */
  18. /* Private Constants -------------------------------------------------- */
  20. /* Private Variables -------------------------------------------------- */
  22. /* Private Macros ----------------------------------------------------- */
  24. /* --- TMTM needed to set options --->----------------------------------- */
  25. /*
  26. DDR = 133, CAS20
  27. = 166, CAS25
  28. SDR = 166, CAS30
  29. */
  31. #ifdef SELECT_DEVICE_STB5118
  32. #define SDRAM_CAS_3_0
  33. #define SDRAM_FREQ_CONFIG_166
  34. #define SDRAM_64MB
  35. #else
  36. #define DDR_SDRAM //undef means SDR_SDRAM
  37. #define SDRAM_CAS_2_0
  38. #define SDRAM_FREQ_CONFIG_133
  39. #define SDRAM_256MB
  40. #endif
  42. //TMTM choose ONLY 1
  43. //#define SDRAM_64MB
  44. //#define SDRAM_128MB
  45. //#define SDRAM_256MB
  46. //#define SDRAM_512MB
  48. /* <--- TMTM needed to set options --------------------------------------- */
  50. #define INPUT_CLOCK_FREQUENCY   27000   /* Input clock frequency in KHz */
  51. #define MIN_PLL_FREQUENCY       10000   /* Value minimum of PLL Frequency in KHz */
  52. #define MAX_PLL_FREQUENCY       6800000 /* Value maximum of PLL Frequency in KHz */
  54. #define PLL_A                   0
  55. #define PLL_B                   1 
  57. #define PLL_A_FREQUENCY 400000
  58. //TMTM for 133sdram #define PLL_B_FREQUENCY         533000 //TMTM 592000
  60. #ifdef SDRAM_FREQ_CONFIG_133
  61. #define PLL_B_FREQUENCY 533000
  62. #elif defined (SDRAM_FREQ_CONFIG_120)
  63. #define PLL_B_FREQUENCY 480000
  64. #elif defined (SDRAM_FREQ_CONFIG_166)
  65. #define PLL_B_FREQUENCY 664000 //TMTM 600000 
  66. #endif
  68. #define CPU_DIV                 2
  69. #define LMI_DIV                 4
  71. #ifdef SELECT_DEVICE_CUT3_0 //KCY 060823
  72. #define BLITTER_DIV             3 //Blitter clock change back to 133Mhz
  73. #else
  74. #define BLITTER_DIV             4 //KCY 060622 Blitter clock 100MHz To fix OSD garbage/white spot noise issue
  75. #endif
  77. #define FDMA_DIV                2
  78. #define SYSTEM_DIV              4
  79. #define AUDIO_VIDEO_DIV         8
  80. #define FLASH_DIV               4 /* FLASH source is the same as LS_INTERCONECT */
  82. #define CPU_SOURCE              PLL_A
  83. #define LMI_SOURCE              PLL_B
  84. #define BLITTER_SOURCE          PLL_A
  85. #define FDMA_SOURCE             PLL_A
  86. #define SYSTEM_SOURCE           PLL_A
  87. #define AUDIO_VIDEO_SOURCE      PLL_A
  90. #define SYS_SERVICES_BASE_ADDRESS   0x20F00000
  92. #define CKG_PLLA_CONFIG0            (SYS_SERVICES_BASE_ADDRESS + 0x00)
  93. #define CKG_PLLA_CONFIG1            (SYS_SERVICES_BASE_ADDRESS + 0x04)
  94. #define CKG_PLLB_CONFIG0            (SYS_SERVICES_BASE_ADDRESS + 0x08)
  95. #define CKG_PLLB_CONFIG1            (SYS_SERVICES_BASE_ADDRESS + 0x0C)
  96. #define CKG_FSA_SETUP               (SYS_SERVICES_BASE_ADDRESS + 0x10)
  97. #define CKG_PCM_CLK_SETUP0          (SYS_SERVICES_BASE_ADDRESS + 0x20)
  98. #define CKG_PCM_CLK_SETUP1          (SYS_SERVICES_BASE_ADDRESS + 0x24)
  99. #define CKG_SPDIF_CLK_SETUP0        (SYS_SERVICES_BASE_ADDRESS + 0x30)
  100. #define CKG_SPDIF_CLK_SETUP1        (SYS_SERVICES_BASE_ADDRESS + 0x34)
  101. #define CKG_SC_CLK_SETUP0           (SYS_SERVICES_BASE_ADDRESS + 0x40)
  102. #define CKG_SC_CLK_SETUP1           (SYS_SERVICES_BASE_ADDRESS + 0x44)
  103. #define CKG_PIX_CLK_SETUP0          (SYS_SERVICES_BASE_ADDRESS + 0x54)
  104. #define CKG_PIX_CLK_SETUP1          (SYS_SERVICES_BASE_ADDRESS + 0x58)
  105. #define CKG_FDMA_CLK_SETUP0         (SYS_SERVICES_BASE_ADDRESS + 0x70)
  106. #define CKG_FDMA_CLK_SETUP1         (SYS_SERVICES_BASE_ADDRESS + 0x74)
  107. #define CKG_AUX_CLK_SETUP0          (SYS_SERVICES_BASE_ADDRESS + 0x70)
  108. #define CKG_AUX_CLK_SETUP1          (SYS_SERVICES_BASE_ADDRESS + 0x74)
  109. #define CKG_MODE_CONTROL            (SYS_SERVICES_BASE_ADDRESS + 0x110)
  110. #define CKG_CLOCK_SELECT_CFG        (SYS_SERVICES_BASE_ADDRESS + 0x180)
  111. #define CKG_REGISTER_LOCK_CFG       (SYS_SERVICES_BASE_ADDRESS + 0x300)
  112. #define CKG_OBSERVATION_CFG_AUX     (SYS_SERVICES_BASE_ADDRESS + 0x188)
  113. #define CKG_FSB_SETUP (SYS_SERVICES_BASE_ADDRESS + 0x050)
  116. /* kc-060112am */
  117. #define REDUCED_POWER_CTRL (SYS_SERVICES_BASE_ADDRESS + 0x114)
  118. #define LP_MODE_DIS0 (SYS_SERVICES_BASE_ADDRESS + 0x118)
  119. #define LP_MODE_DIS1 (SYS_SERVICES_BASE_ADDRESS + 0x11C)
  120. #define LP_MODE_COUNTER_CFG0 (SYS_SERVICES_BASE_ADDRESS + 0x120)
  121. #define LP_MODE_COUNTER_CFG1 (SYS_SERVICES_BASE_ADDRESS + 0x124)
  122. #define WATCHDOG_COUNTER_CFG0 (SYS_SERVICES_BASE_ADDRESS + 0x130)
  123. #define WATCHDOG_COUNTER_CFG1 (SYS_SERVICES_BASE_ADDRESS + 0x134)
  124. #define CKG_RESET_STATUS                 (SYS_SERVICES_BASE_ADDRESS + 0x140)
  128. #define CPU                     1
  129. #define LMI                     2
  130. #define BLITTER                 3
  131. #define SYSTEM                  4
  132. #define FDMA                    5
  133. #define AUDIO_VIDEO             6
  134. #define FLASH                   8
  136. #define HALF_VALUE              1
  137. #define WHOLE_VALUE             0
  140. #define LMI_BASE_ADDRESS                0xC0000000
  141. #define LMICONFIG_BASE_ADDRESS          0xE0000000
  143. #define LMI_VCR0                        (LMICONFIG_BASE_ADDRESS + 0x00)
  144. #define LMI_VCR1                        (LMICONFIG_BASE_ADDRESS + 0x04)
  145. #define LMI_MIM                         (LMICONFIG_BASE_ADDRESS + 0x08)
  146. #define LMI_SCR                         (LMICONFIG_BASE_ADDRESS + 0x10)
  147. #define LMI_STR                         (LMICONFIG_BASE_ADDRESS + 0x18)
  149. #define LMI_PBS                         (LMICONFIG_BASE_ADDRESS + 0x20)
  150. #define LMI_COC_LOWER                   (LMICONFIG_BASE_ADDRESS + 0x28)
  151. #define LMI_COC_UPPER                   (LMICONFIG_BASE_ADDRESS + 0x2C)
  152. #define LMI_CIC                         (LMICONFIG_BASE_ADDRESS + 0x40)
  153. #define LMI_SDRA0                       (LMICONFIG_BASE_ADDRESS + 0x30)
  154. #define LMI_SDRA1                       (LMICONFIG_BASE_ADDRESS + 0x38)
  155. #define LMI_SDMR0                       (LMICONFIG_BASE_ADDRESS + 0x48)
  156. #define LMI_SDMR1                       (LMICONFIG_BASE_ADDRESS + 0x50)
  160. #define FMICONFIG_BASE_ADDRESS          (0x20200000)
  161. #define FMICONFIG_BUFFER_BASE_ADDRESS   (0x202FF800)
  163. #define FMICONFIGDATA0_BANK0            (FMICONFIG_BASE_ADDRESS + 0x100)
  164. #define FMICONFIGDATA1_BANK0            (FMICONFIG_BASE_ADDRESS + 0X108)
  165. #define FMICONFIGDATA2_BANK0            (FMICONFIG_BASE_ADDRESS + 0X110)
  166. #define FMICONFIGDATA3_BANK0            (FMICONFIG_BASE_ADDRESS + 0X118)
  168. #define FMICONFIGDATA0_BANK1            (FMICONFIG_BASE_ADDRESS + 0X140)
  169. #define FMICONFIGDATA1_BANK1            (FMICONFIG_BASE_ADDRESS + 0X148)
  170. #define FMICONFIGDATA2_BANK1            (FMICONFIG_BASE_ADDRESS + 0X150)
  171. #define FMICONFIGDATA3_BANK1            (FMICONFIG_BASE_ADDRESS + 0X158)
  173. #define FMICONFIGDATA0_BANK2            (FMICONFIG_BASE_ADDRESS + 0X180)
  174. #define FMICONFIGDATA1_BANK2            (FMICONFIG_BASE_ADDRESS + 0X188)
  175. #define FMICONFIGDATA2_BANK2            (FMICONFIG_BASE_ADDRESS + 0X190)
  176. #define FMICONFIGDATA3_BANK2            (FMICONFIG_BASE_ADDRESS + 0X198)
  178. #define FMICONFIGDATA0_BANK3            (FMICONFIG_BASE_ADDRESS + 0X1C0)
  179. #define FMICONFIGDATA1_BANK3            (FMICONFIG_BASE_ADDRESS + 0X1C8)
  180. #define FMICONFIGDATA2_BANK3            (FMICONFIG_BASE_ADDRESS + 0X1D0)
  181. #define FMICONFIGDATA3_BANK3            (FMICONFIG_BASE_ADDRESS + 0X1D8)
  183. #define FMI_STATUSCFG                   (FMICONFIG_BASE_ADDRESS + 0X010)
  184. #define FMI_STATUSLOCK                  (FMICONFIG_BASE_ADDRESS + 0X018)
  185. #define FMI_LOCK                        (FMICONFIG_BASE_ADDRESS + 0X020)
  186. #define FMI_GENCFG                      (FMICONFIG_BASE_ADDRESS + 0X028)
  187. #define FMI_FLASHCLKSEL                 (FMICONFIG_BASE_ADDRESS + 0X050)
  188. #define FMI_CLKENABLE                   (FMICONFIG_BASE_ADDRESS + 0X068)
  190. #define BANK_0_TOP_ADDRESS              (FMICONFIG_BUFFER_BASE_ADDRESS + 0x20)
  191. #define BANK_1_TOP_ADDRESS              (FMICONFIG_BUFFER_BASE_ADDRESS + 0x30)
  192. #define BANK_2_TOP_ADDRESS              (FMICONFIG_BUFFER_BASE_ADDRESS + 0x40)
  193. #define BANK_3_TOP_ADDRESS              (FMICONFIG_BUFFER_BASE_ADDRESS + 0x50)
  194. #define BANKS_ENABLED                   (FMICONFIG_BUFFER_BASE_ADDRESS + 0x60)
  196. #define FLASH_EPLD_FLASH                0x45200000
  199. #define CONFIG_CONTROL_BASEADDRESS      (0x20402000)
  201. #define CONFIG_CONTROL_C                (CONFIG_CONTROL_BASEADDRESS+0x0)
  202. #define CONFIG_CONTROL_D                (CONFIG_CONTROL_BASEADDRESS+0X4)
  203. #define CONFIG_CONTROL_E                (CONFIG_CONTROL_BASEADDRESS+0x8)
  204. #define CONFIG_CONTROL_F                (CONFIG_CONTROL_BASEADDRESS+0XC)
  205. #define CONFIG_CONTROL_G                (CONFIG_CONTROL_BASEADDRESS+0X10)
  206. #define CONFIG_CONTROL_H                (CONFIG_CONTROL_BASEADDRESS+0X14)
  211. /* Private Function prototypes ---------------------------------------- */
  213. /* Functions ---------------------------------------------------------- */
  215. static void Simudelay(int);
  216. #pragma ST_nolink(Simudelay)
  217. static void ST_5105_InitClocks(void);
  218. #pragma ST_nolink(ST_5105_InitClocks)
  219. static void ST_5105_InitPLLFrequency(U32 PLLFrequency, U32 PLLSource);
  220. #pragma ST_nolink(ST_5105_InitPLLFrequency)
  221. static void ST_5105_SetupDividers(void);
  222. #pragma ST_nolink(ST_5105_SetupDividers)
  223. static void ST_5105_SetupFrequencySynthesizer(void);
  224. #pragma ST_nolink(ST_5105_SetupFrequencySynthesizer)
  225. static void ST_5105_SetPLLClockDivider(U32 clock, U32 div, U32 half, U32 source, S32 phase);
  226. #pragma ST_nolink(ST_5105_SetPLLClockDivider)
  227. static void ST_5105_IniLMI_Cas20(void);
  228. #pragma ST_nolink(ST_5105_IniLMI_Cas20)
  229. static void ST_5105_IniLMI_Cas25(void);
  230. #pragma ST_nolink(ST_5105_IniLMI_Cas25)
  231. static void ST_5105_InitFMI(void);
  232. #pragma ST_nolink(ST_5105_InitFMI)
  234. /****leslie***/
  235. static void ST_5105_IniLMI_PC_SDRAM(void);
  236. #pragma ST_nolink(ST_5105_IniLMI_PC_SDRAM)
  237. static void ST_5105_IniLMI_Reg(void); #pragma ST_nolink(ST_5105_IniLMI_Reg)
  238. /*****************/
  241. /* Functions -------------------------------------------------------------- */
  243. /*-------------------------------------------------------------------------
  244.  * Function : PostPokeLoopCallback
  245.  * Input    : None
  246.  * Output   :
  247.  * Return   : None
  248.  * ----------------------------------------------------------------------*/
  249. void PostPokeLoopCallback(void)
  250. {
  251. }
  253. /*-------------------------------------------------------------------------
  254.  * Function : PrePokeLoopCallback
  255.  * Input    : None
  256.  * Output   :
  257.  * Return   : None
  258.  * Comment  : Function automatically called after the poke loop
  259.  * ----------------------------------------------------------------------*/
  260. void PrePokeLoopCallback(void)
  261. {
  262.     volatile U32    x;
  264.     /* Set up the PLL's */
  265.     ST_5105_InitClocks ();
  267.     #ifdef DDR_SDRAM
  268. #ifdef SDRAM_CAS_2_0
  269.     ST_5105_IniLMI_Cas20 ();
  270. #else //assume CAS25
  271.     ST_5105_IniLMI_Cas25 ();
  272. #endif
  273.     #else
  274.     ST_5105_IniLMI_PC_SDRAM ();
  275.     #endif
  277.     /* Configure FMI */
  278.     ST_5105_InitFMI ();
  280.     /* Default setup for configuration registers */
  281.     x = STSYS_ReadRegDev32LE(CONFIG_CONTROL_D);
  283. #if 1 /* KCY 060912 */
  284.     STSYS_WriteRegDev32LE(CONFIG_CONTROL_D, ((x) & 0xFCFFE1FF));
  285. #else
  286.     STSYS_WriteRegDev32LE(CONFIG_CONTROL_D, ((x) & 0xFFFFE1FF));
  287. #endif
  289.     x = STSYS_ReadRegDev32LE(CONFIG_CONTROL_H);
  290.     STSYS_WriteRegDev32LE(CONFIG_CONTROL_H, ((x) | 0x0C000000));
  291.     
  293. }
  295. /*-------------------------------------------------------------------------
  296.  * Function : Simudelay
  297.  * Input    : delay
  298.  * Output   :
  299.  * Return   : None
  300.  * ----------------------------------------------------------------------*/
  301. static void Simudelay(int delay)
  302. {
  303.     volatile int j,dummy;
  305.     for ( j = 0 ; j < delay ; j ++ )
  306.        dummy = STSYS_ReadRegDev32LE(0x007C);
  307. }
  309. /*-------------------------------------------------------------------------
  310.  * Function : ST_5105_InitClocks
  311.  * Input    : None
  312.  * Output   :
  313.  * Return   : None
  314.  * ----------------------------------------------------------------------*/
  315. static void ST_5105_InitClocks (void)
  316. {
  317.     volatile U32    Source,
  318.                     LockA,
  319.                     LockB,
  320.                     count = 0,
  321.                     x,y;
  324.     x = STSYS_ReadRegDev32LE(CKG_MODE_CONTROL);
  326.     x = STSYS_ReadRegDev32LE(CKG_PLLA_CONFIG0);
  328.     x = STSYS_ReadRegDev32LE(CKG_PLLB_CONFIG0);
  331.     /* Starting clock generator setup */
  332.     /* Unlock clockgen registers */
  334.     STSYS_WriteRegDev32LE(CKG_REGISTER_LOCK_CFG, 0x00F0);
  335.     STSYS_WriteRegDev32LE(CKG_REGISTER_LOCK_CFG, 0x000F);
  337.     /* Setup the PLL sources for clock */
  338.     Source = (AUDIO_VIDEO_SOURCE << 7) | (LMI_SOURCE << 6) | (FDMA_SOURCE << 5);
  339.     Source = (Source) | (SYSTEM_SOURCE << 4) | (BLITTER_SOURCE << 3) | (LMI_SOURCE << 2);
  340.     Source = (Source) | (CPU_SOURCE << 1);
  342.     STSYS_WriteRegDev32LE(CKG_CLOCK_SELECT_CFG, Source);
  344. #if 0
  345.     /* Setup PLL_A and PLL_B */
  346.     ST_5105_InitPLLFrequency(PLL_A_FREQUENCY, PLL_A);
  347.     ST_5105_InitPLLFrequency(PLL_B_FREQUENCY, PLL_B);
  349.     /* set FS post divider to further reduce pll op
  350.     ** poke  0x20013004  0x00002938
  351.     */
  353.     /* wait for PLL to settle and lock*/
  354.     Simudelay (100000);
  356. #else
  358.     /* GNBvd42626 Resolution : Booting time would be
  359.     reduced from 13-14 seconds to 5-6sec/133*/
  360.     #ifdef SDRAM_FREQ_CONFIG_133
  361.     STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG0,0x02404);
  362.     STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG1,0x04838);
  363.     Simudelay (1000);
  364.     STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG0,0x04406);
  365.     STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG1,0x04838);
  366.     Simudelay (200000);
  367.     #elif defined (SDRAM_FREQ_CONFIG_166) /*3-4sec*/
  368.     STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG0,0x02404);
  369.     STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG1,0x04838);
  370.     Simudelay (1000);
  371.     STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG0,0x05506); //0x0AC07;0x0b80f
  372.     STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG1,0x04838); //9
  373.    Simudelay (200000);
  374.     #endif
  375. #endif
  377.     ST_5105_SetupDividers();
  378.     ST_5105_SetupFrequencySynthesizer();
  380.     /* Check PLL_A and PLL_B has locked*/
  382.     LockA = 0;
  383.     LockB = 0;
  384.     count = 0;
  386.     if (count == 0)
  387.     {
  388.         while (count < 20 && ((LockA == 0) || (LockB == 0)))
  389.         {
  390.             x = STSYS_ReadRegDev32LE(CKG_PLLA_CONFIG1);
  391.             y = STSYS_ReadRegDev32LE(CKG_PLLB_CONFIG1);
  392.             if ((x & 0x4000) == 0x4000) LockA = 1; /* Check for PLL_A Lock */
  393.             if ((y & 0x4000) == 0x4000) LockB = 1; /* Check for PLL_B Lock */
  394.             count++;
  395.         }
  396.         if (LockA == 0)
  397.         {
  398.             /* write PLL_A failed to LOCK! */
  399.             return;
  400.         }
  401.         if (LockB == 0)
  402.         {
  403.             /* write PLL_B failed to LOCK! */
  404.             return;
  405.         }
  406.     }
  409.     Simudelay (1000);
  411.     /* Now Transistion to programmed mode */
  412.     STSYS_WriteRegDev32LE(CKG_MODE_CONTROL, 0x02);
  413.     Simudelay (1000);
  415.     /* Lock Clock Generator registers */
  416.     STSYS_WriteRegDev32LE(CKG_OBSERVATION_CFG_AUX, 0x20);
  417. }
  419. /*-------------------------------------------------------------------------
  420.  * Function : ST_5105_InitPLLFrequency
  421.  * Input    : PLLFrequency, PLLSource
  422.  * Output   :
  423.  * Return   : None
  424.  * ----------------------------------------------------------------------*/
  425. static void ST_5105_InitPLLFrequency ( U32 PLLFrequency, U32 PLLSource )
  426. {
  427.     volatile U32    Pfactor,
  428.                     Divider,
  429.                     Reminder,
  430.                     StoredReminder,
  431.                     Index,
  432.                     IndexMax,
  433.                     tmp,
  434.                     Nfactor,
  435.                     Mfactor,
  436.                     tmp1,
  437.                     tmp2;
  440.     if ((PLLFrequency < MIN_PLL_FREQUENCY) || (PLLFrequency > MAX_PLL_FREQUENCY))
  441.     {
  442.         /* -->  Invalid PLL Frequency : (PLLFrequency) Mhz */
  443.         return;
  444.     }
  446.     if ((MIN_PLL_FREQUENCY <= PLLFrequency) && (PLLFrequency <=300000))
  447.     {
  448.         /*
  449.         ** Pfactor = 1, Fvco = 2 * Fpll
  450.         ** in this case Fpll = (Nfactor/Mfactor) * Fclockin (Fclockin is 27 MHz)
  451.         ** so Nfactor = (Fpll * Mfactor) / Fclockin
  452.         */
  453.         Pfactor = 1;
  454.         Divider = 1;
  455.     }
  457.     if ((300000 <= PLLFrequency) && (PLLFrequency <= MAX_PLL_FREQUENCY))
  458.     {
  459.         /*
  460.         ** Pfactor = 0, Fvco = Fpll
  461.         ** in this case Fpll = (2*Nfactor/Mfactor) * Fclockin (Fclockin is 27 MHz)
  462.         ** so Nfactor = (Fpll * Mfactor) / (2*Fclockin)
  463.         */
  464.         Pfactor = 0;
  465.         Divider = 2;
  466.     }
  468.     StoredReminder = 100000;
  469.     IndexMax = 27;
  471.     for(Index = 5; Index <= IndexMax; Index++)
  472.     {
  473. #if 0
  474.         Reminder = (PLLFrequency*Index) % (INPUT_CLOCK_FREQUENCY*Divider);
  475.         tmp = (PLLFrequency*Index) / (INPUT_CLOCK_FREQUENCY*Divider);
  476. #else
  477.         tmp = 0;
  478.         Reminder = (PLLFrequency*Index);
  479.         while(Reminder > (INPUT_CLOCK_FREQUENCY*Divider))
  480.         {
  481.             Reminder = Reminder - (INPUT_CLOCK_FREQUENCY*Divider);
  482.             tmp = tmp + 1;
  483.         }
  484. #endif
  486.         if ((Reminder == 0) && (tmp < 126))
  487.         {
  488.             Mfactor = Index;
  489.             Nfactor = tmp;
  490.             Index = 100;
  491.         }
  493.         if (Reminder > Index)
  494.         {
  495.             if ((Reminder - Index < StoredReminder) && (tmp < 126) && (Reminder != 0))
  496.             {
  497.                 StoredReminder = Reminder;
  498.                 Mfactor = Index;
  499.                 Nfactor = tmp;
  500.             }
  501.         }
  502.         else
  503.         {
  504.             if ((Index - Reminder < StoredReminder) && (tmp < 126) && (Reminder != 0))
  505.             {
  506.                 StoredReminder = Reminder;
  507.                 Mfactor = Index;
  508.                 Nfactor = tmp;
  509.             }
  510.         }
  511.     }
  513. #if 0
  514.     PLLFrequency = (Divider*Nfactor*INPUT_CLOCK_FREQUENCY)/Mfactor;
  515. #else
  516.     tmp1 = 0;
  517.     tmp2 = (Divider*Nfactor*INPUT_CLOCK_FREQUENCY);
  518.     while (tmp2 > 1000000)
  519.     {
  520.         tmp2 = tmp2- Mfactor;
  521.         tmp1++;
  522.     }
  523.     PLLFrequency = tmp1;
  524. #endif
  526.     if (PLLSource == PLL_A)
  527.     {
  528.         STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG0, (((Nfactor-1)<<8) | (Mfactor-1)));
  529.         STSYS_WriteRegDev32LE(CKG_PLLA_CONFIG1, (0x4838 | Pfactor));
  530.     }
  532.     if (PLLSource == PLL_B)
  533.     {
  534.         STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG0, (((Nfactor-1)<<8) | (Mfactor-1)));
  535.         STSYS_WriteRegDev32LE(CKG_PLLB_CONFIG1, (0x4838 | Pfactor));
  536.     }
  538.     Simudelay (50);
  539. }
  541. /*-------------------------------------------------------------------------
  542.  * Function : ST_5105_SetupDividers
  543.  * Input    : None
  544.  * Output   :
  545.  * Return   : None
  546.  * ----------------------------------------------------------------------*/
  547. static void ST_5105_SetupDividers(void)
  548. {
  549.     /* Setup PLL dividers for STi5100 chip */
  551.     ST_5105_SetPLLClockDivider(CPU,               CPU_DIV,               WHOLE_VALUE,   CPU_SOURCE,               0);
  552.     ST_5105_SetPLLClockDivider(LMI,               LMI_DIV,               WHOLE_VALUE,   LMI_SOURCE,               0);
  553.     ST_5105_SetPLLClockDivider(BLITTER,           BLITTER_DIV,           WHOLE_VALUE,   BLITTER_SOURCE,           0);
  554.     ST_5105_SetPLLClockDivider(SYSTEM,            SYSTEM_DIV,            WHOLE_VALUE,   SYSTEM_SOURCE,            0);
  555.     ST_5105_SetPLLClockDivider(FDMA,              FDMA_DIV,              WHOLE_VALUE,   FDMA_SOURCE,              0);
  556.     ST_5105_SetPLLClockDivider(AUDIO_VIDEO,       AUDIO_VIDEO_DIV,       WHOLE_VALUE,   AUDIO_VIDEO_SOURCE,       0);
  557.     ST_5105_SetPLLClockDivider(FLASH,             FLASH_DIV,             WHOLE_VALUE,   SYSTEM_SOURCE,            0);
  558. }
  560. /*-------------------------------------------------------------------------
  561.  * Function : ST_5105_SetupFrequencySynthesizer
  562.  * Input    : None
  563.  * Output   :
  564.  * Return   : None
  565.  * ----------------------------------------------------------------------*/
  566. static void ST_5105_SetupFrequencySynthesizer(void)
  567. {
  568.     volatile U32    x,
  569.                     MD,SDIV,PE,EN_PRG;
  571.     /* Setup PLL Frequency Synthesizers for STi5100 chip */
  572.     STSYS_WriteRegDev32LE(CKG_FSA_SETUP, 0xc); /*For abnormal audio upon power up*/
  573.     STSYS_WriteRegDev32LE(CKG_FSA_SETUP, 0x4);
  577.     MD   = 0x1f;
  578.     SDIV = 0x2;
  579.     PE   = 0x0000;
  581.     EN_PRG = 0x1;
  583.     /* Pixel clock = 27 MHz */
  584.     STSYS_WriteRegDev32LE(CKG_PIX_CLK_SETUP0, (0xE00 | (SDIV)<<6 | (EN_PRG<<5) | (MD)));
  585.     STSYS_WriteRegDev32LE(CKG_PIX_CLK_SETUP1, (PE));
  587.     x = STSYS_ReadRegDev32LE (CKG_PIX_CLK_SETUP0);
  589.     /* PCM clock = 24.576 MHz */
  590.     STSYS_WriteRegDev32LE(CKG_PCM_CLK_SETUP0, 0x0ef1);
  591.     STSYS_WriteRegDev32LE(CKG_PCM_CLK_SETUP1, 0x3600);
  593.     /* SPDIF clock = 27 MHz */
  594.     STSYS_WriteRegDev32LE(CKG_SPDIF_CLK_SETUP0, 0x0EBF);
  595.     STSYS_WriteRegDev32LE(CKG_SPDIF_CLK_SETUP1, 0x0000);
  597.     /* Smart Card clock = 27 MHz */
  598.     STSYS_WriteRegDev32LE(CKG_SC_CLK_SETUP0, 0x0EBF);
  599.     STSYS_WriteRegDev32LE(CKG_SC_CLK_SETUP1, 0x0000);
  601.     /* AUX clock = 27 MHz */
  602.     STSYS_WriteRegDev32LE(CKG_AUX_CLK_SETUP0, 0x0EBF);
  603.     STSYS_WriteRegDev32LE(CKG_AUX_CLK_SETUP1, 0x0000);
  605. /*FSB setup to toggle the power up and power down on FSB PLL*/
  606. STSYS_WriteRegDev32LE(CKG_FSB_SETUP, 0xc);
  607. STSYS_WriteRegDev32LE(CKG_FSB_SETUP, 0x4);
  609. }
  611. /*-------------------------------------------------------------------------
  612.  * Function : ST_5105_SetPLLClockDivider
  613.  * Input    : None
  614.  * Output   :
  615.  * Return   : None
  616.  * ----------------------------------------------------------------------*/
  617. static void ST_5105_SetPLLClockDivider( U32 clock, U32 div, U32 half, U32 source, S32 phase )
  618. {
  619.     volatile U32    PLL,
  620.                     config_0,
  621.                     config_1,
  622.                     config_2,
  623.                     PLL_MHz_x10,
  624.                     div_x10,
  625.                     depth,
  626.                     pattern,
  627.                     bpat,
  628.                     temptoppat,
  629.                     newpat,
  630.                     offset,
  631.                     tmp1,
  632.                     tmp2;
  634.     /*
  635.      * If phase is not passed in Function Call it must be Zero
  636.      * phase=0; Handled in Fn Call itself
  637.      */
  638.     if (source == PLL_A)
  639.     {
  640.         PLL = PLL_A_FREQUENCY*1000;
  641.     }
  642.     else
  643.     {
  644.         PLL = PLL_B_FREQUENCY*1000;
  645.     }
  647.     offset = (clock * 0x10);
  649.     config_0 = 0;
  650.     config_1 = 0;
  651.     config_2 = 0;
  653.     switch ( div )
  654.     {
  655.         case 2:
  656.             if (half==WHOLE_VALUE) /* divide by 2 */
  657.             {
  658.                 config_0 = 0x0AAA;
  659.                 config_2 = 0x0071;
  660.             }
  661.             else if (half==HALF_VALUE) /* divide by 2.5 */
  662.             {
  663.                 config_0 = 0x5AD6;
  664.                 config_2 = 0x0054;
  665.             }
  666.             break;
  668.         case 3:
  669.             if (half==WHOLE_VALUE)    /* divide by 3 */
  670.             {
  671.                 config_0 = 0x0DB6;
  672.                 config_2 = 0x0011;
  673.             }
  674.             else if (half==HALF_VALUE) /* divide by 3.5 */
  675.             {
  676.                 config_0 = 0x366C;
  677.                 config_2 = 0x0053;
  678.             }
  679.             break;
  681.         case 4:
  682.             if (half==WHOLE_VALUE)    /* divide by 4 */
  683.             {
  684.                 config_0 = 0xCCCC;
  685.                 config_2 = 0x0075;
  686.             }
  687.             else if (half==HALF_VALUE)  /* divide by 4.5 */
  688.             {
  689.                 config_0 = 0x399C;
  690.                 config_1 = 0x0003;
  691.                 config_2 = 0x0057;
  692.             }
  693.             break;
  695.         case 5:
  696.             if (half==WHOLE_VALUE)  /* divide by 5 */
  697.             {
  698.                 config_0 = 0x739c;
  699.                 config_2 = 0x0014;
  700.             }
  701.             else if (half==HALF_VALUE)  /* divide by 5.5 */
  702.             {
  703.                 config_0 = 0x071C;
  704.                 config_2 = 0x0050;
  705.             }
  706.             break;
  708.         case 6:
  709.             if (half==WHOLE_VALUE)  /* divide by 6 */
  710.             {
  711.                 config_0 = 0x0E38;
  712.                 config_2 = 0x0071;
  713.             }
  714.             else if (half==HALF_VALUE)  /* divide by 6.5 */
  715.             {
  716.                 config_0 = 0x1C78;
  717.                 config_2 = 0x0052;
  718.             }
  719.             break;
  721.         case 7:
  722.             if (half==WHOLE_VALUE)  /* divide by 7 */
  723.             {
  724.                 config_0 = 0x3C78;
  725.                 config_2 = 0x0013;
  726.             }
  727.             else if (half==HALF_VALUE)  /* divide by 7.5 */
  728.             {
  729.                 config_0 = 0x7878;
  730.                 config_2 = 0x0054;
  731.             }
  732.             break;
  734.         case 8:
  735.             if (half==WHOLE_VALUE)  /* divide by 8 */
  736.             {
  737.                 config_0 = 0xF0F0;
  738.                 config_2 = 0x0075;
  739.             }
  740.             else if (half==HALF_VALUE)  /* divide by 8.5 */
  741.             {
  742.                 config_0 = 0xE1F0;
  743.                 config_1 = 0x0001;
  744.                 config_2 = 0x0056;
  745.             }
  746.             break;
  748.         case 9:
  749.             if (half==WHOLE_VALUE) /* divide by 9 */
  750.             {
  751.                 config_0 = 0xE1F0;
  752.                 config_1 = 0x0003;
  753.                 config_2 = 0x0017;
  754.             }
  755.             else if (half==HALF_VALUE)    /* divide by 9.5 */
  756.             {
  757.                 config_0 = 0xC1F0;
  758.                 config_1 = 0x0007;
  759.                 config_2 = 0x0058;
  760.             }
  761.             break;
  763.         case 10:
  764.             if (half==WHOLE_VALUE) /* divide by 10 */
  765.             {
  766.                 config_0 = 0x83e0;
  767.                 config_1 = 0x000f;
  768.                 config_2 = 0x0079;
  769.             }
  770.             break;
  772.         case 11:
  773.             if (half==WHOLE_VALUE)  /* divide by 11 */
  774.             {
  775.                 config_0 = 0x07e0;
  776.                 config_2 = 0x0010;
  777.             }
  778.             break;
  780.         case 12:
  781.             if (half==WHOLE_VALUE)  /* divide by 12 */
  782.             {
  783.                 config_0 = 0x0fc0;
  784.                 config_2 = 0x0071;
  785.             }
  786.             break;
  788.         case 13:
  789.             if (half==WHOLE_VALUE)  /* divide by 13 */
  790.             {
  791.                 config_0 = 0x1FC0;
  792.                 config_2 = 0x0012;
  793.             }
  794.             break;
  796.         case 14:
  797.             if (half==WHOLE_VALUE) /* divide by 14 */
  798.             {
  799.                 config_0 = 0x3F80;
  800.                 config_2 = 0x0073;
  801.             }
  802.             break;
  804.         case 15:
  805.             if (half==WHOLE_VALUE)  /* divide by 15 */
  806.             {
  807.                 config_0 = 0x7F80;
  808.                 config_2 = 0x0014;
  809.             }
  810.             break;
  812.         case 16:
  813.             if (half==WHOLE_VALUE)  /* divide by 16 */
  814.             {
  815.                 config_0 = 0xFF00;
  816.                 config_1 = 0x0000;
  817.                 config_2 = 0x0015;
  818.             }
  819.             break;
  821.         case 17:
  822.             if (half==WHOLE_VALUE)  /* divide by 17 */
  823.             {
  824.                 config_0 = 0xFF00;
  825.                 config_1 = 0x0001;
  826.                 config_2 = 0x0016;
  827.             }
  828.             break;
  830.         case 18:
  831.             if (half==WHOLE_VALUE)  /* divide by 18 */
  832.             {
  833.                 config_0 = 0xFE00;
  834.                 config_1 = 0x0003;
  835.                 config_2 = 0x0077;
  836.             }
  837.             break;
  839.         case 19:
  840.             if (half==WHOLE_VALUE)  /* divide by 19 */
  841.             {
  842.                 config_0 = 0xFE00;
  843.                 config_1 = 0x0007;
  844.                 config_2 = 0x0018;
  845.             }
  846.             break;
  848.         case 20:
  849.             if (half==WHOLE_VALUE)  /* divide by 20 */
  850.             {
  851.                 config_0 = 0xFC00;
  852.                 config_1 = 0x000F;
  853.                 config_2 = 0x0019;
  854.             }
  855.             break;
  856.     }
  858.     if (config_0 == 0)
  859.     {
  860.         /* Divider value (div) not supported for module (names[clock]) */
  861.         return;
  862.     }
  864.     /*write (names[clock]) = (PLL / ( div)) Hz*/
  865.     /* Re-adjust PLL and div to allow for half value division using integers. */
  866. #if 0
  867.     PLL_MHz_x10 = (PLL / 1000000) * 10;
  868. #else
  869.     tmp1 = 0;
  870.     tmp2 = PLL;
  871.     while (tmp2 > 1000000)
  872.     {
  873.         tmp2 = tmp2- 1000000;
  874.         tmp1++;
  875.     }
  876.     PLL_MHz_x10 = (tmp1) * 10;
  877. #endif
  879.     if (half==(WHOLE_VALUE))
  880.     {
  881.         div_x10 = div * 10;  /* whole value x10 */
  882.     }
  883.     else
  884.     {
  885.         div_x10 = (div * 10) + 5;  /* half value x10 */
  886.     }
  888.     if (phase > 0)
  889.     {
  890.         /* Calculate the depth of the pattern */
  891.         depth = (config_2 & 0x0f) + 11;
  893.         /* 32-bit field pattern */
  894.         pattern = config_0 | (config_1 << 16);
  896.         /* Shifted Pattern */
  897.         bpat = pattern >> phase;
  899.         /* Bits of the pattern needed to be rapped */
  900.         temptoppat = pattern & ((1 << phase)-1);
  902.         newpat = bpat | (temptoppat << (depth - phase));
  904.         config_0 = newpat & 0xffff;
  905.         config_1 = newpat >> 16;
  906.     }
  907.     else if (phase < 0)
  908.     {
  909.         phase = 0-phase;
  911.         /* Calculate the depth of the pattern */
  912.         depth = (config_2 & 0x0f) + 11;
  914.         /* 32-bit field pattern */
  915.         pattern = config_0 | (config_1 << 16);
  917.         /* Shifted Pattern */
  918.         bpat = (pattern << phase) & ((1 << depth)-1);
  920.         /* Bits of the pattern needed to be rapped */
  921.         temptoppat = pattern >> (depth - phase);
  923.         newpat = bpat | temptoppat;
  925.         config_0 = newpat & 0xffff;
  926.         config_1 = newpat >> 16;
  927.     }
  929.     STSYS_WriteRegDev32LE(SYS_SERVICES_BASE_ADDRESS + 0x80 + offset, config_0);
  930.     STSYS_WriteRegDev32LE(SYS_SERVICES_BASE_ADDRESS + 0x84 + offset, config_1);
  931.     STSYS_WriteRegDev32LE(SYS_SERVICES_BASE_ADDRESS + 0x88 + offset, config_2);
  932. }
  934. /*-------------------------------------------------------------------------
  935.  * Function : ST_5105_IniLMI_Cas20
  936.  * Input    : None
  937.  * Output   :
  938.  * Return   : None
  939.  * ----------------------------------------------------------------------*/
  940. static void ST_5105_IniLMI_Cas20(void)
  941. {
  942.     volatile U32    data;
  944.     /* "n Configuring LMI for 16-bit data CAS 2.0 @ 133MHz " */
  946.     /* Set LMI_COC_UPPER Register, bits [63:32]   (LMI Pad logic) */
  947.     STSYS_WriteRegDev32LE(LMI_COC_UPPER, 0x000C6750);
  948.     /* Even Though its a 64 bit register the upper 32 bits are reserved and therefore no need to fill*/
  950.     /* Set LMI_COC_LOWER Register, bits [31:0]  (LMI Pad logic)
  951.     ** Bits [19:18] Compensation mode DDR
  952.     ** Bits [17:16] Pad strenght         (0x0:5pF, 0x1:15pF, 0x2:25pF, Ox3:35pF)
  953.     ** Bits [15:14] output Impedance (0x0:25Ohm, 0x1:40Ohm, 0x2:55Ohm, Ox3:70Ohm)
  954.     ** Bit  [13]    DLL preset reset value enable
  955.     */
  956.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, 0x00002000);
  957.     data = STSYS_ReadRegDev32LE(LMI_COC_LOWER);
  958.     data = (data | 0x0<<16 | 0x0<<14);
  959.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, data);
  961.     /* SDRAM Mode Register
  962.     ** Set Refresh Interval, Enable Refresh, 16-bit bus,
  963.     ** Grouping Disabled, DDR-SDRAM, Enable.
  964.     ** Bits[27:16]: Refresh Interval = 7.8 microseconds (8K/64ms)
  965.     ** @  50MHz =  390 clk cycles -> 0x186
  966.     ** @  75MHz =  585 clk cycles -> 0x249
  967.     ** @ 100MHz =  780 clk cycles -> 0x30C
  968.     ** @ 125MHz =  975 clk cycles -> 0x3CF
  969.     ** @ 133MHz = 1040 clk cycles -> 0x410  <--
  970.     ** @ 166MHz = 1300 clk cycles -> 0x514
  971.     */
  972. #if defined( SDRAM_512MB ) || defined(SDRAM_256MB)
  973.     STSYS_WriteRegDev32LE(LMI_MIM, 0x04100203);
  974. #elif defined(SDRAM_128MB) || defined(SDRAM_64MB)
  975. STSYS_WriteRegDev32LE(LMI_MIM, 0x08200203);
  976. #endif
  978.     /* SDRAM Timing Register
  979.     ** For 133MHz (7.5ns) operation:
  980.     **  3 clks RAS_precharge, Trp;
  981.     **  3 clks RAS_to_CAS_delay, Trcd-r;
  982.     **  8 clks RAS cycle time, Trc;
  983.     **  6 clks RAS Active time, Tras;
  984.     **  2 clks RAS_to_RAS_Active_delay, Trrd;
  985.     **  2 clks Last write to PRE/PALL period SDRAM, Twr;
  986.     **  2 clks CAS Latency;
  987.     ** 10 clks Auto Refresh RAS cycle time, Trfc;
  988.     **  Enable Write to Read interruption;
  989.     **  1 clk  Write to Read interruption, Twtr;
  990.     **  3 clks RAS_to_CAS_delay, Trcd-w;
  991.     ** (200/16)=3 clks Exit self-refresh to next command, Tsxsr;
  992.     */
  993.     STSYS_WriteRegDev32LE(LMI_STR, 0x35085235);
  995.     /* SDRAM Row Attribute 0 & 1 Registers
  996.     ** UBA = 32MB + Base Adr, Quad-bank, Shape 13x9,
  997.     ** Bank Remapping Disabled
  998.     **
  999.     **  LMI base address    0xC0000000
  1000.     **  Memory size 32MB    0x02000000
  1001.     **  Row UBA value       0xC200
  1002.     */
  1003. #ifdef SDRAM_64MB
  1004.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC0801400);
  1005. #elif defined (SDRAM_128MB)
  1006.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC1001500);
  1007. #elif defined(SDRAM_256MB)
  1008.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC2001900);
  1009. #elif defined(SDRAM_512MB)
  1010.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC4001a00);
  1011. #endif
  1014.     /*  We just have one Row connected to cs0, so we must program UBA0 = UBA1,
  1015.     **  following LMI specification
  1016.     */
  1017. #ifdef SDRAM_64MB
  1018.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC0801400);
  1019. #elif defined (SDRAM_128MB)
  1020.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC1001500);
  1021. #elif defined(SDRAM_256MB)
  1022.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC2001900);
  1023. #elif defined(SDRAM_512MB)
  1024.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC4001a00);
  1025. #endif
  1028.     /*---------------------------------------------------------------------------
  1029.     ** Initialisation Sequence for LMI & DDR-SDRAM Device
  1030.     **---------------------------------------------------------------------------
  1031.     ** 200 microseconds to settle clocks
  1032.     */
  1033.     Simudelay (100);
  1035.     /* SDRAM Control Register */
  1036.     /* Clock enable */
  1037.     STSYS_WriteRegDev32LE(LMI_SCR, 0x3);
  1039.     /* NOP enable */
  1040.     STSYS_WriteRegDev32LE(LMI_SCR, 0x1);
  1042.     /* Precharge all banks */
  1043.     STSYS_WriteRegDev32LE(LMI_SCR, 0x2);
  1045.     /* LMI_SDRAM_ROW_MODE0 & LMI_SDRAM_ROW_MODE1 Registers */
  1046.     /* EMRS Row 0 & 1: Weak Drive : Enable DLL */
  1047.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0402);
  1048.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0402);
  1049.     Simudelay (100);
  1051.     /* MRS Row 0 & 1 : Reset DLL - /CAS = 2.0, Mode Sequential, Burst Length 8 */
  1052.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0123);
  1053.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0123);
  1055.     /* 200 clock cycles required to lock DLL */
  1056.     Simudelay (100);
  1058.     /* Precharge all banks */
  1059.     STSYS_WriteRegDev32LE(LMI_SCR, 0x2);
  1061.     /* CBR enable (auto-refresh) */
  1062.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1063.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1064.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1066.     /* LMI_SDRAM_ROW_MODE0 & 1 Registers */
  1067.     /* MRS Row 0 & 1 : Normal - /CAS = 2.0, Mode Sequential, Burst Length 8 */
  1068.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0023);
  1069.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0023);
  1071.     /* Normal SDRAM operation, No burst Refresh after standby */
  1072.     STSYS_WriteRegDev32LE(LMI_SCR, 0x0);
  1073. }
  1075. /*-------------------------------------------------------------------------
  1076.  * Function : ST_5105_IniLMI_Cas25
  1077.  * Input    : None
  1078.  * Output   :
  1079.  * Return   : None
  1080.  * ----------------------------------------------------------------------*/
  1081. static void ST_5105_IniLMI_Cas25(void)
  1082. {
  1083.     volatile U32    data;
  1085.     /* "n Configuring LMI for 16-bit data CAS 2.5 @ 166MHz " */
  1087.     /* Set LMI_COC_UPPER Register, bits [63:32]   (LMI Pad logic) */
  1088.     STSYS_WriteRegDev32LE(LMI_COC_UPPER, 0x000C6750);
  1089.     /* Even Though its a 64 bit register the upper 32 bits are reserved and therefore no need to fill*/
  1091.     /* Set LMI_COC_LOWER Register, bits [31:0]  (LMI Pad logic)
  1092.     ** Bits [19:18] Compensation mode DDR
  1093.     ** Bits [17:16] Pad strenght         (0x0:5pF, 0x1:15pF, 0x2:25pF, Ox3:35pF)
  1094.     ** Bits [15:14] output Impedance (0x0:25Ohm, 0x1:40Ohm, 0x2:55Ohm, Ox3:70Ohm)
  1095.     ** Bit  [13]    DLL preset reset value enable
  1096.     */
  1097.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, 0x00002000);
  1098.     data = STSYS_ReadRegDev32LE(LMI_COC_LOWER);
  1099.     data = (data | 0x0<<16 | 0x0<<14);
  1100.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, data);
  1102.     /* SDRAM Mode Register
  1103.     ** Set Refresh Interval, Enable Refresh, 16-bit bus,
  1104.     ** Grouping Disabled, DDR-SDRAM, Enable.
  1105.     ** Bits[27:16]: Refresh Interval = 7.8 microseconds (8K/64ms)
  1106.     ** @  50MHz =  390 clk cycles -> 0x186
  1107.     ** @  75MHz =  585 clk cycles -> 0x249
  1108.     ** @ 100MHz =  780 clk cycles -> 0x30C
  1109.     ** @ 125MHz =  975 clk cycles -> 0x3CF
  1110.     ** @ 133MHz = 1040 clk cycles -> 0x410 
  1111.     ** @ 166MHz = 1300 clk cycles -> 0x514 <--
  1112.     */
  1113. #if defined( SDRAM_512MB ) || defined(SDRAM_256MB)
  1114.     STSYS_WriteRegDev32LE(LMI_MIM, 0x50F0203);
  1115. #elif defined(SDRAM_128MB) || defined(SDRAM_64MB)
  1116. STSYS_WriteRegDev32LE(LMI_MIM, 0x0A1E0203);
  1117. #endif
  1119.     /* SDRAM Timing Register
  1120.     ** For 133MHz (7.5ns) operation:
  1121.     **  3 clks RAS_precharge, Trp;
  1122.     **  3 clks RAS_to_CAS_delay, Trcd-r;
  1123.     **  8 clks RAS cycle time, Trc;
  1124.     **  6 clks RAS Active time, Tras;
  1125.     **  2 clks RAS_to_RAS_Active_delay, Trrd;
  1126.     **  2 clks Last write to PRE/PALL period SDRAM, Twr;
  1127.     **  2 clks CAS Latency;
  1128.     ** 10 clks Auto Refresh RAS cycle time, Trfc;
  1129.     **  Enable Write to Read interruption;
  1130.     **  1 clk  Write to Read interruption, Twtr;
  1131.     **  3 clks RAS_to_CAS_delay, Trcd-w;
  1132.     ** (200/16)=3 clks Exit self-refresh to next command, Tsxsr;
  1133.     */
  1135.     STSYS_WriteRegDev32LE(LMI_STR, 0x352D4345);
  1137.     /* SDRAM Row Attribute 0 & 1 Registers
  1138.     ** UBA = 32MB + Base Adr, Quad-bank, Shape 13x9,
  1139.     ** Bank Remapping Disabled
  1140.     **
  1141.     **  LMI base address    0xC0000000
  1142.     **  Memory size 32MB    0x02000000
  1143.     **  Row UBA value       0xC200
  1144.     */
  1145. #ifdef SDRAM_64MB
  1146.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC0801400);
  1147. #elif defined (SDRAM_128MB)
  1148.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC1001500);
  1149. #elif defined(SDRAM_256MB)
  1150.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC2001900);
  1151. #elif defined(SDRAM_512MB)
  1152.     STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC4001a00);
  1153. #endif
  1155.     /*  We just have one Row connected to cs0, so we must program UBA0 = UBA1,
  1156.     **  following LMI specification
  1157.     */
  1158. #ifdef SDRAM_64MB
  1159.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC0801400);
  1160. #elif defined (SDRAM_128MB)
  1161.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC1001500);
  1162. #elif defined(SDRAM_256MB)
  1163.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC2001900);
  1164. #elif defined(SDRAM_512MB)
  1165.     STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC4001a00);
  1166. #endif
  1168.     /*---------------------------------------------------------------------------
  1169.     ** Initialisation Sequence for LMI & DDR-SDRAM Device
  1170.     **---------------------------------------------------------------------------
  1171.     ** 200 microseconds to settle clocks
  1172.     */
  1173.     Simudelay (100);
  1175.     /* SDRAM Control Register */
  1176.     /* Clock enable */
  1177.     STSYS_WriteRegDev32LE(LMI_SCR, 0x3);
  1179.     /* NOP enable */
  1180.     STSYS_WriteRegDev32LE(LMI_SCR, 0x1);
  1182.     /* Precharge all banks */
  1183.     STSYS_WriteRegDev32LE(LMI_SCR, 0x2);
  1185.     /* LMI_SDRAM_ROW_MODE0 & LMI_SDRAM_ROW_MODE1 Registers */
  1186.     /* EMRS Row 0 & 1: Weak Drive : Enable DLL */
  1187.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0402);
  1188.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0402);
  1189.     //Simudelay (100);
  1191.     /* MRS Row 0 & 1 : Reset DLL - /CAS = 2.5, Mode Sequential, Burst Length 8 */
  1192.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0163);
  1193.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0163);
  1195.     /* 200 clock cycles required to lock DLL */
  1196.     Simudelay (100);
  1198.     /* Precharge all banks */
  1199.     STSYS_WriteRegDev32LE(LMI_SCR, 0x2);
  1201.     /* CBR enable (auto-refresh) */
  1202.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1203.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1204.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1206.     /* LMI_SDRAM_ROW_MODE0 & 1 Registers */
  1207.     /* MRS Row 0 & 1 : Normal - /CAS = 2.5, Mode Sequential, Burst Length 8 */
  1208.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0063);
  1209.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0063);
  1211.     /* Normal SDRAM operation, No burst Refresh after standby */
  1212.     STSYS_WriteRegDev32LE(LMI_SCR, 0x0);
  1213. }
  1216. /*-------------------------------------------------------------------------
  1217. * Function : ST_5105_InitFMI
  1218. * Input    : None
  1219. * Output   :
  1220. * Return   : None
  1221. * ----------------------------------------------------------------------*/
  1222. static void ST_5105_InitFMI(void)
  1223. {
  1224.     /* Ensure all FMI control registers are unlocked */
  1225.     /* at reset the state of these regs is 'undefined' */
  1227.     STSYS_WriteRegDev32LE(FMI_LOCK, 0x00000000);
  1228.     STSYS_WriteRegDev32LE(FMI_STATUSLOCK, 0x00000000); /*~!@#$%^&*()*/
  1230.     /* Number of FMI Banks : Enable all banks */
  1231.     STSYS_WriteRegDev32LE(BANKS_ENABLED, 0x00000004);
  1233.     /* FMI Bank base addresses
  1234.     ** NOTE: bits [0,7] define bottom address bits [22,29] of bank
  1235.     ** Bank 0 - 16MBytes Atapi Configured as 16-bit peripheral
  1236.     */
  1237.     STSYS_WriteRegDev32LE(BANK_0_TOP_ADDRESS, 0x00000003); /* 0x40000000 - 0x40FFFFFF */
  1239.     /* Bank 1 - 32MBytes Stem0/DVBCI/EPLD Configured as 16-bit peripheral */
  1240.     STSYS_WriteRegDev32LE(BANK_1_TOP_ADDRESS, 0x0000000B); /* 0x41000000 - 0x42FFFFFF */
  1242.     /* Bank 2 - 32MBytes Stem1 Configured as 16-bit peripheral */
  1243.     STSYS_WriteRegDev32LE(BANK_2_TOP_ADDRESS, 0x00000013); /* 0x43000000 - 0x44FFFFFF */
  1245.     /* Bank 3 - 8MBytes ST M58LW064D Flash */
  1246.     STSYS_WriteRegDev32LE(BANK_3_TOP_ADDRESS, 0x00000017); /* 0x45000000 - 0x45FFFFFF */
  1248.     /*------------------------------------------------------------------------------
  1249.     ## Program bank functions
  1250.     ##------------------------------------------------------------------------------
  1252.     ##------------------------------------------------------------------------------
  1253.     ## Bank 0 - 16MBytes Atapi Configured as 16-bit peripheral
  1254.     ##------------------------------------------------------------------------------
  1255.     ## Parameters: -weuseoeconfig 0 -waitpolarity 0 -latchpoint 16 -datadrivedelay 31
  1256.     ##             -busreleasetime 0 -csactive 3 -oeactive 3 -beactive 0 -portsize 16
  1257.     ##             -devicetype 1
  1259.     ##             -cyclenotphaseread 1 -accesstimeread 62 -cse1timeread 0
  1260.     ##             -cse2timeread 2 -oee1timeread 8 -oee2timeread 15 -bee1timeread 2
  1261.     ##             -bee2timeread 1
  1263.     ##             -cyclenotphasewrite 1 -accesstimewrite 62 -cse1timewrite 0
  1264.     ##             -cse2timewrite 2 -oee1timewrite 8 -oee2timewrite 15 -bee1timewrite 2
  1265.     ##             -bee2timewrite 2
  1267.     ##             -strobeonfalling 0 -burstsize 2 -datalatency 2 -dataholddelay 2
  1268.     ##             -burstmode 0
  1269.     */
  1270. #ifdef M29W320DB
  1271.     STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK0, 0x001016D1);
  1272. #else //TMTM 1MB type
  1273.     STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK0, 0x041016D1);  
  1274. #endif
  1275. //KCY 060921    STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK0, 0x9d200000);
  1276.     STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK0, 0x0c000000);
  1277.     STSYS_WriteRegDev32LE(FMICONFIGDATA2_BANK0, 0x9d220000);
  1278.     STSYS_WriteRegDev32LE(FMICONFIGDATA3_BANK0, 0x00000000);
  1280.     /*------------------------------------------------------------------------------
  1281.     ## Bank 1 - 32MBytes Stem0/DVBCI/EPLD Configured as 16-bit peripheral
  1282.     ##------------------------------------------------------------------------------
  1283.     ## Parameters: -weuseoeconfig 0 -waitpolarity 0 -latchpoint 1 -datadrivedelay 0
  1284.     ##             -busreleasetime 2 -csactive 3 -oeactive 1 -beactive 2 -portsize 16
  1285.     ##             -devicetype 1
  1287.     ##             -cyclenotphaseread 1 -accesstimeread 1d -cse1timeread 2
  1288.     ##             -cse2timeread 0 -oee1timeread 0 -oee2timeread 0 -bee1timeread 0
  1289.     ##             -bee2timeread 0
  1291.     ##             -cyclenotphasewrite 1 -accesstimewrite 1d -cse1timewrite 2
  1292.     ##             -cse2timewrite 2 -oee1timewrite 0 -oee2timewrite 0 -bee1timewrite 0
  1293.     ##             -bee2timewrite 0
  1295.     ##             -strobeonfalling 0 -burstsize 0 -datalatency 0 -dataholddelay 0
  1296.     ##             -burstmode 0
  1297.     */
  1298.     //STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK1, 0x00101699);  /*BE not active during rd */
  1299.     //STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK1, 0xBE426200);
  1300.     //STSYS_WriteRegDev32LE(FMICONFIGDATA2_BANK1, 0xBE426200);
  1301.     //STSYS_WriteRegDev32LE(FMICONFIGDATA3_BANK1, 0x00000000);
  1302.     STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK1, 0x05001ed1);  /*BE not active during rd */
  1303.     STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK1, 0xa0000000);
  1304.     STSYS_WriteRegDev32LE(FMICONFIGDATA2_BANK1, 0xa0000000);
  1305.     STSYS_WriteRegDev32LE(FMICONFIGDATA3_BANK1, 0x00000000);
  1307.     /*------------------------------------------------------------------------------
  1308.     ## Bank 2 - 32MBytes Stem1 Configured as 16-bit peripheral
  1309.     ##------------------------------------------------------------------------------
  1310.     ## Parameters: -weuseoeconfig 0 -waitpolarity 0 -latchpoint 1 -datadrivedelay 0
  1311.     ##             -busreleasetime 2 -csactive 3 -oeactive 1 -beactive 2 -portsize 16
  1312.     ##             -devicetype 1
  1314.     ##             -cyclenotphaseread 1 -accesstimeread 1d -cse1timeread 2
  1315.     ##             -cse2timeread 0 -oee1timeread 0 -oee2timeread 0 -bee1timeread 0
  1316.     ##             -bee2timeread 0
  1318.     ##             -cyclenotphasewrite 1 -accesstimewrite 1d -cse1timewrite 2
  1319.     ##             -cse2timewrite 2 -oee1timewrite 0 -oee2timewrite 0 -bee1timewrite 0
  1320.     ##             -bee2timewrite 0
  1322.     ##             -strobeonfalling 0 -burstsize 0 -datalatency 0 -dataholddelay 0
  1323.     ##             -burstmode 0
  1324.     */
  1325.     STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK2, 0x001016D1);  /* BE not active during rd */
  1326.     STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK2, 0x9d200000);
  1327.     STSYS_WriteRegDev32LE(FMICONFIGDATA2_BANK2, 0x9d220000);
  1328.     STSYS_WriteRegDev32LE(FMICONFIGDATA3_BANK2, 0x00000000);
  1330.     /* FMI Bank 3 8MBytes ST M58LW064D Flash - ONLY 8MBytes FLASH ON BOARD THIS MAY BE WRONG!
  1331.     ##------------------------------------------------------------------------------
  1332.     ## Bank 3 - 8MBytes ST M58LW064D Flash
  1333.     ##------------------------------------------------------------------------------
  1334.     ## Parameters: -weuseoeconfig 0 -waitpolarity 0 -latchpoint 1 -datadrivedelay 0
  1335.     ##             -busreleasetime 2 -csactive 3 -oeactive 1 -beactive 2 -portsize 16
  1336.     ##             -devicetype 1
  1338.     ##             -cyclenotphaseread 1 -accesstimeread 1d -cse1timeread 2
  1339.     ##             -cse2timeread 0 -oee1timeread 0 -oee2timeread 0 -bee1timeread 0
  1340.     ##             -bee2timeread 0
  1342.     ##             -cyclenotphasewrite 1 -accesstimewrite 1d -cse1timewrite 2
  1343.     ##             -cse2timewrite 2 -oee1timewrite 0 -oee2timewrite 0 -bee1timewrite 0
  1344.     ##             -bee2timewrite 0
  1346.     ##             -strobeonfalling 0 -burstsize 0 -datalatency 0 -dataholddelay 0
  1347.     ##             -burstmode 0
  1348.     */
  1349.     STSYS_WriteRegDev32LE(FMICONFIGDATA0_BANK3, 0x01008791);
  1350.     STSYS_WriteRegDev32LE(FMICONFIGDATA1_BANK3, 0x44618f00);
  1351.     STSYS_WriteRegDev32LE(FMICONFIGDATA2_BANK3, 0x44618f00);
  1352.     STSYS_WriteRegDev32LE(FMICONFIGDATA3_BANK3, 0x0000000A);
  1354.     /*  ------- Program Other FMI Registers --------
  1355.     ** sdram refresh bank 5
  1356.     ** flash runs @ 1/3 bus clk
  1357.     ** sdram runs @ bus clk
  1358.     */
  1359.     STSYS_WriteRegDev32LE(FMI_GENCFG, 0x00000000);
  1360.     STSYS_WriteRegDev32LE(FMI_FLASHCLKSEL, 0x00000002);
  1361.     /*STSYS_WriteRegDev32LE(FMI_CLKENABLE, 0x00000000);*/
  1363. #if 0
  1364.     /* Reset flash Banks */
  1365.     STSYS_WriteRegMem32LE(FLASH_EPLD_FLASH, 0x00000000);
  1366.     STSYS_WriteRegMem32LE(FLASH_EPLD_FLASH, 0x03030303);
  1367. #endif
  1368. }
  1370. /***leslie---------------------------------------------------------------------------- ## Procedure Name : ST_5105_IniLMI_Reg ## Purpose  : Initialisation Registers of LMI ## Note  :  ## ##  (LMI Spec: ADCS 7483542) ##----------------------------------------------------------------------------   ***/ static void ST_5105_IniLMI_Reg(void)
  1371. {     volatile U32 data;
  1372.     volatile U8 tRP, tRCDR, tRC, tRAS, tRRD, tWR, tRFC, tWTR, tRCDW, tSXSR, sCL;
  1374.     STSYS_WriteRegDev32LE(LMI_COC_UPPER, 0x000C6750);
  1376.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, 0x00002000);
  1377.     data = STSYS_ReadRegDev32LE(LMI_COC_LOWER);
  1378.     data = (data | 0x0<<16 | 0x0<<14);
  1379.     STSYS_WriteRegDev32LE(LMI_COC_LOWER, data);
  1381. #if 0 //TMTM original
  1382.     STSYS_WriteRegDev32LE(LMI_MIM, 0x8200201);  /* 64ms/4K cycle */    
  1383.     STSYS_WriteRegDev32LE(LMI_STR, 0x35085235); 
  1385. #ifdef SDARM_64MB    
  1386. STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC0801400); /* 64MB */
  1387.   STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC0801400); /* 64MB */
  1388.   #else
  1389.   STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC1001500); /* 128MB */
  1390. STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC1001500); /*128MBDDR */
  1391. #endif
  1393. #else
  1395. #ifdef DDR_SDRAM //TMTM
  1396. data = 2;
  1397. #else
  1398. data = 0;
  1399. #endif
  1401. #ifdef SDRAM_FREQ_CONFIG_133
  1402. STSYS_WriteRegDev32LE(LMI_MIM, 0x08200201 |data);  /* 64ms/4K cycle */
  1403. tRP = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_precharge
  1404. tRCDR = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_to_CAS_delay
  1405. tRC = 3; //0b0011;  // 9 cloks,  60ns -- ,             RAS cycle time
  1406. tRAS = 2; //0b010;  // 6 clocks, 42ns -- 120000ns ,    RAS Active time
  1407. tRRD = 0; // 2 clocks, 12ns -- ,             RAS_to_RAS_Active_delay
  1408. tWR = 1; //0b01; // 2 clocks, 15ns -- ,             Last write to PRE/PALL period SDRAM
  1409. tRFC = 4; //0b100; // 10 clocks,72ns -- ,             Auto Refresh RAS cycle time
  1410. tWTR = 0; // 1 clock,  1ns  -- ,             Write to Read interruption, Twtr
  1411. tRCDW = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_to_CAS_delay
  1412. tSXSR = 13;     // 200ns/16 ,                      Exit self-refresh to next command
  1413. #elif defined (SDRAM_FREQ_CONFIG_120)
  1414. STSYS_WriteRegDev32LE(LMI_MIM, 0x07A10201 |data);  /* 64ms/4K cycle */
  1415. tRP = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_precharge
  1416. tRCDR = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_to_CAS_delay
  1417. tRC = 2; //0b0010; // 8 cloks,  60ns -- ,             RAS cycle time
  1418. tRAS = 3; //0b011; // 7 clocks, 42ns -- 120000ns ,    RAS Active time
  1419. tRRD = 0; // 2 clocks, 12ns -- ,             RAS_to_RAS_Active_delay
  1420. tWR = 1; //0b01; // 2 clocks, 15ns -- ,             Last write to PRE/PALL period SDRAM
  1421. tRFC = 4; //0b100; // 10 clocks,72ns -- ,             Auto Refresh RAS cycle time
  1422. tWTR = 0; // 1 clock,  1ns  -- ,             Write to Read interruption, Twtr
  1423. tRCDW = 1; //0b01; // 2 clocks, 18ns -- ,             RAS_to_CAS_delay
  1424. tSXSR = 13; // 200ns/16 ,                      Exit self-refresh to next command
  1425. #elif defined (SDRAM_FREQ_CONFIG_166)
  1426. #if defined( SDRAM_512MB ) || defined(SDRAM_256MB)
  1427.      STSYS_WriteRegDev32LE(LMI_MIM, 0x50F0201 | data);
  1428. #elif defined(SDRAM_128MB) || defined(SDRAM_64MB)
  1429. STSYS_WriteRegDev32LE(LMI_MIM, 0x0A220201 | data);
  1430. /*STSYS_WriteRegDev32LE(LMI_MIM, 0x0A1E0201 | data);*/
  1432. #endif
  1433. #if 0
  1434. tRP = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_precharge
  1435. tRCDR = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_to_CAS_delay
  1436. tRC = 3; //0b0011; // 9 cloks,  60ns -- ,             RAS cycle time
  1437. tRAS = 3; //0b011; // 7 clocks, 42ns -- 120000ns ,    RAS Active time
  1438. tRRD = 0; // 2 clocks, 12ns -- ,             RAS_to_RAS_Active_delay
  1439. tWR = 2; //0b10; // 3 clocks, 15ns -- ,             Last write to PRE/PALL period SDRAM
  1440. tRFC = 6; //0b110; // 12 clocks,72ns -- ,             Auto Refresh RAS cycle time
  1441. tWTR = 0; // 1 clock,  1ns  -- ,             Write to Read interruption, Twtr
  1442. tRCDW = 1; //0b01; // 3 clocks, 18ns -- ,             RAS_to_CAS_delay
  1443. tSXSR = 13; // 200ns/16 ,                      Exit self-refresh to next command
  1444. #endif
  1446. #ifdef SDRAM_CAS_2_0
  1447. sCL = 2;  //0b0010;  // 2 clocks,                       CAS Latency
  1448. #elif defined (SDRAM_CAS_2_5)
  1449. sCL = 0xA; //0b1010; // 2.5 clocks,                     CAS Latency
  1450. #elif defined (SDRAM_CAS_3_0)
  1451. sCL = 0x3; //0b0011; // 3 clocks,                       CAS Latency
  1452. #endif
  1454. data = (tRP<<0) | (tRCDR<<2) | (tRC<<4) | (tRAS<<8) | (tRRD<<11) | ( (tWR&1) <<12) | (sCL<<13) | (tRFC<<17) | ( ((tWR&2)>>1) <<21) | (tWTR<<23) | (tRCDW<<24) | (tSXSR<<26) ;
  1455. data = data | (1 << 22) ; // Enable Write to Read interruption
  1456. STSYS_WriteRegDev32LE(LMI_STR, data); 
  1457. #endif
  1458. //STSYS_WriteRegDev32LE(LMI_STR, 0x30087345); 
  1459. STSYS_WriteRegDev32LE(LMI_STR, 0x35087345); 
  1461. #ifdef SDRAM_64MB    
  1462. STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC0801400); /* 64MB */
  1463. STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC0801400); /* 64MB */
  1464. #elif defined (SDRAM_128MB)
  1465. STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC1001500); /* 128MB */
  1466. STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC1001500); /* 128MB */
  1467. #elif defined (SDRAM_256MB)
  1468. STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC2001900); /* 256Mb */
  1469. STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC2001900); /* 256Mb */
  1470. #elif defined (SDRAM_256MB)
  1471. STSYS_WriteRegDev32LE(LMI_SDRA0, 0xC4001a00); /* 512Mb */
  1472. STSYS_WriteRegDev32LE(LMI_SDRA1, 0xC4001a00); /* 512Mb */
  1473. #endif
  1474. #endif
  1476. }
  1477. /*##---------------------------------------------------------------------------- ## Procedure Name : ST_5105_IniLMI_PC_SDRAM ## Purpose  : Initialisation of LMI for the PC SDRAM on MB400 board ## Note  :  ## ##  (LMI Spec: ADCS 7483542) ##----------------------------------------------------------------------------*/ static void ST_5105_IniLMI_PC_SDRAM(void)
  1478. {     /*** Initialisation Registers of LMI***/     ST_5105_IniLMI_Reg();     /*---------------------------------------------------------------------------
  1479.     ** Initialisation Sequence for LMI & DDR-SDRAM Device
  1480.     **---------------------------------------------------------------------------
  1481.     ** 200 microseconds to settle clocks
  1482.     */
  1483.     Simudelay (100);
  1485.     /* SDRAM Control Register */
  1486.     /* Clock enable */
  1487.     STSYS_WriteRegDev32LE(LMI_SCR, 0x3);
  1488.     
  1489.     Simudelay (100);
  1490.     
  1491.     STSYS_WriteRegDev32LE(LMI_SCR, 0x2);
  1492.     
  1493.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1494.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1495.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1496.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1497.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1498.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1499.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1500.     STSYS_WriteRegDev32LE(LMI_SCR, 0x4);
  1501.     
  1502. #ifdef SDRAM_CAS_2_0
  1503. // MRS Row 0 & 1 : Reset DLL - /CAS = 2.0, Mode Sequential, Burst Length 8
  1504.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0023);
  1505.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0023);
  1506. #elif defined (SDRAM_CAS_2_5)
  1507. //MRS Row 0 & 1 : Reset DLL - /CAS = 2.5, Mode Sequential, Burst Length 8
  1508.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0063);
  1509.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0063);
  1510. #else //SDRAM_CAS_3_0
  1511. //MRS Row 0 & 1 : Reset DLL - /CAS = 3.0, Mode Sequential, Burst Length 8
  1512.     STSYS_WriteRegDev32LE(LMI_SDMR0, 0x0033);
  1513.     STSYS_WriteRegDev32LE(LMI_SDMR1, 0x0033);
  1514. #endif
  1516. } /**##################leslie################**/
  1519. /* EOF --------------------------------------------------------------------- */