1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
6 * (C) 2017 Theobroma Systems Design und Consulting GmbH
8 * Helper functions for Rockchip images
11 #include "imagetool.h"
13 #include <u-boot/sha256.h>
19 RK_MAGIC = 0x0ff0aa55,
20 RK_MAGIC_V2 = 0x534E4B52,
37 * @size_and_off: [31:16]image size;[15:0]image offset
38 * @address: default as 0xFFFFFFFF
41 * @hash: hash of image
45 uint32_t size_and_off;
54 * struct header0_info_v2 - v2 header block for rockchip BootRom
56 * This is stored at SD card block 64 (where each block is 512 bytes)
58 * @magic: Magic (must be RK_MAGIC_V2)
59 * @size_and_nimage: [31:16]number of images;[15:0]
60 * offset to hash field of header(unit as 4Byte)
61 * @boot_flag: [3:0]hash type(0:none,1:sha256,2:sha512)
62 * @signature: hash or signature for header info
65 struct header0_info_v2 {
68 uint32_t size_and_nimage;
70 uint8_t reserved1[104];
71 struct image_entry images[4];
72 uint8_t reserved2[1064];
77 * struct header0_info - header block for boot ROM
79 * This is stored at SD card block 64 (where each block is 512 bytes, or at
80 * the start of SPI flash. It is encoded with RC4.
82 * @magic: Magic (must be RK_MAGIC)
83 * @disable_rc4: 0 to use rc4 for boot image, 1 to use plain binary
84 * @init_offset: Offset in blocks of the SPL code from this header
85 * block. E.g. 4 means 2KB after the start of this header.
86 * Other fields are not used by U-Boot
93 uint8_t reserved1[492];
95 uint16_t init_boot_size;
100 * struct header1_info
102 struct header1_info {
107 * struct spl_info - spl info for each chip
109 * @imagename: Image name(passed by "mkimage -n")
110 * @spl_hdr: Boot ROM requires a 4-bytes spl header
111 * @spl_size: Spl size(include extra 4-bytes spl header)
112 * @spl_rc4: RC4 encode the SPL binary (same key as header)
113 * @header_ver: header block version
116 const char *imagename;
118 const uint32_t spl_size;
120 const uint32_t header_ver;
123 static struct spl_info spl_infos[] = {
124 { "px30", "RK33", 0x2800, false, RK_HEADER_V1 },
125 { "rk3036", "RK30", 0x1000, false, RK_HEADER_V1 },
126 { "rk3128", "RK31", 0x1800, false, RK_HEADER_V1 },
127 { "rk3188", "RK31", 0x8000 - 0x800, true, RK_HEADER_V1 },
128 { "rk322x", "RK32", 0x8000 - 0x1000, false, RK_HEADER_V1 },
129 { "rk3288", "RK32", 0x8000, false, RK_HEADER_V1 },
130 { "rk3308", "RK33", 0x40000 - 0x1000, false, RK_HEADER_V1 },
131 { "rk3328", "RK32", 0x8000 - 0x1000, false, RK_HEADER_V1 },
132 { "rk3368", "RK33", 0x8000 - 0x1000, false, RK_HEADER_V1 },
133 { "rk3399", "RK33", 0x30000 - 0x2000, false, RK_HEADER_V1 },
134 { "rv1108", "RK11", 0x1800, false, RK_HEADER_V1 },
135 { "rk3568", "RK35", 0x14000 - 0x1000, false, RK_HEADER_V2 },
139 * struct spl_params - spl params parsed in check_params()
141 * @init_file: Init data file path
142 * @init_size: Aligned size of init data in bytes
143 * @boot_file: Boot data file path
144 * @boot_size: Aligned size of boot data in bytes
154 static struct spl_params spl_params = { 0 };
156 static unsigned char rc4_key[16] = {
157 124, 78, 3, 4, 85, 5, 9, 7,
158 45, 44, 123, 56, 23, 13, 23, 17
161 static struct spl_info *rkcommon_get_spl_info(char *imagename)
168 for (i = 0; i < ARRAY_SIZE(spl_infos); i++)
169 if (!strncmp(imagename, spl_infos[i].imagename, 6))
170 return spl_infos + i;
175 static int rkcommon_get_aligned_size(struct image_tool_params *params,
180 size = imagetool_get_filesize(params, fname);
185 * Pad to a 2KB alignment, as required for init/boot size by the ROM
186 * (see https://lists.denx.de/pipermail/u-boot/2017-May/293268.html)
188 return ROUND(size, RK_SIZE_ALIGN);
191 int rkcommon_check_params(struct image_tool_params *params)
196 * If this is a operation (list or extract), the don't require
197 * imagename to be set.
199 if (params->lflag || params->iflag)
202 if (!rkcommon_get_spl_info(params->imagename))
205 spl_params.init_file = params->datafile;
207 spl_params.boot_file = strchr(spl_params.init_file, ':');
208 if (spl_params.boot_file) {
209 *spl_params.boot_file = '\0';
210 spl_params.boot_file += 1;
213 size = rkcommon_get_aligned_size(params, spl_params.init_file);
216 spl_params.init_size = size;
218 /* Boot file is optional, and only for back-to-bootrom functionality. */
219 if (spl_params.boot_file) {
220 size = rkcommon_get_aligned_size(params, spl_params.boot_file);
223 spl_params.boot_size = size;
226 if (spl_params.init_size > rkcommon_get_spl_size(params)) {
228 "Error: SPL image is too large (size %#x than %#x)\n",
229 spl_params.init_size, rkcommon_get_spl_size(params));
236 fprintf(stderr, "ERROR: imagename (%s) is not supported!\n",
237 params->imagename ? params->imagename : "NULL");
239 fprintf(stderr, "Available imagename:");
240 for (i = 0; i < ARRAY_SIZE(spl_infos); i++)
241 fprintf(stderr, "\t%s", spl_infos[i].imagename);
242 fprintf(stderr, "\n");
247 const char *rkcommon_get_spl_hdr(struct image_tool_params *params)
249 struct spl_info *info = rkcommon_get_spl_info(params->imagename);
252 * info would not be NULL, because of we checked params before.
254 return info->spl_hdr;
257 int rkcommon_get_spl_size(struct image_tool_params *params)
259 struct spl_info *info = rkcommon_get_spl_info(params->imagename);
262 * info would not be NULL, because of we checked params before.
264 return info->spl_size;
267 bool rkcommon_need_rc4_spl(struct image_tool_params *params)
269 struct spl_info *info = rkcommon_get_spl_info(params->imagename);
272 * info would not be NULL, because of we checked params before.
274 return info->spl_rc4;
277 bool rkcommon_is_header_v2(struct image_tool_params *params)
279 struct spl_info *info = rkcommon_get_spl_info(params->imagename);
281 return (info->header_ver == RK_HEADER_V2);
284 static void do_sha256_hash(uint8_t *buf, uint32_t size, uint8_t *out)
289 sha256_update(&ctx, buf, size);
290 sha256_finish(&ctx, out);
293 static void rkcommon_set_header0(void *buf, struct image_tool_params *params)
295 struct header0_info *hdr = buf;
296 uint32_t init_boot_size;
298 memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE);
299 hdr->magic = cpu_to_le32(RK_MAGIC);
300 hdr->disable_rc4 = cpu_to_le32(!rkcommon_need_rc4_spl(params));
301 hdr->init_offset = cpu_to_le16(RK_INIT_OFFSET);
302 hdr->init_size = cpu_to_le16(spl_params.init_size / RK_BLK_SIZE);
305 * init_boot_size needs to be set, as it is read by the BootROM
306 * to determine the size of the next-stage bootloader (e.g. U-Boot
307 * proper), when used with the back-to-bootrom functionality.
309 * see https://lists.denx.de/pipermail/u-boot/2017-May/293267.html
310 * for a more detailed explanation by Andy Yan
312 if (spl_params.boot_file)
313 init_boot_size = spl_params.init_size + spl_params.boot_size;
315 init_boot_size = spl_params.init_size + RK_MAX_BOOT_SIZE;
316 hdr->init_boot_size = cpu_to_le16(init_boot_size / RK_BLK_SIZE);
318 rc4_encode(buf, RK_BLK_SIZE, rc4_key);
321 static void rkcommon_set_header0_v2(void *buf, struct image_tool_params *params)
323 struct header0_info_v2 *hdr = buf;
324 uint32_t sector_offset, image_sector_count;
325 uint32_t image_size_array[2];
326 uint8_t *image_ptr = NULL;
329 printf("Image Type: Rockchip %s boot image\n",
330 rkcommon_get_spl_hdr(params));
331 memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE);
332 hdr->magic = cpu_to_le32(RK_MAGIC_V2);
333 hdr->size_and_nimage = cpu_to_le32((2 << 16) + 384);
334 hdr->boot_flag = cpu_to_le32(HASH_SHA256);
336 image_size_array[0] = spl_params.init_size;
337 image_size_array[1] = spl_params.boot_size;
339 for (i = 0; i < 2; i++) {
340 image_sector_count = image_size_array[i] / RK_BLK_SIZE;
341 hdr->images[i].size_and_off = cpu_to_le32((image_sector_count
342 << 16) + sector_offset);
343 hdr->images[i].address = 0xFFFFFFFF;
344 hdr->images[i].counter = cpu_to_le32(i + 1);
345 image_ptr = buf + sector_offset * RK_BLK_SIZE;
346 do_sha256_hash(image_ptr, image_size_array[i],
347 hdr->images[i].hash);
348 sector_offset = sector_offset + image_sector_count;
351 do_sha256_hash(buf, (void *)hdr->hash - buf, hdr->hash);
354 void rkcommon_set_header(void *buf, struct stat *sbuf, int ifd,
355 struct image_tool_params *params)
357 struct header1_info *hdr = buf + RK_SPL_HDR_START;
359 if (rkcommon_is_header_v2(params)) {
360 rkcommon_set_header0_v2(buf, params);
362 rkcommon_set_header0(buf, params);
364 /* Set up the SPL name (i.e. copy spl_hdr over) */
365 if (memcmp(&hdr->magic, "RSAK", 4))
366 memcpy(&hdr->magic, rkcommon_get_spl_hdr(params), RK_SPL_HDR_SIZE);
368 if (rkcommon_need_rc4_spl(params))
369 rkcommon_rc4_encode_spl(buf, RK_SPL_HDR_START,
370 spl_params.init_size);
372 if (spl_params.boot_file) {
373 if (rkcommon_need_rc4_spl(params))
374 rkcommon_rc4_encode_spl(buf + RK_SPL_HDR_START,
375 spl_params.init_size,
376 spl_params.boot_size);
381 static inline unsigned int rkcommon_offset_to_spi(unsigned int offset)
384 * While SD/MMC images use a flat addressing, SPI images are padded
385 * to use the first 2K of every 4K sector only.
387 return ((offset & ~0x7ff) << 1) + (offset & 0x7ff);
390 static int rkcommon_parse_header(const void *buf, struct header0_info *header0,
391 struct spl_info **spl_info)
393 unsigned int hdr1_offset;
394 struct header1_info *hdr1_sdmmc, *hdr1_spi;
401 * The first header (hdr0) is always RC4 encoded, so try to decrypt
402 * with the well-known key.
404 memcpy((void *)header0, buf, sizeof(struct header0_info));
405 rc4_encode((void *)header0, sizeof(struct header0_info), rc4_key);
407 if (le32_to_cpu(header0->magic) != RK_MAGIC)
410 /* We don't support RC4 encoded image payloads here, yet... */
411 if (le32_to_cpu(header0->disable_rc4) == 0)
414 hdr1_offset = le16_to_cpu(header0->init_offset) * RK_BLK_SIZE;
415 hdr1_sdmmc = (struct header1_info *)(buf + hdr1_offset);
416 hdr1_spi = (struct header1_info *)(buf +
417 rkcommon_offset_to_spi(hdr1_offset));
419 for (i = 0; i < ARRAY_SIZE(spl_infos); i++) {
420 if (!memcmp(&hdr1_sdmmc->magic, spl_infos[i].spl_hdr,
423 *spl_info = &spl_infos[i];
425 } else if (!memcmp(&hdr1_spi->magic, spl_infos[i].spl_hdr,
428 *spl_info = &spl_infos[i];
429 return IH_TYPE_RKSPI;
436 static int rkcommon_parse_header_v2(const void *buf, struct header0_info_v2 *header)
438 memcpy((void *)header, buf, sizeof(struct header0_info_v2));
440 if (le32_to_cpu(header->magic) != RK_MAGIC_V2)
446 int rkcommon_verify_header(unsigned char *buf, int size,
447 struct image_tool_params *params)
449 struct header0_info header0;
450 struct spl_info *img_spl_info, *spl_info;
453 ret = rkcommon_parse_header(buf, &header0, &img_spl_info);
455 /* If this is the (unimplemented) RC4 case, then rewrite the result */
463 * If no 'imagename' is specified via the commandline (e.g. if this is
464 * 'dumpimage -l' w/o any further constraints), we accept any spl_info.
466 if (params->imagename == NULL)
469 /* Match the 'imagename' against the 'spl_hdr' found */
470 spl_info = rkcommon_get_spl_info(params->imagename);
471 if (spl_info && img_spl_info)
472 return strcmp(spl_info->spl_hdr, img_spl_info->spl_hdr);
477 void rkcommon_print_header(const void *buf)
479 struct header0_info header0;
480 struct header0_info_v2 header0_v2;
481 struct spl_info *spl_info;
483 int ret, boot_size, init_size;
485 if ((*(uint32_t *)buf) == RK_MAGIC_V2) {
486 ret = rkcommon_parse_header_v2(buf, &header0_v2);
489 fprintf(stderr, "Error: image verification failed\n");
493 init_size = header0_v2.images[0].size_and_off >> 16;
494 init_size = init_size * RK_BLK_SIZE;
495 boot_size = header0_v2.images[1].size_and_off >> 16;
496 boot_size = boot_size * RK_BLK_SIZE;
498 ret = rkcommon_parse_header(buf, &header0, &spl_info);
500 /* If this is the (unimplemented) RC4 case, then fail silently */
505 fprintf(stderr, "Error: image verification failed\n");
510 init_size = header0.init_size * RK_BLK_SIZE;
511 boot_size = header0.init_boot_size * RK_BLK_SIZE - init_size;
513 printf("Image Type: Rockchip %s (%s) boot image\n",
515 (image_type == IH_TYPE_RKSD) ? "SD/MMC" : "SPI");
518 printf("Init Data Size: %d bytes\n", init_size);
520 if (boot_size != RK_MAX_BOOT_SIZE)
521 printf("Boot Data Size: %d bytes\n", boot_size);
524 void rkcommon_rc4_encode_spl(void *buf, unsigned int offset, unsigned int size)
526 unsigned int remaining = size;
528 while (remaining > 0) {
529 int step = (remaining > RK_BLK_SIZE) ? RK_BLK_SIZE : remaining;
531 rc4_encode(buf + offset, step, rc4_key);
532 offset += RK_BLK_SIZE;
537 int rkcommon_vrec_header(struct image_tool_params *params,
538 struct image_type_params *tparams)
541 * The SPL image looks as follows:
543 * 0x0 header0 (see rkcommon.c)
544 * 0x800 spl_name ('RK30', ..., 'RK33')
545 * (start of the payload for AArch64 payloads: we expect the
546 * first 4 bytes to be available for overwriting with our
548 * 0x804 first instruction to be executed
549 * (start of the image/payload for 32bit payloads)
551 * For AArch64 (ARMv8) payloads, natural alignment (8-bytes) is
552 * required for its sections (so the image we receive needs to
553 * have the first 4 bytes reserved for the spl_name). Reserving
554 * these 4 bytes is done using the BOOT0_HOOK infrastructure.
556 * The header is always at 0x800 (as we now use a payload
557 * prepadded using the boot0 hook for all targets): the first
558 * 4 bytes of these images can safely be overwritten using the
561 tparams->header_size = RK_SPL_HDR_START;
563 /* Allocate, clear and install the header */
564 tparams->hdr = malloc(tparams->header_size);
566 fprintf(stderr, "%s: Can't alloc header: %s\n",
567 params->cmdname, strerror(errno));
570 memset(tparams->hdr, 0, tparams->header_size);
573 * We need to store the original file-size (i.e. before padding), as
574 * imagetool does not set this during its adjustment of file_size.
576 params->orig_file_size = tparams->header_size +
577 spl_params.init_size + spl_params.boot_size;
579 params->file_size = ROUND(params->orig_file_size, RK_SIZE_ALIGN);
581 /* Ignoring pad len, since we are using our own copy_image() */
585 static int pad_file(struct image_tool_params *params, int ifd, int pad)
589 memset(zeros, 0, sizeof(zeros));
592 int todo = sizeof(zeros);
596 if (write(ifd, (char *)&zeros, todo) != todo) {
597 fprintf(stderr, "%s: Write error on %s: %s\n",
598 params->cmdname, params->imagefile,
608 static int copy_file(struct image_tool_params *params, int ifd,
609 const char *file, int padded_size)
617 fprintf(stderr, "Adding Image %s\n", file);
619 dfd = open(file, O_RDONLY | O_BINARY);
621 fprintf(stderr, "%s: Can't open %s: %s\n",
622 params->cmdname, file, strerror(errno));
626 if (fstat(dfd, &sbuf) < 0) {
627 fprintf(stderr, "%s: Can't stat %s: %s\n",
628 params->cmdname, file, strerror(errno));
633 fprintf(stderr, "Size %u(pad to %u)\n",
634 (int)sbuf.st_size, padded_size);
636 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
637 if (ptr == MAP_FAILED) {
638 fprintf(stderr, "%s: Can't read %s: %s\n",
639 params->cmdname, file, strerror(errno));
644 if (write(ifd, ptr, size) != size) {
645 fprintf(stderr, "%s: Write error on %s: %s\n",
646 params->cmdname, params->imagefile, strerror(errno));
650 munmap((void *)ptr, sbuf.st_size);
652 return pad_file(params, ifd, padded_size - size);
655 munmap((void *)ptr, sbuf.st_size);
661 int rockchip_copy_image(int ifd, struct image_tool_params *params)
665 ret = copy_file(params, ifd, spl_params.init_file,
666 spl_params.init_size);
670 if (spl_params.boot_file) {
671 ret = copy_file(params, ifd, spl_params.boot_file,
672 spl_params.boot_size);
677 return pad_file(params, ifd,
678 params->file_size - params->orig_file_size);