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 = " error!\nCan't get hash algo "
 864                                 "property";
 865                 return -1;
 866         }
 867         printf("%s", algo);
 868
 869         if (IMAGE_ENABLE_IGNORE) {
 870                 fit_image_hash_get_ignore(fit, noffset, &ignore);
 871                 if (ignore) {
 872                         printf("-skipped ");
 873                         return 0;
 874                 }
 875         }
 876
 877         if (fit_image_hash_get_value(fit, noffset, &fit_value,
 878                                      &fit_value_len)) {
 879                 *err_msgp = " error!\nCan't get hash value "
 880                                 "property";
 881                 return -1;
 882         }
 883
 884         if (calculate_hash(data, size, algo, value, &value_len)) {
 885                 *err_msgp = " error!\n"
 886                                 "Unsupported hash algorithm";
 887                 return -1;
 888         }
 889
 890         if (value_len != fit_value_len) {
 891                 *err_msgp = " error !\nBad hash value len";
 892                 return -1;
 893         } else if (memcmp(value, fit_value, value_len) != 0) {
 894                 *err_msgp = " error!\nBad hash value";
 895                 return -1;
 896         }
 897
 898         return 0;
 899 }
 900
 901 /**
 902  * fit_image_verify - verify data intergity
 903  * @fit: pointer to the FIT format image header
 904  * @image_noffset: component image node offset
 905  *
 906  * fit_image_verify() goes over component image hash nodes,
 907  * re-calculates each data hash and compares with the value stored in hash
 908  * node.
 909  *
 910  * returns:
 911  *     1, if all hashes are valid
 912  *     0, otherwise (or on error)
 913  */
 914 int fit_image_verify(const void *fit, int image_noffset)
 915 {
 916         const void      *data;
 917         size_t          size;
 918         int             noffset;
 919         char            *err_msg = "";
 920
 921         /* Get image data and data length */
 922         if (fit_image_get_data(fit, image_noffset, &data, &size)) {
 923                 printf("Can't get image data/size\n");
 924                 return 0;
 925         }
 926
 927         /* Process all hash subnodes of the component image node */
 928         for (noffset = fdt_first_subnode(fit, image_noffset);
 929              noffset >= 0;
 930              noffset = fdt_next_subnode(fit, noffset)) {
 931                 const char *name = fit_get_name(fit, noffset, NULL);
 932
 933                 /*
 934                  * Check subnode name, must be equal to "hash".
 935                  * Multiple hash nodes require unique unit node
 936                  * names, e.g. hash@1, hash@2, etc.
 937                  */
 938                 if (!strncmp(name, FIT_HASH_NODENAME,
 939                              strlen(FIT_HASH_NODENAME))) {
 940                         if (fit_image_check_hash(fit, noffset, data, size,
 941                                                  &err_msg))
 942                                 goto error;
 943                         puts("+ ");
 944                 }
 945         }
 946
 947         if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
 948                 err_msg = " error!\nCorrupted or truncated tree";
 949                 goto error;
 950         }
 951
 952         return 1;
 953
 954 error:
 955         printf("%s for '%s' hash node in '%s' image node\n",
 956                err_msg, fit_get_name(fit, noffset, NULL),
 957                fit_get_name(fit, image_noffset, NULL));
 958         return 0;
 959 }
 960
 961 /**
 962  * fit_all_image_verify - verify data intergity for all images
 963  * @fit: pointer to the FIT format image header
 964  *
 965  * fit_all_image_verify() goes over all images in the FIT and
 966  * for every images checks if all it's hashes are valid.
 967  *
 968  * returns:
 969  *     1, if all hashes of all images are valid
 970  *     0, otherwise (or on error)
 971  */
 972 int fit_all_image_verify(const void *fit)
 973 {
 974         int images_noffset;
 975         int noffset;
 976         int ndepth;
 977         int count;
 978
 979         /* Find images parent node offset */
 980         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
 981         if (images_noffset < 0) {
 982                 printf("Can't find images parent node '%s' (%s)\n",
 983                        FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 984                 return 0;
 985         }
 986
 987         /* Process all image subnodes, check hashes for each */
 988         printf("## Checking hash(es) for FIT Image at %08lx ...\n",
 989                (ulong)fit);
 990         for (ndepth = 0, count = 0,
 991              noffset = fdt_next_node(fit, images_noffset, &ndepth);
 992                         (noffset >= 0) && (ndepth > 0);
 993                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
 994                 if (ndepth == 1) {
 995                         /*
 996                          * Direct child node of the images parent node,
 997                          * i.e. component image node.
 998                          */
 999                         printf("   Hash(es) for Image %u (%s): ", count++,
1000                                fit_get_name(fit, noffset, NULL));
1001
1002                         if (!fit_image_verify(fit, noffset))
1003                                 return 0;
1004                         printf("\n");
1005                 }
1006         }
1007         return 1;
1008 }
1009
1010 /**
1011  * fit_image_check_os - check whether image node is of a given os type
1012  * @fit: pointer to the FIT format image header
1013  * @noffset: component image node offset
1014  * @os: requested image os
1015  *
1016  * fit_image_check_os() reads image os property and compares its numeric
1017  * id with the requested os. Comparison result is returned to the caller.
1018  *
1019  * returns:
1020  *     1 if image is of given os type
1021  *     0 otherwise (or on error)
1022  */
1023 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1024 {
1025         uint8_t image_os;
1026
1027         if (fit_image_get_os(fit, noffset, &image_os))
1028                 return 0;
1029         return (os == image_os);
1030 }
1031
1032 /**
1033  * fit_image_check_arch - check whether image node is of a given arch
1034  * @fit: pointer to the FIT format image header
1035  * @noffset: component image node offset
1036  * @arch: requested imagearch
1037  *
1038  * fit_image_check_arch() reads image arch property and compares its numeric
1039  * id with the requested arch. Comparison result is returned to the caller.
1040  *
1041  * returns:
1042  *     1 if image is of given arch
1043  *     0 otherwise (or on error)
1044  */
1045 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1046 {
1047         uint8_t image_arch;
1048
1049         if (fit_image_get_arch(fit, noffset, &image_arch))
1050                 return 0;
1051         return (arch == image_arch);
1052 }
1053
1054 /**
1055  * fit_image_check_type - check whether image node is of a given type
1056  * @fit: pointer to the FIT format image header
1057  * @noffset: component image node offset
1058  * @type: requested image type
1059  *
1060  * fit_image_check_type() reads image type property and compares its numeric
1061  * id with the requested type. Comparison result is returned to the caller.
1062  *
1063  * returns:
1064  *     1 if image is of given type
1065  *     0 otherwise (or on error)
1066  */
1067 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1068 {
1069         uint8_t image_type;
1070
1071         if (fit_image_get_type(fit, noffset, &image_type))
1072                 return 0;
1073         return (type == image_type);
1074 }
1075
1076 /**
1077  * fit_image_check_comp - check whether image node uses given compression
1078  * @fit: pointer to the FIT format image header
1079  * @noffset: component image node offset
1080  * @comp: requested image compression type
1081  *
1082  * fit_image_check_comp() reads image compression property and compares its
1083  * numeric id with the requested compression type. Comparison result is
1084  * returned to the caller.
1085  *
1086  * returns:
1087  *     1 if image uses requested compression
1088  *     0 otherwise (or on error)
1089  */
1090 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1091 {
1092         uint8_t image_comp;
1093
1094         if (fit_image_get_comp(fit, noffset, &image_comp))
1095                 return 0;
1096         return (comp == image_comp);
1097 }
1098
1099 /**
1100  * fit_check_format - sanity check FIT image format
1101  * @fit: pointer to the FIT format image header
1102  *
1103  * fit_check_format() runs a basic sanity FIT image verification.
1104  * Routine checks for mandatory properties, nodes, etc.
1105  *
1106  * returns:
1107  *     1, on success
1108  *     0, on failure
1109  */
1110 int fit_check_format(const void *fit)
1111 {
1112         /* mandatory / node 'description' property */
1113         if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1114                 debug("Wrong FIT format: no description\n");
1115                 return 0;
1116         }
1117
1118         if (IMAGE_ENABLE_TIMESTAMP) {
1119                 /* mandatory / node 'timestamp' property */
1120                 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1121                         debug("Wrong FIT format: no timestamp\n");
1122                         return 0;
1123                 }
1124         }
1125
1126         /* mandatory subimages parent '/images' node */
1127         if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1128                 debug("Wrong FIT format: no images parent node\n");
1129                 return 0;
1130         }
1131
1132         return 1;
1133 }
1134
1135
1136 /**
1137  * fit_conf_find_compat
1138  * @fit: pointer to the FIT format image header
1139  * @fdt: pointer to the device tree to compare against
1140  *
1141  * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1142  * most compatible with the passed in device tree.
1143  *
1144  * Example:
1145  *
1146  * / o image-tree
1147  *   |-o images
1148  *   | |-o fdt@1
1149  *   | |-o fdt@2
1150  *   |
1151  *   |-o configurations
1152  *     |-o config@1
1153  *     | |-fdt = fdt@1
1154  *     |
1155  *     |-o config@2
1156  *       |-fdt = fdt@2
1157  *
1158  * / o U-Boot fdt
1159  *   |-compatible = "foo,bar", "bim,bam"
1160  *
1161  * / o kernel fdt1
1162  *   |-compatible = "foo,bar",
1163  *
1164  * / o kernel fdt2
1165  *   |-compatible = "bim,bam", "baz,biz"
1166  *
1167  * Configuration 1 would be picked because the first string in U-Boot's
1168  * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1169  * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1170  *
1171  * returns:
1172  *     offset to the configuration to use if one was found
1173  *     -1 otherwise
1174  */
1175 int fit_conf_find_compat(const void *fit, const void *fdt)
1176 {
1177         int ndepth = 0;
1178         int noffset, confs_noffset, images_noffset;
1179         const void *fdt_compat;
1180         int fdt_compat_len;
1181         int best_match_offset = 0;
1182         int best_match_pos = 0;
1183
1184         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1185         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1186         if (confs_noffset < 0 || images_noffset < 0) {
1187                 debug("Can't find configurations or images nodes.\n");
1188                 return -1;
1189         }
1190
1191         fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1192         if (!fdt_compat) {
1193                 debug("Fdt for comparison has no \"compatible\" property.\n");
1194                 return -1;
1195         }
1196
1197         /*
1198          * Loop over the configurations in the FIT image.
1199          */
1200         for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1201                         (noffset >= 0) && (ndepth > 0);
1202                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
1203                 const void *kfdt;
1204                 const char *kfdt_name;
1205                 int kfdt_noffset;
1206                 const char *cur_fdt_compat;
1207                 int len;
1208                 size_t size;
1209                 int i;
1210
1211                 if (ndepth > 1)
1212                         continue;
1213
1214                 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1215                 if (!kfdt_name) {
1216                         debug("No fdt property found.\n");
1217                         continue;
1218                 }
1219                 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1220                                                   kfdt_name);
1221                 if (kfdt_noffset < 0) {
1222                         debug("No image node named \"%s\" found.\n",
1223                               kfdt_name);
1224                         continue;
1225                 }
1226                 /*
1227                  * Get a pointer to this configuration's fdt.
1228                  */
1229                 if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1230                         debug("Failed to get fdt \"%s\".\n", kfdt_name);
1231                         continue;
1232                 }
1233
1234                 len = fdt_compat_len;
1235                 cur_fdt_compat = fdt_compat;
1236                 /*
1237                  * Look for a match for each U-Boot compatibility string in
1238                  * turn in this configuration's fdt.
1239                  */
1240                 for (i = 0; len > 0 &&
1241                      (!best_match_offset || best_match_pos > i); i++) {
1242                         int cur_len = strlen(cur_fdt_compat) + 1;
1243
1244                         if (!fdt_node_check_compatible(kfdt, 0,
1245                                                        cur_fdt_compat)) {
1246                                 best_match_offset = noffset;
1247                                 best_match_pos = i;
1248                                 break;
1249                         }
1250                         len -= cur_len;
1251                         cur_fdt_compat += cur_len;
1252                 }
1253         }
1254         if (!best_match_offset) {
1255                 debug("No match found.\n");
1256                 return -1;
1257         }
1258
1259         return best_match_offset;
1260 }
1261
1262 /**
1263  * fit_conf_get_node - get node offset for configuration of a given unit name
1264  * @fit: pointer to the FIT format image header
1265  * @conf_uname: configuration node unit name
1266  *
1267  * fit_conf_get_node() finds a configuration (withing the '/configurations'
1268  * parant node) of a provided unit name. If configuration is found its node
1269  * offset is returned to the caller.
1270  *
1271  * When NULL is provided in second argument fit_conf_get_node() will search
1272  * for a default configuration node instead. Default configuration node unit
1273  * name is retrived from FIT_DEFAULT_PROP property of the '/configurations'
1274  * node.
1275  *
1276  * returns:
1277  *     configuration node offset when found (>=0)
1278  *     negative number on failure (FDT_ERR_* code)
1279  */
1280 int fit_conf_get_node(const void *fit, const char *conf_uname)
1281 {
1282         int noffset, confs_noffset;
1283         int len;
1284
1285         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1286         if (confs_noffset < 0) {
1287                 debug("Can't find configurations parent node '%s' (%s)\n",
1288                       FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1289                 return confs_noffset;
1290         }
1291
1292         if (conf_uname == NULL) {
1293                 /* get configuration unit name from the default property */
1294                 debug("No configuration specified, trying default...\n");
1295                 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1296                                                  FIT_DEFAULT_PROP, &len);
1297                 if (conf_uname == NULL) {
1298                         fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1299                                       len);
1300                         return len;
1301                 }
1302                 debug("Found default configuration: '%s'\n", conf_uname);
1303         }
1304
1305         noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1306         if (noffset < 0) {
1307                 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1308                       conf_uname, fdt_strerror(noffset));
1309         }
1310
1311         return noffset;
1312 }
1313
1314 static int __fit_conf_get_prop_node(const void *fit, int noffset,
1315                 const char *prop_name)
1316 {
1317         char *uname;
1318         int len;
1319
1320         /* get kernel image unit name from configuration kernel property */
1321         uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
1322         if (uname == NULL)
1323                 return len;
1324
1325         return fit_image_get_node(fit, uname);
1326 }
1327
1328 /**
1329  * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
1330  * a given configuration
1331  * @fit: pointer to the FIT format image header
1332  * @noffset: configuration node offset
1333  *
1334  * fit_conf_get_kernel_node() retrives kernel image node unit name from
1335  * configuration FIT_KERNEL_PROP property and translates it to the node
1336  * offset.
1337  *
1338  * returns:
1339  *     image node offset when found (>=0)
1340  *     negative number on failure (FDT_ERR_* code)
1341  */
1342 int fit_conf_get_kernel_node(const void *fit, int noffset)
1343 {
1344         return __fit_conf_get_prop_node(fit, noffset, FIT_KERNEL_PROP);
1345 }
1346
1347 /**
1348  * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
1349  * a given configuration
1350  * @fit: pointer to the FIT format image header
1351  * @noffset: configuration node offset
1352  *
1353  * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
1354  * configuration FIT_KERNEL_PROP property and translates it to the node
1355  * offset.
1356  *
1357  * returns:
1358  *     image node offset when found (>=0)
1359  *     negative number on failure (FDT_ERR_* code)
1360  */
1361 int fit_conf_get_ramdisk_node(const void *fit, int noffset)
1362 {
1363         return __fit_conf_get_prop_node(fit, noffset, FIT_RAMDISK_PROP);
1364 }
1365
1366 /**
1367  * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
1368  * a given configuration
1369  * @fit: pointer to the FIT format image header
1370  * @noffset: configuration node offset
1371  *
1372  * fit_conf_get_fdt_node() retrives fdt image node unit name from
1373  * configuration FIT_KERNEL_PROP property and translates it to the node
1374  * offset.
1375  *
1376  * returns:
1377  *     image node offset when found (>=0)
1378  *     negative number on failure (FDT_ERR_* code)
1379  */
1380 int fit_conf_get_fdt_node(const void *fit, int noffset)
1381 {
1382         return __fit_conf_get_prop_node(fit, noffset, FIT_FDT_PROP);
1383 }
1384
1385 /**
1386  * fit_conf_print - prints out the FIT configuration details
1387  * @fit: pointer to the FIT format image header
1388  * @noffset: offset of the configuration node
1389  * @p: pointer to prefix string
1390  *
1391  * fit_conf_print() lists all mandatory properies for the processed
1392  * configuration node.
1393  *
1394  * returns:
1395  *     no returned results
1396  */
1397 void fit_conf_print(const void *fit, int noffset, const char *p)
1398 {
1399         char *desc;
1400         char *uname;
1401         int ret;
1402
1403         /* Mandatory properties */
1404         ret = fit_get_desc(fit, noffset, &desc);
1405         printf("%s  Description:  ", p);
1406         if (ret)
1407                 printf("unavailable\n");
1408         else
1409                 printf("%s\n", desc);
1410
1411         uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1412         printf("%s  Kernel:       ", p);
1413         if (uname == NULL)
1414                 printf("unavailable\n");
1415         else
1416                 printf("%s\n", uname);
1417
1418         /* Optional properties */
1419         uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1420         if (uname)
1421                 printf("%s  Init Ramdisk: %s\n", p, uname);
1422
1423         uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1424         if (uname)
1425                 printf("%s  FDT:          %s\n", p, uname);
1426 }
1427
1428 /**
1429  * fit_check_ramdisk - verify FIT format ramdisk subimage
1430  * @fit_hdr: pointer to the FIT ramdisk header
1431  * @rd_noffset: ramdisk subimage node offset within FIT image
1432  * @arch: requested ramdisk image architecture type
1433  * @verify: data CRC verification flag
1434  *
1435  * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
1436  * specified FIT image.
1437  *
1438  * returns:
1439  *     1, on success
1440  *     0, on failure
1441  */
1442 #ifndef USE_HOSTCC
1443 int fit_check_ramdisk(const void *fit, int rd_noffset, uint8_t arch,
1444                         int verify)
1445 {
1446         fit_image_print(fit, rd_noffset, "   ");
1447
1448         if (verify) {
1449                 puts("   Verifying Hash Integrity ... ");
1450                 if (!fit_image_verify(fit, rd_noffset)) {
1451                         puts("Bad Data Hash\n");
1452                         bootstage_error(BOOTSTAGE_ID_FIT_RD_HASH);
1453                         return 0;
1454                 }
1455                 puts("OK\n");
1456         }
1457
1458         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1459         if (!fit_image_check_os(fit, rd_noffset, IH_OS_LINUX) ||
1460             !fit_image_check_arch(fit, rd_noffset, arch) ||
1461             !fit_image_check_type(fit, rd_noffset, IH_TYPE_RAMDISK)) {
1462                 printf("No Linux %s Ramdisk Image\n",
1463                        genimg_get_arch_name(arch));
1464                 bootstage_error(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1465                 return 0;
1466         }
1467
1468         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL_OK);
1469         return 1;
1470 }
1471 #endif /* USE_HOSTCC */