arm: socfpga: spl: printout sdram size
[oweals/u-boot.git] / 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  * SPDX-License-Identifier:     GPL-2.0+
10  */
11
12 /*
13  * To match the U-Boot user interface on ARM platforms to the U-Boot
14  * standard (as on PPC platforms), some messages with debug character
15  * are removed from the default U-Boot build.
16  *
17  * Define DEBUG here if you want additional info as shown below
18  * printed upon startup:
19  *
20  * U-Boot code: 00F00000 -> 00F3C774  BSS: -> 00FC3274
21  * IRQ Stack: 00ebff7c
22  * FIQ Stack: 00ebef7c
23  */
24
25 #include <common.h>
26 #include <command.h>
27 #include <environment.h>
28 #include <malloc.h>
29 #include <stdio_dev.h>
30 #include <version.h>
31 #include <net.h>
32 #include <serial.h>
33 #include <nand.h>
34 #include <onenand_uboot.h>
35 #include <mmc.h>
36 #include <scsi.h>
37 #include <status_led.h>
38 #include <libfdt.h>
39 #include <fdtdec.h>
40 #include <post.h>
41 #include <logbuff.h>
42 #include <asm/sections.h>
43
44 #ifdef CONFIG_BITBANGMII
45 #include <miiphy.h>
46 #endif
47
48 DECLARE_GLOBAL_DATA_PTR;
49
50 ulong monitor_flash_len;
51
52 #ifdef CONFIG_HAS_DATAFLASH
53 extern int  AT91F_DataflashInit(void);
54 extern void dataflash_print_info(void);
55 #endif
56
57 #if defined(CONFIG_HARD_I2C) || \
58         defined(CONFIG_SYS_I2C)
59 #include <i2c.h>
60 #endif
61
62 /************************************************************************
63  * Coloured LED functionality
64  ************************************************************************
65  * May be supplied by boards if desired
66  */
67 __weak void coloured_LED_init(void) {}
68 __weak void red_led_on(void) {}
69 __weak void red_led_off(void) {}
70 __weak void green_led_on(void) {}
71 __weak void green_led_off(void) {}
72 __weak void yellow_led_on(void) {}
73 __weak void yellow_led_off(void) {}
74 __weak void blue_led_on(void) {}
75 __weak void blue_led_off(void) {}
76
77 /*
78  ************************************************************************
79  * Init Utilities                                                       *
80  ************************************************************************
81  * Some of this code should be moved into the core functions,
82  * or dropped completely,
83  * but let's get it working (again) first...
84  */
85
86 #if defined(CONFIG_ARM_DCC) && !defined(CONFIG_BAUDRATE)
87 #define CONFIG_BAUDRATE 115200
88 #endif
89
90 static int init_baudrate(void)
91 {
92         gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
93         return 0;
94 }
95
96 static int display_banner(void)
97 {
98         printf("\n\n%s\n\n", version_string);
99         debug("U-Boot code: %08lX -> %08lX  BSS: -> %08lX\n",
100                (ulong)&_start,
101                (ulong)&__bss_start, (ulong)&__bss_end);
102 #ifdef CONFIG_MODEM_SUPPORT
103         debug("Modem Support enabled\n");
104 #endif
105 #ifdef CONFIG_USE_IRQ
106         debug("IRQ Stack: %08lx\n", IRQ_STACK_START);
107         debug("FIQ Stack: %08lx\n", FIQ_STACK_START);
108 #endif
109
110         return (0);
111 }
112
113 /*
114  * WARNING: this code looks "cleaner" than the PowerPC version, but
115  * has the disadvantage that you either get nothing, or everything.
116  * On PowerPC, you might see "DRAM: " before the system hangs - which
117  * gives a simple yet clear indication which part of the
118  * initialization if failing.
119  */
120 static int display_dram_config(void)
121 {
122         int i;
123
124 #ifdef DEBUG
125         puts("RAM Configuration:\n");
126
127         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
128                 printf("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
129                 print_size(gd->bd->bi_dram[i].size, "\n");
130         }
131 #else
132         ulong size = 0;
133
134         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++)
135                 size += gd->bd->bi_dram[i].size;
136
137         puts("DRAM:  ");
138         print_size(size, "\n");
139 #endif
140
141         return (0);
142 }
143
144 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
145 static int init_func_i2c(void)
146 {
147         puts("I2C:   ");
148 #ifdef CONFIG_SYS_I2C
149         i2c_init_all();
150 #else
151         i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
152 #endif
153         puts("ready\n");
154         return (0);
155 }
156 #endif
157
158 #if defined(CONFIG_CMD_PCI) || defined (CONFIG_PCI)
159 #include <pci.h>
160 static int arm_pci_init(void)
161 {
162         pci_init();
163         return 0;
164 }
165 #endif /* CONFIG_CMD_PCI || CONFIG_PCI */
166
167 /*
168  * Breathe some life into the board...
169  *
170  * Initialize a serial port as console, and carry out some hardware
171  * tests.
172  *
173  * The first part of initialization is running from Flash memory;
174  * its main purpose is to initialize the RAM so that we
175  * can relocate the monitor code to RAM.
176  */
177
178 /*
179  * All attempts to come up with a "common" initialization sequence
180  * that works for all boards and architectures failed: some of the
181  * requirements are just _too_ different. To get rid of the resulting
182  * mess of board dependent #ifdef'ed code we now make the whole
183  * initialization sequence configurable to the user.
184  *
185  * The requirements for any new initalization function is simple: it
186  * receives a pointer to the "global data" structure as it's only
187  * argument, and returns an integer return code, where 0 means
188  * "continue" and != 0 means "fatal error, hang the system".
189  */
190 typedef int (init_fnc_t) (void);
191
192 __weak void dram_init_banksize(void)
193 {
194         gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
195         gd->bd->bi_dram[0].size =  gd->ram_size;
196 }
197
198 __weak int arch_cpu_init(void)
199 {
200         return 0;
201 }
202
203 __weak int power_init_board(void)
204 {
205         return 0;
206 }
207
208         /* Record the board_init_f() bootstage (after arch_cpu_init()) */
209 static int mark_bootstage(void)
210 {
211         bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_F, "board_init_f");
212
213         return 0;
214 }
215
216 init_fnc_t *init_sequence[] = {
217         arch_cpu_init,          /* basic arch cpu dependent setup */
218         mark_bootstage,
219 #ifdef CONFIG_OF_CONTROL
220         fdtdec_check_fdt,
221 #endif
222 #if defined(CONFIG_BOARD_EARLY_INIT_F)
223         board_early_init_f,
224 #endif
225         timer_init,             /* initialize timer */
226 #ifdef CONFIG_BOARD_POSTCLK_INIT
227         board_postclk_init,
228 #endif
229 #ifdef CONFIG_FSL_ESDHC
230         get_clocks,
231 #endif
232         env_init,               /* initialize environment */
233         init_baudrate,          /* initialze baudrate settings */
234         serial_init,            /* serial communications setup */
235         console_init_f,         /* stage 1 init of console */
236         display_banner,         /* say that we are here */
237         print_cpuinfo,          /* display cpu info (and speed) */
238 #if defined(CONFIG_DISPLAY_BOARDINFO)
239         checkboard,             /* display board info */
240 #endif
241 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
242         init_func_i2c,
243 #endif
244         dram_init,              /* configure available RAM banks */
245         NULL,
246 };
247
248 void board_init_f(ulong bootflag)
249 {
250         bd_t *bd;
251         init_fnc_t **init_fnc_ptr;
252         gd_t *id;
253         ulong addr, addr_sp;
254 #ifdef CONFIG_PRAM
255         ulong reg;
256 #endif
257         void *new_fdt = NULL;
258         size_t fdt_size = 0;
259
260         memset((void *)gd, 0, sizeof(gd_t));
261
262         gd->mon_len = (ulong)&__bss_end - (ulong)_start;
263 #ifdef CONFIG_OF_EMBED
264         /* Get a pointer to the FDT */
265         gd->fdt_blob = __dtb_dt_begin;
266 #elif defined CONFIG_OF_SEPARATE
267         /* FDT is at end of image */
268         gd->fdt_blob = &_end;
269 #endif
270         /* Allow the early environment to override the fdt address */
271         gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16,
272                                                 (uintptr_t)gd->fdt_blob);
273
274         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
275                 if ((*init_fnc_ptr)() != 0) {
276                         hang ();
277                 }
278         }
279
280 #ifdef CONFIG_OF_CONTROL
281         /* For now, put this check after the console is ready */
282         if (fdtdec_prepare_fdt()) {
283                 panic("** CONFIG_OF_CONTROL defined but no FDT - please see "
284                         "doc/README.fdt-control");
285         }
286 #endif
287
288         debug("monitor len: %08lX\n", gd->mon_len);
289         /*
290          * Ram is setup, size stored in gd !!
291          */
292         debug("ramsize: %08lX\n", gd->ram_size);
293 #if defined(CONFIG_SYS_MEM_TOP_HIDE)
294         /*
295          * Subtract specified amount of memory to hide so that it won't
296          * get "touched" at all by U-Boot. By fixing up gd->ram_size
297          * the Linux kernel should now get passed the now "corrected"
298          * memory size and won't touch it either. This should work
299          * for arch/ppc and arch/powerpc. Only Linux board ports in
300          * arch/powerpc with bootwrapper support, that recalculate the
301          * memory size from the SDRAM controller setup will have to
302          * get fixed.
303          */
304         gd->ram_size -= CONFIG_SYS_MEM_TOP_HIDE;
305 #endif
306
307         addr = CONFIG_SYS_SDRAM_BASE + get_effective_memsize();
308
309 #ifdef CONFIG_LOGBUFFER
310 #ifndef CONFIG_ALT_LB_ADDR
311         /* reserve kernel log buffer */
312         addr -= (LOGBUFF_RESERVE);
313         debug("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN,
314                 addr);
315 #endif
316 #endif
317
318 #ifdef CONFIG_PRAM
319         /*
320          * reserve protected RAM
321          */
322         reg = getenv_ulong("pram", 10, CONFIG_PRAM);
323         addr -= (reg << 10);            /* size is in kB */
324         debug("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
325 #endif /* CONFIG_PRAM */
326
327 #if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
328         /* reserve TLB table */
329         gd->arch.tlb_size = PGTABLE_SIZE;
330         addr -= gd->arch.tlb_size;
331
332         /* round down to next 64 kB limit */
333         addr &= ~(0x10000 - 1);
334
335         gd->arch.tlb_addr = addr;
336         debug("TLB table from %08lx to %08lx\n", addr, addr + gd->arch.tlb_size);
337 #endif
338
339         /* round down to next 4 kB limit */
340         addr &= ~(4096 - 1);
341         debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
342
343 #ifdef CONFIG_LCD
344 #ifdef CONFIG_FB_ADDR
345         gd->fb_base = CONFIG_FB_ADDR;
346 #else
347         /* reserve memory for LCD display (always full pages) */
348         addr = lcd_setmem(addr);
349         gd->fb_base = addr;
350 #endif /* CONFIG_FB_ADDR */
351 #endif /* CONFIG_LCD */
352
353         /*
354          * reserve memory for U-Boot code, data & bss
355          * round down to next 4 kB limit
356          */
357         addr -= gd->mon_len;
358         addr &= ~(4096 - 1);
359
360         debug("Reserving %ldk for U-Boot at: %08lx\n", gd->mon_len >> 10, addr);
361
362 #ifndef CONFIG_SPL_BUILD
363         /*
364          * reserve memory for malloc() arena
365          */
366         addr_sp = addr - TOTAL_MALLOC_LEN;
367         debug("Reserving %dk for malloc() at: %08lx\n",
368                         TOTAL_MALLOC_LEN >> 10, addr_sp);
369         /*
370          * (permanently) allocate a Board Info struct
371          * and a permanent copy of the "global" data
372          */
373         addr_sp -= sizeof (bd_t);
374         bd = (bd_t *) addr_sp;
375         gd->bd = bd;
376         debug("Reserving %zu Bytes for Board Info at: %08lx\n",
377                         sizeof (bd_t), addr_sp);
378
379 #ifdef CONFIG_MACH_TYPE
380         gd->bd->bi_arch_number = CONFIG_MACH_TYPE; /* board id for Linux */
381 #endif
382
383         addr_sp -= sizeof (gd_t);
384         id = (gd_t *) addr_sp;
385         debug("Reserving %zu Bytes for Global Data at: %08lx\n",
386                         sizeof (gd_t), addr_sp);
387
388 #if defined(CONFIG_OF_SEPARATE) && defined(CONFIG_OF_CONTROL)
389         /*
390          * If the device tree is sitting immediate above our image then we
391          * must relocate it. If it is embedded in the data section, then it
392          * will be relocated with other data.
393          */
394         if (gd->fdt_blob) {
395                 fdt_size = ALIGN(fdt_totalsize(gd->fdt_blob) + 0x1000, 32);
396
397                 addr_sp -= fdt_size;
398                 new_fdt = (void *)addr_sp;
399                 debug("Reserving %zu Bytes for FDT at: %08lx\n",
400                       fdt_size, addr_sp);
401         }
402 #endif
403
404 #ifndef CONFIG_ARM64
405         /* setup stackpointer for exeptions */
406         gd->irq_sp = addr_sp;
407 #ifdef CONFIG_USE_IRQ
408         addr_sp -= (CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ);
409         debug("Reserving %zu Bytes for IRQ stack at: %08lx\n",
410                 CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ, addr_sp);
411 #endif
412         /* leave 3 words for abort-stack    */
413         addr_sp -= 12;
414
415         /* 8-byte alignment for ABI compliance */
416         addr_sp &= ~0x07;
417 #else   /* CONFIG_ARM64 */
418         /* 16-byte alignment for ABI compliance */
419         addr_sp &= ~0x0f;
420 #endif  /* CONFIG_ARM64 */
421 #else
422         addr_sp += 128; /* leave 32 words for abort-stack   */
423         gd->irq_sp = addr_sp;
424 #endif
425
426         debug("New Stack Pointer is: %08lx\n", addr_sp);
427
428 #ifdef CONFIG_POST
429         post_bootmode_init();
430         post_run(NULL, POST_ROM | post_bootmode_get(0));
431 #endif
432
433         /* Ram ist board specific, so move it to board code ... */
434         dram_init_banksize();
435         display_dram_config();  /* and display it */
436
437         gd->relocaddr = addr;
438         gd->start_addr_sp = addr_sp;
439         gd->reloc_off = addr - (ulong)&_start;
440         debug("relocation Offset is: %08lx\n", gd->reloc_off);
441         if (new_fdt) {
442                 memcpy(new_fdt, gd->fdt_blob, fdt_size);
443                 gd->fdt_blob = new_fdt;
444         }
445         memcpy(id, (void *)gd, sizeof(gd_t));
446 }
447
448 #if !defined(CONFIG_SYS_NO_FLASH)
449 static char *failed = "*** failed ***\n";
450 #endif
451
452 /*
453  * Tell if it's OK to load the environment early in boot.
454  *
455  * If CONFIG_OF_CONFIG is defined, we'll check with the FDT to see
456  * if this is OK (defaulting to saying it's not OK).
457  *
458  * NOTE: Loading the environment early can be a bad idea if security is
459  *       important, since no verification is done on the environment.
460  *
461  * @return 0 if environment should not be loaded, !=0 if it is ok to load
462  */
463 static int should_load_env(void)
464 {
465 #ifdef CONFIG_OF_CONTROL
466         return fdtdec_get_config_int(gd->fdt_blob, "load-environment", 1);
467 #elif defined CONFIG_DELAY_ENVIRONMENT
468         return 0;
469 #else
470         return 1;
471 #endif
472 }
473
474 #if defined(CONFIG_DISPLAY_BOARDINFO_LATE) && defined(CONFIG_OF_CONTROL)
475 static void display_fdt_model(const void *blob)
476 {
477         const char *model;
478
479         model = (char *)fdt_getprop(blob, 0, "model", NULL);
480         printf("Model: %s\n", model ? model : "<unknown>");
481 }
482 #endif
483
484 /************************************************************************
485  *
486  * This is the next part if the initialization sequence: we are now
487  * running from RAM and have a "normal" C environment, i. e. global
488  * data can be written, BSS has been cleared, the stack size in not
489  * that critical any more, etc.
490  *
491  ************************************************************************
492  */
493
494 void board_init_r(gd_t *id, ulong dest_addr)
495 {
496         ulong malloc_start;
497 #if !defined(CONFIG_SYS_NO_FLASH)
498         ulong flash_size;
499 #endif
500
501         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
502         bootstage_mark_name(BOOTSTAGE_ID_START_UBOOT_R, "board_init_r");
503
504         monitor_flash_len = (ulong)&__rel_dyn_end - (ulong)_start;
505
506         /* Enable caches */
507         enable_caches();
508
509         debug("monitor flash len: %08lX\n", monitor_flash_len);
510         board_init();   /* Setup chipselects */
511         /*
512          * TODO: printing of the clock inforamtion of the board is now
513          * implemented as part of bdinfo command. Currently only support for
514          * davinci SOC's is added. Remove this check once all the board
515          * implement this.
516          */
517 #ifdef CONFIG_CLOCKS
518         set_cpu_clk_info(); /* Setup clock information */
519 #endif
520         serial_initialize();
521
522         debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
523
524 #ifdef CONFIG_LOGBUFFER
525         logbuff_init_ptrs();
526 #endif
527 #ifdef CONFIG_POST
528         post_output_backlog();
529 #endif
530
531         /* The Malloc area is immediately below the monitor copy in DRAM */
532         malloc_start = dest_addr - TOTAL_MALLOC_LEN;
533         mem_malloc_init (malloc_start, TOTAL_MALLOC_LEN);
534
535 #ifdef CONFIG_ARCH_EARLY_INIT_R
536         arch_early_init_r();
537 #endif
538         power_init_board();
539
540 #if !defined(CONFIG_SYS_NO_FLASH)
541         puts("Flash: ");
542
543         flash_size = flash_init();
544         if (flash_size > 0) {
545 # ifdef CONFIG_SYS_FLASH_CHECKSUM
546                 print_size(flash_size, "");
547                 /*
548                  * Compute and print flash CRC if flashchecksum is set to 'y'
549                  *
550                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
551                  */
552                 if (getenv_yesno("flashchecksum") == 1) {
553                         printf("  CRC: %08X", crc32(0,
554                                 (const unsigned char *) CONFIG_SYS_FLASH_BASE,
555                                 flash_size));
556                 }
557                 putc('\n');
558 # else  /* !CONFIG_SYS_FLASH_CHECKSUM */
559                 print_size(flash_size, "\n");
560 # endif /* CONFIG_SYS_FLASH_CHECKSUM */
561         } else {
562                 puts(failed);
563                 hang();
564         }
565 #endif
566
567 #if defined(CONFIG_CMD_NAND)
568         puts("NAND:  ");
569         nand_init();            /* go init the NAND */
570 #endif
571
572 #if defined(CONFIG_CMD_ONENAND)
573         onenand_init();
574 #endif
575
576 #ifdef CONFIG_GENERIC_MMC
577         puts("MMC:   ");
578         mmc_initialize(gd->bd);
579 #endif
580
581 #ifdef CONFIG_CMD_SCSI
582         puts("SCSI:  ");
583         scsi_init();
584 #endif
585
586 #ifdef CONFIG_HAS_DATAFLASH
587         AT91F_DataflashInit();
588         dataflash_print_info();
589 #endif
590
591         /* initialize environment */
592         if (should_load_env())
593                 env_relocate();
594         else
595                 set_default_env(NULL);
596
597 #if defined(CONFIG_CMD_PCI) || defined(CONFIG_PCI)
598         arm_pci_init();
599 #endif
600
601         stdio_init();   /* get the devices list going. */
602
603         jumptable_init();
604
605 #if defined(CONFIG_API)
606         /* Initialize API */
607         api_init();
608 #endif
609
610         console_init_r();       /* fully init console as a device */
611
612 #ifdef CONFIG_DISPLAY_BOARDINFO_LATE
613 # ifdef CONFIG_OF_CONTROL
614         /* Put this here so it appears on the LCD, now it is ready */
615         display_fdt_model(gd->fdt_blob);
616 # else
617         checkboard();
618 # endif
619 #endif
620
621 #if defined(CONFIG_ARCH_MISC_INIT)
622         /* miscellaneous arch dependent initialisations */
623         arch_misc_init();
624 #endif
625 #if defined(CONFIG_MISC_INIT_R)
626         /* miscellaneous platform dependent initialisations */
627         misc_init_r();
628 #endif
629
630          /* set up exceptions */
631         interrupt_init();
632         /* enable exceptions */
633         enable_interrupts();
634
635         /* Initialize from environment */
636         load_addr = getenv_ulong("loadaddr", 16, load_addr);
637
638 #ifdef CONFIG_BOARD_LATE_INIT
639         board_late_init();
640 #endif
641
642 #ifdef CONFIG_BITBANGMII
643         bb_miiphy_init();
644 #endif
645 #if defined(CONFIG_CMD_NET)
646         puts("Net:   ");
647         eth_initialize();
648 #if defined(CONFIG_RESET_PHY_R)
649         debug("Reset Ethernet PHY\n");
650         reset_phy();
651 #endif
652 #endif
653
654 #ifdef CONFIG_POST
655         post_run(NULL, POST_RAM | post_bootmode_get(0));
656 #endif
657
658 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
659         /*
660          * Export available size of memory for Linux,
661          * taking into account the protected RAM at top of memory
662          */
663         {
664                 ulong pram = 0;
665                 uchar memsz[32];
666
667 #ifdef CONFIG_PRAM
668                 pram = getenv_ulong("pram", 10, CONFIG_PRAM);
669 #endif
670 #ifdef CONFIG_LOGBUFFER
671 #ifndef CONFIG_ALT_LB_ADDR
672                 /* Also take the logbuffer into account (pram is in kB) */
673                 pram += (LOGBUFF_LEN + LOGBUFF_OVERHEAD) / 1024;
674 #endif
675 #endif
676                 sprintf((char *)memsz, "%ldk", (gd->ram_size / 1024) - pram);
677                 setenv("mem", (char *)memsz);
678         }
679 #endif
680
681         /* main_loop() can return to retry autoboot, if so just run it again. */
682         for (;;) {
683                 main_loop();
684         }
685
686         /* NOTREACHED - no way out of command loop except booting */
687 }