blob: 9d1598b1a93cc96d41aae9f36d8369a737bb4e13 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassc6bdabb2013-05-08 08:06:00 +00002/*
3 * Copyright (c) 2013, Google Inc.
4 *
5 * (C) Copyright 2008 Semihalf
6 *
7 * (C) Copyright 2000-2006
8 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
Simon Glassc6bdabb2013-05-08 08:06:00 +00009 */
10
Matthias Schiffere908fec2023-12-11 12:03:17 +010011#include <command.h>
Simon Glassc6bdabb2013-05-08 08:06:00 +000012#include <fdt_support.h>
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010013#include <fdtdec.h>
Simon Glass83c2e492019-08-01 09:46:50 -060014#include <env.h>
Simon Glassc6bdabb2013-05-08 08:06:00 +000015#include <errno.h>
16#include <image.h>
Simon Glass2dc9c342020-05-10 11:40:01 -060017#include <lmb.h>
Simon Glass0f2af882020-05-10 11:40:05 -060018#include <log.h>
Simon Glass9bc15642020-02-03 07:36:16 -070019#include <malloc.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060020#include <asm/global_data.h>
Masahiro Yamada75f82d02018-03-05 01:20:11 +090021#include <linux/libfdt.h>
Joe Hershberger65b905b2015-03-22 17:08:59 -050022#include <mapmem.h>
Simon Glassc6bdabb2013-05-08 08:06:00 +000023#include <asm/io.h>
Simon Glass4305fe72022-07-30 15:52:31 -060024#include <dm/ofnode.h>
Heiko Stuebnerb1a4fa02019-10-23 16:46:40 +020025#include <tee/optee.h>
Simon Glassc6bdabb2013-05-08 08:06:00 +000026
Simon Glassc6bdabb2013-05-08 08:06:00 +000027DECLARE_GLOBAL_DATA_PTR;
28
29static void fdt_error(const char *msg)
30{
31 puts("ERROR: ");
32 puts(msg);
33 puts(" - must RESET the board to recover.\n");
34}
35
Tom Rinic220bd92019-05-23 07:14:07 -040036#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glassbb7d3bb2022-09-06 20:26:52 -060037static const struct legacy_img_hdr *image_get_fdt(ulong fdt_addr)
Simon Glassc6bdabb2013-05-08 08:06:00 +000038{
Simon Glassbb7d3bb2022-09-06 20:26:52 -060039 const struct legacy_img_hdr *fdt_hdr = map_sysmem(fdt_addr, 0);
Simon Glassc6bdabb2013-05-08 08:06:00 +000040
41 image_print_contents(fdt_hdr);
42
43 puts(" Verifying Checksum ... ");
44 if (!image_check_hcrc(fdt_hdr)) {
45 fdt_error("fdt header checksum invalid");
46 return NULL;
47 }
48
49 if (!image_check_dcrc(fdt_hdr)) {
50 fdt_error("fdt checksum invalid");
51 return NULL;
52 }
53 puts("OK\n");
54
55 if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
56 fdt_error("uImage is not a fdt");
57 return NULL;
58 }
59 if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
60 fdt_error("uImage is compressed");
61 return NULL;
62 }
Masahiro Yamadabc2a07d2013-09-19 12:10:18 +090063 if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {
Simon Glassc6bdabb2013-05-08 08:06:00 +000064 fdt_error("uImage data is not a fdt");
65 return NULL;
66 }
67 return fdt_hdr;
68}
Heiko Schocher515eb122014-05-28 11:33:33 +020069#endif
Simon Glassc6bdabb2013-05-08 08:06:00 +000070
Ilias Apalodimasd8462bf2024-12-18 09:02:31 +020071static void boot_fdt_reserve_region(u64 addr, u64 size, u32 flags)
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010072{
Patrick Delaunaydcd5aba2019-03-06 14:23:52 +010073 long ret;
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010074
Ilias Apalodimasf72c55e2024-12-18 09:02:32 +020075 ret = lmb_reserve(addr, size, flags);
Ilias Apalodimas98491252024-10-23 18:22:00 +030076 if (!ret) {
Patrick Delaunay4a4992b2021-05-07 14:50:33 +020077 debug(" reserving fdt memory region: addr=%llx size=%llx flags=%x\n",
78 (unsigned long long)addr,
79 (unsigned long long)size, flags);
Sam Protsenkoc4b68712024-12-10 20:17:02 -060080 } else if (ret != -EEXIST) {
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010081 puts("ERROR: reserving fdt memory region failed ");
Patrick Delaunay4a4992b2021-05-07 14:50:33 +020082 printf("(addr=%llx size=%llx flags=%x)\n",
83 (unsigned long long)addr,
84 (unsigned long long)size, flags);
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010085 }
86}
87
Simon Glassc6bdabb2013-05-08 08:06:00 +000088/**
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010089 * boot_fdt_add_mem_rsv_regions - Mark the memreserve and reserved-memory
90 * sections as unusable
Simon Glassc6bdabb2013-05-08 08:06:00 +000091 * @fdt_blob: pointer to fdt blob base address
92 *
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +010093 * Adds the and reserved-memorymemreserve regions in the dtb to the lmb block.
94 * Adding the memreserve regions prevents u-boot from using them to store the
95 * initrd or the fdt blob.
Simon Glassc6bdabb2013-05-08 08:06:00 +000096 */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053097void boot_fdt_add_mem_rsv_regions(void *fdt_blob)
Simon Glassc6bdabb2013-05-08 08:06:00 +000098{
99 uint64_t addr, size;
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +0100100 int i, total, ret;
101 int nodeoffset, subnode;
102 struct fdt_resource res;
Ilias Apalodimasd8462bf2024-12-18 09:02:31 +0200103 u32 flags;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000104
105 if (fdt_check_header(fdt_blob) != 0)
106 return;
107
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +0100108 /* process memreserve sections */
Simon Glassc6bdabb2013-05-08 08:06:00 +0000109 total = fdt_num_mem_rsv(fdt_blob);
110 for (i = 0; i < total; i++) {
111 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
112 continue;
Sughosh Ganu04ddcb32024-10-21 22:54:33 +0530113 boot_fdt_reserve_region(addr, size, LMB_NOOVERWRITE);
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +0100114 }
115
116 /* process reserved-memory */
117 nodeoffset = fdt_subnode_offset(fdt_blob, 0, "reserved-memory");
118 if (nodeoffset >= 0) {
119 subnode = fdt_first_subnode(fdt_blob, nodeoffset);
120 while (subnode >= 0) {
121 /* check if this subnode has a reg property */
122 ret = fdt_get_resource(fdt_blob, subnode, "reg", 0,
123 &res);
Thirupathaiah Annapureddye6d6d142020-01-06 22:21:42 -0800124 if (!ret && fdtdec_get_is_enabled(fdt_blob, subnode)) {
Sughosh Ganu04ddcb32024-10-21 22:54:33 +0530125 flags = LMB_NOOVERWRITE;
Patrick Delaunay4a4992b2021-05-07 14:50:33 +0200126 if (fdtdec_get_bool(fdt_blob, subnode,
127 "no-map"))
128 flags = LMB_NOMAP;
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +0100129 addr = res.start;
130 size = res.end - res.start + 1;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530131 boot_fdt_reserve_region(addr, size, flags);
Simon Goldschmidt01adc4c2019-01-14 22:38:17 +0100132 }
133
134 subnode = fdt_next_subnode(fdt_blob, subnode);
135 }
Simon Glassc6bdabb2013-05-08 08:06:00 +0000136 }
137}
138
139/**
140 * boot_relocate_fdt - relocate flat device tree
Simon Glassc6bdabb2013-05-08 08:06:00 +0000141 * @of_flat_tree: pointer to a char* variable, will hold fdt start address
142 * @of_size: pointer to a ulong variable, will hold fdt length
143 *
144 * boot_relocate_fdt() allocates a region of memory within the bootmap and
145 * relocates the of_flat_tree into that region, even if the fdt is already in
146 * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
147 * bytes.
148 *
149 * of_flat_tree and of_size are set to final (after relocation) values
150 *
151 * returns:
152 * 0 - success
153 * 1 - failure
154 */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530155int boot_relocate_fdt(char **of_flat_tree, ulong *of_size)
Simon Glassc6bdabb2013-05-08 08:06:00 +0000156{
Marek Vasutde815742024-04-14 20:37:20 +0200157 u64 start, size, usable, addr, low, mapsize;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000158 void *fdt_blob = *of_flat_tree;
159 void *of_start = NULL;
160 char *fdt_high;
161 ulong of_len = 0;
Marek Vasut6de37b12022-04-08 02:09:19 +0200162 int bank;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000163 int err;
164 int disable_relocation = 0;
165
166 /* nothing to do */
167 if (*of_size == 0)
168 return 0;
169
170 if (fdt_check_header(fdt_blob) != 0) {
171 fdt_error("image is not a fdt");
172 goto error;
173 }
174
175 /* position on a 4K boundary before the alloc_current */
176 /* Pad the FDT by a specified amount */
177 of_len = *of_size + CONFIG_SYS_FDT_PAD;
178
179 /* If fdt_high is set use it to select the relocation address */
Simon Glass64b723f2017-08-03 12:22:12 -0600180 fdt_high = env_get("fdt_high");
Simon Glassc6bdabb2013-05-08 08:06:00 +0000181 if (fdt_high) {
Simon Glass8169ece2022-10-11 09:47:10 -0600182 ulong desired_addr = hextoul(fdt_high, NULL);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000183
Simon Glass8169ece2022-10-11 09:47:10 -0600184 if (desired_addr == ~0UL) {
Simon Glassc6bdabb2013-05-08 08:06:00 +0000185 /* All ones means use fdt in place */
186 of_start = fdt_blob;
Ilias Apalodimasf72c55e2024-12-18 09:02:32 +0200187 lmb_reserve(map_to_sysmem(of_start), of_len, LMB_NONE);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000188 disable_relocation = 1;
189 } else if (desired_addr) {
Ilias Apalodimasd1e9a262024-12-18 09:02:36 +0200190 addr = lmb_alloc_base(of_len, 0x1000, desired_addr,
191 LMB_NONE);
Simon Glass8169ece2022-10-11 09:47:10 -0600192 of_start = map_sysmem(addr, of_len);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000193 if (of_start == NULL) {
194 puts("Failed using fdt_high value for Device Tree");
195 goto error;
196 }
197 } else {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530198 addr = lmb_alloc(of_len, 0x1000);
Simon Glass8169ece2022-10-11 09:47:10 -0600199 of_start = map_sysmem(addr, of_len);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000200 }
201 } else {
Marek Vasut6de37b12022-04-08 02:09:19 +0200202 mapsize = env_get_bootm_mapsize();
203 low = env_get_bootm_low();
204 of_start = NULL;
205
206 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
207 start = gd->bd->bi_dram[bank].start;
208 size = gd->bd->bi_dram[bank].size;
209
210 /* DRAM bank addresses are too low, skip it. */
211 if (start + size < low)
212 continue;
213
Marek Vasut6de37b12022-04-08 02:09:19 +0200214 /*
215 * At least part of this DRAM bank is usable, try
Marek Vasute9748b22024-03-26 23:13:16 +0100216 * using the DRAM bank up to 'usable' address limit
217 * for LMB allocation.
Marek Vasut6de37b12022-04-08 02:09:19 +0200218 */
Marek Vasute9748b22024-03-26 23:13:16 +0100219 usable = min(start + size, low + mapsize);
Ilias Apalodimasd1e9a262024-12-18 09:02:36 +0200220 addr = lmb_alloc_base(of_len, 0x1000, usable, LMB_NONE);
Marek Vasute4530ca2024-03-26 23:13:15 +0100221 of_start = map_sysmem(addr, of_len);
Marek Vasut6de37b12022-04-08 02:09:19 +0200222 /* Allocation succeeded, use this block. */
223 if (of_start != NULL)
224 break;
225
226 /*
227 * Reduce the mapping size in the next bank
228 * by the size of attempt in current bank.
229 */
Marek Vasutf816c422024-03-26 23:13:11 +0100230 mapsize -= usable - max(start, low);
Marek Vasut6de37b12022-04-08 02:09:19 +0200231 if (!mapsize)
232 break;
233 }
Simon Glassc6bdabb2013-05-08 08:06:00 +0000234 }
235
236 if (of_start == NULL) {
237 puts("device tree - allocation error\n");
238 goto error;
239 }
240
241 if (disable_relocation) {
242 /*
243 * We assume there is space after the existing fdt to use
244 * for padding
245 */
246 fdt_set_totalsize(of_start, of_len);
247 printf(" Using Device Tree in place at %p, end %p\n",
248 of_start, of_start + of_len - 1);
249 } else {
250 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
251 fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
252
253 printf(" Loading Device Tree to %p, end %p ... ",
254 of_start, of_start + of_len - 1);
255
256 err = fdt_open_into(fdt_blob, of_start, of_len);
257 if (err != 0) {
258 fdt_error("fdt move failed");
259 goto error;
260 }
261 puts("OK\n");
262 }
263
264 *of_flat_tree = of_start;
265 *of_size = of_len;
266
Simon Glasse2d49d92023-02-05 15:36:30 -0700267 if (IS_ENABLED(CONFIG_CMD_FDT))
Simon Goldschmidt6127ac02018-12-17 20:14:42 +0100268 set_working_fdt_addr(map_to_sysmem(*of_flat_tree));
Simon Glassc6bdabb2013-05-08 08:06:00 +0000269 return 0;
270
271error:
272 return 1;
273}
274
Simon Glassc6bdabb2013-05-08 08:06:00 +0000275/**
Simon Glass8a876e42021-09-25 19:43:41 -0600276 * select_fdt() - Select and locate the FDT to use
Simon Glassc6bdabb2013-05-08 08:06:00 +0000277 *
Simon Glass8a876e42021-09-25 19:43:41 -0600278 * @images: pointer to the bootm images structure
279 * @select: name of FDT to select, or NULL for any
280 * @arch: expected FDT architecture
281 * @fdt_addrp: pointer to a ulong variable, will hold FDT pointer
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100282 * Return: 0 if OK, -ENOPKG if no FDT (but an error should not be reported),
Simon Glass8a876e42021-09-25 19:43:41 -0600283 * other -ve value on other error
Simon Glassc6bdabb2013-05-08 08:06:00 +0000284 */
Simon Glassc6bdabb2013-05-08 08:06:00 +0000285
Simon Glassdf00afa2022-09-06 20:26:50 -0600286static int select_fdt(struct bootm_headers *images, const char *select, u8 arch,
Simon Glass8a876e42021-09-25 19:43:41 -0600287 ulong *fdt_addrp)
288{
289 const char *buf;
290 ulong fdt_addr;
Shawn Guoc9e71522019-01-15 22:26:37 +0800291
Simon Glasse3ee2fb2016-02-22 22:55:43 -0700292#if CONFIG_IS_ENABLED(FIT)
Simon Glass8a876e42021-09-25 19:43:41 -0600293 const char *fit_uname_config = images->fit_uname_cfg;
294 const char *fit_uname_fdt = NULL;
295 ulong default_addr;
296 int fdt_noffset;
Simon Glass3afbb602021-09-25 19:43:40 -0600297
Simon Glass8a876e42021-09-25 19:43:41 -0600298 if (select) {
Simon Glassc6bdabb2013-05-08 08:06:00 +0000299 /*
300 * If the FDT blob comes from the FIT image and the
301 * FIT image address is omitted in the command line
302 * argument, try to use ramdisk or os FIT image
303 * address or default load address.
304 */
305 if (images->fit_uname_rd)
306 default_addr = (ulong)images->fit_hdr_rd;
307 else if (images->fit_uname_os)
308 default_addr = (ulong)images->fit_hdr_os;
309 else
Simon Glass892265d2019-12-28 10:45:02 -0700310 default_addr = image_load_addr;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000311
Simon Glass8a876e42021-09-25 19:43:41 -0600312 if (fit_parse_conf(select, default_addr, &fdt_addr,
313 &fit_uname_config)) {
Simon Glassc6bdabb2013-05-08 08:06:00 +0000314 debug("* fdt: config '%s' from image at 0x%08lx\n",
315 fit_uname_config, fdt_addr);
Simon Glass8a876e42021-09-25 19:43:41 -0600316 } else if (fit_parse_subimage(select, default_addr, &fdt_addr,
317 &fit_uname_fdt)) {
Simon Glassc6bdabb2013-05-08 08:06:00 +0000318 debug("* fdt: subimage '%s' from image at 0x%08lx\n",
319 fit_uname_fdt, fdt_addr);
320 } else
321#endif
Simon Glass8a876e42021-09-25 19:43:41 -0600322 {
323 fdt_addr = hextoul(select, NULL);
324 debug("* fdt: cmdline image address = 0x%08lx\n",
325 fdt_addr);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000326 }
Simon Glass8a876e42021-09-25 19:43:41 -0600327#if CONFIG_IS_ENABLED(FIT)
328 } else {
329 /* use FIT configuration provided in first bootm
330 * command argument
331 */
332 fdt_addr = map_to_sysmem(images->fit_hdr_os);
333 fdt_noffset = fit_get_node_from_config(images, FIT_FDT_PROP,
334 fdt_addr);
335 if (fdt_noffset == -ENOENT)
336 return -ENOPKG;
337 else if (fdt_noffset < 0)
338 return fdt_noffset;
339 }
Simon Glassc6bdabb2013-05-08 08:06:00 +0000340#endif
Simon Glass8a876e42021-09-25 19:43:41 -0600341 debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
342 fdt_addr);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000343
Simon Glass8a876e42021-09-25 19:43:41 -0600344 /*
345 * Check if there is an FDT image at the
346 * address provided in the second bootm argument
347 * check image type, for FIT images get a FIT node.
348 */
349 buf = map_sysmem(fdt_addr, 0);
350 switch (genimg_get_format(buf)) {
Tom Rinic220bd92019-05-23 07:14:07 -0400351#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
Simon Glass8a876e42021-09-25 19:43:41 -0600352 case IMAGE_FORMAT_LEGACY: {
Simon Glassbb7d3bb2022-09-06 20:26:52 -0600353 const struct legacy_img_hdr *fdt_hdr;
Simon Glass3afbb602021-09-25 19:43:40 -0600354 ulong load, load_end;
355 ulong image_start, image_data, image_end;
356
Simon Glassc6bdabb2013-05-08 08:06:00 +0000357 /* verify fdt_addr points to a valid image header */
358 printf("## Flattened Device Tree from Legacy Image at %08lx\n",
359 fdt_addr);
360 fdt_hdr = image_get_fdt(fdt_addr);
361 if (!fdt_hdr)
Simon Glass8a876e42021-09-25 19:43:41 -0600362 return -ENOPKG;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000363
364 /*
365 * move image data to the load address,
366 * make sure we don't overwrite initial image
367 */
368 image_start = (ulong)fdt_hdr;
369 image_data = (ulong)image_get_data(fdt_hdr);
370 image_end = image_get_image_end(fdt_hdr);
371
Simon Glassb1b79922013-05-16 13:53:23 +0000372 load = image_get_load(fdt_hdr);
373 load_end = load + image_get_data_size(fdt_hdr);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000374
Simon Glassb1b79922013-05-16 13:53:23 +0000375 if (load == image_start ||
376 load == image_data) {
Peng Fanab80a112015-11-24 16:54:22 +0800377 fdt_addr = load;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000378 break;
379 }
380
Simon Glassb1b79922013-05-16 13:53:23 +0000381 if ((load < image_end) && (load_end > image_start)) {
Simon Glassc6bdabb2013-05-08 08:06:00 +0000382 fdt_error("fdt overwritten");
Simon Glass8a876e42021-09-25 19:43:41 -0600383 return -EFAULT;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000384 }
385
386 debug(" Loading FDT from 0x%08lx to 0x%08lx\n",
Simon Glassb1b79922013-05-16 13:53:23 +0000387 image_data, load);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000388
Simon Glassb1b79922013-05-16 13:53:23 +0000389 memmove((void *)load,
Simon Glassc6bdabb2013-05-08 08:06:00 +0000390 (void *)image_data,
391 image_get_data_size(fdt_hdr));
392
Simon Glassb1b79922013-05-16 13:53:23 +0000393 fdt_addr = load;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000394 break;
Simon Glass3afbb602021-09-25 19:43:40 -0600395 }
Heiko Schocher515eb122014-05-28 11:33:33 +0200396#endif
Simon Glass8a876e42021-09-25 19:43:41 -0600397 case IMAGE_FORMAT_FIT:
398 /*
399 * This case will catch both: new uImage format
400 * (libfdt based) and raw FDT blob (also libfdt
401 * based).
402 */
Simon Glasse3ee2fb2016-02-22 22:55:43 -0700403#if CONFIG_IS_ENABLED(FIT)
Simon Glassc6bdabb2013-05-08 08:06:00 +0000404 /* check FDT blob vs FIT blob */
Simon Glassd563c252021-02-15 17:08:09 -0700405 if (!fit_check_format(buf, IMAGE_SIZE_INVAL)) {
Simon Glassb1b79922013-05-16 13:53:23 +0000406 ulong load, len;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000407
Simon Glass8a876e42021-09-25 19:43:41 -0600408 fdt_noffset = boot_get_fdt_fit(images, fdt_addr,
409 &fit_uname_fdt,
410 &fit_uname_config,
411 arch, &load, &len);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000412
Hongwei Zhang1f215e32020-12-02 14:47:03 -0500413 if (fdt_noffset < 0)
Simon Glass8a876e42021-09-25 19:43:41 -0600414 return -ENOENT;
Hongwei Zhang1f215e32020-12-02 14:47:03 -0500415
Simon Glassb1b79922013-05-16 13:53:23 +0000416 images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000417 images->fit_uname_fdt = fit_uname_fdt;
418 images->fit_noffset_fdt = fdt_noffset;
Simon Glassb1b79922013-05-16 13:53:23 +0000419 fdt_addr = load;
Pantelis Antoniou6e51fb22017-09-04 23:12:16 +0300420
Simon Glassc6bdabb2013-05-08 08:06:00 +0000421 break;
Simon Glass8a876e42021-09-25 19:43:41 -0600422 } else
Simon Glassc6bdabb2013-05-08 08:06:00 +0000423#endif
Simon Glass8a876e42021-09-25 19:43:41 -0600424 {
425 /*
426 * FDT blob
427 */
428 debug("* fdt: raw FDT blob\n");
429 printf("## Flattened Device Tree blob at %08lx\n",
430 (long)fdt_addr);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000431 }
Simon Glass8a876e42021-09-25 19:43:41 -0600432 break;
433 default:
434 puts("ERROR: Did not find a cmdline Flattened Device Tree\n");
435 return -ENOENT;
436 }
437 *fdt_addrp = fdt_addr;
438
439 return 0;
440}
441
Simon Glassdb125e02023-11-18 14:05:10 -0700442int boot_get_fdt(void *buf, const char *select, uint arch,
Simon Glassaf2c72c2023-11-18 14:05:09 -0700443 struct bootm_headers *images, char **of_flat_tree,
444 ulong *of_size)
Simon Glass8a876e42021-09-25 19:43:41 -0600445{
Simon Glassdb125e02023-11-18 14:05:10 -0700446 char *fdt_blob = NULL;
447 ulong fdt_addr;
Simon Glass8a876e42021-09-25 19:43:41 -0600448
449 *of_flat_tree = NULL;
450 *of_size = 0;
451
Simon Glass8a876e42021-09-25 19:43:41 -0600452 if (select || genimg_has_config(images)) {
453 int ret;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000454
Simon Glass8a876e42021-09-25 19:43:41 -0600455 ret = select_fdt(images, select, arch, &fdt_addr);
456 if (ret == -ENOPKG)
457 goto no_fdt;
458 else if (ret)
459 return 1;
Simon Glassb1b79922013-05-16 13:53:23 +0000460 printf(" Booting using the fdt blob at %#08lx\n", fdt_addr);
461 fdt_blob = map_sysmem(fdt_addr, 0);
Simon Glassc6bdabb2013-05-08 08:06:00 +0000462 } else if (images->legacy_hdr_valid &&
463 image_check_type(&images->legacy_hdr_os_copy,
464 IH_TYPE_MULTI)) {
465 ulong fdt_data, fdt_len;
466
467 /*
468 * Now check if we have a legacy multi-component image,
469 * get second entry data start address and len.
470 */
471 printf("## Flattened Device Tree from multi component Image at %08lX\n",
472 (ulong)images->legacy_hdr_os);
473
474 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
475 &fdt_len);
476 if (fdt_len) {
477 fdt_blob = (char *)fdt_data;
478 printf(" Booting using the fdt at 0x%p\n", fdt_blob);
479
480 if (fdt_check_header(fdt_blob) != 0) {
481 fdt_error("image is not a fdt");
482 goto error;
483 }
484
485 if (fdt_totalsize(fdt_blob) != fdt_len) {
486 fdt_error("fdt size != image size");
487 goto error;
488 }
489 } else {
490 debug("## No Flattened Device Tree\n");
Suriyan Ramasami00f9ca92014-11-27 13:24:16 -0800491 goto no_fdt;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000492 }
Shawn Guoc9e71522019-01-15 22:26:37 +0800493#ifdef CONFIG_ANDROID_BOOT_IMAGE
494 } else if (genimg_get_format(buf) == IMAGE_FORMAT_ANDROID) {
Safae Ouajih51c981b2023-02-06 00:50:17 +0100495 void *hdr = buf;
chenshuo1c7d9042020-07-20 08:48:15 +0800496 ulong fdt_data, fdt_len;
497 u32 fdt_size, dtb_idx;
498 /*
499 * Firstly check if this android boot image has dtb field.
500 */
501 dtb_idx = (u32)env_get_ulong("adtb_idx", 10, 0);
Mattijs Korpershoek2b5c70a2024-07-10 10:40:02 +0200502 if (android_image_get_dtb_by_index((ulong)hdr, get_avendor_bootimg_addr(),
Safae Ouajihc60ae102023-02-06 00:50:11 +0100503 dtb_idx, &fdt_addr, &fdt_size)) {
chenshuo1c7d9042020-07-20 08:48:15 +0800504 fdt_blob = (char *)map_sysmem(fdt_addr, 0);
505 if (fdt_check_header(fdt_blob))
506 goto no_fdt;
Shawn Guoc9e71522019-01-15 22:26:37 +0800507
chenshuo1c7d9042020-07-20 08:48:15 +0800508 debug("## Using FDT in Android image dtb area with idx %u\n", dtb_idx);
509 } else if (!android_image_get_second(hdr, &fdt_data, &fdt_len) &&
510 !fdt_check_header((char *)fdt_data)) {
Eugeniu Rosca60a869a2019-04-01 12:45:36 +0200511 fdt_blob = (char *)fdt_data;
512 if (fdt_totalsize(fdt_blob) != fdt_len)
513 goto error;
Shawn Guoc9e71522019-01-15 22:26:37 +0800514
Eugeniu Rosca60a869a2019-04-01 12:45:36 +0200515 debug("## Using FDT in Android image second area\n");
516 } else {
Eugeniu Roscad3617b42019-04-01 12:52:52 +0200517 fdt_addr = env_get_hex("fdtaddr", 0);
518 if (!fdt_addr)
519 goto no_fdt;
Shawn Guoc9e71522019-01-15 22:26:37 +0800520
Eugeniu Roscad3617b42019-04-01 12:52:52 +0200521 fdt_blob = map_sysmem(fdt_addr, 0);
522 if (fdt_check_header(fdt_blob))
523 goto no_fdt;
Shawn Guoc9e71522019-01-15 22:26:37 +0800524
Eugeniu Roscad3617b42019-04-01 12:52:52 +0200525 debug("## Using FDT at ${fdtaddr}=Ox%lx\n", fdt_addr);
Eugeniu Rosca60a869a2019-04-01 12:45:36 +0200526 }
Shawn Guoc9e71522019-01-15 22:26:37 +0800527#endif
Simon Glassc6bdabb2013-05-08 08:06:00 +0000528 } else {
529 debug("## No Flattened Device Tree\n");
Suriyan Ramasami00f9ca92014-11-27 13:24:16 -0800530 goto no_fdt;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000531 }
532
533 *of_flat_tree = fdt_blob;
534 *of_size = fdt_totalsize(fdt_blob);
535 debug(" of_flat_tree at 0x%08lx size 0x%08lx\n",
536 (ulong)*of_flat_tree, *of_size);
537
538 return 0;
539
Suriyan Ramasami00f9ca92014-11-27 13:24:16 -0800540no_fdt:
Eugeniu Roscaa7da5022019-04-01 12:45:35 +0200541 debug("Continuing to boot without FDT\n");
542 return 0;
Simon Glassc6bdabb2013-05-08 08:06:00 +0000543error:
Simon Glassc6bdabb2013-05-08 08:06:00 +0000544 return 1;
545}
Simon Glass9ca37422013-05-08 08:06:01 +0000546
547/*
548 * Verify the device tree.
549 *
550 * This function is called after all device tree fix-ups have been enacted,
551 * so that the final device tree can be verified. The definition of "verified"
552 * is up to the specific implementation. However, it generally means that the
553 * addresses of some of the devices in the device tree are compared with the
554 * actual addresses at which U-Boot has placed them.
555 *
Bin Meng75574052016-02-05 19:30:11 -0800556 * Returns 1 on success, 0 on failure. If 0 is returned, U-Boot will halt the
Simon Glass9ca37422013-05-08 08:06:01 +0000557 * boot process.
558 */
559__weak int ft_verify_fdt(void *fdt)
560{
561 return 1;
562}
563
Alexey Brodkin91a31592018-01-24 20:47:09 +0300564__weak int arch_fixup_fdt(void *blob)
565{
566 return 0;
567}
568
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530569int image_setup_libfdt(struct bootm_headers *images, void *blob, bool lmb)
Simon Glass9ca37422013-05-08 08:06:01 +0000570{
571 ulong *initrd_start = &images->initrd_start;
572 ulong *initrd_end = &images->initrd_end;
Matthias Schiffere908fec2023-12-11 12:03:17 +0100573 int ret, fdt_ret, of_size;
574
575 if (IS_ENABLED(CONFIG_OF_ENV_SETUP)) {
576 const char *fdt_fixup;
577
578 fdt_fixup = env_get("fdt_fixup");
579 if (fdt_fixup) {
580 set_working_fdt_addr(map_to_sysmem(blob));
581 ret = run_command_list(fdt_fixup, -1, 0);
582 if (ret)
583 printf("WARNING: fdt_fixup command returned %d\n",
584 ret);
585 }
586 }
587
588 ret = -EPERM;
Simon Glass9ca37422013-05-08 08:06:01 +0000589
Paul Kocialkowski2c0fbc72015-05-21 11:27:03 +0200590 if (fdt_root(blob) < 0) {
591 printf("ERROR: root node setup failed\n");
592 goto err;
593 }
Masahiro Yamada451c2042014-04-18 17:41:00 +0900594 if (fdt_chosen(blob) < 0) {
Simon Glassf3dd50b2014-10-23 18:58:53 -0600595 printf("ERROR: /chosen node create failed\n");
596 goto err;
Simon Glass9ca37422013-05-08 08:06:01 +0000597 }
Ma Haijun62358242014-07-12 14:24:06 +0100598 if (arch_fixup_fdt(blob) < 0) {
Simon Glassf3dd50b2014-10-23 18:58:53 -0600599 printf("ERROR: arch-specific fdt fixup failed\n");
600 goto err;
Ma Haijun62358242014-07-12 14:24:06 +0100601 }
Etienne Carriere2502e292020-06-05 09:22:54 +0200602
Patrick Delaunay05381402021-02-08 13:54:31 +0100603 fdt_ret = optee_copy_fdt_nodes(blob);
Etienne Carriere2502e292020-06-05 09:22:54 +0200604 if (fdt_ret) {
605 printf("ERROR: transfer of optee nodes to new fdt failed: %s\n",
606 fdt_strerror(fdt_ret));
607 goto err;
608 }
609
Daniel Gollec5df3e22022-04-12 21:00:43 +0100610 /* Store name of configuration node as u-boot,bootconf in /chosen node */
611 if (images->fit_uname_cfg)
612 fdt_find_and_setprop(blob, "/chosen", "u-boot,bootconf",
613 images->fit_uname_cfg,
614 strlen(images->fit_uname_cfg) + 1, 1);
615
Tom Rini78548ea2017-04-28 08:51:44 -0400616 /* Update ethernet nodes */
617 fdt_fixup_ethernet(blob);
Simon Glassdb5d0d22023-02-05 15:36:38 -0700618#if IS_ENABLED(CONFIG_CMD_PSTORE)
Frédéric Daniscdd6a6d2020-03-20 10:59:24 +0100619 /* Append PStore configuration */
620 fdt_fixup_pstore(blob);
621#endif
Simon Glassd49049f2021-09-25 19:43:26 -0600622 if (IS_ENABLED(CONFIG_OF_BOARD_SETUP)) {
Wasim Khan6e5aad82021-02-04 15:44:04 +0100623 const char *skip_board_fixup;
624
625 skip_board_fixup = env_get("skip_board_fixup");
626 if (skip_board_fixup && ((int)simple_strtol(skip_board_fixup, NULL, 10) == 1)) {
627 printf("skip board fdt fixup\n");
628 } else {
629 fdt_ret = ft_board_setup(blob, gd->bd);
630 if (fdt_ret) {
631 printf("ERROR: board-specific fdt fixup failed: %s\n",
632 fdt_strerror(fdt_ret));
633 goto err;
634 }
Simon Glassf3dd50b2014-10-23 18:58:53 -0600635 }
636 }
Simon Glass336b9c72021-09-25 19:43:27 -0600637 if (IS_ENABLED(CONFIG_OF_SYSTEM_SETUP)) {
Max Krummenacher17585f22015-08-05 17:17:03 +0200638 fdt_ret = ft_system_setup(blob, gd->bd);
639 if (fdt_ret) {
Simon Glass6c0be912014-10-23 18:58:54 -0600640 printf("ERROR: system-specific fdt fixup failed: %s\n",
641 fdt_strerror(fdt_ret));
642 goto err;
643 }
644 }
Simon Glass449b7592023-11-12 08:27:48 -0700645
646 if (fdt_initrd(blob, *initrd_start, *initrd_end))
647 goto err;
648
Simon Glass80968942023-11-12 08:27:50 -0700649 if (!ft_verify_fdt(blob))
650 goto err;
651
652 /* after here we are using a livetree */
Simon Glassf4ff7032022-10-11 09:47:15 -0600653 if (!of_live_active() && CONFIG_IS_ENABLED(EVENT)) {
Simon Glass4305fe72022-07-30 15:52:31 -0600654 struct event_ft_fixup fixup;
655
Simon Glassf4ff7032022-10-11 09:47:15 -0600656 fixup.tree = oftree_from_fdt(blob);
Simon Glass74ba8e62022-09-06 20:26:58 -0600657 fixup.images = images;
Simon Glassf4ff7032022-10-11 09:47:15 -0600658 if (oftree_valid(fixup.tree)) {
659 ret = event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup));
660 if (ret) {
661 printf("ERROR: fdt fixup event failed: %d\n",
662 ret);
663 goto err;
664 }
Simon Glass4305fe72022-07-30 15:52:31 -0600665 }
666 }
Simon Glass9ca37422013-05-08 08:06:01 +0000667
668 /* Delete the old LMB reservation */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530669 if (CONFIG_IS_ENABLED(LMB) && lmb)
670 lmb_free(map_to_sysmem(blob), fdt_totalsize(blob));
Simon Glass9ca37422013-05-08 08:06:01 +0000671
Hannes Schmelzerd3dbac82016-09-20 18:10:43 +0200672 ret = fdt_shrink_to_minimum(blob, 0);
Simon Glass9ca37422013-05-08 08:06:01 +0000673 if (ret < 0)
Simon Glassf3dd50b2014-10-23 18:58:53 -0600674 goto err;
Simon Glass9ca37422013-05-08 08:06:01 +0000675 of_size = ret;
676
Simon Glass9ca37422013-05-08 08:06:01 +0000677 /* Create a new LMB reservation */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530678 if (CONFIG_IS_ENABLED(LMB) && lmb)
Ilias Apalodimasf72c55e2024-12-18 09:02:32 +0200679 lmb_reserve(map_to_sysmem(blob), of_size, LMB_NONE);
Simon Glass9ca37422013-05-08 08:06:01 +0000680
Tom Rini84c0f692021-09-12 20:32:32 -0400681#if defined(CONFIG_ARCH_KEYSTONE)
Simon Glassd49049f2021-09-25 19:43:26 -0600682 if (IS_ENABLED(CONFIG_OF_BOARD_SETUP))
Vitaly Andrianova122cbb2014-04-04 13:16:47 -0400683 ft_board_setup_ex(blob, gd->bd);
684#endif
685
Simon Glass9ca37422013-05-08 08:06:01 +0000686 return 0;
Simon Glassf3dd50b2014-10-23 18:58:53 -0600687err:
688 printf(" - must RESET the board to recover.\n\n");
689
690 return ret;
Simon Glass9ca37422013-05-08 08:06:01 +0000691}