[u-boot.git] / lib / efi_loader / efi_memory.c

// SPDX-License-Identifier: GPL-2.0+
/*
 *  EFI application memory management
 *
 *  Copyright (c) 2016 Alexander Graf
 */

#include <common.h>
#include <efi_loader.h>
#include <malloc.h>
#include <mapmem.h>
#include <watchdog.h>
#include <linux/list_sort.h>
#include <linux/sizes.h>

DECLARE_GLOBAL_DATA_PTR;

efi_uintn_t efi_memory_map_key;

struct efi_mem_list {
	struct list_head link;
	struct efi_mem_desc desc;
};

#define EFI_CARVE_NO_OVERLAP		-1
#define EFI_CARVE_LOOP_AGAIN		-2
#define EFI_CARVE_OVERLAPS_NONRAM	-3

/* This list contains all memory map items */
LIST_HEAD(efi_mem);

#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
void *efi_bounce_buffer;
#endif

/*
 * U-Boot services each EFI AllocatePool request as a separate
 * (multiple) page allocation.  We have to track the number of pages
 * to be able to free the correct amount later.
 * EFI requires 8 byte alignment for pool allocations, so we can
 * prepend each allocation with an 64 bit header tracking the
 * allocation size, and hand out the remainder to the caller.
 */
struct efi_pool_allocation {
	u64 num_pages;
	char data[] __aligned(ARCH_DMA_MINALIGN);
};

/*
 * Sorts the memory list from highest address to lowest address
 *
 * When allocating memory we should always start from the highest
 * address chunk, so sort the memory list such that the first list
 * iterator gets the highest address and goes lower from there.
 */
static int efi_mem_cmp(void *priv, struct list_head *a, struct list_head *b)
{
	struct efi_mem_list *mema = list_entry(a, struct efi_mem_list, link);
	struct efi_mem_list *memb = list_entry(b, struct efi_mem_list, link);

	if (mema->desc.physical_start == memb->desc.physical_start)
		return 0;
	else if (mema->desc.physical_start < memb->desc.physical_start)
		return 1;
	else
		return -1;
}

static uint64_t desc_get_end(struct efi_mem_desc *desc)
{
	return desc->physical_start + (desc->num_pages << EFI_PAGE_SHIFT);
}

static void efi_mem_sort(void)
{
	struct list_head *lhandle;
	struct efi_mem_list *prevmem = NULL;
	bool merge_again = true;

	list_sort(NULL, &efi_mem, efi_mem_cmp);

	/* Now merge entries that can be merged */
	while (merge_again) {
		merge_again = false;
		list_for_each(lhandle, &efi_mem) {
			struct efi_mem_list *lmem;
			struct efi_mem_desc *prev = &prevmem->desc;
			struct efi_mem_desc *cur;
			uint64_t pages;

			lmem = list_entry(lhandle, struct efi_mem_list, link);
			if (!prevmem) {
				prevmem = lmem;
				continue;
			}

			cur = &lmem->desc;

			if ((desc_get_end(cur) == prev->physical_start) &&
			    (prev->type == cur->type) &&
			    (prev->attribute == cur->attribute)) {
				/* There is an existing map before, reuse it */
				pages = cur->num_pages;
				prev->num_pages += pages;
				prev->physical_start -= pages << EFI_PAGE_SHIFT;
				prev->virtual_start -= pages << EFI_PAGE_SHIFT;
				list_del(&lmem->link);
				free(lmem);

				merge_again = true;
				break;
			}

			prevmem = lmem;
		}
	}
}

/** efi_mem_carve_out - unmap memory region
 *
 * @map:		memory map
 * @carve_desc:		memory region to unmap
 * @overlap_only_ram:	the carved out region may only overlap RAM
 * Return Value:	the number of overlapping pages which have been
 *			removed from the map,
 *			EFI_CARVE_NO_OVERLAP, if the regions don't overlap,
 *			EFI_CARVE_OVERLAPS_NONRAM, if the carve and map overlap,
 *			and the map contains anything but free ram
 *			(only when overlap_only_ram is true),
 *			EFI_CARVE_LOOP_AGAIN, if the mapping list should be
 *			traversed again, as it has been altered.
 *
 * Unmaps all memory occupied by the carve_desc region from the list entry
 * pointed to by map.
 *
 * In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility
 * to re-add the already carved out pages to the mapping.
 */
static s64 efi_mem_carve_out(struct efi_mem_list *map,
			     struct efi_mem_desc *carve_desc,
			     bool overlap_only_ram)
{
	struct efi_mem_list *newmap;
	struct efi_mem_desc *map_desc = &map->desc;
	uint64_t map_start = map_desc->physical_start;
	uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT);
	uint64_t carve_start = carve_desc->physical_start;
	uint64_t carve_end = carve_start +
			     (carve_desc->num_pages << EFI_PAGE_SHIFT);

	/* check whether we're overlapping */
	if ((carve_end <= map_start) || (carve_start >= map_end))
		return EFI_CARVE_NO_OVERLAP;

	/* We're overlapping with non-RAM, warn the caller if desired */
	if (overlap_only_ram && (map_desc->type != EFI_CONVENTIONAL_MEMORY))
		return EFI_CARVE_OVERLAPS_NONRAM;

	/* Sanitize carve_start and carve_end to lie within our bounds */
	carve_start = max(carve_start, map_start);
	carve_end = min(carve_end, map_end);

	/* Carving at the beginning of our map? Just move it! */
	if (carve_start == map_start) {
		if (map_end == carve_end) {
			/* Full overlap, just remove map */
			list_del(&map->link);
			free(map);
		} else {
			map->desc.physical_start = carve_end;
			map->desc.num_pages = (map_end - carve_end)
					      >> EFI_PAGE_SHIFT;
		}

		return (carve_end - carve_start) >> EFI_PAGE_SHIFT;
	}

	/*
	 * Overlapping maps, just split the list map at carve_start,
	 * it will get moved or removed in the next iteration.
	 *
	 * [ map_desc |__carve_start__| newmap ]
	 */

	/* Create a new map from [ carve_start ... map_end ] */
	newmap = calloc(1, sizeof(*newmap));
	newmap->desc = map->desc;
	newmap->desc.physical_start = carve_start;
	newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT;
	/* Insert before current entry (descending address order) */
	list_add_tail(&newmap->link, &map->link);

	/* Shrink the map to [ map_start ... carve_start ] */
	map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT;

	return EFI_CARVE_LOOP_AGAIN;
}

uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
			    bool overlap_only_ram)
{
	struct list_head *lhandle;
	struct efi_mem_list *newlist;
	bool carve_again;
	uint64_t carved_pages = 0;

	debug("%s: 0x%llx 0x%llx %d %s\n", __func__,
	      start, pages, memory_type, overlap_only_ram ? "yes" : "no");

	if (memory_type >= EFI_MAX_MEMORY_TYPE)
		return EFI_INVALID_PARAMETER;

	if (!pages)
		return start;

	++efi_memory_map_key;
	newlist = calloc(1, sizeof(*newlist));
	newlist->desc.type = memory_type;
	newlist->desc.physical_start = start;
	newlist->desc.virtual_start = start;
	newlist->desc.num_pages = pages;

	switch (memory_type) {
	case EFI_RUNTIME_SERVICES_CODE:
	case EFI_RUNTIME_SERVICES_DATA:
		newlist->desc.attribute = EFI_MEMORY_WB | EFI_MEMORY_RUNTIME;
		break;
	case EFI_MMAP_IO:
		newlist->desc.attribute = EFI_MEMORY_RUNTIME;
		break;
	default:
		newlist->desc.attribute = EFI_MEMORY_WB;
		break;
	}

	/* Add our new map */
	do {
		carve_again = false;
		list_for_each(lhandle, &efi_mem) {
			struct efi_mem_list *lmem;
			s64 r;

			lmem = list_entry(lhandle, struct efi_mem_list, link);
			r = efi_mem_carve_out(lmem, &newlist->desc,
					      overlap_only_ram);
			switch (r) {
			case EFI_CARVE_OVERLAPS_NONRAM:
				/*
				 * The user requested to only have RAM overlaps,
				 * but we hit a non-RAM region. Error out.
				 */
				return 0;
			case EFI_CARVE_NO_OVERLAP:
				/* Just ignore this list entry */
				break;
			case EFI_CARVE_LOOP_AGAIN:
				/*
				 * We split an entry, but need to loop through
				 * the list again to actually carve it.
				 */
				carve_again = true;
				break;
			default:
				/* We carved a number of pages */
				carved_pages += r;
				carve_again = true;
				break;
			}

			if (carve_again) {
				/* The list changed, we need to start over */
				break;
			}
		}
	} while (carve_again);

	if (overlap_only_ram && (carved_pages != pages)) {
		/*
		 * The payload wanted to have RAM overlaps, but we overlapped
		 * with an unallocated region. Error out.
		 */
		return 0;
	}

	/* Add our new map */
        list_add_tail(&newlist->link, &efi_mem);

	/* And make sure memory is listed in descending order */
	efi_mem_sort();

	return start;
}

static uint64_t efi_find_free_memory(uint64_t len, uint64_t max_addr)
{
	struct list_head *lhandle;

	/*
	 * Prealign input max address, so we simplify our matching
	 * logic below and can just reuse it as return pointer.
	 */
	max_addr &= ~EFI_PAGE_MASK;

	list_for_each(lhandle, &efi_mem) {
		struct efi_mem_list *lmem = list_entry(lhandle,
			struct efi_mem_list, link);
		struct efi_mem_desc *desc = &lmem->desc;
		uint64_t desc_len = desc->num_pages << EFI_PAGE_SHIFT;
		uint64_t desc_end = desc->physical_start + desc_len;
		uint64_t curmax = min(max_addr, desc_end);
		uint64_t ret = curmax - len;

		/* We only take memory from free RAM */
		if (desc->type != EFI_CONVENTIONAL_MEMORY)
			continue;

		/* Out of bounds for max_addr */
		if ((ret + len) > max_addr)
			continue;

		/* Out of bounds for upper map limit */
		if ((ret + len) > desc_end)
			continue;

		/* Out of bounds for lower map limit */
		if (ret < desc->physical_start)
			continue;

		/* Return the highest address in this map within bounds */
		return ret;
	}

	return 0;
}

/*
 * Allocate memory pages.
 *
 * @type		type of allocation to be performed
 * @memory_type		usage type of the allocated memory
 * @pages		number of pages to be allocated
 * @memory		allocated memory
 * @return		status code
 */
efi_status_t efi_allocate_pages(int type, int memory_type,
				efi_uintn_t pages, uint64_t *memory)
{
	u64 len = pages << EFI_PAGE_SHIFT;
	efi_status_t r = EFI_SUCCESS;
	uint64_t addr;

	if (!memory)
		return EFI_INVALID_PARAMETER;

	switch (type) {
	case EFI_ALLOCATE_ANY_PAGES:
		/* Any page */
		addr = efi_find_free_memory(len, -1ULL);
		if (!addr) {
			r = EFI_NOT_FOUND;
			break;
		}
		break;
	case EFI_ALLOCATE_MAX_ADDRESS:
		/* Max address */
		addr = efi_find_free_memory(len, *memory);
		if (!addr) {
			r = EFI_NOT_FOUND;
			break;
		}
		break;
	case EFI_ALLOCATE_ADDRESS:
		/* Exact address, reserve it. The addr is already in *memory. */
		addr = *memory;
		break;
	default:
		/* UEFI doesn't specify other allocation types */
		r = EFI_INVALID_PARAMETER;
		break;
	}

	if (r == EFI_SUCCESS) {
		uint64_t ret;

		/* Reserve that map in our memory maps */
		ret = efi_add_memory_map(addr, pages, memory_type, true);
		if (ret == addr) {
			*memory = addr;
		} else {
			/* Map would overlap, bail out */
			r = EFI_OUT_OF_RESOURCES;
		}
	}

	return r;
}

void *efi_alloc(uint64_t len, int memory_type)
{
	uint64_t ret = 0;
	uint64_t pages = efi_size_in_pages(len);
	efi_status_t r;

	r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type, pages,
			       &ret);
	if (r == EFI_SUCCESS)
		return (void*)(uintptr_t)ret;

	return NULL;
}

/*
 * Free memory pages.
 *
 * @memory	start of the memory area to be freed
 * @pages	number of pages to be freed
 * @return	status code
 */
efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages)
{
	uint64_t r = 0;

	r = efi_add_memory_map(memory, pages, EFI_CONVENTIONAL_MEMORY, false);
	/* Merging of adjacent free regions is missing */

	if (r == memory)
		return EFI_SUCCESS;

	return EFI_NOT_FOUND;
}

/*
 * Allocate memory from pool.
 *
 * @pool_type	type of the pool from which memory is to be allocated
 * @size	number of bytes to be allocated
 * @buffer	allocated memory
 * @return	status code
 */
efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, void **buffer)
{
	efi_status_t r;
	struct efi_pool_allocation *alloc;
	u64 num_pages = efi_size_in_pages(size +
					  sizeof(struct efi_pool_allocation));

	if (!buffer)
		return EFI_INVALID_PARAMETER;

	if (size == 0) {
		*buffer = NULL;
		return EFI_SUCCESS;
	}

	r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, pool_type, num_pages,
			       (uint64_t *)&alloc);

	if (r == EFI_SUCCESS) {
		alloc->num_pages = num_pages;
		*buffer = alloc->data;
	}

	return r;
}

/*
 * Free memory from pool.
 *
 * @buffer	start of memory to be freed
 * @return	status code
 */
efi_status_t efi_free_pool(void *buffer)
{
	efi_status_t r;
	struct efi_pool_allocation *alloc;

	if (buffer == NULL)
		return EFI_INVALID_PARAMETER;

	alloc = container_of(buffer, struct efi_pool_allocation, data);
	/* Sanity check, was the supplied address returned by allocate_pool */
	assert(((uintptr_t)alloc & EFI_PAGE_MASK) == 0);

	r = efi_free_pages((uintptr_t)alloc, alloc->num_pages);

	return r;
}

/*
 * Get map describing memory usage.
 *
 * @memory_map_size	on entry the size, in bytes, of the memory map buffer,
 *			on exit the size of the copied memory map
 * @memory_map		buffer to which the memory map is written
 * @map_key		key for the memory map
 * @descriptor_size	size of an individual memory descriptor
 * @descriptor_version	version number of the memory descriptor structure
 * @return		status code
 */
efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
				struct efi_mem_desc *memory_map,
				efi_uintn_t *map_key,
				efi_uintn_t *descriptor_size,
				uint32_t *descriptor_version)
{
	efi_uintn_t map_size = 0;
	int map_entries = 0;
	struct list_head *lhandle;
	efi_uintn_t provided_map_size;

	if (!memory_map_size)
		return EFI_INVALID_PARAMETER;

	provided_map_size = *memory_map_size;

	list_for_each(lhandle, &efi_mem)
		map_entries++;

	map_size = map_entries * sizeof(struct efi_mem_desc);

	*memory_map_size = map_size;

	if (provided_map_size < map_size)
		return EFI_BUFFER_TOO_SMALL;

	if (!memory_map)
		return EFI_INVALID_PARAMETER;

	if (descriptor_size)
		*descriptor_size = sizeof(struct efi_mem_desc);

	if (descriptor_version)
		*descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;

	/* Copy list into array */
	/* Return the list in ascending order */
	memory_map = &memory_map[map_entries - 1];
	list_for_each(lhandle, &efi_mem) {
		struct efi_mem_list *lmem;

		lmem = list_entry(lhandle, struct efi_mem_list, link);
		*memory_map = lmem->desc;
		memory_map--;
	}

	if (map_key)
		*map_key = efi_memory_map_key;

	return EFI_SUCCESS;
}

__weak void efi_add_known_memory(void)
{
	u64 ram_top = board_get_usable_ram_top(0) & ~EFI_PAGE_MASK;
	int i;

	/*
	 * ram_top is just outside mapped memory. So use an offset of one for
	 * mapping the sandbox address.
	 */
	ram_top = (uintptr_t)map_sysmem(ram_top - 1, 0) + 1;

	/* Fix for 32bit targets with ram_top at 4G */
	if (!ram_top)
		ram_top = 0x100000000ULL;

	/* Add RAM */
	for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
		u64 ram_end, ram_start, pages;

		ram_start = (uintptr_t)map_sysmem(gd->bd->bi_dram[i].start, 0);
		ram_end = ram_start + gd->bd->bi_dram[i].size;

		/* Remove partial pages */
		ram_end &= ~EFI_PAGE_MASK;
		ram_start = (ram_start + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;

		if (ram_end <= ram_start) {
			/* Invalid mapping, keep going. */
			continue;
		}

		pages = (ram_end - ram_start) >> EFI_PAGE_SHIFT;

		efi_add_memory_map(ram_start, pages,
				   EFI_CONVENTIONAL_MEMORY, false);

		/*
		 * Boards may indicate to the U-Boot memory core that they
		 * can not support memory above ram_top. Let's honor this
		 * in the efi_loader subsystem too by declaring any memory
		 * above ram_top as "already occupied by firmware".
		 */
		if (ram_top < ram_start) {
			/* ram_top is before this region, reserve all */
			efi_add_memory_map(ram_start, pages,
					   EFI_BOOT_SERVICES_DATA, true);
		} else if ((ram_top >= ram_start) && (ram_top < ram_end)) {
			/* ram_top is inside this region, reserve parts */
			pages = (ram_end - ram_top) >> EFI_PAGE_SHIFT;

			efi_add_memory_map(ram_top, pages,
					   EFI_BOOT_SERVICES_DATA, true);
		}
	}
}

/* Add memory regions for U-Boot's memory and for the runtime services code */
static void add_u_boot_and_runtime(void)
{
	unsigned long runtime_start, runtime_end, runtime_pages;
	unsigned long runtime_mask = EFI_PAGE_MASK;
	unsigned long uboot_start, uboot_pages;
	unsigned long uboot_stack_size = 16 * 1024 * 1024;

	/* Add U-Boot */
	uboot_start = (gd->start_addr_sp - uboot_stack_size) & ~EFI_PAGE_MASK;
	uboot_pages = (gd->ram_top - uboot_start) >> EFI_PAGE_SHIFT;
	efi_add_memory_map(uboot_start, uboot_pages, EFI_LOADER_DATA, false);

#if defined(__aarch64__)
	/*
	 * Runtime Services must be 64KiB aligned according to the
	 * "AArch64 Platforms" section in the UEFI spec (2.7+).
	 */

	runtime_mask = SZ_64K - 1;
#endif

	/*
	 * Add Runtime Services. We mark surrounding boottime code as runtime as
	 * well to fulfill the runtime alignment constraints but avoid padding.
	 */
	runtime_start = (ulong)&__efi_runtime_start & ~runtime_mask;
	runtime_end = (ulong)&__efi_runtime_stop;
	runtime_end = (runtime_end + runtime_mask) & ~runtime_mask;
	runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT;
	efi_add_memory_map(runtime_start, runtime_pages,
			   EFI_RUNTIME_SERVICES_CODE, false);
}

int efi_memory_init(void)
{
	efi_add_known_memory();

	if (!IS_ENABLED(CONFIG_SANDBOX))
		add_u_boot_and_runtime();

#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
	/* Request a 32bit 64MB bounce buffer region */
	uint64_t efi_bounce_buffer_addr = 0xffffffff;

	if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_LOADER_DATA,
			       (64 * 1024 * 1024) >> EFI_PAGE_SHIFT,
			       &efi_bounce_buffer_addr) != EFI_SUCCESS)
		return -1;

	efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr;
#endif

	return 0;
}
Commit	Line	Data
f739fcd8	1	// SPDX-License-Identifier: GPL-2.0+
5d00995c AG	2	/*
	3	* EFI application memory management
	4	*
	5	* Copyright (c) 2016 Alexander Graf
5d00995c AG	6	*/
5d00995c AG	7
5d00995c AG	8	#include <common.h>
	9	#include <efi_loader.h>
	10	#include <malloc.h>
282a06cb	11	#include <mapmem.h>
bdecaebd	12	#include <watchdog.h>
38ce65e1	13	#include <linux/list_sort.h>
7a82c305	14	#include <linux/sizes.h>
5d00995c AG	15
	16	DECLARE_GLOBAL_DATA_PTR;
	17
1fcb7ea2 HS	18	efi_uintn_t efi_memory_map_key;
1fcb7ea2 HS	19
5d00995c AG	20	struct efi_mem_list {
	21	struct list_head link;
	22	struct efi_mem_desc desc;
	23	};
	24
74c16acc AG	25	#define EFI_CARVE_NO_OVERLAP -1
	26	#define EFI_CARVE_LOOP_AGAIN -2
	27	#define EFI_CARVE_OVERLAPS_NONRAM -3
	28
5d00995c AG	29	/* This list contains all memory map items */
	30	LIST_HEAD(efi_mem);
	31
51735ae0 AG	32	#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
	33	void *efi_bounce_buffer;
	34	#endif
	35
42417bc8 SB	36	/*
	37	* U-Boot services each EFI AllocatePool request as a separate
	38	* (multiple) page allocation. We have to track the number of pages
	39	* to be able to free the correct amount later.
	40	* EFI requires 8 byte alignment for pool allocations, so we can
	41	* prepend each allocation with an 64 bit header tracking the
	42	* allocation size, and hand out the remainder to the caller.
	43	*/
	44	struct efi_pool_allocation {
	45	u64 num_pages;
946160f3	46	char data[] __aligned(ARCH_DMA_MINALIGN);
42417bc8 SB	47	};
42417bc8 SB	48
38ce65e1 AG	49	/*
	50	* Sorts the memory list from highest address to lowest address
	51	*
	52	* When allocating memory we should always start from the highest
	53	* address chunk, so sort the memory list such that the first list
	54	* iterator gets the highest address and goes lower from there.
	55	*/
	56	static int efi_mem_cmp(void priv, struct list_head a, struct list_head *b)
	57	{
	58	struct efi_mem_list *mema = list_entry(a, struct efi_mem_list, link);
	59	struct efi_mem_list *memb = list_entry(b, struct efi_mem_list, link);
	60
	61	if (mema->desc.physical_start == memb->desc.physical_start)
	62	return 0;
	63	else if (mema->desc.physical_start < memb->desc.physical_start)
	64	return 1;
	65	else
	66	return -1;
	67	}
	68
7b05667c AG	69	static uint64_t desc_get_end(struct efi_mem_desc *desc)
	70	{
	71	return desc->physical_start + (desc->num_pages << EFI_PAGE_SHIFT);
	72	}
	73
38ce65e1 AG	74	static void efi_mem_sort(void)
38ce65e1 AG	75	{
7b05667c AG	76	struct list_head *lhandle;
	77	struct efi_mem_list *prevmem = NULL;
	78	bool merge_again = true;
	79
38ce65e1	80	list_sort(NULL, &efi_mem, efi_mem_cmp);
7b05667c AG	81
	82	/* Now merge entries that can be merged */
	83	while (merge_again) {
	84	merge_again = false;
	85	list_for_each(lhandle, &efi_mem) {
	86	struct efi_mem_list *lmem;
	87	struct efi_mem_desc *prev = &prevmem->desc;
	88	struct efi_mem_desc *cur;
	89	uint64_t pages;
	90
	91	lmem = list_entry(lhandle, struct efi_mem_list, link);
	92	if (!prevmem) {
	93	prevmem = lmem;
	94	continue;
	95	}
	96
	97	cur = &lmem->desc;
	98
	99	if ((desc_get_end(cur) == prev->physical_start) &&
	100	(prev->type == cur->type) &&
	101	(prev->attribute == cur->attribute)) {
	102	/* There is an existing map before, reuse it */
	103	pages = cur->num_pages;
	104	prev->num_pages += pages;
	105	prev->physical_start -= pages << EFI_PAGE_SHIFT;
	106	prev->virtual_start -= pages << EFI_PAGE_SHIFT;
	107	list_del(&lmem->link);
	108	free(lmem);
	109
	110	merge_again = true;
	111	break;
	112	}
	113
	114	prevmem = lmem;
	115	}
	116	}
38ce65e1 AG	117	}
38ce65e1 AG	118
32826140 HS	119	/** efi_mem_carve_out - unmap memory region
	120	*
	121	* @map: memory map
	122	* @carve_desc: memory region to unmap
	123	* @overlap_only_ram: the carved out region may only overlap RAM
	124	* Return Value: the number of overlapping pages which have been
	125	* removed from the map,
	126	* EFI_CARVE_NO_OVERLAP, if the regions don't overlap,
	127	* EFI_CARVE_OVERLAPS_NONRAM, if the carve and map overlap,
	128	* and the map contains anything but free ram
	129	* (only when overlap_only_ram is true),
	130	* EFI_CARVE_LOOP_AGAIN, if the mapping list should be
	131	* traversed again, as it has been altered.
5d00995c	132	*
32826140 HS	133	* Unmaps all memory occupied by the carve_desc region from the list entry
32826140 HS	134	* pointed to by map.
852efbf5 SB	135	*
852efbf5 SB	136	* In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility
32826140	137	* to re-add the already carved out pages to the mapping.
5d00995c	138	*/
32826140	139	static s64 efi_mem_carve_out(struct efi_mem_list *map,
5d00995c AG	140	struct efi_mem_desc *carve_desc,
	141	bool overlap_only_ram)
	142	{
	143	struct efi_mem_list *newmap;
	144	struct efi_mem_desc *map_desc = &map->desc;
	145	uint64_t map_start = map_desc->physical_start;
	146	uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT);
	147	uint64_t carve_start = carve_desc->physical_start;
	148	uint64_t carve_end = carve_start +
	149	(carve_desc->num_pages << EFI_PAGE_SHIFT);
	150
	151	/* check whether we're overlapping */
	152	if ((carve_end <= map_start) \|\| (carve_start >= map_end))
74c16acc	153	return EFI_CARVE_NO_OVERLAP;
5d00995c AG	154
	155	/* We're overlapping with non-RAM, warn the caller if desired */
	156	if (overlap_only_ram && (map_desc->type != EFI_CONVENTIONAL_MEMORY))
74c16acc	157	return EFI_CARVE_OVERLAPS_NONRAM;
5d00995c AG	158
	159	/* Sanitize carve_start and carve_end to lie within our bounds */
	160	carve_start = max(carve_start, map_start);
	161	carve_end = min(carve_end, map_end);
	162
	163	/* Carving at the beginning of our map? Just move it! */
	164	if (carve_start == map_start) {
	165	if (map_end == carve_end) {
	166	/* Full overlap, just remove map */
	167	list_del(&map->link);
511d0b97 SB	168	free(map);
	169	} else {
	170	map->desc.physical_start = carve_end;
	171	map->desc.num_pages = (map_end - carve_end)
	172	>> EFI_PAGE_SHIFT;
5d00995c AG	173	}
5d00995c AG	174
74c16acc	175	return (carve_end - carve_start) >> EFI_PAGE_SHIFT;
5d00995c AG	176	}
	177
	178	/*
	179	* Overlapping maps, just split the list map at carve_start,
	180	* it will get moved or removed in the next iteration.
	181	*
	182	* [ map_desc \|__carve_start__\| newmap ]
	183	*/
	184
	185	/* Create a new map from [ carve_start ... map_end ] */
	186	newmap = calloc(1, sizeof(*newmap));
	187	newmap->desc = map->desc;
	188	newmap->desc.physical_start = carve_start;
	189	newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT;
b6a95172 SB	190	/* Insert before current entry (descending address order) */
b6a95172 SB	191	list_add_tail(&newmap->link, &map->link);
5d00995c AG	192
	193	/* Shrink the map to [ map_start ... carve_start ] */
	194	map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT;
	195
74c16acc	196	return EFI_CARVE_LOOP_AGAIN;
5d00995c AG	197	}
	198
	199	uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
	200	bool overlap_only_ram)
	201	{
	202	struct list_head *lhandle;
	203	struct efi_mem_list *newlist;
74c16acc AG	204	bool carve_again;
74c16acc AG	205	uint64_t carved_pages = 0;
5d00995c	206
dee37fc9	207	debug("%s: 0x%llx 0x%llx %d %s\n", __func__,
c933ed94 AF	208	start, pages, memory_type, overlap_only_ram ? "yes" : "no");
c933ed94 AF	209
1fcb7ea2 HS	210	if (memory_type >= EFI_MAX_MEMORY_TYPE)
	211	return EFI_INVALID_PARAMETER;
	212
5d00995c AG	213	if (!pages)
	214	return start;
	215
1fcb7ea2	216	++efi_memory_map_key;
5d00995c AG	217	newlist = calloc(1, sizeof(*newlist));
	218	newlist->desc.type = memory_type;
	219	newlist->desc.physical_start = start;
	220	newlist->desc.virtual_start = start;
	221	newlist->desc.num_pages = pages;
	222
	223	switch (memory_type) {
	224	case EFI_RUNTIME_SERVICES_CODE:
	225	case EFI_RUNTIME_SERVICES_DATA:
9b89183b	226	newlist->desc.attribute = EFI_MEMORY_WB \| EFI_MEMORY_RUNTIME;
5d00995c AG	227	break;
5d00995c AG	228	case EFI_MMAP_IO:
9b89183b	229	newlist->desc.attribute = EFI_MEMORY_RUNTIME;
5d00995c AG	230	break;
5d00995c AG	231	default:
9b89183b	232	newlist->desc.attribute = EFI_MEMORY_WB;
5d00995c AG	233	break;
	234	}
	235
	236	/* Add our new map */
	237	do {
74c16acc	238	carve_again = false;
5d00995c AG	239	list_for_each(lhandle, &efi_mem) {
5d00995c AG	240	struct efi_mem_list *lmem;
32826140	241	s64 r;
5d00995c AG	242
	243	lmem = list_entry(lhandle, struct efi_mem_list, link);
	244	r = efi_mem_carve_out(lmem, &newlist->desc,
	245	overlap_only_ram);
74c16acc AG	246	switch (r) {
	247	case EFI_CARVE_OVERLAPS_NONRAM:
	248	/*
	249	* The user requested to only have RAM overlaps,
	250	* but we hit a non-RAM region. Error out.
	251	*/
5d00995c	252	return 0;
74c16acc AG	253	case EFI_CARVE_NO_OVERLAP:
	254	/* Just ignore this list entry */
	255	break;
	256	case EFI_CARVE_LOOP_AGAIN:
	257	/*
	258	* We split an entry, but need to loop through
	259	* the list again to actually carve it.
	260	*/
	261	carve_again = true;
	262	break;
	263	default:
	264	/* We carved a number of pages */
	265	carved_pages += r;
	266	carve_again = true;
	267	break;
	268	}
	269
	270	if (carve_again) {
	271	/* The list changed, we need to start over */
5d00995c AG	272	break;
	273	}
	274	}
74c16acc AG	275	} while (carve_again);
	276
	277	if (overlap_only_ram && (carved_pages != pages)) {
	278	/*
	279	* The payload wanted to have RAM overlaps, but we overlapped
	280	* with an unallocated region. Error out.
	281	*/
	282	return 0;
	283	}
5d00995c AG	284
	285	/* Add our new map */
	286	list_add_tail(&newlist->link, &efi_mem);
	287
38ce65e1 AG	288	/* And make sure memory is listed in descending order */
	289	efi_mem_sort();
	290
5d00995c AG	291	return start;
	292	}
	293
	294	static uint64_t efi_find_free_memory(uint64_t len, uint64_t max_addr)
	295	{
	296	struct list_head *lhandle;
	297
c2e1ad70 AG	298	/*
	299	* Prealign input max address, so we simplify our matching
	300	* logic below and can just reuse it as return pointer.
	301	*/
	302	max_addr &= ~EFI_PAGE_MASK;
	303
5d00995c AG	304	list_for_each(lhandle, &efi_mem) {
	305	struct efi_mem_list *lmem = list_entry(lhandle,
	306	struct efi_mem_list, link);
	307	struct efi_mem_desc *desc = &lmem->desc;
	308	uint64_t desc_len = desc->num_pages << EFI_PAGE_SHIFT;
	309	uint64_t desc_end = desc->physical_start + desc_len;
	310	uint64_t curmax = min(max_addr, desc_end);
	311	uint64_t ret = curmax - len;
	312
	313	/* We only take memory from free RAM */
	314	if (desc->type != EFI_CONVENTIONAL_MEMORY)
	315	continue;
	316
	317	/* Out of bounds for max_addr */
	318	if ((ret + len) > max_addr)
	319	continue;
	320
	321	/* Out of bounds for upper map limit */
	322	if ((ret + len) > desc_end)
	323	continue;
	324
	325	/* Out of bounds for lower map limit */
	326	if (ret < desc->physical_start)
	327	continue;
	328
	329	/* Return the highest address in this map within bounds */
	330	return ret;
	331	}
	332
	333	return 0;
	334	}
	335
474a6f5a HS	336	/*
	337	* Allocate memory pages.
	338	*
	339	* @type type of allocation to be performed
	340	* @memory_type usage type of the allocated memory
	341	* @pages number of pages to be allocated
	342	* @memory allocated memory
	343	* @return status code
	344	*/
5d00995c	345	efi_status_t efi_allocate_pages(int type, int memory_type,
f5a2a938	346	efi_uintn_t pages, uint64_t *memory)
5d00995c AG	347	{
	348	u64 len = pages << EFI_PAGE_SHIFT;
	349	efi_status_t r = EFI_SUCCESS;
	350	uint64_t addr;
	351
4d5e071e HS	352	if (!memory)
	353	return EFI_INVALID_PARAMETER;
	354
5d00995c	355	switch (type) {
7c92fd69	356	case EFI_ALLOCATE_ANY_PAGES:
5d00995c	357	/* Any page */
14deb5e6	358	addr = efi_find_free_memory(len, -1ULL);
5d00995c AG	359	if (!addr) {
	360	r = EFI_NOT_FOUND;
	361	break;
	362	}
	363	break;
7c92fd69	364	case EFI_ALLOCATE_MAX_ADDRESS:
5d00995c AG	365	/* Max address */
	366	addr = efi_find_free_memory(len, *memory);
	367	if (!addr) {
	368	r = EFI_NOT_FOUND;
	369	break;
	370	}
	371	break;
7c92fd69	372	case EFI_ALLOCATE_ADDRESS:
5d00995c AG	373	/* Exact address, reserve it. The addr is already in memory. /
	374	addr = *memory;
	375	break;
	376	default:
	377	/* UEFI doesn't specify other allocation types */
	378	r = EFI_INVALID_PARAMETER;
	379	break;
	380	}
	381
	382	if (r == EFI_SUCCESS) {
	383	uint64_t ret;
	384
	385	/* Reserve that map in our memory maps */
	386	ret = efi_add_memory_map(addr, pages, memory_type, true);
	387	if (ret == addr) {
49759743	388	*memory = addr;
5d00995c AG	389	} else {
	390	/* Map would overlap, bail out */
	391	r = EFI_OUT_OF_RESOURCES;
	392	}
	393	}
	394
	395	return r;
	396	}
	397
	398	void *efi_alloc(uint64_t len, int memory_type)
	399	{
	400	uint64_t ret = 0;
c3772ca1	401	uint64_t pages = efi_size_in_pages(len);
5d00995c AG	402	efi_status_t r;
5d00995c AG	403
e09159c8 HS	404	r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type, pages,
e09159c8 HS	405	&ret);
5d00995c AG	406	if (r == EFI_SUCCESS)
	407	return (void*)(uintptr_t)ret;
	408
	409	return NULL;
	410	}
	411
474a6f5a HS	412	/*
	413	* Free memory pages.
	414	*
	415	* @memory start of the memory area to be freed
	416	* @pages number of pages to be freed
	417	* @return status code
	418	*/
f5a2a938	419	efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages)
5d00995c	420	{
b61d857b SB	421	uint64_t r = 0;
b61d857b SB	422
49759743	423	r = efi_add_memory_map(memory, pages, EFI_CONVENTIONAL_MEMORY, false);
b61d857b SB	424	/* Merging of adjacent free regions is missing */
b61d857b SB	425
49759743	426	if (r == memory)
b61d857b SB	427	return EFI_SUCCESS;
	428
	429	return EFI_NOT_FOUND;
5d00995c AG	430	}
5d00995c AG	431
474a6f5a HS	432	/*
	433	* Allocate memory from pool.
	434	*
	435	* @pool_type type of the pool from which memory is to be allocated
	436	* @size number of bytes to be allocated
	437	* @buffer allocated memory
	438	* @return status code
	439	*/
	440	efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, void **buffer)
ead1274b SB	441	{
ead1274b SB	442	efi_status_t r;
282a06cb	443	struct efi_pool_allocation *alloc;
c3772ca1 HS	444	u64 num_pages = efi_size_in_pages(size +
c3772ca1 HS	445	sizeof(struct efi_pool_allocation));
42417bc8	446
4d5e071e HS	447	if (!buffer)
	448	return EFI_INVALID_PARAMETER;
	449
42417bc8 SB	450	if (size == 0) {
	451	*buffer = NULL;
	452	return EFI_SUCCESS;
	453	}
ead1274b	454
e09159c8	455	r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, pool_type, num_pages,
282a06cb	456	(uint64_t *)&alloc);
42417bc8 SB	457
42417bc8 SB	458	if (r == EFI_SUCCESS) {
42417bc8 SB	459	alloc->num_pages = num_pages;
	460	*buffer = alloc->data;
	461	}
	462
	463	return r;
	464	}
	465
474a6f5a HS	466	/*
	467	* Free memory from pool.
	468	*
	469	* @buffer start of memory to be freed
	470	* @return status code
	471	*/
42417bc8 SB	472	efi_status_t efi_free_pool(void *buffer)
	473	{
	474	efi_status_t r;
	475	struct efi_pool_allocation *alloc;
	476
71275a3e HS	477	if (buffer == NULL)
	478	return EFI_INVALID_PARAMETER;
	479
42417bc8 SB	480	alloc = container_of(buffer, struct efi_pool_allocation, data);
	481	/* Sanity check, was the supplied address returned by allocate_pool */
	482	assert(((uintptr_t)alloc & EFI_PAGE_MASK) == 0);
	483
	484	r = efi_free_pages((uintptr_t)alloc, alloc->num_pages);
ead1274b SB	485
	486	return r;
	487	}
	488
474a6f5a HS	489	/*
	490	* Get map describing memory usage.
	491	*
	492	* @memory_map_size on entry the size, in bytes, of the memory map buffer,
	493	* on exit the size of the copied memory map
	494	* @memory_map buffer to which the memory map is written
	495	* @map_key key for the memory map
	496	* @descriptor_size size of an individual memory descriptor
	497	* @descriptor_version version number of the memory descriptor structure
	498	* @return status code
	499	*/
f5a2a938 HS	500	efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
	501	struct efi_mem_desc *memory_map,
	502	efi_uintn_t *map_key,
	503	efi_uintn_t *descriptor_size,
	504	uint32_t *descriptor_version)
5d00995c	505	{
f5a2a938	506	efi_uintn_t map_size = 0;
cee752fa	507	int map_entries = 0;
5d00995c	508	struct list_head *lhandle;
fa995d0d	509	efi_uintn_t provided_map_size;
5d00995c	510
8e835554 HS	511	if (!memory_map_size)
	512	return EFI_INVALID_PARAMETER;
	513
fa995d0d HS	514	provided_map_size = *memory_map_size;
fa995d0d HS	515
5d00995c	516	list_for_each(lhandle, &efi_mem)
cee752fa AG	517	map_entries++;
	518
	519	map_size = map_entries * sizeof(struct efi_mem_desc);
5d00995c	520
a1b24823 RC	521	*memory_map_size = map_size;
a1b24823 RC	522
0ecba5db HS	523	if (provided_map_size < map_size)
	524	return EFI_BUFFER_TOO_SMALL;
	525
8e835554 HS	526	if (!memory_map)
	527	return EFI_INVALID_PARAMETER;
	528
5d00995c AG	529	if (descriptor_size)
	530	*descriptor_size = sizeof(struct efi_mem_desc);
	531
4c02c11d MYK	532	if (descriptor_version)
	533	*descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;
	534
5d00995c	535	/* Copy list into array */
8e835554 HS	536	/* Return the list in ascending order */
	537	memory_map = &memory_map[map_entries - 1];
	538	list_for_each(lhandle, &efi_mem) {
	539	struct efi_mem_list *lmem;
5d00995c	540
8e835554 HS	541	lmem = list_entry(lhandle, struct efi_mem_list, link);
	542	*memory_map = lmem->desc;
	543	memory_map--;
5d00995c AG	544	}
5d00995c AG	545
8e835554	546	if (map_key)
1fcb7ea2	547	*map_key = efi_memory_map_key;
c6e3c3e6	548
5d00995c AG	549	return EFI_SUCCESS;
	550	}
	551
42633745	552	__weak void efi_add_known_memory(void)
5d00995c	553	{
7b78d643	554	u64 ram_top = board_get_usable_ram_top(0) & ~EFI_PAGE_MASK;
5d00995c AG	555	int i;
5d00995c AG	556
23f5f4ab HS	557	/*
	558	* ram_top is just outside mapped memory. So use an offset of one for
	559	* mapping the sandbox address.
	560	*/
	561	ram_top = (uintptr_t)map_sysmem(ram_top - 1, 0) + 1;
	562
7b78d643 AG	563	/* Fix for 32bit targets with ram_top at 4G */
	564	if (!ram_top)
	565	ram_top = 0x100000000ULL;
	566
5d00995c AG	567	/* Add RAM */
5d00995c AG	568	for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
108bdff8	569	u64 ram_end, ram_start, pages;
5d00995c	570
49759743	571	ram_start = (uintptr_t)map_sysmem(gd->bd->bi_dram[i].start, 0);
108bdff8 HS	572	ram_end = ram_start + gd->bd->bi_dram[i].size;
	573
	574	/* Remove partial pages */
	575	ram_end &= ~EFI_PAGE_MASK;
	576	ram_start = (ram_start + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
	577
7b78d643 AG	578	if (ram_end <= ram_start) {
	579	/* Invalid mapping, keep going. */
	580	continue;
	581	}
	582
	583	pages = (ram_end - ram_start) >> EFI_PAGE_SHIFT;
108bdff8	584
7b78d643 AG	585	efi_add_memory_map(ram_start, pages,
	586	EFI_CONVENTIONAL_MEMORY, false);
	587
	588	/*
	589	* Boards may indicate to the U-Boot memory core that they
	590	* can not support memory above ram_top. Let's honor this
	591	* in the efi_loader subsystem too by declaring any memory
	592	* above ram_top as "already occupied by firmware".
	593	*/
	594	if (ram_top < ram_start) {
	595	/* ram_top is before this region, reserve all */
108bdff8	596	efi_add_memory_map(ram_start, pages,
7b78d643 AG	597	EFI_BOOT_SERVICES_DATA, true);
	598	} else if ((ram_top >= ram_start) && (ram_top < ram_end)) {
	599	/* ram_top is inside this region, reserve parts */
	600	pages = (ram_end - ram_top) >> EFI_PAGE_SHIFT;
	601
	602	efi_add_memory_map(ram_top, pages,
	603	EFI_BOOT_SERVICES_DATA, true);
108bdff8	604	}
5d00995c	605	}
42633745 YS	606	}
42633745 YS	607
69259b83 SG	608	/* Add memory regions for U-Boot's memory and for the runtime services code */
69259b83 SG	609	static void add_u_boot_and_runtime(void)
42633745 YS	610	{
42633745 YS	611	unsigned long runtime_start, runtime_end, runtime_pages;
7a82c305	612	unsigned long runtime_mask = EFI_PAGE_MASK;
42633745 YS	613	unsigned long uboot_start, uboot_pages;
	614	unsigned long uboot_stack_size = 16 * 1024 * 1024;
	615
5d00995c AG	616	/* Add U-Boot */
	617	uboot_start = (gd->start_addr_sp - uboot_stack_size) & ~EFI_PAGE_MASK;
	618	uboot_pages = (gd->ram_top - uboot_start) >> EFI_PAGE_SHIFT;
	619	efi_add_memory_map(uboot_start, uboot_pages, EFI_LOADER_DATA, false);
	620
7a82c305 AG	621	#if defined(__aarch64__)
	622	/*
	623	* Runtime Services must be 64KiB aligned according to the
	624	* "AArch64 Platforms" section in the UEFI spec (2.7+).
	625	*/
	626
	627	runtime_mask = SZ_64K - 1;
	628	#endif
	629
	630	/*
	631	* Add Runtime Services. We mark surrounding boottime code as runtime as
	632	* well to fulfill the runtime alignment constraints but avoid padding.
	633	*/
	634	runtime_start = (ulong)&__efi_runtime_start & ~runtime_mask;
5d00995c	635	runtime_end = (ulong)&__efi_runtime_stop;
7a82c305	636	runtime_end = (runtime_end + runtime_mask) & ~runtime_mask;
5d00995c AG	637	runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT;
	638	efi_add_memory_map(runtime_start, runtime_pages,
	639	EFI_RUNTIME_SERVICES_CODE, false);
69259b83 SG	640	}
	641
	642	int efi_memory_init(void)
	643	{
	644	efi_add_known_memory();
	645
	646	if (!IS_ENABLED(CONFIG_SANDBOX))
	647	add_u_boot_and_runtime();
5d00995c	648
51735ae0 AG	649	#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
	650	/* Request a 32bit 64MB bounce buffer region */
	651	uint64_t efi_bounce_buffer_addr = 0xffffffff;
	652
e09159c8	653	if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_LOADER_DATA,
51735ae0 AG	654	(64 * 1024 * 1024) >> EFI_PAGE_SHIFT,
	655	&efi_bounce_buffer_addr) != EFI_SUCCESS)
	656	return -1;
	657
	658	efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr;
	659	#endif
	660
5d00995c AG	661	return 0;
5d00995c AG	662	}