mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-31 14:28:52 +09:00
![Alexander Graf](/assets/img/avatar_default.png)
We have a nice framework around image fils to prepare a device tree for OS execution. That one patches in missing device tree nodes and fixes up the memory range bits. We need to call that one from the EFI boot path too to get all those nice fixups. This patch adds the call. Signed-off-by: Alexander Graf <agraf@suse.de>
537 lines
14 KiB
C
537 lines
14 KiB
C
/*
|
|
* Copyright (c) 2013, Google Inc.
|
|
*
|
|
* (C) Copyright 2008 Semihalf
|
|
*
|
|
* (C) Copyright 2000-2006
|
|
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <fdt_support.h>
|
|
#include <errno.h>
|
|
#include <image.h>
|
|
#include <libfdt.h>
|
|
#include <mapmem.h>
|
|
#include <asm/io.h>
|
|
|
|
#ifndef CONFIG_SYS_FDT_PAD
|
|
#define CONFIG_SYS_FDT_PAD 0x3000
|
|
#endif
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
static void fdt_error(const char *msg)
|
|
{
|
|
puts("ERROR: ");
|
|
puts(msg);
|
|
puts(" - must RESET the board to recover.\n");
|
|
}
|
|
|
|
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
|
|
static const image_header_t *image_get_fdt(ulong fdt_addr)
|
|
{
|
|
const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0);
|
|
|
|
image_print_contents(fdt_hdr);
|
|
|
|
puts(" Verifying Checksum ... ");
|
|
if (!image_check_hcrc(fdt_hdr)) {
|
|
fdt_error("fdt header checksum invalid");
|
|
return NULL;
|
|
}
|
|
|
|
if (!image_check_dcrc(fdt_hdr)) {
|
|
fdt_error("fdt checksum invalid");
|
|
return NULL;
|
|
}
|
|
puts("OK\n");
|
|
|
|
if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
|
|
fdt_error("uImage is not a fdt");
|
|
return NULL;
|
|
}
|
|
if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
|
|
fdt_error("uImage is compressed");
|
|
return NULL;
|
|
}
|
|
if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {
|
|
fdt_error("uImage data is not a fdt");
|
|
return NULL;
|
|
}
|
|
return fdt_hdr;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
|
|
* @lmb: pointer to lmb handle, will be used for memory mgmt
|
|
* @fdt_blob: pointer to fdt blob base address
|
|
*
|
|
* Adds the memreserve regions in the dtb to the lmb block. Adding the
|
|
* memreserve regions prevents u-boot from using them to store the initrd
|
|
* or the fdt blob.
|
|
*/
|
|
void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
|
|
{
|
|
uint64_t addr, size;
|
|
int i, total;
|
|
|
|
if (fdt_check_header(fdt_blob) != 0)
|
|
return;
|
|
|
|
total = fdt_num_mem_rsv(fdt_blob);
|
|
for (i = 0; i < total; i++) {
|
|
if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
|
|
continue;
|
|
printf(" reserving fdt memory region: addr=%llx size=%llx\n",
|
|
(unsigned long long)addr, (unsigned long long)size);
|
|
lmb_reserve(lmb, addr, size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* boot_relocate_fdt - relocate flat device tree
|
|
* @lmb: pointer to lmb handle, will be used for memory mgmt
|
|
* @of_flat_tree: pointer to a char* variable, will hold fdt start address
|
|
* @of_size: pointer to a ulong variable, will hold fdt length
|
|
*
|
|
* boot_relocate_fdt() allocates a region of memory within the bootmap and
|
|
* relocates the of_flat_tree into that region, even if the fdt is already in
|
|
* the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
|
|
* bytes.
|
|
*
|
|
* of_flat_tree and of_size are set to final (after relocation) values
|
|
*
|
|
* returns:
|
|
* 0 - success
|
|
* 1 - failure
|
|
*/
|
|
int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
|
|
{
|
|
void *fdt_blob = *of_flat_tree;
|
|
void *of_start = NULL;
|
|
char *fdt_high;
|
|
ulong of_len = 0;
|
|
int err;
|
|
int disable_relocation = 0;
|
|
|
|
/* nothing to do */
|
|
if (*of_size == 0)
|
|
return 0;
|
|
|
|
if (fdt_check_header(fdt_blob) != 0) {
|
|
fdt_error("image is not a fdt");
|
|
goto error;
|
|
}
|
|
|
|
/* position on a 4K boundary before the alloc_current */
|
|
/* Pad the FDT by a specified amount */
|
|
of_len = *of_size + CONFIG_SYS_FDT_PAD;
|
|
|
|
/* If fdt_high is set use it to select the relocation address */
|
|
fdt_high = getenv("fdt_high");
|
|
if (fdt_high) {
|
|
void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
|
|
|
|
if (((ulong) desired_addr) == ~0UL) {
|
|
/* All ones means use fdt in place */
|
|
of_start = fdt_blob;
|
|
lmb_reserve(lmb, (ulong)of_start, of_len);
|
|
disable_relocation = 1;
|
|
} else if (desired_addr) {
|
|
of_start =
|
|
(void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
|
|
(ulong)desired_addr);
|
|
if (of_start == NULL) {
|
|
puts("Failed using fdt_high value for Device Tree");
|
|
goto error;
|
|
}
|
|
} else {
|
|
of_start =
|
|
(void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
|
|
}
|
|
} else {
|
|
of_start =
|
|
(void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
|
|
getenv_bootm_mapsize()
|
|
+ getenv_bootm_low());
|
|
}
|
|
|
|
if (of_start == NULL) {
|
|
puts("device tree - allocation error\n");
|
|
goto error;
|
|
}
|
|
|
|
if (disable_relocation) {
|
|
/*
|
|
* We assume there is space after the existing fdt to use
|
|
* for padding
|
|
*/
|
|
fdt_set_totalsize(of_start, of_len);
|
|
printf(" Using Device Tree in place at %p, end %p\n",
|
|
of_start, of_start + of_len - 1);
|
|
} else {
|
|
debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
|
|
fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
|
|
|
|
printf(" Loading Device Tree to %p, end %p ... ",
|
|
of_start, of_start + of_len - 1);
|
|
|
|
err = fdt_open_into(fdt_blob, of_start, of_len);
|
|
if (err != 0) {
|
|
fdt_error("fdt move failed");
|
|
goto error;
|
|
}
|
|
puts("OK\n");
|
|
}
|
|
|
|
*of_flat_tree = of_start;
|
|
*of_size = of_len;
|
|
|
|
set_working_fdt_addr((ulong)*of_flat_tree);
|
|
return 0;
|
|
|
|
error:
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* boot_get_fdt - main fdt handling routine
|
|
* @argc: command argument count
|
|
* @argv: command argument list
|
|
* @arch: architecture (IH_ARCH_...)
|
|
* @images: pointer to the bootm images structure
|
|
* @of_flat_tree: pointer to a char* variable, will hold fdt start address
|
|
* @of_size: pointer to a ulong variable, will hold fdt length
|
|
*
|
|
* boot_get_fdt() is responsible for finding a valid flat device tree image.
|
|
* Curently supported are the following ramdisk sources:
|
|
* - multicomponent kernel/ramdisk image,
|
|
* - commandline provided address of decicated ramdisk image.
|
|
*
|
|
* returns:
|
|
* 0, if fdt image was found and valid, or skipped
|
|
* of_flat_tree and of_size are set to fdt start address and length if
|
|
* fdt image is found and valid
|
|
*
|
|
* 1, if fdt image is found but corrupted
|
|
* of_flat_tree and of_size are set to 0 if no fdt exists
|
|
*/
|
|
int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
|
|
bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
|
|
{
|
|
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
|
|
const image_header_t *fdt_hdr;
|
|
ulong load, load_end;
|
|
ulong image_start, image_data, image_end;
|
|
#endif
|
|
ulong fdt_addr;
|
|
char *fdt_blob = NULL;
|
|
void *buf;
|
|
#if CONFIG_IS_ENABLED(FIT)
|
|
const char *fit_uname_config = images->fit_uname_cfg;
|
|
const char *fit_uname_fdt = NULL;
|
|
ulong default_addr;
|
|
int fdt_noffset;
|
|
#endif
|
|
const char *select = NULL;
|
|
int ok_no_fdt = 0;
|
|
|
|
*of_flat_tree = NULL;
|
|
*of_size = 0;
|
|
|
|
if (argc > 2)
|
|
select = argv[2];
|
|
if (select || genimg_has_config(images)) {
|
|
#if CONFIG_IS_ENABLED(FIT)
|
|
if (select) {
|
|
/*
|
|
* If the FDT blob comes from the FIT image and the
|
|
* FIT image address is omitted in the command line
|
|
* argument, try to use ramdisk or os FIT image
|
|
* address or default load address.
|
|
*/
|
|
if (images->fit_uname_rd)
|
|
default_addr = (ulong)images->fit_hdr_rd;
|
|
else if (images->fit_uname_os)
|
|
default_addr = (ulong)images->fit_hdr_os;
|
|
else
|
|
default_addr = load_addr;
|
|
|
|
if (fit_parse_conf(select, default_addr,
|
|
&fdt_addr, &fit_uname_config)) {
|
|
debug("* fdt: config '%s' from image at 0x%08lx\n",
|
|
fit_uname_config, fdt_addr);
|
|
} else if (fit_parse_subimage(select, default_addr,
|
|
&fdt_addr, &fit_uname_fdt)) {
|
|
debug("* fdt: subimage '%s' from image at 0x%08lx\n",
|
|
fit_uname_fdt, fdt_addr);
|
|
} else
|
|
#endif
|
|
{
|
|
fdt_addr = simple_strtoul(select, NULL, 16);
|
|
debug("* fdt: cmdline image address = 0x%08lx\n",
|
|
fdt_addr);
|
|
}
|
|
#if CONFIG_IS_ENABLED(FIT)
|
|
} else {
|
|
/* use FIT configuration provided in first bootm
|
|
* command argument
|
|
*/
|
|
fdt_addr = map_to_sysmem(images->fit_hdr_os);
|
|
fdt_noffset = fit_get_node_from_config(images,
|
|
FIT_FDT_PROP,
|
|
fdt_addr);
|
|
if (fdt_noffset == -ENOLINK)
|
|
return 0;
|
|
else if (fdt_noffset < 0)
|
|
return 1;
|
|
}
|
|
#endif
|
|
debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
|
|
fdt_addr);
|
|
|
|
/* copy from dataflash if needed */
|
|
fdt_addr = genimg_get_image(fdt_addr);
|
|
|
|
/*
|
|
* Check if there is an FDT image at the
|
|
* address provided in the second bootm argument
|
|
* check image type, for FIT images get a FIT node.
|
|
*/
|
|
buf = map_sysmem(fdt_addr, 0);
|
|
switch (genimg_get_format(buf)) {
|
|
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
|
|
case IMAGE_FORMAT_LEGACY:
|
|
/* verify fdt_addr points to a valid image header */
|
|
printf("## Flattened Device Tree from Legacy Image at %08lx\n",
|
|
fdt_addr);
|
|
fdt_hdr = image_get_fdt(fdt_addr);
|
|
if (!fdt_hdr)
|
|
goto no_fdt;
|
|
|
|
/*
|
|
* move image data to the load address,
|
|
* make sure we don't overwrite initial image
|
|
*/
|
|
image_start = (ulong)fdt_hdr;
|
|
image_data = (ulong)image_get_data(fdt_hdr);
|
|
image_end = image_get_image_end(fdt_hdr);
|
|
|
|
load = image_get_load(fdt_hdr);
|
|
load_end = load + image_get_data_size(fdt_hdr);
|
|
|
|
if (load == image_start ||
|
|
load == image_data) {
|
|
fdt_addr = load;
|
|
break;
|
|
}
|
|
|
|
if ((load < image_end) && (load_end > image_start)) {
|
|
fdt_error("fdt overwritten");
|
|
goto error;
|
|
}
|
|
|
|
debug(" Loading FDT from 0x%08lx to 0x%08lx\n",
|
|
image_data, load);
|
|
|
|
memmove((void *)load,
|
|
(void *)image_data,
|
|
image_get_data_size(fdt_hdr));
|
|
|
|
fdt_addr = load;
|
|
break;
|
|
#endif
|
|
case IMAGE_FORMAT_FIT:
|
|
/*
|
|
* This case will catch both: new uImage format
|
|
* (libfdt based) and raw FDT blob (also libfdt
|
|
* based).
|
|
*/
|
|
#if CONFIG_IS_ENABLED(FIT)
|
|
/* check FDT blob vs FIT blob */
|
|
if (fit_check_format(buf)) {
|
|
ulong load, len;
|
|
|
|
fdt_noffset = fit_image_load(images,
|
|
fdt_addr, &fit_uname_fdt,
|
|
&fit_uname_config,
|
|
arch, IH_TYPE_FLATDT,
|
|
BOOTSTAGE_ID_FIT_FDT_START,
|
|
FIT_LOAD_OPTIONAL, &load, &len);
|
|
|
|
images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
|
|
images->fit_uname_fdt = fit_uname_fdt;
|
|
images->fit_noffset_fdt = fdt_noffset;
|
|
fdt_addr = load;
|
|
break;
|
|
} else
|
|
#endif
|
|
{
|
|
/*
|
|
* FDT blob
|
|
*/
|
|
debug("* fdt: raw FDT blob\n");
|
|
printf("## Flattened Device Tree blob at %08lx\n",
|
|
(long)fdt_addr);
|
|
}
|
|
break;
|
|
default:
|
|
puts("ERROR: Did not find a cmdline Flattened Device Tree\n");
|
|
goto no_fdt;
|
|
}
|
|
|
|
printf(" Booting using the fdt blob at %#08lx\n", fdt_addr);
|
|
fdt_blob = map_sysmem(fdt_addr, 0);
|
|
} else if (images->legacy_hdr_valid &&
|
|
image_check_type(&images->legacy_hdr_os_copy,
|
|
IH_TYPE_MULTI)) {
|
|
ulong fdt_data, fdt_len;
|
|
|
|
/*
|
|
* Now check if we have a legacy multi-component image,
|
|
* get second entry data start address and len.
|
|
*/
|
|
printf("## Flattened Device Tree from multi component Image at %08lX\n",
|
|
(ulong)images->legacy_hdr_os);
|
|
|
|
image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
|
|
&fdt_len);
|
|
if (fdt_len) {
|
|
fdt_blob = (char *)fdt_data;
|
|
printf(" Booting using the fdt at 0x%p\n", fdt_blob);
|
|
|
|
if (fdt_check_header(fdt_blob) != 0) {
|
|
fdt_error("image is not a fdt");
|
|
goto error;
|
|
}
|
|
|
|
if (fdt_totalsize(fdt_blob) != fdt_len) {
|
|
fdt_error("fdt size != image size");
|
|
goto error;
|
|
}
|
|
} else {
|
|
debug("## No Flattened Device Tree\n");
|
|
goto no_fdt;
|
|
}
|
|
} else {
|
|
debug("## No Flattened Device Tree\n");
|
|
goto no_fdt;
|
|
}
|
|
|
|
*of_flat_tree = fdt_blob;
|
|
*of_size = fdt_totalsize(fdt_blob);
|
|
debug(" of_flat_tree at 0x%08lx size 0x%08lx\n",
|
|
(ulong)*of_flat_tree, *of_size);
|
|
|
|
return 0;
|
|
|
|
no_fdt:
|
|
ok_no_fdt = 1;
|
|
error:
|
|
*of_flat_tree = NULL;
|
|
*of_size = 0;
|
|
if (!select && ok_no_fdt) {
|
|
debug("Continuing to boot without FDT\n");
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Verify the device tree.
|
|
*
|
|
* This function is called after all device tree fix-ups have been enacted,
|
|
* so that the final device tree can be verified. The definition of "verified"
|
|
* is up to the specific implementation. However, it generally means that the
|
|
* addresses of some of the devices in the device tree are compared with the
|
|
* actual addresses at which U-Boot has placed them.
|
|
*
|
|
* Returns 1 on success, 0 on failure. If 0 is returned, U-Boot will halt the
|
|
* boot process.
|
|
*/
|
|
__weak int ft_verify_fdt(void *fdt)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
__weak int arch_fixup_fdt(void *blob)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int image_setup_libfdt(bootm_headers_t *images, void *blob,
|
|
int of_size, struct lmb *lmb)
|
|
{
|
|
ulong *initrd_start = &images->initrd_start;
|
|
ulong *initrd_end = &images->initrd_end;
|
|
int ret = -EPERM;
|
|
int fdt_ret;
|
|
|
|
if (fdt_root(blob) < 0) {
|
|
printf("ERROR: root node setup failed\n");
|
|
goto err;
|
|
}
|
|
if (fdt_chosen(blob) < 0) {
|
|
printf("ERROR: /chosen node create failed\n");
|
|
goto err;
|
|
}
|
|
if (arch_fixup_fdt(blob) < 0) {
|
|
printf("ERROR: arch-specific fdt fixup failed\n");
|
|
goto err;
|
|
}
|
|
if (IMAGE_OF_BOARD_SETUP) {
|
|
fdt_ret = ft_board_setup(blob, gd->bd);
|
|
if (fdt_ret) {
|
|
printf("ERROR: board-specific fdt fixup failed: %s\n",
|
|
fdt_strerror(fdt_ret));
|
|
goto err;
|
|
}
|
|
}
|
|
if (IMAGE_OF_SYSTEM_SETUP) {
|
|
fdt_ret = ft_system_setup(blob, gd->bd);
|
|
if (fdt_ret) {
|
|
printf("ERROR: system-specific fdt fixup failed: %s\n",
|
|
fdt_strerror(fdt_ret));
|
|
goto err;
|
|
}
|
|
}
|
|
fdt_fixup_ethernet(blob);
|
|
|
|
/* Delete the old LMB reservation */
|
|
if (lmb)
|
|
lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
|
|
(phys_size_t)fdt_totalsize(blob));
|
|
|
|
ret = fdt_shrink_to_minimum(blob);
|
|
if (ret < 0)
|
|
goto err;
|
|
of_size = ret;
|
|
|
|
if (*initrd_start && *initrd_end) {
|
|
of_size += FDT_RAMDISK_OVERHEAD;
|
|
fdt_set_totalsize(blob, of_size);
|
|
}
|
|
/* Create a new LMB reservation */
|
|
if (lmb)
|
|
lmb_reserve(lmb, (ulong)blob, of_size);
|
|
|
|
fdt_initrd(blob, *initrd_start, *initrd_end);
|
|
if (!ft_verify_fdt(blob))
|
|
goto err;
|
|
|
|
#if defined(CONFIG_SOC_KEYSTONE)
|
|
if (IMAGE_OF_BOARD_SETUP)
|
|
ft_board_setup_ex(blob, gd->bd);
|
|
#endif
|
|
|
|
return 0;
|
|
err:
|
|
printf(" - must RESET the board to recover.\n\n");
|
|
|
|
return ret;
|
|
}
|