Struct Reg 

pub struct Reg<T: Register, A: Access> { /* private fields */ }

Register abstraction used to read, write, and modify register values

Implementations

impl<T: Register, A: Access> Reg<T, A>

pub const unsafe fn from_ptr(ptr: *mut T::Regwidth) -> Self

Safety

The caller must guarantee that the provided address points to a hardware register of type T with access A.

pub const fn as_ptr(&self) -> *mut T

impl<T: Register, A: Read> Reg<T, A>

pub fn read(&self) -> T

Read a register value.

If the register is to be modified (i.e., a read-modify-write), use the Reg::modify method instead.

Example

let reg1_val = registers.regfile().register1().read();
let field1_val = reg1_val.field1();
let field2_val = reg1_val.field2();

impl<T: Register, A: Write> Reg<T, A>

pub fn write_value(&self, val: T)

Write a register value.

Typically one would use Reg::write or Reg::modify to update a register’s contents, but this method has a few different use cases such as updating a register with a stored value, or updating one register with the contents of another.

Example

let reg0 = registers.regfile().reg_array()[0].read();
registers.regfile().reg_array()[1].write_value(reg0);

impl<T: Default + Register, A: Write> Reg<T, A>

pub fn write<R>(&self, f: impl FnOnce(&mut T) -> R) -> R

Write a register.

This method takes a closure. The input to the closure is a mutable reference to the default value of the register. It can be updated in the closure. The updated value is then written to the hardware register.

Example

registers.regfile().register1().write(|r| {
    // r contains the default (reset) value of the register
    r.set_field1(0x1);
    r.set_field2(0x0);
});

impl<T: Register, A: Read + Write> Reg<T, A>

pub fn modify<R>(&self, f: impl FnOnce(&mut T) -> R) -> R

Modify a register.

This method takes a closure. The input to the closure is a mutable reference to the current value of the register. It can be updated in the closure. The updated value is then written back to the hardware register.

Example

let orig_r = registers.regfile().register1().modify(|r| {
    // r contains the current value of the register
    orig_r = r.clone()
    r.set_field1(r.field1());
    r.set_field2(0x0);
    // whatever value the closure returns is returned by the .modify() method
    orig_r
});

Trait Implementations

impl<T: Clone + Register, A: Clone + Access> Clone for Reg<T, A>

where T::Regwidth: Clone,

fn clone(&self) -> Reg<T, A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Register, A: Debug + Access> Debug for Reg<T, A>

where T::Regwidth: Debug,

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

Formats the value using the given formatter.

impl<T: PartialEq + Register, A: PartialEq + Access> PartialEq for Reg<T, A>

where T::Regwidth: PartialEq,

fn eq(&self, other: &Reg<T, A>) -> 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: Copy + Register, A: Copy + Access> Copy for Reg<T, A>

where T::Regwidth: Copy,

impl<T: Eq + Register, A: Eq + Access> Eq for Reg<T, A>

where T::Regwidth: Eq,

impl<T: Register, A: Access> Send for Reg<T, A>

impl<T: Register, A: Access> StructuralPartialEq for Reg<T, A>

impl<T: Register, A: Access> Sync for Reg<T, A>