]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/image.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sandbox: image: Add support for booting images in sandbox
[people/ms/u-boot.git] / common / image.c
1 /*
2 * (C) Copyright 2008 Semihalf
3 *
4 * (C) Copyright 2000-2006
5 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6 *
7 * See file CREDITS for list of people who contributed to this
8 * project.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 * MA 02111-1307 USA
24 */
25
26 #ifndef USE_HOSTCC
27 #include <common.h>
28 #include <watchdog.h>
29
30 #ifdef CONFIG_SHOW_BOOT_PROGRESS
31 #include <status_led.h>
32 #endif
33
34 #ifdef CONFIG_HAS_DATAFLASH
35 #include <dataflash.h>
36 #endif
37
38 #ifdef CONFIG_LOGBUFFER
39 #include <logbuff.h>
40 #endif
41
42 #include <rtc.h>
43
44 #include <environment.h>
45 #include <image.h>
46
47 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
48 #include <libfdt.h>
49 #include <fdt_support.h>
50 #endif
51
52 #include <u-boot/md5.h>
53 #include <sha1.h>
54 #include <asm/io.h>
55
56 #ifdef CONFIG_CMD_BDI
57 extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
58 #endif
59
60 DECLARE_GLOBAL_DATA_PTR;
61
62 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
63 int verify);
64 #else
65 #include "mkimage.h"
66 #include <u-boot/md5.h>
67 #include <time.h>
68 #include <image.h>
69 #endif /* !USE_HOSTCC*/
70
71 #include <u-boot/crc.h>
72
73 static const table_entry_t uimage_arch[] = {
74 { IH_ARCH_INVALID, NULL, "Invalid ARCH", },
75 { IH_ARCH_ALPHA, "alpha", "Alpha", },
76 { IH_ARCH_ARM, "arm", "ARM", },
77 { IH_ARCH_I386, "x86", "Intel x86", },
78 { IH_ARCH_IA64, "ia64", "IA64", },
79 { IH_ARCH_M68K, "m68k", "M68K", },
80 { IH_ARCH_MICROBLAZE, "microblaze", "MicroBlaze", },
81 { IH_ARCH_MIPS, "mips", "MIPS", },
82 { IH_ARCH_MIPS64, "mips64", "MIPS 64 Bit", },
83 { IH_ARCH_NIOS2, "nios2", "NIOS II", },
84 { IH_ARCH_PPC, "powerpc", "PowerPC", },
85 { IH_ARCH_PPC, "ppc", "PowerPC", },
86 { IH_ARCH_S390, "s390", "IBM S390", },
87 { IH_ARCH_SH, "sh", "SuperH", },
88 { IH_ARCH_SPARC, "sparc", "SPARC", },
89 { IH_ARCH_SPARC64, "sparc64", "SPARC 64 Bit", },
90 { IH_ARCH_BLACKFIN, "blackfin", "Blackfin", },
91 { IH_ARCH_AVR32, "avr32", "AVR32", },
92 { IH_ARCH_NDS32, "nds32", "NDS32", },
93 { IH_ARCH_OPENRISC, "or1k", "OpenRISC 1000",},
94 { IH_ARCH_SANDBOX, "sandbox", "Sandbox", },
95 { -1, "", "", },
96 };
97
98 static const table_entry_t uimage_os[] = {
99 { IH_OS_INVALID, NULL, "Invalid OS", },
100 { IH_OS_LINUX, "linux", "Linux", },
101 #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC)
102 { IH_OS_LYNXOS, "lynxos", "LynxOS", },
103 #endif
104 { IH_OS_NETBSD, "netbsd", "NetBSD", },
105 { IH_OS_OSE, "ose", "Enea OSE", },
106 { IH_OS_PLAN9, "plan9", "Plan 9", },
107 { IH_OS_RTEMS, "rtems", "RTEMS", },
108 { IH_OS_U_BOOT, "u-boot", "U-Boot", },
109 #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
110 { IH_OS_QNX, "qnx", "QNX", },
111 { IH_OS_VXWORKS, "vxworks", "VxWorks", },
112 #endif
113 #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC)
114 { IH_OS_INTEGRITY,"integrity", "INTEGRITY", },
115 #endif
116 #ifdef USE_HOSTCC
117 { IH_OS_4_4BSD, "4_4bsd", "4_4BSD", },
118 { IH_OS_DELL, "dell", "Dell", },
119 { IH_OS_ESIX, "esix", "Esix", },
120 { IH_OS_FREEBSD, "freebsd", "FreeBSD", },
121 { IH_OS_IRIX, "irix", "Irix", },
122 { IH_OS_NCR, "ncr", "NCR", },
123 { IH_OS_OPENBSD, "openbsd", "OpenBSD", },
124 { IH_OS_PSOS, "psos", "pSOS", },
125 { IH_OS_SCO, "sco", "SCO", },
126 { IH_OS_SOLARIS, "solaris", "Solaris", },
127 { IH_OS_SVR4, "svr4", "SVR4", },
128 #endif
129 { -1, "", "", },
130 };
131
132 static const table_entry_t uimage_type[] = {
133 { IH_TYPE_AISIMAGE, "aisimage", "Davinci AIS image",},
134 { IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image", },
135 { IH_TYPE_FIRMWARE, "firmware", "Firmware", },
136 { IH_TYPE_FLATDT, "flat_dt", "Flat Device Tree", },
137 { IH_TYPE_KERNEL, "kernel", "Kernel Image", },
138 { IH_TYPE_KERNEL_NOLOAD, "kernel_noload", "Kernel Image (no loading done)", },
139 { IH_TYPE_KWBIMAGE, "kwbimage", "Kirkwood Boot Image",},
140 { IH_TYPE_IMXIMAGE, "imximage", "Freescale i.MX Boot Image",},
141 { IH_TYPE_INVALID, NULL, "Invalid Image", },
142 { IH_TYPE_MULTI, "multi", "Multi-File Image", },
143 { IH_TYPE_OMAPIMAGE, "omapimage", "TI OMAP SPL With GP CH",},
144 { IH_TYPE_PBLIMAGE, "pblimage", "Freescale PBL Boot Image",},
145 { IH_TYPE_RAMDISK, "ramdisk", "RAMDisk Image", },
146 { IH_TYPE_SCRIPT, "script", "Script", },
147 { IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
148 { IH_TYPE_UBLIMAGE, "ublimage", "Davinci UBL image",},
149 { -1, "", "", },
150 };
151
152 static const table_entry_t uimage_comp[] = {
153 { IH_COMP_NONE, "none", "uncompressed", },
154 { IH_COMP_BZIP2, "bzip2", "bzip2 compressed", },
155 { IH_COMP_GZIP, "gzip", "gzip compressed", },
156 { IH_COMP_LZMA, "lzma", "lzma compressed", },
157 { IH_COMP_LZO, "lzo", "lzo compressed", },
158 { -1, "", "", },
159 };
160
161 /*****************************************************************************/
162 /* Legacy format routines */
163 /*****************************************************************************/
164 int image_check_hcrc(const image_header_t *hdr)
165 {
166 ulong hcrc;
167 ulong len = image_get_header_size();
168 image_header_t header;
169
170 /* Copy header so we can blank CRC field for re-calculation */
171 memmove(&header, (char *)hdr, image_get_header_size());
172 image_set_hcrc(&header, 0);
173
174 hcrc = crc32(0, (unsigned char *)&header, len);
175
176 return (hcrc == image_get_hcrc(hdr));
177 }
178
179 int image_check_dcrc(const image_header_t *hdr)
180 {
181 ulong data = image_get_data(hdr);
182 ulong len = image_get_data_size(hdr);
183 ulong dcrc = crc32_wd(0, (unsigned char *)data, len, CHUNKSZ_CRC32);
184
185 return (dcrc == image_get_dcrc(hdr));
186 }
187
188 /**
189 * image_multi_count - get component (sub-image) count
190 * @hdr: pointer to the header of the multi component image
191 *
192 * image_multi_count() returns number of components in a multi
193 * component image.
194 *
195 * Note: no checking of the image type is done, caller must pass
196 * a valid multi component image.
197 *
198 * returns:
199 * number of components
200 */
201 ulong image_multi_count(const image_header_t *hdr)
202 {
203 ulong i, count = 0;
204 uint32_t *size;
205
206 /* get start of the image payload, which in case of multi
207 * component images that points to a table of component sizes */
208 size = (uint32_t *)image_get_data(hdr);
209
210 /* count non empty slots */
211 for (i = 0; size[i]; ++i)
212 count++;
213
214 return count;
215 }
216
217 /**
218 * image_multi_getimg - get component data address and size
219 * @hdr: pointer to the header of the multi component image
220 * @idx: index of the requested component
221 * @data: pointer to a ulong variable, will hold component data address
222 * @len: pointer to a ulong variable, will hold component size
223 *
224 * image_multi_getimg() returns size and data address for the requested
225 * component in a multi component image.
226 *
227 * Note: no checking of the image type is done, caller must pass
228 * a valid multi component image.
229 *
230 * returns:
231 * data address and size of the component, if idx is valid
232 * 0 in data and len, if idx is out of range
233 */
234 void image_multi_getimg(const image_header_t *hdr, ulong idx,
235 ulong *data, ulong *len)
236 {
237 int i;
238 uint32_t *size;
239 ulong offset, count, img_data;
240
241 /* get number of component */
242 count = image_multi_count(hdr);
243
244 /* get start of the image payload, which in case of multi
245 * component images that points to a table of component sizes */
246 size = (uint32_t *)image_get_data(hdr);
247
248 /* get address of the proper component data start, which means
249 * skipping sizes table (add 1 for last, null entry) */
250 img_data = image_get_data(hdr) + (count + 1) * sizeof(uint32_t);
251
252 if (idx < count) {
253 *len = uimage_to_cpu(size[idx]);
254 offset = 0;
255
256 /* go over all indices preceding requested component idx */
257 for (i = 0; i < idx; i++) {
258 /* add up i-th component size, rounding up to 4 bytes */
259 offset += (uimage_to_cpu(size[i]) + 3) & ~3 ;
260 }
261
262 /* calculate idx-th component data address */
263 *data = img_data + offset;
264 } else {
265 *len = 0;
266 *data = 0;
267 }
268 }
269
270 static void image_print_type(const image_header_t *hdr)
271 {
272 const char *os, *arch, *type, *comp;
273
274 os = genimg_get_os_name(image_get_os(hdr));
275 arch = genimg_get_arch_name(image_get_arch(hdr));
276 type = genimg_get_type_name(image_get_type(hdr));
277 comp = genimg_get_comp_name(image_get_comp(hdr));
278
279 printf("%s %s %s (%s)\n", arch, os, type, comp);
280 }
281
282 /**
283 * image_print_contents - prints out the contents of the legacy format image
284 * @ptr: pointer to the legacy format image header
285 * @p: pointer to prefix string
286 *
287 * image_print_contents() formats a multi line legacy image contents description.
288 * The routine prints out all header fields followed by the size/offset data
289 * for MULTI/SCRIPT images.
290 *
291 * returns:
292 * no returned results
293 */
294 void image_print_contents(const void *ptr)
295 {
296 const image_header_t *hdr = (const image_header_t *)ptr;
297 const char *p;
298
299 #ifdef USE_HOSTCC
300 p = "";
301 #else
302 p = " ";
303 #endif
304
305 printf("%sImage Name: %.*s\n", p, IH_NMLEN, image_get_name(hdr));
306 if (IMAGE_ENABLE_TIMESTAMP) {
307 printf("%sCreated: ", p);
308 genimg_print_time((time_t)image_get_time(hdr));
309 }
310 printf("%sImage Type: ", p);
311 image_print_type(hdr);
312 printf("%sData Size: ", p);
313 genimg_print_size(image_get_data_size(hdr));
314 printf("%sLoad Address: %08x\n", p, image_get_load(hdr));
315 printf("%sEntry Point: %08x\n", p, image_get_ep(hdr));
316
317 if (image_check_type(hdr, IH_TYPE_MULTI) ||
318 image_check_type(hdr, IH_TYPE_SCRIPT)) {
319 int i;
320 ulong data, len;
321 ulong count = image_multi_count(hdr);
322
323 printf("%sContents:\n", p);
324 for (i = 0; i < count; i++) {
325 image_multi_getimg(hdr, i, &data, &len);
326
327 printf("%s Image %d: ", p, i);
328 genimg_print_size(len);
329
330 if (image_check_type(hdr, IH_TYPE_SCRIPT) && i > 0) {
331 /*
332 * the user may need to know offsets
333 * if planning to do something with
334 * multiple files
335 */
336 printf("%s Offset = 0x%08lx\n", p, data);
337 }
338 }
339 }
340 }
341
342
343 #ifndef USE_HOSTCC
344 /**
345 * image_get_ramdisk - get and verify ramdisk image
346 * @rd_addr: ramdisk image start address
347 * @arch: expected ramdisk architecture
348 * @verify: checksum verification flag
349 *
350 * image_get_ramdisk() returns a pointer to the verified ramdisk image
351 * header. Routine receives image start address and expected architecture
352 * flag. Verification done covers data and header integrity and os/type/arch
353 * fields checking.
354 *
355 * If dataflash support is enabled routine checks for dataflash addresses
356 * and handles required dataflash reads.
357 *
358 * returns:
359 * pointer to a ramdisk image header, if image was found and valid
360 * otherwise, return NULL
361 */
362 static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
363 int verify)
364 {
365 const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
366
367 if (!image_check_magic(rd_hdr)) {
368 puts("Bad Magic Number\n");
369 bootstage_error(BOOTSTAGE_ID_RD_MAGIC);
370 return NULL;
371 }
372
373 if (!image_check_hcrc(rd_hdr)) {
374 puts("Bad Header Checksum\n");
375 bootstage_error(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
376 return NULL;
377 }
378
379 bootstage_mark(BOOTSTAGE_ID_RD_MAGIC);
380 image_print_contents(rd_hdr);
381
382 if (verify) {
383 puts(" Verifying Checksum ... ");
384 if (!image_check_dcrc(rd_hdr)) {
385 puts("Bad Data CRC\n");
386 bootstage_error(BOOTSTAGE_ID_RD_CHECKSUM);
387 return NULL;
388 }
389 puts("OK\n");
390 }
391
392 bootstage_mark(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
393
394 if (!image_check_os(rd_hdr, IH_OS_LINUX) ||
395 !image_check_arch(rd_hdr, arch) ||
396 !image_check_type(rd_hdr, IH_TYPE_RAMDISK)) {
397 printf("No Linux %s Ramdisk Image\n",
398 genimg_get_arch_name(arch));
399 bootstage_error(BOOTSTAGE_ID_RAMDISK);
400 return NULL;
401 }
402
403 return rd_hdr;
404 }
405 #endif /* !USE_HOSTCC */
406
407 /*****************************************************************************/
408 /* Shared dual-format routines */
409 /*****************************************************************************/
410 #ifndef USE_HOSTCC
411 ulong load_addr = CONFIG_SYS_LOAD_ADDR; /* Default Load Address */
412 ulong save_addr; /* Default Save Address */
413 ulong save_size; /* Default Save Size (in bytes) */
414
415 static int on_loadaddr(const char *name, const char *value, enum env_op op,
416 int flags)
417 {
418 switch (op) {
419 case env_op_create:
420 case env_op_overwrite:
421 load_addr = simple_strtoul(value, NULL, 16);
422 break;
423 default:
424 break;
425 }
426
427 return 0;
428 }
429 U_BOOT_ENV_CALLBACK(loadaddr, on_loadaddr);
430
431 ulong getenv_bootm_low(void)
432 {
433 char *s = getenv("bootm_low");
434 if (s) {
435 ulong tmp = simple_strtoul(s, NULL, 16);
436 return tmp;
437 }
438
439 #if defined(CONFIG_SYS_SDRAM_BASE)
440 return CONFIG_SYS_SDRAM_BASE;
441 #elif defined(CONFIG_ARM)
442 return gd->bd->bi_dram[0].start;
443 #else
444 return 0;
445 #endif
446 }
447
448 phys_size_t getenv_bootm_size(void)
449 {
450 phys_size_t tmp;
451 char *s = getenv("bootm_size");
452 if (s) {
453 tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
454 return tmp;
455 }
456 s = getenv("bootm_low");
457 if (s)
458 tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
459 else
460 tmp = 0;
461
462
463 #if defined(CONFIG_ARM)
464 return gd->bd->bi_dram[0].size - tmp;
465 #else
466 return gd->bd->bi_memsize - tmp;
467 #endif
468 }
469
470 phys_size_t getenv_bootm_mapsize(void)
471 {
472 phys_size_t tmp;
473 char *s = getenv("bootm_mapsize");
474 if (s) {
475 tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
476 return tmp;
477 }
478
479 #if defined(CONFIG_SYS_BOOTMAPSZ)
480 return CONFIG_SYS_BOOTMAPSZ;
481 #else
482 return getenv_bootm_size();
483 #endif
484 }
485
486 void memmove_wd(void *to, void *from, size_t len, ulong chunksz)
487 {
488 if (to == from)
489 return;
490
491 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
492 while (len > 0) {
493 size_t tail = (len > chunksz) ? chunksz : len;
494 WATCHDOG_RESET();
495 memmove(to, from, tail);
496 to += tail;
497 from += tail;
498 len -= tail;
499 }
500 #else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
501 memmove(to, from, len);
502 #endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
503 }
504 #endif /* !USE_HOSTCC */
505
506 void genimg_print_size(uint32_t size)
507 {
508 #ifndef USE_HOSTCC
509 printf("%d Bytes = ", size);
510 print_size(size, "\n");
511 #else
512 printf("%d Bytes = %.2f kB = %.2f MB\n",
513 size, (double)size / 1.024e3,
514 (double)size / 1.048576e6);
515 #endif
516 }
517
518 #if IMAGE_ENABLE_TIMESTAMP
519 void genimg_print_time(time_t timestamp)
520 {
521 #ifndef USE_HOSTCC
522 struct rtc_time tm;
523
524 to_tm(timestamp, &tm);
525 printf("%4d-%02d-%02d %2d:%02d:%02d UTC\n",
526 tm.tm_year, tm.tm_mon, tm.tm_mday,
527 tm.tm_hour, tm.tm_min, tm.tm_sec);
528 #else
529 printf("%s", ctime(&timestamp));
530 #endif
531 }
532 #endif
533
534 /**
535 * get_table_entry_name - translate entry id to long name
536 * @table: pointer to a translation table for entries of a specific type
537 * @msg: message to be returned when translation fails
538 * @id: entry id to be translated
539 *
540 * get_table_entry_name() will go over translation table trying to find
541 * entry that matches given id. If matching entry is found, its long
542 * name is returned to the caller.
543 *
544 * returns:
545 * long entry name if translation succeeds
546 * msg otherwise
547 */
548 char *get_table_entry_name(const table_entry_t *table, char *msg, int id)
549 {
550 for (; table->id >= 0; ++table) {
551 if (table->id == id)
552 #if defined(USE_HOSTCC) || !defined(CONFIG_NEEDS_MANUAL_RELOC)
553 return table->lname;
554 #else
555 return table->lname + gd->reloc_off;
556 #endif
557 }
558 return (msg);
559 }
560
561 const char *genimg_get_os_name(uint8_t os)
562 {
563 return (get_table_entry_name(uimage_os, "Unknown OS", os));
564 }
565
566 const char *genimg_get_arch_name(uint8_t arch)
567 {
568 return (get_table_entry_name(uimage_arch, "Unknown Architecture",
569 arch));
570 }
571
572 const char *genimg_get_type_name(uint8_t type)
573 {
574 return (get_table_entry_name(uimage_type, "Unknown Image", type));
575 }
576
577 const char *genimg_get_comp_name(uint8_t comp)
578 {
579 return (get_table_entry_name(uimage_comp, "Unknown Compression",
580 comp));
581 }
582
583 /**
584 * get_table_entry_id - translate short entry name to id
585 * @table: pointer to a translation table for entries of a specific type
586 * @table_name: to be used in case of error
587 * @name: entry short name to be translated
588 *
589 * get_table_entry_id() will go over translation table trying to find
590 * entry that matches given short name. If matching entry is found,
591 * its id returned to the caller.
592 *
593 * returns:
594 * entry id if translation succeeds
595 * -1 otherwise
596 */
597 int get_table_entry_id(const table_entry_t *table,
598 const char *table_name, const char *name)
599 {
600 const table_entry_t *t;
601 #ifdef USE_HOSTCC
602 int first = 1;
603
604 for (t = table; t->id >= 0; ++t) {
605 if (t->sname && strcasecmp(t->sname, name) == 0)
606 return(t->id);
607 }
608
609 fprintf(stderr, "\nInvalid %s Type - valid names are", table_name);
610 for (t = table; t->id >= 0; ++t) {
611 if (t->sname == NULL)
612 continue;
613 fprintf(stderr, "%c %s", (first) ? ':' : ',', t->sname);
614 first = 0;
615 }
616 fprintf(stderr, "\n");
617 #else
618 for (t = table; t->id >= 0; ++t) {
619 #ifdef CONFIG_NEEDS_MANUAL_RELOC
620 if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
621 #else
622 if (t->sname && strcmp(t->sname, name) == 0)
623 #endif
624 return (t->id);
625 }
626 debug("Invalid %s Type: %s\n", table_name, name);
627 #endif /* USE_HOSTCC */
628 return (-1);
629 }
630
631 int genimg_get_os_id(const char *name)
632 {
633 return (get_table_entry_id(uimage_os, "OS", name));
634 }
635
636 int genimg_get_arch_id(const char *name)
637 {
638 return (get_table_entry_id(uimage_arch, "CPU", name));
639 }
640
641 int genimg_get_type_id(const char *name)
642 {
643 return (get_table_entry_id(uimage_type, "Image", name));
644 }
645
646 int genimg_get_comp_id(const char *name)
647 {
648 return (get_table_entry_id(uimage_comp, "Compression", name));
649 }
650
651 #ifndef USE_HOSTCC
652 /**
653 * genimg_get_format - get image format type
654 * @img_addr: image start address
655 *
656 * genimg_get_format() checks whether provided address points to a valid
657 * legacy or FIT image.
658 *
659 * New uImage format and FDT blob are based on a libfdt. FDT blob
660 * may be passed directly or embedded in a FIT image. In both situations
661 * genimg_get_format() must be able to dectect libfdt header.
662 *
663 * returns:
664 * image format type or IMAGE_FORMAT_INVALID if no image is present
665 */
666 int genimg_get_format(const void *img_addr)
667 {
668 ulong format = IMAGE_FORMAT_INVALID;
669 const image_header_t *hdr;
670 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
671 char *fit_hdr;
672 #endif
673
674 hdr = (const image_header_t *)img_addr;
675 if (image_check_magic(hdr))
676 format = IMAGE_FORMAT_LEGACY;
677 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
678 else {
679 fit_hdr = (char *)img_addr;
680 if (fdt_check_header(fit_hdr) == 0)
681 format = IMAGE_FORMAT_FIT;
682 }
683 #endif
684
685 return format;
686 }
687
688 /**
689 * genimg_get_image - get image from special storage (if necessary)
690 * @img_addr: image start address
691 *
692 * genimg_get_image() checks if provided image start adddress is located
693 * in a dataflash storage. If so, image is moved to a system RAM memory.
694 *
695 * returns:
696 * image start address after possible relocation from special storage
697 */
698 ulong genimg_get_image(ulong img_addr)
699 {
700 ulong ram_addr = img_addr;
701
702 #ifdef CONFIG_HAS_DATAFLASH
703 ulong h_size, d_size;
704
705 if (addr_dataflash(img_addr)) {
706 void *buf;
707
708 /* ger RAM address */
709 ram_addr = CONFIG_SYS_LOAD_ADDR;
710
711 /* get header size */
712 h_size = image_get_header_size();
713 #if defined(CONFIG_FIT)
714 if (sizeof(struct fdt_header) > h_size)
715 h_size = sizeof(struct fdt_header);
716 #endif
717
718 /* read in header */
719 debug(" Reading image header from dataflash address "
720 "%08lx to RAM address %08lx\n", img_addr, ram_addr);
721
722 buf = map_sysmem(ram_addr, 0);
723 read_dataflash(img_addr, h_size, buf);
724
725 /* get data size */
726 switch (genimg_get_format(buf)) {
727 case IMAGE_FORMAT_LEGACY:
728 d_size = image_get_data_size(buf);
729 debug(" Legacy format image found at 0x%08lx, "
730 "size 0x%08lx\n",
731 ram_addr, d_size);
732 break;
733 #if defined(CONFIG_FIT)
734 case IMAGE_FORMAT_FIT:
735 d_size = fit_get_size(buf) - h_size;
736 debug(" FIT/FDT format image found at 0x%08lx, "
737 "size 0x%08lx\n",
738 ram_addr, d_size);
739 break;
740 #endif
741 default:
742 printf(" No valid image found at 0x%08lx\n",
743 img_addr);
744 return ram_addr;
745 }
746
747 /* read in image data */
748 debug(" Reading image remaining data from dataflash address "
749 "%08lx to RAM address %08lx\n", img_addr + h_size,
750 ram_addr + h_size);
751
752 read_dataflash(img_addr + h_size, d_size,
753 (char *)(buf + h_size));
754
755 }
756 #endif /* CONFIG_HAS_DATAFLASH */
757
758 return ram_addr;
759 }
760
761 /**
762 * fit_has_config - check if there is a valid FIT configuration
763 * @images: pointer to the bootm command headers structure
764 *
765 * fit_has_config() checks if there is a FIT configuration in use
766 * (if FTI support is present).
767 *
768 * returns:
769 * 0, no FIT support or no configuration found
770 * 1, configuration found
771 */
772 int genimg_has_config(bootm_headers_t *images)
773 {
774 #if defined(CONFIG_FIT)
775 if (images->fit_uname_cfg)
776 return 1;
777 #endif
778 return 0;
779 }
780
781 /**
782 * boot_get_ramdisk - main ramdisk handling routine
783 * @argc: command argument count
784 * @argv: command argument list
785 * @images: pointer to the bootm images structure
786 * @arch: expected ramdisk architecture
787 * @rd_start: pointer to a ulong variable, will hold ramdisk start address
788 * @rd_end: pointer to a ulong variable, will hold ramdisk end
789 *
790 * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
791 * Curently supported are the following ramdisk sources:
792 * - multicomponent kernel/ramdisk image,
793 * - commandline provided address of decicated ramdisk image.
794 *
795 * returns:
796 * 0, if ramdisk image was found and valid, or skiped
797 * rd_start and rd_end are set to ramdisk start/end addresses if
798 * ramdisk image is found and valid
799 *
800 * 1, if ramdisk image is found but corrupted, or invalid
801 * rd_start and rd_end are set to 0 if no ramdisk exists
802 */
803 int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
804 uint8_t arch, ulong *rd_start, ulong *rd_end)
805 {
806 ulong rd_addr, rd_load;
807 ulong rd_data, rd_len;
808 const image_header_t *rd_hdr;
809 void *buf;
810 #ifdef CONFIG_SUPPORT_RAW_INITRD
811 char *end;
812 #endif
813 #if defined(CONFIG_FIT)
814 void *fit_hdr;
815 const char *fit_uname_config = NULL;
816 const char *fit_uname_ramdisk = NULL;
817 ulong default_addr;
818 int rd_noffset;
819 int cfg_noffset;
820 const void *data;
821 size_t size;
822 #endif
823
824 *rd_start = 0;
825 *rd_end = 0;
826
827 /*
828 * Look for a '-' which indicates to ignore the
829 * ramdisk argument
830 */
831 if ((argc >= 3) && (strcmp(argv[2], "-") == 0)) {
832 debug("## Skipping init Ramdisk\n");
833 rd_len = rd_data = 0;
834 } else if (argc >= 3 || genimg_has_config(images)) {
835 #if defined(CONFIG_FIT)
836 if (argc >= 3) {
837 /*
838 * If the init ramdisk comes from the FIT image and
839 * the FIT image address is omitted in the command
840 * line argument, try to use os FIT image address or
841 * default load address.
842 */
843 if (images->fit_uname_os)
844 default_addr = (ulong)images->fit_hdr_os;
845 else
846 default_addr = load_addr;
847
848 if (fit_parse_conf(argv[2], default_addr,
849 &rd_addr, &fit_uname_config)) {
850 debug("* ramdisk: config '%s' from image at "
851 "0x%08lx\n",
852 fit_uname_config, rd_addr);
853 } else if (fit_parse_subimage(argv[2], default_addr,
854 &rd_addr, &fit_uname_ramdisk)) {
855 debug("* ramdisk: subimage '%s' from image at "
856 "0x%08lx\n",
857 fit_uname_ramdisk, rd_addr);
858 } else
859 #endif
860 {
861 rd_addr = simple_strtoul(argv[2], NULL, 16);
862 debug("* ramdisk: cmdline image address = "
863 "0x%08lx\n",
864 rd_addr);
865 }
866 #if defined(CONFIG_FIT)
867 } else {
868 /* use FIT configuration provided in first bootm
869 * command argument
870 */
871 rd_addr = map_to_sysmem(images->fit_hdr_os);
872 fit_uname_config = images->fit_uname_cfg;
873 debug("* ramdisk: using config '%s' from image "
874 "at 0x%08lx\n",
875 fit_uname_config, rd_addr);
876
877 /*
878 * Check whether configuration has ramdisk defined,
879 * if not, don't try to use it, quit silently.
880 */
881 fit_hdr = images->fit_hdr_os;
882 cfg_noffset = fit_conf_get_node(fit_hdr,
883 fit_uname_config);
884 if (cfg_noffset < 0) {
885 debug("* ramdisk: no such config\n");
886 return 1;
887 }
888
889 rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
890 cfg_noffset);
891 if (rd_noffset < 0) {
892 debug("* ramdisk: no ramdisk in config\n");
893 return 0;
894 }
895 }
896 #endif
897
898 /* copy from dataflash if needed */
899 rd_addr = genimg_get_image(rd_addr);
900
901 /*
902 * Check if there is an initrd image at the
903 * address provided in the second bootm argument
904 * check image type, for FIT images get FIT node.
905 */
906 buf = map_sysmem(rd_addr, 0);
907 switch (genimg_get_format(buf)) {
908 case IMAGE_FORMAT_LEGACY:
909 printf("## Loading init Ramdisk from Legacy "
910 "Image at %08lx ...\n", rd_addr);
911
912 bootstage_mark(BOOTSTAGE_ID_CHECK_RAMDISK);
913 rd_hdr = image_get_ramdisk(rd_addr, arch,
914 images->verify);
915
916 if (rd_hdr == NULL)
917 return 1;
918
919 rd_data = image_get_data(rd_hdr);
920 rd_len = image_get_data_size(rd_hdr);
921 rd_load = image_get_load(rd_hdr);
922 break;
923 #if defined(CONFIG_FIT)
924 case IMAGE_FORMAT_FIT:
925 fit_hdr = buf;
926 printf("## Loading init Ramdisk from FIT "
927 "Image at %08lx ...\n", rd_addr);
928
929 bootstage_mark(BOOTSTAGE_ID_FIT_RD_FORMAT);
930 if (!fit_check_format(fit_hdr)) {
931 puts("Bad FIT ramdisk image format!\n");
932 bootstage_error(
933 BOOTSTAGE_ID_FIT_RD_FORMAT);
934 return 1;
935 }
936 bootstage_mark(BOOTSTAGE_ID_FIT_RD_FORMAT_OK);
937
938 if (!fit_uname_ramdisk) {
939 /*
940 * no ramdisk image node unit name, try to get config
941 * node first. If config unit node name is NULL
942 * fit_conf_get_node() will try to find default config node
943 */
944 bootstage_mark(
945 BOOTSTAGE_ID_FIT_RD_NO_UNIT_NAME);
946 cfg_noffset = fit_conf_get_node(fit_hdr,
947 fit_uname_config);
948 if (cfg_noffset < 0) {
949 puts("Could not find configuration "
950 "node\n");
951 bootstage_error(
952 BOOTSTAGE_ID_FIT_RD_NO_UNIT_NAME);
953 return 1;
954 }
955 fit_uname_config = fdt_get_name(fit_hdr,
956 cfg_noffset, NULL);
957 printf(" Using '%s' configuration\n",
958 fit_uname_config);
959
960 rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
961 cfg_noffset);
962 fit_uname_ramdisk = fit_get_name(fit_hdr,
963 rd_noffset, NULL);
964 } else {
965 /* get ramdisk component image node offset */
966 bootstage_mark(
967 BOOTSTAGE_ID_FIT_RD_UNIT_NAME);
968 rd_noffset = fit_image_get_node(fit_hdr,
969 fit_uname_ramdisk);
970 }
971 if (rd_noffset < 0) {
972 puts("Could not find subimage node\n");
973 bootstage_error(BOOTSTAGE_ID_FIT_RD_SUBNODE);
974 return 1;
975 }
976
977 printf(" Trying '%s' ramdisk subimage\n",
978 fit_uname_ramdisk);
979
980 bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK);
981 if (!fit_check_ramdisk(fit_hdr, rd_noffset, arch,
982 images->verify))
983 return 1;
984
985 /* get ramdisk image data address and length */
986 if (fit_image_get_data(fit_hdr, rd_noffset, &data,
987 &size)) {
988 puts("Could not find ramdisk subimage data!\n");
989 bootstage_error(BOOTSTAGE_ID_FIT_RD_GET_DATA);
990 return 1;
991 }
992 bootstage_mark(BOOTSTAGE_ID_FIT_RD_GET_DATA_OK);
993
994 rd_data = (ulong)data;
995 rd_len = size;
996
997 if (fit_image_get_load(fit_hdr, rd_noffset, &rd_load)) {
998 puts("Can't get ramdisk subimage load "
999 "address!\n");
1000 bootstage_error(BOOTSTAGE_ID_FIT_RD_LOAD);
1001 return 1;
1002 }
1003 bootstage_mark(BOOTSTAGE_ID_FIT_RD_LOAD);
1004
1005 images->fit_hdr_rd = fit_hdr;
1006 images->fit_uname_rd = fit_uname_ramdisk;
1007 images->fit_noffset_rd = rd_noffset;
1008 break;
1009 #endif
1010 default:
1011 #ifdef CONFIG_SUPPORT_RAW_INITRD
1012 if (argc >= 3 && (end = strchr(argv[2], ':'))) {
1013 rd_len = simple_strtoul(++end, NULL, 16);
1014 rd_data = rd_addr;
1015 } else
1016 #endif
1017 {
1018 puts("Wrong Ramdisk Image Format\n");
1019 rd_data = rd_len = rd_load = 0;
1020 return 1;
1021 }
1022 }
1023 } else if (images->legacy_hdr_valid &&
1024 image_check_type(&images->legacy_hdr_os_copy,
1025 IH_TYPE_MULTI)) {
1026
1027 /*
1028 * Now check if we have a legacy mult-component image,
1029 * get second entry data start address and len.
1030 */
1031 bootstage_mark(BOOTSTAGE_ID_RAMDISK);
1032 printf("## Loading init Ramdisk from multi component "
1033 "Legacy Image at %08lx ...\n",
1034 (ulong)images->legacy_hdr_os);
1035
1036 image_multi_getimg(images->legacy_hdr_os, 1, &rd_data, &rd_len);
1037 } else {
1038 /*
1039 * no initrd image
1040 */
1041 bootstage_mark(BOOTSTAGE_ID_NO_RAMDISK);
1042 rd_len = rd_data = 0;
1043 }
1044
1045 if (!rd_data) {
1046 debug("## No init Ramdisk\n");
1047 } else {
1048 *rd_start = rd_data;
1049 *rd_end = rd_data + rd_len;
1050 }
1051 debug(" ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
1052 *rd_start, *rd_end);
1053
1054 return 0;
1055 }
1056
1057 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
1058 /**
1059 * boot_ramdisk_high - relocate init ramdisk
1060 * @lmb: pointer to lmb handle, will be used for memory mgmt
1061 * @rd_data: ramdisk data start address
1062 * @rd_len: ramdisk data length
1063 * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
1064 * start address (after possible relocation)
1065 * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
1066 * end address (after possible relocation)
1067 *
1068 * boot_ramdisk_high() takes a relocation hint from "initrd_high" environement
1069 * variable and if requested ramdisk data is moved to a specified location.
1070 *
1071 * Initrd_start and initrd_end are set to final (after relocation) ramdisk
1072 * start/end addresses if ramdisk image start and len were provided,
1073 * otherwise set initrd_start and initrd_end set to zeros.
1074 *
1075 * returns:
1076 * 0 - success
1077 * -1 - failure
1078 */
1079 int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
1080 ulong *initrd_start, ulong *initrd_end)
1081 {
1082 char *s;
1083 ulong initrd_high;
1084 int initrd_copy_to_ram = 1;
1085
1086 if ((s = getenv("initrd_high")) != NULL) {
1087 /* a value of "no" or a similar string will act like 0,
1088 * turning the "load high" feature off. This is intentional.
1089 */
1090 initrd_high = simple_strtoul(s, NULL, 16);
1091 if (initrd_high == ~0)
1092 initrd_copy_to_ram = 0;
1093 } else {
1094 /* not set, no restrictions to load high */
1095 initrd_high = ~0;
1096 }
1097
1098
1099 #ifdef CONFIG_LOGBUFFER
1100 /* Prevent initrd from overwriting logbuffer */
1101 lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
1102 #endif
1103
1104 debug("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
1105 initrd_high, initrd_copy_to_ram);
1106
1107 if (rd_data) {
1108 if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */
1109 debug(" in-place initrd\n");
1110 *initrd_start = rd_data;
1111 *initrd_end = rd_data + rd_len;
1112 lmb_reserve(lmb, rd_data, rd_len);
1113 } else {
1114 if (initrd_high)
1115 *initrd_start = (ulong)lmb_alloc_base(lmb,
1116 rd_len, 0x1000, initrd_high);
1117 else
1118 *initrd_start = (ulong)lmb_alloc(lmb, rd_len,
1119 0x1000);
1120
1121 if (*initrd_start == 0) {
1122 puts("ramdisk - allocation error\n");
1123 goto error;
1124 }
1125 bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);
1126
1127 *initrd_end = *initrd_start + rd_len;
1128 printf(" Loading Ramdisk to %08lx, end %08lx ... ",
1129 *initrd_start, *initrd_end);
1130
1131 memmove_wd((void *)*initrd_start,
1132 (void *)rd_data, rd_len, CHUNKSZ);
1133
1134 #ifdef CONFIG_MP
1135 /*
1136 * Ensure the image is flushed to memory to handle
1137 * AMP boot scenarios in which we might not be
1138 * HW cache coherent
1139 */
1140 flush_cache((unsigned long)*initrd_start, rd_len);
1141 #endif
1142 puts("OK\n");
1143 }
1144 } else {
1145 *initrd_start = 0;
1146 *initrd_end = 0;
1147 }
1148 debug(" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
1149 *initrd_start, *initrd_end);
1150
1151 return 0;
1152
1153 error:
1154 return -1;
1155 }
1156 #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
1157
1158 #ifdef CONFIG_OF_LIBFDT
1159 static void fdt_error(const char *msg)
1160 {
1161 puts("ERROR: ");
1162 puts(msg);
1163 puts(" - must RESET the board to recover.\n");
1164 }
1165
1166 static const image_header_t *image_get_fdt(ulong fdt_addr)
1167 {
1168 const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0);
1169
1170 image_print_contents(fdt_hdr);
1171
1172 puts(" Verifying Checksum ... ");
1173 if (!image_check_hcrc(fdt_hdr)) {
1174 fdt_error("fdt header checksum invalid");
1175 return NULL;
1176 }
1177
1178 if (!image_check_dcrc(fdt_hdr)) {
1179 fdt_error("fdt checksum invalid");
1180 return NULL;
1181 }
1182 puts("OK\n");
1183
1184 if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
1185 fdt_error("uImage is not a fdt");
1186 return NULL;
1187 }
1188 if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
1189 fdt_error("uImage is compressed");
1190 return NULL;
1191 }
1192 if (fdt_check_header((char *)image_get_data(fdt_hdr)) != 0) {
1193 fdt_error("uImage data is not a fdt");
1194 return NULL;
1195 }
1196 return fdt_hdr;
1197 }
1198
1199 /**
1200 * fit_check_fdt - verify FIT format FDT subimage
1201 * @fit_hdr: pointer to the FIT header
1202 * fdt_noffset: FDT subimage node offset within FIT image
1203 * @verify: data CRC verification flag
1204 *
1205 * fit_check_fdt() verifies integrity of the FDT subimage and from
1206 * specified FIT image.
1207 *
1208 * returns:
1209 * 1, on success
1210 * 0, on failure
1211 */
1212 #if defined(CONFIG_FIT)
1213 static int fit_check_fdt(const void *fit, int fdt_noffset, int verify)
1214 {
1215 fit_image_print(fit, fdt_noffset, " ");
1216
1217 if (verify) {
1218 puts(" Verifying Hash Integrity ... ");
1219 if (!fit_image_verify(fit, fdt_noffset)) {
1220 fdt_error("Bad Data Hash");
1221 return 0;
1222 }
1223 puts("OK\n");
1224 }
1225
1226 if (!fit_image_check_type(fit, fdt_noffset, IH_TYPE_FLATDT)) {
1227 fdt_error("Not a FDT image");
1228 return 0;
1229 }
1230
1231 if (!fit_image_check_comp(fit, fdt_noffset, IH_COMP_NONE)) {
1232 fdt_error("FDT image is compressed");
1233 return 0;
1234 }
1235
1236 return 1;
1237 }
1238 #endif /* CONFIG_FIT */
1239
1240 #ifndef CONFIG_SYS_FDT_PAD
1241 #define CONFIG_SYS_FDT_PAD 0x3000
1242 #endif
1243
1244 #if defined(CONFIG_OF_LIBFDT)
1245 /**
1246 * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
1247 * @lmb: pointer to lmb handle, will be used for memory mgmt
1248 * @fdt_blob: pointer to fdt blob base address
1249 *
1250 * Adds the memreserve regions in the dtb to the lmb block. Adding the
1251 * memreserve regions prevents u-boot from using them to store the initrd
1252 * or the fdt blob.
1253 */
1254 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
1255 {
1256 uint64_t addr, size;
1257 int i, total;
1258
1259 if (fdt_check_header(fdt_blob) != 0)
1260 return;
1261
1262 total = fdt_num_mem_rsv(fdt_blob);
1263 for (i = 0; i < total; i++) {
1264 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
1265 continue;
1266 printf(" reserving fdt memory region: addr=%llx size=%llx\n",
1267 (unsigned long long)addr, (unsigned long long)size);
1268 lmb_reserve(lmb, addr, size);
1269 }
1270 }
1271
1272 /**
1273 * boot_relocate_fdt - relocate flat device tree
1274 * @lmb: pointer to lmb handle, will be used for memory mgmt
1275 * @of_flat_tree: pointer to a char* variable, will hold fdt start address
1276 * @of_size: pointer to a ulong variable, will hold fdt length
1277 *
1278 * boot_relocate_fdt() allocates a region of memory within the bootmap and
1279 * relocates the of_flat_tree into that region, even if the fdt is already in
1280 * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
1281 * bytes.
1282 *
1283 * of_flat_tree and of_size are set to final (after relocation) values
1284 *
1285 * returns:
1286 * 0 - success
1287 * 1 - failure
1288 */
1289 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
1290 {
1291 void *fdt_blob = *of_flat_tree;
1292 void *of_start = NULL;
1293 char *fdt_high;
1294 ulong of_len = 0;
1295 int err;
1296 int disable_relocation = 0;
1297
1298 /* nothing to do */
1299 if (*of_size == 0)
1300 return 0;
1301
1302 if (fdt_check_header(fdt_blob) != 0) {
1303 fdt_error("image is not a fdt");
1304 goto error;
1305 }
1306
1307 /* position on a 4K boundary before the alloc_current */
1308 /* Pad the FDT by a specified amount */
1309 of_len = *of_size + CONFIG_SYS_FDT_PAD;
1310
1311 /* If fdt_high is set use it to select the relocation address */
1312 fdt_high = getenv("fdt_high");
1313 if (fdt_high) {
1314 void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
1315
1316 if (((ulong) desired_addr) == ~0UL) {
1317 /* All ones means use fdt in place */
1318 of_start = fdt_blob;
1319 lmb_reserve(lmb, (ulong)of_start, of_len);
1320 disable_relocation = 1;
1321 } else if (desired_addr) {
1322 of_start =
1323 (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
1324 (ulong)desired_addr);
1325 if (of_start == NULL) {
1326 puts("Failed using fdt_high value for Device Tree");
1327 goto error;
1328 }
1329 } else {
1330 of_start =
1331 (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
1332 }
1333 } else {
1334 of_start =
1335 (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
1336 getenv_bootm_mapsize()
1337 + getenv_bootm_low());
1338 }
1339
1340 if (of_start == NULL) {
1341 puts("device tree - allocation error\n");
1342 goto error;
1343 }
1344
1345 if (disable_relocation) {
1346 /* We assume there is space after the existing fdt to use for padding */
1347 fdt_set_totalsize(of_start, of_len);
1348 printf(" Using Device Tree in place at %p, end %p\n",
1349 of_start, of_start + of_len - 1);
1350 } else {
1351 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
1352 fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
1353
1354 printf(" Loading Device Tree to %p, end %p ... ",
1355 of_start, of_start + of_len - 1);
1356
1357 err = fdt_open_into(fdt_blob, of_start, of_len);
1358 if (err != 0) {
1359 fdt_error("fdt move failed");
1360 goto error;
1361 }
1362 puts("OK\n");
1363 }
1364
1365 *of_flat_tree = of_start;
1366 *of_size = of_len;
1367
1368 set_working_fdt_addr(*of_flat_tree);
1369 return 0;
1370
1371 error:
1372 return 1;
1373 }
1374 #endif /* CONFIG_OF_LIBFDT */
1375
1376 /**
1377 * boot_get_fdt - main fdt handling routine
1378 * @argc: command argument count
1379 * @argv: command argument list
1380 * @images: pointer to the bootm images structure
1381 * @of_flat_tree: pointer to a char* variable, will hold fdt start address
1382 * @of_size: pointer to a ulong variable, will hold fdt length
1383 *
1384 * boot_get_fdt() is responsible for finding a valid flat device tree image.
1385 * Curently supported are the following ramdisk sources:
1386 * - multicomponent kernel/ramdisk image,
1387 * - commandline provided address of decicated ramdisk image.
1388 *
1389 * returns:
1390 * 0, if fdt image was found and valid, or skipped
1391 * of_flat_tree and of_size are set to fdt start address and length if
1392 * fdt image is found and valid
1393 *
1394 * 1, if fdt image is found but corrupted
1395 * of_flat_tree and of_size are set to 0 if no fdt exists
1396 */
1397 int boot_get_fdt(int flag, int argc, char * const argv[],
1398 bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
1399 {
1400 const image_header_t *fdt_hdr;
1401 ulong fdt_addr;
1402 char *fdt_blob = NULL;
1403 ulong image_start, image_data, image_end;
1404 ulong load_start, load_end;
1405 void *buf;
1406 #if defined(CONFIG_FIT)
1407 void *fit_hdr;
1408 const char *fit_uname_config = NULL;
1409 const char *fit_uname_fdt = NULL;
1410 ulong default_addr;
1411 int cfg_noffset;
1412 int fdt_noffset;
1413 const void *data;
1414 size_t size;
1415 #endif
1416
1417 *of_flat_tree = NULL;
1418 *of_size = 0;
1419
1420 if (argc > 3 || genimg_has_config(images)) {
1421 #if defined(CONFIG_FIT)
1422 if (argc > 3) {
1423 /*
1424 * If the FDT blob comes from the FIT image and the
1425 * FIT image address is omitted in the command line
1426 * argument, try to use ramdisk or os FIT image
1427 * address or default load address.
1428 */
1429 if (images->fit_uname_rd)
1430 default_addr = (ulong)images->fit_hdr_rd;
1431 else if (images->fit_uname_os)
1432 default_addr = (ulong)images->fit_hdr_os;
1433 else
1434 default_addr = load_addr;
1435
1436 if (fit_parse_conf(argv[3], default_addr,
1437 &fdt_addr, &fit_uname_config)) {
1438 debug("* fdt: config '%s' from image at "
1439 "0x%08lx\n",
1440 fit_uname_config, fdt_addr);
1441 } else if (fit_parse_subimage(argv[3], default_addr,
1442 &fdt_addr, &fit_uname_fdt)) {
1443 debug("* fdt: subimage '%s' from image at "
1444 "0x%08lx\n",
1445 fit_uname_fdt, fdt_addr);
1446 } else
1447 #endif
1448 {
1449 fdt_addr = simple_strtoul(argv[3], NULL, 16);
1450 debug("* fdt: cmdline image address = "
1451 "0x%08lx\n",
1452 fdt_addr);
1453 }
1454 #if defined(CONFIG_FIT)
1455 } else {
1456 /* use FIT configuration provided in first bootm
1457 * command argument
1458 */
1459 fdt_addr = map_to_sysmem(images->fit_hdr_os);
1460 fit_uname_config = images->fit_uname_cfg;
1461 debug("* fdt: using config '%s' from image "
1462 "at 0x%08lx\n",
1463 fit_uname_config, fdt_addr);
1464
1465 /*
1466 * Check whether configuration has FDT blob defined,
1467 * if not quit silently.
1468 */
1469 fit_hdr = images->fit_hdr_os;
1470 cfg_noffset = fit_conf_get_node(fit_hdr,
1471 fit_uname_config);
1472 if (cfg_noffset < 0) {
1473 debug("* fdt: no such config\n");
1474 return 0;
1475 }
1476
1477 fdt_noffset = fit_conf_get_fdt_node(fit_hdr,
1478 cfg_noffset);
1479 if (fdt_noffset < 0) {
1480 debug("* fdt: no fdt in config\n");
1481 return 0;
1482 }
1483 }
1484 #endif
1485
1486 debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
1487 fdt_addr);
1488
1489 /* copy from dataflash if needed */
1490 fdt_addr = genimg_get_image(fdt_addr);
1491
1492 /*
1493 * Check if there is an FDT image at the
1494 * address provided in the second bootm argument
1495 * check image type, for FIT images get a FIT node.
1496 */
1497 buf = map_sysmem(fdt_addr, 0);
1498 switch (genimg_get_format(buf)) {
1499 case IMAGE_FORMAT_LEGACY:
1500 /* verify fdt_addr points to a valid image header */
1501 printf("## Flattened Device Tree from Legacy Image "
1502 "at %08lx\n",
1503 fdt_addr);
1504 fdt_hdr = image_get_fdt(fdt_addr);
1505 if (!fdt_hdr)
1506 goto error;
1507
1508 /*
1509 * move image data to the load address,
1510 * make sure we don't overwrite initial image
1511 */
1512 image_start = (ulong)fdt_hdr;
1513 image_data = (ulong)image_get_data(fdt_hdr);
1514 image_end = image_get_image_end(fdt_hdr);
1515
1516 load_start = image_get_load(fdt_hdr);
1517 load_end = load_start + image_get_data_size(fdt_hdr);
1518
1519 if (load_start == image_start ||
1520 load_start == image_data) {
1521 fdt_blob = (char *)image_data;
1522 break;
1523 }
1524
1525 if ((load_start < image_end) && (load_end > image_start)) {
1526 fdt_error("fdt overwritten");
1527 goto error;
1528 }
1529
1530 debug(" Loading FDT from 0x%08lx to 0x%08lx\n",
1531 image_data, load_start);
1532
1533 memmove((void *)load_start,
1534 (void *)image_data,
1535 image_get_data_size(fdt_hdr));
1536
1537 fdt_blob = (char *)load_start;
1538 break;
1539 case IMAGE_FORMAT_FIT:
1540 /*
1541 * This case will catch both: new uImage format
1542 * (libfdt based) and raw FDT blob (also libfdt
1543 * based).
1544 */
1545 #if defined(CONFIG_FIT)
1546 /* check FDT blob vs FIT blob */
1547 if (fit_check_format(buf)) {
1548 /*
1549 * FIT image
1550 */
1551 fit_hdr = buf;
1552 printf("## Flattened Device Tree from FIT "
1553 "Image at %08lx\n",
1554 fdt_addr);
1555
1556 if (!fit_uname_fdt) {
1557 /*
1558 * no FDT blob image node unit name,
1559 * try to get config node first. If
1560 * config unit node name is NULL
1561 * fit_conf_get_node() will try to
1562 * find default config node
1563 */
1564 cfg_noffset = fit_conf_get_node(fit_hdr,
1565 fit_uname_config);
1566
1567 if (cfg_noffset < 0) {
1568 fdt_error("Could not find "
1569 "configuration "
1570 "node\n");
1571 goto error;
1572 }
1573
1574 fit_uname_config = fdt_get_name(fit_hdr,
1575 cfg_noffset, NULL);
1576 printf(" Using '%s' configuration\n",
1577 fit_uname_config);
1578
1579 fdt_noffset = fit_conf_get_fdt_node(
1580 fit_hdr,
1581 cfg_noffset);
1582 fit_uname_fdt = fit_get_name(fit_hdr,
1583 fdt_noffset, NULL);
1584 } else {
1585 /* get FDT component image node offset */
1586 fdt_noffset = fit_image_get_node(
1587 fit_hdr,
1588 fit_uname_fdt);
1589 }
1590 if (fdt_noffset < 0) {
1591 fdt_error("Could not find subimage "
1592 "node\n");
1593 goto error;
1594 }
1595
1596 printf(" Trying '%s' FDT blob subimage\n",
1597 fit_uname_fdt);
1598
1599 if (!fit_check_fdt(fit_hdr, fdt_noffset,
1600 images->verify))
1601 goto error;
1602
1603 /* get ramdisk image data address and length */
1604 if (fit_image_get_data(fit_hdr, fdt_noffset,
1605 &data, &size)) {
1606 fdt_error("Could not find FDT "
1607 "subimage data");
1608 goto error;
1609 }
1610
1611 /* verift that image data is a proper FDT blob */
1612 if (fdt_check_header((char *)data) != 0) {
1613 fdt_error("Subimage data is not a FTD");
1614 goto error;
1615 }
1616
1617 /*
1618 * move image data to the load address,
1619 * make sure we don't overwrite initial image
1620 */
1621 image_start = (ulong)fit_hdr;
1622 image_end = fit_get_end(fit_hdr);
1623
1624 if (fit_image_get_load(fit_hdr, fdt_noffset,
1625 &load_start) == 0) {
1626 load_end = load_start + size;
1627
1628 if ((load_start < image_end) &&
1629 (load_end > image_start)) {
1630 fdt_error("FDT overwritten");
1631 goto error;
1632 }
1633
1634 printf(" Loading FDT from 0x%08lx "
1635 "to 0x%08lx\n",
1636 (ulong)data,
1637 load_start);
1638
1639 memmove((void *)load_start,
1640 (void *)data, size);
1641
1642 fdt_blob = (char *)load_start;
1643 } else {
1644 fdt_blob = (char *)data;
1645 }
1646
1647 images->fit_hdr_fdt = fit_hdr;
1648 images->fit_uname_fdt = fit_uname_fdt;
1649 images->fit_noffset_fdt = fdt_noffset;
1650 break;
1651 } else
1652 #endif
1653 {
1654 /*
1655 * FDT blob
1656 */
1657 fdt_blob = buf;
1658 debug("* fdt: raw FDT blob\n");
1659 printf("## Flattened Device Tree blob at %08lx\n",
1660 (long)fdt_addr);
1661 }
1662 break;
1663 default:
1664 puts("ERROR: Did not find a cmdline Flattened Device "
1665 "Tree\n");
1666 goto error;
1667 }
1668
1669 printf(" Booting using the fdt blob at 0x%p\n", fdt_blob);
1670
1671 } else if (images->legacy_hdr_valid &&
1672 image_check_type(&images->legacy_hdr_os_copy,
1673 IH_TYPE_MULTI)) {
1674
1675 ulong fdt_data, fdt_len;
1676
1677 /*
1678 * Now check if we have a legacy multi-component image,
1679 * get second entry data start address and len.
1680 */
1681 printf("## Flattened Device Tree from multi "
1682 "component Image at %08lX\n",
1683 (ulong)images->legacy_hdr_os);
1684
1685 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
1686 &fdt_len);
1687 if (fdt_len) {
1688
1689 fdt_blob = (char *)fdt_data;
1690 printf(" Booting using the fdt at 0x%p\n", fdt_blob);
1691
1692 if (fdt_check_header(fdt_blob) != 0) {
1693 fdt_error("image is not a fdt");
1694 goto error;
1695 }
1696
1697 if (fdt_totalsize(fdt_blob) != fdt_len) {
1698 fdt_error("fdt size != image size");
1699 goto error;
1700 }
1701 } else {
1702 debug("## No Flattened Device Tree\n");
1703 return 0;
1704 }
1705 } else {
1706 debug("## No Flattened Device Tree\n");
1707 return 0;
1708 }
1709
1710 *of_flat_tree = fdt_blob;
1711 *of_size = fdt_totalsize(fdt_blob);
1712 debug(" of_flat_tree at 0x%08lx size 0x%08lx\n",
1713 (ulong)*of_flat_tree, *of_size);
1714
1715 return 0;
1716
1717 error:
1718 *of_flat_tree = NULL;
1719 *of_size = 0;
1720 return 1;
1721 }
1722 #endif /* CONFIG_OF_LIBFDT */
1723
1724 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
1725 /**
1726 * boot_get_cmdline - allocate and initialize kernel cmdline
1727 * @lmb: pointer to lmb handle, will be used for memory mgmt
1728 * @cmd_start: pointer to a ulong variable, will hold cmdline start
1729 * @cmd_end: pointer to a ulong variable, will hold cmdline end
1730 *
1731 * boot_get_cmdline() allocates space for kernel command line below
1732 * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt
1733 * variable is present its contents is copied to allocated kernel
1734 * command line.
1735 *
1736 * returns:
1737 * 0 - success
1738 * -1 - failure
1739 */
1740 int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end)
1741 {
1742 char *cmdline;
1743 char *s;
1744
1745 cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
1746 getenv_bootm_mapsize() + getenv_bootm_low());
1747
1748 if (cmdline == NULL)
1749 return -1;
1750
1751 if ((s = getenv("bootargs")) == NULL)
1752 s = "";
1753
1754 strcpy(cmdline, s);
1755
1756 *cmd_start = (ulong) & cmdline[0];
1757 *cmd_end = *cmd_start + strlen(cmdline);
1758
1759 debug("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
1760
1761 return 0;
1762 }
1763 #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
1764
1765 #ifdef CONFIG_SYS_BOOT_GET_KBD
1766 /**
1767 * boot_get_kbd - allocate and initialize kernel copy of board info
1768 * @lmb: pointer to lmb handle, will be used for memory mgmt
1769 * @kbd: double pointer to board info data
1770 *
1771 * boot_get_kbd() allocates space for kernel copy of board info data below
1772 * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized
1773 * with the current u-boot board info data.
1774 *
1775 * returns:
1776 * 0 - success
1777 * -1 - failure
1778 */
1779 int boot_get_kbd(struct lmb *lmb, bd_t **kbd)
1780 {
1781 *kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
1782 getenv_bootm_mapsize() + getenv_bootm_low());
1783 if (*kbd == NULL)
1784 return -1;
1785
1786 **kbd = *(gd->bd);
1787
1788 debug("## kernel board info at 0x%08lx\n", (ulong)*kbd);
1789
1790 #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
1791 do_bdinfo(NULL, 0, 0, NULL);
1792 #endif
1793
1794 return 0;
1795 }
1796 #endif /* CONFIG_SYS_BOOT_GET_KBD */
1797 #endif /* !USE_HOSTCC */
"Das U-Boot" Source Tree