Mirrors/opensbi
4
0
Fork 1
mirror of https://github.com/riscv-software-src/opensbi.git synced 2025-12-17 04:21:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

lib: sbi: Replace sbi_hart_pmp_xyz() and sbi_hart_map/unmap_addr()

Browse Source 
The sbi_hart_pmp_xyz() and sbi_hart_map/unmap_addr() functions can
now be replaced by various sbi_hart_protection_xyz() functions.

Signed-off-by: Anup Patel <apatel@ventanamicro.com>
Link: https://lore.kernel.org/r/20251209135235.423391-5-apatel@ventanamicro.com
Signed-off-by: Anup Patel <anup@brainfault.org>
This commit is contained in:
Anup Patel
2025-12-09 19:22:34 +05:30
committed by Anup Patel
parent b6da690ffb
commit 42139bb9b7
9 changed files with 58 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/sbi/sbi_hart.h
View File

@@ -117,8 +117,8 @@ enum sbi_hart_csrs {
* When shared memory access is required, the physical address * When shared memory access is required, the physical address
* should be programmed into the first PMP entry with R/W * should be programmed into the first PMP entry with R/W
* permissions to the M-mode. Once the work is done, it should be * permissions to the M-mode. Once the work is done, it should be
* unmapped. sbi_hart_map_saddr/sbi_hart_unmap_saddr function * unmapped. sbi_hart_protection_map_range/sbi_hart_protection_unmap_range
* pair should be used to map/unmap the shared memory. * function pair should be used to map/unmap the shared memory.
*/ */
#define SBI_SMEPMP_RESV_ENTRY 0 #define SBI_SMEPMP_RESV_ENTRY 0
@@ -149,10 +149,6 @@ unsigned int sbi_hart_pmp_log2gran(struct sbi_scratch *scratch);
unsigned int sbi_hart_pmp_addrbits(struct sbi_scratch *scratch); unsigned int sbi_hart_pmp_addrbits(struct sbi_scratch *scratch);
unsigned int sbi_hart_mhpm_bits(struct sbi_scratch *scratch); unsigned int sbi_hart_mhpm_bits(struct sbi_scratch *scratch);
bool sbi_hart_smepmp_is_fw_region(unsigned int pmp_idx); bool sbi_hart_smepmp_is_fw_region(unsigned int pmp_idx);
int sbi_hart_pmp_configure(struct sbi_scratch *scratch);
void sbi_hart_pmp_unconfigure(struct sbi_scratch *scratch);
int sbi_hart_map_saddr(unsigned long base, unsigned long size);
int sbi_hart_unmap_saddr(void);
int sbi_hart_priv_version(struct sbi_scratch *scratch); int sbi_hart_priv_version(struct sbi_scratch *scratch);
void sbi_hart_get_priv_version_str(struct sbi_scratch *scratch, void sbi_hart_get_priv_version_str(struct sbi_scratch *scratch,
char *version_str, int nvstr); char *version_str, int nvstr);

29
lib/sbi/sbi_dbtr.c
View File

@@ -16,6 +16,7 @@
#include <sbi/sbi_trap.h> #include <sbi/sbi_trap.h>
#include <sbi/sbi_dbtr.h> #include <sbi/sbi_dbtr.h>
#include <sbi/sbi_heap.h> #include <sbi/sbi_heap.h>
#include <sbi/sbi_hart_protection.h>
#include <sbi/riscv_encoding.h> #include <sbi/riscv_encoding.h>
#include <sbi/riscv_asm.h> #include <sbi/riscv_asm.h>
@@ -558,7 +559,7 @@ int sbi_dbtr_read_trig(unsigned long smode,
shmem_base = hart_shmem_base(hs); shmem_base = hart_shmem_base(hs);
sbi_hart_map_saddr((unsigned long)shmem_base, sbi_hart_protection_map_range((unsigned long)shmem_base,
trig_count * sizeof(*entry)); trig_count * sizeof(*entry));
for_each_trig_entry(shmem_base, trig_count, typeof(*entry), entry) { for_each_trig_entry(shmem_base, trig_count, typeof(*entry), entry) {
xmit = &entry->data; xmit = &entry->data;
@@ -572,7 +573,8 @@ int sbi_dbtr_read_trig(unsigned long smode,
xmit->tdata2 = cpu_to_lle(trig->tdata2); xmit->tdata2 = cpu_to_lle(trig->tdata2);
xmit->tdata3 = cpu_to_lle(trig->tdata3); xmit->tdata3 = cpu_to_lle(trig->tdata3);
} }
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base,
trig_count * sizeof(*entry));
return SBI_SUCCESS; return SBI_SUCCESS;
} }
@@ -596,7 +598,7 @@ int sbi_dbtr_install_trig(unsigned long smode,
return SBI_ERR_NO_SHMEM; return SBI_ERR_NO_SHMEM;
shmem_base = hart_shmem_base(hs); shmem_base = hart_shmem_base(hs);
sbi_hart_map_saddr((unsigned long)shmem_base, sbi_hart_protection_map_range((unsigned long)shmem_base,
trig_count * sizeof(*entry)); trig_count * sizeof(*entry));
/* Check requested triggers configuration */ /* Check requested triggers configuration */
@@ -606,20 +608,23 @@ int sbi_dbtr_install_trig(unsigned long smode,
if (!dbtr_trigger_supported(TDATA1_GET_TYPE(ctrl))) { if (!dbtr_trigger_supported(TDATA1_GET_TYPE(ctrl))) {
*out = _idx; *out = _idx;
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base,
trig_count * sizeof(*entry));
return SBI_ERR_FAILED; return SBI_ERR_FAILED;
} }
if (!dbtr_trigger_valid(TDATA1_GET_TYPE(ctrl), ctrl)) { if (!dbtr_trigger_valid(TDATA1_GET_TYPE(ctrl), ctrl)) {
*out = _idx; *out = _idx;
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base,
trig_count * sizeof(*entry));
return SBI_ERR_FAILED; return SBI_ERR_FAILED;
} }
} }
if (hs->available_trigs < trig_count) { if (hs->available_trigs < trig_count) {
*out = hs->available_trigs; *out = hs->available_trigs;
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base,
trig_count * sizeof(*entry));
return SBI_ERR_FAILED; return SBI_ERR_FAILED;
} }
@@ -639,7 +644,9 @@ int sbi_dbtr_install_trig(unsigned long smode,
xmit->idx = cpu_to_lle(trig->index); xmit->idx = cpu_to_lle(trig->index);
} }
sbi_hart_unmap_saddr();
sbi_hart_protection_unmap_range((unsigned long)shmem_base,
trig_count * sizeof(*entry));
return SBI_SUCCESS; return SBI_SUCCESS;
} }
@@ -712,23 +719,23 @@ int sbi_dbtr_update_trig(unsigned long smode,
return SBI_ERR_BAD_RANGE; return SBI_ERR_BAD_RANGE;
for_each_trig_entry(shmem_base, trig_count, typeof(*entry), entry) { for_each_trig_entry(shmem_base, trig_count, typeof(*entry), entry) {
sbi_hart_map_saddr((unsigned long)entry, sizeof(*entry)); sbi_hart_protection_map_range((unsigned long)entry, sizeof(*entry));
trig_idx = entry->id.idx; trig_idx = entry->id.idx;
if (trig_idx >= hs->total_trigs) { if (trig_idx >= hs->total_trigs) {
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)entry, sizeof(*entry));
return SBI_ERR_INVALID_PARAM; return SBI_ERR_INVALID_PARAM;
} }
trig = INDEX_TO_TRIGGER(trig_idx); trig = INDEX_TO_TRIGGER(trig_idx);
if (!(trig->state & RV_DBTR_BIT_MASK(TS, MAPPED))) { if (!(trig->state & RV_DBTR_BIT_MASK(TS, MAPPED))) {
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)entry, sizeof(*entry));
return SBI_ERR_FAILED; return SBI_ERR_FAILED;
} }
dbtr_trigger_setup(trig, &entry->data); dbtr_trigger_setup(trig, &entry->data);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)entry, sizeof(*entry));
dbtr_trigger_enable(trig); dbtr_trigger_enable(trig);
} }

5
lib/sbi/sbi_domain_context.c
View File

@@ -10,6 +10,7 @@
#include <sbi/sbi_console.h> #include <sbi/sbi_console.h>
#include <sbi/sbi_hsm.h> #include <sbi/sbi_hsm.h>
#include <sbi/sbi_hart.h> #include <sbi/sbi_hart.h>
#include <sbi/sbi_hart_protection.h>
#include <sbi/sbi_heap.h> #include <sbi/sbi_heap.h>
#include <sbi/sbi_scratch.h> #include <sbi/sbi_scratch.h>
#include <sbi/sbi_string.h> #include <sbi/sbi_string.h>
@@ -122,8 +123,8 @@ static int switch_to_next_domain_context(struct hart_context *ctx,
spin_unlock(&target_dom->assigned_harts_lock); spin_unlock(&target_dom->assigned_harts_lock);
/* Reconfigure PMP settings for the new domain */ /* Reconfigure PMP settings for the new domain */
sbi_hart_pmp_unconfigure(scratch); sbi_hart_protection_unconfigure(scratch);
sbi_hart_pmp_configure(scratch); sbi_hart_protection_configure(scratch);
/* Save current CSR context and restore target domain's CSR context */ /* Save current CSR context and restore target domain's CSR context */
ctx->sstatus = csr_swap(CSR_SSTATUS, dom_ctx->sstatus); ctx->sstatus = csr_swap(CSR_SSTATUS, dom_ctx->sstatus);

6
lib/sbi/sbi_ecall_dbcn.c
View File

@@ -14,7 +14,7 @@
#include <sbi/sbi_ecall_interface.h> #include <sbi/sbi_ecall_interface.h>
#include <sbi/sbi_trap.h> #include <sbi/sbi_trap.h>
#include <sbi/riscv_asm.h> #include <sbi/riscv_asm.h>
#include <sbi/sbi_hart.h> #include <sbi/sbi_hart_protection.h>
static int sbi_ecall_dbcn_handler(unsigned long extid, unsigned long funcid, static int sbi_ecall_dbcn_handler(unsigned long extid, unsigned long funcid,
struct sbi_trap_regs *regs, struct sbi_trap_regs *regs,
@@ -46,12 +46,12 @@ static int sbi_ecall_dbcn_handler(unsigned long extid, unsigned long funcid,
regs->a1, regs->a0, smode, regs->a1, regs->a0, smode,
SBI_DOMAIN_READ|SBI_DOMAIN_WRITE)) SBI_DOMAIN_READ|SBI_DOMAIN_WRITE))
return SBI_ERR_INVALID_PARAM; return SBI_ERR_INVALID_PARAM;
sbi_hart_map_saddr(regs->a1, regs->a0); sbi_hart_protection_map_range(regs->a1, regs->a0);
if (funcid == SBI_EXT_DBCN_CONSOLE_WRITE) if (funcid == SBI_EXT_DBCN_CONSOLE_WRITE)
out->value = sbi_nputs((const char *)regs->a1, regs->a0); out->value = sbi_nputs((const char *)regs->a1, regs->a0);
else else
out->value = sbi_ngets((char *)regs->a1, regs->a0); out->value = sbi_ngets((char *)regs->a1, regs->a0);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range(regs->a1, regs->a0);
return 0; return 0;
case SBI_EXT_DBCN_CONSOLE_WRITE_BYTE: case SBI_EXT_DBCN_CONSOLE_WRITE_BYTE:
sbi_putc(regs->a0); sbi_putc(regs->a0);

34
lib/sbi/sbi_hart.c
View File

@@ -561,39 +561,7 @@ static int sbi_hart_oldpmp_configure(struct sbi_scratch *scratch)
return 0; return 0;
} }
int sbi_hart_map_saddr(unsigned long addr, unsigned long size) static void sbi_hart_pmp_unconfigure(struct sbi_scratch *scratch)
{
struct sbi_scratch *scratch = sbi_scratch_thishart_ptr();
/* If Smepmp is not supported no special mapping is required */
if (!sbi_hart_has_extension(scratch, SBI_HART_EXT_SMEPMP))
return SBI_OK;
return sbi_hart_smepmp_map_range(scratch, addr, size);
}
int sbi_hart_unmap_saddr(void)
{
struct sbi_scratch *scratch = sbi_scratch_thishart_ptr();
if (!sbi_hart_has_extension(scratch, SBI_HART_EXT_SMEPMP))
return SBI_OK;
return sbi_hart_smepmp_unmap_range(scratch, 0, 0);
}
int sbi_hart_pmp_configure(struct sbi_scratch *scratch)
{
if (!sbi_hart_pmp_count(scratch))
return 0;
if (sbi_hart_has_extension(scratch, SBI_HART_EXT_SMEPMP))
return sbi_hart_smepmp_configure(scratch);
else
return sbi_hart_oldpmp_configure(scratch);
}
void sbi_hart_pmp_unconfigure(struct sbi_scratch *scratch)
{ {
int i, pmp_count = sbi_hart_pmp_count(scratch); int i, pmp_count = sbi_hart_pmp_count(scratch);

16
lib/sbi/sbi_init.c
View File

@@ -389,12 +389,12 @@ static void __noreturn init_coldboot(struct sbi_scratch *scratch, u32 hartid)
} }
/* /*
* Configure PMP at last because if SMEPMP is detected, * Configure hart isolation at last because if SMEPMP is,
* M-mode access to the S/U space will be rescinded. * detected, M-mode access to the S/U space will be rescinded.
*/ */
rc = sbi_hart_pmp_configure(scratch); rc = sbi_hart_protection_configure(scratch);
if (rc) { if (rc) {
sbi_printf("%s: PMP configure failed (error %d)\n", sbi_printf("%s: hart isolation configure failed (error %d)\n",
__func__, rc); __func__, rc);
sbi_hart_hang(); sbi_hart_hang();
} }
@@ -468,10 +468,10 @@ static void __noreturn init_warm_startup(struct sbi_scratch *scratch,
sbi_hart_hang(); sbi_hart_hang();
/* /*
* Configure PMP at last because if SMEPMP is detected, * Configure hart isolation at last because if SMEPMP is,
* M-mode access to the S/U space will be rescinded. * detected, M-mode access to the S/U space will be rescinded.
*/ */
rc = sbi_hart_pmp_configure(scratch); rc = sbi_hart_protection_configure(scratch);
if (rc) if (rc)
sbi_hart_hang(); sbi_hart_hang();
@@ -492,7 +492,7 @@ static void __noreturn init_warm_resume(struct sbi_scratch *scratch,
if (rc) if (rc)
sbi_hart_hang(); sbi_hart_hang();
rc = sbi_hart_pmp_configure(scratch); rc = sbi_hart_protection_configure(scratch);
if (rc) if (rc)
sbi_hart_hang(); sbi_hart_hang();

25
lib/sbi/sbi_mpxy.c
View File

@@ -11,6 +11,7 @@
#include <sbi/sbi_domain.h> #include <sbi/sbi_domain.h>
#include <sbi/sbi_error.h> #include <sbi/sbi_error.h>
#include <sbi/sbi_hart.h> #include <sbi/sbi_hart.h>
#include <sbi/sbi_hart_protection.h>
#include <sbi/sbi_heap.h> #include <sbi/sbi_heap.h>
#include <sbi/sbi_platform.h> #include <sbi/sbi_platform.h>
#include <sbi/sbi_mpxy.h> #include <sbi/sbi_mpxy.h>
@@ -375,10 +376,10 @@ int sbi_mpxy_set_shmem(unsigned long shmem_phys_lo,
if (flags == SBI_EXT_MPXY_SHMEM_FLAG_OVERWRITE_RETURN) { if (flags == SBI_EXT_MPXY_SHMEM_FLAG_OVERWRITE_RETURN) {
ret_buf = (unsigned long *)(ulong)SHMEM_PHYS_ADDR(shmem_phys_hi, ret_buf = (unsigned long *)(ulong)SHMEM_PHYS_ADDR(shmem_phys_hi,
shmem_phys_lo); shmem_phys_lo);
sbi_hart_map_saddr((unsigned long)ret_buf, mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)ret_buf, mpxy_shmem_size);
ret_buf[0] = cpu_to_lle(ms->shmem.shmem_addr_lo); ret_buf[0] = cpu_to_lle(ms->shmem.shmem_addr_lo);
ret_buf[1] = cpu_to_lle(ms->shmem.shmem_addr_hi); ret_buf[1] = cpu_to_lle(ms->shmem.shmem_addr_hi);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)ret_buf, mpxy_shmem_size);
} }
/** Setup the new shared memory */ /** Setup the new shared memory */
@@ -407,7 +408,7 @@ int sbi_mpxy_get_channel_ids(u32 start_index)
return SBI_ERR_INVALID_PARAM; return SBI_ERR_INVALID_PARAM;
shmem_base = hart_shmem_base(ms); shmem_base = hart_shmem_base(ms);
sbi_hart_map_saddr((unsigned long)hart_shmem_base(ms), mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)hart_shmem_base(ms), mpxy_shmem_size);
/** number of channel ids which can be stored in shmem adjusting /** number of channel ids which can be stored in shmem adjusting
* for remaining and returned fields */ * for remaining and returned fields */
@@ -434,7 +435,7 @@ int sbi_mpxy_get_channel_ids(u32 start_index)
shmem_base[0] = cpu_to_le32(remaining); shmem_base[0] = cpu_to_le32(remaining);
shmem_base[1] = cpu_to_le32(returned); shmem_base[1] = cpu_to_le32(returned);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)hart_shmem_base(ms), mpxy_shmem_size);
return SBI_SUCCESS; return SBI_SUCCESS;
} }
@@ -465,7 +466,7 @@ int sbi_mpxy_read_attrs(u32 channel_id, u32 base_attr_id, u32 attr_count)
shmem_base = hart_shmem_base(ms); shmem_base = hart_shmem_base(ms);
end_id = base_attr_id + attr_count - 1; end_id = base_attr_id + attr_count - 1;
sbi_hart_map_saddr((unsigned long)hart_shmem_base(ms), mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)hart_shmem_base(ms), mpxy_shmem_size);
/* Standard attributes range check */ /* Standard attributes range check */
if (mpxy_is_std_attr(base_attr_id)) { if (mpxy_is_std_attr(base_attr_id)) {
@@ -504,7 +505,7 @@ int sbi_mpxy_read_attrs(u32 channel_id, u32 base_attr_id, u32 attr_count)
base_attr_id, attr_count); base_attr_id, attr_count);
} }
out: out:
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)hart_shmem_base(ms), mpxy_shmem_size);
return ret; return ret;
} }
@@ -616,7 +617,7 @@ int sbi_mpxy_write_attrs(u32 channel_id, u32 base_attr_id, u32 attr_count)
shmem_base = hart_shmem_base(ms); shmem_base = hart_shmem_base(ms);
end_id = base_attr_id + attr_count - 1; end_id = base_attr_id + attr_count - 1;
sbi_hart_map_saddr((unsigned long)shmem_base, mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)shmem_base, mpxy_shmem_size);
mem_ptr = (u32 *)shmem_base; mem_ptr = (u32 *)shmem_base;
@@ -673,7 +674,7 @@ int sbi_mpxy_write_attrs(u32 channel_id, u32 base_attr_id, u32 attr_count)
base_attr_id, attr_count); base_attr_id, attr_count);
} }
out: out:
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base, mpxy_shmem_size);
return ret; return ret;
} }
@@ -705,7 +706,7 @@ int sbi_mpxy_send_message(u32 channel_id, u8 msg_id,
return SBI_ERR_INVALID_PARAM; return SBI_ERR_INVALID_PARAM;
shmem_base = hart_shmem_base(ms); shmem_base = hart_shmem_base(ms);
sbi_hart_map_saddr((unsigned long)shmem_base, mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)shmem_base, mpxy_shmem_size);
if (resp_data_len) { if (resp_data_len) {
resp_buf = shmem_base; resp_buf = shmem_base;
@@ -722,7 +723,7 @@ int sbi_mpxy_send_message(u32 channel_id, u8 msg_id,
msg_data_len); msg_data_len);
} }
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base, mpxy_shmem_size);
if (ret == SBI_ERR_TIMEOUT || ret == SBI_ERR_IO) if (ret == SBI_ERR_TIMEOUT || ret == SBI_ERR_IO)
return ret; return ret;
@@ -752,12 +753,12 @@ int sbi_mpxy_get_notification_events(u32 channel_id, unsigned long *events_len)
return SBI_ERR_NOT_SUPPORTED; return SBI_ERR_NOT_SUPPORTED;
shmem_base = hart_shmem_base(ms); shmem_base = hart_shmem_base(ms);
sbi_hart_map_saddr((unsigned long)shmem_base, mpxy_shmem_size); sbi_hart_protection_map_range((unsigned long)shmem_base, mpxy_shmem_size);
eventsbuf = shmem_base; eventsbuf = shmem_base;
ret = channel->get_notification_events(channel, eventsbuf, ret = channel->get_notification_events(channel, eventsbuf,
mpxy_shmem_size, mpxy_shmem_size,
events_len); events_len);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range((unsigned long)shmem_base, mpxy_shmem_size);
if (ret) if (ret)
return ret; return ret;

5
lib/sbi/sbi_pmu.c
View File

@@ -13,6 +13,7 @@
#include <sbi/sbi_domain.h> #include <sbi/sbi_domain.h>
#include <sbi/sbi_ecall_interface.h> #include <sbi/sbi_ecall_interface.h>
#include <sbi/sbi_hart.h> #include <sbi/sbi_hart.h>
#include <sbi/sbi_hart_protection.h>
#include <sbi/sbi_heap.h> #include <sbi/sbi_heap.h>
#include <sbi/sbi_platform.h> #include <sbi/sbi_platform.h>
#include <sbi/sbi_pmu.h> #include <sbi/sbi_pmu.h>
@@ -1053,7 +1054,7 @@ int sbi_pmu_event_get_info(unsigned long shmem_phys_lo, unsigned long shmem_phys
SBI_DOMAIN_READ | SBI_DOMAIN_WRITE)) SBI_DOMAIN_READ | SBI_DOMAIN_WRITE))
return SBI_ERR_INVALID_ADDRESS; return SBI_ERR_INVALID_ADDRESS;
sbi_hart_map_saddr(shmem_phys_lo, shmem_size); sbi_hart_protection_map_range(shmem_phys_lo, shmem_size);
einfo = (struct sbi_pmu_event_info *)(shmem_phys_lo); einfo = (struct sbi_pmu_event_info *)(shmem_phys_lo);
for (i = 0; i < num_events; i++) { for (i = 0; i < num_events; i++) {
@@ -1087,7 +1088,7 @@ int sbi_pmu_event_get_info(unsigned long shmem_phys_lo, unsigned long shmem_phys
} }
} }
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range(shmem_phys_lo, shmem_size);
return 0; return 0;
} }

9
lib/sbi/sbi_sse.c
View File

@@ -15,6 +15,7 @@
#include <sbi/sbi_error.h> #include <sbi/sbi_error.h>
#include <sbi/sbi_fifo.h> #include <sbi/sbi_fifo.h>
#include <sbi/sbi_hart.h> #include <sbi/sbi_hart.h>
#include <sbi/sbi_hart_protection.h>
#include <sbi/sbi_heap.h> #include <sbi/sbi_heap.h>
#include <sbi/sbi_hsm.h> #include <sbi/sbi_hsm.h>
#include <sbi/sbi_ipi.h> #include <sbi/sbi_ipi.h>
@@ -1036,7 +1037,7 @@ int sbi_sse_read_attrs(uint32_t event_id, uint32_t base_attr_id,
if (ret) if (ret)
return ret; return ret;
sbi_hart_map_saddr(output_phys_lo, sizeof(unsigned long) * attr_count); sbi_hart_protection_map_range(output_phys_lo, sizeof(unsigned long) * attr_count);
/* /*
* Copy all attributes at once since struct sse_event_attrs is matching * Copy all attributes at once since struct sse_event_attrs is matching
@@ -1049,7 +1050,7 @@ int sbi_sse_read_attrs(uint32_t event_id, uint32_t base_attr_id,
attrs = (unsigned long *)output_phys_lo; attrs = (unsigned long *)output_phys_lo;
copy_attrs(attrs, &e_attrs[base_attr_id], attr_count); copy_attrs(attrs, &e_attrs[base_attr_id], attr_count);
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range(output_phys_lo, sizeof(unsigned long) * attr_count);
sse_event_put(e); sse_event_put(e);
@@ -1064,7 +1065,7 @@ static int sse_write_attrs(struct sbi_sse_event *e, uint32_t base_attr_id,
uint32_t id, end_id = base_attr_id + attr_count; uint32_t id, end_id = base_attr_id + attr_count;
unsigned long *attrs = (unsigned long *)input_phys; unsigned long *attrs = (unsigned long *)input_phys;
sbi_hart_map_saddr(input_phys, sizeof(unsigned long) * attr_count); sbi_hart_protection_map_range(input_phys, sizeof(unsigned long) * attr_count);
for (id = base_attr_id; id < end_id; id++) { for (id = base_attr_id; id < end_id; id++) {
val = attrs[attr++]; val = attrs[attr++];
@@ -1080,7 +1081,7 @@ static int sse_write_attrs(struct sbi_sse_event *e, uint32_t base_attr_id,
} }
out: out:
sbi_hart_unmap_saddr(); sbi_hart_protection_unmap_range(input_phys, sizeof(unsigned long) * attr_count);
return ret; return ret;
} }