There is no need to have two separate API's for freeing up memory. Use
a single API lmb_free() to achieve this.
Signed-off-by: Sughosh Ganu <sughosh.g...@linaro.org>
---
boot/image-fdt.c | 2 +-
cmd/load.c | 2 +-
include/lmb.h | 6 ++---
lib/efi_loader/efi_memory.c | 6 ++---
lib/lmb.c | 8 +-----
test/lib/lmb.c | 49 +++++++++++++++++++------------------
6 files changed, 33 insertions(+), 40 deletions(-)
diff --git a/boot/image-fdt.c b/boot/image-fdt.c
index b8e1b0f35bb..bcd701a9644 100644
--- a/boot/image-fdt.c
+++ b/boot/image-fdt.c
@@ -700,7 +700,7 @@ int image_setup_libfdt(struct bootm_headers *images, void
*blob, bool lmb)
/* Delete the old LMB reservation */
if (CONFIG_IS_ENABLED(LMB) && lmb)
- lmb_free(map_to_sysmem(blob), fdt_totalsize(blob));
+ lmb_free(map_to_sysmem(blob), fdt_totalsize(blob), LMB_NONE);
ret = fdt_shrink_to_minimum(blob, 0);
if (ret < 0)
diff --git a/cmd/load.c b/cmd/load.c
index 3a4d52ef522..fe61221c3fb 100644
--- a/cmd/load.c
+++ b/cmd/load.c
@@ -190,7 +190,7 @@ static ulong load_serial(long offset)
dst = map_sysmem(store_addr, binlen);
memcpy(dst, binbuf, binlen);
unmap_sysmem(dst);
- lmb_free(store_addr, binlen);
+ lmb_free(store_addr, binlen, LMB_NONE);
}
if ((store_addr) < start_addr)
start_addr = store_addr;
diff --git a/include/lmb.h b/include/lmb.h
index 73df4e07248..f74d2956d95 100644
--- a/include/lmb.h
+++ b/include/lmb.h
@@ -138,16 +138,14 @@ phys_size_t lmb_get_free_size(phys_addr_t addr);
int lmb_is_reserved_flags(phys_addr_t addr, int flags);
/**
- * lmb_free_flags() - Free up a region of memory
+ * lmb_free() - Free up a region of memory
* @base: Base Address of region to be freed
* @size: Size of the region to be freed
* @flags: Memory region attributes
*
* Return: 0 on success, negative error code on failure.
*/
-long lmb_free_flags(phys_addr_t base, phys_size_t size, uint flags);
-
-long lmb_free(phys_addr_t base, phys_size_t size);
+long lmb_free(phys_addr_t base, phys_size_t size, u32 flags);
void lmb_dump_all(void);
void lmb_dump_all_force(void);
diff --git a/lib/efi_loader/efi_memory.c b/lib/efi_loader/efi_memory.c
index 73e1eef5011..fd6aee21d36 100644
--- a/lib/efi_loader/efi_memory.c
+++ b/lib/efi_loader/efi_memory.c
@@ -508,7 +508,7 @@ efi_status_t efi_allocate_pages(enum efi_allocate_type type,
ret = efi_update_memory_map(efi_addr, pages, memory_type, true, false);
if (ret != EFI_SUCCESS) {
/* Map would overlap, bail out */
- lmb_free_flags(addr, (u64)pages << EFI_PAGE_SHIFT, flags);
+ lmb_free(addr, (u64)pages << EFI_PAGE_SHIFT, flags);
unmap_sysmem((void *)(uintptr_t)efi_addr);
return EFI_OUT_OF_RESOURCES;
}
@@ -548,8 +548,8 @@ efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t
pages)
* been mapped with map_sysmem() from efi_allocate_pages(). Convert
* it back to an address LMB understands
*/
- status = lmb_free_flags(map_to_sysmem((void *)(uintptr_t)memory), len,
- LMB_NOOVERWRITE);
+ status = lmb_free(map_to_sysmem((void *)(uintptr_t)memory), len,
+ LMB_NOOVERWRITE);
if (status)
return EFI_NOT_FOUND;
diff --git a/lib/lmb.c b/lib/lmb.c
index 55aca306a90..8f5645339e6 100644
--- a/lib/lmb.c
+++ b/lib/lmb.c
@@ -655,8 +655,7 @@ long lmb_add(phys_addr_t base, phys_size_t size)
return lmb_map_update_notify(base, size, LMB_MAP_OP_ADD, LMB_NONE);
}
-long lmb_free_flags(phys_addr_t base, phys_size_t size,
- uint flags)
+long lmb_free(phys_addr_t base, phys_size_t size, u32 flags)
{
long ret;
@@ -667,11 +666,6 @@ long lmb_free_flags(phys_addr_t base, phys_size_t size,
return lmb_map_update_notify(base, size, LMB_MAP_OP_FREE, flags);
}
-long lmb_free(phys_addr_t base, phys_size_t size)
-{
- return lmb_free_flags(base, size, LMB_NONE);
-}
-
static int _lmb_alloc_base(phys_size_t size, ulong align,
phys_addr_t *addr, u32 flags)
{
diff --git a/test/lib/lmb.c b/test/lib/lmb.c
index 8ce19efc854..94a335a4bb8 100644
--- a/test/lib/lmb.c
+++ b/test/lib/lmb.c
@@ -182,7 +182,7 @@ static int test_multi_alloc(struct unit_test_state *uts,
const phys_addr_t ram,
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
- ret = lmb_free(a, 4);
+ ret = lmb_free(a, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
@@ -191,12 +191,12 @@ static int test_multi_alloc(struct unit_test_state *uts,
const phys_addr_t ram,
ut_asserteq(a, a2);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
- ret = lmb_free(a2, 4);
+ ret = lmb_free(a2, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
- ret = lmb_free(b, 4);
+ ret = lmb_free(b, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 3,
alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
@@ -206,17 +206,17 @@ static int test_multi_alloc(struct unit_test_state *uts,
const phys_addr_t ram,
ut_asserteq(b, b2);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
- ret = lmb_free(b2, 4);
+ ret = lmb_free(b2, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 3,
alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
ram_end - 8, 4);
- ret = lmb_free(c, 4);
+ ret = lmb_free(c, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 2,
alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000, 0, 0);
- ret = lmb_free(d, 4);
+ ret = lmb_free(d, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 1, alloc_64k_addr, 0x10000,
0, 0, 0, 0);
@@ -320,7 +320,7 @@ static int test_bigblock(struct unit_test_state *uts, const
phys_addr_t ram)
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, a,
big_block_size + 0x10000, 0, 0, 0, 0);
- ret = lmb_free(a, big_block_size);
+ ret = lmb_free(a, big_block_size, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, alloc_64k_addr, 0x10000,
0, 0, 0, 0);
@@ -392,12 +392,12 @@ static int test_noreserved(struct unit_test_state *uts,
const phys_addr_t ram,
- alloc_size_aligned, alloc_size, 0, 0);
}
/* and free them */
- ret = lmb_free(b, alloc_size);
+ ret = lmb_free(b, alloc_size, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1,
ram + ram_size - alloc_size_aligned,
alloc_size, 0, 0, 0, 0);
- ret = lmb_free(a, alloc_size);
+ ret = lmb_free(a, alloc_size, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
@@ -408,7 +408,7 @@ static int test_noreserved(struct unit_test_state *uts,
const phys_addr_t ram,
ram + ram_size - alloc_size_aligned,
alloc_size, 0, 0, 0, 0);
/* and free it */
- ret = lmb_free(b, alloc_size);
+ ret = lmb_free(b, alloc_size, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
@@ -476,12 +476,12 @@ static int lib_test_lmb_at_0(struct unit_test_state *uts)
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, a, ram_size - 4,
0, 0, 0, 0);
/* check that this was an error by freeing b */
- ret = lmb_free(b, 4);
+ ret = lmb_free(b, 4, LMB_NONE);
ut_asserteq(ret, -1);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, a, ram_size - 4,
0, 0, 0, 0);
- ret = lmb_free(a, ram_size - 4);
+ ret = lmb_free(a, ram_size - 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
@@ -612,7 +612,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ut_asserteq(b, 0);
b = lmb_alloc_addr(alloc_addr_a, 0x2000, LMB_NONE);
ut_asserteq(b, 0);
- ret = lmb_free(alloc_addr_a, 0x2000);
+ ret = lmb_free(alloc_addr_a, 0x2000, LMB_NONE);
ut_asserteq(ret, 0);
b = lmb_alloc_addr(alloc_addr_a, 0x1000, LMB_NOOVERWRITE);
ut_asserteq(b, 0);
@@ -620,7 +620,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ut_asserteq(b, -EEXIST);
b = lmb_alloc_addr(alloc_addr_a, 0x1000, LMB_NOOVERWRITE);
ut_asserteq(b, -EEXIST);
- ret = lmb_free(alloc_addr_a, 0x1000);
+ ret = lmb_free(alloc_addr_a, 0x1000, LMB_NONE);
ut_asserteq(ret, 0);
/*
@@ -642,9 +642,9 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, alloc_addr_a, 0x1000,
alloc_addr_a + 0x4000, 0x1000, 0, 0);
- ret = lmb_free(alloc_addr_a, 0x1000);
+ ret = lmb_free(alloc_addr_a, 0x1000, LMB_NONE);
ut_asserteq(ret, 0);
- ret = lmb_free(alloc_addr_a + 0x4000, 0x1000);
+ ret = lmb_free(alloc_addr_a + 0x4000, 0x1000, LMB_NOOVERWRITE);
ut_asserteq(ret, 0);
/*
@@ -667,7 +667,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, alloc_addr_a, 0x6000,
0, 0, 0, 0);
- ret = lmb_free(alloc_addr_a, 0x6000);
+ ret = lmb_free(alloc_addr_a, 0x6000, LMB_NONE);
ut_asserteq(ret, 0);
/*
@@ -689,9 +689,9 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, alloc_addr_a, 0x1000,
alloc_addr_a + 0x4000, 0x1000, 0, 0);
- ret = lmb_free(alloc_addr_a, 0x1000);
+ ret = lmb_free(alloc_addr_a, 0x1000, LMB_NOOVERWRITE);
ut_asserteq(ret, 0);
- ret = lmb_free(alloc_addr_a + 0x4000, 0x1000);
+ ret = lmb_free(alloc_addr_a + 0x4000, 0x1000, LMB_NOOVERWRITE);
ut_asserteq(ret, 0);
/* reserve 3 blocks */
@@ -732,7 +732,8 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
0, 0, 0, 0);
/* free thge allocation from d */
- ret = lmb_free(alloc_addr_c + 0x10000, ram_end - alloc_addr_c -
0x10000);
+ ret = lmb_free(alloc_addr_c + 0x10000, ram_end - alloc_addr_c - 0x10000,
+ LMB_NONE);
ut_asserteq(ret, 0);
/* allocate at 3 points in free range */
@@ -741,7 +742,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ut_asserteq(d, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, ram, 0x18010000,
ram_end - 4, 4, 0, 0);
- ret = lmb_free(ram_end - 4, 4);
+ ret = lmb_free(ram_end - 4, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, ram, 0x18010000,
0, 0, 0, 0);
@@ -750,7 +751,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ut_asserteq(d, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, ram, 0x18010000,
ram_end - 128, 4, 0, 0);
- ret = lmb_free(ram_end - 128, 4);
+ ret = lmb_free(ram_end - 128, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, ram, 0x18010000,
0, 0, 0, 0);
@@ -759,13 +760,13 @@ static int test_alloc_addr(struct unit_test_state *uts,
const phys_addr_t ram)
ut_asserteq(d, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, ram, 0x18010004,
0, 0, 0, 0);
- ret = lmb_free(alloc_addr_c + 0x10000, 4);
+ ret = lmb_free(alloc_addr_c + 0x10000, 4, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, ram, 0x18010000,
0, 0, 0, 0);
/* allocate at the bottom a was assigned to ram at the top */
- ret = lmb_free(ram, alloc_addr_a - ram);
+ ret = lmb_free(ram, alloc_addr_a - ram, LMB_NONE);
ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, ram + 0x8000000,
0x10010000, 0, 0, 0, 0);
--
2.34.1
