cmd/elf.c

   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 */
  25 int 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  */
 111 int 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
 315 U_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
 331 U_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