blob: 4eb4d42655e9bebb0fae767d89961327a100e0c8 [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);
1033 if (ret)
1034 puts("- ");
1035 else
1036 puts("+ ");
Simon Glass53fbb7e2013-05-07 06:11:53 +00001037 }
1038 }
1039
1040 if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
Simon Glasse754da22013-05-07 06:11:59 +00001041 err_msg = "Corrupted or truncated tree";
Simon Glass53fbb7e2013-05-07 06:11:53 +00001042 goto error;
1043 }
1044
1045 return 1;
1046
1047error:
Simon Glasse754da22013-05-07 06:11:59 +00001048 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
Simon Glass53fbb7e2013-05-07 06:11:53 +00001049 err_msg, fit_get_name(fit, noffset, NULL),
1050 fit_get_name(fit, image_noffset, NULL));
1051 return 0;
1052}
1053
1054/**
Simon Glassb8da8362013-05-07 06:11:57 +00001055 * fit_all_image_verify - verify data intergity for all images
Simon Glass53fbb7e2013-05-07 06:11:53 +00001056 * @fit: pointer to the FIT format image header
1057 *
Simon Glassb8da8362013-05-07 06:11:57 +00001058 * fit_all_image_verify() goes over all images in the FIT and
Simon Glass53fbb7e2013-05-07 06:11:53 +00001059 * 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 */
Simon Glassb8da8362013-05-07 06:11:57 +00001065int fit_all_image_verify(const void *fit)
Simon Glass53fbb7e2013-05-07 06:11:53 +00001066{
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
Simon Glassb8da8362013-05-07 06:11:57 +00001095 if (!fit_image_verify(fit, noffset))
Simon Glass53fbb7e2013-05-07 06:11:53 +00001096 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;
Simon Glass5bda35c2014-10-10 08:21:57 -06001144 return (arch == image_arch) ||
1145 (arch == IH_ARCH_I386 && image_arch == IH_ARCH_X86_64);
Simon Glass53fbb7e2013-05-07 06:11:53 +00001146}
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
Robert P. J. Day1f8b5462013-08-21 11:39:19 -04001367 * name is retrieved from FIT_DEFAULT_PROP property of the '/configurations'
Simon Glass53fbb7e2013-05-07 06:11:53 +00001368 * 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
Simon Glass003efd72013-05-07 06:12:00 +00001408int fit_conf_get_prop_node(const void *fit, int noffset,
Simon Glass53fbb7e2013-05-07 06:11:53 +00001409 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
1422/**
Simon Glass53fbb7e2013-05-07 06:11:53 +00001423 * 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;
1439
1440 /* Mandatory properties */
1441 ret = fit_get_desc(fit, noffset, &desc);
1442 printf("%s Description: ", p);
1443 if (ret)
1444 printf("unavailable\n");
1445 else
1446 printf("%s\n", desc);
1447
1448 uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1449 printf("%s Kernel: ", p);
1450 if (uname == NULL)
1451 printf("unavailable\n");
1452 else
1453 printf("%s\n", uname);
1454
1455 /* Optional properties */
1456 uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1457 if (uname)
1458 printf("%s Init Ramdisk: %s\n", p, uname);
1459
1460 uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1461 if (uname)
1462 printf("%s FDT: %s\n", p, uname);
1463}
1464
Jeroen Hofstee718feca2014-10-08 22:57:38 +02001465static int fit_image_select(const void *fit, int rd_noffset, int verify)
Simon Glass782cfbb2013-05-16 13:53:21 +00001466{
1467 fit_image_print(fit, rd_noffset, " ");
1468
1469 if (verify) {
1470 puts(" Verifying Hash Integrity ... ");
1471 if (!fit_image_verify(fit, rd_noffset)) {
1472 puts("Bad Data Hash\n");
1473 return -EACCES;
1474 }
1475 puts("OK\n");
1476 }
1477
1478 return 0;
1479}
1480
Simon Glass782cfbb2013-05-16 13:53:21 +00001481int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
1482 ulong addr)
1483{
1484 int cfg_noffset;
1485 void *fit_hdr;
1486 int noffset;
1487
1488 debug("* %s: using config '%s' from image at 0x%08lx\n",
1489 prop_name, images->fit_uname_cfg, addr);
1490
1491 /* Check whether configuration has this property defined */
1492 fit_hdr = map_sysmem(addr, 0);
1493 cfg_noffset = fit_conf_get_node(fit_hdr, images->fit_uname_cfg);
1494 if (cfg_noffset < 0) {
1495 debug("* %s: no such config\n", prop_name);
1496 return -ENOENT;
1497 }
1498
1499 noffset = fit_conf_get_prop_node(fit_hdr, cfg_noffset, prop_name);
1500 if (noffset < 0) {
1501 debug("* %s: no '%s' in config\n", prop_name, prop_name);
1502 return -ENOLINK;
1503 }
1504
1505 return noffset;
1506}
1507
Simon Glass126cc862014-06-12 07:24:47 -06001508/**
1509 * fit_get_image_type_property() - get property name for IH_TYPE_...
1510 *
1511 * @return the properly name where we expect to find the image in the
1512 * config node
1513 */
1514static const char *fit_get_image_type_property(int type)
1515{
1516 /*
1517 * This is sort-of available in the uimage_type[] table in image.c
1518 * but we don't have access to the sohrt name, and "fdt" is different
1519 * anyway. So let's just keep it here.
1520 */
1521 switch (type) {
1522 case IH_TYPE_FLATDT:
1523 return FIT_FDT_PROP;
1524 case IH_TYPE_KERNEL:
1525 return FIT_KERNEL_PROP;
1526 case IH_TYPE_RAMDISK:
1527 return FIT_RAMDISK_PROP;
Simon Glass90268b82014-10-19 21:11:24 -06001528 case IH_TYPE_X86_SETUP:
1529 return FIT_SETUP_PROP;
Simon Glass126cc862014-06-12 07:24:47 -06001530 }
1531
1532 return "unknown";
1533}
1534
1535int fit_image_load(bootm_headers_t *images, ulong addr,
Simon Glassf320a4d2013-07-10 23:08:10 -07001536 const char **fit_unamep, const char **fit_uname_configp,
Simon Glass782cfbb2013-05-16 13:53:21 +00001537 int arch, int image_type, int bootstage_id,
1538 enum fit_load_op load_op, ulong *datap, ulong *lenp)
1539{
1540 int cfg_noffset, noffset;
1541 const char *fit_uname;
Simon Glassf320a4d2013-07-10 23:08:10 -07001542 const char *fit_uname_config;
Simon Glass782cfbb2013-05-16 13:53:21 +00001543 const void *fit;
1544 const void *buf;
1545 size_t size;
1546 int type_ok, os_ok;
1547 ulong load, data, len;
Marek Vasut38117232014-12-16 14:07:22 +01001548 uint8_t os;
Simon Glass126cc862014-06-12 07:24:47 -06001549 const char *prop_name;
Simon Glass782cfbb2013-05-16 13:53:21 +00001550 int ret;
1551
1552 fit = map_sysmem(addr, 0);
1553 fit_uname = fit_unamep ? *fit_unamep : NULL;
Simon Glassf320a4d2013-07-10 23:08:10 -07001554 fit_uname_config = fit_uname_configp ? *fit_uname_configp : NULL;
Simon Glass126cc862014-06-12 07:24:47 -06001555 prop_name = fit_get_image_type_property(image_type);
Simon Glass782cfbb2013-05-16 13:53:21 +00001556 printf("## Loading %s from FIT Image at %08lx ...\n", prop_name, addr);
1557
1558 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1559 if (!fit_check_format(fit)) {
1560 printf("Bad FIT %s image format!\n", prop_name);
1561 bootstage_error(bootstage_id + BOOTSTAGE_SUB_FORMAT);
1562 return -ENOEXEC;
1563 }
1564 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_FORMAT_OK);
1565 if (fit_uname) {
Masahiro Yamadaf150c832014-02-18 15:39:21 +09001566 /* get FIT component image node offset */
Simon Glass782cfbb2013-05-16 13:53:21 +00001567 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_UNIT_NAME);
1568 noffset = fit_image_get_node(fit, fit_uname);
1569 } else {
1570 /*
1571 * no image node unit name, try to get config
1572 * node first. If config unit node name is NULL
1573 * fit_conf_get_node() will try to find default config node
1574 */
1575 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_NO_UNIT_NAME);
1576 if (IMAGE_ENABLE_BEST_MATCH && !fit_uname_config) {
1577 cfg_noffset = fit_conf_find_compat(fit, gd_fdt_blob());
1578 } else {
1579 cfg_noffset = fit_conf_get_node(fit,
1580 fit_uname_config);
1581 }
1582 if (cfg_noffset < 0) {
1583 puts("Could not find configuration node\n");
1584 bootstage_error(bootstage_id +
1585 BOOTSTAGE_SUB_NO_UNIT_NAME);
1586 return -ENOENT;
1587 }
1588 fit_uname_config = fdt_get_name(fit, cfg_noffset, NULL);
1589 printf(" Using '%s' configuration\n", fit_uname_config);
1590 if (image_type == IH_TYPE_KERNEL) {
1591 /* Remember (and possibly verify) this config */
1592 images->fit_uname_cfg = fit_uname_config;
1593 if (IMAGE_ENABLE_VERIFY && images->verify) {
1594 puts(" Verifying Hash Integrity ... ");
Simon Glass12df2ab2014-06-12 07:24:45 -06001595 if (fit_config_verify(fit, cfg_noffset)) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001596 puts("Bad Data Hash\n");
1597 bootstage_error(bootstage_id +
1598 BOOTSTAGE_SUB_HASH);
1599 return -EACCES;
1600 }
1601 puts("OK\n");
1602 }
1603 bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
1604 }
1605
1606 noffset = fit_conf_get_prop_node(fit, cfg_noffset,
1607 prop_name);
1608 fit_uname = fit_get_name(fit, noffset, NULL);
1609 }
1610 if (noffset < 0) {
1611 puts("Could not find subimage node\n");
1612 bootstage_error(bootstage_id + BOOTSTAGE_SUB_SUBNODE);
1613 return -ENOENT;
1614 }
1615
1616 printf(" Trying '%s' %s subimage\n", fit_uname, prop_name);
1617
1618 ret = fit_image_select(fit, noffset, images->verify);
1619 if (ret) {
1620 bootstage_error(bootstage_id + BOOTSTAGE_SUB_HASH);
1621 return ret;
1622 }
1623
1624 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
Simon Glass5ba63dd2014-10-19 21:11:22 -06001625#if !defined(USE_HOSTCC) && !defined(CONFIG_SANDBOX)
Simon Glass782cfbb2013-05-16 13:53:21 +00001626 if (!fit_image_check_target_arch(fit, noffset)) {
1627 puts("Unsupported Architecture\n");
1628 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ARCH);
1629 return -ENOEXEC;
1630 }
Simon Glassce1400f2014-06-12 07:24:53 -06001631#endif
Simon Glass782cfbb2013-05-16 13:53:21 +00001632 if (image_type == IH_TYPE_FLATDT &&
1633 !fit_image_check_comp(fit, noffset, IH_COMP_NONE)) {
1634 puts("FDT image is compressed");
1635 return -EPROTONOSUPPORT;
1636 }
1637
1638 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1639 type_ok = fit_image_check_type(fit, noffset, image_type) ||
1640 (image_type == IH_TYPE_KERNEL &&
1641 fit_image_check_type(fit, noffset,
1642 IH_TYPE_KERNEL_NOLOAD));
Marek Vasut38117232014-12-16 14:07:22 +01001643
Simon Glass782cfbb2013-05-16 13:53:21 +00001644 os_ok = image_type == IH_TYPE_FLATDT ||
Marek Vasut38117232014-12-16 14:07:22 +01001645 fit_image_check_os(fit, noffset, IH_OS_LINUX) ||
1646 fit_image_check_os(fit, noffset, IH_OS_OPENRTOS);
Simon Glass782cfbb2013-05-16 13:53:21 +00001647 if (!type_ok || !os_ok) {
Marek Vasut38117232014-12-16 14:07:22 +01001648 fit_image_get_os(fit, noffset, &os);
1649 printf("No %s %s %s Image\n",
1650 genimg_get_os_name(os),
1651 genimg_get_arch_name(arch),
Simon Glass782cfbb2013-05-16 13:53:21 +00001652 genimg_get_type_name(image_type));
1653 bootstage_error(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL);
1654 return -EIO;
1655 }
1656
1657 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_CHECK_ALL_OK);
1658
1659 /* get image data address and length */
1660 if (fit_image_get_data(fit, noffset, &buf, &size)) {
1661 printf("Could not find %s subimage data!\n", prop_name);
1662 bootstage_error(bootstage_id + BOOTSTAGE_SUB_GET_DATA);
Simon Glass2f998072013-06-16 07:46:49 -07001663 return -ENOENT;
Simon Glass782cfbb2013-05-16 13:53:21 +00001664 }
1665 len = (ulong)size;
1666
1667 /* verify that image data is a proper FDT blob */
Masahiro Yamada2f0877c2013-09-19 12:10:18 +09001668 if (image_type == IH_TYPE_FLATDT && fdt_check_header(buf)) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001669 puts("Subimage data is not a FDT");
1670 return -ENOEXEC;
1671 }
1672
1673 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_GET_DATA_OK);
1674
1675 /*
1676 * Work-around for eldk-4.2 which gives this warning if we try to
Simon Glasse3c83c02014-06-12 07:24:49 -06001677 * cast in the unmap_sysmem() call:
Simon Glass782cfbb2013-05-16 13:53:21 +00001678 * warning: initialization discards qualifiers from pointer target type
1679 */
1680 {
1681 void *vbuf = (void *)buf;
1682
1683 data = map_to_sysmem(vbuf);
1684 }
1685
1686 if (load_op == FIT_LOAD_IGNORED) {
1687 /* Don't load */
1688 } else if (fit_image_get_load(fit, noffset, &load)) {
1689 if (load_op == FIT_LOAD_REQUIRED) {
1690 printf("Can't get %s subimage load address!\n",
1691 prop_name);
1692 bootstage_error(bootstage_id + BOOTSTAGE_SUB_LOAD);
1693 return -EBADF;
1694 }
Simon Glassfe20a812014-08-22 14:26:43 -06001695 } else if (load_op != FIT_LOAD_OPTIONAL_NON_ZERO || load) {
Simon Glass782cfbb2013-05-16 13:53:21 +00001696 ulong image_start, image_end;
1697 ulong load_end;
1698 void *dst;
1699
1700 /*
1701 * move image data to the load address,
1702 * make sure we don't overwrite initial image
1703 */
1704 image_start = addr;
1705 image_end = addr + fit_get_size(fit);
1706
1707 load_end = load + len;
1708 if (image_type != IH_TYPE_KERNEL &&
1709 load < image_end && load_end > image_start) {
1710 printf("Error: %s overwritten\n", prop_name);
1711 return -EXDEV;
1712 }
1713
1714 printf(" Loading %s from 0x%08lx to 0x%08lx\n",
1715 prop_name, data, load);
1716
1717 dst = map_sysmem(load, len);
1718 memmove(dst, buf, len);
1719 data = load;
1720 }
1721 bootstage_mark(bootstage_id + BOOTSTAGE_SUB_LOAD);
1722
1723 *datap = data;
1724 *lenp = len;
1725 if (fit_unamep)
1726 *fit_unamep = (char *)fit_uname;
Simon Glassf320a4d2013-07-10 23:08:10 -07001727 if (fit_uname_configp)
1728 *fit_uname_configp = (char *)fit_uname_config;
Simon Glass782cfbb2013-05-16 13:53:21 +00001729
1730 return noffset;
1731}
Simon Glass90268b82014-10-19 21:11:24 -06001732
1733int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
1734 ulong *setup_start, ulong *setup_len)
1735{
1736 int noffset;
1737 ulong addr;
1738 ulong len;
1739 int ret;
1740
1741 addr = map_to_sysmem(images->fit_hdr_os);
1742 noffset = fit_get_node_from_config(images, FIT_SETUP_PROP, addr);
1743 if (noffset < 0)
1744 return noffset;
1745
1746 ret = fit_image_load(images, addr, NULL, NULL, arch,
1747 IH_TYPE_X86_SETUP, BOOTSTAGE_ID_FIT_SETUP_START,
1748 FIT_LOAD_REQUIRED, setup_start, &len);
1749
1750 return ret;
1751}