Struct sunrise_libutils::io::mmio::Mmio

#[repr(packed)]pub struct Mmio<T> {
    value: MaybeUninit<T>,
}

A value that can only be accessed volatilely.

Generally used behind a pointer, as such:

use sunrise_libutils::io::{Io, Mmio};

/// Layout of Mmio registers of a random device.
///
/// This struct is repr packed so its field are not re-ordered,
/// and no undesired padding is added.
///
/// Be careful though, in rust reading an unaligned field is undefined behaviour,
/// so you must make sure it is correctly aligned.
#[repr(packed)]
struct DeviceFooRegisters {
    register_control: Mmio<u16>,
    register_command: Mmio<u16>,
}


let device_address = 0xabcdef00 as *mut DeviceFooRegisters;

let device: &mut DeviceFooRegisters = unsafe {
    // safety: make sure that device_address is valid and we're not violating
    // rust's aliasing rules.
    device_address.as_mut().unwrap()
};

let status = device.register_control.read();
device.register_command.write(0xF00D);

Fields

value: MaybeUninit<T>

The value. Can only be accessed through .read()

Implementations

impl<T> Mmio<T>

pub fn new() -> Self

Create a new Mmio without initializing.

Mostly unused, you would almost always get a Mmio by casting a raw pointer to a &mut Mmio.

Trait Implementations

impl<T> Debug for Mmio<T> where
    T: Copy + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Debug volatilely reads value.

impl<T> Io for Mmio<T> where
    T: Copy, 

type Value = T

The width of the IO access. Should be a primitive type like u8, u16, u32...

fn read(&self) -> T

Performs a volatile read of the value.

fn write(&mut self, value: T)

Performs a volatile write of the value.

fn readf(&self, flags: Self::Value) -> bool where
    Self::Value: PartialEq + BitAnd<Output = Self::Value>, 

Read from this Io, and mask the value with flags.

fn writef(&mut self, flags: Self::Value, value: bool) where
    Self::Value: PartialEq + BitAnd<Output = Self::Value> + BitOr<Output = Self::Value> + Not<Output = Self::Value>, 

Mask value with flags, and write it to this device address. Note that this causes a read!