kernel/arch/riscv64/
mmio.rs

1//! MMIO access helpers for RISC-V.
2//!
3//! RISC-V does not currently require the AArch64/HVF-specific single-instruction
4//! workaround. Keep this minimal and use volatile pointer accesses.
5
6/// Read an 8-bit value from an MMIO address.
7///
8/// # Safety
9/// Caller must ensure `addr` is a valid MMIO address for an 8-bit access.
10#[inline(always)]
11pub unsafe fn read8(addr: usize) -> u8 {
12    unsafe { core::ptr::read_volatile(addr as *const u8) }
13}
14
15/// Write an 8-bit value to an MMIO address.
16///
17/// # Safety
18/// Caller must ensure `addr` is a valid MMIO address for an 8-bit access.
19#[inline(always)]
20pub unsafe fn write8(addr: usize, val: u8) {
21    unsafe { core::ptr::write_volatile(addr as *mut u8, val) }
22}
23
24/// Read a 16-bit value from an MMIO address.
25///
26/// # Safety
27/// Caller must ensure `addr` is a valid MMIO address for a 16-bit access.
28#[inline(always)]
29pub unsafe fn read16(addr: usize) -> u16 {
30    unsafe { core::ptr::read_volatile(addr as *const u16) }
31}
32
33/// Write a 16-bit value to an MMIO address.
34///
35/// # Safety
36/// Caller must ensure `addr` is a valid MMIO address for a 16-bit access.
37#[inline(always)]
38pub unsafe fn write16(addr: usize, val: u16) {
39    unsafe { core::ptr::write_volatile(addr as *mut u16, val) }
40}
41
42/// Read a 32-bit value from an MMIO address.
43///
44/// # Safety
45/// Caller must ensure `addr` is a valid MMIO address for a 32-bit access.
46#[inline(always)]
47pub unsafe fn read32(addr: usize) -> u32 {
48    unsafe { core::ptr::read_volatile(addr as *const u32) }
49}
50
51/// Write a 32-bit value to an MMIO address.
52///
53/// # Safety
54/// Caller must ensure `addr` is a valid MMIO address for a 32-bit access.
55#[inline(always)]
56pub unsafe fn write32(addr: usize, val: u32) {
57    unsafe { core::ptr::write_volatile(addr as *mut u32, val) }
58}
59
60/// Read a 64-bit value from an MMIO address.
61///
62/// # Safety
63/// Caller must ensure `addr` is a valid MMIO address for a 64-bit access.
64#[inline(always)]
65pub unsafe fn read64(addr: usize) -> u64 {
66    unsafe { core::ptr::read_volatile(addr as *const u64) }
67}
68
69/// Write a 64-bit value to an MMIO address.
70///
71/// # Safety
72/// Caller must ensure `addr` is a valid MMIO address for a 64-bit access.
73#[inline(always)]
74pub unsafe fn write64(addr: usize, val: u64) {
75    unsafe { core::ptr::write_volatile(addr as *mut u64, val) }
76}