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 }