]>
Commit | Line | Data |
---|---|---|
458ded34 WD |
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> | |
18 | #include <linux/ctype.h> | |
19 | #include <net.h> | |
458ded34 | 20 | #include <elf.h> |
29a4c24d | 21 | #include <vxworks.h> |
458ded34 | 22 | |
6d0f6bcf | 23 | #if defined(CONFIG_WALNUT) || defined(CONFIG_SYS_VXWORKS_MAC_PTR) |
d87080b7 WD |
24 | DECLARE_GLOBAL_DATA_PTR; |
25 | #endif | |
458ded34 | 26 | |
f44a928e MF |
27 | static unsigned long load_elf_image_phdr(unsigned long addr); |
28 | static unsigned long load_elf_image_shdr(unsigned long addr); | |
017e9b79 MF |
29 | |
30 | /* Allow ports to override the default behavior */ | |
31 | __attribute__((weak)) | |
62e03d33 | 32 | unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]), |
54841ab5 | 33 | int argc, char * const argv[]) |
1f1d88dd | 34 | { |
017e9b79 MF |
35 | unsigned long ret; |
36 | ||
1f1d88dd MF |
37 | /* |
38 | * QNX images require the data cache is disabled. | |
39 | * Data cache is already flushed, so just turn it off. | |
40 | */ | |
62e03d33 | 41 | int dcache = dcache_status(); |
017e9b79 | 42 | if (dcache) |
62e03d33 | 43 | dcache_disable(); |
1f1d88dd | 44 | |
017e9b79 MF |
45 | /* |
46 | * pass address parameter as argv[0] (aka command name), | |
47 | * and all remaining args | |
48 | */ | |
62e03d33 | 49 | ret = entry(argc, argv); |
1f1d88dd | 50 | |
017e9b79 | 51 | if (dcache) |
62e03d33 | 52 | dcache_enable(); |
017e9b79 MF |
53 | |
54 | return ret; | |
55 | } | |
458ded34 | 56 | |
62e03d33 DS |
57 | /* ====================================================================== |
58 | * Determine if a valid ELF image exists at the given memory location. | |
59 | * First looks at the ELF header magic field, the makes sure that it is | |
60 | * executable and makes sure that it is for a PowerPC. | |
61 | * ====================================================================== */ | |
62 | int valid_elf_image(unsigned long addr) | |
63 | { | |
64 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ | |
65 | ||
66 | /* -------------------------------------------------- */ | |
67 | ||
68 | ehdr = (Elf32_Ehdr *) addr; | |
69 | ||
70 | if (!IS_ELF(*ehdr)) { | |
71 | printf("## No elf image at address 0x%08lx\n", addr); | |
72 | return 0; | |
73 | } | |
74 | ||
75 | if (ehdr->e_type != ET_EXEC) { | |
76 | printf("## Not a 32-bit elf image at address 0x%08lx\n", addr); | |
77 | return 0; | |
78 | } | |
79 | ||
80 | #if 0 | |
81 | if (ehdr->e_machine != EM_PPC) { | |
82 | printf("## Not a PowerPC elf image at address 0x%08lx\n", addr); | |
83 | return 0; | |
84 | } | |
85 | #endif | |
86 | ||
87 | return 1; | |
88 | } | |
89 | ||
458ded34 WD |
90 | /* ====================================================================== |
91 | * Interpreter command to boot an arbitrary ELF image from memory. | |
92 | * ====================================================================== */ | |
62e03d33 | 93 | int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
458ded34 WD |
94 | { |
95 | unsigned long addr; /* Address of the ELF image */ | |
96 | unsigned long rc; /* Return value from user code */ | |
f44a928e | 97 | char *sload, *saddr; |
458ded34 WD |
98 | |
99 | /* -------------------------------------------------- */ | |
100 | int rcode = 0; | |
101 | ||
f44a928e MF |
102 | sload = saddr = NULL; |
103 | if (argc == 3) { | |
104 | sload = argv[1]; | |
105 | saddr = argv[2]; | |
106 | } else if (argc == 2) { | |
107 | if (argv[1][0] == '-') | |
108 | sload = argv[1]; | |
109 | else | |
110 | saddr = argv[1]; | |
111 | } | |
112 | ||
113 | if (saddr) | |
114 | addr = simple_strtoul(saddr, NULL, 16); | |
458ded34 | 115 | else |
f44a928e | 116 | addr = load_addr; |
458ded34 | 117 | |
62e03d33 | 118 | if (!valid_elf_image(addr)) |
458ded34 WD |
119 | return 1; |
120 | ||
f44a928e MF |
121 | if (sload && sload[1] == 'p') |
122 | addr = load_elf_image_phdr(addr); | |
123 | else | |
124 | addr = load_elf_image_shdr(addr); | |
458ded34 | 125 | |
62e03d33 | 126 | printf("## Starting application at 0x%08lx ...\n", addr); |
458ded34 | 127 | |
458ded34 WD |
128 | /* |
129 | * pass address parameter as argv[0] (aka command name), | |
130 | * and all remaining args | |
131 | */ | |
62e03d33 | 132 | rc = do_bootelf_exec((void *)addr, argc - 1, argv + 1); |
458ded34 WD |
133 | if (rc != 0) |
134 | rcode = 1; | |
135 | ||
62e03d33 | 136 | printf("## Application terminated, rc = 0x%lx\n", rc); |
458ded34 WD |
137 | return rcode; |
138 | } | |
139 | ||
140 | /* ====================================================================== | |
141 | * Interpreter command to boot VxWorks from a memory image. The image can | |
142 | * be either an ELF image or a raw binary. Will attempt to setup the | |
143 | * bootline and other parameters correctly. | |
144 | * ====================================================================== */ | |
62e03d33 | 145 | int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
458ded34 | 146 | { |
458ded34 | 147 | unsigned long addr; /* Address of image */ |
62e03d33 | 148 | unsigned long bootaddr; /* Address to put the bootline */ |
458ded34 WD |
149 | char *bootline; /* Text of the bootline */ |
150 | char *tmp; /* Temporary char pointer */ | |
29a4c24d | 151 | char build_buf[128]; /* Buffer for building the bootline */ |
458ded34 | 152 | |
29a4c24d NG |
153 | /* --------------------------------------------------- |
154 | * | |
458ded34 WD |
155 | * Check the loadaddr variable. |
156 | * If we don't know where the image is then we're done. | |
157 | */ | |
158 | ||
1bdd4683 SR |
159 | if (argc < 2) |
160 | addr = load_addr; | |
161 | else | |
62e03d33 | 162 | addr = simple_strtoul(argv[1], NULL, 16); |
458ded34 | 163 | |
baa26db4 | 164 | #if defined(CONFIG_CMD_NET) |
62e03d33 DS |
165 | /* |
166 | * Check to see if we need to tftp the image ourselves before starting | |
167 | */ | |
168 | if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) { | |
e4bf0c5c | 169 | if (NetLoop(TFTPGET) <= 0) |
458ded34 | 170 | return 1; |
62e03d33 DS |
171 | printf("Automatic boot of VxWorks image at address 0x%08lx ...\n", |
172 | addr); | |
458ded34 WD |
173 | } |
174 | #endif | |
175 | ||
176 | /* This should equate | |
177 | * to NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET | |
178 | * from the VxWorks BSP header files. | |
179 | * This will vary from board to board | |
180 | */ | |
181 | ||
c157d8e2 | 182 | #if defined(CONFIG_WALNUT) |
6d0f6bcf | 183 | tmp = (char *) CONFIG_SYS_NVRAM_BASE_ADDR + 0x500; |
76756e41 | 184 | eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); |
62c93d92 | 185 | memcpy(tmp, &build_buf[3], 3); |
6d0f6bcf JCPV |
186 | #elif defined(CONFIG_SYS_VXWORKS_MAC_PTR) |
187 | tmp = (char *) CONFIG_SYS_VXWORKS_MAC_PTR; | |
76756e41 | 188 | eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); |
62c93d92 | 189 | memcpy(tmp, build_buf, 6); |
458ded34 | 190 | #else |
62e03d33 | 191 | puts("## Ethernet MAC address not copied to NV RAM\n"); |
458ded34 WD |
192 | #endif |
193 | ||
8bde7f77 WD |
194 | /* |
195 | * Use bootaddr to find the location in memory that VxWorks | |
196 | * will look for the bootline string. The default value for | |
197 | * PowerPC is LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET which | |
198 | * defaults to 0x4200 | |
458ded34 | 199 | */ |
62e03d33 | 200 | tmp = getenv("bootaddr"); |
1b3e0b19 | 201 | if (!tmp) |
29a4c24d | 202 | bootaddr = CONFIG_SYS_VXWORKS_BOOT_ADDR; |
458ded34 | 203 | else |
62e03d33 | 204 | bootaddr = simple_strtoul(tmp, NULL, 16); |
458ded34 | 205 | |
8bde7f77 WD |
206 | /* |
207 | * Check to see if the bootline is defined in the 'bootargs' | |
208 | * parameter. If it is not defined, we may be able to | |
209 | * construct the info | |
458ded34 | 210 | */ |
62e03d33 DS |
211 | bootline = getenv("bootargs"); |
212 | if (bootline) { | |
213 | memcpy((void *) bootaddr, bootline, | |
214 | max(strlen(bootline), 255)); | |
215 | flush_cache(bootaddr, max(strlen(bootline), 255)); | |
458ded34 | 216 | } else { |
62e03d33 DS |
217 | sprintf(build_buf, CONFIG_SYS_VXWORKS_BOOT_DEVICE); |
218 | tmp = getenv("bootfile"); | |
219 | if (tmp) | |
220 | sprintf(&build_buf[strlen(build_buf)], | |
29a4c24d | 221 | "%s:%s ", CONFIG_SYS_VXWORKS_SERVERNAME, tmp); |
62e03d33 DS |
222 | else |
223 | sprintf(&build_buf[strlen(build_buf)], | |
29a4c24d | 224 | "%s:file ", CONFIG_SYS_VXWORKS_SERVERNAME); |
458ded34 | 225 | |
62e03d33 DS |
226 | tmp = getenv("ipaddr"); |
227 | if (tmp) | |
228 | sprintf(&build_buf[strlen(build_buf)], "e=%s ", tmp); | |
458ded34 | 229 | |
62e03d33 DS |
230 | tmp = getenv("serverip"); |
231 | if (tmp) | |
232 | sprintf(&build_buf[strlen(build_buf)], "h=%s ", tmp); | |
233 | ||
234 | tmp = getenv("hostname"); | |
235 | if (tmp) | |
236 | sprintf(&build_buf[strlen(build_buf)], "tn=%s ", tmp); | |
458ded34 | 237 | |
29a4c24d | 238 | #ifdef CONFIG_SYS_VXWORKS_ADD_PARAMS |
62e03d33 | 239 | sprintf(&build_buf[strlen(build_buf)], |
29a4c24d | 240 | CONFIG_SYS_VXWORKS_ADD_PARAMS); |
458ded34 | 241 | #endif |
29a4c24d | 242 | |
62e03d33 DS |
243 | memcpy((void *) bootaddr, build_buf, |
244 | max(strlen(build_buf), 255)); | |
245 | flush_cache(bootaddr, max(strlen(build_buf), 255)); | |
458ded34 WD |
246 | } |
247 | ||
8bde7f77 WD |
248 | /* |
249 | * If the data at the load address is an elf image, then | |
250 | * treat it like an elf image. Otherwise, assume that it is a | |
251 | * binary image | |
458ded34 WD |
252 | */ |
253 | ||
62e03d33 DS |
254 | if (valid_elf_image(addr)) { |
255 | addr = load_elf_image_shdr(addr); | |
458ded34 | 256 | } else { |
62e03d33 | 257 | puts("## Not an ELF image, assuming binary\n"); |
458ded34 WD |
258 | /* leave addr as load_addr */ |
259 | } | |
260 | ||
62e03d33 | 261 | printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, |
458ded34 | 262 | (char *) bootaddr); |
62e03d33 | 263 | printf("## Starting vxWorks at 0x%08lx ...\n", addr); |
458ded34 | 264 | |
6eee21da RA |
265 | dcache_disable(); |
266 | ((void (*)(int)) addr) (0); | |
458ded34 | 267 | |
62e03d33 | 268 | puts("## vxWorks terminated\n"); |
458ded34 WD |
269 | return 1; |
270 | } | |
271 | ||
458ded34 WD |
272 | /* ====================================================================== |
273 | * A very simple elf loader, assumes the image is valid, returns the | |
274 | * entry point address. | |
275 | * ====================================================================== */ | |
f44a928e MF |
276 | static unsigned long load_elf_image_phdr(unsigned long addr) |
277 | { | |
278 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ | |
279 | Elf32_Phdr *phdr; /* Program header structure pointer */ | |
280 | int i; | |
281 | ||
282 | ehdr = (Elf32_Ehdr *) addr; | |
283 | phdr = (Elf32_Phdr *) (addr + ehdr->e_phoff); | |
284 | ||
285 | /* Load each program header */ | |
286 | for (i = 0; i < ehdr->e_phnum; ++i) { | |
b0d60a98 | 287 | void *dst = (void *)(uintptr_t) phdr->p_paddr; |
f44a928e MF |
288 | void *src = (void *) addr + phdr->p_offset; |
289 | debug("Loading phdr %i to 0x%p (%i bytes)\n", | |
290 | i, dst, phdr->p_filesz); | |
291 | if (phdr->p_filesz) | |
292 | memcpy(dst, src, phdr->p_filesz); | |
293 | if (phdr->p_filesz != phdr->p_memsz) | |
62e03d33 DS |
294 | memset(dst + phdr->p_filesz, 0x00, |
295 | phdr->p_memsz - phdr->p_filesz); | |
f44a928e MF |
296 | flush_cache((unsigned long)dst, phdr->p_filesz); |
297 | ++phdr; | |
298 | } | |
299 | ||
300 | return ehdr->e_entry; | |
301 | } | |
302 | ||
303 | static unsigned long load_elf_image_shdr(unsigned long addr) | |
458ded34 WD |
304 | { |
305 | Elf32_Ehdr *ehdr; /* Elf header structure pointer */ | |
306 | Elf32_Shdr *shdr; /* Section header structure pointer */ | |
307 | unsigned char *strtab = 0; /* String table pointer */ | |
308 | unsigned char *image; /* Binary image pointer */ | |
309 | int i; /* Loop counter */ | |
310 | ||
311 | /* -------------------------------------------------- */ | |
312 | ||
313 | ehdr = (Elf32_Ehdr *) addr; | |
314 | ||
315 | /* Find the section header string table for output info */ | |
316 | shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff + | |
62e03d33 | 317 | (ehdr->e_shstrndx * sizeof(Elf32_Shdr))); |
458ded34 WD |
318 | |
319 | if (shdr->sh_type == SHT_STRTAB) | |
320 | strtab = (unsigned char *) (addr + shdr->sh_offset); | |
321 | ||
322 | /* Load each appropriate section */ | |
323 | for (i = 0; i < ehdr->e_shnum; ++i) { | |
324 | shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff + | |
62e03d33 | 325 | (i * sizeof(Elf32_Shdr))); |
458ded34 WD |
326 | |
327 | if (!(shdr->sh_flags & SHF_ALLOC) | |
328 | || shdr->sh_addr == 0 || shdr->sh_size == 0) { | |
329 | continue; | |
330 | } | |
331 | ||
332 | if (strtab) { | |
3c972849 | 333 | debug("%sing %s @ 0x%08lx (%ld bytes)\n", |
458ded34 WD |
334 | (shdr->sh_type == SHT_NOBITS) ? |
335 | "Clear" : "Load", | |
336 | &strtab[shdr->sh_name], | |
337 | (unsigned long) shdr->sh_addr, | |
338 | (long) shdr->sh_size); | |
339 | } | |
340 | ||
341 | if (shdr->sh_type == SHT_NOBITS) { | |
b0d60a98 DS |
342 | memset((void *)(uintptr_t) shdr->sh_addr, 0, |
343 | shdr->sh_size); | |
458ded34 WD |
344 | } else { |
345 | image = (unsigned char *) addr + shdr->sh_offset; | |
b0d60a98 | 346 | memcpy((void *)(uintptr_t) shdr->sh_addr, |
458ded34 WD |
347 | (const void *) image, |
348 | shdr->sh_size); | |
349 | } | |
62e03d33 | 350 | flush_cache(shdr->sh_addr, shdr->sh_size); |
458ded34 WD |
351 | } |
352 | ||
353 | return ehdr->e_entry; | |
354 | } | |
355 | ||
356 | /* ====================================================================== */ | |
0d498393 | 357 | U_BOOT_CMD( |
f44a928e | 358 | bootelf, 3, 0, do_bootelf, |
2fb2604d | 359 | "Boot from an ELF image in memory", |
f44a928e MF |
360 | "[-p|-s] [address]\n" |
361 | "\t- load ELF image at [address] via program headers (-p)\n" | |
362 | "\t or via section headers (-s)" | |
8bde7f77 WD |
363 | ); |
364 | ||
0d498393 WD |
365 | U_BOOT_CMD( |
366 | bootvx, 2, 0, do_bootvx, | |
2fb2604d | 367 | "Boot vxWorks from an ELF image", |
a89c33db | 368 | " [address] - load address of vxWorks ELF image." |
8bde7f77 | 369 | ); |