Struct kernel::utilities::registers::Aliased

#[repr(transparent)]
pub struct Aliased<T, R = (), W = ()>where
    T: UIntLike,
    R: RegisterLongName,
    W: RegisterLongName,{ /* private fields */ }

Read-only and write-only registers aliased to the same address.

Unlike the ReadWrite register, this represents a register which has different meanings based on if it is written or read. This might be found on a device where control and status registers are accessed via the same memory address via writes and reads, respectively.

This register implements Readable and Writeable, but in general does not implement ReadWriteable (only if the type parameters R and W are identical, in which case a ReadWrite register might be a better choice).

Trait Implementations

impl<T, R, W> Readable for Aliased<T, R, W>where T: UIntLike, R: RegisterLongName, W: RegisterLongName,

type T = T

type R = R

fn get(&self) -> <Aliased<T, R, W> as Readable>::T

Get the raw register value

fn read(&self, field: Field<Self::T, Self::R>) -> Self::T

Read the value of the given field

fn read_as_enum<E>(&self, field: Field<Self::T, Self::R>) -> Option<E>where E: TryFromValue<Self::T, EnumType = E>,

Set the raw register value

fn extract(&self) -> LocalRegisterCopy<Self::T, Self::R>

Make a local copy of the register

fn is_set(&self, field: Field<Self::T, Self::R>) -> bool

Check if one or more bits in a field are set

fn any_matching_bits_set(&self, field: FieldValue<Self::T, Self::R>) -> bool

Check if any bits corresponding to the mask in the passed FieldValue are set. This function is identical to is_set() but operates on a FieldValue rather than a Field, allowing for checking if any bits are set across multiple, non-contiguous portions of a bitfield.

fn matches_all(&self, field: FieldValue<Self::T, Self::R>) -> bool

Check if all specified parts of a field match

fn matches_any(&self, fields: &[FieldValue<Self::T, Self::R>]) -> bool

Check if any of the passed parts of a field exactly match the contained value. This allows for matching on unset bits, or matching on specific values in multi-bit fields.

impl<T, R, W> Writeable for Aliased<T, R, W>where T: UIntLike, R: RegisterLongName, W: RegisterLongName,

type T = T

type R = W

fn set(&self, value: <Aliased<T, R, W> as Writeable>::T)

Set the raw register value

fn write(&self, field: FieldValue<Self::T, Self::R>)

Write the value of one or more fields, overwriting the other fields with zero

fn modify_no_read( &self, original: LocalRegisterCopy<Self::T, Self::R>, field: FieldValue<Self::T, Self::R> )

Write the value of one or more fields, maintaining the value of unchanged fields via a provided original value, rather than a register read.