/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _X86_ENCLS_H
#define _X86_ENCLS_H

#include <linux/bitops.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/rwsem.h>
#include <linux/types.h>
#include <asm/asm.h>
#include <asm/traps.h>
#include "sgx.h"

/* Retrieve the encoded trapnr from the specified return code. */
#define ENCLS_TRAPNR(r) ((r) & ~SGX_ENCLS_FAULT_FLAG)

/* Issue a WARN() about an ENCLS function. */
#define ENCLS_WARN(r, name) {                                             \
        do {                                                              \
                int _r = (r);                                             \
                WARN_ONCE(_r, "%s returned %d (0x%x)\n", (name), _r, _r); \
        } while (0);                                                      \
}

/*
 * encls_faulted() - Check if an ENCLS leaf faulted given an error code
 * @ret:        the return value of an ENCLS leaf function call
 *
 * Return:
 * - true:      ENCLS leaf faulted.
 * - false:     Otherwise.
 */
static inline bool encls_faulted(int ret)
{
        return ret & SGX_ENCLS_FAULT_FLAG;
}

/**
 * encls_failed() - Check if an ENCLS function failed
 * @ret:        the return value of an ENCLS function call
 *
 * Check if an ENCLS function failed. This happens when the function causes a
 * fault that is not caused by an EPCM conflict or when the function returns a
 * non-zero value.
 */
static inline bool encls_failed(int ret)
{
        if (encls_faulted(ret))
                return ENCLS_TRAPNR(ret) != X86_TRAP_PF;

        return !!ret;
}

/**
 * __encls_ret_N - encode an ENCLS function that returns an error code in EAX
 * @rax:        function number
 * @inputs:     asm inputs for the function
 *
 * Emit assembly for an ENCLS function that returns an error code, e.g. EREMOVE.
 * And because SGX isn't complex enough as it is, function that return an error
 * code also modify flags.
 *
 * Return:
 *      0 on success,
 *      SGX error code on failure
 */
#define __encls_ret_N(rax, inputs...)                           \
        ({                                                      \
        int ret;                                                \
        asm volatile(                                           \
        "1: encls\n"                                            \
        "2:\n"                                                  \
        _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_FAULT_SGX)            \
        : "=a"(ret)                                             \
        : "a"(rax), inputs                                      \
        : "memory", "cc");                                      \
        ret;                                                    \
        })

#define __encls_ret_1(rax, rcx)         \
        ({                              \
        __encls_ret_N(rax, "c"(rcx));   \
        })

#define __encls_ret_2(rax, rbx, rcx)            \
        ({                                      \
        __encls_ret_N(rax, "b"(rbx), "c"(rcx)); \
        })

#define __encls_ret_3(rax, rbx, rcx, rdx)                       \
        ({                                                      \
        __encls_ret_N(rax, "b"(rbx), "c"(rcx), "d"(rdx));       \
        })

/**
 * __encls_N - encode an ENCLS function that doesn't return an error code
 * @rax:        function number
 * @rbx_out:    optional output variable
 * @inputs:     asm inputs for the function
 *
 * Emit assembly for an ENCLS function that does not return an error code, e.g.
 * ECREATE.  Leaves without error codes either succeed or fault.  @rbx_out is an
 * optional parameter for use by EDGBRD, which returns the requested value in
 * RBX.
 *
 * Return:
 *   0 on success,
 *   trapnr with SGX_ENCLS_FAULT_FLAG set on fault
 */
#define __encls_N(rax, rbx_out, inputs...)                      \
        ({                                                      \
        int ret;                                                \
        asm volatile(                                           \
        "1: encls\n\t"                                          \
        "xor %%eax,%%eax\n"                                     \
        "2:\n"                                                  \
        _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_FAULT_SGX)            \
        : "=a"(ret), "=b"(rbx_out)                              \
        : "a"(rax), inputs                                      \
        : "memory");                                            \
        ret;                                                    \
        })

#define __encls_2(rax, rbx, rcx)                                \
        ({                                                      \
        unsigned long ign_rbx_out;                              \
        __encls_N(rax, ign_rbx_out, "b"(rbx), "c"(rcx));        \
        })

#define __encls_1_1(rax, data, rcx)                     \
        ({                                              \
        unsigned long rbx_out;                          \
        int ret = __encls_N(rax, rbx_out, "c"(rcx));    \
        if (!ret)                                       \
                data = rbx_out;                         \
        ret;                                            \
        })

/* Initialize an EPC page into an SGX Enclave Control Structure (SECS) page. */
static inline int __ecreate(struct sgx_pageinfo *pginfo, void *secs)
{
        return __encls_2(ECREATE, pginfo, secs);
}

/* Hash a 256 byte region of an enclave page to SECS:MRENCLAVE. */
static inline int __eextend(void *secs, void *addr)
{
        return __encls_2(EEXTEND, secs, addr);
}

/*
 * Associate an EPC page to an enclave either as a REG or TCS page
 * populated with the provided data.
 */
static inline int __eadd(struct sgx_pageinfo *pginfo, void *addr)
{
        return __encls_2(EADD, pginfo, addr);
}

/* Finalize enclave build, initialize enclave for user code execution. */
static inline int __einit(void *sigstruct, void *token, void *secs)
{
        return __encls_ret_3(EINIT, sigstruct, secs, token);
}

/* Disassociate EPC page from its enclave and mark it as unused. */
static inline int __eremove(void *addr)
{
        return __encls_ret_1(EREMOVE, addr);
}

/* Copy data to an EPC page belonging to a debug enclave. */
static inline int __edbgwr(void *addr, unsigned long *data)
{
        return __encls_2(EDGBWR, *data, addr);
}

/* Copy data from an EPC page belonging to a debug enclave. */
static inline int __edbgrd(void *addr, unsigned long *data)
{
        return __encls_1_1(EDGBRD, *data, addr);
}

/* Track that software has completed the required TLB address clears. */
static inline int __etrack(void *addr)
{
        return __encls_ret_1(ETRACK, addr);
}

/* Load, verify, and unblock an EPC page. */
static inline int __eldu(struct sgx_pageinfo *pginfo, void *addr,
                         void *va)
{
        return __encls_ret_3(ELDU, pginfo, addr, va);
}

/* Make EPC page inaccessible to enclave, ready to be written to memory. */
static inline int __eblock(void *addr)
{
        return __encls_ret_1(EBLOCK, addr);
}

/* Initialize an EPC page into a Version Array (VA) page. */
static inline int __epa(void *addr)
{
        unsigned long rbx = SGX_PAGE_TYPE_VA;

        return __encls_2(EPA, rbx, addr);
}

/* Invalidate an EPC page and write it out to main memory. */
static inline int __ewb(struct sgx_pageinfo *pginfo, void *addr,
                        void *va)
{
        return __encls_ret_3(EWB, pginfo, addr, va);
}

/* Restrict the EPCM permissions of an EPC page. */
static inline int __emodpr(struct sgx_secinfo *secinfo, void *addr)
{
        return __encls_ret_2(EMODPR, secinfo, addr);
}

/* Change the type of an EPC page. */
static inline int __emodt(struct sgx_secinfo *secinfo, void *addr)
{
        return __encls_ret_2(EMODT, secinfo, addr);
}

/* Zero a page of EPC memory and add it to an initialized enclave. */
static inline int __eaug(struct sgx_pageinfo *pginfo, void *addr)
{
        return __encls_2(EAUG, pginfo, addr);
}

/* Attempt to update CPUSVN at runtime. */
static inline int __eupdatesvn(void)
{
        return __encls_ret_1(EUPDATESVN, "");
}
#endif /* _X86_ENCLS_H */