Merge branch 'master' of http://git.denx.de/u-boot-sunxi
[platform/kernel/u-boot.git] / 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
17 /* parameters initialized by core will be used by the image type code */
18 static struct image_tool_params params = {
19         .os = IH_OS_LINUX,
20         .arch = IH_ARCH_PPC,
21         .type = IH_TYPE_KERNEL,
22         .comp = IH_COMP_GZIP,
23         .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS,
24         .imagename = "",
25         .imagename2 = "",
26 };
27
28 static enum ih_category cur_category;
29
30 static int h_compare_category_name(const void *vtype1, const void *vtype2)
31 {
32         const int *type1 = vtype1;
33         const int *type2 = vtype2;
34         const char *name1 = genimg_get_cat_short_name(cur_category, *type1);
35         const char *name2 = genimg_get_cat_short_name(cur_category, *type2);
36
37         return strcmp(name1, name2);
38 }
39
40 static int show_valid_options(enum ih_category category)
41 {
42         int *order;
43         int count;
44         int item;
45         int i;
46
47         count = genimg_get_cat_count(category);
48         order = calloc(count, sizeof(*order));
49         if (!order)
50                 return -ENOMEM;
51
52         /* Sort the names in order of short name for easier reading */
53         for (item = 0; item < count; item++)
54                 order[item] = item;
55         cur_category = category;
56         qsort(order, count, sizeof(int), h_compare_category_name);
57
58         fprintf(stderr, "\nInvalid %s, supported are:\n",
59                 genimg_get_cat_desc(category));
60         for (i = 0; i < count; i++) {
61                 item = order[i];
62                 fprintf(stderr, "\t%-15s  %s\n",
63                         genimg_get_cat_short_name(category, item),
64                         genimg_get_cat_name(category, item));
65         }
66         fprintf(stderr, "\n");
67
68         return 0;
69 }
70
71 static void usage(const char *msg)
72 {
73         fprintf(stderr, "Error: %s\n", msg);
74         fprintf(stderr, "Usage: %s -l image\n"
75                          "          -l ==> list image header information\n",
76                 params.cmdname);
77         fprintf(stderr,
78                 "       %s [-x] -A arch -O os -T type -C comp -a addr -e ep -n name -d data_file[:data_file...] image\n"
79                 "          -A ==> set architecture to 'arch'\n"
80                 "          -O ==> set operating system to 'os'\n"
81                 "          -T ==> set image type to 'type'\n"
82                 "          -C ==> set compression type 'comp'\n"
83                 "          -a ==> set load address to 'addr' (hex)\n"
84                 "          -e ==> set entry point to 'ep' (hex)\n"
85                 "          -n ==> set image name to 'name'\n"
86                 "          -d ==> use image data from 'datafile'\n"
87                 "          -x ==> set XIP (execute in place)\n",
88                 params.cmdname);
89         fprintf(stderr,
90                 "       %s [-D dtc_options] [-f fit-image.its|-f auto|-F] [-b <dtb> [-b <dtb>]] fit-image\n"
91                 "           <dtb> file is used with -f auto, it may occour multiple times.\n",
92                 params.cmdname);
93         fprintf(stderr,
94                 "          -D => set all options for device tree compiler\n"
95                 "          -f => input filename for FIT source\n");
96 #ifdef CONFIG_FIT_SIGNATURE
97         fprintf(stderr,
98                 "Signing / verified boot options: [-E] [-k keydir] [-K dtb] [ -c <comment>] [-p addr] [-r]\n"
99                 "          -E => place data outside of the FIT structure\n"
100                 "          -k => set directory containing private keys\n"
101                 "          -K => write public keys to this .dtb file\n"
102                 "          -c => add comment in signature node\n"
103                 "          -F => re-sign existing FIT image\n"
104                 "          -p => place external data at a static position\n"
105                 "          -r => mark keys used as 'required' in dtb\n");
106 #else
107         fprintf(stderr,
108                 "Signing / verified boot not supported (CONFIG_FIT_SIGNATURE undefined)\n");
109 #endif
110         fprintf(stderr, "       %s -V ==> print version information and exit\n",
111                 params.cmdname);
112         fprintf(stderr, "Use -T to see a list of available image types\n");
113
114         exit(EXIT_FAILURE);
115 }
116
117 static int add_content(int type, const char *fname)
118 {
119         struct content_info *cont;
120
121         cont = calloc(1, sizeof(*cont));
122         if (!cont)
123                 return -1;
124         cont->type = type;
125         cont->fname = fname;
126         if (params.content_tail)
127                 params.content_tail->next = cont;
128         else
129                 params.content_head = cont;
130         params.content_tail = cont;
131
132         return 0;
133 }
134
135 static void process_args(int argc, char **argv)
136 {
137         char *ptr;
138         int type = IH_TYPE_INVALID;
139         char *datafile = NULL;
140         int opt;
141
142         while ((opt = getopt(argc, argv,
143                              "a:A:b:cC:d:D:e:Ef:Fk:K:ln:p:O:rR:qsT:vVx")) != -1) {
144                 switch (opt) {
145                 case 'a':
146                         params.addr = strtoull(optarg, &ptr, 16);
147                         if (*ptr) {
148                                 fprintf(stderr, "%s: invalid load address %s\n",
149                                         params.cmdname, optarg);
150                                 exit(EXIT_FAILURE);
151                         }
152                         break;
153                 case 'A':
154                         params.arch = genimg_get_arch_id(optarg);
155                         if (params.arch < 0) {
156                                 show_valid_options(IH_ARCH);
157                                 usage("Invalid architecture");
158                         }
159                         break;
160                 case 'b':
161                         if (add_content(IH_TYPE_FLATDT, optarg)) {
162                                 fprintf(stderr,
163                                         "%s: Out of memory adding content '%s'",
164                                         params.cmdname, optarg);
165                                 exit(EXIT_FAILURE);
166                         }
167                         break;
168                 case 'c':
169                         params.comment = optarg;
170                         break;
171                 case 'C':
172                         params.comp = genimg_get_comp_id(optarg);
173                         if (params.comp < 0) {
174                                 show_valid_options(IH_COMP);
175                                 usage("Invalid compression type");
176                         }
177                         break;
178                 case 'd':
179                         params.datafile = optarg;
180                         params.dflag = 1;
181                         break;
182                 case 'D':
183                         params.dtc = optarg;
184                         break;
185                 case 'e':
186                         params.ep = strtoull(optarg, &ptr, 16);
187                         if (*ptr) {
188                                 fprintf(stderr, "%s: invalid entry point %s\n",
189                                         params.cmdname, optarg);
190                                 exit(EXIT_FAILURE);
191                         }
192                         params.eflag = 1;
193                         break;
194                 case 'E':
195                         params.external_data = true;
196                         break;
197                 case 'f':
198                         datafile = optarg;
199                         params.auto_its = !strcmp(datafile, "auto");
200                         /* no break */
201                 case 'F':
202                         /*
203                          * The flattened image tree (FIT) format
204                          * requires a flattened device tree image type
205                          */
206                         params.type = IH_TYPE_FLATDT;
207                         params.fflag = 1;
208                         break;
209                 case 'k':
210                         params.keydir = optarg;
211                         break;
212                 case 'K':
213                         params.keydest = optarg;
214                         break;
215                 case 'l':
216                         params.lflag = 1;
217                         break;
218                 case 'n':
219                         params.imagename = optarg;
220                         break;
221                 case 'O':
222                         params.os = genimg_get_os_id(optarg);
223                         if (params.os < 0) {
224                                 show_valid_options(IH_OS);
225                                 usage("Invalid operating system");
226                         }
227                         break;
228                 case 'p':
229                         params.external_offset = strtoull(optarg, &ptr, 16);
230                         if (*ptr) {
231                                 fprintf(stderr, "%s: invalid offset size %s\n",
232                                         params.cmdname, optarg);
233                                 exit(EXIT_FAILURE);
234                         }
235                         break;
236                 case 'q':
237                         params.quiet = 1;
238                         break;
239                 case 'r':
240                         params.require_keys = 1;
241                         break;
242                 case 'R':
243                         /*
244                          * This entry is for the second configuration
245                          * file, if only one is not enough.
246                          */
247                         params.imagename2 = optarg;
248                         break;
249                 case 's':
250                         params.skipcpy = 1;
251                         break;
252                 case 'T':
253                         type = genimg_get_type_id(optarg);
254                         if (type < 0) {
255                                 show_valid_options(IH_TYPE);
256                                 usage("Invalid image type");
257                         }
258                         break;
259                 case 'v':
260                         params.vflag++;
261                         break;
262                 case 'V':
263                         printf("mkimage version %s\n", PLAIN_VERSION);
264                         exit(EXIT_SUCCESS);
265                 case 'x':
266                         params.xflag++;
267                         break;
268                 default:
269                         usage("Invalid option");
270                 }
271         }
272
273         /* The last parameter is expected to be the imagefile */
274         if (optind < argc)
275                 params.imagefile = argv[optind];
276
277         /*
278          * For auto-generated FIT images we need to know the image type to put
279          * in the FIT, which is separate from the file's image type (which
280          * will always be IH_TYPE_FLATDT in this case).
281          */
282         if (params.type == IH_TYPE_FLATDT) {
283                 params.fit_image_type = type ? type : IH_TYPE_KERNEL;
284                 /* For auto_its, datafile is always 'auto' */
285                 if (!params.auto_its)
286                         params.datafile = datafile;
287                 else if (!params.datafile)
288                         usage("Missing data file for auto-FIT (use -d)");
289         } else if (type != IH_TYPE_INVALID) {
290                 params.type = type;
291         }
292
293         if (!params.imagefile)
294                 usage("Missing output filename");
295 }
296
297 int main(int argc, char **argv)
298 {
299         int ifd = -1;
300         struct stat sbuf;
301         char *ptr;
302         int retval = 0;
303         struct image_type_params *tparams = NULL;
304         int pad_len = 0;
305         int dfd;
306
307         params.cmdname = *argv;
308         params.addr = 0;
309         params.ep = 0;
310
311         process_args(argc, argv);
312
313         /* set tparams as per input type_id */
314         tparams = imagetool_get_type(params.type);
315         if (tparams == NULL) {
316                 fprintf (stderr, "%s: unsupported type %s\n",
317                         params.cmdname, genimg_get_type_name(params.type));
318                 exit (EXIT_FAILURE);
319         }
320
321         /*
322          * check the passed arguments parameters meets the requirements
323          * as per image type to be generated/listed
324          */
325         if (tparams->check_params)
326                 if (tparams->check_params (&params))
327                         usage("Bad parameters for image type");
328
329         if (!params.eflag) {
330                 params.ep = params.addr;
331                 /* If XIP, entry point must be after the U-Boot header */
332                 if (params.xflag)
333                         params.ep += tparams->header_size;
334         }
335
336         if (params.fflag){
337                 if (tparams->fflag_handle)
338                         /*
339                          * in some cases, some additional processing needs
340                          * to be done if fflag is defined
341                          *
342                          * For ex. fit_handle_file for Fit file support
343                          */
344                         retval = tparams->fflag_handle(&params);
345
346                 if (retval != EXIT_SUCCESS)
347                         exit (retval);
348         }
349
350         if (params.lflag || params.fflag) {
351                 ifd = open (params.imagefile, O_RDONLY|O_BINARY);
352         } else {
353                 ifd = open (params.imagefile,
354                         O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666);
355         }
356
357         if (ifd < 0) {
358                 fprintf (stderr, "%s: Can't open %s: %s\n",
359                         params.cmdname, params.imagefile,
360                         strerror(errno));
361                 exit (EXIT_FAILURE);
362         }
363
364         if (params.lflag || params.fflag) {
365                 /*
366                  * list header information of existing image
367                  */
368                 if (fstat(ifd, &sbuf) < 0) {
369                         fprintf (stderr, "%s: Can't stat %s: %s\n",
370                                 params.cmdname, params.imagefile,
371                                 strerror(errno));
372                         exit (EXIT_FAILURE);
373                 }
374
375                 if ((unsigned)sbuf.st_size < tparams->header_size) {
376                         fprintf (stderr,
377                                 "%s: Bad size: \"%s\" is not valid image\n",
378                                 params.cmdname, params.imagefile);
379                         exit (EXIT_FAILURE);
380                 }
381
382                 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
383                 if (ptr == MAP_FAILED) {
384                         fprintf (stderr, "%s: Can't read %s: %s\n",
385                                 params.cmdname, params.imagefile,
386                                 strerror(errno));
387                         exit (EXIT_FAILURE);
388                 }
389
390                 /*
391                  * scan through mkimage registry for all supported image types
392                  * and verify the input image file header for match
393                  * Print the image information for matched image type
394                  * Returns the error code if not matched
395                  */
396                 retval = imagetool_verify_print_header(ptr, &sbuf,
397                                 tparams, &params);
398
399                 (void) munmap((void *)ptr, sbuf.st_size);
400                 (void) close (ifd);
401
402                 exit (retval);
403         }
404
405         if ((params.type != IH_TYPE_MULTI) && (params.type != IH_TYPE_SCRIPT)) {
406                 dfd = open(params.datafile, O_RDONLY | O_BINARY);
407                 if (dfd < 0) {
408                         fprintf(stderr, "%s: Can't open %s: %s\n",
409                                 params.cmdname, params.datafile,
410                                 strerror(errno));
411                         exit(EXIT_FAILURE);
412                 }
413
414                 if (fstat(dfd, &sbuf) < 0) {
415                         fprintf(stderr, "%s: Can't stat %s: %s\n",
416                                 params.cmdname, params.datafile,
417                                 strerror(errno));
418                         exit(EXIT_FAILURE);
419                 }
420
421                 params.file_size = sbuf.st_size + tparams->header_size;
422                 close(dfd);
423         }
424
425         /*
426          * In case there an header with a variable
427          * length will be added, the corresponding
428          * function is called. This is responsible to
429          * allocate memory for the header itself.
430          */
431         if (tparams->vrec_header)
432                 pad_len = tparams->vrec_header(&params, tparams);
433         else
434                 memset(tparams->hdr, 0, tparams->header_size);
435
436         if (write(ifd, tparams->hdr, tparams->header_size)
437                                         != tparams->header_size) {
438                 fprintf (stderr, "%s: Write error on %s: %s\n",
439                         params.cmdname, params.imagefile, strerror(errno));
440                 exit (EXIT_FAILURE);
441         }
442
443         if (!params.skipcpy) {
444                 if (params.type == IH_TYPE_MULTI ||
445                     params.type == IH_TYPE_SCRIPT) {
446                         char *file = params.datafile;
447                         uint32_t size;
448
449                         for (;;) {
450                                 char *sep = NULL;
451
452                                 if (file) {
453                                         if ((sep = strchr(file, ':')) != NULL) {
454                                                 *sep = '\0';
455                                         }
456
457                                         if (stat (file, &sbuf) < 0) {
458                                                 fprintf (stderr, "%s: Can't stat %s: %s\n",
459                                                          params.cmdname, file, strerror(errno));
460                                                 exit (EXIT_FAILURE);
461                                         }
462                                         size = cpu_to_uimage (sbuf.st_size);
463                                 } else {
464                                         size = 0;
465                                 }
466
467                                 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) {
468                                         fprintf (stderr, "%s: Write error on %s: %s\n",
469                                                  params.cmdname, params.imagefile,
470                                                  strerror(errno));
471                                         exit (EXIT_FAILURE);
472                                 }
473
474                                 if (!file) {
475                                         break;
476                                 }
477
478                                 if (sep) {
479                                         *sep = ':';
480                                         file = sep + 1;
481                                 } else {
482                                         file = NULL;
483                                 }
484                         }
485
486                         file = params.datafile;
487
488                         for (;;) {
489                                 char *sep = strchr(file, ':');
490                                 if (sep) {
491                                         *sep = '\0';
492                                         copy_file (ifd, file, 1);
493                                         *sep++ = ':';
494                                         file = sep;
495                                 } else {
496                                         copy_file (ifd, file, 0);
497                                         break;
498                                 }
499                         }
500                 } else if (params.type == IH_TYPE_PBLIMAGE) {
501                         /* PBL has special Image format, implements its' own */
502                         pbl_load_uboot(ifd, &params);
503                 } else {
504                         copy_file(ifd, params.datafile, pad_len);
505                 }
506         }
507
508         /* We're a bit of paranoid */
509 #if defined(_POSIX_SYNCHRONIZED_IO) && \
510    !defined(__sun__) && \
511    !defined(__FreeBSD__) && \
512    !defined(__OpenBSD__) && \
513    !defined(__APPLE__)
514         (void) fdatasync (ifd);
515 #else
516         (void) fsync (ifd);
517 #endif
518
519         if (fstat(ifd, &sbuf) < 0) {
520                 fprintf (stderr, "%s: Can't stat %s: %s\n",
521                         params.cmdname, params.imagefile, strerror(errno));
522                 exit (EXIT_FAILURE);
523         }
524         params.file_size = sbuf.st_size;
525
526         ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0);
527         if (ptr == MAP_FAILED) {
528                 fprintf (stderr, "%s: Can't map %s: %s\n",
529                         params.cmdname, params.imagefile, strerror(errno));
530                 exit (EXIT_FAILURE);
531         }
532
533         /* Setup the image header as per input image type*/
534         if (tparams->set_header)
535                 tparams->set_header (ptr, &sbuf, ifd, &params);
536         else {
537                 fprintf (stderr, "%s: Can't set header for %s: %s\n",
538                         params.cmdname, tparams->name, strerror(errno));
539                 exit (EXIT_FAILURE);
540         }
541
542         /* Print the image information by processing image header */
543         if (tparams->print_header)
544                 tparams->print_header (ptr);
545         else {
546                 fprintf (stderr, "%s: Can't print header for %s: %s\n",
547                         params.cmdname, tparams->name, strerror(errno));
548                 exit (EXIT_FAILURE);
549         }
550
551         (void) munmap((void *)ptr, sbuf.st_size);
552
553         /* We're a bit of paranoid */
554 #if defined(_POSIX_SYNCHRONIZED_IO) && \
555    !defined(__sun__) && \
556    !defined(__FreeBSD__) && \
557    !defined(__OpenBSD__) && \
558    !defined(__APPLE__)
559         (void) fdatasync (ifd);
560 #else
561         (void) fsync (ifd);
562 #endif
563
564         if (close(ifd)) {
565                 fprintf (stderr, "%s: Write error on %s: %s\n",
566                         params.cmdname, params.imagefile, strerror(errno));
567                 exit (EXIT_FAILURE);
568         }
569
570         exit (EXIT_SUCCESS);
571 }
572
573 static void
574 copy_file (int ifd, const char *datafile, int pad)
575 {
576         int dfd;
577         struct stat sbuf;
578         unsigned char *ptr;
579         int tail;
580         int zero = 0;
581         uint8_t zeros[4096];
582         int offset = 0;
583         int size;
584         struct image_type_params *tparams = imagetool_get_type(params.type);
585
586         memset(zeros, 0, sizeof(zeros));
587
588         if (params.vflag) {
589                 fprintf (stderr, "Adding Image %s\n", datafile);
590         }
591
592         if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
593                 fprintf (stderr, "%s: Can't open %s: %s\n",
594                         params.cmdname, datafile, strerror(errno));
595                 exit (EXIT_FAILURE);
596         }
597
598         if (fstat(dfd, &sbuf) < 0) {
599                 fprintf (stderr, "%s: Can't stat %s: %s\n",
600                         params.cmdname, datafile, strerror(errno));
601                 exit (EXIT_FAILURE);
602         }
603
604         ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
605         if (ptr == MAP_FAILED) {
606                 fprintf (stderr, "%s: Can't read %s: %s\n",
607                         params.cmdname, datafile, strerror(errno));
608                 exit (EXIT_FAILURE);
609         }
610
611         if (params.xflag) {
612                 unsigned char *p = NULL;
613                 /*
614                  * XIP: do not append the image_header_t at the
615                  * beginning of the file, but consume the space
616                  * reserved for it.
617                  */
618
619                 if ((unsigned)sbuf.st_size < tparams->header_size) {
620                         fprintf (stderr,
621                                 "%s: Bad size: \"%s\" is too small for XIP\n",
622                                 params.cmdname, datafile);
623                         exit (EXIT_FAILURE);
624                 }
625
626                 for (p = ptr; p < ptr + tparams->header_size; p++) {
627                         if ( *p != 0xff ) {
628                                 fprintf (stderr,
629                                         "%s: Bad file: \"%s\" has invalid buffer for XIP\n",
630                                         params.cmdname, datafile);
631                                 exit (EXIT_FAILURE);
632                         }
633                 }
634
635                 offset = tparams->header_size;
636         }
637
638         size = sbuf.st_size - offset;
639         if (write(ifd, ptr + offset, size) != size) {
640                 fprintf (stderr, "%s: Write error on %s: %s\n",
641                         params.cmdname, params.imagefile, strerror(errno));
642                 exit (EXIT_FAILURE);
643         }
644
645         tail = size % 4;
646         if ((pad == 1) && (tail != 0)) {
647
648                 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) {
649                         fprintf (stderr, "%s: Write error on %s: %s\n",
650                                 params.cmdname, params.imagefile,
651                                 strerror(errno));
652                         exit (EXIT_FAILURE);
653                 }
654         } else if (pad > 1) {
655                 while (pad > 0) {
656                         int todo = sizeof(zeros);
657
658                         if (todo > pad)
659                                 todo = pad;
660                         if (write(ifd, (char *)&zeros, todo) != todo) {
661                                 fprintf(stderr, "%s: Write error on %s: %s\n",
662                                         params.cmdname, params.imagefile,
663                                         strerror(errno));
664                                 exit(EXIT_FAILURE);
665                         }
666                         pad -= todo;
667                 }
668         }
669
670         (void) munmap((void *)ptr, sbuf.st_size);
671         (void) close (dfd);
672 }