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