use core::marker;
pub trait RawReg:
Copy
+ Default
+ From<bool>
+ core::ops::BitOr<Output = Self>
+ core::ops::BitAnd<Output = Self>
+ core::ops::BitOrAssign
+ core::ops::BitAndAssign
+ core::ops::Not<Output = Self>
+ core::ops::Shl<u8, Output = Self>
{
fn mask<const WI: u8>() -> Self;
fn one() -> Self;
}
macro_rules! raw_reg {
($U:ty, $size:literal, $mask:ident) => {
impl RawReg for $U {
#[inline(always)]
fn mask<const WI: u8>() -> Self {
$mask::<WI>()
}
#[inline(always)]
fn one() -> Self {
1
}
}
const fn $mask<const WI: u8>() -> $U {
<$U>::MAX >> ($size - WI)
}
impl FieldSpec for $U {
type Ux = $U;
}
};
}
raw_reg!(u8, 8, mask_u8);
raw_reg!(u16, 16, mask_u16);
raw_reg!(u32, 32, mask_u32);
raw_reg!(u64, 64, mask_u64);
pub trait RegisterSpec {
type Ux: RawReg;
}
pub trait FieldSpec: Sized {
type Ux: Copy + PartialEq + From<Self>;
}
pub trait Readable: RegisterSpec {}
pub trait Writable: RegisterSpec {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
}
pub trait Resettable: RegisterSpec {
const RESET_VALUE: Self::Ux;
#[inline(always)]
fn reset_value() -> Self::Ux {
Self::RESET_VALUE
}
}
#[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) -> R<REG> {
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 W<REG>) -> &mut W<REG>,
{
self.register.set(
f(&mut W {
bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
| REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
_reg: marker::PhantomData,
})
.bits,
);
}
}
impl<REG: Writable> Reg<REG> {
#[inline(always)]
pub unsafe fn write_with_zero<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
self.register.set(
f(&mut 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(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
{
let bits = self.register.get();
self.register.set(
f(
&R {
bits,
_reg: marker::PhantomData,
},
&mut W {
bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
| REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
_reg: marker::PhantomData,
},
)
.bits,
);
}
}
#[doc(hidden)]
pub mod raw {
use super::{marker, BitM, FieldSpec, RegisterSpec, Unsafe, Writable};
pub struct R<REG: RegisterSpec> {
pub(crate) bits: REG::Ux,
pub(super) _reg: marker::PhantomData<REG>,
}
pub struct W<REG: RegisterSpec> {
pub(crate) bits: REG::Ux,
pub(super) _reg: marker::PhantomData<REG>,
}
pub struct FieldReader<FI = u8>
where
FI: FieldSpec,
{
pub(crate) bits: FI::Ux,
_reg: marker::PhantomData<FI>,
}
impl<FI: FieldSpec> FieldReader<FI> {
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(bits: FI::Ux) -> Self {
Self {
bits,
_reg: marker::PhantomData,
}
}
}
pub struct BitReader<FI = bool> {
pub(crate) bits: bool,
_reg: marker::PhantomData<FI>,
}
impl<FI> BitReader<FI> {
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(bits: bool) -> Self {
Self {
bits,
_reg: marker::PhantomData,
}
}
}
pub struct FieldWriter<'a, REG, const WI: u8, const O: u8, FI = u8, Safety = Unsafe>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
{
pub(crate) w: &'a mut W<REG>,
_field: marker::PhantomData<(FI, Safety)>,
}
impl<'a, REG, const WI: u8, const O: u8, FI, Safety> FieldWriter<'a, REG, WI, O, FI, Safety>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
{
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(w: &'a mut W<REG>) -> Self {
Self {
w,
_field: marker::PhantomData,
}
}
}
pub struct BitWriter<'a, REG, const O: u8, FI = bool, M = BitM>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
pub(crate) w: &'a mut W<REG>,
_field: marker::PhantomData<(FI, M)>,
}
impl<'a, REG, const O: u8, FI, M> BitWriter<'a, REG, O, FI, M>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[allow(unused)]
#[inline(always)]
pub(crate) fn new(w: &'a mut W<REG>) -> Self {
Self {
w,
_field: marker::PhantomData,
}
}
}
}
pub type R<REG> = raw::R<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,
REG::Ux: From<FI>,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(®::Ux::from(*other))
}
}
pub type W<REG> = raw::W<REG>;
pub type FieldReader<FI = u8> = raw::FieldReader<FI>;
pub type BitReader<FI = bool> = raw::BitReader<FI>;
impl<FI: FieldSpec> FieldReader<FI> {
#[inline(always)]
pub fn bits(&self) -> FI::Ux {
self.bits
}
}
impl<FI> PartialEq<FI> for FieldReader<FI>
where
FI: FieldSpec + Copy,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&FI::Ux::from(*other))
}
}
impl<FI> PartialEq<FI> for BitReader<FI>
where
FI: Copy,
bool: From<FI>,
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&bool::from(*other))
}
}
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;
pub type FieldWriter<'a, REG, const WI: u8, const O: u8, FI = u8> =
raw::FieldWriter<'a, REG, WI, O, FI, Unsafe>;
pub type FieldWriterSafe<'a, REG, const WI: u8, const O: u8, FI = u8> =
raw::FieldWriter<'a, REG, WI, O, FI, Safe>;
impl<'a, REG, const WI: u8, const OF: u8, FI> FieldWriter<'a, REG, WI, OF, FI>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
{
pub const WIDTH: u8 = WI;
}
impl<'a, REG, const WI: u8, const OF: u8, FI> FieldWriterSafe<'a, REG, WI, OF, FI>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
{
pub const WIDTH: u8 = WI;
}
macro_rules! bit_proxy {
($writer:ident, $mwv:ident) => {
#[doc(hidden)]
pub struct $mwv;
/// Bit-wise write field proxy
pub type $writer<'a, REG, const O: u8, FI = bool> = raw::BitWriter<'a, REG, O, FI, $mwv>;
impl<'a, REG, const OF: u8, FI> $writer<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
pub const WIDTH: u8 = 1;
}
};
}
macro_rules! impl_bit_proxy {
($writer:ident) => {
impl<'a, REG, const OF: u8, FI> $writer<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::one() << OF);
self.w.bits |= (REG::Ux::from(value) & REG::Ux::one()) << OF;
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut W<REG> {
self.bit(bool::from(variant))
}
}
};
}
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);
impl<'a, REG, const WI: u8, const OF: u8, FI> FieldWriter<'a, REG, WI, OF, FI>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
REG::Ux: From<FI::Ux>,
{
#[inline(always)]
pub unsafe fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::mask::<WI>() << OF);
self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << OF;
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut W<REG> {
unsafe { self.bits(FI::Ux::from(variant)) }
}
}
impl<'a, REG, const WI: u8, const OF: u8, FI> FieldWriterSafe<'a, REG, WI, OF, FI>
where
REG: Writable + RegisterSpec,
FI: FieldSpec,
REG::Ux: From<FI::Ux>,
{
#[inline(always)]
pub fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::mask::<WI>() << OF);
self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << OF;
self.w
}
#[inline(always)]
pub fn variant(self, variant: FI) -> &'a mut W<REG> {
self.bits(FI::Ux::from(variant))
}
}
impl_bit_proxy!(BitWriter);
impl_bit_proxy!(BitWriter1S);
impl_bit_proxy!(BitWriter0C);
impl_bit_proxy!(BitWriter1C);
impl_bit_proxy!(BitWriter0S);
impl_bit_proxy!(BitWriter1T);
impl_bit_proxy!(BitWriter0T);
impl<'a, REG, const OF: u8, FI> BitWriter<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn set_bit(self) -> &'a mut W<REG> {
self.w.bits |= REG::Ux::one() << OF;
self.w
}
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::one() << OF);
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter1S<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn set_bit(self) -> &'a mut W<REG> {
self.w.bits |= REG::Ux::one() << OF;
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter0C<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::one() << OF);
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter1C<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn clear_bit_by_one(self) -> &'a mut W<REG> {
self.w.bits |= REG::Ux::one() << OF;
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter0S<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn set_bit_by_zero(self) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::one() << OF);
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter1T<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn toggle_bit(self) -> &'a mut W<REG> {
self.w.bits |= REG::Ux::one() << OF;
self.w
}
}
impl<'a, REG, const OF: u8, FI> BitWriter0T<'a, REG, OF, FI>
where
REG: Writable + RegisterSpec,
bool: From<FI>,
{
#[inline(always)]
pub fn toggle_bit(self) -> &'a mut W<REG> {
self.w.bits &= !(REG::Ux::one() << OF);
self.w
}
}
#[cfg(feature = "atomics")]
mod atomic {
use super::*;
use portable_atomic::Ordering;
pub trait AtomicOperations {
unsafe fn atomic_or(ptr: *mut Self, val: Self);
unsafe fn atomic_and(ptr: *mut Self, val: Self);
unsafe fn atomic_xor(ptr: *mut Self, val: Self);
}
macro_rules! impl_atomics {
($U:ty, $Atomic:ty) => {
impl AtomicOperations for $U {
unsafe fn atomic_or(ptr: *mut Self, val: Self) {
(*(ptr as *const $Atomic)).or(val, Ordering::SeqCst);
}
unsafe fn atomic_and(ptr: *mut Self, val: Self) {
(*(ptr as *const $Atomic)).and(val, Ordering::SeqCst);
}
unsafe fn atomic_xor(ptr: *mut Self, val: Self) {
(*(ptr as *const $Atomic)).xor(val, Ordering::SeqCst);
}
}
};
}
impl_atomics!(u8, portable_atomic::AtomicU8);
impl_atomics!(u16, portable_atomic::AtomicU16);
#[cfg(not(target_pointer_width = "16"))]
impl_atomics!(u32, portable_atomic::AtomicU32);
#[cfg(any(target_pointer_width = "64", target_has_atomic = "64"))]
impl_atomics!(u64, portable_atomic::AtomicU64);
impl<REG: Readable + Writable> Reg<REG>
where
REG::Ux: AtomicOperations + Default + core::ops::Not<Output = REG::Ux>,
{
#[inline(always)]
pub unsafe fn set_bits<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
let bits = f(&mut W {
bits: Default::default(),
_reg: marker::PhantomData,
})
.bits;
REG::Ux::atomic_or(self.register.as_ptr(), bits);
}
#[inline(always)]
pub unsafe fn clear_bits<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
let bits = f(&mut W {
bits: !REG::Ux::default(),
_reg: marker::PhantomData,
})
.bits;
REG::Ux::atomic_and(self.register.as_ptr(), bits);
}
#[inline(always)]
pub unsafe fn toggle_bits<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
let bits = f(&mut W {
bits: Default::default(),
_reg: marker::PhantomData,
})
.bits;
REG::Ux::atomic_xor(self.register.as_ptr(), bits);
}
}
}