board.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  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. #include <common.h>
  24. #include <command.h>
  25. #include <malloc.h>
  26. #include <devices.h>
  27. #include <version.h>
  28. #include <net.h>
  29. #include <environment.h>
  30. DECLARE_GLOBAL_DATA_PTR;
  31. #if ( ((CFG_ENV_ADDR+CFG_ENV_SIZE) < CFG_MONITOR_BASE) || \
  32. (CFG_ENV_ADDR >= (CFG_MONITOR_BASE + CFG_MONITOR_LEN)) ) || \
  33. defined(CFG_ENV_IS_IN_NVRAM)
  34. #define TOTAL_MALLOC_LEN (CFG_MALLOC_LEN + CFG_ENV_SIZE)
  35. #else
  36. #define TOTAL_MALLOC_LEN CFG_MALLOC_LEN
  37. #endif
  38. #undef DEBUG
  39. extern int timer_init(void);
  40. extern int incaip_set_cpuclk(void);
  41. extern ulong uboot_end_data;
  42. extern ulong uboot_end;
  43. ulong monitor_flash_len;
  44. const char version_string[] =
  45. U_BOOT_VERSION" (" __DATE__ " - " __TIME__ ")";
  46. static char *failed = "*** failed ***\n";
  47. /*
  48. * Begin and End of memory area for malloc(), and current "brk"
  49. */
  50. static ulong mem_malloc_start;
  51. static ulong mem_malloc_end;
  52. static ulong mem_malloc_brk;
  53. /*
  54. * The Malloc area is immediately below the monitor copy in DRAM
  55. */
  56. static void mem_malloc_init (void)
  57. {
  58. ulong dest_addr = CFG_MONITOR_BASE + gd->reloc_off;
  59. mem_malloc_end = dest_addr;
  60. mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN;
  61. mem_malloc_brk = mem_malloc_start;
  62. memset ((void *) mem_malloc_start,
  63. 0,
  64. mem_malloc_end - mem_malloc_start);
  65. }
  66. void *sbrk (ptrdiff_t increment)
  67. {
  68. ulong old = mem_malloc_brk;
  69. ulong new = old + increment;
  70. if ((new < mem_malloc_start) || (new > mem_malloc_end)) {
  71. return (NULL);
  72. }
  73. mem_malloc_brk = new;
  74. return ((void *) old);
  75. }
  76. static int init_func_ram (void)
  77. {
  78. #ifdef CONFIG_BOARD_TYPES
  79. int board_type = gd->board_type;
  80. #else
  81. int board_type = 0; /* use dummy arg */
  82. #endif
  83. puts ("DRAM: ");
  84. if ((gd->ram_size = initdram (board_type)) > 0) {
  85. print_size (gd->ram_size, "\n");
  86. return (0);
  87. }
  88. puts (failed);
  89. return (1);
  90. }
  91. static int display_banner(void)
  92. {
  93. printf ("\n\n%s\n\n", version_string);
  94. return (0);
  95. }
  96. static void display_flash_config(ulong size)
  97. {
  98. puts ("Flash: ");
  99. print_size (size, "\n");
  100. }
  101. static int init_baudrate (void)
  102. {
  103. char tmp[64]; /* long enough for environment variables */
  104. int i = getenv_r ("baudrate", tmp, sizeof (tmp));
  105. gd->baudrate = (i > 0)
  106. ? (int) simple_strtoul (tmp, NULL, 10)
  107. : CONFIG_BAUDRATE;
  108. return (0);
  109. }
  110. /*
  111. * Breath some life into the board...
  112. *
  113. * The first part of initialization is running from Flash memory;
  114. * its main purpose is to initialize the RAM so that we
  115. * can relocate the monitor code to RAM.
  116. */
  117. /*
  118. * All attempts to come up with a "common" initialization sequence
  119. * that works for all boards and architectures failed: some of the
  120. * requirements are just _too_ different. To get rid of the resulting
  121. * mess of board dependend #ifdef'ed code we now make the whole
  122. * initialization sequence configurable to the user.
  123. *
  124. * The requirements for any new initalization function is simple: it
  125. * receives a pointer to the "global data" structure as it's only
  126. * argument, and returns an integer return code, where 0 means
  127. * "continue" and != 0 means "fatal error, hang the system".
  128. */
  129. typedef int (init_fnc_t) (void);
  130. init_fnc_t *init_sequence[] = {
  131. timer_init,
  132. env_init, /* initialize environment */
  133. #ifdef CONFIG_INCA_IP
  134. incaip_set_cpuclk, /* set cpu clock according to environment variable */
  135. #endif
  136. init_baudrate, /* initialze baudrate settings */
  137. serial_init, /* serial communications setup */
  138. console_init_f,
  139. display_banner, /* say that we are here */
  140. checkboard,
  141. init_func_ram,
  142. NULL,
  143. };
  144. void board_init_f(ulong bootflag)
  145. {
  146. gd_t gd_data, *id;
  147. bd_t *bd;
  148. init_fnc_t **init_fnc_ptr;
  149. ulong addr, addr_sp, len = (ulong)&uboot_end - CFG_MONITOR_BASE;
  150. ulong *s;
  151. #ifdef CONFIG_PURPLE
  152. void copy_code (ulong);
  153. #endif
  154. /* Pointer is writable since we allocated a register for it.
  155. */
  156. gd = &gd_data;
  157. /* compiler optimization barrier needed for GCC >= 3.4 */
  158. __asm__ __volatile__("": : :"memory");
  159. memset ((void *)gd, 0, sizeof (gd_t));
  160. for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
  161. if ((*init_fnc_ptr)() != 0) {
  162. hang ();
  163. }
  164. }
  165. /*
  166. * Now that we have DRAM mapped and working, we can
  167. * relocate the code and continue running from DRAM.
  168. */
  169. addr = CFG_SDRAM_BASE + gd->ram_size;
  170. /* We can reserve some RAM "on top" here.
  171. */
  172. /* round down to next 4 kB limit.
  173. */
  174. addr &= ~(4096 - 1);
  175. debug ("Top of RAM usable for U-Boot at: %08lx\n", addr);
  176. /* Reserve memory for U-Boot code, data & bss
  177. * round down to next 16 kB limit
  178. */
  179. addr -= len;
  180. addr &= ~(16 * 1024 - 1);
  181. debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
  182. /* Reserve memory for malloc() arena.
  183. */
  184. addr_sp = addr - TOTAL_MALLOC_LEN;
  185. debug ("Reserving %dk for malloc() at: %08lx\n",
  186. TOTAL_MALLOC_LEN >> 10, addr_sp);
  187. /*
  188. * (permanently) allocate a Board Info struct
  189. * and a permanent copy of the "global" data
  190. */
  191. addr_sp -= sizeof(bd_t);
  192. bd = (bd_t *)addr_sp;
  193. gd->bd = bd;
  194. debug ("Reserving %d Bytes for Board Info at: %08lx\n",
  195. sizeof(bd_t), addr_sp);
  196. addr_sp -= sizeof(gd_t);
  197. id = (gd_t *)addr_sp;
  198. debug ("Reserving %d Bytes for Global Data at: %08lx\n",
  199. sizeof (gd_t), addr_sp);
  200. /* Reserve memory for boot params.
  201. */
  202. addr_sp -= CFG_BOOTPARAMS_LEN;
  203. bd->bi_boot_params = addr_sp;
  204. debug ("Reserving %dk for boot params() at: %08lx\n",
  205. CFG_BOOTPARAMS_LEN >> 10, addr_sp);
  206. /*
  207. * Finally, we set up a new (bigger) stack.
  208. *
  209. * Leave some safety gap for SP, force alignment on 16 byte boundary
  210. * Clear initial stack frame
  211. */
  212. addr_sp -= 16;
  213. addr_sp &= ~0xF;
  214. s = (ulong *)addr_sp;
  215. *s-- = 0;
  216. *s-- = 0;
  217. addr_sp = (ulong)s;
  218. debug ("Stack Pointer at: %08lx\n", addr_sp);
  219. /*
  220. * Save local variables to board info struct
  221. */
  222. bd->bi_memstart = CFG_SDRAM_BASE; /* start of DRAM memory */
  223. bd->bi_memsize = gd->ram_size; /* size of DRAM memory in bytes */
  224. bd->bi_baudrate = gd->baudrate; /* Console Baudrate */
  225. memcpy (id, (void *)gd, sizeof (gd_t));
  226. /* On the purple board we copy the code in a special way
  227. * in order to solve flash problems
  228. */
  229. #ifdef CONFIG_PURPLE
  230. copy_code(addr);
  231. #endif
  232. relocate_code (addr_sp, id, addr);
  233. /* NOTREACHED - relocate_code() does not return */
  234. }
  235. /************************************************************************
  236. *
  237. * This is the next part if the initialization sequence: we are now
  238. * running from RAM and have a "normal" C environment, i. e. global
  239. * data can be written, BSS has been cleared, the stack size in not
  240. * that critical any more, etc.
  241. *
  242. ************************************************************************
  243. */
  244. void board_init_r (gd_t *id, ulong dest_addr)
  245. {
  246. cmd_tbl_t *cmdtp;
  247. ulong size;
  248. extern void malloc_bin_reloc (void);
  249. #ifndef CFG_ENV_IS_NOWHERE
  250. extern char * env_name_spec;
  251. #endif
  252. char *s, *e;
  253. bd_t *bd;
  254. int i;
  255. gd = id;
  256. gd->flags |= GD_FLG_RELOC; /* tell others: relocation done */
  257. debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
  258. gd->reloc_off = dest_addr - CFG_MONITOR_BASE;
  259. monitor_flash_len = (ulong)&uboot_end_data - dest_addr;
  260. /*
  261. * We have to relocate the command table manually
  262. */
  263. for (cmdtp = &__u_boot_cmd_start; cmdtp != &__u_boot_cmd_end; cmdtp++) {
  264. ulong addr;
  265. addr = (ulong) (cmdtp->cmd) + gd->reloc_off;
  266. #if 0
  267. printf ("Command \"%s\": 0x%08lx => 0x%08lx\n",
  268. cmdtp->name, (ulong) (cmdtp->cmd), addr);
  269. #endif
  270. cmdtp->cmd =
  271. (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr;
  272. addr = (ulong)(cmdtp->name) + gd->reloc_off;
  273. cmdtp->name = (char *)addr;
  274. if (cmdtp->usage) {
  275. addr = (ulong)(cmdtp->usage) + gd->reloc_off;
  276. cmdtp->usage = (char *)addr;
  277. }
  278. #ifdef CFG_LONGHELP
  279. if (cmdtp->help) {
  280. addr = (ulong)(cmdtp->help) + gd->reloc_off;
  281. cmdtp->help = (char *)addr;
  282. }
  283. #endif
  284. }
  285. /* there are some other pointer constants we must deal with */
  286. #ifndef CFG_ENV_IS_NOWHERE
  287. env_name_spec += gd->reloc_off;
  288. #endif
  289. /* configure available FLASH banks */
  290. size = flash_init();
  291. display_flash_config (size);
  292. bd = gd->bd;
  293. bd->bi_flashstart = CFG_FLASH_BASE;
  294. bd->bi_flashsize = size;
  295. #if CFG_MONITOR_BASE == CFG_FLASH_BASE
  296. bd->bi_flashoffset = monitor_flash_len; /* reserved area for U-Boot */
  297. #else
  298. bd->bi_flashoffset = 0;
  299. #endif
  300. /* initialize malloc() area */
  301. mem_malloc_init();
  302. malloc_bin_reloc();
  303. /* relocate environment function pointers etc. */
  304. env_relocate();
  305. /* board MAC address */
  306. s = getenv ("ethaddr");
  307. for (i = 0; i < 6; ++i) {
  308. bd->bi_enetaddr[i] = s ? simple_strtoul (s, &e, 16) : 0;
  309. if (s)
  310. s = (*e) ? e + 1 : e;
  311. }
  312. /* IP Address */
  313. bd->bi_ip_addr = getenv_IPaddr("ipaddr");
  314. #if defined(CONFIG_PCI)
  315. /*
  316. * Do pci configuration
  317. */
  318. pci_init();
  319. #endif
  320. /** leave this here (after malloc(), environment and PCI are working) **/
  321. /* Initialize devices */
  322. devices_init ();
  323. jumptable_init ();
  324. /* Initialize the console (after the relocation and devices init) */
  325. console_init_r ();
  326. /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/
  327. /* Initialize from environment */
  328. if ((s = getenv ("loadaddr")) != NULL) {
  329. load_addr = simple_strtoul (s, NULL, 16);
  330. }
  331. #if (CONFIG_COMMANDS & CFG_CMD_NET)
  332. if ((s = getenv ("bootfile")) != NULL) {
  333. copy_filename (BootFile, s, sizeof (BootFile));
  334. }
  335. #endif /* CFG_CMD_NET */
  336. #if defined(CONFIG_MISC_INIT_R)
  337. /* miscellaneous platform dependent initialisations */
  338. misc_init_r ();
  339. #endif
  340. #if (CONFIG_COMMANDS & CFG_CMD_NET)
  341. #if defined(CONFIG_NET_MULTI)
  342. puts ("Net: ");
  343. #endif
  344. eth_initialize(gd->bd);
  345. #endif
  346. /* main_loop() can return to retry autoboot, if so just run it again. */
  347. for (;;) {
  348. main_loop ();
  349. }
  350. /* NOTREACHED - no way out of command loop except booting */
  351. }
  352. void hang (void)
  353. {
  354. puts ("### ERROR ### Please RESET the board ###\n");
  355. for (;;);
  356. }