bootm.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2000-2009
  4. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  5. */
  6. #ifndef USE_HOSTCC
  7. #include <common.h>
  8. #include <bootstage.h>
  9. #include <bzlib.h>
  10. #include <errno.h>
  11. #include <fdt_support.h>
  12. #include <lmb.h>
  13. #include <malloc.h>
  14. #include <mapmem.h>
  15. #include <asm/io.h>
  16. #include <linux/lzo.h>
  17. #include <lzma/LzmaTypes.h>
  18. #include <lzma/LzmaDec.h>
  19. #include <lzma/LzmaTools.h>
  20. #if defined(CONFIG_CMD_USB)
  21. #include <usb.h>
  22. #endif
  23. #else
  24. #include "mkimage.h"
  25. #endif
  26. #include <command.h>
  27. #include <bootm.h>
  28. #include <image.h>
  29. #ifndef CONFIG_SYS_BOOTM_LEN
  30. /* use 8MByte as default max gunzip size */
  31. #define CONFIG_SYS_BOOTM_LEN 0x800000
  32. #endif
  33. #define IH_INITRD_ARCH IH_ARCH_DEFAULT
  34. #ifndef USE_HOSTCC
  35. DECLARE_GLOBAL_DATA_PTR;
  36. bootm_headers_t images; /* pointers to os/initrd/fdt images */
  37. static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
  38. char * const argv[], bootm_headers_t *images,
  39. ulong *os_data, ulong *os_len);
  40. #ifdef CONFIG_LMB
  41. static void boot_start_lmb(bootm_headers_t *images)
  42. {
  43. ulong mem_start;
  44. phys_size_t mem_size;
  45. lmb_init(&images->lmb);
  46. mem_start = env_get_bootm_low();
  47. mem_size = env_get_bootm_size();
  48. lmb_add(&images->lmb, (phys_addr_t)mem_start, mem_size);
  49. arch_lmb_reserve(&images->lmb);
  50. board_lmb_reserve(&images->lmb);
  51. }
  52. #else
  53. #define lmb_reserve(lmb, base, size)
  54. static inline void boot_start_lmb(bootm_headers_t *images) { }
  55. #endif
  56. static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc,
  57. char * const argv[])
  58. {
  59. memset((void *)&images, 0, sizeof(images));
  60. images.verify = env_get_yesno("verify");
  61. boot_start_lmb(&images);
  62. bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
  63. images.state = BOOTM_STATE_START;
  64. return 0;
  65. }
  66. static int bootm_find_os(cmd_tbl_t *cmdtp, int flag, int argc,
  67. char * const argv[])
  68. {
  69. const void *os_hdr;
  70. bool ep_found = false;
  71. int ret;
  72. /* get kernel image header, start address and length */
  73. os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
  74. &images, &images.os.image_start, &images.os.image_len);
  75. if (images.os.image_len == 0) {
  76. puts("ERROR: can't get kernel image!\n");
  77. return 1;
  78. }
  79. /* get image parameters */
  80. switch (genimg_get_format(os_hdr)) {
  81. #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
  82. case IMAGE_FORMAT_LEGACY:
  83. images.os.type = image_get_type(os_hdr);
  84. images.os.comp = image_get_comp(os_hdr);
  85. images.os.os = image_get_os(os_hdr);
  86. images.os.end = image_get_image_end(os_hdr);
  87. images.os.load = image_get_load(os_hdr);
  88. images.os.arch = image_get_arch(os_hdr);
  89. break;
  90. #endif
  91. #if IMAGE_ENABLE_FIT
  92. case IMAGE_FORMAT_FIT:
  93. if (fit_image_get_type(images.fit_hdr_os,
  94. images.fit_noffset_os,
  95. &images.os.type)) {
  96. puts("Can't get image type!\n");
  97. bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
  98. return 1;
  99. }
  100. if (fit_image_get_comp(images.fit_hdr_os,
  101. images.fit_noffset_os,
  102. &images.os.comp)) {
  103. puts("Can't get image compression!\n");
  104. bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
  105. return 1;
  106. }
  107. if (fit_image_get_os(images.fit_hdr_os, images.fit_noffset_os,
  108. &images.os.os)) {
  109. puts("Can't get image OS!\n");
  110. bootstage_error(BOOTSTAGE_ID_FIT_OS);
  111. return 1;
  112. }
  113. if (fit_image_get_arch(images.fit_hdr_os,
  114. images.fit_noffset_os,
  115. &images.os.arch)) {
  116. puts("Can't get image ARCH!\n");
  117. return 1;
  118. }
  119. images.os.end = fit_get_end(images.fit_hdr_os);
  120. if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
  121. &images.os.load)) {
  122. puts("Can't get image load address!\n");
  123. bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
  124. return 1;
  125. }
  126. break;
  127. #endif
  128. #ifdef CONFIG_ANDROID_BOOT_IMAGE
  129. case IMAGE_FORMAT_ANDROID:
  130. images.os.type = IH_TYPE_KERNEL;
  131. images.os.comp = IH_COMP_NONE;
  132. images.os.os = IH_OS_LINUX;
  133. images.os.end = android_image_get_end(os_hdr);
  134. images.os.load = android_image_get_kload(os_hdr);
  135. images.ep = images.os.load;
  136. ep_found = true;
  137. break;
  138. #endif
  139. default:
  140. puts("ERROR: unknown image format type!\n");
  141. return 1;
  142. }
  143. /* If we have a valid setup.bin, we will use that for entry (x86) */
  144. if (images.os.arch == IH_ARCH_I386 ||
  145. images.os.arch == IH_ARCH_X86_64) {
  146. ulong len;
  147. ret = boot_get_setup(&images, IH_ARCH_I386, &images.ep, &len);
  148. if (ret < 0 && ret != -ENOENT) {
  149. puts("Could not find a valid setup.bin for x86\n");
  150. return 1;
  151. }
  152. /* Kernel entry point is the setup.bin */
  153. } else if (images.legacy_hdr_valid) {
  154. images.ep = image_get_ep(&images.legacy_hdr_os_copy);
  155. #if IMAGE_ENABLE_FIT
  156. } else if (images.fit_uname_os) {
  157. int ret;
  158. ret = fit_image_get_entry(images.fit_hdr_os,
  159. images.fit_noffset_os, &images.ep);
  160. if (ret) {
  161. puts("Can't get entry point property!\n");
  162. return 1;
  163. }
  164. #endif
  165. } else if (!ep_found) {
  166. puts("Could not find kernel entry point!\n");
  167. return 1;
  168. }
  169. if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
  170. images.os.load = images.os.image_start;
  171. images.ep += images.os.load;
  172. }
  173. images.os.start = map_to_sysmem(os_hdr);
  174. return 0;
  175. }
  176. /**
  177. * bootm_find_images - wrapper to find and locate various images
  178. * @flag: Ignored Argument
  179. * @argc: command argument count
  180. * @argv: command argument list
  181. *
  182. * boot_find_images() will attempt to load an available ramdisk,
  183. * flattened device tree, as well as specifically marked
  184. * "loadable" images (loadables are FIT only)
  185. *
  186. * Note: bootm_find_images will skip an image if it is not found
  187. *
  188. * @return:
  189. * 0, if all existing images were loaded correctly
  190. * 1, if an image is found but corrupted, or invalid
  191. */
  192. int bootm_find_images(int flag, int argc, char * const argv[])
  193. {
  194. int ret;
  195. /* find ramdisk */
  196. ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
  197. &images.rd_start, &images.rd_end);
  198. if (ret) {
  199. puts("Ramdisk image is corrupt or invalid\n");
  200. return 1;
  201. }
  202. #if IMAGE_ENABLE_OF_LIBFDT
  203. /* find flattened device tree */
  204. ret = boot_get_fdt(flag, argc, argv, IH_ARCH_DEFAULT, &images,
  205. &images.ft_addr, &images.ft_len);
  206. if (ret) {
  207. puts("Could not find a valid device tree\n");
  208. return 1;
  209. }
  210. set_working_fdt_addr((ulong)images.ft_addr);
  211. #endif
  212. #if IMAGE_ENABLE_FIT
  213. #if defined(CONFIG_FPGA)
  214. /* find bitstreams */
  215. ret = boot_get_fpga(argc, argv, &images, IH_ARCH_DEFAULT,
  216. NULL, NULL);
  217. if (ret) {
  218. printf("FPGA image is corrupted or invalid\n");
  219. return 1;
  220. }
  221. #endif
  222. /* find all of the loadables */
  223. ret = boot_get_loadable(argc, argv, &images, IH_ARCH_DEFAULT,
  224. NULL, NULL);
  225. if (ret) {
  226. printf("Loadable(s) is corrupt or invalid\n");
  227. return 1;
  228. }
  229. #endif
  230. return 0;
  231. }
  232. static int bootm_find_other(cmd_tbl_t *cmdtp, int flag, int argc,
  233. char * const argv[])
  234. {
  235. if (((images.os.type == IH_TYPE_KERNEL) ||
  236. (images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
  237. (images.os.type == IH_TYPE_MULTI)) &&
  238. (images.os.os == IH_OS_LINUX ||
  239. images.os.os == IH_OS_VXWORKS))
  240. return bootm_find_images(flag, argc, argv);
  241. return 0;
  242. }
  243. #endif /* USE_HOSTC */
  244. /**
  245. * print_decomp_msg() - Print a suitable decompression/loading message
  246. *
  247. * @type: OS type (IH_OS_...)
  248. * @comp_type: Compression type being used (IH_COMP_...)
  249. * @is_xip: true if the load address matches the image start
  250. */
  251. static void print_decomp_msg(int comp_type, int type, bool is_xip)
  252. {
  253. const char *name = genimg_get_type_name(type);
  254. if (comp_type == IH_COMP_NONE)
  255. printf(" %s %s ... ", is_xip ? "XIP" : "Loading", name);
  256. else
  257. printf(" Uncompressing %s ... ", name);
  258. }
  259. /**
  260. * handle_decomp_error() - display a decompression error
  261. *
  262. * This function tries to produce a useful message. In the case where the
  263. * uncompressed size is the same as the available space, we can assume that
  264. * the image is too large for the buffer.
  265. *
  266. * @comp_type: Compression type being used (IH_COMP_...)
  267. * @uncomp_size: Number of bytes uncompressed
  268. * @unc_len: Amount of space available for decompression
  269. * @ret: Error code to report
  270. * @return BOOTM_ERR_RESET, indicating that the board must be reset
  271. */
  272. static int handle_decomp_error(int comp_type, size_t uncomp_size,
  273. size_t unc_len, int ret)
  274. {
  275. const char *name = genimg_get_comp_name(comp_type);
  276. if (uncomp_size >= unc_len)
  277. printf("Image too large: increase CONFIG_SYS_BOOTM_LEN\n");
  278. else
  279. printf("%s: uncompress error %d\n", name, ret);
  280. /*
  281. * The decompression routines are now safe, so will not write beyond
  282. * their bounds. Probably it is not necessary to reset, but maintain
  283. * the current behaviour for now.
  284. */
  285. printf("Must RESET board to recover\n");
  286. #ifndef USE_HOSTCC
  287. bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
  288. #endif
  289. return BOOTM_ERR_RESET;
  290. }
  291. int bootm_decomp_image(int comp, ulong load, ulong image_start, int type,
  292. void *load_buf, void *image_buf, ulong image_len,
  293. uint unc_len, ulong *load_end)
  294. {
  295. int ret = 0;
  296. *load_end = load;
  297. print_decomp_msg(comp, type, load == image_start);
  298. /*
  299. * Load the image to the right place, decompressing if needed. After
  300. * this, image_len will be set to the number of uncompressed bytes
  301. * loaded, ret will be non-zero on error.
  302. */
  303. switch (comp) {
  304. case IH_COMP_NONE:
  305. if (load == image_start)
  306. break;
  307. if (image_len <= unc_len)
  308. memmove_wd(load_buf, image_buf, image_len, CHUNKSZ);
  309. else
  310. ret = 1;
  311. break;
  312. #ifdef CONFIG_GZIP
  313. case IH_COMP_GZIP: {
  314. ret = gunzip(load_buf, unc_len, image_buf, &image_len);
  315. break;
  316. }
  317. #endif /* CONFIG_GZIP */
  318. #ifdef CONFIG_BZIP2
  319. case IH_COMP_BZIP2: {
  320. uint size = unc_len;
  321. /*
  322. * If we've got less than 4 MB of malloc() space,
  323. * use slower decompression algorithm which requires
  324. * at most 2300 KB of memory.
  325. */
  326. ret = BZ2_bzBuffToBuffDecompress(load_buf, &size,
  327. image_buf, image_len,
  328. CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
  329. image_len = size;
  330. break;
  331. }
  332. #endif /* CONFIG_BZIP2 */
  333. #ifdef CONFIG_LZMA
  334. case IH_COMP_LZMA: {
  335. SizeT lzma_len = unc_len;
  336. ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len,
  337. image_buf, image_len);
  338. image_len = lzma_len;
  339. break;
  340. }
  341. #endif /* CONFIG_LZMA */
  342. #ifdef CONFIG_LZO
  343. case IH_COMP_LZO: {
  344. size_t size = unc_len;
  345. ret = lzop_decompress(image_buf, image_len, load_buf, &size);
  346. image_len = size;
  347. break;
  348. }
  349. #endif /* CONFIG_LZO */
  350. #ifdef CONFIG_LZ4
  351. case IH_COMP_LZ4: {
  352. size_t size = unc_len;
  353. ret = ulz4fn(image_buf, image_len, load_buf, &size);
  354. image_len = size;
  355. break;
  356. }
  357. #endif /* CONFIG_LZ4 */
  358. default:
  359. printf("Unimplemented compression type %d\n", comp);
  360. return BOOTM_ERR_UNIMPLEMENTED;
  361. }
  362. if (ret)
  363. return handle_decomp_error(comp, image_len, unc_len, ret);
  364. *load_end = load + image_len;
  365. puts("OK\n");
  366. return 0;
  367. }
  368. #ifndef USE_HOSTCC
  369. static int bootm_load_os(bootm_headers_t *images, int boot_progress)
  370. {
  371. image_info_t os = images->os;
  372. ulong load = os.load;
  373. ulong load_end;
  374. ulong blob_start = os.start;
  375. ulong blob_end = os.end;
  376. ulong image_start = os.image_start;
  377. ulong image_len = os.image_len;
  378. ulong flush_start = ALIGN_DOWN(load, ARCH_DMA_MINALIGN);
  379. ulong flush_len;
  380. bool no_overlap;
  381. void *load_buf, *image_buf;
  382. int err;
  383. load_buf = map_sysmem(load, 0);
  384. image_buf = map_sysmem(os.image_start, image_len);
  385. err = bootm_decomp_image(os.comp, load, os.image_start, os.type,
  386. load_buf, image_buf, image_len,
  387. CONFIG_SYS_BOOTM_LEN, &load_end);
  388. if (err) {
  389. bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
  390. return err;
  391. }
  392. flush_len = load_end - load;
  393. if (flush_start < load)
  394. flush_len += load - flush_start;
  395. flush_cache(flush_start, ALIGN(flush_len, ARCH_DMA_MINALIGN));
  396. debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, load_end);
  397. bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
  398. no_overlap = (os.comp == IH_COMP_NONE && load == image_start);
  399. if (!no_overlap && load < blob_end && load_end > blob_start) {
  400. debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
  401. blob_start, blob_end);
  402. debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
  403. load_end);
  404. /* Check what type of image this is. */
  405. if (images->legacy_hdr_valid) {
  406. if (image_get_type(&images->legacy_hdr_os_copy)
  407. == IH_TYPE_MULTI)
  408. puts("WARNING: legacy format multi component image overwritten\n");
  409. return BOOTM_ERR_OVERLAP;
  410. } else {
  411. puts("ERROR: new format image overwritten - must RESET the board to recover\n");
  412. bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
  413. return BOOTM_ERR_RESET;
  414. }
  415. }
  416. lmb_reserve(&images->lmb, images->os.load, (load_end -
  417. images->os.load));
  418. return 0;
  419. }
  420. /**
  421. * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot
  422. *
  423. * @return interrupt flag (0 if interrupts were disabled, non-zero if they were
  424. * enabled)
  425. */
  426. ulong bootm_disable_interrupts(void)
  427. {
  428. ulong iflag;
  429. /*
  430. * We have reached the point of no return: we are going to
  431. * overwrite all exception vector code, so we cannot easily
  432. * recover from any failures any more...
  433. */
  434. iflag = disable_interrupts();
  435. #ifdef CONFIG_NETCONSOLE
  436. /* Stop the ethernet stack if NetConsole could have left it up */
  437. eth_halt();
  438. # ifndef CONFIG_DM_ETH
  439. eth_unregister(eth_get_dev());
  440. # endif
  441. #endif
  442. #if defined(CONFIG_CMD_USB)
  443. /*
  444. * turn off USB to prevent the host controller from writing to the
  445. * SDRAM while Linux is booting. This could happen (at least for OHCI
  446. * controller), because the HCCA (Host Controller Communication Area)
  447. * lies within the SDRAM and the host controller writes continously to
  448. * this area (as busmaster!). The HccaFrameNumber is for example
  449. * updated every 1 ms within the HCCA structure in SDRAM! For more
  450. * details see the OpenHCI specification.
  451. */
  452. usb_stop();
  453. #endif
  454. return iflag;
  455. }
  456. #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
  457. #define CONSOLE_ARG "console="
  458. #define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
  459. static void fixup_silent_linux(void)
  460. {
  461. char *buf;
  462. const char *env_val;
  463. char *cmdline = env_get("bootargs");
  464. int want_silent;
  465. /*
  466. * Only fix cmdline when requested. The environment variable can be:
  467. *
  468. * no - we never fixup
  469. * yes - we always fixup
  470. * unset - we rely on the console silent flag
  471. */
  472. want_silent = env_get_yesno("silent_linux");
  473. if (want_silent == 0)
  474. return;
  475. else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT))
  476. return;
  477. debug("before silent fix-up: %s\n", cmdline);
  478. if (cmdline && (cmdline[0] != '\0')) {
  479. char *start = strstr(cmdline, CONSOLE_ARG);
  480. /* Allocate space for maximum possible new command line */
  481. buf = malloc(strlen(cmdline) + 1 + CONSOLE_ARG_LEN + 1);
  482. if (!buf) {
  483. debug("%s: out of memory\n", __func__);
  484. return;
  485. }
  486. if (start) {
  487. char *end = strchr(start, ' ');
  488. int num_start_bytes = start - cmdline + CONSOLE_ARG_LEN;
  489. strncpy(buf, cmdline, num_start_bytes);
  490. if (end)
  491. strcpy(buf + num_start_bytes, end);
  492. else
  493. buf[num_start_bytes] = '\0';
  494. } else {
  495. sprintf(buf, "%s %s", cmdline, CONSOLE_ARG);
  496. }
  497. env_val = buf;
  498. } else {
  499. buf = NULL;
  500. env_val = CONSOLE_ARG;
  501. }
  502. env_set("bootargs", env_val);
  503. debug("after silent fix-up: %s\n", env_val);
  504. free(buf);
  505. }
  506. #endif /* CONFIG_SILENT_CONSOLE */
  507. /**
  508. * Execute selected states of the bootm command.
  509. *
  510. * Note the arguments to this state must be the first argument, Any 'bootm'
  511. * or sub-command arguments must have already been taken.
  512. *
  513. * Note that if states contains more than one flag it MUST contain
  514. * BOOTM_STATE_START, since this handles and consumes the command line args.
  515. *
  516. * Also note that aside from boot_os_fn functions and bootm_load_os no other
  517. * functions we store the return value of in 'ret' may use a negative return
  518. * value, without special handling.
  519. *
  520. * @param cmdtp Pointer to bootm command table entry
  521. * @param flag Command flags (CMD_FLAG_...)
  522. * @param argc Number of subcommand arguments (0 = no arguments)
  523. * @param argv Arguments
  524. * @param states Mask containing states to run (BOOTM_STATE_...)
  525. * @param images Image header information
  526. * @param boot_progress 1 to show boot progress, 0 to not do this
  527. * @return 0 if ok, something else on error. Some errors will cause this
  528. * function to perform a reboot! If states contains BOOTM_STATE_OS_GO
  529. * then the intent is to boot an OS, so this function will not return
  530. * unless the image type is standalone.
  531. */
  532. int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
  533. int states, bootm_headers_t *images, int boot_progress)
  534. {
  535. boot_os_fn *boot_fn;
  536. ulong iflag = 0;
  537. int ret = 0, need_boot_fn;
  538. images->state |= states;
  539. /*
  540. * Work through the states and see how far we get. We stop on
  541. * any error.
  542. */
  543. if (states & BOOTM_STATE_START)
  544. ret = bootm_start(cmdtp, flag, argc, argv);
  545. if (!ret && (states & BOOTM_STATE_FINDOS))
  546. ret = bootm_find_os(cmdtp, flag, argc, argv);
  547. if (!ret && (states & BOOTM_STATE_FINDOTHER))
  548. ret = bootm_find_other(cmdtp, flag, argc, argv);
  549. /* Load the OS */
  550. if (!ret && (states & BOOTM_STATE_LOADOS)) {
  551. iflag = bootm_disable_interrupts();
  552. ret = bootm_load_os(images, 0);
  553. if (ret && ret != BOOTM_ERR_OVERLAP)
  554. goto err;
  555. else if (ret == BOOTM_ERR_OVERLAP)
  556. ret = 0;
  557. }
  558. /* Relocate the ramdisk */
  559. #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
  560. if (!ret && (states & BOOTM_STATE_RAMDISK)) {
  561. ulong rd_len = images->rd_end - images->rd_start;
  562. ret = boot_ramdisk_high(&images->lmb, images->rd_start,
  563. rd_len, &images->initrd_start, &images->initrd_end);
  564. if (!ret) {
  565. env_set_hex("initrd_start", images->initrd_start);
  566. env_set_hex("initrd_end", images->initrd_end);
  567. }
  568. }
  569. #endif
  570. #if IMAGE_ENABLE_OF_LIBFDT && defined(CONFIG_LMB)
  571. if (!ret && (states & BOOTM_STATE_FDT)) {
  572. boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
  573. ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
  574. &images->ft_len);
  575. }
  576. #endif
  577. /* From now on, we need the OS boot function */
  578. if (ret)
  579. return ret;
  580. boot_fn = bootm_os_get_boot_func(images->os.os);
  581. need_boot_fn = states & (BOOTM_STATE_OS_CMDLINE |
  582. BOOTM_STATE_OS_BD_T | BOOTM_STATE_OS_PREP |
  583. BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO);
  584. if (boot_fn == NULL && need_boot_fn) {
  585. if (iflag)
  586. enable_interrupts();
  587. printf("ERROR: booting os '%s' (%d) is not supported\n",
  588. genimg_get_os_name(images->os.os), images->os.os);
  589. bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
  590. return 1;
  591. }
  592. /* Call various other states that are not generally used */
  593. if (!ret && (states & BOOTM_STATE_OS_CMDLINE))
  594. ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, images);
  595. if (!ret && (states & BOOTM_STATE_OS_BD_T))
  596. ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
  597. if (!ret && (states & BOOTM_STATE_OS_PREP)) {
  598. #if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
  599. if (images->os.os == IH_OS_LINUX)
  600. fixup_silent_linux();
  601. #endif
  602. ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
  603. }
  604. #ifdef CONFIG_TRACE
  605. /* Pretend to run the OS, then run a user command */
  606. if (!ret && (states & BOOTM_STATE_OS_FAKE_GO)) {
  607. char *cmd_list = env_get("fakegocmd");
  608. ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_FAKE_GO,
  609. images, boot_fn);
  610. if (!ret && cmd_list)
  611. ret = run_command_list(cmd_list, -1, flag);
  612. }
  613. #endif
  614. /* Check for unsupported subcommand. */
  615. if (ret) {
  616. puts("subcommand not supported\n");
  617. return ret;
  618. }
  619. /* Now run the OS! We hope this doesn't return */
  620. if (!ret && (states & BOOTM_STATE_OS_GO))
  621. ret = boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,
  622. images, boot_fn);
  623. /* Deal with any fallout */
  624. err:
  625. if (iflag)
  626. enable_interrupts();
  627. if (ret == BOOTM_ERR_UNIMPLEMENTED)
  628. bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
  629. else if (ret == BOOTM_ERR_RESET)
  630. do_reset(cmdtp, flag, argc, argv);
  631. return ret;
  632. }
  633. #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
  634. /**
  635. * image_get_kernel - verify legacy format kernel image
  636. * @img_addr: in RAM address of the legacy format image to be verified
  637. * @verify: data CRC verification flag
  638. *
  639. * image_get_kernel() verifies legacy image integrity and returns pointer to
  640. * legacy image header if image verification was completed successfully.
  641. *
  642. * returns:
  643. * pointer to a legacy image header if valid image was found
  644. * otherwise return NULL
  645. */
  646. static image_header_t *image_get_kernel(ulong img_addr, int verify)
  647. {
  648. image_header_t *hdr = (image_header_t *)img_addr;
  649. if (!image_check_magic(hdr)) {
  650. puts("Bad Magic Number\n");
  651. bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
  652. return NULL;
  653. }
  654. bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
  655. if (!image_check_hcrc(hdr)) {
  656. puts("Bad Header Checksum\n");
  657. bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
  658. return NULL;
  659. }
  660. bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
  661. image_print_contents(hdr);
  662. if (verify) {
  663. puts(" Verifying Checksum ... ");
  664. if (!image_check_dcrc(hdr)) {
  665. printf("Bad Data CRC\n");
  666. bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
  667. return NULL;
  668. }
  669. puts("OK\n");
  670. }
  671. bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
  672. if (!image_check_target_arch(hdr)) {
  673. printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
  674. bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
  675. return NULL;
  676. }
  677. return hdr;
  678. }
  679. #endif
  680. /**
  681. * boot_get_kernel - find kernel image
  682. * @os_data: pointer to a ulong variable, will hold os data start address
  683. * @os_len: pointer to a ulong variable, will hold os data length
  684. *
  685. * boot_get_kernel() tries to find a kernel image, verifies its integrity
  686. * and locates kernel data.
  687. *
  688. * returns:
  689. * pointer to image header if valid image was found, plus kernel start
  690. * address and length, otherwise NULL
  691. */
  692. static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
  693. char * const argv[], bootm_headers_t *images,
  694. ulong *os_data, ulong *os_len)
  695. {
  696. #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
  697. image_header_t *hdr;
  698. #endif
  699. ulong img_addr;
  700. const void *buf;
  701. const char *fit_uname_config = NULL;
  702. const char *fit_uname_kernel = NULL;
  703. #if IMAGE_ENABLE_FIT
  704. int os_noffset;
  705. #endif
  706. img_addr = genimg_get_kernel_addr_fit(argc < 1 ? NULL : argv[0],
  707. &fit_uname_config,
  708. &fit_uname_kernel);
  709. bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
  710. /* check image type, for FIT images get FIT kernel node */
  711. *os_data = *os_len = 0;
  712. buf = map_sysmem(img_addr, 0);
  713. switch (genimg_get_format(buf)) {
  714. #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
  715. case IMAGE_FORMAT_LEGACY:
  716. printf("## Booting kernel from Legacy Image at %08lx ...\n",
  717. img_addr);
  718. hdr = image_get_kernel(img_addr, images->verify);
  719. if (!hdr)
  720. return NULL;
  721. bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
  722. /* get os_data and os_len */
  723. switch (image_get_type(hdr)) {
  724. case IH_TYPE_KERNEL:
  725. case IH_TYPE_KERNEL_NOLOAD:
  726. *os_data = image_get_data(hdr);
  727. *os_len = image_get_data_size(hdr);
  728. break;
  729. case IH_TYPE_MULTI:
  730. image_multi_getimg(hdr, 0, os_data, os_len);
  731. break;
  732. case IH_TYPE_STANDALONE:
  733. *os_data = image_get_data(hdr);
  734. *os_len = image_get_data_size(hdr);
  735. break;
  736. default:
  737. printf("Wrong Image Type for %s command\n",
  738. cmdtp->name);
  739. bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
  740. return NULL;
  741. }
  742. /*
  743. * copy image header to allow for image overwrites during
  744. * kernel decompression.
  745. */
  746. memmove(&images->legacy_hdr_os_copy, hdr,
  747. sizeof(image_header_t));
  748. /* save pointer to image header */
  749. images->legacy_hdr_os = hdr;
  750. images->legacy_hdr_valid = 1;
  751. bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
  752. break;
  753. #endif
  754. #if IMAGE_ENABLE_FIT
  755. case IMAGE_FORMAT_FIT:
  756. os_noffset = fit_image_load(images, img_addr,
  757. &fit_uname_kernel, &fit_uname_config,
  758. IH_ARCH_DEFAULT, IH_TYPE_KERNEL,
  759. BOOTSTAGE_ID_FIT_KERNEL_START,
  760. FIT_LOAD_IGNORED, os_data, os_len);
  761. if (os_noffset < 0)
  762. return NULL;
  763. images->fit_hdr_os = map_sysmem(img_addr, 0);
  764. images->fit_uname_os = fit_uname_kernel;
  765. images->fit_uname_cfg = fit_uname_config;
  766. images->fit_noffset_os = os_noffset;
  767. break;
  768. #endif
  769. #ifdef CONFIG_ANDROID_BOOT_IMAGE
  770. case IMAGE_FORMAT_ANDROID:
  771. printf("## Booting Android Image at 0x%08lx ...\n", img_addr);
  772. if (android_image_get_kernel(buf, images->verify,
  773. os_data, os_len))
  774. return NULL;
  775. break;
  776. #endif
  777. default:
  778. printf("Wrong Image Format for %s command\n", cmdtp->name);
  779. bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
  780. return NULL;
  781. }
  782. debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
  783. *os_data, *os_len, *os_len);
  784. return buf;
  785. }
  786. #else /* USE_HOSTCC */
  787. void memmove_wd(void *to, void *from, size_t len, ulong chunksz)
  788. {
  789. memmove(to, from, len);
  790. }
  791. static int bootm_host_load_image(const void *fit, int req_image_type)
  792. {
  793. const char *fit_uname_config = NULL;
  794. ulong data, len;
  795. bootm_headers_t images;
  796. int noffset;
  797. ulong load_end;
  798. uint8_t image_type;
  799. uint8_t imape_comp;
  800. void *load_buf;
  801. int ret;
  802. memset(&images, '\0', sizeof(images));
  803. images.verify = 1;
  804. noffset = fit_image_load(&images, (ulong)fit,
  805. NULL, &fit_uname_config,
  806. IH_ARCH_DEFAULT, req_image_type, -1,
  807. FIT_LOAD_IGNORED, &data, &len);
  808. if (noffset < 0)
  809. return noffset;
  810. if (fit_image_get_type(fit, noffset, &image_type)) {
  811. puts("Can't get image type!\n");
  812. return -EINVAL;
  813. }
  814. if (fit_image_get_comp(fit, noffset, &imape_comp)) {
  815. puts("Can't get image compression!\n");
  816. return -EINVAL;
  817. }
  818. /* Allow the image to expand by a factor of 4, should be safe */
  819. load_buf = malloc((1 << 20) + len * 4);
  820. ret = bootm_decomp_image(imape_comp, 0, data, image_type, load_buf,
  821. (void *)data, len, CONFIG_SYS_BOOTM_LEN,
  822. &load_end);
  823. free(load_buf);
  824. if (ret && ret != BOOTM_ERR_UNIMPLEMENTED)
  825. return ret;
  826. return 0;
  827. }
  828. int bootm_host_load_images(const void *fit, int cfg_noffset)
  829. {
  830. static uint8_t image_types[] = {
  831. IH_TYPE_KERNEL,
  832. IH_TYPE_FLATDT,
  833. IH_TYPE_RAMDISK,
  834. };
  835. int err = 0;
  836. int i;
  837. for (i = 0; i < ARRAY_SIZE(image_types); i++) {
  838. int ret;
  839. ret = bootm_host_load_image(fit, image_types[i]);
  840. if (!err && ret && ret != -ENOENT)
  841. err = ret;
  842. }
  843. /* Return the first error we found */
  844. return err;
  845. }
  846. #endif /* ndef USE_HOSTCC */