arm64: booti: add missing unmap_sysmem()
[platform/kernel/u-boot.git] / cmd / bootm.c
1 /*
2  * (C) Copyright 2000-2009
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 /*
9  * Boot support
10  */
11 #include <common.h>
12 #include <bootm.h>
13 #include <command.h>
14 #include <environment.h>
15 #include <errno.h>
16 #include <image.h>
17 #include <lmb.h>
18 #include <malloc.h>
19 #include <mapmem.h>
20 #include <nand.h>
21 #include <asm/byteorder.h>
22 #include <linux/compiler.h>
23 #include <linux/ctype.h>
24 #include <linux/err.h>
25 #include <u-boot/zlib.h>
26
27 DECLARE_GLOBAL_DATA_PTR;
28
29 #if defined(CONFIG_CMD_IMI)
30 static int image_info(unsigned long addr);
31 #endif
32
33 #if defined(CONFIG_CMD_IMLS)
34 #include <flash.h>
35 #include <mtd/cfi_flash.h>
36 extern flash_info_t flash_info[]; /* info for FLASH chips */
37 #endif
38
39 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
40 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
41 #endif
42
43 bootm_headers_t images;         /* pointers to os/initrd/fdt images */
44
45 /* we overload the cmd field with our state machine info instead of a
46  * function pointer */
47 static cmd_tbl_t cmd_bootm_sub[] = {
48         U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
49         U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
50 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
51         U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""),
52 #endif
53 #ifdef CONFIG_OF_LIBFDT
54         U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""),
55 #endif
56         U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""),
57         U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""),
58         U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""),
59         U_BOOT_CMD_MKENT(fake, 0, 1, (void *)BOOTM_STATE_OS_FAKE_GO, "", ""),
60         U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
61 };
62
63 static int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
64                         char * const argv[])
65 {
66         int ret = 0;
67         long state;
68         cmd_tbl_t *c;
69
70         c = find_cmd_tbl(argv[0], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
71         argc--; argv++;
72
73         if (c) {
74                 state = (long)c->cmd;
75                 if (state == BOOTM_STATE_START)
76                         state |= BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER;
77         } else {
78                 /* Unrecognized command */
79                 return CMD_RET_USAGE;
80         }
81
82         if (((state & BOOTM_STATE_START) != BOOTM_STATE_START) &&
83             images.state >= state) {
84                 printf("Trying to execute a command out of order\n");
85                 return CMD_RET_USAGE;
86         }
87
88         ret = do_bootm_states(cmdtp, flag, argc, argv, state, &images, 0);
89
90         return ret;
91 }
92
93 /*******************************************************************/
94 /* bootm - boot application image from image in memory */
95 /*******************************************************************/
96
97 int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
98 {
99 #ifdef CONFIG_NEEDS_MANUAL_RELOC
100         static int relocated = 0;
101
102         if (!relocated) {
103                 int i;
104
105                 /* relocate names of sub-command table */
106                 for (i = 0; i < ARRAY_SIZE(cmd_bootm_sub); i++)
107                         cmd_bootm_sub[i].name += gd->reloc_off;
108
109                 relocated = 1;
110         }
111 #endif
112
113         /* determine if we have a sub command */
114         argc--; argv++;
115         if (argc > 0) {
116                 char *endp;
117
118                 simple_strtoul(argv[0], &endp, 16);
119                 /* endp pointing to NULL means that argv[0] was just a
120                  * valid number, pass it along to the normal bootm processing
121                  *
122                  * If endp is ':' or '#' assume a FIT identifier so pass
123                  * along for normal processing.
124                  *
125                  * Right now we assume the first arg should never be '-'
126                  */
127                 if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
128                         return do_bootm_subcommand(cmdtp, flag, argc, argv);
129         }
130
131         return do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START |
132                 BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER |
133                 BOOTM_STATE_LOADOS |
134 #if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
135                 BOOTM_STATE_OS_CMDLINE |
136 #endif
137                 BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
138                 BOOTM_STATE_OS_GO, &images, 1);
139 }
140
141 int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
142 {
143         const char *ep = getenv("autostart");
144
145         if (ep && !strcmp(ep, "yes")) {
146                 char *local_args[2];
147                 local_args[0] = (char *)cmd;
148                 local_args[1] = NULL;
149                 printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
150                 return do_bootm(cmdtp, 0, 1, local_args);
151         }
152
153         return 0;
154 }
155
156 #ifdef CONFIG_SYS_LONGHELP
157 static char bootm_help_text[] =
158         "[addr [arg ...]]\n    - boot application image stored in memory\n"
159         "\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
160         "\t'arg' can be the address of an initrd image\n"
161 #if defined(CONFIG_OF_LIBFDT)
162         "\tWhen booting a Linux kernel which requires a flat device-tree\n"
163         "\ta third argument is required which is the address of the\n"
164         "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
165         "\tuse a '-' for the second argument. If you do not pass a third\n"
166         "\ta bd_info struct will be passed instead\n"
167 #endif
168 #if defined(CONFIG_FIT)
169         "\t\nFor the new multi component uImage format (FIT) addresses\n"
170         "\tmust be extened to include component or configuration unit name:\n"
171         "\taddr:<subimg_uname> - direct component image specification\n"
172         "\taddr#<conf_uname>   - configuration specification\n"
173         "\tUse iminfo command to get the list of existing component\n"
174         "\timages and configurations.\n"
175 #endif
176         "\nSub-commands to do part of the bootm sequence.  The sub-commands "
177         "must be\n"
178         "issued in the order below (it's ok to not issue all sub-commands):\n"
179         "\tstart [addr [arg ...]]\n"
180         "\tloados  - load OS image\n"
181 #if defined(CONFIG_SYS_BOOT_RAMDISK_HIGH)
182         "\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
183 #endif
184 #if defined(CONFIG_OF_LIBFDT)
185         "\tfdt     - relocate flat device tree\n"
186 #endif
187         "\tcmdline - OS specific command line processing/setup\n"
188         "\tbdt     - OS specific bd_t processing\n"
189         "\tprep    - OS specific prep before relocation or go\n"
190 #if defined(CONFIG_TRACE)
191         "\tfake    - OS specific fake start without go\n"
192 #endif
193         "\tgo      - start OS";
194 #endif
195
196 U_BOOT_CMD(
197         bootm,  CONFIG_SYS_MAXARGS,     1,      do_bootm,
198         "boot application image from memory", bootm_help_text
199 );
200
201 /*******************************************************************/
202 /* bootd - boot default image */
203 /*******************************************************************/
204 #if defined(CONFIG_CMD_BOOTD)
205 int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
206 {
207         return run_command(getenv("bootcmd"), flag);
208 }
209
210 U_BOOT_CMD(
211         boot,   1,      1,      do_bootd,
212         "boot default, i.e., run 'bootcmd'",
213         ""
214 );
215
216 /* keep old command name "bootd" for backward compatibility */
217 U_BOOT_CMD(
218         bootd, 1,       1,      do_bootd,
219         "boot default, i.e., run 'bootcmd'",
220         ""
221 );
222
223 #endif
224
225
226 /*******************************************************************/
227 /* iminfo - print header info for a requested image */
228 /*******************************************************************/
229 #if defined(CONFIG_CMD_IMI)
230 static int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
231 {
232         int     arg;
233         ulong   addr;
234         int     rcode = 0;
235
236         if (argc < 2) {
237                 return image_info(load_addr);
238         }
239
240         for (arg = 1; arg < argc; ++arg) {
241                 addr = simple_strtoul(argv[arg], NULL, 16);
242                 if (image_info(addr) != 0)
243                         rcode = 1;
244         }
245         return rcode;
246 }
247
248 static int image_info(ulong addr)
249 {
250         void *hdr = (void *)addr;
251
252         printf("\n## Checking Image at %08lx ...\n", addr);
253
254         switch (genimg_get_format(hdr)) {
255 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
256         case IMAGE_FORMAT_LEGACY:
257                 puts("   Legacy image found\n");
258                 if (!image_check_magic(hdr)) {
259                         puts("   Bad Magic Number\n");
260                         return 1;
261                 }
262
263                 if (!image_check_hcrc(hdr)) {
264                         puts("   Bad Header Checksum\n");
265                         return 1;
266                 }
267
268                 image_print_contents(hdr);
269
270                 puts("   Verifying Checksum ... ");
271                 if (!image_check_dcrc(hdr)) {
272                         puts("   Bad Data CRC\n");
273                         return 1;
274                 }
275                 puts("OK\n");
276                 return 0;
277 #endif
278 #if defined(CONFIG_FIT)
279         case IMAGE_FORMAT_FIT:
280                 puts("   FIT image found\n");
281
282                 if (!fit_check_format(hdr)) {
283                         puts("Bad FIT image format!\n");
284                         return 1;
285                 }
286
287                 fit_print_contents(hdr);
288
289                 if (!fit_all_image_verify(hdr)) {
290                         puts("Bad hash in FIT image!\n");
291                         return 1;
292                 }
293
294                 return 0;
295 #endif
296         default:
297                 puts("Unknown image format!\n");
298                 break;
299         }
300
301         return 1;
302 }
303
304 U_BOOT_CMD(
305         iminfo, CONFIG_SYS_MAXARGS,     1,      do_iminfo,
306         "print header information for application image",
307         "addr [addr ...]\n"
308         "    - print header information for application image starting at\n"
309         "      address 'addr' in memory; this includes verification of the\n"
310         "      image contents (magic number, header and payload checksums)"
311 );
312 #endif
313
314
315 /*******************************************************************/
316 /* imls - list all images found in flash */
317 /*******************************************************************/
318 #if defined(CONFIG_CMD_IMLS)
319 static int do_imls_nor(void)
320 {
321         flash_info_t *info;
322         int i, j;
323         void *hdr;
324
325         for (i = 0, info = &flash_info[0];
326                 i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) {
327
328                 if (info->flash_id == FLASH_UNKNOWN)
329                         goto next_bank;
330                 for (j = 0; j < info->sector_count; ++j) {
331
332                         hdr = (void *)info->start[j];
333                         if (!hdr)
334                                 goto next_sector;
335
336                         switch (genimg_get_format(hdr)) {
337 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
338                         case IMAGE_FORMAT_LEGACY:
339                                 if (!image_check_hcrc(hdr))
340                                         goto next_sector;
341
342                                 printf("Legacy Image at %08lX:\n", (ulong)hdr);
343                                 image_print_contents(hdr);
344
345                                 puts("   Verifying Checksum ... ");
346                                 if (!image_check_dcrc(hdr)) {
347                                         puts("Bad Data CRC\n");
348                                 } else {
349                                         puts("OK\n");
350                                 }
351                                 break;
352 #endif
353 #if defined(CONFIG_FIT)
354                         case IMAGE_FORMAT_FIT:
355                                 if (!fit_check_format(hdr))
356                                         goto next_sector;
357
358                                 printf("FIT Image at %08lX:\n", (ulong)hdr);
359                                 fit_print_contents(hdr);
360                                 break;
361 #endif
362                         default:
363                                 goto next_sector;
364                         }
365
366 next_sector:            ;
367                 }
368 next_bank:      ;
369         }
370         return 0;
371 }
372 #endif
373
374 #if defined(CONFIG_CMD_IMLS_NAND)
375 static int nand_imls_legacyimage(nand_info_t *nand, int nand_dev, loff_t off,
376                 size_t len)
377 {
378         void *imgdata;
379         int ret;
380
381         imgdata = malloc(len);
382         if (!imgdata) {
383                 printf("May be a Legacy Image at NAND device %d offset %08llX:\n",
384                                 nand_dev, off);
385                 printf("   Low memory(cannot allocate memory for image)\n");
386                 return -ENOMEM;
387         }
388
389         ret = nand_read_skip_bad(nand, off, &len,
390                         imgdata);
391         if (ret < 0 && ret != -EUCLEAN) {
392                 free(imgdata);
393                 return ret;
394         }
395
396         if (!image_check_hcrc(imgdata)) {
397                 free(imgdata);
398                 return 0;
399         }
400
401         printf("Legacy Image at NAND device %d offset %08llX:\n",
402                         nand_dev, off);
403         image_print_contents(imgdata);
404
405         puts("   Verifying Checksum ... ");
406         if (!image_check_dcrc(imgdata))
407                 puts("Bad Data CRC\n");
408         else
409                 puts("OK\n");
410
411         free(imgdata);
412
413         return 0;
414 }
415
416 static int nand_imls_fitimage(nand_info_t *nand, int nand_dev, loff_t off,
417                 size_t len)
418 {
419         void *imgdata;
420         int ret;
421
422         imgdata = malloc(len);
423         if (!imgdata) {
424                 printf("May be a FIT Image at NAND device %d offset %08llX:\n",
425                                 nand_dev, off);
426                 printf("   Low memory(cannot allocate memory for image)\n");
427                 return -ENOMEM;
428         }
429
430         ret = nand_read_skip_bad(nand, off, &len,
431                         imgdata);
432         if (ret < 0 && ret != -EUCLEAN) {
433                 free(imgdata);
434                 return ret;
435         }
436
437         if (!fit_check_format(imgdata)) {
438                 free(imgdata);
439                 return 0;
440         }
441
442         printf("FIT Image at NAND device %d offset %08llX:\n", nand_dev, off);
443
444         fit_print_contents(imgdata);
445         free(imgdata);
446
447         return 0;
448 }
449
450 static int do_imls_nand(void)
451 {
452         nand_info_t *nand;
453         int nand_dev = nand_curr_device;
454         size_t len;
455         loff_t off;
456         u32 buffer[16];
457
458         if (nand_dev < 0 || nand_dev >= CONFIG_SYS_MAX_NAND_DEVICE) {
459                 puts("\nNo NAND devices available\n");
460                 return -ENODEV;
461         }
462
463         printf("\n");
464
465         for (nand_dev = 0; nand_dev < CONFIG_SYS_MAX_NAND_DEVICE; nand_dev++) {
466                 nand = &nand_info[nand_dev];
467                 if (!nand->name || !nand->size)
468                         continue;
469
470                 for (off = 0; off < nand->size; off += nand->erasesize) {
471                         const image_header_t *header;
472                         int ret;
473
474                         if (nand_block_isbad(nand, off))
475                                 continue;
476
477                         len = sizeof(buffer);
478
479                         ret = nand_read(nand, off, &len, (u8 *)buffer);
480                         if (ret < 0 && ret != -EUCLEAN) {
481                                 printf("NAND read error %d at offset %08llX\n",
482                                                 ret, off);
483                                 continue;
484                         }
485
486                         switch (genimg_get_format(buffer)) {
487 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
488                         case IMAGE_FORMAT_LEGACY:
489                                 header = (const image_header_t *)buffer;
490
491                                 len = image_get_image_size(header);
492                                 nand_imls_legacyimage(nand, nand_dev, off, len);
493                                 break;
494 #endif
495 #if defined(CONFIG_FIT)
496                         case IMAGE_FORMAT_FIT:
497                                 len = fit_get_size(buffer);
498                                 nand_imls_fitimage(nand, nand_dev, off, len);
499                                 break;
500 #endif
501                         }
502                 }
503         }
504
505         return 0;
506 }
507 #endif
508
509 #if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
510 static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
511 {
512         int ret_nor = 0, ret_nand = 0;
513
514 #if defined(CONFIG_CMD_IMLS)
515         ret_nor = do_imls_nor();
516 #endif
517
518 #if defined(CONFIG_CMD_IMLS_NAND)
519         ret_nand = do_imls_nand();
520 #endif
521
522         if (ret_nor)
523                 return ret_nor;
524
525         if (ret_nand)
526                 return ret_nand;
527
528         return (0);
529 }
530
531 U_BOOT_CMD(
532         imls,   1,              1,      do_imls,
533         "list all images found in flash",
534         "\n"
535         "    - Prints information about all images found at sector/block\n"
536         "      boundaries in nor/nand flash."
537 );
538 #endif
539
540 #ifdef CONFIG_CMD_BOOTZ
541
542 int __weak bootz_setup(ulong image, ulong *start, ulong *end)
543 {
544         /* Please define bootz_setup() for your platform */
545
546         puts("Your platform's zImage format isn't supported yet!\n");
547         return -1;
548 }
549
550 /*
551  * zImage booting support
552  */
553 static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
554                         char * const argv[], bootm_headers_t *images)
555 {
556         int ret;
557         ulong zi_start, zi_end;
558
559         ret = do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START,
560                               images, 1);
561
562         /* Setup Linux kernel zImage entry point */
563         if (!argc) {
564                 images->ep = load_addr;
565                 debug("*  kernel: default image load address = 0x%08lx\n",
566                                 load_addr);
567         } else {
568                 images->ep = simple_strtoul(argv[0], NULL, 16);
569                 debug("*  kernel: cmdline image address = 0x%08lx\n",
570                         images->ep);
571         }
572
573         ret = bootz_setup(images->ep, &zi_start, &zi_end);
574         if (ret != 0)
575                 return 1;
576
577         lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
578
579         /*
580          * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not
581          * have a header that provide this informaiton.
582          */
583         if (bootm_find_images(flag, argc, argv))
584                 return 1;
585
586         return 0;
587 }
588
589 int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
590 {
591         int ret;
592
593         /* Consume 'bootz' */
594         argc--; argv++;
595
596         if (bootz_start(cmdtp, flag, argc, argv, &images))
597                 return 1;
598
599         /*
600          * We are doing the BOOTM_STATE_LOADOS state ourselves, so must
601          * disable interrupts ourselves
602          */
603         bootm_disable_interrupts();
604
605         images.os.os = IH_OS_LINUX;
606         ret = do_bootm_states(cmdtp, flag, argc, argv,
607                               BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
608                               BOOTM_STATE_OS_GO,
609                               &images, 1);
610
611         return ret;
612 }
613
614 #ifdef CONFIG_SYS_LONGHELP
615 static char bootz_help_text[] =
616         "[addr [initrd[:size]] [fdt]]\n"
617         "    - boot Linux zImage stored in memory\n"
618         "\tThe argument 'initrd' is optional and specifies the address\n"
619         "\tof the initrd in memory. The optional argument ':size' allows\n"
620         "\tspecifying the size of RAW initrd.\n"
621 #if defined(CONFIG_OF_LIBFDT)
622         "\tWhen booting a Linux kernel which requires a flat device-tree\n"
623         "\ta third argument is required which is the address of the\n"
624         "\tdevice-tree blob. To boot that kernel without an initrd image,\n"
625         "\tuse a '-' for the second argument. If you do not pass a third\n"
626         "\ta bd_info struct will be passed instead\n"
627 #endif
628         "";
629 #endif
630
631 U_BOOT_CMD(
632         bootz,  CONFIG_SYS_MAXARGS,     1,      do_bootz,
633         "boot Linux zImage image from memory", bootz_help_text
634 );
635 #endif  /* CONFIG_CMD_BOOTZ */
636
637 #ifdef CONFIG_CMD_BOOTI
638 /* See Documentation/arm64/booting.txt in the Linux kernel */
639 struct Image_header {
640         uint32_t        code0;          /* Executable code */
641         uint32_t        code1;          /* Executable code */
642         uint64_t        text_offset;    /* Image load offset, LE */
643         uint64_t        image_size;     /* Effective Image size, LE */
644         uint64_t        res1;           /* reserved */
645         uint64_t        res2;           /* reserved */
646         uint64_t        res3;           /* reserved */
647         uint64_t        res4;           /* reserved */
648         uint32_t        magic;          /* Magic number */
649         uint32_t        res5;
650 };
651
652 #define LINUX_ARM64_IMAGE_MAGIC 0x644d5241
653
654 static int booti_setup(bootm_headers_t *images)
655 {
656         struct Image_header *ih;
657         uint64_t dst;
658
659         ih = (struct Image_header *)map_sysmem(images->ep, 0);
660
661         if (ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)) {
662                 puts("Bad Linux ARM64 Image magic!\n");
663                 return 1;
664         }
665         
666         if (ih->image_size == 0) {
667                 puts("Image lacks image_size field, assuming 16MiB\n");
668                 ih->image_size = (16 << 20);
669         }
670
671         /*
672          * If we are not at the correct run-time location, set the new
673          * correct location and then move the image there.
674          */
675         dst = gd->bd->bi_dram[0].start + le32_to_cpu(ih->text_offset);
676
677         unmap_sysmem(ih);
678
679         if (images->ep != dst) {
680                 void *src;
681
682                 debug("Moving Image from 0x%lx to 0x%llx\n", images->ep, dst);
683
684                 src = (void *)images->ep;
685                 images->ep = dst;
686                 memmove((void *)dst, src, le32_to_cpu(ih->image_size));
687         }
688
689         return 0;
690 }
691
692 /*
693  * Image booting support
694  */
695 static int booti_start(cmd_tbl_t *cmdtp, int flag, int argc,
696                         char * const argv[], bootm_headers_t *images)
697 {
698         int ret;
699         struct Image_header *ih;
700
701         ret = do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START,
702                               images, 1);
703
704         /* Setup Linux kernel Image entry point */
705         if (!argc) {
706                 images->ep = load_addr;
707                 debug("*  kernel: default image load address = 0x%08lx\n",
708                                 load_addr);
709         } else {
710                 images->ep = simple_strtoul(argv[0], NULL, 16);
711                 debug("*  kernel: cmdline image address = 0x%08lx\n",
712                         images->ep);
713         }
714
715         ret = booti_setup(images);
716         if (ret != 0)
717                 return 1;
718
719         ih = (struct Image_header *)map_sysmem(images->ep, 0);
720
721         lmb_reserve(&images->lmb, images->ep, le32_to_cpu(ih->image_size));
722
723         unmap_sysmem(ih);
724
725         /*
726          * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not
727          * have a header that provide this informaiton.
728          */
729         if (bootm_find_images(flag, argc, argv))
730                 return 1;
731
732         return 0;
733 }
734
735 int do_booti(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
736 {
737         int ret;
738
739         /* Consume 'booti' */
740         argc--; argv++;
741
742         if (booti_start(cmdtp, flag, argc, argv, &images))
743                 return 1;
744
745         /*
746          * We are doing the BOOTM_STATE_LOADOS state ourselves, so must
747          * disable interrupts ourselves
748          */
749         bootm_disable_interrupts();
750
751         images.os.os = IH_OS_LINUX;
752         ret = do_bootm_states(cmdtp, flag, argc, argv,
753                               BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
754                               BOOTM_STATE_OS_GO,
755                               &images, 1);
756
757         return ret;
758 }
759
760 #ifdef CONFIG_SYS_LONGHELP
761 static char booti_help_text[] =
762         "[addr [initrd[:size]] [fdt]]\n"
763         "    - boot arm64 Linux Image stored in memory\n"
764         "\tThe argument 'initrd' is optional and specifies the address\n"
765         "\tof an initrd in memory. The optional parameter ':size' allows\n"
766         "\tspecifying the size of a RAW initrd.\n"
767 #if defined(CONFIG_OF_LIBFDT)
768         "\tSince booting a Linux kernel requires a flat device-tree, a\n"
769         "\tthird argument providing the address of the device-tree blob\n"
770         "\tis required. To boot a kernel with a device-tree blob but\n"
771         "\twithout an initrd image, use a '-' for the initrd argument.\n"
772 #endif
773         "";
774 #endif
775
776 U_BOOT_CMD(
777         booti,  CONFIG_SYS_MAXARGS,     1,      do_booti,
778         "boot arm64 Linux Image image from memory", booti_help_text
779 );
780 #endif  /* CONFIG_CMD_BOOTI */