wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2001 William L. Pitts |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms are freely |
| 6 | * permitted provided that the above copyright notice and this |
| 7 | * paragraph and the following disclaimer are duplicated in all |
| 8 | * such forms. |
| 9 | * |
| 10 | * This software is provided "AS IS" and without any express or |
| 11 | * implied warranties, including, without limitation, the implied |
| 12 | * warranties of merchantability and fitness for a particular |
| 13 | * purpose. |
| 14 | */ |
| 15 | |
| 16 | #include <common.h> |
| 17 | #include <command.h> |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 18 | #include <elf.h> |
Alex Kiernan | 9925f1d | 2018-04-01 09:22:38 +0000 | [diff] [blame] | 19 | #include <environment.h> |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 20 | #include <net.h> |
Niklaus Giger | 29a4c24 | 2008-11-03 22:15:34 +0100 | [diff] [blame] | 21 | #include <vxworks.h> |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 22 | #ifdef CONFIG_X86 |
| 23 | #include <asm/e820.h> |
Bin Meng | 9aa1280 | 2015-10-07 20:19:19 -0700 | [diff] [blame] | 24 | #include <linux/linkage.h> |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 25 | #endif |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 26 | |
Bin Meng | 9dffa52 | 2015-10-07 20:19:14 -0700 | [diff] [blame] | 27 | /* |
Bin Meng | 839c4e9 | 2018-04-11 22:02:14 -0700 | [diff] [blame] | 28 | * A very simple ELF64 loader, assumes the image is valid, returns the |
Bin Meng | 9dffa52 | 2015-10-07 20:19:14 -0700 | [diff] [blame] | 29 | * entry point address. |
Bin Meng | 839c4e9 | 2018-04-11 22:02:14 -0700 | [diff] [blame] | 30 | * |
| 31 | * Note if U-Boot is 32-bit, the loader assumes the to segment's |
| 32 | * physical address and size is within the lower 32-bit address space. |
| 33 | */ |
| 34 | static unsigned long load_elf64_image_phdr(unsigned long addr) |
| 35 | { |
| 36 | Elf64_Ehdr *ehdr; /* Elf header structure pointer */ |
| 37 | Elf64_Phdr *phdr; /* Program header structure pointer */ |
| 38 | int i; |
| 39 | |
| 40 | ehdr = (Elf64_Ehdr *)addr; |
| 41 | phdr = (Elf64_Phdr *)(addr + (ulong)ehdr->e_phoff); |
| 42 | |
| 43 | /* Load each program header */ |
| 44 | for (i = 0; i < ehdr->e_phnum; ++i) { |
| 45 | void *dst = (void *)(ulong)phdr->p_paddr; |
| 46 | void *src = (void *)addr + phdr->p_offset; |
| 47 | |
| 48 | debug("Loading phdr %i to 0x%p (%lu bytes)\n", |
| 49 | i, dst, (ulong)phdr->p_filesz); |
| 50 | if (phdr->p_filesz) |
| 51 | memcpy(dst, src, phdr->p_filesz); |
| 52 | if (phdr->p_filesz != phdr->p_memsz) |
| 53 | memset(dst + phdr->p_filesz, 0x00, |
| 54 | phdr->p_memsz - phdr->p_filesz); |
| 55 | flush_cache((unsigned long)dst, phdr->p_filesz); |
| 56 | ++phdr; |
| 57 | } |
| 58 | |
| 59 | return ehdr->e_entry; |
| 60 | } |
| 61 | |
| 62 | /* |
| 63 | * A very simple ELF loader, assumes the image is valid, returns the |
| 64 | * entry point address. |
| 65 | * |
| 66 | * The loader firstly reads the EFI class to see if it's a 64-bit image. |
| 67 | * If yes, call the ELF64 loader. Otherwise continue with the ELF32 loader. |
Bin Meng | 9dffa52 | 2015-10-07 20:19:14 -0700 | [diff] [blame] | 68 | */ |
| 69 | static unsigned long load_elf_image_phdr(unsigned long addr) |
| 70 | { |
| 71 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ |
| 72 | Elf32_Phdr *phdr; /* Program header structure pointer */ |
| 73 | int i; |
| 74 | |
| 75 | ehdr = (Elf32_Ehdr *)addr; |
Bin Meng | 839c4e9 | 2018-04-11 22:02:14 -0700 | [diff] [blame] | 76 | if (ehdr->e_ident[EI_CLASS] == ELFCLASS64) |
| 77 | return load_elf64_image_phdr(addr); |
| 78 | |
Bin Meng | 9dffa52 | 2015-10-07 20:19:14 -0700 | [diff] [blame] | 79 | phdr = (Elf32_Phdr *)(addr + ehdr->e_phoff); |
| 80 | |
| 81 | /* Load each program header */ |
| 82 | for (i = 0; i < ehdr->e_phnum; ++i) { |
| 83 | void *dst = (void *)(uintptr_t)phdr->p_paddr; |
| 84 | void *src = (void *)addr + phdr->p_offset; |
Bin Meng | 839c4e9 | 2018-04-11 22:02:14 -0700 | [diff] [blame] | 85 | |
Bin Meng | 9dffa52 | 2015-10-07 20:19:14 -0700 | [diff] [blame] | 86 | debug("Loading phdr %i to 0x%p (%i bytes)\n", |
| 87 | i, dst, phdr->p_filesz); |
| 88 | if (phdr->p_filesz) |
| 89 | memcpy(dst, src, phdr->p_filesz); |
| 90 | if (phdr->p_filesz != phdr->p_memsz) |
| 91 | memset(dst + phdr->p_filesz, 0x00, |
| 92 | phdr->p_memsz - phdr->p_filesz); |
| 93 | flush_cache((unsigned long)dst, phdr->p_filesz); |
| 94 | ++phdr; |
| 95 | } |
| 96 | |
| 97 | return ehdr->e_entry; |
| 98 | } |
| 99 | |
| 100 | static unsigned long load_elf_image_shdr(unsigned long addr) |
| 101 | { |
| 102 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ |
| 103 | Elf32_Shdr *shdr; /* Section header structure pointer */ |
| 104 | unsigned char *strtab = 0; /* String table pointer */ |
| 105 | unsigned char *image; /* Binary image pointer */ |
| 106 | int i; /* Loop counter */ |
| 107 | |
| 108 | ehdr = (Elf32_Ehdr *)addr; |
| 109 | |
| 110 | /* Find the section header string table for output info */ |
| 111 | shdr = (Elf32_Shdr *)(addr + ehdr->e_shoff + |
| 112 | (ehdr->e_shstrndx * sizeof(Elf32_Shdr))); |
| 113 | |
| 114 | if (shdr->sh_type == SHT_STRTAB) |
| 115 | strtab = (unsigned char *)(addr + shdr->sh_offset); |
| 116 | |
| 117 | /* Load each appropriate section */ |
| 118 | for (i = 0; i < ehdr->e_shnum; ++i) { |
| 119 | shdr = (Elf32_Shdr *)(addr + ehdr->e_shoff + |
| 120 | (i * sizeof(Elf32_Shdr))); |
| 121 | |
| 122 | if (!(shdr->sh_flags & SHF_ALLOC) || |
| 123 | shdr->sh_addr == 0 || shdr->sh_size == 0) { |
| 124 | continue; |
| 125 | } |
| 126 | |
| 127 | if (strtab) { |
| 128 | debug("%sing %s @ 0x%08lx (%ld bytes)\n", |
| 129 | (shdr->sh_type == SHT_NOBITS) ? "Clear" : "Load", |
| 130 | &strtab[shdr->sh_name], |
| 131 | (unsigned long)shdr->sh_addr, |
| 132 | (long)shdr->sh_size); |
| 133 | } |
| 134 | |
| 135 | if (shdr->sh_type == SHT_NOBITS) { |
| 136 | memset((void *)(uintptr_t)shdr->sh_addr, 0, |
| 137 | shdr->sh_size); |
| 138 | } else { |
| 139 | image = (unsigned char *)addr + shdr->sh_offset; |
| 140 | memcpy((void *)(uintptr_t)shdr->sh_addr, |
| 141 | (const void *)image, shdr->sh_size); |
| 142 | } |
| 143 | flush_cache(shdr->sh_addr, shdr->sh_size); |
| 144 | } |
| 145 | |
| 146 | return ehdr->e_entry; |
| 147 | } |
Mike Frysinger | 017e9b7 | 2008-04-13 19:42:18 -0400 | [diff] [blame] | 148 | |
| 149 | /* Allow ports to override the default behavior */ |
Jeroen Hofstee | 553d8c3 | 2014-10-08 22:57:31 +0200 | [diff] [blame] | 150 | static unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]), |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 151 | int argc, char * const argv[]) |
Mike Frysinger | 1f1d88d | 2008-01-29 18:21:05 -0500 | [diff] [blame] | 152 | { |
Mike Frysinger | 017e9b7 | 2008-04-13 19:42:18 -0400 | [diff] [blame] | 153 | unsigned long ret; |
| 154 | |
Mike Frysinger | 1f1d88d | 2008-01-29 18:21:05 -0500 | [diff] [blame] | 155 | /* |
Mike Frysinger | 017e9b7 | 2008-04-13 19:42:18 -0400 | [diff] [blame] | 156 | * pass address parameter as argv[0] (aka command name), |
| 157 | * and all remaining args |
| 158 | */ |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 159 | ret = entry(argc, argv); |
Mike Frysinger | 1f1d88d | 2008-01-29 18:21:05 -0500 | [diff] [blame] | 160 | |
Mike Frysinger | 017e9b7 | 2008-04-13 19:42:18 -0400 | [diff] [blame] | 161 | return ret; |
| 162 | } |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 163 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 164 | /* |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 165 | * Determine if a valid ELF image exists at the given memory location. |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 166 | * First look at the ELF header magic field, then make sure that it is |
| 167 | * executable. |
| 168 | */ |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 169 | int valid_elf_image(unsigned long addr) |
| 170 | { |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 171 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 172 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 173 | ehdr = (Elf32_Ehdr *)addr; |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 174 | |
| 175 | if (!IS_ELF(*ehdr)) { |
| 176 | printf("## No elf image at address 0x%08lx\n", addr); |
| 177 | return 0; |
| 178 | } |
| 179 | |
| 180 | if (ehdr->e_type != ET_EXEC) { |
| 181 | printf("## Not a 32-bit elf image at address 0x%08lx\n", addr); |
| 182 | return 0; |
| 183 | } |
| 184 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 185 | return 1; |
| 186 | } |
| 187 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 188 | /* Interpreter command to boot an arbitrary ELF image from memory */ |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 189 | int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 190 | { |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 191 | unsigned long addr; /* Address of the ELF image */ |
| 192 | unsigned long rc; /* Return value from user code */ |
Tom Rini | be1b867 | 2017-05-18 17:03:07 -0400 | [diff] [blame] | 193 | char *sload = NULL; |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 194 | const char *ep = env_get("autostart"); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 195 | int rcode = 0; |
| 196 | |
Tom Rini | be1b867 | 2017-05-18 17:03:07 -0400 | [diff] [blame] | 197 | /* Consume 'bootelf' */ |
| 198 | argc--; argv++; |
Mike Frysinger | f44a928 | 2010-10-02 15:44:53 -0400 | [diff] [blame] | 199 | |
Tom Rini | be1b867 | 2017-05-18 17:03:07 -0400 | [diff] [blame] | 200 | /* Check for flag. */ |
| 201 | if (argc >= 1 && (argv[0][0] == '-' && \ |
| 202 | (argv[0][1] == 'p' || argv[0][1] == 's'))) { |
| 203 | sload = argv[0]; |
| 204 | /* Consume flag. */ |
| 205 | argc--; argv++; |
| 206 | } |
| 207 | /* Check for address. */ |
| 208 | if (argc >= 1 && strict_strtoul(argv[0], 16, &addr) != -EINVAL) { |
| 209 | /* Consume address */ |
| 210 | argc--; argv++; |
| 211 | } else |
Mike Frysinger | f44a928 | 2010-10-02 15:44:53 -0400 | [diff] [blame] | 212 | addr = load_addr; |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 213 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 214 | if (!valid_elf_image(addr)) |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 215 | return 1; |
| 216 | |
Mike Frysinger | f44a928 | 2010-10-02 15:44:53 -0400 | [diff] [blame] | 217 | if (sload && sload[1] == 'p') |
| 218 | addr = load_elf_image_phdr(addr); |
| 219 | else |
| 220 | addr = load_elf_image_shdr(addr); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 221 | |
Siva Durga Prasad Paladugu | 44c8fd3 | 2015-03-09 12:46:47 +0100 | [diff] [blame] | 222 | if (ep && !strcmp(ep, "no")) |
| 223 | return rcode; |
| 224 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 225 | printf("## Starting application at 0x%08lx ...\n", addr); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 226 | |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 227 | /* |
| 228 | * pass address parameter as argv[0] (aka command name), |
| 229 | * and all remaining args |
| 230 | */ |
Tom Rini | be1b867 | 2017-05-18 17:03:07 -0400 | [diff] [blame] | 231 | rc = do_bootelf_exec((void *)addr, argc, argv); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 232 | if (rc != 0) |
| 233 | rcode = 1; |
| 234 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 235 | printf("## Application terminated, rc = 0x%lx\n", rc); |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 236 | |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 237 | return rcode; |
| 238 | } |
| 239 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 240 | /* |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 241 | * Interpreter command to boot VxWorks from a memory image. The image can |
| 242 | * be either an ELF image or a raw binary. Will attempt to setup the |
| 243 | * bootline and other parameters correctly. |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 244 | */ |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 245 | int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 246 | { |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 247 | unsigned long addr; /* Address of image */ |
| 248 | unsigned long bootaddr; /* Address to put the bootline */ |
| 249 | char *bootline; /* Text of the bootline */ |
| 250 | char *tmp; /* Temporary char pointer */ |
| 251 | char build_buf[128]; /* Buffer for building the bootline */ |
Bin Meng | 7f0c3c5 | 2015-10-07 20:19:15 -0700 | [diff] [blame] | 252 | int ptr = 0; |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 253 | #ifdef CONFIG_X86 |
Bin Meng | 2902be8 | 2018-04-11 22:02:07 -0700 | [diff] [blame] | 254 | ulong base; |
Bin Meng | fa5e91f | 2018-04-11 22:02:09 -0700 | [diff] [blame] | 255 | struct e820_info *info; |
Bin Meng | 4551992 | 2018-04-11 22:02:11 -0700 | [diff] [blame] | 256 | struct e820_entry *data; |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 257 | #endif |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 258 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 259 | /* |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 260 | * Check the loadaddr variable. |
| 261 | * If we don't know where the image is then we're done. |
| 262 | */ |
Stany MARCEL | 07a1a0c | 2013-11-27 14:48:43 +0100 | [diff] [blame] | 263 | if (argc < 2) |
Stefan Roese | 1bdd468 | 2006-11-29 12:53:15 +0100 | [diff] [blame] | 264 | addr = load_addr; |
| 265 | else |
Stany MARCEL | 07a1a0c | 2013-11-27 14:48:43 +0100 | [diff] [blame] | 266 | addr = simple_strtoul(argv[1], NULL, 16); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 267 | |
Jon Loeliger | baa26db | 2007-07-08 17:51:39 -0500 | [diff] [blame] | 268 | #if defined(CONFIG_CMD_NET) |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 269 | /* |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 270 | * Check to see if we need to tftp the image ourselves |
| 271 | * before starting |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 272 | */ |
Stany MARCEL | 07a1a0c | 2013-11-27 14:48:43 +0100 | [diff] [blame] | 273 | if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) { |
Joe Hershberger | bc0571f | 2015-04-08 01:41:21 -0500 | [diff] [blame] | 274 | if (net_loop(TFTPGET) <= 0) |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 275 | return 1; |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 276 | printf("Automatic boot of VxWorks image at address 0x%08lx ...\n", |
| 277 | addr); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 278 | } |
| 279 | #endif |
| 280 | |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 281 | /* |
| 282 | * This should equate to |
| 283 | * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 284 | * from the VxWorks BSP header files. |
| 285 | * This will vary from board to board |
| 286 | */ |
Tuomas Tynkkynen | 8996975 | 2018-01-21 18:16:42 +0200 | [diff] [blame] | 287 | #if defined(CONFIG_SYS_VXWORKS_MAC_PTR) |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 288 | tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR; |
Simon Glass | 35affd7 | 2017-08-03 12:22:14 -0600 | [diff] [blame] | 289 | eth_env_get_enetaddr("ethaddr", (uchar *)build_buf); |
Mike Frysinger | 62c93d9 | 2009-02-11 18:51:43 -0500 | [diff] [blame] | 290 | memcpy(tmp, build_buf, 6); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 291 | #else |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 292 | puts("## Ethernet MAC address not copied to NV RAM\n"); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 293 | #endif |
| 294 | |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 295 | /* |
| 296 | * Use bootaddr to find the location in memory that VxWorks |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 297 | * will look for the bootline string. The default value is |
| 298 | * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by |
| 299 | * VxWorks BSP. For example, on PowerPC it defaults to 0x4200. |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 300 | */ |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 301 | tmp = env_get("bootaddr"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 302 | if (!tmp) { |
| 303 | printf("## VxWorks bootline address not specified\n"); |
| 304 | } else { |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 305 | bootaddr = simple_strtoul(tmp, NULL, 16); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 306 | |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 307 | /* |
| 308 | * Check to see if the bootline is defined in the 'bootargs' |
| 309 | * parameter. If it is not defined, we may be able to |
| 310 | * construct the info. |
| 311 | */ |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 312 | bootline = env_get("bootargs"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 313 | if (bootline) { |
| 314 | memcpy((void *)bootaddr, bootline, |
| 315 | max(strlen(bootline), (size_t)255)); |
| 316 | flush_cache(bootaddr, max(strlen(bootline), |
| 317 | (size_t)255)); |
| 318 | } else { |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 319 | tmp = env_get("bootdev"); |
Ben Whitten | 192bc69 | 2015-12-30 13:05:58 +0000 | [diff] [blame] | 320 | if (tmp) { |
| 321 | strcpy(build_buf, tmp); |
| 322 | ptr = strlen(tmp); |
| 323 | } else |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 324 | printf("## VxWorks boot device not specified\n"); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 325 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 326 | tmp = env_get("bootfile"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 327 | if (tmp) |
| 328 | ptr += sprintf(build_buf + ptr, |
| 329 | "host:%s ", tmp); |
| 330 | else |
| 331 | ptr += sprintf(build_buf + ptr, |
| 332 | "host:vxWorks "); |
| 333 | |
| 334 | /* |
| 335 | * The following parameters are only needed if 'bootdev' |
| 336 | * is an ethernet device, otherwise they are optional. |
| 337 | */ |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 338 | tmp = env_get("ipaddr"); |
Bin Meng | a4092db | 2015-10-07 20:19:16 -0700 | [diff] [blame] | 339 | if (tmp) { |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 340 | ptr += sprintf(build_buf + ptr, "e=%s", tmp); |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 341 | tmp = env_get("netmask"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 342 | if (tmp) { |
Simon Glass | 723806c | 2017-08-03 12:22:15 -0600 | [diff] [blame] | 343 | u32 mask = env_get_ip("netmask").s_addr; |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 344 | ptr += sprintf(build_buf + ptr, |
| 345 | ":%08x ", ntohl(mask)); |
| 346 | } else { |
| 347 | ptr += sprintf(build_buf + ptr, " "); |
| 348 | } |
Bin Meng | a4092db | 2015-10-07 20:19:16 -0700 | [diff] [blame] | 349 | } |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 350 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 351 | tmp = env_get("serverip"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 352 | if (tmp) |
| 353 | ptr += sprintf(build_buf + ptr, "h=%s ", tmp); |
| 354 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 355 | tmp = env_get("gatewayip"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 356 | if (tmp) |
| 357 | ptr += sprintf(build_buf + ptr, "g=%s ", tmp); |
| 358 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 359 | tmp = env_get("hostname"); |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 360 | if (tmp) |
| 361 | ptr += sprintf(build_buf + ptr, "tn=%s ", tmp); |
| 362 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 363 | tmp = env_get("othbootargs"); |
Ben Whitten | 192bc69 | 2015-12-30 13:05:58 +0000 | [diff] [blame] | 364 | if (tmp) { |
| 365 | strcpy(build_buf + ptr, tmp); |
| 366 | ptr += strlen(tmp); |
| 367 | } |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 368 | |
| 369 | memcpy((void *)bootaddr, build_buf, |
| 370 | max(strlen(build_buf), (size_t)255)); |
| 371 | flush_cache(bootaddr, max(strlen(build_buf), |
| 372 | (size_t)255)); |
Bin Meng | a4092db | 2015-10-07 20:19:16 -0700 | [diff] [blame] | 373 | } |
Niklaus Giger | 29a4c24 | 2008-11-03 22:15:34 +0100 | [diff] [blame] | 374 | |
Bin Meng | 9e98b7e | 2015-10-07 20:19:17 -0700 | [diff] [blame] | 375 | printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, |
| 376 | (char *)bootaddr); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 377 | } |
| 378 | |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 379 | #ifdef CONFIG_X86 |
| 380 | /* |
Bin Meng | 2902be8 | 2018-04-11 22:02:07 -0700 | [diff] [blame] | 381 | * Get VxWorks's physical memory base address from environment, |
| 382 | * if we don't specify it in the environment, use a default one. |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 383 | */ |
Bin Meng | 2902be8 | 2018-04-11 22:02:07 -0700 | [diff] [blame] | 384 | base = env_get_hex("vx_phys_mem_base", VXWORKS_PHYS_MEM_BASE); |
Bin Meng | 4551992 | 2018-04-11 22:02:11 -0700 | [diff] [blame] | 385 | data = (struct e820_entry *)(base + E820_DATA_OFFSET); |
Bin Meng | fa5e91f | 2018-04-11 22:02:09 -0700 | [diff] [blame] | 386 | info = (struct e820_info *)(base + E820_INFO_OFFSET); |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 387 | |
Bin Meng | fa5e91f | 2018-04-11 22:02:09 -0700 | [diff] [blame] | 388 | memset(info, 0, sizeof(struct e820_info)); |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 389 | info->sign = E820_SIGNATURE; |
| 390 | info->entries = install_e820_map(E820MAX, data); |
Bin Meng | 4551992 | 2018-04-11 22:02:11 -0700 | [diff] [blame] | 391 | info->addr = (info->entries - 1) * sizeof(struct e820_entry) + |
Bin Meng | 2902be8 | 2018-04-11 22:02:07 -0700 | [diff] [blame] | 392 | E820_DATA_OFFSET; |
Bin Meng | 1351700 | 2018-04-11 22:02:08 -0700 | [diff] [blame] | 393 | |
| 394 | /* |
| 395 | * Explicitly clear the bootloader image size otherwise if memory |
| 396 | * at this offset happens to contain some garbage data, the final |
| 397 | * available memory size for the kernel is insane. |
| 398 | */ |
| 399 | *(u32 *)(base + BOOT_IMAGE_SIZE_OFFSET) = 0; |
Bin Meng | b90ff0f | 2015-10-07 20:19:18 -0700 | [diff] [blame] | 400 | #endif |
| 401 | |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 402 | /* |
| 403 | * If the data at the load address is an elf image, then |
| 404 | * treat it like an elf image. Otherwise, assume that it is a |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 405 | * binary image. |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 406 | */ |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 407 | if (valid_elf_image(addr)) |
Christian Gmeiner | 476c2fc | 2018-03-20 14:18:25 +0100 | [diff] [blame] | 408 | addr = load_elf_image_phdr(addr); |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 409 | else |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 410 | puts("## Not an ELF image, assuming binary\n"); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 411 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 412 | printf("## Starting vxWorks at 0x%08lx ...\n", addr); |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 413 | |
Reinhard Arlt | 6eee21d | 2011-11-18 09:06:52 +0000 | [diff] [blame] | 414 | dcache_disable(); |
Vasyl Vavrychuk | 3194daa | 2018-04-10 12:36:36 +0300 | [diff] [blame] | 415 | #if defined(CONFIG_ARM64) && defined(CONFIG_ARMV8_PSCI) |
| 416 | armv8_setup_psci(); |
| 417 | smp_kick_all_cpus(); |
| 418 | #endif |
| 419 | |
Bin Meng | 9aa1280 | 2015-10-07 20:19:19 -0700 | [diff] [blame] | 420 | #ifdef CONFIG_X86 |
| 421 | /* VxWorks on x86 uses stack to pass parameters */ |
| 422 | ((asmlinkage void (*)(int))addr)(0); |
| 423 | #else |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 424 | ((void (*)(int))addr)(0); |
Bin Meng | 9aa1280 | 2015-10-07 20:19:19 -0700 | [diff] [blame] | 425 | #endif |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 426 | |
Daniel Schwierzeck | 62e03d3 | 2012-09-16 06:55:05 +0000 | [diff] [blame] | 427 | puts("## vxWorks terminated\n"); |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 428 | |
wdenk | 458ded3 | 2002-09-20 10:59:08 +0000 | [diff] [blame] | 429 | return 1; |
| 430 | } |
| 431 | |
wdenk | 0d49839 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 432 | U_BOOT_CMD( |
Tom Rini | be1b867 | 2017-05-18 17:03:07 -0400 | [diff] [blame] | 433 | bootelf, CONFIG_SYS_MAXARGS, 0, do_bootelf, |
Peter Tyser | 2fb2604 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 434 | "Boot from an ELF image in memory", |
Mike Frysinger | f44a928 | 2010-10-02 15:44:53 -0400 | [diff] [blame] | 435 | "[-p|-s] [address]\n" |
| 436 | "\t- load ELF image at [address] via program headers (-p)\n" |
| 437 | "\t or via section headers (-s)" |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 438 | ); |
| 439 | |
wdenk | 0d49839 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 440 | U_BOOT_CMD( |
Bin Meng | ebca3df | 2015-10-07 20:19:13 -0700 | [diff] [blame] | 441 | bootvx, 2, 0, do_bootvx, |
Peter Tyser | 2fb2604 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 442 | "Boot vxWorks from an ELF image", |
Wolfgang Denk | a89c33d | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 443 | " [address] - load address of vxWorks ELF image." |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 444 | ); |