blob: 86e694ac69c42c314a28d5214dae9972469858a0 [file] [log] [blame]
wdenk458ded32002-09-20 10:59:08 +00001/*
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>
wdenk458ded32002-09-20 10:59:08 +000018#include <elf.h>
Bin Mengebca3df2015-10-07 20:19:13 -070019#include <net.h>
Niklaus Giger29a4c242008-11-03 22:15:34 +010020#include <vxworks.h>
Bin Mengb90ff0f2015-10-07 20:19:18 -070021#ifdef CONFIG_X86
22#include <asm/e820.h>
Bin Meng9aa12802015-10-07 20:19:19 -070023#include <linux/linkage.h>
Bin Mengb90ff0f2015-10-07 20:19:18 -070024#endif
wdenk458ded32002-09-20 10:59:08 +000025
Bin Meng9dffa522015-10-07 20:19:14 -070026/*
27 * A very simple elf loader, assumes the image is valid, returns the
28 * entry point address.
29 */
30static unsigned long load_elf_image_phdr(unsigned long addr)
31{
32 Elf32_Ehdr *ehdr; /* Elf header structure pointer */
33 Elf32_Phdr *phdr; /* Program header structure pointer */
34 int i;
35
36 ehdr = (Elf32_Ehdr *)addr;
37 phdr = (Elf32_Phdr *)(addr + ehdr->e_phoff);
38
39 /* Load each program header */
40 for (i = 0; i < ehdr->e_phnum; ++i) {
41 void *dst = (void *)(uintptr_t)phdr->p_paddr;
42 void *src = (void *)addr + phdr->p_offset;
43 debug("Loading phdr %i to 0x%p (%i bytes)\n",
44 i, dst, phdr->p_filesz);
45 if (phdr->p_filesz)
46 memcpy(dst, src, phdr->p_filesz);
47 if (phdr->p_filesz != phdr->p_memsz)
48 memset(dst + phdr->p_filesz, 0x00,
49 phdr->p_memsz - phdr->p_filesz);
50 flush_cache((unsigned long)dst, phdr->p_filesz);
51 ++phdr;
52 }
53
54 return ehdr->e_entry;
55}
56
57static unsigned long load_elf_image_shdr(unsigned long addr)
58{
59 Elf32_Ehdr *ehdr; /* Elf header structure pointer */
60 Elf32_Shdr *shdr; /* Section header structure pointer */
61 unsigned char *strtab = 0; /* String table pointer */
62 unsigned char *image; /* Binary image pointer */
63 int i; /* Loop counter */
64
65 ehdr = (Elf32_Ehdr *)addr;
66
67 /* Find the section header string table for output info */
68 shdr = (Elf32_Shdr *)(addr + ehdr->e_shoff +
69 (ehdr->e_shstrndx * sizeof(Elf32_Shdr)));
70
71 if (shdr->sh_type == SHT_STRTAB)
72 strtab = (unsigned char *)(addr + shdr->sh_offset);
73
74 /* Load each appropriate section */
75 for (i = 0; i < ehdr->e_shnum; ++i) {
76 shdr = (Elf32_Shdr *)(addr + ehdr->e_shoff +
77 (i * sizeof(Elf32_Shdr)));
78
79 if (!(shdr->sh_flags & SHF_ALLOC) ||
80 shdr->sh_addr == 0 || shdr->sh_size == 0) {
81 continue;
82 }
83
84 if (strtab) {
85 debug("%sing %s @ 0x%08lx (%ld bytes)\n",
86 (shdr->sh_type == SHT_NOBITS) ? "Clear" : "Load",
87 &strtab[shdr->sh_name],
88 (unsigned long)shdr->sh_addr,
89 (long)shdr->sh_size);
90 }
91
92 if (shdr->sh_type == SHT_NOBITS) {
93 memset((void *)(uintptr_t)shdr->sh_addr, 0,
94 shdr->sh_size);
95 } else {
96 image = (unsigned char *)addr + shdr->sh_offset;
97 memcpy((void *)(uintptr_t)shdr->sh_addr,
98 (const void *)image, shdr->sh_size);
99 }
100 flush_cache(shdr->sh_addr, shdr->sh_size);
101 }
102
103 return ehdr->e_entry;
104}
Mike Frysinger017e9b72008-04-13 19:42:18 -0400105
106/* Allow ports to override the default behavior */
Jeroen Hofstee553d8c32014-10-08 22:57:31 +0200107static unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]),
Bin Mengebca3df2015-10-07 20:19:13 -0700108 int argc, char * const argv[])
Mike Frysinger1f1d88d2008-01-29 18:21:05 -0500109{
Mike Frysinger017e9b72008-04-13 19:42:18 -0400110 unsigned long ret;
111
Mike Frysinger1f1d88d2008-01-29 18:21:05 -0500112 /*
113 * QNX images require the data cache is disabled.
114 * Data cache is already flushed, so just turn it off.
115 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000116 int dcache = dcache_status();
Mike Frysinger017e9b72008-04-13 19:42:18 -0400117 if (dcache)
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000118 dcache_disable();
Mike Frysinger1f1d88d2008-01-29 18:21:05 -0500119
Mike Frysinger017e9b72008-04-13 19:42:18 -0400120 /*
121 * pass address parameter as argv[0] (aka command name),
122 * and all remaining args
123 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000124 ret = entry(argc, argv);
Mike Frysinger1f1d88d2008-01-29 18:21:05 -0500125
Mike Frysinger017e9b72008-04-13 19:42:18 -0400126 if (dcache)
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000127 dcache_enable();
Mike Frysinger017e9b72008-04-13 19:42:18 -0400128
129 return ret;
130}
wdenk458ded32002-09-20 10:59:08 +0000131
Bin Mengebca3df2015-10-07 20:19:13 -0700132/*
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000133 * Determine if a valid ELF image exists at the given memory location.
Bin Mengebca3df2015-10-07 20:19:13 -0700134 * First look at the ELF header magic field, then make sure that it is
135 * executable.
136 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000137int valid_elf_image(unsigned long addr)
138{
Bin Mengebca3df2015-10-07 20:19:13 -0700139 Elf32_Ehdr *ehdr; /* Elf header structure pointer */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000140
Bin Mengebca3df2015-10-07 20:19:13 -0700141 ehdr = (Elf32_Ehdr *)addr;
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000142
143 if (!IS_ELF(*ehdr)) {
144 printf("## No elf image at address 0x%08lx\n", addr);
145 return 0;
146 }
147
148 if (ehdr->e_type != ET_EXEC) {
149 printf("## Not a 32-bit elf image at address 0x%08lx\n", addr);
150 return 0;
151 }
152
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000153 return 1;
154}
155
Bin Mengebca3df2015-10-07 20:19:13 -0700156/* Interpreter command to boot an arbitrary ELF image from memory */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000157int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk458ded32002-09-20 10:59:08 +0000158{
Bin Mengebca3df2015-10-07 20:19:13 -0700159 unsigned long addr; /* Address of the ELF image */
160 unsigned long rc; /* Return value from user code */
Mike Frysingerf44a9282010-10-02 15:44:53 -0400161 char *sload, *saddr;
Siva Durga Prasad Paladugu44c8fd32015-03-09 12:46:47 +0100162 const char *ep = getenv("autostart");
wdenk458ded32002-09-20 10:59:08 +0000163
wdenk458ded32002-09-20 10:59:08 +0000164 int rcode = 0;
165
Mike Frysingerf44a9282010-10-02 15:44:53 -0400166 sload = saddr = NULL;
167 if (argc == 3) {
168 sload = argv[1];
169 saddr = argv[2];
170 } else if (argc == 2) {
171 if (argv[1][0] == '-')
172 sload = argv[1];
173 else
174 saddr = argv[1];
175 }
176
177 if (saddr)
178 addr = simple_strtoul(saddr, NULL, 16);
wdenk458ded32002-09-20 10:59:08 +0000179 else
Mike Frysingerf44a9282010-10-02 15:44:53 -0400180 addr = load_addr;
wdenk458ded32002-09-20 10:59:08 +0000181
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000182 if (!valid_elf_image(addr))
wdenk458ded32002-09-20 10:59:08 +0000183 return 1;
184
Mike Frysingerf44a9282010-10-02 15:44:53 -0400185 if (sload && sload[1] == 'p')
186 addr = load_elf_image_phdr(addr);
187 else
188 addr = load_elf_image_shdr(addr);
wdenk458ded32002-09-20 10:59:08 +0000189
Siva Durga Prasad Paladugu44c8fd32015-03-09 12:46:47 +0100190 if (ep && !strcmp(ep, "no"))
191 return rcode;
192
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000193 printf("## Starting application at 0x%08lx ...\n", addr);
wdenk458ded32002-09-20 10:59:08 +0000194
wdenk458ded32002-09-20 10:59:08 +0000195 /*
196 * pass address parameter as argv[0] (aka command name),
197 * and all remaining args
198 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000199 rc = do_bootelf_exec((void *)addr, argc - 1, argv + 1);
wdenk458ded32002-09-20 10:59:08 +0000200 if (rc != 0)
201 rcode = 1;
202
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000203 printf("## Application terminated, rc = 0x%lx\n", rc);
Bin Mengebca3df2015-10-07 20:19:13 -0700204
wdenk458ded32002-09-20 10:59:08 +0000205 return rcode;
206}
207
Bin Mengebca3df2015-10-07 20:19:13 -0700208/*
wdenk458ded32002-09-20 10:59:08 +0000209 * Interpreter command to boot VxWorks from a memory image. The image can
210 * be either an ELF image or a raw binary. Will attempt to setup the
211 * bootline and other parameters correctly.
Bin Mengebca3df2015-10-07 20:19:13 -0700212 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000213int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk458ded32002-09-20 10:59:08 +0000214{
Bin Mengebca3df2015-10-07 20:19:13 -0700215 unsigned long addr; /* Address of image */
216 unsigned long bootaddr; /* Address to put the bootline */
217 char *bootline; /* Text of the bootline */
218 char *tmp; /* Temporary char pointer */
219 char build_buf[128]; /* Buffer for building the bootline */
Bin Meng7f0c3c52015-10-07 20:19:15 -0700220 int ptr = 0;
Bin Mengb90ff0f2015-10-07 20:19:18 -0700221#ifdef CONFIG_X86
222 struct e820info *info;
223 struct e820entry *data;
224#endif
wdenk458ded32002-09-20 10:59:08 +0000225
Bin Mengebca3df2015-10-07 20:19:13 -0700226 /*
wdenk458ded32002-09-20 10:59:08 +0000227 * Check the loadaddr variable.
228 * If we don't know where the image is then we're done.
229 */
Stany MARCEL07a1a0c2013-11-27 14:48:43 +0100230 if (argc < 2)
Stefan Roese1bdd4682006-11-29 12:53:15 +0100231 addr = load_addr;
232 else
Stany MARCEL07a1a0c2013-11-27 14:48:43 +0100233 addr = simple_strtoul(argv[1], NULL, 16);
wdenk458ded32002-09-20 10:59:08 +0000234
Jon Loeligerbaa26db2007-07-08 17:51:39 -0500235#if defined(CONFIG_CMD_NET)
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000236 /*
Bin Mengebca3df2015-10-07 20:19:13 -0700237 * Check to see if we need to tftp the image ourselves
238 * before starting
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000239 */
Stany MARCEL07a1a0c2013-11-27 14:48:43 +0100240 if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) {
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500241 if (net_loop(TFTPGET) <= 0)
wdenk458ded32002-09-20 10:59:08 +0000242 return 1;
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000243 printf("Automatic boot of VxWorks image at address 0x%08lx ...\n",
244 addr);
wdenk458ded32002-09-20 10:59:08 +0000245 }
246#endif
247
Bin Mengebca3df2015-10-07 20:19:13 -0700248 /*
249 * This should equate to
250 * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET
wdenk458ded32002-09-20 10:59:08 +0000251 * from the VxWorks BSP header files.
252 * This will vary from board to board
253 */
Stefan Roesec157d8e2005-08-01 16:41:48 +0200254#if defined(CONFIG_WALNUT)
Bin Mengebca3df2015-10-07 20:19:13 -0700255 tmp = (char *)CONFIG_SYS_NVRAM_BASE_ADDR + 0x500;
Heiko Schocher76756e42009-03-26 07:33:59 +0100256 eth_getenv_enetaddr("ethaddr", (uchar *)build_buf);
Mike Frysinger62c93d92009-02-11 18:51:43 -0500257 memcpy(tmp, &build_buf[3], 3);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200258#elif defined(CONFIG_SYS_VXWORKS_MAC_PTR)
Bin Mengebca3df2015-10-07 20:19:13 -0700259 tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR;
Heiko Schocher76756e42009-03-26 07:33:59 +0100260 eth_getenv_enetaddr("ethaddr", (uchar *)build_buf);
Mike Frysinger62c93d92009-02-11 18:51:43 -0500261 memcpy(tmp, build_buf, 6);
wdenk458ded32002-09-20 10:59:08 +0000262#else
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000263 puts("## Ethernet MAC address not copied to NV RAM\n");
wdenk458ded32002-09-20 10:59:08 +0000264#endif
265
wdenk8bde7f72003-06-27 21:31:46 +0000266 /*
267 * Use bootaddr to find the location in memory that VxWorks
Bin Meng9e98b7e2015-10-07 20:19:17 -0700268 * will look for the bootline string. The default value is
269 * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by
270 * VxWorks BSP. For example, on PowerPC it defaults to 0x4200.
wdenk458ded32002-09-20 10:59:08 +0000271 */
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000272 tmp = getenv("bootaddr");
Bin Meng9e98b7e2015-10-07 20:19:17 -0700273 if (!tmp) {
274 printf("## VxWorks bootline address not specified\n");
275 } else {
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000276 bootaddr = simple_strtoul(tmp, NULL, 16);
wdenk458ded32002-09-20 10:59:08 +0000277
Bin Meng9e98b7e2015-10-07 20:19:17 -0700278 /*
279 * Check to see if the bootline is defined in the 'bootargs'
280 * parameter. If it is not defined, we may be able to
281 * construct the info.
282 */
283 bootline = getenv("bootargs");
284 if (bootline) {
285 memcpy((void *)bootaddr, bootline,
286 max(strlen(bootline), (size_t)255));
287 flush_cache(bootaddr, max(strlen(bootline),
288 (size_t)255));
289 } else {
290 tmp = getenv("bootdev");
291 if (tmp)
292 ptr = sprintf(build_buf, tmp);
293 else
294 printf("## VxWorks boot device not specified\n");
wdenk458ded32002-09-20 10:59:08 +0000295
Bin Meng9e98b7e2015-10-07 20:19:17 -0700296 tmp = getenv("bootfile");
297 if (tmp)
298 ptr += sprintf(build_buf + ptr,
299 "host:%s ", tmp);
300 else
301 ptr += sprintf(build_buf + ptr,
302 "host:vxWorks ");
303
304 /*
305 * The following parameters are only needed if 'bootdev'
306 * is an ethernet device, otherwise they are optional.
307 */
308 tmp = getenv("ipaddr");
Bin Menga4092db2015-10-07 20:19:16 -0700309 if (tmp) {
Bin Meng9e98b7e2015-10-07 20:19:17 -0700310 ptr += sprintf(build_buf + ptr, "e=%s", tmp);
311 tmp = getenv("netmask");
312 if (tmp) {
313 u32 mask = getenv_ip("netmask").s_addr;
314 ptr += sprintf(build_buf + ptr,
315 ":%08x ", ntohl(mask));
316 } else {
317 ptr += sprintf(build_buf + ptr, " ");
318 }
Bin Menga4092db2015-10-07 20:19:16 -0700319 }
Bin Meng9e98b7e2015-10-07 20:19:17 -0700320
321 tmp = getenv("serverip");
322 if (tmp)
323 ptr += sprintf(build_buf + ptr, "h=%s ", tmp);
324
325 tmp = getenv("gatewayip");
326 if (tmp)
327 ptr += sprintf(build_buf + ptr, "g=%s ", tmp);
328
329 tmp = getenv("hostname");
330 if (tmp)
331 ptr += sprintf(build_buf + ptr, "tn=%s ", tmp);
332
333 tmp = getenv("othbootargs");
334 if (tmp)
335 ptr += sprintf(build_buf + ptr, tmp);
336
337 memcpy((void *)bootaddr, build_buf,
338 max(strlen(build_buf), (size_t)255));
339 flush_cache(bootaddr, max(strlen(build_buf),
340 (size_t)255));
Bin Menga4092db2015-10-07 20:19:16 -0700341 }
Niklaus Giger29a4c242008-11-03 22:15:34 +0100342
Bin Meng9e98b7e2015-10-07 20:19:17 -0700343 printf("## Using bootline (@ 0x%lx): %s\n", bootaddr,
344 (char *)bootaddr);
wdenk458ded32002-09-20 10:59:08 +0000345 }
346
Bin Mengb90ff0f2015-10-07 20:19:18 -0700347#ifdef CONFIG_X86
348 /*
349 * Since E820 information is critical to the kernel, if we don't
350 * specify these in the environments, use a default one.
351 */
352 tmp = getenv("e820data");
353 if (tmp)
354 data = (struct e820entry *)simple_strtoul(tmp, NULL, 16);
355 else
356 data = (struct e820entry *)VXWORKS_E820_DATA_ADDR;
357 tmp = getenv("e820info");
358 if (tmp)
359 info = (struct e820info *)simple_strtoul(tmp, NULL, 16);
360 else
361 info = (struct e820info *)VXWORKS_E820_INFO_ADDR;
362
363 memset(info, 0, sizeof(struct e820info));
364 info->sign = E820_SIGNATURE;
365 info->entries = install_e820_map(E820MAX, data);
366 info->addr = (info->entries - 1) * sizeof(struct e820entry) +
367 VXWORKS_E820_DATA_ADDR;
368#endif
369
wdenk8bde7f72003-06-27 21:31:46 +0000370 /*
371 * If the data at the load address is an elf image, then
372 * treat it like an elf image. Otherwise, assume that it is a
Bin Mengebca3df2015-10-07 20:19:13 -0700373 * binary image.
wdenk458ded32002-09-20 10:59:08 +0000374 */
Bin Mengebca3df2015-10-07 20:19:13 -0700375 if (valid_elf_image(addr))
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000376 addr = load_elf_image_shdr(addr);
Bin Mengebca3df2015-10-07 20:19:13 -0700377 else
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000378 puts("## Not an ELF image, assuming binary\n");
wdenk458ded32002-09-20 10:59:08 +0000379
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000380 printf("## Starting vxWorks at 0x%08lx ...\n", addr);
wdenk458ded32002-09-20 10:59:08 +0000381
Reinhard Arlt6eee21d2011-11-18 09:06:52 +0000382 dcache_disable();
Bin Meng9aa12802015-10-07 20:19:19 -0700383#ifdef CONFIG_X86
384 /* VxWorks on x86 uses stack to pass parameters */
385 ((asmlinkage void (*)(int))addr)(0);
386#else
Bin Mengebca3df2015-10-07 20:19:13 -0700387 ((void (*)(int))addr)(0);
Bin Meng9aa12802015-10-07 20:19:19 -0700388#endif
wdenk458ded32002-09-20 10:59:08 +0000389
Daniel Schwierzeck62e03d32012-09-16 06:55:05 +0000390 puts("## vxWorks terminated\n");
Bin Mengebca3df2015-10-07 20:19:13 -0700391
wdenk458ded32002-09-20 10:59:08 +0000392 return 1;
393}
394
wdenk0d498392003-07-01 21:06:45 +0000395U_BOOT_CMD(
Bin Mengebca3df2015-10-07 20:19:13 -0700396 bootelf, 3, 0, do_bootelf,
Peter Tyser2fb26042009-01-27 18:03:12 -0600397 "Boot from an ELF image in memory",
Mike Frysingerf44a9282010-10-02 15:44:53 -0400398 "[-p|-s] [address]\n"
399 "\t- load ELF image at [address] via program headers (-p)\n"
400 "\t or via section headers (-s)"
wdenk8bde7f72003-06-27 21:31:46 +0000401);
402
wdenk0d498392003-07-01 21:06:45 +0000403U_BOOT_CMD(
Bin Mengebca3df2015-10-07 20:19:13 -0700404 bootvx, 2, 0, do_bootvx,
Peter Tyser2fb26042009-01-27 18:03:12 -0600405 "Boot vxWorks from an ELF image",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200406 " [address] - load address of vxWorks ELF image."
wdenk8bde7f72003-06-27 21:31:46 +0000407);