]> git.ipfire.org Git - people/ms/u-boot.git/blame - common/image-fit.c
board: ti: beagle_x15: added USB initializtion code
[people/ms/u-boot.git] / common / image-fit.c
CommitLineData
53fbb7e8
SG
1/*
2 * Copyright (c) 2013, Google Inc.
3 *
4 * (C) Copyright 2008 Semihalf
5 *
6 * (C) Copyright 2000-2006
7 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
8 *
1a459660 9 * SPDX-License-Identifier: GPL-2.0+
53fbb7e8
SG
10 */
11
12#ifdef USE_HOSTCC
13#include "mkimage.h"
14#include <image.h>
15#include <time.h>
16#else
17#include <common.h>
782cfbb2 18#include <errno.h>
0eb25b61 19#include <mapmem.h>
782cfbb2
SG
20#include <asm/io.h>
21DECLARE_GLOBAL_DATA_PTR;
53fbb7e8
SG
22#endif /* !USE_HOSTCC*/
23
24#include <bootstage.h>
53fbb7e8
SG
25#include <u-boot/crc.h>
26#include <u-boot/md5.h>
2b9912e6
JH
27#include <u-boot/sha1.h>
28#include <u-boot/sha256.h>
53fbb7e8
SG
29
30/*****************************************************************************/
31/* New uImage format routines */
32/*****************************************************************************/
33#ifndef USE_HOSTCC
34static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
35 ulong *addr, const char **name)
36{
37 const char *sep;
38
39 *addr = addr_curr;
40 *name = NULL;
41
42 sep = strchr(spec, sepc);
43 if (sep) {
44 if (sep - spec > 0)
45 *addr = simple_strtoul(spec, NULL, 16);
46
47 *name = sep + 1;
48 return 1;
49 }
50
51 return 0;
52}
53
54/**
55 * fit_parse_conf - parse FIT configuration spec
56 * @spec: input string, containing configuration spec
57 * @add_curr: current image address (to be used as a possible default)
58 * @addr: pointer to a ulong variable, will hold FIT image address of a given
59 * configuration
60 * @conf_name double pointer to a char, will hold pointer to a configuration
61 * unit name
62 *
069d5945 63 * fit_parse_conf() expects configuration spec in the form of [<addr>]#<conf>,
53fbb7e8
SG
64 * where <addr> is a FIT image address that contains configuration
65 * with a <conf> unit name.
66 *
67 * Address part is optional, and if omitted default add_curr will
68 * be used instead.
69 *
70 * returns:
71 * 1 if spec is a valid configuration string,
72 * addr and conf_name are set accordingly
73 * 0 otherwise
74 */
75int fit_parse_conf(const char *spec, ulong addr_curr,
76 ulong *addr, const char **conf_name)
77{
78 return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
79}
80
81/**
82 * fit_parse_subimage - parse FIT subimage spec
83 * @spec: input string, containing subimage spec
84 * @add_curr: current image address (to be used as a possible default)
85 * @addr: pointer to a ulong variable, will hold FIT image address of a given
86 * subimage
87 * @image_name: double pointer to a char, will hold pointer to a subimage name
88 *
069d5945 89 * fit_parse_subimage() expects subimage spec in the form of
53fbb7e8
SG
90 * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
91 * subimage with a <subimg> unit name.
92 *
93 * Address part is optional, and if omitted default add_curr will
94 * be used instead.
95 *
96 * returns:
97 * 1 if spec is a valid subimage string,
98 * addr and image_name are set accordingly
99 * 0 otherwise
100 */
101int fit_parse_subimage(const char *spec, ulong addr_curr,
102 ulong *addr, const char **image_name)
103{
104 return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
105}
106#endif /* !USE_HOSTCC */
107
108static void fit_get_debug(const void *fit, int noffset,
109 char *prop_name, int err)
110{
111 debug("Can't get '%s' property from FIT 0x%08lx, node: offset %d, name %s (%s)\n",
112 prop_name, (ulong)fit, noffset, fit_get_name(fit, noffset, NULL),
113 fdt_strerror(err));
114}
115
39931f96
GMF
116/**
117 * fit_get_subimage_count - get component (sub-image) count
118 * @fit: pointer to the FIT format image header
119 * @images_noffset: offset of images node
120 *
121 * returns:
122 * number of image components
123 */
124int fit_get_subimage_count(const void *fit, int images_noffset)
125{
126 int noffset;
127 int ndepth;
128 int count = 0;
129
130 /* Process its subnodes, print out component images details */
131 for (ndepth = 0, count = 0,
132 noffset = fdt_next_node(fit, images_noffset, &ndepth);
133 (noffset >= 0) && (ndepth > 0);
134 noffset = fdt_next_node(fit, noffset, &ndepth)) {
135 if (ndepth == 1) {
136 count++;
137 }
138 }
139
140 return count;
141}
142
87ebee39 143#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_FIT_SPL_PRINT)
53fbb7e8
SG
144/**
145 * fit_print_contents - prints out the contents of the FIT format image
146 * @fit: pointer to the FIT format image header
147 * @p: pointer to prefix string
148 *
149 * fit_print_contents() formats a multi line FIT image contents description.
150 * The routine prints out FIT image properties (root node level) follwed by
151 * the details of each component image.
152 *
153 * returns:
154 * no returned results
155 */
156void fit_print_contents(const void *fit)
157{
158 char *desc;
159 char *uname;
160 int images_noffset;
161 int confs_noffset;
162 int noffset;
163 int ndepth;
164 int count = 0;
165 int ret;
166 const char *p;
167 time_t timestamp;
168
1fe7d938
SG
169 /* Indent string is defined in header image.h */
170 p = IMAGE_INDENT_STRING;
53fbb7e8
SG
171
172 /* Root node properties */
173 ret = fit_get_desc(fit, 0, &desc);
174 printf("%sFIT description: ", p);
175 if (ret)
176 printf("unavailable\n");
177 else
178 printf("%s\n", desc);
179
180 if (IMAGE_ENABLE_TIMESTAMP) {
181 ret = fit_get_timestamp(fit, 0, &timestamp);
182 printf("%sCreated: ", p);
183 if (ret)
184 printf("unavailable\n");
185 else
186 genimg_print_time(timestamp);
187 }
188
189 /* Find images parent node offset */
190 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
191 if (images_noffset < 0) {
192 printf("Can't find images parent node '%s' (%s)\n",
193 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
194 return;
195 }
196
197 /* Process its subnodes, print out component images details */
198 for (ndepth = 0, count = 0,
199 noffset = fdt_next_node(fit, images_noffset, &ndepth);
200 (noffset >= 0) && (ndepth > 0);
201 noffset = fdt_next_node(fit, noffset, &ndepth)) {
202 if (ndepth == 1) {
203 /*
204 * Direct child node of the images parent node,
205 * i.e. component image node.
206 */
207 printf("%s Image %u (%s)\n", p, count++,
208 fit_get_name(fit, noffset, NULL));
209
210 fit_image_print(fit, noffset, p);
211 }
212 }
213
214 /* Find configurations parent node offset */
215 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
216 if (confs_noffset < 0) {
217 debug("Can't get configurations parent node '%s' (%s)\n",
218 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
219 return;
220 }
221
222 /* get default configuration unit name from default property */
223 uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
224 if (uname)
225 printf("%s Default Configuration: '%s'\n", p, uname);
226
227 /* Process its subnodes, print out configurations details */
228 for (ndepth = 0, count = 0,
229 noffset = fdt_next_node(fit, confs_noffset, &ndepth);
230 (noffset >= 0) && (ndepth > 0);
231 noffset = fdt_next_node(fit, noffset, &ndepth)) {
232 if (ndepth == 1) {
233 /*
234 * Direct child node of the configurations parent node,
235 * i.e. configuration node.
236 */
237 printf("%s Configuration %u (%s)\n", p, count++,
238 fit_get_name(fit, noffset, NULL));
239
240 fit_conf_print(fit, noffset, p);
241 }
242 }
243}
244
d8b75360
SG
245/**
246 * fit_image_print_data() - prints out the hash node details
247 * @fit: pointer to the FIT format image header
248 * @noffset: offset of the hash node
249 * @p: pointer to prefix string
56518e71 250 * @type: Type of information to print ("hash" or "sign")
d8b75360
SG
251 *
252 * fit_image_print_data() lists properies for the processed hash node
253 *
56518e71
SG
254 * This function avoid using puts() since it prints a newline on the host
255 * but does not in U-Boot.
256 *
d8b75360
SG
257 * returns:
258 * no returned results
259 */
56518e71
SG
260static void fit_image_print_data(const void *fit, int noffset, const char *p,
261 const char *type)
d8b75360 262{
56518e71 263 const char *keyname;
d8b75360
SG
264 uint8_t *value;
265 int value_len;
56518e71
SG
266 char *algo;
267 int required;
268 int ret, i;
d8b75360 269
56518e71 270 debug("%s %s node: '%s'\n", p, type,
d8b75360 271 fit_get_name(fit, noffset, NULL));
56518e71 272 printf("%s %s algo: ", p, type);
d8b75360
SG
273 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
274 printf("invalid/unsupported\n");
275 return;
276 }
56518e71
SG
277 printf("%s", algo);
278 keyname = fdt_getprop(fit, noffset, "key-name-hint", NULL);
279 required = fdt_getprop(fit, noffset, "required", NULL) != NULL;
280 if (keyname)
281 printf(":%s", keyname);
282 if (required)
283 printf(" (required)");
284 printf("\n");
d8b75360
SG
285
286 ret = fit_image_hash_get_value(fit, noffset, &value,
287 &value_len);
56518e71 288 printf("%s %s value: ", p, type);
d8b75360
SG
289 if (ret) {
290 printf("unavailable\n");
291 } else {
292 for (i = 0; i < value_len; i++)
293 printf("%02x", value[i]);
294 printf("\n");
295 }
296
56518e71
SG
297 debug("%s %s len: %d\n", p, type, value_len);
298
299 /* Signatures have a time stamp */
300 if (IMAGE_ENABLE_TIMESTAMP && keyname) {
301 time_t timestamp;
302
303 printf("%s Timestamp: ", p);
304 if (fit_get_timestamp(fit, noffset, &timestamp))
305 printf("unavailable\n");
306 else
307 genimg_print_time(timestamp);
308 }
d8b75360
SG
309}
310
311/**
312 * fit_image_print_verification_data() - prints out the hash/signature details
313 * @fit: pointer to the FIT format image header
314 * @noffset: offset of the hash or signature node
315 * @p: pointer to prefix string
316 *
317 * This lists properies for the processed hash node
318 *
319 * returns:
320 * no returned results
321 */
322static void fit_image_print_verification_data(const void *fit, int noffset,
323 const char *p)
324{
325 const char *name;
326
327 /*
328 * Check subnode name, must be equal to "hash" or "signature".
329 * Multiple hash/signature nodes require unique unit node
330 * names, e.g. hash@1, hash@2, signature@1, signature@2, etc.
331 */
332 name = fit_get_name(fit, noffset, NULL);
56518e71
SG
333 if (!strncmp(name, FIT_HASH_NODENAME, strlen(FIT_HASH_NODENAME))) {
334 fit_image_print_data(fit, noffset, p, "Hash");
335 } else if (!strncmp(name, FIT_SIG_NODENAME,
336 strlen(FIT_SIG_NODENAME))) {
337 fit_image_print_data(fit, noffset, p, "Sign");
338 }
d8b75360
SG
339}
340
53fbb7e8
SG
341/**
342 * fit_image_print - prints out the FIT component image details
343 * @fit: pointer to the FIT format image header
344 * @image_noffset: offset of the component image node
345 * @p: pointer to prefix string
346 *
347 * fit_image_print() lists all mandatory properies for the processed component
348 * image. If present, hash nodes are printed out as well. Load
349 * address for images of type firmware is also printed out. Since the load
350 * address is not mandatory for firmware images, it will be output as
351 * "unavailable" when not present.
352 *
353 * returns:
354 * no returned results
355 */
356void fit_image_print(const void *fit, int image_noffset, const char *p)
357{
358 char *desc;
359 uint8_t type, arch, os, comp;
360 size_t size;
361 ulong load, entry;
362 const void *data;
363 int noffset;
364 int ndepth;
365 int ret;
366
367 /* Mandatory properties */
368 ret = fit_get_desc(fit, image_noffset, &desc);
369 printf("%s Description: ", p);
370 if (ret)
371 printf("unavailable\n");
372 else
373 printf("%s\n", desc);
374
1fd1e2f6
SG
375 if (IMAGE_ENABLE_TIMESTAMP) {
376 time_t timestamp;
377
378 ret = fit_get_timestamp(fit, 0, &timestamp);
379 printf("%s Created: ", p);
380 if (ret)
381 printf("unavailable\n");
382 else
383 genimg_print_time(timestamp);
384 }
385
53fbb7e8
SG
386 fit_image_get_type(fit, image_noffset, &type);
387 printf("%s Type: %s\n", p, genimg_get_type_name(type));
388
389 fit_image_get_comp(fit, image_noffset, &comp);
390 printf("%s Compression: %s\n", p, genimg_get_comp_name(comp));
391
392 ret = fit_image_get_data(fit, image_noffset, &data, &size);
393
394#ifndef USE_HOSTCC
395 printf("%s Data Start: ", p);
c6ac13bd 396 if (ret) {
53fbb7e8 397 printf("unavailable\n");
c6ac13bd
SG
398 } else {
399 void *vdata = (void *)data;
400
401 printf("0x%08lx\n", (ulong)map_to_sysmem(vdata));
402 }
53fbb7e8
SG
403#endif
404
405 printf("%s Data Size: ", p);
406 if (ret)
407 printf("unavailable\n");
408 else
409 genimg_print_size(size);
410
411 /* Remaining, type dependent properties */
412 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
413 (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
414 (type == IH_TYPE_FLATDT)) {
415 fit_image_get_arch(fit, image_noffset, &arch);
416 printf("%s Architecture: %s\n", p, genimg_get_arch_name(arch));
417 }
418
419 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK)) {
420 fit_image_get_os(fit, image_noffset, &os);
421 printf("%s OS: %s\n", p, genimg_get_os_name(os));
422 }
423
424 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
425 (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK)) {
426 ret = fit_image_get_load(fit, image_noffset, &load);
427 printf("%s Load Address: ", p);
428 if (ret)
429 printf("unavailable\n");
430 else
431 printf("0x%08lx\n", load);
432 }
433
434 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
435 (type == IH_TYPE_RAMDISK)) {
436 fit_image_get_entry(fit, image_noffset, &entry);
437 printf("%s Entry Point: ", p);
438 if (ret)
439 printf("unavailable\n");
440 else
441 printf("0x%08lx\n", entry);
442 }
443
444 /* Process all hash subnodes of the component image node */
445 for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
446 (noffset >= 0) && (ndepth > 0);
447 noffset = fdt_next_node(fit, noffset, &ndepth)) {
448 if (ndepth == 1) {
449 /* Direct child node of the component image node */
d8b75360 450 fit_image_print_verification_data(fit, noffset, p);
53fbb7e8
SG
451 }
452 }
453}
39931f96
GMF
454
455#endif /* !defined(CONFIG_SPL_BUILD) || defined(CONFIG_FIT_SPL_PRINT) */
53fbb7e8 456
53fbb7e8
SG
457/**
458 * fit_get_desc - get node description property
459 * @fit: pointer to the FIT format image header
460 * @noffset: node offset
461 * @desc: double pointer to the char, will hold pointer to the descrption
462 *
463 * fit_get_desc() reads description property from a given node, if
464 * description is found pointer to it is returened in third call argument.
465 *
466 * returns:
467 * 0, on success
468 * -1, on failure
469 */
470int fit_get_desc(const void *fit, int noffset, char **desc)
471{
472 int len;
473
474 *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
475 if (*desc == NULL) {
476 fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
477 return -1;
478 }
479
480 return 0;
481}
482
483/**
484 * fit_get_timestamp - get node timestamp property
485 * @fit: pointer to the FIT format image header
486 * @noffset: node offset
487 * @timestamp: pointer to the time_t, will hold read timestamp
488 *
489 * fit_get_timestamp() reads timestamp poperty from given node, if timestamp
490 * is found and has a correct size its value is retured in third call
491 * argument.
492 *
493 * returns:
494 * 0, on success
495 * -1, on property read failure
496 * -2, on wrong timestamp size
497 */
498int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
499{
500 int len;
501 const void *data;
502
503 data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
504 if (data == NULL) {
505 fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
506 return -1;
507 }
508 if (len != sizeof(uint32_t)) {
509 debug("FIT timestamp with incorrect size of (%u)\n", len);
510 return -2;
511 }
512
513 *timestamp = uimage_to_cpu(*((uint32_t *)data));
514 return 0;
515}
516
517/**
518 * fit_image_get_node - get node offset for component image of a given unit name
519 * @fit: pointer to the FIT format image header
520 * @image_uname: component image node unit name
521 *
522 * fit_image_get_node() finds a component image (withing the '/images'
523 * node) of a provided unit name. If image is found its node offset is
524 * returned to the caller.
525 *
526 * returns:
527 * image node offset when found (>=0)
528 * negative number on failure (FDT_ERR_* code)
529 */
530int fit_image_get_node(const void *fit, const char *image_uname)
531{
532 int noffset, images_noffset;
533
534 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
535 if (images_noffset < 0) {
536 debug("Can't find images parent node '%s' (%s)\n",
537 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
538 return images_noffset;
539 }
540
541 noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
542 if (noffset < 0) {
543 debug("Can't get node offset for image unit name: '%s' (%s)\n",
544 image_uname, fdt_strerror(noffset));
545 }
546
547 return noffset;
548}
549
550/**
551 * fit_image_get_os - get os id for a given component image node
552 * @fit: pointer to the FIT format image header
553 * @noffset: component image node offset
554 * @os: pointer to the uint8_t, will hold os numeric id
555 *
556 * fit_image_get_os() finds os property in a given component image node.
557 * If the property is found, its (string) value is translated to the numeric
558 * id which is returned to the caller.
559 *
560 * returns:
561 * 0, on success
562 * -1, on failure
563 */
564int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
565{
566 int len;
567 const void *data;
568
569 /* Get OS name from property data */
570 data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
571 if (data == NULL) {
572 fit_get_debug(fit, noffset, FIT_OS_PROP, len);
573 *os = -1;
574 return -1;
575 }
576
577 /* Translate OS name to id */
578 *os = genimg_get_os_id(data);
579 return 0;
580}
581
582/**
583 * fit_image_get_arch - get arch id for a given component image node
584 * @fit: pointer to the FIT format image header
585 * @noffset: component image node offset
586 * @arch: pointer to the uint8_t, will hold arch numeric id
587 *
588 * fit_image_get_arch() finds arch property in a given component image node.
589 * If the property is found, its (string) value is translated to the numeric
590 * id which is returned to the caller.
591 *
592 * returns:
593 * 0, on success
594 * -1, on failure
595 */
596int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
597{
598 int len;
599 const void *data;
600
601 /* Get architecture name from property data */
602 data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
603 if (data == NULL) {
604 fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
605 *arch = -1;
606 return -1;
607 }
608
609 /* Translate architecture name to id */
610 *arch = genimg_get_arch_id(data);
611 return 0;
612}
613
614/**
615 * fit_image_get_type - get type id for a given component image node
616 * @fit: pointer to the FIT format image header
617 * @noffset: component image node offset
618 * @type: pointer to the uint8_t, will hold type numeric id
619 *
620 * fit_image_get_type() finds type property in a given component image node.
621 * If the property is found, its (string) value is translated to the numeric
622 * id which is returned to the caller.
623 *
624 * returns:
625 * 0, on success
626 * -1, on failure
627 */
628int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
629{
630 int len;
631 const void *data;
632
633 /* Get image type name from property data */
634 data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
635 if (data == NULL) {
636 fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
637 *type = -1;
638 return -1;
639 }
640
641 /* Translate image type name to id */
642 *type = genimg_get_type_id(data);
643 return 0;
644}
645
646/**
647 * fit_image_get_comp - get comp id for a given component image node
648 * @fit: pointer to the FIT format image header
649 * @noffset: component image node offset
650 * @comp: pointer to the uint8_t, will hold comp numeric id
651 *
652 * fit_image_get_comp() finds comp property in a given component image node.
653 * If the property is found, its (string) value is translated to the numeric
654 * id which is returned to the caller.
655 *
656 * returns:
657 * 0, on success
658 * -1, on failure
659 */
660int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
661{
662 int len;
663 const void *data;
664
665 /* Get compression name from property data */
666 data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
667 if (data == NULL) {
668 fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
669 *comp = -1;
670 return -1;
671 }
672
673 /* Translate compression name to id */
674 *comp = genimg_get_comp_id(data);
675 return 0;
676}
677
678/**
679 * fit_image_get_load() - get load addr property for given component image node
680 * @fit: pointer to the FIT format image header
681 * @noffset: component image node offset
682 * @load: pointer to the uint32_t, will hold load address
683 *
684 * fit_image_get_load() finds load address property in a given component
685 * image node. If the property is found, its value is returned to the caller.
686 *
687 * returns:
688 * 0, on success
689 * -1, on failure
690 */
691int fit_image_get_load(const void *fit, int noffset, ulong *load)
692{
693 int len;
694 const uint32_t *data;
695
696 data = fdt_getprop(fit, noffset, FIT_LOAD_PROP, &len);
697 if (data == NULL) {
698 fit_get_debug(fit, noffset, FIT_LOAD_PROP, len);
699 return -1;
700 }
701
702 *load = uimage_to_cpu(*data);
703 return 0;
704}
705
706/**
707 * fit_image_get_entry() - get entry point address property
708 * @fit: pointer to the FIT format image header
709 * @noffset: component image node offset
710 * @entry: pointer to the uint32_t, will hold entry point address
711 *
712 * This gets the entry point address property for a given component image
713 * node.
714 *
715 * fit_image_get_entry() finds entry point address property in a given
716 * component image node. If the property is found, its value is returned
717 * to the caller.
718 *
719 * returns:
720 * 0, on success
721 * -1, on failure
722 */
723int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
724{
725 int len;
726 const uint32_t *data;
727
728 data = fdt_getprop(fit, noffset, FIT_ENTRY_PROP, &len);
729 if (data == NULL) {
730 fit_get_debug(fit, noffset, FIT_ENTRY_PROP, len);
731 return -1;
732 }
733
734 *entry = uimage_to_cpu(*data);
735 return 0;
736}
737
738/**
739 * fit_image_get_data - get data property and its size for a given component image node
740 * @fit: pointer to the FIT format image header
741 * @noffset: component image node offset
742 * @data: double pointer to void, will hold data property's data address
743 * @size: pointer to size_t, will hold data property's data size
744 *
745 * fit_image_get_data() finds data property in a given component image node.
746 * If the property is found its data start address and size are returned to
747 * the caller.
748 *
749 * returns:
750 * 0, on success
751 * -1, on failure
752 */
753int fit_image_get_data(const void *fit, int noffset,
754 const void **data, size_t *size)
755{
756 int len;
757
758 *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
759 if (*data == NULL) {
760 fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
761 *size = 0;
762 return -1;
763 }
764
765 *size = len;
766 return 0;
767}
768
769/**
770 * fit_image_hash_get_algo - get hash algorithm name
771 * @fit: pointer to the FIT format image header
772 * @noffset: hash node offset
773 * @algo: double pointer to char, will hold pointer to the algorithm name
774 *
775 * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
776 * If the property is found its data start address is returned to the caller.
777 *
778 * returns:
779 * 0, on success
780 * -1, on failure
781 */
782int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
783{
784 int len;
785
786 *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
787 if (*algo == NULL) {
788 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
789 return -1;
790 }
791
792 return 0;
793}
794
795/**
796 * fit_image_hash_get_value - get hash value and length
797 * @fit: pointer to the FIT format image header
798 * @noffset: hash node offset
799 * @value: double pointer to uint8_t, will hold address of a hash value data
800 * @value_len: pointer to an int, will hold hash data length
801 *
802 * fit_image_hash_get_value() finds hash value property in a given hash node.
803 * If the property is found its data start address and size are returned to
804 * the caller.
805 *
806 * returns:
807 * 0, on success
808 * -1, on failure
809 */
810int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
811 int *value_len)
812{
813 int len;
814
815 *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
816 if (*value == NULL) {
817 fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
818 *value_len = 0;
819 return -1;
820 }
821
822 *value_len = len;
823 return 0;
824}
825
53fbb7e8
SG
826/**
827 * fit_image_hash_get_ignore - get hash ignore flag
828 * @fit: pointer to the FIT format image header
829 * @noffset: hash node offset
830 * @ignore: pointer to an int, will hold hash ignore flag
831 *
832 * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
833 * If the property is found and non-zero, the hash algorithm is not verified by
834 * u-boot automatically.
835 *
836 * returns:
837 * 0, on ignore not found
838 * value, on ignore found
839 */
ab9efc66 840static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
53fbb7e8
SG
841{
842 int len;
843 int *value;
844
845 value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
846 if (value == NULL || len != sizeof(int))
847 *ignore = 0;
848 else
849 *ignore = *value;
850
851 return 0;
852}
53fbb7e8
SG
853
854/**
855 * fit_set_timestamp - set node timestamp property
856 * @fit: pointer to the FIT format image header
857 * @noffset: node offset
858 * @timestamp: timestamp value to be set
859 *
860 * fit_set_timestamp() attempts to set timestamp property in the requested
861 * node and returns operation status to the caller.
862 *
863 * returns:
864 * 0, on success
4f427a42 865 * -ENOSPC if no space in device tree, -1 for other error
53fbb7e8
SG
866 */
867int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
868{
869 uint32_t t;
870 int ret;
871
872 t = cpu_to_uimage(timestamp);
873 ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
874 sizeof(uint32_t));
875 if (ret) {
876 printf("Can't set '%s' property for '%s' node (%s)\n",
877 FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
878 fdt_strerror(ret));
4f427a42 879 return ret == -FDT_ERR_NOSPACE ? -ENOSPC : -1;
53fbb7e8
SG
880 }
881
882 return 0;
883}
884
885/**
886 * calculate_hash - calculate and return hash for provided input data
887 * @data: pointer to the input data
888 * @data_len: data length
889 * @algo: requested hash algorithm
890 * @value: pointer to the char, will hold hash value data (caller must
891 * allocate enough free space)
892 * value_len: length of the calculated hash
893 *
894 * calculate_hash() computes input data hash according to the requested
895 * algorithm.
896 * Resulting hash value is placed in caller provided 'value' buffer, length
897 * of the calculated hash is returned via value_len pointer argument.
898 *
899 * returns:
900 * 0, on success
901 * -1, when algo is unsupported
902 */
604f23dd 903int calculate_hash(const void *data, int data_len, const char *algo,
53fbb7e8
SG
904 uint8_t *value, int *value_len)
905{
87ebee39 906 if (IMAGE_ENABLE_CRC32 && strcmp(algo, "crc32") == 0) {
53fbb7e8
SG
907 *((uint32_t *)value) = crc32_wd(0, data, data_len,
908 CHUNKSZ_CRC32);
909 *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
910 *value_len = 4;
87ebee39 911 } else if (IMAGE_ENABLE_SHA1 && strcmp(algo, "sha1") == 0) {
53fbb7e8
SG
912 sha1_csum_wd((unsigned char *)data, data_len,
913 (unsigned char *)value, CHUNKSZ_SHA1);
914 *value_len = 20;
2842c1c2
HS
915 } else if (IMAGE_ENABLE_SHA256 && strcmp(algo, "sha256") == 0) {
916 sha256_csum_wd((unsigned char *)data, data_len,
917 (unsigned char *)value, CHUNKSZ_SHA256);
918 *value_len = SHA256_SUM_LEN;
87ebee39 919 } else if (IMAGE_ENABLE_MD5 && strcmp(algo, "md5") == 0) {
53fbb7e8
SG
920 md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
921 *value_len = 16;
922 } else {
923 debug("Unsupported hash alogrithm\n");
924 return -1;
925 }
926 return 0;
927}
928
ab9efc66
SG
929static int fit_image_check_hash(const void *fit, int noffset, const void *data,
930 size_t size, char **err_msgp)
931{
932 uint8_t value[FIT_MAX_HASH_LEN];
933 int value_len;
934 char *algo;
935 uint8_t *fit_value;
936 int fit_value_len;
937 int ignore;
938
939 *err_msgp = NULL;
940
941 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
e754da2a 942 *err_msgp = "Can't get hash algo property";
ab9efc66
SG
943 return -1;
944 }
945 printf("%s", algo);
946
947 if (IMAGE_ENABLE_IGNORE) {
948 fit_image_hash_get_ignore(fit, noffset, &ignore);
949 if (ignore) {
950 printf("-skipped ");
951 return 0;
952 }
953 }
954
955 if (fit_image_hash_get_value(fit, noffset, &fit_value,
956 &fit_value_len)) {
e754da2a 957 *err_msgp = "Can't get hash value property";
ab9efc66
SG
958 return -1;
959 }
960
961 if (calculate_hash(data, size, algo, value, &value_len)) {
e754da2a 962 *err_msgp = "Unsupported hash algorithm";
ab9efc66
SG
963 return -1;
964 }
965
966 if (value_len != fit_value_len) {
e754da2a 967 *err_msgp = "Bad hash value len";
ab9efc66
SG
968 return -1;
969 } else if (memcmp(value, fit_value, value_len) != 0) {
e754da2a 970 *err_msgp = "Bad hash value";
ab9efc66
SG
971 return -1;
972 }
973
974 return 0;
975}
976
53fbb7e8 977/**
b8da8366 978 * fit_image_verify - verify data intergity
53fbb7e8
SG
979 * @fit: pointer to the FIT format image header
980 * @image_noffset: component image node offset
981 *
b8da8366 982 * fit_image_verify() goes over component image hash nodes,
53fbb7e8
SG
983 * re-calculates each data hash and compares with the value stored in hash
984 * node.
985 *
986 * returns:
987 * 1, if all hashes are valid
988 * 0, otherwise (or on error)
989 */
b8da8366 990int fit_image_verify(const void *fit, int image_noffset)
53fbb7e8
SG
991{
992 const void *data;
993 size_t size;
56518e71 994 int noffset = 0;
53fbb7e8 995 char *err_msg = "";
56518e71
SG
996 int verify_all = 1;
997 int ret;
53fbb7e8
SG
998
999 /* Get image data and data length */
1000 if (fit_image_get_data(fit, image_noffset, &data, &size)) {
e754da2a 1001 err_msg = "Can't get image data/size";
56518e71
SG
1002 goto error;
1003 }
1004
1005 /* Verify all required signatures */
1006 if (IMAGE_ENABLE_VERIFY &&
1007 fit_image_verify_required_sigs(fit, image_noffset, data, size,
1008 gd_fdt_blob(), &verify_all)) {
1009 err_msg = "Unable to verify required signature";
1010 goto error;
53fbb7e8
SG
1011 }
1012
1013 /* Process all hash subnodes of the component image node */
364ac5b5 1014 fdt_for_each_subnode(fit, noffset, image_noffset) {
ab9efc66
SG
1015 const char *name = fit_get_name(fit, noffset, NULL);
1016
1017 /*
1018 * Check subnode name, must be equal to "hash".
1019 * Multiple hash nodes require unique unit node
1020 * names, e.g. hash@1, hash@2, etc.
1021 */
1022 if (!strncmp(name, FIT_HASH_NODENAME,
1023 strlen(FIT_HASH_NODENAME))) {
1024 if (fit_image_check_hash(fit, noffset, data, size,
1025 &err_msg))
53fbb7e8 1026 goto error;
ab9efc66 1027 puts("+ ");
56518e71
SG
1028 } else if (IMAGE_ENABLE_VERIFY && verify_all &&
1029 !strncmp(name, FIT_SIG_NODENAME,
1030 strlen(FIT_SIG_NODENAME))) {
1031 ret = fit_image_check_sig(fit, noffset, data,
1032 size, -1, &err_msg);
1033 if (ret)
1034 puts("- ");
1035 else
1036 puts("+ ");
53fbb7e8
SG
1037 }
1038 }
1039
1040 if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
e754da2a 1041 err_msg = "Corrupted or truncated tree";
53fbb7e8
SG
1042 goto error;
1043 }
1044
1045 return 1;
1046
1047error:
e754da2a 1048 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
53fbb7e8
SG
1049 err_msg, fit_get_name(fit, noffset, NULL),
1050 fit_get_name(fit, image_noffset, NULL));
1051 return 0;
1052}
1053
1054/**
b8da8366 1055 * fit_all_image_verify - verify data intergity for all images
53fbb7e8
SG
1056 * @fit: pointer to the FIT format image header
1057 *
b8da8366 1058 * fit_all_image_verify() goes over all images in the FIT and
53fbb7e8
SG
1059 * for every images checks if all it's hashes are valid.
1060 *
1061 * returns:
1062 * 1, if all hashes of all images are valid
1063 * 0, otherwise (or on error)
1064 */
b8da8366 1065int fit_all_image_verify(const void *fit)
53fbb7e8
SG
1066{
1067 int images_noffset;
1068 int noffset;
1069 int ndepth;
1070 int count;
1071
1072 /* Find images parent node offset */
1073 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1074 if (images_noffset < 0) {
1075 printf("Can't find images parent node '%s' (%s)\n",
1076 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1077 return 0;
1078 }
1079
1080 /* Process all image subnodes, check hashes for each */
1081 printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1082 (ulong)fit);
1083 for (ndepth = 0, count = 0,
1084 noffset = fdt_next_node(fit, images_noffset, &ndepth);
1085 (noffset >= 0) && (ndepth > 0);
1086 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1087 if (ndepth == 1) {
1088 /*
1089 * Direct child node of the images parent node,
1090 * i.e. component image node.
1091 */
1092 printf(" Hash(es) for Image %u (%s): ", count++,
1093 fit_get_name(fit, noffset, NULL));
1094
b8da8366 1095 if (!fit_image_verify(fit, noffset))
53fbb7e8
SG
1096 return 0;
1097 printf("\n");
1098 }
1099 }
1100 return 1;
1101}
1102
1103/**
1104 * fit_image_check_os - check whether image node is of a given os type
1105 * @fit: pointer to the FIT format image header
1106 * @noffset: component image node offset
1107 * @os: requested image os
1108 *
1109 * fit_image_check_os() reads image os property and compares its numeric
1110 * id with the requested os. Comparison result is returned to the caller.
1111 *
1112 * returns:
1113 * 1 if image is of given os type
1114 * 0 otherwise (or on error)
1115 */
1116int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1117{
1118 uint8_t image_os;
1119
1120 if (fit_image_get_os(fit, noffset, &image_os))
1121 return 0;
1122 return (os == image_os);
1123}
1124
1125/**
1126 * fit_image_check_arch - check whether image node is of a given arch
1127 * @fit: pointer to the FIT format image header
1128 * @noffset: component image node offset
1129 * @arch: requested imagearch
1130 *
1131 * fit_image_check_arch() reads image arch property and compares its numeric
1132 * id with the requested arch. Comparison result is returned to the caller.
1133 *
1134 * returns:
1135 * 1 if image is of given arch
1136 * 0 otherwise (or on error)
1137 */
1138int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1139{
1140 uint8_t image_arch;
1141
1142 if (fit_image_get_arch(fit, noffset, &image_arch))
1143 return 0;
5bda35cf
SG
1144 return (arch == image_arch) ||
1145 (arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64);
53fbb7e8
SG
1146}
1147
1148/**
1149 * fit_image_check_type - check whether image node is of a given type
1150 * @fit: pointer to the FIT format image header
1151 * @noffset: component image node offset
1152 * @type: requested image type
1153 *
1154 * fit_image_check_type() reads image type property and compares its numeric
1155 * id with the requested type. Comparison result is returned to the caller.
1156 *
1157 * returns:
1158 * 1 if image is of given type
1159 * 0 otherwise (or on error)
1160 */
1161int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1162{
1163 uint8_t image_type;
1164
1165 if (fit_image_get_type(fit, noffset, &image_type))
1166 return 0;
1167 return (type == image_type);
1168}
1169
1170/**
1171 * fit_image_check_comp - check whether image node uses given compression
1172 * @fit: pointer to the FIT format image header
1173 * @noffset: component image node offset
1174 * @comp: requested image compression type
1175 *
1176 * fit_image_check_comp() reads image compression property and compares its
1177 * numeric id with the requested compression type. Comparison result is
1178 * returned to the caller.
1179 *
1180 * returns:
1181 * 1 if image uses requested compression
1182 * 0 otherwise (or on error)
1183 */
1184int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1185{
1186 uint8_t image_comp;
1187
1188 if (fit_image_get_comp(fit, noffset, &image_comp))
1189 return 0;
1190 return (comp == image_comp);
1191}
1192
1193/**
1194 * fit_check_format - sanity check FIT image format
1195 * @fit: pointer to the FIT format image header
1196 *
1197 * fit_check_format() runs a basic sanity FIT image verification.
1198 * Routine checks for mandatory properties, nodes, etc.
1199 *
1200 * returns:
1201 * 1, on success
1202 * 0, on failure
1203 */
1204int fit_check_format(const void *fit)
1205{
1206 /* mandatory / node 'description' property */
1207 if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1208 debug("Wrong FIT format: no description\n");
1209 return 0;
1210 }
1211
1212 if (IMAGE_ENABLE_TIMESTAMP) {
1213 /* mandatory / node 'timestamp' property */
1214 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1215 debug("Wrong FIT format: no timestamp\n");
1216 return 0;
1217 }
1218 }
1219
1220 /* mandatory subimages parent '/images' node */
1221 if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1222 debug("Wrong FIT format: no images parent node\n");
1223 return 0;
1224 }
1225
1226 return 1;
1227}
1228
1229
1230/**
1231 * fit_conf_find_compat
1232 * @fit: pointer to the FIT format image header
1233 * @fdt: pointer to the device tree to compare against
1234 *
1235 * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1236 * most compatible with the passed in device tree.
1237 *
1238 * Example:
1239 *
1240 * / o image-tree
1241 * |-o images
1242 * | |-o fdt@1
1243 * | |-o fdt@2
1244 * |
1245 * |-o configurations
1246 * |-o config@1
1247 * | |-fdt = fdt@1
1248 * |
1249 * |-o config@2
1250 * |-fdt = fdt@2
1251 *
1252 * / o U-Boot fdt
1253 * |-compatible = "foo,bar", "bim,bam"
1254 *
1255 * / o kernel fdt1
1256 * |-compatible = "foo,bar",
1257 *
1258 * / o kernel fdt2
1259 * |-compatible = "bim,bam", "baz,biz"
1260 *
1261 * Configuration 1 would be picked because the first string in U-Boot's
1262 * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1263 * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1264 *
1265 * returns:
1266 * offset to the configuration to use if one was found
1267 * -1 otherwise
1268 */
1269int fit_conf_find_compat(const void *fit, const void *fdt)
1270{
1271 int ndepth = 0;
1272 int noffset, confs_noffset, images_noffset;
1273 const void *fdt_compat;
1274 int fdt_compat_len;
1275 int best_match_offset = 0;
1276 int best_match_pos = 0;
1277
1278 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1279 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1280 if (confs_noffset < 0 || images_noffset < 0) {
1281 debug("Can't find configurations or images nodes.\n");
1282 return -1;
1283 }
1284
1285 fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1286 if (!fdt_compat) {
1287 debug("Fdt for comparison has no \"compatible\" property.\n");
1288 return -1;
1289 }
1290
1291 /*
1292 * Loop over the configurations in the FIT image.
1293 */
1294 for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1295 (noffset >= 0) && (ndepth > 0);
1296 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1297 const void *kfdt;
1298 const char *kfdt_name;
1299 int kfdt_noffset;
1300 const char *cur_fdt_compat;
1301 int len;
1302 size_t size;
1303 int i;
1304
1305 if (ndepth > 1)
1306 continue;
1307
1308 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1309 if (!kfdt_name) {
1310 debug("No fdt property found.\n");
1311 continue;
1312 }
1313 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1314 kfdt_name);
1315 if (kfdt_noffset < 0) {
1316 debug("No image node named \"%s\" found.\n",
1317 kfdt_name);
1318 continue;
1319 }
1320 /*
1321 * Get a pointer to this configuration's fdt.
1322 */
1323 if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1324 debug("Failed to get fdt \"%s\".\n", kfdt_name);
1325 continue;
1326 }
1327
1328 len = fdt_compat_len;
1329 cur_fdt_compat = fdt_compat;
1330 /*
1331 * Look for a match for each U-Boot compatibility string in
1332 * turn in this configuration's fdt.
1333 */
1334 for (i = 0; len > 0 &&
1335 (!best_match_offset || best_match_pos > i); i++) {
1336 int cur_len = strlen(cur_fdt_compat) + 1;
1337
1338 if (!fdt_node_check_compatible(kfdt, 0,
1339 cur_fdt_compat)) {
1340 best_match_offset = noffset;
1341 best_match_pos = i;
1342 break;
1343 }
1344 len -= cur_len;
1345 cur_fdt_compat += cur_len;
1346 }
1347 }
1348 if (!best_match_offset) {
1349 debug("No match found.\n");
1350 return -1;
1351 }
1352
1353 return best_match_offset;
1354}
1355
1356/**
1357 * fit_conf_get_node - get node offset for configuration of a given unit name
1358 * @fit: pointer to the FIT format image header
1359 * @conf_uname: configuration node unit name
1360 *
1361 * fit_conf_get_node() finds a configuration (withing the '/configurations'
1362 * parant node) of a provided unit name. If configuration is found its node
1363 * offset is returned to the caller.
1364 *
1365 * When NULL is provided in second argument fit_conf_get_node() will search
1366 * for a default configuration node instead. Default configuration node unit
1f8b546f 1367 * name is retrieved from FIT_DEFAULT_PROP property of the '/configurations'
53fbb7e8
SG
1368 * node.
1369 *
1370 * returns:
1371 * configuration node offset when found (>=0)
1372 * negative number on failure (FDT_ERR_* code)
1373 */
1374int fit_conf_get_node(const void *fit, const char *conf_uname)
1375{
1376 int noffset, confs_noffset;
1377 int len;
1378
1379 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1380 if (confs_noffset < 0) {
1381 debug("Can't find configurations parent node '%s' (%s)\n",
1382 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1383 return confs_noffset;
1384 }
1385
1386 if (conf_uname == NULL) {
1387 /* get configuration unit name from the default property */
1388 debug("No configuration specified, trying default...\n");
1389 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1390 FIT_DEFAULT_PROP, &len);
1391 if (conf_uname == NULL) {
1392 fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1393 len);
1394 return len;
1395 }
1396 debug("Found default configuration: '%s'\n", conf_uname);
1397 }
1398
1399 noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1400 if (noffset < 0) {
1401 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1402 conf_uname, fdt_strerror(noffset));
1403 }
1404
1405 return noffset;
1406}
1407
003efd7d 1408int fit_conf_get_prop_node(const void *fit, int noffset,
53fbb7e8
SG
1409 const char *prop_name)
1410{
1411 char *uname;
1412 int len;
1413
1414 /* get kernel image unit name from configuration kernel property */
1415 uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
1416 if (uname == NULL)
1417 return len;
1418
1419 return fit_image_get_node(fit, uname);
1420}
1421
53fbb7e8
SG
1422/**
1423 * fit_conf_print - prints out the FIT configuration details
1424 * @fit: pointer to the FIT format image header
1425 * @noffset: offset of the configuration node
1426 * @p: pointer to prefix string
1427 *
1428 * fit_conf_print() lists all mandatory properies for the processed
1429 * configuration node.
1430 *
1431 * returns:
1432 * no returned results
1433 */
1434void fit_conf_print(const void *fit, int noffset, const char *p)
1435{
1436 char *desc;
1437 char *uname;
1438 int ret;
ecf8cd65 1439 int loadables_index;
53fbb7e8
SG
1440
1441 /* Mandatory properties */
1442 ret = fit_get_desc(fit, noffset, &desc);
1443 printf("%s Description: ", p);
1444 if (ret)
1445 printf("unavailable\n");
1446 else
1447 printf("%s\n", desc);
1448
1449 uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1450 printf("%s Kernel: ", p);
1451 if (uname == NULL)
1452 printf("unavailable\n");
1453 else
1454 printf("%s\n", uname);
1455
1456 /* Optional properties */
1457 uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1458 if (uname)
1459 printf("%s Init Ramdisk: %s\n", p, uname);
1460
1461 uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1462 if (uname)
1463 printf("%s FDT: %s\n", p, uname);
ecf8cd65
KA
1464
1465 /* Print out all of the specified loadables */
1466 for (loadables_index = 0;
5bcec545 1467 fdt_get_string_index(fit, noffset,
ecf8cd65
KA
1468 FIT_LOADABLE_PROP,
1469 loadables_index,
5bcec545 1470 (const char **)&uname) == 0;
ecf8cd65
KA
1471 loadables_index++)
1472 {
1473 if (loadables_index == 0) {
1474 printf("%s Loadables: ", p);
1475 } else {
1476 printf("%s ", p);
1477 }
1478 printf("%s\n", uname);
1479 }
53fbb7e8
SG
1480}
1481
718fecae 1482static int fit_image_select(const void *fit, int rd_noffset, int verify)
782cfbb2
SG
1483{
1484 fit_image_print(fit, rd_noffset, " ");
1485
1486 if (verify) {
1487 puts(" Verifying Hash Integrity ... ");
1488 if (!fit_image_verify(fit, rd_noffset)) {
1489 puts("Bad Data Hash\n");
1490 return -EACCES;
1491 }
1492 puts("OK\n");
1493 }
1494
1495 return 0;
1496}
1497
782cfbb2
SG
1498int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1499 ulong addr)
1500{
1501 int cfg_noffset;
1502 void *fit_hdr;
1503 int noffset;
1504
1505 debug("* %s: using config '%s' from image at 0x%08lx\n",
1506 prop_name, images->fit_uname_cfg, addr);
1507
1508 /* Check whether configuration has this property defined */
1509 fit_hdr = map_sysmem(addr, 0);
1510 cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1511 if (cfg_noffset < 0) {
1512 debug("* %s: no such config\n", prop_name);
1513 return -ENOENT;
1514 }
1515
1516 noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1517 if (noffset < 0) {
1518 debug("* %s: no '%s' in config\n", prop_name, prop_name);
1519 return -ENOLINK;
1520 }
1521
1522 return noffset;
1523}
1524
126cc864
SG
1525/**
1526 * fit_get_image_type_property() - get property name for IH_TYPE_...
1527 *
1528 * @return the properly name where we expect to find the image in the
1529 * config node
1530 */
1531static const char *fit_get_image_type_property(int type)
1532{
1533 /*
1534 * This is sort-of available in the uimage_type[] table in image.c
1535 * but we don't have access to the sohrt name, and "fdt" is different
1536 * anyway. So let's just keep it here.
1537 */
1538 switch (type) {
1539 case IH_TYPE_FLATDT:
1540 return FIT_FDT_PROP;
1541 case IH_TYPE_KERNEL:
1542 return FIT_KERNEL_PROP;
1543 case IH_TYPE_RAMDISK:
1544 return FIT_RAMDISK_PROP;
90268b87
SG
1545 case IH_TYPE_X86_SETUP:
1546 return FIT_SETUP_PROP;
84a07dbf
KA
1547 case IH_TYPE_LOADABLE:
1548 return FIT_LOADABLE_PROP;
126cc864
SG
1549 }
1550
1551 return "unknown";
1552}
1553
1554int fit_image_load(bootm_headers_t *images, ulong addr,
f320a4d8 1555 const char **fit_unamep, const char **fit_uname_configp,
782cfbb2
SG
1556 int arch, int image_type, int bootstage_id,
1557 enum fit_load_op load_op, ulong *datap, ulong *lenp)
1558{
1559 int cfg_noffset, noffset;
1560 const char *fit_uname;
f320a4d8 1561 const char *fit_uname_config;
782cfbb2
SG
1562 const void *fit;
1563 const void *buf;
1564 size_t size;
1565 int type_ok, os_ok;
1566 ulong load, data, len;
38117231 1567 uint8_t os;
126cc864 1568 const char *prop_name;
782cfbb2
SG
1569 int ret;
1570
1571 fit = map_sysmem(addr, 0);
1572 fit_uname = fit_unamep ? *fit_unamep : NULL;
f320a4d8 1573 fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
126cc864 1574 prop_name = fit_get_image_type_property(image_type);
782cfbb2
SG
1575 printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
1576
1577 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1578 if (!fit_check_format(fit)) {
1579 printf("Bad FIT %s image format!\n", prop_name);
1580 bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1581 return -ENOEXEC;
1582 }
1583 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
1584 if (fit_uname) {
f150c837 1585 /* get FIT component image node offset */
782cfbb2
SG
1586 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
1587 noffset = fit_image_get_node(fit, fit_uname);
1588 } else {
1589 /*
1590 * no image node unit name, try to get config
1591 * node first. If config unit node name is NULL
1592 * fit_conf_get_node() will try to find default config node
1593 */
1594 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
1595 if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
1596 cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
1597 } else {
1598 cfg_noffset = fit_conf_get_node(fit,
1599 fit_uname_config);
1600 }
1601 if (cfg_noffset < 0) {
1602 puts("Could not find configuration node\n");
1603 bootstage_error(bootstage_id +
1604 BOOTSTAGE_SUB_NO_UNIT_NAME);
1605 return -ENOENT;
1606 }
1607 fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
1608 printf(" Using '%s' configuration\n", fit_uname_config);
1609 if (image_type == IH_TYPE_KERNEL) {
1610 /* Remember (and possibly verify) this config */
1611 images->fit_uname_cfg = fit_uname_config;
1612 if (IMAGE_ENABLE_VERIFY && images->verify) {
1613 puts(" Verifying Hash Integrity ... ");
12df2abe 1614 if (fit_config_verify(fit, cfg_noffset)) {
782cfbb2
SG
1615 puts("Bad Data Hash\n");
1616 bootstage_error(bootstage_id +
1617 BOOTSTAGE_SUB_HASH);
1618 return -EACCES;
1619 }
1620 puts("OK\n");
1621 }
1622 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
1623 }
1624
1625 noffset = fit_conf_get_prop_node(fit, cfg_noffset,
1626 prop_name);
1627 fit_uname = fit_get_name(fit, noffset, NULL);
1628 }
1629 if (noffset < 0) {
1630 puts("Could not find subimage node\n");
1631 bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
1632 return -ENOENT;
1633 }
1634
1635 printf(" Trying '%s' %s subimage\n", fit_uname, prop_name);
1636
1637 ret = fit_image_select(fit, noffset, images->verify);
1638 if (ret) {
1639 bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
1640 return ret;
1641 }
1642
1643 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
5ba63dd4 1644#if !defined(USE_HOSTCC) && !defined(CONFIG_SANDBOX)
782cfbb2
SG
1645 if (!fit_image_check_target_arch(fit, noffset)) {
1646 puts("Unsupported Architecture\n");
1647 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1648 return -ENOEXEC;
1649 }
ce1400f6 1650#endif
782cfbb2
SG
1651 if (image_type == IH_TYPE_FLATDT &&
1652 !fit_image_check_comp(fit, noffset, IH_COMP_NONE)) {
1653 puts("FDT image is compressed");
1654 return -EPROTONOSUPPORT;
1655 }
1656
1657 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1658 type_ok = fit_image_check_type(fit, noffset, image_type) ||
1659 (image_type == IH_TYPE_KERNEL &&
1660 fit_image_check_type(fit, noffset,
1661 IH_TYPE_KERNEL_NOLOAD));
38117231 1662
782cfbb2 1663 os_ok = image_type == IH_TYPE_FLATDT ||
38117231
MV
1664 fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
1665 fit_image_check_os(fit, noffset, IH_OS_OPENRTOS);
84a07dbf
KA
1666
1667 /*
1668 * If either of the checks fail, we should report an error, but
1669 * if the image type is coming from the "loadables" field, we
1670 * don't care what it is
1671 */
1672 if ((!type_ok || !os_ok) && image_type != IH_TYPE_LOADABLE) {
38117231
MV
1673 fit_image_get_os(fit, noffset, &os);
1674 printf("No %s %s %s Image\n",
1675 genimg_get_os_name(os),
1676 genimg_get_arch_name(arch),
782cfbb2
SG
1677 genimg_get_type_name(image_type));
1678 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1679 return -EIO;
1680 }
1681
1682 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
1683
1684 /* get image data address and length */
1685 if (fit_image_get_data(fit, noffset, &buf, &size)) {
1686 printf("Could not find %s subimage data!\n", prop_name);
1687 bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
2f998071 1688 return -ENOENT;
782cfbb2
SG
1689 }
1690 len = (ulong)size;
1691
1692 /* verify that image data is a proper FDT blob */
2f0877c7 1693 if (image_type == IH_TYPE_FLATDT && fdt_check_header(buf)) {
782cfbb2
SG
1694 puts("Subimage data is not a FDT");
1695 return -ENOEXEC;
1696 }
1697
1698 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
1699
1700 /*
1701 * Work-around for eldk-4.2 which gives this warning if we try to
e3c83c0a 1702 * cast in the unmap_sysmem() call:
782cfbb2
SG
1703 * warning: initialization discards qualifiers from pointer target type
1704 */
1705 {
1706 void *vbuf = (void *)buf;
1707
1708 data = map_to_sysmem(vbuf);
1709 }
1710
1711 if (load_op == FIT_LOAD_IGNORED) {
1712 /* Don't load */
1713 } else if (fit_image_get_load(fit, noffset, &load)) {
1714 if (load_op == FIT_LOAD_REQUIRED) {
1715 printf("Can't get %s subimage load address!\n",
1716 prop_name);
1717 bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
1718 return -EBADF;
1719 }
fe20a81a 1720 } else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
782cfbb2
SG
1721 ulong image_start, image_end;
1722 ulong load_end;
1723 void *dst;
1724
1725 /*
1726 * move image data to the load address,
1727 * make sure we don't overwrite initial image
1728 */
1729 image_start = addr;
1730 image_end = addr + fit_get_size(fit);
1731
1732 load_end = load + len;
1733 if (image_type != IH_TYPE_KERNEL &&
1734 load < image_end && load_end > image_start) {
1735 printf("Error: %s overwritten\n", prop_name);
1736 return -EXDEV;
1737 }
1738
1739 printf(" Loading %s from 0x%08lx to 0x%08lx\n",
1740 prop_name, data, load);
1741
1742 dst = map_sysmem(load, len);
1743 memmove(dst, buf, len);
1744 data = load;
1745 }
1746 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
1747
1748 *datap = data;
1749 *lenp = len;
1750 if (fit_unamep)
1751 *fit_unamep = (char *)fit_uname;
f320a4d8
SG
1752 if (fit_uname_configp)
1753 *fit_uname_configp = (char *)fit_uname_config;
782cfbb2
SG
1754
1755 return noffset;
1756}
90268b87
SG
1757
1758int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
1759 ulong *setup_start, ulong *setup_len)
1760{
1761 int noffset;
1762 ulong addr;
1763 ulong len;
1764 int ret;
1765
1766 addr = map_to_sysmem(images->fit_hdr_os);
1767 noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
1768 if (noffset < 0)
1769 return noffset;
1770
1771 ret = fit_image_load(images, addr, NULL, NULL, arch,
1772 IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
1773 FIT_LOAD_REQUIRED, setup_start, &len);
1774
1775 return ret;
1776}