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