use core::marker;
pub trait RegisterSpec {
type Ux: Copy;
}
pub trait Readable: RegisterSpec {
type Reader: From<R<Self>> + core::ops::Deref<Target = R<Self>>;
}
pub trait Writable: RegisterSpec {
type Writer: From<W<Self>> + core::ops::DerefMut<Target = W<Self>>;
}
pub trait Resettable: RegisterSpec {
fn reset_value() -> Self::Ux;
}
#[repr(transparent)]
pub struct Reg<REG: RegisterSpec> {
register: vcell::VolatileCell<REG::Ux>,
_marker: marker::PhantomData<REG>,
}
unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
impl<REG: RegisterSpec> Reg<REG> {
#[inline(always)]
pub fn as_ptr(&self) -> *mut REG::Ux {
self.register.as_ptr()
}
}
impl<REG: Readable> Reg<REG> {
#[inline(always)]
pub fn read(&self) -> REG::Reader {
REG::Reader::from(R {
bits: self.register.get(),
_reg: marker::PhantomData,
})
}
}
impl<REG: Resettable + Writable> Reg<REG> {
#[inline(always)]
pub fn reset(&self) {
self.register.set(REG::reset_value())
}
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>
{
self.register.set(
f(&mut REG::Writer::from(W {
bits: REG::reset_value(),
_reg: marker::PhantomData,
}))
.bits,
);
}
}
impl<REG: Writable> Reg<REG>
where
REG::Ux: Default,
{
#[inline(always)]
pub unsafe fn write_with_zero<F>(&self, f: F)
where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>
{
self.register.set(
(*f(&mut REG::Writer::from(W {
bits: REG::Ux::default(),
_reg: marker::PhantomData,
})))
.bits,
);
}
}
impl<REG: Readable + Writable> Reg<REG> {
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(®::Reader, &'w mut REG::Writer) -> &'w mut W<REG>
{
let bits = self.register.get();
self.register.set(
f(
®::Reader::from(R {
bits,
_reg: marker::PhantomData,
}),
&mut REG::Writer::from(W {
bits,
_reg: marker::PhantomData,
}),
)
.bits,
);
}
}
pub struct R<REG: RegisterSpec + ?Sized> {
pub(crate) bits: REG::Ux,
_reg: marker::PhantomData<REG>,
}
impl<REG: RegisterSpec> R<REG> {
#[inline(always)]
pub fn bits(&self) -> REG::Ux {
self.bits
}
}
impl<REG: RegisterSpec, FI> PartialEq<FI> for R<REG>
where
REG::Ux: PartialEq,
FI: Copy + Into<REG::Ux>,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&(*other).into())
}
}
pub struct W<REG: RegisterSpec + ?Sized> {
pub(crate) bits: REG::Ux,
_reg: marker::PhantomData<REG>,
}
impl<REG: RegisterSpec> W<REG> {
#[inline(always)]
pub unsafe fn bits(&mut self, bits: REG::Ux) -> &mut Self {
self.bits = bits;
self
}
}
#[doc(hidden)]
pub struct FieldReaderRaw<U, T> {
pub(crate) bits: U,
_reg: marker::PhantomData<T>,
}
impl<U, FI> FieldReaderRaw<U, FI>
where
U: Copy,
{
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(bits: U) -> Self {
Self {
bits,
_reg: marker::PhantomData,
}
}
}
#[doc(hidden)]
pub struct BitReaderRaw<T> {
pub(crate) bits: bool,
_reg: marker::PhantomData<T>,
}
impl<FI> BitReaderRaw<FI> {
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
Self {
bits,
_reg: marker::PhantomData,
}
}
}
pub type FieldReader<U, FI> = FieldReaderRaw<U, FI>;
pub type BitReader<FI> = BitReaderRaw<FI>;
impl<U, FI> FieldReader<U, FI>
where
U: Copy,
{
#[inline(always)]
pub fn bits(&self) -> U {
self.bits
}
}
impl<U, FI> PartialEq<FI> for FieldReader<U, FI>
where
U: PartialEq,
FI: Copy + Into<U>,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&(*other).into())
}
}
impl<FI> PartialEq<FI> for BitReader<FI>
where
FI: Copy + Into<bool>,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&(*other).into())
}
}
impl<FI> BitReader<FI> {
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc(hidden)]
pub struct Safe;
#[doc(hidden)]
pub struct Unsafe;
#[doc(hidden)]
pub struct FieldWriterRaw<'a, U, REG, N, FI, Safety, const WI: u8, const O: u8>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<N>,
{
pub(crate) w: &'a mut REG::Writer,
_field: marker::PhantomData<(N, FI, Safety)>,
}
impl<'a, U, REG, N, FI, Safety, const WI: u8, const O: u8> FieldWriterRaw<'a, U, REG, N, FI, Safety, WI, O>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<N>,
{
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(w: &'a mut REG::Writer) -> Self {
Self {
w,
_field: marker::PhantomData,
}
}
}
#[doc(hidden)]
pub struct BitWriterRaw<'a, U, REG, FI, M, const O: u8>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<bool>,
{
pub(crate) w: &'a mut REG::Writer,
_field: marker::PhantomData<(FI, M)>,
}
impl<'a, U, REG, FI, M, const O: u8> BitWriterRaw<'a, U, REG, FI, M, O>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<bool>,
{
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(w: &'a mut REG::Writer) -> Self {
Self {
w,
_field: marker::PhantomData,
}
}
}
pub type FieldWriter<'a, U, REG, N, FI, const WI: u8, const O: u8> = FieldWriterRaw<'a, U, REG, N, FI, Unsafe, WI, O>;
pub type FieldWriterSafe<'a, U, REG, N, FI, const WI: u8, const O: u8> = FieldWriterRaw<'a, U, REG, N, FI, Safe, WI, O>;
impl<'a, U, REG, N, FI, const WI: u8, const OF: u8> FieldWriter<'a, U, REG, N, FI, WI, OF>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<N>,
{
pub const WIDTH: u8 = WI;
pub const OFFSET: u8 = OF;
}
impl<'a, U, REG, N, FI, const WI: u8, const OF: u8> FieldWriterSafe<'a, U, REG, N, FI, WI, OF>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<N>,
{
pub const WIDTH: u8 = WI;
pub const OFFSET: u8 = OF;
}
macro_rules! bit_proxy {
($writer:ident, $mwv:ident) => {
#[doc(hidden)]
pub struct $mwv;
/// Bit-wise write field proxy
pub type $writer<'a, U, REG, FI, const O: u8> = BitWriterRaw<'a, U, REG, FI, $mwv, O>;
impl<'a, U, REG, FI, const OF: u8> $writer<'a, U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = U>,
FI: Into<bool>,
{
pub const WIDTH: u8 = 1;
pub const OFFSET: u8 = OF;
}
}
}
macro_rules! impl_bit_proxy {
($writer:ident, $U:ty) => {
impl<'a, REG, FI, const OF: u8> $writer<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut REG::Writer {
self.w.bits = (self.w.bits & !(1 << { OF })) | ((<$U>::from(value) & 1) << { OF });
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
self.bit(variant.into())
}
}
}
}
bit_proxy!(BitWriter, BitM);
bit_proxy!(BitWriter1S, Bit1S);
bit_proxy!(BitWriter0C, Bit0C);
bit_proxy!(BitWriter1C, Bit1C);
bit_proxy!(BitWriter0S, Bit0S);
bit_proxy!(BitWriter1T, Bit1T);
bit_proxy!(BitWriter0T, Bit0T);
macro_rules! impl_proxy {
($U:ty) => {
impl<'a, REG, N, FI, const WI: u8, const OF: u8> FieldWriter<'a, $U, REG, N, FI, WI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
N: Into<$U>,
FI: Into<N>,
{
const MASK: $U = <$U>::MAX >> (<$U>::MAX.leading_ones() as u8 - { WI });
#[inline(always)]
pub unsafe fn bits(self, value: N) -> &'a mut REG::Writer {
self.w.bits =
(self.w.bits & !(Self::MASK << { OF })) | ((value.into() & Self::MASK) << { OF });
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
unsafe { self.bits(variant.into()) }
}
}
impl<'a, REG, N, FI, const WI: u8, const OF: u8> FieldWriterSafe<'a, $U, REG, N, FI, WI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
N: Into<$U>,
FI: Into<N>,
{
const MASK: $U = <$U>::MAX >> (<$U>::MAX.leading_ones() as u8 - { WI });
#[inline(always)]
pub fn bits(self, value: N) -> &'a mut REG::Writer {
self.w.bits =
(self.w.bits & !(Self::MASK << { OF })) | ((value.into() & Self::MASK) << { OF });
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut REG::Writer {
self.bits(variant.into())
}
}
impl_bit_proxy!(BitWriter, $U);
impl_bit_proxy!(BitWriter1S, $U);
impl_bit_proxy!(BitWriter0C, $U);
impl_bit_proxy!(BitWriter1C, $U);
impl_bit_proxy!(BitWriter0S, $U);
impl_bit_proxy!(BitWriter1T, $U);
impl_bit_proxy!(BitWriter0T, $U);
impl<'a, REG, FI, const OF: u8> BitWriter<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn set_bit(self) -> &'a mut REG::Writer {
self.bit(true)
}
#[inline(always)]
pub fn clear_bit(self) -> &'a mut REG::Writer {
self.bit(false)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter1S<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn set_bit(self) -> &'a mut REG::Writer {
self.bit(true)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter0C<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn clear_bit(self) -> &'a mut REG::Writer {
self.bit(false)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter1C<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn clear_bit_by_one(self) -> &'a mut REG::Writer {
self.bit(true)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter0S<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn set_bit_by_zero(self) -> &'a mut REG::Writer {
self.bit(false)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter1T<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn toggle_bit(self) -> &'a mut REG::Writer {
self.bit(true)
}
}
impl<'a, REG, FI, const OF: u8> BitWriter0T<'a, $U, REG, FI, OF>
where
REG: Writable + RegisterSpec<Ux = $U>,
FI: Into<bool>,
{
#[inline(always)]
pub fn toggle_bit(self) -> &'a mut REG::Writer {
self.bit(false)
}
}
}
}
impl_proxy!(u8);
impl_proxy!(u32);
impl_proxy!(u16);