Merge branch 'master' of git://www.denx.de/git/u-boot-mmc
[oweals/u-boot.git] / arch / mips / lib / board.c
1 /*
2  * (C) Copyright 2003
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <command.h>
26 #include <malloc.h>
27 #include <stdio_dev.h>
28 #include <version.h>
29 #include <net.h>
30 #include <environment.h>
31 #include <nand.h>
32 #include <onenand_uboot.h>
33 #include <spi.h>
34
35 #ifdef CONFIG_BITBANGMII
36 #include <miiphy.h>
37 #endif
38
39 DECLARE_GLOBAL_DATA_PTR;
40
41 ulong monitor_flash_len;
42
43 static char *failed = "*** failed ***\n";
44
45 /*
46  * mips_io_port_base is the begin of the address space to which x86 style
47  * I/O ports are mapped.
48  */
49 unsigned long mips_io_port_base = -1;
50
51 int __board_early_init_f(void)
52 {
53         /*
54          * Nothing to do in this dummy implementation
55          */
56         return 0;
57 }
58 int board_early_init_f(void)
59         __attribute__((weak, alias("__board_early_init_f")));
60
61 static int init_func_ram(void)
62 {
63 #ifdef  CONFIG_BOARD_TYPES
64         int board_type = gd->board_type;
65 #else
66         int board_type = 0;     /* use dummy arg */
67 #endif
68         puts("DRAM:  ");
69
70         gd->ram_size = initdram(board_type);
71         if (gd->ram_size > 0) {
72                 print_size(gd->ram_size, "\n");
73                 return 0;
74         }
75         puts(failed);
76         return 1;
77 }
78
79 static int display_banner(void)
80 {
81
82         printf("\n\n%s\n\n", version_string);
83         return 0;
84 }
85
86 #ifndef CONFIG_SYS_NO_FLASH
87 static void display_flash_config(ulong size)
88 {
89         puts("Flash: ");
90         print_size(size, "\n");
91 }
92 #endif
93
94 static int init_baudrate(void)
95 {
96         gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
97         return 0;
98 }
99
100
101 /*
102  * Breath some life into the board...
103  *
104  * The first part of initialization is running from Flash memory;
105  * its main purpose is to initialize the RAM so that we
106  * can relocate the monitor code to RAM.
107  */
108
109 /*
110  * All attempts to come up with a "common" initialization sequence
111  * that works for all boards and architectures failed: some of the
112  * requirements are just _too_ different. To get rid of the resulting
113  * mess of board dependend #ifdef'ed code we now make the whole
114  * initialization sequence configurable to the user.
115  *
116  * The requirements for any new initalization function is simple: it
117  * receives a pointer to the "global data" structure as it's only
118  * argument, and returns an integer return code, where 0 means
119  * "continue" and != 0 means "fatal error, hang the system".
120  */
121 typedef int (init_fnc_t)(void);
122
123 init_fnc_t *init_sequence[] = {
124         board_early_init_f,
125         timer_init,
126         env_init,               /* initialize environment */
127 #ifdef CONFIG_INCA_IP
128         incaip_set_cpuclk,      /* set cpu clock according to env. variable */
129 #endif
130         init_baudrate,          /* initialize baudrate settings */
131         serial_init,            /* serial communications setup */
132         console_init_f,
133         display_banner,         /* say that we are here */
134         checkboard,
135         init_func_ram,
136         NULL,
137 };
138
139
140 void board_init_f(ulong bootflag)
141 {
142         gd_t gd_data, *id;
143         bd_t *bd;
144         init_fnc_t **init_fnc_ptr;
145         ulong addr, addr_sp, len = (ulong)&uboot_end - CONFIG_SYS_MONITOR_BASE;
146         ulong *s;
147
148         /* Pointer is writable since we allocated a register for it.
149          */
150         gd = &gd_data;
151         /* compiler optimization barrier needed for GCC >= 3.4 */
152         __asm__ __volatile__("" : : : "memory");
153
154         memset((void *)gd, 0, sizeof(gd_t));
155
156         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
157                 if ((*init_fnc_ptr)() != 0)
158                         hang();
159         }
160
161         /*
162          * Now that we have DRAM mapped and working, we can
163          * relocate the code and continue running from DRAM.
164          */
165         addr = CONFIG_SYS_SDRAM_BASE + gd->ram_size;
166
167         /* We can reserve some RAM "on top" here.
168          */
169
170         /* round down to next 4 kB limit.
171          */
172         addr &= ~(4096 - 1);
173         debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
174
175         /* Reserve memory for U-Boot code, data & bss
176          * round down to next 16 kB limit
177          */
178         addr -= len;
179         addr &= ~(16 * 1024 - 1);
180
181         debug("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
182
183          /* Reserve memory for malloc() arena.
184          */
185         addr_sp = addr - TOTAL_MALLOC_LEN;
186         debug("Reserving %dk for malloc() at: %08lx\n",
187                         TOTAL_MALLOC_LEN >> 10, addr_sp);
188
189         /*
190          * (permanently) allocate a Board Info struct
191          * and a permanent copy of the "global" data
192          */
193         addr_sp -= sizeof(bd_t);
194         bd = (bd_t *)addr_sp;
195         gd->bd = bd;
196         debug("Reserving %zu Bytes for Board Info at: %08lx\n",
197                         sizeof(bd_t), addr_sp);
198
199         addr_sp -= sizeof(gd_t);
200         id = (gd_t *)addr_sp;
201         debug("Reserving %zu Bytes for Global Data at: %08lx\n",
202                         sizeof(gd_t), addr_sp);
203
204         /* Reserve memory for boot params.
205          */
206         addr_sp -= CONFIG_SYS_BOOTPARAMS_LEN;
207         bd->bi_boot_params = addr_sp;
208         debug("Reserving %dk for boot params() at: %08lx\n",
209                         CONFIG_SYS_BOOTPARAMS_LEN >> 10, addr_sp);
210
211         /*
212          * Finally, we set up a new (bigger) stack.
213          *
214          * Leave some safety gap for SP, force alignment on 16 byte boundary
215          * Clear initial stack frame
216          */
217         addr_sp -= 16;
218         addr_sp &= ~0xF;
219         s = (ulong *)addr_sp;
220         *s-- = 0;
221         *s-- = 0;
222         addr_sp = (ulong)s;
223         debug("Stack Pointer at: %08lx\n", addr_sp);
224
225         /*
226          * Save local variables to board info struct
227          */
228         bd->bi_memstart = CONFIG_SYS_SDRAM_BASE;        /* start of DRAM */
229         bd->bi_memsize  = gd->ram_size;         /* size of DRAM in bytes */
230         bd->bi_baudrate = gd->baudrate;         /* Console Baudrate */
231
232         memcpy(id, (void *)gd, sizeof(gd_t));
233
234         relocate_code(addr_sp, id, addr);
235
236         /* NOTREACHED - relocate_code() does not return */
237 }
238
239 /*
240  * This is the next part if the initialization sequence: we are now
241  * running from RAM and have a "normal" C environment, i. e. global
242  * data can be written, BSS has been cleared, the stack size in not
243  * that critical any more, etc.
244  */
245
246 void board_init_r(gd_t *id, ulong dest_addr)
247 {
248 #ifndef CONFIG_SYS_NO_FLASH
249         ulong size;
250 #endif
251 #ifndef CONFIG_ENV_IS_NOWHERE
252         extern char *env_name_spec;
253 #endif
254         bd_t *bd;
255
256         gd = id;
257         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
258
259         debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
260
261         gd->reloc_off = dest_addr - CONFIG_SYS_MONITOR_BASE;
262
263         monitor_flash_len = (ulong)&uboot_end_data - dest_addr;
264
265 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
266         /*
267          * We have to relocate the command table manually
268          */
269         fixup_cmdtable(ll_entry_start(cmd_tbl_t, cmd),
270                         ll_entry_count(cmd_tbl_t, cmd));
271 #endif /* defined(CONFIG_NEEDS_MANUAL_RELOC) */
272
273         /* there are some other pointer constants we must deal with */
274 #ifndef CONFIG_ENV_IS_NOWHERE
275         env_name_spec += gd->reloc_off;
276 #endif
277
278         bd = gd->bd;
279
280         /* The Malloc area is immediately below the monitor copy in DRAM */
281         mem_malloc_init(CONFIG_SYS_MONITOR_BASE + gd->reloc_off -
282                         TOTAL_MALLOC_LEN, TOTAL_MALLOC_LEN);
283         malloc_bin_reloc();
284
285 #ifndef CONFIG_SYS_NO_FLASH
286         /* configure available FLASH banks */
287         size = flash_init();
288         display_flash_config(size);
289         bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
290         bd->bi_flashsize = size;
291
292 #if CONFIG_SYS_MONITOR_BASE == CONFIG_SYS_FLASH_BASE
293         bd->bi_flashoffset = monitor_flash_len; /* reserved area for U-Boot */
294 #else
295         bd->bi_flashoffset = 0;
296 #endif
297 #else
298         bd->bi_flashstart = 0;
299         bd->bi_flashsize = 0;
300         bd->bi_flashoffset = 0;
301 #endif
302
303 #ifdef CONFIG_CMD_NAND
304         puts("NAND:  ");
305         nand_init();            /* go init the NAND */
306 #endif
307
308 #if defined(CONFIG_CMD_ONENAND)
309         onenand_init();
310 #endif
311
312         /* relocate environment function pointers etc. */
313         env_relocate();
314
315 #if defined(CONFIG_PCI)
316         /*
317          * Do pci configuration
318          */
319         pci_init();
320 #endif
321
322 /** leave this here (after malloc(), environment and PCI are working) **/
323         /* Initialize stdio devices */
324         stdio_init();
325
326         jumptable_init();
327
328         /* Initialize the console (after the relocation and devices init) */
329         console_init_r();
330 /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/
331
332         /* Initialize from environment */
333         load_addr = getenv_ulong("loadaddr", 16, load_addr);
334
335 #ifdef CONFIG_CMD_SPI
336         puts("SPI:   ");
337         spi_init();             /* go init the SPI */
338         puts("ready\n");
339 #endif
340
341 #if defined(CONFIG_MISC_INIT_R)
342         /* miscellaneous platform dependent initialisations */
343         misc_init_r();
344 #endif
345
346 #ifdef CONFIG_BITBANGMII
347         bb_miiphy_init();
348 #endif
349 #if defined(CONFIG_CMD_NET)
350         puts("Net:   ");
351         eth_initialize(gd->bd);
352 #endif
353
354         /* main_loop() can return to retry autoboot, if so just run it again. */
355         for (;;)
356                 main_loop();
357
358         /* NOTREACHED - no way out of command loop except booting */
359 }
360
361 void hang(void)
362 {
363         puts("### ERROR ### Please RESET the board ###\n");
364         for (;;)
365                 ;
366 }