1 /*
2 * (C) Copyright 2019 Rockchip Electronics Co., Ltd
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6 #include <common.h>
7 #include <boot_rkimg.h>
8 #include <image.h>
9 #include <malloc.h>
10 #include <sysmem.h>
11 #include <asm/arch/fit.h>
12 #include <asm/arch/resource_img.h>
13
14 DECLARE_GLOBAL_DATA_PTR;
15
16 #define FIT_PLACEHOLDER_ADDR 0xffffff00
17
18 /*
19 * Must use args '-E -p' for mkimage to generate FIT image, 4K as max assumption.
20 */
21 #define FIT_FDT_MAX_SIZE SZ_4K
22
fit_is_ext_type(const void * fit)23 static int fit_is_ext_type(const void *fit)
24 {
25 return fdt_totalsize(fit) < FIT_FDT_MAX_SIZE;
26 }
27
fit_is_signed(const void * fit,const void * sig_blob)28 static int fit_is_signed(const void *fit, const void *sig_blob)
29 {
30 return fdt_subnode_offset(sig_blob, 0, FIT_SIG_NODENAME) < 0 ? 0 : 1;
31 }
32
fit_image_addr_is_placeholder(ulong addr)33 static inline int fit_image_addr_is_placeholder(ulong addr)
34 {
35 return (addr & 0xffffff00) == FIT_PLACEHOLDER_ADDR;
36 }
37
fit_sig_require_conf(const void * fit,const void * sig_blob)38 static int fit_sig_require_conf(const void *fit, const void *sig_blob)
39 {
40 const char *required;
41 int sig_node;
42 int noffset;
43
44 sig_node = fdt_subnode_offset(sig_blob, 0, FIT_SIG_NODENAME);
45 if (sig_node < 0)
46 return 0;
47
48 fdt_for_each_subnode(noffset, sig_blob, sig_node) {
49 required = fdt_getprop(sig_blob, noffset, "required", NULL);
50 if (required && !strcmp(required, "conf"))
51 return 1;
52 }
53
54 return 0;
55 }
56
fit_default_conf_get_node(const void * fit,const char * prop_name)57 int fit_default_conf_get_node(const void *fit, const char *prop_name)
58 {
59 int conf_noffset;
60
61 conf_noffset = fit_conf_get_node(fit, NULL); /* NULL for default conf */
62 if (conf_noffset < 0)
63 return conf_noffset;
64
65 return fit_conf_get_prop_node(fit, conf_noffset, prop_name);
66 }
67
fix_image_set_addr(const void * fit,const char * prop_name,ulong old,ulong new)68 int fix_image_set_addr(const void *fit, const char *prop_name,
69 ulong old, ulong new)
70 {
71 int noffset;
72
73 /* do not fix if verified-boot */
74 if (!fit_image_addr_is_placeholder(old) ||
75 fit_sig_require_conf(fit, gd_fdt_blob()))
76 return 0;
77
78 noffset = fit_default_conf_get_node(fit, prop_name);
79 if (noffset < 0)
80 return noffset;
81
82 /* optional */
83 fit_image_set_entry(fit, noffset, new);
84
85 return fit_image_set_load(fit, noffset, new);
86 }
87
fdt_image_get_offset_size(const void * fit,const char * prop_name,int * offset,int * size)88 static int fdt_image_get_offset_size(const void *fit, const char *prop_name,
89 int *offset, int *size)
90 {
91 int sz, offs;
92 int noffset;
93 int ret;
94
95 noffset = fit_default_conf_get_node(fit, prop_name);
96 if (noffset < 0)
97 return noffset;
98
99 ret = fit_image_get_data_size(fit, noffset, &sz);
100 if (ret)
101 return ret;
102
103 ret = fit_image_get_data_position(fit, noffset, &offs);
104 if (!ret)
105 offs -= fdt_totalsize(fit);
106 else
107 ret = fit_image_get_data_offset(fit, noffset, &offs);
108
109 *offset = offs;
110 *size = sz;
111
112 return ret;
113 }
114
fdt_image_get_load(const void * fit,const char * prop_name,ulong * load)115 static int fdt_image_get_load(const void *fit, const char *prop_name,
116 ulong *load)
117 {
118 int noffset;
119
120 noffset = fit_default_conf_get_node(fit, prop_name);
121 if (noffset < 0)
122 return noffset;
123
124 return fit_image_get_load(fit, noffset, load);
125 }
126
fit_image_get_param(const void * fit,const char * prop_name,ulong * load,int * offset,int * size)127 static int fit_image_get_param(const void *fit, const char *prop_name,
128 ulong *load, int *offset, int *size)
129 {
130 int ret;
131
132 ret = fdt_image_get_offset_size(fit, prop_name, offset, size);
133 if (ret < 0)
134 return ret;
135
136 return fdt_image_get_load(fit, prop_name, load);
137 }
138
fit_get_blob(struct blk_desc * dev_desc,disk_partition_t * out_part,bool verify)139 static void *fit_get_blob(struct blk_desc *dev_desc,
140 disk_partition_t *out_part,
141 bool verify)
142 {
143 __maybe_unused int conf_noffset;
144 disk_partition_t part;
145 char *part_name = PART_BOOT;
146 void *fit, *fdt;
147 int blk_num;
148
149 #ifndef CONFIG_ANDROID_AB
150 if (rockchip_get_boot_mode() == BOOT_MODE_RECOVERY)
151 part_name = PART_RECOVERY;
152 #endif
153
154 if (part_get_info_by_name(dev_desc, part_name, &part) < 0) {
155 FIT_I("No %s partition\n", part_name);
156 return NULL;
157 }
158
159 *out_part = part;
160 blk_num = DIV_ROUND_UP(sizeof(struct fdt_header), dev_desc->blksz);
161 fdt = memalign(ARCH_DMA_MINALIGN, blk_num * dev_desc->blksz);
162 if (!fdt)
163 return NULL;
164
165 if (blk_dread(dev_desc, part.start, blk_num, fdt) != blk_num) {
166 debug("Failed to read fdt header\n");
167 goto fail;
168 }
169
170 if (fdt_check_header(fdt)) {
171 debug("No fdt header\n");
172 goto fail;
173 }
174
175 if (!fit_is_ext_type(fdt)) {
176 debug("Not external type\n");
177 goto fail;
178 }
179
180 blk_num = DIV_ROUND_UP(fdt_totalsize(fdt), dev_desc->blksz);
181 fit = memalign(ARCH_DMA_MINALIGN, blk_num * dev_desc->blksz);
182 if (!fit) {
183 debug("No memory\n");
184 goto fail;
185 }
186
187 if (blk_dread(dev_desc, part.start, blk_num, fit) != blk_num) {
188 free(fit);
189 debug("Failed to read fit blob\n");
190 goto fail;
191 }
192
193 #ifdef CONFIG_FIT_SIGNATURE
194 if (!verify)
195 return fit;
196
197 conf_noffset = fit_conf_get_node(fit, NULL); /* NULL for default conf */
198 if (conf_noffset < 0)
199 goto fail;
200
201 printf("%s: ", fdt_get_name(fit, conf_noffset, NULL));
202 if (fit_config_verify(fit, conf_noffset)) {
203 puts("\n");
204 /* don't remove this failure handle */
205 run_command("download", 0);
206 hang();
207 }
208 puts("\n");
209 #endif
210 return fit;
211
212 fail:
213 free(fdt);
214 return NULL;
215 }
216
fit_image_fixup_alloc(const void * fit,const char * prop_name,const char * addr_name,enum memblk_id mem)217 static int fit_image_fixup_alloc(const void *fit, const char *prop_name,
218 const char *addr_name, enum memblk_id mem)
219 {
220 ulong load, addr;
221 int offset, size = 0;
222 int ret;
223
224 addr = env_get_ulong(addr_name, 16, 0);
225 if (!addr)
226 return -EINVAL;
227
228 ret = fit_image_get_param(fit, prop_name, &load, &offset, &size);
229 if (ret)
230 return (ret == -FDT_ERR_NOTFOUND) ? 0 : ret;
231
232 if (!size)
233 return 0;
234
235 ret = fix_image_set_addr(fit, prop_name, load, addr);
236 if (ret)
237 return ret;
238
239 if (!sysmem_alloc_base(mem, (phys_addr_t)addr,
240 ALIGN(size, RK_BLK_SIZE)))
241 return -ENOMEM;
242
243 return 0;
244 }
245
fit_image_pre_process(const void * fit)246 int fit_image_pre_process(const void *fit)
247 {
248 int ret;
249
250 /* free for fit_image_fixup_alloc(FIT_FDT_PROP) to re-alloc */
251 if ((gd->flags & GD_FLG_KDTB_READY) && !gd->fdt_blob_kern)
252 sysmem_free((phys_addr_t)gd->fdt_blob);
253
254 ret = fit_image_fixup_alloc(fit, FIT_FDT_PROP,
255 "fdt_addr_r", MEM_FDT);
256 if (ret < 0)
257 return ret;
258
259 ret = fit_image_fixup_alloc(fit, FIT_KERNEL_PROP,
260 "kernel_addr_r", MEM_KERNEL);
261 if (ret < 0)
262 return ret;
263
264 return fit_image_fixup_alloc(fit, FIT_RAMDISK_PROP,
265 "ramdisk_addr_r", MEM_RAMDISK);
266 }
267
fit_image_fail_process(const void * fit)268 int fit_image_fail_process(const void *fit)
269 {
270 ulong raddr, kaddr, faddr;
271
272 raddr = env_get_ulong("ramdisk_addr_r", 16, 0);
273 kaddr = env_get_ulong("kernel_addr_r", 16, 0);
274 faddr = env_get_ulong("fdt_addr_r", 16, 0);
275
276 sysmem_free((phys_addr_t)fit);
277 sysmem_free((phys_addr_t)raddr);
278 sysmem_free((phys_addr_t)kaddr);
279 sysmem_free((phys_addr_t)faddr);
280
281 return 0;
282 }
283
fit_image_get_subnode(const void * fit,int noffset,const char * name)284 static int fit_image_get_subnode(const void *fit, int noffset, const char *name)
285 {
286 int sub_noffset;
287
288 fdt_for_each_subnode(sub_noffset, fit, noffset) {
289 if (!strncmp(fit_get_name(fit, sub_noffset, NULL),
290 name, strlen(name)))
291 return sub_noffset;
292 }
293
294 return -ENOENT;
295 }
296
fit_image_load_one(const void * fit,struct blk_desc * dev_desc,disk_partition_t * part,char * prop_name,void * data,int check_hash)297 static int fit_image_load_one(const void *fit, struct blk_desc *dev_desc,
298 disk_partition_t *part, char *prop_name,
299 void *data, int check_hash)
300 {
301 u32 blk_num, blk_off;
302 int offset, size;
303 int noffset, ret;
304 char *msg = "";
305
306 ret = fdt_image_get_offset_size(fit, prop_name, &offset, &size);
307 if (ret)
308 return ret;
309
310 blk_off = (FIT_ALIGN(fdt_totalsize(fit)) + offset) / dev_desc->blksz;
311 blk_num = DIV_ROUND_UP(size, dev_desc->blksz);
312 if (blk_dread(dev_desc, part->start + blk_off, blk_num, data) != blk_num)
313 return -EIO;
314
315 if (check_hash) {
316 int hash_noffset;
317
318 noffset = fit_default_conf_get_node(fit, prop_name);
319 if (noffset < 0)
320 return noffset;
321
322 hash_noffset = fit_image_get_subnode(fit, noffset,
323 FIT_HASH_NODENAME);
324 if (hash_noffset < 0)
325 return hash_noffset;
326
327 printf("%s: ", fdt_get_name(fit, noffset, NULL));
328 ret = fit_image_check_hash(fit, hash_noffset, data, size, &msg);
329 if (ret)
330 return ret;
331
332 puts("+\n");
333 }
334
335 return 0;
336 }
337
338 /* Calculate what we really need */
fit_image_get_bootables_size(const void * fit)339 ulong fit_image_get_bootables_size(const void *fit)
340 {
341 ulong off[3] = { 0, 0, 0 };
342 ulong max_off, load;
343 int offset, size;
344
345 #if 0
346 if (!fit_get_totalsize(fit, &size))
347 return size;
348 #endif
349
350 if (!fit_image_get_param(fit, FIT_FDT_PROP, &load, &offset, &size))
351 off[0] = offset + FIT_ALIGN(size);
352
353 if (!fit_image_get_param(fit, FIT_KERNEL_PROP, &load, &offset, &size))
354 off[1] = offset + FIT_ALIGN(size);
355
356 if (!fit_image_get_param(fit, FIT_RAMDISK_PROP, &load, &offset, &size))
357 off[2] = offset + FIT_ALIGN(size);
358
359 max_off = max(off[0], off[1]);
360 max_off = max(max_off, off[2]);
361
362 return FIT_ALIGN(fdt_totalsize(fit)) + max_off;
363 }
364
fit_image_load_bootables(ulong * size)365 void *fit_image_load_bootables(ulong *size)
366 {
367 struct blk_desc *dev_desc;
368 disk_partition_t part;
369 int blk_num;
370 void *fit;
371
372 dev_desc = rockchip_get_bootdev();
373 if (!dev_desc)
374 return NULL;
375
376 fit = fit_get_blob(dev_desc, &part, false);
377 if (!fit) {
378 FIT_I("No fit blob\n");
379 return NULL;
380 }
381
382 *size = fit_image_get_bootables_size(fit);
383 if (*size == 0) {
384 FIT_I("No bootable image\n");
385 return NULL;
386 }
387
388 blk_num = DIV_ROUND_UP(*size, dev_desc->blksz);
389 fit = sysmem_alloc(MEM_FIT, blk_num * dev_desc->blksz);
390 if (!fit)
391 return NULL;
392
393 if (blk_dread(dev_desc, part.start, blk_num, fit) != blk_num) {
394 FIT_I("Failed to load bootable images\n");
395 return NULL;
396 }
397
398 return fit;
399 }
400
fit_msg(const void * fit)401 static void fit_msg(const void *fit)
402 {
403 FIT_I("%ssigned, %sconf required\n",
404 fit_is_signed(fit, gd_fdt_blob()) ? "" : "no ",
405 fit_sig_require_conf(fit, gd_fdt_blob()) ? "" : "no ");
406 }
407
408 #ifdef CONFIG_ROCKCHIP_RESOURCE_IMAGE
fit_image_init_resource(struct blk_desc * dev_desc)409 ulong fit_image_init_resource(struct blk_desc *dev_desc)
410 {
411 disk_partition_t part;
412 void *fit, *buf;
413 int offset, size;
414 int ret = 0;
415
416 if (!dev_desc)
417 return -ENODEV;
418
419 fit = fit_get_blob(dev_desc, &part, true);
420 if (!fit)
421 return -EAGAIN;
422
423 ret = fdt_image_get_offset_size(fit, FIT_MULTI_PROP, &offset, &size);
424 if (ret)
425 return -EINVAL;
426
427 buf = memalign(ARCH_DMA_MINALIGN, ALIGN(size, dev_desc->blksz));
428 if (!buf)
429 return -ENOMEM;
430
431 printf("RESC: '%s', blk@0x%08lx\n", part.name,
432 part.start + ((FIT_ALIGN(fdt_totalsize(fit)) + offset) / dev_desc->blksz));
433 ret = fit_image_load_one(fit, dev_desc, &part, FIT_MULTI_PROP, buf, 1);
434 if (ret)
435 return ret;
436
437 ret = resource_setup_ram_list(dev_desc, buf);
438 if (ret) {
439 FIT_I("Failed to setup resource ram list, ret=%d\n", ret);
440 free(fit);
441 return ret;
442 }
443
444 fit_msg(fit);
445 free(fit);
446
447 return 0;
448 }
449 #else
fit_image_read_dtb(void * fdt_addr)450 int fit_image_read_dtb(void *fdt_addr)
451 {
452 struct blk_desc *dev_desc;
453 disk_partition_t part;
454 void *fit;
455
456 dev_desc = rockchip_get_bootdev();
457 if (!dev_desc) {
458 FIT_I("No dev_desc!\n");
459 return -ENODEV;;
460 }
461
462 fit = fit_get_blob(dev_desc, &part, true);
463 if (!fit)
464 return -EINVAL;
465
466 fit_msg(fit);
467
468 return fit_image_load_one(fit, dev_desc, &part, FIT_FDT_PROP,
469 (void *)fdt_addr, 1);
470 }
471 #endif
472