]> git.sur5r.net Git - u-boot/blob - arch/arm/lib/board.c
arm: Use getenv_ulong() in place of getenv(), strtoul
[u-boot] / arch / arm / lib / board.c
1 /*
2  * (C) Copyright 2002-2006
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2002
6  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
7  * Marius Groeger <mgroeger@sysgo.de>
8  *
9  * See file CREDITS for list of people who contributed to this
10  * project.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; either version 2 of
15  * the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25  * MA 02111-1307 USA
26  */
27
28 /*
29  * To match the U-Boot user interface on ARM platforms to the U-Boot
30  * standard (as on PPC platforms), some messages with debug character
31  * are removed from the default U-Boot build.
32  *
33  * Define DEBUG here if you want additional info as shown below
34  * printed upon startup:
35  *
36  * U-Boot code: 00F00000 -> 00F3C774  BSS: -> 00FC3274
37  * IRQ Stack: 00ebff7c
38  * FIQ Stack: 00ebef7c
39  */
40
41 #include <common.h>
42 #include <command.h>
43 #include <malloc.h>
44 #include <stdio_dev.h>
45 #include <version.h>
46 #include <net.h>
47 #include <serial.h>
48 #include <nand.h>
49 #include <onenand_uboot.h>
50 #include <mmc.h>
51 #include <post.h>
52 #include <logbuff.h>
53
54 #ifdef CONFIG_BITBANGMII
55 #include <miiphy.h>
56 #endif
57
58 #ifdef CONFIG_DRIVER_SMC91111
59 #include "../drivers/net/smc91111.h"
60 #endif
61 #ifdef CONFIG_DRIVER_LAN91C96
62 #include "../drivers/net/lan91c96.h"
63 #endif
64
65 DECLARE_GLOBAL_DATA_PTR;
66
67 ulong monitor_flash_len;
68
69 #ifdef CONFIG_HAS_DATAFLASH
70 extern int  AT91F_DataflashInit(void);
71 extern void dataflash_print_info(void);
72 #endif
73
74 #ifdef CONFIG_DRIVER_RTL8019
75 extern void rtl8019_get_enetaddr (uchar * addr);
76 #endif
77
78 #if defined(CONFIG_HARD_I2C) || \
79     defined(CONFIG_SOFT_I2C)
80 #include <i2c.h>
81 #endif
82
83
84 /************************************************************************
85  * Coloured LED functionality
86  ************************************************************************
87  * May be supplied by boards if desired
88  */
89 inline void __coloured_LED_init(void) {}
90 void coloured_LED_init(void)
91         __attribute__((weak, alias("__coloured_LED_init")));
92 inline void __red_led_on(void) {}
93 void red_led_on(void) __attribute__((weak, alias("__red_led_on")));
94 inline void __red_led_off(void) {}
95 void red_led_off(void) __attribute__((weak, alias("__red_led_off")));
96 inline void __green_led_on(void) {}
97 void green_led_on(void) __attribute__((weak, alias("__green_led_on")));
98 inline void __green_led_off(void) {}
99 void green_led_off(void) __attribute__((weak, alias("__green_led_off")));
100 inline void __yellow_led_on(void) {}
101 void yellow_led_on(void) __attribute__((weak, alias("__yellow_led_on")));
102 inline void __yellow_led_off(void) {}
103 void yellow_led_off(void) __attribute__((weak, alias("__yellow_led_off")));
104 inline void __blue_led_on(void) {}
105 void blue_led_on(void) __attribute__((weak, alias("__blue_led_on")));
106 inline void __blue_led_off(void) {}
107 void blue_led_off(void) __attribute__((weak, alias("__blue_led_off")));
108
109 /*
110  ************************************************************************
111  * Init Utilities                                                       *
112  ************************************************************************
113  * Some of this code should be moved into the core functions,
114  * or dropped completely,
115  * but let's get it working (again) first...
116  */
117
118 #if defined(CONFIG_ARM_DCC) && !defined(CONFIG_BAUDRATE)
119 #define CONFIG_BAUDRATE 115200
120 #endif
121
122 static int init_baudrate(void)
123 {
124         gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
125         return 0;
126 }
127
128 static int display_banner(void)
129 {
130         printf("\n\n%s\n\n", version_string);
131         debug("U-Boot code: %08lX -> %08lX  BSS: -> %08lX\n",
132                _TEXT_BASE,
133                _bss_start_ofs + _TEXT_BASE, _bss_end_ofs + _TEXT_BASE);
134 #ifdef CONFIG_MODEM_SUPPORT
135         debug("Modem Support enabled\n");
136 #endif
137 #ifdef CONFIG_USE_IRQ
138         debug("IRQ Stack: %08lx\n", IRQ_STACK_START);
139         debug("FIQ Stack: %08lx\n", FIQ_STACK_START);
140 #endif
141
142         return (0);
143 }
144
145 /*
146  * WARNING: this code looks "cleaner" than the PowerPC version, but
147  * has the disadvantage that you either get nothing, or everything.
148  * On PowerPC, you might see "DRAM: " before the system hangs - which
149  * gives a simple yet clear indication which part of the
150  * initialization if failing.
151  */
152 static int display_dram_config(void)
153 {
154         int i;
155
156 #ifdef DEBUG
157         puts("RAM Configuration:\n");
158
159         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
160                 printf("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
161                 print_size(gd->bd->bi_dram[i].size, "\n");
162         }
163 #else
164         ulong size = 0;
165
166         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++)
167                 size += gd->bd->bi_dram[i].size;
168
169         puts("DRAM:  ");
170         print_size(size, "\n");
171 #endif
172
173         return (0);
174 }
175
176 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
177 static int init_func_i2c(void)
178 {
179         puts("I2C:   ");
180         i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
181         puts("ready\n");
182         return (0);
183 }
184 #endif
185
186 #if defined(CONFIG_CMD_PCI) || defined (CONFIG_PCI)
187 #include <pci.h>
188 static int arm_pci_init(void)
189 {
190         pci_init();
191         return 0;
192 }
193 #endif /* CONFIG_CMD_PCI || CONFIG_PCI */
194
195 /*
196  * Breathe some life into the board...
197  *
198  * Initialize a serial port as console, and carry out some hardware
199  * tests.
200  *
201  * The first part of initialization is running from Flash memory;
202  * its main purpose is to initialize the RAM so that we
203  * can relocate the monitor code to RAM.
204  */
205
206 /*
207  * All attempts to come up with a "common" initialization sequence
208  * that works for all boards and architectures failed: some of the
209  * requirements are just _too_ different. To get rid of the resulting
210  * mess of board dependent #ifdef'ed code we now make the whole
211  * initialization sequence configurable to the user.
212  *
213  * The requirements for any new initalization function is simple: it
214  * receives a pointer to the "global data" structure as it's only
215  * argument, and returns an integer return code, where 0 means
216  * "continue" and != 0 means "fatal error, hang the system".
217  */
218 typedef int (init_fnc_t) (void);
219
220 int print_cpuinfo(void);
221
222 void __dram_init_banksize(void)
223 {
224         gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
225         gd->bd->bi_dram[0].size =  gd->ram_size;
226 }
227 void dram_init_banksize(void)
228         __attribute__((weak, alias("__dram_init_banksize")));
229
230 init_fnc_t *init_sequence[] = {
231 #if defined(CONFIG_ARCH_CPU_INIT)
232         arch_cpu_init,          /* basic arch cpu dependent setup */
233 #endif
234 #if defined(CONFIG_BOARD_EARLY_INIT_F)
235         board_early_init_f,
236 #endif
237         timer_init,             /* initialize timer */
238 #ifdef CONFIG_FSL_ESDHC
239         get_clocks,
240 #endif
241         env_init,               /* initialize environment */
242         init_baudrate,          /* initialze baudrate settings */
243         serial_init,            /* serial communications setup */
244         console_init_f,         /* stage 1 init of console */
245         display_banner,         /* say that we are here */
246 #if defined(CONFIG_DISPLAY_CPUINFO)
247         print_cpuinfo,          /* display cpu info (and speed) */
248 #endif
249 #if defined(CONFIG_DISPLAY_BOARDINFO)
250         checkboard,             /* display board info */
251 #endif
252 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
253         init_func_i2c,
254 #endif
255         dram_init,              /* configure available RAM banks */
256         NULL,
257 };
258
259 void board_init_f(ulong bootflag)
260 {
261         bd_t *bd;
262         init_fnc_t **init_fnc_ptr;
263         gd_t *id;
264         ulong addr, addr_sp;
265 #ifdef CONFIG_PRAM
266         ulong reg;
267 #endif
268
269         /* Pointer is writable since we allocated a register for it */
270         gd = (gd_t *) ((CONFIG_SYS_INIT_SP_ADDR) & ~0x07);
271         /* compiler optimization barrier needed for GCC >= 3.4 */
272         __asm__ __volatile__("": : :"memory");
273
274         memset((void *)gd, 0, sizeof(gd_t));
275
276         gd->mon_len = _bss_end_ofs;
277
278         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
279                 if ((*init_fnc_ptr)() != 0) {
280                         hang ();
281                 }
282         }
283
284         debug("monitor len: %08lX\n", gd->mon_len);
285         /*
286          * Ram is setup, size stored in gd !!
287          */
288         debug("ramsize: %08lX\n", gd->ram_size);
289 #if defined(CONFIG_SYS_MEM_TOP_HIDE)
290         /*
291          * Subtract specified amount of memory to hide so that it won't
292          * get "touched" at all by U-Boot. By fixing up gd->ram_size
293          * the Linux kernel should now get passed the now "corrected"
294          * memory size and won't touch it either. This should work
295          * for arch/ppc and arch/powerpc. Only Linux board ports in
296          * arch/powerpc with bootwrapper support, that recalculate the
297          * memory size from the SDRAM controller setup will have to
298          * get fixed.
299          */
300         gd->ram_size -= CONFIG_SYS_MEM_TOP_HIDE;
301 #endif
302
303         addr = CONFIG_SYS_SDRAM_BASE + gd->ram_size;
304
305 #ifdef CONFIG_LOGBUFFER
306 #ifndef CONFIG_ALT_LB_ADDR
307         /* reserve kernel log buffer */
308         addr -= (LOGBUFF_RESERVE);
309         debug("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN,
310                 addr);
311 #endif
312 #endif
313
314 #ifdef CONFIG_PRAM
315         /*
316          * reserve protected RAM
317          */
318         reg = getenv_ulong("pram", 10, CONFIG_PRAM);
319         addr -= (reg << 10);            /* size is in kB */
320         debug("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
321 #endif /* CONFIG_PRAM */
322
323 #if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
324         /* reserve TLB table */
325         addr -= (4096 * 4);
326
327         /* round down to next 64 kB limit */
328         addr &= ~(0x10000 - 1);
329
330         gd->tlb_addr = addr;
331         debug("TLB table at: %08lx\n", addr);
332 #endif
333
334         /* round down to next 4 kB limit */
335         addr &= ~(4096 - 1);
336         debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
337
338 #ifdef CONFIG_LCD
339 #ifdef CONFIG_FB_ADDR
340         gd->fb_base = CONFIG_FB_ADDR;
341 #else
342         /* reserve memory for LCD display (always full pages) */
343         addr = lcd_setmem(addr);
344         gd->fb_base = addr;
345 #endif /* CONFIG_FB_ADDR */
346 #endif /* CONFIG_LCD */
347
348         /*
349          * reserve memory for U-Boot code, data & bss
350          * round down to next 4 kB limit
351          */
352         addr -= gd->mon_len;
353         addr &= ~(4096 - 1);
354
355         debug("Reserving %ldk for U-Boot at: %08lx\n", gd->mon_len >> 10, addr);
356
357 #ifndef CONFIG_SPL_BUILD
358         /*
359          * reserve memory for malloc() arena
360          */
361         addr_sp = addr - TOTAL_MALLOC_LEN;
362         debug("Reserving %dk for malloc() at: %08lx\n",
363                         TOTAL_MALLOC_LEN >> 10, addr_sp);
364         /*
365          * (permanently) allocate a Board Info struct
366          * and a permanent copy of the "global" data
367          */
368         addr_sp -= sizeof (bd_t);
369         bd = (bd_t *) addr_sp;
370         gd->bd = bd;
371         debug("Reserving %zu Bytes for Board Info at: %08lx\n",
372                         sizeof (bd_t), addr_sp);
373
374 #ifdef CONFIG_MACH_TYPE
375         gd->bd->bi_arch_number = CONFIG_MACH_TYPE; /* board id for Linux */
376 #endif
377
378         addr_sp -= sizeof (gd_t);
379         id = (gd_t *) addr_sp;
380         debug("Reserving %zu Bytes for Global Data at: %08lx\n",
381                         sizeof (gd_t), addr_sp);
382
383         /* setup stackpointer for exeptions */
384         gd->irq_sp = addr_sp;
385 #ifdef CONFIG_USE_IRQ
386         addr_sp -= (CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ);
387         debug("Reserving %zu Bytes for IRQ stack at: %08lx\n",
388                 CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ, addr_sp);
389 #endif
390         /* leave 3 words for abort-stack    */
391         addr_sp -= 12;
392
393         /* 8-byte alignment for ABI compliance */
394         addr_sp &= ~0x07;
395 #else
396         addr_sp += 128; /* leave 32 words for abort-stack   */
397         gd->irq_sp = addr_sp;
398 #endif
399
400         debug("New Stack Pointer is: %08lx\n", addr_sp);
401
402 #ifdef CONFIG_POST
403         post_bootmode_init();
404         post_run(NULL, POST_ROM | post_bootmode_get(0));
405 #endif
406
407         gd->bd->bi_baudrate = gd->baudrate;
408         /* Ram ist board specific, so move it to board code ... */
409         dram_init_banksize();
410         display_dram_config();  /* and display it */
411
412         gd->relocaddr = addr;
413         gd->start_addr_sp = addr_sp;
414         gd->reloc_off = addr - _TEXT_BASE;
415         debug("relocation Offset is: %08lx\n", gd->reloc_off);
416         memcpy(id, (void *)gd, sizeof(gd_t));
417
418         relocate_code(addr_sp, id, addr);
419
420         /* NOTREACHED - relocate_code() does not return */
421 }
422
423 #if !defined(CONFIG_SYS_NO_FLASH)
424 static char *failed = "*** failed ***\n";
425 #endif
426
427 /*
428  ************************************************************************
429  *
430  * This is the next part if the initialization sequence: we are now
431  * running from RAM and have a "normal" C environment, i. e. global
432  * data can be written, BSS has been cleared, the stack size in not
433  * that critical any more, etc.
434  *
435  ************************************************************************
436  */
437
438 void board_init_r(gd_t *id, ulong dest_addr)
439 {
440         ulong malloc_start;
441 #if !defined(CONFIG_SYS_NO_FLASH)
442         ulong flash_size;
443 #endif
444
445         gd = id;
446
447         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
448
449         monitor_flash_len = _end_ofs;
450
451         /* Enable caches */
452         enable_caches();
453
454         debug("monitor flash len: %08lX\n", monitor_flash_len);
455         board_init();   /* Setup chipselects */
456
457 #ifdef CONFIG_SERIAL_MULTI
458         serial_initialize();
459 #endif
460
461         debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
462
463 #ifdef CONFIG_LOGBUFFER
464         logbuff_init_ptrs();
465 #endif
466 #ifdef CONFIG_POST
467         post_output_backlog();
468 #endif
469
470         /* The Malloc area is immediately below the monitor copy in DRAM */
471         malloc_start = dest_addr - TOTAL_MALLOC_LEN;
472         mem_malloc_init (malloc_start, TOTAL_MALLOC_LEN);
473
474 #if !defined(CONFIG_SYS_NO_FLASH)
475         puts("Flash: ");
476
477         flash_size = flash_init();
478         if (flash_size > 0) {
479 # ifdef CONFIG_SYS_FLASH_CHECKSUM
480                 print_size(flash_size, "");
481                 /*
482                  * Compute and print flash CRC if flashchecksum is set to 'y'
483                  *
484                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
485                  */
486                 s = getenv("flashchecksum");
487                 if (s && (*s == 'y')) {
488                         printf("  CRC: %08X", crc32(0,
489                                 (const unsigned char *) CONFIG_SYS_FLASH_BASE,
490                                 flash_size));
491                 }
492                 putc('\n');
493 # else  /* !CONFIG_SYS_FLASH_CHECKSUM */
494                 print_size(flash_size, "\n");
495 # endif /* CONFIG_SYS_FLASH_CHECKSUM */
496         } else {
497                 puts(failed);
498                 hang();
499         }
500 #endif
501
502 #if defined(CONFIG_CMD_NAND)
503         puts("NAND:  ");
504         nand_init();            /* go init the NAND */
505 #endif
506
507 #if defined(CONFIG_CMD_ONENAND)
508         onenand_init();
509 #endif
510
511 #ifdef CONFIG_GENERIC_MMC
512        puts("MMC:   ");
513        mmc_initialize(gd->bd);
514 #endif
515
516 #ifdef CONFIG_HAS_DATAFLASH
517         AT91F_DataflashInit();
518         dataflash_print_info();
519 #endif
520
521         /* initialize environment */
522         env_relocate();
523
524 #if defined(CONFIG_CMD_PCI) || defined(CONFIG_PCI)
525         arm_pci_init();
526 #endif
527
528         /* IP Address */
529         gd->bd->bi_ip_addr = getenv_IPaddr("ipaddr");
530
531         stdio_init();   /* get the devices list going. */
532
533         jumptable_init();
534
535 #if defined(CONFIG_API)
536         /* Initialize API */
537         api_init();
538 #endif
539
540         console_init_r();       /* fully init console as a device */
541
542 #if defined(CONFIG_ARCH_MISC_INIT)
543         /* miscellaneous arch dependent initialisations */
544         arch_misc_init();
545 #endif
546 #if defined(CONFIG_MISC_INIT_R)
547         /* miscellaneous platform dependent initialisations */
548         misc_init_r();
549 #endif
550
551          /* set up exceptions */
552         interrupt_init();
553         /* enable exceptions */
554         enable_interrupts();
555
556         /* Perform network card initialisation if necessary */
557 #if defined(CONFIG_DRIVER_SMC91111) || defined (CONFIG_DRIVER_LAN91C96)
558         /* XXX: this needs to be moved to board init */
559         if (getenv("ethaddr")) {
560                 uchar enetaddr[6];
561                 eth_getenv_enetaddr("ethaddr", enetaddr);
562                 smc_set_mac_addr(enetaddr);
563         }
564 #endif /* CONFIG_DRIVER_SMC91111 || CONFIG_DRIVER_LAN91C96 */
565
566         /* Initialize from environment */
567         load_addr = getenv_ulong("loadaddr", 16, load_addr);
568 #if defined(CONFIG_CMD_NET)
569         s = getenv("bootfile");
570         if (s != NULL)
571                 copy_filename(BootFile, s, sizeof(BootFile));
572 #endif
573
574 #ifdef BOARD_LATE_INIT
575         board_late_init();
576 #endif
577
578 #ifdef CONFIG_BITBANGMII
579         bb_miiphy_init();
580 #endif
581 #if defined(CONFIG_CMD_NET)
582         puts("Net:   ");
583         eth_initialize(gd->bd);
584 #if defined(CONFIG_RESET_PHY_R)
585         debug("Reset Ethernet PHY\n");
586         reset_phy();
587 #endif
588 #endif
589
590 #ifdef CONFIG_POST
591         post_run(NULL, POST_RAM | post_bootmode_get(0));
592 #endif
593
594 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
595         /*
596          * Export available size of memory for Linux,
597          * taking into account the protected RAM at top of memory
598          */
599         {
600                 ulong pram = 0;
601                 uchar memsz[32];
602
603 #ifdef CONFIG_PRAM
604                 pram = getenv_ulong("pram", 10, CONFIG_PRAM);
605 #endif
606 #ifdef CONFIG_LOGBUFFER
607 #ifndef CONFIG_ALT_LB_ADDR
608                 /* Also take the logbuffer into account (pram is in kB) */
609                 pram += (LOGBUFF_LEN + LOGBUFF_OVERHEAD) / 1024;
610 #endif
611 #endif
612                 sprintf((char *)memsz, "%ldk", (gd->ram_size / 1024) - pram);
613                 setenv("mem", (char *)memsz);
614         }
615 #endif
616
617         /* main_loop() can return to retry autoboot, if so just run it again. */
618         for (;;) {
619                 main_loop();
620         }
621
622         /* NOTREACHED - no way out of command loop except booting */
623 }
624
625 void hang(void)
626 {
627         puts("### ERROR ### Please RESET the board ###\n");
628         for (;;);
629 }