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 zynqmp_csum(void * start,void * end)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 zynqmpbif_check_params(struct image_tool_params * params)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 zynqmpbif_check_image_types(uint8_t type)105 static int zynqmpbif_check_image_types(uint8_t type) 106 { 107 return (type == IH_TYPE_ZYNQMPBIF) ? EXIT_SUCCESS : EXIT_FAILURE; 108 } 109 parse_dest_cpu(char * line,struct bif_entry * bf)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 parse_el(char * line,struct bif_entry * bf)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 parse_load(char * line,struct bif_entry * bf)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 parse_entry(char * line,struct bif_entry * bf)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 parse_offset(char * line,struct bif_entry * bf)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 parse_partition_owner(char * line,struct bif_entry * bf)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 read_full_file(const char * filename,size_t * size)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 bif_add_blob(const void * data,size_t len,size_t * offset)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 bif_init(void)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 bif_add_pmufw(struct bif_entry * bf,const char * data,size_t len)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 bif_add_part(struct bif_entry * bf,const char * data,size_t len)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 */ bif_add_bit(struct bif_entry * bf)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 = __swab32(*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 */ bif_add_bin(struct bif_entry * bf)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 */ elf2flat64(char * elf,size_t * flat_size,size_t * load_addr)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 elf2flat32(char * elf,size_t * flat_size,size_t * load_addr)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 bif_add_elf(struct bif_entry * bf)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 bif_fsbl_config(struct bif_entry * fsbl_config,struct bif_entry * entries,int nr_entries)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 find_flag(char * str)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 bif_open_file(struct bif_entry * entry)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 get_file_type(struct bif_entry * entry)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 skip_whitespace(char * str)820 static char *skip_whitespace(char *str) 821 { 822 while (*str == ' ' || *str == '\t') 823 str++; 824 825 return str; 826 } 827 zynqmpbif_copy_image(int outfd,struct image_tool_params * mparams)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 */ zynqmpbif_set_header(void * ptr,struct stat * sbuf,int ifd,struct image_tool_params * params)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 ); 1018