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 #ifndef USE_HOSTCC
 752 /**
 753  * fit_image_hash_get_ignore - get hash ignore flag
 754  * @fit: pointer to the FIT format image header
 755  * @noffset: hash node offset
 756  * @ignore: pointer to an int, will hold hash ignore flag
 757  *
 758  * fit_image_hash_get_ignore() finds hash ignore property in a given hash node.
 759  * If the property is found and non-zero, the hash algorithm is not verified by
 760  * u-boot automatically.
 761  *
 762  * returns:
 763  *     0, on ignore not found
 764  *     value, on ignore found
 765  */
 766 int fit_image_hash_get_ignore(const void *fit, int noffset, int *ignore)
 767 {
 768         int len;
 769         int *value;
 770
 771         value = (int *)fdt_getprop(fit, noffset, FIT_IGNORE_PROP, &len);
 772         if (value == NULL || len != sizeof(int))
 773                 *ignore = 0;
 774         else
 775                 *ignore = *value;
 776
 777         return 0;
 778 }
 779 #endif
 780
 781 /**
 782  * fit_set_timestamp - set node timestamp property
 783  * @fit: pointer to the FIT format image header
 784  * @noffset: node offset
 785  * @timestamp: timestamp value to be set
 786  *
 787  * fit_set_timestamp() attempts to set timestamp property in the requested
 788  * node and returns operation status to the caller.
 789  *
 790  * returns:
 791  *     0, on success
 792  *     -1, on property read failure
 793  */
 794 int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
 795 {
 796         uint32_t t;
 797         int ret;
 798
 799         t = cpu_to_uimage(timestamp);
 800         ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
 801                                 sizeof(uint32_t));
 802         if (ret) {
 803                 printf("Can't set '%s' property for '%s' node (%s)\n",
 804                        FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
 805                        fdt_strerror(ret));
 806                 return -1;
 807         }
 808
 809         return 0;
 810 }
 811
 812 /**
 813  * calculate_hash - calculate and return hash for provided input data
 814  * @data: pointer to the input data
 815  * @data_len: data length
 816  * @algo: requested hash algorithm
 817  * @value: pointer to the char, will hold hash value data (caller must
 818  * allocate enough free space)
 819  * value_len: length of the calculated hash
 820  *
 821  * calculate_hash() computes input data hash according to the requested
 822  * algorithm.
 823  * Resulting hash value is placed in caller provided 'value' buffer, length
 824  * of the calculated hash is returned via value_len pointer argument.
 825  *
 826  * returns:
 827  *     0, on success
 828  *    -1, when algo is unsupported
 829  */
 830 static int calculate_hash(const void *data, int data_len, const char *algo,
 831                         uint8_t *value, int *value_len)
 832 {
 833         if (strcmp(algo, "crc32") == 0) {
 834                 *((uint32_t *)value) = crc32_wd(0, data, data_len,
 835                                                         CHUNKSZ_CRC32);
 836                 *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
 837                 *value_len = 4;
 838         } else if (strcmp(algo, "sha1") == 0) {
 839                 sha1_csum_wd((unsigned char *)data, data_len,
 840                              (unsigned char *)value, CHUNKSZ_SHA1);
 841                 *value_len = 20;
 842         } else if (strcmp(algo, "md5") == 0) {
 843                 md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
 844                 *value_len = 16;
 845         } else {
 846                 debug("Unsupported hash alogrithm\n");
 847                 return -1;
 848         }
 849         return 0;
 850 }
 851
 852 #ifdef USE_HOSTCC
 853 /**
 854  * fit_set_hashes - process FIT component image nodes and calculate hashes
 855  * @fit: pointer to the FIT format image header
 856  *
 857  * fit_set_hashes() adds hash values for all component images in the FIT blob.
 858  * Hashes are calculated for all component images which have hash subnodes
 859  * with algorithm property set to one of the supported hash algorithms.
 860  *
 861  * returns
 862  *     0, on success
 863  *     libfdt error code, on failure
 864  */
 865 int fit_set_hashes(void *fit)
 866 {
 867         int images_noffset;
 868         int noffset;
 869         int ndepth;
 870         int ret;
 871
 872         /* Find images parent node offset */
 873         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
 874         if (images_noffset < 0) {
 875                 printf("Can't find images parent node '%s' (%s)\n",
 876                        FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 877                 return images_noffset;
 878         }
 879
 880         /* Process its subnodes, print out component images details */
 881         for (ndepth = 0, noffset = fdt_next_node(fit, images_noffset, &ndepth);
 882              (noffset >= 0) && (ndepth > 0);
 883              noffset = fdt_next_node(fit, noffset, &ndepth)) {
 884                 if (ndepth == 1) {
 885                         /*
 886                          * Direct child node of the images parent node,
 887                          * i.e. component image node.
 888                          */
 889                         ret = fit_image_set_hashes(fit, noffset);
 890                         if (ret)
 891                                 return ret;
 892                 }
 893         }
 894
 895         return 0;
 896 }
 897
 898 /**
 899  * fit_image_set_hashes - calculate/set hashes for given component image node
 900  * @fit: pointer to the FIT format image header
 901  * @image_noffset: requested component image node
 902  *
 903  * fit_image_set_hashes() adds hash values for an component image node. All
 904  * existing hash subnodes are checked, if algorithm property is set to one of
 905  * the supported hash algorithms, hash value is computed and corresponding
 906  * hash node property is set, for example:
 907  *
 908  * Input component image node structure:
 909  *
 910  * o image@1 (at image_noffset)
 911  *   | - data = [binary data]
 912  *   o hash@1
 913  *     |- algo = "sha1"
 914  *
 915  * Output component image node structure:
 916  *
 917  * o image@1 (at image_noffset)
 918  *   | - data = [binary data]
 919  *   o hash@1
 920  *     |- algo = "sha1"
 921  *     |- value = sha1(data)
 922  *
 923  * returns:
 924  *     0 on sucess
 925  *    <0 on failure
 926  */
 927 int fit_image_set_hashes(void *fit, int image_noffset)
 928 {
 929         const void *data;
 930         size_t size;
 931         char *algo;
 932         uint8_t value[FIT_MAX_HASH_LEN];
 933         int value_len;
 934         int noffset;
 935         int ndepth;
 936
 937         /* Get image data and data length */
 938         if (fit_image_get_data(fit, image_noffset, &data, &size)) {
 939                 printf("Can't get image data/size\n");
 940                 return -1;
 941         }
 942
 943         /* Process all hash subnodes of the component image node */
 944         for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
 945              (noffset >= 0) && (ndepth > 0);
 946              noffset = fdt_next_node(fit, noffset, &ndepth)) {
 947                 if (ndepth == 1) {
 948                         /* Direct child node of the component image node */
 949
 950                         /*
 951                          * Check subnode name, must be equal to "hash".
 952                          * Multiple hash nodes require unique unit node
 953                          * names, e.g. hash@1, hash@2, etc.
 954                          */
 955                         if (strncmp(fit_get_name(fit, noffset, NULL),
 956                                     FIT_HASH_NODENAME,
 957                                     strlen(FIT_HASH_NODENAME)) != 0) {
 958                                 /* Not a hash subnode, skip it */
 959                                 continue;
 960                         }
 961
 962                         if (fit_image_hash_get_algo(fit, noffset, &algo)) {
 963                                 printf("Can't get hash algo property for '%s' hash node in '%s' image node\n",
 964                                        fit_get_name(fit, noffset, NULL),
 965                                        fit_get_name(fit, image_noffset, NULL));
 966                                 return -1;
 967                         }
 968
 969                         if (calculate_hash(data, size, algo, value,
 970                                            &value_len)) {
 971                                 printf("Unsupported hash algorithm (%s) for '%s' hash node in '%s' image node\n",
 972                                        algo, fit_get_name(fit, noffset, NULL),
 973                                        fit_get_name(fit, image_noffset, NULL));
 974                                 return -1;
 975                         }
 976
 977                         if (fit_image_hash_set_value(fit, noffset, value,
 978                                                      value_len)) {
 979                                 printf("Can't set hash value for '%s' hash node in '%s' image node\n",
 980                                        fit_get_name(fit, noffset, NULL),
 981                                        fit_get_name(fit, image_noffset, NULL));
 982                                 return -1;
 983                         }
 984                 }
 985         }
 986
 987         return 0;
 988 }
 989
 990 /**
 991  * fit_image_hash_set_value - set hash value in requested has node
 992  * @fit: pointer to the FIT format image header
 993  * @noffset: hash node offset
 994  * @value: hash value to be set
 995  * @value_len: hash value length
 996  *
 997  * fit_image_hash_set_value() attempts to set hash value in a node at offset
 998  * given and returns operation status to the caller.
 999  *
1000  * returns
1001  *     0, on success
1002  *     -1, on failure
1003  */
1004 int fit_image_hash_set_value(void *fit, int noffset, uint8_t *value,
1005                                 int value_len)
1006 {
1007         int ret;
1008
1009         ret = fdt_setprop(fit, noffset, FIT_VALUE_PROP, value, value_len);
1010         if (ret) {
1011                 printf("Can't set hash '%s' property for '%s' node(%s)\n",
1012                        FIT_VALUE_PROP, fit_get_name(fit, noffset, NULL),
1013                        fdt_strerror(ret));
1014                 return -1;
1015         }
1016
1017         return 0;
1018 }
1019 #endif /* USE_HOSTCC */
1020
1021 /**
1022  * fit_image_check_hashes - verify data intergity
1023  * @fit: pointer to the FIT format image header
1024  * @image_noffset: component image node offset
1025  *
1026  * fit_image_check_hashes() goes over component image hash nodes,
1027  * re-calculates each data hash and compares with the value stored in hash
1028  * node.
1029  *
1030  * returns:
1031  *     1, if all hashes are valid
1032  *     0, otherwise (or on error)
1033  */
1034 int fit_image_check_hashes(const void *fit, int image_noffset)
1035 {
1036         const void      *data;
1037         size_t          size;
1038         char            *algo;
1039         uint8_t         *fit_value;
1040         int             fit_value_len;
1041 #ifndef USE_HOSTCC
1042         int             ignore;
1043 #endif
1044         uint8_t         value[FIT_MAX_HASH_LEN];
1045         int             value_len;
1046         int             noffset;
1047         int             ndepth;
1048         char            *err_msg = "";
1049
1050         /* Get image data and data length */
1051         if (fit_image_get_data(fit, image_noffset, &data, &size)) {
1052                 printf("Can't get image data/size\n");
1053                 return 0;
1054         }
1055
1056         /* Process all hash subnodes of the component image node */
1057         for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
1058              (noffset >= 0) && (ndepth > 0);
1059              noffset = fdt_next_node(fit, noffset, &ndepth)) {
1060                 if (ndepth == 1) {
1061                         /* Direct child node of the component image node */
1062
1063                         /*
1064                          * Check subnode name, must be equal to "hash".
1065                          * Multiple hash nodes require unique unit node
1066                          * names, e.g. hash@1, hash@2, etc.
1067                          */
1068                         if (strncmp(fit_get_name(fit, noffset, NULL),
1069                                     FIT_HASH_NODENAME,
1070                                     strlen(FIT_HASH_NODENAME)) != 0)
1071                                 continue;
1072
1073                         if (fit_image_hash_get_algo(fit, noffset, &algo)) {
1074                                 err_msg = " error!\nCan't get hash algo property";
1075                                 goto error;
1076                         }
1077                         printf("%s", algo);
1078
1079 #ifndef USE_HOSTCC
1080                         fit_image_hash_get_ignore(fit, noffset, &ignore);
1081                         if (ignore) {
1082                                 printf("-skipped ");
1083                                 continue;
1084                         }
1085 #endif
1086
1087                         if (fit_image_hash_get_value(fit, noffset, &fit_value,
1088                                                      &fit_value_len)) {
1089                                 err_msg = " error!\nCan't get hash value "
1090                                                 "property";
1091                                 goto error;
1092                         }
1093
1094                         if (calculate_hash(data, size, algo, value,
1095                                            &value_len)) {
1096                                 err_msg = " error!\n"
1097                                                 "Unsupported hash algorithm";
1098                                 goto error;
1099                         }
1100
1101                         if (value_len != fit_value_len) {
1102                                 err_msg = " error !\nBad hash value len";
1103                                 goto error;
1104                         } else if (memcmp(value, fit_value, value_len) != 0) {
1105                                 err_msg = " error!\nBad hash value";
1106                                 goto error;
1107                         }
1108                         printf("+ ");
1109                 }
1110         }
1111
1112         if (noffset == -FDT_ERR_TRUNCATED || noffset == -FDT_ERR_BADSTRUCTURE) {
1113                 err_msg = " error!\nCorrupted or truncated tree";
1114                 goto error;
1115         }
1116
1117         return 1;
1118
1119 error:
1120         printf("%s for '%s' hash node in '%s' image node\n",
1121                err_msg, fit_get_name(fit, noffset, NULL),
1122                fit_get_name(fit, image_noffset, NULL));
1123         return 0;
1124 }
1125
1126 /**
1127  * fit_all_image_check_hashes - verify data intergity for all images
1128  * @fit: pointer to the FIT format image header
1129  *
1130  * fit_all_image_check_hashes() goes over all images in the FIT and
1131  * for every images checks if all it's hashes are valid.
1132  *
1133  * returns:
1134  *     1, if all hashes of all images are valid
1135  *     0, otherwise (or on error)
1136  */
1137 int fit_all_image_check_hashes(const void *fit)
1138 {
1139         int images_noffset;
1140         int noffset;
1141         int ndepth;
1142         int count;
1143
1144         /* Find images parent node offset */
1145         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1146         if (images_noffset < 0) {
1147                 printf("Can't find images parent node '%s' (%s)\n",
1148                        FIT_IMAGES_PATH, fdt_strerror(images_noffset));
1149                 return 0;
1150         }
1151
1152         /* Process all image subnodes, check hashes for each */
1153         printf("## Checking hash(es) for FIT Image at %08lx ...\n",
1154                (ulong)fit);
1155         for (ndepth = 0, count = 0,
1156              noffset = fdt_next_node(fit, images_noffset, &ndepth);
1157                         (noffset >= 0) && (ndepth > 0);
1158                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
1159                 if (ndepth == 1) {
1160                         /*
1161                          * Direct child node of the images parent node,
1162                          * i.e. component image node.
1163                          */
1164                         printf("   Hash(es) for Image %u (%s): ", count++,
1165                                fit_get_name(fit, noffset, NULL));
1166
1167                         if (!fit_image_check_hashes(fit, noffset))
1168                                 return 0;
1169                         printf("\n");
1170                 }
1171         }
1172         return 1;
1173 }
1174
1175 /**
1176  * fit_image_check_os - check whether image node is of a given os type
1177  * @fit: pointer to the FIT format image header
1178  * @noffset: component image node offset
1179  * @os: requested image os
1180  *
1181  * fit_image_check_os() reads image os property and compares its numeric
1182  * id with the requested os. Comparison result is returned to the caller.
1183  *
1184  * returns:
1185  *     1 if image is of given os type
1186  *     0 otherwise (or on error)
1187  */
1188 int fit_image_check_os(const void *fit, int noffset, uint8_t os)
1189 {
1190         uint8_t image_os;
1191
1192         if (fit_image_get_os(fit, noffset, &image_os))
1193                 return 0;
1194         return (os == image_os);
1195 }
1196
1197 /**
1198  * fit_image_check_arch - check whether image node is of a given arch
1199  * @fit: pointer to the FIT format image header
1200  * @noffset: component image node offset
1201  * @arch: requested imagearch
1202  *
1203  * fit_image_check_arch() reads image arch property and compares its numeric
1204  * id with the requested arch. Comparison result is returned to the caller.
1205  *
1206  * returns:
1207  *     1 if image is of given arch
1208  *     0 otherwise (or on error)
1209  */
1210 int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
1211 {
1212         uint8_t image_arch;
1213
1214         if (fit_image_get_arch(fit, noffset, &image_arch))
1215                 return 0;
1216         return (arch == image_arch);
1217 }
1218
1219 /**
1220  * fit_image_check_type - check whether image node is of a given type
1221  * @fit: pointer to the FIT format image header
1222  * @noffset: component image node offset
1223  * @type: requested image type
1224  *
1225  * fit_image_check_type() reads image type property and compares its numeric
1226  * id with the requested type. Comparison result is returned to the caller.
1227  *
1228  * returns:
1229  *     1 if image is of given type
1230  *     0 otherwise (or on error)
1231  */
1232 int fit_image_check_type(const void *fit, int noffset, uint8_t type)
1233 {
1234         uint8_t image_type;
1235
1236         if (fit_image_get_type(fit, noffset, &image_type))
1237                 return 0;
1238         return (type == image_type);
1239 }
1240
1241 /**
1242  * fit_image_check_comp - check whether image node uses given compression
1243  * @fit: pointer to the FIT format image header
1244  * @noffset: component image node offset
1245  * @comp: requested image compression type
1246  *
1247  * fit_image_check_comp() reads image compression property and compares its
1248  * numeric id with the requested compression type. Comparison result is
1249  * returned to the caller.
1250  *
1251  * returns:
1252  *     1 if image uses requested compression
1253  *     0 otherwise (or on error)
1254  */
1255 int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
1256 {
1257         uint8_t image_comp;
1258
1259         if (fit_image_get_comp(fit, noffset, &image_comp))
1260                 return 0;
1261         return (comp == image_comp);
1262 }
1263
1264 /**
1265  * fit_check_format - sanity check FIT image format
1266  * @fit: pointer to the FIT format image header
1267  *
1268  * fit_check_format() runs a basic sanity FIT image verification.
1269  * Routine checks for mandatory properties, nodes, etc.
1270  *
1271  * returns:
1272  *     1, on success
1273  *     0, on failure
1274  */
1275 int fit_check_format(const void *fit)
1276 {
1277         /* mandatory / node 'description' property */
1278         if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
1279                 debug("Wrong FIT format: no description\n");
1280                 return 0;
1281         }
1282
1283         if (IMAGE_ENABLE_TIMESTAMP) {
1284                 /* mandatory / node 'timestamp' property */
1285                 if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
1286                         debug("Wrong FIT format: no timestamp\n");
1287                         return 0;
1288                 }
1289         }
1290
1291         /* mandatory subimages parent '/images' node */
1292         if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
1293                 debug("Wrong FIT format: no images parent node\n");
1294                 return 0;
1295         }
1296
1297         return 1;
1298 }
1299
1300
1301 /**
1302  * fit_conf_find_compat
1303  * @fit: pointer to the FIT format image header
1304  * @fdt: pointer to the device tree to compare against
1305  *
1306  * fit_conf_find_compat() attempts to find the configuration whose fdt is the
1307  * most compatible with the passed in device tree.
1308  *
1309  * Example:
1310  *
1311  * / o image-tree
1312  *   |-o images
1313  *   | |-o fdt@1
1314  *   | |-o fdt@2
1315  *   |
1316  *   |-o configurations
1317  *     |-o config@1
1318  *     | |-fdt = fdt@1
1319  *     |
1320  *     |-o config@2
1321  *       |-fdt = fdt@2
1322  *
1323  * / o U-Boot fdt
1324  *   |-compatible = "foo,bar", "bim,bam"
1325  *
1326  * / o kernel fdt1
1327  *   |-compatible = "foo,bar",
1328  *
1329  * / o kernel fdt2
1330  *   |-compatible = "bim,bam", "baz,biz"
1331  *
1332  * Configuration 1 would be picked because the first string in U-Boot's
1333  * compatible list, "foo,bar", matches a compatible string in the root of fdt1.
1334  * "bim,bam" in fdt2 matches the second string which isn't as good as fdt1.
1335  *
1336  * returns:
1337  *     offset to the configuration to use if one was found
1338  *     -1 otherwise
1339  */
1340 int fit_conf_find_compat(const void *fit, const void *fdt)
1341 {
1342         int ndepth = 0;
1343         int noffset, confs_noffset, images_noffset;
1344         const void *fdt_compat;
1345         int fdt_compat_len;
1346         int best_match_offset = 0;
1347         int best_match_pos = 0;
1348
1349         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1350         images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
1351         if (confs_noffset < 0 || images_noffset < 0) {
1352                 debug("Can't find configurations or images nodes.\n");
1353                 return -1;
1354         }
1355
1356         fdt_compat = fdt_getprop(fdt, 0, "compatible", &fdt_compat_len);
1357         if (!fdt_compat) {
1358                 debug("Fdt for comparison has no \"compatible\" property.\n");
1359                 return -1;
1360         }
1361
1362         /*
1363          * Loop over the configurations in the FIT image.
1364          */
1365         for (noffset = fdt_next_node(fit, confs_noffset, &ndepth);
1366                         (noffset >= 0) && (ndepth > 0);
1367                         noffset = fdt_next_node(fit, noffset, &ndepth)) {
1368                 const void *kfdt;
1369                 const char *kfdt_name;
1370                 int kfdt_noffset;
1371                 const char *cur_fdt_compat;
1372                 int len;
1373                 size_t size;
1374                 int i;
1375
1376                 if (ndepth > 1)
1377                         continue;
1378
1379                 kfdt_name = fdt_getprop(fit, noffset, "fdt", &len);
1380                 if (!kfdt_name) {
1381                         debug("No fdt property found.\n");
1382                         continue;
1383                 }
1384                 kfdt_noffset = fdt_subnode_offset(fit, images_noffset,
1385                                                   kfdt_name);
1386                 if (kfdt_noffset < 0) {
1387                         debug("No image node named \"%s\" found.\n",
1388                               kfdt_name);
1389                         continue;
1390                 }
1391                 /*
1392                  * Get a pointer to this configuration's fdt.
1393                  */
1394                 if (fit_image_get_data(fit, kfdt_noffset, &kfdt, &size)) {
1395                         debug("Failed to get fdt \"%s\".\n", kfdt_name);
1396                         continue;
1397                 }
1398
1399                 len = fdt_compat_len;
1400                 cur_fdt_compat = fdt_compat;
1401                 /*
1402                  * Look for a match for each U-Boot compatibility string in
1403                  * turn in this configuration's fdt.
1404                  */
1405                 for (i = 0; len > 0 &&
1406                      (!best_match_offset || best_match_pos > i); i++) {
1407                         int cur_len = strlen(cur_fdt_compat) + 1;
1408
1409                         if (!fdt_node_check_compatible(kfdt, 0,
1410                                                        cur_fdt_compat)) {
1411                                 best_match_offset = noffset;
1412                                 best_match_pos = i;
1413                                 break;
1414                         }
1415                         len -= cur_len;
1416                         cur_fdt_compat += cur_len;
1417                 }
1418         }
1419         if (!best_match_offset) {
1420                 debug("No match found.\n");
1421                 return -1;
1422         }
1423
1424         return best_match_offset;
1425 }
1426
1427 /**
1428  * fit_conf_get_node - get node offset for configuration of a given unit name
1429  * @fit: pointer to the FIT format image header
1430  * @conf_uname: configuration node unit name
1431  *
1432  * fit_conf_get_node() finds a configuration (withing the '/configurations'
1433  * parant node) of a provided unit name. If configuration is found its node
1434  * offset is returned to the caller.
1435  *
1436  * When NULL is provided in second argument fit_conf_get_node() will search
1437  * for a default configuration node instead. Default configuration node unit
1438  * name is retrived from FIT_DEFAULT_PROP property of the '/configurations'
1439  * node.
1440  *
1441  * returns:
1442  *     configuration node offset when found (>=0)
1443  *     negative number on failure (FDT_ERR_* code)
1444  */
1445 int fit_conf_get_node(const void *fit, const char *conf_uname)
1446 {
1447         int noffset, confs_noffset;
1448         int len;
1449
1450         confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
1451         if (confs_noffset < 0) {
1452                 debug("Can't find configurations parent node '%s' (%s)\n",
1453                       FIT_CONFS_PATH, fdt_strerror(confs_noffset));
1454                 return confs_noffset;
1455         }
1456
1457         if (conf_uname == NULL) {
1458                 /* get configuration unit name from the default property */
1459                 debug("No configuration specified, trying default...\n");
1460                 conf_uname = (char *)fdt_getprop(fit, confs_noffset,
1461                                                  FIT_DEFAULT_PROP, &len);
1462                 if (conf_uname == NULL) {
1463                         fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
1464                                       len);
1465                         return len;
1466                 }
1467                 debug("Found default configuration: '%s'\n", conf_uname);
1468         }
1469
1470         noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
1471         if (noffset < 0) {
1472                 debug("Can't get node offset for configuration unit name: '%s' (%s)\n",
1473                       conf_uname, fdt_strerror(noffset));
1474         }
1475
1476         return noffset;
1477 }
1478
1479 static int __fit_conf_get_prop_node(const void *fit, int noffset,
1480                 const char *prop_name)
1481 {
1482         char *uname;
1483         int len;
1484
1485         /* get kernel image unit name from configuration kernel property */
1486         uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
1487         if (uname == NULL)
1488                 return len;
1489
1490         return fit_image_get_node(fit, uname);
1491 }
1492
1493 /**
1494  * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
1495  * a given configuration
1496  * @fit: pointer to the FIT format image header
1497  * @noffset: configuration node offset
1498  *
1499  * fit_conf_get_kernel_node() retrives kernel image node unit name from
1500  * configuration FIT_KERNEL_PROP property and translates it to the node
1501  * offset.
1502  *
1503  * returns:
1504  *     image node offset when found (>=0)
1505  *     negative number on failure (FDT_ERR_* code)
1506  */
1507 int fit_conf_get_kernel_node(const void *fit, int noffset)
1508 {
1509         return __fit_conf_get_prop_node(fit, noffset, FIT_KERNEL_PROP);
1510 }
1511
1512 /**
1513  * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
1514  * a given configuration
1515  * @fit: pointer to the FIT format image header
1516  * @noffset: configuration node offset
1517  *
1518  * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
1519  * configuration FIT_KERNEL_PROP property and translates it to the node
1520  * offset.
1521  *
1522  * returns:
1523  *     image node offset when found (>=0)
1524  *     negative number on failure (FDT_ERR_* code)
1525  */
1526 int fit_conf_get_ramdisk_node(const void *fit, int noffset)
1527 {
1528         return __fit_conf_get_prop_node(fit, noffset, FIT_RAMDISK_PROP);
1529 }
1530
1531 /**
1532  * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
1533  * a given configuration
1534  * @fit: pointer to the FIT format image header
1535  * @noffset: configuration node offset
1536  *
1537  * fit_conf_get_fdt_node() retrives fdt image node unit name from
1538  * configuration FIT_KERNEL_PROP property and translates it to the node
1539  * offset.
1540  *
1541  * returns:
1542  *     image node offset when found (>=0)
1543  *     negative number on failure (FDT_ERR_* code)
1544  */
1545 int fit_conf_get_fdt_node(const void *fit, int noffset)
1546 {
1547         return __fit_conf_get_prop_node(fit, noffset, FIT_FDT_PROP);
1548 }
1549
1550 /**
1551  * fit_conf_print - prints out the FIT configuration details
1552  * @fit: pointer to the FIT format image header
1553  * @noffset: offset of the configuration node
1554  * @p: pointer to prefix string
1555  *
1556  * fit_conf_print() lists all mandatory properies for the processed
1557  * configuration node.
1558  *
1559  * returns:
1560  *     no returned results
1561  */
1562 void fit_conf_print(const void *fit, int noffset, const char *p)
1563 {
1564         char *desc;
1565         char *uname;
1566         int ret;
1567
1568         /* Mandatory properties */
1569         ret = fit_get_desc(fit, noffset, &desc);
1570         printf("%s  Description:  ", p);
1571         if (ret)
1572                 printf("unavailable\n");
1573         else
1574                 printf("%s\n", desc);
1575
1576         uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
1577         printf("%s  Kernel:       ", p);
1578         if (uname == NULL)
1579                 printf("unavailable\n");
1580         else
1581                 printf("%s\n", uname);
1582
1583         /* Optional properties */
1584         uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
1585         if (uname)
1586                 printf("%s  Init Ramdisk: %s\n", p, uname);
1587
1588         uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
1589         if (uname)
1590                 printf("%s  FDT:          %s\n", p, uname);
1591 }
1592
1593 /**
1594  * fit_check_ramdisk - verify FIT format ramdisk subimage
1595  * @fit_hdr: pointer to the FIT ramdisk header
1596  * @rd_noffset: ramdisk subimage node offset within FIT image
1597  * @arch: requested ramdisk image architecture type
1598  * @verify: data CRC verification flag
1599  *
1600  * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
1601  * specified FIT image.
1602  *
1603  * returns:
1604  *     1, on success
1605  *     0, on failure
1606  */
1607 #ifndef USE_HOSTCC
1608 int fit_check_ramdisk(const void *fit, int rd_noffset, uint8_t arch,
1609                         int verify)
1610 {
1611         fit_image_print(fit, rd_noffset, "   ");
1612
1613         if (verify) {
1614                 puts("   Verifying Hash Integrity ... ");
1615                 if (!fit_image_check_hashes(fit, rd_noffset)) {
1616                         puts("Bad Data Hash\n");
1617                         bootstage_error(BOOTSTAGE_ID_FIT_RD_HASH);
1618                         return 0;
1619                 }
1620                 puts("OK\n");
1621         }
1622
1623         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1624         if (!fit_image_check_os(fit, rd_noffset, IH_OS_LINUX) ||
1625             !fit_image_check_arch(fit, rd_noffset, arch) ||
1626             !fit_image_check_type(fit, rd_noffset, IH_TYPE_RAMDISK)) {
1627                 printf("No Linux %s Ramdisk Image\n",
1628                        genimg_get_arch_name(arch));
1629                 bootstage_error(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
1630                 return 0;
1631         }
1632
1633         bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL_OK);
1634         return 1;
1635 }
1636 #endif /* USE_HOSTCC */