// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2015 Linaro Ltd <ard.biesheuvel@linaro.org>
 */

#include <linux/efi.h>
#include <linux/memblock.h>
#include <linux/screen_info.h>

#include <asm/efi.h>
#include <asm/mach/map.h>
#include <asm/mmu_context.h>

static int __init set_permissions(pte_t *ptep, unsigned long addr, void *data)
{
        efi_memory_desc_t *md = data;
        pte_t pte = *ptep;

        if (md->attribute & EFI_MEMORY_RO)
                pte = set_pte_bit(pte, __pgprot(L_PTE_RDONLY));
        if (md->attribute & EFI_MEMORY_XP)
                pte = set_pte_bit(pte, __pgprot(L_PTE_XN));
        set_pte_ext(ptep, pte, PTE_EXT_NG);
        return 0;
}

int __init efi_set_mapping_permissions(struct mm_struct *mm,
                                       efi_memory_desc_t *md,
                                       bool ignored)
{
        unsigned long base, size;

        base = md->virt_addr;
        size = md->num_pages << EFI_PAGE_SHIFT;

        /*
         * We can only use apply_to_page_range() if we can guarantee that the
         * entire region was mapped using pages. This should be the case if the
         * region does not cover any naturally aligned SECTION_SIZE sized
         * blocks.
         */
        if (round_down(base + size, SECTION_SIZE) <
            round_up(base, SECTION_SIZE) + SECTION_SIZE)
                return apply_to_page_range(mm, base, size, set_permissions, md);

        return 0;
}

int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md)
{
        struct map_desc desc = {
                .virtual        = md->virt_addr,
                .pfn            = __phys_to_pfn(md->phys_addr),
                .length         = md->num_pages * EFI_PAGE_SIZE,
        };

        /*
         * Order is important here: memory regions may have all of the
         * bits below set (and usually do), so we check them in order of
         * preference.
         */
        if (md->attribute & EFI_MEMORY_WB)
                desc.type = MT_MEMORY_RWX;
        else if (md->attribute & EFI_MEMORY_WT)
                desc.type = MT_MEMORY_RWX_NONCACHED;
        else if (md->attribute & EFI_MEMORY_WC)
                desc.type = MT_DEVICE_WC;
        else
                desc.type = MT_DEVICE;

        create_mapping_late(mm, &desc, true);

        /*
         * If stricter permissions were specified, apply them now.
         */
        if (md->attribute & (EFI_MEMORY_RO | EFI_MEMORY_XP))
                return efi_set_mapping_permissions(mm, md, false);
        return 0;
}

static unsigned long __initdata cpu_state_table = EFI_INVALID_TABLE_ADDR;

const efi_config_table_type_t efi_arch_tables[] __initconst = {
        {LINUX_EFI_ARM_CPU_STATE_TABLE_GUID, &cpu_state_table},
        {}
};

static void __init load_cpu_state_table(void)
{
        if (cpu_state_table != EFI_INVALID_TABLE_ADDR) {
                struct efi_arm_entry_state *state;
                bool dump_state = true;

                state = early_memremap_ro(cpu_state_table,
                                          sizeof(struct efi_arm_entry_state));
                if (state == NULL) {
                        pr_warn("Unable to map CPU entry state table.\n");
                        return;
                }

                if ((state->sctlr_before_ebs & 1) == 0)
                        pr_warn(FW_BUG "EFI stub was entered with MMU and Dcache disabled, please fix your firmware!\n");
                else if ((state->sctlr_after_ebs & 1) == 0)
                        pr_warn(FW_BUG "ExitBootServices() returned with MMU and Dcache disabled, please fix your firmware!\n");
                else
                        dump_state = false;

                if (dump_state || efi_enabled(EFI_DBG)) {
                        pr_info("CPSR at EFI stub entry        : 0x%08x\n",
                                state->cpsr_before_ebs);
                        pr_info("SCTLR at EFI stub entry       : 0x%08x\n",
                                state->sctlr_before_ebs);
                        pr_info("CPSR after ExitBootServices() : 0x%08x\n",
                                state->cpsr_after_ebs);
                        pr_info("SCTLR after ExitBootServices(): 0x%08x\n",
                                state->sctlr_after_ebs);
                }
                early_memunmap(state, sizeof(struct efi_arm_entry_state));
        }
}

void __init arm_efi_init(void)
{
        efi_init();

        /* ARM does not permit early mappings to persist across paging_init() */
        efi_memmap_unmap();

        load_cpu_state_table();
}