mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-27 20:38:52 +09:00
![Simon Glass](/assets/img/avatar_default.png)
This header file is now only used by files that access internal environment features. Drop it from various places where it is not needed. Acked-by: Joe Hershberger <joe.hershberger@ni.com> Signed-off-by: Simon Glass <sjg@chromium.org>
621 lines
15 KiB
C
621 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (c) 2016-2018, NVIDIA CORPORATION.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <env.h>
|
|
#include <fdt_support.h>
|
|
#include <fdtdec.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <linux/ctype.h>
|
|
#include <linux/sizes.h>
|
|
|
|
#include <asm/arch/tegra.h>
|
|
#include <asm/arch-tegra/cboot.h>
|
|
#include <asm/armv8/mmu.h>
|
|
|
|
/*
|
|
* Size of a region that's large enough to hold the relocated U-Boot and all
|
|
* other allocations made around it (stack, heap, page tables, etc.)
|
|
* In practice, running "bdinfo" at the shell prompt, the stack reaches about
|
|
* 5MB from the address selected for ram_top as of the time of writing,
|
|
* so a 16MB region should be plenty.
|
|
*/
|
|
#define MIN_USABLE_RAM_SIZE SZ_16M
|
|
/*
|
|
* The amount of space we expect to require for stack usage. Used to validate
|
|
* that all reservations fit into the region selected for the relocation target
|
|
*/
|
|
#define MIN_USABLE_STACK_SIZE SZ_1M
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
extern struct mm_region tegra_mem_map[];
|
|
|
|
/*
|
|
* These variables are written to before relocation, and hence cannot be
|
|
* in.bss, since .bss overlaps the DTB that's appended to the U-Boot binary.
|
|
* The section attribute forces this into .data and avoids this issue. This
|
|
* also has the nice side-effect of the content being valid after relocation.
|
|
*/
|
|
|
|
/* The number of valid entries in ram_banks[] */
|
|
static int ram_bank_count __attribute__((section(".data")));
|
|
|
|
/*
|
|
* The usable top-of-RAM for U-Boot. This is both:
|
|
* a) Below 4GB to avoid issues with peripherals that use 32-bit addressing.
|
|
* b) At the end of a region that has enough space to hold the relocated U-Boot
|
|
* and all other allocations made around it (stack, heap, page tables, etc.)
|
|
*/
|
|
static u64 ram_top __attribute__((section(".data")));
|
|
/* The base address of the region of RAM that ends at ram_top */
|
|
static u64 region_base __attribute__((section(".data")));
|
|
|
|
/*
|
|
* Explicitly put this in the .data section because it is written before the
|
|
* .bss section is zeroed out but it needs to persist.
|
|
*/
|
|
unsigned long cboot_boot_x0 __attribute__((section(".data")));
|
|
|
|
void cboot_save_boot_params(unsigned long x0, unsigned long x1,
|
|
unsigned long x2, unsigned long x3)
|
|
{
|
|
cboot_boot_x0 = x0;
|
|
}
|
|
|
|
int cboot_dram_init(void)
|
|
{
|
|
unsigned int na, ns;
|
|
const void *cboot_blob = (void *)cboot_boot_x0;
|
|
int node, len, i;
|
|
const u32 *prop;
|
|
|
|
if (!cboot_blob)
|
|
return -EINVAL;
|
|
|
|
na = fdtdec_get_uint(cboot_blob, 0, "#address-cells", 2);
|
|
ns = fdtdec_get_uint(cboot_blob, 0, "#size-cells", 2);
|
|
|
|
node = fdt_path_offset(cboot_blob, "/memory");
|
|
if (node < 0) {
|
|
pr_err("Can't find /memory node in cboot DTB");
|
|
hang();
|
|
}
|
|
prop = fdt_getprop(cboot_blob, node, "reg", &len);
|
|
if (!prop) {
|
|
pr_err("Can't find /memory/reg property in cboot DTB");
|
|
hang();
|
|
}
|
|
|
|
/* Calculate the true # of base/size pairs to read */
|
|
len /= 4; /* Convert bytes to number of cells */
|
|
len /= (na + ns); /* Convert cells to number of banks */
|
|
if (len > CONFIG_NR_DRAM_BANKS)
|
|
len = CONFIG_NR_DRAM_BANKS;
|
|
|
|
/* Parse the /memory node, and save useful entries */
|
|
gd->ram_size = 0;
|
|
ram_bank_count = 0;
|
|
for (i = 0; i < len; i++) {
|
|
u64 bank_start, bank_end, bank_size, usable_bank_size;
|
|
|
|
/* Extract raw memory region data from DTB */
|
|
bank_start = fdt_read_number(prop, na);
|
|
prop += na;
|
|
bank_size = fdt_read_number(prop, ns);
|
|
prop += ns;
|
|
gd->ram_size += bank_size;
|
|
bank_end = bank_start + bank_size;
|
|
debug("Bank %d: %llx..%llx (+%llx)\n", i,
|
|
bank_start, bank_end, bank_size);
|
|
|
|
/*
|
|
* Align the bank to MMU section size. This is not strictly
|
|
* necessary, since the translation table construction code
|
|
* handles page granularity without issue. However, aligning
|
|
* the MMU entries reduces the size and number of levels in the
|
|
* page table, so is worth it.
|
|
*/
|
|
bank_start = ROUND(bank_start, SZ_2M);
|
|
bank_end = bank_end & ~(SZ_2M - 1);
|
|
bank_size = bank_end - bank_start;
|
|
debug(" aligned: %llx..%llx (+%llx)\n",
|
|
bank_start, bank_end, bank_size);
|
|
if (bank_end <= bank_start)
|
|
continue;
|
|
|
|
/* Record data used to create MMU translation tables */
|
|
ram_bank_count++;
|
|
/* Index below is deliberately 1-based to skip MMIO entry */
|
|
tegra_mem_map[ram_bank_count].virt = bank_start;
|
|
tegra_mem_map[ram_bank_count].phys = bank_start;
|
|
tegra_mem_map[ram_bank_count].size = bank_size;
|
|
tegra_mem_map[ram_bank_count].attrs =
|
|
PTE_BLOCK_MEMTYPE(MT_NORMAL) | PTE_BLOCK_INNER_SHARE;
|
|
|
|
/* Determine best bank to relocate U-Boot into */
|
|
if (bank_end > SZ_4G)
|
|
bank_end = SZ_4G;
|
|
debug(" end %llx (usable)\n", bank_end);
|
|
usable_bank_size = bank_end - bank_start;
|
|
debug(" size %llx (usable)\n", usable_bank_size);
|
|
if ((usable_bank_size >= MIN_USABLE_RAM_SIZE) &&
|
|
(bank_end > ram_top)) {
|
|
ram_top = bank_end;
|
|
region_base = bank_start;
|
|
debug("ram top now %llx\n", ram_top);
|
|
}
|
|
}
|
|
|
|
/* Ensure memory map contains the desired sentinel entry */
|
|
tegra_mem_map[ram_bank_count + 1].virt = 0;
|
|
tegra_mem_map[ram_bank_count + 1].phys = 0;
|
|
tegra_mem_map[ram_bank_count + 1].size = 0;
|
|
tegra_mem_map[ram_bank_count + 1].attrs = 0;
|
|
|
|
/* Error out if a relocation target couldn't be found */
|
|
if (!ram_top) {
|
|
pr_err("Can't find a usable RAM top");
|
|
hang();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int cboot_dram_init_banksize(void)
|
|
{
|
|
int i;
|
|
|
|
if (ram_bank_count == 0)
|
|
return -EINVAL;
|
|
|
|
if ((gd->start_addr_sp - region_base) < MIN_USABLE_STACK_SIZE) {
|
|
pr_err("Reservations exceed chosen region size");
|
|
hang();
|
|
}
|
|
|
|
for (i = 0; i < ram_bank_count; i++) {
|
|
gd->bd->bi_dram[i].start = tegra_mem_map[1 + i].virt;
|
|
gd->bd->bi_dram[i].size = tegra_mem_map[1 + i].size;
|
|
}
|
|
|
|
#ifdef CONFIG_PCI
|
|
gd->pci_ram_top = ram_top;
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
ulong cboot_get_usable_ram_top(ulong total_size)
|
|
{
|
|
return ram_top;
|
|
}
|
|
|
|
/*
|
|
* The following few functions run late during the boot process and dynamically
|
|
* calculate the load address of various binaries. To keep track of multiple
|
|
* allocations, some writable list of RAM banks must be used. tegra_mem_map[]
|
|
* is used for this purpose to avoid making yet another copy of the list of RAM
|
|
* banks. This is safe because tegra_mem_map[] is only used once during very
|
|
* early boot to create U-Boot's page tables, long before this code runs. If
|
|
* this assumption becomes invalid later, we can just fix the code to copy the
|
|
* list of RAM banks into some private data structure before running.
|
|
*/
|
|
|
|
static char *gen_varname(const char *var, const char *ext)
|
|
{
|
|
size_t len_var = strlen(var);
|
|
size_t len_ext = strlen(ext);
|
|
size_t len = len_var + len_ext + 1;
|
|
char *varext = malloc(len);
|
|
|
|
if (!varext)
|
|
return 0;
|
|
strcpy(varext, var);
|
|
strcpy(varext + len_var, ext);
|
|
return varext;
|
|
}
|
|
|
|
static void mark_ram_allocated(int bank, u64 allocated_start, u64 allocated_end)
|
|
{
|
|
u64 bank_start = tegra_mem_map[bank].virt;
|
|
u64 bank_size = tegra_mem_map[bank].size;
|
|
u64 bank_end = bank_start + bank_size;
|
|
bool keep_front = allocated_start != bank_start;
|
|
bool keep_tail = allocated_end != bank_end;
|
|
|
|
if (keep_front && keep_tail) {
|
|
/*
|
|
* There are CONFIG_NR_DRAM_BANKS DRAM entries in the array,
|
|
* starting at index 1 (index 0 is MMIO). So, we are at DRAM
|
|
* entry "bank" not "bank - 1" as for a typical 0-base array.
|
|
* The number of remaining DRAM entries is therefore
|
|
* "CONFIG_NR_DRAM_BANKS - bank". We want to duplicate the
|
|
* current entry and shift up the remaining entries, dropping
|
|
* the last one. Thus, we must copy one fewer entry than the
|
|
* number remaining.
|
|
*/
|
|
memmove(&tegra_mem_map[bank + 1], &tegra_mem_map[bank],
|
|
CONFIG_NR_DRAM_BANKS - bank - 1);
|
|
tegra_mem_map[bank].size = allocated_start - bank_start;
|
|
bank++;
|
|
tegra_mem_map[bank].virt = allocated_end;
|
|
tegra_mem_map[bank].phys = allocated_end;
|
|
tegra_mem_map[bank].size = bank_end - allocated_end;
|
|
} else if (keep_front) {
|
|
tegra_mem_map[bank].size = allocated_start - bank_start;
|
|
} else if (keep_tail) {
|
|
tegra_mem_map[bank].virt = allocated_end;
|
|
tegra_mem_map[bank].phys = allocated_end;
|
|
tegra_mem_map[bank].size = bank_end - allocated_end;
|
|
} else {
|
|
/*
|
|
* We could move all subsequent banks down in the array but
|
|
* that's not necessary for subsequent allocations to work, so
|
|
* we skip doing so.
|
|
*/
|
|
tegra_mem_map[bank].size = 0;
|
|
}
|
|
}
|
|
|
|
static void reserve_ram(u64 start, u64 size)
|
|
{
|
|
int bank;
|
|
u64 end = start + size;
|
|
|
|
for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
|
|
u64 bank_start = tegra_mem_map[bank].virt;
|
|
u64 bank_size = tegra_mem_map[bank].size;
|
|
u64 bank_end = bank_start + bank_size;
|
|
|
|
if (end <= bank_start || start > bank_end)
|
|
continue;
|
|
mark_ram_allocated(bank, start, end);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static u64 alloc_ram(u64 size, u64 align, u64 offset)
|
|
{
|
|
int bank;
|
|
|
|
for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
|
|
u64 bank_start = tegra_mem_map[bank].virt;
|
|
u64 bank_size = tegra_mem_map[bank].size;
|
|
u64 bank_end = bank_start + bank_size;
|
|
u64 allocated = ROUND(bank_start, align) + offset;
|
|
u64 allocated_end = allocated + size;
|
|
|
|
if (allocated_end > bank_end)
|
|
continue;
|
|
mark_ram_allocated(bank, allocated, allocated_end);
|
|
return allocated;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void set_calculated_aliases(char *aliases, u64 address)
|
|
{
|
|
char *tmp, *alias;
|
|
int err;
|
|
|
|
aliases = strdup(aliases);
|
|
if (!aliases) {
|
|
pr_err("strdup(aliases) failed");
|
|
return;
|
|
}
|
|
|
|
tmp = aliases;
|
|
while (true) {
|
|
alias = strsep(&tmp, " ");
|
|
if (!alias)
|
|
break;
|
|
debug("%s: alias: %s\n", __func__, alias);
|
|
err = env_set_hex(alias, address);
|
|
if (err)
|
|
pr_err("Could not set %s\n", alias);
|
|
}
|
|
|
|
free(aliases);
|
|
}
|
|
|
|
static void set_calculated_env_var(const char *var)
|
|
{
|
|
char *var_size;
|
|
char *var_align;
|
|
char *var_offset;
|
|
char *var_aliases;
|
|
u64 size;
|
|
u64 align;
|
|
u64 offset;
|
|
char *aliases;
|
|
u64 address;
|
|
int err;
|
|
|
|
var_size = gen_varname(var, "_size");
|
|
if (!var_size)
|
|
return;
|
|
var_align = gen_varname(var, "_align");
|
|
if (!var_align)
|
|
goto out_free_var_size;
|
|
var_offset = gen_varname(var, "_offset");
|
|
if (!var_offset)
|
|
goto out_free_var_align;
|
|
var_aliases = gen_varname(var, "_aliases");
|
|
if (!var_aliases)
|
|
goto out_free_var_offset;
|
|
|
|
size = env_get_hex(var_size, 0);
|
|
if (!size) {
|
|
pr_err("%s not set or zero\n", var_size);
|
|
goto out_free_var_aliases;
|
|
}
|
|
align = env_get_hex(var_align, 1);
|
|
/* Handle extant variables, but with a value of 0 */
|
|
if (!align)
|
|
align = 1;
|
|
offset = env_get_hex(var_offset, 0);
|
|
aliases = env_get(var_aliases);
|
|
|
|
debug("%s: Calc var %s; size=%llx, align=%llx, offset=%llx\n",
|
|
__func__, var, size, align, offset);
|
|
if (aliases)
|
|
debug("%s: Aliases: %s\n", __func__, aliases);
|
|
|
|
address = alloc_ram(size, align, offset);
|
|
if (!address) {
|
|
pr_err("Could not allocate %s\n", var);
|
|
goto out_free_var_aliases;
|
|
}
|
|
debug("%s: Address %llx\n", __func__, address);
|
|
|
|
err = env_set_hex(var, address);
|
|
if (err)
|
|
pr_err("Could not set %s\n", var);
|
|
if (aliases)
|
|
set_calculated_aliases(aliases, address);
|
|
|
|
out_free_var_aliases:
|
|
free(var_aliases);
|
|
out_free_var_offset:
|
|
free(var_offset);
|
|
out_free_var_align:
|
|
free(var_align);
|
|
out_free_var_size:
|
|
free(var_size);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
static void dump_ram_banks(void)
|
|
{
|
|
int bank;
|
|
|
|
for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
|
|
u64 bank_start = tegra_mem_map[bank].virt;
|
|
u64 bank_size = tegra_mem_map[bank].size;
|
|
u64 bank_end = bank_start + bank_size;
|
|
|
|
if (!bank_size)
|
|
continue;
|
|
printf("%d: %010llx..%010llx (+%010llx)\n", bank - 1,
|
|
bank_start, bank_end, bank_size);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void set_calculated_env_vars(void)
|
|
{
|
|
char *vars, *tmp, *var;
|
|
|
|
#ifdef DEBUG
|
|
printf("RAM banks before any calculated env. var.s:\n");
|
|
dump_ram_banks();
|
|
#endif
|
|
|
|
reserve_ram(cboot_boot_x0, fdt_totalsize(cboot_boot_x0));
|
|
|
|
#ifdef DEBUG
|
|
printf("RAM after reserving cboot DTB:\n");
|
|
dump_ram_banks();
|
|
#endif
|
|
|
|
vars = env_get("calculated_vars");
|
|
if (!vars) {
|
|
debug("%s: No env var calculated_vars\n", __func__);
|
|
return;
|
|
}
|
|
|
|
vars = strdup(vars);
|
|
if (!vars) {
|
|
pr_err("strdup(calculated_vars) failed");
|
|
return;
|
|
}
|
|
|
|
tmp = vars;
|
|
while (true) {
|
|
var = strsep(&tmp, " ");
|
|
if (!var)
|
|
break;
|
|
debug("%s: var: %s\n", __func__, var);
|
|
set_calculated_env_var(var);
|
|
#ifdef DEBUG
|
|
printf("RAM banks after allocating %s:\n", var);
|
|
dump_ram_banks();
|
|
#endif
|
|
}
|
|
|
|
free(vars);
|
|
}
|
|
|
|
static int set_fdt_addr(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = env_set_hex("fdt_addr", cboot_boot_x0);
|
|
if (ret) {
|
|
printf("Failed to set fdt_addr to point at DTB: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Attempt to use /chosen/nvidia,ether-mac in the cboot DTB to U-Boot's
|
|
* ethaddr environment variable if possible.
|
|
*/
|
|
static int cboot_get_ethaddr_legacy(const void *fdt, uint8_t mac[ETH_ALEN])
|
|
{
|
|
const char *const properties[] = {
|
|
"nvidia,ethernet-mac",
|
|
"nvidia,ether-mac",
|
|
};
|
|
const char *prop;
|
|
unsigned int i;
|
|
int node, len;
|
|
|
|
node = fdt_path_offset(fdt, "/chosen");
|
|
if (node < 0) {
|
|
printf("Can't find /chosen node in cboot DTB\n");
|
|
return node;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(properties); i++) {
|
|
prop = fdt_getprop(fdt, node, properties[i], &len);
|
|
if (prop)
|
|
break;
|
|
}
|
|
|
|
if (!prop) {
|
|
printf("Can't find Ethernet MAC address in cboot DTB\n");
|
|
return -ENOENT;
|
|
}
|
|
|
|
eth_parse_enetaddr(prop, mac);
|
|
|
|
if (!is_valid_ethaddr(mac)) {
|
|
printf("Invalid MAC address: %s\n", prop);
|
|
return -EINVAL;
|
|
}
|
|
|
|
debug("Legacy MAC address: %pM\n", mac);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int cboot_get_ethaddr(const void *fdt, uint8_t mac[ETH_ALEN])
|
|
{
|
|
int node, len, err = 0;
|
|
const uchar *prop;
|
|
const char *path;
|
|
|
|
path = fdt_get_alias(fdt, "ethernet");
|
|
if (!path) {
|
|
err = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
debug("ethernet alias found: %s\n", path);
|
|
|
|
node = fdt_path_offset(fdt, path);
|
|
if (node < 0) {
|
|
err = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
prop = fdt_getprop(fdt, node, "local-mac-address", &len);
|
|
if (!prop) {
|
|
err = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
if (len != ETH_ALEN) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
debug("MAC address: %pM\n", prop);
|
|
memcpy(mac, prop, ETH_ALEN);
|
|
|
|
out:
|
|
if (err < 0)
|
|
err = cboot_get_ethaddr_legacy(fdt, mac);
|
|
|
|
return err;
|
|
}
|
|
|
|
static char *strip(const char *ptr)
|
|
{
|
|
const char *end;
|
|
|
|
while (*ptr && isblank(*ptr))
|
|
ptr++;
|
|
|
|
/* empty string */
|
|
if (*ptr == '\0')
|
|
return strdup(ptr);
|
|
|
|
end = ptr;
|
|
|
|
while (end[1])
|
|
end++;
|
|
|
|
while (isblank(*end))
|
|
end--;
|
|
|
|
return strndup(ptr, end - ptr + 1);
|
|
}
|
|
|
|
static char *cboot_get_bootargs(const void *fdt)
|
|
{
|
|
const char *args;
|
|
int offset, len;
|
|
|
|
offset = fdt_path_offset(fdt, "/chosen");
|
|
if (offset < 0)
|
|
return NULL;
|
|
|
|
args = fdt_getprop(fdt, offset, "bootargs", &len);
|
|
if (!args)
|
|
return NULL;
|
|
|
|
return strip(args);
|
|
}
|
|
|
|
int cboot_late_init(void)
|
|
{
|
|
const void *fdt = (const void *)cboot_boot_x0;
|
|
uint8_t mac[ETH_ALEN];
|
|
char *bootargs;
|
|
int err;
|
|
|
|
set_calculated_env_vars();
|
|
/*
|
|
* Ignore errors here; the value may not be used depending on
|
|
* extlinux.conf or boot script content.
|
|
*/
|
|
set_fdt_addr();
|
|
|
|
/* Ignore errors here; not all cases care about Ethernet addresses */
|
|
err = cboot_get_ethaddr(fdt, mac);
|
|
if (!err) {
|
|
void *blob = (void *)gd->fdt_blob;
|
|
|
|
err = fdtdec_set_ethernet_mac_address(blob, mac, sizeof(mac));
|
|
if (err < 0)
|
|
printf("failed to set MAC address %pM: %d\n", mac, err);
|
|
}
|
|
|
|
bootargs = cboot_get_bootargs(fdt);
|
|
if (bootargs) {
|
|
env_set("cbootargs", bootargs);
|
|
free(bootargs);
|
|
}
|
|
|
|
return 0;
|
|
}
|