Skip to main content

mmio_ptr/
mmio-ptr.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#![no_std]
6
7unsafe extern "C" {
8    fn mmio_read8(buffer: *const u8) -> u8;
9    fn mmio_write8(data: u8, buffer: *mut u8);
10
11    fn mmio_read16(buffer: *const u16) -> u16;
12    fn mmio_write16(data: u16, buffer: *mut u16);
13
14    fn mmio_read32(buffer: *const u32) -> u32;
15    fn mmio_write32(data: u32, buffer: *mut u32);
16
17    #[cfg(target_pointer_width = "64")]
18    fn mmio_read64(buffer: *const u64) -> u64;
19    #[cfg(target_pointer_width = "64")]
20    fn mmio_write64(data: u64, buffer: *mut u64);
21}
22
23/// Reads an 8-bit value from MMIO memory.
24///
25/// # Safety
26///
27/// `buffer` must be a valid pointer to MMIO memory.
28#[inline(always)]
29pub unsafe fn read8(buffer: *const u8) -> u8 {
30    // Safety: Justification deferred to caller.
31    unsafe { mmio_read8(buffer) }
32}
33
34/// Writes an 8-bit value to MMIO memory.
35///
36/// # Safety
37///
38/// `buffer` must be a valid pointer to MMIO memory.
39#[inline(always)]
40pub unsafe fn write8(data: u8, buffer: *mut u8) {
41    // Safety: Justification deferred to caller.
42    unsafe { mmio_write8(data, buffer) }
43}
44
45/// Reads a 16-bit value from MMIO memory.
46///
47/// # Safety
48///
49/// `buffer` must be a valid pointer to MMIO memory.
50#[inline(always)]
51pub unsafe fn read16(buffer: *const u16) -> u16 {
52    // Safety: Justification deferred to caller.
53    unsafe { mmio_read16(buffer) }
54}
55
56/// Writes a 16-bit value to MMIO memory.
57///
58/// # Safety
59///
60/// `buffer` must be a valid pointer to MMIO memory.
61#[inline(always)]
62pub unsafe fn write16(data: u16, buffer: *mut u16) {
63    // Safety: Justification deferred to caller.
64    unsafe { mmio_write16(data, buffer) }
65}
66
67/// Reads a 32-bit value from MMIO memory.
68///
69/// # Safety
70///
71/// `buffer` must be a valid pointer to MMIO memory.
72#[inline(always)]
73pub unsafe fn read32(buffer: *const u32) -> u32 {
74    // Safety: Justification deferred to caller.
75    unsafe { mmio_read32(buffer) }
76}
77
78/// Writes a 32-bit value to MMIO memory.
79///
80/// # Safety
81///
82/// `buffer` must be a valid pointer to MMIO memory.
83#[inline(always)]
84pub unsafe fn write32(data: u32, buffer: *mut u32) {
85    // Safety: Justification deferred to caller.
86    unsafe { mmio_write32(data, buffer) }
87}
88
89/// Reads a 64-bit value from MMIO memory.
90///
91/// # Safety
92///
93/// `buffer` must be a valid pointer to MMIO memory.
94#[inline(always)]
95#[cfg(target_pointer_width = "64")]
96pub unsafe fn read64(buffer: *const u64) -> u64 {
97    // Safety: Justification deferred to caller.
98    unsafe { mmio_read64(buffer) }
99}
100
101/// Writes a 64-bit value to MMIO memory.
102///
103/// # Safety
104///
105/// `buffer` must be a valid pointer to MMIO memory.
106#[inline(always)]
107#[cfg(target_pointer_width = "64")]
108pub unsafe fn write64(data: u64, buffer: *mut u64) {
109    // Safety: Justification deferred to caller.
110    unsafe { mmio_write64(data, buffer) }
111}