]> git.sur5r.net Git - u-boot/blob - tools/zynqmpbif.c
ARM: Introduce ability to enable invalidate of BTB with ICIALLU on Cortex-A15 for...
[u-boot] / tools / zynqmpbif.c
1 /*
2  * Copyright (C) 2018 Alexander Graf <agraf@suse.de>
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include "imagetool.h"
8 #include "mkimage.h"
9 #include "zynqmpimage.h"
10 #include <elf.h>
11 #include <image.h>
12
13 struct bif_entry {
14         const char *filename;
15         uint64_t flags;
16         uint64_t dest_cpu;
17         uint64_t exp_lvl;
18         uint64_t dest_dev;
19         uint64_t load;
20         uint64_t entry;
21         size_t offset;
22 };
23
24 enum bif_flag {
25         BIF_FLAG_AESKEYFILE,
26         BIF_FLAG_INIT,
27         BIF_FLAG_UDF_BH,
28         BIF_FLAG_HEADERSIGNATURE,
29         BIF_FLAG_PPKFILE,
30         BIF_FLAG_PSKFILE,
31         BIF_FLAG_SPKFILE,
32         BIF_FLAG_SSKFILE,
33         BIF_FLAG_SPKSIGNATURE,
34         BIF_FLAG_FSBL_CONFIG,
35         BIF_FLAG_AUTH_PARAMS,
36         BIF_FLAG_KEYSRC_ENCRYPTION,
37         BIF_FLAG_PMUFW_IMAGE,
38         BIF_FLAG_BOOTLOADER,
39         BIF_FLAG_TZ,
40         BIF_FLAG_BH_KEY_IV,
41         BIF_FLAG_BH_KEYFILE,
42         BIF_FLAG_PUF_FILE,
43         BIF_FLAG_AARCH32,
44         BIF_FLAG_PART_OWNER_UBOOT,
45
46         /* Internal flags */
47         BIF_FLAG_BIT_FILE,
48         BIF_FLAG_ELF_FILE,
49         BIF_FLAG_BIN_FILE,
50 };
51
52 struct bif_flags {
53         const char name[32];
54         uint64_t flag;
55         char *(*parse)(char *line, struct bif_entry *bf);
56 };
57
58 struct bif_file_type {
59         const char name[32];
60         uint32_t header;
61         int (*add)(struct bif_entry *bf);
62 };
63
64 struct bif_output {
65         size_t data_len;
66         char *data;
67         struct image_header_table *imgheader;
68         struct zynqmp_header *header;
69         struct partition_header *last_part;
70 };
71
72 struct bif_output bif_output;
73
74 static uint32_t zynqmp_csum(void *start, void *end)
75 {
76         uint32_t checksum = 0;
77         uint32_t *ptr32 = start;
78
79         while (ptr32 != end) {
80                 checksum += le32_to_cpu(*ptr32);
81                 ptr32++;
82         }
83
84         return ~checksum;
85 }
86
87 static int zynqmpbif_check_params(struct image_tool_params *params)
88 {
89         if (!params)
90                 return 0;
91
92         if (params->addr != 0x0) {
93                 fprintf(stderr, "Error: Load Address can not be specified.\n");
94                 return -1;
95         }
96
97         if (params->eflag) {
98                 fprintf(stderr, "Error: Entry Point can not be specified.\n");
99                 return -1;
100         }
101
102         return !(params->lflag || params->dflag);
103 }
104
105 static int zynqmpbif_check_image_types(uint8_t type)
106 {
107         return (type == IH_TYPE_ZYNQMPBIF) ? EXIT_SUCCESS : EXIT_FAILURE;
108 }
109
110 static char *parse_dest_cpu(char *line, struct bif_entry *bf)
111 {
112         uint64_t i;
113
114         for (i = 0; i < ARRAY_SIZE(dest_cpus); i++) {
115                 if (!strncmp(line, dest_cpus[i], strlen(dest_cpus[i]))) {
116                         bf->dest_cpu = i << PART_ATTR_DEST_CPU_SHIFT;
117                         return line + strlen(dest_cpus[i]);
118                 }
119
120                 /* a5x can also be written as a53 */
121                 if (!strncmp(dest_cpus[i], "a5x", 3)) {
122                         char a53[] = "a53-X";
123
124                         a53[4] = dest_cpus[i][4];
125                         if (!strncmp(line, a53, strlen(a53))) {
126                                 bf->dest_cpu = i << PART_ATTR_DEST_CPU_SHIFT;
127                                 return line + strlen(a53);
128                         }
129                 }
130         }
131
132         return line;
133 }
134
135 static char *parse_el(char *line, struct bif_entry *bf)
136 {
137         const char *dest_els[] = { "none", "el-0", "el-1", "el-2", "el-3" };
138         int i;
139
140         for (i = 0; i < ARRAY_SIZE(dest_els); i++) {
141                 if (!strncmp(line, dest_els[i], strlen(dest_els[i]))) {
142                         bf->exp_lvl = i;
143                         return line + strlen(dest_els[i]);
144                 }
145         }
146
147         return line;
148 }
149
150 static char *parse_load(char *line, struct bif_entry *bf)
151 {
152         char *endptr;
153
154         bf->load = strtoll(line, &endptr, 0);
155
156         return endptr;
157 }
158
159 static char *parse_entry(char *line, struct bif_entry *bf)
160 {
161         char *endptr;
162
163         bf->entry = strtoll(line, &endptr, 0);
164
165         return endptr;
166 }
167
168 static char *parse_offset(char *line, struct bif_entry *bf)
169 {
170         char *endptr;
171
172         bf->offset = strtoll(line, &endptr, 0);
173
174         return endptr;
175 }
176
177 static char *parse_partition_owner(char *line, struct bif_entry *bf)
178 {
179         char *endptr = NULL;
180
181         if (!strncmp(line, "fsbl", 4)) {
182                 endptr = line + 4;
183         } else if (!strncmp(line, "uboot", 5)) {
184                 bf->flags |= 1ULL << BIF_FLAG_PART_OWNER_UBOOT;
185                 endptr = line + 5;
186         } else {
187                 printf("ERROR: Unknown partition type '%s'\n", line);
188         }
189
190         return endptr;
191 }
192
193 static const struct bif_flags bif_flags[] = {
194         { "fsbl_config", BIF_FLAG_FSBL_CONFIG },
195         { "trustzone", BIF_FLAG_TZ },
196         { "pmufw_image", BIF_FLAG_PMUFW_IMAGE },
197         { "bootloader", BIF_FLAG_BOOTLOADER },
198         { "destination_cpu=", 0, parse_dest_cpu },
199         { "exception_level=", 0, parse_el },
200         { "load=", 0, parse_load },
201         { "startup=", 0, parse_entry },
202         { "offset=", 0, parse_offset },
203         { "partition_owner=", 0, parse_partition_owner },
204 };
205
206 static char *read_full_file(const char *filename, size_t *size)
207 {
208         char *buf, *bufp;
209         struct stat sbuf;
210         int len = 0, r, fd;
211
212         fd = open(filename, O_RDONLY);
213         if (fd < 0)
214                 return NULL;
215
216         if (fstat(fd, &sbuf) < 0)
217                 return NULL;
218
219         if (size)
220                 *size = sbuf.st_size;
221
222         buf = malloc(sbuf.st_size);
223         if (!buf)
224                 return NULL;
225
226         bufp = buf;
227         while (len < sbuf.st_size) {
228                 r = read(fd, bufp, sbuf.st_size - len);
229                 if (r < 0)
230                         return NULL;
231                 len += r;
232                 bufp += r;
233         }
234
235         close(fd);
236
237         return buf;
238 }
239
240 static int bif_add_blob(const void *data, size_t len, size_t *offset)
241 {
242         size_t new_size;
243         uintptr_t header_off;
244         uintptr_t last_part_off;
245         uintptr_t imgheader_off;
246         uintptr_t old_data = (uintptr_t)bif_output.data;
247         void *new_data;
248
249         header_off = (uintptr_t)bif_output.header - old_data;
250         last_part_off = (uintptr_t)bif_output.last_part - old_data;
251         imgheader_off = (uintptr_t)bif_output.imgheader - old_data;
252
253         if (offset && *offset) {
254                 /* Pad to a given offset */
255                 if (bif_output.data_len > *offset) {
256                         printf("Can not pad to offset %zx\n", *offset);
257                         return -1;
258                 }
259
260                 bif_output.data_len = *offset;
261         }
262
263         new_size = ROUND(bif_output.data_len + len, 64);
264         new_data = realloc(bif_output.data, new_size);
265         memcpy(new_data + bif_output.data_len, data, len);
266         if (offset)
267                 *offset = bif_output.data_len;
268         bif_output.data = new_data;
269         bif_output.data_len = new_size;
270
271         /* Readjust internal pointers */
272         if (bif_output.header)
273                 bif_output.header = new_data + header_off;
274         if (bif_output.last_part)
275                 bif_output.last_part = new_data + last_part_off;
276         if (bif_output.imgheader)
277                 bif_output.imgheader = new_data + imgheader_off;
278
279         return 0;
280 }
281
282 static int bif_init(void)
283 {
284         struct zynqmp_header header = { { 0 } };
285         int r;
286
287         zynqmpimage_default_header(&header);
288
289         r = bif_add_blob(&header, sizeof(header), NULL);
290         if (r)
291                 return r;
292
293         bif_output.header = (void *)bif_output.data;
294
295         return 0;
296 }
297
298 static int bif_add_pmufw(struct bif_entry *bf, const char *data, size_t len)
299 {
300         int r;
301
302         if (bif_output.header->image_offset) {
303                 printf("PMUFW expected before bootloader in your .bif file!\n");
304                 return -1;
305         }
306
307         r = bif_add_blob(data, len, &bf->offset);
308         if (r)
309                 return r;
310
311         len = ROUND(len, 64);
312         bif_output.header->pfw_image_length = cpu_to_le32(len);
313         bif_output.header->total_pfw_image_length = cpu_to_le32(len);
314         bif_output.header->image_offset = cpu_to_le32(bf->offset);
315
316         return 0;
317 }
318
319 static int bif_add_part(struct bif_entry *bf, const char *data, size_t len)
320 {
321         size_t parthdr_offset = 0;
322         struct partition_header parthdr = {
323                 .len_enc = cpu_to_le32(len / 4),
324                 .len_unenc = cpu_to_le32(len / 4),
325                 .len = cpu_to_le32(len / 4),
326                 .entry_point = cpu_to_le64(bf->entry),
327                 .load_address = cpu_to_le64(bf->load),
328         };
329         int r;
330         uint32_t csum;
331
332         if (bf->flags & (1ULL << BIF_FLAG_PMUFW_IMAGE))
333                 return bif_add_pmufw(bf, data, len);
334
335         r = bif_add_blob(data, len, &bf->offset);
336         if (r)
337                 return r;
338
339         parthdr.offset = cpu_to_le32(bf->offset / 4);
340
341         if (bf->flags & (1ULL << BIF_FLAG_BOOTLOADER)) {
342                 if (bif_output.last_part) {
343                         printf("ERROR: Bootloader expected before others\n");
344                         return -1;
345                 }
346
347                 parthdr.offset = cpu_to_le32(bif_output.header->image_offset);
348                 parthdr.len = cpu_to_le32((bf->offset + len -
349                         bif_output.header->image_offset) / 4);
350                 parthdr.len_enc = parthdr.len;
351                 parthdr.len_unenc = parthdr.len;
352         }
353
354         /* Normalize EL */
355         bf->exp_lvl = bf->exp_lvl ? bf->exp_lvl - 1 : 3;
356         parthdr.attributes |= bf->exp_lvl << PART_ATTR_TARGET_EL_SHIFT;
357         parthdr.attributes |= bf->dest_dev;
358         parthdr.attributes |= bf->dest_cpu;
359         if (bf->flags & (1ULL << BIF_FLAG_TZ))
360                 parthdr.attributes |= PART_ATTR_TZ_SECURE;
361         if (bf->flags & (1ULL << BIF_FLAG_PART_OWNER_UBOOT))
362                 parthdr.attributes |= PART_ATTR_PART_OWNER_UBOOT;
363         switch (bf->dest_cpu) {
364         case PART_ATTR_DEST_CPU_NONE:
365         case PART_ATTR_DEST_CPU_A53_0:
366         case PART_ATTR_DEST_CPU_A53_1:
367         case PART_ATTR_DEST_CPU_A53_2:
368         case PART_ATTR_DEST_CPU_A53_3:
369                 if (bf->flags & (1ULL << BIF_FLAG_AARCH32))
370                         parthdr.attributes |= PART_ATTR_A53_EXEC_AARCH32;
371         }
372
373         csum = zynqmp_csum(&parthdr, &parthdr.checksum);
374         parthdr.checksum = cpu_to_le32(csum);
375
376         r = bif_add_blob(&parthdr, sizeof(parthdr), &parthdr_offset);
377         if (r)
378                 return r;
379
380         /* Add image header table if not there yet */
381         if (!bif_output.imgheader) {
382                 size_t imghdr_off = 0;
383                 struct image_header_table imghdr = {
384                         .version = cpu_to_le32(0x01020000),
385                         .nr_parts = 0,
386                 };
387
388                 r = bif_add_blob(&imghdr, sizeof(imghdr), &imghdr_off);
389                 if (r)
390                         return r;
391
392                 bif_output.header->image_header_table_offset = imghdr_off;
393                 bif_output.imgheader = (void *)(bif_output.data + imghdr_off);
394         }
395
396         bif_output.imgheader->nr_parts = cpu_to_le32(le32_to_cpu(
397                 bif_output.imgheader->nr_parts) + 1);
398
399         /* Link to this partition header */
400         if (bif_output.last_part) {
401                 bif_output.last_part->next_partition_offset =
402                         cpu_to_le32(parthdr_offset / 4);
403
404                 /* Recalc checksum of last_part */
405                 csum = zynqmp_csum(bif_output.last_part,
406                                    &bif_output.last_part->checksum);
407                 bif_output.last_part->checksum = cpu_to_le32(csum);
408         } else {
409                 bif_output.imgheader->partition_header_offset =
410                         cpu_to_le32(parthdr_offset / 4);
411         }
412         bif_output.last_part = (void *)(bif_output.data + parthdr_offset);
413
414         if (bf->flags & (1ULL << BIF_FLAG_BOOTLOADER)) {
415                 bif_output.header->image_load = cpu_to_le32(bf->load);
416                 if (!bif_output.header->image_offset)
417                         bif_output.header->image_offset =
418                                 cpu_to_le32(bf->offset);
419                 bif_output.header->image_size = cpu_to_le32(len);
420                 bif_output.header->image_stored_size = cpu_to_le32(len);
421
422                 bif_output.header->image_attributes &= ~HEADER_CPU_SELECT_MASK;
423                 switch (bf->dest_cpu) {
424                 default:
425                 case PART_ATTR_DEST_CPU_A53_0:
426                         if (bf->flags & BIF_FLAG_AARCH32)
427                                 bif_output.header->image_attributes |=
428                                         HEADER_CPU_SELECT_A53_32BIT;
429                         else
430                                 bif_output.header->image_attributes |=
431                                         HEADER_CPU_SELECT_A53_64BIT;
432                         break;
433                 case PART_ATTR_DEST_CPU_R5_0:
434                         bif_output.header->image_attributes |=
435                                 HEADER_CPU_SELECT_R5_SINGLE;
436                         break;
437                 case PART_ATTR_DEST_CPU_R5_L:
438                         bif_output.header->image_attributes |=
439                                 HEADER_CPU_SELECT_R5_DUAL;
440                         break;
441                 }
442         }
443
444         return 0;
445 }
446
447 /* Add .bit bitstream */
448 static int bif_add_bit(struct bif_entry *bf)
449 {
450         char *bit = read_full_file(bf->filename, NULL);
451         char *bitbin;
452         uint8_t initial_header[] = { 0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f,
453                                      0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61 };
454         uint16_t len;
455         uint32_t bitlen;
456         int i;
457
458         if (!bit)
459                 return -1;
460
461         /* Skip initial header */
462         if (memcmp(bit, initial_header, sizeof(initial_header)))
463                 return -1;
464
465         bit += sizeof(initial_header);
466
467         /* Design name */
468         len = be16_to_cpu(*(uint16_t *)bit);
469         bit += sizeof(uint16_t);
470         debug("Design: %s\n", bit);
471         bit += len;
472
473         /* Device identifier */
474         if (*bit != 'b')
475                 return -1;
476         bit++;
477         len = be16_to_cpu(*(uint16_t *)bit);
478         bit += sizeof(uint16_t);
479         debug("Device: %s\n", bit);
480         bit += len;
481
482         /* Date */
483         if (*bit != 'c')
484                 return -1;
485         bit++;
486         len = be16_to_cpu(*(uint16_t *)bit);
487         bit += sizeof(uint16_t);
488         debug("Date: %s\n", bit);
489         bit += len;
490
491         /* Time */
492         if (*bit != 'd')
493                 return -1;
494         bit++;
495         len = be16_to_cpu(*(uint16_t *)bit);
496         bit += sizeof(uint16_t);
497         debug("Time: %s\n", bit);
498         bit += len;
499
500         /* Bitstream length */
501         if (*bit != 'e')
502                 return -1;
503         bit++;
504         bitlen = be32_to_cpu(*(uint32_t *)bit);
505         bit += sizeof(uint32_t);
506         bitbin = bit;
507
508         debug("Bitstream Length: 0x%x\n", bitlen);
509         for (i = 0; i < bitlen; i += sizeof(uint32_t)) {
510                 uint32_t *bitbin32 = (uint32_t *)&bitbin[i];
511                 *bitbin32 = __swab32(*bitbin32);
512         }
513
514         if (!bf->dest_dev)
515                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PL;
516
517         bf->load = 0xffffffff;
518         bf->entry = 0;
519
520         bf->flags |= 1ULL << BIF_FLAG_BIT_FILE;
521         return bif_add_part(bf, bit, bitlen);
522 }
523
524 /* Add .bin bitstream */
525 static int bif_add_bin(struct bif_entry *bf)
526 {
527         size_t size;
528         char *bin = read_full_file(bf->filename, &size);
529
530         if (!bf->dest_dev)
531                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PS;
532
533         bf->flags |= 1ULL << BIF_FLAG_BIN_FILE;
534         return bif_add_part(bf, bin, size);
535 }
536
537 /* Add elf file */
538 static char *elf2flat64(char *elf, size_t *flat_size, size_t *load_addr)
539 {
540         Elf64_Ehdr *ehdr;
541         Elf64_Shdr *shdr;
542         size_t min_addr = -1, max_addr = 0;
543         char *flat;
544         int i;
545
546         ehdr = (void *)elf;
547         shdr = (void *)(elf + le64_to_cpu(ehdr->e_shoff));
548
549         /* Look for smallest / biggest address */
550         for (i = 0; i < le64_to_cpu(ehdr->e_shnum); i++, shdr++) {
551                 if (!shdr->sh_size || !shdr->sh_addr ||
552                     !(shdr->sh_flags & SHF_ALLOC) ||
553                     (shdr->sh_type == SHT_NOBITS))
554                         continue;
555
556                 if (le64_to_cpu(shdr->sh_addr) < min_addr)
557                         min_addr = le64_to_cpu(shdr->sh_addr);
558                 if ((le64_to_cpu(shdr->sh_addr) + le64_to_cpu(shdr->sh_size)) >
559                         max_addr)
560                         max_addr = le64_to_cpu(shdr->sh_addr) +
561                                    le64_to_cpu(shdr->sh_size);
562         }
563
564         *load_addr = min_addr;
565         *flat_size = max_addr - min_addr;
566         flat = calloc(1, *flat_size);
567         if (!flat)
568                 return NULL;
569
570         shdr = (void *)(elf + le64_to_cpu(ehdr->e_shoff));
571         for (i = 0; i < le64_to_cpu(ehdr->e_shnum); i++, shdr++) {
572                 char *dst = flat + le64_to_cpu(shdr->sh_addr) - min_addr;
573                 char *src = elf + le64_to_cpu(shdr->sh_offset);
574
575                 if (!shdr->sh_size || !shdr->sh_addr ||
576                     !(shdr->sh_flags & SHF_ALLOC))
577                         continue;
578
579                 if (shdr->sh_type != SHT_NOBITS)
580                         memcpy(dst, src, le64_to_cpu(shdr->sh_size));
581         }
582
583         return flat;
584 }
585
586 static char *elf2flat32(char *elf, size_t *flat_size, size_t *load_addr)
587 {
588         Elf32_Ehdr *ehdr;
589         Elf32_Shdr *shdr;
590         size_t min_addr = -1, max_addr = 0;
591         char *flat;
592         int i;
593
594         ehdr = (void *)elf;
595         shdr = (void *)(elf + le32_to_cpu(ehdr->e_shoff));
596
597         /* Look for smallest / biggest address */
598         for (i = 0; i < le32_to_cpu(ehdr->e_shnum); i++, shdr++) {
599                 if (!shdr->sh_size || !shdr->sh_addr ||
600                     !(shdr->sh_flags & SHF_ALLOC) ||
601                     (shdr->sh_type == SHT_NOBITS))
602                         continue;
603
604                 if (le32_to_cpu(shdr->sh_addr) < min_addr)
605                         min_addr = le32_to_cpu(shdr->sh_addr);
606                 if ((le32_to_cpu(shdr->sh_addr) + le32_to_cpu(shdr->sh_size)) >
607                         max_addr)
608                         max_addr = le32_to_cpu(shdr->sh_addr) +
609                                    le32_to_cpu(shdr->sh_size);
610         }
611
612         *load_addr = min_addr;
613         *flat_size = max_addr - min_addr;
614         flat = calloc(1, *flat_size);
615         if (!flat)
616                 return NULL;
617
618         shdr = (void *)(elf + le32_to_cpu(ehdr->e_shoff));
619         for (i = 0; i < le32_to_cpu(ehdr->e_shnum); i++, shdr++) {
620                 char *dst = flat + le32_to_cpu(shdr->sh_addr) - min_addr;
621                 char *src = elf + le32_to_cpu(shdr->sh_offset);
622
623                 if (!shdr->sh_size || !shdr->sh_addr ||
624                     !(shdr->sh_flags & SHF_ALLOC))
625                         continue;
626
627                 if (shdr->sh_type != SHT_NOBITS)
628                         memcpy(dst, src, le32_to_cpu(shdr->sh_size));
629         }
630
631         return flat;
632 }
633
634 static int bif_add_elf(struct bif_entry *bf)
635 {
636         size_t size;
637         size_t elf_size;
638         char *elf;
639         char *flat;
640         size_t load_addr;
641         Elf32_Ehdr *ehdr32;
642         Elf64_Ehdr *ehdr64;
643
644         elf = read_full_file(bf->filename, &elf_size);
645         if (!elf)
646                 return -1;
647
648         ehdr32 = (void *)elf;
649         ehdr64 = (void *)elf;
650
651         switch (ehdr32->e_ident[EI_CLASS]) {
652         case ELFCLASS32:
653                 flat = elf2flat32(elf, &size, &load_addr);
654                 bf->entry = le32_to_cpu(ehdr32->e_entry);
655                 bf->flags |= 1ULL << BIF_FLAG_AARCH32;
656                 break;
657         case ELFCLASS64:
658                 flat = elf2flat64(elf, &size, &load_addr);
659                 bf->entry = le64_to_cpu(ehdr64->e_entry);
660                 break;
661         default:
662                 printf("Unknown ELF class: %d\n", ehdr32->e_ident[EI_CLASS]);
663                 return -1;
664         }
665
666         if (!flat)
667                 return -1;
668
669         bf->load = load_addr;
670         if (!bf->dest_dev)
671                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PS;
672
673         bf->flags |= 1ULL << BIF_FLAG_ELF_FILE;
674         return bif_add_part(bf, flat, size);
675 }
676
677 static const struct bif_file_type bif_file_types[] = {
678         {
679                 .name = "bitstream (.bit)",
680                 .header = 0x00090ff0,
681                 .add = bif_add_bit,
682         },
683
684         {
685                 .name = "ELF",
686                 .header = 0x7f454c46,
687                 .add = bif_add_elf,
688         },
689
690         /* Anything else is a .bin file */
691         {
692                 .name = ".bin",
693                 .add = bif_add_bin,
694         },
695 };
696
697 static int bif_fsbl_config(struct bif_entry *fsbl_config,
698                            struct bif_entry *entries, int nr_entries)
699 {
700         int i;
701         int config_set = 0;
702         struct {
703                 const char *name;
704                 uint64_t flags;
705                 uint64_t dest_cpu;
706         } configs[] = {
707                 { .name = "a5x_x64", .dest_cpu = PART_ATTR_DEST_CPU_A53_0 },
708                 { .name = "a53_x64", .dest_cpu = PART_ATTR_DEST_CPU_A53_0 },
709                 { .name = "a5x_x32", .dest_cpu = PART_ATTR_DEST_CPU_A53_0,
710                                      .flags = 1ULL << BIF_FLAG_AARCH32 },
711                 { .name = "a53_x32", .dest_cpu = PART_ATTR_DEST_CPU_A53_0,
712                                      .flags = 1ULL << BIF_FLAG_AARCH32 },
713                 { .name = "r5_single", .dest_cpu = PART_ATTR_DEST_CPU_R5_0 },
714                 { .name = "r5_dual", .dest_cpu = PART_ATTR_DEST_CPU_R5_L },
715         };
716
717         /* Set target CPU of bootloader entry */
718         for (i = 0; i < nr_entries; i++) {
719                 struct bif_entry *b = &entries[i];
720                 const char *config_attr = fsbl_config->filename;
721                 int j;
722
723                 if (!(b->flags & (1ULL << BIF_FLAG_BOOTLOADER)))
724                         continue;
725
726                 for (j = 0; j < ARRAY_SIZE(configs); j++) {
727                         if (!strncmp(config_attr, configs[j].name,
728                                      strlen(configs[j].name))) {
729                                 b->dest_cpu = configs[j].dest_cpu;
730                                 b->flags |= configs[j].flags;
731                                 config_set = 1;
732                         }
733                 }
734
735                 if (!config_set) {
736                         printf("ERROR: Unsupported fsbl_config: %s\n",
737                                config_attr);
738                         return -1;
739                 }
740         }
741
742         if (!config_set) {
743                 printf("ERROR: fsbl_config w/o bootloader\n");
744                 return -1;
745         }
746
747         return 0;
748 }
749
750 static const struct bif_flags *find_flag(char *str)
751 {
752         const struct bif_flags *bf;
753         int i;
754
755         for (i = 0; i < ARRAY_SIZE(bif_flags); i++) {
756                 bf = &bif_flags[i];
757                 if (!strncmp(bf->name, str, strlen(bf->name)))
758                         return bf;
759         }
760
761         printf("ERROR: Flag '%s' not found\n", str);
762
763         return NULL;
764 }
765
766 static int bif_open_file(struct bif_entry *entry)
767 {
768         int fd = open(entry->filename, O_RDONLY);
769
770         if (fd < 0)
771                 printf("Error opening file %s\n", entry->filename);
772
773         return fd;
774 }
775
776 static const struct bif_file_type *get_file_type(struct bif_entry *entry)
777 {
778         int fd = bif_open_file(entry);
779         uint32_t header;
780         int i;
781
782         if (fd < 0)
783                 return NULL;
784
785         if (read(fd, &header, sizeof(header)) != sizeof(header)) {
786                 printf("Error reading file %s", entry->filename);
787                 return NULL;
788         }
789
790         close(fd);
791
792         for (i = 0; i < ARRAY_SIZE(bif_file_types); i++) {
793                 const struct bif_file_type *type = &bif_file_types[i];
794
795                 if (!type->header)
796                         return type;
797                 if (type->header == be32_to_cpu(header))
798                         return type;
799         }
800
801         return NULL;
802 }
803
804 #define NEXT_CHAR(str, chr) ({          \
805         char *_n = strchr(str, chr);    \
806         if (!_n)                        \
807                 goto err;               \
808         _n;                             \
809 })
810
811 static char *skip_whitespace(char *str)
812 {
813         while (*str == ' ' || *str == '\t')
814                 str++;
815
816         return str;
817 }
818
819 int zynqmpbif_copy_image(int outfd, struct image_tool_params *mparams)
820 {
821         char *bif, *bifp, *bifpn;
822         char *line;
823         struct bif_entry entries[32] = { { 0 } };
824         int nr_entries = 0;
825         struct bif_entry *entry = entries;
826         size_t len;
827         int i;
828         uint32_t csum;
829         int bldr = -1;
830
831         bif_init();
832
833         /* Read .bif input file */
834         bif = read_full_file(mparams->datafile, NULL);
835         if (!bif)
836                 goto err;
837
838         /* Interpret .bif file */
839         bifp = bif;
840
841         /* A bif description starts with a { section */
842         bifp = NEXT_CHAR(bifp, '{') + 1;
843
844         /* Read every line */
845         while (1) {
846                 bifpn = NEXT_CHAR(bifp, '\n');
847
848                 if (bifpn[-1] == '\r')
849                         bifpn[-1] = '\0';
850
851                 *bifpn = '\0';
852                 bifpn++;
853                 line = bifp;
854
855                 line = skip_whitespace(line);
856
857                 /* Attributes? */
858                 if (*line == '[') {
859                         line++;
860                         while (1) {
861                                 const struct bif_flags *bf;
862
863                                 line = skip_whitespace(line);
864                                 bf = find_flag(line);
865                                 if (!bf)
866                                         goto err;
867
868                                 line += strlen(bf->name);
869                                 if (bf->parse)
870                                         line = bf->parse(line, entry);
871                                 else
872                                         entry->flags |= 1ULL << bf->flag;
873
874                                 if (!line)
875                                         goto err;
876
877                                 /* Go to next attribute or quit */
878                                 if (*line == ']') {
879                                         line++;
880                                         break;
881                                 }
882                                 if (*line == ',')
883                                         line++;
884                         }
885                 }
886
887                 /* End of image description */
888                 if (*line == '}')
889                         break;
890
891                 if (*line) {
892                         line = skip_whitespace(line);
893                         entry->filename = line;
894                         nr_entries++;
895                         entry++;
896                 }
897
898                 /* Use next line */
899                 bifp = bifpn;
900         }
901
902         for (i = 0; i < nr_entries; i++) {
903                 debug("Entry flags=%#lx name=%s\n", entries[i].flags,
904                       entries[i].filename);
905         }
906
907         /*
908          * Some entries are actually configuration option for other ones,
909          * let's apply them in an intermediate step.
910          */
911         for (i = 0; i < nr_entries; i++) {
912                 struct bif_entry *entry = &entries[i];
913
914                 if (entry->flags & (1ULL << BIF_FLAG_FSBL_CONFIG))
915                         if (bif_fsbl_config(entry, entries, nr_entries))
916                                 goto err;
917         }
918
919         /* Make sure PMUFW comes before bootloader */
920         for (i = 0; i < nr_entries; i++) {
921                 struct bif_entry *entry = &entries[i];
922
923                 if (entry->flags & (1ULL << BIF_FLAG_BOOTLOADER))
924                         bldr = i;
925                 if (entry->flags & (1ULL << BIF_FLAG_PMUFW_IMAGE)) {
926                         if (bldr >= 0) {
927                                 struct bif_entry tmp = *entry;
928
929                                 *entry = entries[bldr];
930                                 entries[bldr] = tmp;
931                         }
932                 }
933         }
934
935         for (i = 0; i < nr_entries; i++) {
936                 struct bif_entry *entry = &entries[i];
937                 const struct bif_file_type *type;
938                 int r;
939
940                 if (entry->flags & (1ULL << BIF_FLAG_FSBL_CONFIG))
941                         continue;
942
943                 type = get_file_type(entry);
944                 if (!type)
945                         goto err;
946
947                 debug("type=%s file=%s\n", type->name, entry->filename);
948                 r = type->add(entry);
949                 if (r)
950                         goto err;
951         }
952
953         /* Calculate checksums */
954         csum = zynqmp_csum(&bif_output.header->width_detection,
955                            &bif_output.header->checksum);
956         bif_output.header->checksum = cpu_to_le32(csum);
957
958         if (bif_output.imgheader) {
959                 csum = zynqmp_csum(bif_output.imgheader,
960                                    &bif_output.imgheader->checksum);
961                 bif_output.imgheader->checksum = cpu_to_le32(csum);
962         }
963
964         /* Write headers and components */
965         if (lseek(outfd, 0, SEEK_SET) != 0)
966                 goto err;
967
968         len = bif_output.data_len;
969         bifp = bif_output.data;
970         while (len) {
971                 int r;
972
973                 r = write(outfd, bifp, len);
974                 if (r < 0)
975                         goto err;
976                 len -= r;
977                 bifp += r;
978         }
979
980         return 0;
981
982 err:
983         fprintf(stderr, "Error: Failed to create image.\n");
984         return -1;
985 }
986
987 /* Needs to be stubbed out so we can print after creation */
988 static void zynqmpbif_set_header(void *ptr, struct stat *sbuf, int ifd,
989                                  struct image_tool_params *params)
990 {
991 }
992
993 static struct zynqmp_header zynqmpimage_header;
994
995 U_BOOT_IMAGE_TYPE(
996         zynqmpbif,
997         "Xilinx ZynqMP Boot Image support (bif)",
998         sizeof(struct zynqmp_header),
999         (void *)&zynqmpimage_header,
1000         zynqmpbif_check_params,
1001         NULL,
1002         zynqmpimage_print_header,
1003         zynqmpbif_set_header,
1004         NULL,
1005         zynqmpbif_check_image_types,
1006         NULL,
1007         NULL
1008 );