/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2021-05-18     Bernard      port from FreeBSD
 */

/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2019 Mitchell Horne <mhorne@FreeBSD.org>
 *
 * 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 AUTHOR 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 AUTHOR 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 <rtthread.h>

#include <cpu.h>
#include <sbi.h>


/* SBI Implementation-Specific Definitions */
#define OPENSBI_VERSION_MAJOR_OFFSET 16
#define OPENSBI_VERSION_MINOR_MASK 0xFFFF

unsigned long sbi_spec_version;
unsigned long sbi_impl_id;
unsigned long sbi_impl_version;

bool has_time_extension = false;
bool has_ipi_extension = false;
bool has_rfnc_extension = false;
bool has_srst_extension = false;

static rt_bool_t sbi_cpu_mask_test(const unsigned long *cpu_mask, int cpu)
{
    const int bits_per_word = sizeof(*cpu_mask) * 8;

    return !!(cpu_mask[cpu / bits_per_word] &
            (1UL << (cpu % bits_per_word)));
}

static struct sbi_ret sbi_get_spec_version(void)
{
    return (SBI_CALL0(SBI_EXT_ID_BASE, SBI_BASE_GET_SPEC_VERSION));
}

static struct sbi_ret sbi_get_impl_id(void)
{
    return (SBI_CALL0(SBI_EXT_ID_BASE, SBI_BASE_GET_IMPL_ID));
}

static struct sbi_ret sbi_get_impl_version(void)
{
    return (SBI_CALL0(SBI_EXT_ID_BASE, SBI_BASE_GET_IMPL_VERSION));
}

void sbi_print_version(void)
{
    uint32_t major;
    uint32_t minor;

    /* For legacy SBI implementations. */
    if (sbi_spec_version == 0)
    {
        rt_kprintf("SBI: Unknown (Legacy) Implementation\n");
        rt_kprintf("SBI Specification Version: 0.1\n");
        return;
    }

    switch (sbi_impl_id)
    {
    case (SBI_IMPL_ID_BBL):
        rt_kprintf("SBI: Berkely Boot Loader %lu\n", sbi_impl_version);
        break;
    case (SBI_IMPL_ID_XVISOR):
        rt_kprintf("SBI: eXtensible Versatile hypervISOR %lu\n",
                   sbi_impl_version);
        break;
    case (SBI_IMPL_ID_KVM):
        rt_kprintf("SBI: Kernel-based Virtual Machine %lu\n", sbi_impl_version);
        break;
    case (SBI_IMPL_ID_RUSTSBI):
        rt_kprintf("SBI: RustSBI %lu\n", sbi_impl_version);
        break;
    case (SBI_IMPL_ID_DIOSIX):
        rt_kprintf("SBI: Diosix %lu\n", sbi_impl_version);
        break;
    case (SBI_IMPL_ID_OPENSBI):
        major = sbi_impl_version >> OPENSBI_VERSION_MAJOR_OFFSET;
        minor = sbi_impl_version & OPENSBI_VERSION_MINOR_MASK;
        rt_kprintf("SBI: OpenSBI v%u.%u\n", major, minor);
        break;
    default:
        rt_kprintf("SBI: Unrecognized Implementation: %lu\n", sbi_impl_id);
        break;
    }

    major = (sbi_spec_version & SBI_SPEC_VERS_MAJOR_MASK) >>
            SBI_SPEC_VERS_MAJOR_OFFSET;
    minor = (sbi_spec_version & SBI_SPEC_VERS_MINOR_MASK);
    rt_kprintf("SBI Specification Version: %u.%u\n", major, minor);
}

void sbi_set_timer(uint64_t val)
{
    struct sbi_ret ret;

    /* Use the TIME legacy replacement extension, if available. */
    if (has_time_extension)
    {
    #if __riscv_xlen == 32
        ret = SBI_CALL2(SBI_EXT_ID_TIME, SBI_TIME_SET_TIMER,
                (rt_uint32_t)val, (rt_uint32_t)(val >> 32));
    #else
        ret = SBI_CALL1(SBI_EXT_ID_TIME, SBI_TIME_SET_TIMER, val);
    #endif
        RT_ASSERT(ret.error == SBI_SUCCESS);
    }
    else
    {
    #if __riscv_xlen == 32
        (void)SBI_CALL2(SBI_SET_TIMER, 0,
                (rt_uint32_t)val, (rt_uint32_t)(val >> 32));
    #else
        (void)SBI_CALL1(SBI_SET_TIMER, 0, val);
    #endif
    }
}

static rt_bool_t sbi_cpu_mask_to_hart_mask(const unsigned long *cpu_mask,
        unsigned long *hart_mask)
{
    *hart_mask = 0;

    for (int cpu = 0; cpu < RT_CPUS_NR; ++cpu)
    {
        rt_ubase_t hartid;

        if (cpu_mask && !sbi_cpu_mask_test(cpu_mask, cpu))
        {
            continue;
        }
        if (!riscv_cpu_id_available(cpu))
        {
            continue;
        }

        hartid = riscv_cpu_id_to_hartid(cpu);
        if (hartid >= sizeof(*hart_mask) * 8)
        {
            return RT_FALSE;
        }

        *hart_mask |= 1UL << hartid;
    }

    return RT_TRUE;
}

void sbi_send_ipi(const unsigned long *cpu_mask)
{
    struct sbi_ret ret;

    /* Use the IPI legacy replacement extension, if available. */
    if (has_ipi_extension)
    {
        if (!cpu_mask)
        {
            ret = SBI_CALL2(SBI_EXT_ID_IPI, SBI_IPI_SEND_IPI,
                    0, SBI_HART_MASK_BASE_ALL);
            RT_ASSERT(ret.error == SBI_SUCCESS);
        }
        else
        {
            for (int cpu = 0; cpu < RT_CPUS_NR; ++cpu)
            {
                rt_ubase_t hartid;

                if (!sbi_cpu_mask_test(cpu_mask, cpu) ||
                    !riscv_cpu_id_available(cpu))
                {
                    continue;
                }

                hartid = riscv_cpu_id_to_hartid(cpu);
                ret = SBI_CALL2(SBI_EXT_ID_IPI, SBI_IPI_SEND_IPI, 1, hartid);
                RT_ASSERT(ret.error == SBI_SUCCESS);
            }
        }
    }
    else
    {
        unsigned long hart_mask;

        if (!sbi_cpu_mask_to_hart_mask(cpu_mask, &hart_mask))
        {
            RT_ASSERT(0);
            return;
        }
        (void)SBI_CALL1(SBI_SEND_IPI, 0, (rt_ubase_t)&hart_mask);
    }
}

void sbi_remote_fence_i(const unsigned long *cpu_mask)
{
    struct sbi_ret ret;

    /* Use the RFENCE legacy replacement extension, if available. */
    if (has_rfnc_extension)
    {
        if (!cpu_mask)
        {
            ret = SBI_CALL2(SBI_EXT_ID_RFNC, SBI_RFNC_REMOTE_FENCE_I,
                    0, SBI_HART_MASK_BASE_ALL);
            RT_ASSERT(ret.error == SBI_SUCCESS);
        }
        else
        {
            for (int cpu = 0; cpu < RT_CPUS_NR; ++cpu)
            {
                rt_ubase_t hartid;

                if (!sbi_cpu_mask_test(cpu_mask, cpu) ||
                    !riscv_cpu_id_available(cpu))
                {
                    continue;
                }

                hartid = riscv_cpu_id_to_hartid(cpu);
                ret = SBI_CALL2(SBI_EXT_ID_RFNC, SBI_RFNC_REMOTE_FENCE_I, 1, hartid);
                RT_ASSERT(ret.error == SBI_SUCCESS);
            }
        }
    }
    else
    {
        unsigned long hart_mask;

        if (!sbi_cpu_mask_to_hart_mask(cpu_mask, &hart_mask))
        {
            RT_ASSERT(0);
            return;
        }
        (void)SBI_CALL1(SBI_REMOTE_FENCE_I, 0, (rt_ubase_t)&hart_mask);
    }
}

int sbi_remote_sfence_vma(const unsigned long *hart_mask,
                          const unsigned long hart_mask_base,
                          unsigned long start, unsigned long size)
{
    struct sbi_ret ret = {.error = SBI_SUCCESS};

    /* Use the RFENCE legacy replacement extension, if available. */
    if (has_rfnc_extension)
    {
        ret = SBI_CALL4(SBI_EXT_ID_RFNC, SBI_RFNC_REMOTE_SFENCE_VMA, *hart_mask,
                        hart_mask_base, start, size);
    }
    else
    {
        /* Legacy SBI uses a NULL mask to address all harts. */
        if (hart_mask_base == SBI_HART_MASK_BASE_ALL)
        {
            hart_mask = RT_NULL;
        }
        (void)SBI_CALL3(SBI_REMOTE_SFENCE_VMA, 0, (rt_ubase_t)hart_mask, start,
                        size);
    }
    return ret.error;
}

void sbi_remote_sfence_vma_asid(const unsigned long *hart_mask,
                                unsigned long start, unsigned long size,
                                unsigned long asid)
{
    struct sbi_ret ret;

    /* Use the RFENCE legacy replacement extension, if available. */
    if (has_rfnc_extension)
    {
        ret = SBI_CALL5(SBI_EXT_ID_RFNC, SBI_RFNC_REMOTE_SFENCE_VMA_ASID,
                        *hart_mask, 0, start, size, asid);
        RT_ASSERT(ret.error == SBI_SUCCESS);
    }
    else
    {
        (void)SBI_CALL4(SBI_REMOTE_SFENCE_VMA_ASID, 0, (rt_ubase_t)hart_mask,
                        start, size, asid);
    }
}

int sbi_hsm_hart_start(unsigned long hart, unsigned long start_addr,
                       unsigned long priv)
{
    struct sbi_ret ret;

    ret = SBI_CALL3(SBI_EXT_ID_HSM, SBI_HSM_HART_START, hart, start_addr, priv);
    return (ret.error != 0 ? (int)ret.error : 0);
}

void sbi_hsm_hart_stop(void)
{
    (void)SBI_CALL0(SBI_EXT_ID_HSM, SBI_HSM_HART_STOP);
}

int sbi_hsm_hart_status(unsigned long hart)
{
    struct sbi_ret ret;

    ret = SBI_CALL1(SBI_EXT_ID_HSM, SBI_HSM_HART_STATUS, hart);

    return (ret.error != 0 ? (int)ret.error : (int)ret.value);
}

static void sbi_srst_reset(unsigned long type, unsigned long reason)
{
    SBI_CALL2(SBI_EXT_ID_SRST, SBI_SRST_FID_RESET, type, reason);
}

void sbi_srst_reboot(unsigned long reset_type)
{
    sbi_srst_reset(reset_type, SBI_SRST_RESET_REASON_NONE);
}

void sbi_srst_power_off(void)
{
    sbi_srst_reset(SBI_SRST_RESET_TYPE_SHUTDOWN, SBI_SRST_RESET_REASON_NONE);
}

void sbi_init(void)
{
    struct sbi_ret sret;

    /*
     * Get the spec version. For legacy SBI implementations this will
     * return an error, otherwise it is guaranteed to succeed.
     */
    sret = sbi_get_spec_version();
    if (sret.error != 0)
    {
        /* We are running a legacy SBI implementation. */
        sbi_spec_version = 0;
        return;
    }

    /* Set the SBI implementation info. */
    sbi_spec_version = sret.value;
    sbi_impl_id = sbi_get_impl_id().value;
    sbi_impl_version = sbi_get_impl_version().value;

    /* Probe for legacy replacement extensions. */
    if (sbi_probe_extension(SBI_EXT_ID_TIME) != 0)
        has_time_extension = true;
    if (sbi_probe_extension(SBI_EXT_ID_IPI) != 0)
        has_ipi_extension = true;
    if (sbi_probe_extension(SBI_EXT_ID_RFNC) != 0)
        has_rfnc_extension = true;
    if (sbi_probe_extension(SBI_EXT_ID_SRST) != 0)
        has_srst_extension = true;
}