1 /* 2 * Copyright 2012 Freescale Semiconductor, Inc. 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 #include "mkimage.h" 7 #include <image.h> 8 #include "pblimage.h" 9 10 /* 11 * Initialize to an invalid value. 12 */ 13 static uint32_t next_pbl_cmd = 0x82000000; 14 /* 15 * need to store all bytes in memory for calculating crc32, then write the 16 * bytes to image file for PBL boot. 17 */ 18 static unsigned char mem_buf[1000000]; 19 static unsigned char *pmem_buf = mem_buf; 20 static int pbl_size; 21 static char *fname = "Unknown"; 22 static int lineno = -1; 23 static struct pbl_header pblimage_header; 24 25 static union 26 { 27 char c[4]; 28 unsigned char l; 29 } endian_test = { {'l', '?', '?', 'b'} }; 30 31 #define ENDIANNESS ((char)endian_test.l) 32 33 /* 34 * The PBL can load up to 64 bytes at a time, so we split the U-Boot 35 * image into 64 byte chunks. PBL needs a command for each piece, of 36 * the form "81xxxxxx", where "xxxxxx" is the offset. Calculate the 37 * start offset by subtracting the size of the u-boot image from the 38 * top of the allowable 24-bit range. 39 */ 40 static void init_next_pbl_cmd(FILE *fp_uboot) 41 { 42 struct stat st; 43 int fd = fileno(fp_uboot); 44 45 if (fstat(fd, &st) == -1) { 46 printf("Error: Could not determine u-boot image size. %s\n", 47 strerror(errno)); 48 exit(EXIT_FAILURE); 49 } 50 51 next_pbl_cmd = 0x82000000 - st.st_size; 52 } 53 54 static void generate_pbl_cmd(void) 55 { 56 uint32_t val = next_pbl_cmd; 57 next_pbl_cmd += 0x40; 58 int i; 59 60 for (i = 3; i >= 0; i--) { 61 *pmem_buf++ = (val >> (i * 8)) & 0xff; 62 pbl_size++; 63 } 64 } 65 66 static void pbl_fget(size_t size, FILE *stream) 67 { 68 unsigned char c; 69 int c_temp; 70 71 while (size && (c_temp = fgetc(stream)) != EOF) { 72 c = (unsigned char)c_temp; 73 *pmem_buf++ = c; 74 pbl_size++; 75 size--; 76 } 77 } 78 79 /* load split u-boot with PBI command 81xxxxxx. */ 80 static void load_uboot(FILE *fp_uboot) 81 { 82 init_next_pbl_cmd(fp_uboot); 83 while (next_pbl_cmd < 0x82000000) { 84 generate_pbl_cmd(); 85 pbl_fget(64, fp_uboot); 86 } 87 } 88 89 static void check_get_hexval(char *token) 90 { 91 uint32_t hexval; 92 int i; 93 94 if (!sscanf(token, "%x", &hexval)) { 95 printf("Error:%s[%d] - Invalid hex data(%s)\n", fname, 96 lineno, token); 97 exit(EXIT_FAILURE); 98 } 99 for (i = 3; i >= 0; i--) { 100 *pmem_buf++ = (hexval >> (i * 8)) & 0xff; 101 pbl_size++; 102 } 103 } 104 105 static void pbl_parser(char *name) 106 { 107 FILE *fd = NULL; 108 char *line = NULL; 109 char *token, *saveptr1, *saveptr2; 110 size_t len = 0; 111 112 fname = name; 113 fd = fopen(name, "r"); 114 if (fd == NULL) { 115 printf("Error:%s - Can't open\n", fname); 116 exit(EXIT_FAILURE); 117 } 118 119 while ((getline(&line, &len, fd)) > 0) { 120 lineno++; 121 token = strtok_r(line, "\r\n", &saveptr1); 122 /* drop all lines with zero tokens (= empty lines) */ 123 if (token == NULL) 124 continue; 125 for (line = token;; line = NULL) { 126 token = strtok_r(line, " \t", &saveptr2); 127 if (token == NULL) 128 break; 129 /* Drop all text starting with '#' as comments */ 130 if (token[0] == '#') 131 break; 132 check_get_hexval(token); 133 } 134 } 135 if (line) 136 free(line); 137 fclose(fd); 138 } 139 140 static uint32_t crc_table[256]; 141 142 static void make_crc_table(void) 143 { 144 uint32_t mask; 145 int i, j; 146 uint32_t poly; /* polynomial exclusive-or pattern */ 147 148 /* 149 * the polynomial used by PBL is 1 + x1 + x2 + x4 + x5 + x7 + x8 + x10 150 * + x11 + x12 + x16 + x22 + x23 + x26 + x32. 151 */ 152 poly = 0x04c11db7; 153 154 for (i = 0; i < 256; i++) { 155 mask = i << 24; 156 for (j = 0; j < 8; j++) { 157 if (mask & 0x80000000) 158 mask = (mask << 1) ^ poly; 159 else 160 mask <<= 1; 161 } 162 crc_table[i] = mask; 163 } 164 } 165 166 unsigned long pbl_crc32(unsigned long crc, const char *buf, uint32_t len) 167 { 168 uint32_t crc32_val = 0xffffffff; 169 uint32_t xor = 0x0; 170 int i; 171 172 make_crc_table(); 173 174 for (i = 0; i < len; i++) 175 crc32_val = (crc32_val << 8) ^ 176 crc_table[(crc32_val >> 24) ^ (*buf++ & 0xff)]; 177 178 crc32_val = crc32_val ^ xor; 179 if (crc32_val < 0) { 180 crc32_val += 0xffffffff; 181 crc32_val += 1; 182 } 183 return crc32_val; 184 } 185 186 static uint32_t reverse_byte(uint32_t val) 187 { 188 uint32_t temp; 189 unsigned char *p1; 190 int j; 191 192 temp = val; 193 p1 = (unsigned char *)&temp; 194 for (j = 3; j >= 0; j--) 195 *p1++ = (val >> (j * 8)) & 0xff; 196 return temp; 197 } 198 199 /* write end command and crc command to memory. */ 200 static void add_end_cmd(void) 201 { 202 uint32_t pbl_end_cmd[4] = {0x09138000, 0x00000000, 203 0x091380c0, 0x00000000}; 204 uint32_t crc32_pbl; 205 int i; 206 unsigned char *p = (unsigned char *)&pbl_end_cmd; 207 208 if (ENDIANNESS == 'l') { 209 for (i = 0; i < 4; i++) 210 pbl_end_cmd[i] = reverse_byte(pbl_end_cmd[i]); 211 } 212 213 for (i = 0; i < 16; i++) { 214 *pmem_buf++ = *p++; 215 pbl_size++; 216 } 217 218 /* Add PBI CRC command. */ 219 *pmem_buf++ = 0x08; 220 *pmem_buf++ = 0x13; 221 *pmem_buf++ = 0x80; 222 *pmem_buf++ = 0x40; 223 pbl_size += 4; 224 225 /* calculated CRC32 and write it to memory. */ 226 crc32_pbl = pbl_crc32(0, (const char *)mem_buf, pbl_size); 227 *pmem_buf++ = (crc32_pbl >> 24) & 0xff; 228 *pmem_buf++ = (crc32_pbl >> 16) & 0xff; 229 *pmem_buf++ = (crc32_pbl >> 8) & 0xff; 230 *pmem_buf++ = (crc32_pbl) & 0xff; 231 pbl_size += 4; 232 233 if ((pbl_size % 16) != 0) { 234 for (i = 0; i < 8; i++) { 235 *pmem_buf++ = 0x0; 236 pbl_size++; 237 } 238 } 239 if ((pbl_size % 16 != 0)) { 240 printf("Error: Bad size of image file\n"); 241 exit(EXIT_FAILURE); 242 } 243 } 244 245 void pbl_load_uboot(int ifd, struct mkimage_params *params) 246 { 247 FILE *fp_uboot; 248 int size; 249 250 /* parse the rcw.cfg file. */ 251 pbl_parser(params->imagename); 252 253 /* parse the pbi.cfg file. */ 254 pbl_parser(params->imagename2); 255 256 fp_uboot = fopen(params->datafile, "r"); 257 if (fp_uboot == NULL) { 258 printf("Error: %s open failed\n", params->datafile); 259 exit(EXIT_FAILURE); 260 } 261 262 load_uboot(fp_uboot); 263 add_end_cmd(); 264 fclose(fp_uboot); 265 lseek(ifd, 0, SEEK_SET); 266 267 size = pbl_size; 268 if (write(ifd, (const void *)&mem_buf, size) != size) { 269 fprintf(stderr, "Write error on %s: %s\n", 270 params->imagefile, strerror(errno)); 271 exit(EXIT_FAILURE); 272 } 273 } 274 275 static int pblimage_check_image_types(uint8_t type) 276 { 277 if (type == IH_TYPE_PBLIMAGE) 278 return EXIT_SUCCESS; 279 else 280 return EXIT_FAILURE; 281 } 282 283 static int pblimage_verify_header(unsigned char *ptr, int image_size, 284 struct mkimage_params *params) 285 { 286 struct pbl_header *pbl_hdr = (struct pbl_header *) ptr; 287 288 /* Only a few checks can be done: search for magic numbers */ 289 if (ENDIANNESS == 'l') { 290 if (pbl_hdr->preamble != reverse_byte(RCW_PREAMBLE)) 291 return -FDT_ERR_BADSTRUCTURE; 292 293 if (pbl_hdr->rcwheader != reverse_byte(RCW_HEADER)) 294 return -FDT_ERR_BADSTRUCTURE; 295 } else { 296 if (pbl_hdr->preamble != RCW_PREAMBLE) 297 return -FDT_ERR_BADSTRUCTURE; 298 299 if (pbl_hdr->rcwheader != RCW_HEADER) 300 return -FDT_ERR_BADSTRUCTURE; 301 } 302 return 0; 303 } 304 305 static void pblimage_print_header(const void *ptr) 306 { 307 printf("Image Type: Freescale PBL Boot Image\n"); 308 } 309 310 static void pblimage_set_header(void *ptr, struct stat *sbuf, int ifd, 311 struct mkimage_params *params) 312 { 313 /*nothing need to do, pbl_load_uboot takes care of whole file. */ 314 } 315 316 /* pblimage parameters */ 317 static struct image_type_params pblimage_params = { 318 .name = "Freescale PBL Boot Image support", 319 .header_size = sizeof(struct pbl_header), 320 .hdr = (void *)&pblimage_header, 321 .check_image_type = pblimage_check_image_types, 322 .verify_header = pblimage_verify_header, 323 .print_header = pblimage_print_header, 324 .set_header = pblimage_set_header, 325 }; 326 327 void init_pbl_image_type(void) 328 { 329 pbl_size = 0; 330 mkimage_register(&pblimage_params); 331 } 332