#[doc = "Register `IER` reader"]
pub type R = crate::R<IerSpec>;
#[doc = "Register `IER` writer"]
pub type W = crate::W<IerSpec>;
#[doc = "FIFO Full Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FullIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<FullIe> for bool {
    #[inline(always)]
    fn from(variant: FullIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `FULL_IE` reader - FIFO Full Interrupt Enable"]
pub type FullIeR = crate::BitReader<FullIe>;
impl FullIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> FullIe {
        match self.bits {
            false => FullIe::Disabled,
            true => FullIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == FullIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == FullIe::Enabled
    }
}
#[doc = "Field `FULL_IE` writer - FIFO Full Interrupt Enable"]
pub type FullIeW<'a, REG> = crate::BitWriter<'a, REG, FullIe>;
impl<'a, REG> FullIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(FullIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(FullIe::Enabled)
    }
}
#[doc = "FIFO Empty Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EmptyIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<EmptyIe> for bool {
    #[inline(always)]
    fn from(variant: EmptyIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `EMPTY_IE` reader - FIFO Empty Interrupt Enable"]
pub type EmptyIeR = crate::BitReader<EmptyIe>;
impl EmptyIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> EmptyIe {
        match self.bits {
            false => EmptyIe::Disabled,
            true => EmptyIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == EmptyIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == EmptyIe::Enabled
    }
}
#[doc = "Field `EMPTY_IE` writer - FIFO Empty Interrupt Enable"]
pub type EmptyIeW<'a, REG> = crate::BitWriter<'a, REG, EmptyIe>;
impl<'a, REG> EmptyIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(EmptyIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(EmptyIe::Enabled)
    }
}
#[doc = "FIFO Watermark Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WmIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<WmIe> for bool {
    #[inline(always)]
    fn from(variant: WmIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WM_IE` reader - FIFO Watermark Interrupt Enable"]
pub type WmIeR = crate::BitReader<WmIe>;
impl WmIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> WmIe {
        match self.bits {
            false => WmIe::Disabled,
            true => WmIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == WmIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == WmIe::Enabled
    }
}
#[doc = "Field `WM_IE` writer - FIFO Watermark Interrupt Enable"]
pub type WmIeW<'a, REG> = crate::BitWriter<'a, REG, WmIe>;
impl<'a, REG> WmIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(WmIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(WmIe::Enabled)
    }
}
#[doc = "Swing Back One Cycle Complete Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SwbkIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<SwbkIe> for bool {
    #[inline(always)]
    fn from(variant: SwbkIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `SWBK_IE` reader - Swing Back One Cycle Complete Interrupt Enable"]
pub type SwbkIeR = crate::BitReader<SwbkIe>;
impl SwbkIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> SwbkIe {
        match self.bits {
            false => SwbkIe::Disabled,
            true => SwbkIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == SwbkIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == SwbkIe::Enabled
    }
}
#[doc = "Field `SWBK_IE` writer - Swing Back One Cycle Complete Interrupt Enable"]
pub type SwbkIeW<'a, REG> = crate::BitWriter<'a, REG, SwbkIe>;
impl<'a, REG> SwbkIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(SwbkIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(SwbkIe::Enabled)
    }
}
#[doc = "FIFO Overflow Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OfIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<OfIe> for bool {
    #[inline(always)]
    fn from(variant: OfIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OF_IE` reader - FIFO Overflow Interrupt Enable"]
pub type OfIeR = crate::BitReader<OfIe>;
impl OfIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> OfIe {
        match self.bits {
            false => OfIe::Disabled,
            true => OfIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == OfIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == OfIe::Enabled
    }
}
#[doc = "Field `OF_IE` writer - FIFO Overflow Interrupt Enable"]
pub type OfIeW<'a, REG> = crate::BitWriter<'a, REG, OfIe>;
impl<'a, REG> OfIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(OfIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(OfIe::Enabled)
    }
}
#[doc = "FIFO Underflow Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UfIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<UfIe> for bool {
    #[inline(always)]
    fn from(variant: UfIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `UF_IE` reader - FIFO Underflow Interrupt Enable"]
pub type UfIeR = crate::BitReader<UfIe>;
impl UfIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> UfIe {
        match self.bits {
            false => UfIe::Disabled,
            true => UfIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == UfIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == UfIe::Enabled
    }
}
#[doc = "Field `UF_IE` writer - FIFO Underflow Interrupt Enable"]
pub type UfIeW<'a, REG> = crate::BitWriter<'a, REG, UfIe>;
impl<'a, REG> UfIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(UfIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(UfIe::Enabled)
    }
}
#[doc = "PTG Mode Conversion Complete Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PtgcocoIe {
    #[doc = "0: Disables"]
    Disabled = 0,
    #[doc = "1: Enables"]
    Enabled = 1,
}
impl From<PtgcocoIe> for bool {
    #[inline(always)]
    fn from(variant: PtgcocoIe) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PTGCOCO_IE` reader - PTG Mode Conversion Complete Interrupt Enable"]
pub type PtgcocoIeR = crate::BitReader<PtgcocoIe>;
impl PtgcocoIeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> PtgcocoIe {
        match self.bits {
            false => PtgcocoIe::Disabled,
            true => PtgcocoIe::Enabled,
        }
    }
    #[doc = "Disables"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == PtgcocoIe::Disabled
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == PtgcocoIe::Enabled
    }
}
#[doc = "Field `PTGCOCO_IE` writer - PTG Mode Conversion Complete Interrupt Enable"]
pub type PtgcocoIeW<'a, REG> = crate::BitWriter<'a, REG, PtgcocoIe>;
impl<'a, REG> PtgcocoIeW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disables"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(PtgcocoIe::Disabled)
    }
    #[doc = "Enables"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(PtgcocoIe::Enabled)
    }
}
impl R {
    #[doc = "Bit 0 - FIFO Full Interrupt Enable"]
    #[inline(always)]
    pub fn full_ie(&self) -> FullIeR {
        FullIeR::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - FIFO Empty Interrupt Enable"]
    #[inline(always)]
    pub fn empty_ie(&self) -> EmptyIeR {
        EmptyIeR::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - FIFO Watermark Interrupt Enable"]
    #[inline(always)]
    pub fn wm_ie(&self) -> WmIeR {
        WmIeR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Swing Back One Cycle Complete Interrupt Enable"]
    #[inline(always)]
    pub fn swbk_ie(&self) -> SwbkIeR {
        SwbkIeR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 6 - FIFO Overflow Interrupt Enable"]
    #[inline(always)]
    pub fn of_ie(&self) -> OfIeR {
        OfIeR::new(((self.bits >> 6) & 1) != 0)
    }
    #[doc = "Bit 7 - FIFO Underflow Interrupt Enable"]
    #[inline(always)]
    pub fn uf_ie(&self) -> UfIeR {
        UfIeR::new(((self.bits >> 7) & 1) != 0)
    }
    #[doc = "Bit 8 - PTG Mode Conversion Complete Interrupt Enable"]
    #[inline(always)]
    pub fn ptgcoco_ie(&self) -> PtgcocoIeR {
        PtgcocoIeR::new(((self.bits >> 8) & 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("IER")
            .field("full_ie", &self.full_ie())
            .field("empty_ie", &self.empty_ie())
            .field("wm_ie", &self.wm_ie())
            .field("swbk_ie", &self.swbk_ie())
            .field("of_ie", &self.of_ie())
            .field("uf_ie", &self.uf_ie())
            .field("ptgcoco_ie", &self.ptgcoco_ie())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - FIFO Full Interrupt Enable"]
    #[inline(always)]
    pub fn full_ie(&mut self) -> FullIeW<'_, IerSpec> {
        FullIeW::new(self, 0)
    }
    #[doc = "Bit 1 - FIFO Empty Interrupt Enable"]
    #[inline(always)]
    pub fn empty_ie(&mut self) -> EmptyIeW<'_, IerSpec> {
        EmptyIeW::new(self, 1)
    }
    #[doc = "Bit 2 - FIFO Watermark Interrupt Enable"]
    #[inline(always)]
    pub fn wm_ie(&mut self) -> WmIeW<'_, IerSpec> {
        WmIeW::new(self, 2)
    }
    #[doc = "Bit 3 - Swing Back One Cycle Complete Interrupt Enable"]
    #[inline(always)]
    pub fn swbk_ie(&mut self) -> SwbkIeW<'_, IerSpec> {
        SwbkIeW::new(self, 3)
    }
    #[doc = "Bit 6 - FIFO Overflow Interrupt Enable"]
    #[inline(always)]
    pub fn of_ie(&mut self) -> OfIeW<'_, IerSpec> {
        OfIeW::new(self, 6)
    }
    #[doc = "Bit 7 - FIFO Underflow Interrupt Enable"]
    #[inline(always)]
    pub fn uf_ie(&mut self) -> UfIeW<'_, IerSpec> {
        UfIeW::new(self, 7)
    }
    #[doc = "Bit 8 - PTG Mode Conversion Complete Interrupt Enable"]
    #[inline(always)]
    pub fn ptgcoco_ie(&mut self) -> PtgcocoIeW<'_, IerSpec> {
        PtgcocoIeW::new(self, 8)
    }
}
#[doc = "Interrupt Enable\n\nYou can [`read`](crate::Reg::read) this register and get [`ier::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`ier::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IerSpec;
impl crate::RegisterSpec for IerSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`ier::R`](R) reader structure"]
impl crate::Readable for IerSpec {}
#[doc = "`write(|w| ..)` method takes [`ier::W`](W) writer structure"]
impl crate::Writable for IerSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets IER to value 0"]
impl crate::Resettable for IerSpec {}
