blob: d982bc5665f1749c393e689d58122f3c513108ce [file] [log] [blame]
wdenk5b1d7132002-11-03 00:07:02 +00001/*
Bartlomiej Sieka9d254382008-03-11 12:34:47 +01002 * (C) Copyright 2008 Semihalf
3 *
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +05304 * (C) Copyright 2000-2009
wdenk5b1d7132002-11-03 00:07:02 +00005 * DENX Software Engineering
6 * Wolfgang Denk, wd@denx.de
wdenk0c852a22004-02-26 23:01:04 +00007 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02008 * SPDX-License-Identifier: GPL-2.0+
wdenk5b1d7132002-11-03 00:07:02 +00009 */
10
Marian Balakowiczb97a2a02008-01-08 18:14:09 +010011#include "mkimage.h"
Sven Ebenfeldd21bd692016-11-06 16:37:56 +010012#include "imximage.h"
wdenk5b1d7132002-11-03 00:07:02 +000013#include <image.h>
Wolfgang Denk976b38c2011-02-12 10:37:11 +010014#include <version.h>
wdenk5b1d7132002-11-03 00:07:02 +000015
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053016static void copy_file(int, const char *, int);
wdenk5b1d7132002-11-03 00:07:02 +000017
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053018/* parameters initialized by core will be used by the image type code */
Simon Glasscc7a6442016-02-22 22:55:38 -070019static struct image_tool_params params = {
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053020 .os = IH_OS_LINUX,
21 .arch = IH_ARCH_PPC,
22 .type = IH_TYPE_KERNEL,
23 .comp = IH_COMP_GZIP,
24 .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS,
Wolfgang Denk04387d22010-03-27 23:37:46 +010025 .imagename = "",
Shaohui Xie5d898a02012-08-10 02:49:35 +000026 .imagename2 = "",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +053027};
wdenk5b1d7132002-11-03 00:07:02 +000028
Simon Glass30664222016-06-30 10:52:17 -060029static enum ih_category cur_category;
30
31static int h_compare_category_name(const void *vtype1, const void *vtype2)
32{
33 const int *type1 = vtype1;
34 const int *type2 = vtype2;
35 const char *name1 = genimg_get_cat_short_name(cur_category, *type1);
36 const char *name2 = genimg_get_cat_short_name(cur_category, *type2);
37
38 return strcmp(name1, name2);
39}
40
Simon Glassf24e1052016-06-30 10:52:18 -060041static int show_valid_options(enum ih_category category)
Simon Glass30664222016-06-30 10:52:17 -060042{
43 int *order;
44 int count;
45 int item;
46 int i;
47
48 count = genimg_get_cat_count(category);
49 order = calloc(count, sizeof(*order));
50 if (!order)
51 return -ENOMEM;
52
53 /* Sort the names in order of short name for easier reading */
54 for (item = 0; item < count; item++)
55 order[item] = item;
56 cur_category = category;
57 qsort(order, count, sizeof(int), h_compare_category_name);
58
59 fprintf(stderr, "\nInvalid %s, supported are:\n",
60 genimg_get_cat_desc(category));
61 for (i = 0; i < count; i++) {
62 item = order[i];
63 fprintf(stderr, "\t%-15s %s\n",
64 genimg_get_cat_short_name(category, item),
65 genimg_get_cat_name(category, item));
66 }
67 fprintf(stderr, "\n");
Simon Glass0cd82e22016-10-27 17:54:03 -060068 free(order);
Simon Glass30664222016-06-30 10:52:17 -060069
70 return 0;
71}
72
Simon Glass15310342016-02-22 22:55:37 -070073static void usage(const char *msg)
Simon Glassb0a487a2016-02-22 22:55:36 -070074{
Simon Glass15310342016-02-22 22:55:37 -070075 fprintf(stderr, "Error: %s\n", msg);
Simon Glassb0a487a2016-02-22 22:55:36 -070076 fprintf(stderr, "Usage: %s -l image\n"
77 " -l ==> list image header information\n",
78 params.cmdname);
79 fprintf(stderr,
80 " %s [-x] -A arch -O os -T type -C comp -a addr -e ep -n name -d data_file[:data_file...] image\n"
81 " -A ==> set architecture to 'arch'\n"
82 " -O ==> set operating system to 'os'\n"
83 " -T ==> set image type to 'type'\n"
84 " -C ==> set compression type 'comp'\n"
85 " -a ==> set load address to 'addr' (hex)\n"
86 " -e ==> set entry point to 'ep' (hex)\n"
87 " -n ==> set image name to 'name'\n"
88 " -d ==> use image data from 'datafile'\n"
89 " -x ==> set XIP (execute in place)\n",
90 params.cmdname);
91 fprintf(stderr,
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +010092 " %s [-D dtc_options] [-f fit-image.its|-f auto|-F] [-b <dtb> [-b <dtb>]] [-i <ramdisk.cpio.gz>] fit-image\n"
Vagrant Cascadian82bd2f22016-10-23 20:45:17 -070093 " <dtb> file is used with -f auto, it may occur multiple times.\n",
Simon Glassb0a487a2016-02-22 22:55:36 -070094 params.cmdname);
95 fprintf(stderr,
96 " -D => set all options for device tree compiler\n"
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +010097 " -f => input filename for FIT source\n"
98 " -i => input filename for ramdisk file\n");
Simon Glassb0a487a2016-02-22 22:55:36 -070099#ifdef CONFIG_FIT_SIGNATURE
100 fprintf(stderr,
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600101 "Signing / verified boot options: [-E] [-k keydir] [-K dtb] [ -c <comment>] [-p addr] [-r] [-N engine]\n"
Teddy Reedf8f91072016-06-09 19:38:02 -0700102 " -E => place data outside of the FIT structure\n"
Simon Glassb0a487a2016-02-22 22:55:36 -0700103 " -k => set directory containing private keys\n"
104 " -K => write public keys to this .dtb file\n"
105 " -c => add comment in signature node\n"
106 " -F => re-sign existing FIT image\n"
Teddy Reedf8f91072016-06-09 19:38:02 -0700107 " -p => place external data at a static position\n"
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600108 " -r => mark keys used as 'required' in dtb\n"
109 " -N => engine to use for signing (pkcs11)\n");
Simon Glassb0a487a2016-02-22 22:55:36 -0700110#else
111 fprintf(stderr,
112 "Signing / verified boot not supported (CONFIG_FIT_SIGNATURE undefined)\n");
113#endif
114 fprintf(stderr, " %s -V ==> print version information and exit\n",
115 params.cmdname);
116 fprintf(stderr, "Use -T to see a list of available image types\n");
117
118 exit(EXIT_FAILURE);
119}
120
Simon Glassfb4cce02016-02-22 22:55:52 -0700121static int add_content(int type, const char *fname)
122{
123 struct content_info *cont;
124
125 cont = calloc(1, sizeof(*cont));
126 if (!cont)
127 return -1;
128 cont->type = type;
129 cont->fname = fname;
130 if (params.content_tail)
131 params.content_tail->next = cont;
132 else
133 params.content_head = cont;
134 params.content_tail = cont;
135
136 return 0;
137}
138
Simon Glass0b443de2016-02-22 22:55:33 -0700139static void process_args(int argc, char **argv)
wdenk5b1d7132002-11-03 00:07:02 +0000140{
Peter Tysera2513e22010-04-04 22:36:03 -0500141 char *ptr;
Simon Glassd505a092016-02-22 22:55:48 -0700142 int type = IH_TYPE_INVALID;
143 char *datafile = NULL;
Simon Glassa02221f2016-02-22 22:55:34 -0700144 int opt;
wdenk5b1d7132002-11-03 00:07:02 +0000145
Simon Glassa02221f2016-02-22 22:55:34 -0700146 while ((opt = getopt(argc, argv,
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600147 "a:A:b:c:C:d:D:e:Ef:Fk:i:K:ln:N:p:O:rR:qsT:vVx")) != -1) {
Simon Glassa02221f2016-02-22 22:55:34 -0700148 switch (opt) {
Simon Glass07450082016-02-22 22:55:35 -0700149 case 'a':
150 params.addr = strtoull(optarg, &ptr, 16);
151 if (*ptr) {
152 fprintf(stderr, "%s: invalid load address %s\n",
153 params.cmdname, optarg);
154 exit(EXIT_FAILURE);
155 }
Simon Glassa02221f2016-02-22 22:55:34 -0700156 break;
157 case 'A':
158 params.arch = genimg_get_arch_id(optarg);
Simon Glass51f03e62016-06-30 10:52:19 -0600159 if (params.arch < 0) {
160 show_valid_options(IH_ARCH);
Simon Glass15310342016-02-22 22:55:37 -0700161 usage("Invalid architecture");
Simon Glass51f03e62016-06-30 10:52:19 -0600162 }
Simon Glassa02221f2016-02-22 22:55:34 -0700163 break;
Simon Glassfb4cce02016-02-22 22:55:52 -0700164 case 'b':
Andreas Bießmann8edeac82016-05-03 15:17:03 +0200165 if (add_content(IH_TYPE_FLATDT, optarg)) {
Andreas Bießmann7a439ca2016-05-01 03:01:27 +0200166 fprintf(stderr,
167 "%s: Out of memory adding content '%s'",
168 params.cmdname, optarg);
169 exit(EXIT_FAILURE);
170 }
Simon Glassfb4cce02016-02-22 22:55:52 -0700171 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700172 case 'c':
173 params.comment = optarg;
174 break;
175 case 'C':
176 params.comp = genimg_get_comp_id(optarg);
Simon Glass51f03e62016-06-30 10:52:19 -0600177 if (params.comp < 0) {
178 show_valid_options(IH_COMP);
Simon Glass15310342016-02-22 22:55:37 -0700179 usage("Invalid compression type");
Simon Glass51f03e62016-06-30 10:52:19 -0600180 }
Simon Glassa02221f2016-02-22 22:55:34 -0700181 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700182 case 'd':
183 params.datafile = optarg;
184 params.dflag = 1;
185 break;
Simon Glass07450082016-02-22 22:55:35 -0700186 case 'D':
187 params.dtc = optarg;
188 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700189 case 'e':
190 params.ep = strtoull(optarg, &ptr, 16);
191 if (*ptr) {
192 fprintf(stderr, "%s: invalid entry point %s\n",
193 params.cmdname, optarg);
194 exit(EXIT_FAILURE);
195 }
196 params.eflag = 1;
197 break;
Simon Glass722ebc82016-02-22 22:55:53 -0700198 case 'E':
199 params.external_data = true;
200 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700201 case 'f':
Simon Glass8e35bb02016-02-22 22:55:51 -0700202 datafile = optarg;
203 params.auto_its = !strcmp(datafile, "auto");
Simon Glassa02221f2016-02-22 22:55:34 -0700204 /* no break */
205 case 'F':
206 /*
207 * The flattened image tree (FIT) format
208 * requires a flattened device tree image type
209 */
210 params.type = IH_TYPE_FLATDT;
211 params.fflag = 1;
212 break;
Tomeu Vizoso0f7c6cd2016-11-04 14:22:15 +0100213 case 'i':
214 params.fit_ramdisk = optarg;
215 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700216 case 'k':
217 params.keydir = optarg;
218 break;
219 case 'K':
220 params.keydest = optarg;
221 break;
Simon Glass07450082016-02-22 22:55:35 -0700222 case 'l':
223 params.lflag = 1;
224 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700225 case 'n':
226 params.imagename = optarg;
227 break;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600228 case 'N':
229 params.engine_id = optarg;
230 break;
Simon Glass07450082016-02-22 22:55:35 -0700231 case 'O':
232 params.os = genimg_get_os_id(optarg);
Simon Glass51f03e62016-06-30 10:52:19 -0600233 if (params.os < 0) {
234 show_valid_options(IH_OS);
Simon Glass15310342016-02-22 22:55:37 -0700235 usage("Invalid operating system");
Simon Glass51f03e62016-06-30 10:52:19 -0600236 }
Simon Glass07450082016-02-22 22:55:35 -0700237 break;
Teddy Reedf8f91072016-06-09 19:38:02 -0700238 case 'p':
239 params.external_offset = strtoull(optarg, &ptr, 16);
240 if (*ptr) {
241 fprintf(stderr, "%s: invalid offset size %s\n",
242 params.cmdname, optarg);
243 exit(EXIT_FAILURE);
244 }
Teddy Reedb6fefa72016-07-11 22:54:26 -0700245 break;
Simon Glassbd6e1422016-05-01 13:55:38 -0600246 case 'q':
247 params.quiet = 1;
248 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700249 case 'r':
250 params.require_keys = 1;
251 break;
252 case 'R':
253 /*
254 * This entry is for the second configuration
255 * file, if only one is not enough.
256 */
257 params.imagename2 = optarg;
258 break;
259 case 's':
260 params.skipcpy = 1;
261 break;
Simon Glass07450082016-02-22 22:55:35 -0700262 case 'T':
Simon Glassd505a092016-02-22 22:55:48 -0700263 type = genimg_get_type_id(optarg);
264 if (type < 0) {
Simon Glassf24e1052016-06-30 10:52:18 -0600265 show_valid_options(IH_TYPE);
Simon Glass15310342016-02-22 22:55:37 -0700266 usage("Invalid image type");
Simon Glass07450082016-02-22 22:55:35 -0700267 }
268 break;
Simon Glassa02221f2016-02-22 22:55:34 -0700269 case 'v':
270 params.vflag++;
271 break;
272 case 'V':
273 printf("mkimage version %s\n", PLAIN_VERSION);
274 exit(EXIT_SUCCESS);
275 case 'x':
276 params.xflag++;
277 break;
278 default:
Simon Glass15310342016-02-22 22:55:37 -0700279 usage("Invalid option");
wdenk5b1d7132002-11-03 00:07:02 +0000280 }
wdenk5b1d7132002-11-03 00:07:02 +0000281 }
282
Andreas Bießmann8edeac82016-05-03 15:17:03 +0200283 /* The last parameter is expected to be the imagefile */
284 if (optind < argc)
Andreas Bießmann7a439ca2016-05-01 03:01:27 +0200285 params.imagefile = argv[optind];
286
Simon Glassd505a092016-02-22 22:55:48 -0700287 /*
288 * For auto-generated FIT images we need to know the image type to put
289 * in the FIT, which is separate from the file's image type (which
290 * will always be IH_TYPE_FLATDT in this case).
291 */
292 if (params.type == IH_TYPE_FLATDT) {
Simon Glass20deadd2016-06-30 10:52:07 -0600293 params.fit_image_type = type ? type : IH_TYPE_KERNEL;
Simon Glass3c23c0f2016-06-30 10:52:08 -0600294 /* For auto_its, datafile is always 'auto' */
Simon Glass8e35bb02016-02-22 22:55:51 -0700295 if (!params.auto_its)
296 params.datafile = datafile;
Simon Glasse324a922016-06-30 10:52:09 -0600297 else if (!params.datafile)
298 usage("Missing data file for auto-FIT (use -d)");
Simon Glassd505a092016-02-22 22:55:48 -0700299 } else if (type != IH_TYPE_INVALID) {
300 params.type = type;
301 }
302
303 if (!params.imagefile)
Simon Glass15310342016-02-22 22:55:37 -0700304 usage("Missing output filename");
Simon Glass0b443de2016-02-22 22:55:33 -0700305}
306
Simon Glass0b443de2016-02-22 22:55:33 -0700307int main(int argc, char **argv)
308{
309 int ifd = -1;
310 struct stat sbuf;
311 char *ptr;
312 int retval = 0;
313 struct image_type_params *tparams = NULL;
314 int pad_len = 0;
315 int dfd;
316
317 params.cmdname = *argv;
318 params.addr = 0;
319 params.ep = 0;
320
321 process_args(argc, argv);
wdenk5b1d7132002-11-03 00:07:02 +0000322
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530323 /* set tparams as per input type_id */
Guilherme Maciel Ferreiraa93648d2015-01-15 02:48:07 -0200324 tparams = imagetool_get_type(params.type);
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530325 if (tparams == NULL) {
326 fprintf (stderr, "%s: unsupported type %s\n",
327 params.cmdname, genimg_get_type_name(params.type));
328 exit (EXIT_FAILURE);
329 }
330
331 /*
332 * check the passed arguments parameters meets the requirements
333 * as per image type to be generated/listed
334 */
335 if (tparams->check_params)
336 if (tparams->check_params (&params))
Simon Glass15310342016-02-22 22:55:37 -0700337 usage("Bad parameters for image type");
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530338
339 if (!params.eflag) {
340 params.ep = params.addr;
wdenk5b1d7132002-11-03 00:07:02 +0000341 /* If XIP, entry point must be after the U-Boot header */
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530342 if (params.xflag)
343 params.ep += tparams->header_size;
wdenk5b1d7132002-11-03 00:07:02 +0000344 }
345
Peter Tyserc81296c2009-11-24 16:42:10 -0600346 if (params.fflag){
347 if (tparams->fflag_handle)
348 /*
349 * in some cases, some additional processing needs
350 * to be done if fflag is defined
351 *
352 * For ex. fit_handle_file for Fit file support
353 */
354 retval = tparams->fflag_handle(&params);
wdenk5b1d7132002-11-03 00:07:02 +0000355
Peter Tyserc81296c2009-11-24 16:42:10 -0600356 if (retval != EXIT_SUCCESS)
357 exit (retval);
wdenk5b1d7132002-11-03 00:07:02 +0000358 }
359
Peter Tyserc81296c2009-11-24 16:42:10 -0600360 if (params.lflag || params.fflag) {
361 ifd = open (params.imagefile, O_RDONLY|O_BINARY);
362 } else {
363 ifd = open (params.imagefile,
364 O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666);
365 }
366
367 if (ifd < 0) {
368 fprintf (stderr, "%s: Can't open %s: %s\n",
369 params.cmdname, params.imagefile,
370 strerror(errno));
371 exit (EXIT_FAILURE);
372 }
373
374 if (params.lflag || params.fflag) {
wdenk5b1d7132002-11-03 00:07:02 +0000375 /*
376 * list header information of existing image
377 */
378 if (fstat(ifd, &sbuf) < 0) {
379 fprintf (stderr, "%s: Can't stat %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530380 params.cmdname, params.imagefile,
381 strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000382 exit (EXIT_FAILURE);
383 }
384
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530385 if ((unsigned)sbuf.st_size < tparams->header_size) {
wdenk5b1d7132002-11-03 00:07:02 +0000386 fprintf (stderr,
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530387 "%s: Bad size: \"%s\" is not valid image\n",
388 params.cmdname, params.imagefile);
wdenk5b1d7132002-11-03 00:07:02 +0000389 exit (EXIT_FAILURE);
390 }
391
Mike Frysingerfa956fd2008-05-01 04:13:05 -0400392 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
393 if (ptr == MAP_FAILED) {
wdenk5b1d7132002-11-03 00:07:02 +0000394 fprintf (stderr, "%s: Can't read %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530395 params.cmdname, params.imagefile,
396 strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000397 exit (EXIT_FAILURE);
398 }
399
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530400 /*
401 * scan through mkimage registry for all supported image types
402 * and verify the input image file header for match
403 * Print the image information for matched image type
404 * Returns the error code if not matched
405 */
Guilherme Maciel Ferreira0ca66912015-01-15 02:48:05 -0200406 retval = imagetool_verify_print_header(ptr, &sbuf,
407 tparams, &params);
wdenk5b1d7132002-11-03 00:07:02 +0000408
wdenk5b1d7132002-11-03 00:07:02 +0000409 (void) munmap((void *)ptr, sbuf.st_size);
410 (void) close (ifd);
411
Prafulla Wadaskarf7644c02009-08-10 18:49:37 +0530412 exit (retval);
wdenk5b1d7132002-11-03 00:07:02 +0000413 }
414
Marek Vasut34633142015-12-07 18:01:54 +0100415 if ((params.type != IH_TYPE_MULTI) && (params.type != IH_TYPE_SCRIPT)) {
Philippe De Swert6ae6e162015-12-04 00:11:23 +0200416 dfd = open(params.datafile, O_RDONLY | O_BINARY);
417 if (dfd < 0) {
418 fprintf(stderr, "%s: Can't open %s: %s\n",
419 params.cmdname, params.datafile,
420 strerror(errno));
421 exit(EXIT_FAILURE);
422 }
Simon Glass92a655c2015-06-23 15:39:12 -0600423
Philippe De Swert6ae6e162015-12-04 00:11:23 +0200424 if (fstat(dfd, &sbuf) < 0) {
425 fprintf(stderr, "%s: Can't stat %s: %s\n",
426 params.cmdname, params.datafile,
427 strerror(errno));
428 exit(EXIT_FAILURE);
429 }
Simon Glass92a655c2015-06-23 15:39:12 -0600430
Philippe De Swert6ae6e162015-12-04 00:11:23 +0200431 params.file_size = sbuf.st_size + tparams->header_size;
432 close(dfd);
433 }
Simon Glass92a655c2015-06-23 15:39:12 -0600434
wdenk5b1d7132002-11-03 00:07:02 +0000435 /*
Stefano Babicf0662102011-09-15 23:50:16 +0000436 * In case there an header with a variable
437 * length will be added, the corresponding
438 * function is called. This is responsible to
439 * allocate memory for the header itself.
wdenk5b1d7132002-11-03 00:07:02 +0000440 */
Stefano Babicf0662102011-09-15 23:50:16 +0000441 if (tparams->vrec_header)
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200442 pad_len = tparams->vrec_header(&params, tparams);
Stefano Babicf0662102011-09-15 23:50:16 +0000443 else
444 memset(tparams->hdr, 0, tparams->header_size);
wdenk5b1d7132002-11-03 00:07:02 +0000445
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530446 if (write(ifd, tparams->hdr, tparams->header_size)
447 != tparams->header_size) {
wdenk5b1d7132002-11-03 00:07:02 +0000448 fprintf (stderr, "%s: Write error on %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530449 params.cmdname, params.imagefile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000450 exit (EXIT_FAILURE);
451 }
452
Christian Rieschd1be8f92011-12-09 09:47:38 +0000453 if (!params.skipcpy) {
454 if (params.type == IH_TYPE_MULTI ||
455 params.type == IH_TYPE_SCRIPT) {
456 char *file = params.datafile;
457 uint32_t size;
wdenk5b1d7132002-11-03 00:07:02 +0000458
Christian Rieschd1be8f92011-12-09 09:47:38 +0000459 for (;;) {
460 char *sep = NULL;
wdenk5b1d7132002-11-03 00:07:02 +0000461
Christian Rieschd1be8f92011-12-09 09:47:38 +0000462 if (file) {
463 if ((sep = strchr(file, ':')) != NULL) {
464 *sep = '\0';
465 }
466
467 if (stat (file, &sbuf) < 0) {
468 fprintf (stderr, "%s: Can't stat %s: %s\n",
469 params.cmdname, file, strerror(errno));
470 exit (EXIT_FAILURE);
471 }
472 size = cpu_to_uimage (sbuf.st_size);
473 } else {
474 size = 0;
wdenk5b1d7132002-11-03 00:07:02 +0000475 }
476
Christian Rieschd1be8f92011-12-09 09:47:38 +0000477 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) {
478 fprintf (stderr, "%s: Write error on %s: %s\n",
479 params.cmdname, params.imagefile,
480 strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000481 exit (EXIT_FAILURE);
482 }
Christian Rieschd1be8f92011-12-09 09:47:38 +0000483
484 if (!file) {
485 break;
486 }
487
488 if (sep) {
489 *sep = ':';
490 file = sep + 1;
491 } else {
492 file = NULL;
493 }
wdenk5b1d7132002-11-03 00:07:02 +0000494 }
495
Christian Rieschd1be8f92011-12-09 09:47:38 +0000496 file = params.datafile;
wdenk5b1d7132002-11-03 00:07:02 +0000497
Christian Rieschd1be8f92011-12-09 09:47:38 +0000498 for (;;) {
499 char *sep = strchr(file, ':');
500 if (sep) {
501 *sep = '\0';
502 copy_file (ifd, file, 1);
503 *sep++ = ':';
504 file = sep;
505 } else {
506 copy_file (ifd, file, 0);
507 break;
508 }
wdenk5b1d7132002-11-03 00:07:02 +0000509 }
Shaohui Xie5d898a02012-08-10 02:49:35 +0000510 } else if (params.type == IH_TYPE_PBLIMAGE) {
511 /* PBL has special Image format, implements its' own */
512 pbl_load_uboot(ifd, &params);
Christian Rieschd1be8f92011-12-09 09:47:38 +0000513 } else {
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200514 copy_file(ifd, params.datafile, pad_len);
wdenk5b1d7132002-11-03 00:07:02 +0000515 }
Sven Ebenfeldd21bd692016-11-06 16:37:56 +0100516 if (params.type == IH_TYPE_FIRMWARE_IVT) {
517 /* Add alignment and IVT */
518 uint32_t aligned_filesize = (params.file_size + 0x1000
519 - 1) & ~(0x1000 - 1);
520 flash_header_v2_t ivt_header = { { 0xd1, 0x2000, 0x40 },
521 params.addr, 0, 0, 0, params.addr
522 + aligned_filesize
523 - tparams->header_size,
524 params.addr + aligned_filesize
525 - tparams->header_size
526 + 0x20, 0 };
527 int i = params.file_size;
528 for (; i < aligned_filesize; i++) {
Sven Ebenfeldb4e923a2017-01-17 19:36:51 +0100529 if (write(ifd, (char *) &i, 1) != 1) {
Sven Ebenfeldd21bd692016-11-06 16:37:56 +0100530 fprintf(stderr,
531 "%s: Write error on %s: %s\n",
532 params.cmdname,
533 params.imagefile,
534 strerror(errno));
535 exit(EXIT_FAILURE);
536 }
537 }
538 if (write(ifd, &ivt_header, sizeof(flash_header_v2_t))
539 != sizeof(flash_header_v2_t)) {
540 fprintf(stderr, "%s: Write error on %s: %s\n",
541 params.cmdname,
542 params.imagefile,
543 strerror(errno));
544 exit(EXIT_FAILURE);
545 }
546 }
wdenk5b1d7132002-11-03 00:07:02 +0000547 }
548
549 /* We're a bit of paranoid */
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530550#if defined(_POSIX_SYNCHRONIZED_IO) && \
551 !defined(__sun__) && \
552 !defined(__FreeBSD__) && \
Luka Perkov31cbe802014-08-09 18:17:47 +0200553 !defined(__OpenBSD__) && \
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530554 !defined(__APPLE__)
wdenk5b1d7132002-11-03 00:07:02 +0000555 (void) fdatasync (ifd);
556#else
557 (void) fsync (ifd);
558#endif
559
560 if (fstat(ifd, &sbuf) < 0) {
561 fprintf (stderr, "%s: Can't stat %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530562 params.cmdname, params.imagefile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000563 exit (EXIT_FAILURE);
564 }
Simon Glass92a655c2015-06-23 15:39:12 -0600565 params.file_size = sbuf.st_size;
wdenk5b1d7132002-11-03 00:07:02 +0000566
Mike Frysingerfa956fd2008-05-01 04:13:05 -0400567 ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0);
568 if (ptr == MAP_FAILED) {
wdenk5b1d7132002-11-03 00:07:02 +0000569 fprintf (stderr, "%s: Can't map %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530570 params.cmdname, params.imagefile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000571 exit (EXIT_FAILURE);
572 }
573
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530574 /* Setup the image header as per input image type*/
575 if (tparams->set_header)
576 tparams->set_header (ptr, &sbuf, ifd, &params);
577 else {
578 fprintf (stderr, "%s: Can't set header for %s: %s\n",
579 params.cmdname, tparams->name, strerror(errno));
580 exit (EXIT_FAILURE);
581 }
wdenk5b1d7132002-11-03 00:07:02 +0000582
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530583 /* Print the image information by processing image header */
584 if (tparams->print_header)
585 tparams->print_header (ptr);
586 else {
587 fprintf (stderr, "%s: Can't print header for %s: %s\n",
588 params.cmdname, tparams->name, strerror(errno));
589 exit (EXIT_FAILURE);
590 }
wdenk5b1d7132002-11-03 00:07:02 +0000591
592 (void) munmap((void *)ptr, sbuf.st_size);
593
594 /* We're a bit of paranoid */
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530595#if defined(_POSIX_SYNCHRONIZED_IO) && \
596 !defined(__sun__) && \
597 !defined(__FreeBSD__) && \
Luka Perkov31cbe802014-08-09 18:17:47 +0200598 !defined(__OpenBSD__) && \
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530599 !defined(__APPLE__)
wdenk5b1d7132002-11-03 00:07:02 +0000600 (void) fdatasync (ifd);
601#else
602 (void) fsync (ifd);
603#endif
604
605 if (close(ifd)) {
606 fprintf (stderr, "%s: Write error on %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530607 params.cmdname, params.imagefile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000608 exit (EXIT_FAILURE);
609 }
610
611 exit (EXIT_SUCCESS);
612}
613
614static void
615copy_file (int ifd, const char *datafile, int pad)
616{
617 int dfd;
618 struct stat sbuf;
619 unsigned char *ptr;
620 int tail;
621 int zero = 0;
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200622 uint8_t zeros[4096];
wdenk5b1d7132002-11-03 00:07:02 +0000623 int offset = 0;
624 int size;
Guilherme Maciel Ferreiraa93648d2015-01-15 02:48:07 -0200625 struct image_type_params *tparams = imagetool_get_type(params.type);
wdenk5b1d7132002-11-03 00:07:02 +0000626
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200627 memset(zeros, 0, sizeof(zeros));
628
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530629 if (params.vflag) {
wdenk5b1d7132002-11-03 00:07:02 +0000630 fprintf (stderr, "Adding Image %s\n", datafile);
631 }
632
wdenkef1464c2003-10-08 22:14:02 +0000633 if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
wdenk5b1d7132002-11-03 00:07:02 +0000634 fprintf (stderr, "%s: Can't open %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530635 params.cmdname, datafile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000636 exit (EXIT_FAILURE);
637 }
638
639 if (fstat(dfd, &sbuf) < 0) {
640 fprintf (stderr, "%s: Can't stat %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530641 params.cmdname, datafile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000642 exit (EXIT_FAILURE);
643 }
644
Mike Frysingerfa956fd2008-05-01 04:13:05 -0400645 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
646 if (ptr == MAP_FAILED) {
wdenk5b1d7132002-11-03 00:07:02 +0000647 fprintf (stderr, "%s: Can't read %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530648 params.cmdname, datafile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000649 exit (EXIT_FAILURE);
650 }
651
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530652 if (params.xflag) {
wdenk5b1d7132002-11-03 00:07:02 +0000653 unsigned char *p = NULL;
654 /*
655 * XIP: do not append the image_header_t at the
656 * beginning of the file, but consume the space
657 * reserved for it.
658 */
659
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530660 if ((unsigned)sbuf.st_size < tparams->header_size) {
wdenk5b1d7132002-11-03 00:07:02 +0000661 fprintf (stderr,
662 "%s: Bad size: \"%s\" is too small for XIP\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530663 params.cmdname, datafile);
wdenk5b1d7132002-11-03 00:07:02 +0000664 exit (EXIT_FAILURE);
665 }
666
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530667 for (p = ptr; p < ptr + tparams->header_size; p++) {
wdenk5b1d7132002-11-03 00:07:02 +0000668 if ( *p != 0xff ) {
669 fprintf (stderr,
670 "%s: Bad file: \"%s\" has invalid buffer for XIP\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530671 params.cmdname, datafile);
wdenk5b1d7132002-11-03 00:07:02 +0000672 exit (EXIT_FAILURE);
673 }
674 }
675
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530676 offset = tparams->header_size;
wdenk5b1d7132002-11-03 00:07:02 +0000677 }
678
679 size = sbuf.st_size - offset;
680 if (write(ifd, ptr + offset, size) != size) {
681 fprintf (stderr, "%s: Write error on %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530682 params.cmdname, params.imagefile, strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000683 exit (EXIT_FAILURE);
684 }
685
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200686 tail = size % 4;
687 if ((pad == 1) && (tail != 0)) {
wdenk5b1d7132002-11-03 00:07:02 +0000688
689 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) {
690 fprintf (stderr, "%s: Write error on %s: %s\n",
Prafulla Wadaskar89a4d6b2009-08-19 17:36:46 +0530691 params.cmdname, params.imagefile,
692 strerror(errno));
wdenk5b1d7132002-11-03 00:07:02 +0000693 exit (EXIT_FAILURE);
694 }
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200695 } else if (pad > 1) {
Simon Glass424b86a2015-08-30 16:55:22 -0600696 while (pad > 0) {
697 int todo = sizeof(zeros);
698
699 if (todo > pad)
700 todo = pad;
701 if (write(ifd, (char *)&zeros, todo) != todo) {
702 fprintf(stderr, "%s: Write error on %s: %s\n",
703 params.cmdname, params.imagefile,
704 strerror(errno));
705 exit(EXIT_FAILURE);
706 }
707 pad -= todo;
Stefano Babic9bac0bb2013-08-19 19:03:19 +0200708 }
wdenk5b1d7132002-11-03 00:07:02 +0000709 }
710
711 (void) munmap((void *)ptr, sbuf.st_size);
712 (void) close (dfd);
713}