Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-22 04:44:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

lmb: Remove lmb_reserve_flags()

Browse source 
lmb_reserve() is just calling lmb_reserve_flags() with LMB_NONE.
There's not much we gain from this abstraction.
So let's remove the latter, add the flags argument to lmb_reserve()
and make the code a bit easier to follow.

Reviewed-by: Tom Rini <trini@konsulko.com>
Reviewed-by: Sam Protsenko <semen.protsenko@linaro.org>
Tested-by: Sam Protsenko <semen.protsenko@linaro.org>
Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
This commit is contained in:
Ilias Apalodimas 2024-12-18 09:02:32 +02:00 • committed by Tom Rini
parent 3d56c06551
commit 900a8951c3
11 changed files with 48 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
arch/powerpc/cpu/mpc85xx/mp.c
View file

@ -412,7 +412,7 @@ void cpu_mp_lmb_reserve(void)
{ {
u32 bootpg = determine_mp_bootpg(NULL); u32 bootpg = determine_mp_bootpg(NULL);
lmb_reserve(bootpg, 4096); lmb_reserve(bootpg, 4096, LMB_NONE);
} }
void setup_mp(void) void setup_mp(void)

2
arch/powerpc/lib/misc.c
View file

@ -40,7 +40,7 @@ int arch_misc_init(void)
printf("WARNING: adjusting available memory from 0x%lx to 0x%llx\n", printf("WARNING: adjusting available memory from 0x%lx to 0x%llx\n",
size, (unsigned long long)bootm_size); size, (unsigned long long)bootm_size);
lmb_reserve(base, bootm_size - size); lmb_reserve(base, bootm_size - size, LMB_NONE);
} }
#ifdef CONFIG_MP #ifdef CONFIG_MP

3
boot/bootm.c
View file

@ -696,7 +696,8 @@ static int bootm_load_os(struct bootm_headers *images, int boot_progress)
} }
if (CONFIG_IS_ENABLED(LMB)) if (CONFIG_IS_ENABLED(LMB))
lmb_reserve(images->os.load, (load_end - images->os.load)); lmb_reserve(images->os.load, (load_end - images->os.load),
LMB_NONE);
return 0; return 0;
} }

2
boot/image-board.c
View file

@ -562,7 +562,7 @@ int boot_ramdisk_high(ulong rd_data, ulong rd_len, ulong *initrd_start,
debug(" in-place initrd\n"); debug(" in-place initrd\n");
*initrd_start = rd_data; *initrd_start = rd_data;
*initrd_end = rd_data + rd_len; *initrd_end = rd_data + rd_len;
lmb_reserve(rd_data, rd_len); lmb_reserve(rd_data, rd_len, LMB_NONE);
} else { } else {
if (initrd_high) if (initrd_high)
*initrd_start = (ulong)lmb_alloc_base(rd_len, *initrd_start = (ulong)lmb_alloc_base(rd_len,

6
boot/image-fdt.c
View file

@ -72,7 +72,7 @@ static void boot_fdt_reserve_region(u64 addr, u64 size, u32 flags)
{ {
long ret; long ret;
ret = lmb_reserve_flags(addr, size, flags); ret = lmb_reserve(addr, size, flags);
if (!ret) { if (!ret) {
debug(" reserving fdt memory region: addr=%llx size=%llx flags=%x\n", debug(" reserving fdt memory region: addr=%llx size=%llx flags=%x\n",
(unsigned long long)addr, (unsigned long long)addr,
@ -184,7 +184,7 @@ int boot_relocate_fdt(char **of_flat_tree, ulong *of_size)
if (desired_addr == ~0UL) { if (desired_addr == ~0UL) {
/* All ones means use fdt in place */ /* All ones means use fdt in place */
of_start = fdt_blob; of_start = fdt_blob;
lmb_reserve(map_to_sysmem(of_start), of_len); lmb_reserve(map_to_sysmem(of_start), of_len, LMB_NONE);
disable_relocation = 1; disable_relocation = 1;
} else if (desired_addr) { } else if (desired_addr) {
addr = lmb_alloc_base(of_len, 0x1000, desired_addr); addr = lmb_alloc_base(of_len, 0x1000, desired_addr);
@ -675,7 +675,7 @@ int image_setup_libfdt(struct bootm_headers *images, void *blob, bool lmb)
/* Create a new LMB reservation */ /* Create a new LMB reservation */
if (CONFIG_IS_ENABLED(LMB) && lmb) if (CONFIG_IS_ENABLED(LMB) && lmb)
lmb_reserve(map_to_sysmem(blob), of_size); lmb_reserve(map_to_sysmem(blob), of_size, LMB_NONE);
#if defined(CONFIG_ARCH_KEYSTONE) #if defined(CONFIG_ARCH_KEYSTONE)
if (IS_ENABLED(CONFIG_OF_BOARD_SETUP)) if (IS_ENABLED(CONFIG_OF_BOARD_SETUP))

2
cmd/booti.c
View file

@ -87,7 +87,7 @@ static int booti_start(struct bootm_info *bmi)
images->os.start = relocated_addr; images->os.start = relocated_addr;
images->os.end = relocated_addr + image_size; images->os.end = relocated_addr + image_size;
lmb_reserve(images->ep, le32_to_cpu(image_size)); lmb_reserve(images->ep, le32_to_cpu(image_size), LMB_NONE);
/* /*
* Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not

2
cmd/bootz.c
View file

@ -56,7 +56,7 @@ static int bootz_start(struct cmd_tbl *cmdtp, int flag, int argc,
if (ret != 0) if (ret != 0)
return 1; return 1;
lmb_reserve(images->ep, zi_end - zi_start); lmb_reserve(images->ep, zi_end - zi_start, LMB_NONE);
/* /*
* Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not

2
cmd/load.c
View file

@ -179,7 +179,7 @@ static ulong load_serial(long offset)
{ {
void *dst; void *dst;
ret = lmb_reserve(store_addr, binlen); ret = lmb_reserve(store_addr, binlen, LMB_NONE);
if (ret) { if (ret) {
printf("\nCannot overwrite reserved area (%08lx..%08lx)\n", printf("\nCannot overwrite reserved area (%08lx..%08lx)\n",
store_addr, store_addr + binlen); store_addr, store_addr + binlen);

14
include/lmb.h
View file

@ -80,16 +80,7 @@ void lmb_add_memory(void);
long lmb_add(phys_addr_t base, phys_size_t size); long lmb_add(phys_addr_t base, phys_size_t size);
/** /**
* lmb_reserve() - Reserve a memory region (with no special flags) * lmb_reserve() - Reserve one region with a specific flags bitfield
* @base: Base address of the memory region
* @size: Size of the memory region
*
* Return: 0 on success, negative error code on failure.
*/
long lmb_reserve(phys_addr_t base, phys_size_t size);
/**
* lmb_reserve_flags() - Reserve one region with a specific flags bitfield
* @base: Base address of the memory region * @base: Base address of the memory region
* @size: Size of the memory region * @size: Size of the memory region
* @flags: Flags for the memory region * @flags: Flags for the memory region
@ -99,8 +90,7 @@ long lmb_reserve(phys_addr_t base, phys_size_t size);
* * %-EEXIST - The region is already added, and flags != LMB_NONE * * %-EEXIST - The region is already added, and flags != LMB_NONE
* * %-1 - Failure * * %-1 - Failure
*/ */
long lmb_reserve_flags(phys_addr_t base, phys_size_t size, long lmb_reserve(phys_addr_t base, phys_size_t size, u32 flags);
u32 flags);
phys_addr_t lmb_alloc(phys_size_t size, ulong align); phys_addr_t lmb_alloc(phys_size_t size, ulong align);
phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr); phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr);

22
lib/lmb.c
View file

@ -553,11 +553,10 @@ static void lmb_reserve_uboot_region(void)
if (bank_end > end) if (bank_end > end)
bank_end = end - 1; bank_end = end - 1;
lmb_reserve_flags(rsv_start, bank_end - rsv_start + 1, lmb_reserve(rsv_start, bank_end - rsv_start + 1, LMB_NOOVERWRITE);
LMB_NOOVERWRITE);
if (gd->flags & GD_FLG_SKIP_RELOC) if (gd->flags & GD_FLG_SKIP_RELOC)
lmb_reserve_flags((phys_addr_t)(uintptr_t)_start, lmb_reserve((phys_addr_t)(uintptr_t)_start,
gd->mon_len, LMB_NOOVERWRITE); gd->mon_len, LMB_NOOVERWRITE);
break; break;
@ -584,7 +583,7 @@ static __maybe_unused void lmb_reserve_common_spl(void)
if (IS_ENABLED(CONFIG_SPL_STACK_R_ADDR)) { if (IS_ENABLED(CONFIG_SPL_STACK_R_ADDR)) {
rsv_start = gd->start_addr_sp - 16384; rsv_start = gd->start_addr_sp - 16384;
rsv_size = 16384; rsv_size = 16384;
lmb_reserve_flags(rsv_start, rsv_size, LMB_NOOVERWRITE); lmb_reserve(rsv_start, rsv_size, LMB_NOOVERWRITE);
} }
if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) { if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) {
@ -592,7 +591,7 @@ static __maybe_unused void lmb_reserve_common_spl(void)
rsv_start = (phys_addr_t)(uintptr_t)__bss_start; rsv_start = (phys_addr_t)(uintptr_t)__bss_start;
rsv_size = (phys_addr_t)(uintptr_t)__bss_end - rsv_size = (phys_addr_t)(uintptr_t)__bss_end -
(phys_addr_t)(uintptr_t)__bss_start; (phys_addr_t)(uintptr_t)__bss_start;
lmb_reserve_flags(rsv_start, rsv_size, LMB_NOOVERWRITE); lmb_reserve(rsv_start, rsv_size, LMB_NOOVERWRITE);
} }
} }
@ -624,10 +623,10 @@ void lmb_add_memory(void)
* allocated * allocated
*/ */
if (bd->bi_dram[i].start >= ram_top) if (bd->bi_dram[i].start >= ram_top)
lmb_reserve_flags(bd->bi_dram[i].start, size, lmb_reserve(bd->bi_dram[i].start, size,
LMB_NOOVERWRITE); LMB_NOOVERWRITE);
else if (bank_end > ram_top) else if (bank_end > ram_top)
lmb_reserve_flags(ram_top, bank_end - ram_top, lmb_reserve(ram_top, bank_end - ram_top,
LMB_NOOVERWRITE); LMB_NOOVERWRITE);
} }
} }
@ -669,7 +668,7 @@ long lmb_free(phys_addr_t base, phys_size_t size)
return lmb_free_flags(base, size, LMB_NONE); return lmb_free_flags(base, size, LMB_NONE);
} }
long lmb_reserve_flags(phys_addr_t base, phys_size_t size, u32 flags) long lmb_reserve(phys_addr_t base, phys_size_t size, u32 flags)
{ {
long ret = 0; long ret = 0;
struct alist *lmb_rgn_lst = &lmb.used_mem; struct alist *lmb_rgn_lst = &lmb.used_mem;
@ -681,11 +680,6 @@ long lmb_reserve_flags(phys_addr_t base, phys_size_t size, u32 flags)
return lmb_map_update_notify(base, size, MAP_OP_RESERVE, flags); return lmb_map_update_notify(base, size, MAP_OP_RESERVE, flags);
} }
long lmb_reserve(phys_addr_t base, phys_size_t size)
{
return lmb_reserve_flags(base, size, LMB_NONE);
}
static phys_addr_t _lmb_alloc_base(phys_size_t size, ulong align, static phys_addr_t _lmb_alloc_base(phys_size_t size, ulong align,
phys_addr_t max_addr, u32 flags) phys_addr_t max_addr, u32 flags)
{ {
@ -790,7 +784,7 @@ static phys_addr_t _lmb_alloc_addr(phys_addr_t base, phys_size_t size,
lmb_memory[rgn].size, lmb_memory[rgn].size,
base + size - 1, 1)) { base + size - 1, 1)) {
/* ok, reserve the memory */ /* ok, reserve the memory */
if (!lmb_reserve_flags(base, size, flags)) if (!lmb_reserve(base, size, flags))
return base; return base;
} }
} }

48
test/lib/lmb.c
View file

@ -117,7 +117,7 @@ static int test_multi_alloc(struct unit_test_state *uts, const phys_addr_t ram,
} }
/* reserve 64KiB somewhere */ /* reserve 64KiB somewhere */
ret = lmb_reserve(alloc_64k_addr, 0x10000); ret = lmb_reserve(alloc_64k_addr, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, 0, 0, 1, alloc_64k_addr, 0x10000, ASSERT_LMB(mem_lst, used_lst, 0, 0, 1, alloc_64k_addr, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
@ -264,7 +264,7 @@ static int test_bigblock(struct unit_test_state *uts, const phys_addr_t ram)
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
/* reserve 64KiB in the middle of RAM */ /* reserve 64KiB in the middle of RAM */
ret = lmb_reserve(alloc_64k_addr, 0x10000); ret = lmb_reserve(alloc_64k_addr, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, alloc_64k_addr, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, alloc_64k_addr, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
@ -466,35 +466,35 @@ static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
ret = lmb_add(ram, ram_size); ret = lmb_add(ram, ram_size);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ret = lmb_reserve(0x40010000, 0x10000); ret = lmb_reserve(0x40010000, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
/* allocate overlapping region should return the coalesced count */ /* allocate overlapping region should return the coalesced count */
ret = lmb_reserve(0x40011000, 0x10000); ret = lmb_reserve(0x40011000, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x11000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x11000,
0, 0, 0, 0); 0, 0, 0, 0);
/* allocate 3nd region */ /* allocate 3nd region */
ret = lmb_reserve(0x40030000, 0x10000); ret = lmb_reserve(0x40030000, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40010000, 0x11000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40010000, 0x11000,
0x40030000, 0x10000, 0, 0); 0x40030000, 0x10000, 0, 0);
/* allocate 2nd region , This should coalesced all region into one */ /* allocate 2nd region , This should coalesced all region into one */
ret = lmb_reserve(0x40020000, 0x10000); ret = lmb_reserve(0x40020000, 0x10000, LMB_NONE);
ut_assert(ret >= 0); ut_assert(ret >= 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x30000,
0, 0, 0, 0); 0, 0, 0, 0);
/* allocate 2nd region, which should be added as first region */ /* allocate 2nd region, which should be added as first region */
ret = lmb_reserve(0x40000000, 0x8000); ret = lmb_reserve(0x40000000, 0x8000, LMB_NONE);
ut_assert(ret >= 0); ut_assert(ret >= 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x8000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x8000,
0x40010000, 0x30000, 0, 0); 0x40010000, 0x30000, 0, 0);
/* allocate 3rd region, coalesce with first and overlap with second */ /* allocate 3rd region, coalesce with first and overlap with second */
ret = lmb_reserve(0x40008000, 0x10000); ret = lmb_reserve(0x40008000, 0x10000, LMB_NONE);
ut_assert(ret >= 0); ut_assert(ret >= 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40000000, 0x40000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40000000, 0x40000,
0, 0, 0, 0); 0, 0, 0, 0);
@ -550,11 +550,11 @@ static int test_alloc_addr(struct unit_test_state *uts, const phys_addr_t ram)
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
/* reserve 3 blocks */ /* reserve 3 blocks */
ret = lmb_reserve(alloc_addr_a, 0x10000); ret = lmb_reserve(alloc_addr_a, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ret = lmb_reserve(alloc_addr_b, 0x10000); ret = lmb_reserve(alloc_addr_b, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ret = lmb_reserve(alloc_addr_c, 0x10000); ret = lmb_reserve(alloc_addr_c, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, alloc_addr_a, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, alloc_addr_a, 0x10000,
alloc_addr_b, 0x10000, alloc_addr_c, 0x10000); alloc_addr_b, 0x10000, alloc_addr_c, 0x10000);
@ -680,11 +680,11 @@ static int test_get_unreserved_size(struct unit_test_state *uts,
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
/* reserve 3 blocks */ /* reserve 3 blocks */
ret = lmb_reserve(alloc_addr_a, 0x10000); ret = lmb_reserve(alloc_addr_a, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ret = lmb_reserve(alloc_addr_b, 0x10000); ret = lmb_reserve(alloc_addr_b, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ret = lmb_reserve(alloc_addr_c, 0x10000); ret = lmb_reserve(alloc_addr_c, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, alloc_addr_a, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, alloc_addr_a, 0x10000,
alloc_addr_b, 0x10000, alloc_addr_c, 0x10000); alloc_addr_b, 0x10000, alloc_addr_c, 0x10000);
@ -747,19 +747,19 @@ static int lib_test_lmb_flags(struct unit_test_state *uts)
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
/* reserve, same flag */ /* reserve, same flag */
ret = lmb_reserve_flags(0x40010000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40010000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
/* reserve again, same flag */ /* reserve again, same flag */
ret = lmb_reserve_flags(0x40010000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40010000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, -EEXIST); ut_asserteq(ret, -EEXIST);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
/* reserve again, new flag */ /* reserve again, new flag */
ret = lmb_reserve_flags(0x40010000, 0x10000, LMB_NONE); ret = lmb_reserve(0x40010000, 0x10000, LMB_NONE);
ut_asserteq(ret, -1); ut_asserteq(ret, -1);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x10000,
0, 0, 0, 0); 0, 0, 0, 0);
@ -767,20 +767,20 @@ static int lib_test_lmb_flags(struct unit_test_state *uts)
ut_asserteq(lmb_is_nomap(&used[0]), 1); ut_asserteq(lmb_is_nomap(&used[0]), 1);
/* merge after */ /* merge after */
ret = lmb_reserve_flags(0x40020000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40020000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x20000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40010000, 0x20000,
0, 0, 0, 0); 0, 0, 0, 0);
/* merge before */ /* merge before */
ret = lmb_reserve_flags(0x40000000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40000000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 1, 0x40000000, 0x30000,
0, 0, 0, 0); 0, 0, 0, 0);
ut_asserteq(lmb_is_nomap(&used[0]), 1); ut_asserteq(lmb_is_nomap(&used[0]), 1);
ret = lmb_reserve_flags(0x40030000, 0x10000, LMB_NONE); ret = lmb_reserve(0x40030000, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x30000,
0x40030000, 0x10000, 0, 0); 0x40030000, 0x10000, 0, 0);
@ -789,7 +789,7 @@ static int lib_test_lmb_flags(struct unit_test_state *uts)
ut_asserteq(lmb_is_nomap(&used[1]), 0); ut_asserteq(lmb_is_nomap(&used[1]), 0);
/* test that old API use LMB_NONE */ /* test that old API use LMB_NONE */
ret = lmb_reserve(0x40040000, 0x10000); ret = lmb_reserve(0x40040000, 0x10000, LMB_NONE);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 2, 0x40000000, 0x30000,
0x40030000, 0x20000, 0, 0); 0x40030000, 0x20000, 0, 0);
@ -797,18 +797,18 @@ static int lib_test_lmb_flags(struct unit_test_state *uts)
ut_asserteq(lmb_is_nomap(&used[0]), 1); ut_asserteq(lmb_is_nomap(&used[0]), 1);
ut_asserteq(lmb_is_nomap(&used[1]), 0); ut_asserteq(lmb_is_nomap(&used[1]), 0);
ret = lmb_reserve_flags(0x40070000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40070000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, 0x40000000, 0x30000,
0x40030000, 0x20000, 0x40070000, 0x10000); 0x40030000, 0x20000, 0x40070000, 0x10000);
ret = lmb_reserve_flags(0x40050000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40050000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 4, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 4, 0x40000000, 0x30000,
0x40030000, 0x20000, 0x40050000, 0x10000); 0x40030000, 0x20000, 0x40050000, 0x10000);
/* merge with 2 adjacent regions */ /* merge with 2 adjacent regions */
ret = lmb_reserve_flags(0x40060000, 0x10000, LMB_NOMAP); ret = lmb_reserve(0x40060000, 0x10000, LMB_NOMAP);
ut_asserteq(ret, 0); ut_asserteq(ret, 0);
ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, 0x40000000, 0x30000, ASSERT_LMB(mem_lst, used_lst, ram, ram_size, 3, 0x40000000, 0x30000,
0x40030000, 0x20000, 0x40050000, 0x30000); 0x40030000, 0x20000, 0x40050000, 0x30000);