tools: zynqmpbif: Use compiler builtin instead of linux-specific __swab32
[platform/kernel/u-boot.git] / 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         size_t len_padded = ROUND(len, 4);
323
324         struct partition_header parthdr = {
325                 .len_enc = cpu_to_le32(len_padded / 4),
326                 .len_unenc = cpu_to_le32(len_padded / 4),
327                 .len = cpu_to_le32(len_padded / 4),
328                 .entry_point = cpu_to_le64(bf->entry),
329                 .load_address = cpu_to_le64(bf->load),
330         };
331         int r;
332         uint32_t csum;
333
334         if (len < len_padded) {
335                 char *newdata = malloc(len_padded);
336                 memcpy(newdata, data, len);
337                 memset(newdata + len, 0, len_padded - len);
338                 data = newdata;
339         }
340
341         if (bf->flags & (1ULL << BIF_FLAG_PMUFW_IMAGE))
342                 return bif_add_pmufw(bf, data, len);
343
344         r = bif_add_blob(data, len, &bf->offset);
345         if (r)
346                 return r;
347
348         parthdr.offset = cpu_to_le32(bf->offset / 4);
349
350         if (bf->flags & (1ULL << BIF_FLAG_BOOTLOADER)) {
351                 if (bif_output.last_part) {
352                         printf("ERROR: Bootloader expected before others\n");
353                         return -1;
354                 }
355
356                 parthdr.offset = cpu_to_le32(bif_output.header->image_offset);
357                 parthdr.len = cpu_to_le32((bf->offset + len -
358                         bif_output.header->image_offset) / 4);
359                 parthdr.len_enc = parthdr.len;
360                 parthdr.len_unenc = parthdr.len;
361         }
362
363         /* Normalize EL */
364         bf->exp_lvl = bf->exp_lvl ? bf->exp_lvl - 1 : 3;
365         parthdr.attributes |= bf->exp_lvl << PART_ATTR_TARGET_EL_SHIFT;
366         parthdr.attributes |= bf->dest_dev;
367         parthdr.attributes |= bf->dest_cpu;
368         if (bf->flags & (1ULL << BIF_FLAG_TZ))
369                 parthdr.attributes |= PART_ATTR_TZ_SECURE;
370         if (bf->flags & (1ULL << BIF_FLAG_PART_OWNER_UBOOT))
371                 parthdr.attributes |= PART_ATTR_PART_OWNER_UBOOT;
372         switch (bf->dest_cpu) {
373         case PART_ATTR_DEST_CPU_NONE:
374         case PART_ATTR_DEST_CPU_A53_0:
375         case PART_ATTR_DEST_CPU_A53_1:
376         case PART_ATTR_DEST_CPU_A53_2:
377         case PART_ATTR_DEST_CPU_A53_3:
378                 if (bf->flags & (1ULL << BIF_FLAG_AARCH32))
379                         parthdr.attributes |= PART_ATTR_A53_EXEC_AARCH32;
380         }
381
382         csum = zynqmp_csum(&parthdr, &parthdr.checksum);
383         parthdr.checksum = cpu_to_le32(csum);
384
385         r = bif_add_blob(&parthdr, sizeof(parthdr), &parthdr_offset);
386         if (r)
387                 return r;
388
389         /* Add image header table if not there yet */
390         if (!bif_output.imgheader) {
391                 size_t imghdr_off = 0;
392                 struct image_header_table imghdr = {
393                         .version = cpu_to_le32(0x01020000),
394                         .nr_parts = 0,
395                 };
396
397                 r = bif_add_blob(&imghdr, sizeof(imghdr), &imghdr_off);
398                 if (r)
399                         return r;
400
401                 bif_output.header->image_header_table_offset = imghdr_off;
402                 bif_output.imgheader = (void *)(bif_output.data + imghdr_off);
403         }
404
405         bif_output.imgheader->nr_parts = cpu_to_le32(le32_to_cpu(
406                 bif_output.imgheader->nr_parts) + 1);
407
408         /* Link to this partition header */
409         if (bif_output.last_part) {
410                 bif_output.last_part->next_partition_offset =
411                         cpu_to_le32(parthdr_offset / 4);
412
413                 /* Recalc checksum of last_part */
414                 csum = zynqmp_csum(bif_output.last_part,
415                                    &bif_output.last_part->checksum);
416                 bif_output.last_part->checksum = cpu_to_le32(csum);
417         } else {
418                 bif_output.imgheader->partition_header_offset =
419                         cpu_to_le32(parthdr_offset / 4);
420         }
421         bif_output.last_part = (void *)(bif_output.data + parthdr_offset);
422
423         if (bf->flags & (1ULL << BIF_FLAG_BOOTLOADER)) {
424                 bif_output.header->image_load = cpu_to_le32(bf->load);
425                 if (!bif_output.header->image_offset)
426                         bif_output.header->image_offset =
427                                 cpu_to_le32(bf->offset);
428                 bif_output.header->image_size = cpu_to_le32(len_padded);
429                 bif_output.header->image_stored_size = cpu_to_le32(len_padded);
430
431                 bif_output.header->image_attributes &= ~HEADER_CPU_SELECT_MASK;
432                 switch (bf->dest_cpu) {
433                 default:
434                 case PART_ATTR_DEST_CPU_A53_0:
435                         if (bf->flags & BIF_FLAG_AARCH32)
436                                 bif_output.header->image_attributes |=
437                                         HEADER_CPU_SELECT_A53_32BIT;
438                         else
439                                 bif_output.header->image_attributes |=
440                                         HEADER_CPU_SELECT_A53_64BIT;
441                         break;
442                 case PART_ATTR_DEST_CPU_R5_0:
443                         bif_output.header->image_attributes |=
444                                 HEADER_CPU_SELECT_R5_SINGLE;
445                         break;
446                 case PART_ATTR_DEST_CPU_R5_L:
447                         bif_output.header->image_attributes |=
448                                 HEADER_CPU_SELECT_R5_DUAL;
449                         break;
450                 }
451         }
452
453         return 0;
454 }
455
456 /* Add .bit bitstream */
457 static int bif_add_bit(struct bif_entry *bf)
458 {
459         char *bit = read_full_file(bf->filename, NULL);
460         char *bitbin;
461         uint8_t initial_header[] = { 0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f,
462                                      0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61 };
463         uint16_t len;
464         uint32_t bitlen;
465         int i;
466
467         if (!bit)
468                 return -1;
469
470         /* Skip initial header */
471         if (memcmp(bit, initial_header, sizeof(initial_header)))
472                 return -1;
473
474         bit += sizeof(initial_header);
475
476         /* Design name */
477         len = be16_to_cpu(*(uint16_t *)bit);
478         bit += sizeof(uint16_t);
479         debug("Design: %s\n", bit);
480         bit += len;
481
482         /* Device identifier */
483         if (*bit != 'b')
484                 return -1;
485         bit++;
486         len = be16_to_cpu(*(uint16_t *)bit);
487         bit += sizeof(uint16_t);
488         debug("Device: %s\n", bit);
489         bit += len;
490
491         /* Date */
492         if (*bit != 'c')
493                 return -1;
494         bit++;
495         len = be16_to_cpu(*(uint16_t *)bit);
496         bit += sizeof(uint16_t);
497         debug("Date: %s\n", bit);
498         bit += len;
499
500         /* Time */
501         if (*bit != 'd')
502                 return -1;
503         bit++;
504         len = be16_to_cpu(*(uint16_t *)bit);
505         bit += sizeof(uint16_t);
506         debug("Time: %s\n", bit);
507         bit += len;
508
509         /* Bitstream length */
510         if (*bit != 'e')
511                 return -1;
512         bit++;
513         bitlen = be32_to_cpu(*(uint32_t *)bit);
514         bit += sizeof(uint32_t);
515         bitbin = bit;
516
517         debug("Bitstream Length: 0x%x\n", bitlen);
518         for (i = 0; i < bitlen; i += sizeof(uint32_t)) {
519                 uint32_t *bitbin32 = (uint32_t *)&bitbin[i];
520                 *bitbin32 = __builtin_bswap32(*bitbin32);
521         }
522
523         if (!bf->dest_dev)
524                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PL;
525
526         bf->load = 0xffffffff;
527         bf->entry = 0;
528
529         bf->flags |= 1ULL << BIF_FLAG_BIT_FILE;
530         return bif_add_part(bf, bit, bitlen);
531 }
532
533 /* Add .bin bitstream */
534 static int bif_add_bin(struct bif_entry *bf)
535 {
536         size_t size;
537         char *bin = read_full_file(bf->filename, &size);
538
539         if (!bf->dest_dev)
540                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PS;
541
542         bf->flags |= 1ULL << BIF_FLAG_BIN_FILE;
543         return bif_add_part(bf, bin, size);
544 }
545
546 /* Add elf file */
547 static char *elf2flat64(char *elf, size_t *flat_size, size_t *load_addr)
548 {
549         Elf64_Ehdr *ehdr;
550         Elf64_Shdr *shdr;
551         size_t min_addr = -1, max_addr = 0;
552         char *flat;
553         int i;
554
555         ehdr = (void *)elf;
556         shdr = (void *)(elf + le64_to_cpu(ehdr->e_shoff));
557
558         /* Look for smallest / biggest address */
559         for (i = 0; i < le64_to_cpu(ehdr->e_shnum); i++, shdr++) {
560                 if (!shdr->sh_size || !shdr->sh_addr ||
561                     !(shdr->sh_flags & SHF_ALLOC) ||
562                     (shdr->sh_type == SHT_NOBITS))
563                         continue;
564
565                 if (le64_to_cpu(shdr->sh_addr) < min_addr)
566                         min_addr = le64_to_cpu(shdr->sh_addr);
567                 if ((le64_to_cpu(shdr->sh_addr) + le64_to_cpu(shdr->sh_size)) >
568                         max_addr)
569                         max_addr = le64_to_cpu(shdr->sh_addr) +
570                                    le64_to_cpu(shdr->sh_size);
571         }
572
573         *load_addr = min_addr;
574         *flat_size = max_addr - min_addr;
575         flat = calloc(1, *flat_size);
576         if (!flat)
577                 return NULL;
578
579         shdr = (void *)(elf + le64_to_cpu(ehdr->e_shoff));
580         for (i = 0; i < le64_to_cpu(ehdr->e_shnum); i++, shdr++) {
581                 char *dst = flat + le64_to_cpu(shdr->sh_addr) - min_addr;
582                 char *src = elf + le64_to_cpu(shdr->sh_offset);
583
584                 if (!shdr->sh_size || !shdr->sh_addr ||
585                     !(shdr->sh_flags & SHF_ALLOC))
586                         continue;
587
588                 if (shdr->sh_type != SHT_NOBITS)
589                         memcpy(dst, src, le64_to_cpu(shdr->sh_size));
590         }
591
592         return flat;
593 }
594
595 static char *elf2flat32(char *elf, size_t *flat_size, size_t *load_addr)
596 {
597         Elf32_Ehdr *ehdr;
598         Elf32_Shdr *shdr;
599         size_t min_addr = -1, max_addr = 0;
600         char *flat;
601         int i;
602
603         ehdr = (void *)elf;
604         shdr = (void *)(elf + le32_to_cpu(ehdr->e_shoff));
605
606         /* Look for smallest / biggest address */
607         for (i = 0; i < le32_to_cpu(ehdr->e_shnum); i++, shdr++) {
608                 if (!shdr->sh_size || !shdr->sh_addr ||
609                     !(shdr->sh_flags & SHF_ALLOC) ||
610                     (shdr->sh_type == SHT_NOBITS))
611                         continue;
612
613                 if (le32_to_cpu(shdr->sh_addr) < min_addr)
614                         min_addr = le32_to_cpu(shdr->sh_addr);
615                 if ((le32_to_cpu(shdr->sh_addr) + le32_to_cpu(shdr->sh_size)) >
616                         max_addr)
617                         max_addr = le32_to_cpu(shdr->sh_addr) +
618                                    le32_to_cpu(shdr->sh_size);
619         }
620
621         *load_addr = min_addr;
622         *flat_size = max_addr - min_addr;
623         flat = calloc(1, *flat_size);
624         if (!flat)
625                 return NULL;
626
627         shdr = (void *)(elf + le32_to_cpu(ehdr->e_shoff));
628         for (i = 0; i < le32_to_cpu(ehdr->e_shnum); i++, shdr++) {
629                 char *dst = flat + le32_to_cpu(shdr->sh_addr) - min_addr;
630                 char *src = elf + le32_to_cpu(shdr->sh_offset);
631
632                 if (!shdr->sh_size || !shdr->sh_addr ||
633                     !(shdr->sh_flags & SHF_ALLOC))
634                         continue;
635
636                 if (shdr->sh_type != SHT_NOBITS)
637                         memcpy(dst, src, le32_to_cpu(shdr->sh_size));
638         }
639
640         return flat;
641 }
642
643 static int bif_add_elf(struct bif_entry *bf)
644 {
645         size_t size;
646         size_t elf_size;
647         char *elf;
648         char *flat;
649         size_t load_addr;
650         Elf32_Ehdr *ehdr32;
651         Elf64_Ehdr *ehdr64;
652
653         elf = read_full_file(bf->filename, &elf_size);
654         if (!elf)
655                 return -1;
656
657         ehdr32 = (void *)elf;
658         ehdr64 = (void *)elf;
659
660         switch (ehdr32->e_ident[EI_CLASS]) {
661         case ELFCLASS32:
662                 flat = elf2flat32(elf, &size, &load_addr);
663                 bf->entry = le32_to_cpu(ehdr32->e_entry);
664                 bf->flags |= 1ULL << BIF_FLAG_AARCH32;
665                 break;
666         case ELFCLASS64:
667                 flat = elf2flat64(elf, &size, &load_addr);
668                 bf->entry = le64_to_cpu(ehdr64->e_entry);
669                 break;
670         default:
671                 printf("Unknown ELF class: %d\n", ehdr32->e_ident[EI_CLASS]);
672                 return -1;
673         }
674
675         if (!flat)
676                 return -1;
677
678         bf->load = load_addr;
679         if (!bf->dest_dev)
680                 bf->dest_dev = PART_ATTR_DEST_DEVICE_PS;
681
682         bf->flags |= 1ULL << BIF_FLAG_ELF_FILE;
683         return bif_add_part(bf, flat, size);
684 }
685
686 static const struct bif_file_type bif_file_types[] = {
687         {
688                 .name = "bitstream (.bit)",
689                 .header = 0x00090ff0,
690                 .add = bif_add_bit,
691         },
692
693         {
694                 .name = "ELF",
695                 .header = 0x7f454c46,
696                 .add = bif_add_elf,
697         },
698
699         /* Anything else is a .bin file */
700         {
701                 .name = ".bin",
702                 .add = bif_add_bin,
703         },
704 };
705
706 static int bif_fsbl_config(struct bif_entry *fsbl_config,
707                            struct bif_entry *entries, int nr_entries)
708 {
709         int i;
710         int config_set = 0;
711         struct {
712                 const char *name;
713                 uint64_t flags;
714                 uint64_t dest_cpu;
715         } configs[] = {
716                 { .name = "a5x_x64", .dest_cpu = PART_ATTR_DEST_CPU_A53_0 },
717                 { .name = "a53_x64", .dest_cpu = PART_ATTR_DEST_CPU_A53_0 },
718                 { .name = "a5x_x32", .dest_cpu = PART_ATTR_DEST_CPU_A53_0,
719                                      .flags = 1ULL << BIF_FLAG_AARCH32 },
720                 { .name = "a53_x32", .dest_cpu = PART_ATTR_DEST_CPU_A53_0,
721                                      .flags = 1ULL << BIF_FLAG_AARCH32 },
722                 { .name = "r5_single", .dest_cpu = PART_ATTR_DEST_CPU_R5_0 },
723                 { .name = "r5_dual", .dest_cpu = PART_ATTR_DEST_CPU_R5_L },
724         };
725
726         /* Set target CPU of bootloader entry */
727         for (i = 0; i < nr_entries; i++) {
728                 struct bif_entry *b = &entries[i];
729                 const char *config_attr = fsbl_config->filename;
730                 int j;
731
732                 if (!(b->flags & (1ULL << BIF_FLAG_BOOTLOADER)))
733                         continue;
734
735                 for (j = 0; j < ARRAY_SIZE(configs); j++) {
736                         if (!strncmp(config_attr, configs[j].name,
737                                      strlen(configs[j].name))) {
738                                 b->dest_cpu = configs[j].dest_cpu;
739                                 b->flags |= configs[j].flags;
740                                 config_set = 1;
741                         }
742                 }
743
744                 if (!config_set) {
745                         printf("ERROR: Unsupported fsbl_config: %s\n",
746                                config_attr);
747                         return -1;
748                 }
749         }
750
751         if (!config_set) {
752                 printf("ERROR: fsbl_config w/o bootloader\n");
753                 return -1;
754         }
755
756         return 0;
757 }
758
759 static const struct bif_flags *find_flag(char *str)
760 {
761         const struct bif_flags *bf;
762         int i;
763
764         for (i = 0; i < ARRAY_SIZE(bif_flags); i++) {
765                 bf = &bif_flags[i];
766                 if (!strncmp(bf->name, str, strlen(bf->name)))
767                         return bf;
768         }
769
770         printf("ERROR: Flag '%s' not found\n", str);
771
772         return NULL;
773 }
774
775 static int bif_open_file(struct bif_entry *entry)
776 {
777         int fd = open(entry->filename, O_RDONLY);
778
779         if (fd < 0)
780                 printf("Error opening file %s\n", entry->filename);
781
782         return fd;
783 }
784
785 static const struct bif_file_type *get_file_type(struct bif_entry *entry)
786 {
787         int fd = bif_open_file(entry);
788         uint32_t header;
789         int i;
790
791         if (fd < 0)
792                 return NULL;
793
794         if (read(fd, &header, sizeof(header)) != sizeof(header)) {
795                 printf("Error reading file %s", entry->filename);
796                 return NULL;
797         }
798
799         close(fd);
800
801         for (i = 0; i < ARRAY_SIZE(bif_file_types); i++) {
802                 const struct bif_file_type *type = &bif_file_types[i];
803
804                 if (!type->header)
805                         return type;
806                 if (type->header == be32_to_cpu(header))
807                         return type;
808         }
809
810         return NULL;
811 }
812
813 #define NEXT_CHAR(str, chr) ({          \
814         char *_n = strchr(str, chr);    \
815         if (!_n)                        \
816                 goto err;               \
817         _n;                             \
818 })
819
820 static char *skip_whitespace(char *str)
821 {
822         while (*str == ' ' || *str == '\t')
823                 str++;
824
825         return str;
826 }
827
828 int zynqmpbif_copy_image(int outfd, struct image_tool_params *mparams)
829 {
830         char *bif, *bifp, *bifpn;
831         char *line;
832         struct bif_entry entries[32] = { { 0 } };
833         int nr_entries = 0;
834         struct bif_entry *entry = entries;
835         size_t len;
836         int i;
837         uint32_t csum;
838         int bldr = -1;
839
840         bif_init();
841
842         /* Read .bif input file */
843         bif = read_full_file(mparams->datafile, NULL);
844         if (!bif)
845                 goto err;
846
847         /* Interpret .bif file */
848         bifp = bif;
849
850         /* A bif description starts with a { section */
851         bifp = NEXT_CHAR(bifp, '{') + 1;
852
853         /* Read every line */
854         while (1) {
855                 bifpn = NEXT_CHAR(bifp, '\n');
856
857                 if (bifpn[-1] == '\r')
858                         bifpn[-1] = '\0';
859
860                 *bifpn = '\0';
861                 bifpn++;
862                 line = bifp;
863
864                 line = skip_whitespace(line);
865
866                 /* Attributes? */
867                 if (*line == '[') {
868                         line++;
869                         while (1) {
870                                 const struct bif_flags *bf;
871
872                                 line = skip_whitespace(line);
873                                 bf = find_flag(line);
874                                 if (!bf)
875                                         goto err;
876
877                                 line += strlen(bf->name);
878                                 if (bf->parse)
879                                         line = bf->parse(line, entry);
880                                 else
881                                         entry->flags |= 1ULL << bf->flag;
882
883                                 if (!line)
884                                         goto err;
885
886                                 /* Go to next attribute or quit */
887                                 if (*line == ']') {
888                                         line++;
889                                         break;
890                                 }
891                                 if (*line == ',')
892                                         line++;
893                         }
894                 }
895
896                 /* End of image description */
897                 if (*line == '}')
898                         break;
899
900                 if (*line) {
901                         line = skip_whitespace(line);
902                         entry->filename = line;
903                         nr_entries++;
904                         entry++;
905                 }
906
907                 /* Use next line */
908                 bifp = bifpn;
909         }
910
911         for (i = 0; i < nr_entries; i++) {
912                 debug("Entry flags=%#lx name=%s\n", entries[i].flags,
913                       entries[i].filename);
914         }
915
916         /*
917          * Some entries are actually configuration option for other ones,
918          * let's apply them in an intermediate step.
919          */
920         for (i = 0; i < nr_entries; i++) {
921                 struct bif_entry *entry = &entries[i];
922
923                 if (entry->flags & (1ULL << BIF_FLAG_FSBL_CONFIG))
924                         if (bif_fsbl_config(entry, entries, nr_entries))
925                                 goto err;
926         }
927
928         /* Make sure PMUFW comes before bootloader */
929         for (i = 0; i < nr_entries; i++) {
930                 struct bif_entry *entry = &entries[i];
931
932                 if (entry->flags & (1ULL << BIF_FLAG_BOOTLOADER))
933                         bldr = i;
934                 if (entry->flags & (1ULL << BIF_FLAG_PMUFW_IMAGE)) {
935                         if (bldr >= 0) {
936                                 struct bif_entry tmp = *entry;
937
938                                 *entry = entries[bldr];
939                                 entries[bldr] = tmp;
940                         }
941                 }
942         }
943
944         for (i = 0; i < nr_entries; i++) {
945                 struct bif_entry *entry = &entries[i];
946                 const struct bif_file_type *type;
947                 int r;
948
949                 if (entry->flags & (1ULL << BIF_FLAG_FSBL_CONFIG))
950                         continue;
951
952                 type = get_file_type(entry);
953                 if (!type)
954                         goto err;
955
956                 debug("type=%s file=%s\n", type->name, entry->filename);
957                 r = type->add(entry);
958                 if (r)
959                         goto err;
960         }
961
962         /* Calculate checksums */
963         csum = zynqmp_csum(&bif_output.header->width_detection,
964                            &bif_output.header->checksum);
965         bif_output.header->checksum = cpu_to_le32(csum);
966
967         if (bif_output.imgheader) {
968                 csum = zynqmp_csum(bif_output.imgheader,
969                                    &bif_output.imgheader->checksum);
970                 bif_output.imgheader->checksum = cpu_to_le32(csum);
971         }
972
973         /* Write headers and components */
974         if (lseek(outfd, 0, SEEK_SET) != 0)
975                 goto err;
976
977         len = bif_output.data_len;
978         bifp = bif_output.data;
979         while (len) {
980                 int r;
981
982                 r = write(outfd, bifp, len);
983                 if (r < 0)
984                         goto err;
985                 len -= r;
986                 bifp += r;
987         }
988
989         return 0;
990
991 err:
992         fprintf(stderr, "Error: Failed to create image.\n");
993         return -1;
994 }
995
996 /* Needs to be stubbed out so we can print after creation */
997 static void zynqmpbif_set_header(void *ptr, struct stat *sbuf, int ifd,
998                                  struct image_tool_params *params)
999 {
1000 }
1001
1002 static struct zynqmp_header zynqmpimage_header;
1003
1004 U_BOOT_IMAGE_TYPE(
1005         zynqmpbif,
1006         "Xilinx ZynqMP Boot Image support (bif)",
1007         sizeof(struct zynqmp_header),
1008         (void *)&zynqmpimage_header,
1009         zynqmpbif_check_params,
1010         NULL,
1011         zynqmpimage_print_header,
1012         zynqmpbif_set_header,
1013         NULL,
1014         zynqmpbif_check_image_types,
1015         NULL,
1016         NULL
1017 );