Annotation of elwix/tools/uboot_mkimage/include/image.h, revision 1.1.1.1
1.1 misho 1: /*
2: * (C) Copyright 2008 Semihalf
3: *
4: * (C) Copyright 2000-2005
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: * NOTE: This header file defines an interface to U-Boot. Including
27: * this (unmodified) header file in another file is considered normal
28: * use of U-Boot, and does *not* fall under the heading of "derived
29: * work".
30: ********************************************************************
31: */
32:
33: #ifndef __IMAGE_H__
34: #define __IMAGE_H__
35:
36: #include "compiler.h"
37:
38: #ifdef USE_HOSTCC
39:
40: /* new uImage format support enabled on host */
41: #define CONFIG_FIT 1
42: #define CONFIG_OF_LIBFDT 1
43: #define CONFIG_FIT_VERBOSE 1 /* enable fit_format_{error,warning}() */
44:
45: #else
46:
47: #include <lmb.h>
48: #include <asm/u-boot.h>
49: #include <command.h>
50:
51: #endif /* USE_HOSTCC */
52:
53: #if defined(CONFIG_FIT)
54: #include <fdt.h>
55: #include <libfdt.h>
56: #include <fdt_support.h>
57: #define CONFIG_MD5 /* FIT images need MD5 support */
58: #define CONFIG_SHA1 /* and SHA1 */
59: #endif
60:
61: /*
62: * Operating System Codes
63: */
64: #define IH_OS_INVALID 0 /* Invalid OS */
65: #define IH_OS_OPENBSD 1 /* OpenBSD */
66: #define IH_OS_NETBSD 2 /* NetBSD */
67: #define IH_OS_FREEBSD 3 /* FreeBSD */
68: #define IH_OS_4_4BSD 4 /* 4.4BSD */
69: #define IH_OS_LINUX 5 /* Linux */
70: #define IH_OS_SVR4 6 /* SVR4 */
71: #define IH_OS_ESIX 7 /* Esix */
72: #define IH_OS_SOLARIS 8 /* Solaris */
73: #define IH_OS_IRIX 9 /* Irix */
74: #define IH_OS_SCO 10 /* SCO */
75: #define IH_OS_DELL 11 /* Dell */
76: #define IH_OS_NCR 12 /* NCR */
77: #define IH_OS_LYNXOS 13 /* LynxOS */
78: #define IH_OS_VXWORKS 14 /* VxWorks */
79: #define IH_OS_PSOS 15 /* pSOS */
80: #define IH_OS_QNX 16 /* QNX */
81: #define IH_OS_U_BOOT 17 /* Firmware */
82: #define IH_OS_RTEMS 18 /* RTEMS */
83: #define IH_OS_ARTOS 19 /* ARTOS */
84: #define IH_OS_UNITY 20 /* Unity OS */
85: #define IH_OS_INTEGRITY 21 /* INTEGRITY */
86: #define IH_OS_OSE 22 /* OSE */
87:
88: /*
89: * CPU Architecture Codes (supported by Linux)
90: */
91: #define IH_ARCH_INVALID 0 /* Invalid CPU */
92: #define IH_ARCH_ALPHA 1 /* Alpha */
93: #define IH_ARCH_ARM 2 /* ARM */
94: #define IH_ARCH_I386 3 /* Intel x86 */
95: #define IH_ARCH_IA64 4 /* IA64 */
96: #define IH_ARCH_MIPS 5 /* MIPS */
97: #define IH_ARCH_MIPS64 6 /* MIPS 64 Bit */
98: #define IH_ARCH_PPC 7 /* PowerPC */
99: #define IH_ARCH_S390 8 /* IBM S390 */
100: #define IH_ARCH_SH 9 /* SuperH */
101: #define IH_ARCH_SPARC 10 /* Sparc */
102: #define IH_ARCH_SPARC64 11 /* Sparc 64 Bit */
103: #define IH_ARCH_M68K 12 /* M68K */
104: #define IH_ARCH_MICROBLAZE 14 /* MicroBlaze */
105: #define IH_ARCH_NIOS2 15 /* Nios-II */
106: #define IH_ARCH_BLACKFIN 16 /* Blackfin */
107: #define IH_ARCH_AVR32 17 /* AVR32 */
108: #define IH_ARCH_ST200 18 /* STMicroelectronics ST200 */
109:
110: /*
111: * Image Types
112: *
113: * "Standalone Programs" are directly runnable in the environment
114: * provided by U-Boot; it is expected that (if they behave
115: * well) you can continue to work in U-Boot after return from
116: * the Standalone Program.
117: * "OS Kernel Images" are usually images of some Embedded OS which
118: * will take over control completely. Usually these programs
119: * will install their own set of exception handlers, device
120: * drivers, set up the MMU, etc. - this means, that you cannot
121: * expect to re-enter U-Boot except by resetting the CPU.
122: * "RAMDisk Images" are more or less just data blocks, and their
123: * parameters (address, size) are passed to an OS kernel that is
124: * being started.
125: * "Multi-File Images" contain several images, typically an OS
126: * (Linux) kernel image and one or more data images like
127: * RAMDisks. This construct is useful for instance when you want
128: * to boot over the network using BOOTP etc., where the boot
129: * server provides just a single image file, but you want to get
130: * for instance an OS kernel and a RAMDisk image.
131: *
132: * "Multi-File Images" start with a list of image sizes, each
133: * image size (in bytes) specified by an "uint32_t" in network
134: * byte order. This list is terminated by an "(uint32_t)0".
135: * Immediately after the terminating 0 follow the images, one by
136: * one, all aligned on "uint32_t" boundaries (size rounded up to
137: * a multiple of 4 bytes - except for the last file).
138: *
139: * "Firmware Images" are binary images containing firmware (like
140: * U-Boot or FPGA images) which usually will be programmed to
141: * flash memory.
142: *
143: * "Script files" are command sequences that will be executed by
144: * U-Boot's command interpreter; this feature is especially
145: * useful when you configure U-Boot to use a real shell (hush)
146: * as command interpreter (=> Shell Scripts).
147: */
148:
149: #define IH_TYPE_INVALID 0 /* Invalid Image */
150: #define IH_TYPE_STANDALONE 1 /* Standalone Program */
151: #define IH_TYPE_KERNEL 2 /* OS Kernel Image */
152: #define IH_TYPE_RAMDISK 3 /* RAMDisk Image */
153: #define IH_TYPE_MULTI 4 /* Multi-File Image */
154: #define IH_TYPE_FIRMWARE 5 /* Firmware Image */
155: #define IH_TYPE_SCRIPT 6 /* Script file */
156: #define IH_TYPE_FILESYSTEM 7 /* Filesystem Image (any type) */
157: #define IH_TYPE_FLATDT 8 /* Binary Flat Device Tree Blob */
158: #define IH_TYPE_KWBIMAGE 9 /* Kirkwood Boot Image */
159: #define IH_TYPE_IMXIMAGE 10 /* Freescale IMXBoot Image */
160:
161: /*
162: * Compression Types
163: */
164: #define IH_COMP_NONE 0 /* No Compression Used */
165: #define IH_COMP_GZIP 1 /* gzip Compression Used */
166: #define IH_COMP_BZIP2 2 /* bzip2 Compression Used */
167: #define IH_COMP_LZMA 3 /* lzma Compression Used */
168: #define IH_COMP_LZO 4 /* lzo Compression Used */
169:
170: #define IH_MAGIC 0x27051956 /* Image Magic Number */
171: #define IH_NMLEN 32 /* Image Name Length */
172:
173: /*
174: * Legacy format image header,
175: * all data in network byte order (aka natural aka bigendian).
176: */
177: typedef struct image_header {
178: uint32_t ih_magic; /* Image Header Magic Number */
179: uint32_t ih_hcrc; /* Image Header CRC Checksum */
180: uint32_t ih_time; /* Image Creation Timestamp */
181: uint32_t ih_size; /* Image Data Size */
182: uint32_t ih_load; /* Data Load Address */
183: uint32_t ih_ep; /* Entry Point Address */
184: uint32_t ih_dcrc; /* Image Data CRC Checksum */
185: uint8_t ih_os; /* Operating System */
186: uint8_t ih_arch; /* CPU architecture */
187: uint8_t ih_type; /* Image Type */
188: uint8_t ih_comp; /* Compression Type */
189: uint8_t ih_name[IH_NMLEN]; /* Image Name */
190: } image_header_t;
191:
192: typedef struct image_info {
193: ulong start, end; /* start/end of blob */
194: ulong image_start, image_len; /* start of image within blob, len of image */
195: ulong load; /* load addr for the image */
196: uint8_t comp, type, os; /* compression, type of image, os type */
197: } image_info_t;
198:
199: /*
200: * Legacy and FIT format headers used by do_bootm() and do_bootm_<os>()
201: * routines.
202: */
203: typedef struct bootm_headers {
204: /*
205: * Legacy os image header, if it is a multi component image
206: * then boot_get_ramdisk() and get_fdt() will attempt to get
207: * data from second and third component accordingly.
208: */
209: image_header_t *legacy_hdr_os; /* image header pointer */
210: image_header_t legacy_hdr_os_copy; /* header copy */
211: ulong legacy_hdr_valid;
212:
213: #if defined(CONFIG_FIT)
214: const char *fit_uname_cfg; /* configuration node unit name */
215:
216: void *fit_hdr_os; /* os FIT image header */
217: const char *fit_uname_os; /* os subimage node unit name */
218: int fit_noffset_os; /* os subimage node offset */
219:
220: void *fit_hdr_rd; /* init ramdisk FIT image header */
221: const char *fit_uname_rd; /* init ramdisk subimage node unit name */
222: int fit_noffset_rd; /* init ramdisk subimage node offset */
223:
224: void *fit_hdr_fdt; /* FDT blob FIT image header */
225: const char *fit_uname_fdt; /* FDT blob subimage node unit name */
226: int fit_noffset_fdt;/* FDT blob subimage node offset */
227: #endif
228:
229: #ifndef USE_HOSTCC
230: image_info_t os; /* os image info */
231: ulong ep; /* entry point of OS */
232:
233: ulong rd_start, rd_end;/* ramdisk start/end */
234:
235: #ifdef CONFIG_OF_LIBFDT
236: char *ft_addr; /* flat dev tree address */
237: #endif
238: ulong ft_len; /* length of flat device tree */
239:
240: ulong initrd_start;
241: ulong initrd_end;
242: ulong cmdline_start;
243: ulong cmdline_end;
244: bd_t *kbd;
245: #endif
246:
247: int verify; /* getenv("verify")[0] != 'n' */
248:
249: #define BOOTM_STATE_START (0x00000001)
250: #define BOOTM_STATE_LOADOS (0x00000002)
251: #define BOOTM_STATE_RAMDISK (0x00000004)
252: #define BOOTM_STATE_FDT (0x00000008)
253: #define BOOTM_STATE_OS_CMDLINE (0x00000010)
254: #define BOOTM_STATE_OS_BD_T (0x00000020)
255: #define BOOTM_STATE_OS_PREP (0x00000040)
256: #define BOOTM_STATE_OS_GO (0x00000080)
257: int state;
258:
259: #ifdef CONFIG_LMB
260: struct lmb lmb; /* for memory mgmt */
261: #endif
262: } bootm_headers_t;
263:
264: /*
265: * Some systems (for example LWMON) have very short watchdog periods;
266: * we must make sure to split long operations like memmove() or
267: * checksum calculations into reasonable chunks.
268: */
269: #ifndef CHUNKSZ
270: #define CHUNKSZ (64 * 1024)
271: #endif
272:
273: #ifndef CHUNKSZ_CRC32
274: #define CHUNKSZ_CRC32 (64 * 1024)
275: #endif
276:
277: #ifndef CHUNKSZ_MD5
278: #define CHUNKSZ_MD5 (64 * 1024)
279: #endif
280:
281: #ifndef CHUNKSZ_SHA1
282: #define CHUNKSZ_SHA1 (64 * 1024)
283: #endif
284:
285: #define uimage_to_cpu(x) be32_to_cpu(x)
286: #define cpu_to_uimage(x) cpu_to_be32(x)
287:
288: /*
289: * Translation table for entries of a specific type; used by
290: * get_table_entry_id() and get_table_entry_name().
291: */
292: typedef struct table_entry {
293: int id;
294: char *sname; /* short (input) name to find table entry */
295: char *lname; /* long (output) name to print for messages */
296: } table_entry_t;
297:
298: /*
299: * get_table_entry_id() scans the translation table trying to find an
300: * entry that matches the given short name. If a matching entry is
301: * found, it's id is returned to the caller.
302: */
303: int get_table_entry_id (table_entry_t *table,
304: const char *table_name, const char *name);
305: /*
306: * get_table_entry_name() scans the translation table trying to find
307: * an entry that matches the given id. If a matching entry is found,
308: * its long name is returned to the caller.
309: */
310: char *get_table_entry_name (table_entry_t *table, char *msg, int id);
311:
312: const char *genimg_get_os_name (uint8_t os);
313: const char *genimg_get_arch_name (uint8_t arch);
314: const char *genimg_get_type_name (uint8_t type);
315: const char *genimg_get_comp_name (uint8_t comp);
316: int genimg_get_os_id (const char *name);
317: int genimg_get_arch_id (const char *name);
318: int genimg_get_type_id (const char *name);
319: int genimg_get_comp_id (const char *name);
320: void genimg_print_size (uint32_t size);
321:
322: #ifndef USE_HOSTCC
323: /* Image format types, returned by _get_format() routine */
324: #define IMAGE_FORMAT_INVALID 0x00
325: #define IMAGE_FORMAT_LEGACY 0x01 /* legacy image_header based format */
326: #define IMAGE_FORMAT_FIT 0x02 /* new, libfdt based format */
327:
328: int genimg_get_format (void *img_addr);
329: int genimg_has_config (bootm_headers_t *images);
330: ulong genimg_get_image (ulong img_addr);
331:
332: int boot_get_ramdisk (int argc, char * const argv[], bootm_headers_t *images,
333: uint8_t arch, ulong *rd_start, ulong *rd_end);
334:
335:
336: #ifdef CONFIG_OF_LIBFDT
337: int boot_get_fdt (int flag, int argc, char * const argv[], bootm_headers_t *images,
338: char **of_flat_tree, ulong *of_size);
339: int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
340: char **of_flat_tree, ulong *of_size);
341: #endif
342:
343: #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
344: int boot_ramdisk_high (struct lmb *lmb, ulong rd_data, ulong rd_len,
345: ulong *initrd_start, ulong *initrd_end);
346: #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
347: #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
348: int boot_get_cmdline (struct lmb *lmb, ulong *cmd_start, ulong *cmd_end,
349: ulong bootmap_base);
350: #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
351: #ifdef CONFIG_SYS_BOOT_GET_KBD
352: int boot_get_kbd (struct lmb *lmb, bd_t **kbd, ulong bootmap_base);
353: #endif /* CONFIG_SYS_BOOT_GET_KBD */
354: #endif /* !USE_HOSTCC */
355:
356: /*******************************************************************/
357: /* Legacy format specific code (prefixed with image_) */
358: /*******************************************************************/
359: static inline uint32_t image_get_header_size (void)
360: {
361: return (sizeof (image_header_t));
362: }
363:
364: #define image_get_hdr_l(f) \
365: static inline uint32_t image_get_##f(const image_header_t *hdr) \
366: { \
367: return uimage_to_cpu (hdr->ih_##f); \
368: }
369: image_get_hdr_l (magic) /* image_get_magic */
370: image_get_hdr_l (hcrc) /* image_get_hcrc */
371: image_get_hdr_l (time) /* image_get_time */
372: image_get_hdr_l (size) /* image_get_size */
373: image_get_hdr_l (load) /* image_get_load */
374: image_get_hdr_l (ep) /* image_get_ep */
375: image_get_hdr_l (dcrc) /* image_get_dcrc */
376:
377: #define image_get_hdr_b(f) \
378: static inline uint8_t image_get_##f(const image_header_t *hdr) \
379: { \
380: return hdr->ih_##f; \
381: }
382: image_get_hdr_b (os) /* image_get_os */
383: image_get_hdr_b (arch) /* image_get_arch */
384: image_get_hdr_b (type) /* image_get_type */
385: image_get_hdr_b (comp) /* image_get_comp */
386:
387: static inline char *image_get_name (const image_header_t *hdr)
388: {
389: return (char *)hdr->ih_name;
390: }
391:
392: static inline uint32_t image_get_data_size (const image_header_t *hdr)
393: {
394: return image_get_size (hdr);
395: }
396:
397: /**
398: * image_get_data - get image payload start address
399: * @hdr: image header
400: *
401: * image_get_data() returns address of the image payload. For single
402: * component images it is image data start. For multi component
403: * images it points to the null terminated table of sub-images sizes.
404: *
405: * returns:
406: * image payload data start address
407: */
408: static inline ulong image_get_data (const image_header_t *hdr)
409: {
410: return ((ulong)hdr + image_get_header_size ());
411: }
412:
413: static inline uint32_t image_get_image_size (const image_header_t *hdr)
414: {
415: return (image_get_size (hdr) + image_get_header_size ());
416: }
417: static inline ulong image_get_image_end (const image_header_t *hdr)
418: {
419: return ((ulong)hdr + image_get_image_size (hdr));
420: }
421:
422: #define image_set_hdr_l(f) \
423: static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
424: { \
425: hdr->ih_##f = cpu_to_uimage (val); \
426: }
427: image_set_hdr_l (magic) /* image_set_magic */
428: image_set_hdr_l (hcrc) /* image_set_hcrc */
429: image_set_hdr_l (time) /* image_set_time */
430: image_set_hdr_l (size) /* image_set_size */
431: image_set_hdr_l (load) /* image_set_load */
432: image_set_hdr_l (ep) /* image_set_ep */
433: image_set_hdr_l (dcrc) /* image_set_dcrc */
434:
435: #define image_set_hdr_b(f) \
436: static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
437: { \
438: hdr->ih_##f = val; \
439: }
440: image_set_hdr_b (os) /* image_set_os */
441: image_set_hdr_b (arch) /* image_set_arch */
442: image_set_hdr_b (type) /* image_set_type */
443: image_set_hdr_b (comp) /* image_set_comp */
444:
445: static inline void image_set_name (image_header_t *hdr, const char *name)
446: {
447: strncpy (image_get_name (hdr), name, IH_NMLEN);
448: }
449:
450: int image_check_hcrc (const image_header_t *hdr);
451: int image_check_dcrc (const image_header_t *hdr);
452: #ifndef USE_HOSTCC
453: int getenv_yesno (char *var);
454: ulong getenv_bootm_low(void);
455: phys_size_t getenv_bootm_size(void);
456: void memmove_wd (void *to, void *from, size_t len, ulong chunksz);
457: #endif
458:
459: static inline int image_check_magic (const image_header_t *hdr)
460: {
461: return (image_get_magic (hdr) == IH_MAGIC);
462: }
463: static inline int image_check_type (const image_header_t *hdr, uint8_t type)
464: {
465: return (image_get_type (hdr) == type);
466: }
467: static inline int image_check_arch (const image_header_t *hdr, uint8_t arch)
468: {
469: return (image_get_arch (hdr) == arch);
470: }
471: static inline int image_check_os (const image_header_t *hdr, uint8_t os)
472: {
473: return (image_get_os (hdr) == os);
474: }
475:
476: ulong image_multi_count (const image_header_t *hdr);
477: void image_multi_getimg (const image_header_t *hdr, ulong idx,
478: ulong *data, ulong *len);
479:
480: void image_print_contents (const void *hdr);
481:
482: #ifndef USE_HOSTCC
483: static inline int image_check_target_arch (const image_header_t *hdr)
484: {
485: #if defined(__ARM__)
486: if (!image_check_arch (hdr, IH_ARCH_ARM))
487: #elif defined(__avr32__)
488: if (!image_check_arch (hdr, IH_ARCH_AVR32))
489: #elif defined(__bfin__)
490: if (!image_check_arch (hdr, IH_ARCH_BLACKFIN))
491: #elif defined(__I386__)
492: if (!image_check_arch (hdr, IH_ARCH_I386))
493: #elif defined(__M68K__)
494: if (!image_check_arch (hdr, IH_ARCH_M68K))
495: #elif defined(__microblaze__)
496: if (!image_check_arch (hdr, IH_ARCH_MICROBLAZE))
497: #elif defined(__mips__)
498: if (!image_check_arch (hdr, IH_ARCH_MIPS))
499: #elif defined(__nios2__)
500: if (!image_check_arch (hdr, IH_ARCH_NIOS2))
501: #elif defined(__PPC__)
502: if (!image_check_arch (hdr, IH_ARCH_PPC))
503: #elif defined(__sh__)
504: if (!image_check_arch (hdr, IH_ARCH_SH))
505: #elif defined(__sparc__)
506: if (!image_check_arch (hdr, IH_ARCH_SPARC))
507: #else
508: # error Unknown CPU type
509: #endif
510: return 0;
511:
512: return 1;
513: }
514: #endif /* USE_HOSTCC */
515:
516: /*******************************************************************/
517: /* New uImage format specific code (prefixed with fit_) */
518: /*******************************************************************/
519: #if defined(CONFIG_FIT)
520:
521: #define FIT_IMAGES_PATH "/images"
522: #define FIT_CONFS_PATH "/configurations"
523:
524: /* hash node */
525: #define FIT_HASH_NODENAME "hash"
526: #define FIT_ALGO_PROP "algo"
527: #define FIT_VALUE_PROP "value"
528:
529: /* image node */
530: #define FIT_DATA_PROP "data"
531: #define FIT_TIMESTAMP_PROP "timestamp"
532: #define FIT_DESC_PROP "description"
533: #define FIT_ARCH_PROP "arch"
534: #define FIT_TYPE_PROP "type"
535: #define FIT_OS_PROP "os"
536: #define FIT_COMP_PROP "compression"
537: #define FIT_ENTRY_PROP "entry"
538: #define FIT_LOAD_PROP "load"
539:
540: /* configuration node */
541: #define FIT_KERNEL_PROP "kernel"
542: #define FIT_RAMDISK_PROP "ramdisk"
543: #define FIT_FDT_PROP "fdt"
544: #define FIT_DEFAULT_PROP "default"
545:
546: #define FIT_MAX_HASH_LEN 20 /* max(crc32_len(4), sha1_len(20)) */
547:
548: /* cmdline argument format parsing */
549: inline int fit_parse_conf (const char *spec, ulong addr_curr,
550: ulong *addr, const char **conf_name);
551: inline int fit_parse_subimage (const char *spec, ulong addr_curr,
552: ulong *addr, const char **image_name);
553:
554: void fit_print_contents (const void *fit);
555: void fit_image_print (const void *fit, int noffset, const char *p);
556: void fit_image_print_hash (const void *fit, int noffset, const char *p);
557:
558: /**
559: * fit_get_end - get FIT image size
560: * @fit: pointer to the FIT format image header
561: *
562: * returns:
563: * size of the FIT image (blob) in memory
564: */
565: static inline ulong fit_get_size (const void *fit)
566: {
567: return fdt_totalsize (fit);
568: }
569:
570: /**
571: * fit_get_end - get FIT image end
572: * @fit: pointer to the FIT format image header
573: *
574: * returns:
575: * end address of the FIT image (blob) in memory
576: */
577: static inline ulong fit_get_end (const void *fit)
578: {
579: return (ulong)fit + fdt_totalsize (fit);
580: }
581:
582: /**
583: * fit_get_name - get FIT node name
584: * @fit: pointer to the FIT format image header
585: *
586: * returns:
587: * NULL, on error
588: * pointer to node name, on success
589: */
590: static inline const char *fit_get_name (const void *fit_hdr,
591: int noffset, int *len)
592: {
593: return fdt_get_name (fit_hdr, noffset, len);
594: }
595:
596: int fit_get_desc (const void *fit, int noffset, char **desc);
597: int fit_get_timestamp (const void *fit, int noffset, time_t *timestamp);
598:
599: int fit_image_get_node (const void *fit, const char *image_uname);
600: int fit_image_get_os (const void *fit, int noffset, uint8_t *os);
601: int fit_image_get_arch (const void *fit, int noffset, uint8_t *arch);
602: int fit_image_get_type (const void *fit, int noffset, uint8_t *type);
603: int fit_image_get_comp (const void *fit, int noffset, uint8_t *comp);
604: int fit_image_get_load (const void *fit, int noffset, ulong *load);
605: int fit_image_get_entry (const void *fit, int noffset, ulong *entry);
606: int fit_image_get_data (const void *fit, int noffset,
607: const void **data, size_t *size);
608:
609: int fit_image_hash_get_algo (const void *fit, int noffset, char **algo);
610: int fit_image_hash_get_value (const void *fit, int noffset, uint8_t **value,
611: int *value_len);
612:
613: int fit_set_timestamp (void *fit, int noffset, time_t timestamp);
614: int fit_set_hashes (void *fit);
615: int fit_image_set_hashes (void *fit, int image_noffset);
616: int fit_image_hash_set_value (void *fit, int noffset, uint8_t *value,
617: int value_len);
618:
619: int fit_image_check_hashes (const void *fit, int noffset);
620: int fit_all_image_check_hashes (const void *fit);
621: int fit_image_check_os (const void *fit, int noffset, uint8_t os);
622: int fit_image_check_arch (const void *fit, int noffset, uint8_t arch);
623: int fit_image_check_type (const void *fit, int noffset, uint8_t type);
624: int fit_image_check_comp (const void *fit, int noffset, uint8_t comp);
625: int fit_check_format (const void *fit);
626:
627: int fit_conf_get_node (const void *fit, const char *conf_uname);
628: int fit_conf_get_kernel_node (const void *fit, int noffset);
629: int fit_conf_get_ramdisk_node (const void *fit, int noffset);
630: int fit_conf_get_fdt_node (const void *fit, int noffset);
631:
632: void fit_conf_print (const void *fit, int noffset, const char *p);
633:
634: #ifndef USE_HOSTCC
635: static inline int fit_image_check_target_arch (const void *fdt, int node)
636: {
637: #if defined(__ARM__)
638: if (!fit_image_check_arch (fdt, node, IH_ARCH_ARM))
639: #elif defined(__avr32__)
640: if (!fit_image_check_arch (fdt, node, IH_ARCH_AVR32))
641: #elif defined(__bfin__)
642: if (!fit_image_check_arch (fdt, node, IH_ARCH_BLACKFIN))
643: #elif defined(__I386__)
644: if (!fit_image_check_arch (fdt, node, IH_ARCH_I386))
645: #elif defined(__M68K__)
646: if (!fit_image_check_arch (fdt, node, IH_ARCH_M68K))
647: #elif defined(__microblaze__)
648: if (!fit_image_check_arch (fdt, node, IH_ARCH_MICROBLAZE))
649: #elif defined(__mips__)
650: if (!fit_image_check_arch (fdt, node, IH_ARCH_MIPS))
651: #elif defined(__nios2__)
652: if (!fit_image_check_arch (fdt, node, IH_ARCH_NIOS2))
653: #elif defined(__PPC__)
654: if (!fit_image_check_arch (fdt, node, IH_ARCH_PPC))
655: #elif defined(__sh__)
656: if (!fit_image_check_arch (fdt, node, IH_ARCH_SH))
657: #elif defined(__sparc__)
658: if (!fit_image_check_arch (fdt, node, IH_ARCH_SPARC))
659: #else
660: # error Unknown CPU type
661: #endif
662: return 0;
663:
664: return 1;
665: }
666: #endif /* USE_HOSTCC */
667:
668: #ifdef CONFIG_FIT_VERBOSE
669: #define fit_unsupported(msg) printf ("! %s:%d " \
670: "FIT images not supported for '%s'\n", \
671: __FILE__, __LINE__, (msg))
672:
673: #define fit_unsupported_reset(msg) printf ("! %s:%d " \
674: "FIT images not supported for '%s' " \
675: "- must reset board to recover!\n", \
676: __FILE__, __LINE__, (msg))
677: #else
678: #define fit_unsupported(msg)
679: #define fit_unsupported_reset(msg)
680: #endif /* CONFIG_FIT_VERBOSE */
681: #endif /* CONFIG_FIT */
682:
683: #endif /* __IMAGE_H__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to image.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / uboot_mkimage / include