program_evm: Add gel files copied from emupack
[keystone-rtos/mcsdk-tools.git] / program_evm / gel / tcievmk2l.gel
1 /******************************************************************************
2  * Copyright (c) 2014 Texas Instruments Incorporated - http://www.ti.com
3  * 
4  *  Redistribution and use in source and binary forms, with or without 
5  *  modification, are permitted provided that the following conditions 
6  *
7  *  are met:
8  *
9  *    Redistributions of source code must retain the above copyright 
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  *
13  *    Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the     
15  *    documentation and/or other materials provided with the   
16  *
17  *    distribution.
18  *
19  *
20  *    Neither the name of Texas Instruments Incorporated nor the names of
21  *    its contributors may be used to endorse or promote products derived
22  *    from this software without specific prior written permission.
23  *
24  *
25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
26  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
27  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
29  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
30  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
31  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
34  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
35  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  * 
37  *****************************************************************************
38  *
39  *  Filename:           evmtci6630k2l.gel
40  *  Description:        Utility GEL for use with the TCI6630k2l EVM. This GEL has 
41  *                                      functions that initialize the chip PLL's and the DDR3A  interfaces. 
42  *                                              
43  *                                      It also includes general utilities that are useful for EVM development
44  *                        
45  *                      More functions will be added as needed. 
46  *        
47  *      Author: Texas instruments                 
48  *      Revision History: 
49  *                    v1.0 - Initial Revision: Includes functions for Core PLL Init, DDR1066,DDR1600
50  *                    v1.1 - Functions for DDR1333, Enable all PSC, Set Tetris PLL
51  *                                        v1.2 - Function for DFE PLL Setup
52  *                    v1.3 - Modified Ethernet PHY setup function to use MDIO
53  *
54  * ---------------------------------------------------------------------------*/
56 #define GEL_VERSION         1.3
58 // Timeout definitions
59 int _GEL_Global_Timeout1 = 0;
61 #define TIMEOUT_ID 10
62 // Global timeout value
63 #define GTIMEOUT 2000
64 //*****************************************************
65 // Power definitions
66 #define PSC_BASE            0x02350000
67 #define PSC_PTCMD           *( unsigned int* )( PSC_BASE+0x120 )
68 #define PSC_PTSTAT          *( unsigned int* )( PSC_BASE+0x128 )
69 #define PSC_PDCTL_BASE      ( PSC_BASE+0x300 )
70 #define PSC_MDSTAT_BASE     ( PSC_BASE+0x800 )
71 #define PSC_MDCTL_BASE      ( PSC_BASE+0xA00 )
72 // Modules on power domain 0
73 // Always on
74 // Modules on power domain 1
75 #define LPSC_DEBUG     (5)
76 #define LPSC_TETB      (6)
77 // Modules on power domain 2
78 #define LPSC_PA        (7)
79 #define LPSC_SGMII     (8)
80 #define LPSC_SA        (9)
81 // Modules on power domain 3 
82 #define LPSC_PCIE_0      (10)      
83 // Modules on power domain 4
84 #define LPSC_PCIE_1      (11)      
85 // Modules on power domain 5
86 #define LPSC_DFE_PD2       (12)
87 // Modules on power domain 6
88 #define LPSC_SR     (13)
89 // Modules on power domain 7
90 #define LPSC_MSMCRAM   (14)
91 // Modules on power domain 8
92 #define LPSC_GEM_0   (15)
93 // Modules on power domain 9
94 #define LPSC_GEM_1   (16)
95 // Modules on power domain 10
96 #define LPSC_GEM_2   (17)
97 // Modules on power domain 11
98 #define LPSC_GEM_3   (18)
99 // Modules on power domain 16
100 #define LPSC_DDR3_0      (23)
101 // Modules on power domain 17
102 #define LPSC_TAC       (25)
103 #define LPSC_RAC_0       (26)
104 // Modules on power domain 18
105 #define LPSC_DFE_PD0       (27)
106 // Modules on power domain 19
107 #define LPSC_FFTCA_FFTC_0 (28)
108 // Modules on power domain 21
109 #define LPSC_OSR      (34)
110 // Modules on power domain 22
111 #define LPSC_TCP3D_0      (35)
112 // Modules on power domain 23
113 #define LPSC_TCP3D_1      (37)
114 // Modules on power domain 24
115 #define LPSC_VCP_0      (39)
116 #define LPSC_VCP_1      (40)
117 #define LPSC_VCP_2      (41)
118 #define LPSC_VCP_3      (42)
119 // Modules on power domain 26
120 #define LPSC_BCP     (47)
121 // Modules on power domain 27
122 #define LPSC_DFE_PD1       (48)
123 // Modules on power domain 28
124 #define LPSC_FFTCA_FFTC_1      (49)
125 // Modules on power domain 29
126 #define LPSC_IQN_AIL            (50)
127 // Modules on power domain 31
128 #define LPSC_ARM    (52)
129 // Power domains definitions
130 #define PD0         (0)     // Power Domain-0
131 #define PD1         (1)     // Power Domain-1
132 #define PD2         (2)     // Power Domain-2
133 #define PD3         (3)     // Power Domain-3
134 #define PD4         (4)     // Power Domain-4
135 #define PD5         (5)     // Power Domain-5
136 #define PD6         (6)     // Power Domain-6
137 #define PD7         (7)     // Power Domain-7
138 #define PD8         (8)     // Power Domain-8
139 #define PD9         (9)     // Power Domain-9
140 #define PD10        (10)    // Power Domain-10
141 #define PD11        (11)    // Power Domain-11
142 #define PD12        (12)    // Power Domain-12
143 #define PD13        (13)    // Power Domain-13
144 #define PD14        (14)    // Power Domain-14
145 #define PD15        (15)    // Power Domain-15
146 #define PD16        (16)    // Power Domain-16
147 #define PD17        (17)    // Power Domain-17
148 #define PD18        (18)    // Power Domain-18
149 #define PD19        (19)    // Power Domain-19
150 #define PD20        (20)    // Power Domain-20
151 #define PD21        (21)    // Power Domain-21
152 #define PD22        (22)    // Power Domain-22
153 #define PD23        (23)    // Power Domain-23
154 #define PD24        (24)    // Power Domain-24
155 #define PD25        (25)    // Power Domain-25
156 #define PD26        (26)    // Power Domain-26
157 #define PD27        (27)    // Power Domain-27
158 #define PD28        (28)    // Power Domain-28
159 #define PD29        (29)    // Power Domain-29
160 #define PD30        (30)    // Power Domain-30
161 #define PD31        (31)    // Power Domain-31
162 #define PSC_SYNCRESET (0x1)
163 #define PSC_DISABLE   (0x2)
164 #define PSC_ENABLE    (0x3)
165 #define CHIP_LEVEL_REG              0x02620000
167 /******************* PLL registers **********************************/
168 /*Boot cfg registers*/
169 #define KICK0                       *(unsigned int*)(CHIP_LEVEL_REG + 0x0038)
170 #define KICK1                       *(unsigned int*)(CHIP_LEVEL_REG + 0x003C)
171 #define KICK0_UNLOCK                (0x83E70B13)
172 #define KICK1_UNLOCK                (0x95A4F1E0)
173 #define KICK_LOCK                   0
174 #define TINPSEL                     *(unsigned int*)(CHIP_LEVEL_REG + 0x0300)
175 #define TOUTPSEL                    *(unsigned int*)(CHIP_LEVEL_REG + 0x0304)
176 #define MAINPLLCTL0                 *(unsigned int*)(CHIP_LEVEL_REG + 0x0350) //0x0328)
177 #define MAINPLLCTL1                 *(unsigned int*)(CHIP_LEVEL_REG + 0x0354) //0x032C)
178 #define MAIN_PLLD_OFFSET            0
179 #define MAIN_PLLD_MASK              0xFFFFFFC0
180 #define MAIN_PLLM_OFFSET            12
181 #define MAIN_PLLM_MASK              0xFFF80FFF
182 #define MAIN_BWADJ0_OFFSET          24
183 #define MAIN_BWADJ0_MASK            0x00FFFFFF
184 #define MAIN_ENSAT_OFFSET           6
185 #define MAIN_ENSAT_MASK             0xFFFFFFBF
186 #define MAIN_BWADJ1_OFFSET          0
187 #define MAIN_BWADJ1_MASK            0xFFFFFFF0
188 #define OBSCLKCTL                   *(unsigned int*)(CHIP_LEVEL_REG + 0x0C80)
190 /* PA PLL Registers */
191 #define BYPASS_BIT_SHIFT 23
192 #define CLKF_BIT_SHIFT   6
193 #define CLKD_BIT_SHIFT   0
194 #define DEVSTAT    (*((unsigned int *) 0x02620020))
195 #define PAPLLCTL0                 *(unsigned int*)(CHIP_LEVEL_REG + 0x0358) 
196 #define PAPLLCTL1                 *(unsigned int*)(CHIP_LEVEL_REG + 0x035C) 
197 #define PASSCLKSEL_MASK    (1 << 17)    /* Tells the configuration of the PASSCLKSEL pin */
198 #define PA_PLL_BYPASS_MASK (1 << BYPASS_BIT_SHIFT)    /* Tells whether the PA PLL is in BYPASS mode or not */
199 #define PA_PLL_CLKOD_MASK  (0x00780000) /* Tells the output divider value for the PA PLL */
200 #define PA_PLL_CLKF_MASK   (0x0007FFC0) /* Tells the multiplier value for the PA PLL */
201 #define PA_PLL_CLKR_MASK   (0x0000003F) /* Tells the divider value for the PA PLL */
202 #define PA_PLL_RESET_MASK  (0x00004000)
203 #define CHIP_MISC1                  *(unsigned int*)(CHIP_LEVEL_REG + 0x0C7C)
204 #define ARMPLL_ENABLE_OFFSET        13
205 #define DDR3APLLCTL0                    *(unsigned int*)(CHIP_LEVEL_REG + 0x0360)
206 #define DDR3APLLCTL1                    *(unsigned int*)(CHIP_LEVEL_REG + 0x0364)
207 #define DFEPLLCTL0                  (unsigned int*)(CHIP_LEVEL_REG + 0x378)
208 #define DFEPLLCTL1                  (unsigned int*)(CHIP_LEVEL_REG + 0x37C)
209 #define DFE_CLKDIV_CTL              (unsigned int*)(CHIP_LEVEL_REG + 0x6E8)
210 #define DFE_CLKSYNC_CTL             (unsigned int*)(CHIP_LEVEL_REG + 0x6EC)
211 //******************************************************
212 // PLL 1 definitions (DSP and ARM clock and subsystems)
213 #define PLL1_BASE                   0x02310000
214 #define PLL1_PLLCTL                 (*(unsigned int*)(PLL1_BASE + 0x100))   // PLL1 Control
215 #define PLL1_SECCTL                 (*(unsigned int*)(PLL1_BASE + 0x108))   // PLL1 Secondary Control
216 #define PLL1_PLLM                   (*(unsigned int*)(PLL1_BASE + 0x110))   // PLL1 Multiplier
217 #define PLL1_DIV1                   (*(unsigned int*)(PLL1_BASE + 0x118))   // DIV1 divider
218 #define PLL1_DIV2                   (*(unsigned int*)(PLL1_BASE + 0x11C))   // DIV2 divider
219 #define PLL1_DIV3                   (*(unsigned int*)(PLL1_BASE + 0x120))   // DIV3 divider
220 #define PLL1_CMD                    (*(unsigned int*)(PLL1_BASE + 0x138))   // CMD control
221 #define PLL1_STAT                   (*(unsigned int*)(PLL1_BASE + 0x13C))   // STAT control
222 #define PLL1_ALNCTL                 (*(unsigned int*)(PLL1_BASE + 0x140))   // ALNCTL control
223 #define PLL1_DCHANGE                (*(unsigned int*)(PLL1_BASE + 0x144))   // DCHANGE status
224 #define PLL1_CKEN                   (*(unsigned int*)(PLL1_BASE + 0x148))   // CKEN control
225 #define PLL1_CKSTAT                 (*(unsigned int*)(PLL1_BASE + 0x14C))   // CKSTAT status
226 #define PLL1_SYSTAT                 (*(unsigned int*)(PLL1_BASE + 0x150))   // SYSTAT status
227 #define PLL1_DIV4                   (*(unsigned int*)(PLL1_BASE + 0x160))   // DIV4 divider
228 #define PLL1_DIV5                   (*(unsigned int*)(PLL1_BASE + 0x164))   // DIV5 divider
229 #define PLL1_DIV6                   (*(unsigned int*)(PLL1_BASE + 0x168))   // DIV6 divider
230 #define PLL1_DIV7                   (*(unsigned int*)(PLL1_BASE + 0x16C))   // DIV7 divider
231 #define PLL1_DIV8                   (*(unsigned int*)(PLL1_BASE + 0x170))   // DIV8 divider
232 #define PLL1_DIV9                   (*(unsigned int*)(PLL1_BASE + 0x174))   // DIV9 divider
233 #define PLL1_DIV10                  (*(unsigned int*)(PLL1_BASE + 0x178))   // DIV10 divider
234 #define PLL1_DIV11                  (*(unsigned int*)(PLL1_BASE + 0x17C))   // DIV11 divider
235 #define PLL1_DIV12                  (*(unsigned int*)(PLL1_BASE + 0x180))   // DIV12 divider
236 #define PLL1_DIV13                  (*(unsigned int*)(PLL1_BASE + 0x184))   // DIV13 divider
237 #define PLL1_DIV14                  (*(unsigned int*)(PLL1_BASE + 0x188))   // DIV14 divider
238 #define PLL1_DIV15                  (*(unsigned int*)(PLL1_BASE + 0x18C))   // DIV15 divider
239 #define PLL1_DIV16                  (*(unsigned int*)(PLL1_BASE + 0x190))   // DIV16 divider
240 #define PLLPWRDN_OFFSET             1
241 #define PLLPWRDN_MASK               0xFFFFFFFD
242 #define PLLRST_OFFSET               3
243 #define PLLRST_MASK                 0xFFFFFFF7
244 #define PLLENSRC_OFFSET             5
245 #define PLLENSRC_MASK               0xFFFFFFDF
246 #define PLLEN_OFFSET                0
247 #define PLLEN_MASK                  0xFFFFFFFE
248 #define OUTPUT_DIVIDE_OFFSET        19
249 #define OUTPUT_DIVIDE_MASK          0xFF87FFFF    
250 #define BYPASS_OFFSET               23
251 #define BYPASS_MASK                 0xFF7FFFFF
252 #define PLLM_OFFSET                 0
253 #define PLLM_MASK                   0xFFFFFFC0
254 #define GOSET_OFFSET                0
255 #define GOSET_MASK                  0xFFFFFFFE
256 #define GOSTAT_OFFSET               0
257 #define GOSTAT_MASK                 0xFFFFFFFE
258 #define OUTPUT_DIVIDE_OFFSET        19
259 #define OUTPUT_DIVIDE_MASK          0xFF87FFFF   
260 // ARMPLL definitions
261 #define SEC_PLLCTL0_PLLM_OFFSET     6
262 #define SEC_PLLCTL0_PLLM_MASK       0xFFFF003F
263 #define SEC_PLLCTL0_BWADJ_OFFSET    24
264 #define SEC_PLLCTL0_BWADJ_MASK      0x00FFFFFF
265 #define SEC_PLLCTL0_OD_OFFSET       19
266 #define SEC_PLLCTL0_OD_MASK         0xFF87FFFF
267 #define SEC_PLLCTL0_BYPASS_OFFSET   23
268 #define SEC_PLLCTL0_BYPASS_MASK     0xFF7FFFFF
269 #define SEC_PLLCTL1_RESET_OFFSET    14
270 #define SEC_PLLCTL1_RESET_MASK      0xFFFFBFFF
271 #define SEC_PLLCTL1_PWRDWN_OFFSET   15
272 #define SEC_PLLCTL1_PWRDWN_MASK     0xFFFF7FFF
273 #define SEC_PLLCTL1_ENSTAT_OFFSET   6
274 #define SEC_PLLCTL1_ENSTAT_MASK     0xFFFFFFBF
275 /*----------------DDR3A Register definition---------------------*/
276 #define DDR3A_BASE_ADDR (0x21010000)
277 #define DDR3A_STATUS   (*(int*)(DDR3A_BASE_ADDR + 0x00000004))
278 #define DDR3A_SDCFG    (*(int*)(DDR3A_BASE_ADDR + 0x00000008))
279 #define DDR3A_SDRFC    (*(int*)(DDR3A_BASE_ADDR + 0x00000010))
280 #define DDR3A_SDTIM1   (*(int*)(DDR3A_BASE_ADDR + 0x00000018))
281 #define DDR3A_SDTIM2   (*(int*)(DDR3A_BASE_ADDR + 0x0000001C))
282 #define DDR3A_SDTIM3   (*(int*)(DDR3A_BASE_ADDR + 0x00000020))
283 #define DDR3A_SDTIM4   (*(int*)(DDR3A_BASE_ADDR + 0x00000028))
284 #define DDR3A_ZQCFG    (*(int*)(DDR3A_BASE_ADDR + 0x000000C8))
285 #define DDR3A_TMPALRT  (*(int*)(DDR3A_BASE_ADDR + 0x000000CC))
286 #define DDR3A_DDRPHYC  (*(int*)(DDR3A_BASE_ADDR + 0x000000E4))
287 #define DDR3A_PHY_CFG_BASE (0x02329000)
288 #define DDR3A_PIR    (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000004))
289 #define DDR3A_PGCR0  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000008))
290 #define DDR3A_PGCR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000000C))
291 #define DDR3A_PGCR2  (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000008C))
292 #define DDR3A_PGSR0  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000010))
293 #define DDR3A_PGSR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000014))
294 #define DDR3A_PLLCR  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000018))
295 #define DDR3A_PTR0   (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000001C))
296 #define DDR3A_PTR1   (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000020))
297 #define DDR3A_PTR2   (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000024))
298 #define DDR3A_PTR3   (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000028))
299 #define DDR3A_PTR4   (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000002C))
300 #define DDR3A_DSGCR  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000040))
301 #define DDR3A_DCR    (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000044))
302 #define DDR3A_MR0    (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000054))
303 #define DDR3A_MR1    (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000058))
304 #define DDR3A_MR2    (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000005C))
305 #define DDR3A_DTCR   (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000068))
306 #define DDR3A_DTPR0  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000048))
307 #define DDR3A_DTPR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x0000004C))
308 #define DDR3A_DTPR2  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000050))
309 #define DDR3A_ZQ0CR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000184))
310 #define DDR3A_ZQ1CR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000194))
311 #define DDR3A_ZQ2CR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x000001A4))
312 #define DDR3A_ZQ3CR1  (*(int*)(DDR3A_PHY_CFG_BASE + 0x000001B4))
313 #define DDR3A_DATX8_8 (*(int*)(DDR3A_PHY_CFG_BASE + 0x000003C0))
314 #define DDR3_TEST_START_ADDRESS (*(int*)(0x80000000))
315 #define IODDRM_MASK            0x00000180  
316 #define ZCKSEL_MASK            0x01800000
317 #define CL_MASK                            0x00000072
318 #define WR_MASK                            0x00000E00
319 #define BL_MASK                            0x00000003
320 #define RRMODE_MASK            0x00040000
321 #define UDIMM_MASK             0x20000000
322 #define BYTEMASK_MASK          0x0000FC00
323 #define MPRDQ_MASK             0x00000080
324 #define PDQ_MASK               0x00000070
325 #define NOSRA_MASK             0x08000000
326 #define ECC_MASK               0x00000001
327 #define RRMODE_MASK            0x00040000
328 #define DDR3A_DX0GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x000001C4)) //0x71
329 #define DDR3A_DX1GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000204)) //0x81
330 #define DDR3A_DX2GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000244)) //0x91
331 #define DDR3A_DX3GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000284)) //0xA1
332 #define DDR3A_DX4GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x000002C4)) //0xB1
333 #define DDR3A_DX5GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000304)) //0xC1
334 #define DDR3A_DX6GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000344)) //0xD1
335 #define DDR3A_DX7GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x00000384)) //0xE1
336 #define DDR3A_DX8GSR0 (*(int*)(DDR3A_PHY_CFG_BASE + 0x000003C4)) //0xF1
337 #define DDR3A_TEST_START_ADDRESS (0x80000000)
338 #define DDR3A_TEST_END_ADDRESS   (DDR3A_TEST_START_ADDRESS + (4 * 100))
339 #define DDR3A_BASE_ADDRESS        0x80000000
340 #define TETRIS_BASE                 0x01E80000
341 #define TETRIS_CPU0_PTCMD           *(unsigned int*)(TETRIS_BASE + 0x0400)
342 #define TETRIS_CPU0_PDSTAT          *(unsigned int*)(TETRIS_BASE + 0x0404)
343 #define TETRIS_CPU0_PDCTL           *(unsigned int*)(TETRIS_BASE + 0x0408)
344 #define TETRIS_CPU1_PTCMD           *(unsigned int*)(TETRIS_BASE + 0x040C)
345 #define TETRIS_CPU1_PDSTAT          *(unsigned int*)(TETRIS_BASE + 0x0410)
346 #define TETRIS_CPU1_PDCTL           *(unsigned int*)(TETRIS_BASE + 0x0414)
347 #define SECPLLCTL0                  *(unsigned int*)(CHIP_LEVEL_REG + 0x0370)
348 #define SECPLLCTL1                  *(unsigned int*)(CHIP_LEVEL_REG + 0x0374)
349 unsigned int read_val;
351 /****************************************************************************
352  *
353  * NAME
354  *      OnTargetConnect
355  *
356  * PURPOSE:
357  *      Setup almost everything ready for a new debug session:
358  *      DSP modules and EVM board modules, at target connection.
359  *      Do nothing if target is in realtime mode.
360  *      This routine is called when you connect to the target board.
361  *
362  *      IMPORTANT: this routine won't attempt to connect to the target
363  *      if the target is not in real-time mode and that the dsp boot
364  *      mode switches are not set in emulation boot mode.
365  *
366  * USAGE
367  *      This routine is a callback routine and called by CCS only.
368  *
369  * RETURN VALUE
370  *      NONE
371  *
372  * REFERENCE
373  *
374  ****************************************************************************/
375 OnTargetConnect()
377         /*------------------------------------------------------*/
378         /* GEL_Reset() is used to deal with the worst case      */
379         /* senario of unknown target state.  If for some reason */
380         /* a reset is not desired upon target connection,       */
381         /* GEL_Reset() may be removed and replaced with         */
382         /* something "less brutal" like a cache initialization  */
383         /* function.                                            */
384         /*------------------------------------------------------*/
385         //GEL_Reset();
386         //xmc_setup();
387         //ddr3_setup();
389         GEL_TextOut("\nConnecting Target...\n");
391         // Check if target is not in real-time mode. If it is in stop mode,
392         // initialize everything. In real-time mode, do nothing to connect
393         // unobtrusively...
394         if (!GEL_IsInRealtimeMode())
395         {
396                 // Validates if emulation boot mode
397                 if (DEVSTAT & 0x0000000E)
398                 {
399                         GEL_TextOut("No initialization performed since bootmode = %x \n",,,,,(DEVSTAT >> 1 ) & 0xF);
400                         GEL_TextOut("You can manually initialize with GlobalDefaultSetup\n");
401                 }
402                 else
403                 {
404                         // Comment the following line at production application test
405                         // when the application need to initialize everything, but not the
406                         // GEL file.
407                         Global_Default_Setup_Silent();
408                 }
409         } else {
410                 GEL_TextOut("No initialization performed in real time mode\n");
411         }
414 /*--------------------------------------------------------------*/
415 /* OnReset()                                                    */
416 /* This function is called by CCS when you do Debug->Resest.    */
417 /* The goal is to put the C6x into a known good state with      */
418 /* respect to cache, edma and interrupts.                       */
419 /*--------------------------------------------------------------*/
420 OnReset( int nErrorCode )
424 /*--------------------------------------------------------------*/
425 /* xmc_setup()                                                  */
426 /* XMC MPAX register setting to access DDR3 config space        */
427 /*--------------------------------------------------------------*/
429 #define XMC_BASE_ADDR (0x08000000)
430 #define XMPAX2_L     (*(int*)(XMC_BASE_ADDR + 0x00000010))
431 #define XMPAX2_H     (*(int*)(XMC_BASE_ADDR + 0x00000014))
433 xmc_setup()
435         /* mapping for ddr emif registers XMPAX*2 */
437         XMPAX2_L =  0x121010FF;  /* replacement addr + perm */
438         XMPAX2_H =  0x2101000B;    /* base addr + seg size (64KB)*/     //"1B"-->"B" by xj
439         GEL_TextOut("XMC setup complete.\n");
442 /****************************************************************************
443  *
444  * NAME
445  *      Global_Default_Setup_Silent
446  *
447  * PURPOSE:
448  *      Setup almost everything ready for a new debug session:
449  *      DSP modules and EVM board modules.
450  *
451  * USAGE
452  *      This routine can be called as:
453  *
454  *      Global_Default_Setup_Silent()
455  *
456  * RETURN VALUE
457  *      NONE
458  *
459  * REFERENCE
460  *
461  ****************************************************************************/
462 Global_Default_Setup_Silent()
464         float gel_ver = GEL_VERSION;
466         // Set DSP cache to pre defined values...
467         GEL_TextOut( "TCI6630k2l GEL file Ver is %f \n",,,,, (float) (gel_ver/1.0));
468         //Set_DSP_Cache();
469         // Only core 0 can set these
470         if (DNUM == 0)
471         {
472                 // Setup main PLL DSP @ 983 MHz
473                 Set_Pll1(3); // call Set_Pll1 with index = 3 -> 122.88 MHz to 983.04 MHz operation
474                 // Setup all Power Domains on
475                 Set_Psc_All_On();
476                 // Setup PA PLL
477                 PaPllConfig();
478                 GEL_TextOut("DDR begin\n");
479                 xmc_setup();
480                 ddr3A_64bit_DDR1600_setup(0);
481                 GEL_TextOut("DDR done\n");
482         }
485 /****************************************************************************
486  *
487  * NAME
488  *      Set_PSC_State
489  *
490  * PURPOSE:
491  *      Set a new power state for the specified domain id in a power controler
492  *      domain. Wait for the power transition to complete.
493  *
494  * USAGE
495  *      This routine can be called as:
496  *
497  *      Set_PSC_State(unsigned int pd,unsigned int id,unsigned int state)
498  *
499  *      pd    - (i) power domain.
500  *
501  *      id    - (i) module id to use for module in the specified power domain
502  *
503  *      state - (i) new state value to set
504  *                  0 = RESET
505  *                  1 = SYNC RESET
506  *                  2 = DISABLE
507  *                  3 = ENABLE
508  *
509  * RETURN VALUE
510  *      0 if ok, !=0 for error
511  *
512  * REFERENCE
513  *
514  ****************************************************************************/
515 Set_PSC_State(unsigned int pd,unsigned int id,unsigned int state)
517         unsigned int* mdctl;
518         unsigned int* mdstat;
519         unsigned int* pdctl;
520         int ret=0;
522         // Only core0 can set PSC
523         if (DNUM == 0)
524         {
525                 mdctl = ( unsigned int* )(PSC_MDCTL_BASE + ( 4 * id ));
526                 mdstat = ( unsigned int* )( PSC_MDSTAT_BASE + ( 4 * id ));
527                 pdctl = ( unsigned int* )(PSC_PDCTL_BASE + ( 4 * pd ));
529                 // If state is already set, do nothing
530                 if ( ( *mdstat & 0x1f ) == state )
531                 {
532                         return(0);
533                 }
535                 // Wait for GOSTAT to clear
536                 Set_Timeout(GTIMEOUT);
537                 while( Get_Timeout() && (PSC_PTSTAT & (0x1 << pd)) != 0 );
539                 // Check if we got timeout error while waiting
540                 if (!Get_Timeout())
541                 {
542                         GEL_TextOut( "Set_PSC_State... Timeout Error #01 pd=%d, md=%d!\n",,2,,,pd,id);
543                         ret=1;
544                 }
545                 else
546                 {
547                         // Set power domain control
548                         *pdctl = (*pdctl) | 0x00000001;
550                         // Set MDCTL NEXT to new state
551                         *mdctl = ((*mdctl) & ~(0x1f)) | state;
553                         // Start power transition by setting PTCMD GO to 1
554                         PSC_PTCMD = (PSC_PTCMD) | (0x1<<pd);
556                         // Wait for PTSTAT GOSTAT to clear
557                         Set_Timeout(GTIMEOUT);
558                         while( Get_Timeout() && (PSC_PTSTAT & (0x1 << pd)) != 0 );
560                         // Check if we got timeout error while waiting
561                         if (!Get_Timeout())
562                         {
563                                 GEL_TextOut( "Set_PSC_State... Timeout Error #02 pd=%d, md=%d!\n",,2,,,pd,id);
564                                 ret=2;
565                         }
566                         else
567                         {
568                                 // Verify state changed
569                                 Set_Timeout(GTIMEOUT);
570                                 while(Get_Timeout() && ( *mdstat & 0x1f ) != state );
572                                 // Check if we got timeout error while waiting
573                                 if (!Get_Timeout())
574                                 {
575                                         GEL_TextOut( "Set_PSC_State... Timeout Error #03 pd=%d, md=%d!\n",,2,,,pd,id);
576                                         ret=3;
577                                 }
578                         }
579                 }
581                 // Kill the currently running timeout
582                 Kill_Timeout();
583         }
584         else
585         {
586                 GEL_TextOut("DSP core #%d cannot set PSC.\n",,2,,,DNUM);
587         }
589         return(ret);
592 /****************************************************************************
593  *
594  * NAME
595  *      Set_Timeout
596  *
597  * PURPOSE:
598  *      Starts a timeout period of msec. The running timeout period can be
599  *      query with Get_Timeout. To kill a running timeout before the end,
600  *      call Kill_Timeout. Only one timeout period can be used at any time.
601  *      A timeout period can be used to measure a period of time while doing
602  *      anything else. Not accurate, sets timer at least as big as desired.
603  *
604  * USAGE
605  *      This routine can be called as:
606  *
607  *      Set_Timeout(msec)
608  *
609  *      msec - (i) timeout period in msec (not very precise < sec range)
610  *
611  * RETURN VALUE
612  *      NONE
613  *
614  * REFERENCE
615  *
616  ****************************************************************************/
617 Set_Timeout(msec)
619         // Cancel the current timer if not already expired
620         GEL_CancelTimer(TIMEOUT_ID);
622         // Starts the timeout period
623         _GEL_Global_Timeout1=1;
625         // Setup a callback routine with specified timeout
626         GEL_SetTimer(msec, TIMEOUT_ID, "_Timeout_Callback()");
629 /****************************************************************************
630  *
631  * NAME
632  *      Get_Timeout
633  *
634  * PURPOSE:
635  *      Query the running state of a timeout period started by Set_Timeout.
636  *      (see Set_Timeout for more info).
637  *
638  * USAGE
639  *      This routine can be called as:
640  *
641  *      Get_Timeout()
642  *
643  * RETURN VALUE
644  *      0:expired, 1:running
645  *
646  * REFERENCE
647  *
648  ****************************************************************************/
649 Get_Timeout()
651         if (!_GEL_Global_Timeout1)
652         {
653                 // Cancel the current timer
654                 GEL_CancelTimer(TIMEOUT_ID);
655         }
657         // Return the global timeout status 1=running, 0=expired
658         return _GEL_Global_Timeout1;
661 /****************************************************************************
662  *
663  * NAME
664  *      Kill_Timeout
665  *
666  * PURPOSE:
667  *      Cancel a running timeout period before it expires
668  *      (see Set_Timeout for more info).
669  *
670  * USAGE
671  *      This routine can be called as:
672  *
673  *      Kill_Timeout()
674  *
675  * RETURN VALUE
676  *      NONE
677  *
678  * REFERENCE
679  *
680  ****************************************************************************/
681 Kill_Timeout()
683         // Cancel the current timer
684         GEL_CancelTimer(TIMEOUT_ID);
686         // The timeout period is expired
687         _GEL_Global_Timeout1=0;
690 /****************************************************************************
691  *
692  * NAME
693  *      _Timeout_Callback
694  *
695  * PURPOSE:
696  *      Internal Callback function used by Set_timeout
697  *      (see Set_Timeout for more info).
698  *
699  * USAGE
700  *      This routine must not be called by itself.
701  *
702  * RETURN VALUE
703  *      NONE
704  *
705  * REFERENCE
706  *
707  ****************************************************************************/
708 _Timeout_Callback()
710         // The timeout period is expired
711         _GEL_Global_Timeout1=0;
715 /****************************************************************************
716  *
717  * NAME
718  *      Set_Psc_All_On
719  *
720  * PURPOSE:
721  *      Enable all PSC modules and DSP power domains on ALWAYSON, and wait
722  *      for these power transitions to complete.
723  *
724  * USAGE
725  *      This routine can be called as:
726  *
727  *      Set_Psc_All_On()
728  *
729  * RETURN VALUE
730  *      NONE
731  *
732  * REFERENCE
733  *
734  ****************************************************************************/
735 hotmenu Set_Psc_All_On( )
737         unsigned int i=0;
739         // Only core0 can set PSC
740         if (DNUM == 0)
741         {
742                 GEL_TextOut( "Power on all PSC modules and DSP domains... \n");
744                 Set_PSC_State(PD1, LPSC_DEBUG, PSC_ENABLE);     
745                 Set_PSC_State(PD1, LPSC_TETB, PSC_ENABLE);      
746                 Set_PSC_State(PD2, LPSC_PA, PSC_ENABLE);        
747                 Set_PSC_State(PD2, LPSC_SGMII, PSC_ENABLE);
748 //  Removed unwanted power up of modules        
749 //              Set_PSC_State(PD2, LPSC_SA, PSC_ENABLE);        
750 //              Set_PSC_State(PD3, LPSC_PCIE_0, PSC_ENABLE);    
751 //              Set_PSC_State(PD4, LPSC_PCIE_1, PSC_ENABLE);    
752 //              Set_PSC_State(PD5, LPSC_DFE_PD2, PSC_ENABLE);   
753                 Set_PSC_State(PD6, LPSC_SR, PSC_ENABLE);        
754                 Set_PSC_State(PD7, LPSC_MSMCRAM, PSC_ENABLE);   
755                 Set_PSC_State(PD8, LPSC_GEM_0, PSC_ENABLE);     
756                 Set_PSC_State(PD9, LPSC_GEM_1, PSC_ENABLE);     
757                 Set_PSC_State(PD10, LPSC_GEM_2, PSC_ENABLE);    
758                 Set_PSC_State(PD11, LPSC_GEM_3, PSC_ENABLE);    
759                 Set_PSC_State(PD16, LPSC_DDR3_0, PSC_ENABLE);   
760 //              Set_PSC_State(PD17, LPSC_TAC, PSC_ENABLE);      
761 //              Set_PSC_State(PD17, LPSC_RAC_0, PSC_ENABLE);    
762 //              Set_PSC_State(PD18, LPSC_DFE_PD0, PSC_ENABLE);  
763 //              Set_PSC_State(PD19, LPSC_FFTCA_FFTC_0, PSC_ENABLE);     
764 //              Set_PSC_State(PD21, LPSC_OSR, PSC_ENABLE);      
765 //              Set_PSC_State(PD22, LPSC_TCP3D_0, PSC_ENABLE);  
766 //              Set_PSC_State(PD23, LPSC_TCP3D_1, PSC_ENABLE);  
767 //              Set_PSC_State(PD24, LPSC_VCP_0, PSC_ENABLE);    
768 //              Set_PSC_State(PD24, LPSC_VCP_1, PSC_ENABLE);    
769 //              Set_PSC_State(PD24, LPSC_VCP_2, PSC_ENABLE);    
770 //              Set_PSC_State(PD24, LPSC_VCP_3, PSC_ENABLE);    
771 //              Set_PSC_State(PD26, LPSC_BCP, PSC_ENABLE);      
772 //              Set_PSC_State(PD27, LPSC_DFE_PD1, PSC_ENABLE);  
773 //              Set_PSC_State(PD28, LPSC_FFTCA_FFTC_1, PSC_ENABLE);     
774 //              Set_PSC_State(PD29, LPSC_IQN_AIL, PSC_ENABLE);  
775                 Set_PSC_State(PD31, LPSC_ARM, PSC_ENABLE);      
776                 GEL_TextOut( "Power on all PSC modules and DSP domains... Done.\n" );
777         }
778         else
779         {
780                 GEL_TextOut("DSP core #%d cannot set PSC.\n",,2,,,DNUM);
781         }
785 //********************************************************************************************************************************
786 //********************************************************************************************************************************
787 /*
788    Set_Pll1() - This function executes the main PLL initialization 
789    sequence needed to get the main PLL up after coming out of an initial power up 
790    before it is locked or after it is already locked.
792    Index value determines multiplier, divier used and clock reference assumed for 
793    output display. 
794  */
795 Set_Pll1(int index)
797         int i, TEMP;
798         unsigned int BYPASS_val;     
799         unsigned int BWADJ_val;     
800         unsigned int OD_val;            
802         float CLKIN_val;
803         unsigned int PLLM_val;
804         unsigned int PLLD_val;
805         unsigned int PLLDIV3_val; //example value for SYSCLK2 (from 6614 spec) Default /2 - Fast Peripherals, (L2, MSMC, DDR3 EMIF, EDMA0...)
806         unsigned int PLLDIV4_val; //example value for SYSCLK3 (from 6614 spec) Default /3 - Switch Fabric
807         unsigned int PLLDIV7_val; //example value for SYSCLK6 (from 6614 spec) Defualt /6 - Slow Peripherals (UART, SPI, I2C, GPIO...)
809         unsigned int debug_info_on;
810         unsigned int delay;
812         if(index == 1){            // 122.88 MHz -> 614.4 MHz
813                 CLKIN_val   = 122.88;       // setup CLKIN to 122.88 MHz
814                 PLLM_val    = 10;           // setup PLLM (PLL multiplier) to x10
815                 PLLD_val    = 1;            // setup PLLD (reference divider) to /1
816                 OD_val      = 2;            // setup OD to a fixed /2
817         }
818         else if(index == 2){            // 122.88MHz -> 737.28 MHz
819                 CLKIN_val   = 122.88;       // setup CLKIN to 122.88 MHz
820                 PLLM_val    = 12;           // setup PLLM (PLL multiplier) to x12
821                 PLLD_val    = 1;            // setup PLLD (reference divider) to /1
822                 OD_val      = 2;            // setup OD to a fixed /2
823         }
825         else if(index == 3){            // 122.88MHz -> 983.04 MHz
826                 CLKIN_val   = 122.88;       // setup CLKIN to 122.88 MHz
827                 PLLM_val    = 16;           // setup PLLM (PLL multiplier) to x12
828                 PLLD_val    = 1;            // setup PLLD (reference divider) to /1
829                 OD_val      = 2;            // setup OD to a fixed /2
830         }
832         else if(index == 4){            // 122.88 MHz -> 1.2 GHz
833                 CLKIN_val   = 122.88;          // setup CLKIN to 122.88 MHz
834                 PLLM_val    = 20;           // setup PLLM (PLL multiplier) to x20
835                 PLLD_val    = 1;            // setup PLLD (reference divider) to /1
836                 OD_val      = 2;            // setup OD to a fixed /2
837         }
838         else if(index == 5){            // 122.88 MHz -> 1.35 GHz
839                 CLKIN_val   = 122.88;          // setup CLKIN to 122.88 MHz
840                 PLLM_val    = 22;           // setup PLLM (PLL multiplier) to x22
841                 PLLD_val    = 1;            // setup PLLD (reference divider) to /1
842                 OD_val      = 2;            // setup OD to a fixed /2
843         }
848         PLLDIV3_val = 3;            // setup PLL output divider 3 to /3
849         PLLDIV4_val = 5;            // setup PLL output divider 4 to /3
850         PLLDIV7_val = 6;            // setup PLL output divider 7 to /6
852         BYPASS_val      = PLL1_SECCTL & ~BYPASS_MASK;   // get value of the BYPASS field
853         BWADJ_val       = (PLLM_val) >> 1;              // setup BWADJ to be 1/2 the value of PLLM
856         debug_info_on   = 1;
857         delay           = 1000; // fix this!
859         /* Step 1: Unlock Boot Config Registers */
860         KICK0 = KICK0_UNLOCK;
861         KICK1 = KICK1_UNLOCK;
863         /* Step 2: Check if SECCTL bypass is low or high indicating what state the Main PLL is currently in. if 
864        the Main PLL is in bypass still (not yet setup) execute the following steps.  */
866         if(BYPASS_val != 0x00000000){ // PLL bypass enabled - Execute PLL setup for PLL fresh out of power on reset
867                 if(debug_info_on){
868                         GEL_TextOut("Detected PLL bypass enabled: SECCTL[BYPASS] = %x\n",,,,, BYPASS_val);
869                 }
870                 /* Step 2a: Set MAINPLLCTL1[ENSAT] = 1 - This enables proper biasing of PLL analog circuitry */            
871                 MAINPLLCTL1 |= (1 << MAIN_ENSAT_OFFSET); 
872                 if(debug_info_on){
873                         GEL_TextOut("(2a) MAINPLLCTL1 = %x\n",,,,, MAINPLLCTL1);
874                 }        
876                 /* Step 2b: Set PLLCTL[PLLEN] = 0 This enables bypass in PLL controller MUX */        
877                 PLL1_PLLCTL &= ~(1 << PLLEN_OFFSET);        
878                 if(debug_info_on){    
879                         GEL_TextOut("(2b) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
880                 }    
882                 /* Step 2c: Set PLLCTL[PLLENSRC] = 0 - This enables PLLEN to control PLL controller MUX */    
883                 PLL1_PLLCTL &= ~(1 << PLLENSRC_OFFSET);
884                 if(debug_info_on){    
885                         GEL_TextOut("(2c) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
886                 }    
888                 /* Step 2d: Wait 4 reference clock cycles (slowest of ALTCORE or SYSCLK) to make sure 
889            that the PLL controller MUX switches properly to bypass. */
890                 if(debug_info_on){    
891                         GEL_TextOut("(2d) Delay...\n",,,,,);
892                 }        
893                 for(i = 0; i < delay; i++); // this delay is much more than required         
895                 /* Step 2e: Set SECCTL[BYPASS] = 1 - enables bypass in PLL MUX */    
896                 PLL1_SECCTL |= (1 << BYPASS_OFFSET);        
897                 if(debug_info_on){    
898                         GEL_TextOut("(2e) SECCTL = %x\n",,,,, PLL1_SECCTL);
899                 }    
901                 /* Step 2f: Set PLLCTL[PLLPWRDN] = 1 - power down the PLL */        
902                 PLL1_PLLCTL |= (1 << PLLPWRDN_OFFSET);
903                 if(debug_info_on){    
904                         GEL_TextOut("(2f) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
905                 }    
907                 /* Step 2g: Wait for at least 5us for the PLL to power down */
908                 if(debug_info_on){    
909                         GEL_TextOut("(2g) Delay...\n",,,,,);
910                 }    
911                 for(i = 0; i < delay; i++); // this delay is much more than required 
913                 /* Step 2h: Set PLLCTL[PLLPWRDN] = 0 - Power the PLL back up */    
914                 PLL1_PLLCTL &= ~(1 << PLLPWRDN_OFFSET);
915                 if(debug_info_on){    
916                         GEL_TextOut("(2h) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
917                 }            
919         }
920         else{ // PLL bypass disabled - Execute PLL setup for PLL that has previously been locked (skip to Step 3)
921                 if(debug_info_on){    
922                         GEL_TextOut("Detected PLL bypass disabled: SECCTL[BYPASS] = %x\n",,,,, BYPASS_val);
923                 }
925                 /* Step 3a: Set PLLCTL[PLLEN] = 0 This enables bypass in PLL controller MUX */        
926                 PLL1_PLLCTL &= ~(1 << PLLEN_OFFSET);        
927                 if(debug_info_on){    
928                         GEL_TextOut("(3a) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
929                 }    
931                 /* Step 3b: Set PLLCTL[PLLENSRC] = 0 - This enables PLLEN to control PLL controller MUX */    
932                 PLL1_PLLCTL &= ~(1 << PLLENSRC_OFFSET);
933                 if(debug_info_on){    
934                         GEL_TextOut("(3b) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
935                 }
937                 /* Step 3c: Wait 4 reference clock cycles (slowest of ALTCORE or SYSCLK) to make sure 
938            that the PLL controller MUX switches properly to bypass. */
939                 if(debug_info_on){    
940                         GEL_TextOut("(3c) Delay...\n",,,,,);
941                 }        
942                 for(i = 0; i < delay; i++); // this delay is much more than required       
944         }
947         /* Step 4: Programming PLLM[5:0] in the PLLM register of the PLL controller and
948        programming PLLM[12:6] in the MAINPLLCTL0 register */        
949         PLL1_PLLM &= PLLM_MASK;             // clear the PLLM[5:0] bit field
950         PLL1_PLLM |= ~PLLM_MASK & (PLLM_val - 1);   // set the PLLM[5:0] bit field to the 6 LSB of PLLM_val
952         if(debug_info_on){
953                 GEL_TextOut("(4)PLLM[PLLM] = %x\n",,,,, PLL1_PLLM);
954         }    
956         MAINPLLCTL0 &= MAIN_PLLM_MASK;      // clear the PLLM[12:6] bit field
957         MAINPLLCTL0 |= ~MAIN_PLLM_MASK & (( (PLLM_val - 1) >> 6) << MAIN_PLLM_OFFSET);  // set the PLLM[12:6] bit field to the 7 MSB of PLL_val
959         if(debug_info_on){
960                 GEL_TextOut("MAINPLLCTL0 = %x\n",,,,, MAINPLLCTL0);
961         }
963         /* Step 5: Programming BWADJ[7:0] in the MAINPLLCTL0 register and BWADJ[11:8] in MAINPLLCTL1 register */            
964         MAINPLLCTL0 &= MAIN_BWADJ0_MASK;    // clear the MAIN_BWADJ0 bit field
965         MAINPLLCTL0 |= ~MAIN_BWADJ0_MASK & ((BWADJ_val - 1) << MAIN_BWADJ0_OFFSET); // set the MAIN_BWADJ[7:0] bit field to the 8 LSB of BWADJ_val
967         if(debug_info_on){
968                 GEL_TextOut("(5) MAINPLLCTL0 = %x\n",,,,, MAINPLLCTL0);
969         }
971         MAINPLLCTL1 &= MAIN_BWADJ1_MASK;    // clear the MAIN_BWADJ1 bit field
972         MAINPLLCTL1 |= ~MAIN_BWADJ1_MASK & (( (BWADJ_val - 1) >> 8) << MAIN_BWADJ1_OFFSET); // set the MAIN_BWADJ[11:8] bit field to the 4 MSB of BWADJ_val
974         if(debug_info_on){
975                 GEL_TextOut("(5) MAINPLLCTL1 = %x\n",,,,, MAINPLLCTL1);
976         }
978         /* Step 6: Programming PLLD[5:0] in the MAINPLLCTL0 register */            
979         MAINPLLCTL0 &= MAIN_PLLD_MASK;      // clear the PLLD bit field
980         MAINPLLCTL0 |= ~MAIN_PLLD_MASK & (PLLD_val - 1);    // set the PLLD[5:0] bit field of PLLD to PLLD_val
982         if(debug_info_on){
983                 GEL_TextOut("(6) MAINPLLCTL0 = %x\n",,,,, MAINPLLCTL0);
984         }
986         /* Step 7: Programming OD[3:0] in the SECCTL register */            
987         PLL1_SECCTL &= OUTPUT_DIVIDE_MASK;  // clear the OD bit field
988         PLL1_SECCTL |= ~OUTPUT_DIVIDE_MASK & (OD_val - 1) << OUTPUT_DIVIDE_OFFSET;  // set the OD[3:0] bit field of PLLD to OD_val    
990         if(debug_info_on){
991                 GEL_TextOut("(7) SECCTL = %x\n",,,,, PLL1_SECCTL);
992         }
994         /* Step 8: Following steps are needed to change the default output dividers */            
996         /* Step 8a: Check that the GOSTAT bit in PLLSTAT is cleared to show that no GO
997        operation is currently in progress*/
998         if(debug_info_on){    
999                 GEL_TextOut("(8a) Delay...\n",,,,,);
1000         }    
1001         while((PLL1_STAT) & 0x00000001);
1003         /* Step 8b: Program the RATIO field in PLLDIVn to the desired new divide-down rate.
1004        If RATIO field is changed, the PLL controller will flag the change in the
1005        corresponding bit of DCHANGE*/
1006         PLL1_DIV3 = (PLLDIV3_val-1) | 0x8000;  //Set PLLDIV3
1007         PLL1_DIV4 = (PLLDIV4_val-1) | 0x8000;  //Set PLLDIV4
1008         PLL1_DIV7 = (PLLDIV7_val-1) | 0x8000;  //Set PLLDIV7
1010         if(debug_info_on){
1011                 GEL_TextOut("PLL1_DIV3 = %x\n",,,,, PLL1_DIV3);
1012                 GEL_TextOut("PLL1_DIV4 = %x\n",,,,, PLL1_DIV4);
1013                 GEL_TextOut("PLL1_DIV7 = %x\n",,,,, PLL1_DIV7);
1014         }
1016         /* Step 8c: Set GOSET bit in PLLCMD to initiate the GO operation to change the divide
1017        values and align the SYSCLKs as programmed */
1018         PLL1_CMD |= 0x00000001;
1020         /*Step 8d/e: Read the GOSTAT bit in PLLSTAT to make sure the bit returns to 0 to
1021       indicate that the GO operation has completed */
1022         if(debug_info_on){    
1023                 GEL_TextOut("(8d/e) Delay...\n",,,,,);
1024         }    
1025         while((PLL1_STAT) & 0x00000001);
1027         /* Step 9: Set PLLCTL[PLLRST] = 1 - Assert PLL reset (Previously Step 3)*/        
1028         PLL1_PLLCTL |= (1 << PLLRST_OFFSET);
1030         /* Step 10: Wait for the at least 7us for the PLL reset properly (128 CLKIN1 cycles) */        
1031         if(debug_info_on){    
1032                 GEL_TextOut("(10) Delay...\n",,,,,);
1033         }    
1034         for(i=0;i<delay;i++);
1036         /* Step 11: Set PLLCTL[PLLRST] = 0 - De-Assert PLL reset */        
1037         PLL1_PLLCTL &= ~(1 << PLLRST_OFFSET);
1039         /* Step 12: Wait for PLL to lock (2000 CLKIN1 cycles) */
1040         if(debug_info_on){    
1041                 GEL_TextOut("(12) Delay...\n",,,,,);
1042         }    
1043         for(i=0;i<delay;i++);
1045         /* Step 13: In SECCTL, write BYPASS = 0 (enable PLL mux to switch to PLL mode) */
1046         PLL1_SECCTL &= ~(1 << BYPASS_OFFSET);        
1047         if(debug_info_on){    
1048                 GEL_TextOut("(13) SECCTL = %x\n",,,,, PLL1_SECCTL);
1049         }    
1050         if(debug_info_on){    
1051                 GEL_TextOut("(Delay...\n",,,,,);
1052         }    
1053         for(i=0;i<delay;i++);
1054         if(debug_info_on){    
1055                 GEL_TextOut("(Delay...\n",,,,,);
1056         }    
1057         for(i=0;i<delay;i++);
1059         /* Step 14: In PLLCTL, write PLLEN = 1 to enable PLL mode */
1060         PLL1_PLLCTL |= (1 << PLLEN_OFFSET);        
1061         if(debug_info_on){    
1062                 GEL_TextOut("(14) PLLCTL = %x\n",,,,, PLL1_PLLCTL);
1063         }    
1065         /* Step 15: Lock Boot Config Registers */
1066         KICK0 = 0x00000000;
1067         KICK1 = 0x00000000;
1069         GEL_TextOut("PLL has been configured (CLKIN * PLLM / PLLD / PLLOD = PLLOUT):\n",,,,,);
1070         GEL_TextOut("PLL has been configured (%f MHz * %d / %d / 2 = %f MHz)\n",,,,, CLKIN_val, PLLM_val, PLLD_val, (CLKIN_val * PLLM_val / PLLD_val / 2));
1073 Set_Tetris_Pll(int index)
1076         unsigned int BWADJ_val;     
1077         unsigned int OD_val;            
1078         unsigned int PLLM_val;
1079         float CLKIN_val;
1080         int i;
1082         GEL_TextOut("Switching on ARM Core 0\n",,,,,);
1083         TETRIS_CPU0_PDCTL   = 0x00000000;
1084         TETRIS_CPU0_PTCMD   = 0x00000001;    
1086         GEL_TextOut("Switching on ARM Core 1\n",,,,,);
1087         TETRIS_CPU1_PDCTL   = 0x00000000;
1088         TETRIS_CPU1_PTCMD   = 0x00000001;    
1092         if(index == 1){              // 100 MHz -> 1.0 GHz
1093                 CLKIN_val   = 125;          // setup CLKIN to 125 MHz
1094                 PLLM_val    = 16;           // setup PLLM (PLL multiplier) to x20
1095                 OD_val      = 2;            // setup OD to a fixed /2
1096         }
1097         else if(index == 2){            // 100 MHz -> 1.4 GHz
1098                 CLKIN_val   = 125;          // setup CLKIN to 125 MHz
1099                 PLLM_val    = 22;           // setup PLLM (PLL multiplier) to x28
1100                 OD_val      = 2;            // setup OD to a fixed /2
1101         }
1102         else if(index == 3){            // 174.825MHz -> 1.4 GHz
1104                 CLKIN_val   = 174.825;      // setup CLKIN to 174.825 MHz
1105                 PLLM_val    = 16;           // setup PLLM (PLL multiplier) to x16
1106                 OD_val      = 2;            // setup OD to a fixed /2
1107         }
1109         BWADJ_val       = (PLLM_val-1) >> 1;            // setup BWADJ to be 1/2 the value of PLLM
1111         /* Step 1: Unlock Boot Config Registers */
1112         KICK0 = KICK0_UNLOCK;
1113         KICK1 = KICK1_UNLOCK;
1115         //Step 1 : Assert SEC PLL Reset
1116         SECPLLCTL1 = ((1 << SEC_PLLCTL1_RESET_OFFSET) | (1 << SEC_PLLCTL1_ENSTAT_OFFSET));
1118         //Step 2 : Change CLKF/OD/BWADJ etc. for SEC PLL
1119         SECPLLCTL0 = ((BWADJ_val << SEC_PLLCTL0_BWADJ_OFFSET) |
1120                         ((OD_val-1) << SEC_PLLCTL0_OD_OFFSET)|
1121                         ((PLLM_val-1) << SEC_PLLCTL0_PLLM_OFFSET));
1123         //Step 3 : Make sure the resets are held for 5us
1124         for(i = 0; i < 200000; i++);
1126         //Step 4 : Remove SEC PLL reset
1127         SECPLLCTL1 = (1 << SEC_PLLCTL1_ENSTAT_OFFSET);
1129         //Step 5 : Wait for PLL to lock (4000 CLKIN1 cycles)
1130         for(i = 0; i < 4000; i++);
1132         //Step 6 : Get the PLL out of Bypass
1133         //SECPLLCTL0 &= ~(1 << SEC_PLLCTL0_BYPASS_OFFSET);
1134         CHIP_MISC1 |= (1 << ARMPLL_ENABLE_OFFSET); 
1137         //Step 6 : Lock Boot Config Registers
1138         KICK0 = 0x00000000;
1139         KICK1 = 0x00000000;
1141         GEL_TextOut("ARM PLL has been configured (%f MHz * %d / %d = %f MHz)\n",,,,, CLKIN_val, PLLM_val, OD_val, (CLKIN_val * PLLM_val)/OD_val);
1144 /* Set the desired PA PLL configuration */
1145 PaPllConfig()
1147         unsigned int passclksel = (DEVSTAT & PASSCLKSEL_MASK);
1148         unsigned int papllctl0val_orig = PAPLLCTL0;
1149         unsigned int papllctl1val_orig = PAPLLCTL1;
1150         unsigned int papllctl0val_final;
1151         unsigned int papllctl1val_final;
1152         unsigned int papllclkf = 204; //31; // 204; 20 (if PASSREFCLK == 100mhz) Multiply by clkf + 1
1153         unsigned int papllclkd = 11;  //11;   1 (if PASSREFCLK == 100mhz) Divide by clkd + 1
1154         unsigned int i = 0;
1156         if (passclksel != PASSCLKSEL_MASK) GEL_TextOut("WARNING: SYSCLK is the input to the PA PLL.\n");
1158         /* Unlock Chip Level Registers */
1159         KICK0 = KICK0_UNLOCK;
1160         KICK1 = KICK1_UNLOCK;
1162         // PAPLLCTL1 = PAPLLCTL1 | 0x00000040; //Set ENSAT = 1; Set PLL Select to 0 (for SYCLK0 as input of PASS)
1163         PAPLLCTL1 = PAPLLCTL1 | 0x00002040; //Set ENSAT = 1; Set PLL Select to 1 (for PA PLL as input of PASS)  
1165         /*in PAPLLCTL0, clear bypass bit to set the PA PLL in Bypass Mode*/
1166         //PAPLLCTL0 &= ~(1<<BYPASS_BIT_SHIFT); // Not setting Bypass bit
1167         PAPLLCTL0 |=  (1<<BYPASS_BIT_SHIFT); // Actually setting bypass bit
1169         /*Wait 4 cycles for the slowest of PLLOUT or reference clock source (CLKIN)*/
1170         for(i=0;i<100;i++);
1172         /*In PAPLLCTL1, write PLL reset bit to put the PLL in reset*/
1173         PAPLLCTL1 |= PA_PLL_RESET_MASK;
1175         /* Program the multiplier value */
1176         PAPLLCTL0 &= (~PA_PLL_CLKF_MASK);          //clear multiplier value
1177         PAPLLCTL0 &= (~PA_PLL_CLKR_MASK);          //clear divider value
1178         PAPLLCTL0 |= (papllclkf<<CLKF_BIT_SHIFT);  // set PLLM
1179         PAPLLCTL0 |= (papllclkd<<CLKD_BIT_SHIFT);  // set PLLD
1182         PAPLLCTL0 &= 0x00FFFFFF;
1183         PAPLLCTL0 |= ((((papllclkf + 1)>>1)-1)<<24);
1185         PAPLLCTL1 &= ~(0x0000000F);
1186         PAPLLCTL1 |= (((((papllclkf + 1)>>1)-1) >> 8) & 0x0000000F);
1188         //PAPLLCTL1 = PAPLLCTL1 | 0x00002000;
1190         /*Wait for PLL to properly reset (128 CLKIN1 cycles) */
1191         for(i=0;i<1000;i++);
1193         /* take the PA PLL out of reset */
1194         PAPLLCTL1 &= (~PA_PLL_RESET_MASK);
1196         /*Wait for PLL to lock (2000 CLKIN1 cycles) */
1197         for(i=0;i<5000;i++);
1199         /* enable PLL mode */
1200         PAPLLCTL0 &= ~(1<<BYPASS_BIT_SHIFT); // actually setting PLL MODE
1202         for(i=0;i<4000;i++);
1204         /* Lock Chip Level Registers */
1205         KICK0 = KICK_LOCK;
1206         KICK1 = KICK_LOCK;
1208         papllctl0val_final = PAPLLCTL0;
1209         papllctl1val_final = PAPLLCTL1;
1211         GEL_TextOut("Completed PA PLL Setup\n");
1212         GEL_TextOut("PAPLLCTL0 - before: 0x%x\t after: 0x%x\n",,,,, papllctl0val_orig, papllctl0val_final);
1213         GEL_TextOut("PAPLLCTL1 - before: 0x%x\t after: 0x%x\n",,,,, papllctl1val_orig, papllctl1val_final);
1215         if ((papllctl0val_final != 0x09080500) || (papllctl1val_final != 0x00002040))
1216         {
1217                 return 1;
1218         }
1220         return 0;
1224 #define DFE_PLL_MULT_MASK     0x003F
1225 #define DFE_PLL_MULT_SHIFT    6
1226 #define DFE_PLL_ODIV_MASK     0xF
1227 #define DFE_PLL_ODIV_SHIFT    19    
1228 #define DFE_PLL_DIVMODE_MASK     0x3
1229 #define DFE_PLL_DIVMODE_SHIFT    0  
1230 #define DFE_PLL_BWADJ_SHIFT   24     
1231 #define DFE_PLL_BWADJ_MASK    0x00FFFFFF    
1232 #define DFE_PLL_BYPASS_SET 0x00800000
1233 #define DFE_PLL_RESET_SET  0x00004000
1234 #define DFE_PLL_PLLSEL_SET 0x00002000
1235 #define DFE_PLL_PLLSEL_RESET 0xFFFFDFFF
1238 dfepll_setup(unsigned int base, unsigned int clkr, 
1239                 unsigned int clkf, unsigned int clkod,
1240                 unsigned int divmode)
1242         unsigned int *dfepllctl0 = DFEPLLCTL0;
1243         unsigned int *dfepllctl1 = DFEPLLCTL1;
1244         unsigned int *dfe_clkdiv_ctl = DFE_CLKDIV_CTL;
1245         unsigned int *dfe_clksync_ctl = DFE_CLKSYNC_CTL;
1246         unsigned int i = 0;
1248         // check disallowed here. 
1249         if (clkod && ((clkod & 0x1) != 0x1)) return(0);
1250         // Check some unimplemented (yet) features.
1251         if (clkr) return(0);
1252         if (clkf > 63) return(0);
1254         /* Unlock Boot Config Registers */
1255         KICK0 = KICK0_UNLOCK;
1256         KICK1 = KICK1_UNLOCK;
1258         // Reset DFEPLLCTL0, DFEPLLCTL1, DFE_CLKDIV_CTL, DFE_CLKSYNC_CTL
1259         *dfepllctl0 = 0x098803C0;
1260         *dfepllctl1 = 0x00000040;
1261         *dfe_clkdiv_ctl = 0x00000000;
1262         *dfe_clksync_ctl = 0x00000000;
1264         // Step 1: Put PLL in bypass.
1265         *dfepllctl0 |= DFE_PLL_BYPASS_SET;
1267         // Step 2: Put PLL in reset.
1268         *dfepllctl1 |= DFE_PLL_RESET_SET;
1270         // Step 3: Program PLL clkf (CLKF)
1271         *dfepllctl0 &= ~(DFE_PLL_MULT_MASK << DFE_PLL_MULT_SHIFT);
1272         *dfepllctl0 |= ((clkf & DFE_PLL_MULT_MASK) << DFE_PLL_MULT_SHIFT);
1274         // Step 4: Set bwadj factor.
1275         *dfepllctl0 &= DFE_PLL_BWADJ_MASK;
1276         *dfepllctl0 |= (clkf/2) << DFE_PLL_BWADJ_SHIFT;
1278         // Step 5: set PLL post div (CLKOD)
1279         *dfepllctl0 &= ~(DFE_PLL_ODIV_MASK << DFE_PLL_ODIV_SHIFT);
1280         *dfepllctl0 |= ((clkod & DFE_PLL_ODIV_MASK) << DFE_PLL_ODIV_SHIFT);
1282         // Step 6: Wait for 5us based on refclk
1283         for(i=0;i<30000;i++);
1285         // Step 7: Set Divmode in DFE_CLKDIV_CTL
1286         *dfe_clkdiv_ctl &= ~(DFE_PLL_DIVMODE_MASK << DFE_PLL_DIVMODE_SHIFT);
1287         *dfe_clkdiv_ctl |= ((divmode & DFE_PLL_DIVMODE_MASK) << DFE_PLL_DIVMODE_SHIFT);
1289         // Step 8: Release PLL reset. But make sure reset is at least 5us.
1290         for(i=0;i<30000;i++);
1291         *dfepllctl1 &= ~DFE_PLL_RESET_SET;
1293         // Step 9: wait for PLL to lock. --// NEED TO UPDATE Wait for at least 500 * REFCLK cycles * (PLLD + 1) (PLL lock time)
1294         //waitfor(((*stat & DFE_PLL_LOCK_SET) == DFE_PLL_LOCK_SET), 1000);
1295         //if ((*stat & DFE_PLL_LOCK_SET) != DFE_PLL_LOCK_SET) return(FAIL);
1296         for(i=0;i<30000;i++);
1298         // Step 10: Disable PLL bypass
1299         *dfepllctl0 &= ~DFE_PLL_BYPASS_SET;
1301         for(i=0;i<10;i++);
1303         // Step 11: Program sync_en (DFECLKSYNC)
1304         *dfe_clksync_ctl = 0x00000001;
1306         for(i=0;i<100;i++);
1308         // Step 12: Set PLLSEL = 1
1310         *dfepllctl1 |= DFE_PLL_PLLSEL_SET;
1312         /* Lock Boot Config Registers */
1313         KICK0 = KICK_LOCK;
1314         KICK1 = KICK_LOCK;
1316         return(1);
1319 //*************************************************************************************************
1320 //*************************************************************************************************
1321 //*************************************************************************************************
1322 //*************************************************************************************************
1323 //*************************************************************************************************
1324 //*************************************************************************************************
1326 //--------DDR3A Memory test----------------------
1328 ddr3A_memory_test ()
1330         unsigned int index, value;
1332         GEL_TextOut( "DDR3A memory test... Started\n" );
1334         /* Write a pattern */
1335         for (index = DDR3A_TEST_START_ADDRESS; index < DDR3A_TEST_END_ADDRESS; index += 4) {
1336                 *index = index;
1337         }
1339         /* Read and check the pattern */
1340         for (index = DDR3A_TEST_START_ADDRESS; index < DDR3A_TEST_END_ADDRESS; index += 4) {
1342                 value = *index;
1344                 if (value  != index) {
1345                         GEL_TextOut( "DDR3A memory test... Failed\n" );
1346                         return -1;
1347                 }
1348         }
1350         /* Write a pattern for complementary values */
1351         for (index = DDR3A_TEST_START_ADDRESS; index < DDR3A_TEST_END_ADDRESS; index += 4) {
1352                 *index = ~index;
1353         }
1355         /* Read and check the pattern */
1356         for (index = DDR3A_TEST_START_ADDRESS; index < DDR3A_TEST_END_ADDRESS; index += 4) {
1358                 value = *index;
1360                 if (value  != ~index) {
1361                         GEL_TextOut( "DDR3A memory test... Failed\n" );
1362                         return -1;
1363                 }
1364         }
1366         GEL_TextOut( "DDR3A memory test... Passed\n" );
1367         return 0;
1371 //---------------------------------------------------   
1374 /****************************************************************************
1375  *
1376  * NAME
1377  *      Setup_Memory_Map
1378  *
1379  * PURPOSE:
1380  *      Setup the Memory Map for EVMC6678L.
1381  *      Defined memory location avoid debugger access outside these locations.
1382  *
1383  * USAGE
1384  *      This routine can be called as:
1385  *
1386  *      Setup_Memory_Map()
1387  *
1388  * RETURN VALUE
1389  *      NONE
1390  *
1391  * REFERENCE
1392  *      Based on TMS320C6678 datasheet.
1393  *
1394  ****************************************************************************/
1395 hotmenu Setup_Memory_Map( )
1397         GEL_TextOut("Setup_Memory_Map...\n",,);
1399         GEL_MapOn( );
1400         GEL_MapReset( );
1402         GEL_MapAddStr( 0x00000000, 0, 0x21400000, "R|W|AS4", 0 );   // 
1403         GEL_MapAddStr( 0x21400000,0, 0x00000080, "R|W|AS4", 0 );   // Hyperlink Config (remote) 
1404         //GEL_MapAddStr( 0x21400080,0, 0x00000080, "R|W|AS4", 0 );   // Hyperlink Config (remote)
1405         GEL_MapAddStr( 0x21400200, 0, 0xdebffe00, "R|W|AS4", 0 );   // 
1406         GEL_TextOut( "Setup_Memory_Map... Done.\n" );
1408 /*----------------------------------------------------- DDR3A : DDR1066, 64bit--------------------------------------------------------------------------*/
1409 ddr3A_64bit_DDR1066_setup(int ECC_Enable)
1412         unsigned int multiplier = 15;
1413         unsigned int divider = 0;
1414         unsigned int OD_val = 6;
1416         int temp,i;
1417         int delay = 2000;
1419         KICK0 = 0x83E70B13;
1420         KICK1 = 0x95A4F1E0;
1423         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1424         do { 
1425                 read_val = DDR3A_PGSR0;
1426         } while ((read_val&0x00000001) != 0x00000001);
1428         //      Clocks are enabled and frequency is stable---------------------------------------
1429         // DDR3A PLL setup      
1430         GEL_TextOut ( "DDR3 PLL Setup ... \n");
1431         // DDR3APLLCTL0 = DDR3APLLCTL0 & 0xFF7FFFFF;
1432         // Set ENSAT = 1
1433         DDR3APLLCTL1 |= 0x00000040;
1434         // Put the PLL in PLL Mode  
1435         DDR3APLLCTL0 |= 0x00800000;
1437         // Program the necessary multipliers/dividers and BW adjustments            
1438         // Set the divider values 
1439         DDR3APLLCTL0 &= ~(0x0000003F);
1440         DDR3APLLCTL0 |= (divider & 0x0000003F);
1442         // Program OD[3:0] in the SECCTL register            
1443         DDR3APLLCTL0 &= OUTPUT_DIVIDE_MASK;  // clear the OD bit field
1444         DDR3APLLCTL0 |= ~OUTPUT_DIVIDE_MASK & (OD_val - 1) << OUTPUT_DIVIDE_OFFSET;  // set the OD[3:0] bit field of PLLD to OD_val    
1445         // Set the Multipler values 
1446         DDR3APLLCTL0 &= ~(0x0007FFC0);
1447         DDR3APLLCTL0 |= ((multiplier << 6) & 0x0007FFC0 );
1448         temp = ((multiplier + 1) >> 1) - 1;
1449         DDR3APLLCTL0 &= ~(0xFF000000); 
1450         DDR3APLLCTL0 |= ((temp << 24) & 0xFF000000);
1451         DDR3APLLCTL1 &= ~(0x0000000F);
1452         DDR3APLLCTL1 |= ((temp >> 8) & 0x0000000F);
1454         // In PLL Controller, reset the PLL (bit 13 in DDR3APLLCTL1 register) 
1455         DDR3APLLCTL1 |= 0x00004000;
1456         for(i=0;i<delay;i++);
1457         // In DDR3PLLCTL1, write PLLRST = 0 to bring PLL out of reset 
1458         DDR3APLLCTL1 &= ~(0x00004000);
1459         for(i=0;i<delay;i++);
1461         // Put the PLL in PLL Mode  
1462         DDR3APLLCTL0 &= ~(0x00800000); // ReSet the Bit 23
1463         GEL_TextOut( "DDR3 PLL Setup complete, DDR3A clock now running at 533MHz.\n" );
1464         //DDR3A PLL setup complete ---------------------------------------
1467         /*------------------------------- ECO FIX -----------------------------------------*/
1468         /*
1469                 // DDR3 write leveling ECO - Assert & release DDR PHY RESET after DDR PLL setup...
1470                 DDR3APLLCTL1 = DDR3APLLCTL1 | 0x80000000;       //Assert DDR PHY reset after PLL enabled
1471                 //for(i=0;i<delay;i++);                                         //delay 1000 cycles
1472                 DDR3APLLCTL1 = DDR3APLLCTL1 & 0x7FFFFFFF;       //Release DDR PHY reset
1474                 do {   // Poll IDONE after resetting PHY 
1475                         read_val = DDR3A_PGSR0; 
1476                    } while ((read_val&0x00000001) != 0x00000001);
1477          */
1478         /*------------------------- Start PHY Configuration -------------------------------*/
1480         //DDR3A_PGCR1 = 0x0280C487;
1482         // Program FRQSEL in the PLL Control Register (address offset 0x018).
1483         DDR3A_PLLCR = 0xDC000; //Set FRQSEL=11, for ctl_clk between 166-275MHz
1485         // Program WLSTEP=1, IODDRM=1, and ZCKSEL in the PHY General Configuration Register 1 (address offset 0x00C).
1487         DDR3A_PGCR1 |= (1 << 2); //WLSTEP = 1
1488         DDR3A_PGCR1 &= ~(IODDRM_MASK);
1489         DDR3A_PGCR1 |= (( 1 << 7) & IODDRM_MASK);
1490         DDR3A_PGCR1 &= ~(ZCKSEL_MASK);
1491         DDR3A_PGCR1 |= (( 1 << 23) & ZCKSEL_MASK);
1493         // Program PHY Timing Parameters Register 0-4 (address offset 0x01C - 0x02C).
1495         DDR3A_PTR0 = 0x42C21590;
1496         DDR3A_PTR1 = 0xD05612C0;        
1498         // Maintain default values of Phy Timing Parameters Register 2 in PUB
1500         DDR3A_PTR3 = 0x09041104;//0x18061A80; 
1501         DDR3A_PTR4 = 0x0855A068;//0x0AAE7100;
1503         // Program PDQ, MPRDQ, and BYTEMASK in the DRAM Configuration Register (address offset 0x044). 
1504         // All other fields must be left at their default values.
1506         DDR3A_DCR &= ~(PDQ_MASK); //PDQ = 0
1507         DDR3A_DCR &= ~(MPRDQ_MASK); //MPRDQ = 0
1508         DDR3A_DCR &= ~(BYTEMASK_MASK);
1509         DDR3A_DCR |= (( 1 << 10) & BYTEMASK_MASK);
1511         // Program DRAM Timing Parameters Register 0-2 (address offset 0x048 - 0x050). 
1513         DDR3A_DTPR0 = 0x6D147744;
1514         DDR3A_DTPR1 = 0x32845A80;       //Increase tWLO to 12
1515         DDR3A_DTPR2 = 0x50023600;
1517         // Program BL=0, CL, WR, and PD=1 in the Mode Register 0 (address offset 0x054). 
1518         // All other fields must be left at their default values.
1520         DDR3A_MR0 = 0x00001840;
1523         // Program DIC, RTT, and TDQS in the Mode Register 1 (address offset 0x058). 
1524         // All other fields must be left at their default values.
1526         DDR3A_MR1 = 0x00000006;
1528         // Program Mode Register 2 (address offset 0x05C).
1530         DDR3A_MR2 = 0x00000008;
1532         // Program DTMPR=1, DTEXD, DTEXG, RANKEN=1 or 3, and RFSHDT=7 in the Data Training Configuration Register (address offset 0x068). 
1533         // All other fields must be left at their default values.
1534         DDR3A_DTCR = 0x710035C7; //Single-rank  
1536         // Program tREFPRD=(5*tREFI/ddr_clk_period) in the PHY General Configuration Register 2 (address offset 0x08C). 
1537         //All other fields must be left at their default values.
1539         DDR3A_PGCR2 = 0x00F05159; //NOBUB = 0, FXDLAT = 0       
1540         //DDR3A_PGCR2 = 0x00F83D09; //NOBUB = 0, FXDLAT = 1 
1542         //Set Impedence Register and DFIPU0=1 
1543         DDR3A_ZQ0CR1 = 0x0001005D; 
1544         DDR3A_ZQ1CR1 = 0x0001005B;
1545         DDR3A_ZQ2CR1 = 0x0001005B;
1548         // Re-trigger PHY initialization in DDR PHY through the VBUSP interface.
1549         // Program 0x00000033 to the PHY Initialization Register (address offset 0x004) to re-trigger PLL, ZCAL, and DCAL initialization.
1551         DDR3A_PIR = 0x00000033;
1553         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1554         do { 
1555                 read_val = DDR3A_PGSR0;
1556         } while ((read_val&0x00000001) != 0x00000001);
1558         //---------------------------------------------------------------------------------------------------------                                     
1560         if(!ECC_Enable)
1561         {
1562                 DDR3A_DATX8_8 = read_val & 0xFFFFFFFE; //Disable ECC byte lane
1563         }
1564         // Trigger DDR3 initialization and leveling/training in DDR PHY through the VBUSP interface.
1565         // If using a 16-bit wide DDR interface, program DXEN=0 in the DATX8 2-7 General Configuration Registers (address offsets 0x240, 0x280, 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1566         // If using a 32-bit wide DDR interface, program DXEN=0 in the DATX8 4-7 General Configuration Registers (address offsets 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1567         // If ECC is not required, program DXEN=0 in the DATX8 8 General Configuration Register (address offset 0x3C0) to disable the leveling/training for the ECC byte lane.
1568         // NOTE: Setup supports 64-bit by default,  ECC enable by default.
1570         // Program 0x0000XF81 to the PHY Initialization Register (address offset 0x004) to trigger DDR3 initialization and leveling/training sequences 
1572         DDR3A_PIR = 0x0000FF81; //WLADJ - ON
1573         //DDR3A_PIR = 0x00000781;  //WLADJ - OFF
1575         //---------------------------------------------------------------------------------------------------------                                     
1577         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1578         do {              
1579                 read_val = DDR3A_PGSR0;
1580         } while ((read_val&0x00000001) != 0x00000001);
1582         /* End PHY Configuration */
1583         if(ECC_Enable)
1584         {
1585                 //Enable ECC
1586                 //0xB0000000: ECC_EN=1, ECC_VERIFY_EN=1, RMW_EN=1
1587                 //0x50000000: ECC_EN=1, ECC_VERIFY_EN=0, RMW_EN=1
1588                 DDR3A_ECC_CTRL = 0xB0000000;
1589                 read_val = DDR3A_ECC_CTRL;
1590                 if(read_val!=0xB0000000){
1591                         GEL_TextOut("\nIncorrect data written to DDR3A_ECC_CTRL..");
1592                 }
1593         }
1594         //---------------------------------------------------------------------------------------------------------                                     
1596         DDR3A_SDCFG    = 0x62004862;    //Single-Rank
1598         DDR3A_SDTIM1   = 0x0E4C6843;
1599         DDR3A_SDTIM2   = 0x00001CC6;
1600         DDR3A_SDTIM3   = 0x323DFF32;
1601         DDR3A_SDTIM4   = 0x533F08AF;
1603         DDR3A_ZQCFG    = 0x70073200;    //Single-rank
1605         // Program reg_initref_dis=0 in the SDRAM Refresh Control Register (address offset 0x10).
1606         DDR3A_SDRFC = 0x00001044;
1608         GEL_TextOut("DDR3A initialization complete \n");
1609         /* End  DDR3A EMIF Configuration */
1615 /*----------------------------------------------------- DDR3A : DDR1333, 64bit--------------------------------------------------------------------------*/
1616 ddr3A_64bit_DDR1333_setup(int ECC_Enable)       
1618         unsigned int multiplier = 19;
1619         unsigned int divider = 0;
1620         unsigned int OD_val = 6;
1622         int temp,i;
1623         int delay = 2000;
1625         KICK0 = 0x83E70B13;
1626         KICK1 = 0x95A4F1E0;
1629         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1630         do 
1631         { 
1632                 read_val = DDR3A_PGSR0;
1633         } while ((read_val&0x00000001) != 0x00000001);
1635         //Clocks are enabled and frequency is stable---------------------------------------
1636         //DDR3A PLL setup       
1637         GEL_TextOut ( "DDR3 PLL Setup ... \n");
1638         //DDR3APLLCTL0 = DDR3APLLCTL0 & 0xFF7FFFFF;
1639         //Set ENSAT = 1
1641         DDR3APLLCTL1 |= 0x00000040;
1642         // Put the PLL in PLL Mode  
1643         DDR3APLLCTL0 |= 0x00800000;
1645         //Program the necessary multipliers/dividers and BW adjustments            
1646         //Set the divider values 
1647         DDR3APLLCTL0 &= ~(0x0000003F);
1648         DDR3APLLCTL0 |= (divider & 0x0000003F);
1650         //Program OD[3:0] in the SECCTL register            
1651         DDR3APLLCTL0 &= OUTPUT_DIVIDE_MASK;  // clear the OD bit field
1652         DDR3APLLCTL0 |= ~OUTPUT_DIVIDE_MASK & (OD_val - 1) << OUTPUT_DIVIDE_OFFSET;  // set the OD[3:0] bit field of PLLD to OD_val    
1654         // Set the Multipler values 
1655         DDR3APLLCTL0 &= ~(0x0007FFC0);
1656         DDR3APLLCTL0 |= ((multiplier << 6) & 0x0007FFC0 );
1657         temp = ((multiplier + 1) >> 1) - 1;
1658         DDR3APLLCTL0 &= ~(0xFF000000); 
1659         DDR3APLLCTL0 |= ((temp << 24) & 0xFF000000);
1660         DDR3APLLCTL1 &= ~(0x0000000F);
1661         DDR3APLLCTL1 |= ((temp >> 8) & 0x0000000F);
1663         // In PLL Controller, reset the PLL (bit 13 in DDR3APLLCTL1 register) 
1664         DDR3APLLCTL1 |= 0x00004000;
1665         for(i=0;i<delay;i++);
1666         // In DDR3PLLCTL1, write PLLRST = 0 to bring PLL out of reset 
1667         DDR3APLLCTL1 &= ~(0x00004000);
1668         for(i=0;i<delay;i++);
1670         // Put the PLL in PLL Mode  
1671         DDR3APLLCTL0 &= ~(0x00800000); // ReSet the Bit 23
1672         GEL_TextOut( "Lammar DDR3 PLL Setup complete, DDR3A clock now running at 666.5MHz.\n" );
1676         /*------------------------------- ECO FIX -----------------------------------------*/
1677         /*
1678                 // DDR3 write leveling ECO - Assert & release DDR PHY RESET after DDR PLL setup...
1679                 DDR3APLLCTL1 = DDR3APLLCTL1 | 0x80000000;       //Assert DDR PHY reset after PLL enabled
1680                 //for(i=0;i<delay;i++);                                         //delay 1000 cycles
1681                 DDR3APLLCTL1 = DDR3APLLCTL1 & 0x7FFFFFFF;       //Release DDR PHY reset
1683                 do 
1684                 {  // Poll IDONE after resetting PHY 
1685                         read_val = DDR3A_PGSR0; 
1686                 } while ((read_val&0x00000001) != 0x00000001);
1687          */
1691         /*------------------------- Start PHY Configuration -------------------------------*/
1693         //DDR3A_PGCR1 = 0x0280C487;
1695         // Program FRQSEL in the PLL Control Register (address offset 0x018).
1696         DDR3A_PLLCR = 0x0005C000; //Set FRQSEL=11, for ctl_clk between 166-275MHz
1698         // Program WLSTEP=1, IODDRM=1, and ZCKSEL in the PHY General Configuration Register 1 (address offset 0x00C).
1700         DDR3A_PGCR1 |= (1 << 2); //WLSTEP = 1
1701         DDR3A_PGCR1 &= ~(IODDRM_MASK);
1702         DDR3A_PGCR1 |= (( 1 << 7) & IODDRM_MASK);
1703         DDR3A_PGCR1 &= ~(ZCKSEL_MASK);
1704         DDR3A_PGCR1 |= (( 1 << 23) & ZCKSEL_MASK);
1706         // Program PHY Timing Parameters Register 0-4 (address offset 0x01C - 0x02C).
1708         DDR3A_PTR0 = 0x42C21590;
1709         DDR3A_PTR1 = 0xD05612C0;
1712         // Maintain default values of Phy Timing Parameters Register 2 in PUB
1714         DDR3A_PTR3 = 0x0B4515C2;
1715         DDR3A_PTR4 = 0x0A6E08B4;
1718         // Program PDQ, MPRDQ, and BYTEMASK in the DRAM Configuration Register (address offset 0x044). 
1719         // All other fields must be left at their default values.
1721         DDR3A_DCR &= ~(PDQ_MASK); //PDQ = 0
1722         DDR3A_DCR &= ~(MPRDQ_MASK); //MPRDQ = 0
1723         DDR3A_DCR &= ~(BYTEMASK_MASK);
1724         DDR3A_DCR |= (( 1 << 10) & BYTEMASK_MASK);
1726         // Program DRAM Timing Parameters Register 0-2 (address offset 0x048 - 0x050). 
1728         DDR3A_DTPR0 = 0x85589955;
1729         DDR3A_DTPR1 = 0x128573C1;
1730         DDR3A_DTPR2 = 0xD002C200;
1733         // Program BL=0, CL, WR, and PD=1 in the Mode Register 0 (address offset 0x054). 
1734         // All other fields must be left at their default values.
1736         DDR3A_MR0 = 0x00001A60; //00001A60
1741         // Program DIC, RTT, and TDQS in the Mode Register 1 (address offset 0x058). 
1742         // All other fields must be left at their default values.
1744         DDR3A_MR1 = 0x00000006;
1746         // Program Mode Register 2 (address offset 0x05C).
1748         DDR3A_MR2 = 0x00000010;
1750         // Program DTMPR=1, DTEXD, DTEXG, RANKEN=1 or 3, and RFSHDT=7 in the Data Training Configuration Register (address offset 0x068). 
1751         // All other fields must be left at their default values.
1752         DDR3A_DTCR = 0x710035C7; //Single-rank  
1754         // Program tREFPRD=(5*tREFI/ddr_clk_period) in the PHY General Configuration Register 2 (address offset 0x08C). 
1755         //All other fields must be left at their default values.
1757         DDR3A_PGCR2 = 0x00F065B8; //NOBUB = 0, FXDLAT = 0       
1758         //DDR3A_PGCR2 = 0x00F83D09; //NOBUB = 0, FXDLAT = 1 
1760         //Set Impedence Register and DFIPU0=1 
1761         DDR3A_ZQ0CR1 = 0x0001005D; 
1762         DDR3A_ZQ1CR1 = 0x0001005B;
1763         DDR3A_ZQ2CR1 = 0x0001005B;
1766         // Re-trigger PHY initialization in DDR PHY through the VBUSP interface.
1767         // Program 0x00000033 to the PHY Initialization Register (address offset 0x004) to re-trigger PLL, ZCAL, and DCAL initialization.
1769         DDR3A_PIR = 0x00000033;
1771         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1772         do 
1773         { 
1774                 read_val = DDR3A_PGSR0;
1775         } while ((read_val&0x00000001) != 0x00000001);
1777         //---------------------------------------------------------------------------------------------------------                                     
1779         if(!ECC_Enable)
1780         {
1781                 DDR3A_DATX8_8 = read_val & 0xFFFFFFFE; //Disable ECC byte lane
1782         }
1783         // Trigger DDR3 initialization and leveling/training in DDR PHY through the VBUSP interface.
1784         // If using a 16-bit wide DDR interface, program DXEN=0 in the DATX8 2-7 General Configuration Registers (address offsets 0x240, 0x280, 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1785         // If using a 32-bit wide DDR interface, program DXEN=0 in the DATX8 4-7 General Configuration Registers (address offsets 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1786         // If ECC is not required, program DXEN=0 in the DATX8 8 General Configuration Register (address offset 0x3C0) to disable the leveling/training for the ECC byte lane.
1787         // NOTE: Setup supports 64-bit by default,  ECC enable by default.
1789         // Program 0x0000XF81 to the PHY Initialization Register (address offset 0x004) to trigger DDR3 initialization and leveling/training sequences 
1791         DDR3A_PIR = 0x0000FF81; //WLADJ - ON
1792         //DDR3A_PIR = 0x00000781;  //WLADJ - OFF
1794         //---------------------------------------------------------------------------------------------------------                                     
1796         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1797         do {              
1798                 read_val = DDR3A_PGSR0;
1799         } while ((read_val&0x00000001) != 0x00000001);
1801         /* End PHY Configuration */
1802         if(ECC_Enable)
1803         {
1804                 //Enable ECC
1805                 //0xB0000000: ECC_EN=1, ECC_VERIFY_EN=1, RMW_EN=1
1806                 //0x50000000: ECC_EN=1, ECC_VERIFY_EN=0, RMW_EN=1
1807                 DDR3A_ECC_CTRL = 0xB0000000;
1808                 read_val = DDR3A_ECC_CTRL;
1809                 if(read_val!=0xB0000000){
1810                         GEL_TextOut("\nIncorrect data written to DDR3A_ECC_CTRL..");
1811                 }
1812         }
1813         //---------------------------------------------------------------------------------------------------------                                     
1815         DDR3A_SDCFG    = 0x62008C62;    //62008C62
1816         //Single-Rank
1818         DDR3A_SDTIM1   = 0x125C8074;
1819         DDR3A_SDTIM2   = 0x00001D08;
1820         DDR3A_SDTIM3   = 0x32CDFF43;
1821         DDR3A_SDTIM4   = 0x543F0ADF;
1822         DDR3A_ZQCFG    = 0x70073200;    //Single-rank
1824         // Program reg_initref_dis=0 in the SDRAM Refresh Control Register (address offset 0x10).
1825         DDR3A_SDRFC = 0x00001457;
1827         GEL_TextOut("DDR3A initialization complete \n");
1828         /* End  DDR3A EMIF Configuration */
1830 }       
1831 /*----------------------------------------------------- DDR3A : DDR1600, 64bit--------------------------------------------------------------------------*/
1832 ddr3A_64bit_DDR1600_setup(int ECC_Enable)
1834         unsigned int multiplier = 15;
1835         unsigned int divider = 0;
1836         unsigned int OD_val = 4;
1838         int temp,i;
1839         int delay = 2000;
1841         KICK0 = 0x83E70B13;
1842         KICK1 = 0x95A4F1E0;
1845         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1846         do { 
1847                 read_val = DDR3A_PGSR0;
1848         } while ((read_val&0x00000001) != 0x00000001);
1850         //      Clocks are enabled and frequency is stable---------------------------------------
1851         // DDR3A PLL setup      
1852         GEL_TextOut ( "DDR3 PLL Setup ... \n");
1853         // DDR3APLLCTL0 = DDR3APLLCTL0 & 0xFF7FFFFF;
1854         // Set ENSAT = 1
1855         DDR3APLLCTL1 |= 0x00000040;
1856         // Put the PLL in PLL Mode  
1857         DDR3APLLCTL0 |= 0x00800000;
1859         // Program the necessary multipliers/dividers and BW adjustments            
1860         // Set the divider values 
1861         DDR3APLLCTL0 &= ~(0x0000003F);
1862         DDR3APLLCTL0 |= (divider & 0x0000003F);
1864         // Program OD[3:0] in the SECCTL register            
1865         DDR3APLLCTL0 &= OUTPUT_DIVIDE_MASK;  // clear the OD bit field
1866         DDR3APLLCTL0 |= ~OUTPUT_DIVIDE_MASK & (OD_val - 1) << OUTPUT_DIVIDE_OFFSET;  // set the OD[3:0] bit field of PLLD to OD_val    
1867         // Set the Multipler values 
1868         DDR3APLLCTL0 &= ~(0x0007FFC0);
1869         DDR3APLLCTL0 |= ((multiplier << 6) & 0x0007FFC0 );
1870         temp = ((multiplier + 1) >> 1) - 1;
1871         DDR3APLLCTL0 &= ~(0xFF000000); 
1872         DDR3APLLCTL0 |= ((temp << 24) & 0xFF000000);
1873         DDR3APLLCTL1 &= ~(0x0000000F);
1874         DDR3APLLCTL1 |= ((temp >> 8) & 0x0000000F);
1876         // In PLL Controller, reset the PLL (bit 13 in DDR3APLLCTL1 register) 
1877         DDR3APLLCTL1 |= 0x00004000;
1878         for(i=0;i<delay;i++);
1879         // In DDR3PLLCTL1, write PLLRST = 0 to bring PLL out of reset 
1880         DDR3APLLCTL1 &= ~(0x00004000);
1881         for(i=0;i<delay;i++);
1883         // Put the PLL in PLL Mode  
1884         DDR3APLLCTL0 &= ~(0x00800000); // ReSet the Bit 23
1885         GEL_TextOut( "DDR3 PLL Setup complete, DDR3A clock now running at 533MHz.\n" );
1886         //DDR3A PLL setup complete ---------------------------------------
1889         /*------------------------------- ECO FIX -----------------------------------------*/
1890         /*
1891                 // DDR3 write leveling ECO - Assert & release DDR PHY RESET after DDR PLL setup...
1892                 DDR3APLLCTL1 = DDR3APLLCTL1 | 0x80000000;       //Assert DDR PHY reset after PLL enabled
1893                 //for(i=0;i<delay;i++);                                         //delay 1000 cycles
1894                 DDR3APLLCTL1 = DDR3APLLCTL1 & 0x7FFFFFFF;       //Release DDR PHY reset
1896                 do {   // Poll IDONE after resetting PHY 
1897                         read_val = DDR3A_PGSR0; 
1898                    } while ((read_val&0x00000001) != 0x00000001);
1899          */
1900         /*------------------------- Start PHY Configuration -------------------------------*/
1902         // Program FRQSEL in the PLL Control Register (address offset 0x018).
1903         DDR3A_PLLCR = 0x1C000; //Set FRQSEL=11, for ctl_clk between 166-275MHz
1905         // Program WLSTEP=1, IODDRM=1, and ZCKSEL in the PHY General Configuration Register 1 (address offset 0x00C).
1907         DDR3A_PGCR1 |= (1 << 2); //WLSTEP = 1
1908         DDR3A_PGCR1 &= ~(IODDRM_MASK);
1909         DDR3A_PGCR1 |= (( 1 << 7) & IODDRM_MASK);
1910         DDR3A_PGCR1 &= ~(ZCKSEL_MASK);
1911         DDR3A_PGCR1 |= (( 1 << 23) & ZCKSEL_MASK);
1913         // Program PHY Timing Parameters Register 0-4 (address offset 0x01C - 0x02C).
1915         DDR3A_PTR0 = 0x42C21590;
1916         DDR3A_PTR1 = 0xD05612C0;        
1918         // Maintain default values of Phy Timing Parameters Register 2 in PUB
1920         DDR3A_PTR3 = 0x0D861A80;//0x18061A80; 
1921         DDR3A_PTR4 = 0x0C827100;//0x0AAE7100;
1923         // Program PDQ, MPRDQ, and BYTEMASK in the DRAM Configuration Register (address offset 0x044). 
1924         // All other fields must be left at their default values.
1926         DDR3A_DCR &= ~(PDQ_MASK); //PDQ = 0
1927         DDR3A_DCR &= ~(MPRDQ_MASK); //MPRDQ = 0
1928         DDR3A_DCR &= ~(BYTEMASK_MASK);
1929         DDR3A_DCR |= (( 1 << 10) & BYTEMASK_MASK);
1931         // Program DRAM Timing Parameters Register 0-2 (address offset 0x048 - 0x050). 
1933         DDR3A_DTPR0 = 0x9D5CBB66;
1934         DDR3A_DTPR1 = 0x12868300;       //Increase tWLO to 12
1935         DDR3A_DTPR2 = 0x5002D200;
1937         // Program BL=0, CL, WR, and PD=1 in the Mode Register 0 (address offset 0x054). 
1938         // All other fields must be left at their default values.
1940         DDR3A_MR0 = 0x00001C70;
1943         // Program DIC, RTT, and TDQS in the Mode Register 1 (address offset 0x058). 
1944         // All other fields must be left at their default values.
1946         DDR3A_MR1 = 0x00000006;
1948         // Program Mode Register 2 (address offset 0x05C).
1950         DDR3A_MR2 = 0x00000018;
1952         // Program DTMPR=1, DTEXD, DTEXG, RANKEN=1 or 3, and RFSHDT=7 in the Data Training Configuration Register (address offset 0x068). 
1953         // All other fields must be left at their default values.
1954         DDR3A_DTCR = 0x710035C7; //Single-rank  
1956         // Program tREFPRD=(5*tREFI/ddr_clk_period) in the PHY General Configuration Register 2 (address offset 0x08C). 
1957         //All other fields must be left at their default values.
1959         DDR3A_PGCR2 = 0x00F07A12; //NOBUB = 0, FXDLAT = 0       
1960         //DDR3A_PGCR2 = 0x00F83D09; //NOBUB = 0, FXDLAT = 1 
1962         //Set Impedence Register and DFIPU0=1 
1963         DDR3A_ZQ0CR1 = 0x0001005D; 
1964         DDR3A_ZQ1CR1 = 0x0001005B;
1965         DDR3A_ZQ2CR1 = 0x0001005B;
1968         // Re-trigger PHY initialization in DDR PHY through the VBUSP interface.
1969         // Program 0x00000033 to the PHY Initialization Register (address offset 0x004) to re-trigger PLL, ZCAL, and DCAL initialization.
1971         DDR3A_PIR = 0x00000033;
1973         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1974         do { 
1975                 read_val = DDR3A_PGSR0;
1976         } while ((read_val&0x00000001) != 0x00000001);
1978         //---------------------------------------------------------------------------------------------------------                                     
1980         if(!ECC_Enable)
1981         {
1982                 DDR3A_DATX8_8 = read_val & 0xFFFFFFFE; //Disable ECC byte lane
1983         }
1984         // Trigger DDR3 initialization and leveling/training in DDR PHY through the VBUSP interface.
1985         // If using a 16-bit wide DDR interface, program DXEN=0 in the DATX8 2-7 General Configuration Registers (address offsets 0x240, 0x280, 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1986         // If using a 32-bit wide DDR interface, program DXEN=0 in the DATX8 4-7 General Configuration Registers (address offsets 0x2C0, 0x300, 0x340, and 0x380) to disable the leveling/training for the upper byte lanes.
1987         // If ECC is not required, program DXEN=0 in the DATX8 8 General Configuration Register (address offset 0x3C0) to disable the leveling/training for the ECC byte lane.
1988         // NOTE: Setup supports 64-bit by default,  ECC enable by default.
1990         // Program 0x0000XF81 to the PHY Initialization Register (address offset 0x004) to trigger DDR3 initialization and leveling/training sequences 
1992         DDR3A_PIR = 0x0000FF81; //WLADJ - ON
1993         //DDR3A_PIR = 0x00000781;  //WLADJ - OFF
1995         //---------------------------------------------------------------------------------------------------------                                     
1997         // Poll for IDONE=1 in the PHY General Status Register 0 (address offset 0x010).
1998         do {              
1999                 read_val = DDR3A_PGSR0;
2000         } while ((read_val&0x00000001) != 0x00000001);
2002         /* End PHY Configuration */
2003         if(ECC_Enable)
2004         {
2005                 //Enable ECC
2006                 //0xB0000000: ECC_EN=1, ECC_VERIFY_EN=1, RMW_EN=1
2007                 //0x50000000: ECC_EN=1, ECC_VERIFY_EN=0, RMW_EN=1
2008                 DDR3A_ECC_CTRL = 0xB0000000;
2009                 read_val = DDR3A_ECC_CTRL;
2010                 if(read_val!=0xB0000000){
2011                         GEL_TextOut("\nIncorrect data written to DDR3A_ECC_CTRL..");
2012                 }
2013         }
2014         //---------------------------------------------------------------------------------------------------------                                     
2016         DDR3A_SDCFG    = 0x6200CE62;    //Single-Rank
2018         DDR3A_SDTIM1   = 0x166C9855;
2019         DDR3A_SDTIM2   = 0x00001D4A;
2020         DDR3A_SDTIM3   = 0x435DFF53;
2021         DDR3A_SDTIM4   = 0x543F0CFF;
2023         DDR3A_ZQCFG    = 0x70073200;    //Single-rank
2025         // Program reg_initref_dis=0 in the SDRAM Refresh Control Register (address offset 0x10).
2026         DDR3A_SDRFC = 0x00001869;
2028         GEL_TextOut("DDR3A initialization complete \n");
2029         /* End  DDR3A EMIF Configuration */
2036 /*--------------------------------------------------------------*/
2037 /* TCI66x MENU                                              */
2038 /*--------------------------------------------------------------*/
2040 menuitem "TCI66x Functions";
2042 /****************************************************************************
2043  *
2044  * NAME
2045  *      Global_Default_Setup
2046  *
2047  * PURPOSE:
2048  *      Setup almost everything ready for a new debug session:
2049  *      DSP modules and EVM board modules.
2050  *
2051  * USAGE
2052  *      This routine can be called as:
2053  *
2054  *      Global_Default_Setup()
2055  *
2056  * RETURN VALUE
2057  *      NONE
2058  *
2059  * REFERENCE
2060  *
2061  ****************************************************************************/
2062 hotmenu Global_Default_Setup()
2064         GEL_TextOut( "Global Default Setup...\n" );
2065         Global_Default_Setup_Silent();
2066         GEL_TextOut( "Global Default Setup... Done.\n" );
2069 hotmenu Reset()
2071         GEL_Reset();
2074 hotmenu InitXMC()
2076         xmc_setup();
2079 hotmenu CORE_PLL_INIT_122_88MHZ_to_614_4MHz()
2081         Set_Pll1(1); // call Set_Pll1 with index = 1 -> 122.88 MHz to 614.4 MHz operation 
2084 hotmenu CORE_PLL_INIT_122_88MHZ_to_737_28MHz()
2086         Set_Pll1(2); // call Set_Pll1 with index = 2 -> 122.88 MHz to 737.28 MHz operation 
2089 hotmenu CORE_PLL_INIT_122_88MHZ_to_983_04MHz()
2091         Set_Pll1(3); // call Set_Pll1 with index = 3 -> 122.88 MHz to 983.04 MHz operation 
2094 hotmenu CORE_PLL_INIT_122_88MHZ_to_1_2GHz()
2096         Set_Pll1(4); // call Set_Pll1 with index = 4 -> 122.88 MHz  to 1.2 GHz operation 
2100 hotmenu CORE_PLL_INIT_122_88MHZ_to_1_3Gz()
2102         Set_Pll1(5); // call Set_Pll1 with index = 4 -> 122.88 MHz  to 1.2 GHz operation 
2105 hotmenu TETRIS_POWERUP_AND_PLL_INIT_100MHZ_to_1000MHz()
2107         Set_Tetris_Pll(1); // 100 MHz to 1.0 GHz operation 
2110 hotmenu TETRIS_POWERUP_AND_PLL_INIT_100MHZ_to_1400MHz()
2112         Set_Tetris_Pll(2); // 100 MHz to 1.4 GHz operation 
2115 hotmenu TETRIS_POWERUP_AND_PLL_INIT_175MHZ_to_1400MHz()
2117         Set_Tetris_Pll(3); // 175 MHz to 1.4 GHz operation 
2121 hotmenu PA_PLL_Config()
2123         PaPllConfig();
2126 hotmenu DFE_PLL_Init_122MHZ_to_245MHz()
2128         // DFE PLL REFCLK = 122.88 MHz
2129         // DFE PLL CLKR = 0x0 (Default: no prediv)
2130         // DFE PLL CLKF = 0x7(Default) or 0x5 (multiplier = n+1 = 8,or 6)
2131         // DFE PLL CLKOD = 0x0(Default) (postdiv = 1, no postdiv)
2132         // DFE PLL CLKOUT = 983.04 (Default) or 737.28MHz
2134         //DFECLKSYNC_CTL register DIVMODE configured to /4 (default) or /2, to support
2135         //DFE operating frequency of 245.76 (default), 368.64 or 491.52 MHz. Note 491.52 is
2136         //frequency is only supported for internal testing.
2138         //DFE Frequency PLL Configuration DFECLKSYNC Divider Mode
2139         //245.76 MHz x8 (983.04 MHz) /4
2140         //491.52 MHz x8 (983.04 MHz) /2
2141         //368.64 MHz x6 (737.28 MHz) /2
2143         dfepll_setup(CHIP_LEVEL_REG, 0, 8-1, 1-1, 0);    
2145         GEL_TextOut("DFE_CLK setup to 245.76Mh complete!\n",,,,,);
2148 hotmenu InitDDR3A_64bit_DDR1066_NOECC()
2150         ddr3A_64bit_DDR1066_setup(0);
2151
2153 hotmenu InitDDR3A_64bit_DDR1333_NOECC()
2155         ddr3A_64bit_DDR1333_setup(0);
2156
2157 hotmenu InitDDR3A_64bit_DDR1600_NOECC()
2159         ddr3A_64bit_DDR1600_setup(0);
2160 }   
2161 ///* Function to enable CORE PLL observation clock for PLL output *///
2162 hotmenu ENABLE_CORE_PLL_OBSCLK()
2164         /* Unlock Chip Level Registers */
2165         KICK0 = KICK0_UNLOCK;
2166         KICK1 = KICK1_UNLOCK;
2168         /* set bit 1 to enable power to the CORE PLL observation clock, clear bit 0 to view the CORE PLL observation (output) clock */
2169         OBSCLKCTL |= (1 << 1);  /* set bit 1 to enable power to the observation clock */
2170         OBSCLKCTL &= ~(1 << 0); /* clear bit 0 to view the CORE PLL clock */ 
2172         /* Lock Chip Level Registers */
2173         KICK0 = 0x00000000;
2174         KICK1 = 0x00000000;
2176         GEL_TextOut("CORE PLL observation clock enabled and configured to show CORE PLL output\n");
2179 /* Function to enable DDR PLL observation clock for PLL output */
2180 hotmenu ENABLE_DDR_PLL_OBSCLK ()
2182         /* Unlock Chip Level Registers */
2183         KICK0 = KICK0_UNLOCK;
2184         KICK1 = KICK1_UNLOCK;
2186         /* set bit 1 to enable power to the CORE PLL observation clock, clear bit 0 to view the CORE PLL observation (output) clock */
2187         OBSCLKCTL |= (1 << 3);  /* set bit 3 to enable power to the observation clock */
2188         OBSCLKCTL |= (1 << 2);  /* set bit 2 to view the DDR PLL clock */ 
2190         /* Lock Chip Level Registers */
2191         //KICK0 = 0x00000000;
2192         // KICK1 = 0x00000000;
2194         GEL_TextOut("DDR PLL observation clock enabled and configured to show DDR PLL output\n");
2197 hotmenu ENABLE_ARM_PLL_OBSCLK ()
2199         /* Unlock Chip Level Registers */
2200         KICK0 = KICK0_UNLOCK;
2201         KICK1 = KICK1_UNLOCK;
2203         /* set bit 1 to enable power to the CORE PLL observation clock, clear bit 0 to view the CORE PLL observation (output) clock */
2204         //OBSCLKCTL |= (1 << 3);  /* set bit 3 to enable power to the observation clock */
2205         OBSCLKCTL |= (1 << 6);  /* set bit 2 to view the DDR PLL clock */ 
2207         /* Lock Chip Level Registers */
2208         KICK0 = 0x00000000;
2209         KICK1 = 0x00000000;
2211         GEL_TextOut("DDR PLL observation clock enabled and configured to show DDR PLL output\n");
2214 hotmenu ENABLE_PA_PLL_OBSCLK ()
2216         /* Unlock Chip Level Registers */
2217         KICK0 = KICK0_UNLOCK;
2218         KICK1 = KICK1_UNLOCK;
2220         /* set bit 1 to enable power to the CORE PLL observation clock, clear bit 0 to view the CORE PLL observation (output) clock */
2221         OBSCLKCTL |= (1 << 4);  /* set bit 3 to enable power to the observation clock */
2222         OBSCLKCTL |= (1 << 5);  /* set bit 2 to view the DDR PLL clock */ 
2224         /* Lock Chip Level Registers */
2225         KICK0 = 0x00000000;
2226         KICK1 = 0x00000000;
2228         GEL_TextOut("DDR PLL observation clock enabled and configured to show DDR PLL output\n");
2231 hotmenu ddr3A_write_read_test()
2233         //int data_set[4];
2234         //= {0xAAAAAAAA, 0x55555555, 0xFFFFFFFF, 0x00000000};
2235         unsigned int write_data = 0xAAAAAAAA;
2236         unsigned int read_data = 0x0;
2237         unsigned int errors = 0;
2238         int dw;
2239         unsigned int i, mem_start, mem_size, mem_location;
2240         mem_start = DDR3A_BASE_ADDRESS + (DNUM * 0x01000000);
2241         mem_size = 0x100;
2242         for(dw=0;dw<4;dw++)
2243         {
2244                 if (dw == 0) write_data = 0xAAAAAAAA;
2245                 if (dw == 1) write_data = 0x55555555;
2246                 if (dw == 2) write_data = 0xFFFFFFFF;
2247                 if (dw == 3) write_data = 0x00000000;
2248                 mem_location = mem_start;
2249                 GEL_TextOut( "Memory Test Write Core: %d, Mem Start: 0x%x, Mem Size: 0x%x, value: 0x%x ...\n",,2,,,DNUM,mem_start,mem_size,write_data);
2250                 for(i=0;i<mem_size;i++)
2251                 {
2252                         *( unsigned int* )(mem_location) = write_data;
2253                         mem_location += 4;
2254                 }
2255                 mem_location = mem_start;
2256                 GEL_TextOut( "Memory Test Read Core: %d, Mem Start: 0x%x, Mem Size: 0x%x ...\n",,2,,,DNUM,mem_start,mem_size);
2257                 for (i=0;i<mem_size;i++)
2258                 {
2259                         read_data = *( unsigned int* )(mem_location);
2260                         if (read_data != write_data)
2261                         {
2262                                 GEL_TextOut("DDR3 Data Error: DSP Core: %d, Mem Addr: 0x%x, read: 0x%x, expected: 0x%x \n",,2,,,DNUM,(DDR3_BASE_ADDRESS + (i * 4)),read_data,write_data);
2263                                 errors++;
2264                         }
2265                         mem_location += 4;
2266                 }
2267                 if (errors == 0)
2268                 {
2269                         GEL_TextOut( "Memory Test Done, no errors found.\n" );
2270                 }
2271                 else
2272                 {
2273                         GEL_TextOut("Memory Test Done, %d errors were encounterd. \n",,2,,,errors);
2274                 }
2275         }
2276         GEL_TextOut( "All Memory Test Completed on core: %d with %d errors.\n",,2,,,DNUM,errors);
2280 /****************************************************************************
2281  *                              PHY Related Defines and Functions
2282  ****************************************************************************/
2284 #define MDIO_VERSION_REG            (*(unsigned int *) (0x26200F00 + 0x00))
2285 /* mdio_user_access_reg */
2286 #define MDIO_USER_ACCESS_REG            (*(unsigned int *) (0x26200F00 + 0x80))
2287 #define MDIO_USER_CONTROL_REG            (*(unsigned int *) (0x26200F00 + 0x04))
2288 #define MDIO_USER_INT_MASK_REG            (*(unsigned int *) (0x26200F00 + 0x28))
2290 /* shift and mask for MDIO_USER_ACCESS_REG */
2291 #define CSL_MDIO_USER_ACCESS_REG_DATA_MASK (0x0000FFFFu)
2292 #define CSL_MDIO_USER_ACCESS_REG_DATA_SHIFT (0x00000000u)
2293 #define CSL_MDIO_USER_ACCESS_REG_DATA_RESETVAL (0x00000000u)
2295 #define CSL_MDIO_USER_ACCESS_REG_PHYADR_MASK (0x001F0000u)
2296 #define CSL_MDIO_USER_ACCESS_REG_PHYADR_SHIFT (0x00000010u)
2297 #define CSL_MDIO_USER_ACCESS_REG_PHYADR_RESETVAL (0x00000000u)
2299 #define CSL_MDIO_USER_ACCESS_REG_REGADR_MASK (0x03E00000u)
2300 #define CSL_MDIO_USER_ACCESS_REG_REGADR_SHIFT (0x00000015u)
2301 #define CSL_MDIO_USER_ACCESS_REG_REGADR_RESETVAL (0x00000000u)
2303 #define CSL_MDIO_USER_ACCESS_REG_ACK_MASK (0x20000000u)
2304 #define CSL_MDIO_USER_ACCESS_REG_ACK_SHIFT (0x0000001Du)
2305 #define CSL_MDIO_USER_ACCESS_REG_ACK_RESETVAL (0x00000000u)
2307 #define CSL_MDIO_USER_ACCESS_REG_WRITE_MASK (0x40000000u)
2308 #define CSL_MDIO_USER_ACCESS_REG_WRITE_SHIFT (0x0000001Eu)
2309 #define CSL_MDIO_USER_ACCESS_REG_WRITE_RESETVAL (0x00000000u)
2311 #define CSL_MDIO_USER_ACCESS_REG_GO_MASK (0x80000000u)
2312 #define CSL_MDIO_USER_ACCESS_REG_GO_SHIFT (0x0000001Fu)
2313 #define CSL_MDIO_USER_ACCESS_REG_GO_RESETVAL (0x00000000u)
2315 /*
2316 #define CSL_FMK(PER_REG_FIELD, val)                                         \
2317     (((val) << CSL_##PER_REG_FIELD##_SHIFT) & CSL_##PER_REG_FIELD##_MASK)
2319 #define CSL_FEXT(reg, PER_REG_FIELD)                                        \
2320     (((reg) & CSL_##PER_REG_FIELD##_MASK) >> CSL_##PER_REG_FIELD##_SHIFT)
2321 #endif
2322  */
2324 /* the Field MaKe macro */
2325 #define CSL_FMK(SHIFT, MASK, val)               (((val) << SHIFT) & MASK)
2327 /* the Field EXTract macro */
2328 #define CSL_FEXT(reg, SHIFT, MASK)              (((reg) & MASK) >> SHIFT)
2331 #define PHY_REG_PAGE_ADDR 22
2333 phy_hwwrite(unsigned short phy_addr, unsigned short addr, unsigned short val)
2335         unsigned int retVal=1;
2336         unsigned int i, delay=2000;
2337         
2338         MDIO_USER_ACCESS_REG   =  CSL_FMK (CSL_MDIO_USER_ACCESS_REG_GO_SHIFT, CSL_MDIO_USER_ACCESS_REG_GO_MASK, 1u) |
2339                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_WRITE_SHIFT, CSL_MDIO_USER_ACCESS_REG_WRITE_MASK, 1) |
2340                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_REGADR_SHIFT, CSL_MDIO_USER_ACCESS_REG_REGADR_MASK, addr) |
2341                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_PHYADR_SHIFT, CSL_MDIO_USER_ACCESS_REG_PHYADR_MASK, phy_addr) |
2342                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_DATA_SHIFT, CSL_MDIO_USER_ACCESS_REG_DATA_MASK, val);
2344         
2345         while(1)
2346         {
2347                 retVal=CSL_FEXT(MDIO_USER_ACCESS_REG, CSL_MDIO_USER_ACCESS_REG_GO_SHIFT, CSL_MDIO_USER_ACCESS_REG_GO_MASK);
2348                 if(retVal == 0)
2349                         break;
2351                 for(i = 0; i < delay; i++); // this delay is much more than required   
2353         }
2356 phy_hwread(unsigned short phy_addr, unsigned short addr, unsigned short *val)
2359         MDIO_USER_ACCESS_REG =  CSL_FMK (CSL_MDIO_USER_ACCESS_REG_GO_SHIFT, CSL_MDIO_USER_ACCESS_REG_GO_MASK, 1u) |
2360                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_REGADR_SHIFT, CSL_MDIO_USER_ACCESS_REG_REGADR_MASK, addr) |
2361                         CSL_FMK (CSL_MDIO_USER_ACCESS_REG_PHYADR_SHIFT, CSL_MDIO_USER_ACCESS_REG_PHYADR_MASK, phy_addr);
2363         PHYREG0_waitResultsAck(*val, ack);
2365         if(!ack)
2366                 GEL_TextOut("Reg read error for PHY: %d\n",,,,, phy_addr);
2369 #define PHYREG0_waitResultsAck( results, ack ) {                                        \
2370                 results = CSL_FEXT( MDIO_USER_ACCESS_REG, CSL_MDIO_USER_ACCESS_REG_DATA_SHIFT, CSL_MDIO_USER_ACCESS_REG_DATA_MASK);        \
2371                 ack = CSL_FEXT( MDIO_USER_ACCESS_REG, CSL_MDIO_USER_ACCESS_REG_ACK_SHIFT, CSL_MDIO_USER_ACCESS_REG_ACK_MASK); }
2373 phy_miiread (unsigned short phyaddr, unsigned short page, unsigned int addr, unsigned short *val)
2375         phy_hwwrite(phyaddr, PHY_REG_PAGE_ADDR, page);
2376         phy_hwread(phyaddr, addr, val);
2379 phy_miiwrite(unsigned short phyaddr, unsigned short page, unsigned short addr, unsigned short val)
2381         phy_hwwrite(phyaddr, PHY_REG_PAGE_ADDR, page);
2382         phy_hwwrite(phyaddr, addr, val);
2385 setupPhy(unsigned short phyaddr)
2387         unsigned short val = 0;
2388         unsigned int delay = 0x40000;
2389         unsigned int i = 0;
2391         GEL_TextOut("Staring Setup for PHY: %d\n",,,,, phyaddr);
2393         /* PHY settings as per Release Note, Errata section 3.1 */
2394         phy_hwwrite(phyaddr, 22, 0x00ff);
2395         phy_hwwrite(phyaddr, 17, 0x214B);
2396         phy_hwwrite(phyaddr, 16, 0x2144);
2397         phy_hwwrite(phyaddr, 17, 0x0C28);
2398         phy_hwwrite(phyaddr, 16, 0x2146);
2399         phy_hwwrite(phyaddr, 17, 0xB233);
2400         phy_hwwrite(phyaddr, 16, 0x214D);
2401         phy_hwwrite(phyaddr, 17, 0xCC0C);
2402         phy_hwwrite(phyaddr, 16, 0x2159);
2403         phy_hwwrite(phyaddr, 22, 0x0000);
2406         /* Set SGMII to Copper mode Page 18, Reg 20.2:0 = 1  */
2407         phy_hwwrite(phyaddr, 22, 18);
2408         phy_hwwrite(phyaddr, 20, 0x1);
2409         /* PHY Reset Page 18, Reg 20.15 = 1  */
2410         phy_hwwrite(phyaddr, 20, 0x8201);
2411         phy_hwwrite(phyaddr, 22, 00);
2412         
2413         GEL_TextOut("Wait a moment for copper link up for PHY: %d\n",,,,, phyaddr);
2414         for(i = 0; i < delay; i++);
2415         //fix: need to add phy link register read code here
2416         GEL_TextOut("Configuration Completed for PHY: %d\n",,,,, phyaddr);
2419 /****************************************************************************
2420  *
2421  * NAME
2422  *      SetupPhy
2423  *
2424  * PURPOSE:
2425  *      Setup Marvell 88e1514 default settings.
2426  *
2427  * USAGE
2428  *      This routine shall be called before using external network on Port 0
2429  *      Or Port 1 (RJ45 ports) with K2L evm.
2430  *
2431  * RETURN VALUE
2432  *      NONE
2433  *
2434  * REFERENCE
2435  *
2436  ****************************************************************************/
2437 hotmenu SetupPhy0()
2439         MDIO_USER_CONTROL_REG = (1 << 30) | 0xFA;
2440         MDIO_USER_INT_MASK_REG = 0x00;
2441         setupPhy(0);
2444 hotmenu SetupPhy1()
2446         MDIO_USER_CONTROL_REG = (1 << 30) | 0xFA;
2447         MDIO_USER_INT_MASK_REG = 0x00;
2448         setupPhy(1);
2451 menuitem "DSP CLOCK Estimation";
2453 #define TIMER_TSC             (1)    // The timer used for polling TSCH/TSCL  
2454 #define TIMER_TSC_POLL_PERIOD (10)   // Every 10 seconds
2455 unsigned int gPollPeriod = TIMER_TISC_POLL_PERIOD;
2456 unsigned int gTSCL = 0;
2457 unsigned int gTSCH = 0;              // Global var for holding previous read of TSCL/H
2458 unsigned int gNumberPoll=0;          // Number of pulling */
2459 unsigned int gLoopCount=0;
2463 hotmenu dspEnableTsc()
2465         //GEL_TextOut( "dspEnableTsc - write a value to TSCL to enable it\n" );
2466         if( GEL_IsHalted() ) {
2467                 TSCL = 0;  // A write to TSCL will enable TSC (timestamp counter)
2468                 GEL_Run();
2469         } else {
2470                 GEL_Halt();
2471                 TSCL = 0;
2472                 GEL_Run();
2473         }
2477 hotmenu dspDumpTsc()
2479         unsigned int tscl, tsch;
2480         tscl = TSCL;  /* note: need to read TSCL first */
2481         tsch = TSCH;
2482         GEL_TextOut( "dspEnableTsc - TSCH=%x, TSCL=%x\n",,,,, tscl, tsch );
2486 dspPollTsc()
2488         unsigned int tscl, tsch;
2489         unsigned long long tsc1, tsc2;
2491         if( gLoopCount <= gNumberPoll) { 
2492                 //GEL_EnableRealtime();
2493                 GEL_Halt();
2494                 tscl = TSCL;            /* The read time can be considered as variations */
2495                 tsch = TSCH;            /* The read won't cause variation */
2496                 //GEL_DisableRealtime();
2497                 GEL_Run();
2498                 tsc2  = (((unsigned long long) tsch)<<32) +  tscl;
2499                 tsc1  = (((unsigned long long)gTSCH)<<32) + gTSCL;
2500                 gTSCL = tscl;
2501                 gTSCH = tsch;
2503                 //tsc1 = (tsc2-tsc1)/TIMER_TSC_POLL_PERIOD;
2504                 tsc1 = (tsc2-tsc1)/gPollPeriod;
2506                 GEL_TextOut( "dspPollTsc - [TSCH,TSCL] = [%x, %x], freq=%dhz, i=%d\n",,,,,
2507                                 gTSCH, gTSCL, (tsc1), gLoopCount);
2508         }
2510         if( gLoopCount>=gNumberPoll ) {
2511                 dspCancelTscTimer();
2512         } else {  
2513                 gLoopCount++;
2514         }
2518 //
2519 // To cancel the Timer - TIMER_TSC, after using it. Otherwise, it will continue running.
2520 //
2521 hotmenu dspCancelTscTimer()
2523         GEL_TextOut( "dspCancelTscTimer\n");
2524         GEL_CancelTimer( TIMER_TSC );
2528 //
2529 // To poll the DSP clock.
2530 //
2531 dialog dspPollDSPClockFreq(
2532                 pollPeriod   "Polling period (sec) - the longer, the more accurate!",
2533                 numberOfPoll "Number of Polls" )
2535         gPollPeriod = pollPeriod;
2537         GEL_TextOut( "dspPollDSPClockFreq with - pollPeriod=%dsec, numberOfPoll=%d\n"
2538                         ,,,,, gPollPeriod, numberOfPoll);
2540         gNumberPoll = numberOfPoll-1;
2541         gLoopCount  = 0;
2542         dspEnableTsc();
2544         // Get the initial value of TSC
2545         //GEL_EnableRealtime();
2546         GEL_Halt();
2547         gTSCL = TSCL;            /* The read time can be considered as variations */
2548         gTSCH = TSCH;            /* The read won't cause variation */
2549         //GEL_DisableRealtime();
2550         GEL_Run();
2552         GEL_SetTimer( gPollPeriod*1000, TIMER_TSC, "dspPollTsc()");