]> git.sur5r.net Git - u-boot/blob - tools/mkimage.c
e12bc318bbd261ddc6d1c76edfaf096ddebf6323
[u-boot] / tools / mkimage.c
1 /*
2  * (C) Copyright 2008 Semihalf
3  *
4  * (C) Copyright 2000-2009
5  * DENX Software Engineering
6  * Wolfgang Denk, wd@denx.de
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10
11 #include "mkimage.h"
12 #include <image.h>
13 #include <version.h>
14
15 static void copy_file(int, const char *, int);
16 static void usage(void);
17
18 /* image_type_params link list to maintain registered image type supports */
19 struct image_type_params *mkimage_tparams = NULL;
20
21 /* parameters initialized by core will be used by the image type code */
22 struct mkimage_params params = {
23         .os = IH_OS_LINUX,
24         .arch = IH_ARCH_PPC,
25         .type = IH_TYPE_KERNEL,
26         .comp = IH_COMP_GZIP,
27         .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS,
28         .imagename = "",
29         .imagename2 = "",
30 };
31
32 /*
33  * mkimage_register -
34  *
35  * It is used to register respective image generation/list support to the
36  * mkimage core
37  *
38  * the input struct image_type_params is checked and appended to the link
39  * list, if the input structure is already registered, error
40  */
41 void mkimage_register (struct image_type_params *tparams)
42 {
43         struct image_type_params **tp;
44
45         if (!tparams) {
46                 fprintf (stderr, "%s: %s: Null input\n",
47                         params.cmdname, __FUNCTION__);
48                 exit (EXIT_FAILURE);
49         }
50
51         /* scan the linked list, check for registry and point the last one */
52         for (tp = &mkimage_tparams; *tp != NULL; tp = &(*tp)->next) {
53                 if (!strcmp((*tp)->name, tparams->name)) {
54                         fprintf (stderr, "%s: %s already registered\n",
55                                 params.cmdname, tparams->name);
56                         return;
57                 }
58         }
59
60         /* add input struct entry at the end of link list */
61         *tp = tparams;
62         /* mark input entry as last entry in the link list */
63         tparams->next = NULL;
64
65         debug ("Registered %s\n", tparams->name);
66 }
67
68 /*
69  * mkimage_get_type -
70  *
71  * It scans all registers image type supports
72  * checks the input type_id for each supported image type
73  *
74  * if successful,
75  *      returns respective image_type_params pointer if success
76  * if input type_id is not supported by any of image_type_support
77  *      returns NULL
78  */
79 struct image_type_params *mkimage_get_type(int type)
80 {
81         struct image_type_params *curr;
82
83         for (curr = mkimage_tparams; curr != NULL; curr = curr->next) {
84                 if (curr->check_image_type) {
85                         if (!curr->check_image_type (type))
86                                 return curr;
87                 }
88         }
89         return NULL;
90 }
91
92 /*
93  * mkimage_verify_print_header -
94  *
95  * It scans mkimage_tparams link list,
96  * verifies image_header for each supported image type
97  * if verification is successful, prints respective header
98  *
99  * returns negative if input image format does not match with any of
100  * supported image types
101  */
102 int mkimage_verify_print_header (void *ptr, struct stat *sbuf)
103 {
104         int retval = -1;
105         struct image_type_params *curr;
106
107         for (curr = mkimage_tparams; curr != NULL; curr = curr->next ) {
108                 if (curr->verify_header) {
109                         retval = curr->verify_header (
110                                 (unsigned char *)ptr, sbuf->st_size,
111                                 &params);
112
113                         if (retval == 0) {
114                                 /*
115                                  * Print the image information
116                                  * if verify is successful
117                                  */
118                                 if (curr->print_header)
119                                         curr->print_header (ptr);
120                                 else {
121                                         fprintf (stderr,
122                                         "%s: print_header undefined for %s\n",
123                                         params.cmdname, curr->name);
124                                 }
125                                 break;
126                         }
127                 }
128         }
129         return retval;
130 }
131
132 int
133 main (int argc, char **argv)
134 {
135         int ifd = -1;
136         struct stat sbuf;
137         char *ptr;
138         int retval = 0;
139         struct image_type_params *tparams = NULL;
140         int pad_len = 0;
141
142         /* Init Freescale PBL Boot image generation/list support */
143         init_pbl_image_type();
144         /* Init Kirkwood Boot image generation/list support */
145         init_kwb_image_type ();
146         /* Init Freescale imx Boot image generation/list support */
147         init_imx_image_type ();
148         /* Init Freescale mxs Boot image generation/list support */
149         init_mxs_image_type();
150         /* Init FIT image generation/list support */
151         init_fit_image_type ();
152         /* Init TI OMAP Boot image generation/list support */
153         init_omap_image_type();
154         /* Init Default image generation/list support */
155         init_default_image_type ();
156         /* Init Davinci UBL support */
157         init_ubl_image_type();
158         /* Init Davinci AIS support */
159         init_ais_image_type();
160
161         params.cmdname = *argv;
162         params.addr = params.ep = 0;
163
164         while (--argc > 0 && **++argv == '-') {
165                 while (*++*argv) {
166                         switch (**argv) {
167                         case 'l':
168                                 params.lflag = 1;
169                                 break;
170                         case 'A':
171                                 if ((--argc <= 0) ||
172                                         (params.arch =
173                                         genimg_get_arch_id (*++argv)) < 0)
174                                         usage ();
175                                 goto NXTARG;
176                         case 'c':
177                                 if (--argc <= 0)
178                                         usage();
179                                 params.comment = *++argv;
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                                 params.datafile = *++argv;
239                                 /* no break */
240                         case 'F':
241                                 /*
242                                  * The flattened image tree (FIT) format
243                                  * requires a flattened device tree image type
244                                  */
245                                 params.type = IH_TYPE_FLATDT;
246                                 params.fflag = 1;
247                                 goto NXTARG;
248                         case 'k':
249                                 if (--argc <= 0)
250                                         usage();
251                                 params.keydir = *++argv;
252                                 goto NXTARG;
253                         case 'K':
254                                 if (--argc <= 0)
255                                         usage();
256                                 params.keydest = *++argv;
257                                 goto NXTARG;
258                         case 'n':
259                                 if (--argc <= 0)
260                                         usage ();
261                                 params.imagename = *++argv;
262                                 goto NXTARG;
263                         case 'r':
264                                 params.require_keys = 1;
265                                 break;
266                         case 'R':
267                                 if (--argc <= 0)
268                                         usage();
269                                 /*
270                                  * This entry is for the second configuration
271                                  * file, if only one is not enough.
272                                  */
273                                 params.imagename2 = *++argv;
274                                 goto NXTARG;
275                         case 's':
276                                 params.skipcpy = 1;
277                                 break;
278                         case 'v':
279                                 params.vflag++;
280                                 break;
281                         case 'V':
282                                 printf("mkimage version %s\n", PLAIN_VERSION);
283                                 exit(EXIT_SUCCESS);
284                         case 'x':
285                                 params.xflag++;
286                                 break;
287                         default:
288                                 usage ();
289                         }
290                 }
291 NXTARG:         ;
292         }
293
294         if (argc != 1)
295                 usage ();
296
297         /* set tparams as per input type_id */
298         tparams = mkimage_get_type(params.type);
299         if (tparams == NULL) {
300                 fprintf (stderr, "%s: unsupported type %s\n",
301                         params.cmdname, genimg_get_type_name(params.type));
302                 exit (EXIT_FAILURE);
303         }
304
305         /*
306          * check the passed arguments parameters meets the requirements
307          * as per image type to be generated/listed
308          */
309         if (tparams->check_params)
310                 if (tparams->check_params (&params))
311                         usage ();
312
313         if (!params.eflag) {
314                 params.ep = params.addr;
315                 /* If XIP, entry point must be after the U-Boot header */
316                 if (params.xflag)
317                         params.ep += tparams->header_size;
318         }
319
320         params.imagefile = *argv;
321
322         if (params.fflag){
323                 if (tparams->fflag_handle)
324                         /*
325                          * in some cases, some additional processing needs
326                          * to be done if fflag is defined
327                          *
328                          * For ex. fit_handle_file for Fit file support
329                          */
330                         retval = tparams->fflag_handle(&params);
331
332                 if (retval != EXIT_SUCCESS)
333                         exit (retval);
334         }
335
336         if (params.lflag || params.fflag) {
337                 ifd = open (params.imagefile, O_RDONLY|O_BINARY);
338         } else {
339                 ifd = open (params.imagefile,
340                         O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666);
341         }
342
343         if (ifd < 0) {
344                 fprintf (stderr, "%s: Can't open %s: %s\n",
345                         params.cmdname, params.imagefile,
346                         strerror(errno));
347                 exit (EXIT_FAILURE);
348         }
349
350         if (params.lflag || params.fflag) {
351                 /*
352                  * list header information of existing image
353                  */
354                 if (fstat(ifd, &sbuf) < 0) {
355                         fprintf (stderr, "%s: Can't stat %s: %s\n",
356                                 params.cmdname, params.imagefile,
357                                 strerror(errno));
358                         exit (EXIT_FAILURE);
359                 }
360
361                 if ((unsigned)sbuf.st_size < tparams->header_size) {
362                         fprintf (stderr,
363                                 "%s: Bad size: \"%s\" is not valid image\n",
364                                 params.cmdname, params.imagefile);
365                         exit (EXIT_FAILURE);
366                 }
367
368                 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
369                 if (ptr == MAP_FAILED) {
370                         fprintf (stderr, "%s: Can't read %s: %s\n",
371                                 params.cmdname, params.imagefile,
372                                 strerror(errno));
373                         exit (EXIT_FAILURE);
374                 }
375
376                 /*
377                  * scan through mkimage registry for all supported image types
378                  * and verify the input image file header for match
379                  * Print the image information for matched image type
380                  * Returns the error code if not matched
381                  */
382                 retval = mkimage_verify_print_header (ptr, &sbuf);
383
384                 (void) munmap((void *)ptr, sbuf.st_size);
385                 (void) close (ifd);
386
387                 exit (retval);
388         }
389
390         /*
391          * In case there an header with a variable
392          * length will be added, the corresponding
393          * function is called. This is responsible to
394          * allocate memory for the header itself.
395          */
396         if (tparams->vrec_header)
397                 pad_len = tparams->vrec_header(&params, tparams);
398         else
399                 memset(tparams->hdr, 0, tparams->header_size);
400
401         if (write(ifd, tparams->hdr, tparams->header_size)
402                                         != tparams->header_size) {
403                 fprintf (stderr, "%s: Write error on %s: %s\n",
404                         params.cmdname, params.imagefile, strerror(errno));
405                 exit (EXIT_FAILURE);
406         }
407
408         if (!params.skipcpy) {
409                 if (params.type == IH_TYPE_MULTI ||
410                     params.type == IH_TYPE_SCRIPT) {
411                         char *file = params.datafile;
412                         uint32_t size;
413
414                         for (;;) {
415                                 char *sep = NULL;
416
417                                 if (file) {
418                                         if ((sep = strchr(file, ':')) != NULL) {
419                                                 *sep = '\0';
420                                         }
421
422                                         if (stat (file, &sbuf) < 0) {
423                                                 fprintf (stderr, "%s: Can't stat %s: %s\n",
424                                                          params.cmdname, file, strerror(errno));
425                                                 exit (EXIT_FAILURE);
426                                         }
427                                         size = cpu_to_uimage (sbuf.st_size);
428                                 } else {
429                                         size = 0;
430                                 }
431
432                                 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) {
433                                         fprintf (stderr, "%s: Write error on %s: %s\n",
434                                                  params.cmdname, params.imagefile,
435                                                  strerror(errno));
436                                         exit (EXIT_FAILURE);
437                                 }
438
439                                 if (!file) {
440                                         break;
441                                 }
442
443                                 if (sep) {
444                                         *sep = ':';
445                                         file = sep + 1;
446                                 } else {
447                                         file = NULL;
448                                 }
449                         }
450
451                         file = params.datafile;
452
453                         for (;;) {
454                                 char *sep = strchr(file, ':');
455                                 if (sep) {
456                                         *sep = '\0';
457                                         copy_file (ifd, file, 1);
458                                         *sep++ = ':';
459                                         file = sep;
460                                 } else {
461                                         copy_file (ifd, file, 0);
462                                         break;
463                                 }
464                         }
465                 } else if (params.type == IH_TYPE_PBLIMAGE) {
466                         /* PBL has special Image format, implements its' own */
467                         pbl_load_uboot(ifd, &params);
468                 } else {
469                         copy_file(ifd, params.datafile, pad_len);
470                 }
471         }
472
473         /* We're a bit of paranoid */
474 #if defined(_POSIX_SYNCHRONIZED_IO) && \
475    !defined(__sun__) && \
476    !defined(__FreeBSD__) && \
477    !defined(__APPLE__)
478         (void) fdatasync (ifd);
479 #else
480         (void) fsync (ifd);
481 #endif
482
483         if (fstat(ifd, &sbuf) < 0) {
484                 fprintf (stderr, "%s: Can't stat %s: %s\n",
485                         params.cmdname, params.imagefile, strerror(errno));
486                 exit (EXIT_FAILURE);
487         }
488
489         ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0);
490         if (ptr == MAP_FAILED) {
491                 fprintf (stderr, "%s: Can't map %s: %s\n",
492                         params.cmdname, params.imagefile, strerror(errno));
493                 exit (EXIT_FAILURE);
494         }
495
496         /* Setup the image header as per input image type*/
497         if (tparams->set_header)
498                 tparams->set_header (ptr, &sbuf, ifd, &params);
499         else {
500                 fprintf (stderr, "%s: Can't set header for %s: %s\n",
501                         params.cmdname, tparams->name, strerror(errno));
502                 exit (EXIT_FAILURE);
503         }
504
505         /* Print the image information by processing image header */
506         if (tparams->print_header)
507                 tparams->print_header (ptr);
508         else {
509                 fprintf (stderr, "%s: Can't print header for %s: %s\n",
510                         params.cmdname, tparams->name, strerror(errno));
511                 exit (EXIT_FAILURE);
512         }
513
514         (void) munmap((void *)ptr, sbuf.st_size);
515
516         /* We're a bit of paranoid */
517 #if defined(_POSIX_SYNCHRONIZED_IO) && \
518    !defined(__sun__) && \
519    !defined(__FreeBSD__) && \
520    !defined(__APPLE__)
521         (void) fdatasync (ifd);
522 #else
523         (void) fsync (ifd);
524 #endif
525
526         if (close(ifd)) {
527                 fprintf (stderr, "%s: Write error on %s: %s\n",
528                         params.cmdname, params.imagefile, strerror(errno));
529                 exit (EXIT_FAILURE);
530         }
531
532         exit (EXIT_SUCCESS);
533 }
534
535 static void
536 copy_file (int ifd, const char *datafile, int pad)
537 {
538         int dfd;
539         struct stat sbuf;
540         unsigned char *ptr;
541         int tail;
542         int zero = 0;
543         uint8_t zeros[4096];
544         int offset = 0;
545         int size;
546         struct image_type_params *tparams = mkimage_get_type (params.type);
547
548         if (pad >= sizeof(zeros)) {
549                 fprintf(stderr, "%s: Can't pad to %d\n",
550                         params.cmdname, pad);
551                 exit(EXIT_FAILURE);
552         }
553
554         memset(zeros, 0, sizeof(zeros));
555
556         if (params.vflag) {
557                 fprintf (stderr, "Adding Image %s\n", datafile);
558         }
559
560         if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
561                 fprintf (stderr, "%s: Can't open %s: %s\n",
562                         params.cmdname, datafile, strerror(errno));
563                 exit (EXIT_FAILURE);
564         }
565
566         if (fstat(dfd, &sbuf) < 0) {
567                 fprintf (stderr, "%s: Can't stat %s: %s\n",
568                         params.cmdname, datafile, strerror(errno));
569                 exit (EXIT_FAILURE);
570         }
571
572         ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
573         if (ptr == MAP_FAILED) {
574                 fprintf (stderr, "%s: Can't read %s: %s\n",
575                         params.cmdname, datafile, strerror(errno));
576                 exit (EXIT_FAILURE);
577         }
578
579         if (params.xflag) {
580                 unsigned char *p = NULL;
581                 /*
582                  * XIP: do not append the image_header_t at the
583                  * beginning of the file, but consume the space
584                  * reserved for it.
585                  */
586
587                 if ((unsigned)sbuf.st_size < tparams->header_size) {
588                         fprintf (stderr,
589                                 "%s: Bad size: \"%s\" is too small for XIP\n",
590                                 params.cmdname, datafile);
591                         exit (EXIT_FAILURE);
592                 }
593
594                 for (p = ptr; p < ptr + tparams->header_size; p++) {
595                         if ( *p != 0xff ) {
596                                 fprintf (stderr,
597                                         "%s: Bad file: \"%s\" has invalid buffer for XIP\n",
598                                         params.cmdname, datafile);
599                                 exit (EXIT_FAILURE);
600                         }
601                 }
602
603                 offset = tparams->header_size;
604         }
605
606         size = sbuf.st_size - offset;
607         if (write(ifd, ptr + offset, size) != size) {
608                 fprintf (stderr, "%s: Write error on %s: %s\n",
609                         params.cmdname, params.imagefile, strerror(errno));
610                 exit (EXIT_FAILURE);
611         }
612
613         tail = size % 4;
614         if ((pad == 1) && (tail != 0)) {
615
616                 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) {
617                         fprintf (stderr, "%s: Write error on %s: %s\n",
618                                 params.cmdname, params.imagefile,
619                                 strerror(errno));
620                         exit (EXIT_FAILURE);
621                 }
622         } else if (pad > 1) {
623                 if (write(ifd, (char *)&zeros, pad) != pad) {
624                         fprintf(stderr, "%s: Write error on %s: %s\n",
625                                 params.cmdname, params.imagefile,
626                                 strerror(errno));
627                         exit(EXIT_FAILURE);
628                 }
629         }
630
631         (void) munmap((void *)ptr, sbuf.st_size);
632         (void) close (dfd);
633 }
634
635 static void usage(void)
636 {
637         fprintf (stderr, "Usage: %s -l image\n"
638                          "          -l ==> list image header information\n",
639                 params.cmdname);
640         fprintf (stderr, "       %s [-x] -A arch -O os -T type -C comp "
641                          "-a addr -e ep -n name -d data_file[:data_file...] image\n"
642                          "          -A ==> set architecture to 'arch'\n"
643                          "          -O ==> set operating system to 'os'\n"
644                          "          -T ==> set image type to 'type'\n"
645                          "          -C ==> set compression type 'comp'\n"
646                          "          -a ==> set load address to 'addr' (hex)\n"
647                          "          -e ==> set entry point to 'ep' (hex)\n"
648                          "          -n ==> set image name to 'name'\n"
649                          "          -d ==> use image data from 'datafile'\n"
650                          "          -x ==> set XIP (execute in place)\n",
651                 params.cmdname);
652         fprintf(stderr, "       %s [-D dtc_options] [-f fit-image.its|-F] fit-image\n",
653                 params.cmdname);
654         fprintf(stderr, "          -D => set options for device tree compiler\n"
655                         "          -f => input filename for FIT source\n");
656 #ifdef CONFIG_FIT_SIGNATURE
657         fprintf(stderr, "Signing / verified boot options: [-k keydir] [-K dtb] [ -c <comment>] [-r]\n"
658                         "          -k => set directory containing private keys\n"
659                         "          -K => write public keys to this .dtb file\n"
660                         "          -c => add comment in signature node\n"
661                         "          -F => re-sign existing FIT image\n"
662                         "          -r => mark keys used as 'required' in dtb\n");
663 #else
664         fprintf(stderr, "Signing / verified boot not supported (CONFIG_FIT_SIGNATURE undefined)\n");
665 #endif
666         fprintf (stderr, "       %s -V ==> print version information and exit\n",
667                 params.cmdname);
668
669         exit (EXIT_FAILURE);
670 }