jcs.org
"Das U-Boot" Source Tree
1// SPDX-License-Identifier: BSD-2-Clause
2/*
3 * Copyright (c) 2001 William L. Pitts
4 * All rights reserved.
5 */
6
7#include <command.h>
8#include <cpu_func.h>
9#include <elf.h>
10#include <env.h>
11#include <image.h>
12#include <log.h>
13#ifdef CONFIG_CMD_ELF_BOOTVX
14#include <net.h>
15#include <vxworks.h>
16#endif
17#ifdef CONFIG_X86
18#include <vesa.h>
19#include <asm/cache.h>
20#include <asm/e820.h>
21#include <linux/linkage.h>
22#endif
23
24/* Interpreter command to boot an arbitrary ELF image from memory */
25int do_bootelf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
26{
27#if CONFIG_IS_ENABLED(CMD_ELF_FDT_SETUP)
28 struct bootm_headers img = {0};
29 unsigned long fdt_addr = 0; /* Address of the FDT */
30#endif
31 unsigned long addr; /* Address of the ELF image */
32 unsigned long rc; /* Return value from user code */
33 int rcode = CMD_RET_SUCCESS;
34 Bootelf_flags flags = {0};
35
36 /* Consume 'bootelf' */
37 argc--; argv++;
38
39 /* Check for [-p|-s] flag. */
40 if (argc >= 1 && (argv[0][0] == '-' && \
41 (argv[0][1] == 'p' || argv[0][1] == 's'))) {
42 if (argv[0][1] == 'p')
43 flags.phdr = 1;
44 log_debug("Using ELF header format %s\n",
45 flags.phdr ? "phdr" : "shdr");
46 /* Consume flag. */
47 argc--; argv++;
48 }
49
50#if CONFIG_IS_ENABLED(CMD_ELF_FDT_SETUP)
51 /* Check for [-d fdt_addr_r] option. */
52 if ((argc >= 2) && (argv[0][0] == '-') && (argv[0][1] == 'd')) {
53 if (strict_strtoul(argv[1], 16, &fdt_addr) != 0)
54 return CMD_RET_USAGE;
55 /* Consume option. */
56 argc -= 2;
57 argv += 2;
58 }
59#endif
60
61 /* Check for address. */
62 if (argc >= 1 && strict_strtoul(argv[0], 16, &addr) != -EINVAL) {
63 /* Consume address */
64 argc--; argv++;
65 } else
66 addr = image_load_addr;
67
68#if CONFIG_IS_ENABLED(CMD_ELF_FDT_SETUP)
69 if (fdt_addr) {
70 log_debug("Setting up FDT at 0x%08lx ...\n", fdt_addr);
71 flush();
72
73 fdt_set_totalsize((void *)fdt_addr,
74 fdt_totalsize(fdt_addr) + CONFIG_SYS_FDT_PAD);
75 if (image_setup_libfdt(&img, (void *)fdt_addr, false))
76 return 1;
77 }
78#endif
79
80 if (env_get_autostart()) {
81 flags.autostart = 1;
82 log_debug("Starting application at 0x%08lx ...\n", addr);
83 flush();
84 }
85
86 /*
87 * pass address parameter as argv[0] (aka command name),
88 * and all remaining arguments
89 */
90 rc = bootelf(addr, flags, argc, argv);
91 if (rc != 0)
92 rcode = CMD_RET_FAILURE;
93
94 if (flags.autostart)
95 {
96 if (ENOEXEC == errno)
97 log_err("Invalid ELF image\n");
98 else
99 log_debug("## Application terminated, rc = 0x%lx\n", rc);
100 }
101
102 return rcode;
103}
104
105#ifdef CONFIG_CMD_ELF_BOOTVX
106/*
107 * Interpreter command to boot VxWorks from a memory image. The image can
108 * be either an ELF image or a raw binary. Will attempt to setup the
109 * bootline and other parameters correctly.
110 */
111int do_bootvx(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
112{
113 unsigned long addr; /* Address of image */
114 unsigned long bootaddr = 0; /* Address to put the bootline */
115 char *bootline; /* Text of the bootline */
116 char *tmp; /* Temporary char pointer */
117 char build_buf[128]; /* Buffer for building the bootline */
118 int ptr = 0;
119#ifdef CONFIG_X86
120 ulong base;
121 struct e820_info *info;
122 struct e820_entry *data;
123 struct efi_gop_info *gop;
124 struct vesa_mode_info *vesa = &mode_info.vesa;
125#endif
126
127 /*
128 * Check the loadaddr variable.
129 * If we don't know where the image is then we're done.
130 */
131 if (argc < 2)
132 addr = image_load_addr;
133 else
134 addr = hextoul(argv[1], NULL);
135
136#if defined(CONFIG_CMD_NET) && !defined(CONFIG_NET_LWIP)
137 /*
138 * Check to see if we need to tftp the image ourselves
139 * before starting
140 */
141 if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) {
142 if (net_loop(TFTPGET) <= 0)
143 return 1;
144 printf("Automatic boot of VxWorks image at address 0x%08lx ...\n",
145 addr);
146 }
147#endif
148
149 /*
150 * This should equate to
151 * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET
152 * from the VxWorks BSP header files.
153 * This will vary from board to board
154 */
155#if defined(CONFIG_SYS_VXWORKS_MAC_PTR)
156 tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR;
157 eth_env_get_enetaddr("ethaddr", (uchar *)build_buf);
158 memcpy(tmp, build_buf, 6);
159#else
160 puts("## Ethernet MAC address not copied to NV RAM\n");
161#endif
162
163#ifdef CONFIG_X86
164 /*
165 * Get VxWorks's physical memory base address from environment,
166 * if we don't specify it in the environment, use a default one.
167 */
168 base = env_get_hex("vx_phys_mem_base", VXWORKS_PHYS_MEM_BASE);
169 data = (struct e820_entry *)(base + E820_DATA_OFFSET);
170 info = (struct e820_info *)(base + E820_INFO_OFFSET);
171
172 memset(info, 0, sizeof(struct e820_info));
173 info->sign = E820_SIGNATURE;
174 info->entries = install_e820_map(E820MAX, data);
175 info->addr = (info->entries - 1) * sizeof(struct e820_entry) +
176 E820_DATA_OFFSET;
177
178 /*
179 * Explicitly clear the bootloader image size otherwise if memory
180 * at this offset happens to contain some garbage data, the final
181 * available memory size for the kernel is insane.
182 */
183 *(u32 *)(base + BOOT_IMAGE_SIZE_OFFSET) = 0;
184
185 /*
186 * Prepare compatible framebuffer information block.
187 * The VESA mode has to be 32-bit RGBA.
188 */
189 if (vesa->x_resolution && vesa->y_resolution) {
190 gop = (struct efi_gop_info *)(base + EFI_GOP_INFO_OFFSET);
191 gop->magic = EFI_GOP_INFO_MAGIC;
192 gop->info.version = 0;
193 gop->info.width = vesa->x_resolution;
194 gop->info.height = vesa->y_resolution;
195 gop->info.pixel_format = EFI_GOT_RGBA8;
196 gop->info.pixels_per_scanline = vesa->bytes_per_scanline / 4;
197 gop->fb_base = vesa->phys_base_ptr;
198 gop->fb_size = vesa->bytes_per_scanline * vesa->y_resolution;
199 }
200#endif
201
202 /*
203 * Use bootaddr to find the location in memory that VxWorks
204 * will look for the bootline string. The default value is
205 * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by
206 * VxWorks BSP. For example, on PowerPC it defaults to 0x4200.
207 */
208 tmp = env_get("bootaddr");
209 if (!tmp) {
210#ifdef CONFIG_X86
211 bootaddr = base + X86_BOOT_LINE_OFFSET;
212#else
213 printf("## VxWorks bootline address not specified\n");
214 return 1;
215#endif
216 }
217
218 if (!bootaddr)
219 bootaddr = hextoul(tmp, NULL);
220
221 /*
222 * Check to see if the bootline is defined in the 'bootargs' parameter.
223 * If it is not defined, we may be able to construct the info.
224 */
225 bootline = env_get("bootargs");
226 if (!bootline) {
227 tmp = env_get("bootdev");
228 if (tmp) {
229 strcpy(build_buf, tmp);
230 ptr = strlen(tmp);
231 } else {
232 printf("## VxWorks boot device not specified\n");
233 }
234
235 tmp = env_get("bootfile");
236 if (tmp)
237 ptr += sprintf(build_buf + ptr, "host:%s ", tmp);
238 else
239 ptr += sprintf(build_buf + ptr, "host:vxWorks ");
240
241 /*
242 * The following parameters are only needed if 'bootdev'
243 * is an ethernet device, otherwise they are optional.
244 */
245 tmp = env_get("ipaddr");
246 if (tmp) {
247 ptr += sprintf(build_buf + ptr, "e=%s", tmp);
248 tmp = env_get("netmask");
249 if (tmp) {
250 u32 mask = env_get_ip("netmask").s_addr;
251 ptr += sprintf(build_buf + ptr,
252 ":%08x ", ntohl(mask));
253 } else {
254 ptr += sprintf(build_buf + ptr, " ");
255 }
256 }
257
258 tmp = env_get("serverip");
259 if (tmp)
260 ptr += sprintf(build_buf + ptr, "h=%s ", tmp);
261
262 tmp = env_get("gatewayip");
263 if (tmp)
264 ptr += sprintf(build_buf + ptr, "g=%s ", tmp);
265
266 tmp = env_get("hostname");
267 if (tmp)
268 ptr += sprintf(build_buf + ptr, "tn=%s ", tmp);
269
270 tmp = env_get("othbootargs");
271 if (tmp) {
272 strcpy(build_buf + ptr, tmp);
273 ptr += strlen(tmp);
274 }
275
276 bootline = build_buf;
277 }
278
279 memcpy((void *)bootaddr, bootline, max(strlen(bootline), (size_t)255));
280 flush_cache(bootaddr, max(strlen(bootline), (size_t)255));
281 printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, (char *)bootaddr);
282
283 /*
284 * If the data at the load address is an elf image, then
285 * treat it like an elf image. Otherwise, assume that it is a
286 * binary image.
287 */
288 if (valid_elf_image(addr))
289 addr = load_elf_image_phdr(addr);
290 else
291 puts("## Not an ELF image, assuming binary\n");
292
293 printf("## Starting vxWorks at 0x%08lx ...\n", addr);
294 flush();
295
296 dcache_disable();
297#if defined(CONFIG_ARM64) && defined(CONFIG_ARMV8_PSCI)
298 armv8_setup_psci();
299 smp_kick_all_cpus();
300#endif
301
302#ifdef CONFIG_X86
303 /* VxWorks on x86 uses stack to pass parameters */
304 ((asmlinkage void (*)(int))addr)(0);
305#else
306 ((void (*)(int))addr)(0);
307#endif
308
309 puts("## vxWorks terminated\n");
310
311 return 1;
312}
313#endif
314
315U_BOOT_CMD(
316 bootelf, CONFIG_SYS_MAXARGS, 0, do_bootelf,
317 "Boot from an ELF image in memory",
318 "[-p|-s] "
319#if CONFIG_IS_ENABLED(CMD_ELF_FDT_SETUP)
320 "[-d fdt_addr_r] "
321#endif
322 "[address]\n"
323 "\t- load ELF image at [address] via program headers (-p)\n"
324 "\t or via section headers (-s)\n"
325#if CONFIG_IS_ENABLED(CMD_ELF_FDT_SETUP)
326 "\t- setup FDT image at [fdt_addr_r] (-d)"
327#endif
328);
329
330#ifdef CONFIG_CMD_ELF_BOOTVX
331U_BOOT_CMD(
332 bootvx, 2, 0, do_bootvx,
333 "Boot vxWorks from an ELF image",
334 " [address] - load address of vxWorks ELF image."
335);
336#endif