From bf9e3b38f77c2eac620263dd60437c6ec47a27bf Mon Sep 17 00:00:00 2001 From: wdenk Date: Thu, 12 Feb 2004 00:47:09 +0000 Subject: * Some code cleanup * Patch by Josef Baumgartner, 10 Feb 2004: Fixes for Coldfire port * Patch by Brad Kemp, 11 Feb 2004: Fix CFI flash driver problems --- lib_m68k/board.c | 594 +++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 402 insertions(+), 192 deletions(-) (limited to 'lib_m68k/board.c') diff --git a/lib_m68k/board.c b/lib_m68k/board.c index 0bf637d..06b3bd5 100644 --- a/lib_m68k/board.c +++ b/lib_m68k/board.c @@ -1,5 +1,8 @@ /* - * (C) Copyright 2000-2003 + * (C) Copyright 2003 + * Josef Baumgartner + * + * (C) Copyright 2000-2002 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * See file CREDITS for list of people who contributed to this @@ -26,7 +29,11 @@ #include #include #include -#include + +#ifdef CONFIG_M5272 +#include +#endif + #if (CONFIG_COMMANDS & CFG_CMD_IDE) #include #endif @@ -54,18 +61,8 @@ static char *failed = "*** failed ***\n"; extern flash_info_t flash_info[]; #endif -#if defined(CFG_ENV_IS_IN_FLASH) -# ifndef CFG_ENV_ADDR -# define CFG_ENV_ADDR (CFG_FLASH_BASE + CFG_ENV_OFFSET) -# endif -# ifndef CFG_ENV_SIZE -# define CFG_ENV_SIZE CFG_ENV_SECT_SIZE -# endif -# if (CFG_ENV_ADDR >= CFG_MONITOR_BASE) && \ - (CFG_ENV_ADDR+CFG_ENV_SIZE) < (CFG_MONITOR_BASE + CFG_MONITOR_LEN) -# define ENV_IS_EMBEDDED -# endif -#endif /* CFG_ENV_IS_IN_FLASH */ +#include + #if ( ((CFG_ENV_ADDR+CFG_ENV_SIZE) < CFG_MONITOR_BASE) || \ (CFG_ENV_ADDR >= (CFG_MONITOR_BASE + CFG_MONITOR_LEN)) ) || \ defined(CFG_ENV_IS_IN_NVRAM) @@ -74,12 +71,30 @@ extern flash_info_t flash_info[]; #define TOTAL_MALLOC_LEN CFG_MALLOC_LEN #endif +extern ulong __init_end; +extern ulong _end; + +extern void timer_init(void); + +#if defined(CONFIG_WATCHDOG) +# define INIT_FUNC_WATCHDOG_INIT watchdog_init, +# define WATCHDOG_DISABLE watchdog_disable + +extern int watchdog_init(void); +extern int watchdog_disable(void); +#else +# define INIT_FUNC_WATCHDOG_INIT /* undef */ +# define WATCHDOG_DISABLE /* undef */ +#endif /* CONFIG_WATCHDOG */ + +ulong monitor_flash_len; + /* * Begin and End of memory area for malloc(), and current "brk" */ -static ulong mem_malloc_start = 0; -static ulong mem_malloc_end = 0; -static ulong mem_malloc_brk = 0; +static ulong mem_malloc_start = 0; +static ulong mem_malloc_end = 0; +static ulong mem_malloc_brk = 0; /************************************************************************ * Utilities * @@ -89,13 +104,18 @@ static ulong mem_malloc_brk = 0; /* * The Malloc area is immediately below the monitor copy in DRAM */ -static void mem_malloc_init (ulong dest_addr) +static void mem_malloc_init (void) { + DECLARE_GLOBAL_DATA_PTR; + + ulong dest_addr = CFG_MONITOR_BASE + gd->reloc_off; + mem_malloc_end = dest_addr; mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN; mem_malloc_brk = mem_malloc_start; - memset ((void *) mem_malloc_start, 0, + memset ((void *) mem_malloc_start, + 0, mem_malloc_end - mem_malloc_start); } @@ -104,50 +124,106 @@ void *sbrk (ptrdiff_t increment) ulong old = mem_malloc_brk; ulong new = old + increment; - if ((new < mem_malloc_start) || (new > mem_malloc_end)) { + if ((new < mem_malloc_start) || + (new > mem_malloc_end) ) { return (NULL); } mem_malloc_brk = new; - return ((void *) old); + return ((void *)old); } -char *strmhz (char *buf, long hz) +char *strmhz(char *buf, long hz) { - long l, n; - long m; + long l, n; + long m; - n = hz / 1000000L; + n = hz / 1000000L; - l = sprintf (buf, "%ld", n); + l = sprintf (buf, "%ld", n); - m = (hz % 1000000L) / 1000L; + m = (hz % 1000000L) / 1000L; - if (m != 0) - sprintf (buf + l, ".%03ld", m); + if (m != 0) + sprintf (buf+l, ".%03ld", m); - return (buf); + return (buf); } -static void syscalls_init (int reloc_off) +/* + * All attempts to come up with a "common" initialization sequence + * that works for all boards and architectures failed: some of the + * requirements are just _too_ different. To get rid of the resulting + * mess of board dependend #ifdef'ed code we now make the whole + * initialization sequence configurable to the user. + * + * The requirements for any new initalization function is simple: it + * receives a pointer to the "global data" structure as it's only + * argument, and returns an integer return code, where 0 means + * "continue" and != 0 means "fatal error, hang the system". + */ +typedef int (init_fnc_t) (void); + +/************************************************************************ + * Init Utilities * + ************************************************************************ + * Some of this code should be moved into the core functions, + * but let's get it working (again) first... + */ + +static int init_baudrate (void) { - ulong *addr; + DECLARE_GLOBAL_DATA_PTR; + + uchar tmp[64]; /* long enough for environment variables */ + int i = getenv_r ("baudrate", tmp, sizeof (tmp)); + + gd->baudrate = (i > 0) + ? (int) simple_strtoul (tmp, NULL, 10) + : CONFIG_BAUDRATE; + return (0); +} - addr = (ulong *) syscall_tbl; - syscall_tbl[SYSCALL_MALLOC] = (void *) malloc; - syscall_tbl[SYSCALL_FREE] = (void *) free; +/***********************************************************************/ - syscall_tbl[SYSCALL_INSTALL_HDLR] = (void *) irq_install_handler; - syscall_tbl[SYSCALL_FREE_HDLR] = (void *) irq_free_handler; +static int init_func_ram (void) +{ + DECLARE_GLOBAL_DATA_PTR; - addr = (ulong *) 0xc00; /* syscall ISR addr */ + int board_type = 0; /* use dummy arg */ + puts ("DRAM: "); - /* patch ISR code */ - *addr++ |= (ulong) syscall_tbl >> 16; - *addr++ |= (ulong) syscall_tbl & 0xFFFF; - *addr++ |= NR_SYSCALLS >> 16; - *addr++ |= NR_SYSCALLS & 0xFFFF; + if ((gd->ram_size = initdram (board_type)) > 0) { + print_size (gd->ram_size, "\n"); + return (0); + } + puts (failed); + return (1); } +/***********************************************************************/ + +/************************************************************************ + * Initialization sequence * + ************************************************************************ + */ + +init_fnc_t *init_sequence[] = { + env_init, + init_baudrate, + serial_init, + console_init_f, + display_options, + checkcpu, + checkboard, + init_func_ram, +#if defined(CFG_DRAM_TEST) + testdram, +#endif /* CFG_DRAM_TEST */ + INIT_FUNC_WATCHDOG_INIT + NULL, /* Terminate this list */ +}; + + /************************************************************************ * * This is the first part of the initialization sequence that is @@ -164,132 +240,146 @@ static void syscalls_init (int reloc_off) ************************************************************************ */ - -gd_t *global_data; -static gd_t gdata; -static bd_t bdata; - -void board_init_f (ulong bootflag) +void +board_init_f (ulong bootflag) { - DECLARE_GLOBAL_DATA_PTR; + DECLARE_GLOBAL_DATA_PTR; bd_t *bd; - ulong reg, len, addr, addr_sp, dram_size; - int i, baudrate, board_type; - char *s, *e; + ulong len, addr, addr_sp; + gd_t *id; + init_fnc_t **init_fnc_ptr; +#ifdef CONFIG_PRAM + int i; + ulong reg; uchar tmp[64]; /* long enough for environment variables */ +#endif - /* Pointer to initial global data area */ - gd = global_data = &gdata; - bd = gd->bd = &bdata; - - init_timebase (); - env_init (); - - i = getenv_r ("baudrate", tmp, sizeof (tmp)); - baudrate = - (i > 0) ? (int) simple_strtoul (tmp, NULL, - 10) : CONFIG_BAUDRATE; - bd->bi_baudrate = baudrate; /* Console Baudrate */ - - /* set up serial port */ - serial_init (); - - /* Initialize the console (before the relocation) */ - console_init_f (); - -#ifdef DEBUG - if (sizeof (init_data_t) > CFG_INIT_DATA_SIZE) { - printf ("PANIC: sizeof(init_data_t)=%d > CFG_INIT_DATA_SIZE=%d\n", sizeof (init_data_t), CFG_INIT_DATA_SIZE); - hang (); - } -#endif /* DEBUG */ - - /* now we can use standard printf/puts/getc/tstc functions */ - display_options (); - - puts ("CPU: "); /* Check CPU */ - if (checkcpu () < 0) { - puts (failed); - hang (); - } - - puts ("Board: "); /* Check Board */ - if ((board_type = checkboard ()) < 0) { - puts (failed); - hang (); - } + /* Pointer is writable since we allocated a register for it */ + gd = (gd_t *) (CFG_INIT_RAM_ADDR + CFG_GBL_DATA_OFFSET); - puts ("DRAM: "); - if ((dram_size = initdram (board_type)) > 0) { - printf ("%2ld MB\n", dram_size >> 20); - } else { - puts (failed); - hang (); - } + /* Clear initial global data */ + memset ((void *) gd, 0, sizeof (gd_t)); -#if defined(CFG_DRAM_TEST) - if (testdram () != 0) { - hang (); + for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) { + if ((*init_fnc_ptr)() != 0) { + hang (); + } } -#endif /* CFG_DRAM_TEST */ /* * Now that we have DRAM mapped and working, we can * relocate the code and continue running from DRAM. * * Reserve memory at end of RAM for (top down in that order): - * - protected RAM - * - LCD framebuffer - * - monitor code - * - board info struct + * - protected RAM + * - LCD framebuffer + * - monitor code + * - board info struct */ - len = get_endaddr () - CFG_MONITOR_BASE; + len = (ulong)&_end - CFG_MONITOR_BASE; - if (len > CFG_MONITOR_LEN) { - printf ("*** u-boot size %ld > reserved memory (%d)\n", - len, CFG_MONITOR_LEN); - hang (); - } + addr = CFG_SDRAM_BASE + gd->ram_size; - if (CFG_MONITOR_LEN > len) - len = CFG_MONITOR_LEN; +#ifdef CONFIG_LOGBUFFER + /* reserve kernel log buffer */ + addr -= (LOGBUFF_RESERVE); + debug ("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN, addr); +#endif + +#ifdef CONFIG_PRAM + /* + * reserve protected RAM + */ + i = getenv_r ("pram", tmp, sizeof (tmp)); + reg = (i > 0) ? simple_strtoul (tmp, NULL, 10) : CONFIG_PRAM; + addr -= (reg << 10); /* size is in kB */ + debug ("Reserving %ldk for protected RAM at %08lx\n", reg, addr); +#endif /* CONFIG_PRAM */ - addr = CFG_SDRAM_BASE + dram_size; + /* + * reserve memory for U-Boot code, data & bss + * round down to next 4 kB limit + */ addr -= len; + addr &= ~(4096 - 1); + + debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr); /* - * Save local variables to board info struct + * reserve memory for malloc() arena */ - bd->bi_memstart = CFG_SDRAM_BASE; /* start of DRAM memory */ - bd->bi_memsize = dram_size; /* size of DRAM memory in bytes */ - bd->bi_bootflags = bootflag; /* boot / reboot flag (for LynxOS) */ + addr_sp = addr - TOTAL_MALLOC_LEN; + debug ("Reserving %dk for malloc() at: %08lx\n", + TOTAL_MALLOC_LEN >> 10, addr_sp); - i = getenv_r ("ethaddr", tmp, sizeof (tmp)); - s = (i > 0) ? tmp : NULL; + /* + * (permanently) allocate a Board Info struct + * and a permanent copy of the "global" data + */ + addr_sp -= sizeof (bd_t); + bd = (bd_t *) addr_sp; + gd->bd = bd; + debug ("Reserving %d Bytes for Board Info at: %08lx\n", + sizeof (bd_t), addr_sp); + addr_sp -= sizeof (gd_t); + id = (gd_t *) addr_sp; + debug ("Reserving %d Bytes for Global Data at: %08lx\n", + sizeof (gd_t), addr_sp); + + /* Reserve memory for boot params. */ + addr_sp -= CFG_BOOTPARAMS_LEN; + bd->bi_boot_params = addr_sp; + debug ("Reserving %dk for boot parameters at: %08lx\n", + CFG_BOOTPARAMS_LEN >> 10, addr_sp); - for (reg = 0; reg < 6; ++reg) { - bd->bi_enetaddr[reg] = s ? simple_strtoul (s, &e, 16) : 0; - if (s) - s = (*e) ? e + 1 : e; - } + /* + * Finally, we set up a new (bigger) stack. + * + * Leave some safety gap for SP, force alignment on 16 byte boundary + * Clear initial stack frame + */ + addr_sp -= 16; + addr_sp &= ~0xF; + *((ulong *) addr_sp)-- = 0; + *((ulong *) addr_sp)-- = 0; + debug ("Stack Pointer at: %08lx\n", addr_sp); - bd->bi_intfreq = get_gclk_freq (); /* Internal Freq, in Hz */ - bd->bi_busfreq = get_bus_freq (get_gclk_freq ()); /* Bus Freq, in Hz */ + /* + * Save local variables to board info struct + */ + bd->bi_memstart = CFG_SDRAM_BASE; /* start of DRAM memory */ + bd->bi_memsize = gd->ram_size; /* size of DRAM memory in bytes */ + bd->bi_mbar_base = CFG_MBAR; /* base of internal registers */ + + bd->bi_bootflags = bootflag; /* boot / reboot flag (for LynxOS) */ + + WATCHDOG_RESET (); + bd->bi_intfreq = gd->cpu_clk; /* Internal Freq, in Hz */ + bd->bi_busfreq = gd->bus_clk; /* Bus Freq, in Hz */ + bd->bi_baudrate = gd->baudrate; /* Console Baudrate */ #ifdef CFG_EXTBDINFO strncpy (bd->bi_s_version, "1.2", sizeof (bd->bi_s_version)); - strncpy (bd->bi_r_version, PPCBOOT_VERSION, - sizeof (bd->bi_r_version)); + strncpy (bd->bi_r_version, U_BOOT_VERSION, sizeof (bd->bi_r_version)); +#endif + + WATCHDOG_RESET (); - bd->bi_procfreq = get_gclk_freq (); /* Processor Speed, In Hz */ - bd->bi_plb_busfreq = bd->bi_busfreq; +#ifdef CONFIG_POST + post_bootmode_init(); + post_run (NULL, POST_ROM | post_bootmode_get(0)); #endif - board_init_final (addr); + WATCHDOG_RESET(); -} + memcpy (id, (void *)gd, sizeof (gd_t)); + + debug ("Start relocate of code from %08x to %08lx\n", CFG_MONITOR_BASE, addr); + relocate_code (addr_sp, id, addr); + /* NOTREACHED - jump_to_ram() does not return */ +} /************************************************************************ * @@ -300,61 +390,123 @@ void board_init_f (ulong bootflag) * ************************************************************************ */ - -void board_init_final (ulong dest_addr) +void board_init_r (gd_t *id, ulong dest_addr) { DECLARE_GLOBAL_DATA_PTR; - char *s; cmd_tbl_t *cmdtp; - ulong flash_size; + char *s, *e; bd_t *bd; + int i; + extern void malloc_bin_reloc (void); +#ifndef CFG_ENV_IS_NOWHERE + extern char * env_name_spec; +#endif +#ifndef CFG_NO_FLASH + ulong flash_size; +#endif + gd = id; /* initialize RAM version of global data */ bd = gd->bd; - /* icache_enable(); /XX* it's time to enable the instruction cache */ + + gd->flags |= GD_FLG_RELOC; /* tell others: relocation done */ + + debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr); + + WATCHDOG_RESET (); + + gd->reloc_off = dest_addr - CFG_MONITOR_BASE; + + monitor_flash_len = (ulong)&__init_end - dest_addr; + + /* + * We have to relocate the command table manually + */ + for (cmdtp = &__u_boot_cmd_start; cmdtp != &__u_boot_cmd_end; cmdtp++) { + ulong addr; + addr = (ulong) (cmdtp->cmd) + gd->reloc_off; +#if 0 + printf ("Command \"%s\": 0x%08lx => 0x%08lx\n", + cmdtp->name, (ulong) (cmdtp->cmd), addr); +#endif + cmdtp->cmd = + (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr; + + addr = (ulong)(cmdtp->name) + gd->reloc_off; + cmdtp->name = (char *)addr; + + if (cmdtp->usage) { + addr = (ulong)(cmdtp->usage) + gd->reloc_off; + cmdtp->usage = (char *)addr; + } +#ifdef CFG_LONGHELP + if (cmdtp->help) { + addr = (ulong)(cmdtp->help) + gd->reloc_off; + cmdtp->help = (char *)addr; + } +#endif + } + /* there are some other pointer constants we must deal with */ +#ifndef CFG_ENV_IS_NOWHERE + env_name_spec += gd->reloc_off; +#endif + + WATCHDOG_RESET (); + +#ifdef CONFIG_LOGBUFFER + logbuff_init_ptrs (); +#endif +#ifdef CONFIG_POST + post_output_backlog (); + post_reloc (); +#endif + WATCHDOG_RESET(); + +#if 0 + /* instruction cache enabled in cpu_init_f() for faster relocation */ + icache_enable (); /* it's time to enable the instruction cache */ +#endif /* * Setup trap handlers */ - trap_init (dest_addr); + trap_init (0); +#if !defined(CFG_NO_FLASH) puts ("FLASH: "); if ((flash_size = flash_init ()) > 0) { -#ifdef CFG_FLASH_CHECKSUM - if (flash_size >= (1 << 20)) { - printf ("%2ld MB", flash_size >> 20); - } else { - printf ("%2ld kB", flash_size >> 10); - } +# ifdef CFG_FLASH_CHECKSUM + print_size (flash_size, ""); /* * Compute and print flash CRC if flashchecksum is set to 'y' * - * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX + * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX */ s = getenv ("flashchecksum"); if (s && (*s == 'y')) { printf (" CRC: %08lX", - crc32 (0, - (const unsigned char *) CFG_FLASH_BASE, - flash_size) - ); + crc32 (0, + (const unsigned char *) CFG_FLASH_BASE, + flash_size) + ); } putc ('\n'); -#else - if (flash_size >= (1 << 20)) { - printf ("%2ld MB\n", flash_size >> 20); - } else { - printf ("%2ld kB\n", flash_size >> 10); - } -#endif /* CFG_FLASH_CHECKSUM */ +# else /* !CFG_FLASH_CHECKSUM */ + print_size (flash_size, "\n"); +# endif /* CFG_FLASH_CHECKSUM */ } else { puts (failed); hang (); } - bd->bi_flashstart = CFG_FLASH_BASE; /* update start of FLASH memory */ - bd->bi_flashsize = flash_size; /* size of FLASH memory (final value) */ - bd->bi_flashoffset = 0x10000; /* reserved area for startup monitor */ + bd->bi_flashstart = CFG_FLASH_BASE; /* update start of FLASH memory */ + bd->bi_flashsize = flash_size; /* size of FLASH memory (final value) */ + bd->bi_flashoffset = 0; +#else /* CFG_NO_FLASH */ + bd->bi_flashsize = 0; + bd->bi_flashstart = 0; + bd->bi_flashoffset = 0; +#endif /* !CFG_NO_FLASH */ WATCHDOG_RESET (); @@ -364,7 +516,8 @@ void board_init_final (ulong dest_addr) WATCHDOG_RESET (); /* initialize malloc() area */ - mem_malloc_init (dest_addr); + mem_malloc_init (); + malloc_bin_reloc (); #ifdef CONFIG_SPI # if !defined(CFG_ENV_IS_IN_EEPROM) @@ -376,36 +529,35 @@ void board_init_final (ulong dest_addr) /* relocate environment function pointers etc. */ env_relocate (); + /* + * Fill in missing fields of bd_info. + * We do this here, where we have "normal" access to the + * environment; we used to do this still running from ROM, + * where had to use getenv_r(), which can be pretty slow when + * the environment is in EEPROM. + */ + s = getenv ("ethaddr"); + for (i = 0; i < 6; ++i) { + bd->bi_enetaddr[i] = s ? simple_strtoul (s, &e, 16) : 0; + if (s) + s = (*e) ? e + 1 : e; + } + /* IP Address */ bd->bi_ip_addr = getenv_IPaddr ("ipaddr"); WATCHDOG_RESET (); - /* allocate syscalls table (console_init_r will fill it in */ - syscall_tbl = (void **) malloc (NR_SYSCALLS * sizeof (void *)); - - /* Initialize the console (after the relocation and devices init) */ + /** leave this here (after malloc(), environment and PCI are working) **/ + /* Initialize devices */ + devices_init (); -#if (CONFIG_COMMANDS & CFG_CMD_NET) && ( \ - defined(CONFIG_CCM) || \ - defined(CONFIG_EP8260) || \ - defined(CONFIG_IP860) || \ - defined(CONFIG_IVML24) || \ - defined(CONFIG_IVMS8) || \ - defined(CONFIG_LWMON) || \ - defined(CONFIG_MPC8260ADS) || \ - defined(CONFIG_PCU_E) || \ - defined(CONFIG_RPXSUPER) || \ - defined(CONFIG_SPD823TS) ) - - WATCHDOG_RESET (); -# ifdef DEBUG - puts ("Reset Ethernet PHY\n"); -# endif - reset_phy (); -#endif + /* Initialize the jump table for applications */ + jumptable_init (); + /* Initialize the console (after the relocation and devices init) */ + console_init_r (); #if (CONFIG_COMMANDS & CFG_CMD_KGDB) WATCHDOG_RESET (); @@ -413,11 +565,28 @@ void board_init_final (ulong dest_addr) kgdb_init (); #endif + debug ("U-Boot relocated to %08lx\n", dest_addr); + /* * Enable Interrupts */ interrupt_init (); + + /* Must happen after interrupts are initialized since + * an irq handler gets installed + */ + timer_init(); + +#ifdef CONFIG_SERIAL_SOFTWARE_FIFO + serial_buffered_init(); +#endif + +#ifdef CONFIG_STATUS_LED + status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING); +#endif + udelay (20); + set_timer (0); /* Insert function pointers now that we have relocated the code */ @@ -434,10 +603,25 @@ void board_init_final (ulong dest_addr) WATCHDOG_RESET (); -#if (CONFIG_COMMANDS & CFG_CMD_NET) && defined(CONFIG_NET_MULTI) +#if (CONFIG_COMMANDS & CFG_CMD_DOC) + WATCHDOG_RESET (); + puts ("DOC: "); + doc_init (); +#endif + +#if (CONFIG_COMMANDS & CFG_CMD_NAND) WATCHDOG_RESET (); - puts ("Net: "); - eth_initialize (bd); + puts ("NAND:"); + nand_init(); /* go init the NAND */ +#endif + +#if (CONFIG_COMMANDS & CFG_CMD_NET) && defined(FEC_ENET) + WATCHDOG_RESET(); + eth_init(bd); +#endif + +#ifdef CONFIG_POST + post_run (NULL, POST_RAM | post_bootmode_get(0)); #endif #ifdef CONFIG_LAST_STAGE_INIT @@ -455,26 +639,51 @@ void board_init_final (ulong dest_addr) bedbug_init (); #endif -#ifdef CONFIG_PRAM +#if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER) /* * Export available size of memory for Linux, * taking into account the protected RAM at top of memory */ { ulong pram; - char *s; uchar memsz[32]; +#ifdef CONFIG_PRAM + char *s; if ((s = getenv ("pram")) != NULL) { pram = simple_strtoul (s, NULL, 10); } else { pram = CONFIG_PRAM; } +#else + pram=0; +#endif +#ifdef CONFIG_LOGBUFFER + /* Also take the logbuffer into account (pram is in kB) */ + pram += (LOGBUFF_LEN+LOGBUFF_OVERHEAD)/1024; +#endif sprintf (memsz, "%ldk", (bd->bi_memsize / 1024) - pram); setenv ("mem", memsz); } #endif +#ifdef CONFIG_MODEM_SUPPORT + { + extern int do_mdm_init; + do_mdm_init = gd->do_mdm_init; + } +#endif + +#ifdef CONFIG_WATCHDOG + /* disable watchdog if environment is set */ + if ((s = getenv ("watchdog")) != NULL) { + if (strncmp (s, "off", 3) == 0) { + WATCHDOG_DISABLE (); + } + } +#endif /* CONFIG_WATCHDOG*/ + + /* Initialization complete - start the monitor */ /* main_loop() can return to retry autoboot, if so just run it again. */ @@ -486,7 +695,8 @@ void board_init_final (ulong dest_addr) /* NOTREACHED - no way out of command loop except booting */ } -void hang (void) + +void hang(void) { puts ("### ERROR ### Please RESET the board ###\n"); for (;;); -- cgit v1.1