Struct Reg 

pub struct Reg<'io, R: Register, IO: RegisterIO = PtrIO> { /* private fields */ }

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

This is generic over both the Register to access and the RegisterIO type used to access the register.

The Register trait has associated types defining the register width, access controls, and endianness which are used to customize the read/write implementation for each register.

RegisterIO defaults to regular volatile pointer I/O and is only needed for advanced use cases like tunneled registers.

Implementations

impl<R: Register> Reg<'static, R, PtrIO>

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

Safety

The caller must guarantee that the provided address points to a hardware register of type R.

impl<'io, R: Register, IO: RegisterIO> Reg<'io, R, IO>

pub const unsafe fn from_ptr_with(ptr: *mut R::Regwidth, io: &'io IO) -> Self

Safety

The caller must guarantee that the provided address points to a hardware register of type R.

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

impl<R: Register, IO: RegisterIO> Reg<'_, R, IO>

where R::Access: Read,

pub fn try_read(&self) -> Result<R, IO::Error>

Try to 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().try_read().unwrap();
let field1_val = reg1_val.field1();
let field2_val = reg1_val.field2();

impl<R: Register, IO: RegisterIO<Error = Infallible>> Reg<'_, R, IO>

where R::Access: Read,

pub fn read(&self) -> R

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<R: Register, IO: RegisterIO> Reg<'_, R, IO>

where R::Access: Write,

pub fn try_write_value(&self, val: R) -> Result<(), IO::Error>

Try to write a register value.

Typically one would use Reg::try_write or Reg::try_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].try_read().unwrap();
registers.regfile().reg_array()[1].try_write_value(reg0).unwrap();

impl<R: Register, IO: RegisterIO<Error = Infallible>> Reg<'_, R, IO>

where R::Access: Write,

pub fn write_value(&self, val: R)

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<R: Default + Register, IO: RegisterIO> Reg<'_, R, IO>

where R::Access: Write,

pub fn try_write<T>(&self, f: impl FnOnce(&mut R) -> T) -> Result<T, IO::Error>

Try to 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().try_write(|r| {
    // r contains the default (reset) value of the register
    r.set_field1(0x1);
    r.set_field2(0x0);
}).unwrap();

impl<R: Default + Register, IO: RegisterIO<Error = Infallible>> Reg<'_, R, IO>

where R::Access: Write,

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

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<R: Register, IO: RegisterIO> Reg<'_, R, IO>

where R::Access: Read + Write,

pub fn try_modify<T>(&self, f: impl FnOnce(&mut R) -> T) -> Result<T, IO::Error>

Try to 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().try_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 .try_modify() method
    orig_r
}).unwrap();

impl<R: Register, IO: RegisterIO<Error = Infallible>> Reg<'_, R, IO>

where R::Access: Read + Write,

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

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<R: Register, IO: RegisterIO> Clone for Reg<'_, R, IO>

where R::Regwidth: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'io, R: Debug + Register, IO: Debug + RegisterIO> Debug for Reg<'io, R, IO>

where R::Regwidth: Debug,

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

Formats the value using the given formatter.

impl<'io, R: PartialEq + Register, IO: PartialEq + RegisterIO> PartialEq for Reg<'io, R, IO>

where R::Regwidth: PartialEq,

fn eq(&self, other: &Reg<'io, R, IO>) -> 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<R: Register, IO: RegisterIO> Copy for Reg<'_, R, IO>

where R::Regwidth: Copy,

impl<'io, R: Eq + Register, IO: Eq + RegisterIO> Eq for Reg<'io, R, IO>

where R::Regwidth: Eq,

impl<R: Register, IO: RegisterIO + Sync> Send for Reg<'_, R, IO>

impl<'io, R: Register, IO: RegisterIO> StructuralPartialEq for Reg<'io, R, IO>

impl<R: Register, IO: RegisterIO + Sync> Sync for Reg<'_, R, IO>