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, ×tamp); 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 */ 1637