Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2015 Google, Inc |
| 4 | * Written by Simon Glass <sjg@chromium.org> |
| 5 | * |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 6 | * (C) 2017 Theobroma Systems Design und Consulting GmbH |
| 7 | * |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 8 | * Helper functions for Rockchip images |
| 9 | */ |
| 10 | |
| 11 | #include "imagetool.h" |
| 12 | #include <image.h> |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 13 | #include <u-boot/sha256.h> |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 14 | #include <rc4.h> |
| 15 | #include "mkimage.h" |
| 16 | #include "rkcommon.h" |
| 17 | |
| 18 | enum { |
Kever Yang | d7a4461 | 2021-12-24 17:58:32 +0800 | [diff] [blame] | 19 | RK_MAGIC = 0x0ff0aa55, |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 20 | RK_MAGIC_V2 = 0x534E4B52, |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 21 | }; |
| 22 | |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 23 | enum { |
| 24 | RK_HEADER_V1 = 1, |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 25 | RK_HEADER_V2 = 2, |
| 26 | }; |
| 27 | |
| 28 | enum hash_type { |
| 29 | HASH_NONE = 0, |
| 30 | HASH_SHA256 = 1, |
| 31 | HASH_SHA512 = 2, |
| 32 | }; |
| 33 | |
| 34 | /** |
| 35 | * struct image_entry |
| 36 | * |
| 37 | * @size_and_off: [31:16]image size;[15:0]image offset |
| 38 | * @address: default as 0xFFFFFFFF |
| 39 | * @flag: no use |
| 40 | * @counter: no use |
| 41 | * @hash: hash of image |
| 42 | * |
| 43 | */ |
| 44 | struct image_entry { |
| 45 | uint32_t size_and_off; |
| 46 | uint32_t address; |
| 47 | uint32_t flag; |
| 48 | uint32_t counter; |
| 49 | uint8_t reserved[8]; |
| 50 | uint8_t hash[64]; |
| 51 | }; |
| 52 | |
| 53 | /** |
| 54 | * struct header0_info_v2 - v2 header block for rockchip BootRom |
| 55 | * |
| 56 | * This is stored at SD card block 64 (where each block is 512 bytes) |
| 57 | * |
| 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 |
| 63 | * |
| 64 | */ |
| 65 | struct header0_info_v2 { |
| 66 | uint32_t magic; |
| 67 | uint8_t reserved[4]; |
| 68 | uint32_t size_and_nimage; |
| 69 | uint32_t boot_flag; |
| 70 | uint8_t reserved1[104]; |
| 71 | struct image_entry images[4]; |
| 72 | uint8_t reserved2[1064]; |
| 73 | uint8_t hash[512]; |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 74 | }; |
| 75 | |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 76 | /** |
| 77 | * struct header0_info - header block for boot ROM |
| 78 | * |
| 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. |
| 81 | * |
Kever Yang | d7a4461 | 2021-12-24 17:58:32 +0800 | [diff] [blame] | 82 | * @magic: Magic (must be RK_MAGIC) |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 83 | * @disable_rc4: 0 to use rc4 for boot image, 1 to use plain binary |
Jeffy Chen | 3641339 | 2015-11-17 14:20:30 +0800 | [diff] [blame] | 84 | * @init_offset: Offset in blocks of the SPL code from this header |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 85 | * block. E.g. 4 means 2KB after the start of this header. |
| 86 | * Other fields are not used by U-Boot |
| 87 | */ |
| 88 | struct header0_info { |
Kever Yang | d7a4461 | 2021-12-24 17:58:32 +0800 | [diff] [blame] | 89 | uint32_t magic; |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 90 | uint8_t reserved[4]; |
| 91 | uint32_t disable_rc4; |
Jeffy Chen | 3641339 | 2015-11-17 14:20:30 +0800 | [diff] [blame] | 92 | uint16_t init_offset; |
| 93 | uint8_t reserved1[492]; |
| 94 | uint16_t init_size; |
| 95 | uint16_t init_boot_size; |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 96 | uint8_t reserved2[2]; |
| 97 | }; |
| 98 | |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 99 | /** |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 100 | * struct header1_info |
| 101 | */ |
| 102 | struct header1_info { |
| 103 | uint32_t magic; |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 104 | }; |
| 105 | |
| 106 | /** |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 107 | * struct spl_info - spl info for each chip |
| 108 | * |
| 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) |
Heiko Stübner | cfbcdad | 2017-02-18 19:46:27 +0100 | [diff] [blame] | 112 | * @spl_rc4: RC4 encode the SPL binary (same key as header) |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 113 | * @header_ver: header block version |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 114 | */ |
| 115 | struct spl_info { |
| 116 | const char *imagename; |
| 117 | const char *spl_hdr; |
| 118 | const uint32_t spl_size; |
Heiko Stübner | cfbcdad | 2017-02-18 19:46:27 +0100 | [diff] [blame] | 119 | const bool spl_rc4; |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 120 | const uint32_t header_ver; |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 121 | }; |
| 122 | |
| 123 | static struct spl_info spl_infos[] = { |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 124 | { "px30", "RK33", 0x2800, false, RK_HEADER_V1 }, |
| 125 | { "rk3036", "RK30", 0x1000, false, RK_HEADER_V1 }, |
Johan Jonker | 0034f1d | 2022-04-16 17:09:46 +0200 | [diff] [blame] | 126 | { "rk3066", "RK30", 0x8000 - 0x800, true, RK_HEADER_V1 }, |
Kever Yang | 0faa7da | 2021-12-24 18:00:36 +0800 | [diff] [blame] | 127 | { "rk3128", "RK31", 0x1800, false, RK_HEADER_V1 }, |
| 128 | { "rk3188", "RK31", 0x8000 - 0x800, true, RK_HEADER_V1 }, |
| 129 | { "rk322x", "RK32", 0x8000 - 0x1000, false, RK_HEADER_V1 }, |
| 130 | { "rk3288", "RK32", 0x8000, false, RK_HEADER_V1 }, |
| 131 | { "rk3308", "RK33", 0x40000 - 0x1000, false, RK_HEADER_V1 }, |
| 132 | { "rk3328", "RK32", 0x8000 - 0x1000, false, RK_HEADER_V1 }, |
| 133 | { "rk3368", "RK33", 0x8000 - 0x1000, false, RK_HEADER_V1 }, |
| 134 | { "rk3399", "RK33", 0x30000 - 0x2000, false, RK_HEADER_V1 }, |
| 135 | { "rv1108", "RK11", 0x1800, false, RK_HEADER_V1 }, |
Jagan Teki | 6d70d82 | 2022-12-14 23:21:07 +0530 | [diff] [blame^] | 136 | { "rv1126", "110B", 0x10000 - 0x1000, false, RK_HEADER_V1 }, |
Kever Yang | 376b08d | 2021-12-24 18:21:50 +0800 | [diff] [blame] | 137 | { "rk3568", "RK35", 0x14000 - 0x1000, false, RK_HEADER_V2 }, |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 138 | }; |
| 139 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 140 | /** |
| 141 | * struct spl_params - spl params parsed in check_params() |
| 142 | * |
| 143 | * @init_file: Init data file path |
| 144 | * @init_size: Aligned size of init data in bytes |
| 145 | * @boot_file: Boot data file path |
| 146 | * @boot_size: Aligned size of boot data in bytes |
| 147 | */ |
| 148 | |
| 149 | struct spl_params { |
| 150 | char *init_file; |
| 151 | uint32_t init_size; |
| 152 | char *boot_file; |
| 153 | uint32_t boot_size; |
| 154 | }; |
| 155 | |
| 156 | static struct spl_params spl_params = { 0 }; |
| 157 | |
John Keeping | 2c89929 | 2022-11-18 16:13:18 +0000 | [diff] [blame] | 158 | static const unsigned char rc4_key[16] = { |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 159 | 124, 78, 3, 4, 85, 5, 9, 7, |
| 160 | 45, 44, 123, 56, 23, 13, 23, 17 |
| 161 | }; |
| 162 | |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 163 | static struct spl_info *rkcommon_get_spl_info(char *imagename) |
| 164 | { |
| 165 | int i; |
| 166 | |
Philipp Tomsich | 24aae93 | 2017-04-17 17:48:05 +0200 | [diff] [blame] | 167 | if (!imagename) |
| 168 | return NULL; |
| 169 | |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 170 | for (i = 0; i < ARRAY_SIZE(spl_infos); i++) |
| 171 | if (!strncmp(imagename, spl_infos[i].imagename, 6)) |
| 172 | return spl_infos + i; |
| 173 | |
| 174 | return NULL; |
| 175 | } |
| 176 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 177 | static int rkcommon_get_aligned_size(struct image_tool_params *params, |
| 178 | const char *fname) |
| 179 | { |
| 180 | int size; |
| 181 | |
| 182 | size = imagetool_get_filesize(params, fname); |
| 183 | if (size < 0) |
| 184 | return -1; |
| 185 | |
| 186 | /* |
| 187 | * Pad to a 2KB alignment, as required for init/boot size by the ROM |
| 188 | * (see https://lists.denx.de/pipermail/u-boot/2017-May/293268.html) |
| 189 | */ |
| 190 | return ROUND(size, RK_SIZE_ALIGN); |
| 191 | } |
| 192 | |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 193 | int rkcommon_check_params(struct image_tool_params *params) |
| 194 | { |
Heinrich Schuchardt | 69cd0c4 | 2020-05-09 21:31:03 +0200 | [diff] [blame] | 195 | int i, size; |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 196 | |
Philipp Tomsich | 24aae93 | 2017-04-17 17:48:05 +0200 | [diff] [blame] | 197 | /* |
| 198 | * If this is a operation (list or extract), the don't require |
| 199 | * imagename to be set. |
| 200 | */ |
| 201 | if (params->lflag || params->iflag) |
| 202 | return EXIT_SUCCESS; |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 203 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 204 | if (!rkcommon_get_spl_info(params->imagename)) |
| 205 | goto err_spl_info; |
| 206 | |
| 207 | spl_params.init_file = params->datafile; |
| 208 | |
| 209 | spl_params.boot_file = strchr(spl_params.init_file, ':'); |
| 210 | if (spl_params.boot_file) { |
| 211 | *spl_params.boot_file = '\0'; |
| 212 | spl_params.boot_file += 1; |
| 213 | } |
| 214 | |
Heinrich Schuchardt | 69cd0c4 | 2020-05-09 21:31:03 +0200 | [diff] [blame] | 215 | size = rkcommon_get_aligned_size(params, spl_params.init_file); |
| 216 | if (size < 0) |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 217 | return EXIT_FAILURE; |
Heinrich Schuchardt | 69cd0c4 | 2020-05-09 21:31:03 +0200 | [diff] [blame] | 218 | spl_params.init_size = size; |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 219 | |
| 220 | /* Boot file is optional, and only for back-to-bootrom functionality. */ |
| 221 | if (spl_params.boot_file) { |
Heinrich Schuchardt | 69cd0c4 | 2020-05-09 21:31:03 +0200 | [diff] [blame] | 222 | size = rkcommon_get_aligned_size(params, spl_params.boot_file); |
| 223 | if (size < 0) |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 224 | return EXIT_FAILURE; |
Heinrich Schuchardt | 69cd0c4 | 2020-05-09 21:31:03 +0200 | [diff] [blame] | 225 | spl_params.boot_size = size; |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | if (spl_params.init_size > rkcommon_get_spl_size(params)) { |
| 229 | fprintf(stderr, |
| 230 | "Error: SPL image is too large (size %#x than %#x)\n", |
| 231 | spl_params.init_size, rkcommon_get_spl_size(params)); |
| 232 | return EXIT_FAILURE; |
| 233 | } |
| 234 | |
| 235 | return EXIT_SUCCESS; |
| 236 | |
| 237 | err_spl_info: |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 238 | fprintf(stderr, "ERROR: imagename (%s) is not supported!\n", |
Philipp Tomsich | 24aae93 | 2017-04-17 17:48:05 +0200 | [diff] [blame] | 239 | params->imagename ? params->imagename : "NULL"); |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 240 | |
| 241 | fprintf(stderr, "Available imagename:"); |
| 242 | for (i = 0; i < ARRAY_SIZE(spl_infos); i++) |
| 243 | fprintf(stderr, "\t%s", spl_infos[i].imagename); |
| 244 | fprintf(stderr, "\n"); |
| 245 | |
Philipp Tomsich | 24aae93 | 2017-04-17 17:48:05 +0200 | [diff] [blame] | 246 | return EXIT_FAILURE; |
Jeffy Chen | 7bf274b | 2015-11-27 12:07:17 +0800 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | const char *rkcommon_get_spl_hdr(struct image_tool_params *params) |
| 250 | { |
| 251 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); |
| 252 | |
| 253 | /* |
| 254 | * info would not be NULL, because of we checked params before. |
| 255 | */ |
| 256 | return info->spl_hdr; |
| 257 | } |
| 258 | |
| 259 | int rkcommon_get_spl_size(struct image_tool_params *params) |
| 260 | { |
| 261 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); |
| 262 | |
| 263 | /* |
| 264 | * info would not be NULL, because of we checked params before. |
| 265 | */ |
| 266 | return info->spl_size; |
| 267 | } |
| 268 | |
Heiko Stübner | cfbcdad | 2017-02-18 19:46:27 +0100 | [diff] [blame] | 269 | bool rkcommon_need_rc4_spl(struct image_tool_params *params) |
| 270 | { |
| 271 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); |
| 272 | |
| 273 | /* |
| 274 | * info would not be NULL, because of we checked params before. |
| 275 | */ |
| 276 | return info->spl_rc4; |
| 277 | } |
| 278 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 279 | bool rkcommon_is_header_v2(struct image_tool_params *params) |
| 280 | { |
| 281 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); |
| 282 | |
| 283 | return (info->header_ver == RK_HEADER_V2); |
| 284 | } |
| 285 | |
| 286 | static void do_sha256_hash(uint8_t *buf, uint32_t size, uint8_t *out) |
| 287 | { |
| 288 | sha256_context ctx; |
| 289 | |
| 290 | sha256_starts(&ctx); |
| 291 | sha256_update(&ctx, buf, size); |
| 292 | sha256_finish(&ctx, out); |
| 293 | } |
| 294 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 295 | static void rkcommon_set_header0(void *buf, struct image_tool_params *params) |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 296 | { |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 297 | struct header0_info *hdr = buf; |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 298 | uint32_t init_boot_size; |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 299 | |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 300 | memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE); |
Kever Yang | d7a4461 | 2021-12-24 17:58:32 +0800 | [diff] [blame] | 301 | hdr->magic = cpu_to_le32(RK_MAGIC); |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 302 | hdr->disable_rc4 = cpu_to_le32(!rkcommon_need_rc4_spl(params)); |
| 303 | hdr->init_offset = cpu_to_le16(RK_INIT_OFFSET); |
| 304 | hdr->init_size = cpu_to_le16(spl_params.init_size / RK_BLK_SIZE); |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 305 | |
Philipp Tomsich | a1a2dfb | 2017-04-17 17:48:04 +0200 | [diff] [blame] | 306 | /* |
Philipp Tomsich | a1c29d4 | 2017-05-30 23:32:10 +0200 | [diff] [blame] | 307 | * init_boot_size needs to be set, as it is read by the BootROM |
| 308 | * to determine the size of the next-stage bootloader (e.g. U-Boot |
| 309 | * proper), when used with the back-to-bootrom functionality. |
| 310 | * |
| 311 | * see https://lists.denx.de/pipermail/u-boot/2017-May/293267.html |
| 312 | * for a more detailed explanation by Andy Yan |
Philipp Tomsich | a1a2dfb | 2017-04-17 17:48:04 +0200 | [diff] [blame] | 313 | */ |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 314 | if (spl_params.boot_file) |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 315 | init_boot_size = spl_params.init_size + spl_params.boot_size; |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 316 | else |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 317 | init_boot_size = spl_params.init_size + RK_MAX_BOOT_SIZE; |
| 318 | hdr->init_boot_size = cpu_to_le16(init_boot_size / RK_BLK_SIZE); |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 319 | |
| 320 | rc4_encode(buf, RK_BLK_SIZE, rc4_key); |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 321 | } |
| 322 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 323 | static void rkcommon_set_header0_v2(void *buf, struct image_tool_params *params) |
| 324 | { |
| 325 | struct header0_info_v2 *hdr = buf; |
| 326 | uint32_t sector_offset, image_sector_count; |
| 327 | uint32_t image_size_array[2]; |
| 328 | uint8_t *image_ptr = NULL; |
| 329 | int i; |
| 330 | |
| 331 | printf("Image Type: Rockchip %s boot image\n", |
| 332 | rkcommon_get_spl_hdr(params)); |
| 333 | memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE); |
| 334 | hdr->magic = cpu_to_le32(RK_MAGIC_V2); |
| 335 | hdr->size_and_nimage = cpu_to_le32((2 << 16) + 384); |
| 336 | hdr->boot_flag = cpu_to_le32(HASH_SHA256); |
| 337 | sector_offset = 4; |
| 338 | image_size_array[0] = spl_params.init_size; |
| 339 | image_size_array[1] = spl_params.boot_size; |
| 340 | |
| 341 | for (i = 0; i < 2; i++) { |
| 342 | image_sector_count = image_size_array[i] / RK_BLK_SIZE; |
| 343 | hdr->images[i].size_and_off = cpu_to_le32((image_sector_count |
| 344 | << 16) + sector_offset); |
| 345 | hdr->images[i].address = 0xFFFFFFFF; |
| 346 | hdr->images[i].counter = cpu_to_le32(i + 1); |
| 347 | image_ptr = buf + sector_offset * RK_BLK_SIZE; |
| 348 | do_sha256_hash(image_ptr, image_size_array[i], |
| 349 | hdr->images[i].hash); |
| 350 | sector_offset = sector_offset + image_sector_count; |
| 351 | } |
| 352 | |
| 353 | do_sha256_hash(buf, (void *)hdr->hash - buf, hdr->hash); |
| 354 | } |
| 355 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 356 | void rkcommon_set_header(void *buf, struct stat *sbuf, int ifd, |
| 357 | struct image_tool_params *params) |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 358 | { |
| 359 | struct header1_info *hdr = buf + RK_SPL_HDR_START; |
| 360 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 361 | if (rkcommon_is_header_v2(params)) { |
| 362 | rkcommon_set_header0_v2(buf, params); |
| 363 | } else { |
| 364 | rkcommon_set_header0(buf, params); |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 365 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 366 | /* Set up the SPL name (i.e. copy spl_hdr over) */ |
| 367 | if (memcmp(&hdr->magic, "RSAK", 4)) |
| 368 | memcpy(&hdr->magic, rkcommon_get_spl_hdr(params), RK_SPL_HDR_SIZE); |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 369 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 370 | if (rkcommon_need_rc4_spl(params)) |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 371 | rkcommon_rc4_encode_spl(buf, RK_SPL_HDR_START, |
| 372 | spl_params.init_size); |
| 373 | |
| 374 | if (spl_params.boot_file) { |
| 375 | if (rkcommon_need_rc4_spl(params)) |
| 376 | rkcommon_rc4_encode_spl(buf + RK_SPL_HDR_START, |
| 377 | spl_params.init_size, |
| 378 | spl_params.boot_size); |
| 379 | } |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 380 | } |
Simon Glass | a131c1f | 2015-08-30 16:55:24 -0600 | [diff] [blame] | 381 | } |
Heiko Stübner | cfbcdad | 2017-02-18 19:46:27 +0100 | [diff] [blame] | 382 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 383 | static inline unsigned int rkcommon_offset_to_spi(unsigned int offset) |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 384 | { |
| 385 | /* |
| 386 | * While SD/MMC images use a flat addressing, SPI images are padded |
| 387 | * to use the first 2K of every 4K sector only. |
| 388 | */ |
| 389 | return ((offset & ~0x7ff) << 1) + (offset & 0x7ff); |
| 390 | } |
| 391 | |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 392 | static int rkcommon_parse_header(const void *buf, struct header0_info *header0, |
| 393 | struct spl_info **spl_info) |
| 394 | { |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 395 | unsigned int hdr1_offset; |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 396 | struct header1_info *hdr1_sdmmc, *hdr1_spi; |
| 397 | int i; |
| 398 | |
| 399 | if (spl_info) |
| 400 | *spl_info = NULL; |
| 401 | |
| 402 | /* |
| 403 | * The first header (hdr0) is always RC4 encoded, so try to decrypt |
| 404 | * with the well-known key. |
| 405 | */ |
| 406 | memcpy((void *)header0, buf, sizeof(struct header0_info)); |
| 407 | rc4_encode((void *)header0, sizeof(struct header0_info), rc4_key); |
| 408 | |
Kever Yang | d7a4461 | 2021-12-24 17:58:32 +0800 | [diff] [blame] | 409 | if (le32_to_cpu(header0->magic) != RK_MAGIC) |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 410 | return -EPROTO; |
| 411 | |
| 412 | /* We don't support RC4 encoded image payloads here, yet... */ |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 413 | if (le32_to_cpu(header0->disable_rc4) == 0) |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 414 | return -ENOSYS; |
| 415 | |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 416 | hdr1_offset = le16_to_cpu(header0->init_offset) * RK_BLK_SIZE; |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 417 | hdr1_sdmmc = (struct header1_info *)(buf + hdr1_offset); |
| 418 | hdr1_spi = (struct header1_info *)(buf + |
| 419 | rkcommon_offset_to_spi(hdr1_offset)); |
| 420 | |
| 421 | for (i = 0; i < ARRAY_SIZE(spl_infos); i++) { |
Miquel Raynal | e5a4055 | 2020-03-18 17:22:55 +0100 | [diff] [blame] | 422 | if (!memcmp(&hdr1_sdmmc->magic, spl_infos[i].spl_hdr, |
| 423 | RK_SPL_HDR_SIZE)) { |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 424 | if (spl_info) |
| 425 | *spl_info = &spl_infos[i]; |
| 426 | return IH_TYPE_RKSD; |
Miquel Raynal | e5a4055 | 2020-03-18 17:22:55 +0100 | [diff] [blame] | 427 | } else if (!memcmp(&hdr1_spi->magic, spl_infos[i].spl_hdr, |
| 428 | RK_SPL_HDR_SIZE)) { |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 429 | if (spl_info) |
| 430 | *spl_info = &spl_infos[i]; |
| 431 | return IH_TYPE_RKSPI; |
| 432 | } |
| 433 | } |
| 434 | |
| 435 | return -1; |
| 436 | } |
| 437 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 438 | static int rkcommon_parse_header_v2(const void *buf, struct header0_info_v2 *header) |
| 439 | { |
| 440 | memcpy((void *)header, buf, sizeof(struct header0_info_v2)); |
| 441 | |
| 442 | if (le32_to_cpu(header->magic) != RK_MAGIC_V2) |
| 443 | return -EPROTO; |
| 444 | |
| 445 | return 0; |
| 446 | } |
| 447 | |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 448 | int rkcommon_verify_header(unsigned char *buf, int size, |
| 449 | struct image_tool_params *params) |
| 450 | { |
| 451 | struct header0_info header0; |
| 452 | struct spl_info *img_spl_info, *spl_info; |
| 453 | int ret; |
| 454 | |
Yi Liu | 3548903 | 2022-03-30 18:05:59 +0800 | [diff] [blame] | 455 | /* spl_hdr is abandon on header_v2 */ |
| 456 | if ((*(uint32_t *)buf) == RK_MAGIC_V2) |
| 457 | return 0; |
| 458 | |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 459 | ret = rkcommon_parse_header(buf, &header0, &img_spl_info); |
| 460 | |
| 461 | /* If this is the (unimplemented) RC4 case, then rewrite the result */ |
| 462 | if (ret == -ENOSYS) |
| 463 | return 0; |
| 464 | |
| 465 | if (ret < 0) |
| 466 | return ret; |
| 467 | |
| 468 | /* |
| 469 | * If no 'imagename' is specified via the commandline (e.g. if this is |
| 470 | * 'dumpimage -l' w/o any further constraints), we accept any spl_info. |
| 471 | */ |
| 472 | if (params->imagename == NULL) |
| 473 | return 0; |
| 474 | |
| 475 | /* Match the 'imagename' against the 'spl_hdr' found */ |
| 476 | spl_info = rkcommon_get_spl_info(params->imagename); |
| 477 | if (spl_info && img_spl_info) |
| 478 | return strcmp(spl_info->spl_hdr, img_spl_info->spl_hdr); |
| 479 | |
| 480 | return -ENOENT; |
| 481 | } |
| 482 | |
| 483 | void rkcommon_print_header(const void *buf) |
| 484 | { |
| 485 | struct header0_info header0; |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 486 | struct header0_info_v2 header0_v2; |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 487 | struct spl_info *spl_info; |
| 488 | uint8_t image_type; |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 489 | int ret, boot_size, init_size; |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 490 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 491 | if ((*(uint32_t *)buf) == RK_MAGIC_V2) { |
| 492 | ret = rkcommon_parse_header_v2(buf, &header0_v2); |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 493 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 494 | if (ret < 0) { |
| 495 | fprintf(stderr, "Error: image verification failed\n"); |
| 496 | return; |
| 497 | } |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 498 | |
Yi Liu | 8935e52 | 2021-05-18 10:13:40 +0800 | [diff] [blame] | 499 | init_size = header0_v2.images[0].size_and_off >> 16; |
| 500 | init_size = init_size * RK_BLK_SIZE; |
| 501 | boot_size = header0_v2.images[1].size_and_off >> 16; |
| 502 | boot_size = boot_size * RK_BLK_SIZE; |
| 503 | } else { |
| 504 | ret = rkcommon_parse_header(buf, &header0, &spl_info); |
| 505 | |
| 506 | /* If this is the (unimplemented) RC4 case, then fail silently */ |
| 507 | if (ret == -ENOSYS) |
| 508 | return; |
| 509 | |
| 510 | if (ret < 0) { |
| 511 | fprintf(stderr, "Error: image verification failed\n"); |
| 512 | return; |
| 513 | } |
| 514 | |
| 515 | image_type = ret; |
| 516 | init_size = header0.init_size * RK_BLK_SIZE; |
| 517 | boot_size = header0.init_boot_size * RK_BLK_SIZE - init_size; |
| 518 | |
| 519 | printf("Image Type: Rockchip %s (%s) boot image\n", |
| 520 | spl_info->spl_hdr, |
| 521 | (image_type == IH_TYPE_RKSD) ? "SD/MMC" : "SPI"); |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 522 | } |
| 523 | |
Samuel Holland | 29ef48e | 2020-10-24 11:43:17 -0500 | [diff] [blame] | 524 | printf("Init Data Size: %d bytes\n", init_size); |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 525 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 526 | if (boot_size != RK_MAX_BOOT_SIZE) |
| 527 | printf("Boot Data Size: %d bytes\n", boot_size); |
Philipp Tomsich | 2fb371f | 2017-05-30 23:32:08 +0200 | [diff] [blame] | 528 | } |
| 529 | |
Heiko Stübner | cfbcdad | 2017-02-18 19:46:27 +0100 | [diff] [blame] | 530 | void rkcommon_rc4_encode_spl(void *buf, unsigned int offset, unsigned int size) |
| 531 | { |
| 532 | unsigned int remaining = size; |
| 533 | |
| 534 | while (remaining > 0) { |
| 535 | int step = (remaining > RK_BLK_SIZE) ? RK_BLK_SIZE : remaining; |
| 536 | |
| 537 | rc4_encode(buf + offset, step, rc4_key); |
| 538 | offset += RK_BLK_SIZE; |
| 539 | remaining -= step; |
| 540 | } |
| 541 | } |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 542 | |
Philipp Tomsich | 366aad4 | 2017-04-17 17:48:01 +0200 | [diff] [blame] | 543 | int rkcommon_vrec_header(struct image_tool_params *params, |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 544 | struct image_type_params *tparams) |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 545 | { |
| 546 | /* |
| 547 | * The SPL image looks as follows: |
| 548 | * |
| 549 | * 0x0 header0 (see rkcommon.c) |
| 550 | * 0x800 spl_name ('RK30', ..., 'RK33') |
Philipp Tomsich | ea3729e | 2017-04-17 17:48:02 +0200 | [diff] [blame] | 551 | * (start of the payload for AArch64 payloads: we expect the |
| 552 | * first 4 bytes to be available for overwriting with our |
| 553 | * spl_name) |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 554 | * 0x804 first instruction to be executed |
Philipp Tomsich | ea3729e | 2017-04-17 17:48:02 +0200 | [diff] [blame] | 555 | * (start of the image/payload for 32bit payloads) |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 556 | * |
Philipp Tomsich | ea3729e | 2017-04-17 17:48:02 +0200 | [diff] [blame] | 557 | * For AArch64 (ARMv8) payloads, natural alignment (8-bytes) is |
| 558 | * required for its sections (so the image we receive needs to |
| 559 | * have the first 4 bytes reserved for the spl_name). Reserving |
| 560 | * these 4 bytes is done using the BOOT0_HOOK infrastructure. |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 561 | * |
Philipp Tomsich | 95d363c | 2017-10-10 16:21:18 +0200 | [diff] [blame] | 562 | * The header is always at 0x800 (as we now use a payload |
| 563 | * prepadded using the boot0 hook for all targets): the first |
| 564 | * 4 bytes of these images can safely be overwritten using the |
| 565 | * boot magic. |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 566 | */ |
Philipp Tomsich | 95d363c | 2017-10-10 16:21:18 +0200 | [diff] [blame] | 567 | tparams->header_size = RK_SPL_HDR_START; |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 568 | |
| 569 | /* Allocate, clear and install the header */ |
| 570 | tparams->hdr = malloc(tparams->header_size); |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 571 | if (!tparams->hdr) { |
| 572 | fprintf(stderr, "%s: Can't alloc header: %s\n", |
| 573 | params->cmdname, strerror(errno)); |
| 574 | exit(EXIT_FAILURE); |
| 575 | } |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 576 | memset(tparams->hdr, 0, tparams->header_size); |
Philipp Tomsich | 366aad4 | 2017-04-17 17:48:01 +0200 | [diff] [blame] | 577 | |
| 578 | /* |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 579 | * We need to store the original file-size (i.e. before padding), as |
| 580 | * imagetool does not set this during its adjustment of file_size. |
Philipp Tomsich | 366aad4 | 2017-04-17 17:48:01 +0200 | [diff] [blame] | 581 | */ |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 582 | params->orig_file_size = tparams->header_size + |
| 583 | spl_params.init_size + spl_params.boot_size; |
Philipp Tomsich | 366aad4 | 2017-04-17 17:48:01 +0200 | [diff] [blame] | 584 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 585 | params->file_size = ROUND(params->orig_file_size, RK_SIZE_ALIGN); |
Philipp Tomsich | 366aad4 | 2017-04-17 17:48:01 +0200 | [diff] [blame] | 586 | |
Jeffy Chen | eea6cd8 | 2019-12-27 11:24:41 +0800 | [diff] [blame] | 587 | /* Ignoring pad len, since we are using our own copy_image() */ |
| 588 | return 0; |
| 589 | } |
| 590 | |
| 591 | static int pad_file(struct image_tool_params *params, int ifd, int pad) |
| 592 | { |
| 593 | uint8_t zeros[4096]; |
| 594 | |
| 595 | memset(zeros, 0, sizeof(zeros)); |
| 596 | |
| 597 | while (pad > 0) { |
| 598 | int todo = sizeof(zeros); |
| 599 | |
| 600 | if (todo > pad) |
| 601 | todo = pad; |
| 602 | if (write(ifd, (char *)&zeros, todo) != todo) { |
| 603 | fprintf(stderr, "%s: Write error on %s: %s\n", |
| 604 | params->cmdname, params->imagefile, |
| 605 | strerror(errno)); |
| 606 | return -1; |
| 607 | } |
| 608 | pad -= todo; |
| 609 | } |
| 610 | |
| 611 | return 0; |
| 612 | } |
| 613 | |
| 614 | static int copy_file(struct image_tool_params *params, int ifd, |
| 615 | const char *file, int padded_size) |
| 616 | { |
| 617 | int dfd; |
| 618 | struct stat sbuf; |
| 619 | unsigned char *ptr; |
| 620 | int size; |
| 621 | |
| 622 | if (params->vflag) |
| 623 | fprintf(stderr, "Adding Image %s\n", file); |
| 624 | |
| 625 | dfd = open(file, O_RDONLY | O_BINARY); |
| 626 | if (dfd < 0) { |
| 627 | fprintf(stderr, "%s: Can't open %s: %s\n", |
| 628 | params->cmdname, file, strerror(errno)); |
| 629 | return -1; |
| 630 | } |
| 631 | |
| 632 | if (fstat(dfd, &sbuf) < 0) { |
| 633 | fprintf(stderr, "%s: Can't stat %s: %s\n", |
| 634 | params->cmdname, file, strerror(errno)); |
| 635 | goto err_close; |
| 636 | } |
| 637 | |
| 638 | if (params->vflag) |
| 639 | fprintf(stderr, "Size %u(pad to %u)\n", |
| 640 | (int)sbuf.st_size, padded_size); |
| 641 | |
| 642 | ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); |
| 643 | if (ptr == MAP_FAILED) { |
| 644 | fprintf(stderr, "%s: Can't read %s: %s\n", |
| 645 | params->cmdname, file, strerror(errno)); |
| 646 | goto err_munmap; |
| 647 | } |
| 648 | |
| 649 | size = sbuf.st_size; |
| 650 | if (write(ifd, ptr, size) != size) { |
| 651 | fprintf(stderr, "%s: Write error on %s: %s\n", |
| 652 | params->cmdname, params->imagefile, strerror(errno)); |
| 653 | goto err_munmap; |
| 654 | } |
| 655 | |
| 656 | munmap((void *)ptr, sbuf.st_size); |
| 657 | close(dfd); |
| 658 | return pad_file(params, ifd, padded_size - size); |
| 659 | |
| 660 | err_munmap: |
| 661 | munmap((void *)ptr, sbuf.st_size); |
| 662 | err_close: |
| 663 | close(dfd); |
| 664 | return -1; |
| 665 | } |
| 666 | |
| 667 | int rockchip_copy_image(int ifd, struct image_tool_params *params) |
| 668 | { |
| 669 | int ret; |
| 670 | |
| 671 | ret = copy_file(params, ifd, spl_params.init_file, |
| 672 | spl_params.init_size); |
| 673 | if (ret) |
| 674 | return ret; |
| 675 | |
| 676 | if (spl_params.boot_file) { |
| 677 | ret = copy_file(params, ifd, spl_params.boot_file, |
| 678 | spl_params.boot_size); |
| 679 | if (ret) |
| 680 | return ret; |
| 681 | } |
| 682 | |
| 683 | return pad_file(params, ifd, |
| 684 | params->file_size - params->orig_file_size); |
Philipp Tomsich | 111bcc4 | 2017-03-15 12:08:43 +0100 | [diff] [blame] | 685 | } |