blob: 923a9755b70993dfa6756b2464dbdf8a889fcad7 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +05302/*
3 * (C) Copyright 2008 Semihalf
4 *
5 * (C) Copyright 2000-2004
6 * DENX Software Engineering
7 * Wolfgang Denk, wd@denx.de
8 *
9 * Updated-by: Prafulla Wadaskar <prafulla@marvell.com>
10 * FIT image specific code abstracted from mkimage.c
11 * some functions added to address abstraction
12 *
13 * All rights reserved.
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053014 */
15
Guilherme Maciel Ferreiraf86ed6a2013-12-01 12:43:10 -070016#include "imagetool.h"
Heiko Schocher6bf4ca02014-03-03 12:19:29 +010017#include "fit_common.h"
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053018#include "mkimage.h"
19#include <image.h>
Sven Roedererea5d3732020-04-27 02:08:39 +020020#include <string.h>
Simon Glass8e35bb02016-02-22 22:55:51 -070021#include <stdarg.h>
22#include <version.h>
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053023#include <u-boot/crc.h>
24
Simon Glassf3543e62022-09-06 20:26:52 -060025static struct legacy_img_hdr header;
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053026
Simon Glassa9468112014-06-02 22:04:53 -060027static int fit_add_file_data(struct image_tool_params *params, size_t size_inc,
28 const char *tmpfile)
29{
30 int tfd, destfd = 0;
31 void *dest_blob = NULL;
32 off_t destfd_size = 0;
33 struct stat sbuf;
34 void *ptr;
35 int ret = 0;
36
Luca Boccassi7d574852019-05-14 19:35:02 +010037 tfd = mmap_fdt(params->cmdname, tmpfile, size_inc, &ptr, &sbuf, true,
38 false);
Simon Glassa9468112014-06-02 22:04:53 -060039 if (tfd < 0)
40 return -EIO;
41
42 if (params->keydest) {
43 struct stat dest_sbuf;
44
45 destfd = mmap_fdt(params->cmdname, params->keydest, size_inc,
Luca Boccassi7d574852019-05-14 19:35:02 +010046 &dest_blob, &dest_sbuf, false,
47 false);
Simon Glassa9468112014-06-02 22:04:53 -060048 if (destfd < 0) {
49 ret = -EIO;
50 goto err_keydest;
51 }
52 destfd_size = dest_sbuf.st_size;
53 }
54
55 /* for first image creation, add a timestamp at offset 0 i.e., root */
Simon Glass152b2462020-07-09 18:39:43 -060056 if (params->datafile || params->reset_timestamp) {
Alex Kiernan87925df2018-06-20 20:10:51 +000057 time_t time = imagetool_get_source_date(params->cmdname,
58 sbuf.st_mtime);
Vagrant Cascadian58470842016-06-16 12:28:40 -070059 ret = fit_set_timestamp(ptr, 0, time);
60 }
Simon Glassa9468112014-06-02 22:04:53 -060061
Philippe Reynes6e052d12022-03-28 22:57:02 +020062 if (!ret)
63 ret = fit_pre_load_data(params->keydir, dest_blob, ptr);
64
Simon Glassa9468112014-06-02 22:04:53 -060065 if (!ret) {
Philippe Reynes7298e422019-12-18 18:25:41 +010066 ret = fit_cipher_data(params->keydir, dest_blob, ptr,
67 params->comment,
68 params->require_keys,
69 params->engine_id,
70 params->cmdname);
71 }
72
73 if (!ret) {
Alexandru Gagniuc36bfcb62021-02-19 12:45:17 -060074 ret = fit_add_verification_data(params->keydir,
75 params->keyfile, dest_blob, ptr,
Simon Glassa9468112014-06-02 22:04:53 -060076 params->comment,
George McCollisterf1ca1fd2017-01-06 13:14:17 -060077 params->require_keys,
Alex Kiernan795f4522018-06-20 20:10:52 +000078 params->engine_id,
Jan Kiszka5902a392022-01-14 10:21:19 +010079 params->cmdname,
Simon Glass2d2384b2021-11-12 12:28:13 -070080 params->algo_name,
81 &params->summary);
Simon Glassa9468112014-06-02 22:04:53 -060082 }
83
84 if (dest_blob) {
85 munmap(dest_blob, destfd_size);
86 close(destfd);
87 }
88
89err_keydest:
90 munmap(ptr, sbuf.st_size);
91 close(tfd);
Simon Glassa9468112014-06-02 22:04:53 -060092 return ret;
93}
94
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053095/**
Simon Glass8e35bb02016-02-22 22:55:51 -070096 * fit_calc_size() - Calculate the approximate size of the FIT we will generate
97 */
98static int fit_calc_size(struct image_tool_params *params)
99{
Simon Glassfb4cce02016-02-22 22:55:52 -0700100 struct content_info *cont;
Simon Glass8e35bb02016-02-22 22:55:51 -0700101 int size, total_size;
102
103 size = imagetool_get_filesize(params, params->datafile);
104 if (size < 0)
105 return -1;
Simon Glass8e35bb02016-02-22 22:55:51 -0700106 total_size = size;
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100107
108 if (params->fit_ramdisk) {
109 size = imagetool_get_filesize(params, params->fit_ramdisk);
110 if (size < 0)
111 return -1;
112 total_size += size;
113 }
114
Simon Glassfb4cce02016-02-22 22:55:52 -0700115 for (cont = params->content_head; cont; cont = cont->next) {
116 size = imagetool_get_filesize(params, cont->fname);
117 if (size < 0)
118 return -1;
Simon Glass8e35bb02016-02-22 22:55:51 -0700119
Simon Glass31729112020-05-27 07:24:55 -0600120 /* Add space for properties and hash node */
Simon Glassfb4cce02016-02-22 22:55:52 -0700121 total_size += size + 300;
122 }
Simon Glass8e35bb02016-02-22 22:55:51 -0700123
124 /* Add plenty of space for headers, properties, nodes, etc. */
125 total_size += 4096;
126
127 return total_size;
128}
129
130static int fdt_property_file(struct image_tool_params *params,
131 void *fdt, const char *name, const char *fname)
132{
133 struct stat sbuf;
134 void *ptr;
135 int ret;
136 int fd;
137
138 fd = open(fname, O_RDWR | O_BINARY);
139 if (fd < 0) {
140 fprintf(stderr, "%s: Can't open %s: %s\n",
141 params->cmdname, fname, strerror(errno));
142 return -1;
143 }
144
145 if (fstat(fd, &sbuf) < 0) {
146 fprintf(stderr, "%s: Can't stat %s: %s\n",
147 params->cmdname, fname, strerror(errno));
148 goto err;
149 }
150
151 ret = fdt_property_placeholder(fdt, "data", sbuf.st_size, &ptr);
152 if (ret)
Simon Glass3bd3a542016-03-16 07:45:42 -0600153 goto err;
Simon Glass8e35bb02016-02-22 22:55:51 -0700154 ret = read(fd, ptr, sbuf.st_size);
155 if (ret != sbuf.st_size) {
156 fprintf(stderr, "%s: Can't read %s: %s\n",
157 params->cmdname, fname, strerror(errno));
158 goto err;
159 }
Simon Glass3bd3a542016-03-16 07:45:42 -0600160 close(fd);
Simon Glass8e35bb02016-02-22 22:55:51 -0700161
162 return 0;
163err:
164 close(fd);
165 return -1;
166}
167
168static int fdt_property_strf(void *fdt, const char *name, const char *fmt, ...)
169{
170 char str[100];
171 va_list ptr;
172
173 va_start(ptr, fmt);
174 vsnprintf(str, sizeof(str), fmt, ptr);
175 va_end(ptr);
176 return fdt_property_string(fdt, name, str);
177}
178
Simon Glassfb4cce02016-02-22 22:55:52 -0700179static void get_basename(char *str, int size, const char *fname)
180{
181 const char *p, *start, *end;
182 int len;
183
184 /*
185 * Use the base name as the 'name' field. So for example:
186 *
187 * "arch/arm/dts/sun7i-a20-bananapro.dtb"
188 * becomes "sun7i-a20-bananapro"
189 */
190 p = strrchr(fname, '/');
191 start = p ? p + 1 : fname;
192 p = strrchr(fname, '.');
193 end = p ? p : fname + strlen(fname);
194 len = end - start;
195 if (len >= size)
196 len = size - 1;
197 memcpy(str, start, len);
198 str[len] = '\0';
199}
200
Simon Glass8e35bb02016-02-22 22:55:51 -0700201/**
Sean Anderson87b0af92022-05-16 16:11:08 -0400202 * add_hash_node() - Add a hash or signature node
Simon Glass31729112020-05-27 07:24:55 -0600203 *
Sean Anderson87b0af92022-05-16 16:11:08 -0400204 * @params: Image parameters
Simon Glass31729112020-05-27 07:24:55 -0600205 * @fdt: Device tree to add to (in sequential-write mode)
Sean Anderson87b0af92022-05-16 16:11:08 -0400206 *
207 * If there is a key name hint, try to sign the images. Otherwise, just add a
208 * CRC.
209 *
210 * Return: 0 on success, or -1 on failure
Simon Glass31729112020-05-27 07:24:55 -0600211 */
Sean Anderson87b0af92022-05-16 16:11:08 -0400212static int add_hash_node(struct image_tool_params *params, void *fdt)
Simon Glass31729112020-05-27 07:24:55 -0600213{
Sean Anderson87b0af92022-05-16 16:11:08 -0400214 if (params->keyname) {
215 if (!params->algo_name) {
216 fprintf(stderr,
217 "%s: Algorithm name must be specified\n",
218 params->cmdname);
219 return -1;
220 }
221
222 fdt_begin_node(fdt, "signature-1");
223 fdt_property_string(fdt, FIT_ALGO_PROP, params->algo_name);
224 fdt_property_string(fdt, FIT_KEY_HINT, params->keyname);
225 } else {
226 fdt_begin_node(fdt, "hash-1");
227 fdt_property_string(fdt, FIT_ALGO_PROP, "crc32");
228 }
229
Simon Glass31729112020-05-27 07:24:55 -0600230 fdt_end_node(fdt);
Sean Anderson87b0af92022-05-16 16:11:08 -0400231 return 0;
Simon Glass31729112020-05-27 07:24:55 -0600232}
233
234/**
Simon Glass8e35bb02016-02-22 22:55:51 -0700235 * fit_write_images() - Write out a list of images to the FIT
236 *
Simon Glassfb4cce02016-02-22 22:55:52 -0700237 * We always include the main image (params->datafile). If there are device
Andre Przywara2eda8e92017-12-04 02:05:12 +0000238 * tree files, we include an fdt- node for each of those too.
Simon Glass8e35bb02016-02-22 22:55:51 -0700239 */
240static int fit_write_images(struct image_tool_params *params, char *fdt)
241{
Simon Glassfb4cce02016-02-22 22:55:52 -0700242 struct content_info *cont;
Simon Glass8e35bb02016-02-22 22:55:51 -0700243 const char *typename;
244 char str[100];
Simon Glassfb4cce02016-02-22 22:55:52 -0700245 int upto;
Simon Glass8e35bb02016-02-22 22:55:51 -0700246 int ret;
247
248 fdt_begin_node(fdt, "images");
249
250 /* First the main image */
251 typename = genimg_get_type_short_name(params->fit_image_type);
Andre Przywara2eda8e92017-12-04 02:05:12 +0000252 snprintf(str, sizeof(str), "%s-1", typename);
Simon Glass8e35bb02016-02-22 22:55:51 -0700253 fdt_begin_node(fdt, str);
Michal Simek4a8b6e02018-07-20 12:31:02 +0200254 fdt_property_string(fdt, FIT_DESC_PROP, params->imagename);
255 fdt_property_string(fdt, FIT_TYPE_PROP, typename);
256 fdt_property_string(fdt, FIT_ARCH_PROP,
Simon Glass3a45f382016-06-30 10:52:12 -0600257 genimg_get_arch_short_name(params->arch));
Michal Simek4a8b6e02018-07-20 12:31:02 +0200258 fdt_property_string(fdt, FIT_OS_PROP,
259 genimg_get_os_short_name(params->os));
260 fdt_property_string(fdt, FIT_COMP_PROP,
Simon Glass8e35bb02016-02-22 22:55:51 -0700261 genimg_get_comp_short_name(params->comp));
Michal Simek4a8b6e02018-07-20 12:31:02 +0200262 fdt_property_u32(fdt, FIT_LOAD_PROP, params->addr);
263 fdt_property_u32(fdt, FIT_ENTRY_PROP, params->ep);
Simon Glass8e35bb02016-02-22 22:55:51 -0700264
265 /*
266 * Put data last since it is large. SPL may only load the first part
267 * of the DT, so this way it can access all the above fields.
268 */
Michal Simek4a8b6e02018-07-20 12:31:02 +0200269 ret = fdt_property_file(params, fdt, FIT_DATA_PROP, params->datafile);
Simon Glass8e35bb02016-02-22 22:55:51 -0700270 if (ret)
271 return ret;
Sean Anderson87b0af92022-05-16 16:11:08 -0400272 ret = add_hash_node(params, fdt);
273 if (ret)
274 return ret;
Simon Glass8e35bb02016-02-22 22:55:51 -0700275 fdt_end_node(fdt);
276
Simon Glassfb4cce02016-02-22 22:55:52 -0700277 /* Now the device tree files if available */
278 upto = 0;
279 for (cont = params->content_head; cont; cont = cont->next) {
280 if (cont->type != IH_TYPE_FLATDT)
281 continue;
Michal Sojka12e288a2019-09-13 12:43:12 +0200282 typename = genimg_get_type_short_name(cont->type);
Andre Przywara2eda8e92017-12-04 02:05:12 +0000283 snprintf(str, sizeof(str), "%s-%d", FIT_FDT_PROP, ++upto);
Simon Glassfb4cce02016-02-22 22:55:52 -0700284 fdt_begin_node(fdt, str);
285
286 get_basename(str, sizeof(str), cont->fname);
Michal Simek4a8b6e02018-07-20 12:31:02 +0200287 fdt_property_string(fdt, FIT_DESC_PROP, str);
288 ret = fdt_property_file(params, fdt, FIT_DATA_PROP,
289 cont->fname);
Simon Glassfb4cce02016-02-22 22:55:52 -0700290 if (ret)
291 return ret;
Michal Simek4a8b6e02018-07-20 12:31:02 +0200292 fdt_property_string(fdt, FIT_TYPE_PROP, typename);
293 fdt_property_string(fdt, FIT_ARCH_PROP,
Simon Glassfb4cce02016-02-22 22:55:52 -0700294 genimg_get_arch_short_name(params->arch));
Michal Simek4a8b6e02018-07-20 12:31:02 +0200295 fdt_property_string(fdt, FIT_COMP_PROP,
Simon Glassfb4cce02016-02-22 22:55:52 -0700296 genimg_get_comp_short_name(IH_COMP_NONE));
Sean Anderson87b0af92022-05-16 16:11:08 -0400297 ret = add_hash_node(params, fdt);
298 if (ret)
299 return ret;
Simon Glassfb4cce02016-02-22 22:55:52 -0700300 fdt_end_node(fdt);
301 }
302
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100303 /* And a ramdisk file if available */
304 if (params->fit_ramdisk) {
Andre Przywara2eda8e92017-12-04 02:05:12 +0000305 fdt_begin_node(fdt, FIT_RAMDISK_PROP "-1");
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100306
Michal Simek4a8b6e02018-07-20 12:31:02 +0200307 fdt_property_string(fdt, FIT_TYPE_PROP, FIT_RAMDISK_PROP);
308 fdt_property_string(fdt, FIT_OS_PROP,
309 genimg_get_os_short_name(params->os));
Michal Sojka12e288a2019-09-13 12:43:12 +0200310 fdt_property_string(fdt, FIT_ARCH_PROP,
311 genimg_get_arch_short_name(params->arch));
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100312
Michal Simek4a8b6e02018-07-20 12:31:02 +0200313 ret = fdt_property_file(params, fdt, FIT_DATA_PROP,
314 params->fit_ramdisk);
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100315 if (ret)
316 return ret;
Sean Anderson87b0af92022-05-16 16:11:08 -0400317 ret = add_hash_node(params, fdt);
318 if (ret)
319 return ret;
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100320 fdt_end_node(fdt);
321 }
322
Simon Glass8e35bb02016-02-22 22:55:51 -0700323 fdt_end_node(fdt);
324
325 return 0;
326}
327
328/**
329 * fit_write_configs() - Write out a list of configurations to the FIT
330 *
Simon Glassfb4cce02016-02-22 22:55:52 -0700331 * If there are device tree files, we include a configuration for each, which
332 * selects the main image (params->datafile) and its corresponding device
333 * tree file.
334 *
335 * Otherwise we just create a configuration with the main image in it.
Simon Glass8e35bb02016-02-22 22:55:51 -0700336 */
337static void fit_write_configs(struct image_tool_params *params, char *fdt)
338{
Simon Glassfb4cce02016-02-22 22:55:52 -0700339 struct content_info *cont;
Simon Glass8e35bb02016-02-22 22:55:51 -0700340 const char *typename;
341 char str[100];
Simon Glassfb4cce02016-02-22 22:55:52 -0700342 int upto;
Simon Glass8e35bb02016-02-22 22:55:51 -0700343
344 fdt_begin_node(fdt, "configurations");
Michal Simek4a8b6e02018-07-20 12:31:02 +0200345 fdt_property_string(fdt, FIT_DEFAULT_PROP, "conf-1");
Simon Glass8e35bb02016-02-22 22:55:51 -0700346
Simon Glassfb4cce02016-02-22 22:55:52 -0700347 upto = 0;
348 for (cont = params->content_head; cont; cont = cont->next) {
349 if (cont->type != IH_TYPE_FLATDT)
350 continue;
351 typename = genimg_get_type_short_name(cont->type);
Andre Przywara2eda8e92017-12-04 02:05:12 +0000352 snprintf(str, sizeof(str), "conf-%d", ++upto);
Simon Glassfb4cce02016-02-22 22:55:52 -0700353 fdt_begin_node(fdt, str);
354
355 get_basename(str, sizeof(str), cont->fname);
Michal Simek4a8b6e02018-07-20 12:31:02 +0200356 fdt_property_string(fdt, FIT_DESC_PROP, str);
Simon Glassfb4cce02016-02-22 22:55:52 -0700357
358 typename = genimg_get_type_short_name(params->fit_image_type);
Andre Przywara2eda8e92017-12-04 02:05:12 +0000359 snprintf(str, sizeof(str), "%s-1", typename);
Simon Glassfb4cce02016-02-22 22:55:52 -0700360 fdt_property_string(fdt, typename, str);
Abel Vesacabde442019-03-12 08:34:32 +0000361 fdt_property_string(fdt, FIT_LOADABLE_PROP, str);
Simon Glassfb4cce02016-02-22 22:55:52 -0700362
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100363 if (params->fit_ramdisk)
364 fdt_property_string(fdt, FIT_RAMDISK_PROP,
Andre Przywara2eda8e92017-12-04 02:05:12 +0000365 FIT_RAMDISK_PROP "-1");
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100366
Andre Przywara2eda8e92017-12-04 02:05:12 +0000367 snprintf(str, sizeof(str), FIT_FDT_PROP "-%d", upto);
Simon Glassfb4cce02016-02-22 22:55:52 -0700368 fdt_property_string(fdt, FIT_FDT_PROP, str);
369 fdt_end_node(fdt);
370 }
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100371
Simon Glassfb4cce02016-02-22 22:55:52 -0700372 if (!upto) {
Andre Przywara2eda8e92017-12-04 02:05:12 +0000373 fdt_begin_node(fdt, "conf-1");
Simon Glassfb4cce02016-02-22 22:55:52 -0700374 typename = genimg_get_type_short_name(params->fit_image_type);
Andre Przywara2eda8e92017-12-04 02:05:12 +0000375 snprintf(str, sizeof(str), "%s-1", typename);
Simon Glassfb4cce02016-02-22 22:55:52 -0700376 fdt_property_string(fdt, typename, str);
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100377
378 if (params->fit_ramdisk)
379 fdt_property_string(fdt, FIT_RAMDISK_PROP,
Andre Przywara2eda8e92017-12-04 02:05:12 +0000380 FIT_RAMDISK_PROP "-1");
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100381
Simon Glassfb4cce02016-02-22 22:55:52 -0700382 fdt_end_node(fdt);
383 }
Simon Glass8e35bb02016-02-22 22:55:51 -0700384
385 fdt_end_node(fdt);
386}
387
388static int fit_build_fdt(struct image_tool_params *params, char *fdt, int size)
389{
390 int ret;
391
392 ret = fdt_create(fdt, size);
393 if (ret)
394 return ret;
395 fdt_finish_reservemap(fdt);
396 fdt_begin_node(fdt, "");
Michal Simek4a8b6e02018-07-20 12:31:02 +0200397 fdt_property_strf(fdt, FIT_DESC_PROP,
Simon Glass8e35bb02016-02-22 22:55:51 -0700398 "%s image with one or more FDT blobs",
399 genimg_get_type_name(params->fit_image_type));
400 fdt_property_strf(fdt, "creator", "U-Boot mkimage %s", PLAIN_VERSION);
401 fdt_property_u32(fdt, "#address-cells", 1);
402 ret = fit_write_images(params, fdt);
403 if (ret)
404 return ret;
405 fit_write_configs(params, fdt);
406 fdt_end_node(fdt);
407 ret = fdt_finish(fdt);
408 if (ret)
409 return ret;
410
411 return fdt_totalsize(fdt);
412}
413
414static int fit_build(struct image_tool_params *params, const char *fname)
415{
416 char *buf;
417 int size;
418 int ret;
419 int fd;
420
421 size = fit_calc_size(params);
422 if (size < 0)
423 return -1;
Fabio Estevamaaa91a42020-07-27 21:03:13 -0300424 buf = calloc(1, size);
Simon Glass8e35bb02016-02-22 22:55:51 -0700425 if (!buf) {
426 fprintf(stderr, "%s: Out of memory (%d bytes)\n",
427 params->cmdname, size);
428 return -1;
429 }
430 ret = fit_build_fdt(params, buf, size);
431 if (ret < 0) {
432 fprintf(stderr, "%s: Failed to build FIT image\n",
433 params->cmdname);
Simon Glass7b0bbd82016-03-16 07:45:41 -0600434 goto err_buf;
Simon Glass8e35bb02016-02-22 22:55:51 -0700435 }
436 size = ret;
437 fd = open(fname, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
438 if (fd < 0) {
439 fprintf(stderr, "%s: Can't open %s: %s\n",
440 params->cmdname, fname, strerror(errno));
Tom Rini3c2dff52017-09-26 22:14:44 -0400441 goto err_buf;
Simon Glass8e35bb02016-02-22 22:55:51 -0700442 }
443 ret = write(fd, buf, size);
444 if (ret != size) {
445 fprintf(stderr, "%s: Can't write %s: %s\n",
446 params->cmdname, fname, strerror(errno));
Simon Glass8e35bb02016-02-22 22:55:51 -0700447 goto err;
448 }
449 close(fd);
Simon Glass7b0bbd82016-03-16 07:45:41 -0600450 free(buf);
Simon Glass8e35bb02016-02-22 22:55:51 -0700451
452 return 0;
453err:
Simon Glass7b0bbd82016-03-16 07:45:41 -0600454 close(fd);
455err_buf:
Simon Glass8e35bb02016-02-22 22:55:51 -0700456 free(buf);
457 return -1;
458}
459
460/**
Simon Glass722ebc82016-02-22 22:55:53 -0700461 * fit_extract_data() - Move all data outside the FIT
462 *
463 * This takes a normal FIT file and removes all the 'data' properties from it.
464 * The data is placed in an area after the FIT so that it can be accessed
465 * using an offset into that area. The 'data' properties turn into
466 * 'data-offset' properties.
467 *
468 * This function cannot cope with FITs with 'data-offset' properties. All
469 * data must be in 'data' properties on entry.
470 */
471static int fit_extract_data(struct image_tool_params *params, const char *fname)
472{
Kever Yangebfe6112020-03-30 11:56:24 +0800473 void *buf = NULL;
Simon Glass722ebc82016-02-22 22:55:53 -0700474 int buf_ptr;
475 int fit_size, new_size;
476 int fd;
477 struct stat sbuf;
478 void *fdt;
479 int ret;
480 int images;
481 int node;
Kever Yangebfe6112020-03-30 11:56:24 +0800482 int image_number;
483 int align_size;
Simon Glass722ebc82016-02-22 22:55:53 -0700484
Tom Rini7946a812020-05-06 11:05:17 -0400485 align_size = params->bl_len ? params->bl_len : 4;
Luca Boccassi7d574852019-05-14 19:35:02 +0100486 fd = mmap_fdt(params->cmdname, fname, 0, &fdt, &sbuf, false, false);
Simon Glass722ebc82016-02-22 22:55:53 -0700487 if (fd < 0)
488 return -EIO;
489 fit_size = fdt_totalsize(fdt);
490
Simon Glass722ebc82016-02-22 22:55:53 -0700491 images = fdt_path_offset(fdt, FIT_IMAGES_PATH);
492 if (images < 0) {
493 debug("%s: Cannot find /images node: %d\n", __func__, images);
494 ret = -EINVAL;
Simon Glassb97d71e2016-03-16 07:45:39 -0600495 goto err_munmap;
Simon Glass722ebc82016-02-22 22:55:53 -0700496 }
Kever Yangebfe6112020-03-30 11:56:24 +0800497 image_number = fdtdec_get_child_count(fdt, images);
498
499 /*
500 * Allocate space to hold the image data we will extract,
501 * extral space allocate for image alignment to prevent overflow.
502 */
Fabio Estevamaaa91a42020-07-27 21:03:13 -0300503 buf = calloc(1, fit_size + (align_size * image_number));
Kever Yangebfe6112020-03-30 11:56:24 +0800504 if (!buf) {
505 ret = -ENOMEM;
506 goto err_munmap;
507 }
508 buf_ptr = 0;
Simon Glass722ebc82016-02-22 22:55:53 -0700509
510 for (node = fdt_first_subnode(fdt, images);
511 node >= 0;
512 node = fdt_next_subnode(fdt, node)) {
513 const char *data;
514 int len;
515
Michal Simek4a8b6e02018-07-20 12:31:02 +0200516 data = fdt_getprop(fdt, node, FIT_DATA_PROP, &len);
Simon Glass722ebc82016-02-22 22:55:53 -0700517 if (!data)
518 continue;
519 memcpy(buf + buf_ptr, data, len);
520 debug("Extracting data size %x\n", len);
521
Michal Simek4a8b6e02018-07-20 12:31:02 +0200522 ret = fdt_delprop(fdt, node, FIT_DATA_PROP);
Simon Glass722ebc82016-02-22 22:55:53 -0700523 if (ret) {
524 ret = -EPERM;
Simon Glassb97d71e2016-03-16 07:45:39 -0600525 goto err_munmap;
Simon Glass722ebc82016-02-22 22:55:53 -0700526 }
Teddy Reedf8f91072016-06-09 19:38:02 -0700527 if (params->external_offset > 0) {
528 /* An external offset positions the data absolutely. */
Michal Simek4a8b6e02018-07-20 12:31:02 +0200529 fdt_setprop_u32(fdt, node, FIT_DATA_POSITION_PROP,
Teddy Reedf8f91072016-06-09 19:38:02 -0700530 params->external_offset + buf_ptr);
531 } else {
Michal Simek4a8b6e02018-07-20 12:31:02 +0200532 fdt_setprop_u32(fdt, node, FIT_DATA_OFFSET_PROP,
533 buf_ptr);
Teddy Reedf8f91072016-06-09 19:38:02 -0700534 }
Michal Simek4a8b6e02018-07-20 12:31:02 +0200535 fdt_setprop_u32(fdt, node, FIT_DATA_SIZE_PROP, len);
Kever Yangebfe6112020-03-30 11:56:24 +0800536 buf_ptr += ALIGN(len, align_size);
Simon Glass722ebc82016-02-22 22:55:53 -0700537 }
538
539 /* Pack the FDT and place the data after it */
540 fdt_pack(fdt);
541
Kever Yangebfe6112020-03-30 11:56:24 +0800542 new_size = fdt_totalsize(fdt);
Tom Rini7946a812020-05-06 11:05:17 -0400543 new_size = ALIGN(new_size, align_size);
Kever Yangebfe6112020-03-30 11:56:24 +0800544 fdt_set_totalsize(fdt, new_size);
Simon Glass722ebc82016-02-22 22:55:53 -0700545 debug("Size reduced from %x to %x\n", fit_size, fdt_totalsize(fdt));
546 debug("External data size %x\n", buf_ptr);
Simon Glass722ebc82016-02-22 22:55:53 -0700547 munmap(fdt, sbuf.st_size);
548
549 if (ftruncate(fd, new_size)) {
550 debug("%s: Failed to truncate file: %s\n", __func__,
551 strerror(errno));
552 ret = -EIO;
553 goto err;
554 }
Teddy Reedf8f91072016-06-09 19:38:02 -0700555
556 /* Check if an offset for the external data was set. */
557 if (params->external_offset > 0) {
558 if (params->external_offset < new_size) {
Simon Glass206117a2022-01-09 20:13:38 -0700559 fprintf(stderr,
560 "External offset %x overlaps FIT length %x\n",
561 params->external_offset, new_size);
Teddy Reedf8f91072016-06-09 19:38:02 -0700562 ret = -EINVAL;
563 goto err;
564 }
565 new_size = params->external_offset;
566 }
Simon Glass722ebc82016-02-22 22:55:53 -0700567 if (lseek(fd, new_size, SEEK_SET) < 0) {
568 debug("%s: Failed to seek to end of file: %s\n", __func__,
569 strerror(errno));
570 ret = -EIO;
571 goto err;
572 }
573 if (write(fd, buf, buf_ptr) != buf_ptr) {
574 debug("%s: Failed to write external data to file %s\n",
575 __func__, strerror(errno));
576 ret = -EIO;
577 goto err;
578 }
Tom Rini3c2dff52017-09-26 22:14:44 -0400579 free(buf);
Simon Glassb97d71e2016-03-16 07:45:39 -0600580 close(fd);
581 return 0;
Simon Glass722ebc82016-02-22 22:55:53 -0700582
Simon Glassb97d71e2016-03-16 07:45:39 -0600583err_munmap:
584 munmap(fdt, sbuf.st_size);
Simon Glass722ebc82016-02-22 22:55:53 -0700585err:
Bin Meng0dbd6e32020-04-18 01:59:11 -0700586 free(buf);
Simon Glass722ebc82016-02-22 22:55:53 -0700587 close(fd);
588 return ret;
589}
590
Simon Glass529fd182016-02-22 22:55:54 -0700591static int fit_import_data(struct image_tool_params *params, const char *fname)
592{
593 void *fdt, *old_fdt;
594 int fit_size, new_size, size, data_base;
595 int fd;
596 struct stat sbuf;
597 int ret;
598 int images;
599 int node;
600
Luca Boccassi7d574852019-05-14 19:35:02 +0100601 fd = mmap_fdt(params->cmdname, fname, 0, &old_fdt, &sbuf, false, false);
Simon Glass529fd182016-02-22 22:55:54 -0700602 if (fd < 0)
603 return -EIO;
604 fit_size = fdt_totalsize(old_fdt);
Kever Yang02560b12020-03-30 11:56:22 +0800605 data_base = ALIGN(fit_size, 4);
Simon Glass529fd182016-02-22 22:55:54 -0700606
607 /* Allocate space to hold the new FIT */
608 size = sbuf.st_size + 16384;
Fabio Estevamaaa91a42020-07-27 21:03:13 -0300609 fdt = calloc(1, size);
Simon Glass529fd182016-02-22 22:55:54 -0700610 if (!fdt) {
611 fprintf(stderr, "%s: Failed to allocate memory (%d bytes)\n",
612 __func__, size);
613 ret = -ENOMEM;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700614 goto err_munmap;
Simon Glass529fd182016-02-22 22:55:54 -0700615 }
616 ret = fdt_open_into(old_fdt, fdt, size);
617 if (ret) {
618 debug("%s: Failed to expand FIT: %s\n", __func__,
619 fdt_strerror(errno));
620 ret = -EINVAL;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700621 goto err_munmap;
Simon Glass529fd182016-02-22 22:55:54 -0700622 }
623
624 images = fdt_path_offset(fdt, FIT_IMAGES_PATH);
625 if (images < 0) {
626 debug("%s: Cannot find /images node: %d\n", __func__, images);
627 ret = -EINVAL;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700628 goto err_munmap;
Simon Glass529fd182016-02-22 22:55:54 -0700629 }
630
631 for (node = fdt_first_subnode(fdt, images);
632 node >= 0;
633 node = fdt_next_subnode(fdt, node)) {
634 int buf_ptr;
635 int len;
636
637 buf_ptr = fdtdec_get_int(fdt, node, "data-offset", -1);
638 len = fdtdec_get_int(fdt, node, "data-size", -1);
639 if (buf_ptr == -1 || len == -1)
640 continue;
641 debug("Importing data size %x\n", len);
642
Patrick Oppenlanderc995d852020-07-30 14:31:48 +1000643 ret = fdt_setprop(fdt, node, "data",
644 old_fdt + data_base + buf_ptr, len);
Simon Glass529fd182016-02-22 22:55:54 -0700645 if (ret) {
646 debug("%s: Failed to write property: %s\n", __func__,
647 fdt_strerror(ret));
648 ret = -EINVAL;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700649 goto err_munmap;
Simon Glass529fd182016-02-22 22:55:54 -0700650 }
651 }
652
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700653 munmap(old_fdt, sbuf.st_size);
654
Tom Rinibf52fcd2017-10-07 11:27:59 -0400655 /* Close the old fd so we can re-use it. */
Simon Glass529fd182016-02-22 22:55:54 -0700656 close(fd);
657
658 /* Pack the FDT and place the data after it */
659 fdt_pack(fdt);
660
661 new_size = fdt_totalsize(fdt);
662 debug("Size expanded from %x to %x\n", fit_size, new_size);
663
664 fd = open(fname, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
665 if (fd < 0) {
666 fprintf(stderr, "%s: Can't open %s: %s\n",
667 params->cmdname, fname, strerror(errno));
Tom Rinibf52fcd2017-10-07 11:27:59 -0400668 ret = -EIO;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700669 goto err;
Simon Glass529fd182016-02-22 22:55:54 -0700670 }
671 if (write(fd, fdt, new_size) != new_size) {
672 debug("%s: Failed to write external data to file %s\n",
673 __func__, strerror(errno));
674 ret = -EIO;
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700675 goto err;
Simon Glass529fd182016-02-22 22:55:54 -0700676 }
Simon Glass529fd182016-02-22 22:55:54 -0700677
Simon Glass6e0ffce2016-03-16 07:45:38 -0600678 free(fdt);
Lihua Zhao3fc85a72020-04-18 01:59:10 -0700679 close(fd);
680 return 0;
681
682err_munmap:
683 munmap(old_fdt, sbuf.st_size);
684err:
685 free(fdt);
686 close(fd);
Simon Glass529fd182016-02-22 22:55:54 -0700687 return ret;
688}
689
Simon Glass722ebc82016-02-22 22:55:53 -0700690/**
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530691 * fit_handle_file - main FIT file processing function
692 *
693 * fit_handle_file() runs dtc to convert .its to .itb, includes
694 * binary data, updates timestamp property and calculates hashes.
695 *
696 * datafile - .its file
697 * imagefile - .itb file
698 *
699 * returns:
700 * only on success, otherwise calls exit (EXIT_FAILURE);
701 */
Guilherme Maciel Ferreiraf86ed6a2013-12-01 12:43:10 -0700702static int fit_handle_file(struct image_tool_params *params)
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530703{
704 char tmpfile[MKIMAGE_MAX_TMPFILE_LEN];
Philippe Reynes7298e422019-12-18 18:25:41 +0100705 char bakfile[MKIMAGE_MAX_TMPFILE_LEN + 4] = {0};
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530706 char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN];
Simon Glassa9468112014-06-02 22:04:53 -0600707 size_t size_inc;
708 int ret;
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530709
710 /* Flattened Image Tree (FIT) format handling */
711 debug ("FIT format handling\n");
712
713 /* call dtc to include binary properties into the tmp file */
714 if (strlen (params->imagefile) +
715 strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > sizeof (tmpfile)) {
716 fprintf (stderr, "%s: Image file name (%s) too long, "
Sven Roederer9c702372021-05-25 23:15:27 +0200717 "can't create tmpfile.\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530718 params->imagefile, params->cmdname);
719 return (EXIT_FAILURE);
720 }
721 sprintf (tmpfile, "%s%s", params->imagefile, MKIMAGE_TMPFILE_SUFFIX);
722
Simon Glass95d77b42013-06-13 15:10:05 -0700723 /* We either compile the source file, or use the existing FIT image */
Simon Glass8e35bb02016-02-22 22:55:51 -0700724 if (params->auto_its) {
725 if (fit_build(params, tmpfile)) {
726 fprintf(stderr, "%s: failed to build FIT\n",
727 params->cmdname);
728 return EXIT_FAILURE;
729 }
730 *cmd = '\0';
731 } else if (params->datafile) {
Stefan Theil63f881d2018-03-08 09:00:13 +0100732 /* dtc -I dts -O dtb -p 500 -o tmpfile datafile */
733 snprintf(cmd, sizeof(cmd), "%s %s -o \"%s\" \"%s\"",
734 MKIMAGE_DTC, params->dtc, tmpfile, params->datafile);
Simon Glass95d77b42013-06-13 15:10:05 -0700735 debug("Trying to execute \"%s\"\n", cmd);
736 } else {
Mirza, Taimoora6e98102017-10-04 20:28:03 +0500737 snprintf(cmd, sizeof(cmd), "cp \"%s\" \"%s\"",
Simon Glass95d77b42013-06-13 15:10:05 -0700738 params->imagefile, tmpfile);
739 }
Sven Roedererea5d3732020-04-27 02:08:39 +0200740 if (strlen(cmd) >= MKIMAGE_MAX_DTC_CMDLINE_LEN - 1) {
741 fprintf(stderr, "WARNING: command-line for FIT creation might be truncated and will probably fail.\n");
742 }
Philippe Reynes7298e422019-12-18 18:25:41 +0100743
Simon Glass8e35bb02016-02-22 22:55:51 -0700744 if (*cmd && system(cmd) == -1) {
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530745 fprintf (stderr, "%s: system(%s) failed: %s\n",
746 params->cmdname, cmd, strerror(errno));
Simon Glassaa6d6db2013-05-08 08:05:57 +0000747 goto err_system;
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530748 }
749
Simon Glass529fd182016-02-22 22:55:54 -0700750 /* Move the data so it is internal to the FIT, if needed */
751 ret = fit_import_data(params, tmpfile);
752 if (ret)
753 goto err_system;
754
Simon Glassa9468112014-06-02 22:04:53 -0600755 /*
Philippe Reynes7298e422019-12-18 18:25:41 +0100756 * Copy the tmpfile to bakfile, then in the following loop
757 * we copy bakfile to tmpfile. So we always start from the
758 * beginning.
759 */
760 sprintf(bakfile, "%s%s", tmpfile, ".bak");
761 rename(tmpfile, bakfile);
762
763 /*
Simon Glassa9468112014-06-02 22:04:53 -0600764 * Set hashes for images in the blob. Unfortunately we may need more
765 * space in either FDT, so keep trying until we succeed.
766 *
767 * Note: this is pretty inefficient for signing, since we must
768 * calculate the signature every time. It would be better to calculate
769 * all the data and then store it in a separate step. However, this
770 * would be considerably more complex to implement. Generally a few
771 * steps of this loop is enough to sign with several keys.
772 */
773 for (size_inc = 0; size_inc < 64 * 1024; size_inc += 1024) {
Philippe Reynes7298e422019-12-18 18:25:41 +0100774 if (copyfile(bakfile, tmpfile) < 0) {
775 printf("Can't copy %s to %s\n", bakfile, tmpfile);
776 ret = -EIO;
777 break;
778 }
Simon Glassa9468112014-06-02 22:04:53 -0600779 ret = fit_add_file_data(params, size_inc, tmpfile);
780 if (!ret || ret != -ENOSPC)
781 break;
Simon Glasse29495d2013-06-13 15:10:04 -0700782 }
783
Simon Glassa9468112014-06-02 22:04:53 -0600784 if (ret) {
Simon Glass655cc692016-07-03 09:40:43 -0600785 fprintf(stderr, "%s Can't add hashes to FIT blob: %d\n",
786 params->cmdname, ret);
Simon Glassa9468112014-06-02 22:04:53 -0600787 goto err_system;
Simon Glasse29495d2013-06-13 15:10:04 -0700788 }
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530789
Simon Glass722ebc82016-02-22 22:55:53 -0700790 /* Move the data so it is external to the FIT, if requested */
791 if (params->external_data) {
792 ret = fit_extract_data(params, tmpfile);
793 if (ret)
794 goto err_system;
795 }
796
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530797 if (rename (tmpfile, params->imagefile) == -1) {
798 fprintf (stderr, "%s: Can't rename %s to %s: %s\n",
799 params->cmdname, tmpfile, params->imagefile,
800 strerror (errno));
801 unlink (tmpfile);
Philippe Reynes7298e422019-12-18 18:25:41 +0100802 unlink(bakfile);
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530803 unlink (params->imagefile);
Simon Glassa9468112014-06-02 22:04:53 -0600804 return EXIT_FAILURE;
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530805 }
Philippe Reynes7298e422019-12-18 18:25:41 +0100806 unlink(bakfile);
Simon Glassa9468112014-06-02 22:04:53 -0600807 return EXIT_SUCCESS;
Simon Glassaa6d6db2013-05-08 08:05:57 +0000808
Simon Glassaa6d6db2013-05-08 08:05:57 +0000809err_system:
810 unlink(tmpfile);
Philippe Reynes7298e422019-12-18 18:25:41 +0100811 unlink(bakfile);
Simon Glassaa6d6db2013-05-08 08:05:57 +0000812 return -1;
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530813}
814
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200815/**
816 * fit_image_extract - extract a FIT component image
817 * @fit: pointer to the FIT format image header
818 * @image_noffset: offset of the component image node
819 * @file_name: name of the file to store the FIT sub-image
820 *
821 * returns:
822 * zero in case of success or a negative value if fail.
823 */
824static int fit_image_extract(
825 const void *fit,
826 int image_noffset,
827 const char *file_name)
828{
829 const void *file_data;
830 size_t file_size = 0;
Andrew F. Davise5b56282019-09-17 17:09:34 -0400831 int ret;
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200832
Andrew F. Davise5b56282019-09-17 17:09:34 -0400833 /* get the data address and size of component at offset "image_noffset" */
834 ret = fit_image_get_data_and_size(fit, image_noffset, &file_data, &file_size);
835 if (ret) {
836 fprintf(stderr, "Could not get component information\n");
837 return ret;
838 }
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200839
840 /* save the "file_data" into the file specified by "file_name" */
841 return imagetool_save_subimage(file_name, (ulong) file_data, file_size);
842}
843
844/**
845 * fit_extract_contents - retrieve a sub-image component from the FIT image
846 * @ptr: pointer to the FIT format image header
847 * @params: command line parameters
848 *
849 * returns:
850 * zero in case of success or a negative value if fail.
851 */
852static int fit_extract_contents(void *ptr, struct image_tool_params *params)
853{
854 int images_noffset;
855 int noffset;
856 int ndepth;
857 const void *fit = ptr;
858 int count = 0;
859 const char *p;
860
861 /* Indent string is defined in header image.h */
862 p = IMAGE_INDENT_STRING;
863
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200864 /* Find images parent node offset */
865 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
866 if (images_noffset < 0) {
867 printf("Can't find images parent node '%s' (%s)\n",
868 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
869 return -1;
870 }
871
872 /* Avoid any overrun */
873 count = fit_get_subimage_count(fit, images_noffset);
874 if ((params->pflag < 0) || (count <= params->pflag)) {
875 printf("No such component at '%d'\n", params->pflag);
876 return -1;
877 }
878
879 /* Process its subnodes, extract the desired component from image */
880 for (ndepth = 0, count = 0,
881 noffset = fdt_next_node(fit, images_noffset, &ndepth);
882 (noffset >= 0) && (ndepth > 0);
883 noffset = fdt_next_node(fit, noffset, &ndepth)) {
884 if (ndepth == 1) {
885 /*
886 * Direct child node of the images parent node,
887 * i.e. component image node.
888 */
889 if (params->pflag == count) {
890 printf("Extracted:\n%s Image %u (%s)\n", p,
891 count, fit_get_name(fit, noffset, NULL));
892
893 fit_image_print(fit, noffset, p);
894
895 return fit_image_extract(fit, noffset,
896 params->outfile);
897 }
898
899 count++;
900 }
901 }
902
903 return 0;
904}
905
Guilherme Maciel Ferreiraf86ed6a2013-12-01 12:43:10 -0700906static int fit_check_params(struct image_tool_params *params)
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530907{
Simon Glass8e35bb02016-02-22 22:55:51 -0700908 if (params->auto_its)
909 return 0;
Heinrich Schuchardt58194662019-12-11 13:51:38 +0100910 return ((params->dflag && params->fflag) ||
911 (params->fflag && params->lflag) ||
912 (params->lflag && params->dflag));
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530913}
914
Guilherme Maciel Ferreiraa93648d2015-01-15 02:48:07 -0200915U_BOOT_IMAGE_TYPE(
916 fitimage,
917 "FIT Image support",
Simon Glassf3543e62022-09-06 20:26:52 -0600918 sizeof(struct legacy_img_hdr),
Guilherme Maciel Ferreiraa93648d2015-01-15 02:48:07 -0200919 (void *)&header,
920 fit_check_params,
921 fit_verify_header,
922 fit_print_contents,
923 NULL,
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200924 fit_extract_contents,
Guilherme Maciel Ferreiraa93648d2015-01-15 02:48:07 -0200925 fit_check_image_types,
926 fit_handle_file,
927 NULL /* FIT images use DTB header */
928);