blob: c531ee74d7fde55c5ac52edb3949fb824954e750 [file] [log] [blame]
Simon Glass53fbb7e2013-05-07 06:11:53 +00001/*
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 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02009 * SPDX-License-Identifier: GPL-2.0+
Simon Glass53fbb7e2013-05-07 06:11:53 +000010 */
11
12#ifdef USE_HOSTCC
13#include "mkimage.h"
14#include <image.h>
15#include <time.h>
16#else
17#include <common.h>
Simon Glass782cfbb2013-05-16 13:53:21 +000018#include <errno.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050019#include <mapmem.h>
Simon Glass782cfbb2013-05-16 13:53:21 +000020#include <asm/io.h>
21DECLARE_GLOBAL_DATA_PTR;
Simon Glass53fbb7e2013-05-07 06:11:53 +000022#endif /* !USE_HOSTCC*/
23
24#include <bootstage.h>
Simon Glass53fbb7e2013-05-07 06:11:53 +000025#include <u-boot/crc.h>
26#include <u-boot/md5.h>
Jeroen Hofstee2b9912e2014-06-12 22:27:12 +020027#include <u-boot/sha1.h>
28#include <u-boot/sha256.h>
Simon Glass53fbb7e2013-05-07 06:11:53 +000029
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 *
Masahiro Yamada069d5942013-09-18 09:36:38 +090063 * fit_parse_conf() expects configuration spec in the form of [<addr>]#<conf>,
Simon Glass53fbb7e2013-05-07 06:11:53 +000064 * 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 *
Masahiro Yamada069d5942013-09-18 09:36:38 +090089 * fit_parse_subimage() expects subimage spec in the form of
Simon Glass53fbb7e2013-05-07 06:11:53 +000090 * [<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
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200116/**
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
Simon Glass87ebee32013-05-08 08:05:59 +0000143#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_FIT_SPL_PRINT)
Simon Glass53fbb7e2013-05-07 06:11:53 +0000144/**
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
Simon Glass1fe7d932013-05-08 08:05:58 +0000169 /* Indent string is defined in header image.h */
170 p = IMAGE_INDENT_STRING;
Simon Glass53fbb7e2013-05-07 06:11:53 +0000171
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
245/**
Simon Glassd8b75362013-05-07 06:12:02 +0000246 * 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
Simon Glass56518e72013-06-13 15:10:01 -0700250 * @type: Type of information to print ("hash" or "sign")
Simon Glassd8b75362013-05-07 06:12:02 +0000251 *
252 * fit_image_print_data() lists properies for the processed hash node
253 *
Simon Glass56518e72013-06-13 15:10:01 -0700254 * This function avoid using puts() since it prints a newline on the host
255 * but does not in U-Boot.
256 *
Simon Glassd8b75362013-05-07 06:12:02 +0000257 * returns:
258 * no returned results
259 */
Simon Glass56518e72013-06-13 15:10:01 -0700260static void fit_image_print_data(const void *fit, int noffset, const char *p,
261 const char *type)
Simon Glassd8b75362013-05-07 06:12:02 +0000262{
Simon Glass56518e72013-06-13 15:10:01 -0700263 const char *keyname;
Simon Glassd8b75362013-05-07 06:12:02 +0000264 uint8_t *value;
265 int value_len;
Simon Glass56518e72013-06-13 15:10:01 -0700266 char *algo;
267 int required;
268 int ret, i;
Simon Glassd8b75362013-05-07 06:12:02 +0000269
Simon Glass56518e72013-06-13 15:10:01 -0700270 debug("%s %s node: '%s'\n", p, type,
Simon Glassd8b75362013-05-07 06:12:02 +0000271 fit_get_name(fit, noffset, NULL));
Simon Glass56518e72013-06-13 15:10:01 -0700272 printf("%s %s algo: ", p, type);
Simon Glassd8b75362013-05-07 06:12:02 +0000273 if (fit_image_hash_get_algo(fit, noffset, &algo)) {
274 printf("invalid/unsupported\n");
275 return;
276 }
Simon Glass56518e72013-06-13 15:10:01 -0700277 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");
Simon Glassd8b75362013-05-07 06:12:02 +0000285
286 ret = fit_image_hash_get_value(fit, noffset, &value,
287 &value_len);
Simon Glass56518e72013-06-13 15:10:01 -0700288 printf("%s %s value: ", p, type);
Simon Glassd8b75362013-05-07 06:12:02 +0000289 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
Simon Glass56518e72013-06-13 15:10:01 -0700297 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 }
Simon Glassd8b75362013-05-07 06:12:02 +0000309}
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);
Simon Glass56518e72013-06-13 15:10:01 -0700333 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 }
Simon Glassd8b75362013-05-07 06:12:02 +0000339}
340
341/**
Simon Glass53fbb7e2013-05-07 06:11:53 +0000342 * 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
Simon Glass1fd1e2f2013-07-16 20:10:01 -0700375 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
Simon Glass53fbb7e2013-05-07 06:11:53 +0000386 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);
Simon Glassc6ac13b2013-05-16 13:53:26 +0000396 if (ret) {
Simon Glass53fbb7e2013-05-07 06:11:53 +0000397 printf("unavailable\n");
Simon Glassc6ac13b2013-05-16 13:53:26 +0000398 } else {
399 void *vdata = (void *)data;
400
401 printf("0x%08lx\n", (ulong)map_to_sysmem(vdata));
402 }
Simon Glass53fbb7e2013-05-07 06:11:53 +0000403#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 */
Simon Glassd8b75362013-05-07 06:12:02 +0000450 fit_image_print_verification_data(fit, noffset, p);
Simon Glass53fbb7e2013-05-07 06:11:53 +0000451 }
452 }
453}
Guilherme Maciel Ferreira39931f92015-01-15 02:54:42 -0200454
455#endif /* !defined(CONFIG_SPL_BUILD) || defined(CONFIG_FIT_SPL_PRINT) */
Simon Glass53fbb7e2013-05-07 06:11:53 +0000456
457/**
Simon Glass53fbb7e2013-05-07 06:11:53 +0000458 * 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
Simon Glass53fbb7e2013-05-07 06:11:53 +0000826/**
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 */
Simon Glassab9efc62013-05-07 06:11:58 +0000840static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
Simon Glass53fbb7e2013-05-07 06:11:53 +0000841{
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}
Simon Glass53fbb7e2013-05-07 06:11:53 +0000853
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
Simon Glass4f427a42014-06-02 22:04:51 -0600865 * -ENOSPC if no space in device tree, -1 for other error
Simon Glass53fbb7e2013-05-07 06:11:53 +0000866 */
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));
Simon Glass4f427a42014-06-02 22:04:51 -0600879 return ret == -FDT_ERR_NOSPACE ? -ENOSPC : -1;
Simon Glass53fbb7e2013-05-07 06:11:53 +0000880 }
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 */
Simon Glass604f23d2013-05-07 06:11:54 +0000903int calculate_hash(const void *data, int data_len, const char *algo,
Simon Glass53fbb7e2013-05-07 06:11:53 +0000904 uint8_t *value, int *value_len)
905{
Simon Glass87ebee32013-05-08 08:05:59 +0000906 if (IMAGE_ENABLE_CRC32 && strcmp(algo, "crc32") == 0) {
Simon Glass53fbb7e2013-05-07 06:11:53 +0000907 *((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;
Simon Glass87ebee32013-05-08 08:05:59 +0000911 } else if (IMAGE_ENABLE_SHA1 && strcmp(algo, "sha1") == 0) {
Simon Glass53fbb7e2013-05-07 06:11:53 +0000912 sha1_csum_wd((unsigned char *)data, data_len,
913 (unsigned char *)value, CHUNKSZ_SHA1);
914 *value_len = 20;
Heiko Schocher2842c1c2014-03-03 12:19:25 +0100915 } 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;
Simon Glass87ebee32013-05-08 08:05:59 +0000919 } else if (IMAGE_ENABLE_MD5 && strcmp(algo, "md5") == 0) {
Simon Glass53fbb7e2013-05-07 06:11:53 +0000920 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
Simon Glassab9efc62013-05-07 06:11:58 +0000929static 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)) {
Simon Glasse754da22013-05-07 06:11:59 +0000942 *err_msgp = "Can't get hash algo property";
Simon Glassab9efc62013-05-07 06:11:58 +0000943 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)) {
Simon Glasse754da22013-05-07 06:11:59 +0000957 *err_msgp = "Can't get hash value property";
Simon Glassab9efc62013-05-07 06:11:58 +0000958 return -1;
959 }
960
961 if (calculate_hash(data, size, algo, value, &value_len)) {
Simon Glasse754da22013-05-07 06:11:59 +0000962 *err_msgp = "Unsupported hash algorithm";
Simon Glassab9efc62013-05-07 06:11:58 +0000963 return -1;
964 }
965
966 if (value_len != fit_value_len) {
Simon Glasse754da22013-05-07 06:11:59 +0000967 *err_msgp = "Bad hash value len";
Simon Glassab9efc62013-05-07 06:11:58 +0000968 return -1;
969 } else if (memcmp(value, fit_value, value_len) != 0) {
Simon Glasse754da22013-05-07 06:11:59 +0000970 *err_msgp = "Bad hash value";
Simon Glassab9efc62013-05-07 06:11:58 +0000971 return -1;
972 }
973
974 return 0;
975}
976
Simon Glass53fbb7e2013-05-07 06:11:53 +0000977/**
Simon Glassb8da8362013-05-07 06:11:57 +0000978 * fit_image_verify - verify data intergity
Simon Glass53fbb7e2013-05-07 06:11:53 +0000979 * @fit: pointer to the FIT format image header
980 * @image_noffset: component image node offset
981 *
Simon Glassb8da8362013-05-07 06:11:57 +0000982 * fit_image_verify() goes over component image hash nodes,
Simon Glass53fbb7e2013-05-07 06:11:53 +0000983 * 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 */
Simon Glassb8da8362013-05-07 06:11:57 +0000990int fit_image_verify(const void *fit, int image_noffset)
Simon Glass53fbb7e2013-05-07 06:11:53 +0000991{
992 const void *data;
993 size_t size;
Simon Glass56518e72013-06-13 15:10:01 -0700994 int noffset = 0;
Simon Glass53fbb7e2013-05-07 06:11:53 +0000995 char *err_msg = "";
Simon Glass56518e72013-06-13 15:10:01 -0700996 int verify_all = 1;
997 int ret;
Simon Glass53fbb7e2013-05-07 06:11:53 +0000998
999 /* Get image data and data length */
1000 if (fit_image_get_data(fit, image_noffset, &data, &size)) {
Simon Glasse754da22013-05-07 06:11:59 +00001001 err_msg = "Can't get image data/size";
Simon Glass56518e72013-06-13 15:10:01 -07001002 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;
Simon Glass53fbb7e2013-05-07 06:11:53 +00001011 }
1012
1013 /* Process all hash subnodes of the component image node */
Axel Lin364ac5b2015-02-07 09:12:39 +08001014 fdt_for_each_subnode(fit, noffset, image_noffset) {
Simon Glassab9efc62013-05-07 06:11:58 +00001015 const char *name = fit_get_name(fit, noffset, NULL);
Simon Glass53fbb7e2013-05-07 06:11:53 +00001016
Simon Glassab9efc62013-05-07 06:11:58 +00001017 /*
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))
Simon Glass53fbb7e2013-05-07 06:11:53 +00001026 goto error;
Simon Glassab9efc62013-05-07 06:11:58 +00001027 puts("+ ");
Simon Glass56518e72013-06-13 15:10:01 -07001028 } 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);
Andrej Rosano84ca65a2015-10-14 17:45:40 +02001033 if (ret) {
Simon Glass56518e72013-06-13 15:10:01 -07001034 puts("- ");
Andrej Rosano84ca65a2015-10-14 17:45:40 +02001035 goto error;
1036 }
Simon Glass56518e72013-06-13 15:10:01 -07001037 else
1038 puts("+ ");
Simon Glass53fbb7e2013-05-07 06:11:53 +00001039 }
1040 }
1041
1042 if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
Simon Glasse754da22013-05-07 06:11:59 +00001043 err_msg = "Corrupted or truncated tree";
Simon Glass53fbb7e2013-05-07 06:11:53 +00001044 goto error;
1045 }
1046
1047 return 1;
1048
1049error:
Simon Glasse754da22013-05-07 06:11:59 +00001050 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
Simon Glass53fbb7e2013-05-07 06:11:53 +00001051 err_msg, fit_get_name(fit, noffset, NULL),
1052 fit_get_name(fit, image_noffset, NULL));
1053 return 0;
1054}
1055
1056/**
Simon Glassb8da8362013-05-07 06:11:57 +00001057 * fit_all_image_verify - verify data intergity for all images
Simon Glass53fbb7e2013-05-07 06:11:53 +00001058 * @fit: pointer to the FIT format image header
1059 *
Simon Glassb8da8362013-05-07 06:11:57 +00001060 * fit_all_image_verify() goes over all images in the FIT and
Simon Glass53fbb7e2013-05-07 06:11:53 +00001061 * for every images checks if all it's hashes are valid.
1062 *
1063 * returns:
1064 * 1, if all hashes of all images are valid
1065 * 0, otherwise (or on error)
1066 */
Simon Glassb8da8362013-05-07 06:11:57 +00001067int fit_all_image_verify(const void *fit)
Simon Glass53fbb7e2013-05-07 06:11:53 +00001068{
1069 int images_noffset;
1070 int noffset;
1071 int ndepth;
1072 int count;
1073
1074 /* Find images parent node offset */
1075 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1076 if (images_noffset < 0) {
1077 printf("Can't find images parent node '%s' (%s)\n",
1078 FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1079 return 0;
1080 }
1081
1082 /* Process all image subnodes, check hashes for each */
1083 printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1084 (ulong)fit);
1085 for (ndepth = 0, count = 0,
1086 noffset = fdt_next_node(fit, images_noffset, &ndepth);
1087 (noffset >= 0) && (ndepth > 0);
1088 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1089 if (ndepth == 1) {
1090 /*
1091 * Direct child node of the images parent node,
1092 * i.e. component image node.
1093 */
1094 printf(" Hash(es) for Image %u (%s): ", count++,
1095 fit_get_name(fit, noffset, NULL));
1096
Simon Glassb8da8362013-05-07 06:11:57 +00001097 if (!fit_image_verify(fit, noffset))
Simon Glass53fbb7e2013-05-07 06:11:53 +00001098 return 0;
1099 printf("\n");
1100 }
1101 }
1102 return 1;
1103}
1104
1105/**
1106 * fit_image_check_os - check whether image node is of a given os type
1107 * @fit: pointer to the FIT format image header
1108 * @noffset: component image node offset
1109 * @os: requested image os
1110 *
1111 * fit_image_check_os() reads image os property and compares its numeric
1112 * id with the requested os. Comparison result is returned to the caller.
1113 *
1114 * returns:
1115 * 1 if image is of given os type
1116 * 0 otherwise (or on error)
1117 */
1118int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1119{
1120 uint8_t image_os;
1121
1122 if (fit_image_get_os(fit, noffset, &image_os))
1123 return 0;
1124 return (os == image_os);
1125}
1126
1127/**
1128 * fit_image_check_arch - check whether image node is of a given arch
1129 * @fit: pointer to the FIT format image header
1130 * @noffset: component image node offset
1131 * @arch: requested imagearch
1132 *
1133 * fit_image_check_arch() reads image arch property and compares its numeric
1134 * id with the requested arch. Comparison result is returned to the caller.
1135 *
1136 * returns:
1137 * 1 if image is of given arch
1138 * 0 otherwise (or on error)
1139 */
1140int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1141{
1142 uint8_t image_arch;
1143
1144 if (fit_image_get_arch(fit, noffset, &image_arch))
1145 return 0;
Simon Glass5bda35c2014-10-10 08:21:57 -06001146 return (arch == image_arch) ||
1147 (arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64);
Simon Glass53fbb7e2013-05-07 06:11:53 +00001148}
1149
1150/**
1151 * fit_image_check_type - check whether image node is of a given type
1152 * @fit: pointer to the FIT format image header
1153 * @noffset: component image node offset
1154 * @type: requested image type
1155 *
1156 * fit_image_check_type() reads image type property and compares its numeric
1157 * id with the requested type. Comparison result is returned to the caller.
1158 *
1159 * returns:
1160 * 1 if image is of given type
1161 * 0 otherwise (or on error)
1162 */
1163int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1164{
1165 uint8_t image_type;
1166
1167 if (fit_image_get_type(fit, noffset, &image_type))
1168 return 0;
1169 return (type == image_type);
1170}
1171
1172/**
1173 * fit_image_check_comp - check whether image node uses given compression
1174 * @fit: pointer to the FIT format image header
1175 * @noffset: component image node offset
1176 * @comp: requested image compression type
1177 *
1178 * fit_image_check_comp() reads image compression property and compares its
1179 * numeric id with the requested compression type. Comparison result is
1180 * returned to the caller.
1181 *
1182 * returns:
1183 * 1 if image uses requested compression
1184 * 0 otherwise (or on error)
1185 */
1186int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1187{
1188 uint8_t image_comp;
1189
1190 if (fit_image_get_comp(fit, noffset, &image_comp))
1191 return 0;
1192 return (comp == image_comp);
1193}
1194
1195/**
1196 * fit_check_format - sanity check FIT image format
1197 * @fit: pointer to the FIT format image header
1198 *
1199 * fit_check_format() runs a basic sanity FIT image verification.
1200 * Routine checks for mandatory properties, nodes, etc.
1201 *
1202 * returns:
1203 * 1, on success
1204 * 0, on failure
1205 */
1206int fit_check_format(const void *fit)
1207{
1208 /* mandatory / node 'description' property */
1209 if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1210 debug("Wrong FIT format: no description\n");
1211 return 0;
1212 }
1213
1214 if (IMAGE_ENABLE_TIMESTAMP) {
1215 /* mandatory / node 'timestamp' property */
1216 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1217 debug("Wrong FIT format: no timestamp\n");
1218 return 0;
1219 }
1220 }
1221
1222 /* mandatory subimages parent '/images' node */
1223 if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1224 debug("Wrong FIT format: no images parent node\n");
1225 return 0;
1226 }
1227
1228 return 1;
1229}
1230
1231
1232/**
1233 * fit_conf_find_compat
1234 * @fit: pointer to the FIT format image header
1235 * @fdt: pointer to the device tree to compare against
1236 *
1237 * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1238 * most compatible with the passed in device tree.
1239 *
1240 * Example:
1241 *
1242 * / o image-tree
1243 * |-o images
1244 * | |-o fdt@1
1245 * | |-o fdt@2
1246 * |
1247 * |-o configurations
1248 * |-o config@1
1249 * | |-fdt = fdt@1
1250 * |
1251 * |-o config@2
1252 * |-fdt = fdt@2
1253 *
1254 * / o U-Boot fdt
1255 * |-compatible = "foo,bar", "bim,bam"
1256 *
1257 * / o kernel fdt1
1258 * |-compatible = "foo,bar",
1259 *
1260 * / o kernel fdt2
1261 * |-compatible = "bim,bam", "baz,biz"
1262 *
1263 * Configuration 1 would be picked because the first string in U-Boot's
1264 * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1265 * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1266 *
1267 * returns:
1268 * offset to the configuration to use if one was found
1269 * -1 otherwise
1270 */
1271int fit_conf_find_compat(const void *fit, const void *fdt)
1272{
1273 int ndepth = 0;
1274 int noffset, confs_noffset, images_noffset;
1275 const void *fdt_compat;
1276 int fdt_compat_len;
1277 int best_match_offset = 0;
1278 int best_match_pos = 0;
1279
1280 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1281 images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1282 if (confs_noffset < 0 || images_noffset < 0) {
1283 debug("Can't find configurations or images nodes.\n");
1284 return -1;
1285 }
1286
1287 fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1288 if (!fdt_compat) {
1289 debug("Fdt for comparison has no \"compatible\" property.\n");
1290 return -1;
1291 }
1292
1293 /*
1294 * Loop over the configurations in the FIT image.
1295 */
1296 for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1297 (noffset >= 0) && (ndepth > 0);
1298 noffset = fdt_next_node(fit, noffset, &ndepth)) {
1299 const void *kfdt;
1300 const char *kfdt_name;
1301 int kfdt_noffset;
1302 const char *cur_fdt_compat;
1303 int len;
1304 size_t size;
1305 int i;
1306
1307 if (ndepth > 1)
1308 continue;
1309
1310 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1311 if (!kfdt_name) {
1312 debug("No fdt property found.\n");
1313 continue;
1314 }
1315 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1316 kfdt_name);
1317 if (kfdt_noffset < 0) {
1318 debug("No image node named \"%s\" found.\n",
1319 kfdt_name);
1320 continue;
1321 }
1322 /*
1323 * Get a pointer to this configuration's fdt.
1324 */
1325 if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1326 debug("Failed to get fdt \"%s\".\n", kfdt_name);
1327 continue;
1328 }
1329
1330 len = fdt_compat_len;
1331 cur_fdt_compat = fdt_compat;
1332 /*
1333 * Look for a match for each U-Boot compatibility string in
1334 * turn in this configuration's fdt.
1335 */
1336 for (i = 0; len > 0 &&
1337 (!best_match_offset || best_match_pos > i); i++) {
1338 int cur_len = strlen(cur_fdt_compat) + 1;
1339
1340 if (!fdt_node_check_compatible(kfdt, 0,
1341 cur_fdt_compat)) {
1342 best_match_offset = noffset;
1343 best_match_pos = i;
1344 break;
1345 }
1346 len -= cur_len;
1347 cur_fdt_compat += cur_len;
1348 }
1349 }
1350 if (!best_match_offset) {
1351 debug("No match found.\n");
1352 return -1;
1353 }
1354
1355 return best_match_offset;
1356}
1357
1358/**
1359 * fit_conf_get_node - get node offset for configuration of a given unit name
1360 * @fit: pointer to the FIT format image header
1361 * @conf_uname: configuration node unit name
1362 *
1363 * fit_conf_get_node() finds a configuration (withing the '/configurations'
1364 * parant node) of a provided unit name. If configuration is found its node
1365 * offset is returned to the caller.
1366 *
1367 * When NULL is provided in second argument fit_conf_get_node() will search
1368 * for a default configuration node instead. Default configuration node unit
Robert P. J. Day1f8b5462013-08-21 11:39:19 -04001369 * name is retrieved from FIT_DEFAULT_PROP property of the '/configurations'
Simon Glass53fbb7e2013-05-07 06:11:53 +00001370 * node.
1371 *
1372 * returns:
1373 * configuration node offset when found (>=0)
1374 * negative number on failure (FDT_ERR_* code)
1375 */
1376int fit_conf_get_node(const void *fit, const char *conf_uname)
1377{
1378 int noffset, confs_noffset;
1379 int len;
1380
1381 confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1382 if (confs_noffset < 0) {
1383 debug("Can't find configurations parent node '%s' (%s)\n",
1384 FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1385 return confs_noffset;
1386 }
1387
1388 if (conf_uname == NULL) {
1389 /* get configuration unit name from the default property */
1390 debug("No configuration specified, trying default...\n");
1391 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1392 FIT_DEFAULT_PROP, &len);
1393 if (conf_uname == NULL) {
1394 fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1395 len);
1396 return len;
1397 }
1398 debug("Found default configuration: '%s'\n", conf_uname);
1399 }
1400
1401 noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1402 if (noffset < 0) {
1403 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1404 conf_uname, fdt_strerror(noffset));
1405 }
1406
1407 return noffset;
1408}
1409
Simon Glass003efd72013-05-07 06:12:00 +00001410int fit_conf_get_prop_node(const void *fit, int noffset,
Simon Glass53fbb7e2013-05-07 06:11:53 +00001411 const char *prop_name)
1412{
1413 char *uname;
1414 int len;
1415
1416 /* get kernel image unit name from configuration kernel property */
1417 uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
1418 if (uname == NULL)
1419 return len;
1420
1421 return fit_image_get_node(fit, uname);
1422}
1423
1424/**
Simon Glass53fbb7e2013-05-07 06:11:53 +00001425 * fit_conf_print - prints out the FIT configuration details
1426 * @fit: pointer to the FIT format image header
1427 * @noffset: offset of the configuration node
1428 * @p: pointer to prefix string
1429 *
1430 * fit_conf_print() lists all mandatory properies for the processed
1431 * configuration node.
1432 *
1433 * returns:
1434 * no returned results
1435 */
1436void fit_conf_print(const void *fit, int noffset, const char *p)
1437{
1438 char *desc;
1439 char *uname;
1440 int ret;
Karl Apsiteecf8cd62015-05-21 09:52:47 -04001441 int loadables_index;
Simon Glass53fbb7e2013-05-07 06:11:53 +00001442
1443 /* Mandatory properties */
1444 ret = fit_get_desc(fit, noffset, &desc);
1445 printf("%s Description: ", p);
1446 if (ret)
1447 printf("unavailable\n");
1448 else
1449 printf("%s\n", desc);
1450
1451 uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1452 printf("%s Kernel: ", p);
1453 if (uname == NULL)
1454 printf("unavailable\n");
1455 else
1456 printf("%s\n", uname);
1457
1458 /* Optional properties */
1459 uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1460 if (uname)
1461 printf("%s Init Ramdisk: %s\n", p, uname);
1462
1463 uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1464 if (uname)
1465 printf("%s FDT: %s\n", p, uname);
Karl Apsiteecf8cd62015-05-21 09:52:47 -04001466
1467 /* Print out all of the specified loadables */
1468 for (loadables_index = 0;
Hans de Goede5bcec542015-05-29 15:09:48 +02001469 fdt_get_string_index(fit, noffset,
Karl Apsiteecf8cd62015-05-21 09:52:47 -04001470 FIT_LOADABLE_PROP,
1471 loadables_index,
Hans de Goede5bcec542015-05-29 15:09:48 +02001472 (const char **)&uname) == 0;
Karl Apsiteecf8cd62015-05-21 09:52:47 -04001473 loadables_index++)
1474 {
1475 if (loadables_index == 0) {
1476 printf("%s Loadables: ", p);
1477 } else {
1478 printf("%s ", p);
1479 }
1480 printf("%s\n", uname);
1481 }
Simon Glass53fbb7e2013-05-07 06:11:53 +00001482}
1483
Jeroen Hofstee718feca2014-10-08 22:57:38 +02001484static int fit_image_select(const void *fit, int rd_noffset, int verify)
Simon Glass782cfbb2013-05-16 13:53:21 +00001485{
1486 fit_image_print(fit, rd_noffset, " ");
1487
1488 if (verify) {
1489 puts(" Verifying Hash Integrity ... ");
1490 if (!fit_image_verify(fit, rd_noffset)) {
1491 puts("Bad Data Hash\n");
1492 return -EACCES;
1493 }
1494 puts("OK\n");
1495 }
1496
1497 return 0;
1498}
1499
Simon Glass782cfbb2013-05-16 13:53:21 +00001500int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1501 ulong addr)
1502{
1503 int cfg_noffset;
1504 void *fit_hdr;
1505 int noffset;
1506
1507 debug("* %s: using config '%s' from image at 0x%08lx\n",
1508 prop_name, images->fit_uname_cfg, addr);
1509
1510 /* Check whether configuration has this property defined */
1511 fit_hdr = map_sysmem(addr, 0);
1512 cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1513 if (cfg_noffset < 0) {
1514 debug("* %s: no such config\n", prop_name);
1515 return -ENOENT;
1516 }
1517
1518 noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1519 if (noffset < 0) {
1520 debug("* %s: no '%s' in config\n", prop_name, prop_name);
1521 return -ENOLINK;
1522 }
1523
1524 return noffset;
1525}
1526
Simon Glass126cc862014-06-12 07:24:47 -06001527/**
1528 * fit_get_image_type_property() - get property name for IH_TYPE_...
1529 *
1530 * @return the properly name where we expect to find the image in the
1531 * config node
1532 */
1533static const char *fit_get_image_type_property(int type)
1534{
1535 /*
1536 * This is sort-of available in the uimage_type[] table in image.c
1537 * but we don't have access to the sohrt name, and "fdt" is different
1538 * anyway. So let's just keep it here.
1539 */
1540 switch (type) {
1541 case IH_TYPE_FLATDT:
1542 return FIT_FDT_PROP;
1543 case IH_TYPE_KERNEL:
1544 return FIT_KERNEL_PROP;
1545 case IH_TYPE_RAMDISK:
1546 return FIT_RAMDISK_PROP;
Simon Glass90268b82014-10-19 21:11:24 -06001547 case IH_TYPE_X86_SETUP:
1548 return FIT_SETUP_PROP;
Karl Apsite84a07db2015-05-21 09:52:48 -04001549 case IH_TYPE_LOADABLE:
1550 return FIT_LOADABLE_PROP;
Simon Glass126cc862014-06-12 07:24:47 -06001551 }
1552
1553 return "unknown";
1554}
1555
1556int fit_image_load(bootm_headers_t *images, ulong addr,
Simon Glassf320a4d2013-07-10 23:08:10 -07001557 const char **fit_unamep, const char **fit_uname_configp,
Simon Glass782cfbb2013-05-16 13:53:21 +00001558 int arch, int image_type, int bootstage_id,
1559 enum fit_load_op load_op, ulong *datap, ulong *lenp)
1560{
1561 int cfg_noffset, noffset;
1562 const char *fit_uname;
Simon Glassf320a4d2013-07-10 23:08:10 -07001563 const char *fit_uname_config;
Simon Glass782cfbb2013-05-16 13:53:21 +00001564 const void *fit;
1565 const void *buf;
1566 size_t size;
1567 int type_ok, os_ok;
1568 ulong load, data, len;
Marek Vasut38117232014-12-16 14:07:22 +01001569 uint8_t os;
Simon Glass126cc862014-06-12 07:24:47 -06001570 const char *prop_name;
Simon Glass782cfbb2013-05-16 13:53:21 +00001571 int ret;
1572
1573 fit = map_sysmem(addr, 0);
1574 fit_uname = fit_unamep ? *fit_unamep : NULL;
Simon Glassf320a4d2013-07-10 23:08:10 -07001575 fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
Simon Glass126cc862014-06-12 07:24:47 -06001576 prop_name = fit_get_image_type_property(image_type);
Simon Glass782cfbb2013-05-16 13:53:21 +00001577 printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
1578
1579 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1580 if (!fit_check_format(fit)) {
1581 printf("Bad FIT %s image format!\n", prop_name);
1582 bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1583 return -ENOEXEC;
1584 }
1585 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
1586 if (fit_uname) {
Masahiro Yamadaf150c832014-02-18 15:39:21 +09001587 /* get FIT component image node offset */
Simon Glass782cfbb2013-05-16 13:53:21 +00001588 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
1589 noffset = fit_image_get_node(fit, fit_uname);
1590 } else {
1591 /*
1592 * no image node unit name, try to get config
1593 * node first. If config unit node name is NULL
1594 * fit_conf_get_node() will try to find default config node
1595 */
1596 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
1597 if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
1598 cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
1599 } else {
1600 cfg_noffset = fit_conf_get_node(fit,
1601 fit_uname_config);
1602 }
1603 if (cfg_noffset < 0) {
1604 puts("Could not find configuration node\n");
1605 bootstage_error(bootstage_id +
1606 BOOTSTAGE_SUB_NO_UNIT_NAME);
1607 return -ENOENT;
1608 }
1609 fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
1610 printf(" Using '%s' configuration\n", fit_uname_config);
1611 if (image_type == IH_TYPE_KERNEL) {
1612 /* Remember (and possibly verify) this config */
1613 images->fit_uname_cfg = fit_uname_config;
1614 if (IMAGE_ENABLE_VERIFY && images->verify) {
1615 puts(" Verifying Hash Integrity ... ");
Simon Glass12df2ab2014-06-12 07:24:45 -06001616 if (fit_config_verify(fit, cfg_noffset)) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001617 puts("Bad Data Hash\n");
1618 bootstage_error(bootstage_id +
1619 BOOTSTAGE_SUB_HASH);
1620 return -EACCES;
1621 }
1622 puts("OK\n");
1623 }
1624 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
1625 }
1626
1627 noffset = fit_conf_get_prop_node(fit, cfg_noffset,
1628 prop_name);
1629 fit_uname = fit_get_name(fit, noffset, NULL);
1630 }
1631 if (noffset < 0) {
1632 puts("Could not find subimage node\n");
1633 bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
1634 return -ENOENT;
1635 }
1636
1637 printf(" Trying '%s' %s subimage\n", fit_uname, prop_name);
1638
1639 ret = fit_image_select(fit, noffset, images->verify);
1640 if (ret) {
1641 bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
1642 return ret;
1643 }
1644
1645 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
Simon Glass5ba63dd2014-10-19 21:11:22 -06001646#if !defined(USE_HOSTCC) && !defined(CONFIG_SANDBOX)
Simon Glass782cfbb2013-05-16 13:53:21 +00001647 if (!fit_image_check_target_arch(fit, noffset)) {
1648 puts("Unsupported Architecture\n");
1649 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1650 return -ENOEXEC;
1651 }
Simon Glassce1400f2014-06-12 07:24:53 -06001652#endif
Simon Glass782cfbb2013-05-16 13:53:21 +00001653 if (image_type == IH_TYPE_FLATDT &&
1654 !fit_image_check_comp(fit, noffset, IH_COMP_NONE)) {
1655 puts("FDT image is compressed");
1656 return -EPROTONOSUPPORT;
1657 }
1658
1659 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1660 type_ok = fit_image_check_type(fit, noffset, image_type) ||
1661 (image_type == IH_TYPE_KERNEL &&
1662 fit_image_check_type(fit, noffset,
1663 IH_TYPE_KERNEL_NOLOAD));
Marek Vasut38117232014-12-16 14:07:22 +01001664
Simon Glass782cfbb2013-05-16 13:53:21 +00001665 os_ok = image_type == IH_TYPE_FLATDT ||
Marek Vasut38117232014-12-16 14:07:22 +01001666 fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
1667 fit_image_check_os(fit, noffset, IH_OS_OPENRTOS);
Karl Apsite84a07db2015-05-21 09:52:48 -04001668
1669 /*
1670 * If either of the checks fail, we should report an error, but
1671 * if the image type is coming from the "loadables" field, we
1672 * don't care what it is
1673 */
1674 if ((!type_ok || !os_ok) && image_type != IH_TYPE_LOADABLE) {
Marek Vasut38117232014-12-16 14:07:22 +01001675 fit_image_get_os(fit, noffset, &os);
1676 printf("No %s %s %s Image\n",
1677 genimg_get_os_name(os),
1678 genimg_get_arch_name(arch),
Simon Glass782cfbb2013-05-16 13:53:21 +00001679 genimg_get_type_name(image_type));
1680 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1681 return -EIO;
1682 }
1683
1684 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
1685
1686 /* get image data address and length */
1687 if (fit_image_get_data(fit, noffset, &buf, &size)) {
1688 printf("Could not find %s subimage data!\n", prop_name);
1689 bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
Simon Glass2f998072013-06-16 07:46:49 -07001690 return -ENOENT;
Simon Glass782cfbb2013-05-16 13:53:21 +00001691 }
1692 len = (ulong)size;
1693
1694 /* verify that image data is a proper FDT blob */
Masahiro Yamada2f0877c2013-09-19 12:10:18 +09001695 if (image_type == IH_TYPE_FLATDT && fdt_check_header(buf)) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001696 puts("Subimage data is not a FDT");
1697 return -ENOEXEC;
1698 }
1699
1700 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
1701
1702 /*
1703 * Work-around for eldk-4.2 which gives this warning if we try to
Simon Glasse3c83c02014-06-12 07:24:49 -06001704 * cast in the unmap_sysmem() call:
Simon Glass782cfbb2013-05-16 13:53:21 +00001705 * warning: initialization discards qualifiers from pointer target type
1706 */
1707 {
1708 void *vbuf = (void *)buf;
1709
1710 data = map_to_sysmem(vbuf);
1711 }
1712
1713 if (load_op == FIT_LOAD_IGNORED) {
1714 /* Don't load */
1715 } else if (fit_image_get_load(fit, noffset, &load)) {
1716 if (load_op == FIT_LOAD_REQUIRED) {
1717 printf("Can't get %s subimage load address!\n",
1718 prop_name);
1719 bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
1720 return -EBADF;
1721 }
Simon Glassfe20a812014-08-22 14:26:43 -06001722 } else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001723 ulong image_start, image_end;
1724 ulong load_end;
1725 void *dst;
1726
1727 /*
1728 * move image data to the load address,
1729 * make sure we don't overwrite initial image
1730 */
1731 image_start = addr;
1732 image_end = addr + fit_get_size(fit);
1733
1734 load_end = load + len;
1735 if (image_type != IH_TYPE_KERNEL &&
1736 load < image_end && load_end > image_start) {
1737 printf("Error: %s overwritten\n", prop_name);
1738 return -EXDEV;
1739 }
1740
1741 printf(" Loading %s from 0x%08lx to 0x%08lx\n",
1742 prop_name, data, load);
1743
1744 dst = map_sysmem(load, len);
1745 memmove(dst, buf, len);
1746 data = load;
1747 }
1748 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
1749
1750 *datap = data;
1751 *lenp = len;
1752 if (fit_unamep)
1753 *fit_unamep = (char *)fit_uname;
Simon Glassf320a4d2013-07-10 23:08:10 -07001754 if (fit_uname_configp)
1755 *fit_uname_configp = (char *)fit_uname_config;
Simon Glass782cfbb2013-05-16 13:53:21 +00001756
1757 return noffset;
1758}
Simon Glass90268b82014-10-19 21:11:24 -06001759
1760int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
1761 ulong *setup_start, ulong *setup_len)
1762{
1763 int noffset;
1764 ulong addr;
1765 ulong len;
1766 int ret;
1767
1768 addr = map_to_sysmem(images->fit_hdr_os);
1769 noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
1770 if (noffset < 0)
1771 return noffset;
1772
1773 ret = fit_image_load(images, addr, NULL, NULL, arch,
1774 IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
1775 FIT_LOAD_REQUIRED, setup_start, &len);
1776
1777 return ret;
1778}