git.sur5r.net Git - u-boot/blob - 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 );