summaryrefslogtreecommitdiff
path: root/lib_m68k/board.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib_m68k/board.c')
-rw-r--r--lib_m68k/board.c594
1 files changed, 402 insertions, 192 deletions
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 <josef.baumgartner@telex.de>
+ *
+ * (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 <command.h>
#include <malloc.h>
#include <devices.h>
-#include <syscall.h>
+
+#ifdef CONFIG_M5272
+#include <asm/immap_5272.h>
+#endif
+
#if (CONFIG_COMMANDS & CFG_CMD_IDE)
#include <ide.h>
#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 <environment.h>
+
#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 (;;);