Struct UniqueMmioPointer

pub struct UniqueMmioPointer<'a, T: ?Sized>(/* private fields */);

A unique owned pointer to the registers of some MMIO device.

It is guaranteed to be valid and unique; no other access to the MMIO space of the device may happen for the lifetime 'a.

A UniqueMmioPointer may be created from a mutable reference, but this should only be used for testing purposes, as references should never be constructed for real MMIO address space.

Implementations

impl<T> UniqueMmioPointer<'_, T>

pub unsafe fn read_unsafe(&mut self) -> T

Performs an MMIO read of the entire T.

Safety

This field must be safe to perform an MMIO read from.

pub unsafe fn write_unsafe(&mut self, value: T)

Performs an MMIO write of the entire T.

Note that this takes &mut self rather than &self because an MMIO read may cause side-effects that change the state of the device.

Safety

This field must be safe to perform an MMIO write to.

impl<T: ?Sized> UniqueMmioPointer<'_, T>

pub unsafe fn new(regs: NonNull<T>) -> Self

Creates a new UniqueMmioPointer from a non-null raw pointer.

Safety

regs must be a properly aligned and valid pointer to some MMIO address space of type T, which is mapped as device memory and valid to read and write from any thread with volatile operations. There must not be any other aliases which are used to access the same MMIO region while this UniqueMmioPointer exists.

If T contains any fields wrapped in ReadOnly, WriteOnly or ReadWrite then they must indeed be safe to perform MMIO reads or writes on.

pub unsafe fn child<U>(&mut self, regs: NonNull<U>) -> UniqueMmioPointer<'_, U>

Creates a new UniqueMmioPointer with the same lifetime as this one.

This is used internally by the field! macro and shouldn’t be called directly.

Safety

regs must be a properly aligned and valid pointer to some MMIO address space of type T, within the allocation that self points to.

pub fn ptr_mut(&mut self) -> *mut T

Returns a raw mut pointer to the MMIO registers.

pub fn ptr_nonnull(&mut self) -> NonNull<T>

Returns a NonNull<T> pointer to the MMIO registers.

impl<T: FromBytes + IntoBytes> UniqueMmioPointer<'_, ReadWrite<T>>

pub fn read(&mut self) -> T

Performs an MMIO read of the entire T.

impl<T: Immutable + IntoBytes> UniqueMmioPointer<'_, ReadWrite<T>>

pub fn write(&mut self, value: T)

Performs an MMIO write of the entire T.

impl<T: Immutable + IntoBytes> UniqueMmioPointer<'_, ReadPureWrite<T>>

pub fn write(&mut self, value: T)

Performs an MMIO write of the entire T.

impl<T: FromBytes + IntoBytes> UniqueMmioPointer<'_, ReadOnly<T>>

pub fn read(&mut self) -> T

Performs an MMIO read of the entire T.

impl<T: Immutable + IntoBytes> UniqueMmioPointer<'_, WriteOnly<T>>

pub fn write(&mut self, value: T)

Performs an MMIO write of the entire T.

impl<T> UniqueMmioPointer<'_, [T]>

pub fn get(&mut self, index: usize) -> Option<UniqueMmioPointer<'_, T>>

Returns a UniqueMmioPointer to an element of this slice, or None if the index is out of bounds.

Example

use safe_mmio::{UniqueMmioPointer, fields::ReadWrite};

let mut slice: UniqueMmioPointer<[ReadWrite<u32>]>;
let mut element = slice.get(1).unwrap();
element.write(42);

impl<T, const LEN: usize> UniqueMmioPointer<'_, [T; LEN]>

pub fn split(&mut self) -> [UniqueMmioPointer<'_, T>; LEN]

Splits a UniqueMmioPointer to an array into an array of UniqueMmioPointers.

pub fn get(&mut self, index: usize) -> Option<UniqueMmioPointer<'_, T>>

Returns a UniqueMmioPointer to an element of this array, or None if the index is out of bounds.

Example

use safe_mmio::{UniqueMmioPointer, fields::ReadWrite};

let mut slice: UniqueMmioPointer<[ReadWrite<u32>; 3]>;
let mut element = slice.get(1).unwrap();
element.write(42);

Methods from Deref<Target = SharedMmioPointer<'a, T>>

pub unsafe fn read_unsafe(&self) -> T

Performs an MMIO read of the entire T.

Safety

This field must be safe to perform an MMIO read from, and doing so must not cause any side-effects.

pub unsafe fn child<U>(&self, regs: NonNull<U>) -> SharedMmioPointer<'_, U>

Creates a new SharedMmioPointer with the same lifetime as this one.

This is used internally by the field_shared! macro and shouldn’t be called directly.

Safety

regs must be a properly aligned and valid pointer to some MMIO address space of type T, within the allocation that self points to.

pub fn ptr(&self) -> *const T

Returns a raw const pointer to the MMIO registers.

Trait Implementations

impl<T: ?Sized> Debug for UniqueMmioPointer<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: ?Sized> Deref for UniqueMmioPointer<'a, T>

type Target = SharedMmioPointer<'a, T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: ?Sized> From<&'a mut T> for UniqueMmioPointer<'a, T>

fn from(r: &'a mut T) -> Self

Converts to this type from the input type.

impl<'a, T: ?Sized> From<UniqueMmioPointer<'a, T>> for SharedMmioPointer<'a, T>

fn from(unique: UniqueMmioPointer<'a, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> PartialEq for UniqueMmioPointer<'_, T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized> Eq for UniqueMmioPointer<'_, T>