]>
Commit | Line | Data |
---|---|---|
a131c1f4 SG |
1 | /* |
2 | * (C) Copyright 2015 Google, Inc | |
3 | * Written by Simon Glass <sjg@chromium.org> | |
4 | * | |
5 | * SPDX-License-Identifier: GPL-2.0+ | |
6 | * | |
7 | * Helper functions for Rockchip images | |
8 | */ | |
9 | ||
10 | #include "imagetool.h" | |
11 | #include <image.h> | |
12 | #include <rc4.h> | |
13 | #include "mkimage.h" | |
14 | #include "rkcommon.h" | |
15 | ||
16 | enum { | |
17 | RK_SIGNATURE = 0x0ff0aa55, | |
18 | }; | |
19 | ||
20 | /** | |
21 | * struct header0_info - header block for boot ROM | |
22 | * | |
23 | * This is stored at SD card block 64 (where each block is 512 bytes, or at | |
24 | * the start of SPI flash. It is encoded with RC4. | |
25 | * | |
26 | * @signature: Signature (must be RKSD_SIGNATURE) | |
27 | * @disable_rc4: 0 to use rc4 for boot image, 1 to use plain binary | |
3641339e | 28 | * @init_offset: Offset in blocks of the SPL code from this header |
a131c1f4 SG |
29 | * block. E.g. 4 means 2KB after the start of this header. |
30 | * Other fields are not used by U-Boot | |
31 | */ | |
32 | struct header0_info { | |
33 | uint32_t signature; | |
34 | uint8_t reserved[4]; | |
35 | uint32_t disable_rc4; | |
3641339e JC |
36 | uint16_t init_offset; |
37 | uint8_t reserved1[492]; | |
38 | uint16_t init_size; | |
39 | uint16_t init_boot_size; | |
a131c1f4 SG |
40 | uint8_t reserved2[2]; |
41 | }; | |
42 | ||
111bcc4f PT |
43 | /** |
44 | * struct header1_info | |
45 | */ | |
46 | struct header1_info { | |
47 | uint32_t magic; | |
111bcc4f PT |
48 | }; |
49 | ||
7bf274b9 JC |
50 | /** |
51 | * struct spl_info - spl info for each chip | |
52 | * | |
53 | * @imagename: Image name(passed by "mkimage -n") | |
54 | * @spl_hdr: Boot ROM requires a 4-bytes spl header | |
55 | * @spl_size: Spl size(include extra 4-bytes spl header) | |
cfbcdade | 56 | * @spl_rc4: RC4 encode the SPL binary (same key as header) |
30827756 PT |
57 | * @spl_boot0: A new-style (ARM_SOC_BOOT0_HOOK) image that should |
58 | * have the boot magic (e.g. 'RK33') written to its first | |
59 | * word. | |
7bf274b9 | 60 | */ |
111bcc4f | 61 | |
7bf274b9 JC |
62 | struct spl_info { |
63 | const char *imagename; | |
64 | const char *spl_hdr; | |
65 | const uint32_t spl_size; | |
cfbcdade | 66 | const bool spl_rc4; |
30827756 | 67 | const bool spl_boot0; |
7bf274b9 JC |
68 | }; |
69 | ||
70 | static struct spl_info spl_infos[] = { | |
111bcc4f PT |
71 | { "rk3036", "RK30", 0x1000, false, false }, |
72 | { "rk3188", "RK31", 0x8000 - 0x800, true, false }, | |
73 | { "rk3288", "RK32", 0x8000, false, false }, | |
68d12600 | 74 | { "rk3328", "RK32", 0x8000 - 0x1000, false, false }, |
111bcc4f | 75 | { "rk3399", "RK33", 0x20000, false, true }, |
7bf274b9 JC |
76 | }; |
77 | ||
a131c1f4 SG |
78 | static unsigned char rc4_key[16] = { |
79 | 124, 78, 3, 4, 85, 5, 9, 7, | |
80 | 45, 44, 123, 56, 23, 13, 23, 17 | |
81 | }; | |
82 | ||
7bf274b9 JC |
83 | static struct spl_info *rkcommon_get_spl_info(char *imagename) |
84 | { | |
85 | int i; | |
86 | ||
87 | for (i = 0; i < ARRAY_SIZE(spl_infos); i++) | |
88 | if (!strncmp(imagename, spl_infos[i].imagename, 6)) | |
89 | return spl_infos + i; | |
90 | ||
91 | return NULL; | |
92 | } | |
93 | ||
94 | int rkcommon_check_params(struct image_tool_params *params) | |
95 | { | |
96 | int i; | |
97 | ||
98 | if (rkcommon_get_spl_info(params->imagename) != NULL) | |
99 | return 0; | |
100 | ||
101 | fprintf(stderr, "ERROR: imagename (%s) is not supported!\n", | |
102 | strlen(params->imagename) > 0 ? params->imagename : "NULL"); | |
103 | ||
104 | fprintf(stderr, "Available imagename:"); | |
105 | for (i = 0; i < ARRAY_SIZE(spl_infos); i++) | |
106 | fprintf(stderr, "\t%s", spl_infos[i].imagename); | |
107 | fprintf(stderr, "\n"); | |
108 | ||
109 | return -1; | |
110 | } | |
111 | ||
112 | const char *rkcommon_get_spl_hdr(struct image_tool_params *params) | |
113 | { | |
114 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); | |
115 | ||
116 | /* | |
117 | * info would not be NULL, because of we checked params before. | |
118 | */ | |
119 | return info->spl_hdr; | |
120 | } | |
121 | ||
30827756 PT |
122 | |
123 | int rkcommon_get_spl_size(struct image_tool_params *params) | |
111bcc4f PT |
124 | { |
125 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); | |
126 | ||
127 | /* | |
128 | * info would not be NULL, because of we checked params before. | |
129 | */ | |
30827756 | 130 | return info->spl_size; |
111bcc4f PT |
131 | } |
132 | ||
30827756 | 133 | bool rkcommon_need_rc4_spl(struct image_tool_params *params) |
7bf274b9 JC |
134 | { |
135 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); | |
136 | ||
137 | /* | |
138 | * info would not be NULL, because of we checked params before. | |
139 | */ | |
30827756 | 140 | return info->spl_rc4; |
7bf274b9 JC |
141 | } |
142 | ||
30827756 | 143 | bool rkcommon_spl_is_boot0(struct image_tool_params *params) |
cfbcdade HS |
144 | { |
145 | struct spl_info *info = rkcommon_get_spl_info(params->imagename); | |
146 | ||
147 | /* | |
148 | * info would not be NULL, because of we checked params before. | |
149 | */ | |
30827756 | 150 | return info->spl_boot0; |
cfbcdade HS |
151 | } |
152 | ||
111bcc4f PT |
153 | static void rkcommon_set_header0(void *buf, uint file_size, |
154 | struct image_tool_params *params) | |
a131c1f4 | 155 | { |
111bcc4f | 156 | struct header0_info *hdr = buf; |
a131c1f4 | 157 | |
111bcc4f | 158 | memset(buf, '\0', RK_INIT_OFFSET * RK_BLK_SIZE); |
a131c1f4 | 159 | hdr->signature = RK_SIGNATURE; |
cfbcdade | 160 | hdr->disable_rc4 = !rkcommon_need_rc4_spl(params); |
3641339e | 161 | hdr->init_offset = RK_INIT_OFFSET; |
a131c1f4 | 162 | |
3641339e JC |
163 | hdr->init_size = (file_size + RK_BLK_SIZE - 1) / RK_BLK_SIZE; |
164 | hdr->init_size = (hdr->init_size + 3) & ~3; | |
165 | hdr->init_boot_size = hdr->init_size + RK_MAX_BOOT_SIZE / RK_BLK_SIZE; | |
a131c1f4 SG |
166 | |
167 | rc4_encode(buf, RK_BLK_SIZE, rc4_key); | |
111bcc4f PT |
168 | } |
169 | ||
170 | int rkcommon_set_header(void *buf, uint file_size, | |
171 | struct image_tool_params *params) | |
172 | { | |
173 | struct header1_info *hdr = buf + RK_SPL_HDR_START; | |
174 | ||
175 | if (file_size > rkcommon_get_spl_size(params)) | |
176 | return -ENOSPC; | |
177 | ||
178 | rkcommon_set_header0(buf, file_size, params); | |
179 | ||
180 | /* Set up the SPL name and add the AArch64 'nop' padding, if needed */ | |
181 | memcpy(&hdr->magic, rkcommon_get_spl_hdr(params), RK_SPL_HDR_SIZE); | |
182 | ||
111bcc4f PT |
183 | if (rkcommon_need_rc4_spl(params)) |
184 | rkcommon_rc4_encode_spl(buf, RK_SPL_HDR_START, | |
185 | params->file_size - RK_SPL_HDR_START); | |
a131c1f4 SG |
186 | |
187 | return 0; | |
188 | } | |
cfbcdade HS |
189 | |
190 | void rkcommon_rc4_encode_spl(void *buf, unsigned int offset, unsigned int size) | |
191 | { | |
192 | unsigned int remaining = size; | |
193 | ||
194 | while (remaining > 0) { | |
195 | int step = (remaining > RK_BLK_SIZE) ? RK_BLK_SIZE : remaining; | |
196 | ||
197 | rc4_encode(buf + offset, step, rc4_key); | |
198 | offset += RK_BLK_SIZE; | |
199 | remaining -= step; | |
200 | } | |
201 | } | |
111bcc4f | 202 | |
366aad4d PT |
203 | int rkcommon_vrec_header(struct image_tool_params *params, |
204 | struct image_type_params *tparams, | |
205 | unsigned int alignment) | |
111bcc4f | 206 | { |
366aad4d PT |
207 | unsigned int unpadded_size; |
208 | unsigned int padded_size; | |
209 | ||
111bcc4f PT |
210 | /* |
211 | * The SPL image looks as follows: | |
212 | * | |
213 | * 0x0 header0 (see rkcommon.c) | |
214 | * 0x800 spl_name ('RK30', ..., 'RK33') | |
215 | * 0x804 first instruction to be executed | |
216 | * (image start for AArch32, 'nop' for AArch64)) | |
217 | * 0x808 second instruction to be executed | |
218 | * (image start for AArch64) | |
219 | * | |
220 | * For AArch64 (ARMv8) payloads, we receive an input file that | |
221 | * needs to start on an 8-byte boundary (natural alignment), so | |
222 | * we need to put a NOP at 0x804. | |
223 | * | |
224 | * Depending on this, the header is either 0x804 or 0x808 bytes | |
225 | * in length. | |
226 | */ | |
30827756 PT |
227 | if (rkcommon_spl_is_boot0(params)) |
228 | tparams->header_size = RK_SPL_HDR_START; | |
111bcc4f PT |
229 | else |
230 | tparams->header_size = RK_SPL_HDR_START + 4; | |
231 | ||
232 | /* Allocate, clear and install the header */ | |
233 | tparams->hdr = malloc(tparams->header_size); | |
234 | memset(tparams->hdr, 0, tparams->header_size); | |
366aad4d PT |
235 | tparams->header_size = tparams->header_size; |
236 | ||
237 | /* | |
238 | * If someone passed in 0 for the alignment, we'd better handle | |
239 | * it correctly... | |
240 | */ | |
241 | if (!alignment) | |
242 | alignment = 1; | |
243 | ||
244 | unpadded_size = tparams->header_size + params->file_size; | |
245 | padded_size = ROUND(unpadded_size, alignment); | |
246 | ||
247 | return padded_size - unpadded_size; | |
111bcc4f | 248 | } |