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