Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2010 |
| 3 | * Texas Instruments, <www.ti.com> |
| 4 | * |
| 5 | * Aneesh V <aneesh@ti.com> |
| 6 | * |
Wolfgang Denk | 1a45966 | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 7 | * SPDX-License-Identifier: GPL-2.0+ |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 8 | */ |
| 9 | #include <common.h> |
Simon Glass | 1151651 | 2014-11-10 17:16:46 -0700 | [diff] [blame] | 10 | #include <dm.h> |
Tom Rini | 47f7bca | 2012-08-13 12:03:19 -0700 | [diff] [blame] | 11 | #include <spl.h> |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 12 | #include <asm/u-boot.h> |
Simon Schwarz | bb085b8 | 2011-09-14 15:29:26 -0400 | [diff] [blame] | 13 | #include <nand.h> |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 14 | #include <fat.h> |
Simon Glass | efb2172 | 2011-10-10 08:55:19 +0000 | [diff] [blame] | 15 | #include <version.h> |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 16 | #include <i2c.h> |
| 17 | #include <image.h> |
Aneesh V | 2d01dd9 | 2011-10-21 12:29:34 -0400 | [diff] [blame] | 18 | #include <malloc.h> |
Simon Glass | 1151651 | 2014-11-10 17:16:46 -0700 | [diff] [blame] | 19 | #include <dm/root.h> |
Andreas Müller | 761ca31 | 2012-01-04 15:26:24 +0000 | [diff] [blame] | 20 | #include <linux/compiler.h> |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 21 | |
| 22 | DECLARE_GLOBAL_DATA_PTR; |
| 23 | |
Stefan Roese | 3c6f8a0 | 2012-08-28 10:50:59 +0200 | [diff] [blame] | 24 | #ifndef CONFIG_SYS_UBOOT_START |
| 25 | #define CONFIG_SYS_UBOOT_START CONFIG_SYS_TEXT_BASE |
| 26 | #endif |
Stefano Babic | ae83d88 | 2012-08-23 12:46:16 +0200 | [diff] [blame] | 27 | #ifndef CONFIG_SYS_MONITOR_LEN |
Andreas Bießmann | e76caa6 | 2014-10-25 02:54:55 +0200 | [diff] [blame] | 28 | /* Unknown U-Boot size, let's assume it will not be more than 200 KB */ |
Stefano Babic | ae83d88 | 2012-08-23 12:46:16 +0200 | [diff] [blame] | 29 | #define CONFIG_SYS_MONITOR_LEN (200 * 1024) |
| 30 | #endif |
| 31 | |
Tom Rini | 47f7bca | 2012-08-13 12:03:19 -0700 | [diff] [blame] | 32 | u32 *boot_params_ptr = NULL; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 33 | struct spl_image_info spl_image; |
| 34 | |
Tom Rini | 6507f13 | 2012-08-22 15:31:05 -0700 | [diff] [blame] | 35 | /* Define board data structure */ |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 36 | static bd_t bdata __attribute__ ((section(".data"))); |
| 37 | |
Simon Schwarz | 379c19a | 2012-03-15 04:01:38 +0000 | [diff] [blame] | 38 | /* |
| 39 | * Default function to determine if u-boot or the OS should |
| 40 | * be started. This implementation always returns 1. |
| 41 | * |
| 42 | * Please implement your own board specific funcion to do this. |
| 43 | * |
| 44 | * RETURN |
| 45 | * 0 to not start u-boot |
| 46 | * positive if u-boot should start |
| 47 | */ |
| 48 | #ifdef CONFIG_SPL_OS_BOOT |
| 49 | __weak int spl_start_uboot(void) |
| 50 | { |
Tom Rini | 026b2fe | 2012-08-14 12:06:43 -0700 | [diff] [blame] | 51 | puts("SPL: Please implement spl_start_uboot() for your board\n"); |
| 52 | puts("SPL: Direct Linux boot not active!\n"); |
Simon Schwarz | 379c19a | 2012-03-15 04:01:38 +0000 | [diff] [blame] | 53 | return 1; |
| 54 | } |
| 55 | #endif |
| 56 | |
Stefan Roese | ea8256f | 2012-08-23 08:34:21 +0200 | [diff] [blame] | 57 | /* |
| 58 | * Weak default function for board specific cleanup/preparation before |
| 59 | * Linux boot. Some boards/platforms might not need it, so just provide |
| 60 | * an empty stub here. |
| 61 | */ |
| 62 | __weak void spl_board_prepare_for_linux(void) |
| 63 | { |
| 64 | /* Nothing to do! */ |
| 65 | } |
| 66 | |
Heiko Schocher | 0c3117b | 2014-10-31 08:31:00 +0100 | [diff] [blame] | 67 | void spl_set_header_raw_uboot(void) |
| 68 | { |
| 69 | spl_image.size = CONFIG_SYS_MONITOR_LEN; |
| 70 | spl_image.entry_point = CONFIG_SYS_UBOOT_START; |
| 71 | spl_image.load_addr = CONFIG_SYS_TEXT_BASE; |
| 72 | spl_image.os = IH_OS_U_BOOT; |
| 73 | spl_image.name = "U-Boot"; |
| 74 | } |
| 75 | |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 76 | void spl_parse_image_header(const struct image_header *header) |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 77 | { |
| 78 | u32 header_size = sizeof(struct image_header); |
| 79 | |
Stefan Roese | 77552b0 | 2012-08-27 12:50:57 +0200 | [diff] [blame] | 80 | if (image_get_magic(header) == IH_MAGIC) { |
Stefan Roese | 022b497 | 2012-08-27 12:50:58 +0200 | [diff] [blame] | 81 | if (spl_image.flags & SPL_COPY_PAYLOAD_ONLY) { |
| 82 | /* |
| 83 | * On some system (e.g. powerpc), the load-address and |
| 84 | * entry-point is located at address 0. We can't load |
| 85 | * to 0-0x40. So skip header in this case. |
| 86 | */ |
| 87 | spl_image.load_addr = image_get_load(header); |
| 88 | spl_image.entry_point = image_get_ep(header); |
| 89 | spl_image.size = image_get_data_size(header); |
| 90 | } else { |
| 91 | spl_image.entry_point = image_get_load(header); |
| 92 | /* Load including the header */ |
| 93 | spl_image.load_addr = spl_image.entry_point - |
| 94 | header_size; |
| 95 | spl_image.size = image_get_data_size(header) + |
| 96 | header_size; |
| 97 | } |
Stefan Roese | 77552b0 | 2012-08-27 12:50:57 +0200 | [diff] [blame] | 98 | spl_image.os = image_get_os(header); |
| 99 | spl_image.name = image_get_name(header); |
Taras Kondratiuk | 62cf11c | 2013-07-16 14:45:01 +0300 | [diff] [blame] | 100 | debug("spl: payload image: %.*s load addr: 0x%x size: %d\n", |
Vasili Galka | 5d69a5d | 2014-08-26 13:45:48 +0300 | [diff] [blame] | 101 | (int)sizeof(spl_image.name), spl_image.name, |
Taras Kondratiuk | 62cf11c | 2013-07-16 14:45:01 +0300 | [diff] [blame] | 102 | spl_image.load_addr, spl_image.size); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 103 | } else { |
Albert ARIBAUD \(3ADEV\) | 8c80eb3 | 2015-03-31 11:40:50 +0200 | [diff] [blame] | 104 | #ifdef CONFIG_SPL_PANIC_ON_RAW_IMAGE |
| 105 | /* |
| 106 | * CONFIG_SPL_PANIC_ON_RAW_IMAGE is defined when the |
| 107 | * code which loads images in SPL cannot guarantee that |
| 108 | * absolutely all read errors will be reported. |
| 109 | * An example is the LPC32XX MLC NAND driver, which |
| 110 | * will consider that a completely unreadable NAND block |
| 111 | * is bad, and thus should be skipped silently. |
| 112 | */ |
| 113 | panic("** no mkimage signature but raw image not supported"); |
| 114 | #else |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 115 | /* Signature not found - assume u-boot.bin */ |
Tom Rini | 026b2fe | 2012-08-14 12:06:43 -0700 | [diff] [blame] | 116 | debug("mkimage signature not found - ih_magic = %x\n", |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 117 | header->ih_magic); |
Heiko Schocher | 0c3117b | 2014-10-31 08:31:00 +0100 | [diff] [blame] | 118 | spl_set_header_raw_uboot(); |
Albert ARIBAUD \(3ADEV\) | 8c80eb3 | 2015-03-31 11:40:50 +0200 | [diff] [blame] | 119 | #endif |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 120 | } |
| 121 | } |
| 122 | |
Allen Martin | a759f1e | 2012-10-19 21:08:22 +0000 | [diff] [blame] | 123 | __weak void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 124 | { |
SRICHARAN R | 4a0eb75 | 2013-04-24 00:41:24 +0000 | [diff] [blame] | 125 | typedef void __noreturn (*image_entry_noargs_t)(void); |
| 126 | |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 127 | image_entry_noargs_t image_entry = |
Scott Wood | b2d5ac5 | 2015-03-24 13:25:02 -0700 | [diff] [blame] | 128 | (image_entry_noargs_t)(unsigned long)spl_image->entry_point; |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 129 | |
Allen Martin | a759f1e | 2012-10-19 21:08:22 +0000 | [diff] [blame] | 130 | debug("image entry point: 0x%X\n", spl_image->entry_point); |
SRICHARAN R | 4a0eb75 | 2013-04-24 00:41:24 +0000 | [diff] [blame] | 131 | image_entry(); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 132 | } |
| 133 | |
Pavel Machek | c57b953 | 2012-08-30 22:42:11 +0200 | [diff] [blame] | 134 | #ifdef CONFIG_SPL_RAM_DEVICE |
| 135 | static void spl_ram_load_image(void) |
| 136 | { |
| 137 | const struct image_header *header; |
| 138 | |
| 139 | /* |
| 140 | * Get the header. It will point to an address defined by handoff |
| 141 | * which will tell where the image located inside the flash. For |
| 142 | * now, it will temporary fixed to address pointed by U-Boot. |
| 143 | */ |
| 144 | header = (struct image_header *) |
| 145 | (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); |
| 146 | |
| 147 | spl_parse_image_header(header); |
| 148 | } |
| 149 | #endif |
| 150 | |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 151 | int spl_init(void) |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 152 | { |
Simon Glass | f3d46bd | 2015-02-27 22:06:42 -0700 | [diff] [blame] | 153 | int ret; |
| 154 | |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 155 | debug("spl_init()\n"); |
| 156 | #if defined(CONFIG_SYS_MALLOC_F_LEN) |
Simon Glass | 293f16b | 2015-02-27 22:06:37 -0700 | [diff] [blame] | 157 | gd->malloc_limit = CONFIG_SYS_MALLOC_F_LEN; |
Simon Glass | fb4f5e7 | 2014-11-10 17:16:45 -0700 | [diff] [blame] | 158 | gd->malloc_ptr = 0; |
Tom Rini | 24dafad | 2012-08-13 14:13:07 -0700 | [diff] [blame] | 159 | #endif |
Masahiro Yamada | 0f92582 | 2015-08-12 07:31:55 +0900 | [diff] [blame] | 160 | if (CONFIG_IS_ENABLED(OF_CONTROL)) { |
Simon Glass | f3d46bd | 2015-02-27 22:06:42 -0700 | [diff] [blame] | 161 | ret = fdtdec_setup(); |
| 162 | if (ret) { |
| 163 | debug("fdtdec_setup() returned error %d\n", ret); |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 164 | return ret; |
Simon Glass | f3d46bd | 2015-02-27 22:06:42 -0700 | [diff] [blame] | 165 | } |
| 166 | } |
| 167 | if (IS_ENABLED(CONFIG_SPL_DM)) { |
| 168 | ret = dm_init_and_scan(true); |
| 169 | if (ret) { |
| 170 | debug("dm_init_and_scan() returned error %d\n", ret); |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 171 | return ret; |
Simon Glass | f3d46bd | 2015-02-27 22:06:42 -0700 | [diff] [blame] | 172 | } |
| 173 | } |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 174 | gd->flags |= GD_FLG_SPL_INIT; |
Aneesh V | 2d01dd9 | 2011-10-21 12:29:34 -0400 | [diff] [blame] | 175 | |
Simon Glass | 070d00b | 2015-06-23 15:39:10 -0600 | [diff] [blame] | 176 | return 0; |
| 177 | } |
| 178 | |
| 179 | void board_init_r(gd_t *dummy1, ulong dummy2) |
| 180 | { |
| 181 | u32 boot_device; |
| 182 | |
| 183 | debug(">>spl:board_init_r()\n"); |
| 184 | |
| 185 | #if defined(CONFIG_SYS_SPL_MALLOC_START) |
| 186 | mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START, |
| 187 | CONFIG_SYS_SPL_MALLOC_SIZE); |
| 188 | gd->flags |= GD_FLG_FULL_MALLOC_INIT; |
| 189 | #endif |
| 190 | if (!(gd->flags & GD_FLG_SPL_INIT)) { |
| 191 | if (spl_init()) |
| 192 | hang(); |
| 193 | } |
Stefan Roese | ea8256f | 2012-08-23 08:34:21 +0200 | [diff] [blame] | 194 | #ifndef CONFIG_PPC |
| 195 | /* |
| 196 | * timer_init() does not exist on PPC systems. The timer is initialized |
| 197 | * and enabled (decrementer) in interrupt_init() here. |
| 198 | */ |
Ilya Yanok | 4063c77 | 2012-09-17 10:26:26 +0000 | [diff] [blame] | 199 | timer_init(); |
Stefan Roese | ea8256f | 2012-08-23 08:34:21 +0200 | [diff] [blame] | 200 | #endif |
Ilya Yanok | 4063c77 | 2012-09-17 10:26:26 +0000 | [diff] [blame] | 201 | |
Tom Rini | ee08a82 | 2011-11-23 05:13:06 +0000 | [diff] [blame] | 202 | #ifdef CONFIG_SPL_BOARD_INIT |
| 203 | spl_board_init(); |
| 204 | #endif |
| 205 | |
Tom Rini | 8e1b836 | 2012-08-13 12:53:23 -0700 | [diff] [blame] | 206 | boot_device = spl_boot_device(); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 207 | debug("boot device - %d\n", boot_device); |
| 208 | switch (boot_device) { |
Pavel Machek | c57b953 | 2012-08-30 22:42:11 +0200 | [diff] [blame] | 209 | #ifdef CONFIG_SPL_RAM_DEVICE |
| 210 | case BOOT_DEVICE_RAM: |
| 211 | spl_ram_load_image(); |
| 212 | break; |
| 213 | #endif |
Simon Schwarz | bb085b8 | 2011-09-14 15:29:26 -0400 | [diff] [blame] | 214 | #ifdef CONFIG_SPL_MMC_SUPPORT |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 215 | case BOOT_DEVICE_MMC1: |
| 216 | case BOOT_DEVICE_MMC2: |
Balaji T K | f75231b | 2012-03-12 02:25:47 +0000 | [diff] [blame] | 217 | case BOOT_DEVICE_MMC2_2: |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 218 | spl_mmc_load_image(); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 219 | break; |
Simon Schwarz | bb085b8 | 2011-09-14 15:29:26 -0400 | [diff] [blame] | 220 | #endif |
| 221 | #ifdef CONFIG_SPL_NAND_SUPPORT |
| 222 | case BOOT_DEVICE_NAND: |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 223 | spl_nand_load_image(); |
Simon Schwarz | bb085b8 | 2011-09-14 15:29:26 -0400 | [diff] [blame] | 224 | break; |
| 225 | #endif |
Enric Balletbo i Serra | 6000992 | 2013-02-07 23:14:48 +0000 | [diff] [blame] | 226 | #ifdef CONFIG_SPL_ONENAND_SUPPORT |
| 227 | case BOOT_DEVICE_ONENAND: |
| 228 | spl_onenand_load_image(); |
| 229 | break; |
| 230 | #endif |
Stefan Roese | 33d3464 | 2012-08-27 12:50:59 +0200 | [diff] [blame] | 231 | #ifdef CONFIG_SPL_NOR_SUPPORT |
| 232 | case BOOT_DEVICE_NOR: |
| 233 | spl_nor_load_image(); |
| 234 | break; |
| 235 | #endif |
Matt Porter | 24de357 | 2012-01-31 12:03:57 +0000 | [diff] [blame] | 236 | #ifdef CONFIG_SPL_YMODEM_SUPPORT |
| 237 | case BOOT_DEVICE_UART: |
| 238 | spl_ymodem_load_image(); |
| 239 | break; |
| 240 | #endif |
Tom Rini | d4c4e0e | 2012-08-14 12:25:23 -0700 | [diff] [blame] | 241 | #ifdef CONFIG_SPL_SPI_SUPPORT |
| 242 | case BOOT_DEVICE_SPI: |
Tom Rini | a4cc1c4 | 2012-08-14 14:34:10 -0700 | [diff] [blame] | 243 | spl_spi_load_image(); |
| 244 | break; |
Tom Rini | d4c4e0e | 2012-08-14 12:25:23 -0700 | [diff] [blame] | 245 | #endif |
Ilya Yanok | 7ac2fe2 | 2012-09-18 00:22:50 +0000 | [diff] [blame] | 246 | #ifdef CONFIG_SPL_ETH_SUPPORT |
| 247 | case BOOT_DEVICE_CPGMAC: |
| 248 | #ifdef CONFIG_SPL_ETH_DEVICE |
| 249 | spl_net_load_image(CONFIG_SPL_ETH_DEVICE); |
| 250 | #else |
| 251 | spl_net_load_image(NULL); |
| 252 | #endif |
| 253 | break; |
| 254 | #endif |
Ilya Yanok | 62a8143 | 2013-02-05 11:36:24 +0000 | [diff] [blame] | 255 | #ifdef CONFIG_SPL_USBETH_SUPPORT |
| 256 | case BOOT_DEVICE_USBETH: |
| 257 | spl_net_load_image("usb_ether"); |
| 258 | break; |
| 259 | #endif |
Dan Murphy | 8cffe5b | 2014-01-16 11:23:30 -0600 | [diff] [blame] | 260 | #ifdef CONFIG_SPL_USB_SUPPORT |
| 261 | case BOOT_DEVICE_USB: |
| 262 | spl_usb_load_image(); |
| 263 | break; |
| 264 | #endif |
Dan Murphy | fff40a7 | 2014-02-03 06:59:01 -0600 | [diff] [blame] | 265 | #ifdef CONFIG_SPL_SATA_SUPPORT |
| 266 | case BOOT_DEVICE_SATA: |
| 267 | spl_sata_load_image(); |
| 268 | break; |
| 269 | #endif |
Simon Glass | c01c71b | 2015-02-07 10:47:29 -0700 | [diff] [blame] | 270 | #ifdef CONFIG_SPL_BOARD_LOAD_IMAGE |
| 271 | case BOOT_DEVICE_BOARD: |
| 272 | spl_board_load_image(); |
| 273 | break; |
| 274 | #endif |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 275 | default: |
Stefan Roese | 18f26fd | 2014-11-11 19:03:55 +0100 | [diff] [blame] | 276 | #if defined(CONFIG_SPL_SERIAL_SUPPORT) && defined(CONFIG_SPL_LIBCOMMON_SUPPORT) |
Stefan Roese | e860d01 | 2015-01-27 16:45:09 +0100 | [diff] [blame] | 277 | puts("SPL: Unsupported Boot Device!\n"); |
Stefan Roese | 18f26fd | 2014-11-11 19:03:55 +0100 | [diff] [blame] | 278 | #endif |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 279 | hang(); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 280 | } |
| 281 | |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 282 | switch (spl_image.os) { |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 283 | case IH_OS_U_BOOT: |
| 284 | debug("Jumping to U-Boot\n"); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 285 | break; |
Simon Schwarz | 379c19a | 2012-03-15 04:01:38 +0000 | [diff] [blame] | 286 | #ifdef CONFIG_SPL_OS_BOOT |
| 287 | case IH_OS_LINUX: |
| 288 | debug("Jumping to Linux\n"); |
| 289 | spl_board_prepare_for_linux(); |
| 290 | jump_to_image_linux((void *)CONFIG_SYS_SPL_ARGS_ADDR); |
Simon Schwarz | 379c19a | 2012-03-15 04:01:38 +0000 | [diff] [blame] | 291 | #endif |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 292 | default: |
Tom Rini | 4212098 | 2012-08-27 14:58:28 -0700 | [diff] [blame] | 293 | debug("Unsupported OS image.. Jumping nevertheless..\n"); |
Aneesh V | 8cf686e | 2011-07-21 09:10:27 -0400 | [diff] [blame] | 294 | } |
Simon Glass | fb4f5e7 | 2014-11-10 17:16:45 -0700 | [diff] [blame] | 295 | #if defined(CONFIG_SYS_MALLOC_F_LEN) && !defined(CONFIG_SYS_SPL_MALLOC_SIZE) |
| 296 | debug("SPL malloc() used %#lx bytes (%ld KB)\n", gd->malloc_ptr, |
| 297 | gd->malloc_ptr / 1024); |
| 298 | #endif |
| 299 | |
Simon Glass | aea3d40 | 2015-06-23 15:39:11 -0600 | [diff] [blame] | 300 | debug("loaded - jumping to U-Boot..."); |
Allen Martin | a759f1e | 2012-10-19 21:08:22 +0000 | [diff] [blame] | 301 | jump_to_image_no_args(&spl_image); |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 302 | } |
| 303 | |
Tom Rini | 6507f13 | 2012-08-22 15:31:05 -0700 | [diff] [blame] | 304 | /* |
| 305 | * This requires UART clocks to be enabled. In order for this to work the |
| 306 | * caller must ensure that the gd pointer is valid. |
| 307 | */ |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 308 | void preloader_console_init(void) |
| 309 | { |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 310 | gd->bd = &bdata; |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 311 | gd->baudrate = CONFIG_BAUDRATE; |
| 312 | |
Aneesh V | bcae721 | 2011-07-21 09:10:21 -0400 | [diff] [blame] | 313 | serial_init(); /* serial communications setup */ |
| 314 | |
Ilya Yanok | b88befa | 2011-11-01 13:16:03 +0000 | [diff] [blame] | 315 | gd->have_console = 1; |
| 316 | |
Tom Rini | 026b2fe | 2012-08-14 12:06:43 -0700 | [diff] [blame] | 317 | puts("\nU-Boot SPL " PLAIN_VERSION " (" U_BOOT_DATE " - " \ |
| 318 | U_BOOT_TIME ")\n"); |
Tom Rini | 861a86f | 2012-08-13 11:37:56 -0700 | [diff] [blame] | 319 | #ifdef CONFIG_SPL_DISPLAY_PRINT |
| 320 | spl_display_print(); |
| 321 | #endif |
Tom Rini | cc3f705 | 2011-10-04 04:59:23 +0000 | [diff] [blame] | 322 | } |
Simon Glass | db91035 | 2015-03-03 08:03:00 -0700 | [diff] [blame] | 323 | |
| 324 | /** |
| 325 | * spl_relocate_stack_gd() - Relocate stack ready for board_init_r() execution |
| 326 | * |
| 327 | * Sometimes board_init_f() runs with a stack in SRAM but we want to use SDRAM |
| 328 | * for the main board_init_r() execution. This is typically because we need |
| 329 | * more stack space for things like the MMC sub-system. |
| 330 | * |
| 331 | * This function calculates the stack position, copies the global_data into |
| 332 | * place and returns the new stack position. The caller is responsible for |
| 333 | * setting up the sp register. |
| 334 | * |
| 335 | * @return new stack location, or 0 to use the same stack |
| 336 | */ |
| 337 | ulong spl_relocate_stack_gd(void) |
| 338 | { |
| 339 | #ifdef CONFIG_SPL_STACK_R |
| 340 | gd_t *new_gd; |
| 341 | ulong ptr; |
| 342 | |
| 343 | /* Get stack position: use 8-byte alignment for ABI compliance */ |
Simon Glass | ce49e79 | 2015-05-13 21:15:21 -0600 | [diff] [blame] | 344 | ptr = CONFIG_SPL_STACK_R_ADDR - sizeof(gd_t); |
Simon Glass | db91035 | 2015-03-03 08:03:00 -0700 | [diff] [blame] | 345 | ptr &= ~7; |
| 346 | new_gd = (gd_t *)ptr; |
| 347 | memcpy(new_gd, (void *)gd, sizeof(gd_t)); |
| 348 | gd = new_gd; |
| 349 | |
| 350 | /* Clear the BSS. */ |
| 351 | memset(__bss_start, 0, __bss_end - __bss_start); |
| 352 | |
| 353 | return ptr; |
| 354 | #else |
| 355 | return 0; |
| 356 | #endif |
| 357 | } |