ddad1bbb9e534f325786074d2de82eb7aacdfc43
[oweals/u-boot.git] / board / icecube / icecube.c
1 /*
2  * (C) Copyright 2003
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2004
6  * Mark Jonas, Freescale Semiconductor, mark.jonas@motorola.com.
7  *
8  * See file CREDITS for list of people who contributed to this
9  * project.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of
14  * the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24  * MA 02111-1307 USA
25  */
26
27 #include <common.h>
28 #include <mpc5xxx.h>
29 #include <pci.h>
30 #include <asm/processor.h>
31
32 #if defined(CONFIG_OF_FLAT_TREE)
33 #include <ft_build.h>
34 #endif
35
36 #if defined(CONFIG_LITE5200B)
37 #include "mt46v32m16.h"
38 #else
39 # if defined(CONFIG_MPC5200_DDR)
40 #  include "mt46v16m16-75.h"
41 # else
42 #include "mt48lc16m16a2-75.h"
43 # endif
44 #endif
45 #ifndef CFG_RAMBOOT
46 static void sdram_start (int hi_addr)
47 {
48         long hi_addr_bit = hi_addr ? 0x01000000 : 0;
49
50         /* unlock mode register */
51         *(vu_long *)MPC5XXX_SDRAM_CTRL = SDRAM_CONTROL | 0x80000000 | hi_addr_bit;
52         __asm__ volatile ("sync");
53
54         /* precharge all banks */
55         *(vu_long *)MPC5XXX_SDRAM_CTRL = SDRAM_CONTROL | 0x80000002 | hi_addr_bit;
56         __asm__ volatile ("sync");
57
58 #if SDRAM_DDR
59         /* set mode register: extended mode */
60         *(vu_long *)MPC5XXX_SDRAM_MODE = SDRAM_EMODE;
61         __asm__ volatile ("sync");
62
63         /* set mode register: reset DLL */
64         *(vu_long *)MPC5XXX_SDRAM_MODE = SDRAM_MODE | 0x04000000;
65         __asm__ volatile ("sync");
66 #endif
67
68         /* precharge all banks */
69         *(vu_long *)MPC5XXX_SDRAM_CTRL = SDRAM_CONTROL | 0x80000002 | hi_addr_bit;
70         __asm__ volatile ("sync");
71
72         /* auto refresh */
73         *(vu_long *)MPC5XXX_SDRAM_CTRL = SDRAM_CONTROL | 0x80000004 | hi_addr_bit;
74         __asm__ volatile ("sync");
75
76         /* set mode register */
77         *(vu_long *)MPC5XXX_SDRAM_MODE = SDRAM_MODE;
78         __asm__ volatile ("sync");
79
80         /* normal operation */
81         *(vu_long *)MPC5XXX_SDRAM_CTRL = SDRAM_CONTROL | hi_addr_bit;
82         __asm__ volatile ("sync");
83 }
84 #endif
85
86 /*
87  * ATTENTION: Although partially referenced initdram does NOT make real use
88  *            use of CFG_SDRAM_BASE. The code does not work if CFG_SDRAM_BASE
89  *            is something else than 0x00000000.
90  */
91
92 #if defined(CONFIG_MPC5200)
93 long int initdram (int board_type)
94 {
95         ulong dramsize = 0;
96         ulong dramsize2 = 0;
97         uint svr, pvr;
98
99 #ifndef CFG_RAMBOOT
100         ulong test1, test2;
101
102         /* setup SDRAM chip selects */
103         *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0x0000001e;/* 2G at 0x0 */
104         *(vu_long *)MPC5XXX_SDRAM_CS1CFG = 0x80000000;/* disabled */
105         __asm__ volatile ("sync");
106
107         /* setup config registers */
108         *(vu_long *)MPC5XXX_SDRAM_CONFIG1 = SDRAM_CONFIG1;
109         *(vu_long *)MPC5XXX_SDRAM_CONFIG2 = SDRAM_CONFIG2;
110         __asm__ volatile ("sync");
111
112 #if SDRAM_DDR
113         /* set tap delay */
114         *(vu_long *)MPC5XXX_CDM_PORCFG = SDRAM_TAPDELAY;
115         __asm__ volatile ("sync");
116 #endif
117
118         /* find RAM size using SDRAM CS0 only */
119         sdram_start(0);
120         test1 = get_ram_size((long *)CFG_SDRAM_BASE, 0x80000000);
121         sdram_start(1);
122         test2 = get_ram_size((long *)CFG_SDRAM_BASE, 0x80000000);
123         if (test1 > test2) {
124                 sdram_start(0);
125                 dramsize = test1;
126         } else {
127                 dramsize = test2;
128         }
129
130         /* memory smaller than 1MB is impossible */
131         if (dramsize < (1 << 20)) {
132                 dramsize = 0;
133         }
134
135         /* set SDRAM CS0 size according to the amount of RAM found */
136         if (dramsize > 0) {
137                 *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0x13 + __builtin_ffs(dramsize >> 20) - 1;
138         } else {
139                 *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0; /* disabled */
140         }
141
142         /* let SDRAM CS1 start right after CS0 */
143         *(vu_long *)MPC5XXX_SDRAM_CS1CFG = dramsize + 0x0000001e;/* 2G */
144
145         /* find RAM size using SDRAM CS1 only */
146         if (!dramsize)
147                 sdram_start(0);
148         test2 = test1 = get_ram_size((long *)(CFG_SDRAM_BASE + dramsize), 0x80000000);
149         if (!dramsize) {
150                 sdram_start(1);
151                 test2 = get_ram_size((long *)(CFG_SDRAM_BASE + dramsize), 0x80000000);
152         }
153         if (test1 > test2) {
154                 sdram_start(0);
155                 dramsize2 = test1;
156         } else {
157                 dramsize2 = test2;
158         }
159
160         /* memory smaller than 1MB is impossible */
161         if (dramsize2 < (1 << 20)) {
162                 dramsize2 = 0;
163         }
164
165         /* set SDRAM CS1 size according to the amount of RAM found */
166         if (dramsize2 > 0) {
167                 *(vu_long *)MPC5XXX_SDRAM_CS1CFG = dramsize
168                         | (0x13 + __builtin_ffs(dramsize2 >> 20) - 1);
169         } else {
170                 *(vu_long *)MPC5XXX_SDRAM_CS1CFG = dramsize; /* disabled */
171         }
172
173 #else /* CFG_RAMBOOT */
174
175         /* retrieve size of memory connected to SDRAM CS0 */
176         dramsize = *(vu_long *)MPC5XXX_SDRAM_CS0CFG & 0xFF;
177         if (dramsize >= 0x13) {
178                 dramsize = (1 << (dramsize - 0x13)) << 20;
179         } else {
180                 dramsize = 0;
181         }
182
183         /* retrieve size of memory connected to SDRAM CS1 */
184         dramsize2 = *(vu_long *)MPC5XXX_SDRAM_CS1CFG & 0xFF;
185         if (dramsize2 >= 0x13) {
186                 dramsize2 = (1 << (dramsize2 - 0x13)) << 20;
187         } else {
188                 dramsize2 = 0;
189         }
190
191 #endif /* CFG_RAMBOOT */
192
193         /*
194          * On MPC5200B we need to set the special configuration delay in the
195          * DDR controller. Please refer to Freescale's AN3221 "MPC5200B SDRAM
196          * Initialization and Configuration", 3.3.1 SDelay--MBAR + 0x0190:
197          *
198          * "The SDelay should be written to a value of 0x00000004. It is
199          * required to account for changes caused by normal wafer processing
200          * parameters."
201          */
202         svr = get_svr();
203         pvr = get_pvr();
204         if ((SVR_MJREV(svr) >= 2) &&
205             (PVR_MAJ(pvr) == 1) && (PVR_MIN(pvr) == 4)) {
206
207                 *(vu_long *)MPC5XXX_SDRAM_SDELAY = 0x04;
208                 __asm__ volatile ("sync");
209         }
210
211         return dramsize + dramsize2;
212 }
213
214 #elif defined(CONFIG_MGT5100)
215
216 long int initdram (int board_type)
217 {
218         ulong dramsize = 0;
219 #ifndef CFG_RAMBOOT
220         ulong test1, test2;
221
222         /* setup and enable SDRAM chip selects */
223         *(vu_long *)MPC5XXX_SDRAM_START = 0x00000000;
224         *(vu_long *)MPC5XXX_SDRAM_STOP = 0x0000ffff;/* 2G */
225         *(vu_long *)MPC5XXX_ADDECR |= (1 << 22); /* Enable SDRAM */
226         __asm__ volatile ("sync");
227
228         /* setup config registers */
229         *(vu_long *)MPC5XXX_SDRAM_CONFIG1 = SDRAM_CONFIG1;
230         *(vu_long *)MPC5XXX_SDRAM_CONFIG2 = SDRAM_CONFIG2;
231
232         /* address select register */
233         *(vu_long *)MPC5XXX_SDRAM_XLBSEL = SDRAM_ADDRSEL;
234         __asm__ volatile ("sync");
235
236         /* find RAM size */
237         sdram_start(0);
238         test1 = get_ram_size((long *)CFG_SDRAM_BASE, 0x80000000);
239         sdram_start(1);
240         test2 = get_ram_size((long *)CFG_SDRAM_BASE, 0x80000000);
241         if (test1 > test2) {
242                 sdram_start(0);
243                 dramsize = test1;
244         } else {
245                 dramsize = test2;
246         }
247
248         /* set SDRAM end address according to size */
249         *(vu_long *)MPC5XXX_SDRAM_STOP = ((dramsize - 1) >> 15);
250
251 #else /* CFG_RAMBOOT */
252
253         /* Retrieve amount of SDRAM available */
254         dramsize = ((*(vu_long *)MPC5XXX_SDRAM_STOP + 1) << 15);
255
256 #endif /* CFG_RAMBOOT */
257
258         return dramsize;
259 }
260
261 #else
262 #error Neither CONFIG_MPC5200 or CONFIG_MGT5100 defined
263 #endif
264
265 int checkboard (void)
266 {
267 #if defined (CONFIG_LITE5200B)
268         puts ("Board: Freescale Lite5200B\n");
269 #elif defined(CONFIG_MPC5200)
270         puts ("Board: Motorola MPC5200 (IceCube)\n");
271 #elif defined(CONFIG_MGT5100)
272         puts ("Board: Motorola MGT5100 (IceCube)\n");
273 #endif
274         return 0;
275 }
276
277 void flash_preinit(void)
278 {
279         /*
280          * Now, when we are in RAM, enable flash write
281          * access for detection process.
282          * Note that CS_BOOT cannot be cleared when
283          * executing in flash.
284          */
285 #if defined(CONFIG_MGT5100)
286         *(vu_long *)MPC5XXX_ADDECR &= ~(1 << 25); /* disable CS_BOOT */
287         *(vu_long *)MPC5XXX_ADDECR |= (1 << 16); /* enable CS0 */
288 #endif
289         *(vu_long *)MPC5XXX_BOOTCS_CFG &= ~0x1; /* clear RO */
290 }
291
292 void flash_afterinit(ulong size)
293 {
294         if (size == 0x800000) { /* adjust mapping */
295                 *(vu_long *)MPC5XXX_BOOTCS_START = *(vu_long *)MPC5XXX_CS0_START =
296                         START_REG(CFG_BOOTCS_START | size);
297                 *(vu_long *)MPC5XXX_BOOTCS_STOP = *(vu_long *)MPC5XXX_CS0_STOP =
298                         STOP_REG(CFG_BOOTCS_START | size, size);
299         }
300 }
301
302 #ifdef  CONFIG_PCI
303 static struct pci_controller hose;
304
305 extern void pci_mpc5xxx_init(struct pci_controller *);
306
307 void pci_init_board(void)
308 {
309         pci_mpc5xxx_init(&hose);
310 }
311 #endif
312
313 #if defined (CFG_CMD_IDE) && defined (CONFIG_IDE_RESET)
314
315 void init_ide_reset (void)
316 {
317         debug ("init_ide_reset\n");
318
319         /* Configure PSC1_4 as GPIO output for ATA reset */
320         *(vu_long *) MPC5XXX_WU_GPIO_ENABLE |= GPIO_PSC1_4;
321         *(vu_long *) MPC5XXX_WU_GPIO_DIR    |= GPIO_PSC1_4;
322         /* Deassert reset */
323         *(vu_long *) MPC5XXX_WU_GPIO_DATA_O   |= GPIO_PSC1_4;
324 }
325
326 void ide_set_reset (int idereset)
327 {
328         debug ("ide_reset(%d)\n", idereset);
329
330         if (idereset) {
331                 *(vu_long *) MPC5XXX_WU_GPIO_DATA_O &= ~GPIO_PSC1_4;
332                 /* Make a delay. MPC5200 spec says 25 usec min */
333                 udelay(500000);
334         } else {
335                 *(vu_long *) MPC5XXX_WU_GPIO_DATA_O |=  GPIO_PSC1_4;
336         }
337 }
338 #endif /* defined (CFG_CMD_IDE) && defined (CONFIG_IDE_RESET) */
339
340 #if defined(CONFIG_OF_FLAT_TREE) && defined(CONFIG_OF_BOARD_SETUP)
341 void
342 ft_board_setup(void *blob, bd_t *bd)
343 {
344         ft_cpu_setup(blob, bd);
345 }
346 #endif