#[doc = "Register `SM3INTEN` reader"]
pub type R = crate::R<Sm3intenSpec>;
#[doc = "Register `SM3INTEN` writer"]
pub type W = crate::W<Sm3intenSpec>;
#[doc = "Compare Interrupt Enables\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum Cmpie {
    #[doc = "0: The corresponding STS\\[CMPF\\] bit will not cause an interrupt request."]
    Disabled = 0,
    #[doc = "1: The corresponding STS\\[CMPF\\] bit will cause an interrupt request."]
    Enabled = 1,
}
impl From<Cmpie> for u8 {
    #[inline(always)]
    fn from(variant: Cmpie) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for Cmpie {
    type Ux = u8;
}
impl crate::IsEnum for Cmpie {}
#[doc = "Field `CMPIE` reader - Compare Interrupt Enables"]
pub type CmpieR = crate::FieldReader<Cmpie>;
impl CmpieR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<Cmpie> {
        match self.bits {
            0 => Some(Cmpie::Disabled),
            1 => Some(Cmpie::Enabled),
            _ => None,
        }
    }
    #[doc = "The corresponding STS\\[CMPF\\] bit will not cause an interrupt request."]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Cmpie::Disabled
    }
    #[doc = "The corresponding STS\\[CMPF\\] bit will cause an interrupt request."]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Cmpie::Enabled
    }
}
#[doc = "Field `CMPIE` writer - Compare Interrupt Enables"]
pub type CmpieW<'a, REG> = crate::FieldWriter<'a, REG, 6, Cmpie>;
impl<'a, REG> CmpieW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "The corresponding STS\\[CMPF\\] bit will not cause an interrupt request."]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmpie::Disabled)
    }
    #[doc = "The corresponding STS\\[CMPF\\] bit will cause an interrupt request."]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmpie::Enabled)
    }
}
#[doc = "Capture X 0 Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cx0ie {
    #[doc = "0: Interrupt request disabled for STS\\[CFX0\\]."]
    Disabled = 0,
    #[doc = "1: Interrupt request enabled for STS\\[CFX0\\]."]
    Enabled = 1,
}
impl From<Cx0ie> for bool {
    #[inline(always)]
    fn from(variant: Cx0ie) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CX0IE` reader - Capture X 0 Interrupt Enable"]
pub type Cx0ieR = crate::BitReader<Cx0ie>;
impl Cx0ieR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cx0ie {
        match self.bits {
            false => Cx0ie::Disabled,
            true => Cx0ie::Enabled,
        }
    }
    #[doc = "Interrupt request disabled for STS\\[CFX0\\]."]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Cx0ie::Disabled
    }
    #[doc = "Interrupt request enabled for STS\\[CFX0\\]."]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Cx0ie::Enabled
    }
}
#[doc = "Field `CX0IE` writer - Capture X 0 Interrupt Enable"]
pub type Cx0ieW<'a, REG> = crate::BitWriter<'a, REG, Cx0ie>;
impl<'a, REG> Cx0ieW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Interrupt request disabled for STS\\[CFX0\\]."]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cx0ie::Disabled)
    }
    #[doc = "Interrupt request enabled for STS\\[CFX0\\]."]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cx0ie::Enabled)
    }
}
#[doc = "Capture X 1 Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cx1ie {
    #[doc = "0: Interrupt request disabled for STS\\[CFX1\\]."]
    Disabled = 0,
    #[doc = "1: Interrupt request enabled for STS\\[CFX1\\]."]
    Enabled = 1,
}
impl From<Cx1ie> for bool {
    #[inline(always)]
    fn from(variant: Cx1ie) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CX1IE` reader - Capture X 1 Interrupt Enable"]
pub type Cx1ieR = crate::BitReader<Cx1ie>;
impl Cx1ieR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cx1ie {
        match self.bits {
            false => Cx1ie::Disabled,
            true => Cx1ie::Enabled,
        }
    }
    #[doc = "Interrupt request disabled for STS\\[CFX1\\]."]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Cx1ie::Disabled
    }
    #[doc = "Interrupt request enabled for STS\\[CFX1\\]."]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Cx1ie::Enabled
    }
}
#[doc = "Field `CX1IE` writer - Capture X 1 Interrupt Enable"]
pub type Cx1ieW<'a, REG> = crate::BitWriter<'a, REG, Cx1ie>;
impl<'a, REG> Cx1ieW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Interrupt request disabled for STS\\[CFX1\\]."]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cx1ie::Disabled)
    }
    #[doc = "Interrupt request enabled for STS\\[CFX1\\]."]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cx1ie::Enabled)
    }
}
#[doc = "Reload Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Rie {
    #[doc = "0: STS\\[RF\\] CPU interrupt requests disabled"]
    Disabled = 0,
    #[doc = "1: STS\\[RF\\] CPU interrupt requests enabled"]
    Enabled = 1,
}
impl From<Rie> for bool {
    #[inline(always)]
    fn from(variant: Rie) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `RIE` reader - Reload Interrupt Enable"]
pub type RieR = crate::BitReader<Rie>;
impl RieR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Rie {
        match self.bits {
            false => Rie::Disabled,
            true => Rie::Enabled,
        }
    }
    #[doc = "STS\\[RF\\] CPU interrupt requests disabled"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Rie::Disabled
    }
    #[doc = "STS\\[RF\\] CPU interrupt requests enabled"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Rie::Enabled
    }
}
#[doc = "Field `RIE` writer - Reload Interrupt Enable"]
pub type RieW<'a, REG> = crate::BitWriter<'a, REG, Rie>;
impl<'a, REG> RieW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "STS\\[RF\\] CPU interrupt requests disabled"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Rie::Disabled)
    }
    #[doc = "STS\\[RF\\] CPU interrupt requests enabled"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Rie::Enabled)
    }
}
#[doc = "Reload Error Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Reie {
    #[doc = "0: STS\\[REF\\] CPU interrupt requests disabled"]
    Disabled = 0,
    #[doc = "1: STS\\[REF\\] CPU interrupt requests enabled"]
    Enabled = 1,
}
impl From<Reie> for bool {
    #[inline(always)]
    fn from(variant: Reie) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `REIE` reader - Reload Error Interrupt Enable"]
pub type ReieR = crate::BitReader<Reie>;
impl ReieR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Reie {
        match self.bits {
            false => Reie::Disabled,
            true => Reie::Enabled,
        }
    }
    #[doc = "STS\\[REF\\] CPU interrupt requests disabled"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Reie::Disabled
    }
    #[doc = "STS\\[REF\\] CPU interrupt requests enabled"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Reie::Enabled
    }
}
#[doc = "Field `REIE` writer - Reload Error Interrupt Enable"]
pub type ReieW<'a, REG> = crate::BitWriter<'a, REG, Reie>;
impl<'a, REG> ReieW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "STS\\[REF\\] CPU interrupt requests disabled"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Reie::Disabled)
    }
    #[doc = "STS\\[REF\\] CPU interrupt requests enabled"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Reie::Enabled)
    }
}
impl R {
    #[doc = "Bits 0:5 - Compare Interrupt Enables"]
    #[inline(always)]
    pub fn cmpie(&self) -> CmpieR {
        CmpieR::new((self.bits & 0x3f) as u8)
    }
    #[doc = "Bit 6 - Capture X 0 Interrupt Enable"]
    #[inline(always)]
    pub fn cx0ie(&self) -> Cx0ieR {
        Cx0ieR::new(((self.bits >> 6) & 1) != 0)
    }
    #[doc = "Bit 7 - Capture X 1 Interrupt Enable"]
    #[inline(always)]
    pub fn cx1ie(&self) -> Cx1ieR {
        Cx1ieR::new(((self.bits >> 7) & 1) != 0)
    }
    #[doc = "Bit 12 - Reload Interrupt Enable"]
    #[inline(always)]
    pub fn rie(&self) -> RieR {
        RieR::new(((self.bits >> 12) & 1) != 0)
    }
    #[doc = "Bit 13 - Reload Error Interrupt Enable"]
    #[inline(always)]
    pub fn reie(&self) -> ReieR {
        ReieR::new(((self.bits >> 13) & 1) != 0)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("SM3INTEN")
            .field("cmpie", &self.cmpie())
            .field("cx0ie", &self.cx0ie())
            .field("cx1ie", &self.cx1ie())
            .field("rie", &self.rie())
            .field("reie", &self.reie())
            .finish()
    }
}
impl W {
    #[doc = "Bits 0:5 - Compare Interrupt Enables"]
    #[inline(always)]
    pub fn cmpie(&mut self) -> CmpieW<'_, Sm3intenSpec> {
        CmpieW::new(self, 0)
    }
    #[doc = "Bit 6 - Capture X 0 Interrupt Enable"]
    #[inline(always)]
    pub fn cx0ie(&mut self) -> Cx0ieW<'_, Sm3intenSpec> {
        Cx0ieW::new(self, 6)
    }
    #[doc = "Bit 7 - Capture X 1 Interrupt Enable"]
    #[inline(always)]
    pub fn cx1ie(&mut self) -> Cx1ieW<'_, Sm3intenSpec> {
        Cx1ieW::new(self, 7)
    }
    #[doc = "Bit 12 - Reload Interrupt Enable"]
    #[inline(always)]
    pub fn rie(&mut self) -> RieW<'_, Sm3intenSpec> {
        RieW::new(self, 12)
    }
    #[doc = "Bit 13 - Reload Error Interrupt Enable"]
    #[inline(always)]
    pub fn reie(&mut self) -> ReieW<'_, Sm3intenSpec> {
        ReieW::new(self, 13)
    }
}
#[doc = "Interrupt Enable Register\n\nYou can [`read`](crate::Reg::read) this register and get [`sm3inten::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`sm3inten::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct Sm3intenSpec;
impl crate::RegisterSpec for Sm3intenSpec {
    type Ux = u16;
}
#[doc = "`read()` method returns [`sm3inten::R`](R) reader structure"]
impl crate::Readable for Sm3intenSpec {}
#[doc = "`write(|w| ..)` method takes [`sm3inten::W`](W) writer structure"]
impl crate::Writable for Sm3intenSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets SM3INTEN to value 0"]
impl crate::Resettable for Sm3intenSpec {}
