#include <serial.h>
#include <asm/u-boot-x86.h>
#include <elf.h>
+#include <asm/processor.h>
#ifdef CONFIG_BITBANGMII
#include <miiphy.h>
#endif
-/*
- * Pointer to initial global data area
- *
- * Here we initialize it.
- */
-#undef XTRN_DECLARE_GLOBAL_DATA_PTR
-#define XTRN_DECLARE_GLOBAL_DATA_PTR /* empty = allocate here */
-DECLARE_GLOBAL_DATA_PTR = (gd_t *) (CONFIG_SYS_INIT_GD_ADDR);
-
/************************************************************************
* Init Utilities *
************************************************************************
static int copy_uboot_to_ram(void);
static int clear_bss(void);
static int do_elf_reloc_fixups(void);
+static int copy_gd_to_ram(void);
init_fnc_t *init_sequence_f[] = {
cpu_init_f,
console_init_f,
dram_init_f,
calculate_relocation_address,
- copy_uboot_to_ram,
- clear_bss,
- do_elf_reloc_fixups,
NULL,
};
NULL,
};
-gd_t *gd;
-
static int calculate_relocation_address(void)
{
ulong text_start = (ulong)&__text_start;
ulong bss_end = (ulong)&__bss_end;
ulong dest_addr;
- ulong rel_offset;
-
- /* Calculate destination RAM Address and relocation offset */
- dest_addr = gd->ram_size;
- dest_addr -= CONFIG_SYS_STACK_SIZE;
- dest_addr -= (bss_end - text_start);
/*
- * Round destination address down to 16-byte boundary to keep
- * IDT and GDT 16-byte aligned
+ * NOTE: All destination address are rounded down to 16-byte
+ * boundary to satisfy various worst-case alignment
+ * requirements
*/
+
+ /* Global Data is at top of available memory */
+ dest_addr = gd->ram_size;
+ dest_addr -= GENERATED_GBL_DATA_SIZE;
dest_addr &= ~15;
+ gd->new_gd_addr = dest_addr;
- rel_offset = dest_addr - text_start;
+ /* GDT is below Global Data */
+ dest_addr -= X86_GDT_SIZE;
+ dest_addr &= ~15;
+ gd->gdt_addr = dest_addr;
+
+ /* Stack is below GDT */
+ gd->start_addr_sp = dest_addr;
- gd->start_addr_sp = gd->ram_size;
+ /* U-Boot is below the stack */
+ dest_addr -= CONFIG_SYS_STACK_SIZE;
+ dest_addr -= (bss_end - text_start);
+ dest_addr &= ~15;
gd->relocaddr = dest_addr;
- gd->reloc_off = rel_offset;
+ gd->reloc_off = (dest_addr - text_start);
return 0;
}
static int copy_uboot_to_ram(void)
{
- ulong *dst_addr = (ulong *)gd->relocaddr;
- ulong *src_addr = (ulong *)&__text_start;
- ulong *end_addr = (ulong *)&__data_end;
+ size_t len = (size_t)&__data_end - (size_t)&__text_start;
- while (src_addr < end_addr)
- *dst_addr++ = *src_addr++;
+ memcpy((void *)gd->relocaddr, (void *)&__text_start, len);
return 0;
}
static int clear_bss(void)
{
- void *bss_start = &__bss_start;
- void *bss_end = &__bss_end;
-
- ulong *dst_addr = (ulong *)(bss_start + gd->reloc_off);
- ulong *end_addr = (ulong *)(bss_end + gd->reloc_off);
+ ulong dst_addr = (ulong)&__bss_start + gd->reloc_off;
+ size_t len = (size_t)&__bss_end - (size_t)&__bss_start;
- while (dst_addr < end_addr)
- *dst_addr++ = 0x00000000;
+ memset((void *)dst_addr, 0x00, len);
return 0;
}
hang();
}
- gd->flags |= GD_FLG_RELOC;
+ /*
+ * SDRAM is now initialised, U-Boot has been copied into SDRAM,
+ * the BSS has been cleared etc. The final stack can now be setup
+ * in SDRAM. Code execution will continue (momentarily) in Flash,
+ * but with the stack in SDRAM and Global Data in temporary memory
+ * (CPU cache)
+ */
+ board_init_f_r_trampoline(gd->start_addr_sp);
+
+ /* NOTREACHED - board_init_f_r_trampoline() does not return */
+ while (1)
+ ;
+}
+
+void board_init_f_r(void)
+{
+ if (copy_gd_to_ram() != 0)
+ hang();
+
+ if (init_cache() != 0)
+ hang();
- /* Enter the relocated U-Boot! */
- relocate_code(gd->start_addr_sp, gd, gd->relocaddr);
+ copy_uboot_to_ram();
+ clear_bss();
+ do_elf_reloc_fixups();
- /* NOTREACHED - relocate_code() does not return */
+ /*
+ * Transfer execution from Flash to RAM by calculating the address
+ * of the in-RAM copy of board_init_r() and calling it
+ */
+ (board_init_r + gd->reloc_off)(gd, gd->relocaddr);
+
+ /* NOTREACHED - board_init_r() does not return */
while (1)
;
}
+static int copy_gd_to_ram(void)
+{
+ gd_t *ram_gd;
+
+ /*
+ * Global data is still in temporary memory (the CPU cache).
+ * calculate_relocation_address() has set gd->new_gd_addr to
+ * where the global data lives in RAM but getting it there
+ * safely is a bit tricky due to the 'F-Segment Hack' that
+ * we need to use for x86
+ */
+ ram_gd = (gd_t *)gd->new_gd_addr;
+ memcpy((void *)ram_gd, gd, sizeof(gd_t));
+
+ /*
+ * Reload the Global Descriptor Table so FS points to the
+ * in-RAM copy of Global Data (calculate_relocation_address()
+ * has already calculated the in-RAM location of the GDT)
+ */
+ ram_gd->gd_addr = (ulong)ram_gd;
+ init_gd(ram_gd, (u64 *)gd->gdt_addr);
+
+ return 0;
+}
+
void board_init_r(gd_t *id, ulong dest_addr)
{
#if defined(CONFIG_CMD_NET)
ulong size;
#endif
static bd_t bd_data;
- static gd_t gd_data;
init_fnc_t **init_fnc_ptr;
show_boot_progress(0x21);
- /* Global data pointer is now writable */
- gd = &gd_data;
- memcpy(gd, id, sizeof(gd_t));
-
/* compiler optimization barrier needed for GCC >= 3.4 */
__asm__ __volatile__("" : : : "memory");
+ gd->flags |= GD_FLG_RELOC;
+
gd->bd = &bd_data;
memset(gd->bd, 0, sizeof(bd_t));
show_boot_progress(0x22);
projects / oweals / u-boot.git / blobdiff