mkimage: Allow including a ramdisk in FIT auto mode
[platform/kernel/u-boot.git] / tools / imagetool.h
1 /*
2  * (C) Copyright 2013
3  *
4  * Written by Guilherme Maciel Ferreira <guilherme.maciel.ferreira@gmail.com>
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #ifndef _IMAGETOOL_H_
10 #define _IMAGETOOL_H_
11
12 #include "os_support.h"
13 #include <errno.h>
14 #include <fcntl.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20 #include <time.h>
21 #include <unistd.h>
22 #include <u-boot/sha1.h>
23
24 #include "fdt_host.h"
25
26 #define ARRAY_SIZE(x)           (sizeof(x) / sizeof((x)[0]))
27
28 #define IH_ARCH_DEFAULT         IH_ARCH_INVALID
29
30 /* Information about a file that needs to be placed into the FIT */
31 struct content_info {
32         struct content_info *next;
33         int type;               /* File type (IH_TYPE_...) */
34         const char *fname;
35 };
36
37 /*
38  * This structure defines all such variables those are initialized by
39  * mkimage and dumpimage main core and need to be referred by image
40  * type specific functions
41  */
42 struct image_tool_params {
43         int dflag;
44         int eflag;
45         int fflag;
46         int iflag;
47         int lflag;
48         int pflag;
49         int vflag;
50         int xflag;
51         int skipcpy;
52         int os;
53         int arch;
54         int type;
55         int comp;
56         char *dtc;
57         unsigned int addr;
58         unsigned int ep;
59         char *imagename;
60         char *imagename2;
61         char *datafile;
62         char *imagefile;
63         char *cmdname;
64         const char *outfile;    /* Output filename */
65         const char *keydir;     /* Directory holding private keys */
66         const char *keydest;    /* Destination .dtb for public key */
67         const char *comment;    /* Comment to add to signature node */
68         int require_keys;       /* 1 to mark signing keys as 'required' */
69         int file_size;          /* Total size of output file */
70         int orig_file_size;     /* Original size for file before padding */
71         bool auto_its;          /* Automatically create the .its file */
72         int fit_image_type;     /* Image type to put into the FIT */
73         char *fit_ramdisk;      /* Ramdisk file to include */
74         struct content_info *content_head;      /* List of files to include */
75         struct content_info *content_tail;
76         bool external_data;     /* Store data outside the FIT */
77         bool quiet;             /* Don't output text in normal operation */
78         unsigned int external_offset;   /* Add padding to external data */
79 };
80
81 /*
82  * image type specific variables and callback functions
83  */
84 struct image_type_params {
85         /* name is an identification tag string for added support */
86         char *name;
87         /*
88          * header size is local to the specific image type to be supported,
89          * mkimage core treats this as number of bytes
90          */
91         uint32_t header_size;
92         /* Image type header pointer */
93         void *hdr;
94         /*
95          * There are several arguments that are passed on the command line
96          * and are registered as flags in image_tool_params structure.
97          * This callback function can be used to check the passed arguments
98          * are in-lined with the image type to be supported
99          *
100          * Returns 1 if parameter check is successful
101          */
102         int (*check_params) (struct image_tool_params *);
103         /*
104          * This function is used by list command (i.e. mkimage -l <filename>)
105          * image type verification code must be put here
106          *
107          * Returns 0 if image header verification is successful
108          * otherwise, returns respective negative error codes
109          */
110         int (*verify_header) (unsigned char *, int, struct image_tool_params *);
111         /* Prints image information abstracting from image header */
112         void (*print_header) (const void *);
113         /*
114          * The header or image contents need to be set as per image type to
115          * be generated using this callback function.
116          * further output file post processing (for ex. checksum calculation,
117          * padding bytes etc..) can also be done in this callback function.
118          */
119         void (*set_header) (void *, struct stat *, int,
120                                         struct image_tool_params *);
121         /*
122          * This function is used by the command to retrieve a component
123          * (sub-image) from the image (i.e. dumpimage -i <image> -p <position>
124          * <sub-image-name>).
125          * Thus the code to extract a file from an image must be put here.
126          *
127          * Returns 0 if the file was successfully retrieved from the image,
128          * or a negative value on error.
129          */
130         int (*extract_subimage)(void *, struct image_tool_params *);
131         /*
132          * Some image generation support for ex (default image type) supports
133          * more than one type_ids, this callback function is used to check
134          * whether input (-T <image_type>) is supported by registered image
135          * generation/list low level code
136          */
137         int (*check_image_type) (uint8_t);
138         /* This callback function will be executed if fflag is defined */
139         int (*fflag_handle) (struct image_tool_params *);
140         /*
141          * This callback function will be executed for variable size record
142          * It is expected to build this header in memory and return its length
143          * and a pointer to it by using image_type_params.header_size and
144          * image_type_params.hdr. The return value shall indicate if an
145          * additional padding should be used when copying the data image
146          * by returning the padding length.
147          */
148         int (*vrec_header) (struct image_tool_params *,
149                 struct image_type_params *);
150 };
151
152 /**
153  * imagetool_get_type() - find the image type params for a given image type
154  *
155  * It scans all registers image type supports
156  * checks the input type for each supported image type
157  *
158  * if successful,
159  *     returns respective image_type_params pointer if success
160  * if input type_id is not supported by any of image_type_support
161  *     returns NULL
162  */
163 struct image_type_params *imagetool_get_type(int type);
164
165 /*
166  * imagetool_verify_print_header() - verifies the image header
167  *
168  * Scan registered image types and verify the image_header for each
169  * supported image type. If verification is successful, this prints
170  * the respective header.
171  *
172  * @return 0 on success, negative if input image format does not match with
173  * any of supported image types
174  */
175 int imagetool_verify_print_header(
176         void *ptr,
177         struct stat *sbuf,
178         struct image_type_params *tparams,
179         struct image_tool_params *params);
180
181 /**
182  * imagetool_save_subimage - store data into a file
183  * @file_name: name of the destination file
184  * @file_data: data to be written
185  * @file_len: the amount of data to store
186  *
187  * imagetool_save_subimage() store file_len bytes of data pointed by file_data
188  * into the file name by file_name.
189  *
190  * returns:
191  *     zero in case of success or a negative value if fail.
192  */
193 int imagetool_save_subimage(
194         const char *file_name,
195         ulong file_data,
196         ulong file_len);
197
198 /**
199  * imagetool_get_filesize() - Utility function to obtain the size of a file
200  *
201  * This function prints a message if an error occurs, showing the error that
202  * was obtained.
203  *
204  * @params:     mkimage parameters
205  * @fname:      filename to check
206  * @return size of file, or -ve value on error
207  */
208 int imagetool_get_filesize(struct image_tool_params *params, const char *fname);
209
210 /**
211  * imagetool_get_source_date() - Get timestamp for build output.
212  *
213  * Gets a timestamp for embedding it in a build output. If set
214  * SOURCE_DATE_EPOCH is used. Else the given fallback value is returned. Prints
215  * an error message if SOURCE_DATE_EPOCH contains an invalid value and returns
216  * 0.
217  *
218  * @params:     mkimage parameters
219  * @fallback:   timestamp to use if SOURCE_DATE_EPOCH isn't set
220  * @return timestamp based on SOURCE_DATE_EPOCH
221  */
222 time_t imagetool_get_source_date(
223         struct image_tool_params *params,
224         time_t fallback);
225
226 /*
227  * There is a c file associated with supported image type low level code
228  * for ex. default_image.c, fit_image.c
229  */
230
231
232 void pbl_load_uboot(int fd, struct image_tool_params *mparams);
233
234 #define ___cat(a, b) a ## b
235 #define __cat(a, b) ___cat(a, b)
236
237 /* we need some special handling for this host tool running eventually on
238  * Darwin. The Mach-O section handling is a bit different than ELF section
239  * handling. The differnces in detail are:
240  *  a) we have segments which have sections
241  *  b) we need a API call to get the respective section symbols */
242 #if defined(__MACH__)
243 #include <mach-o/getsect.h>
244
245 #define INIT_SECTION(name)  do {                                        \
246                 unsigned long name ## _len;                             \
247                 char *__cat(pstart_, name) = getsectdata("__TEXT",      \
248                         #name, &__cat(name, _len));                     \
249                 char *__cat(pstop_, name) = __cat(pstart_, name) +      \
250                         __cat(name, _len);                              \
251                 __cat(__start_, name) = (void *)__cat(pstart_, name);   \
252                 __cat(__stop_, name) = (void *)__cat(pstop_, name);     \
253         } while (0)
254 #define SECTION(name)   __attribute__((section("__TEXT, " #name)))
255
256 struct image_type_params **__start_image_type, **__stop_image_type;
257 #else
258 #define INIT_SECTION(name) /* no-op for ELF */
259 #define SECTION(name)   __attribute__((section(#name)))
260
261 /* We construct a table of pointers in an ELF section (pointers generally
262  * go unpadded by gcc).  ld creates boundary syms for us. */
263 extern struct image_type_params *__start_image_type[], *__stop_image_type[];
264 #endif /* __MACH__ */
265
266 #if !defined(__used)
267 # if __GNUC__ == 3 && __GNUC_MINOR__ < 3
268 #  define __used                        __attribute__((__unused__))
269 # else
270 #  define __used                        __attribute__((__used__))
271 # endif
272 #endif
273
274 #define U_BOOT_IMAGE_TYPE( \
275                 _id, \
276                 _name, \
277                 _header_size, \
278                 _header, \
279                 _check_params, \
280                 _verify_header, \
281                 _print_header, \
282                 _set_header, \
283                 _extract_subimage, \
284                 _check_image_type, \
285                 _fflag_handle, \
286                 _vrec_header \
287         ) \
288         static struct image_type_params __cat(image_type_, _id) = \
289         { \
290                 .name = _name, \
291                 .header_size = _header_size, \
292                 .hdr = _header, \
293                 .check_params = _check_params, \
294                 .verify_header = _verify_header, \
295                 .print_header = _print_header, \
296                 .set_header = _set_header, \
297                 .extract_subimage = _extract_subimage, \
298                 .check_image_type = _check_image_type, \
299                 .fflag_handle = _fflag_handle, \
300                 .vrec_header = _vrec_header \
301         }; \
302         static struct image_type_params *SECTION(image_type) __used \
303                 __cat(image_type_ptr_, _id) = &__cat(image_type_, _id)
304
305 #endif /* _IMAGETOOL_H_ */