// SPDX-License-Identifier: GPL-2.0

#include <linux/efi.h>
#include <asm/efi.h>

#include "efistub.h"

/**
 * efi_get_memory_map() - get memory map
 * @map:                pointer to memory map pointer to which to assign the
 *                      newly allocated memory map
 * @install_cfg_tbl:    whether or not to install the boot memory map as a
 *                      configuration table
 *
 * Retrieve the UEFI memory map. The allocated memory leaves room for
 * up to EFI_MMAP_NR_SLACK_SLOTS additional memory map entries.
 *
 * Return:      status code
 */
efi_status_t efi_get_memory_map(struct efi_boot_memmap **map,
                                bool install_cfg_tbl)
{
        struct efi_boot_memmap tmp, *m __free(efi_pool) = NULL;
        int memtype = install_cfg_tbl ? EFI_ACPI_RECLAIM_MEMORY
                                      : EFI_LOADER_DATA;
        efi_guid_t tbl_guid = LINUX_EFI_BOOT_MEMMAP_GUID;
        efi_status_t status;
        unsigned long size;

        tmp.map_size = 0;
        status = efi_bs_call(get_memory_map, &tmp.map_size, NULL, &tmp.map_key,
                             &tmp.desc_size, &tmp.desc_ver);
        if (status != EFI_BUFFER_TOO_SMALL)
                return EFI_LOAD_ERROR;

        size = tmp.map_size + tmp.desc_size * EFI_MMAP_NR_SLACK_SLOTS;
        status = efi_bs_call(allocate_pool, memtype, sizeof(*m) + size,
                             (void **)&m);
        if (status != EFI_SUCCESS)
                return status;

        if (install_cfg_tbl) {
                /*
                 * Installing a configuration table might allocate memory, and
                 * this may modify the memory map. This means we should install
                 * the configuration table first, and re-install or delete it
                 * as needed.
                 */
                status = efi_bs_call(install_configuration_table, &tbl_guid, m);
                if (status != EFI_SUCCESS)
                        return status;
        }

        m->buff_size = m->map_size = size;
        status = efi_bs_call(get_memory_map, &m->map_size, m->map, &m->map_key,
                             &m->desc_size, &m->desc_ver);
        if (status != EFI_SUCCESS) {
                if (install_cfg_tbl)
                        efi_bs_call(install_configuration_table, &tbl_guid, NULL);
                return status;
        }

        *map = no_free_ptr(m);
        return EFI_SUCCESS;
}

/**
 * efi_allocate_pages() - Allocate memory pages
 * @size:       minimum number of bytes to allocate
 * @addr:       On return the address of the first allocated page. The first
 *              allocated page has alignment EFI_ALLOC_ALIGN which is an
 *              architecture dependent multiple of the page size.
 * @max:        the address that the last allocated memory page shall not
 *              exceed
 *
 * Allocate pages as EFI_LOADER_DATA. The allocated pages are aligned according
 * to EFI_ALLOC_ALIGN. The last allocated page will not exceed the address
 * given by @max.
 *
 * Return:      status code
 */
efi_status_t efi_allocate_pages(unsigned long size, unsigned long *addr,
                                unsigned long max)
{
        efi_physical_addr_t alloc_addr;
        efi_status_t status;

        max = min(max, EFI_ALLOC_LIMIT);

        if (EFI_ALLOC_ALIGN > EFI_PAGE_SIZE)
                return efi_allocate_pages_aligned(size, addr, max,
                                                  EFI_ALLOC_ALIGN,
                                                  EFI_LOADER_DATA);

        alloc_addr = ALIGN_DOWN(max + 1, EFI_ALLOC_ALIGN) - 1;
        status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS,
                             EFI_LOADER_DATA, DIV_ROUND_UP(size, EFI_PAGE_SIZE),
                             &alloc_addr);
        if (status != EFI_SUCCESS)
                return status;

        *addr = alloc_addr;
        return EFI_SUCCESS;
}

/**
 * efi_free() - free memory pages
 * @size:       size of the memory area to free in bytes
 * @addr:       start of the memory area to free (must be EFI_PAGE_SIZE
 *              aligned)
 *
 * @size is rounded up to a multiple of EFI_ALLOC_ALIGN which is an
 * architecture specific multiple of EFI_PAGE_SIZE. So this function should
 * only be used to return pages allocated with efi_allocate_pages() or
 * efi_low_alloc_above().
 */
void efi_free(unsigned long size, unsigned long addr)
{
        unsigned long nr_pages;

        if (!size)
                return;

        nr_pages = round_up(size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE;
        efi_bs_call(free_pages, addr, nr_pages);
}

/**
 * efi_low_alloc_above() - allocate pages at or above given address
 * @size:       size of the memory area to allocate
 * @align:      minimum alignment of the allocated memory area. It should
 *              a power of two.
 * @addr:       on exit the address of the allocated memory
 * @min:        minimum address to used for the memory allocation
 *
 * Allocate at the lowest possible address that is not below @min as
 * EFI_LOADER_DATA. The allocated pages are aligned according to @align but at
 * least EFI_ALLOC_ALIGN. The first allocated page will not below the address
 * given by @min.
 *
 * Return:      status code
 */
efi_status_t efi_low_alloc_above(unsigned long size, unsigned long align,
                                 unsigned long *addr, unsigned long min)
{
        struct efi_boot_memmap *map __free(efi_pool) = NULL;
        efi_status_t status;
        unsigned long nr_pages;
        int i;

        status = efi_get_memory_map(&map, false);
        if (status != EFI_SUCCESS)
                return status;

        /*
         * Enforce minimum alignment that EFI or Linux requires when
         * requesting a specific address.  We are doing page-based (or
         * larger) allocations, and both the address and size must meet
         * alignment constraints.
         */
        if (align < EFI_ALLOC_ALIGN)
                align = EFI_ALLOC_ALIGN;

        size = round_up(size, EFI_ALLOC_ALIGN);
        nr_pages = size / EFI_PAGE_SIZE;
        for (i = 0; i < map->map_size / map->desc_size; i++) {
                efi_memory_desc_t *desc;
                unsigned long m = (unsigned long)map->map;
                u64 start, end;

                desc = efi_memdesc_ptr(m, map->desc_size, i);

                if (desc->type != EFI_CONVENTIONAL_MEMORY)
                        continue;

                if (desc->attribute & EFI_MEMORY_HOT_PLUGGABLE)
                        continue;

                if (efi_soft_reserve_enabled() &&
                    (desc->attribute & EFI_MEMORY_SP))
                        continue;

                if (desc->num_pages < nr_pages)
                        continue;

                start = desc->phys_addr;
                end = start + desc->num_pages * EFI_PAGE_SIZE;

                if (start < min)
                        start = min;

                start = round_up(start, align);
                if ((start + size) > end)
                        continue;

                status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS,
                                     EFI_LOADER_DATA, nr_pages, &start);
                if (status == EFI_SUCCESS) {
                        *addr = start;
                        break;
                }
        }

        if (i == map->map_size / map->desc_size)
                return EFI_NOT_FOUND;

        return EFI_SUCCESS;
}