use core::marker;
pub trait Readable {}
pub trait Writable {}
pub trait ResetValue {
type Type;
fn reset_value() -> Self::Type;
}
pub struct Reg<U, REG> {
register: vcell::VolatileCell<U>,
_marker: marker::PhantomData<REG>,
}
unsafe impl<U: Send, REG> Send for Reg<U, REG> { }
impl<U, REG> Reg<U, REG>
where
Self: Readable,
U: Copy
{
#[inline(always)]
pub fn read(&self) -> R<U, Self> {
R {bits: self.register.get(), _reg: marker::PhantomData}
}
}
impl<U, REG> Reg<U, REG>
where
Self: ResetValue<Type=U> + Writable,
U: Copy,
{
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
impl<U, REG> Reg<U, REG>
where
Self: ResetValue<Type=U> + Writable,
U: Copy
{
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W<U, Self>) -> &mut W<U, Self>
{
self.register.set(f(&mut W {bits: Self::reset_value(), _reg: marker::PhantomData}).bits);
}
}
impl<U, REG> Reg<U, REG>
where
Self: Writable,
U: Copy + Default
{
#[inline(always)]
pub fn write_with_zero<F>(&self, f: F)
where
F: FnOnce(&mut W<U, Self>) -> &mut W<U, Self>
{
self.register.set(f(&mut W {bits: U::default(), _reg: marker::PhantomData }).bits);
}
}
impl<U, REG> Reg<U, REG>
where
Self: Readable + Writable,
U: Copy,
{
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R<U, Self>, &'w mut W<U, Self>) -> &'w mut W<U, Self>
{
let bits = self.register.get();
self.register.set(f(&R {bits, _reg: marker::PhantomData}, &mut W {bits, _reg: marker::PhantomData}).bits);
}
}
pub struct R<U, T> {
pub(crate) bits: U,
_reg: marker::PhantomData<T>,
}
impl<U, T> R<U, T>
where
U: Copy
{
#[inline(always)]
pub(crate) fn new(bits: U) -> Self {
Self {
bits,
_reg: marker::PhantomData,
}
}
#[inline(always)]
pub fn bits(&self) -> U {
self.bits
}
}
impl<U, T, FI> PartialEq<FI> for R<U, T>
where
U: PartialEq,
FI: Copy+Into<U>
{
#[inline(always)]
fn eq(&self, other: &FI) -> bool {
self.bits.eq(&(*other).into())
}
}
impl<FI> R<bool, 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()
}
}
pub struct W<U, REG> {
pub(crate) bits: U,
_reg: marker::PhantomData<REG>,
}
impl<U, REG> W<U, REG> {
#[inline(always)]
pub unsafe fn bits(&mut self, bits: U) -> &mut Self {
self.bits = bits;
self
}
}
#[derive(Clone,Copy,PartialEq)]
pub enum Variant<U, T> {
Val(T),
Res(U),
}