#[doc = "Register `CR` reader"]
pub type R = crate::R<CrSpec>;
#[doc = "Register `CR` writer"]
pub type W = crate::W<CrSpec>;
#[doc = "Software Reset\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Swr {
    #[doc = "0: No effect"]
    NoEffect = 0,
    #[doc = "1: Perform a software reset"]
    SwReset = 1,
}
impl From<Swr> for bool {
    #[inline(always)]
    fn from(variant: Swr) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `SWR` reader - Software Reset"]
pub type SwrR = crate::BitReader<Swr>;
impl SwrR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Swr {
        match self.bits {
            false => Swr::NoEffect,
            true => Swr::SwReset,
        }
    }
    #[doc = "No effect"]
    #[inline(always)]
    pub fn is_no_effect(&self) -> bool {
        *self == Swr::NoEffect
    }
    #[doc = "Perform a software reset"]
    #[inline(always)]
    pub fn is_sw_reset(&self) -> bool {
        *self == Swr::SwReset
    }
}
#[doc = "Field `SWR` writer - Software Reset"]
pub type SwrW<'a, REG> = crate::BitWriter<'a, REG, Swr>;
impl<'a, REG> SwrW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No effect"]
    #[inline(always)]
    pub fn no_effect(self) -> &'a mut crate::W<REG> {
        self.variant(Swr::NoEffect)
    }
    #[doc = "Perform a software reset"]
    #[inline(always)]
    pub fn sw_reset(self) -> &'a mut crate::W<REG> {
        self.variant(Swr::SwReset)
    }
}
#[doc = "Digital Tamper Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Den {
    #[doc = "0: Disables TDET clock and prescaler"]
    Disable = 0,
    #[doc = "1: Enables TDET clock and prescaler"]
    Enable = 1,
}
impl From<Den> for bool {
    #[inline(always)]
    fn from(variant: Den) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `DEN` reader - Digital Tamper Enable"]
pub type DenR = crate::BitReader<Den>;
impl DenR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Den {
        match self.bits {
            false => Den::Disable,
            true => Den::Enable,
        }
    }
    #[doc = "Disables TDET clock and prescaler"]
    #[inline(always)]
    pub fn is_disable(&self) -> bool {
        *self == Den::Disable
    }
    #[doc = "Enables TDET clock and prescaler"]
    #[inline(always)]
    pub fn is_enable(&self) -> bool {
        *self == Den::Enable
    }
}
#[doc = "Field `DEN` writer - Digital Tamper Enable"]
pub type DenW<'a, REG> = crate::BitWriter<'a, REG, Den>;
impl<'a, REG> DenW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables TDET clock and prescaler"]
    #[inline(always)]
    pub fn disable(self) -> &'a mut crate::W<REG> {
        self.variant(Den::Disable)
    }
    #[doc = "Enables TDET clock and prescaler"]
    #[inline(always)]
    pub fn enable(self) -> &'a mut crate::W<REG> {
        self.variant(Den::Enable)
    }
}
#[doc = "Tamper Force System Reset\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Tfsr {
    #[doc = "0: Do not force chip reset"]
    NoReset = 0,
    #[doc = "1: Force chip reset"]
    Reset = 1,
}
impl From<Tfsr> for bool {
    #[inline(always)]
    fn from(variant: Tfsr) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `TFSR` reader - Tamper Force System Reset"]
pub type TfsrR = crate::BitReader<Tfsr>;
impl TfsrR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Tfsr {
        match self.bits {
            false => Tfsr::NoReset,
            true => Tfsr::Reset,
        }
    }
    #[doc = "Do not force chip reset"]
    #[inline(always)]
    pub fn is_no_reset(&self) -> bool {
        *self == Tfsr::NoReset
    }
    #[doc = "Force chip reset"]
    #[inline(always)]
    pub fn is_reset(&self) -> bool {
        *self == Tfsr::Reset
    }
}
#[doc = "Field `TFSR` writer - Tamper Force System Reset"]
pub type TfsrW<'a, REG> = crate::BitWriter<'a, REG, Tfsr>;
impl<'a, REG> TfsrW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Do not force chip reset"]
    #[inline(always)]
    pub fn no_reset(self) -> &'a mut crate::W<REG> {
        self.variant(Tfsr::NoReset)
    }
    #[doc = "Force chip reset"]
    #[inline(always)]
    pub fn reset(self) -> &'a mut crate::W<REG> {
        self.variant(Tfsr::Reset)
    }
}
#[doc = "Update Mode\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Um {
    #[doc = "0: No effect"]
    NoEffect = 0,
    #[doc = "1: Allows the clearing of interrupts"]
    ClearInts = 1,
}
impl From<Um> for bool {
    #[inline(always)]
    fn from(variant: Um) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `UM` reader - Update Mode"]
pub type UmR = crate::BitReader<Um>;
impl UmR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Um {
        match self.bits {
            false => Um::NoEffect,
            true => Um::ClearInts,
        }
    }
    #[doc = "No effect"]
    #[inline(always)]
    pub fn is_no_effect(&self) -> bool {
        *self == Um::NoEffect
    }
    #[doc = "Allows the clearing of interrupts"]
    #[inline(always)]
    pub fn is_clear_ints(&self) -> bool {
        *self == Um::ClearInts
    }
}
#[doc = "Field `UM` writer - Update Mode"]
pub type UmW<'a, REG> = crate::BitWriter<'a, REG, Um>;
impl<'a, REG> UmW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No effect"]
    #[inline(always)]
    pub fn no_effect(self) -> &'a mut crate::W<REG> {
        self.variant(Um::NoEffect)
    }
    #[doc = "Allows the clearing of interrupts"]
    #[inline(always)]
    pub fn clear_ints(self) -> &'a mut crate::W<REG> {
        self.variant(Um::ClearInts)
    }
}
#[doc = "Disable Prescaler On Tamper\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Distam {
    #[doc = "0: No effect"]
    NoEffect = 0,
    #[doc = "1: Automatically disables the prescaler after tamper detection"]
    AutoDis = 1,
}
impl From<Distam> for bool {
    #[inline(always)]
    fn from(variant: Distam) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `DISTAM` reader - Disable Prescaler On Tamper"]
pub type DistamR = crate::BitReader<Distam>;
impl DistamR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Distam {
        match self.bits {
            false => Distam::NoEffect,
            true => Distam::AutoDis,
        }
    }
    #[doc = "No effect"]
    #[inline(always)]
    pub fn is_no_effect(&self) -> bool {
        *self == Distam::NoEffect
    }
    #[doc = "Automatically disables the prescaler after tamper detection"]
    #[inline(always)]
    pub fn is_auto_dis(&self) -> bool {
        *self == Distam::AutoDis
    }
}
#[doc = "Field `DISTAM` writer - Disable Prescaler On Tamper"]
pub type DistamW<'a, REG> = crate::BitWriter<'a, REG, Distam>;
impl<'a, REG> DistamW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No effect"]
    #[inline(always)]
    pub fn no_effect(self) -> &'a mut crate::W<REG> {
        self.variant(Distam::NoEffect)
    }
    #[doc = "Automatically disables the prescaler after tamper detection"]
    #[inline(always)]
    pub fn auto_dis(self) -> &'a mut crate::W<REG> {
        self.variant(Distam::AutoDis)
    }
}
#[doc = "Field `DPR` reader - Digital Tamper Prescaler"]
pub type DprR = crate::FieldReader<u16>;
#[doc = "Field `DPR` writer - Digital Tamper Prescaler"]
pub type DprW<'a, REG> = crate::FieldWriter<'a, REG, 15, u16>;
impl R {
    #[doc = "Bit 0 - Software Reset"]
    #[inline(always)]
    pub fn swr(&self) -> SwrR {
        SwrR::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - Digital Tamper Enable"]
    #[inline(always)]
    pub fn den(&self) -> DenR {
        DenR::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - Tamper Force System Reset"]
    #[inline(always)]
    pub fn tfsr(&self) -> TfsrR {
        TfsrR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Update Mode"]
    #[inline(always)]
    pub fn um(&self) -> UmR {
        UmR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 8 - Disable Prescaler On Tamper"]
    #[inline(always)]
    pub fn distam(&self) -> DistamR {
        DistamR::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bits 17:31 - Digital Tamper Prescaler"]
    #[inline(always)]
    pub fn dpr(&self) -> DprR {
        DprR::new(((self.bits >> 17) & 0x7fff) as u16)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CR")
            .field("swr", &self.swr())
            .field("den", &self.den())
            .field("tfsr", &self.tfsr())
            .field("um", &self.um())
            .field("distam", &self.distam())
            .field("dpr", &self.dpr())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - Software Reset"]
    #[inline(always)]
    pub fn swr(&mut self) -> SwrW<'_, CrSpec> {
        SwrW::new(self, 0)
    }
    #[doc = "Bit 1 - Digital Tamper Enable"]
    #[inline(always)]
    pub fn den(&mut self) -> DenW<'_, CrSpec> {
        DenW::new(self, 1)
    }
    #[doc = "Bit 2 - Tamper Force System Reset"]
    #[inline(always)]
    pub fn tfsr(&mut self) -> TfsrW<'_, CrSpec> {
        TfsrW::new(self, 2)
    }
    #[doc = "Bit 3 - Update Mode"]
    #[inline(always)]
    pub fn um(&mut self) -> UmW<'_, CrSpec> {
        UmW::new(self, 3)
    }
    #[doc = "Bit 8 - Disable Prescaler On Tamper"]
    #[inline(always)]
    pub fn distam(&mut self) -> DistamW<'_, CrSpec> {
        DistamW::new(self, 8)
    }
    #[doc = "Bits 17:31 - Digital Tamper Prescaler"]
    #[inline(always)]
    pub fn dpr(&mut self) -> DprW<'_, CrSpec> {
        DprW::new(self, 17)
    }
}
#[doc = "Control\n\nYou can [`read`](crate::Reg::read) this register and get [`cr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`cr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CrSpec;
impl crate::RegisterSpec for CrSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`cr::R`](R) reader structure"]
impl crate::Readable for CrSpec {}
#[doc = "`write(|w| ..)` method takes [`cr::W`](W) writer structure"]
impl crate::Writable for CrSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets CR to value 0"]
impl crate::Resettable for CrSpec {}
