Firmware/opensbi
8
0
Fork 0
forked from Mirrors/opensbi
Code Pull Requests Activity

lib: utils/fdt: Use heap in FDT domain parsing

Browse Source 
Let's use heap allocation in FDT domain parsing instead of using
a fixed size global array.

Signed-off-by: Anup Patel <apatel@ventanamicro.com>
Reviewed-by: Andrew Jones <ajones@ventanamicro.com>
This commit is contained in:
Anup Patel
2023-04-20 18:09:55 +05:30
committed by Anup Patel
parent 7e5636ac37
commit 3c1c972cb6
1 changed files with 70 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
lib/utils/fdt/fdt_domain.c
View File

@@ -13,6 +13,7 @@
#include <sbi/sbi_domain.h> #include <sbi/sbi_domain.h>
#include <sbi/sbi_error.h> #include <sbi/sbi_error.h>
#include <sbi/sbi_hartmask.h> #include <sbi/sbi_hartmask.h>
#include <sbi/sbi_heap.h>
#include <sbi/sbi_scratch.h> #include <sbi/sbi_scratch.h>
#include <sbi_utils/fdt/fdt_domain.h> #include <sbi_utils/fdt/fdt_domain.h>
#include <sbi_utils/fdt/fdt_helper.h> #include <sbi_utils/fdt/fdt_helper.h>
@@ -219,14 +220,13 @@ skip_device_disable:
fdt_nop_node(fdt, poffset); fdt_nop_node(fdt, poffset);
} }
#define FDT_DOMAIN_MAX_COUNT 8
#define FDT_DOMAIN_REGION_MAX_COUNT 16 #define FDT_DOMAIN_REGION_MAX_COUNT 16
static u32 fdt_domains_count; struct parse_region_data {
static struct sbi_domain fdt_domains[FDT_DOMAIN_MAX_COUNT]; struct sbi_domain *dom;
static struct sbi_hartmask fdt_masks[FDT_DOMAIN_MAX_COUNT]; u32 region_count;
static struct sbi_domain_memregion u32 max_regions;
fdt_regions[FDT_DOMAIN_MAX_COUNT][FDT_DOMAIN_REGION_MAX_COUNT + 1]; };
static int __fdt_parse_region(void *fdt, int domain_offset, static int __fdt_parse_region(void *fdt, int domain_offset,
int region_offset, u32 region_access, int region_offset, u32 region_access,
@@ -236,7 +236,7 @@ static int __fdt_parse_region(void *fdt, int domain_offset,
u32 val32; u32 val32;
u64 val64; u64 val64;
const u32 *val; const u32 *val;
u32 *region_count = opaque; struct parse_region_data *preg = opaque;
struct sbi_domain_memregion *region; struct sbi_domain_memregion *region;
/* /*
@@ -252,9 +252,9 @@ static int __fdt_parse_region(void *fdt, int domain_offset,
return SBI_EINVAL; return SBI_EINVAL;
/* Find next region of the domain */ /* Find next region of the domain */
if (FDT_DOMAIN_REGION_MAX_COUNT <= *region_count) if (preg->max_regions <= preg->region_count)
return SBI_EINVAL; return SBI_ENOSPC;
region = &fdt_regions[fdt_domains_count][*region_count]; region = &preg->dom->regions[preg->region_count];
/* Read "base" DT property */ /* Read "base" DT property */
val = fdt_getprop(fdt, region_offset, "base", &len); val = fdt_getprop(fdt, region_offset, "base", &len);
@@ -278,7 +278,7 @@ static int __fdt_parse_region(void *fdt, int domain_offset,
if (fdt_get_property(fdt, region_offset, "mmio", NULL)) if (fdt_get_property(fdt, region_offset, "mmio", NULL))
region->flags |= SBI_DOMAIN_MEMREGION_MMIO; region->flags |= SBI_DOMAIN_MEMREGION_MMIO;
(*region_count)++; preg->region_count++;
return 0; return 0;
} }
@@ -291,16 +291,30 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
struct sbi_domain *dom; struct sbi_domain *dom;
struct sbi_hartmask *mask; struct sbi_hartmask *mask;
struct sbi_hartmask assign_mask; struct sbi_hartmask assign_mask;
struct parse_region_data preg;
int *cold_domain_offset = opaque; int *cold_domain_offset = opaque;
struct sbi_domain_memregion *reg, *regions; struct sbi_domain_memregion *reg;
int i, err, len, cpus_offset, cpu_offset, doffset; int i, err = 0, len, cpus_offset, cpu_offset, doffset;
/* Sanity check on maximum domains we can handle */ dom = sbi_zalloc(sizeof(*dom));
if (FDT_DOMAIN_MAX_COUNT <= fdt_domains_count) if (!dom)
return SBI_EINVAL; return SBI_ENOMEM;
dom = &fdt_domains[fdt_domains_count];
mask = &fdt_masks[fdt_domains_count]; dom->regions = sbi_calloc(sizeof(*dom->regions),
regions = &fdt_regions[fdt_domains_count][0]; FDT_DOMAIN_REGION_MAX_COUNT + 1);
if (!dom->regions) {
err = SBI_ENOMEM;
goto fail_free_domain;
}
preg.dom = dom;
preg.region_count = 0;
preg.max_regions = FDT_DOMAIN_REGION_MAX_COUNT;
mask = sbi_zalloc(sizeof(*mask));
if (!mask) {
err = SBI_ENOMEM;
goto fail_free_regions;
}
/* Read DT node name */ /* Read DT node name */
strncpy(dom->name, fdt_get_name(fdt, domain_offset, NULL), strncpy(dom->name, fdt_get_name(fdt, domain_offset, NULL),
@@ -316,12 +330,14 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
cpu_offset = fdt_node_offset_by_phandle(fdt, cpu_offset = fdt_node_offset_by_phandle(fdt,
fdt32_to_cpu(val[i])); fdt32_to_cpu(val[i]));
if (cpu_offset < 0) if (cpu_offset < 0) {
return cpu_offset; err = cpu_offset;
goto fail_free_all;
}
err = fdt_parse_hart_id(fdt, cpu_offset, &val32); err = fdt_parse_hart_id(fdt, cpu_offset, &val32);
if (err) if (err)
return err; goto fail_free_all;
if (!fdt_node_is_enabled(fdt, cpu_offset)) if (!fdt_node_is_enabled(fdt, cpu_offset))
continue; continue;
@@ -331,14 +347,10 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
} }
/* Setup memregions from DT */ /* Setup memregions from DT */
val32 = 0; err = fdt_iterate_each_memregion(fdt, domain_offset, &preg,
memset(regions, 0,
sizeof(*regions) * (FDT_DOMAIN_REGION_MAX_COUNT + 1));
dom->regions = regions;
err = fdt_iterate_each_memregion(fdt, domain_offset, &val32,
__fdt_parse_region); __fdt_parse_region);
if (err) if (err)
return err; goto fail_free_all;
/* /*
* Copy over root domain memregions which don't allow * Copy over root domain memregions which don't allow
@@ -354,9 +366,11 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
(reg->flags & SBI_DOMAIN_MEMREGION_SU_WRITABLE) || (reg->flags & SBI_DOMAIN_MEMREGION_SU_WRITABLE) ||
(reg->flags & SBI_DOMAIN_MEMREGION_SU_EXECUTABLE)) (reg->flags & SBI_DOMAIN_MEMREGION_SU_EXECUTABLE))
continue; continue;
if (FDT_DOMAIN_REGION_MAX_COUNT <= val32) if (preg.max_regions <= preg.region_count) {
return SBI_EINVAL; err = SBI_EINVAL;
memcpy(&regions[val32++], reg, sizeof(*reg)); goto fail_free_all;
}
memcpy(&dom->regions[preg.region_count++], reg, sizeof(*reg));
} }
dom->fw_region_inited = root.fw_region_inited; dom->fw_region_inited = root.fw_region_inited;
@@ -427,8 +441,10 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
/* Find /cpus DT node */ /* Find /cpus DT node */
cpus_offset = fdt_path_offset(fdt, "/cpus"); cpus_offset = fdt_path_offset(fdt, "/cpus");
if (cpus_offset < 0) if (cpus_offset < 0) {
return cpus_offset; err = cpus_offset;
goto fail_free_all;
}
/* HART to domain assignment mask based on CPU DT nodes */ /* HART to domain assignment mask based on CPU DT nodes */
sbi_hartmask_clear_all(&assign_mask); sbi_hartmask_clear_all(&assign_mask);
@@ -444,22 +460,35 @@ static int __fdt_parse_domain(void *fdt, int domain_offset, void *opaque)
continue; continue;
val = fdt_getprop(fdt, cpu_offset, "opensbi-domain", &len); val = fdt_getprop(fdt, cpu_offset, "opensbi-domain", &len);
if (!val || len < 4) if (!val || len < 4) {
return SBI_EINVAL; err = SBI_EINVAL;
goto fail_free_all;
}
doffset = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*val)); doffset = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*val));
if (doffset < 0) if (doffset < 0) {
return doffset; err = doffset;
goto fail_free_all;
}
if (doffset == domain_offset) if (doffset == domain_offset)
sbi_hartmask_set_hart(val32, &assign_mask); sbi_hartmask_set_hart(val32, &assign_mask);
} }
/* Increment domains count */
fdt_domains_count++;
/* Register the domain */ /* Register the domain */
return sbi_domain_register(dom, &assign_mask); err = sbi_domain_register(dom, &assign_mask);
if (err)
goto fail_free_all;
return 0;
fail_free_all:
sbi_free(mask);
fail_free_regions:
sbi_free(dom->regions);
fail_free_domain:
sbi_free(dom);
return err;
} }
int fdt_domains_populate(void *fdt) int fdt_domains_populate(void *fdt)