1 /* 2 * (C) Copyright 2007-2011 3 * Allwinner Technology Co., Ltd. <www.allwinnertech.com> 4 * Tom Cubie <tangliang@allwinnertech.com> 5 * 6 * a simple tool to generate bootable image for sunxi platform. 7 * 8 * SPDX-License-Identifier: GPL-2.0+ 9 */ 10 #include <fcntl.h> 11 #include <stdio.h> 12 #include <unistd.h> 13 #include <stdlib.h> 14 #include <string.h> 15 #include <errno.h> 16 #include <sys/types.h> 17 #include <sys/stat.h> 18 #include "../arch/arm/include/asm/arch-sunxi/spl.h" 19 20 #define STAMP_VALUE 0x5F0A6C39 21 22 /* check sum functon from sun4i boot code */ 23 int gen_check_sum(struct boot_file_head *head_p) 24 { 25 uint32_t length; 26 uint32_t *buf; 27 uint32_t loop; 28 uint32_t i; 29 uint32_t sum; 30 31 length = le32_to_cpu(head_p->length); 32 if ((length & 0x3) != 0) /* must 4-byte-aligned */ 33 return -1; 34 buf = (uint32_t *)head_p; 35 head_p->check_sum = cpu_to_le32(STAMP_VALUE); /* fill stamp */ 36 loop = length >> 2; 37 38 /* calculate the sum */ 39 for (i = 0, sum = 0; i < loop; i++) 40 sum += le32_to_cpu(buf[i]); 41 42 /* write back check sum */ 43 head_p->check_sum = cpu_to_le32(sum); 44 45 return 0; 46 } 47 48 #define ALIGN(x, a) __ALIGN_MASK((x), (typeof(x))(a)-1) 49 #define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask)) 50 51 #define SUN4I_SRAM_SIZE 0x7600 /* 0x7748+ is used by BROM */ 52 #define SRAM_LOAD_MAX_SIZE (SUN4I_SRAM_SIZE - sizeof(struct boot_file_head)) 53 54 /* 55 * BROM (at least on A10 and A20) requires NAND-images to be explicitly aligned 56 * to a multiple of 8K, and rejects the image otherwise. MMC-images are fine 57 * with 512B blocks. To cater for both, align to the largest of the two. 58 */ 59 #define BLOCK_SIZE 0x2000 60 61 struct boot_img { 62 struct boot_file_head header; 63 char code[SRAM_LOAD_MAX_SIZE]; 64 char pad[BLOCK_SIZE]; 65 }; 66 67 int main(int argc, char *argv[]) 68 { 69 int fd_in, fd_out; 70 struct boot_img img; 71 unsigned file_size; 72 int count; 73 74 if (argc < 2) { 75 printf("\tThis program makes an input bin file to sun4i " \ 76 "bootable image.\n" \ 77 "\tUsage: %s input_file out_putfile\n", argv[0]); 78 return EXIT_FAILURE; 79 } 80 81 fd_in = open(argv[1], O_RDONLY); 82 if (fd_in < 0) { 83 perror("Open input file"); 84 return EXIT_FAILURE; 85 } 86 87 memset(&img, 0, sizeof(img)); 88 89 /* get input file size */ 90 file_size = lseek(fd_in, 0, SEEK_END); 91 92 if (file_size > SRAM_LOAD_MAX_SIZE) { 93 fprintf(stderr, "ERROR: File too large!\n"); 94 return EXIT_FAILURE; 95 } 96 97 fd_out = open(argv[2], O_WRONLY | O_CREAT, 0666); 98 if (fd_out < 0) { 99 perror("Open output file"); 100 return EXIT_FAILURE; 101 } 102 103 /* read file to buffer to calculate checksum */ 104 lseek(fd_in, 0, SEEK_SET); 105 count = read(fd_in, img.code, file_size); 106 if (count != file_size) { 107 perror("Reading input image"); 108 return EXIT_FAILURE; 109 } 110 111 /* fill the header */ 112 img.header.b_instruction = /* b instruction */ 113 0xEA000000 | /* jump to the first instr after the header */ 114 ((sizeof(struct boot_file_head) / sizeof(int) - 2) 115 & 0x00FFFFFF); 116 memcpy(img.header.magic, BOOT0_MAGIC, 8); /* no '0' termination */ 117 img.header.length = 118 ALIGN(file_size + sizeof(struct boot_file_head), BLOCK_SIZE); 119 img.header.b_instruction = cpu_to_le32(img.header.b_instruction); 120 img.header.length = cpu_to_le32(img.header.length); 121 122 memcpy(img.header.spl_signature, SPL_SIGNATURE, 3); /* "sunxi" marker */ 123 img.header.spl_signature[3] = SPL_HEADER_VERSION; 124 125 gen_check_sum(&img.header); 126 127 count = write(fd_out, &img, le32_to_cpu(img.header.length)); 128 if (count != le32_to_cpu(img.header.length)) { 129 perror("Writing output"); 130 return EXIT_FAILURE; 131 } 132 133 close(fd_in); 134 close(fd_out); 135 136 return EXIT_SUCCESS; 137 } 138