zimage.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2011 The Chromium OS Authors.
  4. * (C) Copyright 2002
  5. * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
  6. */
  7. /*
  8. * Linux x86 zImage and bzImage loading
  9. *
  10. * based on the procdure described in
  11. * linux/Documentation/i386/boot.txt
  12. */
  13. #include <common.h>
  14. #include <env.h>
  15. #include <irq_func.h>
  16. #include <malloc.h>
  17. #include <asm/acpi_table.h>
  18. #include <asm/io.h>
  19. #include <asm/ptrace.h>
  20. #include <asm/zimage.h>
  21. #include <asm/byteorder.h>
  22. #include <asm/bootm.h>
  23. #include <asm/bootparam.h>
  24. #ifdef CONFIG_SYS_COREBOOT
  25. #include <asm/arch/timestamp.h>
  26. #endif
  27. #include <linux/compiler.h>
  28. #include <linux/libfdt.h>
  29. /*
  30. * Memory lay-out:
  31. *
  32. * relative to setup_base (which is 0x90000 currently)
  33. *
  34. * 0x0000-0x7FFF Real mode kernel
  35. * 0x8000-0x8FFF Stack and heap
  36. * 0x9000-0x90FF Kernel command line
  37. */
  38. #define DEFAULT_SETUP_BASE 0x90000
  39. #define COMMAND_LINE_OFFSET 0x9000
  40. #define HEAP_END_OFFSET 0x8e00
  41. #define COMMAND_LINE_SIZE 2048
  42. static void build_command_line(char *command_line, int auto_boot)
  43. {
  44. char *env_command_line;
  45. command_line[0] = '\0';
  46. env_command_line = env_get("bootargs");
  47. /* set console= argument if we use a serial console */
  48. if (!strstr(env_command_line, "console=")) {
  49. if (!strcmp(env_get("stdout"), "serial")) {
  50. /* We seem to use serial console */
  51. sprintf(command_line, "console=ttyS0,%s ",
  52. env_get("baudrate"));
  53. }
  54. }
  55. if (auto_boot)
  56. strcat(command_line, "auto ");
  57. if (env_command_line)
  58. strcat(command_line, env_command_line);
  59. printf("Kernel command line: \"%s\"\n", command_line);
  60. }
  61. static int kernel_magic_ok(struct setup_header *hdr)
  62. {
  63. if (KERNEL_MAGIC != hdr->boot_flag) {
  64. printf("Error: Invalid Boot Flag "
  65. "(found 0x%04x, expected 0x%04x)\n",
  66. hdr->boot_flag, KERNEL_MAGIC);
  67. return 0;
  68. } else {
  69. printf("Valid Boot Flag\n");
  70. return 1;
  71. }
  72. }
  73. static int get_boot_protocol(struct setup_header *hdr)
  74. {
  75. if (hdr->header == KERNEL_V2_MAGIC) {
  76. printf("Magic signature found\n");
  77. return hdr->version;
  78. } else {
  79. /* Very old kernel */
  80. printf("Magic signature not found\n");
  81. return 0x0100;
  82. }
  83. }
  84. static int setup_device_tree(struct setup_header *hdr, const void *fdt_blob)
  85. {
  86. int bootproto = get_boot_protocol(hdr);
  87. struct setup_data *sd;
  88. int size;
  89. if (bootproto < 0x0209)
  90. return -ENOTSUPP;
  91. if (!fdt_blob)
  92. return 0;
  93. size = fdt_totalsize(fdt_blob);
  94. if (size < 0)
  95. return -EINVAL;
  96. size += sizeof(struct setup_data);
  97. sd = (struct setup_data *)malloc(size);
  98. if (!sd) {
  99. printf("Not enough memory for DTB setup data\n");
  100. return -ENOMEM;
  101. }
  102. sd->next = hdr->setup_data;
  103. sd->type = SETUP_DTB;
  104. sd->len = fdt_totalsize(fdt_blob);
  105. memcpy(sd->data, fdt_blob, sd->len);
  106. hdr->setup_data = (unsigned long)sd;
  107. return 0;
  108. }
  109. struct boot_params *load_zimage(char *image, unsigned long kernel_size,
  110. ulong *load_addressp)
  111. {
  112. struct boot_params *setup_base;
  113. int setup_size;
  114. int bootproto;
  115. int big_image;
  116. struct boot_params *params = (struct boot_params *)image;
  117. struct setup_header *hdr = &params->hdr;
  118. /* base address for real-mode segment */
  119. setup_base = (struct boot_params *)DEFAULT_SETUP_BASE;
  120. if (!kernel_magic_ok(hdr))
  121. return 0;
  122. /* determine size of setup */
  123. if (0 == hdr->setup_sects) {
  124. printf("Setup Sectors = 0 (defaulting to 4)\n");
  125. setup_size = 5 * 512;
  126. } else {
  127. setup_size = (hdr->setup_sects + 1) * 512;
  128. }
  129. printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size);
  130. if (setup_size > SETUP_MAX_SIZE)
  131. printf("Error: Setup is too large (%d bytes)\n", setup_size);
  132. /* determine boot protocol version */
  133. bootproto = get_boot_protocol(hdr);
  134. printf("Using boot protocol version %x.%02x\n",
  135. (bootproto & 0xff00) >> 8, bootproto & 0xff);
  136. if (bootproto >= 0x0200) {
  137. if (hdr->setup_sects >= 15) {
  138. printf("Linux kernel version %s\n",
  139. (char *)params +
  140. hdr->kernel_version + 0x200);
  141. } else {
  142. printf("Setup Sectors < 15 - "
  143. "Cannot print kernel version.\n");
  144. }
  145. }
  146. /* Determine image type */
  147. big_image = (bootproto >= 0x0200) &&
  148. (hdr->loadflags & BIG_KERNEL_FLAG);
  149. /* Determine load address */
  150. if (big_image)
  151. *load_addressp = BZIMAGE_LOAD_ADDR;
  152. else
  153. *load_addressp = ZIMAGE_LOAD_ADDR;
  154. printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base);
  155. memset(setup_base, 0, sizeof(*setup_base));
  156. setup_base->hdr = params->hdr;
  157. if (bootproto >= 0x0204)
  158. kernel_size = hdr->syssize * 16;
  159. else
  160. kernel_size -= setup_size;
  161. if (bootproto == 0x0100) {
  162. /*
  163. * A very old kernel MUST have its real-mode code
  164. * loaded at 0x90000
  165. */
  166. if ((ulong)setup_base != 0x90000) {
  167. /* Copy the real-mode kernel */
  168. memmove((void *)0x90000, setup_base, setup_size);
  169. /* Copy the command line */
  170. memmove((void *)0x99000,
  171. (u8 *)setup_base + COMMAND_LINE_OFFSET,
  172. COMMAND_LINE_SIZE);
  173. /* Relocated */
  174. setup_base = (struct boot_params *)0x90000;
  175. }
  176. /* It is recommended to clear memory up to the 32K mark */
  177. memset((u8 *)0x90000 + setup_size, 0,
  178. SETUP_MAX_SIZE - setup_size);
  179. }
  180. if (big_image) {
  181. if (kernel_size > BZIMAGE_MAX_SIZE) {
  182. printf("Error: bzImage kernel too big! "
  183. "(size: %ld, max: %d)\n",
  184. kernel_size, BZIMAGE_MAX_SIZE);
  185. return 0;
  186. }
  187. } else if ((kernel_size) > ZIMAGE_MAX_SIZE) {
  188. printf("Error: zImage kernel too big! (size: %ld, max: %d)\n",
  189. kernel_size, ZIMAGE_MAX_SIZE);
  190. return 0;
  191. }
  192. printf("Loading %s at address %lx (%ld bytes)\n",
  193. big_image ? "bzImage" : "zImage", *load_addressp, kernel_size);
  194. memmove((void *)*load_addressp, image + setup_size, kernel_size);
  195. return setup_base;
  196. }
  197. int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
  198. unsigned long initrd_addr, unsigned long initrd_size)
  199. {
  200. struct setup_header *hdr = &setup_base->hdr;
  201. int bootproto = get_boot_protocol(hdr);
  202. setup_base->e820_entries = install_e820_map(
  203. ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map);
  204. if (bootproto == 0x0100) {
  205. setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
  206. setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET;
  207. }
  208. if (bootproto >= 0x0200) {
  209. hdr->type_of_loader = 8;
  210. if (initrd_addr) {
  211. printf("Initial RAM disk at linear address "
  212. "0x%08lx, size %ld bytes\n",
  213. initrd_addr, initrd_size);
  214. hdr->ramdisk_image = initrd_addr;
  215. hdr->ramdisk_size = initrd_size;
  216. }
  217. }
  218. if (bootproto >= 0x0201) {
  219. hdr->heap_end_ptr = HEAP_END_OFFSET;
  220. hdr->loadflags |= HEAP_FLAG;
  221. }
  222. if (cmd_line) {
  223. if (bootproto >= 0x0202) {
  224. hdr->cmd_line_ptr = (uintptr_t)cmd_line;
  225. } else if (bootproto >= 0x0200) {
  226. setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
  227. setup_base->screen_info.cl_offset =
  228. (uintptr_t)cmd_line - (uintptr_t)setup_base;
  229. hdr->setup_move_size = 0x9100;
  230. }
  231. /* build command line at COMMAND_LINE_OFFSET */
  232. build_command_line(cmd_line, auto_boot);
  233. }
  234. #ifdef CONFIG_INTEL_MID
  235. if (bootproto >= 0x0207)
  236. hdr->hardware_subarch = X86_SUBARCH_INTEL_MID;
  237. #endif
  238. #ifdef CONFIG_GENERATE_ACPI_TABLE
  239. setup_base->acpi_rsdp_addr = acpi_get_rsdp_addr();
  240. #endif
  241. setup_device_tree(hdr, (const void *)env_get_hex("fdtaddr", 0));
  242. setup_video(&setup_base->screen_info);
  243. #ifdef CONFIG_EFI_STUB
  244. setup_efi_info(&setup_base->efi_info);
  245. #endif
  246. return 0;
  247. }
  248. void setup_pcat_compatibility(void)
  249. __attribute__((weak, alias("__setup_pcat_compatibility")));
  250. void __setup_pcat_compatibility(void)
  251. {
  252. }
  253. int do_zboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
  254. {
  255. struct boot_params *base_ptr;
  256. void *bzImage_addr = NULL;
  257. ulong load_address;
  258. char *s;
  259. ulong bzImage_size = 0;
  260. ulong initrd_addr = 0;
  261. ulong initrd_size = 0;
  262. disable_interrupts();
  263. /* Setup board for maximum PC/AT Compatibility */
  264. setup_pcat_compatibility();
  265. if (argc >= 2) {
  266. /* argv[1] holds the address of the bzImage */
  267. s = argv[1];
  268. } else {
  269. s = env_get("fileaddr");
  270. }
  271. if (s)
  272. bzImage_addr = (void *)simple_strtoul(s, NULL, 16);
  273. if (argc >= 3) {
  274. /* argv[2] holds the size of the bzImage */
  275. bzImage_size = simple_strtoul(argv[2], NULL, 16);
  276. }
  277. if (argc >= 4)
  278. initrd_addr = simple_strtoul(argv[3], NULL, 16);
  279. if (argc >= 5)
  280. initrd_size = simple_strtoul(argv[4], NULL, 16);
  281. /* Lets look for */
  282. base_ptr = load_zimage(bzImage_addr, bzImage_size, &load_address);
  283. if (!base_ptr) {
  284. puts("## Kernel loading failed ...\n");
  285. return -1;
  286. }
  287. if (setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET,
  288. 0, initrd_addr, initrd_size)) {
  289. puts("Setting up boot parameters failed ...\n");
  290. return -1;
  291. }
  292. /* we assume that the kernel is in place */
  293. return boot_linux_kernel((ulong)base_ptr, load_address, false);
  294. }
  295. U_BOOT_CMD(
  296. zboot, 5, 0, do_zboot,
  297. "Boot bzImage",
  298. "[addr] [size] [initrd addr] [initrd size]\n"
  299. " addr - The optional starting address of the bzimage.\n"
  300. " If not set it defaults to the environment\n"
  301. " variable \"fileaddr\".\n"
  302. " size - The optional size of the bzimage. Defaults to\n"
  303. " zero.\n"
  304. " initrd addr - The address of the initrd image to use, if any.\n"
  305. " initrd size - The size of the initrd image to use, if any.\n"
  306. );