1 /* 2 * (C) Copyright 2008 Semihalf 3 * 4 * (C) Copyright 2000-2009 5 * DENX Software Engineering 6 * Wolfgang Denk, wd@denx.de 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 21 * MA 02111-1307 USA 22 */ 23 24 #include "mkimage.h" 25 #include <image.h> 26 #include <version.h> 27 28 static void copy_file(int, const char *, int); 29 static void usage(void); 30 31 /* image_type_params link list to maintain registered image type supports */ 32 struct image_type_params *mkimage_tparams = NULL; 33 34 /* parameters initialized by core will be used by the image type code */ 35 struct mkimage_params params = { 36 .os = IH_OS_LINUX, 37 .arch = IH_ARCH_PPC, 38 .type = IH_TYPE_KERNEL, 39 .comp = IH_COMP_GZIP, 40 .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS, 41 .imagename = "", 42 }; 43 44 /* 45 * mkimage_register - 46 * 47 * It is used to register respective image generation/list support to the 48 * mkimage core 49 * 50 * the input struct image_type_params is checked and appended to the link 51 * list, if the input structure is already registered, error 52 */ 53 void mkimage_register (struct image_type_params *tparams) 54 { 55 struct image_type_params **tp; 56 57 if (!tparams) { 58 fprintf (stderr, "%s: %s: Null input\n", 59 params.cmdname, __FUNCTION__); 60 exit (EXIT_FAILURE); 61 } 62 63 /* scan the linked list, check for registry and point the last one */ 64 for (tp = &mkimage_tparams; *tp != NULL; tp = &(*tp)->next) { 65 if (!strcmp((*tp)->name, tparams->name)) { 66 fprintf (stderr, "%s: %s already registered\n", 67 params.cmdname, tparams->name); 68 return; 69 } 70 } 71 72 /* add input struct entry at the end of link list */ 73 *tp = tparams; 74 /* mark input entry as last entry in the link list */ 75 tparams->next = NULL; 76 77 debug ("Registered %s\n", tparams->name); 78 } 79 80 /* 81 * mkimage_get_type - 82 * 83 * It scans all registers image type supports 84 * checks the input type_id for each supported image type 85 * 86 * if successful, 87 * returns respective image_type_params pointer if success 88 * if input type_id is not supported by any of image_type_support 89 * returns NULL 90 */ 91 struct image_type_params *mkimage_get_type(int type) 92 { 93 struct image_type_params *curr; 94 95 for (curr = mkimage_tparams; curr != NULL; curr = curr->next) { 96 if (curr->check_image_type) { 97 if (!curr->check_image_type (type)) 98 return curr; 99 } 100 } 101 return NULL; 102 } 103 104 /* 105 * mkimage_verify_print_header - 106 * 107 * It scans mkimage_tparams link list, 108 * verifies image_header for each supported image type 109 * if verification is successful, prints respective header 110 * 111 * returns negative if input image format does not match with any of 112 * supported image types 113 */ 114 int mkimage_verify_print_header (void *ptr, struct stat *sbuf) 115 { 116 int retval = -1; 117 struct image_type_params *curr; 118 119 for (curr = mkimage_tparams; curr != NULL; curr = curr->next ) { 120 if (curr->verify_header) { 121 retval = curr->verify_header ( 122 (unsigned char *)ptr, sbuf->st_size, 123 ¶ms); 124 125 if (retval == 0) { 126 /* 127 * Print the image information 128 * if verify is successful 129 */ 130 if (curr->print_header) 131 curr->print_header (ptr); 132 else { 133 fprintf (stderr, 134 "%s: print_header undefined for %s\n", 135 params.cmdname, curr->name); 136 } 137 break; 138 } 139 } 140 } 141 return retval; 142 } 143 144 int 145 main (int argc, char **argv) 146 { 147 int ifd = -1; 148 struct stat sbuf; 149 char *ptr; 150 int retval = 0; 151 struct image_type_params *tparams = NULL; 152 153 /* Init Kirkwood Boot image generation/list support */ 154 init_kwb_image_type (); 155 /* Init Freescale imx Boot image generation/list support */ 156 init_imx_image_type (); 157 /* Init FIT image generation/list support */ 158 init_fit_image_type (); 159 /* Init TI OMAP Boot image generation/list support */ 160 init_omap_image_type(); 161 /* Init Default image generation/list support */ 162 init_default_image_type (); 163 /* Init Davinci UBL support */ 164 init_ubl_image_type(); 165 166 params.cmdname = *argv; 167 params.addr = params.ep = 0; 168 169 while (--argc > 0 && **++argv == '-') { 170 while (*++*argv) { 171 switch (**argv) { 172 case 'l': 173 params.lflag = 1; 174 break; 175 case 'A': 176 if ((--argc <= 0) || 177 (params.arch = 178 genimg_get_arch_id (*++argv)) < 0) 179 usage (); 180 goto NXTARG; 181 case 'C': 182 if ((--argc <= 0) || 183 (params.comp = 184 genimg_get_comp_id (*++argv)) < 0) 185 usage (); 186 goto NXTARG; 187 case 'D': 188 if (--argc <= 0) 189 usage (); 190 params.dtc = *++argv; 191 goto NXTARG; 192 193 case 'O': 194 if ((--argc <= 0) || 195 (params.os = 196 genimg_get_os_id (*++argv)) < 0) 197 usage (); 198 goto NXTARG; 199 case 'T': 200 if ((--argc <= 0) || 201 (params.type = 202 genimg_get_type_id (*++argv)) < 0) 203 usage (); 204 goto NXTARG; 205 206 case 'a': 207 if (--argc <= 0) 208 usage (); 209 params.addr = strtoul (*++argv, &ptr, 16); 210 if (*ptr) { 211 fprintf (stderr, 212 "%s: invalid load address %s\n", 213 params.cmdname, *argv); 214 exit (EXIT_FAILURE); 215 } 216 goto NXTARG; 217 case 'd': 218 if (--argc <= 0) 219 usage (); 220 params.datafile = *++argv; 221 params.dflag = 1; 222 goto NXTARG; 223 case 'e': 224 if (--argc <= 0) 225 usage (); 226 params.ep = strtoul (*++argv, &ptr, 16); 227 if (*ptr) { 228 fprintf (stderr, 229 "%s: invalid entry point %s\n", 230 params.cmdname, *argv); 231 exit (EXIT_FAILURE); 232 } 233 params.eflag = 1; 234 goto NXTARG; 235 case 'f': 236 if (--argc <= 0) 237 usage (); 238 /* 239 * The flattened image tree (FIT) format 240 * requires a flattened device tree image type 241 */ 242 params.type = IH_TYPE_FLATDT; 243 params.datafile = *++argv; 244 params.fflag = 1; 245 goto NXTARG; 246 case 'n': 247 if (--argc <= 0) 248 usage (); 249 params.imagename = *++argv; 250 goto NXTARG; 251 case 'v': 252 params.vflag++; 253 break; 254 case 'V': 255 printf("mkimage version %s\n", PLAIN_VERSION); 256 exit(EXIT_SUCCESS); 257 case 'x': 258 params.xflag++; 259 break; 260 default: 261 usage (); 262 } 263 } 264 NXTARG: ; 265 } 266 267 if (argc != 1) 268 usage (); 269 270 /* set tparams as per input type_id */ 271 tparams = mkimage_get_type(params.type); 272 if (tparams == NULL) { 273 fprintf (stderr, "%s: unsupported type %s\n", 274 params.cmdname, genimg_get_type_name(params.type)); 275 exit (EXIT_FAILURE); 276 } 277 278 /* 279 * check the passed arguments parameters meets the requirements 280 * as per image type to be generated/listed 281 */ 282 if (tparams->check_params) 283 if (tparams->check_params (¶ms)) 284 usage (); 285 286 if (!params.eflag) { 287 params.ep = params.addr; 288 /* If XIP, entry point must be after the U-Boot header */ 289 if (params.xflag) 290 params.ep += tparams->header_size; 291 } 292 293 params.imagefile = *argv; 294 295 if (params.fflag){ 296 if (tparams->fflag_handle) 297 /* 298 * in some cases, some additional processing needs 299 * to be done if fflag is defined 300 * 301 * For ex. fit_handle_file for Fit file support 302 */ 303 retval = tparams->fflag_handle(¶ms); 304 305 if (retval != EXIT_SUCCESS) 306 exit (retval); 307 } 308 309 if (params.lflag || params.fflag) { 310 ifd = open (params.imagefile, O_RDONLY|O_BINARY); 311 } else { 312 ifd = open (params.imagefile, 313 O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666); 314 } 315 316 if (ifd < 0) { 317 fprintf (stderr, "%s: Can't open %s: %s\n", 318 params.cmdname, params.imagefile, 319 strerror(errno)); 320 exit (EXIT_FAILURE); 321 } 322 323 if (params.lflag || params.fflag) { 324 /* 325 * list header information of existing image 326 */ 327 if (fstat(ifd, &sbuf) < 0) { 328 fprintf (stderr, "%s: Can't stat %s: %s\n", 329 params.cmdname, params.imagefile, 330 strerror(errno)); 331 exit (EXIT_FAILURE); 332 } 333 334 if ((unsigned)sbuf.st_size < tparams->header_size) { 335 fprintf (stderr, 336 "%s: Bad size: \"%s\" is not valid image\n", 337 params.cmdname, params.imagefile); 338 exit (EXIT_FAILURE); 339 } 340 341 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0); 342 if (ptr == MAP_FAILED) { 343 fprintf (stderr, "%s: Can't read %s: %s\n", 344 params.cmdname, params.imagefile, 345 strerror(errno)); 346 exit (EXIT_FAILURE); 347 } 348 349 /* 350 * scan through mkimage registry for all supported image types 351 * and verify the input image file header for match 352 * Print the image information for matched image type 353 * Returns the error code if not matched 354 */ 355 retval = mkimage_verify_print_header (ptr, &sbuf); 356 357 (void) munmap((void *)ptr, sbuf.st_size); 358 (void) close (ifd); 359 360 exit (retval); 361 } 362 363 /* 364 * Must be -w then: 365 * 366 * write dummy header, to be fixed later 367 */ 368 memset (tparams->hdr, 0, tparams->header_size); 369 370 if (write(ifd, tparams->hdr, tparams->header_size) 371 != tparams->header_size) { 372 fprintf (stderr, "%s: Write error on %s: %s\n", 373 params.cmdname, params.imagefile, strerror(errno)); 374 exit (EXIT_FAILURE); 375 } 376 377 if (params.type == IH_TYPE_MULTI || params.type == IH_TYPE_SCRIPT) { 378 char *file = params.datafile; 379 uint32_t size; 380 381 for (;;) { 382 char *sep = NULL; 383 384 if (file) { 385 if ((sep = strchr(file, ':')) != NULL) { 386 *sep = '\0'; 387 } 388 389 if (stat (file, &sbuf) < 0) { 390 fprintf (stderr, "%s: Can't stat %s: %s\n", 391 params.cmdname, file, strerror(errno)); 392 exit (EXIT_FAILURE); 393 } 394 size = cpu_to_uimage (sbuf.st_size); 395 } else { 396 size = 0; 397 } 398 399 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) { 400 fprintf (stderr, "%s: Write error on %s: %s\n", 401 params.cmdname, params.imagefile, 402 strerror(errno)); 403 exit (EXIT_FAILURE); 404 } 405 406 if (!file) { 407 break; 408 } 409 410 if (sep) { 411 *sep = ':'; 412 file = sep + 1; 413 } else { 414 file = NULL; 415 } 416 } 417 418 file = params.datafile; 419 420 for (;;) { 421 char *sep = strchr(file, ':'); 422 if (sep) { 423 *sep = '\0'; 424 copy_file (ifd, file, 1); 425 *sep++ = ':'; 426 file = sep; 427 } else { 428 copy_file (ifd, file, 0); 429 break; 430 } 431 } 432 } else { 433 copy_file (ifd, params.datafile, 0); 434 } 435 436 /* We're a bit of paranoid */ 437 #if defined(_POSIX_SYNCHRONIZED_IO) && \ 438 !defined(__sun__) && \ 439 !defined(__FreeBSD__) && \ 440 !defined(__APPLE__) 441 (void) fdatasync (ifd); 442 #else 443 (void) fsync (ifd); 444 #endif 445 446 if (fstat(ifd, &sbuf) < 0) { 447 fprintf (stderr, "%s: Can't stat %s: %s\n", 448 params.cmdname, params.imagefile, strerror(errno)); 449 exit (EXIT_FAILURE); 450 } 451 452 ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0); 453 if (ptr == MAP_FAILED) { 454 fprintf (stderr, "%s: Can't map %s: %s\n", 455 params.cmdname, params.imagefile, strerror(errno)); 456 exit (EXIT_FAILURE); 457 } 458 459 /* Setup the image header as per input image type*/ 460 if (tparams->set_header) 461 tparams->set_header (ptr, &sbuf, ifd, ¶ms); 462 else { 463 fprintf (stderr, "%s: Can't set header for %s: %s\n", 464 params.cmdname, tparams->name, strerror(errno)); 465 exit (EXIT_FAILURE); 466 } 467 468 /* Print the image information by processing image header */ 469 if (tparams->print_header) 470 tparams->print_header (ptr); 471 else { 472 fprintf (stderr, "%s: Can't print header for %s: %s\n", 473 params.cmdname, tparams->name, strerror(errno)); 474 exit (EXIT_FAILURE); 475 } 476 477 (void) munmap((void *)ptr, sbuf.st_size); 478 479 /* We're a bit of paranoid */ 480 #if defined(_POSIX_SYNCHRONIZED_IO) && \ 481 !defined(__sun__) && \ 482 !defined(__FreeBSD__) && \ 483 !defined(__APPLE__) 484 (void) fdatasync (ifd); 485 #else 486 (void) fsync (ifd); 487 #endif 488 489 if (close(ifd)) { 490 fprintf (stderr, "%s: Write error on %s: %s\n", 491 params.cmdname, params.imagefile, strerror(errno)); 492 exit (EXIT_FAILURE); 493 } 494 495 exit (EXIT_SUCCESS); 496 } 497 498 static void 499 copy_file (int ifd, const char *datafile, int pad) 500 { 501 int dfd; 502 struct stat sbuf; 503 unsigned char *ptr; 504 int tail; 505 int zero = 0; 506 int offset = 0; 507 int size; 508 struct image_type_params *tparams = mkimage_get_type (params.type); 509 510 if (params.vflag) { 511 fprintf (stderr, "Adding Image %s\n", datafile); 512 } 513 514 if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) { 515 fprintf (stderr, "%s: Can't open %s: %s\n", 516 params.cmdname, datafile, strerror(errno)); 517 exit (EXIT_FAILURE); 518 } 519 520 if (fstat(dfd, &sbuf) < 0) { 521 fprintf (stderr, "%s: Can't stat %s: %s\n", 522 params.cmdname, datafile, strerror(errno)); 523 exit (EXIT_FAILURE); 524 } 525 526 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 527 if (ptr == MAP_FAILED) { 528 fprintf (stderr, "%s: Can't read %s: %s\n", 529 params.cmdname, datafile, strerror(errno)); 530 exit (EXIT_FAILURE); 531 } 532 533 if (params.xflag) { 534 unsigned char *p = NULL; 535 /* 536 * XIP: do not append the image_header_t at the 537 * beginning of the file, but consume the space 538 * reserved for it. 539 */ 540 541 if ((unsigned)sbuf.st_size < tparams->header_size) { 542 fprintf (stderr, 543 "%s: Bad size: \"%s\" is too small for XIP\n", 544 params.cmdname, datafile); 545 exit (EXIT_FAILURE); 546 } 547 548 for (p = ptr; p < ptr + tparams->header_size; p++) { 549 if ( *p != 0xff ) { 550 fprintf (stderr, 551 "%s: Bad file: \"%s\" has invalid buffer for XIP\n", 552 params.cmdname, datafile); 553 exit (EXIT_FAILURE); 554 } 555 } 556 557 offset = tparams->header_size; 558 } 559 560 size = sbuf.st_size - offset; 561 if (write(ifd, ptr + offset, size) != size) { 562 fprintf (stderr, "%s: Write error on %s: %s\n", 563 params.cmdname, params.imagefile, strerror(errno)); 564 exit (EXIT_FAILURE); 565 } 566 567 if (pad && ((tail = size % 4) != 0)) { 568 569 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) { 570 fprintf (stderr, "%s: Write error on %s: %s\n", 571 params.cmdname, params.imagefile, 572 strerror(errno)); 573 exit (EXIT_FAILURE); 574 } 575 } 576 577 (void) munmap((void *)ptr, sbuf.st_size); 578 (void) close (dfd); 579 } 580 581 void 582 usage () 583 { 584 fprintf (stderr, "Usage: %s -l image\n" 585 " -l ==> list image header information\n", 586 params.cmdname); 587 fprintf (stderr, " %s [-x] -A arch -O os -T type -C comp " 588 "-a addr -e ep -n name -d data_file[:data_file...] image\n" 589 " -A ==> set architecture to 'arch'\n" 590 " -O ==> set operating system to 'os'\n" 591 " -T ==> set image type to 'type'\n" 592 " -C ==> set compression type 'comp'\n" 593 " -a ==> set load address to 'addr' (hex)\n" 594 " -e ==> set entry point to 'ep' (hex)\n" 595 " -n ==> set image name to 'name'\n" 596 " -d ==> use image data from 'datafile'\n" 597 " -x ==> set XIP (execute in place)\n", 598 params.cmdname); 599 fprintf (stderr, " %s [-D dtc_options] -f fit-image.its fit-image\n", 600 params.cmdname); 601 fprintf (stderr, " %s -V ==> print version information and exit\n", 602 params.cmdname); 603 604 exit (EXIT_FAILURE); 605 } 606