common/image-fit.c

   1 /*
   2  * Copyright (c) 2013, Google Inc.
   3  *
   4  * (C) Copyright 2008 Semihalf
   5  *
   6  * (C) Copyright 2000-2006
   7  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   8  *
   9  * See file CREDITS for list of people who contributed to this
  10  * project.
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License as
  14  * published by the Free Software Foundation; either version 2 of
  15  * the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  25  * MA 02111-1307 USA
  26  */
  27
  28 #ifdef USE_HOSTCC
  29 #include "mkimage.h"
  30 #include <image.h>
  31 #include <time.h>
  32 #else
  33 #include <common.h>
  34 #endif /* !USE_HOSTCC*/
  35
  36 #include <bootstage.h>
  37 #include <sha1.h>
  38 #include <u-boot/crc.h>
  39 #include <u-boot/md5.h>
  40
  41 /*****************************************************************************/
  42 /* New uImage format routines */
  43 /*****************************************************************************/
  44 #ifndef USE_HOSTCC
  45 static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
  46                 ulong *addr, const char **name)
  47 {
  48         const char *sep;
  49
  50         *addr = addr_curr;
  51         *name = NULL;
  52
  53         sep = strchr(spec, sepc);
  54         if (sep) {
  55                 if (sep - spec > 0)
  56                         *addr = simple_strtoul(spec, NULL, 16);
  57
  58                 *name = sep + 1;
  59                 return 1;
  60         }
  61
  62         return 0;
  63 }
  64
  65 /**
  66  * fit_parse_conf - parse FIT configuration spec
  67  * @spec: input string, containing configuration spec
  68  * @add_curr: current image address (to be used as a possible default)
  69  * @addr: pointer to a ulong variable, will hold FIT image address of a given
  70  * configuration
  71  * @conf_name double pointer to a char, will hold pointer to a configuration
  72  * unit name
  73  *
  74  * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>,
  75  * where <addr> is a FIT image address that contains configuration
  76  * with a <conf> unit name.
  77  *
  78  * Address part is optional, and if omitted default add_curr will
  79  * be used instead.
  80  *
  81  * returns:
  82  *     1 if spec is a valid configuration string,
  83  *     addr and conf_name are set accordingly
  84  *     0 otherwise
  85  */
  86 int fit_parse_conf(const char *spec, ulong addr_curr,
  87                 ulong *addr, const char **conf_name)
  88 {
  89         return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
  90 }
  91
  92 /**
  93  * fit_parse_subimage - parse FIT subimage spec
  94  * @spec: input string, containing subimage spec
  95  * @add_curr: current image address (to be used as a possible default)
  96  * @addr: pointer to a ulong variable, will hold FIT image address of a given
  97  * subimage
  98  * @image_name: double pointer to a char, will hold pointer to a subimage name
  99  *
 100  * fit_parse_subimage() expects subimage spec in the for of
 101  * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
 102  * subimage with a <subimg> unit name.
 103  *
 104  * Address part is optional, and if omitted default add_curr will
 105  * be used instead.
 106  *
 107  * returns:
 108  *     1 if spec is a valid subimage string,
 109  *     addr and image_name are set accordingly
 110  *     0 otherwise
 111  */
 112 int fit_parse_subimage(const char *spec, ulong addr_curr,
 113                 ulong *addr, const char **image_name)
 114 {
 115         return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
 116 }
 117 #endif /* !USE_HOSTCC */
 118
 119 static void fit_get_debug(const void *fit, int noffset,
 120                 char *prop_name, int err)
 121 {
 122         debug("Can't get '%s' property from FIT 0x%08lx, node: offset %d, name %s (%s)\n",
 123               prop_name, (ulong)fit, noffset, fit_get_name(fit, noffset, NULL),
 124               fdt_strerror(err));
 125 }
 126
 127 /**
 128  * fit_print_contents - prints out the contents of the FIT format image
 129  * @fit: pointer to the FIT format image header
 130  * @p: pointer to prefix string
 131  *
 132  * fit_print_contents() formats a multi line FIT image contents description.
 133  * The routine prints out FIT image properties (root node level) follwed by
 134  * the details of each component image.
 135  *
 136  * returns:
 137  *     no returned results
 138  */
 139 void fit_print_contents(const void *fit)
 140 {
 141         char *desc;
 142         char *uname;
 143         int images_noffset;
 144         int confs_noffset;
 145         int noffset;
 146         int ndepth;
 147         int count = 0;
 148         int ret;
 149         const char *p;
 150         time_t timestamp;
 151
 152 #ifdef USE_HOSTCC
 153         p = "";
 154 #else
 155         p = "   ";
 156 #endif
 157
 158         /* Root node properties */
 159         ret = fit_get_desc(fit, 0, &desc);
 160         printf("%sFIT description: ", p);
 161         if (ret)
 162                 printf("unavailable\n");
 163         else
 164                 printf("%s\n", desc);
 165
 166         if (IMAGE_ENABLE_TIMESTAMP) {
 167                 ret = fit_get_timestamp(fit, 0, &timestamp);
 168                 printf("%sCreated:         ", p);
 169                 if (ret)
 170                         printf("unavailable\n");
 171                 else
 172                         genimg_print_time(timestamp);
 173         }
 174
 175         /* Find images parent node offset */
 176         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
 177         if (images_noffset < 0) {
 178                 printf("Can't find images parent node '%s' (%s)\n",
 179                        FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 180                 return;
 181         }
 182
 183         /* Process its subnodes, print out component images details */
 184         for (ndepth = 0, count = 0,
 185                 noffset = fdt_next_node(fit, images_noffset, &ndepth);
 186              (noffset >= 0) && (ndepth > 0);
 187              noffset = fdt_next_node(fit, noffset, &ndepth)) {
 188                 if (ndepth == 1) {
 189                         /*
 190                          * Direct child node of the images parent node,
 191                          * i.e. component image node.
 192                          */
 193                         printf("%s Image %u (%s)\n", p, count++,
 194                                fit_get_name(fit, noffset, NULL));
 195
 196                         fit_image_print(fit, noffset, p);
 197                 }
 198         }
 199
 200         /* Find configurations parent node offset */
 201         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
 202         if (confs_noffset < 0) {
 203                 debug("Can't get configurations parent node '%s' (%s)\n",
 204                       FIT_CONFS_PATH, fdt_strerror(confs_noffset));
 205                 return;
 206         }
 207
 208         /* get default configuration unit name from default property */
 209         uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
 210         if (uname)
 211                 printf("%s Default Configuration: '%s'\n", p, uname);
 212
 213         /* Process its subnodes, print out configurations details */
 214         for (ndepth = 0, count = 0,
 215                 noffset = fdt_next_node(fit, confs_noffset, &ndepth);
 216              (noffset >= 0) && (ndepth > 0);
 217              noffset = fdt_next_node(fit, noffset, &ndepth)) {
 218                 if (ndepth == 1) {
 219                         /*
 220                          * Direct child node of the configurations parent node,
 221                          * i.e. configuration node.
 222                          */
 223                         printf("%s Configuration %u (%s)\n", p, count++,
 224                                fit_get_name(fit, noffset, NULL));
 225
 226                         fit_conf_print(fit, noffset, p);
 227                 }
 228         }
 229 }
 230
 231 /**
 232  * fit_image_print - prints out the FIT component image details
 233  * @fit: pointer to the FIT format image header
 234  * @image_noffset: offset of the component image node
 235  * @p: pointer to prefix string
 236  *
 237  * fit_image_print() lists all mandatory properies for the processed component
 238  * image. If present, hash nodes are printed out as well. Load
 239  * address for images of type firmware is also printed out. Since the load
 240  * address is not mandatory for firmware images, it will be output as
 241  * "unavailable" when not present.
 242  *
 243  * returns:
 244  *     no returned results
 245  */
 246 void fit_image_print(const void *fit, int image_noffset, const char *p)
 247 {
 248         char *desc;
 249         uint8_t type, arch, os, comp;
 250         size_t size;
 251         ulong load, entry;
 252         const void *data;
 253         int noffset;
 254         int ndepth;
 255         int ret;
 256
 257         /* Mandatory properties */
 258         ret = fit_get_desc(fit, image_noffset, &desc);
 259         printf("%s  Description:  ", p);
 260         if (ret)
 261                 printf("unavailable\n");
 262         else
 263                 printf("%s\n", desc);
 264
 265         fit_image_get_type(fit, image_noffset, &type);
 266         printf("%s  Type:         %s\n", p, genimg_get_type_name(type));
 267
 268         fit_image_get_comp(fit, image_noffset, &comp);
 269         printf("%s  Compression:  %s\n", p, genimg_get_comp_name(comp));
 270
 271         ret = fit_image_get_data(fit, image_noffset, &data, &size);
 272
 273 #ifndef USE_HOSTCC
 274         printf("%s  Data Start:   ", p);
 275         if (ret)
 276                 printf("unavailable\n");
 277         else
 278                 printf("0x%08lx\n", (ulong)data);
 279 #endif
 280
 281         printf("%s  Data Size:    ", p);
 282         if (ret)
 283                 printf("unavailable\n");
 284         else
 285                 genimg_print_size(size);
 286
 287         /* Remaining, type dependent properties */
 288         if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
 289             (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
 290             (type == IH_TYPE_FLATDT)) {
 291                 fit_image_get_arch(fit, image_noffset, &arch);
 292                 printf("%s  Architecture: %s\n", p, genimg_get_arch_name(arch));
 293         }
 294
 295         if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK)) {
 296                 fit_image_get_os(fit, image_noffset, &os);
 297                 printf("%s  OS:           %s\n", p, genimg_get_os_name(os));
 298         }
 299
 300         if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
 301             (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK)) {
 302                 ret = fit_image_get_load(fit, image_noffset, &load);
 303                 printf("%s  Load Address: ", p);
 304                 if (ret)
 305                         printf("unavailable\n");
 306                 else
 307                         printf("0x%08lx\n", load);
 308         }
 309
 310         if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
 311             (type == IH_TYPE_RAMDISK)) {
 312                 fit_image_get_entry(fit, image_noffset, &entry);
 313                 printf("%s  Entry Point:  ", p);
 314                 if (ret)
 315                         printf("unavailable\n");
 316                 else
 317                         printf("0x%08lx\n", entry);
 318         }
 319
 320         /* Process all hash subnodes of the component image node */
 321         for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
 322              (noffset >= 0) && (ndepth > 0);
 323              noffset = fdt_next_node(fit, noffset, &ndepth)) {
 324                 if (ndepth == 1) {
 325                         /* Direct child node of the component image node */
 326                         fit_image_print_hash(fit, noffset, p);
 327                 }
 328         }
 329 }
 330
 331 /**
 332  * fit_image_print_hash - prints out the hash node details
 333  * @fit: pointer to the FIT format image header
 334  * @noffset: offset of the hash node
 335  * @p: pointer to prefix string
 336  *
 337  * fit_image_print_hash() lists properies for the processed hash node
 338  *
 339  * returns:
 340  *     no returned results
 341  */
 342 void fit_image_print_hash(const void *fit, int noffset, const char *p)
 343 {
 344         char *algo;
 345         uint8_t *value;
 346         int value_len;
 347         int i, ret;
 348
 349         /*
 350          * Check subnode name, must be equal to "hash".
 351          * Multiple hash nodes require unique unit node
 352          * names, e.g. hash@1, hash@2, etc.
 353          */
 354         if (strncmp(fit_get_name(fit, noffset, NULL),
 355                     FIT_HASH_NODENAME, strlen(FIT_HASH_NODENAME)) != 0)
 356                 return;
 357
 358         debug("%s  Hash node:    '%s'\n", p,
 359               fit_get_name(fit, noffset, NULL));
 360
 361         printf("%s  Hash algo:    ", p);
 362         if (fit_image_hash_get_algo(fit, noffset, &algo)) {
 363                 printf("invalid/unsupported\n");
 364                 return;
 365         }
 366         printf("%s\n", algo);
 367
 368         ret = fit_image_hash_get_value(fit, noffset, &value,
 369                                         &value_len);
 370         printf("%s  Hash value:   ", p);
 371         if (ret) {
 372                 printf("unavailable\n");
 373         } else {
 374                 for (i = 0; i < value_len; i++)
 375                         printf("%02x", value[i]);
 376                 printf("\n");
 377         }
 378
 379         debug("%s  Hash len:     %d\n", p, value_len);
 380 }
 381
 382 /**
 383  * fit_get_desc - get node description property
 384  * @fit: pointer to the FIT format image header
 385  * @noffset: node offset
 386  * @desc: double pointer to the char, will hold pointer to the descrption
 387  *
 388  * fit_get_desc() reads description property from a given node, if
 389  * description is found pointer to it is returened in third call argument.
 390  *
 391  * returns:
 392  *     0, on success
 393  *     -1, on failure
 394  */
 395 int fit_get_desc(const void *fit, int noffset, char **desc)
 396 {
 397         int len;
 398
 399         *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
 400         if (*desc == NULL) {
 401                 fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
 402                 return -1;
 403         }
 404
 405         return 0;
 406 }
 407
 408 /**
 409  * fit_get_timestamp - get node timestamp property
 410  * @fit: pointer to the FIT format image header
 411  * @noffset: node offset
 412  * @timestamp: pointer to the time_t, will hold read timestamp
 413  *
 414  * fit_get_timestamp() reads timestamp poperty from given node, if timestamp
 415  * is found and has a correct size its value is retured in third call
 416  * argument.
 417  *
 418  * returns:
 419  *     0, on success
 420  *     -1, on property read failure
 421  *     -2, on wrong timestamp size
 422  */
 423 int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
 424 {
 425         int len;
 426         const void *data;
 427
 428         data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
 429         if (data == NULL) {
 430                 fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
 431                 return -1;
 432         }
 433         if (len != sizeof(uint32_t)) {
 434                 debug("FIT timestamp with incorrect size of (%u)\n", len);
 435                 return -2;
 436         }
 437
 438         *timestamp = uimage_to_cpu(*((uint32_t *)data));
 439         return 0;
 440 }
 441
 442 /**
 443  * fit_image_get_node - get node offset for component image of a given unit name
 444  * @fit: pointer to the FIT format image header
 445  * @image_uname: component image node unit name
 446  *
 447  * fit_image_get_node() finds a component image (withing the '/images'
 448  * node) of a provided unit name. If image is found its node offset is
 449  * returned to the caller.
 450  *
 451  * returns:
 452  *     image node offset when found (>=0)
 453  *     negative number on failure (FDT_ERR_* code)
 454  */
 455 int fit_image_get_node(const void *fit, const char *image_uname)
 456 {
 457         int noffset, images_noffset;
 458
 459         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
 460         if (images_noffset < 0) {
 461                 debug("Can't find images parent node '%s' (%s)\n",
 462                       FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 463                 return images_noffset;
 464         }
 465
 466         noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
 467         if (noffset < 0) {
 468                 debug("Can't get node offset for image unit name: '%s' (%s)\n",
 469                       image_uname, fdt_strerror(noffset));
 470         }
 471
 472         return noffset;
 473 }
 474
 475 /**
 476  * fit_image_get_os - get os id for a given component image node
 477  * @fit: pointer to the FIT format image header
 478  * @noffset: component image node offset
 479  * @os: pointer to the uint8_t, will hold os numeric id
 480  *
 481  * fit_image_get_os() finds os property in a given component image node.
 482  * If the property is found, its (string) value is translated to the numeric
 483  * id which is returned to the caller.
 484  *
 485  * returns:
 486  *     0, on success
 487  *     -1, on failure
 488  */
 489 int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
 490 {
 491         int len;
 492         const void *data;
 493
 494         /* Get OS name from property data */
 495         data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
 496         if (data == NULL) {
 497                 fit_get_debug(fit, noffset, FIT_OS_PROP, len);
 498                 *os = -1;
 499                 return -1;
 500         }
 501
 502         /* Translate OS name to id */
 503         *os = genimg_get_os_id(data);
 504         return 0;
 505 }
 506
 507 /**
 508  * fit_image_get_arch - get arch id for a given component image node
 509  * @fit: pointer to the FIT format image header
 510  * @noffset: component image node offset
 511  * @arch: pointer to the uint8_t, will hold arch numeric id
 512  *
 513  * fit_image_get_arch() finds arch property in a given component image node.
 514  * If the property is found, its (string) value is translated to the numeric
 515  * id which is returned to the caller.
 516  *
 517  * returns:
 518  *     0, on success
 519  *     -1, on failure
 520  */
 521 int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
 522 {
 523         int len;
 524         const void *data;
 525
 526         /* Get architecture name from property data */
 527         data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
 528         if (data == NULL) {
 529                 fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
 530                 *arch = -1;
 531                 return -1;
 532         }
 533
 534         /* Translate architecture name to id */
 535         *arch = genimg_get_arch_id(data);
 536         return 0;
 537 }
 538
 539 /**
 540  * fit_image_get_type - get type id for a given component image node
 541  * @fit: pointer to the FIT format image header
 542  * @noffset: component image node offset
 543  * @type: pointer to the uint8_t, will hold type numeric id
 544  *
 545  * fit_image_get_type() finds type property in a given component image node.
 546  * If the property is found, its (string) value is translated to the numeric
 547  * id which is returned to the caller.
 548  *
 549  * returns:
 550  *     0, on success
 551  *     -1, on failure
 552  */
 553 int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
 554 {
 555         int len;
 556         const void *data;
 557
 558         /* Get image type name from property data */
 559         data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
 560         if (data == NULL) {
 561                 fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
 562                 *type = -1;
 563                 return -1;
 564         }
 565
 566         /* Translate image type name to id */
 567         *type = genimg_get_type_id(data);
 568         return 0;
 569 }
 570
 571 /**
 572  * fit_image_get_comp - get comp id for a given component image node
 573  * @fit: pointer to the FIT format image header
 574  * @noffset: component image node offset
 575  * @comp: pointer to the uint8_t, will hold comp numeric id
 576  *
 577  * fit_image_get_comp() finds comp property in a given component image node.
 578  * If the property is found, its (string) value is translated to the numeric
 579  * id which is returned to the caller.
 580  *
 581  * returns:
 582  *     0, on success
 583  *     -1, on failure
 584  */
 585 int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
 586 {
 587         int len;
 588         const void *data;
 589
 590         /* Get compression name from property data */
 591         data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
 592         if (data == NULL) {
 593                 fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
 594                 *comp = -1;
 595                 return -1;
 596         }
 597
 598         /* Translate compression name to id */
 599         *comp = genimg_get_comp_id(data);
 600         return 0;
 601 }
 602
 603 /**
 604  * fit_image_get_load() - get load addr property for given component image node
 605  * @fit: pointer to the FIT format image header
 606  * @noffset: component image node offset
 607  * @load: pointer to the uint32_t, will hold load address
 608  *
 609  * fit_image_get_load() finds load address property in a given component
 610  * image node. If the property is found, its value is returned to the caller.
 611  *
 612  * returns:
 613  *     0, on success
 614  *     -1, on failure
 615  */
 616 int fit_image_get_load(const void *fit, int noffset, ulong *load)
 617 {
 618         int len;
 619         const uint32_t *data;
 620
 621         data = fdt_getprop(fit, noffset, FIT_LOAD_PROP, &len);
 622         if (data == NULL) {
 623                 fit_get_debug(fit, noffset, FIT_LOAD_PROP, len);
 624                 return -1;
 625         }
 626
 627         *load = uimage_to_cpu(*data);
 628         return 0;
 629 }
 630
 631 /**
 632  * fit_image_get_entry() - get entry point address property
 633  * @fit: pointer to the FIT format image header
 634  * @noffset: component image node offset
 635  * @entry: pointer to the uint32_t, will hold entry point address
 636  *
 637  * This gets the entry point address property for a given component image
 638  * node.
 639  *
 640  * fit_image_get_entry() finds entry point address property in a given
 641  * component image node.  If the property is found, its value is returned
 642  * to the caller.
 643  *
 644  * returns:
 645  *     0, on success
 646  *     -1, on failure
 647  */
 648 int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
 649 {
 650         int len;
 651         const uint32_t *data;
 652
 653         data = fdt_getprop(fit, noffset, FIT_ENTRY_PROP, &len);
 654         if (data == NULL) {
 655                 fit_get_debug(fit, noffset, FIT_ENTRY_PROP, len);
 656                 return -1;
 657         }
 658
 659         *entry = uimage_to_cpu(*data);
 660         return 0;
 661 }
 662
 663 /**
 664  * fit_image_get_data - get data property and its size for a given component image node
 665  * @fit: pointer to the FIT format image header
 666  * @noffset: component image node offset
 667  * @data: double pointer to void, will hold data property's data address
 668  * @size: pointer to size_t, will hold data property's data size
 669  *
 670  * fit_image_get_data() finds data property in a given component image node.
 671  * If the property is found its data start address and size are returned to
 672  * the caller.
 673  *
 674  * returns:
 675  *     0, on success
 676  *     -1, on failure
 677  */
 678 int fit_image_get_data(const void *fit, int noffset,
 679                 const void **data, size_t *size)
 680 {
 681         int len;
 682
 683         *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
 684         if (*data == NULL) {
 685                 fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
 686                 *size = 0;
 687                 return -1;
 688         }
 689
 690         *size = len;
 691         return 0;
 692 }
 693
 694 /**
 695  * fit_image_hash_get_algo - get hash algorithm name
 696  * @fit: pointer to the FIT format image header
 697  * @noffset: hash node offset
 698  * @algo: double pointer to char, will hold pointer to the algorithm name
 699  *
 700  * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
 701  * If the property is found its data start address is returned to the caller.
 702  *
 703  * returns:
 704  *     0, on success
 705  *     -1, on failure
 706  */
 707 int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
 708 {
 709         int len;
 710
 711         *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
 712         if (*algo == NULL) {
 713                 fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
 714                 return -1;
 715         }
 716
 717         return 0;
 718 }
 719
 720 /**
 721  * fit_image_hash_get_value - get hash value and length
 722  * @fit: pointer to the FIT format image header
 723  * @noffset: hash node offset
 724  * @value: double pointer to uint8_t, will hold address of a hash value data
 725  * @value_len: pointer to an int, will hold hash data length
 726  *
 727  * fit_image_hash_get_value() finds hash value property in a given hash node.
 728  * If the property is found its data start address and size are returned to
 729  * the caller.
 730  *
 731  * returns:
 732  *     0, on success
 733  *     -1, on failure
 734  */
 735 int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
 736                                 int *value_len)
 737 {
 738         int len;
 739
 740         *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
 741         if (*value == NULL) {
 742                 fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
 743                 *value_len = 0;
 744                 return -1;
 745         }
 746
 747         *value_len = len;
 748         return 0;
 749 }
 750
 751 /**
 752  * fit_image_hash_get_ignore - get hash ignore flag
 753  * @fit: pointer to the FIT format image header
 754  * @noffset: hash node offset
 755  * @ignore: pointer to an int, will hold hash ignore flag
 756  *
 757  * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
 758  * If the property is found and non-zero, the hash algorithm is not verified by
 759  * u-boot automatically.
 760  *
 761  * returns:
 762  *     0, on ignore not found
 763  *     value, on ignore found
 764  */
 765 static int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
 766 {
 767         int len;
 768         int *value;
 769
 770         value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
 771         if (value == NULL || len != sizeof(int))
 772                 *ignore = 0;
 773         else
 774                 *ignore = *value;
 775
 776         return 0;
 777 }
 778
 779 /**
 780  * fit_set_timestamp - set node timestamp property
 781  * @fit: pointer to the FIT format image header
 782  * @noffset: node offset
 783  * @timestamp: timestamp value to be set
 784  *
 785  * fit_set_timestamp() attempts to set timestamp property in the requested
 786  * node and returns operation status to the caller.
 787  *
 788  * returns:
 789  *     0, on success
 790  *     -1, on property read failure
 791  */
 792 int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
 793 {
 794         uint32_t t;
 795         int ret;
 796
 797         t = cpu_to_uimage(timestamp);
 798         ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
 799                                 sizeof(uint32_t));
 800         if (ret) {
 801                 printf("Can't set '%s' property for '%s' node (%s)\n",
 802                        FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
 803                        fdt_strerror(ret));
 804                 return -1;
 805         }
 806
 807         return 0;
 808 }
 809
 810 /**
 811  * calculate_hash - calculate and return hash for provided input data
 812  * @data: pointer to the input data
 813  * @data_len: data length
 814  * @algo: requested hash algorithm
 815  * @value: pointer to the char, will hold hash value data (caller must
 816  * allocate enough free space)
 817  * value_len: length of the calculated hash
 818  *
 819  * calculate_hash() computes input data hash according to the requested
 820  * algorithm.
 821  * Resulting hash value is placed in caller provided 'value' buffer, length
 822  * of the calculated hash is returned via value_len pointer argument.
 823  *
 824  * returns:
 825  *     0, on success
 826  *    -1, when algo is unsupported
 827  */
 828 int calculate_hash(const void *data, int data_len, const char *algo,
 829                         uint8_t *value, int *value_len)
 830 {
 831         if (strcmp(algo, "crc32") == 0) {
 832                 *((uint32_t *)value) = crc32_wd(0, data, data_len,
 833                                                         CHUNKSZ_CRC32);
 834                 *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
 835                 *value_len = 4;
 836         } else if (strcmp(algo, "sha1") == 0) {
 837                 sha1_csum_wd((unsigned char *)data, data_len,
 838                              (unsigned char *)value, CHUNKSZ_SHA1);
 839                 *value_len = 20;
 840         } else if (strcmp(algo, "md5") == 0) {
 841                 md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
 842                 *value_len = 16;
 843         } else {
 844                 debug("Unsupported hash alogrithm\n");
 845                 return -1;
 846         }
 847         return 0;
 848 }
 849
 850 static int fit_image_check_hash(const void *fit, int noffset, const void *data,
 851                                 size_t size, char **err_msgp)
 852 {
 853         uint8_t value[FIT_MAX_HASH_LEN];
 854         int value_len;
 855         char *algo;
 856         uint8_t *fit_value;
 857         int fit_value_len;
 858         int ignore;
 859
 860         *err_msgp = NULL;
 861
 862         if (fit_image_hash_get_algo(fit, noffset, &algo)) {
 863                 *err_msgp = "Can't get hash algo property";
 864                 return -1;
 865         }
 866         printf("%s", algo);
 867
 868         if (IMAGE_ENABLE_IGNORE) {
 869                 fit_image_hash_get_ignore(fit, noffset, &ignore);
 870                 if (ignore) {
 871                         printf("-skipped ");
 872                         return 0;
 873                 }
 874         }
 875
 876         if (fit_image_hash_get_value(fit, noffset, &fit_value,
 877                                      &fit_value_len)) {
 878                 *err_msgp = "Can't get hash value property";
 879                 return -1;
 880         }
 881
 882         if (calculate_hash(data, size, algo, value, &value_len)) {
 883                 *err_msgp = "Unsupported hash algorithm";
 884                 return -1;
 885         }
 886
 887         if (value_len != fit_value_len) {
 888                 *err_msgp = "Bad hash value len";
 889                 return -1;
 890         } else if (memcmp(value, fit_value, value_len) != 0) {
 891                 *err_msgp = "Bad hash value";
 892                 return -1;
 893         }
 894
 895         return 0;
 896 }
 897
 898 /**
 899  * fit_image_verify - verify data intergity
 900  * @fit: pointer to the FIT format image header
 901  * @image_noffset: component image node offset
 902  *
 903  * fit_image_verify() goes over component image hash nodes,
 904  * re-calculates each data hash and compares with the value stored in hash
 905  * node.
 906  *
 907  * returns:
 908  *     1, if all hashes are valid
 909  *     0, otherwise (or on error)
 910  */
 911 int fit_image_verify(const void *fit, int image_noffset)
 912 {
 913         const void      *data;
 914         size_t          size;
 915         int             noffset;
 916         char            *err_msg = "";
 917
 918         /* Get image data and data length */
 919         if (fit_image_get_data(fit, image_noffset, &data, &size)) {
 920                 err_msg = "Can't get image data/size";
 921                 return 0;
 922         }
 923
 924         /* Process all hash subnodes of the component image node */
 925         for (noffset = fdt_first_subnode(fit, image_noffset);
 926              noffset >= 0;
 927              noffset = fdt_next_subnode(fit, noffset)) {
 928                 const char *name = fit_get_name(fit, noffset, NULL);
 929
 930                 /*
 931                  * Check subnode name, must be equal to "hash".
 932                  * Multiple hash nodes require unique unit node
 933                  * names, e.g. hash@1, hash@2, etc.
 934                  */
 935                 if (!strncmp(name, FIT_HASH_NODENAME,
 936                              strlen(FIT_HASH_NODENAME))) {
 937                         if (fit_image_check_hash(fit, noffset, data, size,
 938                                                  &err_msg))
 939                                 goto error;
 940                         puts("+ ");
 941                 }
 942         }
 943
 944         if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
 945                 err_msg = "Corrupted or truncated tree";
 946                 goto error;
 947         }
 948
 949         return 1;
 950
 951 error:
 952         printf(" error!\n%s for '%s' hash node in '%s' image node\n",
 953                err_msg, fit_get_name(fit, noffset, NULL),
 954                fit_get_name(fit, image_noffset, NULL));
 955         return 0;
 956 }
 957
 958 /**
 959  * fit_all_image_verify - verify data intergity for all images
 960  * @fit: pointer to the FIT format image header
 961  *
 962  * fit_all_image_verify() goes over all images in the FIT and
 963  * for every images checks if all it's hashes are valid.
 964  *
 965  * returns:
 966  *     1, if all hashes of all images are valid
 967  *     0, otherwise (or on error)
 968  */
 969 int fit_all_image_verify(const void *fit)
 970 {
 971         int images_noffset;
 972         int noffset;
 973         int ndepth;
 974         int count;
 975
 976         /* Find images parent node offset */
 977         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
 978         if (images_noffset < 0) {
 979                 printf("Can't find images parent node '%s' (%s)\n",
 980                        FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 981                 return 0;
 982         }
 983
 984         /* Process all image subnodes, check hashes for each */
 985         printf("## Checking hash(es) for FIT Image at %08lx ...\n",
 986                (ulong)fit);
 987         for (ndepth = 0, count = 0,
 988              noffset = fdt_next_node(fit, images_noffset, &ndepth);
 989                         (noffset >= 0) && (ndepth > 0);
 990                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
 991                 if (ndepth == 1) {
 992                         /*
 993                          * Direct child node of the images parent node,
 994                          * i.e. component image node.
 995                          */
 996                         printf("   Hash(es) for Image %u (%s): ", count++,
 997                                fit_get_name(fit, noffset, NULL));
 998
 999                         if (!fit_image_verify(fit, noffset))
1000                                 return 0;
1001                         printf("\n");
1002                 }
1003         }
1004         return 1;
1005 }
1006
1007 /**
1008  * fit_image_check_os - check whether image node is of a given os type
1009  * @fit: pointer to the FIT format image header
1010  * @noffset: component image node offset
1011  * @os: requested image os
1012  *
1013  * fit_image_check_os() reads image os property and compares its numeric
1014  * id with the requested os. Comparison result is returned to the caller.
1015  *
1016  * returns:
1017  *     1 if image is of given os type
1018  *     0 otherwise (or on error)
1019  */
1020 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1021 {
1022         uint8_t image_os;
1023
1024         if (fit_image_get_os(fit, noffset, &image_os))
1025                 return 0;
1026         return (os == image_os);
1027 }
1028
1029 /**
1030  * fit_image_check_arch - check whether image node is of a given arch
1031  * @fit: pointer to the FIT format image header
1032  * @noffset: component image node offset
1033  * @arch: requested imagearch
1034  *
1035  * fit_image_check_arch() reads image arch property and compares its numeric
1036  * id with the requested arch. Comparison result is returned to the caller.
1037  *
1038  * returns:
1039  *     1 if image is of given arch
1040  *     0 otherwise (or on error)
1041  */
1042 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1043 {
1044         uint8_t image_arch;
1045
1046         if (fit_image_get_arch(fit, noffset, &image_arch))
1047                 return 0;
1048         return (arch == image_arch);
1049 }
1050
1051 /**
1052  * fit_image_check_type - check whether image node is of a given type
1053  * @fit: pointer to the FIT format image header
1054  * @noffset: component image node offset
1055  * @type: requested image type
1056  *
1057  * fit_image_check_type() reads image type property and compares its numeric
1058  * id with the requested type. Comparison result is returned to the caller.
1059  *
1060  * returns:
1061  *     1 if image is of given type
1062  *     0 otherwise (or on error)
1063  */
1064 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1065 {
1066         uint8_t image_type;
1067
1068         if (fit_image_get_type(fit, noffset, &image_type))
1069                 return 0;
1070         return (type == image_type);
1071 }
1072
1073 /**
1074  * fit_image_check_comp - check whether image node uses given compression
1075  * @fit: pointer to the FIT format image header
1076  * @noffset: component image node offset
1077  * @comp: requested image compression type
1078  *
1079  * fit_image_check_comp() reads image compression property and compares its
1080  * numeric id with the requested compression type. Comparison result is
1081  * returned to the caller.
1082  *
1083  * returns:
1084  *     1 if image uses requested compression
1085  *     0 otherwise (or on error)
1086  */
1087 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1088 {
1089         uint8_t image_comp;
1090
1091         if (fit_image_get_comp(fit, noffset, &image_comp))
1092                 return 0;
1093         return (comp == image_comp);
1094 }
1095
1096 /**
1097  * fit_check_format - sanity check FIT image format
1098  * @fit: pointer to the FIT format image header
1099  *
1100  * fit_check_format() runs a basic sanity FIT image verification.
1101  * Routine checks for mandatory properties, nodes, etc.
1102  *
1103  * returns:
1104  *     1, on success
1105  *     0, on failure
1106  */
1107 int fit_check_format(const void *fit)
1108 {
1109         /* mandatory / node 'description' property */
1110         if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1111                 debug("Wrong FIT format: no description\n");
1112                 return 0;
1113         }
1114
1115         if (IMAGE_ENABLE_TIMESTAMP) {
1116                 /* mandatory / node 'timestamp' property */
1117                 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1118                         debug("Wrong FIT format: no timestamp\n");
1119                         return 0;
1120                 }
1121         }
1122
1123         /* mandatory subimages parent '/images' node */
1124         if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1125                 debug("Wrong FIT format: no images parent node\n");
1126                 return 0;
1127         }
1128
1129         return 1;
1130 }
1131
1132
1133 /**
1134  * fit_conf_find_compat
1135  * @fit: pointer to the FIT format image header
1136  * @fdt: pointer to the device tree to compare against
1137  *
1138  * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1139  * most compatible with the passed in device tree.
1140  *
1141  * Example:
1142  *
1143  * / o image-tree
1144  *   |-o images
1145  *   | |-o fdt@1
1146  *   | |-o fdt@2
1147  *   |
1148  *   |-o configurations
1149  *     |-o config@1
1150  *     | |-fdt = fdt@1
1151  *     |
1152  *     |-o config@2
1153  *       |-fdt = fdt@2
1154  *
1155  * / o U-Boot fdt
1156  *   |-compatible = "foo,bar", "bim,bam"
1157  *
1158  * / o kernel fdt1
1159  *   |-compatible = "foo,bar",
1160  *
1161  * / o kernel fdt2
1162  *   |-compatible = "bim,bam", "baz,biz"
1163  *
1164  * Configuration 1 would be picked because the first string in U-Boot's
1165  * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1166  * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1167  *
1168  * returns:
1169  *     offset to the configuration to use if one was found
1170  *     -1 otherwise
1171  */
1172 int fit_conf_find_compat(const void *fit, const void *fdt)
1173 {
1174         int ndepth = 0;
1175         int noffset, confs_noffset, images_noffset;
1176         const void *fdt_compat;
1177         int fdt_compat_len;
1178         int best_match_offset = 0;
1179         int best_match_pos = 0;
1180
1181         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1182         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1183         if (confs_noffset < 0 || images_noffset < 0) {
1184                 debug("Can't find configurations or images nodes.\n");
1185                 return -1;
1186         }
1187
1188         fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1189         if (!fdt_compat) {
1190                 debug("Fdt for comparison has no \"compatible\" property.\n");
1191                 return -1;
1192         }
1193
1194         /*
1195          * Loop over the configurations in the FIT image.
1196          */
1197         for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1198                         (noffset >= 0) && (ndepth > 0);
1199                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
1200                 const void *kfdt;
1201                 const char *kfdt_name;
1202                 int kfdt_noffset;
1203                 const char *cur_fdt_compat;
1204                 int len;
1205                 size_t size;
1206                 int i;
1207
1208                 if (ndepth > 1)
1209                         continue;
1210
1211                 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1212                 if (!kfdt_name) {
1213                         debug("No fdt property found.\n");
1214                         continue;
1215                 }
1216                 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1217                                                   kfdt_name);
1218                 if (kfdt_noffset < 0) {
1219                         debug("No image node named \"%s\" found.\n",
1220                               kfdt_name);
1221                         continue;
1222                 }
1223                 /*
1224                  * Get a pointer to this configuration's fdt.
1225                  */
1226                 if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1227                         debug("Failed to get fdt \"%s\".\n", kfdt_name);
1228                         continue;
1229                 }
1230
1231                 len = fdt_compat_len;
1232                 cur_fdt_compat = fdt_compat;
1233                 /*
1234                  * Look for a match for each U-Boot compatibility string in
1235                  * turn in this configuration's fdt.
1236                  */
1237                 for (i = 0; len > 0 &&
1238                      (!best_match_offset || best_match_pos > i); i++) {
1239                         int cur_len = strlen(cur_fdt_compat) + 1;
1240
1241                         if (!fdt_node_check_compatible(kfdt, 0,
1242                                                        cur_fdt_compat)) {
1243                                 best_match_offset = noffset;
1244                                 best_match_pos = i;
1245                                 break;
1246                         }
1247                         len -= cur_len;
1248                         cur_fdt_compat += cur_len;
1249                 }
1250         }
1251         if (!best_match_offset) {
1252                 debug("No match found.\n");
1253                 return -1;
1254         }
1255
1256         return best_match_offset;
1257 }
1258
1259 /**
1260  * fit_conf_get_node - get node offset for configuration of a given unit name
1261  * @fit: pointer to the FIT format image header
1262  * @conf_uname: configuration node unit name
1263  *
1264  * fit_conf_get_node() finds a configuration (withing the '/configurations'
1265  * parant node) of a provided unit name. If configuration is found its node
1266  * offset is returned to the caller.
1267  *
1268  * When NULL is provided in second argument fit_conf_get_node() will search
1269  * for a default configuration node instead. Default configuration node unit
1270  * name is retrived from FIT_DEFAULT_PROP property of the '/configurations'
1271  * node.
1272  *
1273  * returns:
1274  *     configuration node offset when found (>=0)
1275  *     negative number on failure (FDT_ERR_* code)
1276  */
1277 int fit_conf_get_node(const void *fit, const char *conf_uname)
1278 {
1279         int noffset, confs_noffset;
1280         int len;
1281
1282         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1283         if (confs_noffset < 0) {
1284                 debug("Can't find configurations parent node '%s' (%s)\n",
1285                       FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1286                 return confs_noffset;
1287         }
1288
1289         if (conf_uname == NULL) {
1290                 /* get configuration unit name from the default property */
1291                 debug("No configuration specified, trying default...\n");
1292                 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1293                                                  FIT_DEFAULT_PROP, &len);
1294                 if (conf_uname == NULL) {
1295                         fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1296                                       len);
1297                         return len;
1298                 }
1299                 debug("Found default configuration: '%s'\n", conf_uname);
1300         }
1301
1302         noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1303         if (noffset < 0) {
1304                 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1305                       conf_uname, fdt_strerror(noffset));
1306         }
1307
1308         return noffset;
1309 }
1310
1311 static int __fit_conf_get_prop_node(const void *fit, int noffset,
1312                 const char *prop_name)
1313 {
1314         char *uname;
1315         int len;
1316
1317         /* get kernel image unit name from configuration kernel property */
1318         uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
1319         if (uname == NULL)
1320                 return len;
1321
1322         return fit_image_get_node(fit, uname);
1323 }
1324
1325 /**
1326  * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
1327  * a given configuration
1328  * @fit: pointer to the FIT format image header
1329  * @noffset: configuration node offset
1330  *
1331  * fit_conf_get_kernel_node() retrives kernel image node unit name from
1332  * configuration FIT_KERNEL_PROP property and translates it to the node
1333  * offset.
1334  *
1335  * returns:
1336  *     image node offset when found (>=0)
1337  *     negative number on failure (FDT_ERR_* code)
1338  */
1339 int fit_conf_get_kernel_node(const void *fit, int noffset)
1340 {
1341         return __fit_conf_get_prop_node(fit, noffset, FIT_KERNEL_PROP);
1342 }
1343
1344 /**
1345  * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
1346  * a given configuration
1347  * @fit: pointer to the FIT format image header
1348  * @noffset: configuration node offset
1349  *
1350  * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
1351  * configuration FIT_KERNEL_PROP property and translates it to the node
1352  * offset.
1353  *
1354  * returns:
1355  *     image node offset when found (>=0)
1356  *     negative number on failure (FDT_ERR_* code)
1357  */
1358 int fit_conf_get_ramdisk_node(const void *fit, int noffset)
1359 {
1360         return __fit_conf_get_prop_node(fit, noffset, FIT_RAMDISK_PROP);
1361 }
1362
1363 /**
1364  * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
1365  * a given configuration
1366  * @fit: pointer to the FIT format image header
1367  * @noffset: configuration node offset
1368  *
1369  * fit_conf_get_fdt_node() retrives fdt image node unit name from
1370  * configuration FIT_KERNEL_PROP property and translates it to the node
1371  * offset.
1372  *
1373  * returns:
1374  *     image node offset when found (>=0)
1375  *     negative number on failure (FDT_ERR_* code)
1376  */
1377 int fit_conf_get_fdt_node(const void *fit, int noffset)
1378 {
1379         return __fit_conf_get_prop_node(fit, noffset, FIT_FDT_PROP);
1380 }
1381
1382 /**
1383  * fit_conf_print - prints out the FIT configuration details
1384  * @fit: pointer to the FIT format image header
1385  * @noffset: offset of the configuration node
1386  * @p: pointer to prefix string
1387  *
1388  * fit_conf_print() lists all mandatory properies for the processed
1389  * configuration node.
1390  *
1391  * returns:
1392  *     no returned results
1393  */
1394 void fit_conf_print(const void *fit, int noffset, const char *p)
1395 {
1396         char *desc;
1397         char *uname;
1398         int ret;
1399
1400         /* Mandatory properties */
1401         ret = fit_get_desc(fit, noffset, &desc);
1402         printf("%s  Description:  ", p);
1403         if (ret)
1404                 printf("unavailable\n");
1405         else
1406                 printf("%s\n", desc);
1407
1408         uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1409         printf("%s  Kernel:       ", p);
1410         if (uname == NULL)
1411                 printf("unavailable\n");
1412         else
1413                 printf("%s\n", uname);
1414
1415         /* Optional properties */
1416         uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1417         if (uname)
1418                 printf("%s  Init Ramdisk: %s\n", p, uname);
1419
1420         uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1421         if (uname)
1422                 printf("%s  FDT:          %s\n", p, uname);
1423 }
1424
1425 /**
1426  * fit_check_ramdisk - verify FIT format ramdisk subimage
1427  * @fit_hdr: pointer to the FIT ramdisk header
1428  * @rd_noffset: ramdisk subimage node offset within FIT image
1429  * @arch: requested ramdisk image architecture type
1430  * @verify: data CRC verification flag
1431  *
1432  * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
1433  * specified FIT image.
1434  *
1435  * returns:
1436  *     1, on success
1437  *     0, on failure
1438  */
1439 #ifndef USE_HOSTCC
1440 int fit_check_ramdisk(const void *fit, int rd_noffset, uint8_t arch,
1441                         int verify)
1442 {
1443         fit_image_print(fit, rd_noffset, "   ");
1444
1445         if (verify) {
1446                 puts("   Verifying Hash Integrity ... ");
1447                 if (!fit_image_verify(fit, rd_noffset)) {
1448                         puts("Bad Data Hash\n");
1449                         bootstage_error(BOOTSTAGE_ID_FIT_RD_HASH);
1450                         return 0;
1451                 }
1452                 puts("OK\n");
1453         }
1454
1455         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1456         if (!fit_image_check_os(fit, rd_noffset, IH_OS_LINUX) ||
1457             !fit_image_check_arch(fit, rd_noffset, arch) ||
1458             !fit_image_check_type(fit, rd_noffset, IH_TYPE_RAMDISK)) {
1459                 printf("No Linux %s Ramdisk Image\n",
1460                        genimg_get_arch_name(arch));
1461                 bootstage_error(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1462                 return 0;
1463         }
1464
1465         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL_OK);
1466         return 1;
1467 }
1468 #endif /* USE_HOSTCC */