int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, unsigned long initrd_addr, unsigned long initrd_size) { struct setup_header *hdr = &setup_base->hdr; int bootproto = get_boot_protocol(hdr); setup_base->e820_entries = install_e820_map( ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map); if (bootproto == 0x0100) { setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET; } if (bootproto >= 0x0200) { hdr->type_of_loader = 8; if (initrd_addr) { printf("Initial RAM disk at linear address " "0x%08lx, size %ld bytes\n", initrd_addr, initrd_size); hdr->ramdisk_image = initrd_addr; hdr->ramdisk_size = initrd_size; } } if (bootproto >= 0x0201) { hdr->heap_end_ptr = HEAP_END_OFFSET; hdr->loadflags |= HEAP_FLAG; } if (cmd_line) { if (bootproto >= 0x0202) { hdr->cmd_line_ptr = (uintptr_t)cmd_line; } else if (bootproto >= 0x0200) { setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; setup_base->screen_info.cl_offset = (uintptr_t)cmd_line - (uintptr_t)setup_base; hdr->setup_move_size = 0x9100; } /* build command line at COMMAND_LINE_OFFSET */ build_command_line(cmd_line, auto_boot); } setup_video(&setup_base->screen_info); return 0; }
/* * Interpreter command to boot VxWorks from a memory image. The image can * be either an ELF image or a raw binary. Will attempt to setup the * bootline and other parameters correctly. */ int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { unsigned long addr; /* Address of image */ unsigned long bootaddr; /* Address to put the bootline */ char *bootline; /* Text of the bootline */ char *tmp; /* Temporary char pointer */ char build_buf[128]; /* Buffer for building the bootline */ int ptr = 0; #ifdef CONFIG_X86 struct e820info *info; struct e820entry *data; #endif /* * Check the loadaddr variable. * If we don't know where the image is then we're done. */ if (argc < 2) addr = load_addr; else addr = simple_strtoul(argv[1], NULL, 16); #if defined(CONFIG_CMD_NET) /* * Check to see if we need to tftp the image ourselves * before starting */ if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) { if (net_loop(TFTPGET) <= 0) return 1; printf("Automatic boot of VxWorks image at address 0x%08lx ...\n", addr); } #endif /* * This should equate to * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET * from the VxWorks BSP header files. * This will vary from board to board */ #if defined(CONFIG_WALNUT) tmp = (char *)CONFIG_SYS_NVRAM_BASE_ADDR + 0x500; eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); memcpy(tmp, &build_buf[3], 3); #elif defined(CONFIG_SYS_VXWORKS_MAC_PTR) tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR; eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); memcpy(tmp, build_buf, 6); #else puts("## Ethernet MAC address not copied to NV RAM\n"); #endif /* * Use bootaddr to find the location in memory that VxWorks * will look for the bootline string. The default value is * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by * VxWorks BSP. For example, on PowerPC it defaults to 0x4200. */ tmp = getenv("bootaddr"); if (!tmp) { printf("## VxWorks bootline address not specified\n"); } else { bootaddr = simple_strtoul(tmp, NULL, 16); /* * Check to see if the bootline is defined in the 'bootargs' * parameter. If it is not defined, we may be able to * construct the info. */ bootline = getenv("bootargs"); if (bootline) { memcpy((void *)bootaddr, bootline, max(strlen(bootline), (size_t)255)); flush_cache(bootaddr, max(strlen(bootline), (size_t)255)); } else { tmp = getenv("bootdev"); if (tmp) ptr = sprintf(build_buf, tmp); else printf("## VxWorks boot device not specified\n"); tmp = getenv("bootfile"); if (tmp) ptr += sprintf(build_buf + ptr, "host:%s ", tmp); else ptr += sprintf(build_buf + ptr, "host:vxWorks "); /* * The following parameters are only needed if 'bootdev' * is an ethernet device, otherwise they are optional. */ tmp = getenv("ipaddr"); if (tmp) { ptr += sprintf(build_buf + ptr, "e=%s", tmp); tmp = getenv("netmask"); if (tmp) { u32 mask = getenv_ip("netmask").s_addr; ptr += sprintf(build_buf + ptr, ":%08x ", ntohl(mask)); } else { ptr += sprintf(build_buf + ptr, " "); } } tmp = getenv("serverip"); if (tmp) ptr += sprintf(build_buf + ptr, "h=%s ", tmp); tmp = getenv("gatewayip"); if (tmp) ptr += sprintf(build_buf + ptr, "g=%s ", tmp); tmp = getenv("hostname"); if (tmp) ptr += sprintf(build_buf + ptr, "tn=%s ", tmp); tmp = getenv("othbootargs"); if (tmp) ptr += sprintf(build_buf + ptr, tmp); memcpy((void *)bootaddr, build_buf, max(strlen(build_buf), (size_t)255)); flush_cache(bootaddr, max(strlen(build_buf), (size_t)255)); } printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, (char *)bootaddr); } #ifdef CONFIG_X86 /* * Since E820 information is critical to the kernel, if we don't * specify these in the environments, use a default one. */ tmp = getenv("e820data"); if (tmp) data = (struct e820entry *)simple_strtoul(tmp, NULL, 16); else data = (struct e820entry *)VXWORKS_E820_DATA_ADDR; tmp = getenv("e820info"); if (tmp) info = (struct e820info *)simple_strtoul(tmp, NULL, 16); else info = (struct e820info *)VXWORKS_E820_INFO_ADDR; memset(info, 0, sizeof(struct e820info)); info->sign = E820_SIGNATURE; info->entries = install_e820_map(E820MAX, data); info->addr = (info->entries - 1) * sizeof(struct e820entry) + VXWORKS_E820_DATA_ADDR; #endif /* * If the data at the load address is an elf image, then * treat it like an elf image. Otherwise, assume that it is a * binary image. */ if (valid_elf_image(addr)) addr = load_elf_image_shdr(addr); else puts("## Not an ELF image, assuming binary\n"); printf("## Starting vxWorks at 0x%08lx ...\n", addr); dcache_disable(); #ifdef CONFIG_X86 /* VxWorks on x86 uses stack to pass parameters */ ((asmlinkage void (*)(int))addr)(0); #else ((void (*)(int))addr)(0); #endif puts("## vxWorks terminated\n"); return 1; }
/* * Interpreter command to boot VxWorks from a memory image. The image can * be either an ELF image or a raw binary. Will attempt to setup the * bootline and other parameters correctly. */ int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { unsigned long addr; /* Address of image */ unsigned long bootaddr = 0; /* Address to put the bootline */ char *bootline; /* Text of the bootline */ char *tmp; /* Temporary char pointer */ char build_buf[128]; /* Buffer for building the bootline */ int ptr = 0; #ifdef CONFIG_X86 ulong base; struct e820_info *info; struct e820_entry *data; struct efi_gop_info *gop; struct vesa_mode_info *vesa = &mode_info.vesa; #endif /* * Check the loadaddr variable. * If we don't know where the image is then we're done. */ if (argc < 2) addr = load_addr; else addr = simple_strtoul(argv[1], NULL, 16); #if defined(CONFIG_CMD_NET) /* * Check to see if we need to tftp the image ourselves * before starting */ if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) { if (net_loop(TFTPGET) <= 0) return 1; printf("Automatic boot of VxWorks image at address 0x%08lx ...\n", addr); } #endif /* * This should equate to * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET * from the VxWorks BSP header files. * This will vary from board to board */ #if defined(CONFIG_SYS_VXWORKS_MAC_PTR) tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR; eth_env_get_enetaddr("ethaddr", (uchar *)build_buf); memcpy(tmp, build_buf, 6); #else puts("## Ethernet MAC address not copied to NV RAM\n"); #endif #ifdef CONFIG_X86 /* * Get VxWorks's physical memory base address from environment, * if we don't specify it in the environment, use a default one. */ base = env_get_hex("vx_phys_mem_base", VXWORKS_PHYS_MEM_BASE); data = (struct e820_entry *)(base + E820_DATA_OFFSET); info = (struct e820_info *)(base + E820_INFO_OFFSET); memset(info, 0, sizeof(struct e820_info)); info->sign = E820_SIGNATURE; info->entries = install_e820_map(E820MAX, data); info->addr = (info->entries - 1) * sizeof(struct e820_entry) + E820_DATA_OFFSET; /* * Explicitly clear the bootloader image size otherwise if memory * at this offset happens to contain some garbage data, the final * available memory size for the kernel is insane. */ *(u32 *)(base + BOOT_IMAGE_SIZE_OFFSET) = 0; /* * Prepare compatible framebuffer information block. * The VESA mode has to be 32-bit RGBA. */ if (vesa->x_resolution && vesa->y_resolution) { gop = (struct efi_gop_info *)(base + EFI_GOP_INFO_OFFSET); gop->magic = EFI_GOP_INFO_MAGIC; gop->info.version = 0; gop->info.width = vesa->x_resolution; gop->info.height = vesa->y_resolution; gop->info.pixel_format = EFI_GOT_RGBA8; gop->info.pixels_per_scanline = vesa->bytes_per_scanline / 4; gop->fb_base = vesa->phys_base_ptr; gop->fb_size = vesa->bytes_per_scanline * vesa->y_resolution; } #endif /* * Use bootaddr to find the location in memory that VxWorks * will look for the bootline string. The default value is * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by * VxWorks BSP. For example, on PowerPC it defaults to 0x4200. */ tmp = env_get("bootaddr"); if (!tmp) { #ifdef CONFIG_X86 bootaddr = base + X86_BOOT_LINE_OFFSET; #else printf("## VxWorks bootline address not specified\n"); return 1; #endif } if (!bootaddr) bootaddr = simple_strtoul(tmp, NULL, 16); /* * Check to see if the bootline is defined in the 'bootargs' parameter. * If it is not defined, we may be able to construct the info. */ bootline = env_get("bootargs"); if (!bootline) { tmp = env_get("bootdev"); if (tmp) { strcpy(build_buf, tmp); ptr = strlen(tmp); } else { printf("## VxWorks boot device not specified\n"); } tmp = env_get("bootfile"); if (tmp) ptr += sprintf(build_buf + ptr, "host:%s ", tmp); else ptr += sprintf(build_buf + ptr, "host:vxWorks "); /* * The following parameters are only needed if 'bootdev' * is an ethernet device, otherwise they are optional. */ tmp = env_get("ipaddr"); if (tmp) { ptr += sprintf(build_buf + ptr, "e=%s", tmp); tmp = env_get("netmask"); if (tmp) { u32 mask = env_get_ip("netmask").s_addr; ptr += sprintf(build_buf + ptr, ":%08x ", ntohl(mask)); } else { ptr += sprintf(build_buf + ptr, " "); } } tmp = env_get("serverip"); if (tmp) ptr += sprintf(build_buf + ptr, "h=%s ", tmp); tmp = env_get("gatewayip"); if (tmp) ptr += sprintf(build_buf + ptr, "g=%s ", tmp); tmp = env_get("hostname"); if (tmp) ptr += sprintf(build_buf + ptr, "tn=%s ", tmp); tmp = env_get("othbootargs"); if (tmp) { strcpy(build_buf + ptr, tmp); ptr += strlen(tmp); } bootline = build_buf; } memcpy((void *)bootaddr, bootline, max(strlen(bootline), (size_t)255)); flush_cache(bootaddr, max(strlen(bootline), (size_t)255)); printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, (char *)bootaddr); /* * If the data at the load address is an elf image, then * treat it like an elf image. Otherwise, assume that it is a * binary image. */ if (valid_elf_image(addr)) addr = load_elf_image_phdr(addr); else puts("## Not an ELF image, assuming binary\n"); printf("## Starting vxWorks at 0x%08lx ...\n", addr); dcache_disable(); #if defined(CONFIG_ARM64) && defined(CONFIG_ARMV8_PSCI) armv8_setup_psci(); smp_kick_all_cpus(); #endif #ifdef CONFIG_X86 /* VxWorks on x86 uses stack to pass parameters */ ((asmlinkage void (*)(int))addr)(0); #else ((void (*)(int))addr)(0); #endif puts("## vxWorks terminated\n"); return 1; }