xref: /openbmc/u-boot/cmd/elf.c (revision 3aa4b703b483f165dd2eb5c3324b44b60fbb1672)
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 <elf.h>
19  #include <net.h>
20  #include <vxworks.h>
21  #ifdef CONFIG_X86
22  #include <asm/e820.h>
23  #include <linux/linkage.h>
24  #endif
25  
26  /*
27   * A very simple elf loader, assumes the image is valid, returns the
28   * entry point address.
29   */
30  static 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  
57  static 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  }
105  
106  /* Allow ports to override the default behavior */
107  static unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]),
108  				     int argc, char * const argv[])
109  {
110  	unsigned long ret;
111  
112  	/*
113  	 * pass address parameter as argv[0] (aka command name),
114  	 * and all remaining args
115  	 */
116  	ret = entry(argc, argv);
117  
118  	return ret;
119  }
120  
121  /*
122   * Determine if a valid ELF image exists at the given memory location.
123   * First look at the ELF header magic field, then make sure that it is
124   * executable.
125   */
126  int valid_elf_image(unsigned long addr)
127  {
128  	Elf32_Ehdr *ehdr; /* Elf header structure pointer */
129  
130  	ehdr = (Elf32_Ehdr *)addr;
131  
132  	if (!IS_ELF(*ehdr)) {
133  		printf("## No elf image at address 0x%08lx\n", addr);
134  		return 0;
135  	}
136  
137  	if (ehdr->e_type != ET_EXEC) {
138  		printf("## Not a 32-bit elf image at address 0x%08lx\n", addr);
139  		return 0;
140  	}
141  
142  	return 1;
143  }
144  
145  /* Interpreter command to boot an arbitrary ELF image from memory */
146  int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
147  {
148  	unsigned long addr; /* Address of the ELF image */
149  	unsigned long rc; /* Return value from user code */
150  	char *sload = NULL;
151  	const char *ep = env_get("autostart");
152  	int rcode = 0;
153  
154  	/* Consume 'bootelf' */
155  	argc--; argv++;
156  
157  	/* Check for flag. */
158  	if (argc >= 1 && (argv[0][0] == '-' && \
159  				(argv[0][1] == 'p' || argv[0][1] == 's'))) {
160  		sload = argv[0];
161  		/* Consume flag. */
162  		argc--; argv++;
163  	}
164  	/* Check for address. */
165  	if (argc >= 1 && strict_strtoul(argv[0], 16, &addr) != -EINVAL) {
166  		/* Consume address */
167  		argc--; argv++;
168  	} else
169  		addr = load_addr;
170  
171  	if (!valid_elf_image(addr))
172  		return 1;
173  
174  	if (sload && sload[1] == 'p')
175  		addr = load_elf_image_phdr(addr);
176  	else
177  		addr = load_elf_image_shdr(addr);
178  
179  	if (ep && !strcmp(ep, "no"))
180  		return rcode;
181  
182  	printf("## Starting application at 0x%08lx ...\n", addr);
183  
184  	/*
185  	 * pass address parameter as argv[0] (aka command name),
186  	 * and all remaining args
187  	 */
188  	rc = do_bootelf_exec((void *)addr, argc, argv);
189  	if (rc != 0)
190  		rcode = 1;
191  
192  	printf("## Application terminated, rc = 0x%lx\n", rc);
193  
194  	return rcode;
195  }
196  
197  /*
198   * Interpreter command to boot VxWorks from a memory image.  The image can
199   * be either an ELF image or a raw binary.  Will attempt to setup the
200   * bootline and other parameters correctly.
201   */
202  int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
203  {
204  	unsigned long addr; /* Address of image */
205  	unsigned long bootaddr; /* Address to put the bootline */
206  	char *bootline; /* Text of the bootline */
207  	char *tmp; /* Temporary char pointer */
208  	char build_buf[128]; /* Buffer for building the bootline */
209  	int ptr = 0;
210  #ifdef CONFIG_X86
211  	struct e820info *info;
212  	struct e820entry *data;
213  #endif
214  
215  	/*
216  	 * Check the loadaddr variable.
217  	 * If we don't know where the image is then we're done.
218  	 */
219  	if (argc < 2)
220  		addr = load_addr;
221  	else
222  		addr = simple_strtoul(argv[1], NULL, 16);
223  
224  #if defined(CONFIG_CMD_NET)
225  	/*
226  	 * Check to see if we need to tftp the image ourselves
227  	 * before starting
228  	 */
229  	if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) {
230  		if (net_loop(TFTPGET) <= 0)
231  			return 1;
232  		printf("Automatic boot of VxWorks image at address 0x%08lx ...\n",
233  			addr);
234  	}
235  #endif
236  
237  	/*
238  	 * This should equate to
239  	 * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET
240  	 * from the VxWorks BSP header files.
241  	 * This will vary from board to board
242  	 */
243  #if defined(CONFIG_WALNUT)
244  	tmp = (char *)CONFIG_SYS_NVRAM_BASE_ADDR + 0x500;
245  	eth_env_get_enetaddr("ethaddr", (uchar *)build_buf);
246  	memcpy(tmp, &build_buf[3], 3);
247  #elif defined(CONFIG_SYS_VXWORKS_MAC_PTR)
248  	tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR;
249  	eth_env_get_enetaddr("ethaddr", (uchar *)build_buf);
250  	memcpy(tmp, build_buf, 6);
251  #else
252  	puts("## Ethernet MAC address not copied to NV RAM\n");
253  #endif
254  
255  	/*
256  	 * Use bootaddr to find the location in memory that VxWorks
257  	 * will look for the bootline string. The default value is
258  	 * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by
259  	 * VxWorks BSP. For example, on PowerPC it defaults to 0x4200.
260  	 */
261  	tmp = env_get("bootaddr");
262  	if (!tmp) {
263  		printf("## VxWorks bootline address not specified\n");
264  	} else {
265  		bootaddr = simple_strtoul(tmp, NULL, 16);
266  
267  		/*
268  		 * Check to see if the bootline is defined in the 'bootargs'
269  		 * parameter. If it is not defined, we may be able to
270  		 * construct the info.
271  		 */
272  		bootline = env_get("bootargs");
273  		if (bootline) {
274  			memcpy((void *)bootaddr, bootline,
275  			       max(strlen(bootline), (size_t)255));
276  			flush_cache(bootaddr, max(strlen(bootline),
277  						  (size_t)255));
278  		} else {
279  			tmp = env_get("bootdev");
280  			if (tmp) {
281  				strcpy(build_buf, tmp);
282  				ptr = strlen(tmp);
283  			} else
284  				printf("## VxWorks boot device not specified\n");
285  
286  			tmp = env_get("bootfile");
287  			if (tmp)
288  				ptr += sprintf(build_buf + ptr,
289  					       "host:%s ", tmp);
290  			else
291  				ptr += sprintf(build_buf + ptr,
292  					       "host:vxWorks ");
293  
294  			/*
295  			 * The following parameters are only needed if 'bootdev'
296  			 * is an ethernet device, otherwise they are optional.
297  			 */
298  			tmp = env_get("ipaddr");
299  			if (tmp) {
300  				ptr += sprintf(build_buf + ptr, "e=%s", tmp);
301  				tmp = env_get("netmask");
302  				if (tmp) {
303  					u32 mask = env_get_ip("netmask").s_addr;
304  					ptr += sprintf(build_buf + ptr,
305  						       ":%08x ", ntohl(mask));
306  				} else {
307  					ptr += sprintf(build_buf + ptr, " ");
308  				}
309  			}
310  
311  			tmp = env_get("serverip");
312  			if (tmp)
313  				ptr += sprintf(build_buf + ptr, "h=%s ", tmp);
314  
315  			tmp = env_get("gatewayip");
316  			if (tmp)
317  				ptr += sprintf(build_buf + ptr, "g=%s ", tmp);
318  
319  			tmp = env_get("hostname");
320  			if (tmp)
321  				ptr += sprintf(build_buf + ptr, "tn=%s ", tmp);
322  
323  			tmp = env_get("othbootargs");
324  			if (tmp) {
325  				strcpy(build_buf + ptr, tmp);
326  				ptr += strlen(tmp);
327  			}
328  
329  			memcpy((void *)bootaddr, build_buf,
330  			       max(strlen(build_buf), (size_t)255));
331  			flush_cache(bootaddr, max(strlen(build_buf),
332  						  (size_t)255));
333  		}
334  
335  		printf("## Using bootline (@ 0x%lx): %s\n", bootaddr,
336  		       (char *)bootaddr);
337  	}
338  
339  #ifdef CONFIG_X86
340  	/*
341  	 * Since E820 information is critical to the kernel, if we don't
342  	 * specify these in the environments, use a default one.
343  	 */
344  	tmp = env_get("e820data");
345  	if (tmp)
346  		data = (struct e820entry *)simple_strtoul(tmp, NULL, 16);
347  	else
348  		data = (struct e820entry *)VXWORKS_E820_DATA_ADDR;
349  	tmp = env_get("e820info");
350  	if (tmp)
351  		info = (struct e820info *)simple_strtoul(tmp, NULL, 16);
352  	else
353  		info = (struct e820info *)VXWORKS_E820_INFO_ADDR;
354  
355  	memset(info, 0, sizeof(struct e820info));
356  	info->sign = E820_SIGNATURE;
357  	info->entries = install_e820_map(E820MAX, data);
358  	info->addr = (info->entries - 1) * sizeof(struct e820entry) +
359  		     VXWORKS_E820_DATA_ADDR;
360  #endif
361  
362  	/*
363  	 * If the data at the load address is an elf image, then
364  	 * treat it like an elf image. Otherwise, assume that it is a
365  	 * binary image.
366  	 */
367  	if (valid_elf_image(addr))
368  		addr = load_elf_image_shdr(addr);
369  	else
370  		puts("## Not an ELF image, assuming binary\n");
371  
372  	printf("## Starting vxWorks at 0x%08lx ...\n", addr);
373  
374  	dcache_disable();
375  #ifdef CONFIG_X86
376  	/* VxWorks on x86 uses stack to pass parameters */
377  	((asmlinkage void (*)(int))addr)(0);
378  #else
379  	((void (*)(int))addr)(0);
380  #endif
381  
382  	puts("## vxWorks terminated\n");
383  
384  	return 1;
385  }
386  
387  U_BOOT_CMD(
388  	bootelf, CONFIG_SYS_MAXARGS, 0, do_bootelf,
389  	"Boot from an ELF image in memory",
390  	"[-p|-s] [address]\n"
391  	"\t- load ELF image at [address] via program headers (-p)\n"
392  	"\t  or via section headers (-s)"
393  );
394  
395  U_BOOT_CMD(
396  	bootvx, 2, 0, do_bootvx,
397  	"Boot vxWorks from an ELF image",
398  	" [address] - load address of vxWorks ELF image."
399  );
400