u-boot/lib_bootstrap/bootstrap_board.c

   1 /*
   2  * (C) Copyright 2003
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <common.h>
  25 #include <command.h>
  26 #include <malloc.h>
  27 #include <devices.h>
  28 #include <version.h>
  29 #include <net.h>
  30 #include <environment.h>
  31 #include <tinf.h>
  32 #include "LzmaWrapper.h"
  33
  34 //#define DEBUG_ENABLE_BOOTSTRAP_PRINTF
  35
  36 DECLARE_GLOBAL_DATA_PTR;
  37
  38 #if (((CFG_ENV_ADDR+CFG_ENV_SIZE) < BOOTSTRAP_CFG_MONITOR_BASE) || (CFG_ENV_ADDR >= (BOOTSTRAP_CFG_MONITOR_BASE + CFG_MONITOR_LEN)) ) || defined(CFG_ENV_IS_IN_NVRAM)
  39 #define TOTAL_MALLOC_LEN        (CFG_MALLOC_LEN + CFG_ENV_SIZE)
  40 #else
  41 #define TOTAL_MALLOC_LEN        CFG_MALLOC_LEN
  42 #endif
  43
  44 #undef DEBUG
  45
  46 extern void bootstrap_relocate_code(ulong addr_sp, gd_t *gd, ulong addr_moni);
  47
  48 extern int timer_init(void);
  49
  50 extern ulong uboot_end_data_bootstrap;
  51 extern ulong uboot_end_bootstrap;
  52
  53 /*
  54  * Begin and End of memory area for malloc(), and current "brk"
  55  */
  56 static ulong mem_malloc_start;
  57 static ulong mem_malloc_end;
  58 static ulong mem_malloc_brk;
  59
  60 /*
  61  * The Malloc area is immediately below the monitor copy in DRAM
  62  */
  63 static void mem_malloc_init(ulong dest_addr){
  64 //      ulong dest_addr = BOOTSTRAP_CFG_MONITOR_BASE + gd->reloc_off;
  65
  66         mem_malloc_end = dest_addr;
  67         mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN;
  68         mem_malloc_brk = mem_malloc_start;
  69
  70         memset((void *)mem_malloc_start, 0, mem_malloc_end - mem_malloc_start);
  71 }
  72
  73 void *malloc(unsigned int size){
  74         if(size < (mem_malloc_end - mem_malloc_start)){
  75                 mem_malloc_start += size;
  76
  77                 return((void *)(mem_malloc_start - size));
  78         }
  79
  80         return(NULL);
  81 }
  82
  83 void *realloc(void *src, unsigned int size){
  84         return(NULL);
  85 }
  86
  87 void free(void *src){
  88         return;
  89 }
  90
  91 static int init_func_ram(void){
  92         if((gd->ram_size = initdram()) > 0){
  93                 return(0);
  94         }
  95         return(1);
  96 }
  97
  98 /*
  99  * Breath some life into the board...
 100  *
 101  * The first part of initialization is running from Flash memory;
 102  * its main purpose is to initialize the RAM so that we
 103  * can relocate the monitor code to RAM.
 104  */
 105
 106 /*
 107  * All attempts to come up with a "common" initialization sequence
 108  * that works for all boards and architectures failed: some of the
 109  * requirements are just _too_ different. To get rid of the resulting
 110  * mess of board dependend #ifdef'ed code we now make the whole
 111  * initialization sequence configurable to the user.
 112  *
 113  * The requirements for any new initalization function is simple: it
 114  * receives a pointer to the "global data" structure as it's only
 115  * argument, and returns an integer return code, where 0 means
 116  * "continue" and != 0 means "fatal error, hang the system".
 117  */
 118 typedef int(init_fnc_t)(void);
 119
 120 init_fnc_t *init_sequence[] = { timer_init,
 121                                 init_func_ram,
 122                                 NULL, };
 123
 124 void bootstrap_board_init_f(ulong bootflag){
 125         gd_t gd_data, *id;
 126         bd_t *bd;
 127         init_fnc_t **init_fnc_ptr;
 128         ulong addr, addr_sp, len = (ulong)&uboot_end_bootstrap - BOOTSTRAP_CFG_MONITOR_BASE;
 129         ulong *s;
 130
 131         /* Pointer is writable since we allocated a register for it.
 132          */
 133         gd = &gd_data;
 134
 135         /* compiler optimization barrier needed for GCC >= 3.4 */
 136         __asm__ __volatile__("": : :"memory");
 137
 138         memset((void *)gd, 0, sizeof(gd_t));
 139
 140         for(init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr){
 141                 if((*init_fnc_ptr)() != 0){
 142                         hang();
 143                 }
 144         }
 145
 146         /*
 147          * Now that we have DRAM mapped and working, we can
 148          * relocate the code and continue running from DRAM.
 149          */
 150         addr = CFG_SDRAM_BASE + gd->ram_size;
 151
 152         /*
 153          * We can reserve some RAM "on top" here.
 154          * round down to next 4 kB limit.
 155          */
 156         addr &= ~(4096 - 1);
 157
 158         /*
 159          * Reserve memory for U-Boot code, data & bss
 160          * round down to next 16 kB limit
 161          */
 162         addr -= len;
 163         addr &= ~(16 * 1024 - 1);
 164
 165         /*
 166          * Reserve memory for malloc() arena.
 167          */
 168         addr_sp = addr - TOTAL_MALLOC_LEN;
 169
 170         /*
 171          * (permanently) allocate a Board Info struct
 172          * and a permanent copy of the "global" data
 173          */
 174         addr_sp -= sizeof(bd_t);
 175         bd = (bd_t *)addr_sp;
 176         gd->bd = bd;
 177
 178         addr_sp -= sizeof(gd_t);
 179         id = (gd_t *)addr_sp;
 180
 181         /*
 182          * Reserve memory for boot params.
 183          */
 184         addr_sp -= CFG_BOOTPARAMS_LEN;
 185         bd->bi_boot_params = addr_sp;
 186
 187         /*
 188          * Finally, we set up a new (bigger) stack.
 189          *
 190          * Leave some safety gap for SP, force alignment on 16 byte boundary
 191          * Clear initial stack frame
 192          */
 193         addr_sp -= 16;
 194         addr_sp &= ~0xF;
 195         s = (ulong *)addr_sp;
 196         *s-- = 0;
 197         *s-- = 0;
 198         addr_sp = (ulong)s;
 199
 200         /*
 201          * Save local variables to board info struct
 202          */
 203         bd->bi_memstart = CFG_SDRAM_BASE;       /* start of  DRAM memory */
 204         bd->bi_memsize = gd->ram_size;          /* size  of  DRAM memory in bytes */
 205
 206         memcpy(id, (void *)gd, sizeof(gd_t));
 207
 208         bootstrap_relocate_code(addr_sp, id, addr);
 209
 210         /* NOTREACHED - relocate_code() does not return */
 211 }
 212
 213 /************************************************************************
 214  *
 215  * This is the next part if the initialization sequence: we are now
 216  * running from RAM and have a "normal" C environment, i. e. global
 217  * data can be written, BSS has been cleared, the stack size in not
 218  * that critical any more, etc.
 219  *
 220  ************************************************************************
 221  */
 222 void bootstrap_board_init_r(gd_t *id, ulong dest_addr){
 223         int i;
 224         ulong addr;
 225         ulong data, len, checksum;
 226         image_header_t header;
 227         image_header_t *hdr = &header;
 228         unsigned int destLen;
 229         int (*fn)(int);
 230
 231         /* initialize malloc() area */
 232         mem_malloc_init(dest_addr);
 233
 234         addr = (ulong)((char *)(BOOTSTRAP_CFG_MONITOR_BASE + ((ulong)&uboot_end_data_bootstrap - dest_addr)));
 235         memmove(&header, (char *)addr, sizeof(image_header_t));
 236
 237         if(ntohl(hdr->ih_magic) != IH_MAGIC){
 238                 return;
 239         }
 240
 241         data = (ulong)&header;
 242         len = sizeof(image_header_t);
 243
 244         checksum = ntohl(hdr->ih_hcrc);
 245         hdr->ih_hcrc = 0;
 246
 247         if(tinf_crc32((unsigned char *)data, len) != checksum){
 248                 return;
 249         }
 250
 251         data = addr + sizeof(image_header_t);
 252         len = ntohl(hdr->ih_size);
 253
 254         /*
 255          * If we've got less than 4 MB of malloc() space,
 256          * use slower decompression algorithm which requires
 257          * at most 2300 KB of memory.
 258          */
 259         destLen = 0x0;
 260
 261 #ifdef CONFIG_LZMA
 262         i = lzma_inflate((unsigned char *)data, len, (unsigned char*)ntohl(hdr->ih_load), (int *)&destLen);
 263
 264         if(i != LZMA_RESULT_OK){
 265                 //do_reset(cmdtp, flag, argc, argv);
 266                 return;
 267         }
 268 #endif
 269
 270         fn = (void *)ntohl(hdr->ih_load);
 271
 272         (*fn)(gd->ram_size);
 273
 274         hang();
 275 }
 276
 277 void hang(void){
 278         for(;;);
 279 }