265 lines
7.7 KiB
C
265 lines
7.7 KiB
C
/*
|
|
* 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 "sbi.h"
|
|
#include <rtthread.h>
|
|
#include <stdbool.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;
|
|
|
|
static bool has_time_extension = false;
|
|
static bool has_ipi_extension = false;
|
|
static bool has_rfnc_extension = false;
|
|
|
|
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)
|
|
{
|
|
unsigned int major;
|
|
unsigned int 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)
|
|
{
|
|
ret = SBI_CALL1(SBI_EXT_ID_TIME, SBI_TIME_SET_TIMER, val);
|
|
RT_ASSERT(ret.error == SBI_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
(void)SBI_CALL1(SBI_SET_TIMER, 0, val);
|
|
}
|
|
}
|
|
|
|
void sbi_send_ipi(const unsigned long *hart_mask)
|
|
{
|
|
struct sbi_ret ret;
|
|
|
|
/* Use the IPI legacy replacement extension, if available. */
|
|
if (has_ipi_extension)
|
|
{
|
|
ret = SBI_CALL2(SBI_EXT_ID_IPI, SBI_IPI_SEND_IPI, *hart_mask, 0);
|
|
RT_ASSERT(ret.error == SBI_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
(void)SBI_CALL1(SBI_SEND_IPI, 0, (uint64_t)hart_mask);
|
|
}
|
|
}
|
|
|
|
void sbi_remote_fence_i(const unsigned long *hart_mask)
|
|
{
|
|
struct sbi_ret ret;
|
|
|
|
/* Use the RFENCE legacy replacement extension, if available. */
|
|
if (has_rfnc_extension)
|
|
{
|
|
ret =
|
|
SBI_CALL2(SBI_EXT_ID_RFNC, SBI_RFNC_REMOTE_FENCE_I, *hart_mask, 0);
|
|
RT_ASSERT(ret.error == SBI_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
(void)SBI_CALL1(SBI_REMOTE_FENCE_I, 0, (uint64_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
|
|
{
|
|
(void)SBI_CALL3(SBI_REMOTE_SFENCE_VMA, 0, (uint64_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, (uint64_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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void rt_hw_console_output(const char *str)
|
|
{
|
|
while (*str)
|
|
{
|
|
sbi_console_putchar(*str++);
|
|
}
|
|
}
|