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 "LzmaWrapper.h"
  32
  33 //#define DEBUG_ENABLE_BOOTSTRAP_PRINTF
  34
  35 DECLARE_GLOBAL_DATA_PTR;
  36
  37 #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)
  38 #define TOTAL_MALLOC_LEN        (CFG_MALLOC_LEN + CFG_ENV_SIZE)
  39 #else
  40 #define TOTAL_MALLOC_LEN        CFG_MALLOC_LEN
  41 #endif
  42
  43 #undef DEBUG
  44
  45 extern void bootstrap_relocate_code(ulong addr_sp, gd_t *gd, ulong addr_moni);
  46
  47 extern int timer_init(void);
  48
  49 extern ulong uboot_end_data_bootstrap;
  50 extern ulong uboot_end_bootstrap;
  51
  52 /*
  53  * Begin and End of memory area for malloc(), and current "brk"
  54  */
  55 static ulong mem_malloc_start;
  56 static ulong mem_malloc_end;
  57 static ulong mem_malloc_brk;
  58
  59 /*
  60  * The Malloc area is immediately below the monitor copy in DRAM
  61  */
  62 static void mem_malloc_init(ulong dest_addr){
  63 //      ulong dest_addr = BOOTSTRAP_CFG_MONITOR_BASE + gd->reloc_off;
  64
  65         mem_malloc_end = dest_addr;
  66         mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN;
  67         mem_malloc_brk = mem_malloc_start;
  68
  69         memset((void *)mem_malloc_start, 0, mem_malloc_end - mem_malloc_start);
  70 }
  71
  72 void *malloc(unsigned int size){
  73         if(size < (mem_malloc_end - mem_malloc_start)){
  74                 mem_malloc_start += size;
  75
  76                 return((void *)(mem_malloc_start - size));
  77         }
  78
  79         return(NULL);
  80 }
  81
  82 void *realloc(void *src, unsigned int size){
  83         return(NULL);
  84 }
  85
  86 void free(void *src){
  87         return;
  88 }
  89
  90 static int init_func_ram(void){
  91         if((gd->ram_size = initdram()) > 0){
  92                 return(0);
  93         }
  94         return(1);
  95 }
  96
  97 /*
  98  * Breath some life into the board...
  99  *
 100  * The first part of initialization is running from Flash memory;
 101  * its main purpose is to initialize the RAM so that we
 102  * can relocate the monitor code to RAM.
 103  */
 104
 105 /*
 106  * All attempts to come up with a "common" initialization sequence
 107  * that works for all boards and architectures failed: some of the
 108  * requirements are just _too_ different. To get rid of the resulting
 109  * mess of board dependend #ifdef'ed code we now make the whole
 110  * initialization sequence configurable to the user.
 111  *
 112  * The requirements for any new initalization function is simple: it
 113  * receives a pointer to the "global data" structure as it's only
 114  * argument, and returns an integer return code, where 0 means
 115  * "continue" and != 0 means "fatal error, hang the system".
 116  */
 117 typedef int(init_fnc_t)(void);
 118
 119 init_fnc_t *init_sequence[] = { timer_init,
 120                                 serial_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         bd->bi_baudrate = gd->baudrate;         /* Console Baudrate */
 206
 207         memcpy(id, (void *)gd, sizeof(gd_t));
 208
 209         bootstrap_relocate_code(addr_sp, id, addr);
 210
 211         /* NOTREACHED - relocate_code() does not return */
 212 }
 213
 214 /************************************************************************
 215  *
 216  * This is the next part if the initialization sequence: we are now
 217  * running from RAM and have a "normal" C environment, i. e. global
 218  * data can be written, BSS has been cleared, the stack size in not
 219  * that critical any more, etc.
 220  *
 221  ************************************************************************
 222  */
 223 void bootstrap_board_init_r(gd_t *id, ulong dest_addr){
 224         int i;
 225         ulong addr;
 226         ulong data, len, checksum;
 227         image_header_t header;
 228         image_header_t *hdr = &header;
 229         unsigned int destLen;
 230         int (*fn)(int);
 231
 232         /* initialize malloc() area */
 233         mem_malloc_init(dest_addr);
 234
 235         addr = (ulong)((char *)(BOOTSTRAP_CFG_MONITOR_BASE + ((ulong)&uboot_end_data_bootstrap - dest_addr)));
 236         memmove(&header, (char *)addr, sizeof(image_header_t));
 237
 238         if(ntohl(hdr->ih_magic) != IH_MAGIC){
 239                 return;
 240         }
 241
 242         data = (ulong)&header;
 243         len = sizeof(image_header_t);
 244
 245         checksum = ntohl(hdr->ih_hcrc);
 246         hdr->ih_hcrc = 0;
 247
 248         if(crc32(0, (unsigned char *)data, len) != checksum){
 249                 return;
 250         }
 251
 252         data = addr + sizeof(image_header_t);
 253         len = ntohl(hdr->ih_size);
 254
 255         /*
 256          * If we've got less than 4 MB of malloc() space,
 257          * use slower decompression algorithm which requires
 258          * at most 2300 KB of memory.
 259          */
 260         destLen = 0x0;
 261
 262 #ifdef CONFIG_LZMA
 263         i = lzma_inflate((unsigned char *)data, len, (unsigned char*)ntohl(hdr->ih_load), (int *)&destLen);
 264
 265         if(i != LZMA_RESULT_OK){
 266                 //do_reset(cmdtp, flag, argc, argv);
 267                 return;
 268         }
 269 #endif
 270
 271         fn = (void *)ntohl(hdr->ih_load);
 272
 273         (*fn)(gd->ram_size);
 274
 275         hang();
 276 }
 277
 278 void hang(void){
 279         for(;;);
 280 }