/* $NetBSD: efi_runtime.c,v 1.11 2023/05/22 16:27:48 riastradh Exp $ */

/*-
 * Copyright (c) 2018 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jared McNeill <jmcneill@invisible.ca>.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "efi.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: efi_runtime.c,v 1.11 2023/05/22 16:27:48 riastradh Exp $");

#include <sys/param.h>
#include <sys/mutex.h>
#include <sys/endian.h>

#include <uvm/uvm_extern.h>

#include <dev/efivar.h>

#include <arm/arm/efi_runtime.h>
#include <arm/bootconfig.h>

static kmutex_t efi_lock;
static struct efi_rt *RT;
#if BYTE_ORDER == LITTLE_ENDIAN
static struct efi_rt efi_rtcopy;

#if NEFI > 0
static struct efi_ops arm_efi_ops = {
        .efi_gettime    = arm_efirt_gettime,
        .efi_settime    = arm_efirt_settime,
        .efi_getvar     = arm_efirt_getvar,
        .efi_setvar     = arm_efirt_setvar,
        .efi_nextvar    = arm_efirt_nextvar,
};
#endif
#endif

int
arm_efirt_init(paddr_t efi_system_table)
{
#if BYTE_ORDER == LITTLE_ENDIAN
        struct efi_systbl *ST;
        const size_t sz = PAGE_SIZE * 2;
        vaddr_t va, cva;
        paddr_t cpa;
        int val;

        if (get_bootconf_option(boot_args, "noefirt",
                                BOOTOPT_TYPE_BOOLEAN, &val) && val) {
                return ENXIO;
        }

        va = uvm_km_alloc(kernel_map, sz, 0, UVM_KMF_VAONLY);
        if (va == 0) {
                aprint_error("%s: can't allocate VA\n", __func__);
                return ENOMEM;
        }
        for (cva = va, cpa = trunc_page(efi_system_table);
             cva < va + sz;
             cva += PAGE_SIZE, cpa += PAGE_SIZE) {
                pmap_kenter_pa(cva, cpa, VM_PROT_READ, 0);
        }
        pmap_update(pmap_kernel());

        ST = (void *)(va + (efi_system_table - trunc_page(efi_system_table)));
        if (ST->st_hdr.th_sig != EFI_SYSTBL_SIG) {
                aprint_error("EFI: signature mismatch (%#" PRIx64 " != %#"
                    PRIx64 ")\n", ST->st_hdr.th_sig, EFI_SYSTBL_SIG);
                return EINVAL;
        }

        struct efi_rt *rt = ST->st_rt;
        mutex_init(&efi_lock, MUTEX_DEFAULT, IPL_HIGH);

        pmap_activate_efirt();

        memcpy(&efi_rtcopy, rt, sizeof(efi_rtcopy));
        RT = &efi_rtcopy;

        pmap_deactivate_efirt();

#if NEFI > 0
        efi_register_ops(&arm_efi_ops);
#endif

        return 0;
#else
        /* EFI runtime not supported in big endian mode */
        return ENXIO;
#endif
}

efi_status
arm_efirt_gettime(struct efi_tm *tm, struct efi_tmcap *tmcap)
{
        efi_status status = EFI_DEVICE_ERROR;

        if (RT == NULL || RT->rt_gettime == NULL) {
                return EFI_UNSUPPORTED;
        }

        mutex_enter(&efi_lock);
        if (arm_efirt_md_enter() == 0) {
                status = RT->rt_gettime(tm, tmcap);
        }
        arm_efirt_md_exit();
        mutex_exit(&efi_lock);

        return status;
}

efi_status
arm_efirt_settime(struct efi_tm *tm)
{
        efi_status status = EFI_DEVICE_ERROR;

        if (RT == NULL || RT->rt_settime == NULL) {
                return EFI_UNSUPPORTED;
        }

        mutex_enter(&efi_lock);
        if (arm_efirt_md_enter() == 0) {
                status = RT->rt_settime(tm);
        }
        arm_efirt_md_exit();
        mutex_exit(&efi_lock);

        return status;
}

efi_status
arm_efirt_getvar(uint16_t *name, struct uuid *vendor, uint32_t *attrib,
    u_long *datasize, void *data)
{
        efi_status status = EFI_DEVICE_ERROR;

        if (RT == NULL || RT->rt_getvar == NULL) {
                return EFI_UNSUPPORTED;
        }

        mutex_enter(&efi_lock);
        if (arm_efirt_md_enter() == 0) {
                status = RT->rt_getvar(name, vendor, attrib, datasize, data);
        }
        arm_efirt_md_exit();
        mutex_exit(&efi_lock);

        return status;
}

efi_status
arm_efirt_nextvar(u_long *namesize, efi_char *name, struct uuid *vendor)
{
        efi_status status = EFI_DEVICE_ERROR;

        if (RT == NULL || RT->rt_scanvar == NULL) {
                return EFI_UNSUPPORTED;
        }

        mutex_enter(&efi_lock);
        if (arm_efirt_md_enter() == 0) {
                status = RT->rt_scanvar(namesize, name, vendor);
        }
        arm_efirt_md_exit();
        mutex_exit(&efi_lock);

        return status;
}

efi_status
arm_efirt_setvar(uint16_t *name, struct uuid *vendor, uint32_t attrib,
    u_long datasize, void *data)
{
        efi_status status = EFI_DEVICE_ERROR;

        if (RT == NULL || RT->rt_setvar == NULL) {
                return EFI_UNSUPPORTED;
        }

        mutex_enter(&efi_lock);
        if (arm_efirt_md_enter() == 0) {
                status = RT->rt_setvar(name, vendor, attrib, datasize, data);
        }
        arm_efirt_md_exit();
        mutex_exit(&efi_lock);

        return status;
}

int
arm_efirt_reset(enum efi_reset type)
{
        static int reset_called = false;
        int error;

        if (RT == NULL || RT->rt_reset == NULL)
                return ENXIO;

        mutex_enter(&efi_lock);
        if (reset_called == false) {
                reset_called = true;
                if ((error = arm_efirt_md_enter()) == 0) {
                        if (RT->rt_reset(type, 0, 0, NULL) != 0) {
                                error = EIO;
                        }
                }
                arm_efirt_md_exit();
        } else {
                error = EPERM;
        }
        mutex_exit(&efi_lock);

        return error;
}