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